geovisio 2.8.0__py3-none-any.whl → 2.9.0__py3-none-any.whl

geovisio/utils/upload_set.py

@@ -6,7 +6,7 @@ from geovisio.utils.extent import TemporalExtent
 from uuid import UUID
 from typing import Optional, List, Dict, Any
 from datetime import datetime, timedelta
-from geovisio.utils import db, sequences
+from geovisio.utils import cql2, db, sequences
 from geovisio import errors
 from geovisio.utils.link import make_link, Link
 import psycopg
@@ -17,6 +17,8 @@ from flask import current_app
 from flask_babel import gettext as _
 from geopic_tag_reader import sequence as geopic_sequence, reader
 
+from geovisio.utils.loggers import getLoggerWithExtra
+
 
 class AggregatedStatus(BaseModel):
     """Aggregated status"""
@@ -355,16 +357,7 @@ def _parse_filter(filter: Optional[str]) -> SQL:
     """
     if not filter:
         return SQL("TRUE")
-    from pygeofilter.backends.sql import to_sql_where
-    from pygeofilter.parsers.cql2_text import parse as cql_parser
-
-    try:
-        filterAst = cql_parser(filter)
-        f = to_sql_where(filterAst, FIELD_TO_SQL_FILTER).replace('"', "")  # type: ignore
-        return SQL(f)  # type: ignore
-    except Exception:
-        logging.error(f"Unsupported filter parameter: {filter}")
-        raise errors.InvalidAPIUsage(_("Unsupported filter parameter"), status_code=400)
+    return cql2.parse_cql2_filter(filter, FIELD_TO_SQL_FILTER)
 
 
 def list_upload_sets(account_id: UUID, limit: int = 100, filter: Optional[str] = None) -> UploadSets:
@@ -435,6 +428,7 @@ def dispatch(upload_set_id: UUID):
     if not db_upload_set:
         raise Exception(f"Upload set {upload_set_id} not found")
 
+    logger = getLoggerWithExtra("geovisio.upload_set", {"upload_set_id": str(upload_set_id)})
     with db.conn(current_app) as conn:
         with conn.transaction(), conn.cursor(row_factory=dict_row) as cursor:
 
@@ -493,19 +487,19 @@ WHERE p.upload_set_id = %(upload_set_id)s"""
                     maxDistance=db_upload_set.duplicate_distance, maxRotationAngle=db_upload_set.duplicate_rotation
                 ),
                 sortMethod=db_upload_set.sort_method,
-                splitParams=geopic_sequence.SplitParams(maxDistance=db_upload_set.split_distance, maxTime=db_upload_set.split_time.seconds),
+                splitParams=geopic_sequence.SplitParams(
+                    maxDistance=db_upload_set.split_distance, maxTime=db_upload_set.split_time.total_seconds()
+                ),
             )
             reused_sequence = set()
 
             pics_to_delete_duplicates = [pics_by_filename[p.filename]["id"] for p in report.duplicate_pictures or []]
             pics_to_delete = pics_to_delete_duplicates + pics_to_delete_bug
             if pics_to_delete:
-                logging.debug(
-                    f"For uploadset '{upload_set_id}', nb duplicate pictures {len(pics_to_delete_duplicates)} {f' and {len(pics_to_delete_bug)} pictures without files' if pics_to_delete_bug else ''}"
-                )
-                logging.debug(
-                    f"For uploadset '{upload_set_id}', duplicate pictures {[p.filename for p in report.duplicate_pictures or []]}"
+                logger.debug(
+                    f"nb duplicate pictures {len(pics_to_delete_duplicates)} {f' and {len(pics_to_delete_bug)} pictures without files' if pics_to_delete_bug else ''}"
                 )
+                logger.debug(f"duplicate pictures {[p.filename for p in report.duplicate_pictures or []]}")
 
                 cursor.execute(SQL("CREATE TEMPORARY TABLE tmp_duplicates(picture_id UUID) ON COMMIT DROP"))
                 with cursor.copy("COPY tmp_duplicates(picture_id) FROM stdin;") as copy:
@@ -521,6 +515,8 @@ WHERE p.upload_set_id = %(upload_set_id)s"""
                 cursor.execute(SQL("DELETE FROM pictures WHERE id IN (select picture_id FROM tmp_duplicates)"))
 
             number_title = len(report.sequences) > 1
+            existing_sequences = set(p["sequence_id"] for p in db_pics if p["sequence_id"])
+            new_sequence_ids = set()
             for i, s in enumerate(report.sequences, start=1):
                 existing_sequence = next(
                     (seq for p in s.pictures if (seq := pics_by_filename[p.filename]["sequence_id"]) not in reused_sequence),
@@ -528,9 +524,7 @@ WHERE p.upload_set_id = %(upload_set_id)s"""
                 )
                 # if some of the pictures were already in a sequence, we should not create a new one
                 if existing_sequence:
-                    logging.info(
-                        f"For uploadset '{upload_set_id}', sequence {existing_sequence} already contains pictures, we will not create a new one"
-                    )
+                    logger.info(f"sequence {existing_sequence} already contains pictures, we will not create a new one")
                     # we should wipe the sequences_pictures though
                     seq_id = existing_sequence
                     cursor.execute(
@@ -554,6 +548,8 @@ RETURNING id"""
                     ).fetchone()
                     seq_id = seq_id["id"]
 
+                new_sequence_ids.add(seq_id)
+
                 with cursor.copy("COPY sequences_pictures(seq_id, pic_id, rank) FROM stdin;") as copy:
                     for i, p in enumerate(s.pictures, 1):
                         copy.write_row(
@@ -562,8 +558,17 @@ RETURNING id"""
 
                 sequences.add_finalization_job(cursor=cursor, seqId=seq_id)
 
+            # we can delete all the old sequences
+            sequences_to_delete = existing_sequences - new_sequence_ids
+            if sequences_to_delete:
+                logger.debug(f"sequences to delete = {sequences_to_delete} (existing = {existing_sequences}, new = {new_sequence_ids})")
+                conn.execute(SQL("DELETE FROM sequences_pictures WHERE seq_id = ANY(%(seq_ids)s)"), {"seq_ids": list(sequences_to_delete)})
+                conn.execute(
+                    SQL("UPDATE sequences SET status = 'deleted' WHERE id = ANY(%(seq_ids)s)"), {"seq_ids": list(sequences_to_delete)}
+                )
+
             for s in report.sequences_splits or []:
-                logging.debug(f"For uploadset '{upload_set_id}', split = {s.prevPic.filename} -> {s.nextPic.filename} : {s.reason}")
+                logger.debug(f"split = {s.prevPic.filename} -> {s.nextPic.filename} : {s.reason}")
             conn.execute(SQL("UPDATE upload_sets SET dispatched = true WHERE id = %(upload_set_id)s"), {"upload_set_id": db_upload_set.id})
 
 

geovisio/utils/website.py

@@ -37,6 +37,9 @@ class Website:
             )
 
     def _to_url(self, route: str, params: Optional[Dict[str, str]] = None):
+        if not self.url:
+            return None
+
         base_url = self.url if self.url != WEBSITE_UNDER_SAME_HOST else url_for("index", _external=True)
 
         from urllib.parse import urlencode

geovisio/web/annotations.py

@@ -1,17 +1,213 @@
-from geovisio.utils import auth
-from psycopg.rows import dict_row, class_row
-from psycopg.sql import SQL
-from geovisio.utils.semantics import Entity, EntityType, SemanticTagUpdate, update_tags
+from typing import List, Optional
+from geovisio.utils import auth, db
+from geovisio.utils.annotations import AnnotationCreationParameter, creation_annotation, get_annotation, update_annotation
+from geovisio.utils.tags import SemanticTagUpdate
 from geovisio.web.utils import accountIdOrDefault
-from psycopg.types.json import Jsonb
-from geovisio.utils import db
 from geovisio.utils.params import validation_error
 from geovisio import errors
-from pydantic import BaseModel, ConfigDict, ValidationError
+from pydantic import BaseModel, ValidationError
 from uuid import UUID
-from typing import List, Optional
-from flask import Blueprint, request, current_app
+from flask import Blueprint, current_app, request, url_for
 from flask_babel import gettext as _
 
 
 bp = Blueprint("annotations", __name__, url_prefix="/api")
+
+
+@bp.route("/collections/<uuid:collectionId>/items/<uuid:itemId>/annotations", methods=["POST"])
+@auth.login_required()
+def postAnnotation(collectionId, itemId, account):
+    """Create an annotation on a picture.
+
+    The geometry can be provided as a bounding box (a list of 4 integers, minx, miny, maxx, maxy) or as a geojson geometry.
+    All coordinates must be in pixel, starting from the top left of the picture.
+
+    If an annotation already exists on the picture with the same shape, it will be used.
+        ---
+        tags:
+            - Editing
+            - Semantics
+        parameters:
+            - name: collectionId
+              in: path
+              description: ID of collection to retrieve
+              required: true
+              schema:
+                type: string
+            - name: itemId
+              in: path
+              description: ID of item to retrieve
+              required: true
+              schema:
+                type: string
+        requestBody:
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/GeoVisioPostAnnotation'
+        security:
+            - bearerToken: []
+            - cookieAuth: []
+        responses:
+            200:
+                description: the annotation metadata
+                content:
+                    application/json:
+                        schema:
+                            $ref: '#/components/schemas/GeoVisioAnnotation'
+    """
+
+    account_id = UUID(accountIdOrDefault(account))
+
+    pic = db.fetchone(
+        current_app,
+        "SELECT 1 FROM sequences_pictures WHERE seq_id = %(seq)s AND pic_id = %(pic)s",
+        {"seq": collectionId, "pic": itemId},
+    )
+    if not pic:
+        raise errors.InvalidAPIUsage(_("Picture %(p)s wasn't found in database", p=itemId), status_code=404)
+
+    if request.is_json and request.json is not None:
+        try:
+            params = AnnotationCreationParameter(**request.json, account_id=account_id, picture_id=itemId)
+        except ValidationError as ve:
+            raise errors.InvalidAPIUsage(_("Impossible to create an annotation"), payload=validation_error(ve))
+    else:
+        raise errors.InvalidAPIUsage(_("Parameter for creating an annotation should be a valid JSON"), status_code=415)
+
+    annotation = creation_annotation(params)
+
+    return (
+        annotation.model_dump_json(exclude_none=True),
+        200,
+        {
+            "Content-Type": "application/json",
+            "Access-Control-Expose-Headers": "Location",  # Needed for allowing web browsers access Location header
+            "Location": url_for(
+                "annotations.getAnnotation", _external=True, annotationId=annotation.id, collectionId=collectionId, itemId=itemId
+            ),
+        },
+    )
+
+
+@bp.route("/collections/<uuid:collectionId>/items/<uuid:itemId>/annotations/<uuid:annotationId>", methods=["GET"])
+def getAnnotation(collectionId, itemId, annotationId):
+    """Get an annotation
+
+    ---
+    tags:
+        - Semantics
+    parameters:
+        - name: collectionId
+          in: path
+          description: ID of collection
+          required: true
+          schema:
+            type: string
+        - name: itemId
+          in: path
+          description: ID of item
+          required: true
+          schema:
+            type: string
+        - name: annotationId
+          in: path
+          description: ID of annotation
+          required: true
+          schema:
+            type: string
+    security:
+        - bearerToken: []
+        - cookieAuth: []
+    responses:
+        200:
+            description: the annotation metadata
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/GeoVisioAnnotation'
+    """
+    with db.conn(current_app) as conn:
+
+        annotation = get_annotation(conn, annotationId)
+        if not annotation or annotation.picture_id != itemId:
+            raise errors.InvalidAPIUsage(_("Annotation %(p)s not found", p=itemId), status_code=404)
+
+        return annotation.model_dump_json(exclude_none=True), 200, {"Content-Type": "application/json"}
+
+
+class AnnotationPatchParameter(BaseModel):
+    """Parameters used to update an annotation"""
+
+    semantics: Optional[List[SemanticTagUpdate]] = None
+    """Tags to update on the annotation. By default each tag will be added to the annotation's tags, but you can change this behavior by setting the `action` parameter to `delete`.
+
+    If you want to replace a tag, you need to first delete it, then add it again.
+
+    Like:
+[
+    {"key": "some_key", "value": "some_value", "action": "delete"},
+    {"key": "some_key", "value": "some_new_value"}
+]
+    """
+
+
+@bp.route("/collections/<uuid:collectionId>/items/<uuid:itemId>/annotations/<uuid:annotationId>", methods=["PATCH"])
+@auth.login_required()
+def patchAnnotation(collectionId, itemId, annotationId, account):
+    """Patch an annotation
+
+    Note that if the annotation has no associated tags anymore, it will be deleted.
+    ---
+    tags:
+        - Semantics
+    parameters:
+        - name: collectionId
+          in: path
+          description: ID of collection
+          required: true
+          schema:
+            type: string
+        - name: itemId
+          in: path
+          description: ID of item
+          required: true
+          schema:
+            type: string
+        - name: annotationId
+          in: path
+          description: ID of annotation
+          required: true
+          schema:
+            type: string
+    security:
+        - bearerToken: []
+        - cookieAuth: []
+    responses:
+        200:
+            description: the annotation metadata
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/GeoVisioAnnotation'
+        204:
+            description: The annotation was empty, it has been correctly deleted
+    """
+    if request.is_json and request.json is not None:
+        try:
+            params = AnnotationPatchParameter(**request.json)
+        except ValidationError as ve:
+            raise errors.InvalidAPIUsage(_("Impossible to patch annotation, invalid parameters"), payload=validation_error(ve))
+    else:
+        raise errors.InvalidAPIUsage(_("Parameter for updating an annotation should be a valid JSON"), status_code=415)
+
+    with db.conn(current_app) as conn:
+
+        annotation = get_annotation(conn, annotationId)
+        if not annotation or annotation.picture_id != itemId:
+            raise errors.InvalidAPIUsage(_("Annotation %(p)s not found", p=itemId), status_code=404)
+
+        a = update_annotation(annotation, params.semantics, account.id)
+        if a is None:
+            return "", 204
+        return a.model_dump_json(exclude_none=True), 200, {"Content-Type": "application/json"}

geovisio/web/auth.py

@@ -94,8 +94,9 @@ def auth():
         if not tos_accepted and current_app.config["API_ENFORCE_TOS_ACCEPTANCE"]:
             args = {"next_url": next_url} if next_url else None
             next_url = current_app.config["API_WEBSITE_URL"].tos_validation_page(args)
-        else:
-            next_url = next_url or "/"
+
+        if next_url is None:
+            next_url = "/"
 
         response = flask.make_response(redirect(next_url))
 

geovisio/web/collections.py

@@ -1,14 +1,16 @@
+from copy import deepcopy
 from enum import Enum
 from attr import dataclass
 from geovisio import errors, utils, db
 from geovisio.utils import auth, sequences
 from geovisio.utils.params import validation_error
-from geovisio.utils.semantics import SemanticTagUpdate, Entity, EntityType, update_tags
+from geovisio.utils.semantics import Entity, EntityType, update_tags
+from geovisio.utils.tags import SemanticTagUpdate
 from geovisio.web.params import (
     parse_datetime,
     parse_datetime_interval,
     parse_bbox,
-    parse_filter,
+    parse_collection_filter,
     parse_sortby,
     parse_collections_limit,
 )
@@ -16,6 +18,7 @@ from geovisio.utils.sequences import (
     STAC_FIELD_MAPPINGS,
     CollectionsRequest,
     get_collections,
+    get_dataset_bounds,
 )
 from geovisio.utils.fields import SortBy, SortByField, SQLDirection, Bounds, BBox
 from geovisio.web.rss import dbSequencesToGeoRSS
@@ -248,12 +251,18 @@ def getAllCollections():
     if not sortBy:
         direction = SQLDirection.DESC if format == "rss" else SQLDirection.ASC
         sortBy = SortBy(fields=[SortByField(field=STAC_FIELD_MAPPINGS["created"], direction=direction)])
+    # we always add the creation date fields in the sort list (after the selected ones), this will we'll get the `created` bounds of the dataset
+    # we'll also get
+    if not any(s.field == STAC_FIELD_MAPPINGS["created"] for s in sortBy.fields):
+        sortBy.fields.append(SortByField(field=STAC_FIELD_MAPPINGS["created"], direction=SQLDirection.ASC))
+    if not any(s.field == STAC_FIELD_MAPPINGS["id"] for s in sortBy.fields):
+        sortBy.fields.append(SortByField(field=STAC_FIELD_MAPPINGS["id"], direction=SQLDirection.ASC))
 
     collection_request = CollectionsRequest(sort_by=sortBy)
 
     # Filter parameter
-    collection_request.user_filter = parse_filter(request.args.get("filter"))
-    collection_request.pagination_filter = parse_filter(request.args.get("page"))
+    collection_request.user_filter = parse_collection_filter(request.args.get("filter"))
+    collection_request.pagination_filter = parse_collection_filter(request.args.get("page"))
 
     # Limit parameter
     collection_request.limit = parse_collections_limit(request.args.get("limit"))
@@ -298,14 +307,14 @@ def getAllCollections():
         },
     ]
 
-    with db.cursor(current_app, row_factory=dict_row) as cursor:
-        stats = cursor.execute("SELECT min(inserted_at) as min, max(inserted_at) as max FROM sequences").fetchone()
-        if stats is None:
+    with db.conn(current_app) as conn:
+        datasetBounds = get_dataset_bounds(conn, collection_request.sort_by, additional_filters=collection_request.user_filter)
+        if datasetBounds is None:
             return ({"collections": [], "links": links}, 200, {"Content-Type": "application/json"})
-        datasetBounds = Bounds(min=stats["min"], max=stats["max"])
-        if collection_request.created_after and collection_request.created_after > datasetBounds.max:
+        creation_date_index = collection_request.sort_by.get_field_index("created")
+        if collection_request.created_after and collection_request.created_after > datasetBounds.last[creation_date_index]:
             raise errors.InvalidAPIUsage(_("There is no collection created after %(d)s", d=collection_request.created_after))
-        if collection_request.created_before and collection_request.created_before < datasetBounds.min:
+        if collection_request.created_before and collection_request.created_before < datasetBounds.first[creation_date_index]:
             raise errors.InvalidAPIUsage(_("There is no collection created before %(d)s", d=collection_request.created_before))
 
     db_collections = get_collections(collection_request)
@@ -322,10 +331,9 @@ def getAllCollections():
     pagination_links = sequences.get_pagination_links(
         route="stac_collections.getAllCollections",
         routeArgs={"limit": collection_request.limit},
-        field=sortBy.fields[0].field.stac,
-        direction=sortBy.fields[0].direction,
+        sortBy=sortBy,
         datasetBounds=datasetBounds,
-        dataBounds=db_collections.query_first_order_bounds,
+        dataBounds=db_collections.query_bounds,
         additional_filters=additional_filters,
     )
 
@@ -402,7 +410,7 @@ def getCollection(collectionId):
                 SELECT sequence_id, json_agg(json_strip_nulls(json_build_object(
                     'key', key,
                     'value', value
-                ))) AS semantics
+                )) ORDER BY key, value) AS semantics
                 FROM sequences_semantics
                 GROUP BY sequence_id
             ) t ON t.sequence_id = s.id
@@ -607,7 +615,7 @@ If unset, sort order is unchanged."""
             if relHeading < -180 or relHeading > 180:
                 raise ValueError()
             return relHeading
-        except ValueError:
+        except (ValueError, TypeError):
             raise errors.InvalidAPIUsage(
                 _("Relative heading is not valid, should be an integer in degrees from -180 to 180"), status_code=400
             )
@@ -629,7 +637,7 @@ def patchCollection(collectionId, account):
     ---
     tags:
         - Editing
-        - Tags
+        - Semantics
     parameters:
         - name: collectionId
           in: path
@@ -749,13 +757,7 @@ def patchCollection(collectionId, account):
                     sqlUpdates.append(SQL("last_account_to_edit = %(account)s"))
 
                     cursor.execute(
-                        SQL(
-                            """
-                            UPDATE sequences
-                            SET {updates}
-                            WHERE id = %(id)s
-                            """
-                        ).format(updates=SQL(", ").join(sqlUpdates)),
+                        SQL("UPDATE sequences SET {updates} WHERE id = %(id)s").format(updates=SQL(", ").join(sqlUpdates)),
                         sqlParams,
                     )
 
@@ -924,7 +926,12 @@ def send_collections_as_csv(collection_request: CollectionsRequest):
         raise errors.InvalidAPIUsage(_("CSV export does not support pagination"), status_code=400)
     if collection_request.filters():
         raise errors.InvalidAPIUsage(_("CSV export does not support filters"), status_code=400)
-    if collection_request.sort_by != SortBy(fields=[SortByField(field=STAC_FIELD_MAPPINGS["created"], direction=SQLDirection.DESC)]):
+    if collection_request.sort_by != SortBy(
+        fields=[
+            SortByField(field=STAC_FIELD_MAPPINGS["created"], direction=SQLDirection.DESC),
+            SortByField(field=STAC_FIELD_MAPPINGS["id"], direction=SQLDirection.ASC),
+        ]
+    ):
         raise errors.InvalidAPIUsage(_("CSV export does not support sorting by anything but creation date"), status_code=400)
 
     def generate_csv():
@@ -957,7 +964,7 @@ SELECT
     s.computed_gps_accuracy AS computed_gps_accuracy
 FROM sequences s 
 WHERE {filter}
-ORDER BY s.inserted_at DESC
+ORDER BY s.inserted_at DESC, id ASC
 ) TO STDOUT CSV HEADER"""
                 ).format(filter=SQL(" AND ").join(filters)),
                 params,
@@ -966,7 +973,7 @@ ORDER BY s.inserted_at DESC
                 for a in copy:
                     yield bytes(a)
 
-    return stream_with_context(generate_csv()), {"Content-Disposition": "attachment"}
+    return stream_with_context(generate_csv()), {"Content-Type": "text/csv", "Content-Disposition": "attachment"}
 
 
 @bp.route("/users/<uuid:userId>/collection")
@@ -1033,13 +1040,17 @@ def getUserCollection(userId, userIdMatchesAccount=False):
     if not sortBy:
         sortBy = SortBy(fields=[SortByField(field=STAC_FIELD_MAPPINGS["created"], direction=SQLDirection.DESC)])
 
+    if not any(s.field == STAC_FIELD_MAPPINGS["created"] for s in sortBy.fields):
+        sortBy.fields.append(SortByField(field=STAC_FIELD_MAPPINGS["created"], direction=SQLDirection.ASC))
+    if not any(s.field == STAC_FIELD_MAPPINGS["id"] for s in sortBy.fields):
+        sortBy.fields.append(SortByField(field=STAC_FIELD_MAPPINGS["id"], direction=SQLDirection.ASC))
     collection_request = CollectionsRequest(sort_by=sortBy, userOwnsAllCollections=userIdMatchesAccount)
 
     # Filter parameter
-    collection_request.user_filter = parse_filter(request.args.get("filter"))
+    collection_request.user_filter = parse_collection_filter(request.args.get("filter"))
 
     # Filters added by the pagination
-    collection_request.pagination_filter = parse_filter(request.args.get("page"))
+    collection_request.pagination_filter = parse_collection_filter(request.args.get("page"))
 
     # Limit parameter
     # if not specified, the default with CSV it 1000. if there are more, the paginated API should be used
@@ -1095,8 +1106,6 @@ def getUserCollection(userId, userIdMatchesAccount=False):
                 MAX(LEAST(90, ST_YMax(s.bbox))) AS maxy,
                 MIN(s.inserted_at) AS created,
                 MAX(s.updated_at) AS updated,
-                MIN({order_column}) AS min_order,
-                MAX({order_column}) AS max_order,
                 ROUND(SUM(ST_Length(s.geom::geography))) / 1000 AS length_km
             FROM sequences s
             WHERE {filter}
@@ -1115,6 +1124,13 @@ def getUserCollection(userId, userIdMatchesAccount=False):
             else:
                 raise errors.InvalidAPIUsage(_("No matching sequences found"), 404)
 
+        datasetBounds = get_dataset_bounds(
+            cursor.connection,
+            collection_request.sort_by,
+            additional_filters=SQL(" AND ").join(meta_filter),
+            additional_filters_params={"account": userId},
+        )
+
     collections = get_collections(collection_request)
 
     sequences_links = [
@@ -1164,10 +1180,9 @@ def getUserCollection(userId, userIdMatchesAccount=False):
     pagination_links = sequences.get_pagination_links(
         route="stac_collections.getUserCollection",
         routeArgs={"userId": str(userId), "limit": collection_request.limit},
-        field=sortBy.fields[0].field.stac,
-        direction=sortBy.fields[0].direction,
-        datasetBounds=Bounds(min=meta_collection["min_order"], max=meta_collection["max_order"]),
-        dataBounds=collections.query_first_order_bounds,
+        sortBy=sortBy,
+        datasetBounds=datasetBounds,
+        dataBounds=collections.query_bounds,
         additional_filters=additional_filters,
     )
 

geovisio/web/configuration.py

@@ -29,7 +29,7 @@ def configuration():
             "name": _get_translated(apiSum.name, userLang),
             "description": _get_translated(apiSum.description, userLang),
             "geo_coverage": _get_translated(apiSum.geo_coverage, userLang),
-            "logo": apiSum.logo,
+            "logo": str(apiSum.logo),
             "color": str(apiSum.color),
             "email": apiSum.email,
             "auth": _auth_configuration(),
@@ -53,6 +53,7 @@ def _auth_configuration():
         return {
             "enabled": True,
             "user_profile": {"url": auth.oauth_provider.user_profile_page_url()},
+            "registration_is_open": flask.current_app.config["API_REGISTRATION_IS_OPEN"],
             "enforce_tos_acceptance": flask.current_app.config["API_ENFORCE_TOS_ACCEPTANCE"],
         }