goodmap 1.1.7__py3-none-any.whl

goodmap/exceptions.py

@@ -0,0 +1,100 @@
+"""Custom exceptions for Goodmap application."""
+
+import logging
+import uuid as uuid_lib
+
+from pydantic import ValidationError as PydanticValidationError
+
+logger = logging.getLogger(__name__)
+
+
+def _sanitize_uuid(uuid: str | None) -> str:
+    """Validate and sanitize UUID to prevent injection attacks."""
+    if uuid is None:
+        return "<unknown>"
+    try:
+        # Validate UUID format
+        uuid_lib.UUID(uuid)
+        return uuid
+    except (ValueError, AttributeError, TypeError):
+        logger.warning("Invalid UUID format detected", extra={"raw_uuid": repr(uuid)})
+        return "<invalid-uuid>"
+
+
+class GoodmapError(Exception):
+    """Base exception for all Goodmap errors."""
+
+    pass
+
+
+class ValidationError(GoodmapError):
+    """Base validation error."""
+
+    pass
+
+
+class LocationValidationError(ValidationError):
+    """Validation error for location data with enhanced context."""
+
+    def __init__(self, validation_error: PydanticValidationError, uuid: str | None = None):
+        self.uuid = _sanitize_uuid(uuid)
+        self.original_error = validation_error
+        self.validation_errors = validation_error.errors()
+        super().__init__(str(validation_error))
+
+    def __str__(self):
+        # Don't expose error details in string representation
+        if self.uuid and self.uuid not in ("<unknown>", "<invalid-uuid>"):
+            return f"Validation failed for location '{self.uuid}'"
+        return "Validation failed"
+
+
+class NotFoundError(GoodmapError):
+    """Resource not found error."""
+
+    def __init__(self, uuid: str, resource_type: str = "Resource"):
+        self.uuid = _sanitize_uuid(uuid)
+        super().__init__(f"{resource_type} with uuid '{self.uuid}' not found")
+
+
+class LocationNotFoundError(NotFoundError):
+    """Location with specified UUID not found."""
+
+    def __init__(self, uuid: str):
+        super().__init__(uuid, "Location")
+
+
+class AlreadyExistsError(GoodmapError):
+    """Resource already exists error."""
+
+    def __init__(self, uuid: str, resource_type: str = "Resource"):
+        self.uuid = _sanitize_uuid(uuid)
+        super().__init__(f"{resource_type} with uuid '{self.uuid}' already exists")
+
+
+class LocationAlreadyExistsError(AlreadyExistsError):
+    """Location with specified UUID already exists."""
+
+    def __init__(self, uuid: str):
+        super().__init__(uuid, "Location")
+
+
+class SuggestionNotFoundError(NotFoundError):
+    """Suggestion with specified UUID not found."""
+
+    def __init__(self, uuid: str):
+        super().__init__(uuid, "Suggestion")
+
+
+class SuggestionAlreadyExistsError(AlreadyExistsError):
+    """Suggestion with specified UUID already exists."""
+
+    def __init__(self, uuid: str):
+        super().__init__(uuid, "Suggestion")
+
+
+class ReportNotFoundError(NotFoundError):
+    """Report with specified UUID not found."""
+
+    def __init__(self, uuid: str):
+        super().__init__(uuid, "Report")

goodmap/formatter.py

@@ -0,0 +1,27 @@
+from flask_babel import gettext, lazy_gettext
+
+
+def safe_gettext(text):
+    if isinstance(text, list):
+        return list(map(gettext, text))
+    elif isinstance(text, dict):
+        return text
+    else:
+        return gettext(text)
+
+
+def prepare_pin(place, visible_fields, meta_data):
+    pin_data = {
+        "title": place["name"],
+        "subtitle": lazy_gettext(place["type_of_place"]),  # TODO this should not be obligatory
+        "position": place["position"],
+        "metadata": {
+            gettext(field): safe_gettext(place[field]) for field in meta_data if field in place
+        },
+        "data": [
+            [gettext(field), safe_gettext(place[field])]
+            for field in visible_fields
+            if field in place
+        ],
+    }
+    return pin_data

goodmap/goodmap.py

@@ -0,0 +1,89 @@
+import os
+
+from flask import Blueprint, redirect, render_template, session
+from flask_wtf.csrf import CSRFProtect, generate_csrf
+from platzky import platzky
+from platzky.config import languages_dict
+from platzky.models import CmsModule
+
+from goodmap.config import GoodmapConfig
+from goodmap.core_api import core_pages
+from goodmap.data_models.location import create_location_model
+from goodmap.db import extend_db_with_goodmap_queries, get_location_obligatory_fields
+
+
+def create_app(config_path: str) -> platzky.Engine:
+    config = GoodmapConfig.parse_yaml(config_path)
+    return create_app_from_config(config)
+
+
+# TODO Checking if there is a feature flag secition should be part of configs logic not client app
+def is_feature_enabled(config: GoodmapConfig, feature: str) -> bool:
+    return config.feature_flags.get(feature, False) if config.feature_flags else False
+
+
+def create_app_from_config(config: GoodmapConfig) -> platzky.Engine:
+    directory = os.path.dirname(os.path.realpath(__file__))
+
+    locale_dir = os.path.join(directory, "locale")
+    config.translation_directories.append(locale_dir)
+    app = platzky.create_app_from_config(config)
+
+    if is_feature_enabled(config, "USE_LAZY_LOADING"):
+        location_obligatory_fields = get_location_obligatory_fields(app.db)
+    else:
+        location_obligatory_fields = []
+
+    location_model = create_location_model(location_obligatory_fields)
+
+    app.db = extend_db_with_goodmap_queries(app.db, location_model)
+
+    CSRFProtect(app)
+
+    cp = core_pages(
+        app.db,
+        languages_dict(config.languages),
+        app.notify,
+        generate_csrf,
+        location_model,
+        feature_flags=config.feature_flags,
+    )
+    app.register_blueprint(cp)
+    goodmap = Blueprint("goodmap", __name__, url_prefix="/", template_folder="templates")
+
+    @goodmap.route("/")
+    def index():
+        return render_template(
+            "map.html",
+            feature_flags=config.feature_flags,
+            goodmap_frontend_lib_url=config.goodmap_frontend_lib_url,
+        )
+
+    @goodmap.route("/goodmap-admin")
+    def admin():
+        user = session.get("user", None)
+        if not user:
+            return redirect("/admin")
+
+        # TODO: This should be replaced with a proper user authentication check,
+        #       cms_modules should be passed from the app
+        return render_template(
+            "goodmap-admin.html",
+            feature_flags=config.feature_flags,
+            goodmap_frontend_lib_url=config.goodmap_frontend_lib_url,
+            user=user,
+            cms_modules=app.cms_modules,
+        )
+
+    app.register_blueprint(goodmap)
+    goodmap_cms_modules = CmsModule.model_validate(
+        {
+            "name": "Map admin panel",
+            "description": "Admin panel for managing map data",
+            "slug": "goodmap-admin",
+            "template": "goodmap-admin.html",
+        }
+    )
+    app.add_cms_module(goodmap_cms_modules)
+
+    return app