[SDESK-7516] - Upgrade Locations resource & service to async (#2219)

* Create location resource model

* Create location async service

* Create resource config for Location async service, register it in module, set old service to internal resource

* Added Locations rest endpoints to cover on_fetched and on_fetched_item

* Code refactor

* Simplify find count with just count, add generate_guid in model, remove on_create

* Added auth config

* Added fields.Keywords and validate unique where needed

* Added validate on guid

Author: BrianMwangi21

server/planning/locations/__init__.py

@@ -12,6 +12,11 @@
 import superdesk
 from .locations_service import LocationsResource, LocationsService
 
+from .locations_service_async import LocationsAsyncService
+from .module import locations_resource_config
+
+__all__ = ["LocationsAsyncService", "locations_resource_config"]
+
 
 def init_app(app):
     locations_search_service = LocationsService("locations", backend=superdesk.get_backend())

server/planning/locations/locations_service.py

@@ -173,3 +173,4 @@ class LocationsResource(Resource):
     }
 
     merge_nested_documents = True
+    internal_resource = True

server/planning/locations/locations_service_async.py

@@ -0,0 +1,30 @@
+from typing import Any
+
+from planning.core.service import BasePlanningAsyncService
+from planning.events.events_service import EventsAsyncService
+from planning.types import LocationResourceModel
+
+from superdesk.resource_fields import ID_FIELD
+
+
+class LocationsAsyncService(BasePlanningAsyncService[LocationResourceModel]):
+    async def delete_many(self, lookup: dict[str, Any]) -> list[str]:
+        """
+        If the document to be deleted is referenced in an event, flag it as inactive otherwise just delete it.
+        """
+        if lookup:
+            location = await self.find_by_id(lookup[ID_FIELD])
+            if location:
+                events_count = await EventsAsyncService().count({"location.qcode": str(location.guid)})
+                if events_count > 0:
+                    # Update the unique name in case the location get recreated
+                    await self.update(
+                        location.id,
+                        {
+                            "is_active": False,
+                            "unique_name": str(location.id),
+                        },
+                    )
+                    return []
+
+        return await super().delete_many(lookup)

server/planning/locations/module.py

@@ -0,0 +1,29 @@
+from superdesk.core.auth.privilege_rules import http_method_privilege_based_rules
+from superdesk.core.resources import (
+    ResourceConfig,
+    ElasticResourceConfig,
+    RestEndpointConfig,
+)
+
+from planning.types import LocationResourceModel
+from .locations_service_async import LocationsAsyncService
+from .rest_api import LocationsRestEndpoints
+
+locations_resource_config: ResourceConfig = ResourceConfig(
+    name="locations",
+    data_class=LocationResourceModel,
+    service=LocationsAsyncService,
+    elastic=ElasticResourceConfig(),
+    rest_endpoints=RestEndpointConfig(
+        item_methods=["GET", "PATCH", "PUT", "DELETE"],
+        resource_methods=["GET", "POST"],
+        endpoints_class=LocationsRestEndpoints,
+        auth=http_method_privilege_based_rules(
+            {
+                "POST": "planning",
+                "PATCH": "planning_locations_management",
+                "DELETE": "planning_locations_management",
+            }
+        ),
+    ),
+)

server/planning/locations/rest_api.py

@@ -0,0 +1,19 @@
+from planning.common import format_address
+
+from superdesk.core.types import Request, RestGetResponse
+from superdesk.core.resources import ResourceRestEndpoints
+
+
+class LocationsRestEndpoints(ResourceRestEndpoints):
+    async def on_fetched(self, request: Request, doc: RestGetResponse) -> None:
+        """
+        Overriding to format location address for multi-item response
+        """
+        for item in doc.get("_items", []):
+            format_address(item)
+
+    async def on_fetched_item(self, request: Request, doc: dict) -> None:
+        """
+        Overriding to format location address for single item response
+        """
+        format_address(doc)

server/planning/module.py

@@ -22,7 +22,7 @@
 from planning.assignments import assignments_resource_config, delivery_resource_config
 from planning.published import published_resource_config
 from planning.content_profiles import planning_types_resource_config
-
+from planning.locations import locations_resource_config
 from .planning_locks import planning_locks as planning_locks_endpoint
 
 
@@ -74,5 +74,6 @@ def init_planning(app: SuperdeskAsyncApp):
         events_autosave_resource_config,
         planning_featured_resource_config,
         planning_autosave_resource_config,
+        locations_resource_config,
     ],
 )

server/planning/types/__init__.py

@@ -26,6 +26,7 @@
 from .planning_types import PlanningTypesResourceModel
 from .planning_featured import PlanningFeaturedResourceModel
 from .autosave import EventAutosaveResourceModel, PlanningAutosaveResourceModel
+from .locations import LocationResourceModel
 
 
 __all__ = [
@@ -49,6 +50,7 @@
     "PlanningFeaturedResourceModel",
     "EventAutosaveResourceModel",
     "PlanningAutosaveResourceModel",
+    "LocationResourceModel",
 ]
 
 

server/planning/types/locations.py

@@ -0,0 +1,83 @@
+from datetime import datetime
+from typing import Any, Annotated
+from pydantic import Field
+
+from planning.types.base import BasePlanningModel
+
+from superdesk.utc import utcnow
+from superdesk.core.resources import fields, dataclass
+from superdesk.core.resources.validators import validate_data_relation_async, validate_iunique_value_async
+from superdesk.core.utils import generate_guid, GUID_NEWSML
+
+
+@dataclass
+class Position:
+    latitude: float | None = None
+    longitude: float | None = None
+    altitude: int | None = None
+    gps_datum: str | None = None
+
+
+@dataclass
+class Address:
+    title: str | None = None
+    line: list[str] | None = None
+    suburb: str | None = None
+    city: str | None = None
+    state: str | None = None
+    postal_code: str | None = None
+    country: str | None = None
+    locality: str | None = None  # Aka city
+    area: str | None = None
+    external: dict | None = None
+    boundingbox: list | None = None
+    address_type: str | None = Field(alias="type", default=None)
+
+
+class LocationResourceModel(BasePlanningModel):
+    guid: Annotated[
+        fields.Keyword,
+        validate_iunique_value_async("locations", "guid"),
+        Field(default_factory=lambda: generate_guid(type=GUID_NEWSML)),
+    ]
+    unique_id: Annotated[int, validate_iunique_value_async("locations", "unique_id")] | None = None
+    unique_name: Annotated[fields.Keyword, validate_iunique_value_async("locations", "unique_name")] | None = None
+    version: int | None = None
+    ingest_id: fields.Keyword | None = None
+
+    # Audit Information
+    firstcreated: datetime = Field(default_factory=utcnow)
+    versioncreated: datetime = Field(default_factory=utcnow)
+
+    # Ingest Details
+    ingest_provider: Annotated[fields.ObjectId, validate_data_relation_async("ingest_providers")] | None = None
+    source: fields.Keyword | None = None
+    original_source: fields.Keyword | None = None
+    ingest_provider_sequence: fields.Keyword | None = None
+
+    # Location Details
+    # NewsML-G2 Event properties See:
+    #    https://iptc.org/std/NewsML-G2/2.23/specification/XML-Schema-Doc-Core/ConceptItem.html#LinkC5
+    name: str | None = None
+    translations: dict[str, Any] | None = None
+    location_type: str = Field(alias="type", default="Unclassified")
+
+    # Position Details
+    # NewsML-G2 poiDetails properties See IPTC-G2-Implementation_Guide 12.6.3
+    # or https://iptc.org/std/NewsML-G2/2.23/specification/XML-Schema-Doc-Power/ConceptItem.html#LinkAA
+    position: Position | None = None
+
+    # Address Details
+    address: Address | None = None
+
+    # Other Location Info
+    access: list[str] | None = None
+    details: list[str] | None = None
+    created: datetime | None = None
+    ceased_to_exist: datetime | None = None
+    open_hours: str | None = None
+    capacity: str | None = None
+    contact_info: list[str] | None = None
+    is_active: bool = Field(
+        default=True, description="Flag indicates if the location is active and should be shown in the UI"
+    )