goodmap 0.4.4__py3-none-any.whl → 0.5.1__py3-none-any.whl

goodmap/core_api.py

@@ -1,13 +1,11 @@
 import importlib.metadata
 import uuid
 
-import deprecation
 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 goodmap.core import get_queried_data
 from goodmap.formatter import prepare_pin
 
 
@@ -15,6 +13,74 @@ def make_tuple_translation(keys_to_translate):
     return [(x, gettext(x)) for x in keys_to_translate]
 
 
+def paginate_results(items, raw_params, sort_by_default=None):
+    """
+    Apply pagination and sorting to a list of items.
+
+    Args:
+        items: The list of items to paginate
+        raw_params: The query parameters dictionary
+
+    Returns:
+        Tuple of (paginated_items, pagination_metadata)
+    """
+    # Extract pagination parameters
+    try:
+        page = int(raw_params.pop("page", ["1"])[0])
+    except ValueError:
+        page = 1
+
+    per_page_raw = raw_params.pop("per_page", [None])[0]
+    if per_page_raw is None:
+        per_page = 20
+    elif per_page_raw == "all":
+        per_page = None
+    else:
+        try:
+            per_page = max(1, int(per_page_raw))
+        except ValueError:
+            per_page = 20
+
+    sort_by = raw_params.pop("sort_by", [None])[0] or sort_by_default
+    sort_order = raw_params.pop("sort_order", ["asc"])[0].lower()
+
+    def get_sort_key(item):
+        if not sort_by:
+            return None
+
+        value = None
+        if isinstance(item, dict):
+            value = item.get(sort_by)
+        else:
+            value = getattr(item, sort_by, None)
+
+        return (value is not None, value)
+
+    if sort_by:
+        reverse = sort_order == "desc"
+        items.sort(key=get_sort_key, reverse=reverse)
+
+    # Apply pagination
+    total = len(items)
+    if per_page:
+        start = (page - 1) * per_page
+        end = start + per_page
+        page_items = items[start:end]
+        total_pages = (total + per_page - 1) // per_page
+    else:
+        page_items = items
+        total_pages = 1
+        page = 1
+        per_page = total
+
+    return page_items, {
+        "total": total,
+        "page": page,
+        "per_page": per_page,
+        "total_pages": total_pages,
+    }
+
+
 def core_pages(
     database, languages: LanguagesMapping, notifier_function, csrf_generator, location_model
 ) -> Blueprint:
@@ -48,6 +114,7 @@ def core_pages(
                 suggested_location = request.get_json()
                 suggested_location.update({"uuid": str(uuid.uuid4())})
                 location = location_model.model_validate(suggested_location)
+                database.add_suggestion(location.model_dump())
                 message = (
                     f"A new location has been suggested under uuid: '{location.uuid}' "
                     f"at position: {location.position}"
@@ -66,39 +133,27 @@ def core_pages(
             """Report location"""
             try:
                 location_report = request.get_json()
+                report = {
+                    "uuid": str(uuid.uuid4()),
+                    "location_id": location_report["id"],
+                    "description": location_report["description"],
+                    "status": "pending",
+                    "priority": "medium",
+                }
+                database.add_report(report)
                 message = (
                     f"A location has been reported: '{location_report['id']}' "
                     f"with problem: {location_report['description']}"
                 )
                 notifier_function(message)
+            except KeyError as e:
+                error_message = gettext("Error reporting location")
+                return make_response(jsonify({"message": f"{error_message} : {e}"}), 400)
             except Exception as e:
                 error_message = gettext("Error sending notification")
                 return make_response(jsonify({"message": f"{error_message} : {e}"}), 400)
             return make_response(jsonify({"message": gettext("Location reported")}), 200)
 
-    @core_api.route("/data")
-    class Data(Resource):
-        @deprecation.deprecated(
-            deprecated_in="0.4.1",
-            removed_in="0.5.0",
-            current_version=importlib.metadata.version("goodmap"),
-            details="Use /locations or /location/<point_id> instead",
-        )
-        def get(self):
-            """
-            Shows all data filtered by query parameters
-            e.g. /api/data?category=category1&category=category2
-            """
-            all_data = database.get_data()
-            query_params = request.args.to_dict(flat=False)
-            data = all_data["data"]
-            categories = all_data["categories"]
-            visible_data = all_data["visible_data"]
-            meta_data = all_data["meta_data"]
-            queried_data = get_queried_data(data, categories, query_params)
-            formatted_data = [prepare_pin(x, visible_data, meta_data) for x in queried_data]
-            return jsonify(formatted_data)
-
     @core_api.route("/locations")
     class GetLocations(Resource):
         def get(self):
@@ -162,4 +217,136 @@ def core_pages(
             csrf_token = csrf_generator()
             return {"csrf_token": csrf_token}
 
+    @core_api.route("/admin/locations")
+    class AdminManageLocations(Resource):
+        def get(self):
+            """
+            Shows full list of locations, with optional server-side pagination, sorting,
+            and filtering.
+            """
+            # Raw query params from request
+            raw_params = request.args.to_dict(flat=False)
+            all_locations = database.get_locations(raw_params)
+            page_items, pagination = paginate_results(
+                all_locations, raw_params, sort_by_default="name"
+            )
+            items = [x.model_dump() for x in page_items]
+            return jsonify({"items": items, **pagination})
+
+        def post(self):
+            """
+            Creates a new location
+            """
+            location_data = request.get_json()
+            try:
+                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)
+            return jsonify(location.model_dump())
+
+    @core_api.route("/admin/locations/<location_id>")
+    class AdminManageLocation(Resource):
+        def put(self, location_id):
+            """
+            Updates a single location
+            """
+            location_data = request.get_json()
+            try:
+                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)
+            return jsonify(location.model_dump())
+
+        def delete(self, location_id):
+            """
+            Deletes a single location
+            """
+            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)
+            return "", 204
+
+    @core_api.route("/admin/suggestions")
+    class AdminManageSuggestions(Resource):
+        def get(self):
+            """
+            List location suggestions, with optional server-side pagination, sorting,
+            and filtering by status.
+            """
+            raw_params = request.args.to_dict(flat=False)
+            suggestions = database.get_suggestions(raw_params)
+            page_items, pagination = paginate_results(suggestions, raw_params)
+            return jsonify({"items": page_items, **pagination})
+
+    @core_api.route("/admin/suggestions/<suggestion_id>")
+    class AdminManageSuggestion(Resource):
+        def put(self, suggestion_id):
+            """
+            Accept or reject a location suggestion
+            """
+            try:
+                data = request.get_json()
+                status = data.get("status")
+                if status not in ("accepted", "rejected"):
+                    return make_response(jsonify({"message": f"Invalid status: {status}"}), 400)
+                suggestion = database.get_suggestion(suggestion_id)
+                if not suggestion:
+                    return make_response(jsonify({"message": "Suggestion not found"}), 404)
+                if suggestion.get("status") != "pending":
+                    return make_response(jsonify({"message": "Suggestion already processed"}), 400)
+                if status == "accepted":
+                    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)
+            return jsonify(database.get_suggestion(suggestion_id))
+
+    @core_api.route("/admin/reports")
+    class AdminManageReports(Resource):
+        def get(self):
+            """
+            List location reports, with optional server-side pagination, sorting,
+            and filtering by status/priority.
+            """
+            raw_params = request.args.to_dict(flat=False)
+            reports = database.get_reports(raw_params)
+            page_items, pagination = paginate_results(reports, raw_params)
+            return jsonify({"items": page_items, **pagination})
+
+    @core_api.route("/admin/reports/<report_id>")
+    class AdminManageReport(Resource):
+        def put(self, report_id):
+            """
+            Update a report's status and/or priority
+            """
+            try:
+                data = request.get_json()
+                status = data.get("status")
+                priority = data.get("priority")
+                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)
+                if priority and priority not in valid_priority:
+                    return make_response(jsonify({"message": f"Invalid priority: {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)
+            return jsonify(database.get_report(report_id))
+
     return core_api_blueprint

goodmap/data_models/location.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel, Field, create_model, field_validator
 class LocationBase(BaseModel, extra="allow"):
     position: tuple[float, float]
     uuid: str
+    remark: bool = False
 
     @field_validator("position")
     @classmethod
@@ -17,7 +18,7 @@ class LocationBase(BaseModel, extra="allow"):
         return v
 
     def basic_info(self):
-        return {"uuid": self.uuid, "position": self.position}
+        return {"uuid": self.uuid, "position": self.position, "remark": bool(self.remark)}
 
 
 def create_location_model(obligatory_fields: list[tuple[str, Type[Any]]]) -> Type[BaseModel]:

goodmap/data_validator.py

@@ -50,7 +50,7 @@ def get_invalid_value_in_category_violations(p, categories):
     for category in categories & p.keys():
         category_value_in_point = p[category]
         valid_values_set = categories[category]
-        if type(category_value_in_point) is list:
+        if isinstance(category_value_in_point, list):
             for attribute_value in category_value_in_point:
                 if attribute_value not in valid_values_set:
                     violations.append(