c2cgeoportal-admin 2.6.0__py3-none-any.whl → 2.8.1.180__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
-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
@@ -31,21 +29,27 @@
 import colander
 from c2cgeoform.ext.deform_ext import RelationCheckBoxListWidget
 from c2cgeoform.schema import GeoFormManyToManySchemaNode, manytomany_validator
+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-2021, Camptocamp SA
+# Copyright (c) 2018-2023, 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
 
 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,11 +112,11 @@ 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):
-    """Boolean metadata values are stored as string in database"""
+class BooleanMetadata(colander.Boolean):  # type: ignore
+    """Boolean metadata values are stored as string in database."""
 
     def serialize(self, node, appstruct):
         if appstruct == "true":
@@ -115,11 +136,12 @@ class BooleanMetadata(colander.Boolean):
         return None
 
 
-class MetadataSchemaNode(GeoFormSchemaNode):  # pylint: disable=abstract-method
+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] = []
@@ -134,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)
 
@@ -153,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
@@ -31,23 +29,27 @@
 import colander
 from c2cgeoform.ext.deform_ext import RelationCheckBoxListWidget
 from c2cgeoform.schema import GeoFormManyToManySchemaNode, manytomany_validator
+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
@@ -31,14 +29,18 @@
 import colander
 from c2cgeoform.ext.deform_ext import RelationCheckBoxListWidget
 from c2cgeoform.schema import GeoFormManyToManySchemaNode, manytomany_validator
+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-2024, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -30,15 +28,18 @@
 
 import logging
 from functools import partial
+from typing import Any, Dict, List, Optional
 
 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__)
 
@@ -48,11 +49,13 @@ ITEM_TYPE_ROUTE_MAP = {
     "group": "layer_groups",
     "layer": None,
     "l_wms": "layers_wms",
-    "l_wmts": "layers_wms",
+    "l_wmts": "layers_wmts",
 }
 
 
-class ChildSchemaNode(GeoFormSchemaNode):  # pylint: disable=abstract-method
+class ChildSchemaNode(GeoFormSchemaNode):  # type: ignore # pylint: disable=abstract-method
+    """Schema of the child nodes."""
+
     def objectify(self, dict_, context=None):
         if dict_.get("id", None):
             context = self.dbsession.query(LayergroupTreeitem).get(dict_["id"])
@@ -61,7 +64,11 @@ 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")
@@ -71,7 +78,7 @@ def treeitems(node, kw, only_groups=False):  # pylint: disable=unused-argument
         .distinct()
         .outerjoin("parents_relation")
         .filter(TreeItem.item_type != "theme")
-        .group_by(TreeItem.id)
+        .group_by(TreeItem)
         .order_by(group.desc(), TreeItem.name)
     )
 
@@ -101,7 +108,7 @@ def treeitems(node, kw, only_groups=False):  # pylint: disable=unused-argument
         {
             "id": item.id,
             "label": item.name,
-            "icon_class": "icon-{}".format(item.item_type),
+            "icon_class": f"icon-{item.item_type}",
             "edit_url": treeitem_edit_url(kw["request"], item),
             "group": group,
         }
@@ -110,6 +117,7 @@ def treeitems(node, kw, only_groups=False):  # pylint: disable=unused-argument
 
 
 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 in node.candidates]:
             raise colander.Invalid(
@@ -120,31 +128,34 @@ 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 treeitem_edit_url(request, treeitem):
+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(
+    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=False):
+def children_schema_node(only_groups: bool = False) -> colander.SequenceSchema:
+    """Geth the sequence to the children nodes."""
     return colander.SequenceSchema(
         ChildSchemaNode(
             LayergroupTreeitem,
@@ -153,12 +164,22 @@ def children_schema_node(only_groups=False):
                 input_name="treeitem_id",
                 model=TreeItem,
                 label_field="name",
-                icon_class=lambda treeitem: "icon-{}".format(treeitem.item_type),
+                icon_class=lambda treeitem: f"icon-{treeitem.item_type}",
                 edit_url=treeitem_edit_url,
             ),
         ),
         name="children_relation",
         title=_("Children"),
+        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(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",

c2cgeoportal_admin/static/layertree.css

@@ -64,7 +64,6 @@
   padding-left: 0px;
 }
 
-
 .jstree-grid-wrapper .jstree-node,
 .jstree-grid-wrapper .jstree-grid-cell-regular {
   border-top: 1px solid #ddd;
@@ -115,11 +114,11 @@
 }
 
 .jstree-open .jstree-icon.jstree-ocl:before {
-  content: "\e252";
+  content: '\e252';
 }
 .jstree-closed .jstree-icon.jstree-ocl:before {
-  content: "\e250";
+  content: '\e250';
 }
 .jstree-leaf .jstree-icon.jstree-ocl:before {
-  content: "";
+  content: '';
 }