c2cgeoportal-commons 2.7.1.145__py3-none-any.whl → 2.9.0.350__py3-none-any.whl

c2cgeoportal_commons/models/main.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2011-2021, Camptocamp SA
+# Copyright (c) 2011-2025, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -26,10 +26,12 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+import enum
 import logging
 import os
 import re
-from typing import Any, Dict, List, Optional, Set, Tuple, Union, cast
+from datetime import datetime
+from typing import Any, Literal, Optional, cast, get_args
 
 import pyramid.request
 import sqlalchemy.orm.base
@@ -38,24 +40,29 @@ from geoalchemy2 import Geometry
 from geoalchemy2.shape import to_shape
 from papyrus.geo_interface import GeoInterface
 from sqlalchemy import Column, ForeignKey, Table, UniqueConstraint, event
-from sqlalchemy.orm import Session, backref, relationship
+from sqlalchemy.ext.declarative import AbstractConcreteBase
+from sqlalchemy.orm import Mapped, Session, backref, mapped_column, relationship
 from sqlalchemy.schema import Index
-from sqlalchemy.types import Boolean, Enum, Integer, String, Unicode
+from sqlalchemy.types import Boolean, DateTime, Enum, Integer, String, Unicode
 
-from c2cgeoportal_commons.lib.literal import Literal
+import c2cgeoportal_commons.lib.literal
 from c2cgeoportal_commons.lib.url import get_url2
 from c2cgeoportal_commons.models import Base, _, cache_invalidate_cb
 from c2cgeoportal_commons.models.sqlalchemy import JSONEncodedDict, TsVector
 
 try:
+    import colander
     from c2cgeoform import default_map_settings
     from c2cgeoform.ext.colander_ext import Geometry as ColanderGeometry
     from c2cgeoform.ext.deform_ext import MapWidget, RelationSelect2Widget
     from colander import drop
     from deform.widget import CheckboxWidget, HiddenWidget, SelectWidget, TextAreaWidget, TextInputWidget
+
+    colander_null = colander.null
 except ModuleNotFoundError:
-    drop = None
+    drop = None  # pylint: disable=invalid-name
     default_map_settings = {"srid": 3857, "view": {"projection": "EPSG:3857"}}
+    colander_null = None  # pylint: disable=invalid-name
 
     class GenericClass:
         """Fallback class implementation."""
@@ -65,11 +72,11 @@ except ModuleNotFoundError:
 
     CheckboxWidget = GenericClass
     HiddenWidget = GenericClass
-    MapWidget = GenericClass
+    MapWidget = GenericClass  # type: ignore[misc,assignment]
     SelectWidget = GenericClass
     TextAreaWidget = GenericClass
-    ColanderGeometry = GenericClass
-    RelationSelect2Widget = GenericClass
+    ColanderGeometry = GenericClass  # type: ignore[misc,assignment]
+    RelationSelect2Widget = GenericClass  # type: ignore[misc,assignment]
     TextInputWidget = GenericClass
 
 
@@ -84,14 +91,16 @@ if os.environ.get("DEVELOPMENT", "0") == "1":
     # information
     sqlalchemy.orm.base.state_str = state_str
 
-LOG = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 _schema: str = config["schema"] or "main"
 _srid: int = cast(int, config["srid"]) or 3857
 
 # Set some default values for the admin interface
-_admin_config: Dict[str, Any] = config.get_config().get("admin_interface", {})
-_map_config: Dict[str, Any] = {**default_map_settings, **_admin_config.get("map", {})}
+conf = config.get_config()
+assert conf is not None
+_admin_config: dict[str, Any] = conf.get("admin_interface", {})
+_map_config: dict[str, Any] = {**default_map_settings, **_admin_config.get("map", {})}
 view_srid_match = re.match(r"EPSG:(\d+)", _map_config["view"]["projection"])
 if "map_srid" not in _admin_config and view_srid_match is not None:
     _admin_config["map_srid"] = view_srid_match.group(1)
@@ -101,22 +110,30 @@ class FullTextSearch(GeoInterface, Base):  # type: ignore
     """The tsearch table representation."""
 
     __tablename__ = "tsearch"
-    __table_args__ = (Index("tsearch_ts_idx", "ts", postgresql_using="gin"), {"schema": _schema})
+    __table_args__ = (
+        Index("tsearch_search_index", "ts", "public", "role_id", "interface_id", "lang"),
+        Index("tsearch_ts_idx", "ts", postgresql_using="gin"),
+        {"schema": _schema},
+    )
 
-    id = Column(Integer, primary_key=True)
-    label = Column(Unicode)
-    layer_name = Column(Unicode)
-    role_id = Column(Integer, ForeignKey(_schema + ".role.id", ondelete="CASCADE"), nullable=True)
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    label: Mapped[str] = mapped_column(Unicode)
+    layer_name: Mapped[str] = mapped_column(Unicode, nullable=True)
+    role_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey(_schema + ".role.id", ondelete="CASCADE"), nullable=True
+    )
     role = relationship("Role")
-    interface_id = Column(Integer, ForeignKey(_schema + ".interface.id", ondelete="CASCADE"), nullable=True)
+    interface_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey(_schema + ".interface.id", ondelete="CASCADE"), nullable=True
+    )
     interface = relationship("Interface")
-    lang = Column(String(2), nullable=True)
-    public = Column(Boolean, server_default="true")
-    ts = Column(TsVector)
-    the_geom = Column(Geometry("GEOMETRY", srid=_srid))
-    params = Column(JSONEncodedDict, nullable=True)
-    actions = Column(JSONEncodedDict, nullable=True)
-    from_theme = Column(Boolean, server_default="false")
+    lang: Mapped[str] = mapped_column(String(2), nullable=True)
+    public: Mapped[bool] = mapped_column(Boolean, server_default="true")
+    ts = mapped_column(TsVector)
+    the_geom = mapped_column(Geometry("GEOMETRY", srid=_srid, spatial_index=False))
+    params = mapped_column(JSONEncodedDict, nullable=True)
+    actions = mapped_column(JSONEncodedDict, nullable=True)
+    from_theme: Mapped[bool] = mapped_column(Boolean, server_default="false")
 
     def __str__(self) -> str:
         return f"{self.label}[{self.id}]"
@@ -131,8 +148,10 @@ class Functionality(Base):  # type: ignore
 
     __c2cgeoform_config__ = {"duplicate": True}
 
-    id = Column(Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}})
-    name = Column(
+    id: Mapped[int] = mapped_column(
+        Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}}
+    )
+    name: Mapped[str] = mapped_column(
         Unicode,
         nullable=False,
         info={
@@ -152,7 +171,7 @@ class Functionality(Base):  # type: ignore
             }
         },
     )
-    description = Column(
+    description: Mapped[str | None] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
@@ -161,7 +180,7 @@ class Functionality(Base):  # type: ignore
             }
         },
     )
-    value = Column(
+    value: Mapped[str] = mapped_column(
         Unicode,
         nullable=False,
         info={
@@ -222,8 +241,10 @@ class Role(Base):  # type: ignore
     __colanderalchemy_config__ = {"title": _("Role"), "plural": _("Roles")}
     __c2cgeoform_config__ = {"duplicate": True}
 
-    id = Column(Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}})
-    name = Column(
+    id: Mapped[int] = mapped_column(
+        Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}}
+    )
+    name: Mapped[str] = mapped_column(
         Unicode,
         unique=True,
         nullable=False,
@@ -234,7 +255,7 @@ class Role(Base):  # type: ignore
             }
         },
     )
-    description = Column(
+    description: Mapped[str | None] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
@@ -243,8 +264,8 @@ class Role(Base):  # type: ignore
             }
         },
     )
-    extent = Column(
-        Geometry("POLYGON", srid=_srid),
+    extent = mapped_column(
+        Geometry("POLYGON", srid=_srid, spatial_index=False),
         info={
             "colanderalchemy": {
                 "title": _("Extent"),
@@ -273,8 +294,8 @@ class Role(Base):  # type: ignore
         self,
         name: str = "",
         description: str = "",
-        functionalities: Optional[List[Functionality]] = None,
-        extent: Geometry = None,
+        functionalities: list[Functionality] | None = None,
+        extent: Geometry | None = None,
     ) -> None:
         if functionalities is None:
             functionalities = []
@@ -287,10 +308,10 @@ class Role(Base):  # type: ignore
         return f"{self.name}[{self.id}]>"
 
     @property
-    def bounds(self) -> Optional[Tuple[float, float, float, float]]:  # TODO
+    def bounds(self) -> tuple[float, float, float, float] | None:  # TODO
         if self.extent is None:
             return None
-        return cast(Tuple[float, float, float, float], to_shape(self.extent).bounds)
+        return cast(tuple[float, float, float, float], to_shape(self.extent).bounds)
 
 
 event.listen(Role.functionalities, "set", cache_invalidate_cb)
@@ -302,15 +323,17 @@ class TreeItem(Base):  # type: ignore
     """The treeitem table representation."""
 
     __tablename__ = "treeitem"
-    __table_args__: Union[Tuple[Any, ...], Dict[str, Any]] = (
+    __table_args__: tuple[Any, ...] | dict[str, Any] = (
         UniqueConstraint("type", "name"),
         {"schema": _schema},
     )
-    item_type = Column("type", String(10), nullable=False, info={"colanderalchemy": {"exclude": True}})
+    item_type: Mapped[str] = mapped_column(
+        "type", String(10), nullable=False, info={"colanderalchemy": {"exclude": True}}
+    )
     __mapper_args__ = {"polymorphic_on": item_type}
 
-    id = Column(Integer, primary_key=True)
-    name = Column(
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    name: Mapped[str] = mapped_column(
         Unicode,
         nullable=False,
         info={
@@ -325,7 +348,7 @@ class TreeItem(Base):  # type: ignore
             }
         },
     )
-    description = Column(
+    description: Mapped[str | None] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
@@ -337,7 +360,7 @@ class TreeItem(Base):  # type: ignore
 
     @property
     # Better: def parents(self) -> List[TreeGroup]:
-    def parents(self) -> List["TreeItem"]:
+    def parents(self) -> list["TreeItem"]:
         return [c.treegroup for c in self.parents_relation]
 
     def is_in_interface(self, name: str) -> bool:
@@ -350,7 +373,7 @@ class TreeItem(Base):  # type: ignore
 
         return False
 
-    def get_metadata(self, name: str) -> List["Metadata"]:
+    def get_metadata(self, name: str) -> list["Metadata"]:
         return [metadata for metadata in self.metadatas if metadata.name == name]
 
     def __init__(self, name: str = "") -> None:
@@ -373,11 +396,13 @@ class LayergroupTreeitem(Base):  # type: ignore
     __table_args__ = {"schema": _schema}
 
     # required by formalchemy
-    id = Column(Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}})
-    description = Column(Unicode, info={"colanderalchemy": {"exclude": True}})
-    treegroup_id = Column(
+    id: Mapped[int] = mapped_column(
+        Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}}
+    )
+    description: Mapped[str | None] = mapped_column(Unicode, info={"colanderalchemy": {"exclude": True}})
+    treegroup_id: Mapped[int] = mapped_column(
         Integer,
-        ForeignKey(_schema + ".treegroup.id"),
+        ForeignKey(_schema + ".treegroup.id", name="treegroup_id_fkey"),
         nullable=False,
         info={"colanderalchemy": {"exclude": True}},
     )
@@ -392,9 +417,9 @@ class LayergroupTreeitem(Base):  # type: ignore
         primaryjoin="LayergroupTreeitem.treegroup_id==TreeGroup.id",
         info={"colanderalchemy": {"exclude": True}, "c2cgeoform": {"duplicate": False}},
     )
-    treeitem_id = Column(
+    treeitem_id: Mapped[int] = mapped_column(
         Integer,
-        ForeignKey(_schema + ".treeitem.id"),
+        ForeignKey(_schema + ".treeitem.id", ondelete="CASCADE"),
         nullable=False,
         info={"colanderalchemy": {"widget": HiddenWidget()}},
     )
@@ -411,10 +436,10 @@ class LayergroupTreeitem(Base):  # type: ignore
         primaryjoin="LayergroupTreeitem.treeitem_id==TreeItem.id",
         info={"colanderalchemy": {"exclude": True}, "c2cgeoform": {"duplicate": False}},
     )
-    ordering = Column(Integer, info={"colanderalchemy": {"widget": HiddenWidget()}})
+    ordering: Mapped[int] = mapped_column(Integer, info={"colanderalchemy": {"widget": HiddenWidget()}})
 
     def __init__(
-        self, group: Optional["TreeGroup"] = None, item: Optional[TreeItem] = None, ordering: int = 0
+        self, group: Optional["TreeGroup"] = None, item: TreeItem | None = None, ordering: int = 0
     ) -> None:
         self.treegroup = group
         self.treeitem = item
@@ -434,14 +459,18 @@ class TreeGroup(TreeItem):
 
     __tablename__ = "treegroup"
     __table_args__ = {"schema": _schema}
-    __mapper_args__ = {"polymorphic_identity": "treegroup"}  # needed for _identity_class
+    __mapper_args__ = {"polymorphic_identity": "treegroup"}  # type: ignore[dict-item] # needed for _identity_class
 
-    id = Column(Integer, ForeignKey(_schema + ".treeitem.id"), primary_key=True)
+    id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey(_schema + ".treeitem.id", ondelete="CASCADE", name="treegroup_id_fkey"),
+        primary_key=True,
+    )
 
-    def _get_children(self) -> List[TreeItem]:
+    def _get_children(self) -> list[TreeItem]:
         return [c.treeitem for c in self.children_relation]
 
-    def _set_children(self, children: List[TreeItem], order: bool = False) -> None:
+    def _set_children(self, children: list[TreeItem], order: bool = False) -> None:
         """
         Set the current TreeGroup children TreeItem instances.
 
@@ -487,7 +516,7 @@ class LayerGroup(TreeGroup):
     __colanderalchemy_config__ = {
         "title": _("Layers group"),
         "plural": _("Layers groups"),
-        "description": Literal(
+        "description": c2cgeoportal_commons.lib.literal.Literal(
             _(
                 """
             <div class="help-block">
@@ -500,12 +529,12 @@ class LayerGroup(TreeGroup):
             )
         ),
     }
-    __mapper_args__ = {"polymorphic_identity": "group"}
+    __mapper_args__ = {"polymorphic_identity": "group"}  # type: ignore[dict-item]
     __c2cgeoform_config__ = {"duplicate": True}
 
-    id = Column(
+    id: Mapped[int] = mapped_column(
         Integer,
-        ForeignKey(_schema + ".treegroup.id"),
+        ForeignKey(_schema + ".treegroup.id", ondelete="CASCADE"),
         primary_key=True,
         info={"colanderalchemy": {"missing": drop, "widget": HiddenWidget()}},
     )
@@ -530,19 +559,19 @@ class Theme(TreeGroup):
     __tablename__ = "theme"
     __table_args__ = {"schema": _schema}
     __colanderalchemy_config__ = {"title": _("Theme"), "plural": _("Themes")}
-    __mapper_args__ = {"polymorphic_identity": "theme"}
+    __mapper_args__ = {"polymorphic_identity": "theme"}  # type: ignore[dict-item]
     __c2cgeoform_config__ = {"duplicate": True}
 
-    id = Column(
+    id: Mapped[int] = mapped_column(
         Integer,
-        ForeignKey(_schema + ".treegroup.id"),
+        ForeignKey(_schema + ".treegroup.id", ondelete="CASCADE"),
         primary_key=True,
         info={"colanderalchemy": {"missing": drop, "widget": HiddenWidget()}},
     )
-    ordering = Column(
+    ordering: Mapped[int] = mapped_column(
         Integer, nullable=False, info={"colanderalchemy": {"title": _("Order"), "widget": HiddenWidget()}}
     )
-    public = Column(
+    public: Mapped[bool] = mapped_column(
         Boolean,
         default=True,
         nullable=False,
@@ -553,12 +582,14 @@ class Theme(TreeGroup):
             }
         },
     )
-    icon = Column(
+    icon: Mapped[str] = mapped_column(
         Unicode,
+        nullable=True,
         info={
             "colanderalchemy": {
                 "title": _("Icon"),
                 "description": _("The icon URL."),
+                "missing": "",
             }
         },
     )
@@ -607,15 +638,15 @@ class Layer(TreeItem):
 
     __tablename__ = "layer"
     __table_args__ = {"schema": _schema}
-    __mapper_args__ = {"polymorphic_identity": "layer"}  # needed for _identity_class
+    __mapper_args__ = {"polymorphic_identity": "layer"}  # type: ignore[dict-item] # needed for _identity_class
 
-    id = Column(
+    id: Mapped[int] = mapped_column(
         Integer,
-        ForeignKey(_schema + ".treeitem.id"),
+        ForeignKey(_schema + ".treeitem.id", ondelete="CASCADE"),
         primary_key=True,
         info={"colanderalchemy": {"widget": HiddenWidget()}},
     )
-    public = Column(
+    public: Mapped[bool] = mapped_column(
         Boolean,
         default=True,
         info={
@@ -625,7 +656,7 @@ class Layer(TreeItem):
             }
         },
     )
-    geo_table = Column(
+    geo_table: Mapped[str | None] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
@@ -634,18 +665,22 @@ class Layer(TreeItem):
             }
         },
     )
-    exclude_properties = Column(
+    exclude_properties: Mapped[str] = mapped_column(
         Unicode,
+        nullable=True,
         info={
             "colanderalchemy": {
                 "title": _("Exclude properties"),
-                "description": _(
-                    """
+                "description": c2cgeoportal_commons.lib.literal.Literal(
+                    _(
+                        """
                     The list of attributes (database columns) that should not appear in
                     the editing form so that they cannot be modified by the end user.
-                    For enumerable attributes (foreign key), the column name should end with '_id'.
+                    For enumerable attributes (foreign key), the column name should end with <code>_id</code>.
                     """
+                    )
                 ),
+                "missing": "",
             }
         },
     )
@@ -658,19 +693,27 @@ class Layer(TreeItem):
 class DimensionLayer(Layer):
     """The intermediate class for the leyser with dimension."""
 
-    __mapper_args__ = {"polymorphic_identity": "dimensionlayer"}  # needed for _identity_class
+    __mapper_args__ = {"polymorphic_identity": "dimensionlayer"}  # type: ignore[dict-item] # needed for _identity_class
 
 
-OGCSERVER_TYPE_MAPSERVER = "mapserver"
-OGCSERVER_TYPE_QGISSERVER = "qgisserver"
-OGCSERVER_TYPE_GEOSERVER = "geoserver"
-OGCSERVER_TYPE_ARCGIS = "arcgis"
-OGCSERVER_TYPE_OTHER = "other"
+OGCServerType = Literal["mapserver", "qgisserver", "geoserver", "arcgis", "other"]
+OGCSERVER_TYPE_MAPSERVER: OGCServerType = "mapserver"
+OGCSERVER_TYPE_QGISSERVER: OGCServerType = "qgisserver"
+OGCSERVER_TYPE_GEOSERVER: OGCServerType = "geoserver"
+OGCSERVER_TYPE_ARCGIS: OGCServerType = "arcgis"
+OGCSERVER_TYPE_OTHER: OGCServerType = "other"
 
-OGCSERVER_AUTH_NOAUTH = "No auth"
-OGCSERVER_AUTH_STANDARD = "Standard auth"
-OGCSERVER_AUTH_GEOSERVER = "Geoserver auth"
-OGCSERVER_AUTH_PROXY = "Proxy"
+
+OGCServerAuth = Literal["No auth", "Standard auth", "Geoserver auth", "Proxy"]
+OGCSERVER_AUTH_NOAUTH: OGCServerAuth = "No auth"
+OGCSERVER_AUTH_STANDARD: OGCServerAuth = "Standard auth"
+OGCSERVER_AUTH_GEOSERVER: OGCServerAuth = "Geoserver auth"
+OGCSERVER_AUTH_PROXY: OGCServerAuth = "Proxy"
+
+
+ImageType = Literal["image/jpeg", "image/png", "image/webp"]
+TimeMode = Literal["disabled", "value", "range"]
+TimeWidget = Literal["slider", "datepicker"]
 
 
 class OGCServer(Base):  # type: ignore
@@ -681,7 +724,7 @@ class OGCServer(Base):  # type: ignore
     __colanderalchemy_config__ = {
         "title": _("OGC Server"),
         "plural": _("OGC Servers"),
-        "description": Literal(
+        "description": c2cgeoportal_commons.lib.literal.Literal(
             _(
                 """
             <div class="help-block">
@@ -696,55 +739,58 @@ class OGCServer(Base):  # type: ignore
         ),
     }
     __c2cgeoform_config__ = {"duplicate": True}
-    id = Column(Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}})
-    name = Column(
+    id: Mapped[int] = mapped_column(
+        Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}}
+    )
+    name: Mapped[str] = mapped_column(
         Unicode,
         nullable=False,
         unique=True,
         info={
             "colanderalchemy": {
                 "title": _("Name"),
-                "description": _("The name of the OGC Server"),
+                "description": c2cgeoportal_commons.lib.literal.Literal(
+                    _(
+                        "The name of the OGC Server should contain only unaccentuated letters, numbers and _. "
+                        "When you rename it, do not forget to update the <code>ogcServer</code> metadata on the "
+                        "WMTS and COG layers."
+                    )
+                ),
             }
         },
     )
-    description = Column(
+    description: Mapped[str | None] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
                 "title": _("Description"),
-                "description": _("A description"),
+                "description": _("An optional description."),
             }
         },
     )
-    url = Column(
+    url: Mapped[str] = mapped_column(
         Unicode,
         nullable=False,
         info={
             "colanderalchemy": {
                 "title": _("Basic URL"),
-                "description": _("The server URL"),
+                "description": _("The server URL."),
             }
         },
     )
-    url_wfs = Column(
+    url_wfs: Mapped[str | None] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
                 "title": _("WFS URL"),
-                "description": _("The WFS server URL. If empty, the ``Basic URL`` is used."),
+                "description": c2cgeoportal_commons.lib.literal.Literal(
+                    _("The WFS server URL. If empty, the <code>Basic URL</code> is used.")
+                ),
             }
         },
     )
-    type = Column(
-        Enum(
-            OGCSERVER_TYPE_MAPSERVER,
-            OGCSERVER_TYPE_QGISSERVER,
-            OGCSERVER_TYPE_GEOSERVER,
-            OGCSERVER_TYPE_ARCGIS,
-            OGCSERVER_TYPE_OTHER,
-            native_enum=False,
-        ),
+    type: Mapped[OGCServerType] = mapped_column(
+        Enum(*get_args(OGCServerType), native_enum=False),
         nullable=False,
         info={
             "colanderalchemy": {
@@ -752,56 +798,39 @@ class OGCServer(Base):  # type: ignore
                 "description": _(
                     "The server type which is used to know which custom attribute will be used."
                 ),
-                "widget": SelectWidget(
-                    values=(
-                        (OGCSERVER_TYPE_MAPSERVER, OGCSERVER_TYPE_MAPSERVER),
-                        (OGCSERVER_TYPE_QGISSERVER, OGCSERVER_TYPE_QGISSERVER),
-                        (OGCSERVER_TYPE_GEOSERVER, OGCSERVER_TYPE_GEOSERVER),
-                        (OGCSERVER_TYPE_ARCGIS, OGCSERVER_TYPE_ARCGIS),
-                        (OGCSERVER_TYPE_OTHER, OGCSERVER_TYPE_OTHER),
-                    )
-                ),
+                "widget": SelectWidget(values=list((e, e) for e in get_args(OGCServerType))),
             }
         },
     )
-    image_type = Column(
-        Enum("image/jpeg", "image/png", native_enum=False),
+    image_type: Mapped[ImageType] = mapped_column(
+        Enum(*get_args(ImageType), native_enum=False),
         nullable=False,
         info={
             "colanderalchemy": {
                 "title": _("Image type"),
-                "description": _("The MIME type of the images (e.g.: ``image/png``)."),
-                "widget": SelectWidget(values=(("image/jpeg", "image/jpeg"), ("image/png", "image/png"))),
+                "description": c2cgeoportal_commons.lib.literal.Literal(
+                    _(
+                        "The MIME type of the images (e.g.: <code>image/png</code>, <code>image/webp</code> is experimental)."
+                    )
+                ),
+                "widget": SelectWidget(values=list((e, e) for e in get_args(ImageType))),
                 "column": 2,
             }
         },
     )
-    auth = Column(
-        Enum(
-            OGCSERVER_AUTH_NOAUTH,
-            OGCSERVER_AUTH_STANDARD,
-            OGCSERVER_AUTH_GEOSERVER,
-            OGCSERVER_AUTH_PROXY,
-            native_enum=False,
-        ),
+    auth: Mapped[OGCServerAuth] = mapped_column(
+        Enum(*get_args(OGCServerAuth), native_enum=False),
         nullable=False,
         info={
             "colanderalchemy": {
                 "title": _("Authentication type"),
                 "description": "The kind of authentication to use.",
-                "widget": SelectWidget(
-                    values=(
-                        (OGCSERVER_AUTH_NOAUTH, OGCSERVER_AUTH_NOAUTH),
-                        (OGCSERVER_AUTH_STANDARD, OGCSERVER_AUTH_STANDARD),
-                        (OGCSERVER_AUTH_GEOSERVER, OGCSERVER_AUTH_GEOSERVER),
-                        (OGCSERVER_AUTH_PROXY, OGCSERVER_AUTH_PROXY),
-                    )
-                ),
+                "widget": SelectWidget(values=list((e, e) for e in get_args(OGCServerAuth))),
                 "column": 2,
             }
         },
     )
-    wfs_support = Column(
+    wfs_support: Mapped[bool] = mapped_column(
         Boolean,
         info={
             "colanderalchemy": {
@@ -811,7 +840,7 @@ class OGCServer(Base):  # type: ignore
             }
         },
     )
-    is_single_tile = Column(
+    is_single_tile: Mapped[bool] = mapped_column(
         Boolean,
         info={
             "colanderalchemy": {
@@ -825,12 +854,12 @@ class OGCServer(Base):  # type: ignore
     def __init__(
         self,
         name: str = "",
-        description: Optional[str] = None,
+        description: str | None = None,
         url: str = "https://wms.example.com",
-        url_wfs: Optional[str] = None,
-        type_: str = "mapserver",
-        image_type: str = "image/png",
-        auth: str = "Standard auth",
+        url_wfs: str | None = None,
+        type_: OGCServerType = OGCSERVER_TYPE_MAPSERVER,
+        image_type: ImageType = "image/png",
+        auth: OGCServerAuth = OGCSERVER_AUTH_STANDARD,
         wfs_support: bool = True,
         is_single_tile: bool = False,
     ) -> None:
@@ -848,23 +877,18 @@ class OGCServer(Base):  # type: ignore
         return self.name or ""
 
     def url_description(self, request: pyramid.request.Request) -> str:
-        errors: Set[str] = set()
+        errors: set[str] = set()
         url = get_url2(self.name, self.url, request, errors)
         return url.url() if url else "\n".join(errors)
 
-    def url_wfs_description(self, request: pyramid.request.Request) -> Optional[str]:
+    def url_wfs_description(self, request: pyramid.request.Request) -> str | None:
         if not self.url_wfs:
             return self.url_description(request)
-        errors: Set[str] = set()
+        errors: set[str] = set()
         url = get_url2(self.name, self.url_wfs, request, errors)
         return url.url() if url else "\n".join(errors)
 
 
-event.listen(OGCServer, "after_insert", cache_invalidate_cb, propagate=True)
-event.listen(OGCServer, "after_update", cache_invalidate_cb, propagate=True)
-event.listen(OGCServer, "after_delete", cache_invalidate_cb, propagate=True)
-
-
 class LayerWMS(DimensionLayer):
     """The layer_wms table representation."""
 
@@ -873,7 +897,7 @@ class LayerWMS(DimensionLayer):
     __colanderalchemy_config__ = {
         "title": _("WMS Layer"),
         "plural": _("WMS Layers"),
-        "description": Literal(
+        "description": c2cgeoportal_commons.lib.literal.Literal(
             _(
                 """
             <div class="help-block">
@@ -889,15 +913,15 @@ class LayerWMS(DimensionLayer):
 
     __c2cgeoform_config__ = {"duplicate": True}
 
-    __mapper_args__ = {"polymorphic_identity": "l_wms"}
+    __mapper_args__ = {"polymorphic_identity": "l_wms"}  # type: ignore[dict-item]
 
-    id = Column(
+    id: Mapped[int] = mapped_column(
         Integer,
         ForeignKey(_schema + ".layer.id", ondelete="CASCADE"),
         primary_key=True,
         info={"colanderalchemy": {"missing": None, "widget": HiddenWidget()}},
     )
-    ogc_server_id = Column(
+    ogc_server_id: Mapped[int] = mapped_column(
         Integer,
         ForeignKey(_schema + ".ogc_server.id"),
         nullable=False,
@@ -911,7 +935,7 @@ class LayerWMS(DimensionLayer):
             }
         },
     )
-    layer = Column(
+    layer: Mapped[str] = mapped_column(
         Unicode,
         nullable=False,
         info={
@@ -929,7 +953,7 @@ class LayerWMS(DimensionLayer):
             }
         },
     )
-    style = Column(
+    style: Mapped[str | None] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
@@ -939,30 +963,34 @@ class LayerWMS(DimensionLayer):
             }
         },
     )
-    valid = Column(
+    valid: Mapped[bool] = mapped_column(
         Boolean,
+        nullable=True,
         info={
             "colanderalchemy": {
                 "title": _("Valid"),
                 "description": _("The status reported by latest synchronization (readonly)."),
                 "column": 2,
                 "widget": CheckboxWidget(readonly=True),
+                "missing": colander_null,
             }
         },
     )
-    invalid_reason = Column(
+    invalid_reason: Mapped[str] = mapped_column(
         Unicode,
+        nullable=True,
         info={
             "colanderalchemy": {
                 "title": _("Reason why I am not valid"),
                 "description": _("The reason for status reported by latest synchronization (readonly)."),
                 "column": 2,
                 "widget": TextInputWidget(readonly=True),
+                "missing": "",
             }
         },
     )
-    time_mode = Column(
-        Enum("disabled", "value", "range", native_enum=False),
+    time_mode: Mapped[TimeMode] = mapped_column(
+        Enum(*get_args(TimeMode), native_enum=False),
         default="disabled",
         nullable=False,
         info={
@@ -976,8 +1004,8 @@ class LayerWMS(DimensionLayer):
             }
         },
     )
-    time_widget = Column(
-        Enum("slider", "datepicker", native_enum=False),
+    time_widget: Mapped[TimeWidget] = mapped_column(
+        Enum(*get_args(TimeWidget), native_enum=False),
         default="slider",
         nullable=False,
         info={
@@ -1008,8 +1036,8 @@ class LayerWMS(DimensionLayer):
         name: str = "",
         layer: str = "",
         public: bool = True,
-        time_mode: str = "disabled",
-        time_widget: str = "slider",
+        time_mode: TimeMode = "disabled",
+        time_widget: TimeWidget = "slider",
     ) -> None:
         super().__init__(name=name, public=public)
         self.layer = layer
@@ -1017,7 +1045,7 @@ class LayerWMS(DimensionLayer):
         self.time_widget = time_widget
 
     @staticmethod
-    def get_default(dbsession: Session) -> Optional[DimensionLayer]:
+    def get_default(dbsession: Session) -> DimensionLayer | None:
         return cast(
             Optional[DimensionLayer],
             dbsession.query(LayerWMS).filter(LayerWMS.name == "wms-defaults").one_or_none(),
@@ -1032,7 +1060,7 @@ class LayerWMTS(DimensionLayer):
     __colanderalchemy_config__ = {
         "title": _("WMTS Layer"),
         "plural": _("WMTS Layers"),
-        "description": Literal(
+        "description": c2cgeoportal_commons.lib.literal.Literal(
             _(
                 """
             <div class="help-block">
@@ -1080,15 +1108,15 @@ class LayerWMTS(DimensionLayer):
         ),
     }
     __c2cgeoform_config__ = {"duplicate": True}
-    __mapper_args__ = {"polymorphic_identity": "l_wmts"}
+    __mapper_args__ = {"polymorphic_identity": "l_wmts"}  # type: ignore[dict-item]
 
-    id = Column(
+    id: Mapped[int] = mapped_column(
         Integer,
-        ForeignKey(_schema + ".layer.id"),
+        ForeignKey(_schema + ".layer.id", ondelete="CASCADE"),
         primary_key=True,
         info={"colanderalchemy": {"missing": None, "widget": HiddenWidget()}},
     )
-    url = Column(
+    url: Mapped[str] = mapped_column(
         Unicode,
         nullable=False,
         info={
@@ -1099,29 +1127,32 @@ class LayerWMTS(DimensionLayer):
             }
         },
     )
-    layer = Column(
+    layer: Mapped[str] = mapped_column(
         Unicode,
         nullable=False,
         info={
             "colanderalchemy": {
                 "title": _("WMTS layer name"),
-                "description": _("The name of the WMTS layer to use"),
+                "description": _("The name of the WMTS layer to use."),
                 "column": 2,
             }
         },
     )
-    style = Column(
+    style: Mapped[str] = mapped_column(
         Unicode,
+        nullable=True,
         info={
             "colanderalchemy": {
                 "title": _("Style"),
                 "description": _("The style to use; if not present, the default style is used."),
                 "column": 2,
+                "missing": "",
             }
         },
     )
-    matrix_set = Column(
+    matrix_set: Mapped[str] = mapped_column(
         Unicode,
+        nullable=True,
         info={
             "colanderalchemy": {
                 "title": _("Matrix set"),
@@ -1130,34 +1161,35 @@ class LayerWMTS(DimensionLayer):
                     "left empty."
                 ),
                 "column": 2,
+                "missing": "",
             }
         },
     )
-    image_type = Column(
-        Enum("image/jpeg", "image/png", native_enum=False),
+    image_type: Mapped[ImageType] = mapped_column(
+        Enum(*get_args(ImageType), native_enum=False),
         nullable=False,
         info={
             "colanderalchemy": {
                 "title": _("Image type"),
-                "description": Literal(
+                "description": c2cgeoportal_commons.lib.literal.Literal(
                     _(
                         """
-                        The MIME type of the images (e.g.: <code>image/png</code>).
+                        The MIME type of the images (e.g.: <code>image/png</code>, <code>image/webp</code> is experimental).
                         """
                     )
                 ),
                 "column": 2,
-                "widget": SelectWidget(values=(("image/jpeg", "image/jpeg"), ("image/png", "image/png"))),
+                "widget": SelectWidget(values=list((e, e) for e in get_args(ImageType))),
             }
         },
     )
 
-    def __init__(self, name: str = "", public: bool = True, image_type: str = "image/png") -> None:
+    def __init__(self, name: str = "", public: bool = True, image_type: ImageType = "image/png") -> None:
         super().__init__(name=name, public=public)
         self.image_type = image_type
 
     @staticmethod
-    def get_default(dbsession: Session) -> Optional[DimensionLayer]:
+    def get_default(dbsession: Session) -> DimensionLayer | None:
         return cast(
             Optional[DimensionLayer],
             dbsession.query(LayerWMTS).filter(LayerWMTS.name == "wmts-defaults").one_or_none(),
@@ -1193,6 +1225,58 @@ layer_ra = Table(
 )
 
 
+class LayerCOG(Layer):
+    """The Cloud Optimized GeoTIFF layer table representation."""
+
+    __tablename__ = "layer_cog"
+    __table_args__ = {"schema": _schema}
+    __colanderalchemy_config__ = {
+        "title": _("COG Layer"),
+        "plural": _("COG Layers"),
+        "description": c2cgeoportal_commons.lib.literal.Literal(
+            _(
+                """
+            <div class="help-block">
+                <p>Definition of a <code>COG Layer</code> (COG for
+                <a href="https://www.cogeo.org/">Cloud Optimized GeoTIFF</a>).</p>
+                <p>Note: The layer named <code>cog-defaults</code> contain the values
+                used when a new <code>COG layer</code> is created.</p>
+            </div>
+                """
+            )
+        ),
+    }
+    __c2cgeoform_config__ = {"duplicate": True}
+    __mapper_args__ = {"polymorphic_identity": "l_cog"}  # type: ignore[dict-item]
+
+    id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey(_schema + ".layer.id"),
+        primary_key=True,
+        info={"colanderalchemy": {"missing": None, "widget": HiddenWidget()}},
+    )
+    url: Mapped[str] = mapped_column(
+        Unicode,
+        nullable=False,
+        info={
+            "colanderalchemy": {
+                "title": _("URL"),
+                "description": _("URL of the COG file."),
+                "column": 2,
+            }
+        },
+    )
+
+    @staticmethod
+    def get_default(dbsession: Session) -> Layer | None:
+        return dbsession.query(LayerCOG).filter(LayerCOG.name == "cog-defaults").one_or_none()
+
+    def url_description(self, request: pyramid.request.Request) -> str:
+        errors: set[str] = set()
+        url = get_url2(self.name, self.url, request, errors)
+        return url.url() if url else "\n".join(errors)
+
+
 class LayerVectorTiles(DimensionLayer):
     """The layer_vectortiles table representation."""
 
@@ -1201,7 +1285,7 @@ class LayerVectorTiles(DimensionLayer):
     __colanderalchemy_config__ = {
         "title": _("Vector Tiles Layer"),
         "plural": _("Vector Tiles Layers"),
-        "description": Literal(
+        "description": c2cgeoportal_commons.lib.literal.Literal(
             _(
                 """
             <div class="help-block">
@@ -1235,16 +1319,16 @@ class LayerVectorTiles(DimensionLayer):
 
     __c2cgeoform_config__ = {"duplicate": True}
 
-    __mapper_args__ = {"polymorphic_identity": "l_mvt"}
+    __mapper_args__ = {"polymorphic_identity": "l_mvt"}  # type: ignore[dict-item]
 
-    id = Column(
+    id: Mapped[int] = mapped_column(
         Integer,
         ForeignKey(_schema + ".layer.id"),
         primary_key=True,
         info={"colanderalchemy": {"missing": None, "widget": HiddenWidget()}},
     )
 
-    style = Column(
+    style: Mapped[str] = mapped_column(
         Unicode,
         nullable=False,
         info={
@@ -1252,7 +1336,7 @@ class LayerVectorTiles(DimensionLayer):
                 "title": _("Style"),
                 "description": _(
                     """
-                    The path to a Mapbox Style file (version 8 or higher). Example: https://url/style.json
+                    The path to a Mapbox Style file (version 8 or higher). Example: https://url/style.json.
                     """
                 ),
                 "column": 2,
@@ -1260,24 +1344,20 @@ class LayerVectorTiles(DimensionLayer):
         },
     )
 
-    sql = Column(
+    sql: Mapped[str] = mapped_column(
         Unicode,
         nullable=True,
         info={
             "colanderalchemy": {
                 "title": _("SQL query"),
-                "description": _(
-                    """
-                    A SQL query to get the vector tiles data.
-                    """
-                ),
+                "description": _("An SQL query to retrieve the vector tiles data."),
                 "column": 2,
                 "widget": TextAreaWidget(rows=15),
             }
         },
     )
 
-    xyz = Column(
+    xyz: Mapped[str] = mapped_column(
         Unicode,
         nullable=True,
         info={
@@ -1300,7 +1380,7 @@ class LayerVectorTiles(DimensionLayer):
         self.sql = sql
 
     @staticmethod
-    def get_default(dbsession: Session) -> Optional[DimensionLayer]:
+    def get_default(dbsession: Session) -> DimensionLayer | None:
         return cast(
             Optional[DimensionLayer],
             dbsession.query(LayerVectorTiles)
@@ -1309,7 +1389,7 @@ class LayerVectorTiles(DimensionLayer):
         )
 
     def style_description(self, request: pyramid.request.Request) -> str:
-        errors: Set[str] = set()
+        errors: set[str] = set()
         url = get_url2(self.name, self.style, request, errors)
         return url.url() if url else "\n".join(errors)
 
@@ -1321,9 +1401,11 @@ class RestrictionArea(Base):  # type: ignore
     __table_args__ = {"schema": _schema}
     __colanderalchemy_config__ = {"title": _("Restriction area"), "plural": _("Restriction areas")}
     __c2cgeoform_config__ = {"duplicate": True}
-    id = Column(Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}})
+    id: Mapped[int] = mapped_column(
+        Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}}
+    )
 
-    name = Column(
+    name: Mapped[str] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
@@ -1332,16 +1414,16 @@ class RestrictionArea(Base):  # type: ignore
             }
         },
     )
-    description = Column(
+    description: Mapped[str | None] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
                 "title": _("Description"),
-                "description": _("An optional description"),
+                "description": _("An optional description."),
             }
         },
     )
-    readwrite = Column(
+    readwrite: Mapped[bool] = mapped_column(
         Boolean,
         default=False,
         info={
@@ -1351,7 +1433,7 @@ class RestrictionArea(Base):  # type: ignore
             }
         },
     )
-    area = Column(
+    area = mapped_column(
         Geometry("POLYGON", srid=_srid),
         info={
             "colanderalchemy": {
@@ -1396,7 +1478,7 @@ class RestrictionArea(Base):  # type: ignore
             "colanderalchemy": {
                 "title": _("Layers"),
                 "exclude": True,
-                "description": Literal(
+                "description": c2cgeoportal_commons.lib.literal.Literal(
                     _(
                         """
                         <div class="help-block">
@@ -1425,9 +1507,9 @@ class RestrictionArea(Base):  # type: ignore
         self,
         name: str = "",
         description: str = "",
-        layers: Optional[List[Layer]] = None,
-        roles: Optional[List[Role]] = None,
-        area: Geometry = None,
+        layers: list[Layer] | None = None,
+        roles: list[Role] | None = None,
+        area: Geometry | None = None,
         readwrite: bool = False,
     ) -> None:
         if layers is None:
@@ -1481,8 +1563,10 @@ class Interface(Base):  # type: ignore
     __c2cgeoform_config__ = {"duplicate": True}
     __colanderalchemy_config__ = {"title": _("Interface"), "plural": _("Interfaces")}
 
-    id = Column(Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}})
-    name = Column(
+    id: Mapped[int] = mapped_column(
+        Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}}
+    )
+    name: Mapped[str] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
@@ -1491,7 +1575,7 @@ class Interface(Base):  # type: ignore
             }
         },
     )
-    description = Column(
+    description: Mapped[str | None] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
@@ -1553,18 +1637,23 @@ class Metadata(Base):  # type: ignore
         "plural": _("Metadatas"),
     }
 
-    id = Column(Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}})
-    name = Column(
+    id: Mapped[int] = mapped_column(
+        Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}}
+    )
+    name: Mapped[str] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
                 "title": _("Name"),
-                "description": Literal(_("The type of <code>Metadata</code> we want to set.")),
+                "description": c2cgeoportal_commons.lib.literal.Literal(
+                    _("The type of <code>Metadata</code> we want to set.")
+                ),
             }
         },
     )
-    value = Column(
+    value: Mapped[str] = mapped_column(
         Unicode,
+        nullable=True,
         info={
             "colanderalchemy": {
                 "title": _("Value"),
@@ -1573,7 +1662,7 @@ class Metadata(Base):  # type: ignore
             }
         },
     )
-    description = Column(
+    description: Mapped[str | None] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
@@ -1584,10 +1673,10 @@ class Metadata(Base):  # type: ignore
         },
     )
 
-    item_id = Column(
+    item_id: Mapped[int] = mapped_column(
         "item_id",
         Integer,
-        ForeignKey(_schema + ".treeitem.id"),
+        ForeignKey(_schema + ".treeitem.id", ondelete="CASCADE"),
         nullable=False,
         info={"colanderalchemy": {"exclude": True}, "c2cgeoform": {"duplicate": False}},
     )
@@ -1601,7 +1690,7 @@ class Metadata(Base):  # type: ignore
             info={
                 "colanderalchemy": {
                     "title": _("Metadatas"),
-                    "description": Literal(
+                    "description": c2cgeoportal_commons.lib.literal.Literal(
                         _(
                             """
         <div class="help-block">
@@ -1634,7 +1723,7 @@ class Metadata(Base):  # type: ignore
         ),
     )
 
-    def __init__(self, name: str = "", value: str = "", description: Optional[str] = None) -> None:
+    def __init__(self, name: str = "", value: str = "", description: str | None = None) -> None:
         self.name = name
         self.value = value
         self.description = description
@@ -1658,8 +1747,10 @@ class Dimension(Base):  # type: ignore
         "plural": _("Dimensions"),
     }
 
-    id = Column(Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}})
-    name = Column(
+    id: Mapped[int] = mapped_column(
+        Integer, primary_key=True, info={"colanderalchemy": {"widget": HiddenWidget()}}
+    )
+    name: Mapped[str] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
@@ -1668,8 +1759,9 @@ class Dimension(Base):  # type: ignore
             }
         },
     )
-    value = Column(
+    value: Mapped[str] = mapped_column(
         Unicode,
+        nullable=True,
         info={
             "colanderalchemy": {
                 "title": _("Value"),
@@ -1677,7 +1769,7 @@ class Dimension(Base):  # type: ignore
             }
         },
     )
-    field = Column(
+    field: Mapped[str | None] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
@@ -1688,7 +1780,7 @@ class Dimension(Base):  # type: ignore
             }
         },
     )
-    description = Column(
+    description: Mapped[str | None] = mapped_column(
         Unicode,
         info={
             "colanderalchemy": {
@@ -1699,7 +1791,7 @@ class Dimension(Base):  # type: ignore
         },
     )
 
-    layer_id = Column(
+    layer_id: Mapped[int] = mapped_column(
         "layer_id",
         Integer,
         ForeignKey(_schema + ".layer.id"),
@@ -1716,7 +1808,7 @@ class Dimension(Base):  # type: ignore
                 "colanderalchemy": {
                     "title": _("Dimensions"),
                     "exclude": True,
-                    "description": Literal(
+                    "description": c2cgeoportal_commons.lib.literal.Literal(
                         _(
                             """
         <div class="help-block">
@@ -1735,9 +1827,9 @@ class Dimension(Base):  # type: ignore
         self,
         name: str = "",
         value: str = "",
-        layer: Optional[str] = None,
-        field: Optional[str] = None,
-        description: Optional[str] = None,
+        layer: str | None = None,
+        field: str | None = None,
+        description: str | None = None,
     ) -> None:
         self.name = name
         self.value = value
@@ -1748,3 +1840,100 @@ class Dimension(Base):  # type: ignore
 
     def __str__(self) -> str:
         return f"{self.name}={self.value}[{self.id}]"
+
+
+class LogAction(enum.Enum):
+    """The log action enumeration."""
+
+    INSERT = enum.auto()
+    UPDATE = enum.auto()
+    DELETE = enum.auto()
+    SYNCHRONIZE = enum.auto()
+    CONVERT_TO_WMTS = enum.auto()
+    CONVERT_TO_WMS = enum.auto()
+
+
+class AbstractLog(AbstractConcreteBase, Base):  # type: ignore
+    """The abstract log table representation."""
+
+    strict_attrs = True
+    __colanderalchemy_config__ = {
+        "title": _("Log"),
+        "plural": _("Logs"),
+    }
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, info={"colanderalchemy": {}})
+    date: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        nullable=False,
+        info={
+            "colanderalchemy": {
+                "title": _("Date"),
+            }
+        },
+    )
+    action: Mapped[LogAction] = mapped_column(
+        Enum(LogAction, native_enum=False),
+        nullable=False,
+        info={
+            "colanderalchemy": {
+                "title": _("Action"),
+            }
+        },
+    )
+    element_type: Mapped[str] = mapped_column(
+        String(50),
+        nullable=False,
+        info={
+            "colanderalchemy": {
+                "title": _("Element type"),
+            }
+        },
+    )
+    element_id: Mapped[int] = mapped_column(
+        Integer,
+        nullable=False,
+        info={
+            "colanderalchemy": {
+                "title": _("Element identifier"),
+            }
+        },
+    )
+    element_name: Mapped[str] = mapped_column(
+        Unicode,
+        nullable=False,
+        info={
+            "colanderalchemy": {
+                "title": _("Element name"),
+            }
+        },
+    )
+    element_url_table: Mapped[str] = mapped_column(
+        Unicode,
+        nullable=False,
+        info={
+            "colanderalchemy": {
+                "title": _("Table segment of the element URL"),
+            }
+        },
+    )
+    username: Mapped[str] = mapped_column(
+        Unicode,
+        nullable=False,
+        info={
+            "colanderalchemy": {
+                "title": _("Username"),
+            }
+        },
+    )
+
+
+class Log(AbstractLog):
+    """The main log table representation."""
+
+    __tablename__ = "log"
+    __table_args__ = {"schema": _schema}
+    __mapper_args__ = {
+        "polymorphic_identity": "main",
+        "concrete": True,
+    }