geovisio 2.4.0__py3-none-any.whl → 2.6.0__py3-none-any.whl

geovisio/web/collections.py

@@ -1,7 +1,6 @@
 import logging
 from geovisio import errors, utils
-from geovisio.utils import auth
-from geovisio.utils.sequences import get_pagination_links
+from geovisio.utils import auth, sequences
 from geovisio.web.params import (
     parse_datetime,
     parse_datetime_interval,
@@ -12,9 +11,7 @@ from geovisio.web.params import (
 )
 from geovisio.utils.sequences import (
     STAC_FIELD_MAPPINGS,
-    STAC_FIELD_TO_SQL_FILTER,
     CollectionsRequest,
-    Collections,
     get_collections,
 )
 from geovisio.utils.fields import SortBy, SortByField, SQLDirection, Bounds, BBox
@@ -22,6 +19,7 @@ from geovisio.web.rss import dbSequencesToGeoRSS
 import psycopg
 from psycopg.rows import dict_row
 from psycopg.sql import SQL
+import json
 from flask import current_app, request, url_for, Blueprint
 from geovisio.web.utils import (
     STAC_VERSION,
@@ -34,8 +32,6 @@ from geovisio.web.utils import (
     removeNoneInDict,
 )
 from geovisio.workers import runner_pictures
-import geovisio.utils.sequences
-from typing import Dict, Any
 
 
 bp = Blueprint("stac_collections", __name__, url_prefix="/api")
@@ -70,6 +66,7 @@ def dbSequenceToStacCollection(dbSeq, description="A sequence of geolocated pict
             "created": dbTsToStac(dbSeq["created"]),
             "updated": dbTsToStac(dbSeq.get("updated")),
             "geovisio:status": dbSeq.get("status"),
+            "geovisio:sorted-by": dbSeq.get("current_sort"),
             "providers": [
                 {"name": dbSeq["account_name"], "roles": ["producer"]},
             ],
@@ -274,7 +271,7 @@ def getAllCollections():
 
     additional_filters = request.args.get("filter")
 
-    pagination_links = get_pagination_links(
+    pagination_links = sequences.get_pagination_links(
         route="stac_collections.getAllCollections",
         routeArgs={"limit": collection_request.limit},
         field=sortBy.fields[0].field.stac,
@@ -331,37 +328,38 @@ def getCollection(collectionId):
         with conn.cursor() as cursor:
             record = cursor.execute(
                 """
-				SELECT
-					s.id,
-					s.metadata->>'title' AS name,
-					ST_XMin(s.geom) AS minx,
-					ST_YMin(s.geom) AS miny,
-					ST_XMax(s.geom) AS maxx,
-					ST_YMax(s.geom) AS maxy,
-					s.status AS status,
-					accounts.name AS account_name,
-					s.inserted_at AS created,
-	 				s.updated_at AS updated,
-					a.*
-				FROM sequences s
-				JOIN accounts ON s.account_id = accounts.id, (
-					SELECT
-						MIN(ts) as mints,
-						MAX(ts) as maxts,
-						array_agg(DISTINCT jsonb_build_object(
-							'make', metadata->>'make',
-							'model', metadata->>'model',
-							'focal_length', metadata->>'focal_length',
-							'field_of_view', metadata->>'field_of_view'
-						)) AS metas,
-						COUNT(*) AS nbpic
-					FROM pictures p
-					JOIN sequences_pictures sp ON sp.seq_id = %(id)s AND sp.pic_id = p.id
-				) a
-				WHERE s.id = %(id)s
-					AND (s.status != 'hidden' OR s.account_id = %(account)s)
-					AND s.status != 'deleted'
-			""",
+                SELECT
+                    s.id,
+                    s.metadata->>'title' AS name,
+                    ST_XMin(s.bbox) AS minx,
+                    ST_YMin(s.bbox) AS miny,
+                    ST_XMax(s.bbox) AS maxx,
+                    ST_YMax(s.bbox) AS maxy,
+                    s.status AS status,
+                    accounts.name AS account_name,
+                    s.inserted_at AS created,
+                    s.updated_at AS updated,
+                    s.current_sort AS current_sort,
+                    a.*,
+                    min_picture_ts AS mints,
+                    max_picture_ts AS maxts,
+                    nb_pictures AS nbpic
+                FROM sequences s
+                JOIN accounts ON s.account_id = accounts.id, (
+                    SELECT
+                        array_agg(DISTINCT jsonb_build_object(
+                            'make', metadata->>'make',
+                            'model', metadata->>'model',
+                            'focal_length', metadata->>'focal_length',
+                            'field_of_view', metadata->>'field_of_view'
+                        )) AS metas
+                    FROM pictures p
+                    JOIN sequences_pictures sp ON sp.seq_id = %(id)s AND sp.pic_id = p.id
+                ) a
+                WHERE s.id = %(id)s
+                    AND (s.status != 'hidden' OR s.account_id = %(account)s)
+                    AND s.status != 'deleted'
+            """,
                 params,
             ).fetchone()
 
@@ -411,17 +409,17 @@ def getCollectionThumbnail(collectionId):
         with conn.cursor() as cursor:
             records = cursor.execute(
                 """
-				SELECT
-					sp.pic_id
-				FROM sequences_pictures sp
-				JOIN pictures p ON sp.pic_id = p.id
-				JOIN sequences s ON sp.seq_id = s.id
-				WHERE
-					sp.seq_id = %(seq)s
-					AND (p.status = 'ready' OR p.account_id = %(account)s)
-					AND is_sequence_visible_by_user(s, %(account)s)
-				LIMIT 1
-			""",
+                SELECT
+                    sp.pic_id
+                FROM sequences_pictures sp
+                JOIN pictures p ON sp.pic_id = p.id
+                JOIN sequences s ON sp.seq_id = s.id
+                WHERE
+                    sp.seq_id = %(seq)s
+                    AND (p.status = 'ready' OR p.account_id = %(account)s)
+                    AND is_sequence_visible_by_user(s, %(account)s)
+                LIMIT 1
+            """,
                 params,
             ).fetchone()
 
@@ -464,7 +462,7 @@ def postCollection(account=None):
     # Parse received parameters
     metadata = {}
     content_type = request.headers.get("Content-Type")
-    if request.is_json:
+    if request.is_json and request.json:
         metadata["title"] = request.json.get("title")
     elif content_type in ["multipart/form-data", "application/x-www-form-urlencoded"]:
         metadata["title"] = request.form.get("title")
@@ -473,7 +471,7 @@ def postCollection(account=None):
 
     # Create sequence folder
     accountId = accountIdOrDefault(account)
-    seqId = geovisio.utils.sequences.createSequence(metadata, accountId)
+    seqId = sequences.createSequence(metadata, accountId)
 
     # Return created sequence
     return (
@@ -527,8 +525,8 @@ def patchCollection(collectionId, account):
     # Parse received parameters
     metadata = {}
     content_type = (request.headers.get("Content-Type") or "").split(";")[0]
-    for param in ["visible", "title"]:
-        if request.is_json:
+    for param in ["visible", "title", "relative_heading", "sortby"]:
+        if request.is_json and request.json:
             metadata[param] = request.json.get(param)
         elif content_type in ["multipart/form-data", "application/x-www-form-urlencoded"]:
             metadata[param] = request.form.get(param)
@@ -547,13 +545,29 @@ def patchCollection(collectionId, account):
         if not (isinstance(newTitle, str) and len(newTitle) <= 250):
             raise errors.InvalidAPIUsage("Sequence title is not valid, should be a string with a max of 250 characters", status_code=400)
 
+    # Check if sortby is valid
+    sortby = metadata.get("sortby")
+    if sortby is not None:
+        if sortby not in ["+gpsdate", "-gpsdate", "+filedate", "-filedate", "+filename", "-filename"]:
+            raise errors.InvalidAPIUsage("Sort order parameter is invalid", status_code=400)
+
+    # Check if relative_heading is valid
+    relHeading = metadata.get("relative_heading")
+    if relHeading is not None:
+        try:
+            relHeading = int(relHeading)
+            if relHeading < -180 or relHeading > 180:
+                raise ValueError()
+        except ValueError:
+            raise errors.InvalidAPIUsage("Relative heading is not valid, should be an integer in degrees from -180 to 180", status_code=400)
+
     # If no parameter is changed, no need to contact DB, just return sequence as is
-    if {visible, newTitle} == {None}:
+    if {visible, newTitle, relHeading, sortby} == {None}:
         return getCollection(collectionId)
 
     # Check if sequence exists and if given account is authorized to edit
     with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn, conn.cursor() as cursor:
-        seq = cursor.execute("SELECT status, metadata, account_id FROM sequences WHERE id = %s", [collectionId]).fetchone()
+        seq = cursor.execute("SELECT status, metadata, account_id, current_sort FROM sequences WHERE id = %s", [collectionId]).fetchone()
 
         # Sequence not found
         if not seq:
@@ -573,9 +587,8 @@ def patchCollection(collectionId, account):
                 f"Sequence {collectionId} is in {oldStatus} state, its visibility can't be changed for now", status_code=400
             )
 
-        # Let's edit this picture
         sqlUpdates = []
-        sqlParams = {"id": collectionId}
+        sqlParams = {"id": collectionId, "account": account.id}
 
         if visible is not None:
             newStatus = "ready" if visible is True else "hidden"
@@ -583,22 +596,57 @@ def patchCollection(collectionId, account):
                 sqlUpdates.append(SQL("status = %(status)s"))
                 sqlParams["status"] = newStatus
 
+        new_metadata = {}
         if newTitle is not None and oldTitle != newTitle:
-            sqlUpdates.append(SQL("metadata = jsonb_set(metadata, '{title}', %(title)s)"))
-            sqlParams["title"] = f'"{newTitle}"'
+            new_metadata["title"] = newTitle
+        if relHeading:
+            new_metadata["relative_heading"] = relHeading
+
+        if new_metadata:
+            sqlUpdates.append(SQL("metadata = metadata || %(new_metadata)s"))
+            from psycopg.types.json import Jsonb
+
+            sqlParams["new_metadata"] = Jsonb(new_metadata)
+
+        if sortby is not None:
+            sqlUpdates.append(SQL("current_sort = %(sort)s"))
+            sqlParams["sort"] = sortby
 
         if len(sqlUpdates) > 0:
+            # 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 sequences
-                SET {updates}
-                WHERE id = %(id)s
-            """
+                    UPDATE sequences
+                    SET {updates}
+                    WHERE id = %(id)s
+                    """
                 ).format(updates=SQL(", ").join(sqlUpdates)),
                 sqlParams,
             )
-            conn.commit()
+
+        # Edits picture sort order
+        if sortby is not None:
+            direction = sequences.Direction(sortby[0])
+            order = sequences.CollectionSortOrder(sortby[1:])
+            sequences.sort_collection(cursor, collectionId, sequences.CollectionSort(order=order, direction=direction))
+            if not relHeading:
+                # if we do not plan to override headings specifically, we recompute headings that have not bee provided by the users
+                # with the new movement track
+                sequences.update_headings(cursor, collectionId, editingAccount=account.id)
+
+        # Edits relative heading of pictures in sequence
+        if relHeading is not None:
+            # New heading is computed based on sequence movement track
+            #   We take each picture and its following, compute azimuth,
+            #   then add given relative heading to offset picture heading.
+            #   Last picture is computed based on previous one in sequence.
+            sequences.update_headings(cursor, collectionId, relativeHeading=relHeading, updateOnlyMissing=False, editingAccount=account.id)
+
+        conn.commit()
 
         # Redirect response to a classic GET
         return getCollection(collectionId)
@@ -665,7 +713,7 @@ def deleteCollection(collectionId, account):
                 INSERT INTO pictures_to_process(picture_id, task)
                     SELECT pic_id, 'delete' FROM picWithoutOtherSeq
                     ON CONFLICT (picture_id) DO UPDATE SET task = 'delete'
-			""",
+            """,
                 {"seq": collectionId},
             ).rowcount
 
@@ -681,7 +729,7 @@ def deleteCollection(collectionId, account):
                     SELECT pic_id FROM sequences_pictures WHERE pic_id IN (SELECT pic_id FROM pic2rm) AND seq_id != %(seq)s
                 )
                 UPDATE pictures SET status = 'waiting-for-delete' WHERE id IN (SELECT pic_id FROM picWithoutOtherSeq)
-			""",
+            """,
                 {"seq": collectionId},
             ).rowcount
 
@@ -722,6 +770,18 @@ def getCollectionImportStatus(collectionId):
     with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn:
         with conn.cursor() as cursor:
             sequence_status = cursor.execute(
+                SQL(
+                    """SELECT status 
+                    FROM sequences
+                    WHERE id = %(seq_id)s
+                        AND (status != 'hidden' OR account_id = %(account)s)-- show deleted sequence here"""
+                ),
+                params,
+            ).fetchone()
+            if sequence_status is None:
+                raise errors.InvalidAPIUsage("Sequence doesn't exists", status_code=404)
+
+            pics_status = cursor.execute(
                 """WITH
 pic_jobs_stats AS (
     SELECT
@@ -748,47 +808,37 @@ pic_jobs_stats AS (
     pic_jobs_stats.nb_errors,
     pic_jobs_stats.last_job_finished_at
     FROM sequences s
-    LEFT JOIN sequences_pictures sp ON sp.seq_id = s.id
-    LEFT JOIN pictures p ON sp.pic_id = p.id
+    JOIN sequences_pictures sp ON sp.seq_id = s.id
+    JOIN pictures p ON sp.pic_id = p.id
     LEFT JOIN pic_jobs_stats ON pic_jobs_stats.picture_id = p.id
     WHERE
                 s.id = %(seq_id)s
                 AND (p IS NULL OR p.status != 'hidden' OR p.account_id = %(account)s)
-                AND (s.status != 'hidden' OR s.account_id = %(account)s) -- show deleted sequence here
     ORDER BY s.id, sp.rank
 )
-SELECT json_build_object(
-        'status', s.status,
-        'items', json_agg(
-                    json_strip_nulls(
-                        json_build_object(
-                            'id', i.id,
-                            -- status is a bit deprecated, we'll split this field in more fields (like `processing_in_progress`, `hidden`, ...)
-                            -- but we maintain it for retrocompatibility
-                            'status', CASE 
-                                    WHEN i.is_job_running IS TRUE THEN 'preparing' 
-                                    WHEN i.last_job_error IS NOT NULL THEN 'broken' 
-                                    ELSE i.status
-                                END, 
-                            'processing_in_progress', i.is_job_running,
-                            'process_error', i.last_job_error,
-                            'nb_errors', i.nb_errors,
-                            'processed_at', i.last_job_finished_at,
-                            'rank', i.rank
-                        )
-                )
+SELECT json_strip_nulls(
+        json_build_object(
+            'id', i.id,
+            -- status is a bit deprecated, we'll split this field in more fields (like `processing_in_progress`, `hidden`, ...)
+            -- but we maintain it for retrocompatibility
+            'status', CASE 
+                    WHEN i.is_job_running IS TRUE THEN 'preparing' 
+                    WHEN i.last_job_error IS NOT NULL THEN 'broken' 
+                    ELSE i.status
+                END, 
+            'processing_in_progress', i.is_job_running,
+            'process_error', i.last_job_error,
+            'nb_errors', i.nb_errors,
+            'processed_at', i.last_job_finished_at,
+            'rank', i.rank
         )
-) AS sequence
-FROM items i
-JOIN sequences s on i.seq_id = s.id
-GROUP by s.id;""",
+    ) as pic_status
+FROM items i;""",
                 params,
             ).fetchall()
+            pics = [p["pic_status"] for p in pics_status if len(p["pic_status"]) > 0]
 
-            if len(sequence_status) == 0:
-                raise errors.InvalidAPIUsage("Sequence doesn't exists", status_code=404)
-
-            return sequence_status[0]["sequence"]
+            return {"status": sequence_status["status"], "items": pics}
 
 
 @bp.route("/users/<uuid:userId>/collection")
@@ -881,23 +931,23 @@ def getUserCollection(userId, userIdMatchesAccount=False):
             meta_collection = cursor.execute(
                 SQL(
                     """SELECT
-					COUNT(sp.pic_id) AS nbpic,
-					COUNT(s.id) AS nbseq,
-					MIN(p.ts) AS mints,
-					MAX(p.ts) AS maxts,
-					MIN(GREATEST(-180, ST_X(p.geom))) AS minx,
-					MIN(GREATEST(-90, ST_Y(p.geom))) AS miny,
-					MAX(LEAST(180, ST_X(p.geom))) AS maxx,
-					MAX(LEAST(90, ST_Y(p.geom))) AS maxy,
+                    COUNT(sp.pic_id) AS nbpic,
+                    COUNT(s.id) AS nbseq,
+                    MIN(p.ts) AS mints,
+                    MAX(p.ts) AS maxts,
+                    MIN(GREATEST(-180, ST_X(p.geom))) AS minx,
+                    MIN(GREATEST(-90, ST_Y(p.geom))) AS miny,
+                    MAX(LEAST(180, ST_X(p.geom))) AS maxx,
+                    MAX(LEAST(90, ST_Y(p.geom))) AS maxy,
                     MIN(s.inserted_at) AS created,
                     MAX(s.updated_at) AS updated,
                     MIN({order_column}) AS min_order,
                     MAX({order_column}) AS max_order
-				FROM sequences s
-				LEFT JOIN sequences_pictures sp ON s.id = sp.seq_id
-				LEFT JOIN pictures p on sp.pic_id = p.id
-				WHERE {filter}
-			    """
+                FROM sequences s
+                LEFT JOIN sequences_pictures sp ON s.id = sp.seq_id
+                LEFT JOIN pictures p on sp.pic_id = p.id
+                WHERE {filter}
+                """
                 ).format(
                     filter=SQL(" AND ").join(meta_filter),
                     order_column=collection_request.sort_by.fields[0].field.sql_filter,
@@ -955,7 +1005,7 @@ def getUserCollection(userId, userIdMatchesAccount=False):
         # if some filters were given, we continue to pass them to the pagination
         additional_filters = request.args.get("filter")
 
-    pagination_links = get_pagination_links(
+    pagination_links = sequences.get_pagination_links(
         route="stac_collections.getUserCollection",
         routeArgs={"userId": str(userId), "limit": collection_request.limit},
         field=sortBy.fields[0].field.stac,