udata 9.2.5.dev32190__py2.py3-none-any.whl → 9.2.5.dev32222__py2.py3-none-any.whl

udata/api/__init__.py

@@ -303,6 +303,7 @@ def init_app(app):
     import udata.core.dataset.api  # noqa
     import udata.core.dataset.apiv2  # noqa
     import udata.core.dataservices.api  # noqa
+    import udata.core.dataservices.apiv2  # noqa
     import udata.core.discussions.api  # noqa
     import udata.core.reuse.api  # noqa
     import udata.core.reuse.apiv2  # noqa

udata/core/dataservices/api.py

@@ -7,8 +7,8 @@ from flask_login import current_user
 
 from udata.api import API, api, fields
 from udata.api_fields import patch
+from udata.core.dataservices.permissions import OwnablePermission
 from udata.core.dataset.models import Dataset
-from udata.core.dataset.permissions import OwnablePermission
 from udata.core.followers.api import FollowAPI
 from udata.rdf import RDF_EXTENSIONS, graph_response, negociate_content
 

udata/core/dataservices/apiv2.py

@@ -0,0 +1,29 @@
+from flask import request
+
+from udata import search
+from udata.api import API, apiv2
+from udata.core.dataservices.models import Dataservice, HarvestMetadata
+from udata.utils import multi_to_dict
+
+from .search import DataserviceSearch
+
+apiv2.inherit("DataservicePage", Dataservice.__page_fields__)
+apiv2.inherit("Dataservice (read)", Dataservice.__read_fields__)
+apiv2.inherit("HarvestMetadata (read)", HarvestMetadata.__read_fields__)
+
+ns = apiv2.namespace("dataservices", "Dataservice related operations")
+
+search_parser = DataserviceSearch.as_request_parser()
+
+
+@ns.route("/search/", endpoint="dataservice_search")
+class DataserviceSearchAPI(API):
+    """Dataservices collection search endpoint"""
+
+    @apiv2.doc("search_dataservices")
+    @apiv2.expect(search_parser)
+    @apiv2.marshal_with(Dataservice.__page_fields__)
+    def get(self):
+        """Search all dataservices"""
+        search_parser.parse_args()
+        return search.query(DataserviceSearch, **multi_to_dict(request.args))

udata/core/dataservices/search.py

@@ -0,0 +1,118 @@
+import datetime
+
+from bson.objectid import ObjectId
+from flask_restx.inputs import boolean
+
+from udata.api import api
+from udata.api.parsers import ModelApiParser
+from udata.models import Dataservice, Organization, User
+from udata.search import (
+    BoolFilter,
+    Filter,
+    ModelSearchAdapter,
+    ModelTermsFilter,
+    register,
+)
+from udata.utils import to_iso_datetime
+
+__all__ = ("DataserviceSearch",)
+
+DEFAULT_SORTING = "-created_at"
+
+
+class DataserviceApiParser(ModelApiParser):
+    sorts = {
+        "created": "created_at",
+    }
+
+    def __init__(self):
+        super().__init__()
+        self.parser.add_argument("tag", type=str, location="args")
+        self.parser.add_argument("organization", type=str, location="args")
+        self.parser.add_argument("is_restricted", type=bool, location="args")
+
+    @staticmethod
+    def parse_filters(dataservices, args):
+        if args.get("q"):
+            # Following code splits the 'q' argument by spaces to surround
+            # every word in it with quotes before rebuild it.
+            # This allows the search_text method to tokenise with an AND
+            # between tokens whereas an OR is used without it.
+            phrase_query = " ".join([f'"{elem}"' for elem in args["q"].split(" ")])
+            dataservices = dataservices.search_text(phrase_query)
+        if args.get("tag"):
+            dataservices = dataservices.filter(tags=args["tag"])
+        if args.get("organization"):
+            if not ObjectId.is_valid(args["organization"]):
+                api.abort(400, "Organization arg must be an identifier")
+            dataservices = dataservices.filter(organization=args["organization"])
+        if "is_restricted" in args:
+            dataservices = dataservices.filter(is_restricted=boolean(args["is_restricted"]))
+        return dataservices
+
+
+@register
+class DataserviceSearch(ModelSearchAdapter):
+    model = Dataservice
+    search_url = "dataservices/"
+
+    sorts = {
+        "created": "created_at",
+    }
+
+    filters = {
+        "tag": Filter(),
+        "organization": ModelTermsFilter(model=Organization),
+        "archived": BoolFilter(),
+    }
+
+    @classmethod
+    def is_indexable(cls, dataservice: Dataservice) -> bool:
+        return dataservice.deleted_at is None and not dataservice.private
+
+    @classmethod
+    def mongo_search(cls, args):
+        dataservices = Dataservice.objects.visible()
+        dataservices = DataserviceApiParser.parse_filters(dataservices, args)
+
+        sort = (
+            cls.parse_sort(args["sort"])
+            or ("$text_score" if args["q"] else None)
+            or DEFAULT_SORTING
+        )
+        return dataservices.order_by(sort).paginate(args["page"], args["page_size"])
+
+    @classmethod
+    def serialize(cls, dataservice: Dataservice) -> dict:
+        organization = None
+        owner = None
+        if dataservice.organization:
+            org = Organization.objects(id=dataservice.organization.id).first()
+            organization = {
+                "id": str(org.id),
+                "name": org.name,
+                "public_service": 1 if org.public_service else 0,
+                "followers": org.metrics.get("followers", 0),
+            }
+        elif dataservice.owner:
+            owner = User.objects(id=dataservice.owner.id).first()
+        extras = {}
+        for key, value in dataservice.extras.items():
+            extras[key] = to_iso_datetime(value) if isinstance(value, datetime.datetime) else value
+
+        return {
+            "id": str(dataservice.id),
+            "title": dataservice.title,
+            "description": dataservice.description,
+            "base_api_url": dataservice.base_api_url,
+            "created_at": to_iso_datetime(dataservice.created_at),
+            "archived": to_iso_datetime(dataservice.archived_at)
+            if dataservice.archived_at
+            else None,
+            "organization": organization,
+            "owner": str(owner.id) if owner else None,
+            "tags": dataservice.tags,
+            "extras": extras,
+            "followers": dataservice.metrics.get("followers", 0),
+            "is_restricted": dataservice.is_restricted or False,
+        }

udata/core/dataset/search.py

@@ -52,7 +52,7 @@ class DatasetSearch(ModelSearchAdapter):
 
     @classmethod
     def mongo_search(cls, args):
-        datasets = Dataset.objects(archived=None, deleted=None, private=False)
+        datasets = Dataset.objects.visible()
         datasets = DatasetApiParser.parse_filters(datasets, args)
 
         sort = (
@@ -60,8 +60,7 @@ class DatasetSearch(ModelSearchAdapter):
             or ("$text_score" if args["q"] else None)
             or DEFAULT_SORTING
         )
-        offset = (args["page"] - 1) * args["page_size"]
-        return datasets.order_by(sort).skip(offset).limit(args["page_size"]), datasets.count()
+        return datasets.order_by(sort).paginate(args["page"], args["page_size"])
 
     @classmethod
     def serialize(cls, dataset):

udata/core/organization/search.py

@@ -34,7 +34,7 @@ class OrganizationSearch(search.ModelSearchAdapter):
 
     @classmethod
     def mongo_search(cls, args):
-        orgs = Organization.objects(deleted=None)
+        orgs = Organization.objects.visible()
         orgs = OrgApiParser.parse_filters(orgs, args)
 
         sort = (
@@ -42,8 +42,7 @@ class OrganizationSearch(search.ModelSearchAdapter):
             or ("$text_score" if args["q"] else None)
             or DEFAULT_SORTING
         )
-        offset = (args["page"] - 1) * args["page_size"]
-        return orgs.order_by(sort).skip(offset).limit(args["page_size"]), orgs.count()
+        return orgs.order_by(sort).paginate(args["page"], args["page_size"])
 
     @classmethod
     def serialize(cls, organization):

udata/core/reuse/search.py

@@ -44,7 +44,7 @@ class ReuseSearch(ModelSearchAdapter):
 
     @classmethod
     def mongo_search(cls, args):
-        reuses = Reuse.objects(deleted=None, private__ne=True)
+        reuses = Reuse.objects.visible()
         reuses = ReuseApiParser.parse_filters(reuses, args)
 
         sort = (
@@ -52,8 +52,7 @@ class ReuseSearch(ModelSearchAdapter):
             or ("$text_score" if args["q"] else None)
             or DEFAULT_SORTING
         )
-        offset = (args["page"] - 1) * args["page_size"]
-        return reuses.order_by(sort).skip(offset).limit(args["page_size"]), reuses.count()
+        return reuses.order_by(sort).paginate(args["page"], args["page_size"])
 
     @classmethod
     def serialize(cls, reuse: Reuse) -> dict:

udata/search/query.py

@@ -54,8 +54,10 @@ class SearchQuery:
                 "sort": self.sort,
             }
             query_args.update(self._filters)
-            result, total = self.adapter.mongo_search(query_args)
-            return SearchResult(query=self, mongo_objects=result, total=total, **query_args)
+            result = self.adapter.mongo_search(query_args)
+            return SearchResult(
+                query=self, mongo_objects=list(result), total=result.total, **query_args
+            )
 
     def to_url(self, url=None, replace=False, **kwargs):
         """Serialize the query into an URL"""