geovisio 2.8.1__py3-none-any.whl → 2.10.0__py3-none-any.whl

geovisio/web/items.py

@@ -6,13 +6,18 @@ from typing import Dict, List, Optional, Any
 from urllib.parse import unquote
 from psycopg.types.json import Jsonb
 from pydantic import BaseModel, ConfigDict, ValidationError, field_validator, model_validator
+from shapely import intersects
 from werkzeug.datastructures import MultiDict
 from uuid import UUID
 from geovisio import errors, utils
 from geovisio.utils import auth, db
+from geovisio.utils.cql2 import parse_search_filter
 from geovisio.utils.params import validation_error
 from geovisio.utils.pictures import cleanupExif
-from geovisio.utils.semantics import SemanticTagUpdate, Entity, EntityType, update_tags
+from geovisio.utils.semantics import Entity, EntityType, update_tags
+from geovisio.utils.items import SortableItemField, SortBy, ItemSortByField
+from geovisio.utils.tags import SemanticTagUpdate
+from geovisio.utils.auth import Account
 from geovisio.web.params import (
     as_latitude,
     as_longitude,
@@ -20,12 +25,13 @@ from geovisio.web.params import (
     parse_datetime,
     parse_datetime_interval,
     parse_bbox,
+    parse_item_sortby,
     parse_list,
     parse_lonlat,
     parse_distance_range,
     parse_picture_heading,
 )
-from geovisio.utils.fields import Bounds
+from geovisio.utils.fields import Bounds, SQLDirection
 import hashlib
 from psycopg.rows import dict_row
 from psycopg.sql import SQL
@@ -49,7 +55,7 @@ import math
 bp = Blueprint("stac_items", __name__, url_prefix="/api")
 
 
-def dbPictureToStacItem(seqId, dbPic):
+def dbPictureToStacItem(dbPic):
     """Transforms a picture extracted from database into a STAC Item
 
     Parameters
@@ -67,6 +73,7 @@ def dbPictureToStacItem(seqId, dbPic):
 
     sensorDim = None
     visibleArea = None
+    seqId = str(dbPic["seq_id"])
     if dbPic["metadata"].get("crop") is not None:
         sensorDim = [dbPic["metadata"]["crop"].get("fullWidth"), dbPic["metadata"]["crop"].get("fullHeight")]
         visibleArea = [
@@ -112,7 +119,7 @@ def dbPictureToStacItem(seqId, dbPic):
                     "datetime": dbTsToStac(dbPic["ts"]),
                     "datetimetz": dbTsToStacTZ(dbPic["ts"], dbPic["metadata"].get("tz")),
                     "created": dbTsToStac(dbPic["inserted_at"]),
-                    # TODO : add "updated" TS for last edit time of metadata
+                    "updated": dbTsToStac(dbPic["updated_at"]),
                     "license": current_app.config["API_PICTURES_LICENSE_SPDX_ID"],
                     "view:azimuth": dbPic["heading"],
                     "pers:interior_orientation": (
@@ -138,6 +145,7 @@ def dbPictureToStacItem(seqId, dbPic):
                     "pers:roll": dbPic["metadata"].get("roll"),
                     "geovisio:status": dbPic.get("status"),
                     "geovisio:producer": dbPic["account_name"],
+                    "geovisio:rank_in_collection": dbPic["rank"],
                     "original_file:size": dbPic["metadata"].get("originalFileSize"),
                     "original_file:name": dbPic["metadata"].get("originalFileName"),
                     "panoramax:horizontal_pixel_density": dbPic.get("h_pixel_density"),
@@ -145,7 +153,9 @@ def dbPictureToStacItem(seqId, dbPic):
                     "geovisio:thumbnail": _getThumbJpgPictureURL(dbPic["id"], dbPic.get("status")),
                     "exif": removeNoneInDict(cleanupExif(dbPic["exif"])),
                     "quality:horizontal_accuracy": float("{:.1f}".format(dbPic["gps_accuracy_m"])) if dbPic.get("gps_accuracy_m") else None,
-                    "semantics": dbPic["semantics"] if "semantics" in dbPic else None,
+                    "semantics": [s for s in dbPic.get("semantics") or [] if s],
+                    "annotations": [a for a in dbPic.get("annotations") or [] if a],
+                    "collection": {"semantics": dbPic["sequence_semantics"]} if "sequence_semantics" in dbPic else None,
                 }
             ),
             "links": cleanNoneInList(
@@ -419,7 +429,7 @@ def getCollectionItems(collectionId):
                     params={"id": withPicture, "seq": collectionId},
                 ).fetchone()
                 if not pic:
-                    raise errors.InvalidAPIUsage(_("Picture with id %(p)s does not exists", p=withPicture))
+                    raise errors.InvalidAPIUsage(_("Picture with id %(p)s does not exist", p=withPicture))
                 rank = get_first_rank_of_page(pic["rank"], limit)
 
                 filters.append(SQL("rank >= %(start_after_rank)s"))
@@ -428,28 +438,21 @@ def getCollectionItems(collectionId):
             query = SQL(
                 """
                 SELECT
-                    p.id, p.ts, p.heading, p.metadata, p.inserted_at, p.status,
+                    p.id, p.ts, p.heading, p.metadata, p.inserted_at, p.updated_at, p.status,
                     ST_AsGeoJSON(p.geom)::json AS geojson,
                     a.name AS account_name,
                     p.account_id AS account_id,
-                    sp.rank, p.exif, p.gps_accuracy_m, p.h_pixel_density,
+                    sp.seq_id, sp.rank, p.exif, p.gps_accuracy_m, p.h_pixel_density,
                     CASE WHEN LAG(p.status) OVER othpics = 'ready' THEN LAG(p.id) OVER othpics END AS prevpic,
                     CASE WHEN LAG(p.status) OVER othpics = 'ready' THEN ST_AsGeoJSON(LAG(p.geom) OVER othpics)::json END AS prevpicgeojson,
                     CASE WHEN LEAD(p.status) OVER othpics = 'ready' THEN LEAD(p.id) OVER othpics END AS nextpic,
                     CASE WHEN LEAD(p.status) OVER othpics = 'ready' THEN ST_AsGeoJSON(LEAD(p.geom) OVER othpics)::json END AS nextpicgeojson,
-                    t.semantics
+                    get_picture_semantics(p.id) as semantics,
+                    get_picture_annotations(p.id) as annotations
                 FROM sequences_pictures sp
                 JOIN pictures p ON sp.pic_id = p.id
                 JOIN accounts a ON a.id = p.account_id
                 JOIN sequences s ON s.id = sp.seq_id
-                LEFT JOIN (
-                    SELECT picture_id, json_agg(json_strip_nulls(json_build_object(
-                        'key', key,
-                        'value', value
-                    ))) AS semantics
-                    FROM pictures_semantics
-                    GROUP BY picture_id
-                ) t ON t.picture_id = p.id
                 WHERE
                     {filter}
                 WINDOW othpics AS (PARTITION BY sp.seq_id ORDER BY sp.rank)
@@ -460,15 +463,14 @@ def getCollectionItems(collectionId):
 
             records = cursor.execute(query, params)
 
-            bounds: Optional[Bounds] = None
             items = []
+            first_rank, last_rank = None, None
             for dbPic in records:
-                if not bounds:
-                    bounds = Bounds(min=dbPic["rank"], max=dbPic["rank"])
-                else:
-                    bounds.update(dbPic["rank"])
-
-                items.append(dbPictureToStacItem(collectionId, dbPic))
+                if first_rank is None:
+                    first_rank = dbPic["rank"]
+                last_rank = dbPic["rank"]
+                items.append(dbPictureToStacItem(dbPic))
+            bounds = Bounds(first=first_rank, last=last_rank) if records else None
 
             links = [
                 get_root_link(),
@@ -491,8 +493,8 @@ def getCollectionItems(collectionId):
             ]
 
             if paginated and items and bounds:
-                if bounds.min:
-                    has_item_before = bounds.min > seqMeta["min_rank"]
+                if bounds.first:
+                    has_item_before = bounds.first > seqMeta["min_rank"]
                     if has_item_before:
                         links.append(
                             {
@@ -504,7 +506,7 @@ def getCollectionItems(collectionId):
                         # Previous page link
                         #   - If limit is set, rank is current - limit -1
                         #   - If no limit is set, rank is 0 (none)
-                        prevRank = bounds.min - limit - 1 if limit is not None else 0
+                        prevRank = bounds.first - limit - 1 if limit is not None else 0
                         if prevRank < 1:
                             prevRank = None
                         links.append(
@@ -521,7 +523,7 @@ def getCollectionItems(collectionId):
                             }
                         )
 
-                has_item_after = bounds.max < seqMeta["max_rank"]
+                has_item_after = bounds.last < seqMeta["max_rank"]
                 if has_item_after:
                     links.append(
                         {
@@ -532,7 +534,7 @@ def getCollectionItems(collectionId):
                                 _external=True,
                                 collectionId=collectionId,
                                 limit=limit,
-                                startAfterRank=bounds.max,
+                                startAfterRank=bounds.last,
                             ),
                         }
                     )
@@ -543,10 +545,10 @@ def getCollectionItems(collectionId):
 
                     lastPageRank = startAfterRank
                     if limit is not None:
-                        if seqMeta["max_rank"] > bounds.max:
+                        if seqMeta["max_rank"] > bounds.last:
                             lastPageRank = seqMeta["max_rank"] - limit
-                            if lastPageRank < bounds.max:
-                                lastPageRank = bounds.max
+                            if lastPageRank < bounds.last:
+                                lastPageRank = bounds.last
 
                     links.append(
                         {
@@ -573,26 +575,8 @@ def getCollectionItems(collectionId):
             )
 
 
-def _getPictureItemById(collectionId, itemId):
-    """Get a picture metadata by its ID and collection ID
-
-    ---
-    tags:
-        - Pictures
-    parameters:
-        - name: collectionId
-          in: path
-          description: ID of collection to retrieve
-          required: true
-          schema:
-            type: string
-        - name: itemId
-          in: path
-          description: ID of item to retrieve
-          required: true
-          schema:
-            type: string
-    """
+def _getPictureItemById(itemId: UUID, account: Optional[Account]):
+    """Get a picture metadata by its ID"""
     with current_app.pool.connection() as conn:
         with conn.cursor(row_factory=dict_row) as cursor:
             # Check if there is a logged user
@@ -601,26 +585,22 @@ def _getPictureItemById(collectionId, itemId):
 
             # Get rank + position of wanted picture
             record = cursor.execute(
-                """
+                """WITH seq AS (
+                    SELECT seq_id FROM sequences_pictures WHERE pic_id = %(pic)s LIMIT 1
+                )
                 SELECT
-                    p.id, sp.rank, ST_AsGeoJSON(p.geom)::json AS geojson, p.heading, p.ts, p.metadata,
-                    p.inserted_at, p.status, accounts.name AS account_name,
+                    p.id, sp.seq_id, sp.rank, ST_AsGeoJSON(p.geom)::json AS geojson, p.heading, p.ts, p.metadata,
+                    p.inserted_at, p.updated_at, p.status, accounts.name AS account_name,
                     p.account_id AS account_id,
                     spl.prevpic, spl.prevpicgeojson, spl.nextpic, spl.nextpicgeojson, p.exif,
                     relp.related_pics, p.gps_accuracy_m, p.h_pixel_density,
-                    t.semantics
+                    get_picture_semantics(p.id) as semantics,
+                    get_picture_annotations(p.id) as annotations,
+                    COALESCE(seq_sem.semantics, '[]'::json) AS sequence_semantics
                 FROM pictures p
                 JOIN sequences_pictures sp ON sp.pic_id = p.id
                 JOIN accounts ON p.account_id = accounts.id
                 JOIN sequences s ON sp.seq_id = s.id
-                LEFT JOIN (
-                    SELECT picture_id, json_agg(json_strip_nulls(json_build_object(
-                        'key', key,
-                        'value', value
-                    ))) AS semantics
-                    FROM pictures_semantics
-                    GROUP BY picture_id
-                ) t ON t.picture_id = p.id
                 LEFT JOIN (
                     SELECT
                         p.id,
@@ -631,7 +611,7 @@ def _getPictureItemById(collectionId, itemId):
                     FROM pictures p
                     JOIN sequences_pictures sp ON p.id = sp.pic_id
                     WHERE
-                        sp.seq_id = %(seq)s
+                        sp.seq_id IN (SELECT seq_id FROM seq)
                         AND (p.account_id = %(acc)s OR p.status != 'hidden')
                     WINDOW othpics AS (PARTITION BY sp.seq_id ORDER BY sp.rank)
                 ) spl ON p.id = spl.id
@@ -659,7 +639,7 @@ def _getPictureItemById(collectionId, itemId):
                             AND relp.status != 'waiting-for-delete'
                             AND relp.id != p.id
                             AND relsp.pic_id = relp.id
-                            AND relsp.seq_id != %(seq)s
+                            AND relsp.seq_id NOT IN (SELECT seq_id FROM seq)
                             AND (
                                 p.metadata->>'type' = 'equirectangular'
                                 OR (relp.heading IS NULL OR p.heading IS NULL)
@@ -672,19 +652,27 @@ def _getPictureItemById(collectionId, itemId):
                         ORDER BY relsp.seq_id, p.geom <-> relp.geom
                     ) a
                 ) relp ON TRUE
-                WHERE sp.seq_id = %(seq)s
+                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
+                ) seq_sem ON seq_sem.sequence_id = s.id
+                WHERE sp.seq_id IN (SELECT seq_id FROM seq)
                     AND p.id = %(pic)s
                     AND (p.account_id = %(acc)s OR p.status != 'hidden')
                     AND (s.status != 'hidden' OR s.account_id = %(acc)s)
                     AND s.status != 'deleted'
                 """,
-                {"seq": collectionId, "pic": itemId, "acc": accountId},
+                {"pic": itemId, "acc": accountId},
             ).fetchone()
 
             if record is None:
                 return None
 
-            return dbPictureToStacItem(collectionId, record)
+            return dbPictureToStacItem(record)
 
 
 @bp.route("/collections/<uuid:collectionId>/items/<uuid:itemId>")
@@ -720,12 +708,12 @@ def getCollectionItem(collectionId, itemId):
                     schema:
                         $ref: '#/components/schemas/GeoVisioItem'
     """
+    account = auth.get_current_account()
 
-    stacItem = _getPictureItemById(collectionId, itemId)
+    stacItem = _getPictureItemById(itemId, account)
     if stacItem is None:
         raise errors.InvalidAPIUsage(_("Item doesn't exist"), status_code=404)
 
-    account = auth.get_current_account()
     picStatusToHttpCode = {
         "waiting-for-process": 102,
         "ready": 200,
@@ -755,6 +743,8 @@ def searchItems():
             - $ref: '#/components/parameters/GeoVisio_place_position'
             - $ref: '#/components/parameters/GeoVisio_place_distance'
             - $ref: '#/components/parameters/GeoVisio_place_fov_tolerance'
+            - $ref: '#/components/parameters/searchCQL2_filter'
+            - $ref: '#/components/parameters/GeoVisioSearchSortedBy'
     post:
         requestBody:
             required: true
@@ -764,7 +754,11 @@ def searchItems():
                   $ref: '#/components/schemas/GeoVisioItemSearchBody'
     responses:
         200:
-            $ref: '#/components/responses/STAC_search'
+            description: The search results
+            content:
+                application/geo+json:
+                    schema:
+                        $ref: '#/components/schemas/GeoVisioCollectionItems'
     """
 
     account = auth.get_current_account()
@@ -772,7 +766,6 @@ def searchItems():
     sqlWhere = [SQL("(p.status = 'ready' OR p.account_id = %(account)s)"), SQL("(is_sequence_visible_by_user(s, %(account)s))")]
     sqlParams: Dict[str, Any] = {"account": accountId}
     sqlSubQueryWhere = [SQL("(p.status = 'ready' OR p.account_id = %(account)s)")]
-    order_by = SQL("")
 
     #
     # Parameters parsing and verification
@@ -788,14 +781,16 @@ def searchItems():
         args = request.args
 
     # Limit
-    if args.get("limit") is not None:
-        limit = args.get("limit", type=int)
-        if limit is None or limit < 1 or limit > 10000:
-            raise errors.InvalidAPIUsage(_("Parameter limit must be either empty or a number between 1 and 10000"), status_code=400)
-        else:
-            sqlParams["limit"] = limit
-    else:
-        sqlParams["limit"] = 10
+    limit = args.get("limit") or 10
+    try:
+        limit = int(limit)
+        if limit < 1 or limit > 10000:
+            raise ValueError()
+    except ValueError:
+        raise errors.InvalidAPIUsage(_("Parameter limit must be either empty or a number between 1 and 10000"), status_code=400)
+    sqlParams["limit"] = limit
+
+    sort_by = parse_item_sortby(args.get("sortby"))
 
     # Bounding box
     bboxarg = parse_bbox(args.getlist("bbox"))
@@ -806,7 +801,16 @@ def searchItems():
         sqlParams["maxx"] = bboxarg[2]
         sqlParams["maxy"] = bboxarg[3]
         # if we search by bbox, we'll give first the items near the center of the bounding box
-        order_by = SQL("ORDER BY p.geom <-> ST_Centroid(ST_MakeEnvelope(%(minx)s, %(miny)s, %(maxx)s, %(maxy)s, 4326))")
+        if not sort_by:
+            sort_by = SortBy(
+                fields=[
+                    ItemSortByField(
+                        field=SortableItemField.distance_to,
+                        direction=SQLDirection.ASC,
+                        obj_to_compare=SQL("ST_Centroid(ST_MakeEnvelope(%(minx)s, %(miny)s, %(maxx)s, %(maxy)s, 4326))"),
+                    ),
+                ]
+            )
 
     # Datetime
     min_dt, max_dt = parse_datetime_interval(args.get("datetime"))
@@ -862,7 +866,16 @@ def searchItems():
         )
 
         # Sort pictures by nearest to POI
-        order_by = SQL("ORDER BY p.geom <-> ST_Point(%(placex)s, %(placey)s, 4326)")
+        if not sort_by:
+            sort_by = SortBy(
+                fields=[
+                    ItemSortByField(
+                        field=SortableItemField.distance_to,
+                        direction=SQLDirection.ASC,
+                        obj_to_compare=SQL("ST_Point(%(placex)s, %(placey)s, 4326)"),
+                    ),
+                ]
+            )
 
     # Intersects
     if args.get("intersects") is not None:
@@ -877,7 +890,16 @@ def searchItems():
             sqlWhere.append(SQL("ST_Intersects(p.geom, ST_GeomFromGeoJSON(%(geom)s))"))
         sqlParams["geom"] = Jsonb(intersects)
         # if we search by bbox, we'll give first the items near the center of the bounding box
-        order_by = SQL("ORDER BY p.geom <-> ST_Centroid(ST_GeomFromGeoJSON(%(geom)s))")
+        if not sort_by:
+            sort_by = SortBy(
+                fields=[
+                    ItemSortByField(
+                        field=SortableItemField.distance_to,
+                        direction=SQLDirection.ASC,
+                        obj_to_compare=SQL("ST_Centroid(ST_GeomFromGeoJSON(%(geom)s))"),
+                    ),
+                ]
+            )
 
     # Ids
     if args.get("ids") is not None:
@@ -900,23 +922,35 @@ def searchItems():
             raise errors.InvalidAPIUsage(_("Parameter collections should be a JSON array of strings"), status_code=400)
 
     # To speed up search, if it's a search by id and on only one id, we use the same code as /collections/:cid/items/:id
-    if args.get("ids") is not None and args:
+    if args.get("ids") is not None:
         ids = parse_list(args.get("ids"), paramName="ids")
         if ids and len(ids) == 1:
             picture_id = ids[0]
 
             with current_app.pool.connection() as conn, conn.cursor() as cursor:
-                seq = cursor.execute("SELECT seq_id FROM sequences_pictures WHERE pic_id = %s", [picture_id]).fetchone()
-                if not seq:
-                    raise errors.InvalidAPIUsage(_("Picture doesn't exist"), status_code=404)
-
-                item = _getPictureItemById(seq[0], UUID(picture_id))
+                item = _getPictureItemById(UUID(picture_id), account)
                 features = [item] if item else []
                 return (
                     {"type": "FeatureCollection", "features": features, "links": [get_root_link()]},
                     200,
                     {"Content-Type": "application/geo+json"},
                 )
+    filter_param = args.get("filter")
+    if filter_param is not None:
+        cql_filter = parse_search_filter(filter_param)
+        if cql_filter is not None:
+            sqlWhere.append(cql_filter)
+
+    if not sort_by:
+        # by default we sort by last updated (and id in case of equalities)
+        sort_by = SortBy(
+            fields=[
+                ItemSortByField(field=SortableItemField.updated, direction=SQLDirection.DESC),
+                ItemSortByField(field=SortableItemField.id, direction=SQLDirection.ASC),
+            ]
+        )
+
+    order_by = sort_by.to_sql()
 
     #
     # Database query
@@ -926,25 +960,27 @@ def searchItems():
             """
 SELECT * FROM (
     SELECT
-        p.id, p.ts, p.heading, p.metadata, p.inserted_at,
+        p.id, p.ts, p.heading, p.metadata, p.inserted_at, p.updated_at,
         ST_AsGeoJSON(p.geom)::json AS geojson,
         sp.seq_id, sp.rank AS rank,
         accounts.name AS account_name, 
         p.account_id AS account_id,
         p.exif, p.gps_accuracy_m, p.h_pixel_density,
-        t.semantics
+        get_picture_semantics(p.id) as semantics,
+        get_picture_annotations(p.id) as annotations,
+        COALESCE(seq_sem.semantics, '[]'::json) AS sequence_semantics
     FROM pictures p
     LEFT JOIN sequences_pictures sp ON p.id = sp.pic_id
     LEFT JOIN sequences s ON s.id = sp.seq_id
     LEFT JOIN accounts ON p.account_id = accounts.id
     LEFT JOIN (
-        SELECT picture_id, json_agg(json_strip_nulls(json_build_object(
+        SELECT sequence_id, json_agg(json_strip_nulls(json_build_object(
             'key', key,
             'value', value
-        ))) AS semantics
-        FROM pictures_semantics
-        GROUP BY picture_id
-    ) t ON t.picture_id = p.id
+        )) ORDER BY key, value) AS semantics
+        FROM sequences_semantics
+        GROUP BY sequence_id
+    ) seq_sem ON seq_sem.sequence_id = s.id
     WHERE {sqlWhere}
     {orderBy}
     LIMIT %(limit)s
@@ -967,13 +1003,14 @@ LEFT JOIN LATERAL (
     ORDER BY sp.rank ASC 
     LIMIT 1
 ) next on true
+
 ;
         """
         ).format(sqlWhere=SQL(" AND ").join(sqlWhere), sqlSubQueryWhere=SQL(" AND ").join(sqlSubQueryWhere), orderBy=order_by)
 
         records = cursor.execute(query, sqlParams)
 
-        items = [dbPictureToStacItem(str(dbPic["seq_id"]), dbPic) for dbPic in records]
+        items = [dbPictureToStacItem(dbPic) for dbPic in records]
 
         return (
             {
@@ -991,7 +1028,9 @@ LEFT JOIN LATERAL (
 @bp.route("/collections/<uuid:collectionId>/items", methods=["POST"])
 @auth.login_required_by_setting("API_FORCE_AUTH_ON_UPLOAD")
 def postCollectionItem(collectionId, account=None):
-    """Add a new picture in a given sequence
+    """Add a new picture in a given sequence.
+
+    Note that this is the legacy API, upload should be done using the [UploadSet](#UploadSet) endpoints if possible.
     ---
     tags:
         - Upload
@@ -1017,6 +1056,42 @@ def postCollectionItem(collectionId, account=None):
                 application/geo+json:
                     schema:
                         $ref: '#/components/schemas/GeoVisioItem'
+        400:
+            description: Error if the request is malformed
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/GeoVisioError'
+        401:
+            description: Error if you're not logged in
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/GeoVisioError'
+        403:
+            description: Error if you're not authorized to add picture to this collection
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/GeoVisioError'
+        404:
+            description: Error if the collection doesn't exist
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/GeoVisioError'
+        409:
+            description: Error if a picture (named `item` in the API) has already been added in the same index (named `position` in the API) in this collection
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/GeoVisioError'
+        415:
+            description: Error if the content type is not multipart/form-data
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/GeoVisioError'
     """
 
     if not request.headers.get("Content-Type", "").startswith("multipart/form-data"):
@@ -1124,7 +1199,7 @@ def postCollectionItem(collectionId, account=None):
                         conn, collectionId, position, updated_picture, accountId, additionalMetadata, lang=get_locale().language
                     )
                 except utils.pictures.PicturePositionConflict:
-                    raise errors.InvalidAPIUsage(_("Picture at given position already exist"), status_code=409)
+                    raise errors.InvalidAPIUsage(_("There is already a picture with the same index in the sequence"), status_code=409)
                 except utils.pictures.MetadataReadingError as e:
                     raise errors.InvalidAPIUsage(_("Impossible to parse picture metadata"), payload={"details": {"error": e.details}})
                 except utils.pictures.InvalidMetadataValue as e:
@@ -1232,60 +1307,8 @@ class PatchItemParameter(BaseModel):
         return self.model_fields_set == {"semantics"}
 
 
-@bp.route("/collections/<uuid:collectionId>/items/<uuid:itemId>", methods=["PATCH"])
-@auth.login_required()
-def patchCollectionItem(collectionId, itemId, account):
-    """Edits properties of an existing picture
-
-    Note that tags cannot be added as form-data for the moment, only as JSON.
-
-    Note that there are rules on the editing of a picture's metadata:
-
-    - Only the owner of a picture can change its visibility
-    - For core metadata (heading, capture_time, position, longitude, latitude), the owner can restrict their change by other accounts (see `collaborative_metadata` field in `/api/users/me`) and if not explicitly defined by the user, the instance's default value is used.
-    - Everyone can add/edit/delete semantics tags.
-    ---
-    tags:
-        - Editing
-        - Tags
-    parameters:
-        - name: collectionId
-          in: path
-          description: ID of sequence the picture belongs to
-          required: true
-          schema:
-            type: string
-        - name: itemId
-          in: path
-          description: ID of picture to edit
-          required: true
-          schema:
-            type: string
-    requestBody:
-        content:
-            application/json:
-                schema:
-                    $ref: '#/components/schemas/GeoVisioPatchItem'
-            application/x-www-form-urlencoded:
-                schema:
-                    $ref: '#/components/schemas/GeoVisioPatchItem'
-            multipart/form-data:
-                schema:
-                    $ref: '#/components/schemas/GeoVisioPatchItem'
-    security:
-        - bearerToken: []
-        - cookieAuth: []
-    responses:
-        200:
-            description: the wanted item
-            content:
-                application/geo+json:
-                    schema:
-                        $ref: '#/components/schemas/GeoVisioItem'
-    """
-
+def update_picture(itemId: UUID, account: Optional[Account]):
     # Parse received parameters
-
     metadata = None
     content_type = (request.headers.get("Content-Type") or "").split(";")[0]
 
@@ -1299,7 +1322,7 @@ def patchCollectionItem(collectionId, itemId, account):
 
     # If no parameter is set
     if metadata is None or not metadata.has_override():
-        return getCollectionItem(collectionId, itemId)
+        return (_getPictureItemById(itemId, account), 304)
 
     # Check if picture exists and if given account is authorized to edit
     with db.conn(current_app) as conn:
@@ -1380,7 +1403,61 @@ WHERE id = %(id)s"""
                 )
 
     # Redirect response to a classic GET
-    return getCollectionItem(collectionId, itemId)
+    return (_getPictureItemById(itemId, account), 200)
+
+
+@bp.route("/collections/<uuid:collectionId>/items/<uuid:itemId>", methods=["PATCH"])
+@auth.login_required()
+def patchCollectionItem(collectionId, itemId, account):
+    """Edits properties of an existing picture
+
+    Note that tags cannot be added as form-data for the moment, only as JSON.
+
+    Note that there are rules on the editing of a picture's metadata:
+
+    - Only the owner of a picture can change its visibility
+    - For core metadata (heading, capture_time, position, longitude, latitude), the owner can restrict their change by other accounts (see `collaborative_metadata` field in `/api/users/me`) and if not explicitly defined by the user, the instance's default value is used.
+    - Everyone can add/edit/delete semantics tags.
+    ---
+    tags:
+        - Editing
+        - Semantics
+    parameters:
+        - name: collectionId
+          in: path
+          description: ID of sequence the picture belongs to
+          required: true
+          schema:
+            type: string
+        - name: itemId
+          in: path
+          description: ID of picture to edit
+          required: true
+          schema:
+            type: string
+    requestBody:
+        content:
+            application/json:
+                schema:
+                    $ref: '#/components/schemas/GeoVisioPatchItem'
+            application/x-www-form-urlencoded:
+                schema:
+                    $ref: '#/components/schemas/GeoVisioPatchItem'
+            multipart/form-data:
+                schema:
+                    $ref: '#/components/schemas/GeoVisioPatchItem'
+    security:
+        - bearerToken: []
+        - cookieAuth: []
+    responses:
+        200:
+            description: the wanted item
+            content:
+                application/geo+json:
+                    schema:
+                        $ref: '#/components/schemas/GeoVisioItem'
+    """
+    return update_picture(itemId, account)
 
 
 @bp.route("/collections/<uuid:collectionId>/items/<uuid:itemId>", methods=["DELETE"])