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

geovisio/__init__.py

@@ -1,6 +1,6 @@
 """GeoVisio API - Main"""
 
-__version__ = "2.4.0"
+__version__ = "2.6.0"
 
 import os
 from flask import Flask, jsonify, stream_template, send_from_directory, redirect
@@ -60,7 +60,8 @@ def create_app(test_config=None, app=None):
     app.config["FILESYSTEMS"] = filesystems.openFilesystemsFromConfig(app.config)
 
     # Check database connection and update its schema if needed
-    db_migrations.update_db_schema(app.config["DB_URL"])
+    if app.config.get("DB_CHECK_SCHEMA"):
+        db_migrations.update_db_schema(app.config["DB_URL"])
 
     if app.config.get("OAUTH_PROVIDER"):
         utils.auth.make_auth(app)

geovisio/admin_cli/__init__.py

@@ -58,8 +58,8 @@ def cleanup_cmd(sequencesids, full, database, cache, permanent_pictures):
 @bp.cli.command("process-sequences")
 @with_appcontext
 def process_sequences():
-    """Deprecated entry point, use https://gitlab.com/geovisio/cli to upload a sequence instead"""
-    logging.error("This function has been deprecated, use https://gitlab.com/geovisio/cli to upload a sequence instead.")
+    """Deprecated entry point, use https://gitlab.com/panoramax/clients/cli to upload a sequence instead"""
+    logging.error("This function has been deprecated, use https://gitlab.com/panoramax/clients/cli to upload a sequence instead.")
     logging.error(
         "To upload a sequence with this tool, install it with `pip install geovisio_cli`, then run:\ngeovisio upload --path <directory> --api-url <api-url>"
     )

geovisio/admin_cli/db.py

@@ -1,7 +1,9 @@
 from flask import Blueprint, current_app
 from flask.cli import with_appcontext
 import click
+import psycopg
 from geovisio import db_migrations
+from geovisio.utils import sequences
 
 bp = Blueprint("db", __name__)
 
@@ -25,3 +27,12 @@ def upgrade():
 def rollback(all):
     """Rollbacks the latest database migration"""
     db_migrations.rollback_db_schema(current_app.config["DB_URL"], all)
+
+
+@bp.cli.command("refresh")
+@with_appcontext
+def refresh():
+    """Refresh cached data (pictures_grid)"""
+    with psycopg.connect(current_app.config["DB_URL"]) as db:
+        sequences.update_pictures_grid(db)
+        db.commit()

geovisio/admin_cli/sequence_heading.py

@@ -1,7 +1,7 @@
 import logging
 import psycopg
 from flask import current_app
-from geovisio.workers.runner_pictures import updateSequenceHeadings
+from geovisio.utils.sequences import update_headings
 
 log = logging.getLogger("geovisio.cli.sequence_heading")
 
@@ -13,6 +13,6 @@ def setSequencesHeadings(sequences, value, overwrite):
             sequences = [r[0] for r in db.execute("SELECT id FROM sequences").fetchall()]
 
         for seq in sequences:
-            updateSequenceHeadings(db, seq, value, not overwrite)
+            update_headings(db, seq, value, not overwrite)
 
         log.info("Done processing %s sequences" % len(sequences))

geovisio/config_app.py

@@ -3,6 +3,8 @@ import os.path
 from urllib.parse import urlparse
 import datetime
 import logging
+from typing import Optional
+import croniter
 
 
 class DefaultConfig:
@@ -14,9 +16,14 @@ class DefaultConfig:
     PICTURE_PROCESS_DERIVATES_STRATEGY = "ON_DEMAND"
     API_BLUR_URL = None
     PICTURE_PROCESS_THREADS_LIMIT = 1
+    DB_CHECK_SCHEMA = True  # If True check the database schema, and do not start the api if not up to date
     API_PICTURES_LICENSE_SPDX_ID = None
     API_PICTURES_LICENSE_URL = None
     DEBUG_PICTURES_SKIP_FS_CHECKS_WITH_PUBLIC_URL = False
+    SESSION_COOKIE_HTTPONLY = False
+    PICTURE_PROCESS_REFRESH_CRON = (
+        "0 2 * * *"  # Background worker will refresh by default some stats at 2 o'clock in the night (local time of the server)
+    )
 
 
 def read_config(app, test_config):
@@ -38,6 +45,7 @@ def read_config(app, test_config):
         "DB_USERNAME",
         "DB_PASSWORD",
         "DB_NAME",
+        "DB_CHECK_SCHEMA",
         # API
         "API_BLUR_URL",
         "API_VIEWER_PAGE",
@@ -51,6 +59,7 @@ def read_config(app, test_config):
         # Picture process
         "PICTURE_PROCESS_DERIVATES_STRATEGY",
         "PICTURE_PROCESS_THREADS_LIMIT",
+        "PICTURE_PROCESS_REFRESH_CRON",
         # OAUTH
         "OAUTH_PROVIDER",
         "OAUTH_OIDC_URL",
@@ -106,6 +115,8 @@ def read_config(app, test_config):
 
         app.config["DB_URL"] = f"postgres://{username}:{passw}@{host}:{port}/{dbname}"
 
+    app.config["DB_CHECK_SCHEMA"] = _read_bool(app.config, "DB_CHECK_SCHEMA")
+
     if app.config.get("API_BLUR_URL") is not None and len(app.config.get("API_BLUR_URL")) > 0:
         try:
             urlparse(app.config.get("API_BLUR_URL"))
@@ -155,6 +166,9 @@ def read_config(app, test_config):
     if app.config.get("API_PICTURES_LICENSE_SPDX_ID") is None:
         app.config["API_PICTURES_LICENSE_SPDX_ID"] = "proprietary"
 
+    cron_val = app.config["PICTURE_PROCESS_REFRESH_CRON"]
+    if not croniter.croniter.is_valid(cron_val):
+        raise Exception(f"PICTURE_PROCESS_REFRESH_CRON should be a valid cron syntax, got '{cron_val}'")
     #
     # Add generated config vars
     #
@@ -164,6 +178,17 @@ def read_config(app, test_config):
     app.config["EXECUTOR_PROPAGATE_EXCEPTIONS"] = True  # propagate the excecutor's exceptions, to be able to trace them
 
 
+def _read_bool(config, value_name: str) -> Optional[bool]:
+    value = config.get(value_name)
+    if value is None:
+        return value
+    if type(value) == bool:
+        return value
+    if type(value) == str:
+        return value.lower() == "true"
+    raise Exception(f"Configuration {value_name} should either be a boolean or a string, got '{value}'")
+
+
 def _get_threads_limit(param: str) -> int:
     """Computes maximum thread limit depending on environment variables and available CPU.
 

geovisio/templates/main.html

@@ -67,7 +67,7 @@
 			+'<div id="viewer" style="width: 500px; height: 300px"></div>\n\n'
 			+'&lt;script>\n'
 			+'\t// All options available are listed here\n'
-			+'\t// https://gitlab.com/geovisio/web-viewer/-/blob/develop/docs/02_Usage.md\n'
+			+'\t// https://gitlab.com/panoramax/clients/web-viewer/-/blob/develop/docs/02_Usage.md\n'
 			+'\tvar instance = new GeoVisio.default(\n'
 			+'\t\t"viewer",\n'
 			+'\t\t"'+baseUrl+'/api",\n'
@@ -85,7 +85,7 @@
 		-
 		<a href="/api/docs/swagger">API docs</a>
 		-
-		<a href="https://gitlab.com/geovisio/web-viewer/-/tree/develop/docs">JS library docs</a>
+		<a href="https://gitlab.com/panoramax/clients/web-viewer/-/tree/develop/docs">JS library docs</a>
 		-
 		<a href="https://gitlab.com/geovisio">Repositories</a>
 	</p>

geovisio/utils/pictures.py

@@ -1,5 +1,5 @@
 import math
-from typing import Optional
+from typing import Dict, Optional
 from flask import current_app, redirect, send_file
 import os
 import psycopg
@@ -526,7 +526,7 @@ def insertNewPictureInDatabase(db, sequenceId, position, pictureBytes, associate
 
     # Create a fully-featured metadata object
     picturePillow = Image.open(io.BytesIO(pictureBytes))
-    metadata = readPictureMetadata(pictureBytes, True) | utils.pictures.getPictureSizing(picturePillow) | addtionalMetadata
+    metadata = readPictureMetadata(pictureBytes) | utils.pictures.getPictureSizing(picturePillow) | addtionalMetadata
 
     # Remove cols/rows information for flat pictures
     if metadata["type"] == "flat":
@@ -537,23 +537,26 @@ def insertNewPictureInDatabase(db, sequenceId, position, pictureBytes, associate
     lighterMetadata = dict(filter(lambda v: v[0] not in ["ts", "heading", "lon", "lat", "exif"], metadata.items()))
     if lighterMetadata.get("tagreader_warnings") is not None and len(lighterMetadata["tagreader_warnings"]) == 0:
         del lighterMetadata["tagreader_warnings"]
+    lighterMetadata["tz"] = metadata["ts"].tzname()
+
+    exif = cleanupExif(metadata["exif"])
 
     with db.transaction():
         # Add picture metadata to database
         picId = db.execute(
             """
 			INSERT INTO pictures (ts, heading, metadata, geom, account_id, exif)
-			VALUES (to_timestamp(%s), %s, %s, ST_SetSRID(ST_MakePoint(%s, %s), 4326), %s, %s)
+			VALUES (%s, %s, %s, ST_SetSRID(ST_MakePoint(%s, %s), 4326), %s, %s)
 			RETURNING id
 		""",
             (
-                metadata["ts"],
+                metadata["ts"].isoformat(),
                 metadata["heading"],
                 Jsonb(lighterMetadata),
                 metadata["lon"],
                 metadata["lat"],
                 associatedAccountID,
-                Jsonb(metadata["exif"]),
+                Jsonb(exif),
             ),
         ).fetchone()[0]
 
@@ -600,7 +603,39 @@ def insertNewPictureInDatabase(db, sequenceId, position, pictureBytes, associate
     return picId
 
 
-def readPictureMetadata(picture: bytes, fullExif=False) -> dict:
+# Note: we don't want to store and expose exif binary fields as they are difficult to use and take a lot of storage in the database (~20% for maker notes only)
+# This list has been queried from real data (cf [this comment](https://gitlab.com/panoramax/server/api/-/merge_requests/241#note_1790580636)).
+# Update this list (and do a sql migration) if new binary fields are added
+BLACK_LISTED_BINARY_EXIF_FIELDS = set(
+    [
+        "Exif.Photo.MakerNote",
+        "Exif.Photo.0xea1c",
+        "Exif.Image.0xea1c",
+        "Exif.Canon.CameraInfo",
+        "Exif.Image.PrintImageMatching",
+        "Exif.Image.0xc6d3",
+        "Exif.Panasonic.FaceDetInfo",
+        "Exif.Panasonic.DataDump",
+        "Exif.Image.0xc6d2",
+        "Exif.Canon.CustomFunctions",
+        "Exif.Canon.AFInfo",
+        "Exif.Canon.0x4011",
+        "Exif.Canon.0x4019",
+        "Exif.Canon.ColorData",
+        "Exif.Canon.DustRemovalData",
+        "Exif.Canon.VignettingCorr",
+        "Exif.Canon.AFInfo3",
+        "Exif.Canon.0x001f",
+        "Exif.Canon.0x0018",
+        "Exif.Canon.ContrastInfo",
+        "Exif.Canon.0x002e",
+        "Exif.Canon.0x0022",
+        "Exif.Photo.0x9aaa",
+    ]
+)
+
+
+def readPictureMetadata(picture: bytes) -> dict:
     """Extracts metadata from picture file
 
     Parameters
@@ -621,29 +656,39 @@ def readPictureMetadata(picture: bytes, fullExif=False) -> dict:
     except Exception as e:
         raise MetadataReadingError(details=str(e))
 
-    if not fullExif:
-        metadata.pop("exif")
-    else:
-        # Cleanup raw EXIF tags to avoid SQL issues
-        cleanedExif = dict()
-
-        for k, v in metadata["exif"].items():
-            try:
-                if isinstance(v, bytes):
-                    try:
-                        cleanedExif[k] = v.decode("utf-8").replace("\x00", "")
-                    except UnicodeDecodeError:
-                        cleanedExif[k] = str(v).replace("\x00", "")
-                elif isinstance(v, str):
-                    cleanedExif[k] = v.replace("\x00", "")
-                else:
-                    try:
-                        cleanedExif[k] = str(v)
-                    except:
-                        logging.warning("Unsupported EXIF tag conversion: " + k + " " + str(type(v)))
-            except:
-                logging.exception("Can't read EXIF tag: " + k + " " + str(type(v)))
-
-        metadata["exif"] = cleanedExif
+    # Cleanup raw EXIF tags to avoid SQL issues
+    cleanedExif = {}
+    for k, v in metadata["exif"].items():
+        if k in BLACK_LISTED_BINARY_EXIF_FIELDS:
+            continue
+        try:
+            if isinstance(v, bytes):
+                try:
+                    cleanedExif[k] = v.decode("utf-8").replace("\x00", "")
+                except UnicodeDecodeError:
+                    cleanedExif[k] = str(v).replace("\x00", "")
+            elif isinstance(v, str):
+                cleanedExif[k] = v.replace("\x00", "")
+            else:
+                try:
+                    cleanedExif[k] = str(v)
+                except:
+                    logging.warning("Unsupported EXIF tag conversion: " + k + " " + str(type(v)))
+        except:
+            logging.exception("Can't read EXIF tag: " + k + " " + str(type(v)))
 
     return metadata
+
+
+def cleanupExif(exif: Optional[Dict[str, str]]) -> Optional[Dict[str, str]]:
+    """Removes binary fields from exif
+    >>> cleanupExif({'A': 'B', 'Exif.Canon.AFInfo': 'Blablabla'})
+    {'A': 'B'}
+    >>> cleanupExif({'A': 'B', 'Exif.Photo.MakerNote': 'Blablabla'})
+    {'A': 'B'}
+    """
+
+    if exif is None:
+        return None
+
+    return {k: v for k, v in exif.items() if k not in BLACK_LISTED_BINARY_EXIF_FIELDS}

geovisio/utils/sequences.py

@@ -5,10 +5,16 @@ from psycopg import sql
 from psycopg.sql import SQL
 from psycopg.rows import dict_row
 from dataclasses import dataclass, field
-from typing import Any, List, Dict, Optional, Generic, TypeVar, Protocol
+from typing import Any, List, Dict, Optional
 import datetime
 from uuid import UUID
-from geovisio.utils.fields import FieldMapping, SortBy, SortByField, SQLDirection, BBox, Bounds
+from enum import Enum
+from geovisio.utils.fields import FieldMapping, SortBy, SQLDirection, BBox, Bounds
+from geopic_tag_reader import reader
+from pathlib import PurePath
+from geovisio import errors, utils
+import logging
+import sentry_sdk
 
 
 def createSequence(metadata, accountId) -> str:
@@ -115,7 +121,7 @@ def get_collections(request: CollectionsRequest) -> Collections:
         seq_params["cmaxdate"] = request.max_dt
 
     if request.bbox is not None:
-        seq_filter.append(SQL("s.geom && ST_MakeEnvelope(%(minx)s, %(miny)s, %(maxx)s, %(maxy)s, 4326)"))
+        seq_filter.append(SQL("ST_Intersects(s.geom, ST_MakeEnvelope(%(minx)s, %(miny)s, %(maxx)s, %(maxy)s, 4326))"))
         seq_params["minx"] = request.bbox.minx
         seq_params["miny"] = request.bbox.miny
         seq_params["maxx"] = request.bbox.maxx
@@ -134,37 +140,29 @@ def get_collections(request: CollectionsRequest) -> Collections:
         with conn.cursor() as cursor:
             sqlSequencesRaw = SQL(
                 """
-                SELECT * FROM (
-                    SELECT
-                        s.id,
-                        s.status,
-                        s.metadata->>'title' AS name,
-                        s.inserted_at AS created,
-                        s.updated_at AS updated,
-                        ST_XMin(s.geom) AS minx,
-                        ST_YMin(s.geom) AS miny,
-                        ST_XMax(s.geom) AS maxx,
-                        ST_YMax(s.geom) AS maxy,
-                        accounts.name AS account_name,
-                        ST_X(ST_PointN(s.geom, 1)) AS x1,
-                        ST_Y(ST_PointN(s.geom, 1)) AS y1,
-                        {status},
-                        s.computed_capture_date AS datetime
-                    FROM sequences s
-                    LEFT JOIN accounts on s.account_id = accounts.id
-                    WHERE {filter}
-                    ORDER BY {order1}
-                    LIMIT {limit}
-                ) s
-                LEFT JOIN LATERAL (
-                    SELECT MIN(p.ts) as mints,
-                            MAX(p.ts) as maxts,
-                            COUNT(p.*) AS nbpic
-                    FROM sequences_pictures sp
-                    JOIN pictures p ON sp.pic_id = p.id
-                    WHERE {pic_filter}
-                    GROUP BY sp.seq_id
-                ) sub ON true
+                SELECT
+                    s.id,
+                    s.status,
+                    s.metadata->>'title' AS name,
+                    s.inserted_at AS created,
+                    s.updated_at AS updated,
+                    ST_XMin(s.bbox) AS minx,
+                    ST_YMin(s.bbox) AS miny,
+                    ST_XMax(s.bbox) AS maxx,
+                    ST_YMax(s.bbox) AS maxy,
+                    accounts.name AS account_name,
+                    ST_X(ST_PointN(s.geom, 1)) AS x1,
+                    ST_Y(ST_PointN(s.geom, 1)) AS y1,
+                    s.min_picture_ts AS mints,
+                    s.max_picture_ts AS maxts,
+                    s.nb_pictures AS nbpic,
+                    {status},
+                    s.computed_capture_date AS datetime
+                FROM sequences s
+                LEFT JOIN accounts on s.account_id = accounts.id
+                WHERE {filter}
+                ORDER BY {order1}
+                LIMIT {limit}
             """
             )
             sqlSequences = sqlSequencesRaw.format(
@@ -306,3 +304,203 @@ def get_pagination_links(
         )
 
     return links
+
+
+class Direction(Enum):
+    """Represent the sort direction"""
+
+    ASC = "+"
+    DESC = "-"
+
+    def is_reverse(self):
+        return self == Direction.DESC
+
+
+class CollectionSortOrder(Enum):
+    """Represent the sort order"""
+
+    FILE_DATE = "filedate"
+    FILE_NAME = "filename"
+    GPS_DATE = "gpsdate"
+
+
+@dataclass
+class CollectionSort:
+    order: CollectionSortOrder
+    direction: Direction
+
+    def as_str(self) -> str:
+        return f"{self.direction.value}{self.order.value}"
+
+
+def sort_collection(db, collectionId: UUID, sortby: CollectionSort):
+    """
+    Sort a collection by a given parameter
+
+    Note: the transaction is not commited at the end, you need to commit it or use an autocommit connection
+    """
+
+    # Remove existing order, and keep list of pictures IDs
+    picIds = db.execute(
+        SQL(
+            """
+            DELETE FROM sequences_pictures
+            WHERE seq_id = %(id)s
+            RETURNING pic_id
+            """
+        ),
+        {"id": collectionId},
+    ).fetchall()
+    picIds = [p["pic_id"] for p in picIds]
+
+    # Fetch metadata and EXIF tags of concerned pictures
+    picMetas = db.execute(SQL("SELECT id, metadata, exif FROM pictures WHERE id = ANY(%s)"), [picIds]).fetchall()
+    usedDateField = None
+    isFileNameNumeric = False
+
+    if sortby.order == CollectionSortOrder.FILE_NAME:
+        # Check if filenames are numeric
+        try:
+            for pm in picMetas:
+                int(PurePath(pm["metadata"]["originalFileName"] or "").stem)
+            isFileNameNumeric = True
+        except ValueError:
+            pass
+
+    if sortby.order == CollectionSortOrder.FILE_DATE:
+        # Look out what EXIF field is used for storing dates in this sequence
+        for field in [
+            "Exif.Image.DateTimeOriginal",
+            "Exif.Photo.DateTimeOriginal",
+            "Exif.Image.DateTime",
+            "Xmp.GPano.SourceImageCreateTime",
+        ]:
+            if field in picMetas[0]["exif"]:
+                usedDateField = field
+                break
+
+        if usedDateField is None:
+            raise errors.InvalidAPIUsage(
+                "Sort by file date is not possible on this sequence (no file date information available on pictures)",
+                status_code=422,
+            )
+
+    for pm in picMetas:
+        # Find value for wanted sort
+        if sortby.order == CollectionSortOrder.GPS_DATE:
+            pm["sort"] = reader.decodeGPSDateTime(pm["exif"], "Exif.GPSInfo")[0]
+        elif sortby.order == CollectionSortOrder.FILE_DATE:
+            assert usedDateField  # nullity has been checked before
+            pm["sort"] = reader.decodeDateTimeOriginal(pm["exif"], usedDateField)[0]
+        elif sortby.order == CollectionSortOrder.FILE_NAME:
+            pm["sort"] = pm["metadata"].get("originalFileName")
+            if isFileNameNumeric:
+                pm["sort"] = int(PurePath(pm["sort"]).stem)
+
+        # Fail if sort value is missing
+        if pm["sort"] is None:
+            raise errors.InvalidAPIUsage(
+                f"Sort using {sortby} is not possible on this sequence, picture {pm['id']} is missing mandatory metadata",
+                status_code=422,
+            )
+
+    # Actual sorting of pictures
+    picMetas.sort(key=lambda p: p["sort"], reverse=sortby.direction.is_reverse())
+    picForDb = [(collectionId, i + 1, p["id"]) for i, p in enumerate(picMetas)]
+
+    # Inject back pictures in sequence
+    db.executemany(
+        SQL(
+            """
+            INSERT INTO sequences_pictures(seq_id, rank, pic_id)
+            VALUES (%s, %s, %s)
+            """
+        ),
+        picForDb,
+    )
+
+
+def update_headings(
+    db,
+    sequenceId: UUID,
+    editingAccount: Optional[UUID] = None,
+    relativeHeading: int = 0,
+    updateOnlyMissing: bool = True,
+):
+    """Defines pictures heading according to sequence path.
+    Database is not committed in this function, to make entry definitively stored
+    you have to call db.commit() after or use an autocommit connection.
+
+    Parameters
+    ----------
+    db : psycopg.Connection
+            Database connection
+    sequenceId : uuid
+            The sequence's uuid, as stored in the database
+    relativeHeading : int
+            Camera relative orientation compared to path, in degrees clockwise.
+            Example: 0° = looking forward, 90° = looking to right, 180° = looking backward, -90° = looking left.
+    updateOnlyMissing : bool
+            If true, doesn't change existing heading values in database
+    """
+
+    db.execute(
+        SQL(
+            """
+		WITH h AS (
+			SELECT
+				p.id,
+                p.heading AS old_heading,
+				CASE
+					WHEN LEAD(sp.rank) OVER othpics IS NULL AND LAG(sp.rank) OVER othpics IS NULL
+						THEN NULL
+					WHEN LEAD(sp.rank) OVER othpics IS NULL
+						THEN (360 + FLOOR(DEGREES(ST_Azimuth(LAG(p.geom) OVER othpics, p.geom)))::int + (%(diff)s %% 360)) %% 360
+					ELSE
+						(360 + FLOOR(DEGREES(ST_Azimuth(p.geom, LEAD(p.geom) OVER othpics)))::int + (%(diff)s %% 360)) %% 360
+				END AS heading
+			FROM pictures p
+			JOIN sequences_pictures sp ON sp.pic_id = p.id AND sp.seq_id = %(seq)s
+			WINDOW othpics AS (ORDER BY sp.rank)
+		) 
+		UPDATE pictures p
+		SET heading = h.heading, heading_computed = true {editing_account}
+		FROM h
+		WHERE h.id = p.id {update_missing}
+		"""
+        ).format(
+            update_missing=SQL(" AND (p.heading IS NULL OR p.heading = 0 OR p.heading_computed)") if updateOnlyMissing else SQL(""),
+            editing_account=SQL(", last_account_to_edit = %(account)s") if editingAccount is not None else SQL(""),
+        ),  # lots of camera have heading set to 0 for unset heading, so we recompute the heading when it's 0 too, even if this could be a valid value
+        {"seq": sequenceId, "diff": relativeHeading, "account": editingAccount},
+    )
+
+
+def update_pictures_grid(db) -> bool:
+    """Refreshes the pictures_grid materialized view for an up-to-date view of pictures availability on map.
+
+    Note: the transaction is not commited at the end, you need to commit it or use an autocommit connection.
+
+    Parameters
+    ----------
+    db : psycopg.Connection
+            Database connection
+
+    Returns
+    -------
+    bool : True if the view has been updated else False
+    """
+    logger = logging.getLogger("geovisio.picture_grid")
+    with db.transaction():
+        try:
+            db.execute("SELECT refreshed_at FROM refresh_database FOR UPDATE NOWAIT").fetchone()
+        except psycopg.errors.LockNotAvailable:
+            logger.info("Database refresh already in progress, nothing to do")
+            return False
+
+        with sentry_sdk.start_span(description="Refreshing database") as span:
+            with utils.time.log_elapsed(f"Refreshing database", logger=logger):
+                logger.info("Refreshing database")
+                db.execute("UPDATE refresh_database SET refreshed_at = NOW()")
+                db.execute("REFRESH MATERIALIZED VIEW pictures_grid")
+    return True

geovisio/web/auth.py

@@ -3,8 +3,9 @@ from flask import current_app, url_for, session, redirect, request, jsonify
 import psycopg
 from typing import Any
 from urllib.parse import quote
-from geovisio import utils
+from geovisio import utils, errors
 from geovisio.utils.auth import Account, ACCOUNT_KEY
+from authlib.integrations.base_client.errors import MismatchingStateError
 
 bp = flask.Blueprint("auth", __name__, url_prefix="/api/auth")
 
@@ -52,7 +53,19 @@ def auth():
                     schema:
                         type: string
     """
-    tokenResponse = utils.auth.oauth_provider.client.authorize_access_token()
+    try:
+        tokenResponse = utils.auth.oauth_provider.client.authorize_access_token()
+    except MismatchingStateError as e:
+        raise errors.InternalError(
+            "Impossible to finish authentication flow",
+            payload={
+                "details": {
+                    "error": str(e),
+                    "tips": "You can try to clear your cookies and retry. If the problem persists, contact your instance administrator.",
+                }
+            },
+            status_code=403,
+        )
 
     oauth_info = utils.auth.oauth_provider.get_user_oauth_info(tokenResponse)
     with psycopg.connect(current_app.config["DB_URL"]) as conn: