Fulfill works

Author: natlibfi-kaisa

api/circulation.py

@@ -50,7 +50,7 @@
 from core.model.patron import LoanCheckout
 from core.util.datetime_helpers import utc_now
 from core.util.log import LoggerMixin
-
+from core.util.http import HTTP, BadResponseException
 
 class CirculationInfo:
     def __init__(
@@ -1496,7 +1496,7 @@ def fulfill(
         :return: A FulfillmentInfo object.
 
         """
-        fulfillment: FulfillmentInfo
+        fulfillment: Fulfillment
         loan = get_one(
             self._db,
             Loan,

api/controller/loan.py

@@ -53,7 +53,8 @@
 from core.model import DataSource, DeliveryMechanism, Loan, Patron, Representation
 from core.util.http import RemoteIntegrationException
 from core.util.opds_writer import OPDSFeed
-from core.util.problem_detail import ProblemDetail
+from core.util.problem_detail import ProblemDetail, BaseProblemDetailException, ProblemDetail
+from core.exceptions import BaseError
 
 
 class LoanController(CirculationManagerController):
@@ -395,95 +396,33 @@ def fulfill(
 
         try:
             fulfillment = self.circulation.fulfill(
-                patron,
+                patron,  # type: ignore[arg-type]
                 credential,
                 requested_license_pool,
                 mechanism,
             )
-        except DeliveryMechanismConflict as e:
-            return DELIVERY_CONFLICT.detailed(str(e))
-        except NoActiveLoan as e:
-            return NO_ACTIVE_LOAN.detailed(
-                _("Can't fulfill loan because you have no active loan for this book."),
-                status_code=e.status_code,
-            )
-        except FormatNotAvailable as e:
-            return NO_ACCEPTABLE_FORMAT.with_debug(str(e), status_code=e.status_code)
-        except CannotFulfill as e:
-            return CANNOT_FULFILL.with_debug(str(e), status_code=e.status_code)
-        except DeliveryMechanismError as e:
-            return BAD_DELIVERY_MECHANISM.with_debug(str(e), status_code=e.status_code)
-
-        # A subclass of FulfillmentInfo may want to bypass the whole
-        # response creation process.
-        response = fulfillment.as_response
-        
-        if response is not None:
-            print("fulfill response: ", response)
-            return response
-
-        headers = dict()
-        encoding_header = dict()
-        if (
-            fulfillment.data_source_name == DataSource.ENKI
-            and mechanism.delivery_mechanism.drm_scheme_media_type
-            == DeliveryMechanism.NO_DRM
+        except (CirculationException, RemoteInitiatedServerError) as e:
+            return e.problem_detail
+
+        # TODO: This should really be turned into its own Fulfillment class,
+        #   so each integration can choose when to return a feed response like
+        #   this, and when to return a direct response.
+        if mechanism.delivery_mechanism.is_streaming and isinstance(
+            fulfillment, UrlFulfillment
         ):
-            encoding_header["Accept-Encoding"] = "deflate"
-
-        if mechanism.delivery_mechanism.is_streaming:
-            # If this is a streaming delivery mechanism, create an OPDS entry
-            # with a fulfillment link to the streaming reader url.
-            feed = OPDSAcquisitionFeed.single_entry_loans_feed(
+            # If this is a streaming delivery mechanism (note: E-kirjasto does not stream),
+            # create an OPDS entry with a fulfillment link to the streaming reader url.
+            return OPDSAcquisitionFeed.single_entry_loans_feed(
                 self.circulation, loan, fulfillment=fulfillment
             )
-            if isinstance(feed, ProblemDetail):
-                print("problems")
-                # This should typically never happen, since we've gone through the entire fulfill workflow
-                # But for the sake of return-type completeness we are adding this here
-                return feed
-            if isinstance(feed, Response):
-                print("response")
-                return feed
-            else:
-                content = etree.tostring(feed)
-            status_code = 200
-            headers["Content-Type"] = OPDSFeed.ACQUISITION_FEED_TYPE
-        elif fulfillment.content_link_redirect is True:
-            # The fulfillment API has asked us to not be a proxy and instead redirect the client directly
-            print(f"elif fulfillment.content_link_redirect is True:")
-            return redirect(fulfillment.content_link)
-        else:
-            content = fulfillment.content
-            if fulfillment.content_link:
-                print("if fulfillment.content_link: ", fulfillment.content_link)
-                # If we have a link to the content on a remote server, web clients may not
-                # be able to access it if the remote server does not support CORS requests.
-
-                # If the pool is open access though, the web client can link directly to the
-                # file to download it, so it's safe to redirect.
-                if requested_license_pool.open_access:
-                    print("if requested_license_pool.open_access:")
-                    return redirect(fulfillment.content_link)
-
-                # Otherwise, we need to fetch the content and return it instead
-                # of redirecting to it, since it may be downloaded through an
-                # indirect acquisition link.
-                try:
-                    status_code, headers, content = do_get(
-                        fulfillment.content_link, headers=encoding_header
-                    )
-                    headers = dict(headers)
-                    print(f"loanpy fulfill: code: {status_code}, headers: {headers}, fulfillment.content_link: {fulfillment.content_link}")
-                except RemoteIntegrationException as e:
-                    return e.as_problem_detail_document(debug=False)
-            else:
-                status_code = 200
-            if fulfillment.content_type:
-                headers["Content-Type"] = fulfillment.content_type
 
-        print(f"fulfill at end response: {response}, status: {status_code} headers: {headers}")
-        return Response(response=content, status=status_code, headers=headers)
+        try:
+            resp = fulfillment.response()
+            print("response in loan: ", resp)
+            return resp
+        except BaseError as e:
+            return e.problem_detail
+
 
     def can_fulfill_without_loan(self, library, patron, pool, lpdm):
         """Is it acceptable to fulfill the given LicensePoolDeliveryMechanism

api/odl.py

@@ -436,7 +436,7 @@ def checkin(self, patron: Patron, pin: str, licensepool: LicensePool) -> None:
             raise NotCheckedOut()
         loan_result = loan.one()
 
-        if loan_result.license_pool.open_access:
+        if license_pool.open_access or licensepool.unlimited_access:
             # If this is an open-access book, we don't need to do anything.
             return
 
@@ -512,7 +512,7 @@ def checkout(
         if loan.count() > 0:
             raise AlreadyCheckedOut()
 
-        if licensepool.open_access:
+        if licensepool.open_access or licensepool.unlimited_access:
             loan_start = None
             loan_end = None
             external_identifier = None
@@ -756,39 +756,6 @@ def _unlimited_access_fulfill(
         content_type = resource.representation.media_type
         return RedirectFulfillment(content_link, content_type) # Tää pitää kattoo, ei ole circulation.py:ssä
 
-    # PITÄÄ POISTAA
-    @staticmethod
-    def _find_content_link_and_type(
-        links: list[dict[str, str]],
-        drm_scheme: str | None,
-    ) -> tuple[str | None, str | None]:
-        """Find a content link with the type information corresponding to the selected delivery mechanism.
-
-        :param links: List of dict-like objects containing information about available links in the LCP license file
-        :param drm_scheme: Selected delivery mechanism DRM scheme
-
-        :return: Two-tuple containing a content link and content type
-        """
-        candidates = []
-        for link in links:
-            # Depending on the format being served, the crucial information
-            # may be in 'manifest' or in 'license'.
-            if link.get("rel") not in ("manifest", "license"):
-                continue
-            href = link.get("href")
-            type = link.get("type")
-            candidates.append((href, type))
-
-        if len(candidates) == 0:
-            # No candidates
-            return None, None
-
-        # For DeMarque audiobook content, we need to translate the type property
-        # to reflect what we have stored in our delivery mechanisms.
-        if drm_scheme == DeliveryMechanism.FEEDBOOKS_AUDIOBOOK_DRM:
-            drm_scheme = ODLImporter.FEEDBOOKS_AUDIO
-
-        return next(filter(lambda x: x[1] == drm_scheme, candidates), (None, None))
 
     def _license_fulfill(
         self, loan: Loan, delivery_mechanism: LicensePoolDeliveryMechanism
@@ -841,67 +808,11 @@ def _fulfill(
         loan: Loan,
         delivery_mechanism: LicensePoolDeliveryMechanism,
     ) -> Fulfillment:
-        if loan.license_pool.open_access:
+        if loan.license_pool.open_access or licensepool.unlimited_access:
                 return self._unlimited_access_fulfill(loan, delivery_mechanism)
         else:
             return self._license_fulfill(loan, delivery_mechanism)
 
-    def _fulfill_old(
-        self,
-        loan: Loan,
-        delivery_mechanism: LicensePoolDeliveryMechanism,
-    ) -> FulfillmentInfo:
-        licensepool = loan.license_pool
-
-        if licensepool.open_access:
-            expires = None
-            requested_mechanism = delivery_mechanism.delivery_mechanism
-            self.log.info(f"delivery mech: {requested_mechanism}")
-            fulfillment = next(
-                (
-                    lpdm
-                    for lpdm in licensepool.delivery_mechanisms
-                    if lpdm.delivery_mechanism == requested_mechanism
-                ),
-                None,
-            )
-            self.log.info(f"fulfillment: {fulfillment}")
-            if fulfillment is None:
-                raise FormatNotAvailable()
-            content_link = fulfillment.resource.representation.public_url
-            content_type = fulfillment.resource.representation.media_type
-        else:
-            doc = self.get_license_status_document(loan)
-            status = doc.get("status")
-
-            if status not in [self.READY_STATUS, self.ACTIVE_STATUS]:
-                # This loan isn't available for some reason. It's possible
-                # the distributor revoked it or the patron already returned it
-                # through the DRM system, and we didn't get a notification
-                # from the distributor yet.
-                self.update_loan(loan, doc)
-                raise CannotFulfill()
-
-            expires = doc.get("potential_rights", {}).get("end")
-            expires = dateutil.parser.parse(expires)
-
-            links = doc.get("links", [])
-
-            content_link, content_type = self._find_content_link_and_type(
-                links, delivery_mechanism.delivery_mechanism.drm_scheme
-            )
-            self.log.info(f"cont link: {content_link}, type: {content_type}")
-
-        return FulfillmentInfo(
-            licensepool.collection,
-            licensepool.data_source.name,
-            licensepool.identifier.type,
-            licensepool.identifier.identifier,
-            content_link,
-            content_type,
-            None,
-            expires,
-        )
 
     def _count_holds_before(self, holdinfo: HoldInfo, pool: LicensePool) -> int:
         # Count holds on the license pool that started before this hold and
@@ -1102,9 +1013,9 @@ def _place_hold(self, patron: Patron, licensepool: LicensePool) -> HoldInfo:
             licensepool.data_source.name,
             licensepool.identifier.type,
             licensepool.identifier.identifier,
-            utc_now(),
-            None,
-            0,
+            start_date=utc_now(),
+            end_date=None,
+            hold_position=licensepool.patrons_in_hold_queue,
         )
         library = patron.library
         self._update_hold_end_date(holdinfo, licensepool, library=library)

core/util/problem_detail.py

@@ -7,6 +7,7 @@
 import json as j
 import logging
 
+from abc import ABC, abstractmethod
 from flask_babel import LazyString
 from pydantic import BaseModel
 
@@ -154,3 +155,36 @@ def problem_detail(self) -> ProblemDetail:
         :return: ProblemDetail object associated with this exception
         """
         return self._problem_detail
+
+class BaseProblemDetailException(BaseError, ABC):
+    """Mixin for exceptions that can be converted into a ProblemDetail."""
+
+    @property
+    @abstractmethod
+    def problem_detail(self) -> ProblemDetail:
+        """Convert this object into a ProblemDetail."""
+        ...
+
+
+class ProblemDetailException(BaseProblemDetailException):
+    """Exception class allowing to raise and catch ProblemDetail objects."""
+
+    def __init__(self, problem_detail: ProblemDetail) -> None:
+        """Initialize a new instance of ProblemError class.
+
+        :param problem_detail: ProblemDetail object
+        """
+        if not isinstance(problem_detail, ProblemDetail):
+            raise ValueError(
+                'Argument "problem_detail" must be an instance of ProblemDetail class'
+            )
+        super().__init__(problem_detail.title)
+        self._problem_detail = problem_detail
+
+    @property
+    def problem_detail(self) -> ProblemDetail:
+        """Return the ProblemDetail object associated with this exception.
+
+        :return: ProblemDetail object associated with this exception
+        """
+        return self._problem_detail