Merge pull request #2 from KatKatKateryna/kate/resources

Kate/resources

Author: doublebyte1

models/ConfigData.py

@@ -14,7 +14,7 @@ class LoggingLevel(Enum):
 
 # data classes
 @dataclass(kw_only=True)
-class RotationConfig:
+class LoggingRotationConfig:
     # Not currently used in the UI
     mode: str | None = None
     when: str | None = None
@@ -29,10 +29,10 @@ class LoggingConfig:
 
     # fields with default values:
     level: LoggingLevel = field(default_factory=lambda: LoggingLevel.ERROR)
-    logfile: str = field(default="")
 
     # optional fields:
+    logfile: str | None = None
     logformat: str | None = None
     dateformat: str | None = None
     # TODO: Not currently used in the UI
-    # rotation: RotationConfig | None = None
+    # rotation: LoggingRotationConfig | None = None

models/top_level/LoggingConfig.py

@@ -4,15 +4,15 @@
 
 
 # records
-class KeywordType(Enum):
+class MetadataKeywordTypeEnum(Enum):
     DISCIPLINE = "discipline"
     TEMPORAL = "temporal"
     PLACE = "place"
     THEME = "theme"
     STRATUM = "stratum"
 
 
-class Role(Enum):
+class MetadataRoleEnum(Enum):
     AUTHOR = "author"
     COAUTHOR = "coAuthor"
     COLLABORATOR = "collaborator"
@@ -37,31 +37,33 @@ class Role(Enum):
 
 # data classes
 @dataclass(kw_only=True)
-class IdentificationConfig:
+class MetadataIdentificationConfig:
     title: str | dict = field(default_factory=lambda: "")
     description: str | dict = field(default_factory=lambda: "")
     keywords: list | dict = field(default_factory=lambda: [])
-    keywords_type: KeywordType = field(default_factory=lambda: KeywordType.THEME)
+    keywords_type: MetadataKeywordTypeEnum = field(
+        default_factory=lambda: MetadataKeywordTypeEnum.THEME
+    )
     terms_of_service: str = field(
         default="https://creativecommons.org/licenses/by/4.0/"
     )
     url: str = field(default="https://example.org")
 
 
 @dataclass(kw_only=True)
-class LicenseConfig:
+class MetadataLicenseConfig:
     name: str = field(default="CC-BY 4.0 license")
     url: str = field(default="https://creativecommons.org/licenses/by/4.0/")
 
 
 @dataclass(kw_only=True)
-class ProviderConfig:
+class MetadataProviderConfig:
     name: str = field(default="Organization Name")
     url: str = field(default="https://pygeoapi.io")
 
 
 @dataclass(kw_only=True)
-class ContactConfig:
+class MetadataContactConfig:
     name: str = field(default="Lastname, Firstname")
     position: str = field(default="Position Title")
     address: str = field(default="Mailing Address")
@@ -75,19 +77,27 @@ class ContactConfig:
     url: str = field(default="Contact URL")
     hours: str = field(default="Mo-Fr 08:00-17:00")
     instructions: str = field(default="During hours of service. Off on weekends.")
-    role: Role = field(default_factory=lambda: Role.POINTOFCONTACT)
+    role: MetadataRoleEnum = field(
+        default_factory=lambda: MetadataRoleEnum.POINTOFCONTACT
+    )
 
 
 @dataclass(kw_only=True)
 class MetadataConfig:
     """Placeholder class for Metadata configuration data."""
 
-    identification: IdentificationConfig = field(
-        default_factory=lambda: IdentificationConfig()
+    identification: MetadataIdentificationConfig = field(
+        default_factory=lambda: MetadataIdentificationConfig()
+    )
+    license: MetadataLicenseConfig = field(
+        default_factory=lambda: MetadataLicenseConfig()
+    )
+    provider: MetadataProviderConfig = field(
+        default_factory=lambda: MetadataProviderConfig()
+    )
+    contact: MetadataContactConfig = field(
+        default_factory=lambda: MetadataContactConfig()
     )
-    license: LicenseConfig = field(default_factory=lambda: LicenseConfig())
-    provider: ProviderConfig = field(default_factory=lambda: ProviderConfig())
-    contact: ContactConfig = field(default_factory=lambda: ContactConfig())
 
     def get_invalid_properties(self):
         """Checks the values of mandatory fields: identification (title, description, keywords)."""

models/top_level/MetadataConfig.py

@@ -1,92 +1,128 @@
 from dataclasses import dataclass, field
+from datetime import datetime
 from enum import Enum
 
-from .utils import InlineList
+from .providers import ProviderPostgresql, ProviderMvtProxy, ProviderWmsFacade
+from .utils import (
+    InlineList,
+    bbox_from_list,
+    get_enum_value_from_string,
+    is_valid_string,
+)
+from .providers.records import CrsAuthorities
+from .providers.records import Languages
 
 
 # records
-class ResourceTypes(Enum):
+class ResourceTypesEnum(Enum):
     COLLECTION = "collection"
     STAC = "stac-collection"
 
 
-class ProviderTypes(Enum):
-    FEATURE = "feature"
-    MAP = "map"
-    TILE = "tile"
+class ResourceVisibilityEnum(Enum):
+    NONE = ""
+    DEFAULT = "default"
+    HIDDEN = "hidden"
 
 
 # data classes
 @dataclass(kw_only=True)
-class ProviderTemplate:
-    """Class to represent a Provider configuration template."""
+class ResourceLinkTemplate:
+    """Class to represent a Link configuration template."""
 
-    type: ProviderTypes
-    name: str
-    data: str
+    type: str = ""
+    rel: str = ""
+    href: str = ""
 
-    # optional fields:
-    id_field: str | None = None
-    title_field: str | None = None
-    geometry: dict | None = None
-    options: dict | None = None
-    format: dict | None = None
+    # optional
+    title: str | None = None
+    hreflang: Languages | None = None
+    length: int | None = None
 
 
 @dataclass(kw_only=True)
-class LinkTemplate:
-    """Class to represent a Link configuration template."""
+class ResourceSpatialConfig:
+    bbox: InlineList = field(default_factory=lambda: InlineList([-180, -90, 180, 90]))
+
+    # optional, but with assumed default value:
+    crs: str = field(default="http://www.opengis.net/def/crs/OGC/1.3/CRS84")
+
+    # we need these as separate properties so that Enum class values can be set&selected in the UI
+    @property
+    def crs_authority(self):
+        crs_auth_id = self.crs.split("http://www.opengis.net/def/crs/")[
+            -1
+        ]  # OGC/1.3/CRS84
+        auth_string = "/".join(crs_auth_id.split("/")[:-1])
+        return get_enum_value_from_string(CrsAuthorities, auth_string)
 
-    type: str
-    rel: str
-    title: str
-    href: str
-    hreflang: str
+    @property
+    def crs_id(self):
+        return self.crs.split("/")[-1]
 
 
 @dataclass(kw_only=True)
-class SpatialConfig:
-    bbox: InlineList = field(default_factory=lambda: InlineList([-180, -90, 180, 90]))
-    crs: str = field(default="http://www.opengis.net/def/crs/OGC/1.3/CRS84")
+class ResourceTemporalConfig:
+
+    # optional
+    begin: str | datetime | None = None
+    end: str | datetime | None = None
+    trs: str | None = None
 
 
 @dataclass(kw_only=True)
-class ExtentsConfig:
+class ResourceExtentsConfig:
     """Class to represent Extents configuration template."""
 
     # fields with default values:
-    spatial: dict = field(default_factory=lambda: SpatialConfig())
+    spatial: ResourceSpatialConfig = field(
+        default_factory=lambda: ResourceSpatialConfig()
+    )
 
-    # optional fields:
-    temporal: dict | None = None
+    # optional
+    temporal: ResourceTemporalConfig | None = None
 
 
 @dataclass(kw_only=True)
 class ResourceConfigTemplate:
     """Class to represent a Resource configuration template."""
 
     # fields with default values:
-    type: ResourceTypes = field(default_factory=lambda: ResourceTypes.COLLECTION)
+    type: ResourceTypesEnum = field(
+        default_factory=lambda: ResourceTypesEnum.COLLECTION
+    )
     title: str | dict = field(default="")
     description: str | dict = field(default="")
     keywords: list | dict = field(default_factory=lambda: [])
-    links: list[LinkTemplate] = field(default_factory=lambda: [])
-    extents: ExtentsConfig = field(default_factory=lambda: ExtentsConfig())
-    providers: list[ProviderTemplate] = field(default_factory=lambda: [])
+    links: list[ResourceLinkTemplate] = field(default_factory=lambda: [])
+    extents: ResourceExtentsConfig = field(
+        default_factory=lambda: ResourceExtentsConfig()
+    )
+    # for providers, the types have to be explicitly listed so they are picked up on deserialization
+    providers: list[
+        ProviderPostgresql | ProviderMvtProxy | ProviderWmsFacade | dict
+    ] = field(default_factory=lambda: [])
+
+    # optional
+    visibility: ResourceVisibilityEnum | None = None
+    # limits, linked-data: ignored for now
 
     # Overwriding __init__ method to pass 'instance_name' as an input but not make it an instance property
     # This will allow to have a clean 'asdict(class)' output without 'instance_name' in it
     def __init__(
         self,
         *,
         instance_name: str,
-        type: str = "collection",
+        type: ResourceTypesEnum = ResourceTypesEnum.COLLECTION,
         title: str = "",
         description: str = "",
         keywords: dict = None,
-        links: list[LinkTemplate] = None,
-        extents: ExtentsConfig = None,
-        providers: list[ProviderTemplate] = None
+        links: list[ResourceLinkTemplate] = None,
+        extents: ResourceExtentsConfig = None,
+        providers: list[
+            ProviderPostgresql | ProviderMvtProxy | ProviderWmsFacade
+        ] = None,
+        visibility: ResourceVisibilityEnum | None = None
     ):
         self._instance_name = instance_name
         self.type = type
@@ -115,7 +151,38 @@ def __init__(
         self.links = links
         self.extents = extents
         self.providers = providers
+        self.visibility = visibility
 
     @property
     def instance_name(self):
         return self._instance_name
+
+    def validate_reassign_bbox(self) -> bool:
+        """Validates the bbox values and converts to int/float if needed."""
+        try:
+            self.extents.spatial.bbox = bbox_from_list(self.extents.spatial.bbox)
+            return True
+        except ValueError:
+            self.extents.spatial.bbox = InlineList([-180, -90, 180, 90])
+            return False
+
+    def get_invalid_properties(self):
+        """Checks the values of mandatory fields: identification (title, description, keywords)."""
+        all_invalid_fields = []
+
+        if not isinstance(self.type, ResourceTypesEnum):
+            all_invalid_fields.append("type")
+        if len(self.title) == 0:
+            all_invalid_fields.append("title")
+        if len(self.description) == 0:
+            all_invalid_fields.append("description")
+        if len(self.keywords) == 0:
+            all_invalid_fields.append("keywords")
+        if len(self.providers) == 0:
+            all_invalid_fields.append("providers")
+        if not is_valid_string(self.extents.spatial.crs):
+            all_invalid_fields.append("extents.spatial.crs")
+        if len(self.extents.spatial.bbox) < 4:
+            all_invalid_fields.append("extents.spatial.bbox")
+
+        return all_invalid_fields