geovisio 2.5.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

geovisio/web/collections.py

@@ -1,5 +1,5 @@
-import logging
-from geovisio import errors, utils
+from enum import Enum
+from geovisio import errors, utils, db
 from geovisio.utils import auth, sequences
 from geovisio.web.params import (
     parse_datetime,
@@ -16,11 +16,10 @@ from geovisio.utils.sequences import (
 )
 from geovisio.utils.fields import SortBy, SortByField, SQLDirection, Bounds, BBox
 from geovisio.web.rss import dbSequencesToGeoRSS
-import psycopg
 from psycopg.rows import dict_row
 from psycopg.sql import SQL
-import json
 from flask import current_app, request, url_for, Blueprint
+from flask_babel import gettext as _
 from geovisio.web.utils import (
     STAC_VERSION,
     accountIdOrDefault,
@@ -31,12 +30,37 @@ from geovisio.web.utils import (
     get_root_link,
     removeNoneInDict,
 )
-from geovisio.workers import runner_pictures
+from typing import Optional
 
 
 bp = Blueprint("stac_collections", __name__, url_prefix="/api")
 
 
+class UploadClient(Enum):
+    unknown = "unknown"
+    other = "other"
+    website = "website"
+    cli = "cli"
+    mobile_app = "mobile_app"
+
+
+def userAgentToClient(user_agent: Optional[str] = None) -> UploadClient:
+    """Transforms an open user agent string into a limited set of clients."""
+    if user_agent is None:
+        return UploadClient.unknown
+
+    software = user_agent.split("/")[0].lower().strip()
+
+    if software == "geovisiocli" or software == "panoramaxcli":
+        return UploadClient.cli
+    elif software == "geovisiowebsite":
+        return UploadClient.website
+    elif software == "panoramaxapp":
+        return UploadClient.mobile_app
+    else:
+        return UploadClient.other
+
+
 def dbSequenceToStacCollection(dbSeq, description="A sequence of geolocated pictures"):
     """Transforms a sequence extracted from database into a STAC Collection
 
@@ -53,6 +77,7 @@ def dbSequenceToStacCollection(dbSeq, description="A sequence of geolocated pict
         The equivalent in STAC Collection format
     """
     mints, maxts = dbSeq.get("mints"), dbSeq.get("maxts")
+    nb_pic = int(dbSeq.get("nbpic")) if "nbpic" in dbSeq else None
     return removeNoneInDict(
         {
             "type": "Collection",
@@ -65,10 +90,14 @@ def dbSequenceToStacCollection(dbSeq, description="A sequence of geolocated pict
             "license": current_app.config["API_PICTURES_LICENSE_SPDX_ID"],
             "created": dbTsToStac(dbSeq["created"]),
             "updated": dbTsToStac(dbSeq.get("updated")),
-            "geovisio:status": dbSeq.get("status"),
+            "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:sorted-by": dbSeq.get("current_sort"),
+            "geovisio:upload-software": userAgentToClient(dbSeq.get("user_agent")).value,
+            "geovisio:length_km": dbSeq.get("length_km"),
             "providers": [
-                {"name": dbSeq["account_name"], "roles": ["producer"]},
+                {"name": dbSeq["account_name"], "roles": ["producer"], "id": str(dbSeq["account_id"])},
             ],
             "extent": {
                 "spatial": {"bbox": [[dbSeq["minx"] or -180.0, dbSeq["miny"] or -90.0, dbSeq["maxx"] or 180.0, dbSeq["maxy"] or 90.0]]},
@@ -82,7 +111,7 @@ def dbSequenceToStacCollection(dbSeq, description="A sequence of geolocated pict
                 },
             },
             "summaries": cleanNoneInDict({"pers:interior_orientation": dbSeq.get("metas")}),
-            "stats:items": removeNoneInDict({"count": dbSeq.get("nbpic")}),
+            "stats:items": removeNoneInDict({"count": nb_pic}),
             "links": cleanNoneInList(
                 [
                     (
@@ -230,10 +259,10 @@ def getAllCollections():
     created_before = args.get("created_before")
 
     if created_after:
-        collection_request.created_after = parse_datetime(created_after, error=f"Invalid `created_after` argument", fallback_as_UTC=True)
+        collection_request.created_after = parse_datetime(created_after, error="Invalid `created_after` argument", fallback_as_UTC=True)
 
     if created_before:
-        collection_request.created_before = parse_datetime(created_before, error=f"Invalid `created_before` argument", fallback_as_UTC=True)
+        collection_request.created_before = parse_datetime(created_before, error="Invalid `created_before` argument", fallback_as_UTC=True)
 
     links = [
         get_root_link(),
@@ -249,16 +278,16 @@ def getAllCollections():
             ),
         },
     ]
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn:
-        with conn.cursor() as cursor:
-            stats = cursor.execute("SELECT min(inserted_at) as min, max(inserted_at) as max FROM sequences").fetchone()
-            if stats 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:
-                raise errors.InvalidAPIUsage(f"There is no collection created after {collection_request.created_after}")
-            if collection_request.created_before and collection_request.created_before < datasetBounds.min:
-                raise errors.InvalidAPIUsage(f"There is no collection created before {collection_request.created_before}")
+
+    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:
+            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:
+            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:
+            raise errors.InvalidAPIUsage(_("There is no collection created before %(d)s", d=collection_request.created_before))
 
     db_collections = get_collections(collection_request)
 
@@ -324,55 +353,58 @@ def getCollection(collectionId):
         "account": account.id if account is not None else None,
     }
 
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn:
-        with conn.cursor() as cursor:
-            record = cursor.execute(
-                """
+    record = db.fetchone(
+        current_app,
+        """
+            SELECT
+                s.id,
+                s.metadata->>'title' AS name,
+                ST_XMin(s.bbox) AS minx,
+                ST_YMin(s.bbox) AS miny,
+                ST_XMax(s.bbox) AS maxx,
+                ST_YMax(s.bbox) AS maxy,
+                s.status AS status,
+                accounts.name AS account_name,
+                s.account_id AS account_id,
+                s.inserted_at AS created,
+                s.updated_at AS updated,
+                s.current_sort AS current_sort,
+                a.*,
+                min_picture_ts AS mints,
+                max_picture_ts AS maxts,
+                nb_pictures AS nbpic,
+                s.user_agent,
+                ROUND(ST_Length(s.geom::geography)) / 1000 as length_km
+            FROM sequences s
+            JOIN accounts ON s.account_id = accounts.id, (
                 SELECT
-                    s.id,
-                    s.metadata->>'title' AS name,
-                    ST_XMin(s.bbox) AS minx,
-                    ST_YMin(s.bbox) AS miny,
-                    ST_XMax(s.bbox) AS maxx,
-                    ST_YMax(s.bbox) AS maxy,
-                    s.status AS status,
-                    accounts.name AS account_name,
-                    s.inserted_at AS created,
-                    s.updated_at AS updated,
-                    s.current_sort AS current_sort,
-                    a.*
-                FROM sequences s
-                JOIN accounts ON s.account_id = accounts.id, (
-                    SELECT
-                        MIN(ts) as mints,
-                        MAX(ts) as maxts,
-                        array_agg(DISTINCT jsonb_build_object(
-                            'make', metadata->>'make',
-                            'model', metadata->>'model',
-                            'focal_length', metadata->>'focal_length',
-                            'field_of_view', metadata->>'field_of_view'
-                        )) AS metas,
-                        COUNT(*) AS nbpic
-                    FROM pictures p
-                    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 s.status != 'deleted'
-            """,
-                params,
-            ).fetchone()
-
-            if record is None:
-                raise errors.InvalidAPIUsage("Collection doesn't exist", status_code=404)
-
-            return (
-                dbSequenceToStacCollection(record),
-                200,
-                {
-                    "Content-Type": "application/json",
-                },
-            )
+                    array_agg(DISTINCT jsonb_build_object(
+                        'make', metadata->>'make',
+                        'model', metadata->>'model',
+                        'focal_length', metadata->>'focal_length',
+                        'field_of_view', metadata->>'field_of_view'
+                    )) AS metas
+                FROM pictures p
+                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 s.status != 'deleted'
+        """,
+        params,
+        row_factory=dict_row,
+    )
+
+    if record is None:
+        raise errors.InvalidAPIUsage(_("Collection doesn't exist"), status_code=404)
+
+    return (
+        dbSequenceToStacCollection(record),
+        200,
+        {
+            "Content-Type": "application/json",
+        },
+    )
 
 
 @bp.route("/collections/<uuid:collectionId>/thumb.jpg", methods=["GET"])
@@ -405,28 +437,27 @@ def getCollectionThumbnail(collectionId):
         "account": account.id if account is not None else None,
     }
 
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn:
-        with conn.cursor() as cursor:
-            records = cursor.execute(
-                """
-                SELECT
-                    sp.pic_id
-                FROM sequences_pictures sp
-                JOIN pictures p ON sp.pic_id = p.id
-                JOIN sequences s ON sp.seq_id = s.id
-                WHERE
-                    sp.seq_id = %(seq)s
-                    AND (p.status = 'ready' OR p.account_id = %(account)s)
-                    AND is_sequence_visible_by_user(s, %(account)s)
-                LIMIT 1
-            """,
-                params,
-            ).fetchone()
+    records = db.fetchone(
+        current_app,
+        """SELECT
+                sp.pic_id
+            FROM sequences_pictures sp
+            JOIN pictures p ON sp.pic_id = p.id
+            JOIN sequences s ON sp.seq_id = s.id
+            WHERE
+                sp.seq_id = %(seq)s
+                AND (p.status = 'ready' OR p.account_id = %(account)s)
+                AND is_sequence_visible_by_user(s, %(account)s)
+            ORDER BY RANK ASC
+            LIMIT 1""",
+        params,
+        row_factory=dict_row,
+    )
 
-            if records is None:
-                raise errors.InvalidAPIUsage("Impossible to find a thumbnail for the collection", status_code=404)
+    if records is None:
+        raise errors.InvalidAPIUsage(_("Impossible to find a thumbnail for the collection"), status_code=404)
 
-            return utils.pictures.sendThumbnail(records["pic_id"], "jpg")
+    return utils.pictures.sendThumbnail(records["pic_id"], "jpg")
 
 
 @bp.route("/collections", methods=["POST"])
@@ -436,6 +467,13 @@ def postCollection(account=None):
     ---
     tags:
         - Upload
+    parameters:
+        - in: header
+          name: User-Agent
+          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"
     requestBody:
         content:
             application/json:
@@ -471,7 +509,7 @@ def postCollection(account=None):
 
     # Create sequence folder
     accountId = accountIdOrDefault(account)
-    seqId = sequences.createSequence(metadata, accountId)
+    seqId = sequences.createSequence(metadata, accountId, request.user_agent.string)
 
     # Return created sequence
     return (
@@ -537,19 +575,19 @@ def patchCollection(collectionId, account):
         if visible in ["true", "false"]:
             visible = visible == "true"
         else:
-            raise errors.InvalidAPIUsage("Picture visibility parameter (visible) should be either unset, true or false", status_code=400)
+            raise errors.InvalidAPIUsage(_("Picture visibility parameter (visible) should be either unset, true or false"), status_code=400)
 
     # Check if title is valid
     newTitle = metadata.get("title")
     if newTitle is not None:
         if not (isinstance(newTitle, str) and len(newTitle) <= 250):
-            raise errors.InvalidAPIUsage("Sequence title is not valid, should be a string with a max of 250 characters", status_code=400)
+            raise errors.InvalidAPIUsage(_("Sequence title is not valid, should be a string with a max of 250 characters"), status_code=400)
 
     # Check if sortby is valid
     sortby = metadata.get("sortby")
     if sortby is not None:
         if sortby not in ["+gpsdate", "-gpsdate", "+filedate", "-filedate", "+filename", "-filename"]:
-            raise errors.InvalidAPIUsage("Sort order parameter is invalid", status_code=400)
+            raise errors.InvalidAPIUsage(_("Sort order parameter is invalid"), status_code=400)
 
     # Check if relative_heading is valid
     relHeading = metadata.get("relative_heading")
@@ -559,94 +597,101 @@ def patchCollection(collectionId, account):
             if relHeading < -180 or relHeading > 180:
                 raise ValueError()
         except ValueError:
-            raise errors.InvalidAPIUsage("Relative heading is not valid, should be an integer in degrees from -180 to 180", status_code=400)
+            raise errors.InvalidAPIUsage(
+                _("Relative heading is not valid, should be an integer in degrees from -180 to 180"), status_code=400
+            )
 
     # If no parameter is changed, no need to contact DB, just return sequence as is
     if {visible, newTitle, relHeading, sortby} == {None}:
         return getCollection(collectionId)
 
     # Check if sequence exists and if given account is authorized to edit
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn, conn.cursor() as cursor:
-        seq = cursor.execute("SELECT status, metadata, account_id, current_sort FROM sequences WHERE id = %s", [collectionId]).fetchone()
-
-        # Sequence not found
-        if not seq:
-            raise errors.InvalidAPIUsage(f"Sequence {collectionId} wasn't found in database", status_code=404)
-
-        # Account associated to sequence doesn't match current user
-        if account is not None and account.id != str(seq["account_id"]):
-            raise errors.InvalidAPIUsage("You're not authorized to edit this sequence", status_code=403)
-
-        oldStatus = seq["status"]
-        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"]:
-            raise errors.InvalidAPIUsage(
-                f"Sequence {collectionId} is in {oldStatus} state, its visibility can't be changed for now", status_code=400
-            )
-
-        sqlUpdates = []
-        sqlParams = {"id": collectionId, "account": account.id}
-
-        if visible is not None:
-            newStatus = "ready" if visible is True else "hidden"
-            if newStatus != oldStatus:
-                sqlUpdates.append(SQL("status = %(status)s"))
-                sqlParams["status"] = newStatus
-
-        new_metadata = {}
-        if newTitle is not None and oldTitle != newTitle:
-            new_metadata["title"] = newTitle
-        if relHeading:
-            new_metadata["relative_heading"] = relHeading
-
-        if new_metadata:
-            sqlUpdates.append(SQL("metadata = metadata || %(new_metadata)s"))
-            from psycopg.types.json import Jsonb
-
-            sqlParams["new_metadata"] = Jsonb(new_metadata)
-
-        if sortby is not None:
-            sqlUpdates.append(SQL("current_sort = %(sort)s"))
-            sqlParams["sort"] = sortby
-
-        if len(sqlUpdates) > 0:
-            # Note: we set the field `last_account_to_edit` to track who changed the collection last (later we'll make it possible for everybody to edit some collection fields)
-            # setting this field will trigger the history tracking of the collection (using postgres trigger)
-            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)),
-                sqlParams,
-            )
-
-        # Edits picture sort order
-        if sortby is not None:
-            direction = sequences.Direction(sortby[0])
-            order = sequences.CollectionSortOrder(sortby[1:])
-            sequences.sort_collection(cursor, collectionId, sequences.CollectionSort(order=order, direction=direction))
-            if not relHeading:
-                # if we do not plan to override headings specifically, we recompute headings that have not bee provided by the users
-                # with the new movement track
-                sequences.update_headings(cursor, collectionId, editingAccount=account.id)
-
-        # Edits relative heading of pictures in sequence
-        if relHeading is not None:
-            # New heading is computed based on sequence movement track
-            #   We take each picture and its following, compute azimuth,
-            #   then add given relative heading to offset picture heading.
-            #   Last picture is computed based on previous one in sequence.
-            sequences.update_headings(cursor, collectionId, relativeHeading=relHeading, updateOnlyMissing=False, editingAccount=account.id)
-
-        conn.commit()
+    with db.conn(current_app) as conn:
+        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]
+                ).fetchone()
+
+                # Sequence not found
+                if not seq:
+                    raise errors.InvalidAPIUsage(_("Collection %(c)s wasn't found in database", c=collectionId), status_code=404)
+
+                # Account associated to sequence doesn't match current user
+                if account is not None and account.id != str(seq["account_id"]):
+                    raise errors.InvalidAPIUsage(_("You're not authorized to edit this sequence"), status_code=403)
+
+                oldStatus = seq["status"]
+                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"]:
+                    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 visible is not None:
+                    newStatus = "ready" if visible is True else "hidden"
+                    if newStatus != oldStatus:
+                        sqlUpdates.append(SQL("status = %(status)s"))
+                        sqlParams["status"] = newStatus
+
+                new_metadata = {}
+                if newTitle is not None and oldTitle != newTitle:
+                    new_metadata["title"] = newTitle
+                if relHeading:
+                    new_metadata["relative_heading"] = relHeading
+
+                if new_metadata:
+                    sqlUpdates.append(SQL("metadata = metadata || %(new_metadata)s"))
+                    from psycopg.types.json import Jsonb
+
+                    sqlParams["new_metadata"] = Jsonb(new_metadata)
+
+                if sortby is not None:
+                    sqlUpdates.append(SQL("current_sort = %(sort)s"))
+                    sqlParams["sort"] = sortby
+
+                if len(sqlUpdates) > 0:
+                    # Note: we set the field `last_account_to_edit` to track who changed the collection last (later we'll make it possible for everybody to edit some collection fields)
+                    # setting this field will trigger the history tracking of the collection (using postgres trigger)
+                    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)),
+                        sqlParams,
+                    )
+
+                # Edits picture sort order
+                if sortby is not None:
+                    direction = sequences.Direction(sortby[0])
+                    order = sequences.CollectionSortOrder(sortby[1:])
+                    sequences.sort_collection(cursor, collectionId, sequences.CollectionSort(order=order, direction=direction))
+                    if not relHeading:
+                        # if we do not plan to override headings specifically, we recompute headings that have not bee provided by the users
+                        # with the new movement track
+                        sequences.update_headings(cursor, collectionId, editingAccount=account.id)
+
+                # Edits relative heading of pictures in sequence
+                if relHeading is not None:
+                    # New heading is computed based on sequence movement track
+                    #   We take each picture and its following, compute azimuth,
+                    #   then add given relative heading to offset picture heading.
+                    #   Last picture is computed based on previous one in sequence.
+                    sequences.update_headings(
+                        cursor, collectionId, relativeHeading=relHeading, updateOnlyMissing=False, editingAccount=account.id
+                    )
 
         # Redirect response to a classic GET
         return getCollection(collectionId)
@@ -674,73 +719,13 @@ def deleteCollection(collectionId, account):
         204:
             description: The collection has been correctly deleted
     """
+    nb_updated = utils.sequences.delete_collection(collectionId, account)
+
+    # add background task if needed, to really delete pictures
+    for _ in range(nb_updated):
+        current_app.background_processor.process_pictures()
 
-    # Check if collection exists and if given account is authorized to edit
-    with psycopg.connect(current_app.config["DB_URL"]) as conn:
-        with conn.cursor() as cursor:
-            sequence = cursor.execute("SELECT status, account_id FROM sequences WHERE id = %s", [collectionId]).fetchone()
-
-            # sequence not found
-            if not sequence:
-                raise errors.InvalidAPIUsage(f"Collection {collectionId} wasn't found in database", status_code=404)
-
-            # Account associated to sequence doesn't match current user
-            if account is not None and account.id != str(sequence[1]):
-                raise errors.InvalidAPIUsage("You're not authorized to edit this sequence", status_code=403)
-
-            logging.info(f"Asking for deletion of sequence {collectionId} and all its pictures")
-
-            # mark all the pictures as waiting for deletion for async removal as this can be quite long if the storage is slow if there are lots of pictures
-            # Note: To avoid a deadlock if some workers are currently also working on those picture to prepare them,
-            # the SQL queries are split in 2:
-            # - First a query to add the async deletion task to the queue.
-            # - Then a query changing the status of the picture to `waiting-for-delete`
-            #
-            # The trick there is that there can only be one task for a given picture (either preparing or deleting it)
-            # And the first query do a `ON CONFLICT DO UPDATE` to change the remaining `prepare` task to `delete`.
-            # So at the end of this query, we know that there are no more workers working on those pictures, so we can change their status
-            # without fearing a deadlock.
-            nb_updated = cursor.execute(
-                """
-                WITH pic2rm AS (
-                    SELECT pic_id FROM sequences_pictures WHERE seq_id = %(seq)s
-                ),
-                picWithoutOtherSeq AS (
-                    SELECT pic_id FROM pic2rm
-                    EXCEPT
-                    SELECT pic_id FROM sequences_pictures WHERE pic_id IN (SELECT pic_id FROM pic2rm) AND seq_id != %(seq)s
-                )
-                INSERT INTO pictures_to_process(picture_id, task)
-                    SELECT pic_id, 'delete' FROM picWithoutOtherSeq
-                    ON CONFLICT (picture_id) DO UPDATE SET task = 'delete'
-            """,
-                {"seq": collectionId},
-            ).rowcount
-
-            # after the task have been added to the queue, we mark all picture for deletion
-            cursor.execute(
-                """
-                WITH pic2rm AS (
-                    SELECT pic_id FROM sequences_pictures WHERE seq_id = %(seq)s
-                ),
-                picWithoutOtherSeq AS (
-                    SELECT pic_id FROM pic2rm
-                    EXCEPT
-                    SELECT pic_id FROM sequences_pictures WHERE pic_id IN (SELECT pic_id FROM pic2rm) AND seq_id != %(seq)s
-                )
-                UPDATE pictures SET status = 'waiting-for-delete' WHERE id IN (SELECT pic_id FROM picWithoutOtherSeq)
-            """,
-                {"seq": collectionId},
-            ).rowcount
-
-            cursor.execute("UPDATE sequences SET status = 'deleted' WHERE id = %s", [collectionId])
-            conn.commit()
-
-            # add background task if needed, to really delete pictures
-            for _ in range(nb_updated):
-                runner_pictures.background_processor.process_pictures()
-
-            return "", 204
+    return "", 204
 
 
 @bp.route("/collections/<uuid:collectionId>/geovisio_status")
@@ -767,10 +752,21 @@ def getCollectionImportStatus(collectionId):
 
     account = auth.get_current_account()
     params = {"seq_id": collectionId, "account": account.id if account is not None else None}
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn:
-        with conn.cursor() as cursor:
-            sequence_status = cursor.execute(
-                """WITH
+    with db.cursor(current_app, row_factory=dict_row) as cursor:
+        sequence_status = cursor.execute(
+            SQL(
+                """SELECT status 
+                FROM sequences
+                WHERE id = %(seq_id)s
+                    AND (status != 'hidden' OR account_id = %(account)s)-- show deleted sequence here"""
+            ),
+            params,
+        ).fetchone()
+        if sequence_status is None:
+            raise errors.InvalidAPIUsage(_("Sequence doesn't exists"), status_code=404)
+
+        pics_status = cursor.execute(
+            """WITH
 pic_jobs_stats AS (
     SELECT
     picture_id,
@@ -796,47 +792,37 @@ pic_jobs_stats AS (
     pic_jobs_stats.nb_errors,
     pic_jobs_stats.last_job_finished_at
     FROM sequences s
-    LEFT JOIN sequences_pictures sp ON sp.seq_id = s.id
-    LEFT JOIN pictures p ON sp.pic_id = p.id
+    JOIN sequences_pictures sp ON sp.seq_id = s.id
+    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)
-                AND (s.status != 'hidden' OR s.account_id = %(account)s) -- show deleted sequence here
     ORDER BY s.id, sp.rank
 )
-SELECT json_build_object(
-        'status', s.status,
-        'items', json_agg(
-                    json_strip_nulls(
-                        json_build_object(
-                            'id', i.id,
-                            -- status is a bit deprecated, we'll split this field in more fields (like `processing_in_progress`, `hidden`, ...)
-                            -- but we maintain it for retrocompatibility
-                            'status', CASE 
-                                    WHEN i.is_job_running IS TRUE THEN 'preparing' 
-                                    WHEN i.last_job_error IS NOT NULL THEN 'broken' 
-                                    ELSE i.status
-                                END, 
-                            'processing_in_progress', i.is_job_running,
-                            'process_error', i.last_job_error,
-                            'nb_errors', i.nb_errors,
-                            'processed_at', i.last_job_finished_at,
-                            'rank', i.rank
-                        )
-                )
+SELECT json_strip_nulls(
+        json_build_object(
+            'id', i.id,
+            -- status is a bit deprecated, we'll split this field in more fields (like `processing_in_progress`, `hidden`, ...)
+            -- but we maintain it for retrocompatibility
+            'status', CASE 
+                    WHEN i.is_job_running IS TRUE THEN 'preparing' 
+                    WHEN i.last_job_error IS NOT NULL THEN 'broken' 
+                    ELSE i.status
+                END, 
+            'processing_in_progress', i.is_job_running,
+            'process_error', i.last_job_error,
+            'nb_errors', i.nb_errors,
+            'processed_at', i.last_job_finished_at,
+            'rank', i.rank
         )
-) AS sequence
-FROM items i
-JOIN sequences s on i.seq_id = s.id
-GROUP by s.id;""",
-                params,
-            ).fetchall()
-
-            if len(sequence_status) == 0:
-                raise errors.InvalidAPIUsage("Sequence doesn't exists", status_code=404)
+    ) as pic_status
+FROM items i;""",
+            params,
+        ).fetchall()
+        pics = [p["pic_status"] for p in pics_status if len(p["pic_status"]) > 0]
 
-            return sequence_status[0]["sequence"]
+        return {"status": sequence_status["status"], "items": pics}
 
 
 @bp.route("/users/<uuid:userId>/collection")
@@ -913,52 +899,50 @@ def getUserCollection(userId, userIdMatchesAccount=False):
     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'"), SQL("p.status = 'ready'")])
+            meta_filter.extend([SQL("s.status = 'ready'")])
         else:
             meta_filter.append(SQL("s.status != 'deleted'"))
 
     # Check user account parameter
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn:
-        with conn.cursor() as cursor:
-            userName = cursor.execute("SELECT name FROM accounts WHERE id = %s", [userId]).fetchone()
-
-            if not userName:
-                raise errors.InvalidAPIUsage(f"Impossible to find user {userId}")
-            userName = userName["name"]
-
-            meta_collection = cursor.execute(
-                SQL(
-                    """SELECT
-                    COUNT(sp.pic_id) AS nbpic,
-                    COUNT(s.id) AS nbseq,
-                    MIN(p.ts) AS mints,
-                    MAX(p.ts) AS maxts,
-                    MIN(GREATEST(-180, ST_X(p.geom))) AS minx,
-                    MIN(GREATEST(-90, ST_Y(p.geom))) AS miny,
-                    MAX(LEAST(180, ST_X(p.geom))) AS maxx,
-                    MAX(LEAST(90, ST_Y(p.geom))) 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
-                FROM sequences s
-                LEFT JOIN sequences_pictures sp ON s.id = sp.seq_id
-                LEFT JOIN pictures p on sp.pic_id = p.id
-                WHERE {filter}
-                """
-                ).format(
-                    filter=SQL(" AND ").join(meta_filter),
-                    order_column=collection_request.sort_by.fields[0].field.sql_filter,
-                ),
-                params={"account": userId},
-            ).fetchone()
-
-            if not meta_collection or meta_collection["created"] is None:
-                # No data found, trying to give the most meaningfull error message
-                if collection_request.user_filter is None:
-                    raise errors.InvalidAPIUsage(f"No data loaded for user {userId}", 404)
-                else:
-                    raise errors.InvalidAPIUsage(f"No matching sequences found", 404)
+    with db.cursor(current_app, row_factory=dict_row) as cursor:
+        userName = cursor.execute("SELECT name FROM accounts WHERE id = %s", [userId]).fetchone()
+
+        if not userName:
+            raise errors.InvalidAPIUsage(_("Impossible to find user %(u)s", u=userId))
+        userName = userName["name"]
+
+        meta_collection = cursor.execute(
+            SQL(
+                """SELECT
+                SUM(s.nb_pictures) AS nbpic,
+                COUNT(s.id) AS nbseq,
+                MIN(s.min_picture_ts) AS mints,
+                MAX(s.max_picture_ts) AS maxts,
+                MIN(GREATEST(-180, ST_XMin(s.bbox))) AS minx,
+                MIN(GREATEST(-90, ST_YMin(s.bbox))) AS miny,
+                MAX(LEAST(180, ST_XMax(s.bbox))) AS maxx,
+                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}
+            """
+            ).format(
+                filter=SQL(" AND ").join(meta_filter),
+                order_column=collection_request.sort_by.fields[0].field.sql_filter,
+            ),
+            params={"account": userId},
+        ).fetchone()
+
+        if not meta_collection or meta_collection["created"] is None:
+            # No data found, trying to give the most meaningful error message
+            if collection_request.user_filter is None:
+                raise errors.InvalidAPIUsage(_("No data loaded for user %(u)s", u=userId), 404)
+            else:
+                raise errors.InvalidAPIUsage(_("No matching sequences found"), 404)
 
     collections = get_collections(collection_request)
 
@@ -984,6 +968,7 @@ 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:length_km": s.get("length_km"),
             }
         )
         for s in collections.collections
@@ -994,6 +979,7 @@ def getUserCollection(userId, userIdMatchesAccount=False):
             "id": f"user:{userId}",
             "name": f"{userName}'s sequences",
             "account_name": userName,
+            "account_id": userId,
         }
     )
     collection = dbSequenceToStacCollection(meta_collection, description=f"List of all sequences of user {userName}")