goodmap 0.5.3__py3-none-any.whl → 1.0.2__py3-none-any.whl

goodmap/core_api.py

@@ -22,74 +22,6 @@ def get_or_none(data, *keys):
     return data
 
 
-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,
@@ -207,13 +139,14 @@ def core_pages(
     class Categories(Resource):
         def get(self):
             """Shows all available categories"""
-            all_data = database.get_data()
-            categories = make_tuple_translation(all_data["categories"].keys())
+            raw_categories = database.get_categories()
+            categories = make_tuple_translation(raw_categories)
 
             if not feature_flags.get("CATEGORIES_HELP", False):
                 return jsonify(categories)
             else:
-                categories_help = all_data["categories_help"]
+                category_data = database.get_category_data()
+                categories_help = category_data["categories_help"]
                 proper_categories_help = []
                 if categories_help is not None:
                     for option in categories_help:
@@ -233,11 +166,11 @@ def core_pages(
     class CategoryTypes(Resource):
         def get(self, category_type):
             """Shows all available types in category"""
-            all_data = database.get_data()
-            local_data = make_tuple_translation(all_data["categories"][category_type])
+            category_data = database.get_category_data(category_type)
+            local_data = make_tuple_translation(category_data["categories"][category_type])
 
             categories_options_help = get_or_none(
-                all_data, "categories_options_help", category_type
+                category_data, "categories_options_help", category_type
             )
             proper_categories_options_help = []
             if categories_options_help is not None:
@@ -268,14 +201,11 @@ def core_pages(
             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})
+            query_params = request.args.to_dict(flat=False)
+            if "sort_by" not in query_params:
+                query_params["sort_by"] = ["name"]
+            result = database.get_locations_paginated(query_params)
+            return jsonify(result)
 
         def post(self):
             """
@@ -328,10 +258,9 @@ def core_pages(
             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})
+            query_params = request.args.to_dict(flat=False)
+            result = database.get_suggestions_paginated(query_params)
+            return jsonify(result)
 
     @core_api.route("/admin/suggestions/<suggestion_id>")
     class AdminManageSuggestion(Resource):
@@ -364,10 +293,9 @@ def core_pages(
             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})
+            query_params = request.args.to_dict(flat=False)
+            result = database.get_reports_paginated(query_params)
+            return jsonify(result)
 
     @core_api.route("/admin/reports/<report_id>")
     class AdminManageReport(Resource):

goodmap/db.py

@@ -4,11 +4,53 @@ import tempfile
 from functools import partial
 
 from goodmap.core import get_queried_data
+from goodmap.data_models.location import LocationBase
 
 # TODO file is temporary solution to be compatible with old, static code,
 #  it should be replaced with dynamic solution
 
 
+def __parse_pagination_params(query):
+    """Extract and validate pagination parameters from query."""
+    try:
+        page = max(1, int(query.get("page", ["1"])[0]))
+    except (ValueError, IndexError, TypeError):
+        page = 1
+
+    per_page_raw = query.get("per_page", ["20"])[0] if query.get("per_page") else "20"
+    if per_page_raw == "all":
+        per_page = None
+    else:
+        try:
+            per_page = max(1, min(int(per_page_raw), 1000))  # Cap at 1000
+        except (ValueError, TypeError):
+            per_page = 20
+
+    sort_by = query.get("sort_by", [None])[0]
+    sort_order = query.get("sort_order", ["asc"])[0] if query.get("sort_order") else "asc"
+
+    return page, per_page, sort_by, sort_order.lower()
+
+
+def __build_pagination_response(items, total, page, per_page):
+    """Build standardized pagination response."""
+    if per_page:
+        total_pages = (total + per_page - 1) // per_page
+    else:
+        total_pages = 1
+        per_page = total
+
+    return {
+        "items": items,
+        "pagination": {
+            "total": total,
+            "page": page,
+            "per_page": per_page,
+            "total_pages": total_pages,
+        },
+    }
+
+
 def json_file_atomic_dump(data, file_path):
     dir_name = os.path.dirname(file_path)
     with tempfile.NamedTemporaryFile("w", dir=dir_name, delete=False) as temp_file:
@@ -18,6 +60,264 @@ def json_file_atomic_dump(data, file_path):
     os.replace(temp_file.name, file_path)
 
 
+class PaginationHelper:
+    """Common pagination utility to eliminate duplication across backends."""
+
+    @staticmethod
+    def get_sort_key(item, sort_by):
+        """Extract sort key from item for both dict and object types."""
+        if sort_by == "name" and hasattr(item, "name"):
+            value = item.name
+        elif isinstance(item, dict):
+            value = item.get(sort_by)
+        else:
+            value = getattr(item, sort_by, None)
+        return (value is not None, value or "")
+
+    @staticmethod
+    def apply_pagination_and_sorting(items, page, per_page, sort_by, sort_order):
+        """Apply sorting and pagination to a list of items."""
+        # Apply sorting
+        if sort_by:
+            reverse = sort_order == "desc"
+            items.sort(
+                key=lambda item: PaginationHelper.get_sort_key(item, sort_by), reverse=reverse  # type: ignore
+            )
+
+        total_count = len(items)
+
+        # Apply pagination
+        if per_page:
+            start_idx = (page - 1) * per_page
+            end_idx = start_idx + per_page
+            paginated_items = items[start_idx:end_idx]
+        else:
+            paginated_items = items
+
+        return paginated_items, total_count
+
+    @staticmethod
+    def apply_filters(items, filters):
+        """Apply filtering based on provided filters dictionary."""
+        filtered_items = items
+
+        # Apply status filtering
+        if "status" in filters:
+            statuses = filters["status"]
+            if statuses:
+                filtered_items = [
+                    item
+                    for item in filtered_items
+                    if (
+                        item.get("status")
+                        if isinstance(item, dict)
+                        else getattr(item, "status", None)
+                    )
+                    in statuses
+                ]
+
+        # Apply priority filtering
+        if "priority" in filters:
+            priorities = filters["priority"]
+            if priorities:
+                filtered_items = [
+                    item
+                    for item in filtered_items
+                    if (
+                        item.get("priority")
+                        if isinstance(item, dict)
+                        else getattr(item, "priority", None)
+                    )
+                    in priorities
+                ]
+
+        return filtered_items
+
+    @staticmethod
+    def serialize_items(items):
+        """Convert items to dict if needed (for location models)."""
+        if items and hasattr(items[0], "model_dump"):
+            return [x.model_dump() for x in items]
+        else:
+            return items
+
+    @staticmethod
+    def create_paginated_response(items, query, extract_filters_func=None):
+        """Create a complete paginated response with all common logic."""
+        # Parse pagination parameters using the existing function
+        try:
+            page = max(1, int(query.get("page", ["1"])[0]))
+        except (ValueError, IndexError, TypeError):
+            page = 1
+
+        per_page_raw = query.get("per_page", ["20"])[0] if query.get("per_page") else "20"
+        if per_page_raw == "all":
+            per_page = None
+        else:
+            try:
+                per_page = max(1, min(int(per_page_raw), 1000))  # Cap at 1000
+            except (ValueError, TypeError):
+                per_page = 20
+
+        sort_by = query.get("sort_by", [None])[0]
+        sort_order = query.get("sort_order", ["asc"])[0] if query.get("sort_order") else "asc"
+        sort_order = sort_order.lower()
+
+        # Apply filters if any
+        filters = {}
+        if query:
+            if "status" in query:
+                filters["status"] = query["status"]
+            if "priority" in query:
+                filters["priority"] = query["priority"]
+
+        # Allow custom filter extraction
+        if extract_filters_func:
+            custom_filters = extract_filters_func(query)
+            filters.update(custom_filters)
+
+        if filters:
+            items = PaginationHelper.apply_filters(items, filters)
+
+        # Apply pagination and sorting
+        paginated_items, total_count = PaginationHelper.apply_pagination_and_sorting(
+            items, page, per_page, sort_by, sort_order
+        )
+
+        # Serialize items if needed
+        serialized_items = PaginationHelper.serialize_items(paginated_items)
+
+        # Build pagination response directly
+        if per_page:
+            total_pages = (total_count + per_page - 1) // per_page
+        else:
+            total_pages = 1
+            per_page = total_count
+
+        return {
+            "items": serialized_items,
+            "pagination": {
+                "total": total_count,
+                "page": page,
+                "per_page": per_page,
+                "total_pages": total_pages,
+            },
+        }
+
+
+class FileIOHelper:
+    """Common file I/O utilities to eliminate duplication."""
+
+    @staticmethod
+    def read_json_file(file_path):
+        """Read and parse JSON file."""
+        with open(file_path, "r") as file:
+            return json.load(file)
+
+    @staticmethod
+    def write_json_file_atomic(data, file_path):
+        """Write JSON data to file atomically."""
+        json_file_atomic_dump(data, file_path)
+
+    @staticmethod
+    def get_data_from_file(file_path, data_key="map"):
+        """Get data from JSON file with specified key structure."""
+        json_data = FileIOHelper.read_json_file(file_path)
+        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")
+
+    @staticmethod
+    def raise_not_found_error(item_type, uuid):
+        """Raise standardized 'not found' error."""
+        raise ValueError(f"{item_type} with uuid {uuid} not found")
+
+    @staticmethod
+    def check_item_exists(items, uuid, item_type):
+        """Check if item with UUID exists and raise error if it does."""
+        existing = next(
+            (
+                item
+                for item in items
+                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()
+        )
+
+        record = dict(item_data)
+        if default_status:
+            record["status"] = default_status
+        collection.append(record)
+
+    @staticmethod
+    def add_item_to_json_file_db(file_path, collection_name, item_data, default_status=None):
+        """Add item to JSON file database."""
+        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()
+        )
+
+        record = dict(item_data)
+        if default_status:
+            record["status"] = default_status
+        collection.append(record)
+        json_file["map"][collection_name] = collection
+
+        FileIOHelper.write_json_file_atomic(json_file, file_path)
+
+    @staticmethod
+    def add_item_to_mongodb(db_collection, item_data, item_type, default_status=None):
+        """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"))
+
+        record = dict(item_data)
+        if default_status:
+            record["status"] = default_status
+        db_collection.insert_one(record)
+
+
 # ------------------------------------------------
 # get_location_obligatory_fields
 
@@ -35,6 +335,13 @@ def google_json_db_get_location_obligatory_fields(db):
     return json.loads(db.blob.download_as_text(client=None))["map"]["location_obligatory_fields"]
 
 
+def mongodb_db_get_location_obligatory_fields(db):
+    config_doc = db.db.config.find_one({"_id": "map_config"})
+    if config_doc and "location_obligatory_fields" in config_doc:
+        return config_doc["location_obligatory_fields"]
+    return []
+
+
 def get_location_obligatory_fields(db):
     return globals()[f"{db.module_name}_get_location_obligatory_fields"](db)
 
@@ -56,10 +363,140 @@ def json_db_get_data(self):
     return self.data
 
 
+def mongodb_db_get_data(self):
+    config_doc = self.db.config.find_one({"_id": "map_config"})
+    if config_doc:
+        return {
+            "data": list(self.db.locations.find({}, {"_id": 0})),
+            "categories": config_doc.get("categories", {}),
+            "location_obligatory_fields": config_doc.get("location_obligatory_fields", []),
+            # Backward-compat keys expected by core_api today
+            "visible_data": config_doc.get("visible_data", {}),
+            "meta_data": config_doc.get("meta_data", {}),
+        }
+    return {
+        "data": [],
+        "categories": {},
+        "location_obligatory_fields": [],
+        "visible_data": {},
+        "meta_data": {},
+    }
+
+
 def get_data(db):
     return globals()[f"{db.module_name}_get_data"]
 
 
+# ------------------------------------------------
+# get_categories
+
+
+def json_db_get_categories(self):
+    return self.data["categories"].keys()
+
+
+def json_file_db_get_categories(self):
+    with open(self.data_file_path, "r") as file:
+        return json.load(file)["map"]["categories"].keys()
+
+
+def google_json_db_get_categories(self):
+    return json.loads(self.blob.download_as_text(client=None))["map"]["categories"].keys()
+
+
+def mongodb_db_get_categories(self):
+    config_doc = self.db.config.find_one({"_id": "map_config"})
+    if config_doc and "categories" in config_doc:
+        return list(config_doc["categories"].keys())
+    return []
+
+
+def get_categories(db):
+    return globals()[f"{db.module_name}_get_categories"]
+
+
+# ------------------------------------------------
+# get_category_data
+
+
+def json_db_get_category_data(self, category_type=None):
+    if category_type:
+        return {
+            "categories": {category_type: self.data["categories"].get(category_type, [])},
+            "categories_help": self.data.get("categories_help", []),
+            "categories_options_help": {
+                category_type: self.data.get("categories_options_help", {}).get(category_type, [])
+            },
+        }
+    return {
+        "categories": self.data["categories"],
+        "categories_help": self.data.get("categories_help", []),
+        "categories_options_help": self.data.get("categories_options_help", {}),
+    }
+
+
+def json_file_db_get_category_data(self, category_type=None):
+    with open(self.data_file_path, "r") as file:
+        data = json.load(file)["map"]
+        if category_type:
+            return {
+                "categories": {category_type: data["categories"].get(category_type, [])},
+                "categories_help": data.get("categories_help", []),
+                "categories_options_help": {
+                    category_type: data.get("categories_options_help", {}).get(category_type, [])
+                },
+            }
+        return {
+            "categories": data["categories"],
+            "categories_help": data.get("categories_help", []),
+            "categories_options_help": data.get("categories_options_help", {}),
+        }
+
+
+def google_json_db_get_category_data(self, category_type=None):
+    data = json.loads(self.blob.download_as_text(client=None))["map"]
+    if category_type:
+        return {
+            "categories": {category_type: data["categories"].get(category_type, [])},
+            "categories_help": data.get("categories_help", []),
+            "categories_options_help": {
+                category_type: data.get("categories_options_help", {}).get(category_type, [])
+            },
+        }
+    return {
+        "categories": data["categories"],
+        "categories_help": data.get("categories_help", []),
+        "categories_options_help": data.get("categories_options_help", {}),
+    }
+
+
+def mongodb_db_get_category_data(self, category_type=None):
+    config_doc = self.db.config.find_one({"_id": "map_config"})
+    if config_doc:
+        if category_type:
+            return {
+                "categories": {
+                    category_type: config_doc.get("categories", {}).get(category_type, [])
+                },
+                "categories_help": config_doc.get("categories_help", []),
+                "categories_options_help": {
+                    category_type: config_doc.get("categories_options_help", {}).get(
+                        category_type, []
+                    )
+                },
+            }
+        return {
+            "categories": config_doc.get("categories", {}),
+            "categories_help": config_doc.get("categories_help", []),
+            "categories_options_help": config_doc.get("categories_options_help", {}),
+        }
+    return {"categories": {}, "categories_help": [], "categories_options_help": {}}
+
+
+def get_category_data(db):
+    return globals()[f"{db.module_name}_get_category_data"]
+
+
 # ------------------------------------------------
 # get_location
 
@@ -85,6 +522,11 @@ def json_db_get_location(self, uuid, location_model):
     return get_location_from_raw_data(self.data, uuid, location_model)
 
 
+def mongodb_db_get_location(self, uuid, location_model):
+    location_doc = self.db.locations.find_one({"uuid": uuid}, {"_id": 0})
+    return location_model.model_validate(location_doc) if location_doc else None
+
+
 def get_location(db, location_model):
     return partial(globals()[f"{db.module_name}_get_location"], location_model=location_model)
 
@@ -113,10 +555,91 @@ def json_db_get_locations(self, query, location_model):
     return get_locations_list_from_raw_data(self.data, query, location_model)
 
 
+def mongodb_db_get_locations(self, query, location_model):
+    mongo_query = {}
+    for key, values in query.items():
+        if values:
+            mongo_query[key] = {"$in": values}
+
+    projection = {"_id": 0, "uuid": 1, "position": 1, "remark": 1}
+    data = self.db.locations.find(mongo_query, projection)
+    return (LocationBase.model_validate(loc) for loc in data)
+
+
 def get_locations(db, location_model):
     return partial(globals()[f"{db.module_name}_get_locations"], location_model=location_model)
 
 
+def google_json_db_get_locations_paginated(self, query, location_model):
+    """Google JSON locations with improved pagination."""
+    # Get all locations from raw data
+    data = json.loads(self.blob.download_as_text(client=None))["map"]
+    all_locations = list(get_locations_list_from_raw_data(data, query, location_model))
+    return PaginationHelper.create_paginated_response(all_locations, query)
+
+
+def json_db_get_locations_paginated(self, query, location_model):
+    """JSON locations with improved pagination."""
+    # Get all locations from raw data
+    all_locations = list(get_locations_list_from_raw_data(self.data, query, location_model))
+    return PaginationHelper.create_paginated_response(all_locations, query)
+
+
+def json_file_db_get_locations_paginated(self, query, location_model):
+    """JSON file locations with improved pagination."""
+    data = FileIOHelper.get_data_from_file(self.data_file_path)
+    # Get all locations from raw data
+    all_locations = list(get_locations_list_from_raw_data(data, query, location_model))
+    return PaginationHelper.create_paginated_response(all_locations, query)
+
+
+def mongodb_db_get_locations_paginated(self, query, location_model):
+    """MongoDB locations with improved pagination."""
+    page, per_page, sort_by, sort_order = __parse_pagination_params(query)
+
+    # Build MongoDB query
+    mongo_query = {}
+    for key, values in query.items():
+        if values:
+            mongo_query[key] = {"$in": values}
+
+    # Get total count
+    total_count = self.db.locations.count_documents(mongo_query)
+
+    # Build aggregation pipeline
+    pipeline = [{"$match": mongo_query}]
+
+    # Add sorting
+    if sort_by:
+        sort_direction = -1 if sort_order == "desc" else 1
+        pipeline.append({"$sort": {sort_by: sort_direction}})
+
+    # Add pagination
+    if per_page:
+        pipeline.extend([{"$skip": (page - 1) * per_page}, {"$limit": per_page}])  # type: ignore
+
+    # Remove MongoDB _id field
+    pipeline.append({"$project": {"_id": 0}})
+
+    # Execute query
+    cursor = self.db.locations.aggregate(pipeline)
+    locations = [location_model.model_validate(loc) for loc in cursor]
+
+    # Convert items to dict if needed (for location models)
+    if locations and hasattr(locations[0], "model_dump"):
+        serialized_locations = [x.model_dump() for x in locations]
+    else:
+        serialized_locations = locations
+
+    return __build_pagination_response(serialized_locations, total_count, page, per_page)
+
+
+def get_locations_paginated(db, location_model):
+    return partial(
+        globals()[f"{db.module_name}_get_locations_paginated"], location_model=location_model
+    )
+
+
 # ------------------------------------------------
 # add_location
 
@@ -154,6 +677,14 @@ def json_db_add_location(self, location_data, location_model):
     self.data["data"].append(location.model_dump())
 
 
+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")
+    self.db.locations.insert_one(location.model_dump())
+
+
 def add_location(db, location_data, location_model):
     return globals()[f"{db.module_name}_add_location"](db, location_data, location_model)
 
@@ -188,6 +719,13 @@ def json_db_update_location(self, uuid, location_data, location_model):
     self.data["data"][idx] = location.model_dump()
 
 
+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")
+
+
 def update_location(db, uuid, location_data, location_model):
     return globals()[f"{db.module_name}_update_location"](db, uuid, location_data, location_model)
 
@@ -220,6 +758,12 @@ def json_db_delete_location(self, 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")
+
+
 def delete_location(db, uuid):
     return globals()[f"{db.module_name}_delete_location"](db, uuid)
 
@@ -229,29 +773,17 @@ def delete_location(db, uuid):
 
 
 def json_db_add_suggestion(self, suggestion_data):
-    suggestions = self.data.setdefault("suggestions", [])
-    if any(s.get("uuid") == suggestion_data.get("uuid") for s in suggestions):
-        raise ValueError(f"Suggestion with uuid {suggestion_data['uuid']} already exists")
-
-    record = dict(suggestion_data)
-    record["status"] = "pending"
-    suggestions.append(record)
+    CRUDHelper.add_item_to_json_db(self.data, "suggestions", suggestion_data, "pending")
 
 
 def json_file_db_add_suggestion(self, suggestion_data):
-    with open(self.data_file_path, "r") as file:
-        json_file = json.load(file)
-
-    suggestions = json_file["map"].get("suggestions", [])
-    if any(s.get("uuid") == suggestion_data.get("uuid") for s in suggestions):
-        raise ValueError(f"Suggestion with uuid {suggestion_data['uuid']} already exists")
+    CRUDHelper.add_item_to_json_file_db(
+        self.data_file_path, "suggestions", suggestion_data, "pending"
+    )
 
-    record = dict(suggestion_data)
-    record["status"] = "pending"
-    suggestions.append(record)
-    json_file["map"]["suggestions"] = suggestions
 
-    json_file_atomic_dump(json_file, self.data_file_path)
+def mongodb_db_add_suggestion(self, suggestion_data):
+    CRUDHelper.add_item_to_mongodb(self.db.suggestions, suggestion_data, "Suggestion", "pending")
 
 
 def add_suggestion(db, suggestion_data):
@@ -272,6 +804,12 @@ def json_db_get_suggestions(self, query_params):
     return suggestions
 
 
+def json_db_get_suggestions_paginated(self, query):
+    """JSON suggestions with improved pagination."""
+    suggestions = self.data.get("suggestions", [])
+    return PaginationHelper.create_paginated_response(suggestions, query)
+
+
 def json_file_db_get_suggestions(self, query_params):
     with open(self.data_file_path, "r") as file:
         json_file = json.load(file)
@@ -285,10 +823,67 @@ def json_file_db_get_suggestions(self, query_params):
     return suggestions
 
 
+def json_file_db_get_suggestions_paginated(self, query):
+    """JSON file suggestions with improved pagination."""
+    with open(self.data_file_path, "r") as file:
+        json_file = json.load(file)
+
+    suggestions = json_file["map"].get("suggestions", [])
+    return PaginationHelper.create_paginated_response(suggestions, query)
+
+
+def mongodb_db_get_suggestions(self, query_params):
+    query = {}
+    statuses = query_params.get("status")
+    if statuses:
+        query["status"] = {"$in": statuses}
+
+    return list(self.db.suggestions.find(query, {"_id": 0}))
+
+
+def mongodb_db_get_suggestions_paginated(self, query):
+    """MongoDB suggestions with improved pagination."""
+    page, per_page, sort_by, sort_order = __parse_pagination_params(query)
+
+    # Build MongoDB query
+    mongo_query = {}
+    statuses = query.get("status")
+    if statuses:
+        mongo_query["status"] = {"$in": statuses}
+
+    # Get total count
+    total_count = self.db.suggestions.count_documents(mongo_query)
+
+    # Build aggregation pipeline
+    pipeline = [{"$match": mongo_query}]
+
+    # Add sorting
+    if sort_by:
+        sort_direction = -1 if sort_order == "desc" else 1
+        pipeline.append({"$sort": {sort_by: sort_direction}})
+
+    # Add pagination
+    if per_page:
+        pipeline.extend([{"$skip": (page - 1) * per_page}, {"$limit": per_page}])  # type: ignore
+
+    # Remove MongoDB _id field
+    pipeline.append({"$project": {"_id": 0}})
+
+    # Execute query
+    cursor = self.db.suggestions.aggregate(pipeline)
+    items = list(cursor)
+
+    return __build_pagination_response(items, total_count, page, per_page)
+
+
 def get_suggestions(db):
     return globals()[f"{db.module_name}_get_suggestions"]
 
 
+def get_suggestions_paginated(db):
+    return globals()[f"{db.module_name}_get_suggestions_paginated"]
+
+
 # ------------------------------------------------
 # get_suggestion
 
@@ -307,6 +902,10 @@ def json_file_db_get_suggestion(self, suggestion_id):
     )
 
 
+def mongodb_db_get_suggestion(self, suggestion_id):
+    return self.db.suggestions.find_one({"uuid": suggestion_id}, {"_id": 0})
+
+
 def get_suggestion(db):
     return globals()[f"{db.module_name}_get_suggestion"]
 
@@ -341,6 +940,12 @@ def json_file_db_update_suggestion(self, suggestion_id, status):
     json_file_atomic_dump(json_file, self.data_file_path)
 
 
+def mongodb_db_update_suggestion(self, suggestion_id, status):
+    result = self.db.suggestions.update_one({"uuid": suggestion_id}, {"$set": {"status": status}})
+    if result.matched_count == 0:
+        raise ValueError(f"Suggestion with uuid {suggestion_id} not found")
+
+
 def update_suggestion(db, suggestion_id, status):
     return globals()[f"{db.module_name}_update_suggestion"](db, suggestion_id, status)
 
@@ -373,6 +978,12 @@ def json_file_db_delete_suggestion(self, suggestion_id):
     json_file_atomic_dump(json_file, self.data_file_path)
 
 
+def mongodb_db_delete_suggestion(self, suggestion_id):
+    result = self.db.suggestions.delete_one({"uuid": suggestion_id})
+    if result.deleted_count == 0:
+        raise ValueError(f"Suggestion with uuid {suggestion_id} not found")
+
+
 def delete_suggestion(db, suggestion_id):
     return globals()[f"{db.module_name}_delete_suggestion"](db, suggestion_id)
 
@@ -403,6 +1014,14 @@ def json_file_db_add_report(self, report_data):
     json_file_atomic_dump(json_file, self.data_file_path)
 
 
+def mongodb_db_add_report(self, report_data):
+    existing = self.db.reports.find_one({"uuid": report_data.get("uuid")})
+    if existing:
+        raise ValueError(f"Report with uuid {report_data['uuid']} already exists")
+
+    self.db.reports.insert_one(report_data)
+
+
 def add_report(db, report_data):
     return globals()[f"{db.module_name}_add_report"](db, report_data)
 
@@ -425,6 +1044,12 @@ def json_db_get_reports(self, query_params):
     return reports
 
 
+def json_db_get_reports_paginated(self, query):
+    """JSON reports with improved pagination."""
+    reports = self.data.get("reports", [])
+    return PaginationHelper.create_paginated_response(reports, query)
+
+
 def json_file_db_get_reports(self, query_params):
     with open(self.data_file_path, "r") as file:
         json_file = json.load(file)
@@ -442,10 +1067,75 @@ def json_file_db_get_reports(self, query_params):
     return reports
 
 
+def json_file_db_get_reports_paginated(self, query):
+    """JSON file reports with improved pagination."""
+    data = FileIOHelper.get_data_from_file(self.data_file_path)
+    reports = data.get("reports", [])
+    return PaginationHelper.create_paginated_response(reports, query)
+
+
+def mongodb_db_get_reports(self, query_params):
+    query = {}
+
+    statuses = query_params.get("status")
+    if statuses:
+        query["status"] = {"$in": statuses}
+
+    priorities = query_params.get("priority")
+    if priorities:
+        query["priority"] = {"$in": priorities}
+
+    return list(self.db.reports.find(query, {"_id": 0}))
+
+
+def mongodb_db_get_reports_paginated(self, query):
+    """MongoDB reports with improved pagination."""
+    page, per_page, sort_by, sort_order = __parse_pagination_params(query)
+
+    # Build MongoDB query
+    mongo_query = {}
+
+    statuses = query.get("status")
+    if statuses:
+        mongo_query["status"] = {"$in": statuses}
+
+    priorities = query.get("priority")
+    if priorities:
+        mongo_query["priority"] = {"$in": priorities}
+
+    # Get total count
+    total_count = self.db.reports.count_documents(mongo_query)
+
+    # Build aggregation pipeline
+    pipeline = [{"$match": mongo_query}]
+
+    # Add sorting
+    if sort_by:
+        sort_direction = -1 if sort_order == "desc" else 1
+        pipeline.append({"$sort": {sort_by: sort_direction}})
+
+    # Add pagination
+    if per_page:
+        pipeline.extend([{"$skip": (page - 1) * per_page}, {"$limit": per_page}])  # type: ignore
+
+    # Remove MongoDB _id field
+    pipeline.append({"$project": {"_id": 0}})
+
+    # Execute query
+    cursor = self.db.reports.aggregate(pipeline)
+    items = list(cursor)
+
+    return __build_pagination_response(items, total_count, page, per_page)
+
+
 def get_reports(db):
     return globals()[f"{db.module_name}_get_reports"]
 
 
+def get_reports_paginated(db):
+    return globals()[f"{db.module_name}_get_reports_paginated"]
+
+
 # ------------------------------------------------
 # get_report
 
@@ -463,6 +1153,10 @@ def json_file_db_get_report(self, report_id):
     )
 
 
+def mongodb_db_get_report(self, report_id):
+    return self.db.reports.find_one({"uuid": report_id}, {"_id": 0})
+
+
 def get_report(db):
     return globals()[f"{db.module_name}_get_report"]
 
@@ -503,6 +1197,19 @@ def json_file_db_update_report(self, report_id, status=None, priority=None):
     json_file_atomic_dump(json_file, self.data_file_path)
 
 
+def mongodb_db_update_report(self, report_id, status=None, priority=None):
+    update_doc = {}
+    if status:
+        update_doc["status"] = status
+    if priority:
+        update_doc["priority"] = priority
+
+    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")
+
+
 def update_report(db, report_id, status=None, priority=None):
     return globals()[f"{db.module_name}_update_report"](db, report_id, status, priority)
 
@@ -534,6 +1241,12 @@ def json_file_db_delete_report(self, report_id):
     json_file_atomic_dump(json_file, self.data_file_path)
 
 
+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")
+
+
 def delete_report(db, report_id):
     return globals()[f"{db.module_name}_delete_report"](db, report_id)
 
@@ -546,18 +1259,23 @@ def delete_report(db, report_id):
 def extend_db_with_goodmap_queries(db, location_model):
     db.extend("get_data", get_data(db))
     db.extend("get_locations", get_locations(db, location_model))
+    db.extend("get_locations_paginated", get_locations_paginated(db, location_model))
     db.extend("get_location", get_location(db, location_model))
     db.extend("add_location", partial(add_location, location_model=location_model))
     db.extend("update_location", partial(update_location, location_model=location_model))
     db.extend("delete_location", delete_location)
-    if db.module_name in ("json_db", "json_file_db"):
+    db.extend("get_categories", get_categories(db))
+    db.extend("get_category_data", get_category_data(db))
+    if db.module_name in ("json_db", "json_file_db", "mongodb_db"):
         db.extend("add_suggestion", add_suggestion)
         db.extend("get_suggestions", get_suggestions(db))
+        db.extend("get_suggestions_paginated", get_suggestions_paginated(db))
         db.extend("get_suggestion", get_suggestion(db))
         db.extend("update_suggestion", update_suggestion)
         db.extend("delete_suggestion", delete_suggestion)
         db.extend("add_report", add_report)
         db.extend("get_reports", get_reports(db))
+        db.extend("get_reports_paginated", get_reports_paginated(db))
         db.extend("get_report", get_report(db))
         db.extend("update_report", update_report)
         db.extend("delete_report", delete_report)

{goodmap-0.5.3.dist-info → goodmap-1.0.2.dist-info}/METADATA

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: goodmap
-Version: 0.5.3
+Version: 1.0.2
 Summary: Map engine to serve all the people :)
+License-File: LICENSE.md
 Author: Krzysztof Kolodzinski
 Author-email: krzysztof.kolodzinski@problematy.pl
 Requires-Python: >=3.10,<4.0
@@ -10,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: Babel (>=2.10.3,<3.0.0)
 Requires-Dist: Flask (==3.0.3)
 Requires-Dist: Flask-Babel (>=4.0.0,<5.0.0)
@@ -22,11 +24,11 @@ Requires-Dist: google-cloud-storage (>=2.7.0,<3.0.0)
 Requires-Dist: gql (>=3.4.0,<4.0.0)
 Requires-Dist: gunicorn (>=20.1.0,<21.0.0)
 Requires-Dist: humanize (>=4.6.0,<5.0.0)
-Requires-Dist: platzky (>=0.3.6,<0.4.0)
+Requires-Dist: platzky (>=0.4.0,<0.5.0)
 Requires-Dist: pydantic (>=2.7.1,<3.0.0)
 Description-Content-Type: text/markdown
 
-![Github Actions](https://github.com/problematy/goodmap/actions/workflows/tests.yml/badge.svg?event=push&branch=main)
+![Github Actions](https://github.com/problematy/goodmap/actions/workflows/release.yml/badge.svg?event=push&branch=main)
 [![Coverage Status](https://coveralls.io/repos/github/Problematy/goodmap/badge.png)](https://coveralls.io/github/Problematy/goodmap)
 
 # Good Map

{goodmap-0.5.3.dist-info → goodmap-1.0.2.dist-info}/RECORD

@@ -1,14 +1,14 @@
 goodmap/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 goodmap/core.py,sha256=rzMhOIYnR1jxTX6uHQJKIPLYxdUm4_v2d6LrtHtJpHU,1465
-goodmap/core_api.py,sha256=8Mhs59c_MnORmHK7aFCNM7eBJBhNQ0MWcdYnmiW2GW4,15515
+goodmap/core_api.py,sha256=MxJ7SGOFBBnV_cBIiZoImHLaY8_FtEW-dl3od5-mIt8,13529
 goodmap/data_models/location.py,sha256=H3EKozc-WZvrYm6cwajl8_gaw4rQhxdlvxR1mk4mpkA,1104
 goodmap/data_validator.py,sha256=lBmVAPxvSmEOdUGeVYSjUvVVmKfPyq4CWoHfczTtEMM,4090
-goodmap/db.py,sha256=fB9B0nzNuTsMBak7iV4bGxAxGF5NSTGikht9keDOTGA,17518
+goodmap/db.py,sha256=i-fe_f_s9hQxvTqq4alA-RK9j6vQpnaNpXEDPci3s1Y,42049
 goodmap/formatter.py,sha256=VlUHcK1HtM_IEU0VE3S5TOkZLVheMdakvUeW2tCKdq0,783
 goodmap/goodmap.py,sha256=OOcuDEY7GZsHh8vjIJ9brd4SuGxNRq_lC_DMmNuome8,2731
 goodmap/templates/goodmap-admin.html,sha256=zGuau239BXyBerV21mDXcHy34ke8cLmZcMngcX1xhAs,35598
 goodmap/templates/map.html,sha256=-qbJ313t2EdSyIwULnQy3j81pH4MqI5yjtJ4Xoo7N7M,3979
-goodmap-0.5.3.dist-info/LICENSE.md,sha256=nkCQOR7uheLRvHRfXmwx9LhBnMcPeBU9d4ebLojDiQU,1067
-goodmap-0.5.3.dist-info/METADATA,sha256=d5Wqic-brdjC_wocR63g1YINlERblKpmkZpTOZ-j5pg,5278
-goodmap-0.5.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-goodmap-0.5.3.dist-info/RECORD,,
+goodmap-1.0.2.dist-info/METADATA,sha256=nqqszznBX2xjMT-QiQwWNqUlyqhtjlI4Dsz5yUZtjlg,5356
+goodmap-1.0.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+goodmap-1.0.2.dist-info/licenses/LICENSE.md,sha256=nkCQOR7uheLRvHRfXmwx9LhBnMcPeBU9d4ebLojDiQU,1067
+goodmap-1.0.2.dist-info/RECORD,,

{goodmap-0.5.3.dist-info → goodmap-1.0.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any