api.admin.controller package

Submodules

api.admin.controller.admin_auth_services module

class api.admin.controller.admin_auth_services.AdminAuthServicesController(manager)

Bases: SettingsController

process_admin_auth_services()

Fetch, create, or update admin_auth_services

Returns:

dict: if Get request returns a dict of auth services and protocols Response: If POST request updates or creates auth services and protocols.

process_delete(protocol)

Delete an auth service from the database

Args:

protocol (string): Name of protocol to search for the service to be deleted.

Returns:

Response: (‘Deleted’, 200)

process_get()

Return dict of auth services and protocols available to library

Returns:

dict: auth_services and protocols available

process_post()

Create new auth_service if none exists and set service and protocol

form: ‘protocol’ form: ‘id’ form: ‘name’

Returns:

Response: ProblemDetail or string of auth_service.protocol and 200, or 201 if newly created service

validate_form_fields(**fields)

Check that 1) the user has selected a valid protocol, 2) the user has not left the required fields blank, and 3) the user is not attempting to change the protocol of an existing admin auth service.

api.admin.controller.analytics_services module

class api.admin.controller.analytics_services.AnalyticsServicesController(manager)

Bases: SettingsController

process_analytics_services()

process_delete(service_id)

process_get()

process_post()

validate_form_fields(**fields)

The ‘name’ and ‘URL’ fields cannot be blank, the URL must be valid, and the protocol must be selected from the list of recognized protocols.

api.admin.controller.catalog_services module

class api.admin.controller.catalog_services.CatalogServicesController(manager)

Bases: SettingsController

check_libraries(service)

Check that no library ended up with multiple MARC export integrations.

get_name(service)

Check that there isn’t already a service with this name

process_catalog_services()

process_delete(service_id)

process_get()

process_post()

update_protocol_settings()

validate_form_fields(protocol)

Verify that the protocol which the user has selected is in the list of recognized protocol options.

api.admin.controller.cdn_services module

class api.admin.controller.cdn_services.CDNServicesController(manager)

Bases: SettingsController

process_cdn_services()

process_delete(service_id)

process_get()

process_post()

validate_form_fields(**fields)

The ‘name’ and ‘protocol’ fields cannot be blank, and the protocol must be selected from the list of recognized protocols. The URL must be valid.

api.admin.controller.collection_library_registrations module

class api.admin.controller.collection_library_registrations.CollectionLibraryRegistrationsController(manager)

Bases: SettingsController

Use the OPDS Directory Registration Protocol to register a Collection with its remote source of truth.

Parameters:

registration_class – Mock class to use instead of Registration.

get_library_info(library, collection)

Find the relevant information about the library which the user is trying to register

look_up_collection(collection_id)

Find the collection that the user is trying to register the library with, and check that it actually exists.

look_up_library(library_short_name)

Find the library the user is trying to register, and check that it actually exists.

look_up_registry(external_integration)

Find the remote registry that the user is trying to register the collection with, and check that it is in the list of recognized protocols (currently just SharedODLAPI)

process_collection_library_registrations(do_get=<bound method HTTP.debuggable_get of <class 'core.util.http.HTTP'>>, do_post=<bound method HTTP.debuggable_post of <class 'core.util.http.HTTP'>>, key=None, registration_class=<class 'api.registry.Registration'>)

process_get()

process_post(registration_class, do_get, do_post)

api.admin.controller.collection_self_tests module

class api.admin.controller.collection_self_tests.CollectionSelfTestsController(manager)

Bases: SelfTestsController

get_info(collection)

Compile information about this collection, including the results from the last time, if ever, that the self tests were run.

look_up_by_id(identifier)

Find the collection to display self test results or run self tests for; display an error message if a collection with this ID turns out not to exist

process_collection_self_tests(identifier)

run_tests(collection)

api.admin.controller.collection_settings module

class api.admin.controller.collection_settings.CollectionSettingsController(manager)

Bases: SettingsController

collection_to_dict(collection_object)

find_protocol_class(collection_object)

Figure out which class this collection’s protocol belongs to, from the list of possible protocols defined in PROVIDER_APIS (in SettingsController)

load_libraries(collection_object, user, protocol)

Get a list of the libraries that 1) are associated with this collection and 2) the user is affiliated with

load_settings(protocol_settings, collection_object, collection_settings)

Compile the information about the collection that corresponds to the settings externally imposed by the collection’s protocol.

process_collections()

process_delete(collection_id)

process_get()

process_libraries(protocol, collection)

Go through the libraries that the user is trying to associate with this collection; check that each library actually exists, and that the library-related configuration settings that the user has submitted are complete and valid. If the library passes all of the validations, go ahead and associate it with this collection.

process_post()

process_settings(settings, collection)

Go through the settings that the user has just submitted for this collection, and check that each setting is valid and that no required settings are missing. If the setting passes all of the validations, go ahead and set it for this collection.

validate_collection(**fields)

The protocol of an existing collection cannot be changed, and collections must have unique names.

validate_external_account_id_setting(value, setting)

Check that the user has submitted any required values for associating this collection with an external account.

validate_form_fields(is_new, protocols, **fields)

Check that 1) the required fields aren’t blank, 2) the protocol is on the list of recognized protocols, 3) the collection (if there is one) is valid, and 4) the URL is valid

validate_parent(protocol, collection)

Verify that the parent collection is set properly, then determine the type of the settings that need to be validated: are they 1) settings for a regular collection (e.g. client key and client secret for an Overdrive collection), or 2) settings for a child collection (e.g. library ID for an Overdrive Advantage collection)?

api.admin.controller.discovery_service_library_registrations module

class api.admin.controller.discovery_service_library_registrations.DiscoveryServiceLibraryRegistrationsController(manager)

Bases: SettingsController

List the libraries that have been registered with a specific RemoteRegistry, and allow the admin to register a library with a RemoteRegistry.

Parameters:

registration_class – Mock class to use instead of Registration.

get_library_info(registration)

Find the relevant information about the library which the user is trying to register

look_up_library(library_short_name)

Find the library the user is trying to register, and check that it actually exists.

look_up_registry(integration_id)

Find the RemoteRegistry that the user is trying to register the library with, and check that it actually exists.

process_discovery_service_library_registrations(registration_class=None, do_get=<bound method HTTP.debuggable_get of <class 'core.util.http.HTTP'>>, do_post=<bound method HTTP.debuggable_post of <class 'core.util.http.HTTP'>>)

process_get(do_get=<bound method HTTP.debuggable_get of <class 'core.util.http.HTTP'>>)

Make a list of all discovery services, each with the list of libraries registered with that service and the status of the registration.

process_post(registration_class, do_get, do_post)

Attempt to register a library with a RemoteRegistry.

api.admin.controller.discovery_services module

class api.admin.controller.discovery_services.DiscoveryServicesController(manager)

Bases: SettingsController

look_up_service_from_registry(protocol, id)

Find an existing service, and make sure that the user is not trying to edit its protocol.

process_delete(service_id)

process_discovery_services()

process_get()

process_post()

set_up_default_registry()

Set up the default library registry; no other registries exist yet.

validate_form_fields(**fields)

The ‘name’ and ‘protocol’ fields cannot be blank, and the protocol must be selected from the list of recognized protocols. The URL must be valid.

api.admin.controller.individual_admin_settings module

class api.admin.controller.individual_admin_settings.IndividualAdminSettingsController(manager)

Bases: SettingsController

check_permissions(admin, settingUp)

Before going any further, check that the user actually has permission to create/edit this type of admin

handle_password(password, admin, is_new, settingUp)

Check that the user has permission to change this type of admin’s password

handle_roles(admin, roles, settingUp)

Compare the admin’s existing set of roles against the roles submitted in the form, and, unless there’s a problem with the roles or the permissions, modify the admin’s roles accordingly

look_up_library_for_role(role)

If the role is affiliated with a particular library, as opposed to being sitewide, find the library (and check that it actually exists).

process_delete(email)

process_get()

process_individual_admins()

process_post()

response(admin, is_new)

validate_form_fields(email)

Check that 1) the user has entered something into the required email field, and 2) if so, the input is formatted as a valid email address.

validate_role_exists(role)

api.admin.controller.library_settings module

class api.admin.controller.library_settings.LibrarySettingsController(manager)

Bases: SettingsController

check_for_missing_fields(settings)

check_for_missing_settings(settings)

check_header_links(settings)

Verify that header links and labels are the same length.

check_short_name_unique(library, short_name)

check_web_color_contrast(settings)

Verify that the web primary and secondary color both contrast well on white, as these colors will serve as button backgrounds with white test, as well as text color on white backgrounds.

create_library(short_name, library_uuid)

current_value(setting, library)

Retrieve the current value of the given setting from the database.

get_extra_geographic_information(value)

get_library_from_uuid(library_uuid)

image_setting(setting)

Retrieve an uploaded image for the given setting from the current HTTP request.

library_configuration_settings(library, validators_by_format, settings=None)

Validate and update a library’s configuration settings based on incoming new values.

Parameters:

• library – A Library

• validators_by_format – A dictionary mapping the ‘format’ field from a setting configuration to a corresponding validator object.

• settings – A list of setting configurations to use in tests instead of Configuration.LIBRARY_SETTINGS

list_setting(setting, json_objects=False)

Retrieve the list of values for the given setting from the current HTTP request.

Parameters:

json_objects – If this is True, the incoming settings are JSON-encoded objects and not regular strings.

Returns:

A JSON-encoded string encoding the list of values set for the given setting in the current request.

process_delete(library_uuid)

process_get()

process_libraries()

process_post(validators_by_type=None)

scalar_setting(setting)

Retrieve the single value of the given setting from the current HTTP request.

validate_form_fields()

api.admin.controller.metadata_service_self_tests module

Self-tests for metadata integrations.

class api.admin.controller.metadata_service_self_tests.MetadataServiceSelfTestsController(manager)

Bases: MetadataServicesController, SelfTestsController

look_up_by_id(id)

process_metadata_service_self_tests(identifier)

api.admin.controller.metadata_services module

class api.admin.controller.metadata_services.MetadataServicesController(manager)

Bases: SitewideRegistrationController

find_protocol_class(integration)

process_delete(service_id)

process_get()

process_metadata_services()

process_post(do_get=<bound method HTTP.debuggable_get of <class 'core.util.http.HTTP'>>, do_post=<bound method HTTP.debuggable_post of <class 'core.util.http.HTTP'>>)

register_with_metadata_wrangler(do_get, do_post, is_new, service)

Register this site with the Metadata Wrangler.

validate_form_fields(**fields)

The ‘name’ and ‘protocol’ fields cannot be blank, and the protocol must be selected from the list of recognized protocols. The URL must be valid.

api.admin.controller.patron_auth_service_self_tests module

class api.admin.controller.patron_auth_service_self_tests.PatronAuthServiceSelfTestsController(manager)

Bases: SelfTestsController, PatronAuthServicesController

get_info(patron_auth_service)

look_up_by_id(identifier)

process_patron_auth_service_self_tests(identifier)

run_tests(patron_auth_service)

api.admin.controller.patron_auth_services module

class api.admin.controller.patron_auth_services.PatronAuthServicesController(manager)

Bases: SettingsController

check_external_type(library, auth_service)

Check that the library’s external type regular expression is valid, if it was set.

check_identifier_restriction(library, auth_service)

Check whether the library’s identifier restriction regular expression is set and is supposed to be a regular expression; if so, check that it’s valid.

check_libraries(auth_service)

Run the three library validation methods on each of the libraries for which the user is trying to configure this patron auth service.

check_library_integrations(library)

Check that the library didn’t end up with multiple basic auth services.

get_name(auth_service)

Check that there isn’t already an auth service with this name

process_delete(service_id)

process_get()

process_patron_auth_services()

process_post()

validate_form_fields(protocol)

Verify that the protocol which the user has selected is in the list of recognized protocol options.

api.admin.controller.search_service_self_tests module

class api.admin.controller.search_service_self_tests.SearchServiceSelfTestsController(manager)

Bases: SelfTestsController, ExternalSearchTest

look_up_by_id(identifier)

process_search_service_self_tests(identifier)

api.admin.controller.self_tests module

class api.admin.controller.self_tests.SelfTestsController(manager)

Bases: SettingsController

find_protocol_class(integration)

Given an ExternalIntegration, find the class on which run_tests() or prior_test_results() should be called, and any extra arguments that should be passed into the call.

get_info(integration)

run_tests(integration)

self_tests_process_get(identifier)

self_tests_process_post(identifier)

api.admin.controller.sitewide_services module

class api.admin.controller.sitewide_services.LoggingServicesController(manager)

Bases: SitewideServicesController

process_delete(service_id)

process_services()

class api.admin.controller.sitewide_services.SearchServicesController(manager)

Bases: SitewideServicesController

process_delete(service_id)

process_services()

class api.admin.controller.sitewide_services.SitewideServicesController(manager)

Bases: SettingsController

process_get(protocols, goal, service_key_name)

process_post(protocols, goal, multiple_sitewide_services_detail)

validate_form_fields(protocols, **fields)

The ‘name’ and ‘protocol’ fields cannot be blank, and the protocol must be selected from the list of recognized protocols.

api.admin.controller.sitewide_settings module

class api.admin.controller.sitewide_settings.SitewideConfigurationSettingsController(manager)

Bases: SettingsController

process_delete(key)

process_get()

process_post()

process_services()

validate_form_fields(setting, fields)

api.admin.controller.storage_services module

class api.admin.controller.storage_services.StorageServicesController(manager)

Bases: SettingsController

process_delete(service_id)

process_get()

process_post()

process_services()

api.admin.controller.work_editor module

class api.admin.controller.work_editor.WorkController(manager)

Bases: AdminCirculationManagerController

BOTTOM = 'bottom'

CENTER = 'center'

MINIMUM_COVER_HEIGHT = 900

MINIMUM_COVER_WIDTH = 600

STAFF_WEIGHT = 1000

TITLE_POSITIONS = ['top', 'center', 'bottom']

TOP = 'top'

change_book_cover(identifier_type, identifier, mirrors=None)

Save a new book cover based on the submitted form.

classifications(identifier_type, identifier)

Return list of this work’s classifications.

Args:

identifier_type (string): Type of identifier e.g ISBN identifier (string): Identifier for a work

Returns:

dict: A dict of work with list of classifications for the work.

complaints(identifier_type, identifier)

Return detailed complaint information for admins.

custom_lists(identifier_type, identifier)

details(identifier_type, identifier)

Return an OPDS entry with detailed information for admins.

This includes relevant links for editing the book.

Returns:

An OPDSEntryResponse

edit(identifier_type, identifier)

Edit a work’s metadata.

edit_classifications(identifier_type, identifier)

Edit a work’s audience, target age, fiction status, and genres.

generate_cover_image(work, identifier_type, identifier, preview=False)

languages()

Return the supported language codes and their English names.

media()

Return the supported media types for a work and their schema.org values.

preview_book_cover(identifier_type, identifier)

Return a preview of the submitted cover image information.

refresh_metadata(identifier_type, identifier, provider=None)

Refresh the metadata for a book from the content server

resolve_complaints(identifier_type, identifier)

Resolve all complaints for a particular license pool and complaint type.

rights_status()

Return the supported rights status values with their names and whether they are open access.

roles()

Return a mapping from MARC codes to contributor roles.

suppress(identifier_type, identifier)

Suppress the license pool associated with a book.

unsuppress(identifier_type, identifier)

Unsuppress all license pools associated with a book.

TODO: This will need to be revisited when we distinguish between complaints about a work and complaints about a LicensePoool.

Module contents

class api.admin.controller.AdminCirculationManagerController(manager)

Bases: CirculationManagerController

Parent class that provides methods for verifying an admin’s roles.

require_higher_than_librarian()

require_librarian(library)

require_library_manager(library)

require_sitewide_library_manager()

require_system_admin()

class api.admin.controller.AdminController(manager)

Bases: object

admin_auth_provider(type)

Return an auth provider with the given type. If no auth provider has this type, return None.

property admin_auth_providers

authenticated_admin(admin_details)

Creates or updates an admin with the given details

authenticated_admin_from_request()

Returns an authenticated admin or a problem detail.

check_csrf_token()

Verifies that the CSRF token in the form data or X-CSRF-Token header matches the one in the session cookie.

generate_csrf_token()

Generate a random CSRF token.

get_csrf_token()

Returns the CSRF token for the current session.

class api.admin.controller.CustomListsController(manager)

Bases: AdminCirculationManagerController

custom_list(list_id)

custom_lists()

url_for_custom_list(library, list)

class api.admin.controller.DashboardController(manager)

Bases: AdminCirculationManagerController

bulk_circulation_events(analytics_exporter=None)

circulation_events()

Return dict of circulation events for a given work.

Optional “num” parameter in request to change number of results.

Returns:

dict: A dictionary of events

stats()

Return an accounting of library statistics

Returns:

dict: Stats total licenses, available licenses, and patrons for each library.

class api.admin.controller.FeedController(manager)

Bases: AdminCirculationManagerController

complaints()

genres()

suppressed()

class api.admin.controller.LanesController(manager)

Bases: AdminCirculationManagerController

change_order()

hide_lane(lane_identifier)

lane(lane_identifier)

lanes()

reset()

show_lane(lane_identifier)

class api.admin.controller.PatronController(manager)

Bases: AdminCirculationManagerController

lookup_patron(authenticator=None)

Look up personal information about a patron via the ILS.

Parameters:

authenticator – A LibraryAuthenticator. This is for mocking during tests; it’s not necessary to provide it normally.

reset_adobe_id(authenticator=None)

Delete all Credentials for a patron that are relevant to the patron’s Adobe Account ID.

Parameters:

authenticator – A LibraryAuthenticator. This is for mocking during tests; it’s not necessary to provide it normal

class api.admin.controller.SettingsController(manager)

Bases: AdminCirculationManagerController

METADATA_SERVICE_URI_TYPE = 'application/opds+json;profile=https://librarysimplified.org/rel/profile/metadata-service'

NO_MIRROR_INTEGRATION = 'NO_MIRROR'

PROVIDER_APIS = [<class 'core.opds_import.OPDSImporter'>, <class 'api.opds_for_distributors.OPDSForDistributorsAPI'>, <class 'core.opds2_import.OPDS2Importer'>, <class 'api.proquest.importer.ProQuestOPDS2Importer'>, <class 'api.overdrive.OverdriveAPI'>, <class 'api.odilo.OdiloAPI'>, <class 'api.bibliotheca.BibliothecaAPI'>, <class 'api.axis.Axis360API'>, <class 'api.rbdigital.RBDigitalAPI'>, <class 'api.enki.EnkiAPI'>, <class 'api.odl.ODLAPI'>, <class 'api.odl.SharedODLAPI'>, <class 'api.feedbooks.FeedbooksOPDSImporter'>, <class 'api.lcp.collection.LCPAPI'>]

check_name_unique(new_service, name)

A service cannot be created with, or edited to have, the same name as a service that already exists. This method is used by analytics_services, cdn_services, discovery_services, metadata_services, and sitewide_services.

check_url_unique(new_service, url, protocol, goal)

Enforce a rule that a given circulation manager can only have one integration that uses a given URL for a certain purpose.

Whether to enforce this rule for a given type of integration is up to you – it’s a good general rule but there are conceivable exceptions.

This method is used by discovery_services.

look_up_service_by_id(id, protocol, goal=None)

Find an existing service, and make sure that the user is not trying to edit its protocol. This method is used by analytics_services, cdn_services, metadata_services, and sitewide_services.

set_protocols(service, protocol, protocols=None)

Validate the protocol that the user has submitted; depending on whether the validations pass, either save it to this metadata service or return an error message. This method is used by analytics_services, cdn_services, discovery_services, metadata_services, and sitewide_services.

classmethod url_variants(url, check_protocol_variant=True)

Generate minor variants of a URL – HTTP vs HTTPS, trailing slash vs not, etc.

Technically these are all distinct URLs, but in real life they generally mean someone typed the same URL slightly differently. Since this isn’t an exact science, this doesn’t need to catch all variant URLs, only the most common ones.

validate_formats(settings=None, validator=None)

validate_protocol(protocols=None)

class api.admin.controller.SignInController(manager)

Bases: AdminController

ERROR_RESPONSE_TEMPLATE = '<!DOCTYPE HTML><html lang="en"><head><meta charset="utf8"></head><body style="\n    margin: 10vh auto;\n    font-family: -apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica,Arial,sans-serif;\n    padding: 25px 15px;\n    width: 40vw;\n    color: #403d37;\n    border: 1px solid #DDD;\n    border-radius: 4px;\n    display: flex;\n    flex-direction: column;\n    align-items: center;\n\n    border-color: #D0343A;\n"><p><strong>%(status_code)d ERROR:</strong> %(message)s</p><hr style="\n    width: 10vw;\n    margin: 3px 0 0 0;\n    border: none;\n    border-bottom: 1px solid #403d37;\n"><a href="/admin/sign_in" style="\n    background: #1B7FA7;\n    text-align: center;\n    text-decoration: none;\n    border-color: #1B7FA7;\n    border-radius: .25em;\n    color: #fff;\n    padding: 10px;\n    font-size: 1rem;\n    cursor: pointer;\n    display: block;\n    width: 25vw;\n    margin: 2vh auto;\n\n    width: 5vw;\n    margin-bottom: 0;\n">Try again</a></body></html>'

SIGN_IN_TEMPLATE = '<!DOCTYPE HTML><html lang="en"><head><meta charset="utf8"></head><body style="\n    margin: 10vh auto;\n    font-family: -apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica,Arial,sans-serif;\n    padding: 25px 15px;\n    width: 40vw;\n    color: #403d37;\n    border: 1px solid #DDD;\n    border-radius: 4px;\n    display: flex;\n    flex-direction: column;\n    align-items: center;\n"><h1>Library Simplified</h1>%(auth_provider_html)s</body></html>'

change_password()

error_response(problem_detail)

Returns a problem detail as an HTML response

password_sign_in()

redirect_after_google_sign_in()

Uses the Google OAuth client to determine admin details upon callback. Barring error, redirects to the provided redirect url..

sign_in()

Redirects admin if they’re signed in, or shows the sign in page.

sign_out()

class api.admin.controller.SitewideRegistrationController(manager)

Bases: SettingsController

A controller for managing a circulation manager’s registrations with external services.

Currently the only supported site-wide registration is with a metadata wrangler. The protocol for registration with library registries and ODL collections is similar, but those registrations happen on the level of the individual library, not on the level of the circulation manager.

check_content_type(catalog_response)

Make sure the catalog for the service is in a valid format.

get_catalog(do_get, url)

Get the catalog for this service.

get_registration_link(catalog, links)

Get the link for registration from the catalog.

get_shared_secret(response)

Find the shared secret which we need to use in order to register this service, or return an error message if there is no shared secret.

process_sitewide_registration(integration, do_get=<bound method HTTP.debuggable_get of <class 'core.util.http.HTTP'>>, do_post=<bound method HTTP.debuggable_post of <class 'core.util.http.HTTP'>>)

Performs a sitewide registration for a particular service.

Returns:

A ProblemDetail or, if successful, None

register(register_url, headers, do_post)

Register this server using the sitewide registration document.

sitewide_registration_document()

Generate the document to be sent as part of a sitewide registration request.

Returns:

A dictionary with keys ‘url’ and ‘jwt’. ‘url’ is the URL to this site’s public key document, and ‘jwt’ is a JSON Web Token proving control over that URL.

update_headers(integration)

If the integration has an existing shared_secret, use it to access the server and update it.

class api.admin.controller.TimestampsController(manager)

Bases: AdminCirculationManagerController

Returns a dict: each key is a type of service (script, monitor, or coverage provider); each value is a nested dict in which timestamps are organized by service name and then by collection ID.

diagnostics()

class api.admin.controller.ViewController(manager)

Bases: AdminController

api.admin.controller.setup_admin_controllers(manager)

Set up all the controllers that will be used by the admin parts of the web app.