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

c2cgeoportal_admin/__init__.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,8 +26,11 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+from typing import Any
+
 import c2cgeoform
 import c2cwsgiutils.pretty_json
+import sqlalchemy.orm.session
 import zope.sqlalchemy
 from c2c.template.config import config as configuration
 from pkg_resources import resource_filename
@@ -37,9 +38,11 @@ from pyramid.config import Configurator
 from pyramid.events import BeforeRender, NewRequest
 from sqlalchemy import engine_from_config
 from sqlalchemy.orm import configure_mappers, sessionmaker
+from transaction import TransactionManager
 from translationstring import TranslationStringFactory
 
 from c2cgeoportal_admin.subscribers import add_localizer, add_renderer_globals
+from c2cgeoportal_admin.views import IsAdminPredicate
 
 search_paths = (resource_filename(__name__, "templates/widgets"),) + c2cgeoform.default_search_paths
 c2cgeoform.default_search_paths = search_paths
@@ -48,11 +51,13 @@ _ = TranslationStringFactory("c2cgeoportal_admin")
 
 
 def main(_, **settings):
-    """
-    This function returns a Pyramid WSGI application.
-    """
-    configuration.init(settings.get("app.cfg"))
-    settings.update(configuration.get_config())
+    """Return a Pyramid WSGI application."""
+    app_cfg = settings.get("app.cfg")
+    assert app_cfg is not None
+    configuration.init(app_cfg)
+    conf = configuration.get_config()
+    assert conf is not None
+    settings.update(conf)
 
     config = Configurator(settings=settings)
 
@@ -68,8 +73,14 @@ def main(_, **settings):
     session_factory = sessionmaker()
     session_factory.configure(bind=engine)
 
-    def get_tm_session(session_factory, transaction_manager):
+    def get_tm_session(
+        session_factory: sessionmaker[  # pylint: disable=unsubscriptable-object
+            sqlalchemy.orm.session.Session
+        ],
+        transaction_manager: TransactionManager,
+    ) -> sqlalchemy.orm.session.Session:
         dbsession = session_factory()
+        assert isinstance(dbsession, sqlalchemy.orm.session.Session)
         zope.sqlalchemy.register(dbsession, transaction_manager=transaction_manager)
         return dbsession
 
@@ -81,6 +92,19 @@ def main(_, **settings):
         reify=True,
     )
 
+    # Add fake user as we do not have authentication from geoportal
+    from c2cgeoportal_commons.models.static import User  # pylint: disable=import-outside-toplevel
+
+    config.add_request_method(
+        lambda request: User(
+            username="test_user",
+        ),
+        name="user",
+        property=True,
+    )
+
+    config.add_route("ogc_server_clear_cache", "/admin/ogc_server_clear_cache/{id}")
+
     config.add_subscriber(add_renderer_globals, BeforeRender)
     config.add_subscriber(add_localizer, NewRequest)
 
@@ -88,7 +112,9 @@ def main(_, **settings):
 
 
 class PermissionSetter:
-    def __init__(self, config):
+    """Set the permission to the admin user."""
+
+    def __init__(self, config: Configurator):
         self.default_permission_to_revert = None
         self.config = config
 
@@ -100,12 +126,13 @@ class PermissionSetter:
             ]["introspectable"]["value"]
         self.config.set_default_permission("admin")
 
-    def __exit__(self, _type, value, traceback):
+    def __exit__(self, _type: Any, value: Any, traceback: Any) -> None:
         self.config.commit()  # avoid .ConfigurationConflictError
         self.config.set_default_permission(self.default_permission_to_revert)
 
 
-def includeme(config: Configurator):
+def includeme(config: Configurator) -> None:
+    """Initialize the Pyramid application."""
     config.include("pyramid_jinja2")
     config.include("c2cgeoform")
     config.include("c2cgeoportal_commons")
@@ -113,6 +140,9 @@ def includeme(config: Configurator):
     # Use pyramid_tm to hook the transaction lifecycle to the request
     config.include("pyramid_tm")
     config.add_translation_dirs("c2cgeoportal_admin:locale")
+    config.add_view_predicate("is_admin", IsAdminPredicate)
+
+    configure_mappers()
 
     with PermissionSetter(config):
         config.scan()

c2cgeoportal_admin/lib/lingva_extractor.py

@@ -0,0 +1,77 @@
+# Copyright (c) 2011-2024, Camptocamp SA
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+
+
+import os
+from typing import Any
+
+import yaml
+from lingva.extractors import Extractor, Message
+
+
+class GeomapfishConfigExtractor(Extractor):  # type: ignore
+    """GeoMapFish config extractor (raster layers, and print templates)."""
+
+    extensions = [".yaml"]
+
+    def __call__(
+        self,
+        filename: str,
+        options: dict[str, Any],
+        fileobj: dict[str, Any] | None = None,
+        lineno: int = 0,
+    ) -> list[Message]:
+        del options, fileobj, lineno
+
+        print(f"Running {self.__class__.__name__} on {filename}")
+
+        with open(filename, encoding="utf8") as config_file:
+            data = config_file.read()
+            settings = yaml.load(
+                data.replace("{{cookiecutter.geomapfish_main_version}}", os.environ["MAJOR_VERSION"]),
+                Loader=yaml.SafeLoader,
+            )
+
+        admin_interface = settings.get("vars", {}).get("admin_interface", {})
+
+        available_metadata = []
+        for elem in admin_interface.get("available_metadata", []):
+            if "description" in elem:
+                location = f"admin_interface/available_metadata/{elem.get('name', '')}"
+                available_metadata.append(
+                    Message(None, elem["description"].strip(), None, [], "", "", (filename, location))
+                )
+
+        available_functionalities = []
+        for elem in admin_interface.get("available_functionalities", []):
+            if "description" in elem:
+                location = f"admin_interface/available_functionalities/{elem.get('name', '')}"
+                available_functionalities.append(
+                    Message(None, elem["description"].strip(), None, [], "", "", (filename, location))
+                )
+
+        return available_metadata + available_functionalities

c2cgeoportal_admin/lib/ogcserver_synchronizer.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2020, Camptocamp SA
+# Copyright (c) 2020-2024, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,35 +26,71 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+import functools
 import logging
 from io import StringIO
-from typing import Set, cast  # noqa, pylint: disable=unused-import
+from typing import Any, Optional, cast
+from xml.etree.ElementTree import Element  # nosec
 
+import pyramid.request
 import requests
 from defusedxml import ElementTree
+from sqlalchemy.orm.session import Session
 
-from c2cgeoportal_commons.lib.url import add_url_params, get_url2
+from c2cgeoportal_commons.lib.url import get_url2
 from c2cgeoportal_commons.models import main
 
 
-class dry_run_transaction:  # noqa N801: class names should use CapWords convention
-    def __init__(self, dbsession, dry_run):
+class dry_run_transaction:  # noqa ignore=N801: class names should use CapWords convention
+    def __init__(self, dbsession: Session, dry_run: bool):
         self.dbsession = dbsession
         self.dry_run = dry_run
 
-    def __enter__(self):
+    def __enter__(self) -> None:
         if self.dry_run:
             self.dbsession.begin_nested()
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         if self.dry_run:
             self.dbsession.rollback()
 
 
 class OGCServerSynchronizer:
-    def __init__(self, request, ogc_server):
+    """A processor which imports WMS Capabilities in layer tree."""
+
+    def __init__(
+        self,
+        request: pyramid.request.Request,
+        ogc_server: main.OGCServer,
+        force_parents: bool = False,
+        force_ordering: bool = False,
+        clean: bool = False,
+    ) -> None:
+        """
+        Initialize the Synchronizer.
+
+        request
+            The current pyramid request object. Used to retrieve the SQLAlchemy Session object,
+            and to construct the capabilities URL.
+
+        ogc_server
+            The considered OGCServer from witch to import the capabilities.
+
+        force_parents
+            When set to True, overwrite parents of each node with those from the capabilities.
+
+        force_ordering
+            When set to True, sort children of each node in order from the capabilities.
+
+        clean
+            When set to True, remove layers which do not exist in capabilities and remove all empty groups.
+        """
         self._request = request
         self._ogc_server = ogc_server
+        self._force_parents = force_parents
+        self._force_ordering = force_ordering
+        self._clean = clean
+
         self._default_wms = main.LayerWMS()
         self._interfaces = None
 
@@ -68,18 +102,20 @@ class OGCServerSynchronizer:
         self._items_found = 0
         self._themes_added = 0
         self._groups_added = 0
+        self._groups_removed = 0
         self._layers_added = 0
+        self._layers_removed = 0
 
-    def __str__(self):
-        return "OGCServerSynchronizer({})".format(self._ogc_server.name)
+    def __str__(self) -> str:
+        return f"OGCServerSynchronizer({self._ogc_server.name})"
 
-    def logger(self):
+    def logger(self) -> logging.Logger:
         return self._logger
 
-    def report(self):
+    def report(self) -> str:
         return self._log.getvalue()
 
-    def check_layers(self):
+    def check_layers(self) -> None:
         capabilities = ElementTree.fromstring(self.wms_capabilities())
         layers = self._request.dbsession.query(main.LayerWMS).filter(
             main.LayerWMS.ogc_server == self._ogc_server
@@ -90,15 +126,24 @@ class OGCServerSynchronizer:
             valid = True
             reason = None
             for name in layer.layer.split(","):
-                el = capabilities.find(".//Layer[Name='{}']".format(name))
+                if "'" in name:
+                    valid = False
+                    reason = "Layer name contains quote"
+                    self._logger.info(reason)
+                    break
+                el = capabilities.find(f".//Layer[Name='{name}']")
                 if el is None:
                     valid = False
-                    reason = "Layer {} does not exists on OGC server".format(name)
+                    reason = f"Layer {name} does not exists on OGC server"
                     self._logger.info(reason)
+                    if self._clean:
+                        self._request.dbsession.delete(layer)
+                        self._logger.info("Removed layer %s", name)
+                        self._layers_removed += 1
                     break
-                if layer.style and el.find("./Style/Name[.='{}']".format(layer.style)) is None:
+                if layer.style and el.find(f"./Style/Name[.='{layer.style}']") is None:
                     valid = False
-                    reason = "Style {} does not exists in Layer {}".format(layer.style, name)
+                    reason = f"Style {layer.style} does not exists in Layer {name}"
                     self._logger.info(reason)
                     break
             layer.valid = valid
@@ -106,19 +151,36 @@ class OGCServerSynchronizer:
                 invalids += 1
             layer.invalid_reason = reason
             items += 1
+
+        if self._clean:
+            groups = self._request.dbsession.query(main.LayerGroup)
+            for group in groups:
+                if len(group.children_relation) == 0:
+                    self._request.dbsession.delete(group)
+                    self._logger.info("Removed empty group %s", group.name)
+                    self._groups_removed += 1
+
         self._logger.info("Checked %s layers, %s are invalid", items, invalids)
 
-    def synchronize(self, dry_run=False):
+    def synchronize(self, dry_run: bool = False) -> None:
+        """
+        Run the import of capabilities in layer tree.
+
+        dry_run
+            When set to True, do not commit but roll back transaction at end of synchronization.
+        """
         with dry_run_transaction(self._request.dbsession, dry_run):
             self.do_synchronize()
             if dry_run:
                 self._logger.info("Rolling back transaction due to dry run")
 
-    def do_synchronize(self):
+    def do_synchronize(self) -> None:
         self._items_found = 0
         self._themes_added = 0
         self._groups_added = 0
+        self._groups_removed = 0
         self._layers_added = 0
+        self._layers_removed = 0
 
         self._default_wms = cast(
             main.LayerWMS, main.LayerWMS.get_default(self._request.dbsession) or main.LayerWMS()
@@ -130,12 +192,17 @@ class OGCServerSynchronizer:
         for theme_layer in theme_layers:
             self.synchronize_layer(theme_layer)
 
-        self._logger.info("%s items were found", self._items_found)
-        self._logger.info("%s themes were added", self._themes_added)
-        self._logger.info("%s groups were added", self._groups_added)
-        self._logger.info("%s layers were added", self._layers_added)
+        if self._clean:
+            self.check_layers()
 
-    def synchronize_layer(self, el, parent=None):
+        self._logger.info("%s items found", self._items_found)
+        self._logger.info("%s themes added", self._themes_added)
+        self._logger.info("%s groups added", self._groups_added)
+        self._logger.info("%s groups removed", self._groups_removed)
+        self._logger.info("%s layers added", self._layers_added)
+        self._logger.info("%s layers removed", self._layers_removed)
+
+    def synchronize_layer(self, el: Element, parent: main.TreeGroup | None = None) -> main.TreeItem:
         if el.find("Layer") is None:
             tree_item = self.get_layer_wms(el, parent)
         elif parent is None:
@@ -143,13 +210,37 @@ class OGCServerSynchronizer:
         else:
             tree_item = self.get_layer_group(el, parent)
 
+        server_children = []
         for child in el.findall("Layer"):
-            self.synchronize_layer(child, tree_item)
+            child_item = self.synchronize_layer(child, tree_item)
+
+            if isinstance(tree_item, main.Theme) and isinstance(child_item, main.LayerWMS):
+                # We cannot add layers in themes
+                continue
 
-    def get_theme(self, el):
-        name = el.find("Name").text
+            server_children.append(child_item)
 
-        theme = self._request.dbsession.query(main.Theme).filter(main.Theme.name == name).one_or_none()
+        if self._force_ordering and isinstance(tree_item, main.TreeGroup):
+            # Force children ordering, server_children first, external_children last
+            external_children = [item for item in tree_item.children if item not in server_children]
+            children = server_children + external_children
+            if tree_item.children != children:
+                tree_item._set_children(  # pylint: disable=protected-access
+                    server_children + external_children, order=True
+                )
+                self._logger.info("Children of %s have been sorted", tree_item.name)
+
+        return tree_item
+
+    def get_theme(self, el: ElementTree) -> main.Theme:
+        name_el = el.find("Name")
+        assert name_el is not None
+        name = name_el.text
+
+        theme = cast(
+            Optional[main.Theme],
+            self._request.dbsession.query(main.Theme).filter(main.Theme.name == name).one_or_none(),
+        )
 
         if theme is None:
             theme = main.Theme()
@@ -165,16 +256,24 @@ class OGCServerSynchronizer:
 
         return theme
 
-    def get_layer_group(self, el, parent):
-        name = el.find("Name").text
-
-        group = (
-            self._request.dbsession.query(main.LayerGroup).filter(main.LayerGroup.name == name).one_or_none()
+    def get_layer_group(self, el: Element, parent: main.TreeGroup) -> main.LayerGroup:
+        name_el = el.find("Name")
+        assert name_el is not None
+        name = name_el.text
+        assert name is not None
+
+        group = cast(
+            Optional[main.LayerGroup],
+            (
+                self._request.dbsession.query(main.LayerGroup)
+                .filter(main.LayerGroup.name == name)
+                .one_or_none()
+            ),
         )
 
         if group is None:
-            group = main.LayerGroup(name=el.find("Name").text)
-            group.parents_relation.append(main.LayergroupTreeitem(group=parent))  # noqa, pylint: no-member
+            group = main.LayerGroup(name=name)
+            group.parents_relation.append(main.LayergroupTreeitem(group=parent))
 
             self._request.dbsession.add(group)
             self._logger.info("Layer %s added as new group in theme %s", name, parent.name)
@@ -182,18 +281,28 @@ class OGCServerSynchronizer:
         else:
             self._items_found += 1
 
+            if self._force_parents and group.parents != [parent]:
+                group.parents_relation = [main.LayergroupTreeitem(group=parent)]
+                self._logger.info("Group %s moved to %s", name, parent.name)
+
         return group
 
-    def get_layer_wms(self, el, parent):
-        name = el.find("Name").text
+    def get_layer_wms(self, el: Element, parent: main.TreeGroup | None = None) -> main.LayerWMS:
+        name_el = el.find("Name")
+        assert name_el is not None
+        name = name_el.text
+        assert name is not None
 
-        layer = self._request.dbsession.query(main.LayerWMS).filter(main.LayerWMS.name == name).one_or_none()
+        layer = cast(
+            Optional[main.LayerWMS],
+            self._request.dbsession.query(main.LayerWMS).filter(main.LayerWMS.name == name).one_or_none(),
+        )
 
         if layer is None:
             layer = main.LayerWMS()
 
             # TreeItem
-            layer.name = el.find("Name").text
+            layer.name = name
             layer.description = self._default_wms.description
             layer.metadatas = [main.Metadata(name=m.name, value=m.value) for m in self._default_wms.metadatas]
 
@@ -216,17 +325,17 @@ class OGCServerSynchronizer:
 
             # LayerWMS
             layer.ogc_server = self._ogc_server
-            layer.layer = el.find("Name").text
+            layer.layer = name
             layer.style = (
                 self._default_wms.style
-                if el.find("./Style/Name[.='{}']".format(self._default_wms.style)) is not None
+                if el.find(f"./Style/Name[.='{self._default_wms.style}']") is not None
                 else None
             )
             # layer.time_mode =
             # layer.time_widget =
 
             self._request.dbsession.add(layer)
-            if parent is None or isinstance(parent, main.Theme):
+            if not isinstance(parent, main.LayerGroup):
                 self._logger.info("Layer %s added as new layer with no parent", name)
             else:
                 layer.parents_relation.append(main.LayergroupTreeitem(group=parent))
@@ -242,30 +351,35 @@ class OGCServerSynchronizer:
                     self._ogc_server.name,
                 )
 
+            parents = [parent] if isinstance(parent, main.LayerGroup) else []
+            if self._force_parents and layer.parents != parents:
+                layer.parents_relation = [main.LayergroupTreeitem(group=parent) for parent in parents]
+                self._logger.info("Layer %s moved to %s", name, parent.name if parent else "root")
+
         return layer
 
-    def wms_capabilities(self):
-        errors: Set[str] = set()
+    @functools.lru_cache(maxsize=10)
+    def wms_capabilities(self) -> bytes:
+        errors: set[str] = set()
         url = get_url2(
-            "The OGC server '{}'".format(self._ogc_server.name),
+            f"The OGC server '{self._ogc_server.name}'",
             self._ogc_server.url,
             self._request,
             errors,
         )
         if url is None:
-            raise Exception("\n".join(errors))
+            raise Exception("\n".join(errors))  # pylint: disable=broad-exception-raised
 
         # Add functionality params
         # sparams = get_mapserver_substitution_params(self.request)
-        # url = add_url_params(url, sparams)
+        # url.add_query(url, sparams)
 
-        url = add_url_params(
-            url,
+        url.add_query(
             {
                 "SERVICE": "WMS",
                 "VERSION": "1.1.1",
                 "REQUEST": "GetCapabilities",
-                "ROLE_ID": "0",
+                "ROLE_IDS": "0",
                 "USER_ID": "0",
             },
         )
@@ -279,7 +393,7 @@ class OGCServerSynchronizer:
             headers["sec-username"] = "root"
             headers["sec-roles"] = "root"
 
-        response = requests.get(url, headers=headers, timeout=300)
+        response = requests.get(url.url(), headers=headers, timeout=300)
         self._logger.info("Got response %s in %.1fs.", response.status_code, response.elapsed.total_seconds())
         response.raise_for_status()
 
@@ -288,10 +402,9 @@ class OGCServerSynchronizer:
             "application/vnd.ogc.wms_xml",
             "text/xml",
         ]:
-            raise Exception(
-                "GetCapabilities from URL {} returns a wrong Content-Type: {}\n{}".format(
-                    url, response.headers.get("Content-Type", ""), response.text
-                )
+            raise Exception(  # pylint: disable=broad-exception-raised
+                f"GetCapabilities from URL '{url}' returns a wrong Content-Type: "
+                f"{response.headers.get('Content-Type', '')}\n{response.text}"
             )
 
         return response.content

c2cgeoportal_admin/routes.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2017-2021, 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")
 
@@ -58,9 +57,12 @@ def includeme(config):
     from c2cgeoportal_commons.models.main import (  # pylint: disable=import-outside-toplevel
         Functionality,
         Interface,
+        LayerCOG,
         LayerGroup,
+        LayerVectorTiles,
         LayerWMS,
         LayerWMTS,
+        Log,
         OGCServer,
         RestrictionArea,
         Role,
@@ -71,18 +73,28 @@ def includeme(config):
         User,
     )
 
+    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),
+        *([("oauth2_clients", OAuth2Client)] if oauth2_enabled else []),
+        ("logs", Log),
     ]
 
     admin_interface_config = config.registry.settings["admin_interface"]