invenio-app-ils 1.0.0a54__py2.py3-none-any.whl → 6.1.0__py2.py3-none-any.whl

invenio_app_ils/closures/api.py

@@ -1,13 +1,14 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2020 CERN.
+# Copyright (C) 2020-2025 CERN.
 #
 # invenio-app-ils is free software; you can redistribute it and/or modify it
 # under the terms of the MIT License; see LICENSE file for more details.
 
 """ILS location closures API."""
 
-from datetime import timedelta
+from datetime import date, timedelta
+from calendar import day_name
 
 import arrow
 
@@ -51,9 +52,7 @@ def _is_open_on(location, date):
 
 def find_next_open_date(location_pid, date):
     """Finds the next day where this location is open."""
-    location = current_app_ils.location_record_cls.get_record_by_pid(
-        location_pid
-    )
+    location = current_app_ils.location_record_cls.get_record_by_pid(location_pid)
     _infinite_loop_guard = date + timedelta(days=365)
     while date < _infinite_loop_guard:
         if _is_open_on(location, date):
@@ -64,6 +63,72 @@ def find_next_open_date(location_pid, date):
     raise IlsException(
         description="Cannot find any date for which the "
         "location %s is open after the given date %s."
-        "Please check opening/closures dates."
-        % (location_pid, date.isoformat())
+        "Please check opening/closures dates." % (location_pid, date.isoformat())
     )
+
+
+def get_closure_periods(location, start, end):
+    """
+    Return date ranges within a specified period when the location is closed.
+    """
+    if (
+        not location
+        or not isinstance(start, date)
+        or not isinstance(end, date)
+        or start > end
+    ):
+        raise ValueError("Invalid input parameters")
+
+    one_day_delta = timedelta(days=1)
+
+    weekday_name_to_index = {name.lower(): i for i, name in enumerate(day_name)}
+    closed_weekdays = set()
+    for weekday_rule in location.get("opening_weekdays", []):
+        if weekday_rule.get("is_open") is False:
+            weekday_str = weekday_rule.get("weekday", "").lower()
+            closed_weekdays.add(weekday_name_to_index[weekday_str])
+
+    exception_overrides = {}
+    for exception in location.get("opening_exceptions", []):
+        is_closed_override = not exception.get("is_open")
+
+        ex_start = date.fromisoformat(exception["start_date"])
+        ex_end = date.fromisoformat(exception["end_date"])
+
+        current_ex_date = ex_start
+        while current_ex_date <= ex_end:
+            exception_overrides[current_ex_date] = is_closed_override
+            current_ex_date += one_day_delta
+
+    closure_periods = []
+    closure_streak_start = None
+    current_date = start
+
+    while current_date <= end:
+        is_date_closed = False
+
+        override_status = exception_overrides.get(current_date)
+
+        if override_status is not None:
+            is_date_closed = override_status
+        else:
+            if current_date.weekday() in closed_weekdays:
+                is_date_closed = True
+
+        if is_date_closed:
+            if closure_streak_start is None:
+                closure_streak_start = current_date
+        else:
+            if closure_streak_start is not None:
+                closure_periods.append(
+                    {"start": closure_streak_start, "end": current_date - one_day_delta}
+                )
+                closure_streak_start = None
+
+        current_date += one_day_delta
+
+    # Handle trailing closed period
+    if closure_streak_start is not None:
+        closure_periods.append({"start": closure_streak_start, "end": end})
+
+    return closure_periods

invenio_app_ils/closures/serializers/__init__.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+#
+# This file is part of Invenio.
+# Copyright (C) 2025-2025 CERN.
+#
+# Invenio is free software; you can redistribute it and/or modify it
+# under the terms of the MIT License; see LICENSE file for more details.
+
+
+from invenio_app_ils.closures.serializers.response import closure_periods_responsify
+from invenio_app_ils.closures.serializers.schema import ClosurePeriodsV1
+
+
+closure_periods_response = closure_periods_responsify(
+    ClosurePeriodsV1, "application/json"
+)

invenio_app_ils/closures/serializers/response.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+#
+# This file is part of Invenio.
+# Copyright (C) 2025-2025 CERN.
+#
+# Invenio is free software; you can redistribute it and/or modify it
+# under the terms of the MIT License; see LICENSE file for more details.
+
+"""Invenio App ILS Closures response serializers."""
+
+import json
+from flask import current_app
+
+
+def closure_periods_responsify(schema_class, mimetype):
+    """Closure periods response serializer.
+
+    :param schema_class: Schema instance.
+    :param mimetype: MIME type of response.
+    """
+
+    def view(data, code=200, headers=None):
+        """Generate the response object."""
+        response_data = schema_class().dump(data)
+
+        response = current_app.response_class(
+            json.dumps(response_data), mimetype=mimetype
+        )
+        response.status_code = code
+
+        if headers is not None:
+            response.headers.extend(headers)
+        return response
+
+    return view

invenio_app_ils/closures/serializers/schema.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+#
+# This file is part of Invenio.
+# Copyright (C) 2025-2025 CERN.
+#
+# Invenio is free software; you can redistribute it and/or modify it
+# under the terms of the MIT License; see LICENSE file for more details.
+
+"""Invenio App ILS Closures response schemas."""
+
+from marshmallow import Schema, fields
+
+
+class DateRangeSchema(Schema):
+    """Schema for a single closure period."""
+
+    start = fields.Date(required=True, description="Start date of the closure period.")
+    end = fields.Date(required=True, description="End date of the closure period.")
+
+
+class ClosurePeriodsV1(Schema):
+    """Schema for a list of closure periods."""
+
+    closure_periods = fields.List(
+        fields.Nested(DateRangeSchema),
+        required=True,
+        description="List of closure date periods.",
+    )

invenio_app_ils/closures/tasks.py

@@ -71,16 +71,13 @@ def notify_location_updated(location_pid):
 
     def is_already_running():
         inspect = Inspect(app=current_app.extensions["invenio-celery"].celery)
-        filtered_results = filter(
-            None, [inspect.scheduled(), inspect.active()]
-        )
+        filtered_results = filter(None, [inspect.scheduled(), inspect.active()])
         for results in filtered_results:
             for result in results.values():
                 for task in result:
                     request = task["request"]
                     matches_name = (
-                        request["name"]
-                        == extend_active_loans_location_closure.name
+                        request["name"] == extend_active_loans_location_closure.name
                     )
                     matches_location = request["args"][0] == location_pid
                     if matches_name and matches_location:
@@ -95,9 +92,7 @@ def notify_location_updated(location_pid):
         if eta <= now:
             eta += timedelta(days=1)
 
-        extend_active_loans_location_closure.apply_async(
-            args=[location_pid], eta=eta
-        )
+        extend_active_loans_location_closure.apply_async(args=[location_pid], eta=eta)
 
 
 @shared_task
@@ -110,9 +105,7 @@ def extend_active_loans_location_closure(location_pid):
             new_end_date = find_next_open_date(location_pid, current_end_date)
             if new_end_date != current_end_date:  # Update loan
                 modified_count += 1
-                loan = current_circulation.loan_record_cls.get_record_by_pid(
-                    hit.pid
-                )
+                loan = current_circulation.loan_record_cls.get_record_by_pid(hit.pid)
                 _log("extend_loan_closure_before", loan)
                 loan.update(end_date=new_end_date.isoformat())
                 loan.commit()

invenio_app_ils/closures/views.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+#
+# This file is part of Invenio.
+# Copyright (C) 2025-2025 CERN.
+#
+# Invenio is free software; you can redistribute it and/or modify it
+# under the terms of the MIT License; see LICENSE file for more details.
+
+"""Invenio App ILS Closure views."""
+
+from flask import Blueprint, abort
+from flask_login import current_user
+from datetime import date
+from invenio_records_rest.views import pass_record
+from invenio_rest import ContentNegotiatedMethodView
+from invenio_app_ils.locations.api import LOCATION_PID_TYPE
+from invenio_app_ils.closures.serializers import closure_periods_response
+from invenio_app_ils.closures.api import get_closure_periods
+from invenio_app_ils.permissions import backoffice_read_permission
+from invenio_app_ils.records.permissions import RecordPermission
+
+
+def create_closures_blueprint(app):
+    """Create location closed periods blueprint."""
+    blueprint = Blueprint("invenio_app_ils_closures", __name__, url_prefix="")
+    endpoints = app.config["RECORDS_REST_ENDPOINTS"]
+
+    options = endpoints[LOCATION_PID_TYPE]
+    default_media_type = options.get("default_media_type", "")
+    closure_periods_serializers = {"application/json": closure_periods_response}
+
+    closure_periods_view = LocationClosurePeriodsResource.as_view(
+        LocationClosurePeriodsResource.view_name,
+        serializers=closure_periods_serializers,
+        default_media_type=default_media_type,
+    )
+    blueprint.add_url_rule(
+        "{0}/closure_periods/<int:year>".format(options["item_route"]),
+        view_func=closure_periods_view,
+        methods=["GET"],
+    )
+
+    return blueprint
+
+
+class LocationClosurePeriodsResource(ContentNegotiatedMethodView):
+    """Returns the closure periods of a Location"""
+
+    view_name = "location_closure_periods"
+
+    @pass_record
+    def get(self, pid, record, year, **kwargs):
+        """Get the date ranges for which a location is closure based in the specified year"""
+
+        factory = RecordPermission(record, "read")
+        if not factory.is_public() and not backoffice_read_permission().can():
+            if not current_user.is_authenticated:
+                abort(401)
+            abort(403)
+
+        start_date = date(year, 1, 1)
+        end_date = date(year, 12, 31)
+
+        closure_periods = get_closure_periods(record, start_date, end_date)
+
+        return self.make_response({"closure_periods": closure_periods}, 200)