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

geovisio/web/docs.py

@@ -1,5 +1,10 @@
-from geovisio.web import annotations, collections, items, prepare, users, utils, upload_set, reports, excluded_areas, pages
-from geovisio.utils import upload_set as upload_set_utils, reports as reports_utils, excluded_areas as excluded_areas_utils
+from geovisio.web import collections, items, prepare, users, utils, upload_set, reports, excluded_areas, pages
+from geovisio.utils import (
+    upload_set as upload_set_utils,
+    reports as reports_utils,
+    excluded_areas as excluded_areas_utils,
+    annotations as annotations_utils,
+)
 from importlib import metadata
 import re
 
@@ -258,6 +263,9 @@ Note that you may not rely only on these ID that could change through time.
             "GeoVisioUploadSetFiles": upload_set_utils.UploadSetFiles.model_json_schema(
                 ref_template="#/components/schemas/GeoVisioUploadSetFiles/$defs/{model}", mode="serialization"
             ),
+            "UploadSetUpdateParameter": upload_set.UploadSetUpdateParameter.model_json_schema(
+                ref_template="#/components/schemas/UploadSetUpdateParameter/$defs/{model}", mode="serialization"
+            ),
             "GeoVisioCollectionOfCollection": {
                 "allOf": [
                     {"$ref": "#/components/schemas/STACCollection"},
@@ -462,6 +470,11 @@ The CSV headers will be:
                                     "geovisio:producer": {"type": "string"},
                                     "geovisio:image": {"type": "string", "format": "uri"},
                                     "geovisio:thumbnail": {"type": "string", "format": "uri"},
+                                    "geovisio:rank_in_collection": {
+                                        "type": "integer",
+                                        "minimum": 1,
+                                        "title": "Rank of the picture in its collection.",
+                                    },
                                     "original_file:size": {"type": "integer", "minimum": 0, "title": "Size of the original file, in bytes"},
                                     "original_file:name": {"type": "string", "title": "Original file name"},
                                     "panoramax:horizontal_pixel_density": {
@@ -647,20 +660,9 @@ Available properties are:
             "GeoVisioUserConfiguration": users.UserConfiguration.model_json_schema(
                 ref_template="#/components/schemas/GeoVisioUserConfiguration/$defs/{model}", mode="serialization"
             ),
-            "GeoVisioUser": {
-                "type": "object",
-                "properties": {
-                    "id": {"type": "string", "format": "uuid"},
-                    "name": {"type": "string"},
-                    "links": {
-                        "type": "array",
-                        "items": {
-                            "type": "object",
-                            "properties": {"href": {"type": "string"}, "ref": {"type": "string"}, "type": {"type": "string"}},
-                        },
-                    },
-                },
-            },
+            "GeoVisioUser": users.UserInfo.model_json_schema(
+                ref_template="#/components/schemas/GeoVisioUser/$defs/{model}", mode="serialization"
+            ),
             "GeoVisioUserAuth": {
                 "type": "object",
                 "properties": {
@@ -753,6 +755,10 @@ Available properties are:
                         "properties": {
                             "user_profile": {"type": "object", "properties": {"url": {"type": "string"}}},
                             "enabled": {"type": "boolean"},
+                            "registration_is_open": {
+                                "type": "boolean",
+                                "description": "If true, users can create their own account on the instance. Only used for reference in the federation for the moment",
+                            },
                             "enforce_tos_acceptance": {"type": "boolean"},
                         },
                         "required": ["enabled"],
@@ -832,6 +838,12 @@ Available properties are:
                     "payload": {"type": "object", "description": "The error payload"},
                 },
             },
+            "GeoVisioAnnotation": annotations_utils.Annotation.model_json_schema(
+                ref_template="#/components/schemas/GeoVisioAnnotation/$defs/{model}", mode="serialization"
+            ),
+            "GeoVisioPostAnnotation": annotations_utils.AnnotationCreationParameter.model_json_schema(
+                ref_template="#/components/schemas/GeoVisioPostAnnotation/$defs/{model}", mode="serialization"
+            ),
         },
         "parameters": {
             "STAC_bbox": {"$ref": f"https://api.stacspec.org/v{utils.STAC_VERSION}/item-search/openapi.yaml#/components/parameters/bbox"},
@@ -927,6 +939,33 @@ Note that this parameter is not taken in account for 360° pictures, as by defin
                 "required": False,
                 "schema": {"type": "integer", "minimum": 2, "maximum": 180, "default": 30},
             },
+            "searchCQL2_filter": {
+                "name": "filter",
+                "in": "query",
+                "description": """
+A CQL2 filter expression for filtering search results.
+
+Only works for semantic search for the moment.
+
+The attributes must start with "semantics." and formated like "semantics.some_key"='some_value'.
+
+Note: it's important for the attribute to be quoted (`"`) and the value to around simple quotes (`'`) to avoid issues with CQL2 parsing.
+
+For the moment only equality (`=`) and list (`IN`) filters are supported. We do not support searching for multiple different tags at once with an `AND` operator (for example, `"semantics.traffic_sign"='yes' AND "semantics.colour"='red'` __will not work__). We suggest to filter data on your side, after retrieving by the main attribute depending on your interest.
+
+To search for any values of a semantic tag, use `semantics.some_key IS NOT NULL` (case matter here).
+
+Examples:
+
+* "semantics.osm|traffic_sign"='yes'
+* "semantics.osm|traffic_sign" IS NOT NULL'
+* "semantics.osm|amenity" IN ('bench', 'whatever') OR "semantics.osm|traffic_sign"='yes'
+""",
+                "required": False,
+                "schema": {
+                    "type": "string",
+                },
+            },
             "GeoVisioReports_filter": {
                 "name": "filter",
                 "in": "query",

geovisio/web/items.py

@@ -6,13 +6,16 @@ from typing import Dict, List, Optional, Any
 from urllib.parse import unquote
 from psycopg.types.json import Jsonb
 from pydantic import BaseModel, ConfigDict, ValidationError, field_validator, model_validator
+from shapely import intersects
 from werkzeug.datastructures import MultiDict
 from uuid import UUID
 from geovisio import errors, utils
 from geovisio.utils import auth, db
+from geovisio.utils.cql2 import parse_search_filter
 from geovisio.utils.params import validation_error
 from geovisio.utils.pictures import cleanupExif
-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 (
     as_latitude,
     as_longitude,
@@ -138,6 +141,7 @@ def dbPictureToStacItem(seqId, dbPic):
                     "pers:roll": dbPic["metadata"].get("roll"),
                     "geovisio:status": dbPic.get("status"),
                     "geovisio:producer": dbPic["account_name"],
+                    "geovisio:rank_in_collection": dbPic["rank"],
                     "original_file:size": dbPic["metadata"].get("originalFileSize"),
                     "original_file:name": dbPic["metadata"].get("originalFileName"),
                     "panoramax:horizontal_pixel_density": dbPic.get("h_pixel_density"),
@@ -145,7 +149,8 @@ def dbPictureToStacItem(seqId, dbPic):
                     "geovisio:thumbnail": _getThumbJpgPictureURL(dbPic["id"], dbPic.get("status")),
                     "exif": removeNoneInDict(cleanupExif(dbPic["exif"])),
                     "quality:horizontal_accuracy": float("{:.1f}".format(dbPic["gps_accuracy_m"])) if dbPic.get("gps_accuracy_m") else None,
-                    "semantics": dbPic["semantics"] if "semantics" in dbPic else None,
+                    "semantics": [s for s in dbPic.get("semantics") or [] if s],
+                    "annotations": [a for a in dbPic.get("annotations") or [] if a],
                 }
             ),
             "links": cleanNoneInList(
@@ -437,19 +442,12 @@ def getCollectionItems(collectionId):
                     CASE WHEN LAG(p.status) OVER othpics = 'ready' THEN ST_AsGeoJSON(LAG(p.geom) OVER othpics)::json END AS prevpicgeojson,
                     CASE WHEN LEAD(p.status) OVER othpics = 'ready' THEN LEAD(p.id) OVER othpics END AS nextpic,
                     CASE WHEN LEAD(p.status) OVER othpics = 'ready' THEN ST_AsGeoJSON(LEAD(p.geom) OVER othpics)::json END AS nextpicgeojson,
-                    t.semantics
+                    get_picture_semantics(p.id) as semantics,
+                    get_picture_annotations(p.id) as annotations
                 FROM sequences_pictures sp
                 JOIN pictures p ON sp.pic_id = p.id
                 JOIN accounts a ON a.id = p.account_id
                 JOIN sequences s ON s.id = sp.seq_id
-                LEFT JOIN (
-                    SELECT picture_id, json_agg(json_strip_nulls(json_build_object(
-                        'key', key,
-                        'value', value
-                    ))) AS semantics
-                    FROM pictures_semantics
-                    GROUP BY picture_id
-                ) t ON t.picture_id = p.id
                 WHERE
                     {filter}
                 WINDOW othpics AS (PARTITION BY sp.seq_id ORDER BY sp.rank)
@@ -460,15 +458,14 @@ def getCollectionItems(collectionId):
 
             records = cursor.execute(query, params)
 
-            bounds: Optional[Bounds] = None
             items = []
+            first_rank, last_rank = None, None
             for dbPic in records:
-                if not bounds:
-                    bounds = Bounds(min=dbPic["rank"], max=dbPic["rank"])
-                else:
-                    bounds.update(dbPic["rank"])
-
+                if first_rank is None:
+                    first_rank = dbPic["rank"]
+                last_rank = dbPic["rank"]
                 items.append(dbPictureToStacItem(collectionId, dbPic))
+            bounds = Bounds(first=first_rank, last=last_rank) if records else None
 
             links = [
                 get_root_link(),
@@ -491,8 +488,8 @@ def getCollectionItems(collectionId):
             ]
 
             if paginated and items and bounds:
-                if bounds.min:
-                    has_item_before = bounds.min > seqMeta["min_rank"]
+                if bounds.first:
+                    has_item_before = bounds.first > seqMeta["min_rank"]
                     if has_item_before:
                         links.append(
                             {
@@ -504,7 +501,7 @@ def getCollectionItems(collectionId):
                         # Previous page link
                         #   - If limit is set, rank is current - limit -1
                         #   - If no limit is set, rank is 0 (none)
-                        prevRank = bounds.min - limit - 1 if limit is not None else 0
+                        prevRank = bounds.first - limit - 1 if limit is not None else 0
                         if prevRank < 1:
                             prevRank = None
                         links.append(
@@ -521,7 +518,7 @@ def getCollectionItems(collectionId):
                             }
                         )
 
-                has_item_after = bounds.max < seqMeta["max_rank"]
+                has_item_after = bounds.last < seqMeta["max_rank"]
                 if has_item_after:
                     links.append(
                         {
@@ -532,7 +529,7 @@ def getCollectionItems(collectionId):
                                 _external=True,
                                 collectionId=collectionId,
                                 limit=limit,
-                                startAfterRank=bounds.max,
+                                startAfterRank=bounds.last,
                             ),
                         }
                     )
@@ -543,10 +540,10 @@ def getCollectionItems(collectionId):
 
                     lastPageRank = startAfterRank
                     if limit is not None:
-                        if seqMeta["max_rank"] > bounds.max:
+                        if seqMeta["max_rank"] > bounds.last:
                             lastPageRank = seqMeta["max_rank"] - limit
-                            if lastPageRank < bounds.max:
-                                lastPageRank = bounds.max
+                            if lastPageRank < bounds.last:
+                                lastPageRank = bounds.last
 
                     links.append(
                         {
@@ -608,19 +605,13 @@ def _getPictureItemById(collectionId, itemId):
                     p.account_id AS account_id,
                     spl.prevpic, spl.prevpicgeojson, spl.nextpic, spl.nextpicgeojson, p.exif,
                     relp.related_pics, p.gps_accuracy_m, p.h_pixel_density,
-                    t.semantics
+                   
+                    get_picture_semantics(p.id) as semantics,
+                    get_picture_annotations(p.id) as annotations
                 FROM pictures p
                 JOIN sequences_pictures sp ON sp.pic_id = p.id
                 JOIN accounts ON p.account_id = accounts.id
                 JOIN sequences s ON sp.seq_id = s.id
-                LEFT JOIN (
-                    SELECT picture_id, json_agg(json_strip_nulls(json_build_object(
-                        'key', key,
-                        'value', value
-                    ))) AS semantics
-                    FROM pictures_semantics
-                    GROUP BY picture_id
-                ) t ON t.picture_id = p.id
                 LEFT JOIN (
                     SELECT
                         p.id,
@@ -735,6 +726,18 @@ def getCollectionItem(collectionId, itemId):
     return stacItem, picStatusToHttpCode[stacItem["properties"]["geovisio:status"]], {"Content-Type": "application/geo+json"}
 
 
+class SearchParams(BaseModel):
+    bbox: Optional[str] = None
+    limit: int = 10
+    datetime: Optional[str] = None
+    place_position: Optional[str] = None
+    place_distance: Optional[str] = None
+    place_fov_tolerance: Optional[int] = None
+    intersects: Optional[str] = None
+    ids: Optional[str] = None
+    collections: Optional[str] = None
+
+
 @bp.route("/search", methods=["GET", "POST"])
 def searchItems():
     """Search through all available items
@@ -755,6 +758,7 @@ def searchItems():
             - $ref: '#/components/parameters/GeoVisio_place_position'
             - $ref: '#/components/parameters/GeoVisio_place_distance'
             - $ref: '#/components/parameters/GeoVisio_place_fov_tolerance'
+            - $ref: '#/components/parameters/searchCQL2_filter'
     post:
         requestBody:
             required: true
@@ -788,14 +792,14 @@ def searchItems():
         args = request.args
 
     # Limit
-    if args.get("limit") is not None:
-        limit = args.get("limit", type=int)
-        if limit is None or limit < 1 or limit > 10000:
-            raise errors.InvalidAPIUsage(_("Parameter limit must be either empty or a number between 1 and 10000"), status_code=400)
-        else:
-            sqlParams["limit"] = limit
-    else:
-        sqlParams["limit"] = 10
+    limit = args.get("limit") or 10
+    try:
+        limit = int(limit)
+        if limit < 1 or limit > 10000:
+            raise ValueError()
+    except ValueError:
+        raise errors.InvalidAPIUsage(_("Parameter limit must be either empty or a number between 1 and 10000"), status_code=400)
+    sqlParams["limit"] = limit
 
     # Bounding box
     bboxarg = parse_bbox(args.getlist("bbox"))
@@ -900,7 +904,7 @@ def searchItems():
             raise errors.InvalidAPIUsage(_("Parameter collections should be a JSON array of strings"), status_code=400)
 
     # To speed up search, if it's a search by id and on only one id, we use the same code as /collections/:cid/items/:id
-    if args.get("ids") is not None and args:
+    if args.get("ids") is not None:
         ids = parse_list(args.get("ids"), paramName="ids")
         if ids and len(ids) == 1:
             picture_id = ids[0]
@@ -917,7 +921,11 @@ def searchItems():
                     200,
                     {"Content-Type": "application/geo+json"},
                 )
-
+    filter_param = args.get("filter")
+    if filter_param is not None:
+        cql_filter = parse_search_filter(filter_param)
+        if cql_filter is not None:
+            sqlWhere.append(cql_filter)
     #
     # Database query
     #
@@ -932,19 +940,12 @@ SELECT * FROM (
         accounts.name AS account_name, 
         p.account_id AS account_id,
         p.exif, p.gps_accuracy_m, p.h_pixel_density,
-        t.semantics
+        get_picture_semantics(p.id) as semantics,
+        get_picture_annotations(p.id) as annotations
     FROM pictures p
     LEFT JOIN sequences_pictures sp ON p.id = sp.pic_id
     LEFT JOIN sequences s ON s.id = sp.seq_id
     LEFT JOIN accounts ON p.account_id = accounts.id
-    LEFT JOIN (
-        SELECT picture_id, json_agg(json_strip_nulls(json_build_object(
-            'key', key,
-            'value', value
-        ))) AS semantics
-        FROM pictures_semantics
-        GROUP BY picture_id
-    ) t ON t.picture_id = p.id
     WHERE {sqlWhere}
     {orderBy}
     LIMIT %(limit)s
@@ -1247,7 +1248,7 @@ def patchCollectionItem(collectionId, itemId, account):
     ---
     tags:
         - Editing
-        - Tags
+        - Semantics
     parameters:
         - name: collectionId
           in: path

geovisio/web/map.py

@@ -352,23 +352,35 @@ def _get_query(z: int, x: int, y: int, onlyForUser: Optional[UUID], additional_f
         sql.SQL("nb_360_pictures"),
         sql.SQL("nb_pictures - nb_360_pictures AS nb_flat_pictures"),
         sql.SQL(
-            """((CASE WHEN nb_pictures = 0 THEN 0 WHEN nb_pictures <= (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_pictures) from pictures_grid)
-                THEN nb_pictures::float / (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_pictures) from pictures_grid) * 0.5
-                ELSE 0.5 + nb_pictures::float / (SELECT MAX(nb_pictures) FROM pictures_grid) * 0.5
+            """((CASE WHEN nb_pictures = 0 
+                    THEN 0 
+                WHEN nb_pictures <= (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_pictures) FILTER (WHERE nb_pictures > 0) FROM pictures_grid)
+                THEN 
+                    nb_pictures::float / (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_pictures) FILTER (WHERE nb_pictures > 0) FROM pictures_grid) * 0.5
+                ELSE 
+                    0.5 + nb_pictures::float / (SELECT MAX(nb_pictures) FROM pictures_grid) * 0.5
             END) * 10)::int / 10::float AS coef"""
         ),
         sql.SQL(
-            """((CASE WHEN nb_360_pictures = 0 THEN 0
-                WHEN nb_360_pictures <= (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_360_pictures) from pictures_grid)
-                THEN nb_360_pictures::float / (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_360_pictures) from pictures_grid) * 0.5
-                ELSE 0.5 + nb_360_pictures::float / (SELECT MAX(nb_360_pictures) FROM pictures_grid) * 0.5
+            """((CASE WHEN nb_360_pictures = 0 
+                    THEN 0
+                WHEN (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_360_pictures) FILTER (WHERE nb_360_pictures > 0) FROM pictures_grid) = 0 
+                    THEN 0
+                WHEN nb_360_pictures <= (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_360_pictures) FILTER (WHERE nb_360_pictures > 0) FROM pictures_grid)
+                    THEN nb_360_pictures::float / (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_360_pictures) FILTER (WHERE nb_360_pictures > 0) FROM pictures_grid) * 0.5
+                ELSE 
+                    0.5 + nb_360_pictures::float / (SELECT MAX(nb_360_pictures) FROM pictures_grid) * 0.5
             END) * 10)::int / 10::float AS coef_360_pictures"""
         ),
         sql.SQL(
-            """((CASE WHEN (nb_pictures - nb_360_pictures) = 0 THEN 0 
-                WHEN (nb_pictures - nb_360_pictures) <= (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY (nb_pictures - nb_360_pictures)) from pictures_grid)
-                    THEN (nb_pictures - nb_360_pictures)::float / (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY (nb_pictures - nb_360_pictures)) from pictures_grid) * 0.5
-                ELSE 0.5 + (nb_pictures - nb_360_pictures)::float / (SELECT MAX((nb_pictures - nb_360_pictures)) FROM pictures_grid) * 0.5
+            """((CASE WHEN (nb_pictures - nb_360_pictures) = 0 
+                    THEN 0 
+                WHEN (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY (nb_pictures - nb_360_pictures)) FILTER (WHERE (nb_pictures - nb_360_pictures) > 0) FROM pictures_grid) = 0 
+                    THEN 0
+                WHEN (nb_pictures - nb_360_pictures) <= (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY (nb_pictures - nb_360_pictures)) FILTER (WHERE (nb_pictures - nb_360_pictures) > 0) FROM pictures_grid)
+                    THEN (nb_pictures - nb_360_pictures)::float / (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY (nb_pictures - nb_360_pictures)) FILTER (WHERE (nb_pictures - nb_360_pictures) > 0) FROM pictures_grid) * 0.5
+                ELSE 
+                    0.5 + (nb_pictures - nb_360_pictures)::float / (SELECT MAX((nb_pictures - nb_360_pictures)) FROM pictures_grid) * 0.5
             END) * 10)::int / 10::float AS coef_flat_pictures"""
         ),
     ]
@@ -616,7 +628,7 @@ def getUserTile(userId: UUID, z: int, x: int, y: int, format: str):
                         format: binary
     """
 
-    filter = params.parse_filter(request.args.get("filter"))
+    filter = params.parse_collection_filter(request.args.get("filter"))
     return _getTile(z, x, y, format, onlyForUser=userId, filter=filter)
 
 
@@ -688,5 +700,5 @@ def getMyTile(account: Account, z: int, x: int, y: int, format: str):
                         type: string
                         format: binary
     """
-    filter = params.parse_filter(request.args.get("filter"))
+    filter = params.parse_collection_filter(request.args.get("filter"))
     return _getTile(z, x, y, format, onlyForUser=UUID(account.id), filter=filter)

geovisio/web/params.py

@@ -8,8 +8,6 @@ import datetime
 import re
 from werkzeug.datastructures import MultiDict
 from typing import Optional, Tuple, Any, List
-from pygeofilter.backends.sql import to_sql_where
-from pygeofilter.parsers.ecql import parse as ecql_parser
 from pygeofilter import ast
 from pygeofilter.backends.evaluator import Evaluator, handle
 from psycopg import sql
@@ -17,6 +15,8 @@ from geovisio.utils.sequences import STAC_FIELD_MAPPINGS, STAC_FIELD_TO_SQL_FILT
 from geovisio.utils.fields import SortBy, SQLDirection, SortByField
 from flask_babel import gettext as _
 
+from geovisio.utils.cql2 import parse_cql2_filter
+
 
 RGX_SORTBY = re.compile("[+-]?[A-Za-z_].*(,[+-]?[A-Za-z_].*)*")
 SEQUENCES_DEFAULT_FETCH = 100
@@ -325,37 +325,27 @@ def parse_list(value: Optional[Any], tryFallbacks: bool = True, paramName: Optio
         return None
 
 
-def parse_filter(value: Optional[str]) -> Optional[sql.SQL]:
+def parse_collection_filter(value: Optional[str]) -> Optional[sql.SQL]:
     """Reads STAC filter parameter and sends SQL condition back.
 
-    >>> parse_filter('')
+    >>> parse_collection_filter('')
 
-    >>> parse_filter("updated >= '2023-12-31'")
+    >>> parse_collection_filter("updated >= '2023-12-31'")
     SQL("(s.updated_at >= '2023-12-31')")
-    >>> parse_filter("updated >= '2023-12-31' AND created < '2023-10-31'")
+    >>> parse_collection_filter("updated >= '2023-12-31' AND created < '2023-10-31'")
     SQL("((s.updated_at >= '2023-12-31') AND (s.inserted_at < '2023-10-31'))")
-    >>> parse_filter("status IN ('deleted','ready')") # when we ask for deleted, we should also have hidden collections
+    >>> parse_collection_filter("status IN ('deleted','ready')") # when we ask for deleted, we should also have hidden collections
     SQL("s.status IN ('deleted', 'ready', 'hidden')")
-    >>> parse_filter("status = 'deleted' OR status = 'ready'")
+    >>> parse_collection_filter("status = 'deleted' OR status = 'ready'")
     SQL("(((s.status = 'deleted') OR (s.status = 'hidden')) OR (s.status = 'ready'))")
-    >>> parse_filter('invalid = 10') # doctest: +IGNORE_EXCEPTION_DETAIL
+    >>> parse_collection_filter('invalid = 10') # doctest: +IGNORE_EXCEPTION_DETAIL
     Traceback (most recent call last):
     geovisio.errors.InvalidAPIUsage: Unsupported filter parameter
-    >>> parse_filter('updated == 10') # doctest: +IGNORE_EXCEPTION_DETAIL
+    >>> parse_collection_filter('updated == 10') # doctest: +IGNORE_EXCEPTION_DETAIL
     Traceback (most recent call last):
     geovisio.errors.InvalidAPIUsage: Unsupported filter parameter
     """
-    if value is not None and len(value) > 0:
-        try:
-            filterAst = ecql_parser(value)
-            altered_ast = _alterFilterAst(filterAst)  # type: ignore
-
-            f = to_sql_where(altered_ast, STAC_FIELD_TO_SQL_FILTER).replace('"', "")
-            return sql.SQL(f)  # type: ignore
-        except:
-            raise errors.InvalidAPIUsage(_("Unsupported filter parameter"), status_code=400)
-    else:
-        return None
+    return parse_cql2_filter(value, STAC_FIELD_TO_SQL_FILTER, ast_updater=_alterFilterAst)
 
 
 def parse_picture_heading(heading: Optional[str]) -> Optional[int]:

geovisio/web/stac.py

@@ -20,10 +20,11 @@ from geovisio.utils.sequences import (
     get_collections,
     CollectionsRequest,
     STAC_FIELD_MAPPINGS,
+    get_dataset_bounds,
     get_pagination_links,
 )
 from geovisio.web.params import (
-    parse_filter,
+    parse_collection_filter,
     parse_collections_limit,
 )
 
@@ -334,12 +335,17 @@ def getUserCatalog(userId, userIdMatchesAccount=False):
     """
 
     collection_request = CollectionsRequest(
-        sort_by=SortBy(fields=[SortByField(field=STAC_FIELD_MAPPINGS["created"], direction=SQLDirection.ASC)]),
+        sort_by=SortBy(
+            fields=[
+                SortByField(field=STAC_FIELD_MAPPINGS["created"], direction=SQLDirection.ASC),
+                SortByField(field=STAC_FIELD_MAPPINGS["id"], direction=SQLDirection.ASC),
+            ]
+        ),
         user_id=userId,
         userOwnsAllCollections=userIdMatchesAccount,
     )
     collection_request.limit = parse_collections_limit(request.args.get("limit"))
-    collection_request.pagination_filter = parse_filter(request.args.get("page"))
+    collection_request.pagination_filter = parse_collection_filter(request.args.get("page"))
 
     userName = None
     meta_collection = None
@@ -350,12 +356,14 @@ def getUserCatalog(userId, userIdMatchesAccount=False):
             raise errors.InvalidAPIUsage(_("Impossible to find user %(u)s", u=userId))
         userName = userName["name"]
 
-        meta_collection = cursor.execute(
-            SQL("SELECT MIN(inserted_at) AS min_order, MAX(inserted_at) AS max_order FROM sequences s WHERE account_id = %(account)s"),
-            params={"account": userId},
-        ).fetchone()
+        datasetBounds = get_dataset_bounds(
+            cursor.connection,
+            collection_request.sort_by,
+            additional_filters=SQL("s.account_id = %(account)s"),
+            additional_filters_params={"account": userId},
+        )
 
-        if not meta_collection or meta_collection["min_order"] is None:
+        if datasetBounds is None:
             # No data found, trying to give the most meaningfull error message
             raise errors.InvalidAPIUsage(_("No data loaded for user %(u)s", u=userId), 404)
 
@@ -388,10 +396,9 @@ def getUserCatalog(userId, userIdMatchesAccount=False):
     pagination_links = get_pagination_links(
         route="stac.getUserCatalog",
         routeArgs={"userId": str(userId), "limit": collection_request.limit},
-        field=collection_request.sort_by.fields[0].field.stac,
-        direction=collection_request.sort_by.fields[0].direction,
-        datasetBounds=Bounds(min=meta_collection["min_order"], max=meta_collection["max_order"]),
-        dataBounds=db_collections.query_first_order_bounds,
+        sortBy=collection_request.sort_by,
+        datasetBounds=datasetBounds,
+        dataBounds=db_collections.query_bounds,
         additional_filters=None,
     )