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

geovisio/web/collections.py

@@ -1,6 +1,4 @@
-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
@@ -11,8 +9,11 @@ from geovisio.web.params import (
     parse_datetime_interval,
     parse_bbox,
     parse_collection_filter,
-    parse_sortby,
+    parse_collection_sortby,
     parse_collections_limit,
+    parse_boolean,
+    Visibility,
+    check_visibility,
 )
 from geovisio.utils.sequences import (
     STAC_FIELD_MAPPINGS,
@@ -20,16 +21,16 @@ from geovisio.utils.sequences import (
     get_collections,
     get_dataset_bounds,
 )
-from geovisio.utils.fields import SortBy, SortByField, SQLDirection, Bounds, BBox
+from geovisio.utils.fields import SortBy, SortByField, SQLDirection, BBox, parse_relative_heading
 from geovisio.web.rss import dbSequencesToGeoRSS
 from psycopg.rows import dict_row
 from psycopg.sql import SQL
-from pydantic import BaseModel, Field, ValidationError, field_validator
+from pydantic import BaseModel, Field, ValidationError, field_validator, model_validator
 from flask import current_app, request, url_for, Blueprint, stream_with_context
 from flask_babel import gettext as _
 from geovisio.web.utils import (
     STAC_VERSION,
-    accountIdOrDefault,
+    accountOrDefault,
     cleanNoneInDict,
     cleanNoneInList,
     dbTsToStac,
@@ -68,6 +69,18 @@ def userAgentToClient(user_agent: Optional[str] = None) -> UploadClient:
         return UploadClient.other
 
 
+def retrocompatible_sequence_status(dbSeq, explicit=False):
+    """We used to display status='hidden' for hidden sequence, now that the status and the visiblity has been split, we still return a 'hidden' status for retrocompatibility"""
+    db_status = dbSeq.get("status")
+    if db_status not in ("ready", "hidden"):
+        # for all preparing/error/deleted status, we display the real status
+        return db_status
+    # Note: hidden is a deprecated status value, we consider hidden pictures as ready (it's the visibility that matters)
+    # if the sequence is 'ready' we do not display any status (as it is the default state)
+    # Note that some route are explicit about the default value, so we return it
+    return "ready" if explicit else None
+
+
 def dbSequenceToStacCollection(dbSeq, description="A sequence of geolocated pictures"):
     """Transforms a sequence extracted from database into a STAC Collection
 
@@ -83,8 +96,15 @@ def dbSequenceToStacCollection(dbSeq, description="A sequence of geolocated pict
     object
         The equivalent in STAC Collection format
     """
+    if dbSeq.get("is_sequence_visible_by_user") is False or dbSeq.get("status") == "deleted":
+        # if the sequence is not visible for a given user (it might be because it has been deleted or hidden), we only display its id and its status
+        return {"id": dbSeq["id"], "geovisio:status": "deleted"}
     mints, maxts = dbSeq.get("mints"), dbSeq.get("maxts")
     nb_pic = int(dbSeq.get("nbpic")) if "nbpic" in dbSeq else None
+
+    # we do not want to add a `geovisio:status` = 'ready', we only use it for hidden/deleted status
+    exposed_status = retrocompatible_sequence_status(dbSeq)
+
     return removeNoneInDict(
         {
             "type": "Collection",
@@ -97,13 +117,12 @@ def dbSequenceToStacCollection(dbSeq, description="A sequence of geolocated pict
             "title": str(dbSeq["name"]),
             "description": description,
             "keywords": ["pictures", str(dbSeq["name"])],
-            "semantics": dbSeq["semantics"] if "semantics" in dbSeq else None,
+            "semantics": dbSeq.get("semantics", []),
             "license": current_app.config["API_PICTURES_LICENSE_SPDX_ID"],
             "created": dbTsToStac(dbSeq["created"]),
             "updated": dbTsToStac(dbSeq.get("updated")),
-            "geovisio:status": (
-                dbSeq.get("status") if dbSeq.get("status") != "ready" else None
-            ),  # we do not want to add a `geovisio:status` = 'ready', we only use it for hidden/deleted status
+            "geovisio:status": exposed_status,
+            "geovisio:visibility": dbSeq.get("visibility"),
             "geovisio:sorted-by": dbSeq.get("current_sort"),
             "geovisio:upload-software": userAgentToClient(dbSeq.get("user_agent")).value,
             "geovisio:length_km": dbSeq.get("length_km"),
@@ -160,6 +179,16 @@ def dbSequenceToStacCollection(dbSeq, description="A sequence of geolocated pict
                         "href": url_for("stac_collections.getCollection", _external=True, collectionId=dbSeq["id"]),
                     },
                     get_license_link(),
+                    (
+                        {
+                            "rel": "upload_set",
+                            "type": "application/json",
+                            "title": "Link to the upload set",
+                            "href": url_for("upload_set.getUploadSet", _external=True, upload_set_id=dbSeq["upload_set_id"]),
+                        }
+                        if dbSeq.get("upload_set_id")
+                        else None
+                    ),
                 ]
             ),
         }
@@ -200,6 +229,17 @@ def getAllCollections():
             default: json
         - $ref: '#/components/parameters/STAC_bbox'
         - $ref: '#/components/parameters/STAC_collections_filter'
+
+        - name: show_deleted
+          in: query
+          description: >-
+            Show the deleted collections in a separate `deleted_collections` field. Usefull when crawling the catalog to know which collections have been deleted.
+            The deleted collections are returned in the same `collections` list, but the deleted collection will only have their `id` and a `deleted` `geovisio:status`, without additional fields.
+            Note that thus, when using this parameter, the response does no longer follow the STAC format for deleted collections.
+          required: false
+          schema:
+            type: boolean
+            default: false
         - name: datetime
           in: query
           required: false
@@ -235,7 +275,6 @@ def getAllCollections():
                     schema:
                         $ref: '#/components/schemas/GeoVisioCollectionsRSS'
     """
-
     args = request.args
 
     # Expected output format
@@ -247,7 +286,7 @@ def getAllCollections():
         format = "rss"
 
     # Sort-by parameter
-    sortBy = parse_sortby(request.args.get("sortby"))
+    sortBy = parse_collection_sortby(request.args.get("sortby"))
     if not sortBy:
         direction = SQLDirection.DESC if format == "rss" else SQLDirection.ASC
         sortBy = SortBy(fields=[SortByField(field=STAC_FIELD_MAPPINGS["created"], direction=direction)])
@@ -259,11 +298,21 @@ def getAllCollections():
         sortBy.fields.append(SortByField(field=STAC_FIELD_MAPPINGS["id"], direction=SQLDirection.ASC))
 
     collection_request = CollectionsRequest(sort_by=sortBy)
+    collection_request.show_deleted = parse_boolean(request.args.get("show_deleted"))
 
     # Filter parameter
-    collection_request.user_filter = parse_collection_filter(request.args.get("filter"))
+    cql_filter = request.args.get("filter")
+    if cql_filter and "status IN ('deleted','ready') AND" in cql_filter:
+        # Note handle a bit or retrocompatibility: we used to accept a `status` filter for the metacatalog, this we deprecated this in favour of the `show_deleted` parameter
+        collection_request.show_deleted = True
+        cql_filter = cql_filter.replace("status IN ('deleted','ready') AND", "")
+    collection_request.user_filter = parse_collection_filter(cql_filter)
+
     collection_request.pagination_filter = parse_collection_filter(request.args.get("page"))
 
+    if collection_request.show_deleted and format == "rss":
+        raise errors.InvalidAPIUsage(_("RSS format does not support deleted sequences"), status_code=400)
+
     # Limit parameter
     collection_request.limit = parse_collections_limit(request.args.get("limit"))
 
@@ -305,17 +354,34 @@ def getAllCollections():
                 created_after=args.get("created_after"),
             ),
         },
+        {
+            "title": "Queryables",
+            "href": url_for("queryables.collection_queryables", _external=True),
+            "rel": "http://www.opengis.net/def/rel/ogc/1.0/queryables",
+            "type": "application/schema+json",
+        },
     ]
 
     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"})
-        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.first[creation_date_index]:
-            raise errors.InvalidAPIUsage(_("There is no collection created before %(d)s", d=collection_request.created_before))
+        account_to_query = auth.get_current_account()
+        if account_to_query is not None and account_to_query.can_see_all():
+            meta_filter = [SQL("TRUE")]
+        else:
+            meta_filter = [SQL("is_sequence_visible_by_user(s, %(account_to_query)s)")]
+        if collection_request.user_filter is not None:
+            meta_filter.append(collection_request.user_filter)
+        datasetBounds = get_dataset_bounds(
+            conn,
+            collection_request.sort_by,
+            additional_filters=SQL(" AND ").join(meta_filter),
+            account_to_query_id=account_to_query.id if account_to_query is not None else None,
+        )
+        if datasetBounds is not None:
+            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.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)
 
@@ -324,34 +390,32 @@ def getAllCollections():
         return (dbSequencesToGeoRSS(db_collections.collections).rss(), 200, {"Content-Type": "text/xml"})
 
     stac_collections = [dbSequenceToStacCollection(c) for c in db_collections.collections]
-    pagination_links = []
+    if datasetBounds is not None:
+        pagination_links = []
 
-    additional_filters = request.args.get("filter")
-
-    pagination_links = sequences.get_pagination_links(
-        route="stac_collections.getAllCollections",
-        routeArgs={"limit": collection_request.limit},
-        sortBy=sortBy,
-        datasetBounds=datasetBounds,
-        dataBounds=db_collections.query_bounds,
-        additional_filters=additional_filters,
-    )
+        additional_filters = request.args.get("filter")
 
-    # Compute paginated links
-    links.extend(pagination_links)
+        # Compute paginated links
+        pagination_links = sequences.get_pagination_links(
+            route="stac_collections.getAllCollections",
+            routeArgs={"limit": collection_request.limit},
+            sortBy=sortBy,
+            datasetBounds=datasetBounds,
+            dataBounds=db_collections.query_bounds,
+            additional_filters=additional_filters,
+            showDeleted=collection_request.show_deleted,
+        )
+        links.extend(pagination_links)
 
     return (
-        {
-            "collections": stac_collections,
-            "links": links,
-        },
+        removeNoneInDict({"collections": stac_collections, "links": links}),
         200,
         {"Content-Type": "application/json"},
     )
 
 
 @bp.route("/collections/<uuid:collectionId>")
-def getCollection(collectionId):
+def getCollection(collectionId, account=None):
     """Retrieve metadata of a single collection
     ---
     tags:
@@ -372,18 +436,24 @@ def getCollection(collectionId):
                         $ref: '#/components/schemas/GeoVisioCollection'
     """
 
-    account = auth.get_current_account()
+    account = account or auth.get_current_account()
 
     params = {
         "id": collectionId,
         # Only the owner of an account can view sequence not 'ready'
         "account": account.id if account is not None else None,
     }
+    perm_filter = SQL("")
+    if account is not None and account.can_see_all():
+        # admins can see all the collections
+        perm_filter = SQL("TRUE")
+    else:
+        perm_filter = SQL("is_sequence_visible_by_user(s, %(account)s)")
 
     record = db.fetchone(
         current_app,
-        """
-            SELECT
+        SQL(
+            """SELECT
                 s.id,
                 s.metadata->>'title' AS name,
                 ST_XMin(s.bbox) AS minx,
@@ -391,8 +461,10 @@ def getCollection(collectionId):
                 ST_XMax(s.bbox) AS maxx,
                 ST_YMax(s.bbox) AS maxy,
                 s.status AS status,
+                s.visibility,
                 accounts.name AS account_name,
                 s.account_id AS account_id,
+                s.upload_set_id,
                 s.inserted_at AS created,
                 s.updated_at AS updated,
                 s.current_sort AS current_sort,
@@ -404,7 +476,7 @@ def getCollection(collectionId):
                 ROUND(ST_Length(s.geom::geography)) / 1000 as length_km,
                 s.computed_h_pixel_density,
                 s.computed_gps_accuracy,
-                t.semantics
+                COALESCE(seq_sem.semantics, '[]'::json) AS semantics
             FROM sequences s
             LEFT JOIN (
                 SELECT sequence_id, json_agg(json_strip_nulls(json_build_object(
@@ -413,7 +485,7 @@ def getCollection(collectionId):
                 )) ORDER BY key, value) AS semantics
                 FROM sequences_semantics
                 GROUP BY sequence_id
-            ) t ON t.sequence_id = s.id
+            ) seq_sem ON seq_sem.sequence_id = s.id
             JOIN accounts ON s.account_id = accounts.id, (
                 SELECT
                     array_agg(DISTINCT jsonb_build_object(
@@ -426,9 +498,10 @@ def getCollection(collectionId):
                 JOIN sequences_pictures sp ON sp.seq_id = %(id)s AND sp.pic_id = p.id
             ) a
             WHERE s.id = %(id)s
-                AND (s.status != 'hidden' OR s.account_id = %(account)s)
+                AND {perm_filter}
                 AND s.status != 'deleted'
-        """,
+        """
+        ).format(perm_filter=perm_filter),
         params,
         row_factory=dict_row,
     )
@@ -467,12 +540,10 @@ def getCollectionThumbnail(collectionId):
                         type: string
                         format: binary
     """
-    account = auth.get_current_account()
-
     params = {
         "seq": collectionId,
         # Only the owner of an account can view pictures not 'ready'
-        "account": account.id if account is not None else None,
+        "account": auth.get_current_account_id(),
     }
 
     records = db.fetchone(
@@ -485,6 +556,7 @@ def getCollectionThumbnail(collectionId):
             WHERE
                 sp.seq_id = %(seq)s
                 AND (p.status = 'ready' OR p.account_id = %(account)s)
+                AND is_picture_visible_by_user(p, %(account)s)
                 AND is_sequence_visible_by_user(s, %(account)s)
             ORDER BY RANK ASC
             LIMIT 1""",
@@ -502,6 +574,10 @@ def getCollectionThumbnail(collectionId):
 @auth.login_required_by_setting("API_FORCE_AUTH_ON_UPLOAD")
 def postCollection(account=None):
     """Create a new sequence
+
+    Note that this is the legacy API, upload should be done using the [UploadSet](#UploadSet) endpoints if possible.
+
+    Using an upload set makes it possible to handle more use cases like dispatching pictures into several collections, removing capture duplicates, parralele upload, ...
     ---
     tags:
         - Upload
@@ -511,7 +587,7 @@ def postCollection(account=None):
           required: false
           schema:
             type: string
-          description: An explicit User-Agent value is prefered if you create a production-ready tool, formatted like "PanoramaxCLI/1.0"
+          description: An explicit User-Agent value is preferred if you create a production-ready tool, formatted like "PanoramaxCLI/1.0"
     requestBody:
         content:
             application/json:
@@ -546,12 +622,12 @@ def postCollection(account=None):
     metadata = removeNoneInDict(metadata)
 
     # Create sequence folder
-    accountId = accountIdOrDefault(account)
-    seqId = sequences.createSequence(metadata, accountId, request.user_agent.string)
+    account = accountOrDefault(account)
+    seqId = sequences.createSequence(metadata, account.id, request.user_agent.string)
 
     # Return created sequence
     return (
-        getCollection(seqId)[0],
+        getCollection(seqId, account=account)[0],
         200,
         {
             "Content-Type": "application/json",
@@ -565,9 +641,23 @@ class PatchCollectionParameter(BaseModel):
     """Parameters used to add an item to an UploadSet"""
 
     relative_heading: Optional[int] = None
-    """The relative heading (in degrees), offset based on movement path (0° = looking forward, -90° = looking left, 90° = looking right). Headings are unchanged if this parameter is not set."""
+    """The relative heading (in degrees), offset based on movement path (0° = looking forward, -90° = looking left, 90° = looking right). For single picture collections, 0° is heading north). Headings are unchanged if this parameter is not set."""
     visible: Optional[bool] = None
-    """Should the sequence be publicly visible ?"""
+    """Should the sequence be publicly visible ?
+    
+    This parameter is deprecated in favor of the finer grained `visibility` parameter.
+    `visible=true` is equivalent to `visibility=anyone`.
+    `visible=false` is equivalent to `visibility=logged-only`.
+    """
+    visibility: Optional[Visibility] = None
+    """Visibility of the sequence. Can be set to:
+    * `anyone`: the sequence is visible to anyone
+    * `owner-only`: the sequence is visible to the owner and administrator only
+    * `logged-only`: the sequence is visible to logged users only
+
+    This visibility can also be set for each picture individually, using the `visibility` field of the pictures.
+    If not set at the sequence level, it will default to the visibility of the `upload_set` and if not set the default visibility of the `account` and if not set the default visibility of the instance.
+    """
     title: Optional[str] = Field(max_length=250, default=None)
     """The sequence title (publicly displayed)"""
     sortby: Optional[str] = None
@@ -610,19 +700,30 @@ If unset, sort order is unchanged."""
     @field_validator("relative_heading", mode="before")
     @classmethod
     def parse_relative_heading(cls, value):
-        try:
-            relHeading = int(value)
-            if relHeading < -180 or relHeading > 180:
-                raise ValueError()
-            return relHeading
-        except (ValueError, TypeError):
-            raise errors.InvalidAPIUsage(
-                _("Relative heading is not valid, should be an integer in degrees from -180 to 180"), status_code=400
-            )
+        return parse_relative_heading(value)
+
+    @model_validator(mode="after")
+    def validate(self):
+        if self.visibility is not None and self.visible is not None:
+            raise errors.InvalidAPIUsage(_("Visibility and visible parameters are mutually exclusive parameters"))
+        # handle retrocompatibility on the visible parameter
+        if self.visible is not None:
+            self.visibility = Visibility.anyone if self.visible is True else Visibility.owner_only
+        return self
 
     def has_only_semantics_updates(self):
         return self.model_fields_set == {"semantics"}
 
+    @field_validator("visibility", mode="after")
+    @classmethod
+    def validate_visibility(cls, visibility):
+        if not check_visibility(visibility):
+            raise errors.InvalidAPIUsage(
+                _("The logged-only visibility is not allowed on this instance since anybody can create an account"),
+                status_code=400,
+            )
+        return visibility
+
 
 @bp.route("/collections/<uuid:collectionId>", methods=["PATCH"])
 @auth.login_required()
@@ -688,14 +789,15 @@ def patchCollection(collectionId, account):
         with conn.transaction():
             with conn.cursor(row_factory=dict_row) as cursor:
                 seq = cursor.execute(
-                    "SELECT status, metadata, account_id, current_sort FROM sequences WHERE id = %s AND status != 'deleted'", [collectionId]
+                    "SELECT metadata, account_id, current_sort, visibility FROM sequences WHERE id = %s AND status != 'deleted'",
+                    [collectionId],
                 ).fetchone()
 
                 # Sequence not found
                 if not seq:
                     raise errors.InvalidAPIUsage(_("Collection %(c)s wasn't found in database", c=collectionId), status_code=404)
 
-                if account is not None and account.id != str(seq["account_id"]):
+                if account is not None and not account.can_edit_collection(str(seq["account_id"])):
                     # Only owner of the sequence is allower to change its visibility and title
                     # tags and headings can be changed by anyone
                     if metadata.visible is not None or metadata.title is not None:
@@ -714,26 +816,18 @@ def patchCollection(collectionId, account):
                                 status_code=403,
                             )
 
-                oldStatus = seq["status"]
+                oldVisibility = seq["visibility"]
                 oldMetadata = seq["metadata"]
                 oldTitle = oldMetadata.get("title")
 
-                # Check if sequence is in a preparing/broken/... state so no edit possible
-                if oldStatus not in ["ready", "hidden"]:
-                    if metadata.visible is not None:
-                        raise errors.InvalidAPIUsage(
-                            _("Sequence %(c)s is in %(s)s state, its visibility can't be changed for now", c=collectionId, s=oldStatus),
-                            status_code=400,
-                        )
-
                 sqlUpdates = []
                 sqlParams = {"id": collectionId, "account": account.id}
 
-                if metadata.visible is not None:
-                    newStatus = "ready" if metadata.visible is True else "hidden"
-                    if newStatus != oldStatus:
-                        sqlUpdates.append(SQL("status = %(status)s"))
-                        sqlParams["status"] = newStatus
+                if metadata.visibility is not None:
+                    newVisibility = metadata.visibility.value
+                    if newVisibility != oldVisibility:
+                        sqlUpdates.append(SQL("visibility = %(visibility)s"))
+                        sqlParams["visibility"] = newVisibility
 
                 new_metadata = {}
                 if metadata.title is not None and oldTitle != metadata.title:
@@ -841,21 +935,20 @@ def getCollectionImportStatus(collectionId):
                     schema:
                         $ref: '#/components/schemas/GeoVisioCollectionImportStatus'
     """
-
-    account = auth.get_current_account()
-    params = {"seq_id": collectionId, "account": account.id if account is not None else None}
+    params = {"seq_id": collectionId, "account": auth.get_current_account_id()}
     with db.cursor(current_app, row_factory=dict_row) as cursor:
         sequence_status = cursor.execute(
             SQL(
-                """SELECT status 
+                """SELECT status, visibility 
                 FROM sequences
                 WHERE id = %(seq_id)s
-                    AND (status != 'hidden' OR account_id = %(account)s)-- show deleted sequence here"""
+                    AND is_sequence_visible_by_user(sequences, %(account)s)
+                    AND status != 'deleted'""",
             ),
             params,
         ).fetchone()
         if sequence_status is None:
-            raise errors.InvalidAPIUsage(_("Sequence doesn't exists"), status_code=404)
+            raise errors.InvalidAPIUsage(_("Sequence doesn't exist"), status_code=404)
 
         pics_status = cursor.execute(
             """WITH
@@ -888,8 +981,8 @@ pic_jobs_stats AS (
     JOIN pictures p ON sp.pic_id = p.id
     LEFT JOIN pic_jobs_stats ON pic_jobs_stats.picture_id = p.id
     WHERE
-                s.id = %(seq_id)s
-                AND (p IS NULL OR p.status != 'hidden' OR p.account_id = %(account)s)
+        s.id = %(seq_id)s
+        AND (p IS NULL OR is_picture_visible_by_user(p, %(account)s))
     ORDER BY s.id, sp.rank
 )
 SELECT json_strip_nulls(
@@ -1036,7 +1129,7 @@ def getUserCollection(userId, userIdMatchesAccount=False):
         format = "csv"
 
     # Sort-by parameter
-    sortBy = parse_sortby(request.args.get("sortby"))
+    sortBy = parse_collection_sortby(request.args.get("sortby"))
     if not sortBy:
         sortBy = SortBy(fields=[SortByField(field=STAC_FIELD_MAPPINGS["created"], direction=SQLDirection.DESC)])
 
@@ -1046,6 +1139,8 @@ def getUserCollection(userId, userIdMatchesAccount=False):
         sortBy.fields.append(SortByField(field=STAC_FIELD_MAPPINGS["id"], direction=SQLDirection.ASC))
     collection_request = CollectionsRequest(sort_by=sortBy, userOwnsAllCollections=userIdMatchesAccount)
 
+    account_to_query_id = auth.get_current_account_id()
+
     # Filter parameter
     collection_request.user_filter = parse_collection_filter(request.args.get("filter"))
 
@@ -1071,16 +1166,16 @@ def getUserCollection(userId, userIdMatchesAccount=False):
     meta_filter = [
         SQL("{field} IS NOT NULL").format(field=collection_request.sort_by.fields[0].field.sql_filter),
         SQL("s.account_id = %(account)s"),
+        SQL("is_sequence_visible_by_user(s, %(account_to_query)s)"),
     ]
     if collection_request.user_filter is not None:
         meta_filter.append(collection_request.user_filter)
 
-    if collection_request.user_filter is None or "status" not in collection_request.user_filter.as_string(None):
-        # if the filter does not contains any `status` condition, we want to show only 'ready' collection to the general users, and non deleted one for the owner
-        if not userIdMatchesAccount:
-            meta_filter.extend([SQL("s.status = 'ready'")])
-        else:
-            meta_filter.append(SQL("s.status != 'deleted'"))
+    # we want to show only 'ready' collection to the general users, and non deleted one for the owner
+    if not userIdMatchesAccount:
+        meta_filter.extend([SQL("s.status = 'ready'")])
+    else:
+        meta_filter.append(SQL("s.status != 'deleted'"))
 
     # Check user account parameter
     with db.cursor(current_app, row_factory=dict_row) as cursor:
@@ -1114,7 +1209,7 @@ def getUserCollection(userId, userIdMatchesAccount=False):
                 filter=SQL(" AND ").join(meta_filter),
                 order_column=collection_request.sort_by.fields[0].field.sql_filter,
             ),
-            params={"account": userId},
+            params={"account": userId, "account_to_query": account_to_query_id},
         ).fetchone()
 
         if not meta_collection or meta_collection["created"] is None:
@@ -1129,6 +1224,7 @@ def getUserCollection(userId, userIdMatchesAccount=False):
             collection_request.sort_by,
             additional_filters=SQL(" AND ").join(meta_filter),
             additional_filters_params={"account": userId},
+            account_to_query_id=account_to_query_id,
         )
 
     collections = get_collections(collection_request)
@@ -1154,7 +1250,8 @@ def getUserCollection(userId, userIdMatchesAccount=False):
                     },
                     "spatial": {"bbox": [[s["minx"] or -180.0, s["miny"] or -90.0, s["maxx"] or 180.0, s["maxy"] or 90.0]]},
                 },
-                "geovisio:status": s["status"] if userIdMatchesAccount else None,
+                "geovisio:status": retrocompatible_sequence_status(s, explicit=True) if userIdMatchesAccount else None,
+                "geovisio:visibility": s["visibility"] if userIdMatchesAccount else None,
                 "geovisio:length_km": s.get("length_km"),
             }
         )

geovisio/web/configuration.py

@@ -1,15 +1,21 @@
 import flask
 from typing import Dict, Any
-from flask import jsonify
+from flask import jsonify, current_app
 from flask_babel import get_locale
 from geovisio.web.utils import get_api_version
+from geovisio.web.params import Visibility
+from geovisio.utils import db
+from psycopg.rows import class_row
+from typing import Optional
+from pydantic import BaseModel, Field, ConfigDict, field_serializer
+import datetime
 
 bp = flask.Blueprint("configuration", __name__, url_prefix="/api")
 
 
 @bp.route("/configuration")
 def configuration():
-    """Return instance configuration informations
+    """Return instance configuration information
     ---
     tags:
         - Metadata
@@ -36,6 +42,8 @@ def configuration():
             "license": _license_configuration(),
             "version": get_api_version(),
             "pages": _get_pages(),
+            "defaults": _get_default_values(),
+            "visibility": {"possible_values": _get_possible_visibility_values()},
         }
     )
 
@@ -66,10 +74,34 @@ def _license_configuration():
     return l
 
 
+def _get_possible_visibility_values():
+    val = ["anyone", "owner-only"]
+    if not flask.current_app.config["API_REGISTRATION_IS_OPEN"]:
+        val.insert(1, "logged-only")
+    return val
+
+
 def _get_pages():
-    from geovisio.utils import db
-    from flask import current_app
 
     pages = db.fetchall(current_app, "SELECT distinct(name) FROM pages")
 
     return [p[0] for p in pages]
+
+
+class Config(BaseModel):
+    collaborative_metadata: Optional[bool]
+    split_distance: Optional[int] = Field(validation_alias="default_split_distance")
+    split_time: Optional[datetime.timedelta] = Field(validation_alias="default_split_time")
+    duplicate_distance: Optional[float] = Field(validation_alias="default_duplicate_distance")
+    duplicate_rotation: Optional[int] = Field(validation_alias="default_duplicate_rotation")
+    default_visibility: Visibility
+
+    @field_serializer("split_time")
+    def split_time_to_s(self, s: datetime.timedelta, _):
+        return s.total_seconds()
+
+    model_config = ConfigDict(use_enum_values=True)
+
+
+def _get_default_values():
+    return db.fetchone(current_app, "SELECT * FROM configurations", row_factory=class_row(Config)).model_dump()