feat: Enhance deployment model and repository functionality

- Updated the Deploy model to make fields optional, improving flexibility in deployment data handling.
- Refactored DeployRepository to support fetching multiple deployment records and added methods for retrieving deployments by owner and for obtaining deployment statistics.
- Modified the deploy router to include new endpoints for retrieving deployments and statistics, enhancing API capabilities.
- Improved error handling and logging for better traceability during deployment operations.

Author: mo7amedgom3a

Backend/app/models/deploy.py

@@ -1,12 +1,12 @@
 from pydantic import BaseModel
 from typing import Optional, List, Dict
 from datetime import datetime
-
+from bson import ObjectId
 class Deploy(BaseModel):
-    user_github_id: str
-    repo_name:str
-    owner: str
-    branch: str
+    user_github_id: Optional[str] = None
+    repo_name: Optional[str] = None
+    owner: Optional[str] = None
+    branch: Optional[str] = None
     pipeline_path: Optional[str] = None  # path to the pipeline file
     framework: Optional[str] = None  # e.g., "flask", "django", etc.
     root_folder_path: Optional[str] = None
@@ -24,4 +24,4 @@ class Deploy(BaseModel):
     updated_at: Optional[datetime] = None
 
     class Config:
-        from_attributes = True
+        from_attributes = True

Backend/app/repositories/deploy.py

@@ -2,6 +2,7 @@
 from typing import List, Dict, Optional
 from models.deploy import Deploy
 from datetime import datetime
+from bson import ObjectId
 from dependencies.database_connection import DatabaseConnection
 import logging
 
@@ -22,6 +23,7 @@ async def create_deploy(self, deploy: Dict) -> Deploy:
         deploy_data = deploy.copy()
         deploy_data["created_at"] = datetime.now()
         deploy_data["updated_at"] = datetime.now()
+        deploy_data["status"] = "success"
         try:
             result = await collection.insert_one(deploy_data)
             if result.inserted_id:
@@ -34,21 +36,59 @@ async def create_deploy(self, deploy: Dict) -> Deploy:
             logger.error(f"Error creating deployment record: {str(e)}")
             raise
 
-    async def get_deploy(self, repo_name: str, owner: str) -> Optional[Deploy]:
+    async def get_deploys(self, owner: str, repo_name: str) -> List[Deploy]:
         """
-        Get a deploy record from the database.
+        Get a deploys records from the database.
         """
         logger.info(f"Fetching deployment record for {owner}/{repo_name}")
         collection = await self.db.get_collection(self.collection)
+        
         try:
-            deploy = await collection.find_one({"repo_name": repo_name, "owner": owner})
-            if deploy:
-                logger.info(f"Found deployment record for {owner}/{repo_name}")
-                return Deploy(**deploy)
-            else:
-                logger.warning(f"No deployment record found for {owner}/{repo_name}")
-                return None
+            deploys = await collection.find({"owner": owner, "repo_name": repo_name}).to_list(length=None)
+            return [Deploy(**deploy) for deploy in deploys]
         except Exception as e:
             logger.error(f"Error fetching deployment record: {str(e)}")
             raise
-    
+    
+    # get a list of all the deploys for owner
+    async def get_deploys_for_owner(self, owner: str) -> List[Deploy]:
+        """
+        Get a list of all the deploys for a given owner.
+        """
+        logger.info(f"Fetching all deployment records for {owner}")
+        collection = await self.db.get_collection(self.collection)
+        try:
+            deploys = await collection.find({"owner": owner}).to_list(length=None)
+            print(f"deploys: {deploys}")
+            logger.info(f"Found {len(deploys)} deployment records for {owner}")
+            return [Deploy(**deploy) for deploy in deploys]
+        except Exception as e:
+            logger.error(f"Error fetching deployment records: {str(e)}")
+            raise
+    # deployment statistics
+    async def get_deployment_statistics(self, owner: str) -> Dict:
+        """
+        Get deployment statistics for a specific owner.
+        """
+        logger.info(f"Fetching deployment statistics for owner: {owner}")
+        collection = await self.db.get_collection(self.collection)
+        try:
+            # Get total number of deployments for owner
+            total_deployments = await collection.count_documents({"owner": owner})
+            logger.info(f"Total deployments for {owner}: {total_deployments}")
+            
+            # Get total number of deployments by status for owner
+            successful_deployments = await collection.count_documents({"owner": owner, "status": "success"})
+            failed_deployments = await collection.count_documents({"owner": owner, "status": "failed"}) 
+            pending_deployments = await collection.count_documents({"owner": owner, "status": "pending"})
+
+            return {
+                "total": total_deployments,
+                "successful": successful_deployments,
+                "failed": failed_deployments,
+                "pending": pending_deployments,
+            }
+
+        except Exception as e:
+            logger.error(f"Error getting deployment statistics for {owner}: {str(e)}")
+            raise

Backend/app/routers/auth.py

@@ -80,6 +80,7 @@ async def github_callback(
     # Return the token and state in the response
     response_data = {
         "jwt_token": token,
+        "token": token,
         "user": {
 
             "login": user.login,

Backend/app/routers/deploy.py

@@ -12,7 +12,7 @@
 
 oauth_2_scheme = OAuth2PasswordBearer(tokenUrl="token")
 router = APIRouter(prefix="/deploy", tags=["deploy"], dependencies=[Depends(get_current_user)])
-@router.post("/", response_model=DeploySchema)
+@router.post("/", response_model=Deploy)
 async def create_deploy(
     deploy: DeployCreateSchema,
     user: UserSchema = Depends(get_current_user),
@@ -45,16 +45,48 @@ def get_frameworks(
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@router.delete("/{owner}/{repo_name}")
-async def delete_deploy(
+@router.get("/repository/{owner}/{repo_name}")
+async def get_deploys(
     owner: str,
     repo_name: str,
     deploy_service: DeployService = Depends(get_deploy_service)
+) -> List[Deploy]:
+    """
+    Get deploy records for a specific repository.
+    """
+    try:
+        return await deploy_service.get_deploys(owner, repo_name)
+    except HTTPException as http_ex:
+        raise http_ex
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+@router.get("/owner/{owner}")
+async def get_deploys_for_owner(
+    owner: str,
+    deploy_service: DeployService = Depends(get_deploy_service)
+) -> List[Deploy]:
+    """
+    Get a list of all the deploys for a given owner.
+    """
+    try:
+        return await deploy_service.get_deploys_for_owner(owner)
+    except HTTPException as http_ex:
+        raise http_ex
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/statistics/{owner}")
+async def get_deploy_statistics(
+    owner: str,
+    deploy_service: DeployService = Depends(get_deploy_service)
 ) -> Dict:
     """
-    destroy terraform resources for repo
+    Get the deployment statistics.
     """
     try:
-        return await deploy_service.destroy_terraform_resources(owner, repo_name)
+        return await deploy_service.get_deploy_statistics(owner)
     except HTTPException as http_ex:
-        raise http_ex
+        raise http_ex
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

Backend/app/services/deploy.py

@@ -18,7 +18,7 @@
 from services.aws_user import AWSUserService
 from services.git_repository import GitRepositoryService
 from services.aws_codebuild import AWSCodeBuild
-
+from typing import List
 logger = logging.getLogger('deploy')
 
 class DeployService:
@@ -97,28 +97,28 @@ async def get_aws_user(self, user_id: str) -> AWSUserSchema:
             raise ValueError("Invalid user ID")
         return await self.aws_user_service.get_user_by_id(user_id)
 
-    async def get_deploy(self, repo_name: str, owner: str) -> Deploy:
+    async def get_deploys(self, owner: str, repo_name: str) -> List[Deploy]:
         """Fetch a deployment record from the repository."""
-        if not repo_name or not isinstance(repo_name, str):
-            raise ValueError("Invalid repo name")
-        if not owner or not isinstance(owner, str):
-            raise ValueError("Invalid owner")
-        deploy = await self.deploy_repository.get_deploy(repo_name, owner)
-        if not deploy:
-            raise ValueError(f"Deployment not found for {owner}/{repo_name}")
-        return deploy
+        return await self.deploy_repository.get_deploys(owner, repo_name)
 
+    async def get_deploys_for_owner(self, owner: str) -> List[Deploy]:
+        """Fetch all deployment records for a given owner."""
+      
+        return await self.deploy_repository.get_deploys_for_owner(owner)
+    async def get_deploy_statistics(self, owner: str) -> Dict:
+        """Fetch deployment statistics from the repository."""
+        return await self.deploy_repository.get_deployment_statistics(owner)
     async def destroy_terraform_resources(self, owner: str, repo_name: str) -> Dict[str, str]:
         """Destroy Terraform resources for a given repository."""
         try:
             # Get the deploy record
-            deploy = await self.get_deploy(repo_name, owner)
-            if not deploy or not deploy.absolute_path:
+            deploys = await self.get_deploys(owner, repo_name)
+            if not deploys or not deploys[0].absolute_path:
                 raise ValueError("Deploy record not found or missing absolute path")
             # get the absolute path of the deploy
-            tf_working_dir = os.path.join(str(deploy.absolute_path), "terraform")
+            tf_working_dir = os.path.join(str(deploys[0].absolute_path), "terraform")
             tf = Terraform(working_dir=tf_working_dir)
-            tf.destroy(auto_approve=True, var={'github_owner': deploy.owner})
+            tf.destroy(auto_approve=True, var={'github_owner': deploys[0].owner})
             return {"status": "success", "message": "Resources destroyed successfully"}
         except Exception as e:
             raise ValueError(f"Error destroying Terraform resources: {str(e)}")
@@ -353,4 +353,5 @@ async def create_deploy(self, deploy: DeployCreateSchema, access_token: str, use
             deploy_data["image_tag"] = deployment_tag  # Still store the tag even if build fails
 
         logger.info(f"Creating deployment record for {deploy.owner}/{deploy.repo_name}")
+
         return await self.deploy_repository.create_deploy(deploy_data)