c2cgeoportal-admin 2.5.0.100__py3-none-any.whl → 2.9rc44__py3-none-any.whl

c2cgeoportal_admin/routes.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2017-2020, Camptocamp SA
+# Copyright (c) 2017-2024, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -32,12 +30,13 @@ from c2cgeoform.routes import register_route, register_routes
 
 
 def includeme(config):
+    """Initialize the Pyramid routes."""
     config.add_static_view("c2cgeoportal_admin_node_modules", "c2cgeoportal_admin:node_modules")
     config.override_asset(
         to_override="c2cgeoportal_admin:node_modules/", override_with="/opt/c2cgeoportal/admin/node_modules"
     )
     # Because c2cgeoform widgets target {root_package}:node_modules/...
-    asset_spec = "{}:node_modules/".format(config.root_package.__name__)
+    asset_spec = f"{config.root_package.__name__}:node_modules/"
     config.add_static_view("root_package_node_modules", asset_spec)
     config.override_asset(to_override=asset_spec, override_with="/opt/c2cgeoportal/admin/node_modules")
 
@@ -51,31 +50,51 @@ def includeme(config):
     register_route(config, "layertree_delete", "/{application:admin}/layertree/delete/{item_id}")
     register_route(config, "convert_to_wms", "/{application:admin}/{table:layers_wmts}/{id}/convert_to_wms")
     register_route(config, "convert_to_wmts", "/{application:admin}/{table:layers_wms}/{id}/convert_to_wmts")
+    register_route(
+        config, "ogcserver_synchronize", "/{application:admin}/{table:ogc_servers}/{id}/synchronize"
+    )
 
     from c2cgeoportal_commons.models.main import (  # pylint: disable=import-outside-toplevel
-        Role,
+        Functionality,
+        Interface,
+        LayerCOG,
+        LayerGroup,
+        LayerVectorTiles,
         LayerWMS,
         LayerWMTS,
-        Theme,
-        LayerGroup,
-        Interface,
+        Log,
         OGCServer,
-        Functionality,
         RestrictionArea,
+        Role,
+        Theme,
+    )
+    from c2cgeoportal_commons.models.static import (  # pylint: disable=import-outside-toplevel
+        OAuth2Client,
+        User,
     )
-    from c2cgeoportal_commons.models.static import User  # pylint: disable=import-outside-toplevel
+
+    authentication_configuration = config.registry.settings.get("authentication", {})
+    oidc_configuration = authentication_configuration.get("openid_connect", {})
+    oidc_enabled = oidc_configuration.get("enabled", False)
+    oidc_provide_roles = oidc_configuration.get("provide_roles", False)
+    oauth2_configuration = authentication_configuration.get("oauth2", {})
+    oauth2_enabled = oauth2_configuration.get("enabled", not oidc_enabled)
 
     visible_routes = [
         ("themes", Theme),
         ("layer_groups", LayerGroup),
         ("layers_wms", LayerWMS),
         ("layers_wmts", LayerWMTS),
+        ("layers_vectortiles", LayerVectorTiles),
+        ("layers_cog", LayerCOG),
         ("ogc_servers", OGCServer),
         ("restriction_areas", RestrictionArea),
-        ("users", User),
+        *([("users", User)] if not oidc_enabled or not oidc_provide_roles else []),
         ("roles", Role),
         ("functionalities", Functionality),
         ("interfaces", Interface),
+        *([("oauth2_clients", OAuth2Client)] if oauth2_enabled else []),
+        ("logs", Log),
     ]
 
     admin_interface_config = config.registry.settings["admin_interface"]

c2cgeoportal_admin/schemas/dimensions.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2018-2020, Camptocamp SA
+# Copyright (c) 2018-2024, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,16 +26,24 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
-from c2cgeoform.schema import GeoFormSchemaNode
+from typing import Any
+
 import colander
+from c2cgeoform.schema import GeoFormSchemaNode
 from deform.widget import MappingWidget, SequenceWidget
+from sqlalchemy.orm.attributes import InstrumentedAttribute
 
-from c2cgeoportal_admin import _
 from c2cgeoportal_commons.models.main import Dimension
 
-dimensions_schema_node = colander.SequenceSchema(
-    GeoFormSchemaNode(Dimension, name="dimension", widget=MappingWidget(template="dimension")),
-    name="dimensions",
-    title=_("Dimensions"),
-    widget=SequenceWidget(category="structural", template="dimensions"),
-)
+
+def dimensions_schema_node(
+    prop: InstrumentedAttribute[Any],  # pylint: disable=unsubscriptable-object
+) -> colander.SequenceSchema:
+    """Get the scheme of the dimensions."""
+    return colander.SequenceSchema(
+        GeoFormSchemaNode(Dimension, name="dimension", widget=MappingWidget(template="dimension")),
+        name=prop.key,
+        title=prop.info["colanderalchemy"]["title"],
+        description=prop.info["colanderalchemy"]["description"],
+        widget=SequenceWidget(category="structural", template="dimensions"),
+    )

c2cgeoportal_admin/schemas/functionalities.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2018-2020, Camptocamp SA
+# Copyright (c) 2018-2024, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,28 +26,68 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+from typing import Any
+
+import colander
 from c2cgeoform.ext.deform_ext import RelationCheckBoxListWidget
 from c2cgeoform.schema import GeoFormManyToManySchemaNode, manytomany_validator
-import colander
-from sqlalchemy import select
+from sqlalchemy import inspect, select
+from sqlalchemy.orm.attributes import InstrumentedAttribute
 from sqlalchemy.sql.functions import concat
 
 from c2cgeoportal_commons.models.main import Functionality
 
-functionalities_schema_node = colander.SequenceSchema(
-    GeoFormManyToManySchemaNode(Functionality),
-    name="functionalities",
-    widget=RelationCheckBoxListWidget(
-        select([Functionality.id, concat(Functionality.name, "=", Functionality.value).label("label")]).alias(
-            "functionality_labels"
-        ),
-        "id",
-        "label",
-        order_by="label",
-        edit_url=lambda request, value: request.route_url(
-            "c2cgeoform_item", table="functionalities", id=value
-        ),
-    ),
-    validator=manytomany_validator,
-    missing=colander.drop,
-)
+
+def available_functionalities_for(settings: dict[str, Any], model: type[Any]) -> list[dict[str, Any]]:
+    """Return filtered list of functionality definitions."""
+    mapper = inspect(model)
+    relevant_for = {mapper.local_table.name}
+    return [
+        f
+        for f in settings["admin_interface"]["available_functionalities"]
+        if relevant_for & set(f.get("relevant_for", relevant_for))
+    ]
+
+
+def functionalities_widget(model: type[Any]) -> colander.deferred:
+    """Return a colander deferred which itself returns a widget for the functionalities field."""
+
+    def create_widget(node, kw):
+        del node
+
+        return RelationCheckBoxListWidget(
+            select(  # type: ignore[arg-type]
+                Functionality.id,
+                concat(Functionality.name, "=", Functionality.value).label("label"),
+            )
+            .where(
+                Functionality.name.in_(
+                    [f["name"] for f in available_functionalities_for(kw["request"].registry.settings, model)]
+                )
+            )
+            .alias("functionality_labels"),
+            "id",
+            "label",
+            order_by="label",
+            edit_url=lambda request, value: request.route_url(
+                "c2cgeoform_item", table="functionalities", id=value
+            ),
+        )
+
+    return colander.deferred(create_widget)
+
+
+def functionalities_schema_node(
+    prop: InstrumentedAttribute[Any], model: type[Any]
+) -> colander.SequenceSchema:
+    """Get the schema of the functionalities."""
+
+    return colander.SequenceSchema(
+        GeoFormManyToManySchemaNode(Functionality, None),
+        name=prop.key,
+        title=prop.info["colanderalchemy"]["title"],
+        description=prop.info["colanderalchemy"].get("description"),
+        widget=functionalities_widget(model),
+        validator=manytomany_validator,
+        missing=colander.drop,
+    )

c2cgeoportal_admin/schemas/interfaces.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2018-2020, Camptocamp SA
+# Copyright (c) 2018-2024, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,24 +26,34 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+from typing import Any
+
+import colander
 from c2cgeoform.ext.deform_ext import RelationCheckBoxListWidget
 from c2cgeoform.schema import GeoFormManyToManySchemaNode, manytomany_validator
-import colander
+from sqlalchemy.orm.attributes import InstrumentedAttribute
 
-from c2cgeoportal_admin import _
 from c2cgeoportal_commons.models.main import Interface
 
-interfaces_schema_node = colander.SequenceSchema(
-    GeoFormManyToManySchemaNode(Interface),
-    name="interfaces",
-    title=_("Interfaces"),
-    widget=RelationCheckBoxListWidget(
-        Interface,
-        "id",
-        "name",
-        order_by="name",
-        edit_url=lambda request, value: request.route_url("c2cgeoform_item", table="interfaces", id=value),
-    ),
-    validator=manytomany_validator,
-    missing=colander.drop,
-)
+
+def interfaces_schema_node(
+    prop: InstrumentedAttribute[Any],  # pylint: disable=unsubscriptable-object
+) -> colander.SequenceSchema:
+    """Get the serializable representation of an interface."""
+    return colander.SequenceSchema(
+        GeoFormManyToManySchemaNode(Interface, None),
+        name=prop.key,
+        title=prop.info["colanderalchemy"]["title"],
+        description=prop.info["colanderalchemy"]["description"],
+        widget=RelationCheckBoxListWidget(
+            Interface,
+            "id",
+            "name",
+            order_by="name",
+            edit_url=lambda request, value: request.route_url(
+                "c2cgeoform_item", table="interfaces", id=value
+            ),
+        ),
+        validator=manytomany_validator,
+        missing=colander.drop,
+    )

c2cgeoportal_admin/schemas/metadata.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2018-2020, Camptocamp SA
+# Copyright (c) 2018-2024, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -27,32 +25,49 @@
 # of the authors and should not be interpreted as representing official policies,
 # either expressed or implied, of the FreeBSD Project.
 
-
 import json
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, cast
 
-from c2cgeoform.schema import GeoFormSchemaNode
 import colander
+import pyramid.request
+from c2cgeoform.schema import GeoFormSchemaNode
 from deform.widget import MappingWidget, SelectWidget, SequenceWidget, TextAreaWidget
+from sqlalchemy import inspect
+from sqlalchemy.orm.attributes import InstrumentedAttribute
+from sqlalchemy.orm.mapper import Mapper
 
 from c2cgeoportal_admin import _
 from c2cgeoportal_commons.lib.validators import url
 from c2cgeoportal_commons.models.main import Metadata
 
 
-@colander.deferred
-def metadata_definitions(node, kw):
-    del node
-    return {m["name"]: m for m in kw["request"].registry.settings["admin_interface"]["available_metadata"]}
+def get_relevant_for(model: type[Any] | Mapper[Any]) -> set[str]:
+    """Return list of relevant_for values for passed class."""
+    mapper = inspect(model)
+    assert mapper is not None
+    relevant_for = {mapper.local_table.name}  # or mapper.polymorphic_identity
+    if mapper.inherits:
+        relevant_for |= get_relevant_for(mapper.inherits)
+    return relevant_for
+
 
+def metadata_definitions(settings: dict[str, Any], model: type[Any]) -> list[dict[str, Any]]:
+    """Return filtered list metadata definitions."""
+    return [
+        m
+        for m in settings["admin_interface"]["available_metadata"]
+        if get_relevant_for(model) & set(m.get("relevant_for", ["treeitem"]))
+    ]
 
-class MetadataSelectWidget(SelectWidget):
-    """Extends class SelectWidget to support undefined metadatas.
+
+class MetadataSelectWidget(SelectWidget):  # type: ignore
+    """
+    Extends class SelectWidget to support undefined metadata.
 
     Override serialize to add option in values for current cstruct when needed.
     """
 
-    def serialize(self, field, cstruct, **kw):
+    def serialize(self, field: Any, cstruct: Any, **kw: Any) -> Any:
         values = kw.get("values", self.values)
         if isinstance(cstruct, str) and (cstruct, cstruct) not in values:
             values = values.copy()
@@ -61,21 +76,26 @@ class MetadataSelectWidget(SelectWidget):
         return super().serialize(field, cstruct, **kw)
 
 
-@colander.deferred
-def metadata_name_widget(node, kw):
-    del node
-    return MetadataSelectWidget(
-        values=[
-            (m["name"], m["name"])
-            for m in sorted(
-                kw["request"].registry.settings["admin_interface"]["available_metadata"],
-                key=lambda m: m["name"],
-            )
-        ]
-    )
+def metadata_name_widget(model: type[Any]) -> colander.deferred:
+    """Return a colander deferred which itself returns a widget for the metadata name field."""
+
+    def create_widget(node, kw):
+        del node
+        return MetadataSelectWidget(
+            values=[
+                (m["name"], m["name"])
+                for m in sorted(
+                    metadata_definitions(kw["request"].registry.settings, model),
+                    key=lambda m: cast(str, m["name"]),
+                )
+            ]
+        )
+
+    return colander.deferred(create_widget)
 
 
 def json_validator(node, value):
+    """Validate the value to be a valid JSON."""
     try:
         json.loads(value)
     except ValueError as e:
@@ -83,6 +103,7 @@ def json_validator(node, value):
 
 
 def regex_validator(node, value):
+    """Validate the value with a regexp."""
     definition = node.metadata_definitions.get(value["name"], {})
     if definition.get("type", "string") == "regex":
         validator = colander.Regex(definition["regex"], msg=_(definition["error_message"]))
@@ -91,21 +112,43 @@ def regex_validator(node, value):
         except colander.Invalid as e:
             error = colander.Invalid(node)
             error.add(e, node.children.index(node["string"]))
-            raise error
+            raise error from e
+
+
+class BooleanMetadata(colander.Boolean):  # type: ignore
+    """Boolean metadata values are stored as string in database."""
+
+    def serialize(self, node, appstruct):
+        if appstruct == "true":
+            appstruct = True
+        elif appstruct == "false":
+            appstruct = False
+        else:
+            appstruct = colander.null
+        return super().serialize(node, appstruct)
+
+    def deserialize(self, node, cstruct):
+        appstruct = super().deserialize(node, cstruct)
+        if appstruct is True:
+            return "true"
+        if appstruct is False:
+            return "false"
+        return None
 
 
 class MetadataSchemaNode(GeoFormSchemaNode):  # pylint: disable=abstract-method
+    """The metadata schema."""
 
-    metadata_definitions: Optional[Dict[str, Any]] = None
+    metadata_definitions: dict[str, Any] | None = None
 
-    def __init__(self, *args, **kw):
+    def __init__(self, *args: Any, **kw: Any):
         super().__init__(*args, **kw)
 
-        self.available_types: List[str] = []
+        self.available_types: list[str] = []
 
         self._add_value_node("string", colander.String())
         self._add_value_node("liste", colander.String())
-        self._add_value_node("boolean", colander.Boolean())
+        self._add_value_node("boolean", BooleanMetadata())
         self._add_value_node("int", colander.Int())
         self._add_value_node("float", colander.Float())
         self._add_value_node("url", colander.String(), validator=url)
@@ -113,10 +156,17 @@ class MetadataSchemaNode(GeoFormSchemaNode):  # pylint: disable=abstract-method
             "json", colander.String(), widget=TextAreaWidget(rows=10), validator=json_validator
         )
 
-    def _add_value_node(self, type_name, colander_type, **kw):
+    def _add_value_node(self, type_name: str, colander_type: colander.SchemaType, **kw: Any) -> None:
         self.add_before(
             "description",
-            colander.SchemaNode(colander_type, name=type_name, title=_("Value"), missing=colander.null, **kw),
+            colander.SchemaNode(
+                colander_type,
+                name=type_name,
+                title=Metadata.value.info["colanderalchemy"]["title"],
+                description=Metadata.value.info["colanderalchemy"]["description"],
+                missing=colander.null,
+                **kw,
+            ),
         )
         self.available_types.append(type_name)
 
@@ -132,24 +182,48 @@ class MetadataSchemaNode(GeoFormSchemaNode):  # pylint: disable=abstract-method
         dict_[self._ui_type(obj.name)] = value
         return dict_
 
-    def _ui_type(self, metadata_name: str):
+    def _ui_type(self, metadata_name: str) -> str:
         metadata_type = (
-            cast(Dict[str, Any], self.metadata_definitions).get(metadata_name, {}).get("type", "string")
+            cast(dict[str, dict[str, str]], self.metadata_definitions)
+            .get(metadata_name, {})
+            .get("type", "string")
         )
         return metadata_type if metadata_type in self.available_types else "string"
 
 
-metadatas_schema_node = colander.SequenceSchema(
-    MetadataSchemaNode(
-        Metadata,
-        name="metadata",
-        metadata_definitions=metadata_definitions,
-        validator=regex_validator,
-        widget=MappingWidget(template="metadata"),
-        overrides={"name": {"widget": metadata_name_widget}},
-    ),
-    name="metadatas",
-    title=_("Metadatas"),
-    metadata_definitions=metadata_definitions,
-    widget=SequenceWidget(template="metadatas", category="structural"),
-)
+def _translate_available_metadata(
+    available_metadata: dict[str, Any], request: pyramid.request.Request
+) -> dict[str, Any]:
+    result = {}
+    result.update(available_metadata)
+    result["description"] = request.localizer.translate(_(available_metadata.get("description", "").strip()))
+    return result
+
+
+def metadata_schema_node(prop: InstrumentedAttribute[Any], model: type[Any]) -> colander.SequenceSchema:
+    """Get the schema of a collection of metadata."""
+
+    # Deferred which returns a dictionary with metadata name as key and metadata definition as value.
+    # Needed to get the metadata types on UI side.
+    metadata_definitions_dict = colander.deferred(
+        lambda node, kw: {
+            m["name"]: _translate_available_metadata(m, kw["request"])
+            for m in metadata_definitions(kw["request"].registry.settings, model)
+        }
+    )
+
+    return colander.SequenceSchema(
+        MetadataSchemaNode(
+            Metadata,
+            name="metadata",
+            metadata_definitions=metadata_definitions_dict,
+            validator=regex_validator,
+            widget=MappingWidget(template="metadata"),
+            overrides={"name": {"widget": metadata_name_widget(model)}},
+        ),
+        name=prop.key,
+        title=prop.info["colanderalchemy"]["title"],
+        description=prop.info["colanderalchemy"]["description"],
+        metadata_definitions=metadata_definitions_dict,
+        widget=SequenceWidget(template="metadatas", category="structural"),
+    )

c2cgeoportal_admin/schemas/restriction_areas.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2017-2020, Camptocamp SA
+# Copyright (c) 2017-2024, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,26 +26,34 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+from typing import Any
+
+import colander
 from c2cgeoform.ext.deform_ext import RelationCheckBoxListWidget
 from c2cgeoform.schema import GeoFormManyToManySchemaNode, manytomany_validator
-import colander
+from sqlalchemy.orm.attributes import InstrumentedAttribute
 
-from c2cgeoportal_admin import _
 from c2cgeoportal_commons.models.main import RestrictionArea
 
-restrictionareas_schema_node = colander.SequenceSchema(
-    GeoFormManyToManySchemaNode(RestrictionArea),
-    name="restrictionareas",
-    title=_("Restriction areas"),
-    widget=RelationCheckBoxListWidget(
-        RestrictionArea,
-        "id",
-        "name",
-        order_by="name",
-        edit_url=lambda request, value: request.route_url(
-            "c2cgeoform_item", table="restriction_areas", id=value
+
+def restrictionareas_schema_node(
+    prop: InstrumentedAttribute[Any],  # pylint: disable=unsubscriptable-object
+) -> colander.SequenceSchema:
+    """Get the schema of a restriction area."""
+    return colander.SequenceSchema(
+        GeoFormManyToManySchemaNode(RestrictionArea, None),
+        name=prop.key,
+        title=prop.info["colanderalchemy"]["title"],
+        description=prop.info["colanderalchemy"].get("description"),
+        widget=RelationCheckBoxListWidget(
+            RestrictionArea,
+            "id",
+            "name",
+            order_by="name",
+            edit_url=lambda request, value: request.route_url(
+                "c2cgeoform_item", table="restriction_areas", id=value
+            ),
         ),
-    ),
-    validator=manytomany_validator,
-    missing=colander.drop,
-)
+        validator=manytomany_validator,
+        missing=colander.drop,
+    )

c2cgeoportal_admin/schemas/roles.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2018-2020, Camptocamp SA
+# Copyright (c) 2018-2024, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,17 +26,25 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+from typing import Any
+
+import colander
 from c2cgeoform.ext.deform_ext import RelationCheckBoxListWidget
 from c2cgeoform.schema import GeoFormManyToManySchemaNode, manytomany_validator
-import colander
+from sqlalchemy.orm.attributes import InstrumentedAttribute
 
 from c2cgeoportal_commons.models.main import Role
 
 
-def roles_schema_node(name):
+def roles_schema_node(
+    prop: InstrumentedAttribute[Any],  # pylint: disable=unsubscriptable-object
+) -> colander.SequenceSchema:
+    """Get the schema of all the items."""
     return colander.SequenceSchema(
-        GeoFormManyToManySchemaNode(Role),
-        name=name,
+        GeoFormManyToManySchemaNode(Role, None),
+        name=prop.key,
+        title=prop.info["colanderalchemy"]["title"],
+        description=prop.info["colanderalchemy"].get("description"),
         widget=RelationCheckBoxListWidget(
             Role,
             "id",