udata 10.8.4.dev37339__py2.py3-none-any.whl → 10.8.4.dev37405__py2.py3-none-any.whl

udata/core/dataservices/api.py

@@ -9,6 +9,7 @@ from flask_login import current_user
 
 from udata.api import API, api, fields
 from udata.api_fields import patch
+from udata.auth import admin_permission
 from udata.core.dataservices.constants import DATASERVICE_ACCESS_TYPE_RESTRICTED
 from udata.core.dataset.models import Dataset
 from udata.core.followers.api import FollowAPI
@@ -138,6 +139,28 @@ class DataserviceAPI(API):
         return "", 204
 
 
+@ns.route("/<dataservice:dataservice>/featured/", endpoint="dataservice_featured")
+@api.doc(**common_doc)
+class ReuseFeaturedAPI(API):
+    @api.doc("feature_dataservice")
+    @api.secure(admin_permission)
+    @api.marshal_with(Dataservice.__read_fields__)
+    def post(self, dataservice):
+        """Mark a dataservice as featured"""
+        dataservice.featured = True
+        dataservice.save()
+        return dataservice
+
+    @api.doc("unfeature_dataservice")
+    @api.secure(admin_permission)
+    @api.marshal_with(Dataservice.__read_fields__)
+    def delete(self, dataservice):
+        """Unmark a dataservice as featured"""
+        dataservice.featured = False
+        dataservice.save()
+        return dataservice
+
+
 dataservice_add_datasets_fields = api.model(
     "DataserviceDatasetsAdd",
     {

udata/core/dataservices/csv.py

@@ -25,6 +25,7 @@ class DataserviceCsvAdapter(csv.Adapter):
         ("organization_id", "organization.id"),
         ("owner", "owner.slug"),  # in case it's owned by a user
         ("owner_id", "owner.id"),
+        ("featured", lambda d: d.featured or False),
         "created_at",
         "metadata_modified_at",
         ("archived", lambda d: d.archived_at or False),

udata/core/dataservices/models.py

@@ -224,6 +224,13 @@ class Dataservice(Auditable, WithMetrics, Linkable, Owned, db.Document):
         auditable=False,
     )
 
+    featured = field(
+        db.BooleanField(),
+        filterable={},
+        readonly=True,
+        auditable=False,
+    )
+
     contact_points = field(
         db.ListField(
             field(

udata/core/dataservices/rdf.py

@@ -14,6 +14,7 @@ from udata.rdf import (
     TAG_TO_EU_HVD_CATEGORIES,
     contact_points_from_rdf,
     contact_points_to_rdf,
+    default_lang_value,
     namespace_manager,
     rdf_value,
     remote_url_from_rdf,
@@ -38,7 +39,9 @@ def dataservice_from_rdf(
     d = graph.resource(node)
 
     dataservice.title = rdf_value(d, DCT.title)
-    dataservice.description = sanitize_html(d.value(DCT.description) or d.value(DCT.abstract))
+    dataservice.description = sanitize_html(
+        default_lang_value(d, DCT.description) or default_lang_value(d, DCT.abstract)
+    )
 
     dataservice.base_api_url = url_from_rdf(d, DCAT.endpointURL)
 

udata/core/dataservices/search.py

@@ -35,6 +35,7 @@ class DataserviceApiParser(ModelApiParser):
         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")
+        self.parser.add_argument("featured", type=bool, location="args")
 
     @staticmethod
     def parse_filters(dataservices, args):
@@ -57,6 +58,8 @@ class DataserviceApiParser(ModelApiParser):
                 if boolean(args["is_restricted"])
                 else [DATASERVICE_ACCESS_TYPE_OPEN, DATASERVICE_ACCESS_TYPE_OPEN_WITH_ACCOUNT]
             )
+        if args.get("featured"):
+            dataservices = dataservices.filter(featured=args["featured"])
         return dataservices
 
 
@@ -71,6 +74,7 @@ class DataserviceSearch(ModelSearchAdapter):
         "tag": Filter(),
         "organization": ModelTermsFilter(model=Organization),
         "archived": BoolFilter(),
+        "featured": BoolFilter(),
     }
 
     @classmethod
@@ -116,6 +120,7 @@ class DataserviceSearch(ModelSearchAdapter):
             "archived": to_iso_datetime(dataservice.archived_at)
             if dataservice.archived_at
             else None,
+            "featured": 1 if dataservice.featured else 0,
             "organization": organization,
             "owner": str(owner.id) if owner else None,
             "tags": dataservice.tags,

udata/core/dataset/rdf.py

@@ -40,6 +40,7 @@ from udata.rdf import (
     TAG_TO_EU_HVD_CATEGORIES,
     contact_points_from_rdf,
     contact_points_to_rdf,
+    default_lang_value,
     namespace_manager,
     rdf_unique_values,
     rdf_value,
@@ -656,7 +657,7 @@ def resource_from_rdf(graph_or_distrib, dataset=None, is_additionnal=False):
     resource.filetype = "remote"
     resource.title = title_from_rdf(distrib, url)
     resource.url = url
-    resource.description = sanitize_html(distrib.value(DCT.description))
+    resource.description = sanitize_html(default_lang_value(distrib, DCT.description))
     resource.filesize = rdf_value(distrib, DCAT.byteSize)
     resource.mime = mime_from_rdf(distrib)
     resource.format = format_from_rdf(distrib)
@@ -731,7 +732,7 @@ def dataset_from_rdf(graph: Graph, dataset=None, node=None, remote_url_prefix: s
         raise HarvestSkipException("missing title on dataset")
 
     # Support dct:abstract if dct:description is missing (sometimes used instead)
-    description = d.value(DCT.description) or d.value(DCT.abstract)
+    description = default_lang_value(d, DCT.description) or default_lang_value(d, DCT.abstract)
     dataset.description = sanitize_html(description)
     dataset.frequency = frequency_from_rdf(d.value(DCT.accrualPeriodicity)) or dataset.frequency
     roles = [  # Imbricated list of contact points for each role

udata/rdf.py

@@ -239,11 +239,28 @@ def rdf_unique_values(resource, predicate, parse_label=False) -> set[str]:
 
 
 def rdf_value(obj, predicate, default=None, parse_label=False):
-    """Serialize the value for a predicate on a RdfResource"""
-    value = obj.value(predicate)
+    """
+    Serialize the value for a predicate on a RdfResource,
+    expecting one value only or (at most) one per language for Literals.
+    """
+    value = default_lang_value(obj, predicate)
     return serialize_value(value, parse_label=parse_label) if value else default
 
 
+def default_lang_value(obj, predicate):
+    """
+    Return the value with the default language if multiple Literal values exist in different languages.
+    """
+    candidate_values = list(obj.objects(predicate))
+    if not candidate_values:
+        return None
+    for val in candidate_values:
+        if isinstance(val, Literal) and val.language == current_app.config["DEFAULT_LANGUAGE"]:
+            return val
+    # Defaulting to the first value found
+    return candidate_values[0]
+
+
 class HTMLDetector(HTMLParser):
     def __init__(self, *args, **kwargs):
         HTMLParser.__init__(self, *args, **kwargs)