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

geovisio/utils/reports.py

@@ -0,0 +1,171 @@
+from enum import Enum
+from uuid import UUID
+from typing import Optional, List
+from typing_extensions import Self
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict
+from geovisio.utils import db
+from geovisio.errors import InvalidAPIUsage
+from flask import current_app
+from psycopg.sql import SQL
+from psycopg.rows import class_row
+
+
+class ReportType(Enum):
+    blur_missing = "blur_missing"
+    blur_excess = "blur_excess"
+    inappropriate = "inappropriate"
+    privacy = "privacy"
+    picture_low_quality = "picture_low_quality"
+    mislocated = "mislocated"
+    copyright = "copyright"
+    other = "other"
+
+
+class ReportStatus(Enum):
+    open = "open"
+    open_autofix = "open_autofix"
+    waiting = "waiting"
+    closed_solved = "closed_solved"
+    closed_ignored = "closed_ignored"
+
+
+class Report(BaseModel):
+    """A Report is a problem reported from a third-party about a picture or a sequence."""
+
+    id: UUID
+    issue: ReportType
+    status: ReportStatus
+    picture_id: Optional[UUID]
+    sequence_id: Optional[UUID]
+    ts_opened: datetime
+    ts_closed: Optional[datetime]
+    reporter_account_id: Optional[UUID]
+    reporter_email: Optional[str]
+    resolver_account_id: Optional[UUID]
+    reporter_comments: Optional[str]
+    resolver_comments: Optional[str]
+
+    model_config = ConfigDict(use_enum_values=True, ser_json_timedelta="float")
+
+    def for_public(self) -> Self:
+        """Report version for public display (without report email and admin comments)"""
+        return Report(
+            id=self.id,
+            issue=self.issue,
+            status=self.status,
+            picture_id=self.picture_id,
+            sequence_id=self.sequence_id,
+            ts_opened=self.ts_opened,
+            ts_closed=self.ts_closed,
+            reporter_account_id=self.reporter_account_id,
+            reporter_email=None,
+            resolver_account_id=self.resolver_account_id,
+            reporter_comments=self.reporter_comments,
+            resolver_comments=None,
+        )
+
+
+class Reports(BaseModel):
+    reports: List[Report]
+
+
+def get_report(id: UUID) -> Optional[Report]:
+    """Get the Report corresponding to the ID"""
+    db_report = db.fetchone(
+        current_app,
+        SQL("SELECT * FROM reports WHERE id = %(id)s"),
+        {"id": id},
+        row_factory=class_row(Report),
+    )
+
+    return db_report
+
+
+def is_picture_owner(report: Report, account_id: UUID):
+    """Check if given account is owner of picture concerned by report"""
+
+    isOwner = False
+    if report.picture_id is not None:
+        concernedPic = db.fetchone(
+            current_app,
+            SQL("SELECT id FROM pictures WHERE id = %(id)s AND account_id = %(uid)s"),
+            {"id": report.picture_id, "uid": account_id},
+        )
+        isOwner = concernedPic is not None
+    elif report.sequence_id is not None:
+        concernedSeq = db.fetchone(
+            current_app,
+            SQL("SELECT id FROM sequences WHERE id = %(id)s AND account_id = %(uid)s"),
+            {"id": report.sequence_id, "uid": account_id},
+        )
+        isOwner = concernedSeq is not None
+    return isOwner
+
+
+def _parse_filter(filter: Optional[str]) -> SQL:
+    """
+    Parse a filter string and return a SQL expression
+
+    >>> _parse_filter('')
+    SQL('TRUE')
+    >>> _parse_filter(None)
+    SQL('TRUE')
+    >>> _parse_filter("status = \'open\'")
+    SQL("(r.status = \'open\')")
+    >>> _parse_filter("status IN (\'open_autofix\', \'waiting\')")
+    SQL("r.status IN (\'open_autofix\', \'waiting\')")
+    >>> _parse_filter("reporter = \'me\'")
+    SQL('(reporter_account_id = %(account_id)s)')
+    >>> _parse_filter("owner = \'me\'")
+    SQL('(COALESCE(p.account_id, s.account_id) = %(account_id)s)')
+    >>> _parse_filter("status IN (\'open\', \'open_autofix\', \'waiting\') AND (owner = \'me\' OR reporter = \'me\')")
+    SQL("(r.status IN (\'open\', \'open_autofix\', \'waiting\') AND ((COALESCE(p.account_id, s.account_id) = %(account_id)s) OR (reporter_account_id = %(account_id)s)))")
+    """
+    if not filter:
+        return SQL("TRUE")
+    from pygeofilter.backends.sql import to_sql_where
+    from pygeofilter.parsers.ecql import parse as ecql_parser
+
+    try:
+        filterAst = ecql_parser(filter)
+        fieldsToFilter = {
+            "status": "r.status",
+            "reporter": "reporter_account_id",
+            "owner": "COALESCE(p.account_id, s.account_id)",
+        }
+
+        f = to_sql_where(filterAst, fieldsToFilter).replace('"', "").replace("'me'", "%(account_id)s")  # type: ignore
+        return SQL(f)  # type: ignore
+    except Exception as e:
+        print(e)
+        raise InvalidAPIUsage(_("Unsupported filter parameter"), status_code=400)
+
+
+def list_reports(account_id: UUID, limit: int = 100, filter: Optional[str] = None, forceAccount: bool = True) -> Reports:
+    filter_sql = _parse_filter(filter)
+    if forceAccount:
+        filter_sql = SQL(" ").join(
+            [SQL("(COALESCE(p.account_id, s.account_id) = %(account_id)s OR reporter_account_id = %(account_id)s) AND "), filter_sql]
+        )
+
+    l = db.fetchall(
+        current_app,
+        SQL(
+            """
+        SELECT
+            r.*,
+            COALESCE(p.account_id, s.account_id) AS owner_account_id
+        FROM reports r
+        LEFT JOIN pictures p ON r.picture_id = p.id
+        LEFT JOIN sequences s ON r.sequence_id = s.id
+        WHERE {filter}
+        ORDER BY ts_opened DESC
+        LIMIT %(limit)s
+        """
+        ).format(filter=filter_sql),
+        {"account_id": account_id, "limit": limit},
+        row_factory=class_row(Report),
+    )
+
+    return Reports(reports=l)

geovisio/utils/sequences.py

@@ -1,44 +1,44 @@
 import psycopg
 from flask import current_app, url_for
+from flask_babel import gettext as _
 from psycopg.types.json import Jsonb
-from psycopg import sql
-from psycopg.sql import SQL
+from psycopg.sql import SQL, Composable
 from psycopg.rows import dict_row
 from dataclasses import dataclass, field
 from typing import Any, List, Dict, Optional
 import datetime
 from uuid import UUID
 from enum import Enum
+from geovisio.utils import db
+from geovisio.utils.auth import Account
 from geovisio.utils.fields import FieldMapping, SortBy, SQLDirection, BBox, Bounds
 from geopic_tag_reader import reader
 from pathlib import PurePath
-from geovisio import errors
+from geovisio import errors, utils
+import logging
+import sentry_sdk
 
 
-def createSequence(metadata, accountId) -> str:
-    with psycopg.connect(current_app.config["DB_URL"]) as conn:
-        with conn.cursor() as cursor:
-            # Add sequence in database
-            seqId = cursor.execute(
-                "INSERT INTO sequences(account_id, metadata) VALUES(%s, %s) RETURNING id", [accountId, Jsonb(metadata)]
-            ).fetchone()
-
-            # Make changes definitive in database
-            conn.commit()
-
-            if seqId is None:
-                raise Exception(f"impossible to insert sequence in database")
-            return seqId[0]
+def createSequence(metadata, accountId, user_agent: Optional[str] = None) -> UUID:
+    with db.execute(
+        current_app,
+        "INSERT INTO sequences(account_id, metadata, user_agent) VALUES(%s, %s, %s) RETURNING id",
+        [accountId, Jsonb(metadata), user_agent],
+    ) as r:
+        seqId = r.fetchone()
+        if seqId is None:
+            raise Exception("impossible to insert sequence in database")
+        return seqId[0]
 
 
 # Mappings from stac name to SQL names
 STAC_FIELD_MAPPINGS = {
     p.stac: p
     for p in [
-        FieldMapping(sql_column=sql.SQL("inserted_at"), stac="created"),
-        FieldMapping(sql_column=sql.SQL("updated_at"), stac="updated"),
-        FieldMapping(sql_column=sql.SQL("computed_capture_date"), stac="datetime"),
-        FieldMapping(sql_column=sql.SQL("status"), stac="status"),
+        FieldMapping(sql_column=SQL("inserted_at"), stac="created"),
+        FieldMapping(sql_column=SQL("updated_at"), stac="updated"),
+        FieldMapping(sql_column=SQL("computed_capture_date"), stac="datetime"),
+        FieldMapping(sql_column=SQL("status"), stac="status"),
     ]
 }
 STAC_FIELD_TO_SQL_FILTER = {p.stac: p.sql_filter.as_string(None) for p in STAC_FIELD_MAPPINGS.values()}
@@ -64,8 +64,8 @@ class CollectionsRequest:
     created_before: Optional[datetime.datetime] = None
     user_id: Optional[UUID] = None
     bbox: Optional[BBox] = None
-    user_filter: Optional[sql.SQL] = None
-    pagination_filter: Optional[sql.SQL] = None
+    user_filter: Optional[SQL] = None
+    pagination_filter: Optional[SQL] = None
     limit: int = 100
     userOwnsAllCollections: bool = False  # bool to represent that the user's asking for the collections is the owner of them
 
@@ -75,9 +75,8 @@ class CollectionsRequest:
 
 def get_collections(request: CollectionsRequest) -> Collections:
     # Check basic parameters
-    seq_filter: List[sql.Composable] = []
+    seq_filter: List[Composable] = []
     seq_params: dict = {}
-    pic_filter = [SQL("sp.seq_id = s.id")]
 
     # Sort-by parameter
     # Note for review: I'm not sure I understand this non nullity constraint, but if so, shouldn't all sortby fields be added ?
@@ -90,25 +89,25 @@ def get_collections(request: CollectionsRequest) -> Collections:
         seq_filter.append(SQL("s.account_id = %(account)s"))
         seq_params["account"] = request.user_id
 
-    if request.user_filter is None or "status" not in request.user_filter.as_string(None):
+    user_filter_str = request.user_filter.as_string(None) if request.user_filter is not None else None
+    if user_filter_str is None or "status" not in user_filter_str:
         # 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 request.userOwnsAllCollections:
-            seq_filter.append(SQL("s.status = 'ready'"))
-            pic_filter.append(SQL("p.status = 'ready'"))
+            seq_filter.append(SQL("status = 'ready'"))
         else:
-            seq_filter.append(SQL("s.status != 'deleted'"))
+            seq_filter.append(SQL("status != 'deleted'"))
     else:
-        # else, even if there are status filter, we make sure not to show hidden pictures/sequence to non owner
-        if not request.userOwnsAllCollections:
-            seq_filter.append(SQL("s.status <> 'hidden'"))
-            pic_filter.append(SQL("p.status <> 'hidden'"))
+        if not request.userOwnsAllCollections and "'deleted'" not in user_filter_str:
+            # if there are status filter and we ask for deleted sequence, we also include hidden one and consider them as deleted
+            seq_filter.append(SQL("status <> 'hidden'"))
 
     status_field = None
     if request.userOwnsAllCollections:
         # only logged users can see detailed status
         status_field = SQL("s.status AS status")
     else:
-        status_field = SQL("CASE WHEN s.status = 'deleted' THEN s.status ELSE NULL END AS status")
+        # hidden sequence are marked as deleted, this way crawler can update their catalog
+        status_field = SQL("CASE WHEN s.status IN ('hidden', 'deleted') THEN 'deleted' ELSE s.status END AS status")
 
     # Datetime
     if request.min_dt is not None:
@@ -134,102 +133,90 @@ def get_collections(request: CollectionsRequest) -> Collections:
         seq_filter.append(SQL("s.inserted_at < %(created_before)s::timestamp with time zone"))
         seq_params["created_before"] = request.created_before
 
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn:
-        with conn.cursor() as cursor:
-            sqlSequencesRaw = SQL(
-                """
-                SELECT * FROM (
-                    SELECT
-                        s.id,
-                        s.status,
-                        s.metadata->>'title' AS name,
-                        s.inserted_at AS created,
-                        s.updated_at AS updated,
-                        ST_XMin(s.bbox) AS minx,
-                        ST_YMin(s.bbox) AS miny,
-                        ST_XMax(s.bbox) AS maxx,
-                        ST_YMax(s.bbox) AS maxy,
-                        accounts.name AS account_name,
-                        ST_X(ST_PointN(s.geom, 1)) AS x1,
-                        ST_Y(ST_PointN(s.geom, 1)) AS y1,
-                        {status},
-                        s.computed_capture_date AS datetime
-                    FROM sequences s
-                    LEFT JOIN accounts on s.account_id = accounts.id
-                    WHERE {filter}
-                    ORDER BY {order1}
-                    LIMIT {limit}
-                ) s
-                LEFT JOIN LATERAL (
-                    SELECT MIN(p.ts) as mints,
-                            MAX(p.ts) as maxts,
-                            COUNT(p.*) AS nbpic
-                    FROM sequences_pictures sp
-                    JOIN pictures p ON sp.pic_id = p.id
-                    WHERE {pic_filter}
-                    GROUP BY sp.seq_id
-                ) sub ON true
+    with utils.db.cursor(current_app, row_factory=dict_row) as cursor:
+        sqlSequencesRaw = SQL(
             """
+            SELECT
+                s.id,
+                s.status,
+                s.metadata->>'title' AS name,
+                s.inserted_at AS created,
+                s.updated_at AS updated,
+                ST_XMin(s.bbox) AS minx,
+                ST_YMin(s.bbox) AS miny,
+                ST_XMax(s.bbox) AS maxx,
+                ST_YMax(s.bbox) AS maxy,
+                accounts.name AS account_name,
+                s.account_id AS account_id,
+                ST_X(ST_PointN(ST_GeometryN(s.geom, 1), 1)) AS x1,
+                ST_Y(ST_PointN(ST_GeometryN(s.geom, 1), 1)) AS y1,
+                s.min_picture_ts AS mints,
+                s.max_picture_ts AS maxts,
+                s.nb_pictures AS nbpic,
+                {status},
+                s.computed_capture_date AS datetime,
+                s.user_agent,
+                ROUND(ST_Length(s.geom::geography)) / 1000 AS length_km
+            FROM sequences s
+            LEFT JOIN accounts on s.account_id = accounts.id
+            WHERE {filter}
+            ORDER BY {order1}
+            LIMIT {limit}
+        """
+        )
+        sqlSequences = sqlSequencesRaw.format(
+            filter=SQL(" AND ").join(seq_filter),
+            order1=request.sort_by.as_sql(),
+            limit=request.limit,
+            status=status_field,
+        )
+
+        # Different request if we want the last n sequences
+        #  Useful for paginating from last page to first
+        if request.pagination_filter and (
+            (
+                request.sort_by.fields[0].direction == SQLDirection.ASC
+                and request.pagination_filter.as_string(None).startswith(f"({request.sort_by.fields[0].field.sql_filter.as_string(None)} <")
             )
-            sqlSequences = sqlSequencesRaw.format(
+            or (
+                request.sort_by.fields[0].direction == SQLDirection.DESC
+                and request.pagination_filter.as_string(None).startswith(f"({request.sort_by.fields[0].field.sql_filter.as_string(None)} >")
+            )
+        ):
+            base_query = sqlSequencesRaw.format(
                 filter=SQL(" AND ").join(seq_filter),
-                order1=request.sort_by.as_sql(),
+                order1=request.sort_by.revert(),
                 limit=request.limit,
-                pic_filter=SQL(" AND ").join(pic_filter),
                 status=status_field,
             )
-
-            # Different request if we want the last n sequences
-            #  Useful for paginating from last page to first
-            if request.pagination_filter and (
-                (
-                    request.sort_by.fields[0].direction == SQLDirection.ASC
-                    and request.pagination_filter.as_string(None).startswith(
-                        f"({request.sort_by.fields[0].field.sql_filter.as_string(None)} <"
-                    )
-                )
-                or (
-                    request.sort_by.fields[0].direction == SQLDirection.DESC
-                    and request.pagination_filter.as_string(None).startswith(
-                        f"({request.sort_by.fields[0].field.sql_filter.as_string(None)} >"
-                    )
-                )
-            ):
-                base_query = sqlSequencesRaw.format(
-                    filter=SQL(" AND ").join(seq_filter),
-                    order1=request.sort_by.revert(),
-                    limit=request.limit,
-                    pic_filter=SQL(" AND ").join(pic_filter),
-                    status=status_field,
-                )
-                sqlSequences = SQL(
-                    """
-                    SELECT *
-                    FROM ({base_query}) s
-                    ORDER BY {order2}
+            sqlSequences = SQL(
                 """
-                ).format(
-                    order2=request.sort_by.as_sql(),
-                    base_query=base_query,
-                )
-
-            records = cursor.execute(sqlSequences, seq_params).fetchall()
-
-            query_bounds = None
-            for s in records:
-                first_order_val = s.get(request.sort_by.fields[0].field.stac)
-                if first_order_val is None:
-                    continue
-                if query_bounds is None:
-                    query_bounds = Bounds(first_order_val, first_order_val)
-                else:
-                    query_bounds.update(first_order_val)
-
-            return Collections(
-                collections=records,
-                query_first_order_bounds=query_bounds,
+                SELECT *
+                FROM ({base_query}) s
+                ORDER BY {order2}
+            """
+            ).format(
+                order2=request.sort_by.as_sql(),
+                base_query=base_query,
             )
 
+        records = cursor.execute(sqlSequences, seq_params).fetchall()
+
+        query_bounds = None
+        for s in records:
+            first_order_val = s.get(request.sort_by.fields[0].field.stac)
+            if first_order_val is None:
+                continue
+            if query_bounds is None:
+                query_bounds = Bounds(first_order_val, first_order_val)
+            else:
+                query_bounds.update(first_order_val)
+
+        return Collections(
+            collections=records,
+            query_first_order_bounds=query_bounds,
+        )
+
 
 def get_pagination_links(
     route: str,
@@ -387,17 +374,23 @@ def sort_collection(db, collectionId: UUID, sortby: CollectionSort):
 
         if usedDateField is None:
             raise errors.InvalidAPIUsage(
-                "Sort by file date is not possible on this sequence (no file date information available on pictures)",
+                _("Sort by file date is not possible on this sequence (no file date information available on pictures)"),
                 status_code=422,
             )
 
     for pm in picMetas:
         # Find value for wanted sort
         if sortby.order == CollectionSortOrder.GPS_DATE:
-            pm["sort"] = reader.decodeGPSDateTime(pm["exif"], "Exif.GPSInfo")[0]
+            if "ts_gps" in pm["metadata"]:
+                pm["sort"] = pm["metadata"]["ts_gps"]
+            else:
+                pm["sort"] = reader.decodeGPSDateTime(pm["exif"], "Exif.GPSInfo", _)[0]
         elif sortby.order == CollectionSortOrder.FILE_DATE:
-            assert usedDateField  # nullity has been checked before
-            pm["sort"] = reader.decodeDateTimeOriginal(pm["exif"], usedDateField)[0]
+            if "ts_camera" in pm["metadata"]:
+                pm["sort"] = pm["metadata"]["ts_camera"]
+            else:
+                assert usedDateField  # nullity has been checked before
+                pm["sort"] = reader.decodeDateTimeOriginal(pm["exif"], usedDateField, _)[0]
         elif sortby.order == CollectionSortOrder.FILE_NAME:
             pm["sort"] = pm["metadata"].get("originalFileName")
             if isFileNameNumeric:
@@ -406,7 +399,11 @@ def sort_collection(db, collectionId: UUID, sortby: CollectionSort):
         # Fail if sort value is missing
         if pm["sort"] is None:
             raise errors.InvalidAPIUsage(
-                f"Sort using {sortby} is not possible on this sequence, picture {pm['id']} is missing mandatory metadata",
+                _(
+                    "Sort using %(sort)s is not possible on this sequence, picture %(pic)s is missing mandatory metadata",
+                    sort=sortby,
+                    pic=pm["id"],
+                ),
                 status_code=422,
             )
 
@@ -480,3 +477,168 @@ def update_headings(
         ),  # lots of camera have heading set to 0 for unset heading, so we recompute the heading when it's 0 too, even if this could be a valid value
         {"seq": sequenceId, "diff": relativeHeading, "account": editingAccount},
     )
+
+
+def add_finalization_job(cursor, seqId: UUID):
+    """
+    Add a sequence finalization job in the queue.
+    If there is already a finalization job, do nothing (changing it might cause a deadlock, since a worker could be processing this job)
+    """
+    cursor.execute(
+        """INSERT INTO 
+        job_queue(sequence_id, task)
+        VALUES (%(seq_id)s, 'finalize')
+        ON CONFLICT (sequence_id) DO NOTHING""",
+        {"seq_id": seqId},
+    )
+
+
+def finalize(cursor, seqId: UUID, logger: logging.Logger = logging.getLogger()):
+    """
+    Finalize a sequence, by updating its status and computed fields.
+    """
+    with sentry_sdk.start_span(description="Finalizing sequence") as span:
+        span.set_data("sequence_id", seqId)
+        logger.debug(f"Finalizing sequence {seqId}")
+
+        with utils.time.log_elapsed(f"Finalizing sequence {seqId}"):
+            # Complete missing headings in pictures
+            update_headings(cursor, seqId)
+
+            # Change sequence database status in DB
+            # Also generates data in computed columns
+            cursor.execute(
+                """WITH
+aggregated_pictures AS (
+SELECT
+    sp.seq_id, 
+    MIN(p.ts::DATE) AS day,
+    ARRAY_AGG(DISTINCT TRIM(
+        CONCAT(p.metadata->>'make', ' ', p.metadata->>'model')
+    )) AS models,
+    ARRAY_AGG(DISTINCT p.metadata->>'type') AS types
+FROM sequences_pictures sp
+JOIN pictures p ON sp.pic_id = p.id
+WHERE sp.seq_id = %(seq)s
+GROUP BY sp.seq_id
+)
+UPDATE sequences
+SET
+status = CASE WHEN status = 'hidden' THEN 'hidden'::sequence_status ELSE 'ready'::sequence_status END, -- we don't want to change status if it's hidden
+geom = compute_sequence_geom(id),
+bbox = compute_sequence_bbox(id),
+computed_type = CASE WHEN array_length(types, 1) = 1 THEN types[1] ELSE NULL END,
+computed_model = CASE WHEN array_length(models, 1) = 1 THEN models[1] ELSE NULL END,
+computed_capture_date = day
+FROM aggregated_pictures
+WHERE id = %(seq)s
+            """,
+                {"seq": seqId},
+            )
+
+            logger.info(f"Sequence {seqId} is ready")
+
+
+def update_pictures_grid() -> Optional[datetime.datetime]:
+    """Refreshes the pictures_grid materialized view for an up-to-date view of pictures availability on map.
+
+    Parameters
+    ----------
+    db : psycopg.Connection
+            Database connection
+
+    Returns
+    -------
+    bool : True if the view has been updated else False
+    """
+    from geovisio.utils import db
+
+    logger = logging.getLogger("geovisio.picture_grid")
+
+    # get a connection outside of the connection pool in order to avoid
+    # the default statement timeout as this query can be very long
+    with db.long_queries_conn(current_app) as conn, conn.transaction():
+        try:
+            conn.execute("SELECT refreshed_at FROM refresh_database FOR UPDATE NOWAIT").fetchone()
+        except psycopg.errors.LockNotAvailable:
+            logger.info("Database refresh already in progress, nothing to do")
+            return False
+
+        with sentry_sdk.start_span(description="Refreshing database"):
+            with utils.time.log_elapsed("Refreshing database", logger=logger):
+                logger.info("Refreshing database")
+                conn.execute("UPDATE refresh_database SET refreshed_at = NOW()")
+                conn.execute("REFRESH MATERIALIZED VIEW CONCURRENTLY pictures_grid")
+
+    return True
+
+
+def delete_collection(collectionId: UUID, account: Optional[Account]) -> int:
+    """
+    Mark a collection as deleted and delete all it's pictures.
+
+    Note that since the deletion as asynchronous, some workers need to be run in order for the deletion to be effective.
+    """
+    with db.conn(current_app) as conn:
+        with conn.transaction(), conn.cursor() as cursor:
+            sequence = cursor.execute(
+                "SELECT status, account_id FROM sequences WHERE id = %s AND status != 'deleted'", [collectionId]
+            ).fetchone()
+
+            # sequence not found
+            if not sequence:
+                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(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 job_queue(picture_id, task)
+                    SELECT pic_id, 'delete' FROM picWithoutOtherSeq
+                    ON CONFLICT (picture_id) DO UPDATE SET task = 'delete'
+            """,
+                {"seq": collectionId},
+            ).rowcount
+            # if there was a finalize task for this collection in the queue, we remove it, it's useless
+            cursor.execute("""DELETE FROM job_queue WHERE sequence_id = %(seq)s""", {"seq": collectionId})
+
+            # 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])
+            return nb_updated