udata 8.0.1.dev28859__py2.py3-none-any.whl → 8.0.1.dev28928__py2.py3-none-any.whl

udata/api/__init__.py

@@ -22,7 +22,7 @@ from udata.auth import (
 from udata.utils import safe_unicode
 from udata.mongo.errors import FieldValidationError
 
-from . import fields, oauth2
+from . import fields
 from .signals import on_api_call
 
 
@@ -129,6 +129,7 @@ class UDataApi(Api):
         @wraps(func)
         def wrapper(*args, **kwargs):
             from udata.core.user.models import User
+            from udata.api.oauth2 import check_credentials
 
             if current_user.is_authenticated:
                 return func(*args, **kwargs)
@@ -143,7 +144,7 @@ class UDataApi(Api):
                 if not login_user(user, False):
                     self.abort(401, 'Inactive user')
             else:
-                oauth2.check_credentials()
+                check_credentials()
             return func(*args, **kwargs)
         return wrapper
 
@@ -321,10 +322,10 @@ def init_app(app):
     # Load all core APIs
     import udata.core.activity.api  # noqa
     import udata.core.spatial.api  # noqa
-    import udata.core.metrics.api  # noqa
     import udata.core.user.api  # noqa
     import udata.core.dataset.api  # noqa
     import udata.core.dataset.apiv2  # noqa
+    import udata.core.dataservices.api  # noqa
     import udata.core.discussions.api  # noqa
     import udata.core.reuse.api  # noqa
     import udata.core.reuse.apiv2  # noqa
@@ -351,5 +352,6 @@ def init_app(app):
     app.register_blueprint(apiv1_blueprint)
     app.register_blueprint(apiv2_blueprint)
 
-    oauth2.init_app(app)
+    from udata.api.oauth2 import init_app as oauth2_init_app
+    oauth2_init_app(app)
     cors.init_app(app)

udata/api/oauth2.py

@@ -34,6 +34,7 @@ from werkzeug.security import gen_salt
 
 from udata.app import csrf
 from udata.auth import current_user, login_required, login_user
+from udata.core.organization.models import Organization
 from udata.i18n import I18nBlueprint, lazy_gettext as _
 from udata.mongo import db
 from udata.core.storages import images, default_image_basename
@@ -66,7 +67,7 @@ class OAuth2Client(ClientMixin, db.Datetimed, db.Document):
     description = db.StringField()
 
     owner = db.ReferenceField('User')
-    organization = db.ReferenceField('Organization', reverse_delete_rule=db.NULLIFY)
+    organization = db.ReferenceField(Organization, reverse_delete_rule=db.NULLIFY)
     image = db.ImageField(fs=images, basename=default_image_basename,
                           thumbnails=[150, 25])
 

udata/api_fields.py

@@ -0,0 +1,254 @@
+from udata.api import api
+import flask_restx.fields as restx_fields
+import udata.api.fields as custom_restx_fields
+from bson import ObjectId
+import mongoengine
+import mongoengine.fields as mongo_fields
+
+from udata.mongo.errors import FieldValidationError
+
+def convert_db_to_field(key, field, info = {}):
+    '''
+    This function maps a Mongo field to a Flask RestX field.
+    Most of the types are a simple 1-to-1 mapping except lists and references that requires
+    more work.
+    We currently only map the params that we use from Mongo to RestX (for example min_length / max_length…).
+
+    In the first part of the function we save the RestX constructor as a lambda because we need to call it with the
+    params. Since merging the params involve a litte bit of work (merging default params with read/write params and then with
+    user-supplied overrides, setting the readonly flag…), it's easier to have do this one time at the end of the function.
+    '''
+    info = { **getattr(field, '__additional_field_info__', {}), **info }
+
+    params = {}
+    params['required'] = field.required
+
+    read_params = {}
+    write_params = {}
+
+    constructor = None
+    constructor_read = None
+    constructor_write = None
+
+    if info.get('convert_to'):
+        # TODO: this is currently never used. We may remove it if the auto-conversion
+        # is always good enough.
+        return info.get('convert_to'), info.get('convert_to')
+    elif isinstance(field, mongo_fields.StringField):
+        constructor = restx_fields.String
+        params['min_length'] = field.min_length
+        params['max_length'] = field.max_length
+    elif isinstance(field, mongo_fields.FloatField):
+        constructor = restx_fields.Float
+        params['min'] = field.min # TODO min_value?
+        params['max'] = field.max
+    elif isinstance(field, mongo_fields.BooleanField):
+        constructor = restx_fields.Boolean
+    elif isinstance(field, mongo_fields.DateTimeField):
+        constructor = custom_restx_fields.ISODateTime
+    elif isinstance(field, mongo_fields.DictField):
+        constructor = restx_fields.Raw
+    elif isinstance(field, mongo_fields.ListField):
+        # For lists, we convert the inner value from Mongo to RestX then we create
+        # the `List` RestX type with this converted inner value.
+        field_read, field_write = convert_db_to_field(f"{key}.inner", field.field, info.get('inner_field_info', {}))
+        constructor_read = lambda **kwargs: restx_fields.List(field_read, **kwargs)
+        constructor_write = lambda **kwargs: restx_fields.List(field_write, **kwargs)
+    elif isinstance(field, mongo_fields.ReferenceField):
+        # For reference we accept while writing a String representing the ID of the referenced model.
+        # For reading, if the user supplied a `nested_fields` (RestX model), we use it to convert
+        # the referenced model, if not we return a String (and RestX will call the `str()` of the model
+        # when returning from an endpoint)
+        nested_fields = info.get('nested_fields')
+        if nested_fields is None:
+            # If there is no `nested_fields` convert the object to the string representation.
+            constructor_read = restx_fields.String
+        else:
+            constructor_read = lambda **kwargs: restx_fields.Nested(nested_fields, **kwargs)
+
+        write_params['description'] = "ID of the reference"
+        constructor_write = restx_fields.String
+    elif isinstance(field, mongo_fields.EmbeddedDocumentField):
+        nested_fields = info.get('nested_fields')
+        if nested_fields is None:
+            raise ValueError(f"EmbeddedDocumentField `{key}` requires a `nested_fields` param to serialize/deserialize.")
+
+        constructor = lambda **kwargs: restx_fields.Nested(nested_fields, **kwargs)
+    else:
+        raise ValueError(f"Unsupported MongoEngine field type {field.__class__.__name__}")
+    
+    read_params = {**params, **read_params, **info}
+    write_params = {**params, **write_params, **info}
+
+    read = constructor_read(**read_params) if constructor_read else constructor(**read_params)
+    if write_params.get('readonly', False):
+        write = None
+    else:
+        write = constructor_write(**write_params) if constructor_write else constructor(**write_params)
+    return read, write
+
+def generate_fields(**kwargs):
+    '''
+    This decorator will create two auto-generated attributes on the class `__read_fields__` and `__write_fields__`
+    that can be used in API endpoint inside `expect()` and `marshall_with()`.
+    '''
+    def wrapper(cls):
+        read_fields = {}
+        write_fields = {}
+        sortables = []
+
+        read_fields['id'] = restx_fields.String(required=True)
+
+        for key, field in cls._fields.items():
+            info = getattr(field, '__additional_field_info__', None)
+            if info is None: continue 
+
+            if info.get('sortable', False):
+                sortables.append(key)
+
+            read, write = convert_db_to_field(key, field)
+
+            if read:
+                read_fields[key] = read
+            if write:
+                write_fields[key] = write
+
+        # The goal of this loop is to fetch all functions (getters) of the class
+        # If a function has an `__additional_field_info__` attribute it means 
+        # it has been decorated with `@function_field()` and should be included
+        # in the API response.
+        for method_name in dir(cls):
+            if method_name == 'objects': continue
+            if method_name.startswith('_'): continue
+            if method_name in read_fields: continue # Do not override if the attribute is also callable like for Extras
+
+            method = getattr(cls, method_name)
+            if not callable(method): continue
+
+            info = getattr(method, '__additional_field_info__', None)
+            if info is None: continue
+
+            def make_lambda(method):
+                '''
+                Factory function to create a lambda with the correct scope.
+                If we don't have this factory function, the `method` will be the 
+                last method assigned in this loop?
+                '''
+                return lambda o: method(o)
+
+            read_fields[method_name] = restx_fields.String(attribute=make_lambda(method), **{ 'readonly':True, **info })
+
+
+        cls.__read_fields__ = api.model(f"{cls.__name__} (read)", read_fields, **kwargs)
+        cls.__write_fields__ = api.model(f"{cls.__name__} (write)", write_fields, **kwargs)
+
+        mask = kwargs.pop('mask', None)
+        if mask is not None:
+            mask = 'data{{{0}}},*'.format(mask)
+        cls.__page_fields__ = api.model(f"{cls.__name__}Page", custom_restx_fields.pager(cls.__read_fields__), mask=mask, **kwargs)
+
+        # Parser for index sort/filters
+        paginable = kwargs.get('paginable', True)
+        parser = api.parser()
+
+        if paginable:
+            parser.add_argument('page', type=int, location='args', default=1, help='The page to display')
+            parser.add_argument('page_size', type=int, location='args', default=20, help='The page size')
+        
+        if sortables:
+            choices = sortables + ['-' + k for k in sortables]
+            parser.add_argument('sort', type=str, location='args', choices=choices, help='The field (and direction) on which sorting apply')
+
+        cls.__index_parser__ = parser
+        def apply_sort_filters_and_pagination(base_query):
+            args = cls.__index_parser__.parse_args()
+
+            if sortables and args['sort']:
+                base_query = base_query.order_by(args['sort'])
+
+            if paginable:
+                base_query = base_query.paginate(args['page'], args['page_size'])
+
+            return base_query
+
+        cls.apply_sort_filters_and_pagination = apply_sort_filters_and_pagination
+        return cls
+    return wrapper
+
+
+def function_field(**info):
+    def inner(func):
+        func.__additional_field_info__ = info
+        return func
+
+    return inner
+
+def field(inner, **kwargs):
+    '''
+    Simple decorator to mark a field as visible for the API fields.
+    We can pass additional arguments that will be forward to the RestX field constructor.
+    '''
+    inner.__additional_field_info__ = kwargs
+    return inner
+
+
+def patch(obj, request): 
+    '''
+    Patch the object with the data from the request.
+    Only fields decorated with the `field()` decorator will be read (and not readonly).
+    '''
+    for key, value in request.json.items():
+        field = obj.__write_fields__.get(key)
+        if field is not None and not field.readonly:
+            model_attribute = getattr(obj.__class__, key)
+            if isinstance(model_attribute, mongoengine.fields.ListField) and isinstance(model_attribute.field, mongoengine.fields.ReferenceField):
+                # TODO `wrap_primary_key` do Mongo request, do a first pass to fetch all documents before calling it (to avoid multiple queries).
+                value = [wrap_primary_key(key, model_attribute.field, id) for id in value]
+            if isinstance(model_attribute, mongoengine.fields.ReferenceField):
+                value = wrap_primary_key(key, model_attribute, value)
+
+
+            info = getattr(model_attribute, '__additional_field_info__', {})
+
+            # `check` field attribute allows to do validation from the request before setting
+            # the attribute
+            check = info.get('check', None)
+            if check is not None:
+                check(**{key: value}) # TODO add other model attributes in function parameters
+
+            setattr(obj, key, value)
+
+    return obj
+
+def wrap_primary_key(field_name: str, foreign_field: mongoengine.fields.ReferenceField, value: str):
+    '''
+    We need to wrap the `String` inside an `ObjectId` most of the time. If the foreign ID is a `String` we need to get 
+    a `DBRef` from the database.
+
+    TODO: we only check the document reference if the ID is a `String` field (not in the case of a classic `ObjectId`).
+    '''
+    document_type = foreign_field.document_type()
+    id_field_name = document_type.__class__._meta["id_field"]
+
+    id_field = getattr(document_type.__class__, id_field_name)
+
+    # Get the foreign document from MongoDB because the othewise it fails during read
+    # Also useful to get a DBRef for non ObjectId references (see below)
+    foreign_document = document_type.__class__.objects(**{id_field_name: value}).first()
+    if foreign_document is None:
+        raise FieldValidationError(field=field_name, message=f"Unknown reference '{value}'")
+    
+    if isinstance(id_field, mongoengine.fields.ObjectIdField):
+        return ObjectId(value)
+    elif isinstance(id_field, mongoengine.fields.StringField):
+        # Right now I didn't find a simpler way to make mongoengine happy.
+        # For references, it expects `ObjectId`, `DBRef`, `LazyReference` or `document` but since
+        # the primary key a StringField (not an `ObjectId`) we cannot create an `ObjectId`, I didn't find
+        # a way to create a `DBRef` nor a `LazyReference` so I create a simple document with only the ID field.
+        # We could use a simple dict as follow instead:
+        # { 'id': value }
+        # … but it may be important to check before-hand that the reference point to a correct document.
+        return foreign_document.to_dbref()
+    else:
+        raise ValueError(f"Unknown ID field type {id_field.__class__} for {document_type.__class__} (ID field name is {id_field_name}, value was {value})")
+

udata/core/badges/models.py

@@ -1,14 +1,15 @@
 import logging
-import weakref
 
 from datetime import datetime
 
 from mongoengine.signals import post_save
 
+from udata.api_fields import field
 from udata.auth import current_user
 from udata.mongo import db
 
 from .signals import on_badge_added, on_badge_removed
+from .fields import badge_fields
 
 log = logging.getLogger(__name__)
 

udata/core/dataservices/api.py

@@ -0,0 +1,84 @@
+from datetime import datetime
+from flask import request
+from flask_login import current_user
+import mongoengine
+
+from udata.api import api, API
+from udata.api_fields import patch
+from udata.core.dataset.permissions import OwnablePermission
+from .models import Dataservice
+from udata.models import db
+
+ns = api.namespace('dataservices', 'Dataservices related operations (beta)')
+
+@ns.route('/', endpoint='dataservices')
+class DataservicesAPI(API):
+    '''Dataservices collection endpoint'''
+    @api.doc('list_dataservices')
+    @api.expect(Dataservice.__index_parser__)
+    @api.marshal_with(Dataservice.__page_fields__)
+    def get(self):
+        '''List or search all dataservices'''
+        query = Dataservice.objects.visible()
+
+        return Dataservice.apply_sort_filters_and_pagination(query)
+
+    @api.secure
+    @api.doc('create_dataservice', responses={400: 'Validation error'})
+    @api.expect(Dataservice.__write_fields__)
+    @api.marshal_with(Dataservice.__read_fields__, code=201)
+    def post(self):
+        dataservice = patch(Dataservice(), request)
+        if not dataservice.owner and not dataservice.organization:
+            dataservice.owner = current_user._get_current_object()
+
+        try:
+            dataservice.save()
+        except mongoengine.errors.ValidationError as e:
+            api.abort(400, e.message)
+
+        return dataservice, 201
+
+@ns.route('/<dataservice:dataservice>/', endpoint='dataservice')
+class DataserviceAPI(API):
+    @api.doc('get_dataservice')
+    @api.marshal_with(Dataservice.__read_fields__)
+    def get(self, dataservice):
+        if dataservice.deleted_at and not OwnablePermission(dataservice).can():
+            api.abort(410, 'Dataservice has been deleted')
+        return dataservice
+    
+    @api.secure
+    @api.doc('update_dataservice', responses={400: 'Validation error'})
+    @api.expect(Dataservice.__write_fields__)
+    @api.marshal_with(Dataservice.__read_fields__)
+    def patch(self, dataservice):
+        if dataservice.deleted_at:
+            api.abort(410, 'dataservice has been deleted')
+
+        OwnablePermission(dataservice).test()
+
+        patch(dataservice, request)
+        dataservice.modified_at = datetime.utcnow()
+
+        try:
+            dataservice.save()
+            return dataservice
+        except mongoengine.errors.ValidationError as e:
+            api.abort(400, e.message)
+
+    @api.secure
+    @api.doc('delete_dataservice')
+    @api.response(204, 'dataservice deleted')
+    def delete(self, dataservice):
+        if dataservice.deleted_at:
+            api.abort(410, 'dataservice has been deleted')
+
+        OwnablePermission(dataservice).test()
+
+        dataservice.deleted_at = datetime.utcnow()
+        dataservice.modified_at = datetime.utcnow()
+        dataservice.save()
+
+        return '', 204
+

udata/core/dataservices/models.py

@@ -0,0 +1,130 @@
+from datetime import datetime
+from udata.api_fields import field, function_field, generate_fields
+from udata.core.dataset.models import Dataset
+from udata.core.metrics.models import WithMetrics
+from udata.core.owned import Owned, OwnedQuerySet
+from udata.i18n import lazy_gettext as _
+import udata.core.contact_point.api_fields as contact_api_fields
+import udata.core.dataset.api_fields as datasets_api_fields
+
+from udata.models import db
+from udata.uris import endpoint_for
+
+# "frequency"
+# "harvest"
+# "internal"
+# "page"
+# "quality" # Peut-être pas dans une v1 car la qualité sera probablement calculé différemment
+# "datasets" # objet : liste de datasets liés à une API
+# "spatial"
+# "temporal_coverage"
+
+DATASERVICE_FORMATS = ['REST', 'WMS', 'WSL']
+
+
+class DataserviceQuerySet(OwnedQuerySet):
+    def visible(self):
+        return self(archived_at=None, deleted_at=None, private=False)
+
+    def hidden(self):
+        return self(db.Q(private=True) |
+                    db.Q(deleted_at__ne=None) |
+                    db.Q(archived_at__ne=None))
+
+@generate_fields()
+class Dataservice(WithMetrics, Owned, db.Document):
+    meta = {
+        'indexes': [
+            '$title',
+        ] + Owned.meta['indexes'],
+        'queryset_class': DataserviceQuerySet,
+        'auto_create_index_on_save': True
+    }
+
+    title = field(
+        db.StringField(required=True),
+        example="My awesome API",
+        sortable=True,
+    )
+    acronym = field(
+        db.StringField(max_length=128),
+    )
+    # /!\ do not set directly the slug when creating or updating a dataset
+    # this will break the search indexation
+    slug = field(
+        db.SlugField(max_length=255, required=True, populate_from='title', update=True, follow=True),
+        readonly=True,
+    )
+    description = field(
+        db.StringField(default=''),
+        description="In markdown"
+    )
+    base_api_url = field(
+        db.URLField(required=True),
+        sortable=True,
+    )
+    endpoint_description_url = field(db.URLField())
+    authorization_request_url = field(db.URLField())
+    availability= field(
+        db.FloatField(min=0, max=100),
+        example='99.99'
+    )
+    rate_limiting = field(db.StringField())
+    is_restricted = field(db.BooleanField())
+    has_token = field(db.BooleanField())
+    format = field(db.StringField(choices=DATASERVICE_FORMATS))
+
+    license = field(
+        db.ReferenceField('License'),
+        allow_null=True,
+    )
+
+    tags = field(
+        db.TagListField(),
+    )
+
+    private = field(
+        db.BooleanField(default=False),
+        description='Is the dataservice private to the owner or the organization'
+    )
+    
+    extras = field(db.ExtrasField())
+
+    contact_point = field(
+        db.ReferenceField('ContactPoint', reverse_delete_rule=db.NULLIFY),
+        nested_fields=contact_api_fields.contact_point_fields,
+        allow_null=True,
+    )
+
+    created_at = field(
+        db.DateTimeField(verbose_name=_('Creation date'), default=datetime.utcnow, required=True),
+        readonly=True,
+    )
+    metadata_modified_at = field(
+        db.DateTimeField(verbose_name=_('Last modification date'), default=datetime.utcnow, required=True),
+        readonly=True,
+    )
+    deleted_at = field(db.DateTimeField(), readonly=True)
+    archived_at = field(db.DateTimeField(), readonly=True)
+
+    datasets = field(
+        db.ListField(
+            field(
+                db.ReferenceField(Dataset),
+                nested_fields=datasets_api_fields.dataset_fields,
+            )
+        )
+    )
+
+    @function_field(description="Link to the API endpoint for this dataservice")
+    def self_api_url(self):
+        return endpoint_for('api.dataservice', dataservice=self, _external=True)
+
+    def self_web_url():
+        pass
+
+    # TODO
+    # frequency = db.StringField(choices=list(UPDATE_FREQUENCIES.keys()))
+    # temporal_coverage = db.EmbeddedDocumentField(db.DateRange)
+    # spatial = db.EmbeddedDocumentField(SpatialCoverage)
+    # harvest = db.EmbeddedDocumentField(HarvestDatasetMetadata)

udata/core/metrics/commands.py

@@ -5,7 +5,7 @@ import click
 from flask import current_app
 
 from udata.commands import cli, success
-from udata.models import User, Dataset, Reuse, Organization, Site
+from udata.models import User, Dataset, Reuse, Organization, Site, GeoZone
 
 log = logging.getLogger(__name__)
 
@@ -24,11 +24,12 @@ def grp():
               help='Compute datasets metrics')
 @click.option('-r', '--reuses', is_flag=True, help='Compute reuses metrics')
 @click.option('-u', '--users', is_flag=True, help='Compute users metrics')
+@click.option('-g', '--geozones', is_flag=True, help='Compute geo levels metrics')
 @click.option('--drop', is_flag=True, help='Clear old metrics before computing new ones')
 def update(site=False, organizations=False, users=False, datasets=False,
-           reuses=False, drop=False):
+           reuses=False, geozones = False, drop=False):
     '''Update all metrics for the current date'''
-    do_all = not any((site, organizations, users, datasets, reuses))
+    do_all = not any((site, organizations, users, datasets, reuses, geozones))
 
     if do_all or site:
         log.info('Update site metrics')
@@ -114,4 +115,18 @@ def update(site=False, organizations=False, users=False, datasets=False,
                 except Exception as e:
                     log.info(f'Error during update: {e}')
                     continue
+
+    if do_all or geozones:
+        log.info('Update GeoZone metrics')
+        all_geozones = GeoZone.objects.timeout(False)
+        with click.progressbar(all_geozones, length=GeoZone.objects.count()) as geozones_bar:
+            for geozone in geozones_bar:
+                try:
+                    if drop:
+                        geozone.metrics.clear()
+                    geozone.count_datasets()
+                except Exception as e:
+                    log.info(f'Error during update: {e}')
+                    continue
+
     success('All metrics have been updated')

udata/core/metrics/models.py

@@ -1,5 +1,4 @@
-from datetime import date, timedelta
-
+from udata.api_fields import field
 from udata.mongo import db
 
 
@@ -7,7 +6,7 @@ __all__ = ('WithMetrics',)
 
 
 class WithMetrics(object):
-    metrics = db.DictField()
+    metrics = field(db.DictField())
 
     __metrics_keys__ = []
 

udata/core/organization/models.py

@@ -5,9 +5,11 @@ from blinker import Signal
 from mongoengine.signals import pre_save, post_save
 from werkzeug.utils import cached_property
 
+from udata.core.badges.models import BadgeMixin
+from udata.core.metrics.models import WithMetrics
 from udata.core.storages import avatars, default_image_basename
 from udata.frontend.markdown import mdstrip
-from udata.models import db, BadgeMixin, WithMetrics
+from udata.mongo import db
 from udata.i18n import lazy_gettext as _
 from udata.uris import endpoint_for
 from .constants import ASSOCIATION, CERTIFIED, COMPANY, LOCAL_AUTHORITY, LOGO_SIZES, ORG_BID_SIZE_LIMIT, ORG_ROLES, DEFAULT_ROLE, MEMBERSHIP_STATUS, LOGO_MAX_SIZE, PUBLIC_SERVICE

udata/core/owned.py

@@ -4,7 +4,15 @@ from blinker import signal
 from mongoengine import NULLIFY, Q, post_save
 from mongoengine.fields import ReferenceField
 
+from udata.api_fields import field
+from udata.core.organization.models import Organization
+from udata.core.user.models import User
 from udata.mongo.queryset import UDataQuerySet
+from udata.core.user.api_fields import user_ref_fields
+from udata.core.organization.api_fields import org_ref_fields
+from udata.core.organization.permissions import OrganizationPrivatePermission
+from udata.mongo.errors import FieldValidationError
+from udata.i18n import lazy_gettext as _
 
 log = logging.getLogger(__name__)
 
@@ -15,14 +23,42 @@ class OwnedQuerySet(UDataQuerySet):
         for owner in owners:
             qs |= Q(owner=owner) | Q(organization=owner)
         return self(qs)
+    
+def check_owner_is_current_user(owner):
+    from udata.auth import current_user, admin_permission
+    if current_user.is_authenticated and owner and not admin_permission and current_user.id != owner:
+        raise FieldValidationError(_('You can only set yourself as owner'), field="owner")
+
+def check_organization_is_valid_for_current_user(organization):
+    from udata.auth import current_user
+    from udata.models import Organization
+
+    org = Organization.objects(id=organization).first()
+    if org is None:
+        raise FieldValidationError(_("Unknown organization"), field="organization")
+
+    if current_user.is_authenticated and org and not OrganizationPrivatePermission(org).can():
+        raise FieldValidationError(_("Permission denied for this organization"), field="organization")
 
 
 class Owned(object):
     '''
     A mixin to factorize owning behvaior between users and organizations.
     '''
-    owner = ReferenceField('User', reverse_delete_rule=NULLIFY)
-    organization = ReferenceField('Organization', reverse_delete_rule=NULLIFY)
+    owner = field(
+        ReferenceField(User, reverse_delete_rule=NULLIFY),
+        nested_fields=user_ref_fields,
+        description="Only present if organization is not set. Can only be set to the current authenticated user.",
+        check=check_owner_is_current_user,
+        allow_null=True,
+    )
+    organization = field(
+        ReferenceField(Organization, reverse_delete_rule=NULLIFY),
+        nested_fields=org_ref_fields,
+        description="Only present if owner is not set. Can only be set to an organization of the current authenticated user.",
+        check=check_organization_is_valid_for_current_user,
+        allow_null=True,
+    )
 
     on_owner_change = signal('Owned.on_owner_change')
 
@@ -38,6 +74,7 @@ class Owned(object):
         '''
         Verify owner consistency and fetch original owner before the new one erase it.
         '''
+
         changed_fields = self._get_changed_fields()
         if 'organization' in changed_fields and 'owner' in changed_fields:
             # Ownership changes (org to owner or the other way around) have already been made

udata/core/spatial/api.py

@@ -162,11 +162,6 @@ class SpatialCoverageAPI(API):
         features = []
 
         for zone in GeoZone.objects(level=level.id):
-            # fetch nested levels IDs
-            ids = []
-            ids.append(zone.id)
-            # Count datasets in zone
-            nb_datasets = Dataset.objects(spatial__zones__in=ids).count()
             features.append({
                 'id': zone.id,
                 'type': 'Feature',
@@ -174,7 +169,7 @@ class SpatialCoverageAPI(API):
                     'name': _(zone.name),
                     'code': zone.code,
                     'uri': zone.uri,
-                    'datasets': nb_datasets
+                    'datasets': zone.metrics.get('datasets', 0)
                 }
             })
 

udata/core/spatial/models.py

@@ -3,6 +3,7 @@ from werkzeug.local import LocalProxy
 from werkzeug.utils import cached_property
 
 from udata.app import cache
+from udata.core.metrics.models import WithMetrics
 from udata.uris import endpoint_for
 from udata.i18n import _, get_locale, language
 from udata.mongo import db
@@ -21,7 +22,6 @@ class GeoLevel(db.Document):
                               max_value=ADMIN_LEVEL_MAX,
                               default=100)
 
-
 class GeoZoneQuerySet(db.BaseQuerySet):
 
     def resolve(self, geoid, id_only=False):
@@ -40,7 +40,7 @@ class GeoZoneQuerySet(db.BaseQuerySet):
         return result.id if id_only and result else result
 
 
-class GeoZone(db.Document):
+class GeoZone(WithMetrics, db.Document):
     SEPARATOR = ':'
 
     id = db.StringField(primary_key=True)
@@ -101,6 +101,11 @@ class GeoZone(db.Document):
     def external_url(self):
         return endpoint_for('territories.territory', territory=self, _external=True)
 
+    def count_datasets(self):
+        from udata.models import Dataset
+        self.metrics['datasets'] = Dataset.objects(spatial__zones=self.id).visible().count()
+        self.save()
+
     def toGeoJSON(self):
         return {
             'id': self.id,

udata/core/spatial/tasks.py

@@ -0,0 +1,7 @@
+from udata.core.spatial.models import GeoZone
+from udata.tasks import job
+
+@job('compute-geozones-metrics')
+def compute_geozones_metrics(self):
+    for geozone in GeoZone.objects.timeout(False):
+        geozone.count_datasets()

udata/core/spatial/tests/test_api.py

@@ -10,6 +10,7 @@ from udata.core.dataset.factories import DatasetFactory
 from udata.core.spatial.factories import (
     SpatialCoverageFactory, GeoZoneFactory, GeoLevelFactory
 )
+from udata.core.spatial.tasks import compute_geozones_metrics
 
 
 class SpatialApiTest(APITestCase):
@@ -229,6 +230,31 @@ class SpatialApiTest(APITestCase):
             'features': [],
         })
 
+    def test_coverage_datasets_count(self):
+        GeoLevelFactory(id='fr:commune')
+        paris = GeoZoneFactory(
+            id='fr:commune:75056', level='fr:commune',
+            name='Paris', code='75056')
+        arles = GeoZoneFactory(
+            id='fr:commune:13004', level='fr:commune',
+            name='Arles', code='13004')
+
+        for _ in range(3):
+            DatasetFactory(
+                spatial=SpatialCoverageFactory(zones=[paris.id]))
+        for _ in range(2):
+            DatasetFactory(
+                spatial=SpatialCoverageFactory(zones=[arles.id]))
+                    
+        compute_geozones_metrics()
+
+        response = self.get(url_for('api.spatial_coverage', level='fr:commune'))
+        self.assert200(response)
+        self.assertEqual(response.json['features'][0]['id'], 'fr:commune:13004')
+        self.assertEqual(response.json['features'][0]['properties']['datasets'], 2)
+        self.assertEqual(response.json['features'][1]['id'], 'fr:commune:75056')
+        self.assertEqual(response.json['features'][1]['properties']['datasets'], 3)
+
 
 class SpatialTerritoriesApiTest(APITestCase):
     modules = []

udata/routing.py

@@ -10,6 +10,7 @@ from werkzeug.urls import url_quote
 from udata import models
 from udata.mongo import db
 from udata.core.spatial.models import GeoZone
+from udata.core.dataservices.models import Dataservice
 from udata.i18n import ISO_639_1_CODES
 
 
@@ -121,6 +122,10 @@ class DatasetConverter(ModelConverter):
     model = models.Dataset
 
 
+class DataserviceConverter(ModelConverter):
+    model = Dataservice
+
+
 class CommunityResourceConverter(ModelConverter):
     model = models.CommunityResource
 
@@ -222,6 +227,7 @@ def init_app(app):
     app.url_map.converters['pathlist'] = PathListConverter
     app.url_map.converters['uuid'] = UUIDConverter
     app.url_map.converters['dataset'] = DatasetConverter
+    app.url_map.converters['dataservice'] = DataserviceConverter
     app.url_map.converters['crid'] = CommunityResourceConverter
     app.url_map.converters['org'] = OrganizationConverter
     app.url_map.converters['reuse'] = ReuseConverter

udata/tasks.py

@@ -162,6 +162,7 @@ def init_app(app):
     import udata.core.tags.tasks  # noqa
     import udata.core.activity.tasks  # noqa
     import udata.core.dataset.tasks  # noqa
+    import udata.core.spatial.tasks  # noqa
     import udata.core.reuse.tasks  # noqa
     import udata.core.user.tasks  # noqa
     import udata.core.organization.tasks  # noqa

udata/tests/api/__init__.py

@@ -29,5 +29,8 @@ class APITestCase(FrontTestCase):
     def put(self, url, data=None, json=True, *args, **kwargs):
         return self.api.put(url, data=data, json=json, *args, **kwargs)
 
+    def patch(self, url, data=None, json=True, *args, **kwargs):
+        return self.api.patch(url, data=data, json=json, *args, **kwargs)
+
     def delete(self, url, data=None, *args, **kwargs):
         return self.api.delete(url, data=data, *args, **kwargs)

udata/tests/api/test_dataservices_api.py

@@ -0,0 +1,236 @@
+from pprint import pprint
+from flask import url_for
+
+from udata.core.dataservices.models import Dataservice
+from udata.core.dataset.factories import (DatasetFactory, LicenseFactory)
+from udata.i18n import gettext as _
+from udata.core.user.factories import UserFactory
+from udata.core.organization.factories import OrganizationFactory
+from udata.core.organization.models import Member
+
+from . import APITestCase
+
+class DataserviceAPITest(APITestCase):
+    modules = []
+
+    def test_dataservice_api_create(self):
+        user = self.login()
+        datasets = DatasetFactory.create_batch(3)
+        license = LicenseFactory.create()
+
+        response = self.post(url_for('api.dataservices'), {
+            'title': 'My API',
+            'base_api_url': 'https://example.org',
+        })
+        self.assert201(response)
+        self.assertEqual(Dataservice.objects.count(), 1)
+
+        dataservice = Dataservice.objects.first()
+
+        response = self.get(url_for('api.dataservice', dataservice=dataservice))
+        self.assert200(response)
+
+        self.assertEqual(response.json['title'], 'My API')
+        self.assertEqual(response.json['base_api_url'], 'https://example.org')
+        self.assertEqual(response.json['owner']['id'], str(user.id))
+
+        response = self.patch(url_for('api.dataservice', dataservice=dataservice), {
+            'title': 'Updated title',
+            'tags': ['hello', 'world'],
+            'private': True,
+            'datasets': [datasets[0].id, datasets[2].id],
+            'license': license.id,
+            'extras': {
+                'foo': 'bar',
+            },
+        })
+        self.assert200(response)
+
+        self.assertEqual(response.json['title'], 'Updated title')
+        self.assertEqual(response.json['base_api_url'], 'https://example.org')
+        self.assertEqual(response.json['tags'], ['hello', 'world'])
+        self.assertEqual(response.json['private'], True)
+        self.assertEqual(response.json['datasets'][0]['title'], datasets[0].title)
+        self.assertEqual(response.json['datasets'][1]['title'], datasets[2].title)
+        self.assertEqual(response.json['extras'], {
+            'foo': 'bar',
+        })
+        self.assertEqual(response.json['license'], license.title)
+        self.assertEqual(response.json['self_api_url'], 'http://local.test/api/1/dataservices/updated-title/')
+        dataservice.reload()
+        self.assertEqual(dataservice.title, 'Updated title')
+        self.assertEqual(dataservice.base_api_url, 'https://example.org')
+        self.assertEqual(dataservice.tags, ['hello', 'world'])
+        self.assertEqual(dataservice.private, True)
+        self.assertEqual(dataservice.datasets[0].title, datasets[0].title)
+        self.assertEqual(dataservice.datasets[1].title, datasets[2].title)
+        self.assertEqual(dataservice.extras, {
+            'foo': 'bar',
+        })
+        self.assertEqual(dataservice.license.title, license.title)
+        self.assertEqual(dataservice.self_api_url(), 'http://local.test/api/1/dataservices/updated-title/')
+
+        response = self.delete(url_for('api.dataservice', dataservice=dataservice))
+        self.assert204(response)
+
+        self.assertEqual(Dataservice.objects.count(), 1)
+
+        dataservice.reload()
+        self.assertEqual(dataservice.title, 'Updated title')
+        self.assertEqual(dataservice.base_api_url, 'https://example.org')
+        self.assertIsNotNone(dataservice.deleted_at)
+
+        # response = self.get(url_for('api.dataservice', dataservice=dataservice))
+        # self.assert410(response)
+
+
+    def test_dataservice_api_index(self):
+        self.login()
+        self.post(url_for('api.dataservices'), {
+            'title': 'B',
+            'base_api_url': 'https://example.org/B',
+        })
+        self.post(url_for('api.dataservices'), {
+            'title': 'C',
+            'base_api_url': 'https://example.org/C',
+        })
+        self.post(url_for('api.dataservices'), {
+            'title': 'A',
+            'base_api_url': 'https://example.org/A',
+        })
+        response = self.post(url_for('api.dataservices'), {
+            'title': 'X',
+            'base_api_url': 'https://example.org/X',
+            'private': True,
+        })
+
+        self.assertEqual(Dataservice.objects.count(), 4)
+
+        response = self.get(url_for('api.dataservices'))
+        self.assert200(response)
+
+        self.assertEqual(response.json['previous_page'], None)
+        self.assertEqual(response.json['next_page'], None)
+        self.assertEqual(response.json['page'], 1)
+        self.assertEqual(response.json['total'], 3)
+        self.assertEqual(len(response.json['data']), 3)
+        self.assertEqual(response.json['data'][0]['title'], 'B')
+        self.assertEqual(response.json['data'][1]['title'], 'C')
+        self.assertEqual(response.json['data'][2]['title'], 'A')
+
+        response = self.get(url_for('api.dataservices', sort='title'))
+        self.assert200(response)
+
+        self.assertEqual(response.json['previous_page'], None)
+        self.assertEqual(response.json['next_page'], None)
+        self.assertEqual(response.json['page'], 1)
+        self.assertEqual(response.json['total'], 3)
+        self.assertEqual(len(response.json['data']), 3)
+        self.assertEqual(response.json['data'][0]['title'], 'A')
+        self.assertEqual(response.json['data'][1]['title'], 'B')
+        self.assertEqual(response.json['data'][2]['title'], 'C')
+
+        response = self.get(url_for('api.dataservices', sort='-title'))
+        self.assert200(response)
+
+        self.assertEqual(response.json['previous_page'], None)
+        self.assertEqual(response.json['next_page'], None)
+        self.assertEqual(response.json['page'], 1)
+        self.assertEqual(response.json['total'], 3)
+        self.assertEqual(len(response.json['data']), 3)
+        self.assertEqual(response.json['data'][0]['title'], 'C')
+        self.assertEqual(response.json['data'][1]['title'], 'B')
+        self.assertEqual(response.json['data'][2]['title'], 'A')
+
+
+        response = self.get(url_for('api.dataservices', page_size=1))
+        self.assert200(response)
+
+        self.assertEqual(response.json['previous_page'], None)
+        assert response.json['next_page'].endswith(url_for('api.dataservices', page_size=1, page=2))
+        self.assertEqual(response.json['page'], 1)
+        self.assertEqual(response.json['total'], 3)
+        self.assertEqual(len(response.json['data']), 1)
+        self.assertEqual(response.json['data'][0]['title'], 'B')
+
+    def test_dataservice_api_create_with_validation_error(self):
+        self.login()
+        response = self.post(url_for('api.dataservices'), {
+            'base_api_url': 'https://example.org',
+        })
+        self.assert400(response)
+        self.assertEqual(Dataservice.objects.count(), 0)
+
+    def test_dataservice_api_create_with_unkwown_license(self):
+        self.login()
+        response = self.post(url_for('api.dataservices'), {
+            'title': 'My title',
+            'base_api_url': 'https://example.org',
+            'license': 'unwkown-license',
+        })
+        self.assert400(response)
+        self.assertEqual(response.json['errors']['license'], ["Unknown reference 'unwkown-license'"])
+        self.assertEqual(Dataservice.objects.count(), 0)
+
+
+    def test_dataservice_api_create_with_unkwown_contact_point(self):
+        self.login()
+
+        response = self.post(url_for('api.dataservices'), {
+            'title': 'My title',
+            'base_api_url': 'https://example.org',
+            'contact_point': '66212433e42ab56639ad516e',
+        })
+        self.assert400(response)
+        self.assertEqual(response.json['errors']['contact_point'], ["Unknown reference '66212433e42ab56639ad516e'"])
+        self.assertEqual(Dataservice.objects.count(), 0)
+
+
+    def test_dataservice_api_create_with_custom_user_or_org(self):
+        other = UserFactory()
+        other_member = Member(user=other, role='editor')
+        other_org = OrganizationFactory(members=[other_member])
+
+        me = self.login()
+        me_member = Member(user=me, role='editor')
+        me_org = OrganizationFactory(members=[me_member])
+
+        response = self.post(url_for('api.dataservices'), {
+            'title': 'My title',
+            'base_api_url': 'https://example.org',
+            'owner': other.id,
+        })
+        self.assert400(response)
+        self.assertEqual(response.json['errors']['owner'], [_("You can only set yourself as owner")])
+        self.assertEqual(Dataservice.objects.count(), 0)
+
+        response = self.post(url_for('api.dataservices'), {
+            'title': 'My title',
+            'base_api_url': 'https://example.org',
+            'organization': other_org.id,
+        })
+        self.assert400(response)
+        self.assertEqual(response.json['errors']['organization'], [_("Permission denied for this organization")])
+        self.assertEqual(Dataservice.objects.count(), 0)
+
+
+        response = self.post(url_for('api.dataservices'), {
+            'title': 'My title',
+            'base_api_url': 'https://example.org',
+            'owner': me.id,
+        })
+        self.assert201(response)
+        dataservice = Dataservice.objects(id=response.json['id']).first()
+        self.assertEqual(dataservice.owner.id, me.id)
+        self.assertEqual(dataservice.organization, None)
+
+
+        response = self.post(url_for('api.dataservices'), {
+            'title': 'My title',
+            'base_api_url': 'https://example.org',
+            'organization': me_org.id,
+        })
+        self.assert201(response)
+        dataservice = Dataservice.objects(id=response.json['id']).first()
+        self.assertEqual(dataservice.owner, None)
+        self.assertEqual(dataservice.organization.id, me_org.id)

udata/tests/plugin.py

@@ -192,6 +192,11 @@ class ApiClient(object):
             return self.client.put(url, data or {}, *args, **kwargs)
         return self.perform('put', url, data=data or {}, *args, **kwargs)
 
+    def patch(self, url, data=None, json=True, *args, **kwargs):
+        if not json:
+            return self.client.patch(url, data or {}, *args, **kwargs)
+        return self.perform('patch', url, data=data or {}, *args, **kwargs)
+
     def delete(self, url, data=None, *args, **kwargs):
         return self.perform('delete', url, data=data or {}, *args, **kwargs)
 

{udata-8.0.1.dev28859.dist-info → udata-8.0.1.dev28928.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: udata
-Version: 8.0.1.dev28859
+Version: 8.0.1.dev28928
 Summary: Open data portal
 Home-page: https://github.com/opendatateam/udata
 Author: Opendata Team
@@ -137,7 +137,9 @@ It is collectively taken care of by members of the
 
 ## Current (in progress)
 
-- Nothing yet
+- Add dataservices in beta [#2986](https://github.com/opendatateam/udata/pull/2986)
+- Remove deprecated `metrics_for` route [#3022](https://github.com/opendatateam/udata/pull/3022)
+- Fix spatial coverage fetching perfs. Need to schedule `compute-geozones-metrics` [#3018](https://github.com/opendatateam/udata/pull/3018)
 
 ## 8.0.0 (2024-04-23)
 

{udata-8.0.1.dev28859.dist-info → udata-8.0.1.dev28928.dist-info}/RECORD

@@ -1,6 +1,7 @@
 tasks/__init__.py,sha256=CnVhb_TV-6nMhxVR6itnBmvuU2OSCs02AfNB4irVBTE,8132
 tasks/helpers.py,sha256=k_HiuiEJNgQLvWdeHqczPOAcrYpFjEepBeKo7EQzY8M,994
 udata/__init__.py,sha256=qPn-jr9CTcAEJ6KD95BxAliMbSxwtelLc8fyakV7UO0,101
+udata/api_fields.py,sha256=myHkndhedV3g9cn2FWBu1Hx24Fy-fxaGedEP1ZMOoi0,11506
 udata/app.py,sha256=6upwrImLaWrSYtsXPW1zH84_oRxp3B6XFuocMe2D6NU,7329
 udata/assets.py,sha256=aMa-MnAEXVSTavptSn2V8sUE6jL_N0MrYCQ6_QpsuHs,645
 udata/entrypoints.py,sha256=8bZUvZ8ICO3kZxa8xDUaen6YS_OAGNKHFvaD7d8BOk0,2687
@@ -9,12 +10,12 @@ udata/factories.py,sha256=6en2qdHHoR6rEvNEUeH_0-T-vR7x7GUBGgNEm9vuylE,492
 udata/i18n.py,sha256=E-JoY57Cv4vgPvChkWjpwZAbuYVI8e6BO6raeu_3_Pw,8352
 udata/mail.py,sha256=dAMcbEtk5e54alpQezvF5adDrRPgdaT36QEdHD_5v50,2145
 udata/rdf.py,sha256=QiHcK2iklbtPkl6UFdBxTj0oaiY41en9k-kmbIVJ8Xw,9893
-udata/routing.py,sha256=lU1XNL-YQgx1GN3pjKue1tIjHzjO3QdTiF9aaLNLitg,7044
+udata/routing.py,sha256=Qhpf5p97fs1SoJXtDctc1FPk0MeOKLn_C0Z1dP4ZNJA,7234
 udata/sentry.py,sha256=KiZz0PpmYpZMvykH9UAbHpF4xBY0Q-8DeiEbXEHDUdw,2683
 udata/settings.py,sha256=5cU5_oiPiuS8RS98F9qfCp37qbjjN_g8ipoyZjDQP0M,17298
 udata/sitemap.py,sha256=pjtR2lU3gRHvK8l1Lw8B9wrqMMTYC5adUfFh0pUp_Q4,977
 udata/tags.py,sha256=8MvgyjfUz8O71tCV0V1fQV4_0C2P-SLFrm2IA2QfNDs,595
-udata/tasks.py,sha256=WR07NfqRMpEBNOnsXZ9myvDDSVfx4R5VZCi3CgO53A8,4886
+udata/tasks.py,sha256=Dyjoxp6_IuPZSnKi6KmaFrFvnyCM5EF5g_W-jG0qYIo,4930
 udata/terms.md,sha256=nFx978tUQ3vTEv6POykXaZvcQ5e_gcvmO4ZgcfbSWXo,187
 udata/tracking.py,sha256=iaGqN9NCqcEAayemJe9a-3N8fO--ixBXCUvQ7jRxbhA,359
 udata/uris.py,sha256=_RaQSy6ghs2IHJQkDFaYpM2e--VA3p1D6awm5ybueAQ,3489
@@ -23,11 +24,11 @@ udata/worker.py,sha256=K-Wafye5-uXP4kQlffRKws2J9YbJ6m6n2QjcVsY8Nsg,118
 udata/wsgi.py,sha256=P7AJvZ5JqY4uRSBOzaFiBniChWIU9RVQ-Y0PN4vCCMY,77
 udata/admin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 udata/admin/views.py,sha256=wMlpnC1aINW-6JDk6-kQXhcTYBZH-5wajEuWzVDcIKA,331
-udata/api/__init__.py,sha256=7AZWPTUCt-ib0FlPm-lEInFdHB1cruPjq-n_fLsRWRw,11278
+udata/api/__init__.py,sha256=I40g3PLG4s-zGNQfjB8_KQGzfs3ZyUrZdajd20vQ9ks,11388
 udata/api/commands.py,sha256=oK2p1VdUvULDdYuvYYpYvY_bdkPJy-KfROfoX71oOuA,3277
 udata/api/errors.py,sha256=Sy_f3WVrNTUPZjCOogIVgocDdUjnKz149KDi4mMA_Lg,240
 udata/api/fields.py,sha256=l-Fa27-easR86qgof2bk130jq1N1pNUgGmQzok1UI3Q,3094
-udata/api/oauth2.py,sha256=ERppP1FtigiAJXO01IjhFFzG8ajPVD6gPcKpBrjHFO4,11726
+udata/api/oauth2.py,sha256=LTtkpkNYrPl_7xf-JmP-TLwrk_RHajnHDFKo-3NPEd8,11780
 udata/api/parsers.py,sha256=Fo4krCaFao0D1QNqKpjWiFVvKVLd9b_2mon6RbbOXls,1485
 udata/api/signals.py,sha256=9zcw4NDdpJwhgsS5UyLtnls1w_RfqghYFULza6d4-cw,162
 udata/auth/__init__.py,sha256=ziR6gzkE1V4__3ynjE-_IPWHzmapOsZIrnaDAjDijsM,1958
@@ -52,7 +53,7 @@ udata/commands/worker.py,sha256=zek8YRxCESrZIULhx9D9RQOPFc4WwhYm2sF7-PPbEKY,4028
 udata/commands/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 udata/commands/tests/fixtures.py,sha256=h78grSpZDgOwvmezyD3qBpiSnpxaQ9tDeQOr3sB8EiY,1581
 udata/core/__init__.py,sha256=n7TBP0lkYJl-BLoc67V5fyaawrWmsrWG_mLIF49UFOY,385
-udata/core/owned.py,sha256=sLI4UpVuMukMEkC3K9Iwjl6P6Cz25J48M6VZc_-HZRQ,2718
+udata/core/owned.py,sha256=ZOoRacTWHiCgZDEENu_7vRcoemZrNLmVVI3PVLuLK5E,4453
 udata/core/activity/__init__.py,sha256=4vB92owvzwn2VVxbFWGNcfESb6izDzvbj6lmLH4ssrU,299
 udata/core/activity/api.py,sha256=ohDEbzhbsmJ6YHQh3Aa8wYctaDQGuwKdg0kjh3lC028,3276
 udata/core/activity/models.py,sha256=kzy9kcixX3DUo-2YpVjGXVHR4cOZMl7AsPiDBZ52EDs,2118
@@ -64,7 +65,7 @@ udata/core/badges/commands.py,sha256=NMihQH6ABUlkYpR2lNFW4dkeaWOjpijW7voudww8zW4
 udata/core/badges/factories.py,sha256=rDQC28fKLtYA6l69EqiyOQyN4C2jVj87EdKBEo4sYsw,297
 udata/core/badges/fields.py,sha256=rpeyZcw5-oU8FZXPnzU9-rGrwW5vCyhwgei7aAR-n3I,255
 udata/core/badges/forms.py,sha256=8z28_rln9duvJ7IvKx9IFO9DAMe3cU2bv0FQRdiMFEw,511
-udata/core/badges/models.py,sha256=cQBpLudR-cRxlbN68z_05UbX0BXRu97n1vMMdat4Ry4,3176
+udata/core/badges/models.py,sha256=GtfqdeyPkve4HZa4mOIhVcHIXr5IOFnASEFqazi-oQg,3229
 udata/core/badges/permissions.py,sha256=5jFKFG4OlVp0pL0xSa7AGO0Ttn0QMsy9xEY2jTfKVmE,552
 udata/core/badges/signals.py,sha256=T12kgKO1lmIbdXlKnRmedYRnJzC2PZIMkrtcA1U2mNo,237
 udata/core/badges/tasks.py,sha256=LA1Sd0B0uUa6OANqmx0t-kDNK99uGePwwtilsdj9Evw,431
@@ -77,6 +78,9 @@ udata/core/contact_point/api_fields.py,sha256=KQADF7Drnd1uT9ZWjLRKQPJh6GdGUXJkYf
 udata/core/contact_point/factories.py,sha256=ATuV1seBCGKY3CzvPDG5nxfBBqHu-3YtER0_fiQJx6c,248
 udata/core/contact_point/forms.py,sha256=ggLhSJ1IRn5MclrhydckjAxwr4fFZxgAD4huSSucSsA,598
 udata/core/contact_point/models.py,sha256=NlNKureCpzgTLJuGviZPjNx-ABYRp4j2L-ur9Gmixao,324
+udata/core/dataservices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+udata/core/dataservices/api.py,sha256=j0_fQdq_O3zBqY7PGapmNbeMjb2sS4x8jr3cTM-4i_Q,2803
+udata/core/dataservices/models.py,sha256=G8m-YKHf32DdA-3Q4m-hlQCLZ8ZZUFKaRFD0YZtqvbE,4037
 udata/core/dataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 udata/core/dataset/actions.py,sha256=3pzBg_qOR-w7fwPpTOKUHXWC9lkjALbOn1UQFmmT-s0,1199
 udata/core/dataset/activities.py,sha256=qQnHNL0hOB1IGtQl7JsnVOiUsWT0gm-pts9uDyR3bvU,1536
@@ -122,9 +126,8 @@ udata/core/jobs/commands.py,sha256=kYoSluhbIG7MwnCSyO7ptD1V9LGwNjlabqlXSQ4hZq4,4
 udata/core/jobs/forms.py,sha256=CB_z8JSyvSSJX1XhohsQ1S3kdOhTMgzsFTofso7AD60,1495
 udata/core/jobs/models.py,sha256=3vRfBp8e7KqJgKxTSSeMgfsMu07rAz1o_IfsYBFk9o4,1325
 udata/core/metrics/__init__.py,sha256=Q3nZVl7no0E1ygz7zNJH-KCa-m9FV6wAH2_y6zimcek,397
-udata/core/metrics/api.py,sha256=vHfH-4n2QR-HE6bXMeAlj1Ma3RR6DRPWDj1LAFukDAM,262
-udata/core/metrics/commands.py,sha256=_365QvZ1Kt3qJPGlMg2CkBE4gwe7ZM5ye6_O43FFt28,4493
-udata/core/metrics/models.py,sha256=v0xlLxl2Y9QdILW4DTZ1WzUy2a4XTNepdLNKmb8T8LY,287
+udata/core/metrics/commands.py,sha256=74L6PUJyaTnr4w-_redN9ucY0v-3Vi4QumWHKZ__DYE,5143
+udata/core/metrics/models.py,sha256=k4kgKjAViQ1XO1F6n-iRfF4eT9cHoGqjQP4e8vC2vmk,291
 udata/core/metrics/signals.py,sha256=Xs_k-9lWzsoZU5Joli-41FNgvIVvbAejkjSFB6DHxh0,176
 udata/core/metrics/tasks.py,sha256=Z7La3-zPB5j6qJoPKr_MgjNZhqscZCmNLPa711ZBkdY,797
 udata/core/organization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -138,7 +141,7 @@ udata/core/organization/csv.py,sha256=x0afMfhWYvx_karwuw5jXqBhMbzkrsiEuAq1wTVurZ
 udata/core/organization/factories.py,sha256=5BABVcDhEChRhJsDfCDm8WyJG4l9j3H1_OFZa3VtlVs,646
 udata/core/organization/forms.py,sha256=JXXv4tQGbIbICti7RXLVZdnc6VujATmLhDrHIsFxBME,3550
 udata/core/organization/metrics.py,sha256=45NDcsFV-oJJQUuq6AyIDXjR-RNubwYWF5-Ke8KrPDY,777
-udata/core/organization/models.py,sha256=Y7iFRQY6m87nKZNUMK9qsZJXZ6xzA6t2q_YxAm8K7Dg,8315
+udata/core/organization/models.py,sha256=aLEqb7F1J7I9TKzSrODMB2Ecf7IxMqYmlgrZvLIx1k8,8387
 udata/core/organization/notifications.py,sha256=j-2LIHZ5y5QuVietWAWOrAqf4v1HMCtSDZ0w7V-z_1c,763
 udata/core/organization/permissions.py,sha256=cNIPiPgXVW2hvKqbuKHA_62tX2xaT8jiVJ3BEfnsHn0,1299
 udata/core/organization/rdf.py,sha256=ZSoxyZDj_5g6hv7lbTIy6bIW3xwvQy27rWNgJwtZ6LE,1762
@@ -184,17 +187,18 @@ udata/core/spam/signals.py,sha256=4VVLyC2I39LFAot4P56nHzY0xumjMBDz_N0Ff_kgBd0,15
 udata/core/spam/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 udata/core/spam/tests/test_spam.py,sha256=W1Ck_rsnURhFi0fy5xOO0CPpW9MuUFbr-NmPZdk5R4Q,676
 udata/core/spatial/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-udata/core/spatial/api.py,sha256=tlApg3JpqbO6CwEwp1LzZ1hyPQreVEgF3H5yrcAPE74,5848
+udata/core/spatial/api.py,sha256=8viSuSSfjZY6GrPj5Ax9WJIYr9KD4YBWAqSd3vhQz50,5666
 udata/core/spatial/api_fields.py,sha256=ymGK3FyE2KNlASOU5GiPgZGeBjjOqnOyCOcRCbuw3D8,2629
 udata/core/spatial/commands.py,sha256=qdJ4mUg3NUTrGx6L5MKPh1usvxmeCn8xMCZNGKyjWYE,6914
 udata/core/spatial/constants.py,sha256=u_4OwAAVYqT0VX6nw_Hc4wIRUPcYww19EFJcnWuMZNo,146
 udata/core/spatial/factories.py,sha256=GxUU8nRtSoGPw2m3Q-al0PYps2oSnlqC-bM7Eeu14rk,3288
 udata/core/spatial/forms.py,sha256=tXlYKge5Rc8L8pOjfUo1-9howgVJZDAh7q8xTIlbBww,3218
 udata/core/spatial/geoids.py,sha256=UqCto4dtQYPXOxyG7sx_0npzM6yvId40ngw3eAlmioQ,1159
-udata/core/spatial/models.py,sha256=8yvjj6SjQcBqPVfmBdRzQRHi9RZNTqdENYzkjlAeSN8,5021
+udata/core/spatial/models.py,sha256=xAc44TRnoThYvHvHVHvKZWHHQVfTWbT6HQr_Q79oSnM,5268
+udata/core/spatial/tasks.py,sha256=UPdq3bWR-xW87BWaPVbWVi1IEC3jJyiuFoW2NmvEYQs,228
 udata/core/spatial/translations.py,sha256=7BjZAMPObm1fwM5U_wnrlpcG-1FtMoS6Z5E3h3Y3sog,533
 udata/core/spatial/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-udata/core/spatial/tests/test_api.py,sha256=BySPgLpHvWs3vBIX2_7vJkuqfrFBIsTHtdg6PXOsE_U,10171
+udata/core/spatial/tests/test_api.py,sha256=eU-hwsUFtzguN4JfqA-R_qH_7ZNv5odhvRYPU6nTvvE,11317
 udata/core/spatial/tests/test_fields.py,sha256=23MBhrkGhYkQtWcRbj8TsPsUPT5QWhR-C9sohEKpQrU,9744
 udata/core/spatial/tests/test_geoid.py,sha256=ovVphCxHb5a-iWl7eoLASRAFUY0CGfNEq-MuqHqTPgE,1533
 udata/core/spatial/tests/test_models.py,sha256=SZx3NhngXWgVon5BKtP0pPPEdvxGTvHQlYFE-fewzTU,951
@@ -560,7 +564,7 @@ udata/tests/__init__.py,sha256=BezijRRI6dPPiEWWjLsJFLrhhfsTZgcctcxhVfp4j70,2332
 udata/tests/es-fake-result.json,sha256=z0CX9Gs-NRj49dmtdFvw8ZKsAbMhDt97Na6JX3ucX34,3155
 udata/tests/helpers.py,sha256=aaifyevJ1Z8CZ8htRrl8OCG5hGcaHfj0lL8iMEKds9w,6022
 udata/tests/models.py,sha256=_V0smMb1Z6p3aZv6PorzNN-HiNt_B46Ox1fqXrTJEqk,238
-udata/tests/plugin.py,sha256=puoSIbE5vL6eum0YAeGhE2ARwxWstC6ua-rXJC9Z5fI,11044
+udata/tests/plugin.py,sha256=DXP0H1Sm2fc-okGSKKBOgH8D8x4fl4_1OVhakgQLz4w,11278
 udata/tests/schemas.json,sha256=szM1jDpkogfOG4xWbjIGjLgG8l9-ZyE3JKQtecJyD1E,4990
 udata/tests/test_activity.py,sha256=spWfhueuLze0kD-pAnegiL3_Kv5io155jQuFI4sjN7I,3258
 udata/tests/test_discussions.py,sha256=zPvKOdcTNGXrvHFp9zqjhKE2fqgUkhb_1F98egXYCL0,31036
@@ -579,10 +583,11 @@ udata/tests/test_topics.py,sha256=r7Y0BW0Z5obld9ASs2Ck9AhykgBtmMedZmL2Bfz_rDw,13
 udata/tests/test_transfer.py,sha256=Y0adyR3CswK2Vvao7DgpP_19b8K6XwNO2dvbKlmnlD0,8036
 udata/tests/test_uris.py,sha256=FQJvz7RXkr21tZ7rZp2uwgZUHk88PxhYId-jXSAl9GM,8519
 udata/tests/test_utils.py,sha256=5awzhJlbnLga0mRXNR2mBGW_kGuAIoQLEZEMQRKuaIM,7944
-udata/tests/api/__init__.py,sha256=Tz_WigHLDlnJNKOKzEAnJswkKiLtHlIpCE54-wgocgM,957
+udata/tests/api/__init__.py,sha256=gIIB9OPiSs1A-u1bEIHlOesaCQzJ08SOLPuJd34LesE,1097
 udata/tests/api/test_auth_api.py,sha256=3Zhn2A29poZIcCJ_R9_-LkR3xOFUTw1aTquiZVXQ2F0,20306
 udata/tests/api/test_base_api.py,sha256=DRX5nuFIj51GFmMIAxUzoW1yiq1apNgr1vS4U4agzeg,2319
 udata/tests/api/test_contact_points.py,sha256=MJm8B06iaUqIZCqxll3NViFwUCxwqZZ4u9e9s1h8MgU,1056
+udata/tests/api/test_dataservices_api.py,sha256=eIo0b18BSSRocyf9pTChzDnKotxxLMq8R1tX53JdH_M,9743
 udata/tests/api/test_datasets_api.py,sha256=zqRtC61NvYUNum4kBTjA1W87JAIobA4k564rm-U6c98,81704
 udata/tests/api/test_fields.py,sha256=OW85Z5MES5HeWOpapeem8OvR1cIcrqW-xMWpdZO4LZ8,1033
 udata/tests/api/test_follow_api.py,sha256=0h54P_Dfbo07u6tg0Rbai1WWgWb19ZLN2HGv4oLCWfg,3383
@@ -676,9 +681,9 @@ udata/translations/pt/LC_MESSAGES/udata.mo,sha256=uttB2K8VsqzkEQG-5HfTtFms_3LtV9
 udata/translations/pt/LC_MESSAGES/udata.po,sha256=8Ql1Lp7Z9KLnvp-qRxw-NhFu1p35Xj-q6Jg9JHsYhcw,43733
 udata/translations/sr/LC_MESSAGES/udata.mo,sha256=US8beNIMPxP5h-zD_jfP1TheDDd4DdRVS5UIiY5XVZ8,28553
 udata/translations/sr/LC_MESSAGES/udata.po,sha256=TM0yMDvKRljyOzgZZMlTX6OfpF6OC4Ngf_9Zc8n6ayA,50313
-udata-8.0.1.dev28859.dist-info/LICENSE,sha256=V8j_M8nAz8PvAOZQocyRDX7keai8UJ9skgmnwqETmdY,34520
-udata-8.0.1.dev28859.dist-info/METADATA,sha256=3rqxzk4v1iCCTubvJDJPsW_KbaImLKC-aSY3HhvlV8A,122074
-udata-8.0.1.dev28859.dist-info/WHEEL,sha256=DZajD4pwLWue70CAfc7YaxT1wLUciNBvN_TTcvXpltE,110
-udata-8.0.1.dev28859.dist-info/entry_points.txt,sha256=3SKiqVy4HUqxf6iWspgMqH8d88Htk6KoLbG1BU-UddQ,451
-udata-8.0.1.dev28859.dist-info/top_level.txt,sha256=39OCg-VWFWOq4gCKnjKNu-s3OwFlZIu_dVH8Gl6ndHw,12
-udata-8.0.1.dev28859.dist-info/RECORD,,
+udata-8.0.1.dev28928.dist-info/LICENSE,sha256=V8j_M8nAz8PvAOZQocyRDX7keai8UJ9skgmnwqETmdY,34520
+udata-8.0.1.dev28928.dist-info/METADATA,sha256=tB-T4SHz3x5TYr-Ztafc3klwqZmf9NdtIQD6Ak1GYzY,122381
+udata-8.0.1.dev28928.dist-info/WHEEL,sha256=DZajD4pwLWue70CAfc7YaxT1wLUciNBvN_TTcvXpltE,110
+udata-8.0.1.dev28928.dist-info/entry_points.txt,sha256=3SKiqVy4HUqxf6iWspgMqH8d88Htk6KoLbG1BU-UddQ,451
+udata-8.0.1.dev28928.dist-info/top_level.txt,sha256=39OCg-VWFWOq4gCKnjKNu-s3OwFlZIu_dVH8Gl6ndHw,12
+udata-8.0.1.dev28928.dist-info/RECORD,,

udata/core/metrics/api.py

@@ -1,10 +0,0 @@
-from flask import abort
-
-from udata.api import api, API
-
-
-@api.route('/metrics/<id>', endpoint='metrics')
-class MetricsAPI(API):
-    @api.doc('metrics_for')
-    def get(self, id):
-        abort(501, 'This endpoint was deprecated because of metrics refactoring')