goodmap 1.1.6__tar.gz → 1.1.8__tar.gz

{goodmap-1.1.6 → goodmap-1.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: goodmap
-Version: 1.1.6
+Version: 1.1.8
 Summary: Map engine to serve all the people :)
 License-File: LICENSE.md
 Author: Krzysztof Kolodzinski

{goodmap-1.1.6 → goodmap-1.1.8}/goodmap/core_api.py

@@ -8,11 +8,18 @@ from flask import Blueprint, jsonify, make_response, request
 from flask_babel import gettext
 from flask_restx import Api, Resource, fields
 from platzky.config import LanguagesMapping
+from werkzeug.exceptions import BadRequest
 
 from goodmap.clustering import (
     map_clustering_data_to_proper_lazy_loading_object,
     match_clusters_uuids,
 )
+from goodmap.exceptions import (
+    LocationAlreadyExistsError,
+    LocationNotFoundError,
+    LocationValidationError,
+    ReportNotFoundError,
+)
 from goodmap.formatter import prepare_pin
 
 # SuperCluster configuration constants
@@ -21,6 +28,11 @@ MAX_ZOOM = 16
 CLUSTER_RADIUS = 200
 CLUSTER_EXTENT = 512
 
+# Error message constants
+ERROR_INVALID_REQUEST_DATA = "Invalid request data"
+ERROR_INVALID_LOCATION_DATA = "Invalid location data"
+ERROR_INTERNAL_ERROR = "An internal error occurred"
+
 logger = logging.getLogger(__name__)
 
 
@@ -102,10 +114,20 @@ def core_pages(
                     f"at position: {location.position}"
                 )
                 notifier_function(message)
-            except ValueError as e:
-                return make_response(jsonify({"message": f"Invalid location data: {e}"}), 400)
-            except Exception as e:
-                return make_response(jsonify({"message": f"Error sending notification : {e}"}), 400)
+            except BadRequest:
+                logger.warning("Invalid JSON in suggest endpoint")
+                return make_response(jsonify({"message": ERROR_INVALID_REQUEST_DATA}), 400)
+            except LocationValidationError as e:
+                logger.warning(
+                    "Location validation failed in suggest endpoint",
+                    extra={"errors": e.validation_errors},
+                )
+                return make_response(jsonify({"message": ERROR_INVALID_LOCATION_DATA}), 400)
+            except Exception:
+                logger.error("Error in suggest location endpoint", exc_info=True)
+                return make_response(
+                    jsonify({"message": "An error occurred while processing your suggestion"}), 500
+                )
             return make_response(jsonify({"message": "Location suggested"}), 200)
 
     @core_api.route("/report-location")
@@ -128,12 +150,19 @@ def core_pages(
                     f"with problem: {location_report['description']}"
                 )
                 notifier_function(message)
+            except BadRequest:
+                logger.warning("Invalid JSON in report location endpoint")
+                return make_response(jsonify({"message": ERROR_INVALID_REQUEST_DATA}), 400)
             except KeyError as e:
+                logger.warning(
+                    "Missing required field in report location", extra={"missing_field": str(e)}
+                )
                 error_message = gettext("Error reporting location")
-                return make_response(jsonify({"message": f"{error_message} : {e}"}), 400)
-            except Exception as e:
+                return make_response(jsonify({"message": error_message}), 400)
+            except Exception:
+                logger.error("Error in report location endpoint", exc_info=True)
                 error_message = gettext("Error sending notification")
-                return make_response(jsonify({"message": f"{error_message} : {e}"}), 400)
+                return make_response(jsonify({"message": error_message}), 500)
             return make_response(jsonify({"message": gettext("Location reported")}), 200)
 
     @core_api.route("/locations")
@@ -296,10 +325,15 @@ def core_pages(
                 location_data.update({"uuid": str(uuid.uuid4())})
                 location = location_model.model_validate(location_data)
                 database.add_location(location.model_dump())
-            except ValueError as e:
-                return make_response(jsonify({"message": f"Invalid location data: {e}"}), 400)
-            except Exception as e:
-                return make_response(jsonify({"message": f"Error creating location: {e}"}), 400)
+            except LocationValidationError as e:
+                logger.warning(
+                    "Location validation failed",
+                    extra={"uuid": e.uuid, "errors": e.validation_errors},
+                )
+                return make_response(jsonify({"message": ERROR_INVALID_LOCATION_DATA}), 400)
+            except Exception:
+                logger.error("Error creating location", exc_info=True)
+                return make_response(jsonify({"message": ERROR_INTERNAL_ERROR}), 500)
             return jsonify(location.model_dump())
 
     @core_api.route("/admin/locations/<location_id>")
@@ -313,10 +347,18 @@ def core_pages(
                 location_data.update({"uuid": location_id})
                 location = location_model.model_validate(location_data)
                 database.update_location(location_id, location.model_dump())
-            except ValueError as e:
-                return make_response(jsonify({"message": f"Invalid location data: {e}"}), 400)
-            except Exception as e:
-                return make_response(jsonify({"message": f"Error updating location: {e}"}), 400)
+            except LocationValidationError as e:
+                logger.warning(
+                    "Location validation failed",
+                    extra={"uuid": e.uuid, "errors": e.validation_errors},
+                )
+                return make_response(jsonify({"message": ERROR_INVALID_LOCATION_DATA}), 400)
+            except LocationNotFoundError as e:
+                logger.info("Location not found for update", extra={"uuid": e.uuid})
+                return make_response(jsonify({"message": "Location not found"}), 404)
+            except Exception:
+                logger.error("Error updating location", exc_info=True)
+                return make_response(jsonify({"message": ERROR_INTERNAL_ERROR}), 500)
             return jsonify(location.model_dump())
 
         def delete(self, location_id):
@@ -325,10 +367,12 @@ def core_pages(
             """
             try:
                 database.delete_location(location_id)
-            except ValueError as e:
-                return make_response(jsonify({"message": f"Location not found: {e}"}), 404)
-            except Exception as e:
-                return make_response(jsonify({"message": f"Error deleting location: {e}"}), 400)
+            except LocationNotFoundError as e:
+                logger.info("Location not found for deletion", extra={"uuid": e.uuid})
+                return make_response(jsonify({"message": "Location not found"}), 404)
+            except Exception:
+                logger.error("Error deleting location", exc_info=True)
+                return make_response(jsonify({"message": ERROR_INTERNAL_ERROR}), 500)
             return "", 204
 
     @core_api.route("/admin/suggestions")
@@ -352,7 +396,7 @@ def core_pages(
                 data = request.get_json()
                 status = data.get("status")
                 if status not in ("accepted", "rejected"):
-                    return make_response(jsonify({"message": f"Invalid status: {status}"}), 400)
+                    return make_response(jsonify({"message": "Invalid status"}), 400)
                 suggestion = database.get_suggestion(suggestion_id)
                 if not suggestion:
                     return make_response(jsonify({"message": "Suggestion not found"}), 404)
@@ -362,8 +406,20 @@ def core_pages(
                     suggestion_data = {k: v for k, v in suggestion.items() if k != "status"}
                     database.add_location(suggestion_data)
                 database.update_suggestion(suggestion_id, status)
-            except ValueError as e:
-                return make_response(jsonify({"message": f"{e}"}), 400)
+            except LocationValidationError as e:
+                logger.warning(
+                    "Location validation failed in suggestion",
+                    extra={"uuid": e.uuid, "errors": e.validation_errors},
+                )
+                return make_response(jsonify({"message": ERROR_INVALID_LOCATION_DATA}), 400)
+            except LocationAlreadyExistsError as e:
+                logger.warning(
+                    "Attempted to create duplicate location from suggestion", extra={"uuid": e.uuid}
+                )
+                return make_response(jsonify({"message": "Location already exists"}), 409)
+            except Exception:
+                logger.error("Error processing suggestion", exc_info=True)
+                return make_response(jsonify({"message": ERROR_INTERNAL_ERROR}), 500)
             return jsonify(database.get_suggestion(suggestion_id))
 
     @core_api.route("/admin/reports")
@@ -390,15 +446,22 @@ def core_pages(
                 valid_status = ("resolved", "rejected")
                 valid_priority = ("critical", "high", "medium", "low")
                 if status and status not in valid_status:
-                    return make_response(jsonify({"message": f"Invalid status: {status}"}), 400)
+                    return make_response(jsonify({"message": "Invalid status"}), 400)
                 if priority and priority not in valid_priority:
-                    return make_response(jsonify({"message": f"Invalid priority: {priority}"}), 400)
+                    return make_response(jsonify({"message": "Invalid priority"}), 400)
                 report = database.get_report(report_id)
                 if not report:
                     return make_response(jsonify({"message": "Report not found"}), 404)
                 database.update_report(report_id, status=status, priority=priority)
-            except ValueError as e:
-                return make_response(jsonify({"message": f"{e}"}), 400)
+            except BadRequest:
+                logger.warning("Invalid JSON in report update endpoint")
+                return make_response(jsonify({"message": ERROR_INVALID_REQUEST_DATA}), 400)
+            except ReportNotFoundError as e:
+                logger.info("Report not found for update", extra={"uuid": e.uuid})
+                return make_response(jsonify({"message": "Report not found"}), 404)
+            except Exception:
+                logger.error("Error updating report", exc_info=True)
+                return make_response(jsonify({"message": ERROR_INTERNAL_ERROR}), 500)
             return jsonify(database.get_report(report_id))
 
     return core_api_blueprint

{goodmap-1.1.6 → goodmap-1.1.8}/goodmap/data_models/location.py

@@ -1,6 +1,15 @@
 from typing import Any, Type
 
-from pydantic import BaseModel, Field, create_model, field_validator
+from pydantic import (
+    BaseModel,
+    Field,
+    ValidationError,
+    create_model,
+    field_validator,
+    model_validator,
+)
+
+from goodmap.exceptions import LocationValidationError
 
 
 class LocationBase(BaseModel, extra="allow"):
@@ -16,6 +25,24 @@ class LocationBase(BaseModel, extra="allow"):
             raise ValueError("longitude must be in range -180 to 180")
         return v
 
+    @model_validator(mode="before")
+    @classmethod
+    def validate_uuid_exists(cls, data: Any) -> Any:
+        """Ensure UUID is present before validation for better error messages."""
+        if isinstance(data, dict) and "uuid" not in data:
+            raise ValueError("Location data must include 'uuid' field")
+        return data
+
+    @model_validator(mode="wrap")
+    @classmethod
+    def enrich_validation_errors(cls, data, handler):
+        """Wrap validation errors with UUID context for better debugging."""
+        try:
+            return handler(data)
+        except ValidationError as e:
+            uuid = data.get("uuid") if isinstance(data, dict) else None
+            raise LocationValidationError(e, uuid=uuid) from e
+
     def basic_info(self):
         return {
             "uuid": self.uuid,

{goodmap-1.1.6 → goodmap-1.1.8}/goodmap/db.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import os
 import tempfile
 from functools import partial
@@ -6,6 +7,14 @@ from typing import Any
 
 from goodmap.core import get_queried_data
 from goodmap.data_models.location import LocationBase
+from goodmap.exceptions import (
+    AlreadyExistsError,
+    LocationAlreadyExistsError,
+    LocationNotFoundError,
+    ReportNotFoundError,
+)
+
+logger = logging.getLogger(__name__)
 
 # TODO file is temporary solution to be compatible with old, static code,
 #  it should be replaced with dynamic solution
@@ -227,61 +236,28 @@ class FileIOHelper:
         return json_data.get(data_key, {})
 
 
-class ErrorHelper:
-    """Common error handling utilities."""
-
-    @staticmethod
-    def raise_already_exists_error(item_type, uuid):
-        """Raise standardized 'already exists' error."""
-        raise ValueError(f"{item_type} with uuid {uuid} already exists")
+class CRUDHelper:
+    """Common CRUD operation utilities to eliminate duplication."""
 
     @staticmethod
-    def raise_not_found_error(item_type, uuid):
-        """Raise standardized 'not found' error."""
-        raise ValueError(f"{item_type} with uuid {uuid} not found")
+    def add_item_to_json_db(db_data, collection_name, item_data, default_status=None):
+        """Add item to JSON in-memory database."""
+        collection = db_data.setdefault(collection_name, [])
+        uuid = item_data.get("uuid")
+        resource_type = collection_name.rstrip("s").capitalize()
 
-    @staticmethod
-    def check_item_exists(items, uuid, item_type):
-        """Check if item with UUID exists and raise error if it does."""
+        # Check if item already exists
         existing = next(
             (
                 item
-                for item in items
+                for item in collection
                 if (item.get("uuid") if isinstance(item, dict) else getattr(item, "uuid", None))
                 == uuid
             ),
             None,
         )
         if existing:
-            ErrorHelper.raise_already_exists_error(item_type, uuid)
-
-    @staticmethod
-    def find_item_by_uuid(items, uuid, item_type):
-        """Find item by UUID and raise error if not found."""
-        item = next(
-            (
-                item
-                for item in items
-                if (item.get("uuid") if isinstance(item, dict) else getattr(item, "uuid", None))
-                == uuid
-            ),
-            None,
-        )
-        if not item:
-            ErrorHelper.raise_not_found_error(item_type, uuid)
-        return item
-
-
-class CRUDHelper:
-    """Common CRUD operation utilities to eliminate duplication."""
-
-    @staticmethod
-    def add_item_to_json_db(db_data, collection_name, item_data, default_status=None):
-        """Add item to JSON in-memory database."""
-        collection = db_data.setdefault(collection_name, [])
-        ErrorHelper.check_item_exists(
-            collection, item_data.get("uuid"), collection_name.rstrip("s").capitalize()
-        )
+            raise AlreadyExistsError(uuid, resource_type)
 
         record = dict(item_data)
         if default_status:
@@ -294,9 +270,21 @@ class CRUDHelper:
         json_file = FileIOHelper.read_json_file(file_path)
         collection = json_file["map"].get(collection_name, [])
 
-        ErrorHelper.check_item_exists(
-            collection, item_data.get("uuid"), collection_name.rstrip("s").capitalize()
+        uuid = item_data.get("uuid")
+        resource_type = collection_name.rstrip("s").capitalize()
+
+        # Check if item already exists
+        existing = next(
+            (
+                item
+                for item in collection
+                if (item.get("uuid") if isinstance(item, dict) else getattr(item, "uuid", None))
+                == uuid
+            ),
+            None,
         )
+        if existing:
+            raise AlreadyExistsError(uuid, resource_type)
 
         record = dict(item_data)
         if default_status:
@@ -311,7 +299,7 @@ class CRUDHelper:
         """Add item to MongoDB database."""
         existing = db_collection.find_one({"uuid": item_data.get("uuid")})
         if existing:
-            ErrorHelper.raise_already_exists_error(item_type, item_data.get("uuid"))
+            raise AlreadyExistsError(item_data.get("uuid"), item_type)
 
         record = dict(item_data)
         if default_status:
@@ -787,7 +775,7 @@ def json_file_db_add_location(self, location_data, location_model):
         (i for i, point in enumerate(map_data) if point.get("uuid") == location_data["uuid"]), None
     )
     if idx is not None:
-        raise ValueError(f"Location with uuid {location_data['uuid']} already exists")
+        raise LocationAlreadyExistsError(location_data["uuid"])
 
     map_data.append(location.model_dump())
     json_file["map"]["data"] = map_data
@@ -806,7 +794,7 @@ def json_db_add_location(self, location_data, location_model):
         None,
     )
     if idx is not None:
-        raise ValueError(f"Location with uuid {location_data['uuid']} already exists")
+        raise LocationAlreadyExistsError(location_data["uuid"])
     self.data["data"].append(location.model_dump())
 
 
@@ -814,7 +802,7 @@ def mongodb_db_add_location(self, location_data, location_model):
     location = location_model.model_validate(location_data)
     existing = self.db.locations.find_one({"uuid": location_data["uuid"]})
     if existing:
-        raise ValueError(f"Location with uuid {location_data['uuid']} already exists")
+        raise LocationAlreadyExistsError(location_data["uuid"])
     self.db.locations.insert_one(location.model_dump())
 
 
@@ -834,7 +822,7 @@ def json_file_db_update_location(self, uuid, location_data, location_model):
     map_data = json_file["map"].get("data", [])
     idx = next((i for i, point in enumerate(map_data) if point.get("uuid") == uuid), None)
     if idx is None:
-        raise ValueError(f"Location with uuid {uuid} not found")
+        raise LocationNotFoundError(uuid)
 
     map_data[idx] = location.model_dump()
     json_file["map"]["data"] = map_data
@@ -848,7 +836,7 @@ def json_db_update_location(self, uuid, location_data, location_model):
         (i for i, point in enumerate(self.data.get("data", [])) if point.get("uuid") == uuid), None
     )
     if idx is None:
-        raise ValueError(f"Location with uuid {uuid} not found")
+        raise LocationNotFoundError(uuid)
     self.data["data"][idx] = location.model_dump()
 
 
@@ -856,7 +844,7 @@ def mongodb_db_update_location(self, uuid, location_data, location_model):
     location = location_model.model_validate(location_data)
     result = self.db.locations.update_one({"uuid": uuid}, {"$set": location.model_dump()})
     if result.matched_count == 0:
-        raise ValueError(f"Location with uuid {uuid} not found")
+        raise LocationNotFoundError(uuid)
 
 
 def update_location(db, uuid, location_data, location_model):
@@ -874,7 +862,7 @@ def json_file_db_delete_location(self, uuid):
     map_data = json_file["map"].get("data", [])
     idx = next((i for i, point in enumerate(map_data) if point.get("uuid") == uuid), None)
     if idx is None:
-        raise ValueError(f"Location with uuid {uuid} not found")
+        raise LocationNotFoundError(uuid)
 
     del map_data[idx]
     json_file["map"]["data"] = map_data
@@ -887,14 +875,14 @@ def json_db_delete_location(self, uuid):
         (i for i, point in enumerate(self.data.get("data", [])) if point.get("uuid") == uuid), None
     )
     if idx is None:
-        raise ValueError(f"Location with uuid {uuid} not found")
+        raise LocationNotFoundError(uuid)
     del self.data["data"][idx]
 
 
 def mongodb_db_delete_location(self, uuid):
     result = self.db.locations.delete_one({"uuid": uuid})
     if result.deleted_count == 0:
-        raise ValueError(f"Location with uuid {uuid} not found")
+        raise LocationNotFoundError(uuid)
 
 
 def delete_location(db, uuid):
@@ -1359,7 +1347,7 @@ def json_db_update_report(self, report_id, status=None, priority=None):
             if priority:
                 r["priority"] = priority
             return
-    raise ValueError(f"Report with uuid {report_id} not found")
+    raise ReportNotFoundError(report_id)
 
 
 def json_file_db_update_report(self, report_id, status=None, priority=None):
@@ -1375,7 +1363,7 @@ def json_file_db_update_report(self, report_id, status=None, priority=None):
                 r["priority"] = priority
             break
     else:
-        raise ValueError(f"Report with uuid {report_id} not found")
+        raise ReportNotFoundError(report_id)
 
     json_file["map"]["reports"] = reports
 
@@ -1392,7 +1380,7 @@ def mongodb_db_update_report(self, report_id, status=None, priority=None):
     if update_doc:
         result = self.db.reports.update_one({"uuid": report_id}, {"$set": update_doc})
         if result.matched_count == 0:
-            raise ValueError(f"Report with uuid {report_id} not found")
+            raise ReportNotFoundError(report_id)
 
 
 def google_json_db_update_report(self, report_id, status=None, priority=None):
@@ -1412,7 +1400,7 @@ def json_db_delete_report(self, report_id):
     reports = self.data.get("reports", [])
     idx = next((i for i, r in enumerate(reports) if r.get("uuid") == report_id), None)
     if idx is None:
-        raise ValueError(f"Report with uuid {report_id} not found")
+        raise ReportNotFoundError(report_id)
     del reports[idx]
 
 
@@ -1423,7 +1411,7 @@ def json_file_db_delete_report(self, report_id):
     reports = json_file["map"].get("reports", [])
     idx = next((i for i, r in enumerate(reports) if r.get("uuid") == report_id), None)
     if idx is None:
-        raise ValueError(f"Report with uuid {report_id} not found")
+        raise ReportNotFoundError(report_id)
 
     del reports[idx]
     json_file["map"]["reports"] = reports
@@ -1434,7 +1422,7 @@ def json_file_db_delete_report(self, report_id):
 def mongodb_db_delete_report(self, report_id):
     result = self.db.reports.delete_one({"uuid": report_id})
     if result.deleted_count == 0:
-        raise ValueError(f"Report with uuid {report_id} not found")
+        raise ReportNotFoundError(report_id)
 
 
 def google_json_db_delete_report(self, report_id):

goodmap-1.1.8/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-1.1.6 → goodmap-1.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "goodmap"
-version = "1.1.6"
+version = "1.1.8"
 description = "Map engine to serve all the people :)"
 authors = ["Krzysztof Kolodzinski <krzysztof.kolodzinski@problematy.pl>"]
 readme = "README.md"