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

geovisio/utils/semantics.py

@@ -22,6 +22,7 @@ class EntityType(Enum):
     pic = "picture_id"
     seq = "sequence_id"
     annotation = "annotation_id"
+    upload_set = "upload_set_id"
 
 
 @dataclass
@@ -37,10 +38,12 @@ class Entity:
                 return Identifier("sequences_semantics")
             case EntityType.annotation:
                 return Identifier("annotations_semantics")
+            case EntityType.upload_set:
+                return Identifier("upload_sets_semantics")
             case _:
                 raise ValueError(f"Unknown entity type: {self.type}")
 
-    def get_history_table(self) -> Identifier:
+    def get_history_table(self) -> Optional[Identifier]:
         match self.type:
             case EntityType.pic:
                 return Identifier("pictures_semantics_history")
@@ -48,6 +51,8 @@ class Entity:
                 return Identifier("sequences_semantics_history")
             case EntityType.annotation:
                 return Identifier("pictures_semantics_history")
+            case EntityType.upload_set:
+                return None
             case _:
                 raise ValueError(f"Unknown entity type: {self.type}")
 
@@ -77,14 +82,34 @@ AND ({filter})"""
                 params,
             )
         if tag_to_add:
+            fields = [Identifier(entity.type.value), Identifier("key"), Identifier("value")]
+            if entity.type == EntityType.upload_set:
+                # upload_set semantics have no history, the account is directly stored in the table
+                fields.append(Identifier("account_id"))
+
             with cursor.copy(
                 SQL("COPY {table} ({fields}) FROM STDIN").format(
                     table=table_name,
-                    fields=SQL(",").join([Identifier(entity.type.value), Identifier("key"), Identifier("value")]),
+                    fields=SQL(",").join(fields),
                 )
             ) as copy:
                 for tag in tag_to_add:
-                    copy.write_row((entity.id, tag.key, tag.value))
+                    row = [entity.id, tag.key, tag.value]
+                    if entity.type == EntityType.upload_set:
+                        row.append(account)
+                    copy.write_row(row)
+        if tag_to_delete and entity.type == EntityType.annotation and not tag_to_add:
+            # if tags have been deleted, we check if some annotations are now empty and need to be deleted
+            cursor.execute(
+                """DELETE FROM annotations
+WHERE id  = %(annotation_id)s AND 
+(
+    SELECT count(*) AS nb_semantics 
+    FROM annotations_semantics 
+    WHERE annotation_id = %(annotation_id)s
+) = 0""",
+                {"annotation_id": entity.id},
+            )
         if tag_to_add or tag_to_delete:
             # we track the history changes of the semantic tags
             track_semantic_history(cursor, entity, actions, account, annotation)
@@ -100,6 +125,10 @@ class SemanticTagUpdateOnAnnotation(SemanticTagUpdate):
 
 
 def track_semantic_history(cursor: Cursor, entity: Entity, actions: List[SemanticTagUpdate], account: UUID, annotation):
+    history_table = entity.get_history_table()
+    if history_table is None:
+        # no history for upload_set semantics
+        return
     params = {
         "account_id": account,
     }

geovisio/utils/sentry.py

@@ -73,7 +73,7 @@ def _wrap_cursor_execute(f):
 
 
 class FileSystemIntegration(Integration):
-    """Add metrics to the 2 most usefull filesystem, the 'os file' filesystem and the s3 filesystem"""
+    """Add metrics to the 2 most useful filesystem, the 'os file' filesystem and the s3 filesystem"""
 
     identifier = "filesystem"
 

geovisio/utils/sequences.py

@@ -1,20 +1,17 @@
-from operator import ne
-from click import Option
-from numpy import sort
 import psycopg
-from flask import current_app, g, url_for
+from flask import current_app, url_for
 from flask_babel import gettext as _
 from psycopg.types.json import Jsonb
 from psycopg.sql import SQL, Composable
 from psycopg.rows import dict_row
 from dataclasses import dataclass, field
-from typing import Any, List, Dict, Optional
+from typing import Any, List, Dict, Optional, Tuple
 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, SortByField
+from geovisio.utils.auth import Account, get_current_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, utils
@@ -22,11 +19,22 @@ import logging
 import sentry_sdk
 
 
-def createSequence(metadata, accountId, user_agent: Optional[str] = None) -> UUID:
+def createSequence(
+    metadata, accountId, user_agent: Optional[str] = None, upload_set_id: Optional[UUID] = None, visibility: Optional[str] = None
+):
     with db.execute(
         current_app,
-        "INSERT INTO sequences(account_id, metadata, user_agent) VALUES(%s, %s, %s) RETURNING id",
-        [accountId, Jsonb(metadata), user_agent],
+        """INSERT INTO sequences(account_id, metadata, user_agent, upload_set_id, visibility)
+VALUES(%(account_id)s, %(metadata)s, %(user_agent)s, %(upload_set_id)s, 
+    COALESCE(%(visibility)s, (SELECT default_visibility FROM accounts WHERE id = %(account_id)s), (SELECT default_visibility FROM configurations LIMIT 1)))
+RETURNING id""",
+        {
+            "account_id": accountId,
+            "metadata": Jsonb(metadata),
+            "user_agent": user_agent,
+            "upload_set_id": upload_set_id,
+            "visibility": visibility,
+        },
     ) as r:
         seqId = r.fetchone()
         if seqId is None:
@@ -41,7 +49,7 @@ STAC_FIELD_MAPPINGS = {
         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"),
+        FieldMapping(sql_column=SQL("visibility"), stac="visibility"),
         FieldMapping(sql_column=SQL("id"), stac="id"),
     ]
 }
@@ -55,7 +63,7 @@ class Collections:
     """
 
     collections: List[Dict[Any, Any]] = field(default_factory=lambda: [])
-    # Bounds of the field used by the first field of the `ORDER BY` (usefull especially for pagination)
+    # Bounds of the field used by the first field of the `ORDER BY` (useful especially for pagination)
     query_bounds: Optional[Bounds] = None
 
 
@@ -72,77 +80,90 @@ class CollectionsRequest:
     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
+    show_deleted: bool = False
+    """Do we want to return deleted collections that respect the other filters in a separate field"""
 
     def filters(self):
         return [f for f in (self.user_filter, self.pagination_filter) if f is not None]
 
+    def to_sql_filters_and_params_without_permissions(self) -> Tuple[List[Composable], dict]:
+        """Transform the request to a list of SQL filters and a dict of parameters
+        Note: the filters do not contain any filter on permission/status, they need to be added afterward"""
+        seq_filter: List[Composable] = []
+        seq_params: dict = {}
+
+        # Sort-by parameter
+        seq_filter.append(SQL("{field} IS NOT NULL").format(field=self.sort_by.fields[0].field.sql_filter))
+        seq_filter.extend(self.filters())
+
+        if self.user_id is not None:
+            seq_filter.append(SQL("s.account_id = %(account)s"))
+            seq_params["account"] = self.user_id
+
+        # Datetime
+        if self.min_dt is not None:
+            seq_filter.append(SQL("s.computed_capture_date >= %(cmindate)s::date"))
+            seq_params["cmindate"] = self.min_dt
+        if self.max_dt is not None:
+            seq_filter.append(SQL("s.computed_capture_date <= %(cmaxdate)s::date"))
+            seq_params["cmaxdate"] = self.max_dt
+
+        if self.bbox is not None:
+            seq_filter.append(SQL("ST_Intersects(s.geom, ST_MakeEnvelope(%(minx)s, %(miny)s, %(maxx)s, %(maxy)s, 4326))"))
+            seq_params["minx"] = self.bbox.minx
+            seq_params["miny"] = self.bbox.miny
+            seq_params["maxx"] = self.bbox.maxx
+            seq_params["maxy"] = self.bbox.maxy
+
+        # Created after/before
+        if self.created_after is not None:
+            seq_filter.append(SQL("s.inserted_at > %(created_after)s::timestamp with time zone"))
+            seq_params["created_after"] = self.created_after
+
+        if self.created_before:
+            seq_filter.append(SQL("s.inserted_at < %(created_before)s::timestamp with time zone"))
+            seq_params["created_before"] = self.created_before
+
+        return seq_filter, seq_params
+
 
 def get_collections(request: CollectionsRequest) -> Collections:
     # Check basic parameters
-    seq_filter: List[Composable] = []
-    seq_params: dict = {}
-
-    # 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 ?
-    # for s in request.sort_by.fields:
-    #     sqlConditionsSequences.append(SQL("{field} IS NOT NULL").format(field=s.field.sql_filter))
-    seq_filter.append(SQL("{field} IS NOT NULL").format(field=request.sort_by.fields[0].field.sql_filter))
-    seq_filter.extend(request.filters())
-
-    if request.user_id is not None:
-        seq_filter.append(SQL("s.account_id = %(account)s"))
-        seq_params["account"] = request.user_id
-
-    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
+    seq_filter, seq_params = request.to_sql_filters_and_params_without_permissions()
+
+    # Only the owner of an account can view sequences not 'ready' (and we don't want to show the deleted even to the owner)
+    account_to_query = get_current_account()
+    if not request.show_deleted:
         if not request.userOwnsAllCollections:
             seq_filter.append(SQL("status = 'ready'"))
         else:
             seq_filter.append(SQL("status != 'deleted'"))
     else:
-        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'"))
+        seq_filter.append(SQL("status IN ('deleted', 'ready')"))
+
+    seq_params["account_to_query"] = account_to_query.id if account_to_query is not None else None
+
+    if account_to_query is not None and account_to_query.can_see_all():
+        # if the account querying is an admin, we also do not filter, and we consider that the admin can see all sequences
+        visible_by_user = SQL("TRUE")
+    elif request.show_deleted:
+        # if asked to show deletion, we do not filter using the rights, but we'll output only the id of the non visible sequence
+        visible_by_user = SQL("is_sequence_visible_by_user(s, %(account_to_query)s)")
+    else:
+        visible_by_user = SQL("is_sequence_visible_by_user(s, %(account_to_query)s)")
+        seq_filter.append(SQL("is_sequence_visible_by_user(s, %(account_to_query)s)"))
 
-    status_field = None
+    status_field = SQL("s.status AS status")
     if request.userOwnsAllCollections:
-        # only logged users can see detailed status
-        status_field = SQL("s.status AS status")
+        # only show detailed visibility if the user querying owns all the collections (so on /api/users/me/collection)
+        visibility_field = SQL("s.visibility")
     else:
-        # 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:
-        seq_filter.append(SQL("s.computed_capture_date >= %(cmindate)s::date"))
-        seq_params["cmindate"] = request.min_dt
-    if request.max_dt is not None:
-        seq_filter.append(SQL("s.computed_capture_date <= %(cmaxdate)s::date"))
-        seq_params["cmaxdate"] = request.max_dt
-
-    if request.bbox is not None:
-        seq_filter.append(SQL("ST_Intersects(s.geom, ST_MakeEnvelope(%(minx)s, %(miny)s, %(maxx)s, %(maxy)s, 4326))"))
-        seq_params["minx"] = request.bbox.minx
-        seq_params["miny"] = request.bbox.miny
-        seq_params["maxx"] = request.bbox.maxx
-        seq_params["maxy"] = request.bbox.maxy
-
-    # Created after/before
-    if request.created_after is not None:
-        seq_filter.append(SQL("s.inserted_at > %(created_after)s::timestamp with time zone"))
-        seq_params["created_after"] = request.created_after
-
-    if request.created_before:
-        seq_filter.append(SQL("s.inserted_at < %(created_before)s::timestamp with time zone"))
-        seq_params["created_before"] = request.created_before
+        visibility_field = SQL("NULL AS visibility")
 
     with utils.db.cursor(current_app, row_factory=dict_row) as cursor:
         sqlSequencesRaw = SQL(
-            """
-            SELECT
+            """SELECT
                 s.id,
-                s.status,
                 s.metadata->>'title' AS name,
                 s.inserted_at AS created,
                 s.updated_at AS updated,
@@ -157,33 +178,37 @@ def get_collections(request: CollectionsRequest) -> Collections:
                 s.min_picture_ts AS mints,
                 s.max_picture_ts AS maxts,
                 s.nb_pictures AS nbpic,
+                s.upload_set_id,
                 {status},
+                {visibility},
+                {visible_by_user} as is_sequence_visible_by_user,
                 s.computed_capture_date AS datetime,
                 s.user_agent,
                 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 accounts on s.account_id = accounts.id
             LEFT JOIN (
-                    SELECT sequence_id, json_agg(json_strip_nulls(json_build_object(
-                        'key', key,
-                        'value', value
-                    )) ORDER BY key, value) AS semantics
-                    FROM sequences_semantics
-                    GROUP BY sequence_id
-                ) t ON t.sequence_id = s.id
+                SELECT sequence_id, json_agg(json_strip_nulls(json_build_object(
+                    'key', key,
+                    'value', value
+                )) ORDER BY key, value) AS semantics
+                FROM sequences_semantics
+                GROUP BY sequence_id
+            ) seq_sem ON seq_sem.sequence_id = s.id
             WHERE {filter}
             ORDER BY {order1}
-            LIMIT {limit}
-        """
+            LIMIT {limit}"""
         )
         sqlSequences = sqlSequencesRaw.format(
             filter=SQL(" AND ").join(seq_filter),
             order1=request.sort_by.as_sql(),
             limit=request.limit,
             status=status_field,
+            visibility=visibility_field,
+            visible_by_user=visible_by_user,
         )
 
         # Different request if we want the last n sequences
@@ -200,13 +225,13 @@ def get_collections(request: CollectionsRequest) -> Collections:
                     order1=request.sort_by.revert(),
                     limit=request.limit,
                     status=status_field,
+                    visibility=visibility_field,
+                    visible_by_user=visible_by_user,
                 )
                 sqlSequences = SQL(
-                    """
-                    SELECT *
-                    FROM ({base_query}) s
-                    ORDER BY {order2}
-                """
+                    """SELECT *
+FROM ({base_query}) s
+ORDER BY {order2}"""
                 ).format(
                     order2=request.sort_by.as_sql(),
                     base_query=base_query,
@@ -253,6 +278,7 @@ def get_dataset_bounds(
     sortBy: SortBy,
     additional_filters: Optional[SQL] = None,
     additional_filters_params: Optional[Dict[str, Any]] = None,
+    account_to_query_id: Optional[UUID] = None,
 ) -> Optional[Bounds]:
     """Computes the dataset bounds from the sortBy field (using lexicographic order)
 
@@ -277,7 +303,7 @@ SELECT * FROM min_bounds, max_bounds;
                 reverse_fields=sortBy.revert_non_aliased_sql(),
                 filters=additional_filters or SQL("TRUE"),
             ),
-            params=additional_filters_params or {},
+            params=(additional_filters_params or {}) | {"account_to_query": account_to_query_id},
         ).fetchone()
         if not sql_bounds:
             return None
@@ -322,6 +348,7 @@ def get_pagination_links(
     datasetBounds: Bounds,
     dataBounds: Optional[Bounds],
     additional_filters: Optional[str],
+    showDeleted: Optional[bool] = None,
 ) -> List:
     """Computes STAC links to handle pagination"""
 
@@ -336,7 +363,7 @@ def get_pagination_links(
             {
                 "rel": "first",
                 "type": "application/json",
-                "href": url_for(route, _external=True, **routeArgs, filter=additional_filters, sortby=sortby),
+                "href": url_for(route, _external=True, **routeArgs, filter=additional_filters, sortby=sortby, show_deleted=showDeleted),
             }
         )
 
@@ -351,6 +378,7 @@ def get_pagination_links(
                     _external=True,
                     **routeArgs,
                     sortby=sortby,
+                    show_deleted=showDeleted,
                     filter=additional_filters,
                     page=page_filter,
                 ),
@@ -369,6 +397,7 @@ def get_pagination_links(
                     _external=True,
                     **routeArgs,
                     sortby=sortby,
+                    show_deleted=showDeleted,
                     filter=additional_filters,
                     page=next_filter,
                 ),
@@ -387,6 +416,7 @@ def get_pagination_links(
                     _external=True,
                     **routeArgs,
                     sortby=sortby,
+                    show_deleted=showDeleted,
                     filter=additional_filters,
                     page=last_filter,
                 ),
@@ -427,7 +457,7 @@ def sort_collection(db, collectionId: UUID, sortby: CollectionSort):
     """
     Sort a collection by a given parameter
 
-    Note: the transaction is not commited at the end, you need to commit it or use an autocommit connection
+    Note: the transaction is not committed at the end, you need to commit it or use an autocommit connection
     """
 
     # Remove existing order, and keep list of pictures IDs
@@ -519,8 +549,8 @@ def update_headings(
     db,
     sequenceId: UUID,
     editingAccount: Optional[UUID] = None,
-    relativeHeading: int = 0,
-    updateOnlyMissing: bool = True,
+    relativeHeading: Optional[int] = None,
+    updateOnlyMissing: Optional[bool] = None,
 ):
     """Defines pictures heading according to sequence path.
     Database is not committed in this function, to make entry definitively stored
@@ -532,27 +562,42 @@ def update_headings(
             Database connection
     sequenceId : uuid
             The sequence's uuid, as stored in the database
-    relativeHeading : int
+    relativeHeading : Optional[int]
             Camera relative orientation compared to path, in degrees clockwise.
             Example: 0° = looking forward, 90° = looking to right, 180° = looking backward, -90° = looking left.
-    updateOnlyMissing : bool
+            If not provided, will first use the relative_heading stored in the sequence's metadata, then the relative_heading of its upload_set (if if none is set, default to 0).
+    updateOnlyMissing : Optional[bool]
             If true, doesn't change existing heading values in database
+            if not provided, we check if some relative heading has been set (either in the sequence or in its upload_set), and if so, we recompute all
     """
-
     db.execute(
         SQL(
-            """
-		WITH h AS (
+            """WITH
+        relative_heading AS (
+            SELECT COALESCE(
+                    %(relativeHeading)s, 
+                    (SELECT (metadata->>'relative_heading')::int FROM sequences WHERE id = %(seq)s),
+                    (SELECT upload_sets.relative_heading FROM sequences JOIN upload_sets ON sequences.upload_set_id = upload_sets.id WHERE sequences.id = %(seq)s),
+                    0
+            ) AS heading,
+            COALESCE(
+                %(update_only_missing)s,
+                (SELECT metadata->'relative_heading' IS NULL FROM sequences WHERE id = %(seq)s and metadata ? 'relative_heading'),
+                (SELECT upload_sets.relative_heading IS NULL FROM sequences JOIN upload_sets ON sequences.upload_set_id = upload_sets.id WHERE sequences.id = %(seq)s)
+            ) AS update_only_missing
+        )
+        , h AS (
 			SELECT
 				p.id,
                 p.heading AS old_heading,
 				CASE
 					WHEN LEAD(sp.rank) OVER othpics IS NULL AND LAG(sp.rank) OVER othpics IS NULL
-						THEN NULL
+                        -- if there is a single picture, we take the relative heading directly
+						THEN (SELECT heading FROM relative_heading)
 					WHEN LEAD(sp.rank) OVER othpics IS NULL
-						THEN (360 + FLOOR(DEGREES(ST_Azimuth(LAG(p.geom) OVER othpics, p.geom)))::int + (%(diff)s %% 360)) %% 360
+						THEN (360 + FLOOR(DEGREES(ST_Azimuth(LAG(p.geom) OVER othpics, p.geom)))::int + ((SELECT heading FROM relative_heading) %% 360)) %% 360
 					ELSE
-						(360 + FLOOR(DEGREES(ST_Azimuth(p.geom, LEAD(p.geom) OVER othpics)))::int + (%(diff)s %% 360)) %% 360
+						(360 + FLOOR(DEGREES(ST_Azimuth(p.geom, LEAD(p.geom) OVER othpics)))::int + ((SELECT heading FROM relative_heading) %% 360)) %% 360
 				END AS heading
 			FROM pictures p
 			JOIN sequences_pictures sp ON sp.pic_id = p.id AND sp.seq_id = %(seq)s
@@ -561,13 +606,15 @@ def update_headings(
 		UPDATE pictures p
 		SET heading = h.heading, heading_computed = true {editing_account}
 		FROM h
-		WHERE h.id = p.id {update_missing}
+		WHERE h.id = p.id AND (
+            (SELECT NOT update_only_missing FROM relative_heading) 
+            OR (p.heading IS NULL OR p.heading = 0 OR p.heading_computed) -- # 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
+        )
 		"""
         ).format(
-            update_missing=SQL(" AND (p.heading IS NULL OR p.heading = 0 OR p.heading_computed)") if updateOnlyMissing else SQL(""),
             editing_account=SQL(", last_account_to_edit = %(account)s") if editingAccount is not None else SQL(""),
-        ),  # 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},
+        ),
+        {"seq": sequenceId, "relativeHeading": relativeHeading, "account": editingAccount, "update_only_missing": updateOnlyMissing},
     )
 
 
@@ -593,14 +640,13 @@ def finalize(cursor, seqId: UUID, logger: logging.Logger = logging.getLogger()):
         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)
+        # Complete missing headings in pictures
+        update_headings(cursor, seqId)
 
-            # Change sequence database status in DB
-            # Also generates data in computed columns
-            cursor.execute(
-                """WITH
+        # Change sequence database status in DB
+        # Also generates data in computed columns
+        cursor.execute(
+            """WITH
 aggregated_pictures AS (
 SELECT
     sp.seq_id, 
@@ -618,7 +664,7 @@ 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
+status = 'ready'::sequence_status,
 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,
@@ -629,13 +675,13 @@ computed_gps_accuracy = gpsacc
 FROM aggregated_pictures
 WHERE id = %(seq)s
             """,
-                {"seq": seqId},
-            )
+            {"seq": seqId},
+        )
 
-            logger.info(f"Sequence {seqId} is ready")
+        logger.info(f"Sequence {seqId} is ready")
 
 
-def update_pictures_grid() -> Optional[datetime.datetime]:
+def update_pictures_grid() -> bool:
     """Refreshes the pictures_grid materialized view for an up-to-date view of pictures availability on map.
 
     Parameters
@@ -686,7 +732,7 @@ def delete_collection(collectionId: UUID, account: Optional[Account]) -> int:
                 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]):
+            if account is not None and not account.can_edit_collection(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")