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

geovisio/web/users.py

@@ -1,20 +1,23 @@
 import flask
-from flask import request, current_app
-from geovisio.utils import auth
+from flask import request, current_app, url_for
+from flask_babel import gettext as _
+from geovisio.utils import auth, db
 from geovisio import errors
-import psycopg
 from psycopg.rows import dict_row
 from psycopg.sql import SQL
 
+from geovisio.web import stac
+from geovisio.web.utils import get_root_link
+
 bp = flask.Blueprint("user", __name__, url_prefix="/api/users")
 
 
 def _get_user_info(id, name):
     userMapUrl = (
-        flask.url_for("map.getUserTile", userId=id, x="111111", y="222222", z="333333", format="mvt", _external=True)
-        .replace("111111", "{x}")
-        .replace("222222", "{y}")
-        .replace("333333", "{z}")
+        flask.url_for("map.getUserTile", userId=id, x="11111111", y="22222222", z="33333333", format="mvt", _external=True)
+        .replace("11111111", "{x}")
+        .replace("22222222", "{y}")
+        .replace("33333333", "{z}")
     )
     response = {
         "id": id,
@@ -76,12 +79,11 @@ def getUserInfo(userId):
                     schema:
                         $ref: '#/components/schemas/GeoVisioUser'
     """
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn, conn.cursor() as cursor:
-        account = cursor.execute(SQL("SELECT name, id FROM accounts WHERE id = %s"), [userId]).fetchone()
-        if not account:
-            raise errors.InvalidAPIUsage("Impossible to find user", status_code=404)
+    account = db.fetchone(current_app, SQL("SELECT name, id FROM accounts WHERE id = %s"), [userId], row_factory=dict_row)
+    if not account:
+        raise errors.InvalidAPIUsage(_("Impossible to find user"), status_code=404)
 
-        return _get_user_info(account["id"], account["name"])
+    return _get_user_info(account["id"], account["name"])
 
 
 @bp.route("/me/catalog")
@@ -155,14 +157,11 @@ def searchUser():
     q = request.args.get("q")
     # for the moment, we can only search by string
     if not q:
-        raise errors.InvalidAPIUsage("No search parameter given, you should provide `q=<pattern>` as query parameter", status_code=400)
+        raise errors.InvalidAPIUsage(_("No search parameter given, you should provide `q=<pattern>` as query parameter"), status_code=400)
 
     limit = request.args.get("limit", default=20, type=int)
-
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn, conn.cursor() as cursor:
-        res = cursor.execute(
-            SQL(
-                """
+    query = SQL(
+        """
 WITH ranked AS (
     SELECT name, id, similarity({q}, name) AS similarity from accounts
 )
@@ -171,29 +170,30 @@ WHERE similarity > 0.1
 ORDER BY similarity DESC
 LIMIT {limit};
 """
-            ).format(limit=limit, q=q)
-        ).fetchall()
-        return {
-            "features": [
-                {
-                    "label": r["name"],
-                    "id": r["id"],
-                    "links": [
-                        {
-                            "rel": "user-info",
-                            "type": "application/json",
-                            "href": flask.url_for("user.getUserInfo", userId=r["id"], _external=True),
-                        },
-                        {
-                            "rel": "collection",
-                            "type": "application/json",
-                            "href": flask.url_for("stac_collections.getUserCollection", userId=r["id"], _external=True),
-                        },
-                    ],
-                }
-                for r in res
-            ]
-        }
+    ).format(limit=limit, q=q)
+    res = db.fetchall(current_app, query, row_factory=dict_row)
+
+    return {
+        "features": [
+            {
+                "label": r["name"],
+                "id": r["id"],
+                "links": [
+                    {
+                        "rel": "user-info",
+                        "type": "application/json",
+                        "href": flask.url_for("user.getUserInfo", userId=r["id"], _external=True),
+                    },
+                    {
+                        "rel": "collection",
+                        "type": "application/json",
+                        "href": flask.url_for("stac_collections.getUserCollection", userId=r["id"], _external=True),
+                    },
+                ],
+            }
+            for r in res
+        ]
+    }
 
 
 @bp.route("/")
@@ -213,35 +213,62 @@ def listUsers():
 
     # no pagination yet, can be done when needed
     limit = min(request.args.get("limit", default=1000, type=int), 1000)
-
-    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn, conn.cursor() as cursor:
-        res = cursor.execute(SQL("""SELECT name, id FROM accounts LIMIT {limit};""").format(limit=limit)).fetchall()
-        return {
-            "users": [
-                {
-                    "name": r["name"],
-                    "id": r["id"],
-                    "links": [
-                        {
-                            "rel": "user-info",
-                            "type": "application/json",
-                            "href": flask.url_for("user.getUserInfo", userId=r["id"], _external=True),
-                        },
-                        {
-                            "rel": "collection",
-                            "type": "application/json",
-                            "href": flask.url_for("stac_collections.getUserCollection", userId=r["id"], _external=True),
-                        },
-                    ],
-                }
-                for r in res
-            ],
-            "links": [
-                {
-                    "rel": "user-search",
-                    "type": "application/json",
-                    "href": flask.url_for("user.searchUser", _external=True),
-                    "title": "Search users",
-                },
-            ],
-        }
+    query = SQL(
+        """SELECT 
+a.id, a.name, l.has_seq
+FROM accounts a
+LEFT OUTER JOIN LATERAL (
+   SELECT 1 as has_seq
+   FROM sequences s
+   WHERE s.account_id = a.id
+   LIMIT 1
+) l ON true
+ORDER BY created_at
+LIMIT {limit};"""
+    ).format(limit=limit)
+    res = db.fetchall(current_app, query, row_factory=dict_row)
+    return {
+        "stac_version": stac.STAC_VERSION,
+        "id": "geovisio:users",
+        "title": "users catalog",
+        "description": "List of users catalog",
+        "type": "Catalog",
+        "conformsTo": stac.CONFORMANCE_LIST,
+        "users": [
+            {
+                "name": r["name"],
+                "id": r["id"],
+                "links": [
+                    {
+                        "rel": "user-info",
+                        "type": "application/json",
+                        "href": flask.url_for("user.getUserInfo", userId=r["id"], _external=True),
+                    },
+                    {
+                        "rel": "collection",
+                        "type": "application/json",
+                        "href": flask.url_for("stac_collections.getUserCollection", userId=r["id"], _external=True),
+                    },
+                ],
+            }
+            for r in res
+        ],
+        "links": [
+            {
+                "rel": "user-search",
+                "type": "application/json",
+                "href": flask.url_for("user.searchUser", _external=True),
+                "title": "Search users",
+            },
+            get_root_link(),
+        ]
+        + [
+            {
+                "rel": "child",
+                "title": f'User "{r["name"]}" sequences',
+                "href": url_for("stac_collections.getUserCollection", userId=r["id"], _external=True),
+            }
+            for r in res
+            if r["has_seq"]
+        ],
+    }

geovisio/web/utils.py

@@ -1,10 +1,14 @@
 import typing
 from dateutil import tz
-from typing import Optional
-from functools import wraps
-import psycopg
-from flask import current_app, url_for, Response, make_response
+from datetime import timezone
+from dateutil.tz import gettz
+from functools import wraps, cache
 from geovisio import errors
+from geovisio.utils import db
+from flask import current_app, url_for
+from flask_babel import gettext as _
+from geovisio import __version__
+import subprocess
 
 STAC_VERSION = "1.0.0"
 
@@ -25,6 +29,14 @@ def dbTsToStac(dbts):
     return dbts.astimezone(tz.gettz("UTC")).isoformat() if dbts is not None else None
 
 
+def dbTsToStacTZ(dbts, dbtz):
+    """Transforms timestamp returned by PostgreSQL into ISO format with timezone"""
+    tzSwitches = {"CEST": "CET"}
+    if dbtz in tzSwitches:
+        dbtz = tzSwitches[dbtz]
+    return dbts.astimezone(gettz(dbtz or "UTC") or timezone.utc).isoformat()
+
+
 def cleanNoneInList(val: typing.List) -> typing.List:
     """Removes empty values from list"""
     return list(filter(lambda e: e is not None, val))
@@ -34,11 +46,10 @@ def accountIdOrDefault(account):
     # Get default account ID
     if account is not None:
         return account.id
-    with psycopg.connect(current_app.config["DB_URL"]) as conn:
-        accountId = conn.execute("SELECT id FROM accounts WHERE is_default").fetchone()
-        if accountId is None:
-            raise errors.InternalError("No default account defined, please contact your instance administrator")
-        return str(accountId[0])
+    accountId = db.fetchone(current_app, "SELECT id FROM accounts WHERE is_default")
+    if accountId is None:
+        raise errors.InternalError(_("No default account defined, please contact your instance administrator"))
+    return str(accountId[0])
 
 
 def get_license_link():
@@ -75,6 +86,24 @@ def get_viewerpage_url():
         return url_for("viewer", _external=True)
 
 
+@cache
+def get_api_version():
+    """
+    Retrieve complete API version.
+
+    Format can be:
+    - 2.6.0-99-abcdefgh (release + amount of commits since last tag + commit short SHA) if Git repo is not on a release tag
+    - 2.6.0 (release) if Git repo is on release tag (or no Git repo available)
+    """
+
+    if current_app.config.get("API_GIT_VERSION") is not None:
+        return current_app.config["API_GIT_VERSION"]
+    try:
+        return subprocess.check_output(["git", "describe"]).strip().decode("utf-8")
+    except Exception:
+        return __version__
+
+
 def user_dependant_response(flag):
     """Set if a response is user dependant.