def adobe_id_tags(self, patron_identifier):
"""Construct tags using the DRM Extensions for OPDS standard that
explain how to get an Adobe ID for this patron, and how to
manage their list of device IDs.
:param delivery_mechanism: A DeliveryMechanism
:return: If Adobe Vendor ID delegation is configured, a list
containing a <drm:licensor> tag. If not, an empty list.
"""
# CirculationManagerAnnotators are created per request.
# Within the context of a single request, we can cache the
# tags that explain how the patron can get an Adobe ID, and
# reuse them across <entry> tags. This saves a little time,
# makes tests more reliable, and stops us from providing a
# different Short Client Token for every <entry> tag.
if isinstance(patron_identifier, Patron):
cache_key = patron_identifier.id
else:
cache_key = patron_identifier
cached = self._adobe_id_tags.get(cache_key)
if cached is None:
if isinstance(patron_identifier, Patron):
# Find the patron's identifier for Adobe ID purposes.
patron_identifier = self._adobe_patron_identifier(
patron_identifier
)
cached = []
authdata = AuthdataUtility.from_config(self.library)
if authdata:
# TODO: We would like to call encode() here, and have
# the client use a JWT as authdata, but we can't,
# because there's no way to use authdata to deactivate
# a device. So we've used this alternate technique
# that's much smaller than a JWT and can be smuggled
# into username/password.
vendor_id, jwt = authdata.encode_short_client_token(patron_identifier)
drm_licensor = OPDSFeed.makeelement("{%s}licensor" % OPDSFeed.DRM_NS)
vendor_attr = "{%s}vendor" % OPDSFeed.DRM_NS
drm_licensor.attrib[vendor_attr] = vendor_id
patron_key = OPDSFeed.makeelement("{%s}clientToken" % OPDSFeed.DRM_NS)
patron_key.text = jwt
drm_licensor.append(patron_key)
# Add the link to the DRM Device Management Protocol
# endpoint. See:
# https://github.com/NYPL-Simplified/Simplified/wiki/DRM-Device-Management
device_list_link = OPDSFeed.makeelement("link")
device_list_link.attrib['rel'] = 'http://librarysimplified.org/terms/drm/rel/devices'
device_list_link.attrib['href'] = self.url_for(
"adobe_drm_devices", library_short_name=self.library.short_name, _external=True
)
drm_licensor.append(device_list_link)
cached = [drm_licensor]
self._adobe_id_tags[cache_key] = cached
else:
cached = copy.deepcopy(cached)
return cached
def add_patron(self, feed_obj):
patron_details = {}
if self.patron.username:
patron_details["{%s}username" % OPDSFeed.SIMPLIFIED_NS] = self.patron.username
if self.patron.authorization_identifier:
patron_details["{%s}authorizationIdentifier" % OPDSFeed.SIMPLIFIED_NS] = self.patron.authorization_identifier
patron_tag = OPDSFeed.makeelement("{%s}patron" % OPDSFeed.SIMPLIFIED_NS, patron_details)
feed_obj.feed.append(patron_tag)
def user_profile_management_protocol_link(self):
"""Create a <link> tag that points to the circulation
manager's User Profile Management Protocol endpoint
for the current patron.
"""
link = OPDSFeed.makeelement("link")
link.attrib[
'rel'] = 'http://librarysimplified.org/terms/rel/user-profile'
link.attrib['href'] = self.url_for('patron_profile', _external=True)
return link
def open_access_link(self, lpdm):
url = cdnify(lpdm.resource.url, Configuration.cdns())
kw = dict(rel=OPDSFeed.OPEN_ACCESS_REL, href=url)
rep = lpdm.resource.representation
if rep and rep.media_type:
kw['type'] = rep.media_type
link_tag = AcquisitionFeed.link(**kw)
always_available = OPDSFeed.makeelement("{%s}availability" %
OPDSFeed.OPDS_NS,
status="available")
link_tag.append(always_available)
return link_tag
def acquisition_links(self, active_license_pool, active_loan, active_hold, active_fulfillment,
feed, identifier):
"""Generate a number of <link> tags that enumerate all acquisition methods."""
can_borrow = False
can_fulfill = False
can_revoke = False
can_hold = self.library.allow_holds
if active_loan:
can_fulfill = True
can_revoke = True
elif active_hold:
# We display the borrow link even if the patron can't
# borrow the book right this minute.
can_borrow = True
can_revoke = (
not self.circulation or
self.circulation.can_revoke_hold(
active_license_pool, active_hold)
)
elif active_fulfillment:
can_fulfill = True
can_revoke = True
else:
# The patron has no existing relationship with this
# work. Give them the opportunity to check out the work
# or put it on hold.
can_borrow = True
# If there is something to be revoked for this book,
# add a link to revoke it.
revoke_links = []
if can_revoke:
url = self.url_for(
'revoke_loan_or_hold',
license_pool_id=active_license_pool.id,
library_short_name=self.library.short_name,
_external=True)
kw = dict(href=url, rel=OPDSFeed.REVOKE_LOAN_REL)
revoke_link_tag = OPDSFeed.makeelement("link", **kw)
revoke_links.append(revoke_link_tag)
# Add next-step information for every useful delivery
# mechanism.
borrow_links = []
api = None
if self.circulation:
api = self.circulation.api_for_license_pool(active_license_pool)
if api:
set_mechanism_at_borrow = (
api.SET_DELIVERY_MECHANISM_AT == BaseCirculationAPI.BORROW_STEP)
else:
# This is most likely an open-access book. Just put one
# borrow link and figure out the rest later.
set_mechanism_at_borrow = False
if can_borrow:
# Borrowing a book gives you an OPDS entry that gives you
# fulfillment links.
if set_mechanism_at_borrow:
# The ebook distributor requires that the delivery
# mechanism be set at the point of checkout. This means
# a separate borrow link for each mechanism.
for mechanism in active_license_pool.delivery_mechanisms:
borrow_links.append(
self.borrow_link(
identifier,
mechanism, [mechanism]
)
)
else:
# The ebook distributor does not require that the
# delivery mechanism be set at the point of
# checkout. This means a single borrow link with
# indirectAcquisition tags for every delivery
# mechanism. If a delivery mechanism must be set, it
# will be set at the point of fulfillment.
borrow_links.append(
self.borrow_link(
identifier,
None, active_license_pool.delivery_mechanisms
)
)
# Generate the licensing tags that tell you whether the book
# is available.
license_tags = feed.license_tags(
active_license_pool, active_loan, active_hold
)
for link in borrow_links:
for t in license_tags:
link.append(t)
# Add links for fulfilling an active loan.
fulfill_links = []
if can_fulfill:
if active_fulfillment:
# We're making an entry for a specific fulfill link.
type = active_fulfillment.content_type
url = active_fulfillment.content_link
rel = OPDSFeed.ACQUISITION_REL
link_tag = AcquisitionFeed.acquisition_link(
rel=rel, href=url, types=[type])
fulfill_links.append(link_tag)
elif active_loan.fulfillment:
# The delivery mechanism for this loan has been
# set. There is one link for the delivery mechanism
# that was locked in, and links for any streaming
# delivery mechanisms.
for lpdm in active_license_pool.delivery_mechanisms:
if lpdm is active_loan.fulfillment or lpdm.delivery_mechanism.is_streaming:
fulfill_links.append(
self.fulfill_link(
active_license_pool,
active_loan,
lpdm.delivery_mechanism
)
)
else:
# The delivery mechanism for this loan has not been
# set. There is one fulfill link for every delivery
# mechanism.
for lpdm in active_license_pool.delivery_mechanisms:
fulfill_links.append(
self.fulfill_link(
active_license_pool,
active_loan,
lpdm.delivery_mechanism
)
)
# If this is an open-access book, add an open-access link for
# every delivery mechanism with an associated resource.
open_access_links = []
if active_license_pool.open_access:
for lpdm in active_license_pool.delivery_mechanisms:
if lpdm.resource:
open_access_links.append(self.open_access_link(lpdm))
return [x for x in borrow_links + fulfill_links + open_access_links + revoke_links
if x is not None]
