c2cgeoportal-admin 2.5.0.100__py3-none-any.whl → 2.7.1.156__py3-none-any.whl

c2cgeoportal_admin/schemas/functionalities.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2018-2020, Camptocamp SA
+# Copyright (c) 2018-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,28 +26,71 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+from typing import Any, Dict, List
+
+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.orm.decl_api import DeclarativeMeta
 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: DeclarativeMeta) -> 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: DeclarativeMeta) -> 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(
+                [
+                    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, model: DeclarativeMeta
+) -> colander.SequenceSchema:
+    """Get the schema of the functionalities."""
+
+    return colander.SequenceSchema(
+        GeoFormManyToManySchemaNode(Functionality),
+        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-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,24 +26,30 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+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) -> colander.SequenceSchema:
+    """Get the serializable representation of an interface."""
+    return colander.SequenceSchema(
+        GeoFormManyToManySchemaNode(Interface),
+        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-2021, 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, Dict, List, Optional, Set, Union, 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.decl_api import DeclarativeMeta
+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: Union[DeclarativeMeta, Mapper]) -> Set[str]:
+    """Return list of relevant_for values for passed class."""
+    mapper = inspect(model)
+    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: DeclarativeMeta) -> 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: DeclarativeMeta) -> 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 MetadataSchemaNode(GeoFormSchemaNode):  # pylint: disable=abstract-method
+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):  # type: ignore # pylint: disable=abstract-method
+    """The metadata schema."""
 
     metadata_definitions: Optional[Dict[str, Any]] = None
 
-    def __init__(self, *args, **kw):
+    def __init__(self, *args: Any, **kw: Any):
         super().__init__(*args, **kw)
 
         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, model: DeclarativeMeta) -> 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-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,26 +26,30 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+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) -> colander.SequenceSchema:
+    """Get the schema of a restriction area."""
+    return colander.SequenceSchema(
+        GeoFormManyToManySchemaNode(RestrictionArea),
+        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-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,17 +26,21 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+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) -> colander.SequenceSchema:
+    """Get the schema of all the items."""
     return colander.SequenceSchema(
         GeoFormManyToManySchemaNode(Role),
-        name=name,
+        name=prop.key,
+        title=prop.info["colanderalchemy"]["title"],
+        description=prop.info["colanderalchemy"].get("description"),
         widget=RelationCheckBoxListWidget(
             Role,
             "id",

c2cgeoportal_admin/schemas/treegroup.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2018-2020, Camptocamp SA
+# Copyright (c) 2018-2022, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,19 +26,36 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+import logging
 from functools import partial
+from typing import Any, Dict, List, Optional
 
-from c2cgeoform.schema import GeoFormSchemaNode
 import colander
+import pyramid.request
+from c2cgeoform.schema import GeoFormSchemaNode
 from sqlalchemy.orm import aliased
 from sqlalchemy.sql.expression import case, func
 
 from c2cgeoportal_admin import _
 from c2cgeoportal_admin.widgets import ChildrenWidget, ChildWidget
-from c2cgeoportal_commons.models.main import LayergroupTreeitem, TreeItem
+from c2cgeoportal_commons.lib.literal import Literal
+from c2cgeoportal_commons.models.main import LayergroupTreeitem, TreeGroup, TreeItem
+
+LOG = logging.getLogger(__name__)
+
+# Correspondence between TreeItem.item_type and route table segment
+ITEM_TYPE_ROUTE_MAP = {
+    "theme": "themes",
+    "group": "layer_groups",
+    "layer": None,
+    "l_wms": "layers_wms",
+    "l_wmts": "layers_wmts",
+}
+
 
+class ChildSchemaNode(GeoFormSchemaNode):  # type: ignore # pylint: disable=abstract-method
+    """Schema of the child nodes."""
 
-class ChildSchemaNode(GeoFormSchemaNode):  # pylint: disable=abstract-method
     def objectify(self, dict_, context=None):
         if dict_.get("id", None):
             context = self.dbsession.query(LayergroupTreeitem).get(dict_["id"])
@@ -49,10 +64,14 @@ class ChildSchemaNode(GeoFormSchemaNode):  # pylint: disable=abstract-method
         return context
 
 
-def treeitems(node, kw, only_groups=False):  # pylint: disable=unused-argument
+def treeitems(
+    node: TreeGroup, kw: Dict[str, pyramid.request.Request], only_groups: bool = False
+) -> List[Dict[str, Any]]:
+    """Get a serializable representation of the tree items."""
+    del node
     dbsession = kw["request"].dbsession
 
-    group = case([(func.count(LayergroupTreeitem.id) == 0, "Unlinked")], else_="Others").label("group")
+    group = case([(func.count(LayergroupTreeitem.id) == 0, "Unlinked")], else_="Others")
 
     query = (
         dbsession.query(TreeItem, group)
@@ -85,12 +104,22 @@ def treeitems(node, kw, only_groups=False):  # pylint: disable=unused-argument
     if only_groups:
         query = query.filter(TreeItem.item_type == "group")
 
-    return query
+    return [
+        {
+            "id": item.id,
+            "label": item.name,
+            "icon_class": f"icon-{item.item_type}",
+            "edit_url": treeitem_edit_url(kw["request"], item),
+            "group": group,
+        }
+        for item, group in query
+    ]
 
 
 def children_validator(node, cstruct):
+    """Get the validator on the children nodes."""
     for dict_ in cstruct:
-        if not dict_["treeitem_id"] in [item.id for item, group in node.treeitems]:
+        if not dict_["treeitem_id"] in [item["id"] for item in node.candidates]:
             raise colander.Invalid(
                 node,
                 _("Value {} does not exist in table {} or is not allowed to avoid cycles").format(
@@ -99,22 +128,59 @@ def children_validator(node, cstruct):
             )
 
 
-def base_deferred_parent_id_validator(node, kw, model):  # pylint: disable=unused-argument
+def base_deferred_parent_id_validator(node, kw, model):
+    """Get the validator on the parent node ID."""
+    del node
+
     def validator(node, cstruct):
         if kw["dbsession"].query(model).filter(model.id == cstruct).count() == 0:
-            raise colander.Invalid(
-                node, "Value {} does not exist in table {}".format(cstruct, model.__tablename__)
-            )
+            raise colander.Invalid(node, f"Value {cstruct} does not exist in table {model.__tablename__}")
 
     return validator
 
 
-def children_schema_node(only_groups=False):
+def treeitem_edit_url(request: pyramid.request.Request, treeitem: TreeGroup) -> Optional[str]:
+    """Get the tree item editing URL."""
+    if treeitem.item_type is None:
+        return None
+    table = ITEM_TYPE_ROUTE_MAP.get(treeitem.item_type, None)
+    if table is None:
+        LOG.warning("%s not found in ITEM_TYPE_ROUTE_MAP", treeitem.item_type)
+        return None
+    return request.route_url(  # type: ignore
+        "c2cgeoform_item",
+        table=ITEM_TYPE_ROUTE_MAP[treeitem.item_type],
+        id=treeitem.id,
+    )
+
+
+def children_schema_node(only_groups: bool = False) -> colander.SequenceSchema:
+    """Geth the sequence to the children nodes."""
     return colander.SequenceSchema(
-        ChildSchemaNode(LayergroupTreeitem, name="layergroup_treeitem", widget=ChildWidget()),
+        ChildSchemaNode(
+            LayergroupTreeitem,
+            name="layergroup_treeitem",
+            widget=ChildWidget(
+                input_name="treeitem_id",
+                model=TreeItem,
+                label_field="name",
+                icon_class=lambda treeitem: f"icon-{treeitem.item_type}",
+                edit_url=treeitem_edit_url,
+            ),
+        ),
         name="children_relation",
         title=_("Children"),
-        treeitems=colander.deferred(partial(treeitems, only_groups=only_groups)),
+        description=Literal(
+            _(
+                """
+                <div class="help-block">
+                    <p>The ordered children elements.</p>
+                    <hr>
+                </div>
+                """
+            ),
+        ),
+        candidates=colander.deferred(partial(treeitems, only_groups=only_groups)),
         validator=children_validator,
-        widget=ChildrenWidget(category="structural"),
+        widget=ChildrenWidget(child_input_name="treeitem_id", add_subitem=True, orderable=True),
     )

c2cgeoportal_admin/schemas/treeitem.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2018-2020, Camptocamp SA
+# Copyright (c) 2018-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -38,6 +36,7 @@ from c2cgeoportal_admin.schemas.treegroup import base_deferred_parent_id_validat
 
 # Used for the creation of a new layer/layergroup from the layertree
 def parent_id_node(model):
+    """Get the scheme to the parent node ID."""
     return colander.SchemaNode(
         colander.Integer(),
         name="parent_id",