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

geovisio/web/docs.py

@@ -1,4 +1,4 @@
-from geovisio.web import utils, upload_set, reports, excluded_areas
+from geovisio.web import annotations, collections, items, prepare, users, utils, upload_set, reports, excluded_areas, pages
 from geovisio.utils import upload_set as upload_set_utils, reports as reports_utils, excluded_areas as excluded_areas_utils
 from importlib import metadata
 import re
@@ -135,6 +135,9 @@ API_CONFIG = {
                 },
             },
             "STACStatsForItems": {"$ref": "https://stac-extensions.github.io/stats/v0.2.0/schema.json#/definitions/stats_for_items"},
+            "STACStatsForCollections": {
+                "$ref": "https://stac-extensions.github.io/stats/v0.2.0/schema.json#/definitions/stats_for_collections"
+            },
             "STACLinks": {
                 "type": "object",
                 "properties": {
@@ -234,6 +237,9 @@ Note that you may not rely only on these ID that could change through time.
                     },
                 ]
             },
+            "PreparationParameter": prepare.PreparationParameter.model_json_schema(
+                ref_template="#/components/schemas/PreparationParameter/$defs/{model}", mode="serialization"
+            ),
             "GeoVisioPostUploadSet": upload_set.UploadSetCreationParameter.model_json_schema(
                 ref_template="#/components/schemas/GeoVisioPostUploadSet/$defs/{model}", mode="serialization"
             ),
@@ -266,6 +272,7 @@ Note that you may not rely only on these ID that could change through time.
                                     "required": ["href", "rel"],
                                     "properties": {
                                         "stats:items": {"$ref": "#/components/schemas/STACStatsForItems"},
+                                        "stats:collections": {"$ref": "#/components/schemas/STACStatsForCollections"},
                                         "extent": {"$ref": "#/components/schemas/STACExtentTemporal"},
                                         "geovisio:status": {"$ref": "#/components/schemas/GeoVisioCollectionStatus"},
                                         "geovisio:length_km": {"$ref": "#/components/schemas/GeoVisioLengthKm"},
@@ -286,6 +293,30 @@ Note that you may not rely only on these ID that could change through time.
                     },
                 ]
             },
+            "GeoVisioCSVCollections": {
+                "type": "string",
+                "descrition": f"""CSV file containing the collections.
+
+The CSV headers will be:
+* id: ID of the collection
+* status: Status of the collection
+* name: Name of the collection (its title)
+* created: Creation date of the collection
+* updated: Last update date of the collection
+* capture_date: Computed capture date of the collection (date of its first picture)
+* minimum_capture_time: Capture datetime of the first picture
+* maximum_capture_time: Capture datetime of the last picture
+* min_x: Minimum X coordinate of the bounding box of the collection
+* min_y: Minimum Y coordinate of the bounding box of the collection
+* max_x: Maximum X coordinate of the bounding box of the collection
+* max_y: Maximum Y coordinate of the bounding box of the collection
+* nb_pictures: Number of pictures in the collection
+* length_km: Total length of the collection in kilometers
+* computed_h_pixel_density: Horizontal pixel density of the pictures in the collection, if all pictures have the same one
+* computed_gps_accuracy: GPS accuracy of the pictures in the collection, if all pictures have the same one
+
+""",
+            },
             "GeoVisioCollections": {
                 "allOf": [
                     {"$ref": "#/components/schemas/STACCollections"},
@@ -400,41 +431,9 @@ Note that you may not rely only on these ID that could change through time.
                 "type": "object",
                 "properties": {"title": {"type": "string", "description": "The sequence title"}},
             },
-            "GeoVisioPatchCollection": {
-                "type": "object",
-                "properties": {
-                    "visible": {
-                        "type": "string",
-                        "description": "Should the sequence be publicly visible ?",
-                        "enum": ["true", "false", "null"],
-                        "default": "null",
-                    },
-                    "title": {
-                        "type": "string",
-                        "description": "The sequence title (publicly displayed)",
-                    },
-                    "relative_heading": {
-                        "type": "number",
-                        "minimum": -180,
-                        "maximum": 180,
-                        "description": "The relative heading (in degrees), offset based on movement path (0° = looking forward, -90° = looking left, 90° = looking right). Headings are unchanged if this parameter is not set.",
-                    },
-                    "sortby": {
-                        "description": """
-Define the pictures sort order based on given property. Sort order is defined based on preceding '+' (asc) or '-' (desc).
-
-Available properties are:
-* `gpsdate`: sort by GPS datetime
-* `filedate`: sort by the camera-generated capture date. This is based on EXIF tags `Exif.Image.DateTimeOriginal`, `Exif.Photo.DateTimeOriginal`, `Exif.Image.DateTime` or `Xmp.GPano.SourceImageCreateTime` (in this order).
-* `filename`: sort by the original picture file name
-
-If unset, sort order is unchanged.
-""",
-                        "type": "string",
-                        "enum": ["+gpsdate", "-gpsdate", "+filedate", "-filedate", "+filename", "-filename"],
-                    },
-                },
-            },
+            "GeoVisioPatchCollection": collections.PatchCollectionParameter.model_json_schema(
+                ref_template="#/components/schemas/GeoVisioPatchCollection/$defs/{model}", mode="serialization"
+            ),
             "GeoVisioCollectionItems": {
                 "allOf": [
                     {"$ref": "#/components/schemas/STACCollectionItems"},
@@ -583,23 +582,9 @@ Note that this parameter is not taken in account for 360° pictures, as by defin
                     },
                 ],
             },
-            "GeoVisioPatchItem": {
-                "type": "object",
-                "properties": {
-                    "visible": {
-                        "type": "string",
-                        "description": "Should the picture be publicly visible ?",
-                        "enum": ["true", "false", "null"],
-                        "default": "null",
-                    },
-                    "heading": {
-                        "type": "number",
-                        "minimum": 0,
-                        "maximum": 360,
-                        "description": "The picture heading (in degrees). North is 0°, East = 90°, South = 180° and West = 270°.",
-                    },
-                },
-            },
+            "GeoVisioPatchItem": items.PatchItemParameter.model_json_schema(
+                ref_template="#/components/schemas/GeoVisioPatchItem/$defs/{model}", mode="serialization"
+            ),
             "GeoVisioCollectionStatus": {"type": "string", "enum": ["ready", "broken", "preparing", "waiting-for-process"]},
             "GeoVisioLengthKm": {"type": "number", "description": "Total length of sequence (in kilometers)"},
             "GeoVisioCollectionSortedBy": {
@@ -659,20 +644,12 @@ Available properties are:
                     },
                 },
             },
-            "GeoVisioUser": {
-                "type": "object",
-                "properties": {
-                    "id": {"type": "string", "format": "uuid"},
-                    "name": {"type": "string"},
-                    "links": {
-                        "type": "array",
-                        "items": {
-                            "type": "object",
-                            "properties": {"href": {"type": "string"}, "ref": {"type": "string"}, "type": {"type": "string"}},
-                        },
-                    },
-                },
-            },
+            "GeoVisioUserConfiguration": users.UserConfiguration.model_json_schema(
+                ref_template="#/components/schemas/GeoVisioUserConfiguration/$defs/{model}", mode="serialization"
+            ),
+            "GeoVisioUser": users.UserInfo.model_json_schema(
+                ref_template="#/components/schemas/GeoVisioUser/$defs/{model}", mode="serialization"
+            ),
             "GeoVisioUserAuth": {
                 "type": "object",
                 "properties": {
@@ -704,6 +681,10 @@ Available properties are:
                     },
                 },
             },
+            "GeoVisioPageName": {"type": "string", "enum": ["end-user-license-agreement", "terms-of-service"]},
+            "GeoVisioPageSummary": pages.PageSummary.model_json_schema(
+                ref_template="#/components/schemas/GeoVisioPageSummary/$defs/{model}", mode="serialization"
+            ),
             "GeoVisioConfiguration": {
                 "type": "object",
                 "properties": {
@@ -731,6 +712,21 @@ Available properties are:
                             },
                         },
                     },
+                    "geo_coverage": {
+                        "type": "object",
+                        "properties": {
+                            "label": {
+                                "type": "string",
+                                "description": "Instance geographical coverage for pictures uploads, in user language",
+                            },
+                            "langs": {
+                                "type": "object",
+                                "additionalProperties": "string",
+                                "description": "Translated descriptions as lang -> value object",
+                                "default": {"en": "Worldwide\nThe picture can be sent from anywhere in the world."},
+                            },
+                        },
+                    },
                     "logo": {
                         "default": "https://gitlab.com/panoramax/gitlab-profile/-/raw/main/images/logo.svg",
                         "format": "uri",
@@ -740,11 +736,13 @@ Available properties are:
                         "type": "string",
                     },
                     "color": {"default": "#bf360c", "format": "color", "title": "Color", "type": "string"},
+                    "email": {"default": "panoramax@panoramax.fr", "format": "email", "title": "Contact email", "type": "string"},
                     "auth": {
                         "type": "object",
                         "properties": {
                             "user_profile": {"type": "object", "properties": {"url": {"type": "string"}}},
                             "enabled": {"type": "boolean"},
+                            "enforce_tos_acceptance": {"type": "boolean"},
                         },
                         "required": ["enabled"],
                     },
@@ -1078,9 +1076,11 @@ def getApiDocs():
                 "externalDocs": {"url": "https://docs.panoramax.fr/api/api/api/#upload"},
             },
             {"name": "Editing", "description": "Modifying pictures & sequences"},
+            {"name": "Semantics", "description": "Panoramax semantics"},
             {"name": "Reports", "description": "Report issues with pictures & sequences"},
             {"name": "Excluded Areas", "description": "Areas where pictures cannot be uploaded"},
             {"name": "Users", "description": "Account management"},
             {"name": "Auth", "description": "User authentication"},
+            {"name": "Configuration", "description": "Various settings"},
         ],
     }

geovisio/web/items.py

@@ -1,14 +1,18 @@
+from datetime import datetime
 import json
 import logging
 import os
-from typing import Dict, Optional, Any
+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 werkzeug.datastructures import MultiDict
 from uuid import UUID
 from geovisio import errors, utils
 from geovisio.utils import auth, db
+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.web.params import (
     as_latitude,
     as_longitude,
@@ -19,6 +23,7 @@ from geovisio.web.params import (
     parse_list,
     parse_lonlat,
     parse_distance_range,
+    parse_picture_heading,
 )
 from geovisio.utils.fields import Bounds
 import hashlib
@@ -140,6 +145,7 @@ 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,
                 }
             ),
             "links": cleanNoneInList(
@@ -421,24 +427,33 @@ def getCollectionItems(collectionId):
 
             query = SQL(
                 """
-				SELECT
-					p.id, p.ts, p.heading, p.metadata, p.inserted_at, p.status,
-					ST_AsGeoJSON(p.geom)::json AS geojson,
-					a.name AS account_name,
+                SELECT
+                    p.id, p.ts, p.heading, p.metadata, p.inserted_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,
-					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
-				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
-				WHERE
-    				{filter}
-				WINDOW othpics AS (PARTITION BY sp.seq_id ORDER BY sp.rank)
-				ORDER BY rank
+                    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
+                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)
+                ORDER BY rank
                 {limit}
                 """
             ).format(filter=SQL(" AND ").join(filters), limit=sql_limit)
@@ -587,30 +602,39 @@ def _getPictureItemById(collectionId, itemId):
             # Get rank + position of wanted picture
             record = cursor.execute(
                 """
-				SELECT
-    				p.id, sp.rank, ST_AsGeoJSON(p.geom)::json AS geojson, p.heading, p.ts, p.metadata,
+                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.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
-				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
-						p.id,
-						LAG(p.id) OVER othpics AS prevpic,
-						ST_AsGeoJSON(LAG(p.geom) OVER othpics)::json AS prevpicgeojson,
-						LEAD(p.id) OVER othpics AS nextpic,
-						ST_AsGeoJSON(LEAD(p.geom) OVER othpics)::json AS nextpicgeojson
-					FROM pictures p
-					JOIN sequences_pictures sp ON p.id = sp.pic_id
-					WHERE
-						sp.seq_id = %(seq)s
-						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
+                    spl.prevpic, spl.prevpicgeojson, spl.nextpic, spl.nextpicgeojson, p.exif,
+                    relp.related_pics, p.gps_accuracy_m, p.h_pixel_density,
+                    t.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,
+                        LAG(p.id) OVER othpics AS prevpic,
+                        ST_AsGeoJSON(LAG(p.geom) OVER othpics)::json AS prevpicgeojson,
+                        LEAD(p.id) OVER othpics AS nextpic,
+                        ST_AsGeoJSON(LEAD(p.geom) OVER othpics)::json AS nextpicgeojson
+                    FROM pictures p
+                    JOIN sequences_pictures sp ON p.id = sp.pic_id
+                    WHERE
+                        sp.seq_id = %(seq)s
+                        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
                 LEFT JOIN (
                     SELECT array_agg(ARRAY[seq_id::text, id::text, geom, tstxt]) AS related_pics
                     FROM (
@@ -648,12 +672,12 @@ def _getPictureItemById(collectionId, itemId):
                         ORDER BY relsp.seq_id, p.geom <-> relp.geom
                     ) a
                 ) relp ON TRUE
-				WHERE sp.seq_id = %(seq)s
-					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)
+                WHERE sp.seq_id = %(seq)s
+                    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},
             ).fetchone()
 
@@ -907,11 +931,20 @@ SELECT * FROM (
         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
+        p.exif, p.gps_accuracy_m, p.h_pixel_density,
+        t.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(
+            'key', key,
+            'value', value
+        ))) AS semantics
+        FROM pictures_semantics
+        GROUP BY picture_id
+    ) t ON t.picture_id = p.id
     WHERE {sqlWhere}
     {orderBy}
     LIMIT %(limit)s
@@ -1119,13 +1152,102 @@ def postCollectionItem(collectionId, account=None):
     )
 
 
+class PatchItemParameter(BaseModel):
+    """Parameters used to add an item to an UploadSet"""
+
+    heading: Optional[int] = None
+    """Heading of the picture. The new heading will not be persisted in the picture's exif tags for the moment."""
+    visible: Optional[bool] = None
+    """Should the picture be publicly visible ?"""
+
+    capture_time: Optional[datetime] = None
+    """Capture time of the picture. The new capture time will not be persisted in the picture's exif tags for the moment."""
+    longitude: Optional[float] = None
+    """Longitude of the picture. The new longitude will not be persisted in the picture's exif tags for the moment."""
+    latitude: Optional[float] = None
+    """Latitude of the picture. The new latitude will not be persisted in the picture's exif tags for the moment."""
+
+    semantics: Optional[List[SemanticTagUpdate]] = None
+    """Tags to update on the picture. By default each tag will be added to the picture's tags, but you can change this behavior by setting the `action` parameter to `delete`.
+
+    If you want to replace a tag, you need to first delete it, then add it again.
+
+    Like:
+[
+    {"key": "some_key", "value": "some_value", "action": "delete"},
+    {"key": "some_key", "value": "some_new_value"}
+]
+
+    
+    Note that updating tags is only possible with JSON data, not with form-data."""
+
+    def has_override(self) -> bool:
+        return self.model_fields_set
+
+    @field_validator("heading", mode="before")
+    @classmethod
+    def parse_heading(cls, value):
+        if value is None:
+            return None
+        return parse_picture_heading(value)
+
+    @field_validator("visible", mode="before")
+    @classmethod
+    def parse_visible(cls, value):
+        if value not in ["true", "false"]:
+            raise errors.InvalidAPIUsage(_("Picture visibility parameter (visible) should be either unset, true or false"), status_code=400)
+        return value == "true"
+
+    @field_validator("capture_time", mode="before")
+    @classmethod
+    def parse_capture_time(cls, value):
+        if value is None:
+            return None
+        return parse_datetime(
+            value,
+            error=_(
+                "Parameter `capture_time` is not a valid datetime, it should be an iso formated datetime (like '2017-07-21T17:32:28Z')."
+            ),
+        )
+
+    @field_validator("longitude")
+    @classmethod
+    def parse_longitude(cls, value):
+        return as_longitude(value, error=_("For parameter `longitude`, `%(v)s` is not a valid longitude", v=value))
+
+    @field_validator("latitude")
+    @classmethod
+    def parse_latitude(cls, value):
+        return as_latitude(value, error=_("For parameter `latitude`, `%(v)s` is not a valid latitude", v=value))
+
+    @model_validator(mode="after")
+    def validate(self):
+        if self.latitude is None and self.longitude is not None:
+            raise errors.InvalidAPIUsage(_("Longitude cannot be overridden alone, latitude also needs to be set"))
+        if self.longitude is None and self.latitude is not None:
+            raise errors.InvalidAPIUsage(_("Latitude cannot be overridden alone, longitude also needs to be set"))
+        return self
+
+    def has_only_semantics_updates(self):
+        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
@@ -1163,37 +1285,20 @@ def patchCollectionItem(collectionId, itemId, account):
     """
 
     # Parse received parameters
-    metadata = {}
+
+    metadata = None
     content_type = (request.headers.get("Content-Type") or "").split(";")[0]
-    for param in ["visible", "heading"]:
+
+    try:
         if request.is_json and request.json:
-            metadata[param] = request.json.get(param)
+            metadata = PatchItemParameter(**request.json)
         elif content_type in ["multipart/form-data", "application/x-www-form-urlencoded"]:
-            metadata[param] = request.form.get(param)
-
-    visible = metadata.get("visible")
-    if visible is not None:
-        if visible not in ["true", "false"]:
-            raise errors.InvalidAPIUsage(_("Picture visibility parameter (visible) should be either unset, true or false"), status_code=400)
-        visible = visible == "true"
-
-    # Check if heading is valid
-    heading = metadata.get("heading")
-    if heading is not None:
-        try:
-            heading = int(heading)
-            if heading < 0 or heading > 360:
-                raise ValueError()
-        except ValueError:
-            raise errors.InvalidAPIUsage(
-                _(
-                    "Heading is not valid, should be an integer in degrees from 0° to 360°. North is 0°, East = 90°, South = 180° and West = 270°."
-                ),
-                status_code=400,
-            )
+            metadata = PatchItemParameter(**request.form)
+    except ValidationError as ve:
+        raise errors.InvalidAPIUsage(_("Impossible to parse parameters"), payload=validation_error(ve))
 
     # If no parameter is set
-    if {visible, heading} == {None}:
+    if metadata is None or not metadata.has_override():
         return getCollectionItem(collectionId, itemId)
 
     # Check if picture exists and if given account is authorized to edit
@@ -1205,10 +1310,21 @@ def patchCollectionItem(collectionId, itemId, account):
             if not pic:
                 raise errors.InvalidAPIUsage(_("Picture %(p)s wasn't found in database", p=itemId), status_code=404)
 
-            # Account associated to picture doesn't match current user
             if account is not None and account.id != str(pic["account_id"]):
-                raise errors.InvalidAPIUsage(_("You're not authorized to edit this picture"), status_code=403)
+                # Account associated to picture doesn't match current user
+                # and we limit the status change to only the owner.
+                if metadata.visible is not None:
+                    raise errors.InvalidAPIUsage(
+                        _("You're not authorized to edit the visibility of this picture. Only the owner can change this."), status_code=403
+                    )
 
+                # for core metadata editing (all appart the semantic tags), we check if the user has allowed it
+                if not metadata.has_only_semantics_updates():
+                    if not auth.account_allow_collaborative_editing(pic["account_id"]):
+                        raise errors.InvalidAPIUsage(
+                            _("You're not authorized to edit this picture, collaborative editing is not allowed"),
+                            status_code=403,
+                        )
             sqlUpdates = []
             sqlParams = {"id": itemId, "account": account.id}
 
@@ -1226,34 +1342,42 @@ def patchCollectionItem(collectionId, itemId, account):
                 )
 
             newStatus = None
-            if visible is not None:
-                newStatus = "ready" if visible is True else "hidden"
+            if metadata.visible is not None:
+                newStatus = "ready" if metadata.visible is True else "hidden"
                 if newStatus != oldStatus:
                     sqlUpdates.append(SQL("status = %(status)s"))
                     sqlParams["status"] = newStatus
 
-            if heading is not None:
+            if metadata.heading is not None:
                 sqlUpdates.extend([SQL("heading = %(heading)s"), SQL("heading_computed = false")])
-                sqlParams["heading"] = heading
-
-            if not sqlUpdates:
-                # Nothing to change, we can return the item
-                return getCollectionItem(collectionId, itemId)
-
-            # 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 pictures
-                    SET {updates}
-                    WHERE id = %(id)s
-                    """
-                ).format(updates=SQL(", ").join(sqlUpdates)),
-                sqlParams,
-            )
+                sqlParams["heading"] = metadata.heading
+
+            if metadata.capture_time is not None:
+                sqlUpdates.extend([SQL("ts = %(capture_time)s")])
+                sqlParams["capture_time"] = metadata.capture_time
+
+            if metadata.longitude is not None and metadata.latitude is not None:
+                sqlUpdates.extend([SQL("geom = ST_SetSRID(ST_MakePoint(%(longitude)s, %(latitude)s), 4326)")])
+                sqlParams["longitude"] = metadata.longitude
+                sqlParams["latitude"] = metadata.latitude
+
+            if metadata.semantics is not None:
+                # semantic tags are managed separately
+                update_tags(cursor, Entity(type=EntityType.pic, id=itemId), metadata.semantics, account=account.id)
+
+            if sqlUpdates:
+                # Note: we set the field `last_account_to_edit` to track who changed the collection last
+                # 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 pictures
+SET {updates}
+WHERE id = %(id)s"""
+                    ).format(updates=SQL(", ").join(sqlUpdates)),
+                    sqlParams,
+                )
 
     # Redirect response to a classic GET
     return getCollectionItem(collectionId, itemId)