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

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
@@ -38,6 +43,7 @@ from flask import current_app, request, url_for, Blueprint
 from flask_babel import gettext as _, get_locale
 from geopic_tag_reader.writer import writePictureMetadata, PictureMetadata
 import sentry_sdk
+import math
 
 
 bp = Blueprint("stac_items", __name__, url_prefix="/api")
@@ -77,6 +83,8 @@ def dbPictureToStacItem(seqId, dbPic):
             sensorDim = None
         if None in visibleArea or visibleArea == [0, 0, 0, 0]:
             visibleArea = None
+    elif "height" in dbPic["metadata"] and "width" in dbPic["metadata"]:
+        sensorDim = [dbPic["metadata"]["width"], dbPic["metadata"]["height"]]
 
     item = removeNoneInDict(
         {
@@ -119,7 +127,11 @@ def dbPictureToStacItem(seqId, dbPic):
                             }
                         )
                         if "metadata" in dbPic
-                        and any(True for f in dbPic["metadata"] if f in ["make", "model", "focal_length", "field_of_view", "crop"])
+                        and any(
+                            True
+                            for f in dbPic["metadata"]
+                            if f in ["make", "model", "focal_length", "field_of_view", "crop", "width", "height"]
+                        )
                         else {}
                     ),
                     "pers:pitch": dbPic["metadata"].get("pitch"),
@@ -128,9 +140,12 @@ def dbPictureToStacItem(seqId, dbPic):
                     "geovisio:producer": dbPic["account_name"],
                     "original_file:size": dbPic["metadata"].get("originalFileSize"),
                     "original_file:name": dbPic["metadata"].get("originalFileName"),
+                    "panoramax:horizontal_pixel_density": dbPic.get("h_pixel_density"),
                     "geovisio:image": _getHDJpgPictureURL(dbPic["id"], dbPic.get("status")),
                     "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(
@@ -412,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,
-					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
+                    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
+                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)
@@ -578,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
-				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 (
@@ -639,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()
 
@@ -898,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.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
@@ -1110,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
@@ -1154,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
@@ -1196,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}
 
@@ -1217,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)
@@ -1293,8 +1426,8 @@ def deleteCollectionItem(collectionId, itemId, account):
 
             cursor.execute("DELETE FROM pictures WHERE id = %s", [itemId])
 
-            # delete images
-            utils.pictures.removeAllFiles(itemId)
+    # let the picture be removed from the filesystem by the asynchronous workers
+    current_app.background_processor.process_pictures()
 
     return "", 204