Feat/goole drive

.github/workflows/smokeshow.yml

@@ -19,7 +19,7 @@ jobs:
         with:
           python-version: "3.10"
       - run: pip install smokeshow
-      - uses: actions/download-artifact@v7
+      - uses: actions/download-artifact@v6
         with:
           name: coverage-html
           path: backend/htmlcov

.github/workflows/test-backend.yml

@@ -59,7 +59,7 @@ jobs:
         if: failure()
         run: docker compose logs --no-color db || true
       - name: Store coverage files
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v5
         with:
           name: coverage-html
           path: backend/htmlcov

backend/app/api/controllers/dropbox_controller.py

@@ -1,4 +1,5 @@
 import uuid
+from datetime import datetime
 from typing import Any
 
 from fastapi.datastructures import UploadFile
@@ -18,6 +19,16 @@ def __init__(self) -> None:
         self.response_class: type[ResponseSchema[Any]] = ResponseSchema
         self.error_class = AppException
 
+    def _serialize_datetime(self, obj: Any) -> Any:
+        """Recursively serialize datetime objects to ISO format strings"""
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        elif isinstance(obj, dict):
+            return {k: self._serialize_datetime(v) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [self._serialize_datetime(item) for item in obj]
+        return obj
+
     def _success(
         self,
         data: Any = None,
@@ -40,6 +51,8 @@ def _success(
         elif isinstance(data, SQLModel):
             # Convert SQLModel to dict with proper UUID serialization
             data_payload = data.model_dump(mode="json")
+            # Recursively serialize any remaining datetime objects (e.g., in extra_data)
+            data_payload = self._serialize_datetime(data_payload)
 
         payload = self.response_class(
             success=True,
@@ -94,7 +107,6 @@ async def connect_dropbox_with_tokens(
                 access_token=token_response.access_token,
                 expires_in=token_response.expires_in,
                 refresh_token=token_response.refresh_token,
-                token_type=token_response.token_type,
                 scope=token_response.scope,
                 user_id=user_id,
             )
@@ -133,6 +145,20 @@ async def get_all_files_with_namespaces(
         except Exception as e:
             return self._error(message=e)
 
+    async def get_all_files(
+        self,
+        user_id: uuid.UUID,
+    ) -> JSONResponse:
+        """Get all files as a flat list without namespace organization"""
+        try:
+            files = await self.service.get_all_files_combined(user_id=user_id)
+            return self._success(
+                data={"files": files, "total_files": len(files)},
+                message="Successfully retrieved all files",
+            )
+        except Exception as e:
+            return self._error(message=e)
+
     async def get_all_namespaces(
         self,
         user_id: uuid.UUID,
@@ -182,4 +208,3 @@ async def upload_file(
             )
         except Exception as e:
             return self._error(message=e)
-

backend/app/api/controllers/search_controller.py

@@ -0,0 +1,127 @@
+import uuid
+from typing import Any
+
+from fastapi.responses import JSONResponse
+from sqlmodel import SQLModel
+from starlette import status
+
+from app.core.exceptions import AppException
+from app.schemas.response import ResponseSchema
+from app.services.search_service import SearchService
+
+
+class SearchController:
+    def __init__(self) -> None:
+        self.service = SearchService()
+        self.response_class: type[ResponseSchema[Any]] = ResponseSchema
+        self.error_class = AppException
+
+    def _serialize_datetime(self, obj: Any) -> Any:
+        """Recursively serialize datetime objects to ISO format strings"""
+        if isinstance(obj, (str, int, float, bool, type(None))):
+            return obj
+        elif hasattr(obj, "isoformat"):  # datetime objects
+            return obj.isoformat()
+        elif isinstance(obj, dict):
+            return {k: self._serialize_datetime(v) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [self._serialize_datetime(item) for item in obj]
+        return obj
+
+    def _success(
+        self,
+        data: Any = None,
+        message: str = "OK",
+        status_code: int = status.HTTP_200_OK,
+    ) -> JSONResponse:
+        msg = message
+        data_payload = data
+
+        if isinstance(data, dict):
+            msg = data.get("message") or message
+            if "user" in data:
+                data_payload = data.get("user")
+            elif "data" in data:
+                data_payload = data.get("data")
+                if isinstance(data_payload, dict) and "message" in data_payload:
+                    data_payload = {
+                        k: v for k, v in data_payload.items() if k != "message"
+                    }
+        elif isinstance(data, SQLModel):
+            # Convert SQLModel to dict with proper UUID serialization
+            data_payload = data.model_dump(mode="json")
+            # Recursively serialize any remaining datetime objects
+            data_payload = self._serialize_datetime(data_payload)
+
+        # Serialize datetime objects in data_payload
+        data_payload = self._serialize_datetime(data_payload)
+
+        payload = self.response_class(
+            success=True,
+            message=msg,
+            data=data_payload,
+            errors=None,
+            meta=None,
+        ).model_dump(mode="json", exclude_none=True)
+
+        return JSONResponse(status_code=status_code, content=payload)
+
+    def _error(
+        self, message: Any = "Error", errors: Any = None, status_code: int | None = None
+    ) -> JSONResponse:
+        code = status_code
+        if isinstance(message, self.error_class):
+            exc = message
+            fallback_status = getattr(exc, "status_code", status.HTTP_400_BAD_REQUEST)
+            if code is None:
+                if isinstance(fallback_status, int):
+                    code = fallback_status
+                else:
+                    code = status.HTTP_400_BAD_REQUEST
+            payload = self.response_class(
+                success=False,
+                message=getattr(exc, "message", str(exc)),
+                errors=getattr(exc, "details", None),
+                data=None,
+            ).model_dump(mode="json", exclude_none=True)
+            return JSONResponse(status_code=int(code), content=payload)
+
+        code = code if code is not None else status.HTTP_400_BAD_REQUEST
+        msg = str(message)
+
+        payload = self.response_class(
+            success=False,
+            message=msg,
+            errors=errors,
+            data=None,
+        ).model_dump(mode="json", exclude_none=True)
+
+        return JSONResponse(status_code=int(code), content=payload)
+
+    async def search_all_providers(
+        self,
+        user_id: uuid.UUID,
+        query: str,
+        search_in_content: bool = True,
+        max_file_size: int = 10 * 1024 * 1024,
+    ) -> JSONResponse:
+        try:
+            if not query or not query.strip():
+                return self._error(
+                    message="Search query cannot be empty",
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                )
+
+            results = await self.service.search_all_providers(
+                user_id=user_id,
+                search_query=query,
+                search_in_content=search_in_content,
+                max_file_size=max_file_size,
+            )
+
+            return self._success(
+                data=results,
+                message=f"Search completed. Found {results.get('total_files', 0)} files matching '{query}'",
+            )
+        except Exception as e:
+            return self._error(message=e)

backend/app/api/main.py

@@ -1,6 +1,6 @@
 from fastapi import APIRouter
 
-from app.api.routes import auth, dropbox, integrations, one_drive, utils, ws
+from app.api.routes import auth, dropbox, integrations, one_drive, search, utils, ws
 
 api_router = APIRouter()
 api_router.include_router(auth.router)
@@ -9,3 +9,4 @@
 api_router.include_router(integrations.router)
 api_router.include_router(one_drive.router)
 api_router.include_router(dropbox.router)
+api_router.include_router(search.router)

backend/app/api/routes/dropbox.py

@@ -34,6 +34,14 @@ async def connect_dropbox_with_tokens(
     )
 
 
+@router.get("/files")
+async def get_all_files(
+    user_id: uuid.UUID = Depends(get_current_user_id),
+) -> JSONResponse:
+    """Get all files as a flat list without namespace organization"""
+    return await controller.get_all_files(user_id=user_id)
+
+
 @router.get("/files/all")
 async def get_all_files_with_namespaces(
     user_id: uuid.UUID = Depends(get_current_user_id),

backend/app/api/routes/search.py

@@ -0,0 +1,30 @@
+import uuid
+
+from fastapi import APIRouter, Depends, Query
+from fastapi.responses import JSONResponse
+
+from app.api.controllers.search_controller import SearchController
+from app.api.deps import get_current_user_id
+
+router = APIRouter(prefix="/search", tags=["Search"])
+controller = SearchController()
+
+
+@router.get("/files")
+async def search_all_providers(
+    query: str = Query(..., description="Search query string (e.g., 'asad')"),
+    search_in_content: bool = Query(
+        True, description="Whether to search inside file contents"
+    ),
+    max_file_size: int = Query(
+        10 * 1024 * 1024,
+        description="Maximum file size to search content in bytes (default: 10MB)",
+    ),
+    user_id: uuid.UUID = Depends(get_current_user_id),
+) -> JSONResponse:
+    return await controller.search_all_providers(
+        user_id=user_id,
+        query=query,
+        search_in_content=search_in_content,
+        max_file_size=max_file_size,
+    )

backend/app/schemas/external_account.py

@@ -28,9 +28,8 @@ class OneDriveTokenResponse(BaseModel):
 
 class DropboxTokenResponse(BaseModel):
     access_token: str = Field(..., description="Dropbox OAuth access token")
-    expires_in: int | None = Field(
-        None, description="Access token expiration time in seconds"
+    expires_in: str | None = Field(
+        None, description="Access token expiration time in ISO 8601 format"
     )
-    token_type: str | None = Field(default="Bearer", description="Token type")
     refresh_token: str | None = Field(None, description="Dropbox OAuth refresh token")
     scope: str | None = Field(None, description="OAuth scopes granted")