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

geovisio/web/items.py

@@ -15,7 +15,9 @@ 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 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,
@@ -23,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
@@ -52,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
@@ -70,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 = [
@@ -115,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": (
@@ -151,6 +155,7 @@ def dbPictureToStacItem(seqId, dbPic):
                     "quality:horizontal_accuracy": float("{:.1f}".format(dbPic["gps_accuracy_m"])) if dbPic.get("gps_accuracy_m") 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(
@@ -424,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"))
@@ -433,11 +438,11 @@ 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,
@@ -464,7 +469,7 @@ def getCollectionItems(collectionId):
                 if first_rank is None:
                     first_rank = dbPic["rank"]
                 last_rank = dbPic["rank"]
-                items.append(dbPictureToStacItem(collectionId, dbPic))
+                items.append(dbPictureToStacItem(dbPic))
             bounds = Bounds(first=first_rank, last=last_rank) if records else None
 
             links = [
@@ -570,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
@@ -598,16 +585,18 @@ 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,
-                   
                     get_picture_semantics(p.id) as semantics,
-                    get_picture_annotations(p.id) as annotations
+                    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
@@ -622,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
@@ -650,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)
@@ -663,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>")
@@ -711,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,
@@ -726,18 +723,6 @@ def getCollectionItem(collectionId, itemId):
     return stacItem, picStatusToHttpCode[stacItem["properties"]["geovisio:status"]], {"Content-Type": "application/geo+json"}
 
 
-class SearchParams(BaseModel):
-    bbox: Optional[str] = None
-    limit: int = 10
-    datetime: Optional[str] = None
-    place_position: Optional[str] = None
-    place_distance: Optional[str] = None
-    place_fov_tolerance: Optional[int] = None
-    intersects: Optional[str] = None
-    ids: Optional[str] = None
-    collections: Optional[str] = None
-
-
 @bp.route("/search", methods=["GET", "POST"])
 def searchItems():
     """Search through all available items
@@ -759,6 +744,7 @@ def searchItems():
             - $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
@@ -768,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()
@@ -776,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
@@ -801,6 +790,8 @@ def searchItems():
         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"))
     if bboxarg is not None:
@@ -810,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"))
@@ -866,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:
@@ -881,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:
@@ -910,11 +928,7 @@ def searchItems():
             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()]},
@@ -926,6 +940,18 @@ def searchItems():
         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
     #
@@ -934,18 +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,
         get_picture_semantics(p.id) as semantics,
-        get_picture_annotations(p.id) as annotations
+        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 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 {sqlWhere}
     {orderBy}
     LIMIT %(limit)s
@@ -968,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 (
             {
@@ -992,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
@@ -1018,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"):
@@ -1125,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:
@@ -1233,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
-        - 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'
-    """
-
+def update_picture(itemId: UUID, account: Optional[Account]):
     # Parse received parameters
-
     metadata = None
     content_type = (request.headers.get("Content-Type") or "").split(";")[0]
 
@@ -1300,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:
@@ -1381,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"])