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

geovisio/utils/sequences.py

@@ -1,14 +1,16 @@
 import psycopg
 from flask import current_app, url_for
+from flask_babel import gettext as _
 from psycopg.types.json import Jsonb
-from psycopg import sql
-from psycopg.sql import SQL
+from psycopg.sql import SQL, Composable
 from psycopg.rows import dict_row
 from dataclasses import dataclass, field
 from typing import Any, List, Dict, Optional
 import datetime
 from uuid import UUID
 from enum import Enum
+from geovisio.utils import db
+from geovisio.utils.auth import Account
 from geovisio.utils.fields import FieldMapping, SortBy, SQLDirection, BBox, Bounds
 from geopic_tag_reader import reader
 from pathlib import PurePath
@@ -17,30 +19,26 @@ import logging
 import sentry_sdk
 
 
-def createSequence(metadata, accountId) -> str:
-    with psycopg.connect(current_app.config["DB_URL"]) as conn:
-        with conn.cursor() as cursor:
-            # Add sequence in database
-            seqId = cursor.execute(
-                "INSERT INTO sequences(account_id, metadata) VALUES(%s, %s) RETURNING id", [accountId, Jsonb(metadata)]
-            ).fetchone()
-
-            # Make changes definitive in database
-            conn.commit()
-
-            if seqId is None:
-                raise Exception(f"impossible to insert sequence in database")
-            return seqId[0]
+def createSequence(metadata, accountId, user_agent: Optional[str] = None) -> UUID:
+    with db.execute(
+        current_app,
+        "INSERT INTO sequences(account_id, metadata, user_agent) VALUES(%s, %s, %s) RETURNING id",
+        [accountId, Jsonb(metadata), user_agent],
+    ) as r:
+        seqId = r.fetchone()
+        if seqId is None:
+            raise Exception("impossible to insert sequence in database")
+        return seqId[0]
 
 
 # Mappings from stac name to SQL names
 STAC_FIELD_MAPPINGS = {
     p.stac: p
     for p in [
-        FieldMapping(sql_column=sql.SQL("inserted_at"), stac="created"),
-        FieldMapping(sql_column=sql.SQL("updated_at"), stac="updated"),
-        FieldMapping(sql_column=sql.SQL("computed_capture_date"), stac="datetime"),
-        FieldMapping(sql_column=sql.SQL("status"), stac="status"),
+        FieldMapping(sql_column=SQL("inserted_at"), stac="created"),
+        FieldMapping(sql_column=SQL("updated_at"), stac="updated"),
+        FieldMapping(sql_column=SQL("computed_capture_date"), stac="datetime"),
+        FieldMapping(sql_column=SQL("status"), stac="status"),
     ]
 }
 STAC_FIELD_TO_SQL_FILTER = {p.stac: p.sql_filter.as_string(None) for p in STAC_FIELD_MAPPINGS.values()}
@@ -66,8 +64,8 @@ class CollectionsRequest:
     created_before: Optional[datetime.datetime] = None
     user_id: Optional[UUID] = None
     bbox: Optional[BBox] = None
-    user_filter: Optional[sql.SQL] = None
-    pagination_filter: Optional[sql.SQL] = None
+    user_filter: Optional[SQL] = None
+    pagination_filter: Optional[SQL] = None
     limit: int = 100
     userOwnsAllCollections: bool = False  # bool to represent that the user's asking for the collections is the owner of them
 
@@ -77,9 +75,8 @@ class CollectionsRequest:
 
 def get_collections(request: CollectionsRequest) -> Collections:
     # Check basic parameters
-    seq_filter: List[sql.Composable] = []
+    seq_filter: List[Composable] = []
     seq_params: dict = {}
-    pic_filter = [SQL("sp.seq_id = s.id")]
 
     # Sort-by parameter
     # Note for review: I'm not sure I understand this non nullity constraint, but if so, shouldn't all sortby fields be added ?
@@ -92,25 +89,25 @@ def get_collections(request: CollectionsRequest) -> Collections:
         seq_filter.append(SQL("s.account_id = %(account)s"))
         seq_params["account"] = request.user_id
 
-    if request.user_filter is None or "status" not in request.user_filter.as_string(None):
+    user_filter_str = request.user_filter.as_string(None) if request.user_filter is not None else None
+    if user_filter_str is None or "status" not in user_filter_str:
         # if the filter does not contains any `status` condition, we want to show only 'ready' collection to the general users, and non deleted one for the owner
         if not request.userOwnsAllCollections:
-            seq_filter.append(SQL("s.status = 'ready'"))
-            pic_filter.append(SQL("p.status = 'ready'"))
+            seq_filter.append(SQL("status = 'ready'"))
         else:
-            seq_filter.append(SQL("s.status != 'deleted'"))
+            seq_filter.append(SQL("status != 'deleted'"))
     else:
-        # else, even if there are status filter, we make sure not to show hidden pictures/sequence to non owner
-        if not request.userOwnsAllCollections:
-            seq_filter.append(SQL("s.status <> 'hidden'"))
-            pic_filter.append(SQL("p.status <> 'hidden'"))
+        if not request.userOwnsAllCollections and "'deleted'" not in user_filter_str:
+            # if there are status filter and we ask for deleted sequence, we also include hidden one and consider them as deleted
+            seq_filter.append(SQL("status <> 'hidden'"))
 
     status_field = None
     if request.userOwnsAllCollections:
         # only logged users can see detailed status
         status_field = SQL("s.status AS status")
     else:
-        status_field = SQL("CASE WHEN s.status = 'deleted' THEN s.status ELSE NULL END AS status")
+        # hidden sequence are marked as deleted, this way crawler can update their catalog
+        status_field = SQL("CASE WHEN s.status IN ('hidden', 'deleted') THEN 'deleted' ELSE s.status END AS status")
 
     # Datetime
     if request.min_dt is not None:
@@ -136,94 +133,92 @@ def get_collections(request: CollectionsRequest) -> Collections:
         seq_filter.append(SQL("s.inserted_at < %(created_before)s::timestamp with time zone"))
         seq_params["created_before"] = request.created_before
 
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn:
-        with conn.cursor() as cursor:
-            sqlSequencesRaw = SQL(
-                """
-                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}
+    with utils.db.cursor(current_app, row_factory=dict_row) as cursor:
+        sqlSequencesRaw = SQL(
             """
+            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,
+                s.account_id AS account_id,
+                ST_X(ST_PointN(ST_GeometryN(s.geom, 1), 1)) AS x1,
+                ST_Y(ST_PointN(ST_GeometryN(s.geom, 1), 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,
+                s.user_agent,
+                ROUND(ST_Length(s.geom::geography)) / 1000 AS length_km,
+                s.computed_h_pixel_density,
+                s.computed_gps_accuracy
+            FROM sequences s
+            LEFT JOIN accounts on s.account_id = accounts.id
+            WHERE {filter}
+            ORDER BY {order1}
+            LIMIT {limit}
+        """
+        )
+        sqlSequences = sqlSequencesRaw.format(
+            filter=SQL(" AND ").join(seq_filter),
+            order1=request.sort_by.as_sql(),
+            limit=request.limit,
+            status=status_field,
+        )
+
+        # Different request if we want the last n sequences
+        #  Useful for paginating from last page to first
+        if request.pagination_filter and (
+            (
+                request.sort_by.fields[0].direction == SQLDirection.ASC
+                and request.pagination_filter.as_string(None).startswith(f"({request.sort_by.fields[0].field.sql_filter.as_string(None)} <")
+            )
+            or (
+                request.sort_by.fields[0].direction == SQLDirection.DESC
+                and request.pagination_filter.as_string(None).startswith(f"({request.sort_by.fields[0].field.sql_filter.as_string(None)} >")
             )
-            sqlSequences = sqlSequencesRaw.format(
+        ):
+            base_query = sqlSequencesRaw.format(
                 filter=SQL(" AND ").join(seq_filter),
-                order1=request.sort_by.as_sql(),
+                order1=request.sort_by.revert(),
                 limit=request.limit,
-                pic_filter=SQL(" AND ").join(pic_filter),
                 status=status_field,
             )
-
-            # Different request if we want the last n sequences
-            #  Useful for paginating from last page to first
-            if request.pagination_filter and (
-                (
-                    request.sort_by.fields[0].direction == SQLDirection.ASC
-                    and request.pagination_filter.as_string(None).startswith(
-                        f"({request.sort_by.fields[0].field.sql_filter.as_string(None)} <"
-                    )
-                )
-                or (
-                    request.sort_by.fields[0].direction == SQLDirection.DESC
-                    and request.pagination_filter.as_string(None).startswith(
-                        f"({request.sort_by.fields[0].field.sql_filter.as_string(None)} >"
-                    )
-                )
-            ):
-                base_query = sqlSequencesRaw.format(
-                    filter=SQL(" AND ").join(seq_filter),
-                    order1=request.sort_by.revert(),
-                    limit=request.limit,
-                    pic_filter=SQL(" AND ").join(pic_filter),
-                    status=status_field,
-                )
-                sqlSequences = SQL(
-                    """
-                    SELECT *
-                    FROM ({base_query}) s
-                    ORDER BY {order2}
+            sqlSequences = SQL(
                 """
-                ).format(
-                    order2=request.sort_by.as_sql(),
-                    base_query=base_query,
-                )
-
-            records = cursor.execute(sqlSequences, seq_params).fetchall()
-
-            query_bounds = None
-            for s in records:
-                first_order_val = s.get(request.sort_by.fields[0].field.stac)
-                if first_order_val is None:
-                    continue
-                if query_bounds is None:
-                    query_bounds = Bounds(first_order_val, first_order_val)
-                else:
-                    query_bounds.update(first_order_val)
-
-            return Collections(
-                collections=records,
-                query_first_order_bounds=query_bounds,
+                SELECT *
+                FROM ({base_query}) s
+                ORDER BY {order2}
+            """
+            ).format(
+                order2=request.sort_by.as_sql(),
+                base_query=base_query,
             )
 
+        records = cursor.execute(sqlSequences, seq_params).fetchall()
+
+        query_bounds = None
+        for s in records:
+            first_order_val = s.get(request.sort_by.fields[0].field.stac)
+            if first_order_val is None:
+                continue
+            if query_bounds is None:
+                query_bounds = Bounds(first_order_val, first_order_val)
+            else:
+                query_bounds.update(first_order_val)
+
+        return Collections(
+            collections=records,
+            query_first_order_bounds=query_bounds,
+        )
+
 
 def get_pagination_links(
     route: str,
@@ -381,17 +376,23 @@ def sort_collection(db, collectionId: UUID, sortby: CollectionSort):
 
         if usedDateField is None:
             raise errors.InvalidAPIUsage(
-                "Sort by file date is not possible on this sequence (no file date information available on pictures)",
+                _("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]
+            if "ts_gps" in pm["metadata"]:
+                pm["sort"] = pm["metadata"]["ts_gps"]
+            else:
+                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]
+            if "ts_camera" in pm["metadata"]:
+                pm["sort"] = pm["metadata"]["ts_camera"]
+            else:
+                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:
@@ -400,7 +401,11 @@ def sort_collection(db, collectionId: UUID, sortby: CollectionSort):
         # 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",
+                _(
+                    "Sort using %(sort)s is not possible on this sequence, picture %(pic)s is missing mandatory metadata",
+                    sort=sortby,
+                    pic=pm["id"],
+                ),
                 status_code=422,
             )
 
@@ -476,10 +481,72 @@ def update_headings(
     )
 
 
-def update_pictures_grid(db) -> bool:
-    """Refreshes the pictures_grid materialized view for an up-to-date view of pictures availability on map.
+def add_finalization_job(cursor, seqId: UUID):
+    """
+    Add a sequence finalization job in the queue.
+    If there is already a finalization job, do nothing (changing it might cause a deadlock, since a worker could be processing this job)
+    """
+    cursor.execute(
+        """INSERT INTO 
+        job_queue(sequence_id, task)
+        VALUES (%(seq_id)s, 'finalize')
+        ON CONFLICT (sequence_id) DO NOTHING""",
+        {"seq_id": seqId},
+    )
 
-    Note: the transaction is not commited at the end, you need to commit it or use an autocommit connection.
+
+def finalize(cursor, seqId: UUID, logger: logging.Logger = logging.getLogger()):
+    """
+    Finalize a sequence, by updating its status and computed fields.
+    """
+    with sentry_sdk.start_span(description="Finalizing sequence") as span:
+        span.set_data("sequence_id", seqId)
+        logger.debug(f"Finalizing sequence {seqId}")
+
+        with utils.time.log_elapsed(f"Finalizing sequence {seqId}"):
+            # Complete missing headings in pictures
+            update_headings(cursor, seqId)
+
+            # Change sequence database status in DB
+            # Also generates data in computed columns
+            cursor.execute(
+                """WITH
+aggregated_pictures AS (
+SELECT
+    sp.seq_id, 
+    MIN(p.ts::DATE) AS day,
+    ARRAY_AGG(DISTINCT TRIM(
+        CONCAT(p.metadata->>'make', ' ', p.metadata->>'model')
+    )) AS models,
+    ARRAY_AGG(DISTINCT p.metadata->>'type') AS types,
+    ARRAY_AGG(DISTINCT p.h_pixel_density) AS reshpd,
+    PERCENTILE_CONT(0.9) WITHIN GROUP(ORDER BY p.gps_accuracy_m) AS gpsacc
+FROM sequences_pictures sp
+JOIN pictures p ON sp.pic_id = p.id
+WHERE sp.seq_id = %(seq)s
+GROUP BY sp.seq_id
+)
+UPDATE sequences
+SET
+status = CASE WHEN status = 'hidden' THEN 'hidden'::sequence_status ELSE 'ready'::sequence_status END, -- we don't want to change status if it's hidden
+geom = compute_sequence_geom(id),
+bbox = compute_sequence_bbox(id),
+computed_type = CASE WHEN array_length(types, 1) = 1 THEN types[1] ELSE NULL END,
+computed_model = CASE WHEN array_length(models, 1) = 1 THEN models[1] ELSE NULL END,
+computed_capture_date = day,
+computed_h_pixel_density = CASE WHEN array_length(reshpd, 1) = 1 THEN reshpd[1] ELSE NULL END,
+computed_gps_accuracy = gpsacc
+FROM aggregated_pictures
+WHERE id = %(seq)s
+            """,
+                {"seq": seqId},
+            )
+
+            logger.info(f"Sequence {seqId} is ready")
+
+
+def update_pictures_grid() -> Optional[datetime.datetime]:
+    """Refreshes the pictures_grid materialized view for an up-to-date view of pictures availability on map.
 
     Parameters
     ----------
@@ -490,17 +557,86 @@ def update_pictures_grid(db) -> bool:
     -------
     bool : True if the view has been updated else False
     """
+    from geovisio.utils import db
+
     logger = logging.getLogger("geovisio.picture_grid")
-    with db.transaction():
+
+    # get a connection outside of the connection pool in order to avoid
+    # the default statement timeout as this query can be very long
+    with db.long_queries_conn(current_app) as conn, conn.transaction():
         try:
-            db.execute("SELECT refreshed_at FROM refresh_database FOR UPDATE NOWAIT").fetchone()
+            conn.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):
+        with sentry_sdk.start_span(description="Refreshing database"):
+            with utils.time.log_elapsed("Refreshing database", logger=logger):
                 logger.info("Refreshing database")
-                db.execute("UPDATE refresh_database SET refreshed_at = NOW()")
-                db.execute("REFRESH MATERIALIZED VIEW pictures_grid")
+                conn.execute("UPDATE refresh_database SET refreshed_at = NOW()")
+                conn.execute("REFRESH MATERIALIZED VIEW CONCURRENTLY pictures_grid")
+
     return True
+
+
+def delete_collection(collectionId: UUID, account: Optional[Account]) -> int:
+    """
+    Mark a collection as deleted and delete all it's pictures.
+
+    Note that since the deletion as asynchronous, some workers need to be run in order for the deletion to be effective.
+    """
+    with db.conn(current_app) as conn:
+        with conn.transaction(), conn.cursor() as cursor:
+            sequence = cursor.execute(
+                "SELECT status, account_id FROM sequences WHERE id = %s AND status != 'deleted'", [collectionId]
+            ).fetchone()
+
+            # sequence not found
+            if not sequence:
+                raise errors.InvalidAPIUsage(_("Collection %(c)s wasn't found in database", c=collectionId), status_code=404)
+
+            # Account associated to sequence doesn't match current user
+            if account is not None and account.id != str(sequence[1]):
+                raise errors.InvalidAPIUsage("You're not authorized to edit this sequence", status_code=403)
+
+            logging.info(f"Asking for deletion of sequence {collectionId} and all its pictures")
+
+            # mark all the pictures as waiting for deletion for async removal as this can be quite long if the storage is slow and there are lots of pictures
+            # Note: To avoid a deadlock if some workers are currently also working on those picture to prepare them,
+            # the SQL queries are split in 2:
+            # - First a query to remove jobs preparing those pictures
+            # - Then a query deleting those pictures from the database (and a trigger will add async deletion tasks to the queue)
+            #
+            # Since the workers lock their job_queue row when working, at the end of this query, we know that there are no more workers working on those pictures,
+            # so we can delete them without fearing a deadlock.
+            cursor.execute(
+                """WITH pic2rm AS (
+                    SELECT pic_id FROM sequences_pictures WHERE seq_id = %(seq)s
+                ),
+                picWithoutOtherSeq AS (
+                    SELECT pic_id FROM pic2rm
+                    EXCEPT
+                    SELECT pic_id FROM sequences_pictures WHERE pic_id IN (SELECT pic_id FROM pic2rm) AND seq_id != %(seq)s
+                )
+                DELETE FROM job_queue WHERE picture_id IN (SELECT pic_id FROM picWithoutOtherSeq)""",
+                {"seq": collectionId},
+            ).rowcount
+            # if there was a finalize task for this collection in the queue, we remove it, it's useless
+            cursor.execute("""DELETE FROM job_queue WHERE sequence_id = %(seq)s""", {"seq": collectionId})
+
+            # after the task have been added to the queue, delete the pictures, and db triggers will ensure the correct deletion jobs are added
+            nb_updated = cursor.execute(
+                """WITH pic2rm AS (
+                    SELECT pic_id FROM sequences_pictures WHERE seq_id = %(seq)s
+                ),
+                picWithoutOtherSeq AS (
+                    SELECT pic_id FROM pic2rm
+                    EXCEPT
+                    SELECT pic_id FROM sequences_pictures WHERE pic_id IN (SELECT pic_id FROM pic2rm) AND seq_id != %(seq)s
+                )
+                DELETE FROM pictures WHERE id IN (SELECT pic_id FROM picWithoutOtherSeq)""",
+                {"seq": collectionId},
+            ).rowcount
+
+            cursor.execute("UPDATE sequences SET status = 'deleted' WHERE id = %s", [collectionId])
+            return nb_updated

geovisio/utils/tokens.py

@@ -1,11 +1,9 @@
 from geovisio import errors
-from geovisio.utils import auth
+from geovisio.utils import auth, db
 from geovisio.web.tokens import _decode_jwt_token, _generate_jwt_token
-
-
-import psycopg
 from authlib.jose.errors import BadSignatureError
 from flask import current_app
+from flask_babel import gettext as _
 from psycopg.rows import dict_row
 
 
@@ -14,7 +12,7 @@ import logging
 
 class InvalidTokenException(errors.InvalidAPIUsage):
     def __init__(self, details, status_code=401):
-        msg = f"Token not valid"
+        msg = "Token not valid"
         super().__init__(msg, status_code=status_code, payload={"details": {"error": details}})
 
 
@@ -39,39 +37,37 @@ def get_account_from_jwt_token(jwt_token: str) -> auth.Account:
     """
     try:
         decoded = _decode_jwt_token(jwt_token)
-    except BadSignatureError as e:
+    except BadSignatureError:
         logging.exception("invalid signature of jwt token")
-        raise InvalidTokenException("JWT token signature does not match")
+        raise InvalidTokenException(_("JWT token signature does not match"))
     token_id = decoded["sub"]
 
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn:
-        with conn.cursor() as cursor:
-            # check token existence
-            records = cursor.execute(
-                """
-                SELECT
-                    t.account_id AS id, a.name, a.oauth_provider, a.oauth_id
-                FROM tokens t
-                LEFT OUTER JOIN accounts a ON t.account_id = a.id
-                WHERE t.id = %(token)s
-            """,
-                {"token": token_id},
-            ).fetchone()
-            if not records:
-                raise InvalidTokenException("Token does not exist anymore", status_code=403)
-
-            if not records["id"]:
-                raise InvalidTokenException(
-                    "Token not yet claimed, this token cannot be used yet. Either claim this token or generate a new one", status_code=403
-                )
-
-            return auth.Account(
-                id=str(records["id"]),
-                name=records["name"],
-                oauth_provider=records["oauth_provider"],
-                oauth_id=records["oauth_id"],
+    with db.cursor(current_app, row_factory=dict_row) as cursor:
+        # check token existence
+        records = cursor.execute(
+            """SELECT
+    t.account_id AS id, a.name, a.oauth_provider, a.oauth_id, a.role
+FROM tokens t
+LEFT OUTER JOIN accounts a ON t.account_id = a.id
+WHERE t.id = %(token)s""",
+            {"token": token_id},
+        ).fetchone()
+        if not records:
+            raise InvalidTokenException(_("Token does not exist anymore"), status_code=403)
+
+        if not records["id"]:
+            raise InvalidTokenException(
+                _("Token not yet claimed, this token cannot be used yet. Either claim this token or generate a new one"), status_code=403
             )
 
+        return auth.Account(
+            id=str(records["id"]),
+            name=records["name"],
+            oauth_provider=records["oauth_provider"],
+            oauth_id=records["oauth_id"],
+            role=auth.AccountRole[records["role"]],
+        )
+
 
 def get_default_account_jwt_token() -> str:
     """
@@ -80,18 +76,17 @@ def get_default_account_jwt_token() -> str:
     Note: do not expose this method externally, only an instance administrator should be able to get the default account JWT token!
     """
 
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn:
-        with conn.cursor() as cursor:
-            # check token existence
-            records = cursor.execute(
-                """
+    with db.cursor(current_app, row_factory=dict_row) as cursor:
+        # check token existence
+        records = cursor.execute(
+            """
                 SELECT t.id AS id
                 FROM tokens t
                 JOIN accounts a ON t.account_id = a.id
                 WHERE a.is_default
             """
-            ).fetchone()
-            if not records:
-                raise Exception("Default account has no associated token")
+        ).fetchone()
+        if not records:
+            raise Exception("Default account has no associated token")
 
-            return _generate_jwt_token(records["id"])
+        return _generate_jwt_token(records["id"])