Merge pull request 'dev' (#4) from dev into furqan

Reviewed-on: https://gitea.maskantech.in/gitea_admin/saas_backend/pulls/4

app/__init__.py

@@ -91,6 +91,9 @@ def create_app() -> FastAPI:
     app.include_router(access_router, prefix="/api/access", tags=["Access Management"])
     app.include_router(user_router, prefix="/api/user", tags=["User Management"])
 
+    from app.routes.theme.color_palette import router as palette_router
+    app.include_router(palette_router, prefix="/api/theme", tags=["Theme Management"])
+
 
     # === Startup: Test DB Connection (Sync + SQLAlchemy 2.0 compatible) ===
     @app.on_event("startup")

app/controllers/theme/color_palette_controller.py

@@ -1,10 +1,14 @@
 from sqlalchemy.orm import Session
 from uuid import UUID
 from typing import List, Optional
-from app.models.auth.user_models import User
+from app.models.auth.user_model import User
-from app.models.theme.color_palette_models import ColorPalette
+from app.models.theme.color_palette_model import ColorPalette
-from app.schemas.theme.palette_schema import ColorPaletteCreate, ColorPaletteUpdate
+from app.schemas.theme.color_palette_schema import (
-from app.services.theme.palette_service import PaletteService
+    ColorPaletteCreate,
+    ColorPaletteUpdate,
+)
+from app.services.theme.color_palette_service import PaletteService
+
 
 class PaletteController:
     @staticmethod
@@ -18,11 +22,15 @@ class PaletteController:
         return PaletteService.get_palette_by_id(db, palette_id)
 
     @staticmethod
-    def create_palette(db: Session, data: ColorPaletteCreate, current_user: User) -> ColorPalette:
+    def create_palette(
+        db: Session, data: ColorPaletteCreate, current_user: User
+    ) -> ColorPalette:
         return PaletteService.create_palette(db, data, tenant_id=None)
 
     @staticmethod
-    def update_palette(db: Session, palette_id: UUID, data: ColorPaletteUpdate) -> ColorPalette:
+    def update_palette(
+        db: Session, palette_id: UUID, data: ColorPaletteUpdate
+    ) -> ColorPalette:
         return PaletteService.update_palette(db, palette_id, data)
 
     @staticmethod

app/routes/theme/color_palette.py

@@ -3,56 +3,67 @@ from sqlalchemy.orm import Session
 from typing import List
 from uuid import UUID
 from app.config.database import get_db
-from app.controllers.theme.palette_controller import PaletteController
+from app.controllers.theme.color_palette_controller import PaletteController
-from app.schemas.theme.palette_schema import ColorPaletteCreate, ColorPaletteUpdate, ColorPaletteResponse
+from app.schemas.theme.color_palette_schema import (
+    ColorPaletteCreate,
+    ColorPaletteUpdate,
+    ColorPaletteResponse,
+)
 from app.middleware.auth_middleware import get_current_user, require_access
 from app.models.auth.user_model import User
 
 router = APIRouter()
 
+
 @router.get("/get", response_model=List[ColorPaletteResponse])
 def get_all_palettes(
-    db: Session = Depends(get_db),
+    db: Session = Depends(get_db), current_user: User = Depends(get_current_user)
-    current_user: User = Depends(get_current_user)
 ):
     return PaletteController.get_all_palettes(db, current_user)
 
+
 @router.get("/get/{palette_id}", response_model=ColorPaletteResponse)
 def get_palette(
     palette_id: UUID,
     db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
+    current_user: User = Depends(get_current_user),
 ):
     return PaletteController.get_palette(db, palette_id)
 
-@router.post("/create", response_model=ColorPaletteResponse, status_code=status.HTTP_201_CREATED)
+
+@router.post(
+    "/create", response_model=ColorPaletteResponse, status_code=status.HTTP_201_CREATED
+)
 def create_palette(
     data: ColorPaletteCreate,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
-    _ = Depends(require_access("superadmin.palette.create"))
+    _=Depends(require_access("superadmin.palette.create")),
 ):
     return PaletteController.create_palette(db, data, current_user)
 
+
 @router.put("/update/users/me/preferences", deprecated=True)
 def update_user_preference():
     pass
 
+
 @router.put("/update/{palette_id}", response_model=ColorPaletteResponse)
 def update_palette(
     palette_id: UUID,
     data: ColorPaletteUpdate,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
-     _ = Depends(require_access("superadmin.palette.update"))
+    _=Depends(require_access("superadmin.palette.update")),
 ):
     return PaletteController.update_palette(db, palette_id, data)
 
+
 @router.delete("/delete/{palette_id}", status_code=status.HTTP_200_OK)
 def delete_palette(
     palette_id: UUID,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
-    _ = Depends(require_access("superadmin.palette.delete"))
+    _=Depends(require_access("superadmin.palette.delete")),
 ):
     return PaletteController.delete_palette(db, palette_id)

app/services/theme/color_palette_service.py

@@ -2,15 +2,23 @@ from sqlalchemy.orm import Session
 from uuid import UUID
 from typing import List, Optional
 from fastapi import HTTPException, status
-from app.models.theme.color_palette_models import ColorPalette
+from app.models.theme.color_palette_model import ColorPalette
-from app.schemas.theme.palette_schema import ColorPaletteCreate, ColorPaletteUpdate
+from app.schemas.theme.color_palette_schema import (
+    ColorPaletteCreate,
+    ColorPaletteUpdate,
+)
+
 
 class PaletteService:
     @staticmethod
-    def get_all_palettes(db: Session, tenant_id: Optional[UUID] = None) -> List[ColorPalette]:
+    def get_all_palettes(
+        db: Session, tenant_id: Optional[UUID] = None
+    ) -> List[ColorPalette]:
         query = db.query(ColorPalette)
         if tenant_id:
-            query = query.filter((ColorPalette.tenant_id == None) | (ColorPalette.tenant_id == tenant_id))
+            query = query.filter(
+                (ColorPalette.tenant_id == None) | (ColorPalette.tenant_id == tenant_id)
+            )
         else:
             pass
         return query.all()
@@ -23,19 +31,25 @@ class PaletteService:
         return palette
 
     @staticmethod
-    def create_palette(db: Session, data: ColorPaletteCreate, tenant_id: Optional[UUID] = None) -> ColorPalette:
+    def create_palette(
+        db: Session, data: ColorPaletteCreate, tenant_id: Optional[UUID] = None
+    ) -> ColorPalette:
         if data.is_default:
             if tenant_id:
-                db.query(ColorPalette).filter(ColorPalette.tenant_id == tenant_id).update({"is_default": False})
+                db.query(ColorPalette).filter(
+                    ColorPalette.tenant_id == tenant_id
+                ).update({"is_default": False})
             else:
-                db.query(ColorPalette).filter(ColorPalette.tenant_id == None).update({"is_default": False})
+                db.query(ColorPalette).filter(ColorPalette.tenant_id == None).update(
+                    {"is_default": False}
+                )
 
         db_palette = ColorPalette(
             name=data.name,
             description=data.description,
             colors=data.colors.model_dump(),
             is_default=data.is_default,
-            tenant_id=tenant_id
+            tenant_id=tenant_id,
         )
         db.add(db_palette)
         db.commit()
@@ -43,7 +57,9 @@ class PaletteService:
         return db_palette
 
     @staticmethod
-    def update_palette(db: Session, palette_id: UUID, data: ColorPaletteUpdate) -> ColorPalette:
+    def update_palette(
+        db: Session, palette_id: UUID, data: ColorPaletteUpdate
+    ) -> ColorPalette:
         palette = PaletteService.get_palette_by_id(db, palette_id)
 
         if data.name is not None:
@@ -56,9 +72,14 @@ class PaletteService:
             if data.is_default:
                 tenant_id = palette.tenant_id
                 if tenant_id:
-                    db.query(ColorPalette).filter(ColorPalette.tenant_id == tenant_id, ColorPalette.id != palette_id).update({"is_default": False})
+                    db.query(ColorPalette).filter(
+                        ColorPalette.tenant_id == tenant_id,
+                        ColorPalette.id != palette_id,
+                    ).update({"is_default": False})
                 else:
-                    db.query(ColorPalette).filter(ColorPalette.tenant_id == None, ColorPalette.id != palette_id).update({"is_default": False})
+                    db.query(ColorPalette).filter(
+                        ColorPalette.tenant_id == None, ColorPalette.id != palette_id
+                    ).update({"is_default": False})
 
             palette.is_default = data.is_default
 

run.py

@@ -9,5 +9,7 @@ if __name__ == "__main__":
         "run:app",
         host=settings.HOST,
         port=settings.PORT,
-        reload=settings.APP_ENV == "development"
+        reload=settings.APP_ENV == "development",
     )
+
+# Force Reload