SuperMapper Release to production.

.github/workflows/pr_test_backend.yml

@@ -31,7 +31,7 @@ jobs:
 
       - name: Run PEP8 checks
         run: |
-          flake8 manage.py backend tests migrations --ignore=E203,W503
+          flake8 manage.py backend tests migrations --ignore=E203,W503,F401,E501
           black --check manage.py backend tests migrations
 
   pytest:

backend/api/mapping_badges/resources.py

@@ -0,0 +1,121 @@
+from databases import Database
+from fastapi import APIRouter, Depends
+
+from backend.db import get_db
+from backend.models.dtos.mapping_badge_dto import (
+    MappingBadgeDTO,
+    MappingBadgeCreateDTO,
+    MappingBadgeUpdateDTO,
+    MappingBadgeListDTO,
+    MappingBadgePublicListDTO,
+)
+from backend.models.dtos.user_dto import AuthUserDTO
+from backend.services.mapping_badges import MappingBadgeService
+from backend.services.users.authentication_service import pm_only
+
+router = APIRouter(
+    prefix="/badges",
+    tags=["mapping_badges"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+@router.get("/")
+async def get_mapping_badges(
+    db: Database = Depends(get_db),
+) -> MappingBadgeListDTO:
+    """
+    List mapping badges
+    ---
+    tags:
+      - badges
+    produces:
+      - application/json
+    """
+    return await MappingBadgeService.get_all(db)
+
+
+@router.post("/")
+async def create_mapping_badge(
+    data: MappingBadgeCreateDTO,
+    db: Database = Depends(get_db),
+    user: AuthUserDTO = Depends(pm_only),
+) -> MappingBadgeDTO:
+    """
+    Creates a new MappingBadge
+    ---
+    tags:
+      - badges
+    produces:
+      - application/json
+    """
+    return await MappingBadgeService.create(data, db)
+
+
+@router.get("/{badge_id}/")
+async def get_mapping_badge(
+    badge_id: int,
+    db: Database = Depends(get_db),
+) -> MappingBadgeDTO:
+    """
+    Gets information for a single badge
+    ---
+    tags:
+      - badges
+    produces:
+      - application/json
+    """
+    return await MappingBadgeService.get_by_id(badge_id, db)
+
+
+@router.patch("/{badge_id}/")
+async def update_mapping_badge(
+    data: MappingBadgeUpdateDTO,
+    badge_id: int,
+    db: Database = Depends(get_db),
+    user: AuthUserDTO = Depends(pm_only),
+) -> MappingBadgeDTO:
+    """
+    Updates a mapping badge
+    ---
+    tags:
+      - badges
+    produces:
+      - application/json
+    """
+    data.id = badge_id
+
+    return await MappingBadgeService.update(data, db)
+
+
+@router.delete("/{badge_id}/")
+async def delete_mapping_badge(
+    badge_id: int,
+    db: Database = Depends(get_db),
+    user: AuthUserDTO = Depends(pm_only),
+):
+    """
+    Deletes a mapping badge
+    ---
+    tags:
+      - badges
+    produces:
+      - application/json
+    """
+    await MappingBadgeService.delete(badge_id, db)
+
+
+@router.get("/user/{user_id}/")
+async def get_for_user(
+    user_id: int,
+    db: Database = Depends(get_db),
+) -> MappingBadgePublicListDTO:
+    """
+    Get all mapping badges that a user has earned
+    ---
+    tags:
+      - badges
+    produces:
+      - application/json
+    """
+    return await MappingBadgeService.get_for_user(user_id, db)

backend/api/mapping_levels/resources.py

@@ -0,0 +1,102 @@
+from databases import Database
+from fastapi import APIRouter, Depends
+
+from backend.db import get_db
+from backend.models.dtos.mapping_level_dto import (
+    MappingLevelCreateDTO,
+    MappingLevelUpdateDTO,
+)
+from backend.models.dtos.user_dto import AuthUserDTO
+from backend.services.mapping_levels import MappingLevelService
+from backend.services.users.authentication_service import pm_only
+
+router = APIRouter(
+    prefix="/levels",
+    tags=["mapping_levels"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+@router.get("/")
+async def get_mapping_levels(
+    db: Database = Depends(get_db),
+):
+    """
+    List mapping levels
+    ---
+    tags:
+      - levels
+    produces:
+      - application/json
+    """
+    return await MappingLevelService.get_all(db)
+
+
+@router.post("/")
+async def create_mapping_level(
+    data: MappingLevelCreateDTO,
+    db: Database = Depends(get_db),
+    user: AuthUserDTO = Depends(pm_only),
+):
+    """
+    Create a new mapping level
+    ---
+    tags:
+      - levels
+    produces:
+      - application/json
+    """
+    return await MappingLevelService.create(data, db)
+
+
+@router.get("/{level_id}/")
+async def get_mapping_level(
+    level_id: int,
+    db: Database = Depends(get_db),
+):
+    """
+    Get a mapping level by its id
+    ---
+    tags:
+      - levels
+    produces:
+      - application/json
+    """
+    return await MappingLevelService.get_by_id(level_id, db)
+
+
+@router.patch("/{level_id}/")
+async def update_mapping_level(
+    data: MappingLevelUpdateDTO,
+    level_id: int,
+    db: Database = Depends(get_db),
+    user: AuthUserDTO = Depends(pm_only),
+):
+    """
+    Update a given mapping level
+    ---
+    tags:
+      - levels
+    produces:
+      - application/json
+    """
+    data.id = level_id
+
+    return await MappingLevelService.update(data, db)
+
+
+@router.delete("/{level_id}/")
+async def delete_mapping_level(
+    level_id: int,
+    db: Database = Depends(get_db),
+    user: AuthUserDTO = Depends(pm_only),
+):
+    """
+    Delete the specified mapping level
+    ---
+    tags:
+      - levels
+    produces:
+      - application/json
+    """
+    await MappingLevelService.delete(level_id, db)

backend/api/projects/activities.py

@@ -71,7 +71,6 @@ async def get_activities(
             db,
         )
         if not project_dto:
-
             return JSONResponse(
                 content={
                     "Error": "User not permitted: Private Project",
@@ -133,7 +132,6 @@ async def get_latest_activities(
             db,
         )
         if not project_dto:
-
             return JSONResponse(
                 content={
                     "Error": "User not permitted: Private Project",

backend/api/projects/contributions.py

@@ -66,7 +66,6 @@ async def get_project_contributions(
             db,
         )
         if not project_dto:
-
             return JSONResponse(
                 content={
                     "Error": "User not permitted: Private Project",

backend/api/projects/resources.py

@@ -1160,7 +1160,6 @@ async def get_project_summary(
             db,
         )
         if not project_dto:
-
             return JSONResponse(
                 content={
                     "Error": "User not permitted: Private Project",

backend/api/tasks/resources.py

@@ -115,7 +115,6 @@ async def get_project_tasks(
             description: Internal Server Error
     """
     try:
-
         is_private, status = await ProjectService.get_project_privacy_and_status(
             project_id, db
         )
@@ -137,7 +136,6 @@ async def get_project_tasks(
                 db,
             )
             if not project_dto:
-
                 return JSONResponse(
                     content={
                         "Error": "User not permitted: Private Project",

backend/api/users/actions.py

@@ -224,6 +224,59 @@ async def set_user_role(
         )
 
 
+@router.patch("/{username}/actions/update-stats")
+async def update_stats(
+    request: Request,
+    username: str,
+    _: AuthUserDTO = Depends(pm_only),
+    db: Database = Depends(get_db),
+):
+    """
+    Updates user stats
+    ---
+    tags:
+        - users
+        - stats
+    produces:
+        - application/json
+    """
+    try:
+        user = await UserService.get_user_by_username(username, db)
+        stats = await UserService.get_and_save_stats(user.id, db)
+        await UserService.check_and_update_mapper_level(user.id, db, stats)
+    except UserServiceError as e:
+        return JSONResponse(
+            content={"Error": str(e).split("-")[1], "SubCode": str(e).split("-")[0]},
+            status_code=500,
+        )
+
+
+@router.patch("/{username}/actions/approve-level")
+async def approve_level(
+    request: Request,
+    username: str,
+    voter: AuthUserDTO = Depends(pm_only),
+    db: Database = Depends(get_db),
+):
+    """
+    Casts a vote for the promotion of a user to their next level
+    ---
+    tags:
+        - users
+        - levels
+    produces:
+        - application/json
+    """
+    try:
+        user = await UserService.get_user_by_username(username, db)
+        await UserService.approve_level(user.id, voter.id, db)
+    except UserServiceError as e:
+        return JSONResponse(
+            content={"Error": str(e).split("-")[1], "SubCode": str(e).split("-")[0]},
+            status_code=400,
+        )
+
+
 @router.patch("/{user_name}/actions/set-expert-mode/{is_expert}/")
 async def set_user_is_expert(
     request: Request,

backend/api/users/openstreetmap.py

@@ -5,7 +5,8 @@
 from backend.db import get_db
 from backend.models.dtos.user_dto import AuthUserDTO
 from backend.services.users.authentication_service import login_required
-from backend.services.users.user_service import OSMServiceError, UserService
+from backend.services.users.user_service import UserService
+from backend.services.users.osm_service import OSMServiceError
 
 router = APIRouter(
     prefix="/users",

backend/api/users/resources.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from databases import Database
 from fastapi import APIRouter, Depends, Request, Query, Path
 from fastapi.responses import JSONResponse
@@ -61,6 +63,8 @@ async def get_user(
 async def list_users(
     page: int = Query(1, description="Page of results user requested"),
     pagination: bool = Query(True, description="Whether to return paginated results"),
+    sort: Optional[str] = Query(None, description="sort by this metric"),
+    sort_dir: str = Query(default="asc", description="sort direction"),
     per_page: int = Query(
         20, alias="perPage", description="Number of results per page"
     ),
@@ -125,9 +129,12 @@ async def list_users(
             pagination=pagination,
             page=page if pagination else None,
             per_page=per_page,
+            sort=sort,
+            sort_dir=sort_dir,
             username=username,
             mapping_level=level,
             role=role,
+            voter_id=user.id,
         )
     except Exception as e:
         logger.error(f"Error validating request: {str(e)}")