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

geovisio/web/stac.py

@@ -1,8 +1,8 @@
-import psycopg
 from psycopg.sql import SQL
 from flask import Blueprint, current_app, request, url_for
+from flask_babel import gettext as _
 from geovisio import errors
-from geovisio.utils import auth
+from geovisio.utils import auth, db
 from psycopg.rows import dict_row
 from geovisio.utils.fields import SortBy, SQLDirection, Bounds, SortByField
 from geovisio.web.utils import (
@@ -14,6 +14,7 @@ from geovisio.web.utils import (
     get_root_link,
     removeNoneInDict,
     user_dependant_response,
+    get_api_version,
 )
 from geovisio.utils.sequences import (
     get_collections,
@@ -57,140 +58,134 @@ def getLanding():
                         $ref: '#/components/schemas/GeoVisioLanding'
     """
 
-    with psycopg.connect(current_app.config["DB_URL"]) as conn:
-        with conn.cursor() as cursor:
-            spatial_xmin, spatial_ymin, spatial_xmax, spatial_ymax, temporal_min, temporal_max = cursor.execute(
-                """
-				SELECT
-					GREATEST(-180, ST_XMin(ST_EstimatedExtent('pictures', 'geom'))),
-					GREATEST(-90, ST_YMin(ST_EstimatedExtent('pictures', 'geom'))),
-					LEAST(180, ST_XMax(ST_EstimatedExtent('pictures', 'geom'))),
-					LEAST(90, ST_YMax(ST_EstimatedExtent('pictures', 'geom'))),
-					MIN(ts), MAX(ts)
-				FROM pictures
-			"""
-            ).fetchone()
-
-            extent = (
-                cleanNoneInDict(
-                    {
-                        "spatial": (
-                            {"bbox": [[spatial_xmin, spatial_ymin, spatial_xmax, spatial_ymax]]} if spatial_xmin is not None else None
-                        ),
-                        "temporal": (
-                            {"interval": [[dbTsToStac(temporal_min), dbTsToStac(temporal_max)]]} if temporal_min is not None else None
-                        ),
-                    }
-                )
-                if spatial_xmin is not None or temporal_min is not None
-                else None
+    with db.cursor(current_app) as cursor:
+        spatial_xmin, spatial_ymin, spatial_xmax, spatial_ymax, temporal_min, temporal_max = cursor.execute(
+            """SELECT
+                GREATEST(-180, ST_XMin(ST_EstimatedExtent('pictures', 'geom'))),
+                GREATEST(-90, ST_YMin(ST_EstimatedExtent('pictures', 'geom'))),
+                LEAST(180, ST_XMax(ST_EstimatedExtent('pictures', 'geom'))),
+                LEAST(90, ST_YMax(ST_EstimatedExtent('pictures', 'geom'))),
+                MIN(ts), MAX(ts)
+            FROM pictures
+        """
+        ).fetchone()
+
+        extent = (
+            cleanNoneInDict(
+                {
+                    "spatial": ({"bbox": [[spatial_xmin, spatial_ymin, spatial_xmax, spatial_ymax]]} if spatial_xmin is not None else None),
+                    "temporal": (
+                        {"interval": [[dbTsToStac(temporal_min), dbTsToStac(temporal_max)]]} if temporal_min is not None else None
+                    ),
+                }
             )
+            if spatial_xmin is not None or temporal_min is not None
+            else None
+        )
 
-            sequences = [
-                {"rel": "child", "title": f'User "{s[1]}" sequences', "href": url_for("stac.getUserCatalog", userId=s[0], _external=True)}
-                for s in cursor.execute(
-                    """
-					SELECT DISTINCT s.account_id, a.name
-					FROM sequences s
-					JOIN accounts a ON s.account_id = a.id
-				"""
-                ).fetchall()
-            ]
+        catalog = dbSequencesToStacCatalog(
+            id="geovisio",
+            title=current_app.config["API_SUMMARY"].name.get("en"),
+            description=current_app.config["API_SUMMARY"].description.get("en"),
+            sequences=[],
+            request=request,
+            extent=extent,
+        )
 
-            catalog = dbSequencesToStacCatalog(
-                "geovisio",
-                "GeoVisio STAC API",
-                "This catalog list all geolocated pictures available in this GeoVisio instance",
-                sequences,
-                request,
-                extent,
-            )
+        catalog["geovisio_version"] = get_api_version()
 
-            mapUrl = (
-                url_for("map.getTile", x="111", y="222", z="333", format="mvt", _external=True)
-                .replace("111", "{x}")
-                .replace("222", "{y}")
-                .replace("333", "{z}")
-            )
-            userMapUrl = (
-                url_for("map.getUserTile", userId="bob", x="111", y="222", z="333", format="mvt", _external=True)
-                .replace("111", "{x}")
-                .replace("222", "{y}")
-                .replace("333", "{z}")
-                .replace("bob", "{userId}")
-            )
-            userStyleUrl = url_for("map.getUserStyle", userId="bob", _external=True).replace("bob", "{userId}")
-
-            if "stac_extensions" not in catalog:
-                catalog["stac_extensions"] = []
-
-            catalog["stac_extensions"] += ["https://stac-extensions.github.io/web-map-links/v1.0.0/schema.json"]
-
-            catalog["links"] += cleanNoneInList(
-                [
-                    {"rel": "service-desc", "type": "application/json", "href": url_for("flasgger.swagger", _external=True)},
-                    {"rel": "service-doc", "type": "text/html", "href": url_for("flasgger.apidocs", _external=True)},
-                    {"rel": "conformance", "type": "application/json", "href": url_for("stac.getConformance", _external=True)},
-                    {"rel": "data", "type": "application/json", "href": url_for("stac_collections.getAllCollections", _external=True)},
-                    {
-                        "rel": "data",
-                        "type": "application/rss+xml",
-                        "href": url_for("stac_collections.getAllCollections", _external=True, format="rss"),
-                    },
-                    {"rel": "search", "type": "application/geo+json", "href": url_for("stac_items.searchItems", _external=True)},
-                    {
-                        "rel": "xyz",
-                        "type": "application/vnd.mapbox-vector-tile",
-                        "href": mapUrl,
-                        "title": "Pictures and sequences vector tiles",
-                    },
-                    {
-                        "rel": "xyz-style",
-                        "type": "application/json",
-                        "href": url_for("map.getStyle", _external=True),
-                        "title": "MapLibre Style JSON",
-                    },
-                    {
-                        "rel": "user-xyz",
-                        "type": "application/vnd.mapbox-vector-tile",
-                        "href": userMapUrl,
-                        "title": "Pictures and sequences vector tiles for a given user",
-                    },
-                    {
-                        "rel": "user-xyz-style",
-                        "type": "application/json",
-                        "href": userStyleUrl,
-                        "title": "MapLibre Style JSON",
-                    },
-                    {
-                        "rel": "collection-preview",
-                        "type": "image/jpeg",
-                        "href": url_for("stac_collections.getCollectionThumbnail", collectionId="{id}", _external=True),
-                        "title": "Thumbnail URL for a given sequence",
-                    },
-                    {
-                        "rel": "item-preview",
-                        "type": "image/jpeg",
-                        "href": url_for("pictures.getPictureThumb", pictureId="{id}", format="jpg", _external=True),
-                        "title": "Thumbnail URL for a given picture",
-                    },
-                    {
-                        "rel": "users",
-                        "type": "application/json",
-                        "href": url_for("user.listUsers", _external=True),
-                        "title": "List of users",
-                    },
-                    {
-                        "rel": "user-search",
-                        "type": "application/json",
-                        "href": url_for("user.searchUser", _external=True),
-                        "title": "Search users",
-                    },
-                    get_license_link(),
-                ]
-            )
+        mapUrl = (
+            url_for("map.getTile", x="11111", y="22222", z="33333", format="mvt", _external=True)
+            .replace("11111", "{x}")
+            .replace("22222", "{y}")
+            .replace("33333", "{z}")
+        )
+        userMapUrl = (
+            url_for("map.getUserTile", userId="bob", x="11111", y="22222", z="33333", format="mvt", _external=True)
+            .replace("11111", "{x}")
+            .replace("22222", "{y}")
+            .replace("33333", "{z}")
+            .replace("bob", "{userId}")
+        )
+        userStyleUrl = url_for("map.getUserStyle", userId="bob", _external=True).replace("bob", "{userId}")
+
+        if "stac_extensions" not in catalog:
+            catalog["stac_extensions"] = []
+
+        catalog["stac_extensions"] += ["https://stac-extensions.github.io/web-map-links/v1.0.0/schema.json"]
+
+        catalog["links"] += cleanNoneInList(
+            [
+                {"rel": "service-desc", "type": "application/json", "href": url_for("flasgger.swagger", _external=True)},
+                {"rel": "service-doc", "type": "text/html", "href": url_for("flasgger.apidocs", _external=True)},
+                {"rel": "conformance", "type": "application/json", "href": url_for("stac.getConformance", _external=True)},
+                {"rel": "data", "type": "application/json", "href": url_for("stac_collections.getAllCollections", _external=True)},
+                {"rel": "child", "type": "application/json", "href": url_for("user.listUsers", _external=True)},
+                {
+                    "rel": "data",
+                    "type": "application/rss+xml",
+                    "href": url_for("stac_collections.getAllCollections", _external=True, format="rss"),
+                },
+                {"rel": "search", "type": "application/geo+json", "href": url_for("stac_items.searchItems", _external=True)},
+                {
+                    "rel": "xyz",
+                    "type": "application/vnd.mapbox-vector-tile",
+                    "href": mapUrl,
+                    "title": "Pictures and sequences vector tiles",
+                },
+                {
+                    "rel": "xyz-style",
+                    "type": "application/json",
+                    "href": url_for("map.getStyle", _external=True),
+                    "title": "MapLibre Style JSON",
+                },
+                {
+                    "rel": "user-xyz",
+                    "type": "application/vnd.mapbox-vector-tile",
+                    "href": userMapUrl,
+                    "title": "Pictures and sequences vector tiles for a given user",
+                },
+                {
+                    "rel": "user-xyz-style",
+                    "type": "application/json",
+                    "href": userStyleUrl,
+                    "title": "MapLibre Style JSON",
+                },
+                {
+                    "rel": "collection-preview",
+                    "type": "image/jpeg",
+                    "href": url_for("stac_collections.getCollectionThumbnail", collectionId="{id}", _external=True),
+                    "title": "Thumbnail URL for a given sequence",
+                },
+                {
+                    "rel": "item-preview",
+                    "type": "image/jpeg",
+                    "href": url_for("pictures.getPictureThumb", pictureId="{id}", format="jpg", _external=True),
+                    "title": "Thumbnail URL for a given picture",
+                },
+                {
+                    "rel": "users",
+                    "type": "application/json",
+                    "href": url_for("user.listUsers", _external=True),
+                    "title": "List of users",
+                },
+                {
+                    "rel": "user-search",
+                    "type": "application/json",
+                    "href": url_for("user.searchUser", _external=True),
+                    "title": "Search users",
+                },
+                {
+                    "rel": "report",
+                    "type": "application/json",
+                    "href": url_for("reports.postReport", _external=True),
+                    "title": "Post feedback/report about picture or sequence",
+                },
+                get_license_link(),
+            ]
+        )
 
-            return catalog, 200, {"Content-Type": "application/json"}
+        return catalog, 200, {"Content-Type": "application/json"}
 
 
 @bp.route("/conformance")
@@ -335,11 +330,11 @@ def getUserCatalog(userId, userIdMatchesAccount=False):
 
     userName = None
     meta_collection = None
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn, conn.cursor() as cursor:
+    with db.cursor(current_app, row_factory=dict_row) as cursor:
         userName = cursor.execute("SELECT name FROM accounts WHERE id = %s", [userId]).fetchone()
 
         if not userName:
-            raise errors.InvalidAPIUsage(f"Impossible to find user {userId}")
+            raise errors.InvalidAPIUsage(_("Impossible to find user %(u)s", u=userId))
         userName = userName["name"]
 
         meta_collection = cursor.execute(
@@ -349,7 +344,7 @@ def getUserCatalog(userId, userIdMatchesAccount=False):
 
         if not meta_collection or meta_collection["min_order"] is None:
             # No data found, trying to give the most meaningfull error message
-            raise errors.InvalidAPIUsage(f"No data loaded for user {userId}", 404)
+            raise errors.InvalidAPIUsage(_("No data loaded for user %(u)s", u=userId), 404)
 
     db_collections = get_collections(collection_request)
 

geovisio/web/tokens.py

@@ -1,13 +1,13 @@
 import flask
 from flask import current_app, url_for, request
+from flask_babel import gettext as _
 from dateutil import tz
-import psycopg
 from psycopg.rows import dict_row
 from authlib.jose import jwt
 from authlib.jose.errors import DecodeError
 import logging
 import uuid
-from geovisio.utils import auth
+from geovisio.utils import auth, db
 from geovisio import errors, utils
 
 
@@ -36,31 +36,29 @@ def list_tokens(account):
                         $ref: '#/components/schemas/GeoVisioTokens'
     """
 
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn:
-        with conn.cursor() as cursor:
-            records = cursor.execute(
-                """
-                SELECT id, description, generated_at FROM tokens WHERE account_id = %(account)s
-            """,
-                {"account": account.id},
-            ).fetchall()
-
-            tokens = [
+    records = db.fetchall(
+        current_app,
+        "SELECT id, description, generated_at FROM tokens WHERE account_id = %(account)s",
+        {"account": account.id},
+        row_factory=dict_row,
+    )
+
+    tokens = [
+        {
+            "id": r["id"],
+            "description": r["description"],
+            "generated_at": r["generated_at"].astimezone(tz.gettz("UTC")).isoformat(),
+            "links": [
                 {
-                    "id": r["id"],
-                    "description": r["description"],
-                    "generated_at": r["generated_at"].astimezone(tz.gettz("UTC")).isoformat(),
-                    "links": [
-                        {
-                            "rel": "self",
-                            "type": "application/json",
-                            "href": url_for("tokens.get_jwt_token", token_id=r["id"], _external=True),
-                        }
-                    ],
+                    "rel": "self",
+                    "type": "application/json",
+                    "href": url_for("tokens.get_jwt_token", token_id=r["id"], _external=True),
                 }
-                for r in records
-            ]
-            return flask.jsonify(tokens)
+            ],
+        }
+        for r in records
+    ]
+    return flask.jsonify(tokens)
 
 
 @bp.route("/users/me/tokens/<uuid:token_id>", methods=["GET"])
@@ -90,28 +88,26 @@ def get_jwt_token(token_id: uuid.UUID, account: auth.Account):
                         $ref: '#/components/schemas/GeoVisioEncodedToken'
     """
 
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn:
-        with conn.cursor() as cursor:
-            # check token existence
-            token = cursor.execute(
-                """
-                SELECT id, description, generated_at FROM tokens WHERE account_id = %(account)s AND id = %(token)s
-                """,
-                {"account": account.id, "token": token_id},
-            ).fetchone()
-
-            if not token:
-                raise errors.InvalidAPIUsage("Impossible to find token", status_code=404)
-
-            jwt_token = _generate_jwt_token(token["id"])
-            return flask.jsonify(
-                {
-                    "jwt_token": jwt_token,
-                    "id": token["id"],
-                    "description": token["description"],
-                    "generated_at": token["generated_at"].astimezone(tz.gettz("UTC")).isoformat(),
-                }
-            )
+    token = db.fetchone(
+        current_app,
+        "SELECT id, description, generated_at FROM tokens WHERE account_id = %(account)s AND id = %(token)s",
+        {"account": account.id, "token": token_id},
+        row_factory=dict_row,
+    )
+
+    # check token existence
+    if not token:
+        raise errors.InvalidAPIUsage(_("Impossible to find token"), status_code=404)
+
+    jwt_token = _generate_jwt_token(token["id"])
+    return flask.jsonify(
+        {
+            "jwt_token": jwt_token,
+            "id": token["id"],
+            "description": token["description"],
+            "generated_at": token["generated_at"].astimezone(tz.gettz("UTC")).isoformat(),
+        }
+    )
 
 
 @bp.route("/users/me/tokens/<uuid:token_id>", methods=["DELETE"])
@@ -136,22 +132,16 @@ def revoke_token(token_id: uuid.UUID, account: auth.Account):
             description: The token has been correctly deleted
     """
 
-    with psycopg.connect(current_app.config["DB_URL"]) as conn:
-        with conn.cursor() as cursor:
-            # check token existence
-            res = cursor.execute(
-                """
-                DELETE FROM tokens WHERE account_id = %(account)s AND id = %(token)s
-                """,
-                {"account": account.id, "token": token_id},
-            )
-
-            token_deleted = res.rowcount
+    with db.execute(
+        current_app,
+        "DELETE FROM tokens WHERE account_id = %(account)s AND id = %(token)s",
+        {"account": account.id, "token": token_id},
+    ) as res:
+        token_deleted = res.rowcount
 
-            if not token_deleted:
-                raise errors.InvalidAPIUsage("Impossible to find token", status_code=404)
-            conn.commit()
-            return flask.jsonify({"message": "token revoked"}), 200
+        if not token_deleted:
+            raise errors.InvalidAPIUsage(_("Impossible to find token"), status_code=404)
+        return flask.jsonify({"message": "token revoked"}), 200
 
 
 @bp.route("/auth/tokens/generate", methods=["POST"])
@@ -180,30 +170,31 @@ def generate_non_associated_token():
                         $ref: '#/components/schemas/JWTokenClaimable'
     """
     description = request.args.get("description", "")
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn:
-        with conn.cursor() as cursor:
-            token = cursor.execute(
-                "INSERT INTO tokens (description) VALUES (%(description)s) RETURNING *",
-                {"description": description},
-            ).fetchone()
-            if not token:
-                raise errors.InternalError("Impossible to generate a new token")
-
-            jwt_token = _generate_jwt_token(token["id"])
-            token = {
-                "id": token["id"],
-                "jwt_token": jwt_token,
-                "description": token["description"],
-                "generated_at": token["generated_at"].astimezone(tz.gettz("UTC")).isoformat(),
-                "links": [
-                    {
-                        "rel": "claim",
-                        "type": "application/json",
-                        "href": url_for("tokens.claim_non_associated_token", token_id=token["id"], _external=True),
-                    }
-                ],
+
+    token = db.fetchone(
+        current_app,
+        "INSERT INTO tokens (description) VALUES (%(description)s) RETURNING *",
+        {"description": description},
+        row_factory=dict_row,
+    )
+    if not token:
+        raise errors.InternalError(_("Impossible to generate a new token"))
+
+    jwt_token = _generate_jwt_token(token["id"])
+    token = {
+        "id": token["id"],
+        "jwt_token": jwt_token,
+        "description": token["description"],
+        "generated_at": token["generated_at"].astimezone(tz.gettz("UTC")).isoformat(),
+        "links": [
+            {
+                "rel": "claim",
+                "type": "application/json",
+                "href": url_for("tokens.claim_non_associated_token", token_id=token["id"], _external=True),
             }
-            return flask.jsonify(token)
+        ],
+    }
+    return flask.jsonify(token)
 
 
 @bp.route("/auth/tokens/<uuid:token_id>/claim", methods=["GET"])
@@ -229,30 +220,28 @@ def claim_non_associated_token(token_id, account):
         200:
             description: The token has been correctly associated to the account
     """
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn:
-        with conn.cursor() as cursor:
-            token = cursor.execute(
-                """
-                SELECT account_id FROM tokens WHERE id = %(token)s
-                """,
-                {"token": token_id},
-            ).fetchone()
-            if not token:
-                raise errors.InvalidAPIUsage("Impossible to find token", status_code=404)
-
-            associated_account = token["account_id"]
-            if associated_account:
-                if associated_account != account.id:
-                    raise errors.InvalidAPIUsage("Token already claimed by another account", status_code=403)
-                else:
-                    return flask.jsonify({"message": "token already associated to account"}), 200
-
-            cursor.execute(
-                "UPDATE tokens SET account_id = %(account)s WHERE id = %(token)s",
-                {"account": account.id, "token": token_id},
-            )
-            conn.commit()
-            return "You are now logged in the CLI, you can upload your pictures", 200
+    with db.cursor(current_app, row_factory=dict_row) as cursor:
+        token = cursor.execute(
+            """
+            SELECT account_id FROM tokens WHERE id = %(token)s
+            """,
+            {"token": token_id},
+        ).fetchone()
+        if not token:
+            raise errors.InvalidAPIUsage(_("Impossible to find token"), status_code=404)
+
+        associated_account = token["account_id"]
+        if associated_account:
+            if associated_account != account.id:
+                raise errors.InvalidAPIUsage(_("Token already claimed by another account"), status_code=403)
+            else:
+                return flask.jsonify({"message": "token already associated to account"}), 200
+
+        cursor.execute(
+            "UPDATE tokens SET account_id = %(account)s WHERE id = %(token)s",
+            {"account": account.id, "token": token_id},
+        )
+        return "You are now logged in the CLI, you can upload your pictures", 200
 
 
 def _generate_jwt_token(token_id: uuid.UUID) -> str: