Team NonNomine3

.github/workflows/docker-build-test.yml

@@ -0,0 +1,33 @@
+name: Docker CI Pipeline
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Docker
+      uses: docker/setup-buildx-action@v2
+
+    - name: Build Docker Image
+      run: |
+        docker build -t fastapi-app .
+
+    - name: Run Docker Container
+      run: |
+        docker run -d --name fastapi-container -p 8000:8000 fastapi-app
+
+    - name: Cleanup
+      run: |
+        docker stop fastapi-container
+        docker rm fastapi-container

.github/workflows/docker.yml

@@ -0,0 +1,45 @@
+name: Docker CI Pipeline
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+
+    steps:
+    # Step 1: Check out the code
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    # Step 2: Log in to DockerHub (Optional, if pushing the image)
+    - name: Log in to DockerHub
+      uses: docker/login-action@v2
+      with:
+        username: ${{ secrets.DOCKER_USERNAME }}
+        password: ${{ secrets.DOCKER_PASSWORD }}
+
+    # Step 3: Set up Docker
+    - name: Set up Docker
+      uses: docker/setup-buildx-action@v2
+
+    # Step 4: Build Docker image
+    - name: Build Docker Image
+      run: |
+        docker build -t fastapi-app .
+
+    # Step 5: Run Docker Container with GitHub Secrets
+    - name: Run Docker Container
+      run: |
+        docker run -d -p 8000:8000 -e MONGODB_URI='${{ secrets.MONGODB_URI }}' -e MONGODB_NAME='${{ secrets.MONGODB_NAME }}' fastapi-app:latest
+
+    # Step 6: Test API Endpoints
+    - name: Test API Endpoints
+      run: |
+        sleep 5 # Allow time for the container to start
+        curl -f http://localhost:8000/docs

.github/workflows/pylint.yml

@@ -0,0 +1,33 @@
+name: Pylint
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10"]
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install pylint pytest pytest-asyncio pytest-cov
+    - name: Analysing the code with pylint
+      run: |
+        pylint ./app; # pylint $(git ls-files '*.py')
+    - name: Run tests with coverage
+      env:
+        PYTHONPATH: ${{ github.workspace }}
+      run: |
+        pytest --cov=app tests/ --cov-report=term-missing
+    - name: Upload coverage reports
+      uses: codecov/codecov-action@v3
+      with:
+        file: ./coverage.xml

.gitignore

@@ -1,4 +1,6 @@
 .venv
+venv/
 .idea
 __pycache__
 .DS_Store
+.env

Dockerfile

@@ -0,0 +1,30 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install system dependencies required for psutil and other packages
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    python3-dev \
+    libffi-dev \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install dependencies
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir --upgrade pip && pip install -r requirements.txt
+
+# Copy the FastAPI app into the container
+COPY . /app
+
+# Expose port 8000 for FastAPI
+EXPOSE 8000
+
+# Command to run the FastAPI server
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

app/.env

@@ -0,0 +1,2 @@
+MONGODB_URI=mongodb+srv://team:IOi4XgpRxWVkKLv2@cluster0.mcjdj.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0
+MONGODB_NAME=Cluster0

app/clients/router.py

@@ -1,15 +1,141 @@
-from fastapi import APIRouter
-from fastapi.responses import HTMLResponse
+"""
+This module handles client-related API routes for the application.
+"""
 
-from app.clients.service.logic import interpret_and_calculate
-from app.clients.schema import PredictionInput
+from datetime import datetime, date
+from typing import List
+
+from bson import ObjectId
+from fastapi import APIRouter, HTTPException
+
+from app.clients.schema import Client, ClientUpdate
+from app.database import clients_collection
 
 router = APIRouter(prefix="/clients", tags=["clients"])
 
-@router.post("/predictions")
-async def predict(data: PredictionInput):
-    print("HERE")
-    print(data.model_dump())
-    return interpret_and_calculate(data.model_dump())
 
+@router.post("/create", response_model=Client, summary="Create a new client")
+async def create_client(client_data: Client):
+    """
+    Create a new client in the database.
+
+    Args:
+        client_data (Client): The client data to create.
+
+    Returns:
+        Client: The created client object.
+    """
+    client_dict = client_data.dict(exclude={"id"})
+    for key, value in client_dict.items():
+        if isinstance(value, date):
+            client_dict[key] = datetime.combine(value, datetime.min.time())
+    result = await clients_collection.insert_one(client_dict)
+    client_dict["_id"] = result.inserted_id
+    return Client(id=str(client_dict["_id"]), **client_dict)
+
+
+@router.get("/clients/{client_id}", response_model=Client, summary="Retrieve client by ID")
+async def get_client_by_id(client_id: str):
+    """
+    Retrieve a client by their ID.
+
+    Args:
+        client_id (str): The ID of the client to retrieve.
+
+    Returns:
+        Client: The retrieved client object.
+    """
+    client = await clients_collection.find_one({"_id": ObjectId(client_id)})
+    if client is None:
+        raise HTTPException(status_code=404, detail="Client not found")
+    # Convert ObjectId to string and return a formatted client object
+    client["id"] = str(client["_id"])
+    del client["_id"]
+    return client
+
+
+@router.get("/clients", response_model=List[Client], summary="Retrieve all clients")
+async def get_all_clients():
+    """
+    Retrieve all clients in the database.
+
+    Returns:
+        List[Client]: A list of all clients.
+    """
+    # clients_cursor = list(await clients_collection.find())
+    clients_cursor = await clients_collection.find().to_list(length=None)
+    # Convert _id to id and return the list
+    for client in clients_cursor:
+        client["id"] = str(client["_id"])
+        del client["_id"]
+
+    return clients_cursor
+
+
+@router.delete("/clients/{client_id}", response_model=None, summary="Delete client by ID")
+async def delete_client_by_id(client_id: str):
+    """
+    Delete a client by their ID.
+
+    Args:
+        client_id (str): The ID of the client to delete.
+
+    Returns:
+        dict: A message indicating successful deletion.
+    """
+    if not ObjectId.is_valid(client_id):
+        raise HTTPException(status_code=400, detail="Invalid ObjectId format")
+
+    client = await clients_collection.find_one({"_id": ObjectId(client_id)})
+    if client is None:
+        raise HTTPException(status_code=404, detail="Client not found")
+
+    delete_result = await clients_collection.delete_one({"_id": ObjectId(client_id)})
+    if delete_result.deleted_count == 0:
+        raise HTTPException(status_code=404, detail="Client not found")
+
+    return {"message": f"Client with ID {client_id} deleted successfully."}
+
+
+@router.delete("/clients", response_model=None, summary="Delete all clients")
+async def delete_all_clients():
+    """
+    Delete all clients in the database.
+
+    Returns:
+        dict: A message indicating successful deletion of all clients.
+    """
+    await clients_collection.delete_many({})
+    return {"message": "All clients deleted successfully."}
+
+
+@router.put("/clients/{client_id}", response_model=Client, summary="Update client by ID")
+async def update_client(client_id: str, client_data: ClientUpdate):
+    """
+    Update a client's information by their ID.
+
+    Args:
+        client_id (str): The ID of the client to update.
+        client_data (ClientUpdate): The updated client data.
+
+    Returns:
+        Client: The updated client object.
+    """
+    client = await clients_collection.find_one({"_id": ObjectId(client_id)})
+    if client is None:
+        raise HTTPException(status_code=404, detail="Client not found")
+
+    # Convert datetime.date to datetime.datetime for fields that are datetime.date
+    updated_fields = client_data.dict(exclude_unset=True)
+    for field, value in updated_fields.items():
+        if isinstance(value, date):
+            updated_fields[field] = datetime.combine(
+                value, datetime.min.time())
+
+    await clients_collection.update_one({"_id": ObjectId(client_id)}, {"$set": updated_fields})
+
+    updated_client = await clients_collection.find_one({"_id": ObjectId(client_id)})
+    updated_client["id"] = str(updated_client["_id"])
+    del updated_client["_id"]
 
+    return updated_client

app/clients/schema.py

@@ -1,6 +1,18 @@
+"""
+Schemas for client and prediction data models.
+Defines Pydantic models for validation and data manipulation.
+"""
+
+from datetime import date
+from typing import Optional
 from pydantic import BaseModel
 
+
 class PredictionInput(BaseModel):
+    """
+    Schema for prediction input parameters.
+    Used for validating data submitted for predictions.
+    """
     age: int
     gender: str
     work_experience: int
@@ -25,3 +37,30 @@ class PredictionInput(BaseModel):
     substance_use: str
     time_unemployed: int
     need_mental_health_support_bool: str
+
+
+class Client(BaseModel):
+    """
+    Schema for client data.
+    Represents information stored about a client in the database.
+    """
+    id: str
+    first_name: str
+    last_name: str
+    email: str
+    date_of_birth: date
+    address: Optional[str] = None
+    phone: Optional[str] = None
+
+
+class ClientUpdate(BaseModel):
+    """
+    Schema for client update data.
+    Used for partial updates to client information.
+    """
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+    email: Optional[str] = None
+    date_of_birth: Optional[date] = None
+    address: Optional[str] = None
+    phone: Optional[str] = None