Initial commit

dashboard/app.py

+import streamlit as st
+import yfinance as yf
+from datetime import date
+from transformers import pipeline
+
+st.set_page_config(page_title="Stock Dashboard", layout="wide")
+st.title("Stock Price Dashboard + Summarizer")
+
+st.sidebar.header("Stock Price Inputs")
+ticker = st.sidebar.text_input("Enter Stock Ticker (e.g., AAPL)", value="AAPL")
+start_date = st.sidebar.date_input("Start Date", date(2023, 1, 1))
+end_date = st.sidebar.date_input("End Date", date.today())
+
+if st.sidebar.button("Show Stock Chart"):
+    with st.spinner("Fetching stock data..."):
+        try:
+            data = yf.download(ticker, start=start_date, end=end_date)
+            st.subheader(f"{ticker} Closing Price from {start_date} to {end_date}")
+            st.line_chart(data['Close'])
+        except Exception as e:
+            st.error(f"Failed to fetch stock data: {e}")
+
+st.sidebar.header("Text Summarizer")
+text_input = st.sidebar.text_area("Paste stock-related news or article here:")
+summarize_button = st.sidebar.button("Summarize Text")
+
+if summarize_button:
+    if not text_input.strip():
+        st.warning("Please enter some text to summarize.")
+    else:
+        with st.spinner("Summarizing..."):
+            summarizer = pipeline("summarization")
+            summary = summarizer(text_input, max_length=120, min_length=30, do_sample=False)
+            st.subheader("📝 Summary:")
+            st.success(summary[0]['summary_text'])
+
+
+

dashboard/requirements.txt

+streamlit
+yfinance
+transformers

fundamentals/calculator.py

+class Calculator:
+    def __init__(self):
+        self.result = 0
+
+    def add(self, a, b):
+        try:
+            self.result = a + b
+            return self.result
+        except TypeError:
+            print("Error: Invalid input. Please enter numbers.")
+            return None
+
+    def subtract(self, a, b):
+        try:
+            self.result = a - b
+            return self.result
+        except TypeError:
+            print("Error: Invalid input. Please enter numbers.")
+            return None
+
+    def multiply(self, a, b):
+        try:
+            self.result = a * b
+            return self.result
+        except TypeError:
+            print("Error: Invalid input. Please enter numbers.")
+            return None
+
+    def divide(self, a, b):
+        try:
+            if b == 0:
+                raise ZeroDivisionError("Cannot divide by zero.")
+            self.result = a / b
+            return self.result
+        except ZeroDivisionError as zde:
+            print(f"Error: {zde}")
+            return None
+        except TypeError:
+            print("Error: Invalid input. Please enter numbers.")
+            return None
+
+    def power(self, a, b):
+        try:
+            self.result = a ** b
+            return self.result
+        except TypeError:
+            print("Error: Invalid input. Please enter numbers.")
+            return None
+
+    def clear(self):
+        self.result = 0
+
+def get_number(prompt):
+    while True:
+        try:
+            return float(input(prompt))
+        except ValueError:
+            print("Invalid input. Please enter a valid number.")
+
+def main():
+    calc = Calculator()
+    operations = {
+        '1': ('Add', calc.add),
+        '2': ('Subtract', calc.subtract),
+        '3': ('Multiply', calc.multiply),
+        '4': ('Divide', calc.divide),
+        '5': ('Power', calc.power),
+        '6': ('Clear', calc.clear),
+        '7': ('Exit', None)
+    }
+
+    while True:
+        print("\n--- Calculator Menu ---")
+        for key, (name, _) in operations.items():
+            print(f"{key}. {name}")
+        choice = input("Select operation: ")
+
+        if choice == '7':
+            print("Exiting calculator. Goodbye!")
+            break
+        elif choice == '6':
+            calc.clear()
+            print("Calculator cleared.")
+            continue
+        elif choice in operations and choice != '6':
+            a = get_number("Enter first number: ")
+            b = get_number("Enter second number: ")
+            func = operations[choice][1]
+            result = func(a, b)
+            if result is not None:
+                print(f"Result: {result}")
+        else:
+            print("Invalid choice. Please select a valid operation.")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file

fundamentals/sms_data.json

+{
+  "students": {
+    "S40E463EC": {
+      "id": "43fd0154-dc0b-44ee-87f8-90c65fbfab7f",
+      "first_name": "Alice",
+      "last_name": "Johnson",
+      "date_of_birth": "2000-05-15",
+      "contact_email": "alice@example.com",
+      "student_id": "S40E463EC",
+      "major": "Computer Science",
+      "enrollment_date": "2025-05-21",
+      "enrolled_courses": [
+        "MATH201",
+        "CS101"
+      ],
+      "grades": [
+        {
+          "student_id": "S40E463EC",
+          "course_code": "CS101",
+          "grade": "A",
+          "semester": "Fall",
+          "year": 2023,
+          "date_recorded": "2025-05-21"
+        }
+      ],
+      "status": "Active"
+    },
+    "S1803D86D": {
+      "id": "1ebaa60c-6f64-495b-8c52-1a1acc72198d",
+      "first_name": "Bob",
+      "last_name": "Smith",
+      "date_of_birth": "2001-02-20",
+      "contact_email": "bob@example.com",
+      "student_id": "S1803D86D",
+      "major": "Mathematics",
+      "enrollment_date": "2025-05-21",
+      "enrolled_courses": [
+        "CS102",
+        "CS101"
+      ],
+      "grades": [
+        {
+          "student_id": "S1803D86D",
+          "course_code": "CS101",
+          "grade": "B+",
+          "semester": "Fall",
+          "year": 2023,
+          "date_recorded": "2025-05-21"
+        }
+      ],
+      "status": "Active"
+    }
+  },
+  "courses": {
+    "CS101": {
+      "code": "CS101",
+      "name": "Introduction to Computer Science",
+      "credits": 3,
+      "description": "Basic programming concepts",
+      "students": [
+        "S1803D86D",
+        "S40E463EC"
+      ]
+    },
+    "CS102": {
+      "code": "CS102",
+      "name": "Data Structures",
+      "credits": 4,
+      "description": "Fundamental data structures and algorithms",
+      "students": [
+        "S1803D86D"
+      ]
+    },
+    "MATH201": {
+      "code": "MATH201",
+      "name": "Calculus I",
+      "credits": 4,
+      "description": "Limits, derivatives, and integrals",
+      "students": [
+        "S40E463EC"
+      ]
+    }
+  },
+  "instructors": {
+    "E72B04555": {
+      "id": "f8e201fc-45a2-476e-bf6a-cbc7f8336309",
+      "first_name": "David",
+      "last_name": "Brown",
+      "date_of_birth": "1975-08-10",
+      "contact_email": "brown@example.edu",
+      "employee_id": "E72B04555",
+      "department": "Computer Science",
+      "position": "Professor",
+      "hire_date": "2025-05-21",
+      "courses_taught": [
+        "CS102",
+        "CS101"
+      ]
+    }
+  }
+}
\ No newline at end of file

to_dos/Dockerfile

+FROM python:3.13.1-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 8000
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+

to_dos/app/Oauth.py

+from datetime import datetime, timedelta
+from typing import Optional
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from sqlalchemy.orm import Session
+from app.models.user_model import User
+from app.database import get_db
+from sqlalchemy.future import select
+from uuid import UUID
+
+# Constants
+SECRET_KEY = "X3oSxzUEKJcHZAnMM-EuEMi6cBu5DpSoqIoA5vwBnyU"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 60
+
+# Hashing
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# OAuth2
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/login")
+
+# Hash password
+def hash_password(password: str) -> str:
+    return pwd_context.hash(password)
+
+# Verify password
+def verify_password(plain_password, hashed_password) -> bool:
+    return pwd_context.verify(plain_password, hashed_password)
+
+# Create access token
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    to_encode = data.copy()
+    expire = datetime.utcnow() + (expires_delta or timedelta(minutes=15))
+    to_encode.update({"exp": expire})
+    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+
+# Get current user from token
+async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        user_id: str = payload.get("sub")
+        if user_id is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+
+    result = db.execute(select(User).where(User.id == UUID(user_id)))
+    user = result.scalars().first()
+    if user is None:
+        raise credentials_exception
+    return user

to_dos/app/__init__.py

+from fastapi import FastAPI , Request , status
+from app.database import Database
+from app.routes import  (
+    simple_model_routes,
+    user_routes,
+    todo_routes
+)
+from app.auth import AuthRoutes
+import logging
+from fastapi.exceptions import RequestValidationError
+from app.global_constants import GlobalConstants
+from app.auth_routes import auth_router
+
+
+
+# Custom exception handler for validation errors
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    errors = exc.errors()
+    error_messages = []
+
+    for error in errors:
+        field = error.get("loc")[-1]  # Extract the field name
+        msg = error.get("msg")  # Extract the error message
+        error_messages.append(field)
+
+    return GlobalConstants.return_api_response(
+        message=f"{GlobalConstants.api_response_messages.missing_required_parameters}: {', '.join(error_messages)}",
+        result=None,
+        status_code=status.HTTP_400_BAD_REQUEST
+    )
+
+
+def create_app():
+    app = FastAPI(title="FastAPI Application", version="1.0.0")
+    
+    # Register the custom exception handler for validation errors
+    app.add_exception_handler(RequestValidationError, validation_exception_handler)
+
+    # Create database tables
+    print("Creating database tables...")
+    logging.info("Creating database tables...")
+    Database.Base.metadata.create_all(bind=Database.engine)
+    logging.info("Database tables created.")
+    print("Database tables created.")   
+
+    # Include the user routes
+    # app.include_router(AuthRoutes.router,tags=["Authentication"])
+    # app.include_router(simple_model_routes.SimpleModelRoutes.router,tags=["Simple Model"])
+    app.include_router(auth_router, tags=["Authentication"])
+    app.include_router(user_routes.UserRoutes.router,tags=["User"])
+    app.include_router(todo_routes.ToDoRoutes.router,tags=["ToDo"])
+
+
+
+    return app

to_dos/app/auth_routes.py

+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordRequestForm
+from sqlalchemy.orm import Session
+from app.Oauth import verify_password, create_access_token
+from app.database import get_db
+from app.models.user_model import User
+from sqlalchemy.future import select
+from datetime import timedelta
+
+auth_router = APIRouter()
+
+@auth_router.post("/login")
+def login(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_db)):
+    result = db.execute(select(User).where(User.email == form_data.username))
+    user = result.scalars().first()
+
+    if not user or not verify_password(form_data.password, user.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    access_token = create_access_token(
+        data={"sub": str(user.id)},
+        expires_delta=timedelta(minutes=60)
+    )
+
+    return {"access_token": access_token, "token_type": "bearer"}

to_dos/app/config.py

+import os
+from dotenv import load_dotenv
+
+def load_env(env):
+    env_path = os.path.join(os.path.dirname(__file__), 'env_files', env, '.env')
+    if os.path.exists(env_path):
+        load_dotenv(env_path)
+        print(f"Loaded {env} environment configuration")
+    else:
+        raise FileNotFoundError(f".env file for {env} not found.")
+
+# Load environment (default to 'dev' if not provided)
+current_env = os.getenv('ENV', 'dev')
+load_env(current_env)
+
+class Config:
+    SQLALCHEMY_DATABASE_URI = os.getenv('DATABASE_URL')
+    SQLALCHEMY_TRACK_MODIFICATIONS = False
+    # Microsoft Azure AD Configurations
+    CLIENT_ID = os.getenv('CLIENT_ID')
+    CLIENT_SECRET = os.getenv('CLIENT_SECRET')
+    TENANT_ID = os.getenv('TENANT_ID')
+    REDIRECT_URI = os.getenv('REDIRECT_URI')
+    POST_LOGOUT_REDIRECT_URI = os.getenv('POST_LOGOUT_REDIRECT_URI')
+
+

to_dos/app/database.py

+from sqlalchemy import create_engine, exc
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from app.config import Config
+import logging
+
+class Database:
+    # Base class for declarative class definitions (main database)
+    Base = declarative_base()
+
+    # Configure logging for this module
+    logging.basicConfig(level=logging.INFO)
+    logger = logging.getLogger(__name__)
+
+    # Database configuration: get the connection string from config
+    DATABASE_URL = Config.SQLALCHEMY_DATABASE_URI
+    
+    # Create SQLAlchemy engine with connection pool settings
+    engine = create_engine(DATABASE_URL)
+
+    # Create a configured "Session" class
+    SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    # Redefine Base for ORM models (main database)
+    Base = declarative_base()
+
+    # Create all tables in the database (with error handling)
+    try:
+        Base.metadata.create_all(bind=engine)
+        logger.info("Database tables created successfully.")
+    except exc.SQLAlchemyError as e:
+        logger.error(f"Failed to create database tables: {e}")
+
+# Dependency to get a database session (for use in FastAPI or similar frameworks)
+def get_db():
+    db = Database.SessionLocal()
+    try:
+        yield db  # Provide the session to the caller
+    except exc.SQLAlchemyError as e:
+        Database.logger.error(f"Database error occurred: {e}")
+        db.rollback()  # Rollback in case of error
+        raise  # Re-raise the exception for further handling
+    finally:
+        db.close()  # Always close the session
+

to_dos/app/env_files/dev/.env

+# Development Environment Variables
+DATABASE_URL=postgresql://postgres:password@localhost/to_dos
+CLIENT_ID="63c339ba-876c-4724-b813-f7cbc77e7e3b"
+TENANT_ID="6d084a41-2a0b-4141-a5fa-1eb080f65327"
+CLIENT_SECRET="Hdd8Q~bSgayDmsaEA6L9DWqEg-U8zV.uZSohPbFc"
+REDIRECT_URI="http://localhost:8000/authenticate"
+POST_LOGOUT_REDIRECT_URI="http://localhost:8000/login"
+
+
+

to_dos/app/env_files/prod/.env

+# Production Environment Variables
+DATABASE_URL=postgresql://postgres:password@localhost/rbac_db_may_2
+CLIENT_ID="63c339ba-876c-4724-b813-f7cbc77e7e3b"
+TENANT_ID="6d084a41-2a0b-4141-a5fa-1eb080f65327"
+CLIENT_SECRET="Hdd8Q~bSgayDmsaEA6L9DWqEg-U8zV.uZSohPbFc"
+REDIRECT_URI="http://localhost:8000/authenticate"
+POST_LOGOUT_REDIRECT_URI="http://localhost:8000/login"
\ No newline at end of file

to_dos/app/env_files/test/.env

+# Testing Environment Variables
+DATABASE_URL=postgresql://postgres:password@localhost/rbac_db_may_2
+CLIENT_ID="63c339ba-876c-4724-b813-f7cbc77e7e3b"
+TENANT_ID="6d084a41-2a0b-4141-a5fa-1eb080f65327"
+CLIENT_SECRET="Hdd8Q~bSgayDmsaEA6L9DWqEg-U8zV.uZSohPbFc"
+REDIRECT_URI="http://localhost:8000/authenticate"
+POST_LOGOUT_REDIRECT_URI="http://localhost:8000/login"
\ No newline at end of file

to_dos/app/global_constants.py

+from fastapi import status
+from fastapi.responses import JSONResponse
+from typing import Any
+from fastapi.encoders import jsonable_encoder
+
+
+class DotNotationDict:
+    def __init__(self, dictionary):
+        self._data = dictionary
+    
+    def __getattr__(self, name):
+        if name in self._data:
+            return self._data[name]
+        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")
+
+
+class GlobalConstants:
+    
+    api_response_messages = DotNotationDict({
+        "success": "successfully",
+        "accepted": "Accepted",
+        "invalid_request_data": "Invalid request data",
+        "unauthorized": "Unauthorized access",
+        "forbidden": "Forbidden access",
+        "not_found": "Resource not found",
+        "method_not_allowed": "Method not allowed for the requested resource",
+        "internal_server_error": "Internal server error occurred",
+        "missing_required_parameters": "Missing required parameters",
+        "error_in": "Error in",
+        "db_error" : "An error occurred while accessing the database.",
+    })
+
+    # api_request_messages = DotNotationDict({
+    # "page_no": 1,
+    # "page_size": 10,
+    # "filter_data": "Filter data for the request",
+    # "page_no_description": "Page number, starting from 1",
+    # "page_size_description": "Number of records per page",
+    # })
+
+    
+
+    """
+    Custom function to generate a standardized JSON response.
+
+    :param message: Message string for the response.
+    :param result: The result data to include in the response.
+    :return: A FastAPI JSONResponse object.
+    """
+    @staticmethod
+    def return_api_response(message: str, result: Any, status_code: int = status.HTTP_200_OK) -> JSONResponse:
+        
+        if result:
+            result = jsonable_encoder(result)
+            
+        return JSONResponse(
+            status_code=status_code,
+            content={
+                "message": message,
+                "result": result
+            }
+        )
+

to_dos/app/models/__init__.py

+# This file is intentionally left blank
\ No newline at end of file

to_dos/app/models/simple_model.py

+from sqlalchemy import Column, Integer, String, DateTime
+from app.database import Database
+from datetime import datetime, timezone
+from pydantic import BaseModel, Field
+from typing import Optional
+
+class SimpleModel(Database.Base):
+    __tablename__ = "simple_model"
+
+    id = Column(Integer, primary_key=True, autoincrement=True, index=True)
+    name = Column(String, nullable=False)
+    created_at = Column(DateTime, default=datetime.now(timezone.utc))
+    updated_at = Column(DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
+    created_by = Column(String, nullable=True)
+    updated_by = Column(String, nullable=True)
+
+class SimpleModelCreateSchema(BaseModel):
+    name: str = Field(..., example="Test Name")
+    created_by: Optional[str] = Field(None, example="admin")
+
+    class Config:
+        orm_mode = True
+
+class SimpleModelUpdateSchema(BaseModel):
+    simple_model_id: int = Field(..., example=1)
+    name: Optional[str] = Field(None, example="Updated Name")
+    updated_by: Optional[str] = Field(None, example="admin")
+
+    class Config:
+        orm_mode = True
+
+class SimpleModelResponseSchema(BaseModel):
+    id: int = Field(..., example=1)
+    name: str = Field(..., example="Test Name")
+    created_at: Optional[datetime] = Field(None, example="2021-08-01T00:00:00Z")
+    updated_at: Optional[datetime] = Field(None, example="2021-08-02T00:00:00Z")
+    created_by: Optional[str] = Field(None, example="admin")
+    updated_by: Optional[str] = Field(None, example="admin")
+
+    class Config:
+        orm_mode = True
+        
+
+class RefreshTokenSchema(BaseModel):
+    refresh_token: str = Field(..., example="1.AXEAQUoIbQsqQUGl-h6wgPZTJ7o5w2NshyRHuBP3y8d-fjsvAbNxAA.AgABAwEAAABVrSpeuWamRam2jAF1XRQEAwDs_")
+    
+    class Config:
+        orm_mode = True
\ No newline at end of file

to_dos/app/models/todo_model.py

+from sqlalchemy import Column, Integer, String, Boolean, DateTime
+from sqlalchemy.dialects.postgresql import UUID
+from app.database import Database
+from datetime import datetime, timezone
+from typing import Optional
+from pydantic import BaseModel, Field
+from uuid import UUID as UUIDType
+import uuid
+
+class ToDo(Database.Base):
+    __tablename__ = "todos"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=lambda: uuid.uuid4(), index=True)
+    title = Column(String, nullable=False)
+    description = Column(String, nullable=True)
+    is_completed = Column(Boolean, default=False)
+
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
+    
+    created_by = Column(UUID(as_uuid=True), nullable=True)
+    updated_by = Column(UUID(as_uuid=True), nullable=True)
+
+
+class ToDoCreateSchema(BaseModel):
+    title: str = Field(..., example="Buy groceries")
+    description: Optional[str] = Field(None, example="Milk, eggs, bread")
+    created_by: Optional[UUIDType] = Field(None, example="123e4567-e89b-12d3-a456-426614174000")
+
+    class Config:
+        orm_mode = True
+
+
+class ToDoUpdateSchema(BaseModel):
+    todo_id: UUIDType = Field(..., example="123e4567-e89b-12d3-a456-426614174000")
+    title: Optional[str] = Field(None, example="Buy groceries and fruits")
+    description: Optional[str] = Field(None, example="Milk, eggs, bread, apples")
+    is_completed: Optional[bool] = Field(None, example=True)
+    updated_by: Optional[UUIDType] = Field(None, example="123e4567-e89b-12d3-a456-426614174000")
+
+    class Config:
+        orm_mode = True
+
+
+class ToDoResponseSchema(BaseModel):
+    id: UUIDType = Field(..., example="123e4567-e89b-12d3-a456-426614174000")
+    title: str = Field(..., example="Buy groceries")
+    description: Optional[str] = Field(None, example="Milk, eggs, bread")
+    is_completed: bool = Field(..., example=False)
+    created_at: Optional[datetime] = Field(None, example="2025-05-23T10:00:00Z")
+    updated_at: Optional[datetime] = Field(None, example="2025-05-23T11:00:00Z")
+    created_by: Optional[UUIDType] = Field(None, example="123e4567-e89b-12d3-a456-426614174000")
+    updated_by: Optional[UUIDType] = Field(None, example="123e4567-e89b-12d3-a456-426614174000")
+
+    class Config:
+        orm_mode = True

to_dos/app/models/user_model.py

+import uuid
+from sqlalchemy import Column, String, DateTime
+from sqlalchemy.dialects.postgresql import UUID
+from app.database import Database
+from datetime import datetime, timezone
+from pydantic import BaseModel, Field, EmailStr
+from typing import Optional
+from uuid import UUID as UUID_TYPE
+
+# SQLAlchemy User Model
+class User(Database.Base):
+    __tablename__ = "users"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, index=True)
+    username = Column(String, unique=True, nullable=False)
+    email = Column(String, unique=True, nullable=False)
+    full_name = Column(String, nullable=True)
+    hashed_password = Column(String, nullable=False)
+    created_at = Column(DateTime, default=datetime.now(timezone.utc))
+    updated_at = Column(DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
+    created_by = Column(String, nullable=True)
+    updated_by = Column(String, nullable=True)
+
+
+
+class UserCreateSchema(BaseModel):
+    username: str = Field(..., example="john_doe")
+    email: EmailStr = Field(..., example="john@example.com")
+    full_name: Optional[str] = Field(..., example="John Doe")
+    password: str = Field(..., example="securepassword")
+    created_by: Optional[str] = Field(..., example="admin")
+
+    class Config:
+        orm_mode = True
+
+
+class UserUpdateSchema(BaseModel):
+    user_id: UUID_TYPE = Field(..., example="8c5d62dc-7b87-4e5b-9d8f-8d54757c8a2e")
+    email: Optional[EmailStr] = Field(None, example="john_updated@example.com")
+    full_name: Optional[str] = Field(None, example="John Doe Updated")
+    password: Optional[str] = Field(None, example="newsecurepassword")
+    updated_by: Optional[str] = Field(..., example="admin")
+
+    class Config:
+        orm_mode = True
+
+
+class UserResponseSchema(BaseModel):
+    id: UUID_TYPE = Field(..., example="8c5d62dc-7b87-4e5b-9d8f-8d54757c8a2e")
+    username: str = Field(..., example="john_doe")
+    email: EmailStr = Field(..., example="john@example.com")
+    full_name: Optional[str] = Field(None, example="John Doe")
+    created_at: Optional[datetime] = Field(None, example="2021-08-01T00:00:00Z")
+    updated_at: Optional[datetime] = Field(None, example="2021-08-02T00:00:00Z")
+    created_by: Optional[str] = Field(None, example="admin")
+    updated_by: Optional[str] = Field(None, example="admin")
+
+    class Config:
+        orm_mode = True

to_dos/app/routes/__init__.py

+# This file is intentionally left blank.
+# It is used to mark the `routes` directory as a Python package.
\ No newline at end of file

to_dos/app/routes/simple_model_routes.py

+from fastapi import APIRouter, HTTPException, Depends, status , Request
+from sqlalchemy.orm import Session
+from typing import List
+from app.database import get_db
+from app.models.simple_model import (
+    SimpleModelCreateSchema,
+    SimpleModelResponseSchema,
+    SimpleModelUpdateSchema,
+)
+from app.services.simple_model_service import SimpleModelService
+from app.global_constants import GlobalConstants
+from app.auth import validate_and_authorize , AuthRoutes
+
+
+
+class SimpleModelRoutes:
+    router = APIRouter()
+
+    """
+    Creates a new SimpleModel entry.
+    """
+    @staticmethod
+    @router.post("/simple-models", response_model=SimpleModelResponseSchema)
+    def create_simple_model(simple_model: SimpleModelCreateSchema, db: Session = Depends(get_db)):
+        try:
+            service = SimpleModelService(db)
+            return service.create_simple_model(simple_model)
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} create_simple_model route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    """
+    Retrieves all SimpleModel entries.
+    """
+    @staticmethod
+    @router.get("/simple-models", response_model=List[SimpleModelResponseSchema])
+    @validate_and_authorize()
+    def get_all_simple_models(request : Request, db: Session = Depends(get_db),token: dict = Depends(AuthRoutes.oauth2_scheme)):
+        try:
+            service = SimpleModelService(db)
+            user_info = request.state.user_info
+            print("User Info: ", user_info)
+            return service.get_all_simple_models()
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} get_all_simple_models route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    """
+    Retrieves a specific SimpleModel by ID.
+    """
+    @staticmethod
+    @router.get("/simple-model/{simple_model_id}", response_model=SimpleModelResponseSchema)
+    def get_simple_model_by_id(simple_model_id: int, db: Session = Depends(get_db)):
+        try:
+            service = SimpleModelService(db)
+            return service.get_simple_model_by_id(simple_model_id)
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} get_simple_model_by_id route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    """
+    Updates a SimpleModel entry by ID.
+    """
+    @staticmethod
+    @router.patch("/simple-model", response_model=SimpleModelResponseSchema)
+    def update_simple_model(payload: SimpleModelUpdateSchema, db: Session = Depends(get_db)):
+        try:
+            service = SimpleModelService(db)
+            return service.update_simple_model(payload)
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} update_simple_model route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    """
+    Deletes a SimpleModel entry by ID.
+    """
+    @staticmethod
+    @router.delete("/simple-model/{simple_model_id}")
+    def delete_simple_model(simple_model_id: int, db: Session = Depends(get_db)):
+        try:
+            service = SimpleModelService(db)
+            return service.delete_simple_model(simple_model_id)
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} delete_simple_model route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )

to_dos/app/routes/todo_routes.py

+from fastapi import APIRouter, HTTPException, Depends, status, Request
+from sqlalchemy.orm import Session
+from typing import List
+from uuid import UUID
+from app.database import get_db
+from app.models.todo_model import (
+    ToDoCreateSchema,
+    ToDoResponseSchema,
+    ToDoUpdateSchema,
+)
+from app.services.todo_service import ToDoService
+from app.global_constants import GlobalConstants
+
+
+class ToDoRoutes:
+    router = APIRouter()
+
+    """
+    Creates a new ToDo entry.
+    """
+    @staticmethod
+    @router.post("/todos", response_model=ToDoResponseSchema)
+    def create_todo(todo: ToDoCreateSchema, db: Session = Depends(get_db)):
+        try:
+            service = ToDoService(db)
+            return service.create_todo(todo)
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} create_todo route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    """
+    Retrieves all ToDo entries.
+    """
+    @staticmethod
+    @router.get("/todos", response_model=List[ToDoResponseSchema])
+    def get_all_todos(
+        request: Request,
+        db: Session = Depends(get_db)
+    ):
+        try:
+            service = ToDoService(db)
+            return service.get_all_todos()
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} get_all_todos route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    """
+    Retrieves a specific ToDo by ID.
+    """
+    @staticmethod
+    @router.get("/todo/{todo_id}", response_model=ToDoResponseSchema)
+    def get_todo_by_id(todo_id: UUID, db: Session = Depends(get_db)):
+        try:
+            service = ToDoService(db)
+            return service.get_todo_by_id(todo_id)
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} get_todo_by_id route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    """
+    Updates a ToDo entry by ID.
+    """
+    @staticmethod
+    @router.patch("/todo", response_model=ToDoResponseSchema)
+    def update_todo(payload: ToDoUpdateSchema, db: Session = Depends(get_db)):
+        try:
+            service = ToDoService(db)
+            return service.update_todo(payload)
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} update_todo route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    """
+    Deletes a ToDo entry by ID.
+    """
+    @staticmethod
+    @router.delete("/todo/{todo_id}")
+    def delete_todo(todo_id: int, db: Session = Depends(get_db)):
+        try:
+            service = ToDoService(db)
+            return service.delete_todo(todo_id)
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} delete_todo route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+
+    """
+    Retrieves all ToDo entries created by a specific user.
+    """
+    @staticmethod
+    @router.get("/todos/created_by/{created_by_id}", response_model=List[ToDoResponseSchema])
+    def get_todos_by_created_by_id(created_by_id: UUID, db: Session = Depends(get_db)):
+        try:
+            service = ToDoService(db)
+            return service.get_todos_by_created_by_id(created_by_id)
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} get_todos_by_created_by_id route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
\ No newline at end of file

to_dos/app/routes/user_routes.py

+from fastapi import APIRouter, HTTPException, Depends, status, Request
+from sqlalchemy.orm import Session
+from typing import List
+from uuid import UUID
+from app.database import get_db
+from app.models.user_model import (
+    User,
+    UserCreateSchema,
+    UserResponseSchema,
+    UserUpdateSchema,
+)
+from app.services.user_service import UserService
+from app.global_constants import GlobalConstants
+from app.auth import validate_and_authorize, AuthRoutes
+from app.Oauth import get_current_user
+
+class UserRoutes:
+    router = APIRouter()
+
+    @staticmethod
+    @router.post("/users", response_model=UserResponseSchema)
+    def create_user(user: UserCreateSchema, db: Session = Depends(get_db)):
+        try:
+            service = UserService(db)
+            return service.create_user(user)
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} create_user route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @staticmethod
+    @router.get("/users", response_model=List[UserResponseSchema])
+    def get_all_users(
+        request: Request,
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_user)
+    ):
+        try:
+            service = UserService(db)
+            return service.get_all_users()
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} get_all_users route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @staticmethod
+    @router.get("/user/{user_id}", response_model=UserResponseSchema)
+    def get_user_by_id(user_id: UUID, db: Session = Depends(get_db)):
+        try:
+            service = UserService(db)
+            return service.get_user_by_id(user_id)
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} get_user_by_id route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @staticmethod
+    @router.patch("/user", response_model=UserResponseSchema)
+    def update_user(payload: UserUpdateSchema, db: Session = Depends(get_db)):
+        try:
+            service = UserService(db)
+            return service.update_user(payload)
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} update_user route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @staticmethod
+    @router.delete("/user/{user_id}")
+    def delete_user(user_id: UUID, db: Session = Depends(get_db)):
+        try:
+            service = UserService(db)
+            return service.delete_user(user_id)
+        except Exception as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} delete_user route: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.internal_server_error,
+                result=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

to_dos/app/services/__init__.py

+# This is the initialization file for the `services` package.
+# Add any package-level imports or initialization code here.
\ No newline at end of file

to_dos/app/services/simple_model_service.py

+from sqlalchemy.orm import Session
+from sqlalchemy.exc import SQLAlchemyError
+from app.models.simple_model import (
+    SimpleModel,
+    SimpleModelCreateSchema,
+    SimpleModelUpdateSchema,
+    SimpleModelResponseSchema,
+)
+from fastapi import status
+from datetime import datetime, timezone
+from app.global_constants import GlobalConstants
+from sqlalchemy.future import select
+
+class SimpleModelService:
+    def __init__(self, db_session: Session):
+        self.db_session = db_session
+
+
+    def create_simple_model(self, simple_model_data: SimpleModelCreateSchema):
+        try:
+            new_simple_model = SimpleModel(
+                name=simple_model_data.name,
+                created_at=datetime.now(timezone.utc),
+                updated_at=datetime.now(timezone.utc),
+                created_by=simple_model_data.created_by,
+                updated_by=simple_model_data.created_by,
+            )
+            self.db_session.add(new_simple_model)
+            self.db_session.commit()
+            self.db_session.refresh(new_simple_model)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.accepted,
+                result=[SimpleModelResponseSchema(
+                    id=new_simple_model.id,
+                    name=new_simple_model.name,
+                    created_at=new_simple_model.created_at.isoformat() if new_simple_model.created_at else None,
+                    updated_at=new_simple_model.updated_at.isoformat() if new_simple_model.updated_at else None,
+                    created_by=new_simple_model.created_by,
+                    updated_by=new_simple_model.updated_by,
+                )],
+                status_code=status.HTTP_201_CREATED
+            )
+        except SQLAlchemyError as e:
+            self.db_session.rollback()
+            print(f"{GlobalConstants.api_response_messages.error_in} create_simple_model service: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.db_error,
+                result=None,
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def get_all_simple_models(self):
+        try:
+            result = self.db_session.execute(select(SimpleModel))
+            simple_models = result.scalars().all()
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.success,
+                result=[SimpleModelResponseSchema(
+                    id=model.id,
+                    name=model.name,
+                    created_at=model.created_at.isoformat() if model.created_at else None,
+                    updated_at=model.updated_at.isoformat() if model.updated_at else None,
+                    created_by=model.created_by,
+                    updated_by=model.updated_by,
+                ) for model in simple_models],
+                status_code=status.HTTP_200_OK
+            )
+        except SQLAlchemyError as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} get_all_simple_models service: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.db_error,
+                result=None,
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+
+    def get_simple_model_by_id(self, model_id: int):
+        try:
+            result = self.db_session.execute(
+                select(SimpleModel).where(SimpleModel.id == model_id)
+            )
+            model = result.scalars().first()
+            if not model:
+                return GlobalConstants.return_api_response(
+                    message=f"SimpleModel with ID {model_id} not found.",
+                    result=[],
+                    status_code=status.HTTP_400_BAD_REQUEST
+                )
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.success,
+                result=[SimpleModelResponseSchema(
+                    id=model.id,
+                    name=model.name,
+                    created_at=model.created_at.isoformat() if model.created_at else None,
+                    updated_at=model.updated_at.isoformat() if model.updated_at else None,
+                    created_by=model.created_by,
+                    updated_by=model.updated_by,
+                )],
+                status_code=status.HTTP_200_OK
+            )
+        except SQLAlchemyError as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} get_simple_model_by_id service: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.db_error,
+                result=None,
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def update_simple_model(self, simple_model_update: SimpleModelUpdateSchema):
+        try:
+            result = self.db_session.execute(
+                select(SimpleModel).where(SimpleModel.id == simple_model_update.simple_model_id)
+            )
+            model = result.scalars().first()
+            if not model:
+                return GlobalConstants.return_api_response(
+                    message=f"SimpleModel with ID {simple_model_update.simple_model_id} not found.",
+                    result=[],
+                    status_code=status.HTTP_400_BAD_REQUEST
+                )
+            if simple_model_update.name is not None:
+                model.name = simple_model_update.name
+            if simple_model_update.updated_by is not None:
+                model.updated_by = simple_model_update.updated_by
+            model.updated_at = datetime.now(timezone.utc)
+            self.db_session.commit()
+            self.db_session.refresh(model)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.success,
+                result=[SimpleModelResponseSchema(
+                    id=model.id,
+                    name=model.name,
+                    created_at=model.created_at.isoformat() if model.created_at else None,
+                    updated_at=model.updated_at.isoformat() if model.updated_at else None,
+                    created_by=model.created_by,
+                    updated_by=model.updated_by,
+                )],
+                status_code=status.HTTP_200_OK
+            )
+        except SQLAlchemyError as e:
+            self.db_session.rollback()
+            print(f"{GlobalConstants.api_response_messages.error_in} update_simple_model service: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.db_error,
+                result=None,
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def delete_simple_model(self, model_id: int):
+        try:
+            result = self.db_session.execute(
+                select(SimpleModel).where(SimpleModel.id == model_id)
+            )
+            model = result.scalars().first()
+            if not model:
+                return GlobalConstants.return_api_response(
+                    message=f"SimpleModel with ID {model_id} not found.",
+                    result=[],
+                    status_code=status.HTTP_400_BAD_REQUEST
+                )
+            self.db_session.delete(model)
+            self.db_session.commit()
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.success,
+                result=None,
+                status_code=status.HTTP_200_OK
+            )
+        except SQLAlchemyError as e:
+            self.db_session.rollback()
+            print(f"{GlobalConstants.api_response_messages.error_in} delete_simple_model service: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.db_error,
+                result=None,
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
\ No newline at end of file

to_dos/app/services/user_service.py

+from sqlalchemy.orm import Session
+from sqlalchemy.exc import SQLAlchemyError
+from app.models.user_model import (
+    User,
+    UserCreateSchema,
+    UserUpdateSchema,
+    UserResponseSchema,
+)
+from fastapi import status
+from datetime import datetime, timezone
+from app.global_constants import GlobalConstants
+from sqlalchemy.future import select
+from uuid import UUID
+import hashlib
+from app.Oauth import hash_password  
+
+class UserService:
+    def __init__(self, db_session: Session):
+        self.db_session = db_session
+
+
+    def create_user(self, user_data: UserCreateSchema):
+        try:
+
+            # Check if email already exists
+            existing_user = self.db_session.execute(
+                select(User).where(User.email == user_data.email)
+            ).scalars().first()
+            if existing_user:
+                return GlobalConstants.return_api_response(
+                    message="Email already exists.",
+                    result=[],
+                    status_code=status.HTTP_400_BAD_REQUEST
+                )
+                
+            # Use bcrypt to hash the password
+            hashed_password = hash_password(user_data.password)
+
+            new_user = User(
+                username=user_data.username,
+                email=user_data.email,
+                full_name=user_data.full_name,
+                hashed_password=hashed_password,
+                created_at=datetime.now(timezone.utc),
+                updated_at=datetime.now(timezone.utc),
+                created_by=user_data.created_by,
+                updated_by=user_data.created_by,
+            )
+            self.db_session.add(new_user)
+            self.db_session.commit()
+            self.db_session.refresh(new_user)
+
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.accepted,
+                result=[UserResponseSchema(
+                    id=new_user.id,
+                    username=new_user.username,
+                    email=new_user.email,
+                    full_name=new_user.full_name,
+                    created_at=new_user.created_at.isoformat() if new_user.created_at else None,
+                    updated_at=new_user.updated_at.isoformat() if new_user.updated_at else None,
+                    created_by=new_user.created_by,
+                    updated_by=new_user.updated_by,
+                )],
+                status_code=status.HTTP_201_CREATED
+            )
+        except SQLAlchemyError as e:
+            self.db_session.rollback()
+            print(f"{GlobalConstants.api_response_messages.error_in} create_user service: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.db_error,
+                result=None,
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def get_all_users(self):
+        try:
+            result = self.db_session.execute(select(User))
+            users = result.scalars().all()
+
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.success,
+                result=[UserResponseSchema(
+                    id=user.id,
+                    username=user.username,
+                    email=user.email,
+                    full_name=user.full_name,
+                    created_at=user.created_at.isoformat() if user.created_at else None,
+                    updated_at=user.updated_at.isoformat() if user.updated_at else None,
+                    created_by=user.created_by,
+                    updated_by=user.updated_by,
+                ) for user in users],
+                status_code=status.HTTP_200_OK
+            )
+        except SQLAlchemyError as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} get_all_users service: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.db_error,
+                result=None,
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def get_user_by_id(self, user_id: UUID):
+        try:
+            result = self.db_session.execute(select(User).where(User.id == user_id))
+            user = result.scalars().first()
+            if not user:
+                return GlobalConstants.return_api_response(
+                    message=f"User with ID {user_id} not found.",
+                    result=[],
+                    status_code=status.HTTP_400_BAD_REQUEST
+                )
+
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.success,
+                result=[UserResponseSchema(
+                    id=user.id,
+                    username=user.username,
+                    email=user.email,
+                    full_name=user.full_name,
+                    created_at=user.created_at.isoformat() if user.created_at else None,
+                    updated_at=user.updated_at.isoformat() if user.updated_at else None,
+                    created_by=user.created_by,
+                    updated_by=user.updated_by,
+                )],
+                status_code=status.HTTP_200_OK
+            )
+        except SQLAlchemyError as e:
+            print(f"{GlobalConstants.api_response_messages.error_in} get_user_by_id service: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.db_error,
+                result=None,
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def update_user(self, user_update: UserUpdateSchema):
+        try:
+            result = self.db_session.execute(select(User).where(User.id == user_update.user_id))
+            user = result.scalars().first()
+            if not user:
+                return GlobalConstants.return_api_response(
+                    message=f"User with ID {user_update.user_id} not found.",
+                    result=[],
+                    status_code=status.HTTP_400_BAD_REQUEST
+                )
+            if user_update.email is not None:
+                user.email = user_update.email
+            if user_update.full_name is not None:
+                user.full_name = user_update.full_name
+            if user_update.password is not None:
+                user.hashed_password = hash_password(user_update.password)
+            if user_update.updated_by is not None:
+                user.updated_by = user_update.updated_by
+
+            user.updated_at = datetime.now(timezone.utc)
+            self.db_session.commit()
+            self.db_session.refresh(user)
+
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.success,
+                result=[UserResponseSchema(
+                    id=user.id,
+                    username=user.username,
+                    email=user.email,
+                    full_name=user.full_name,
+                    created_at=user.created_at.isoformat() if user.created_at else None,
+                    updated_at=user.updated_at.isoformat() if user.updated_at else None,
+                    created_by=user.created_by,
+                    updated_by=user.updated_by,
+                )],
+                status_code=status.HTTP_200_OK
+            )
+        except SQLAlchemyError as e:
+            self.db_session.rollback()
+            print(f"{GlobalConstants.api_response_messages.error_in} update_user service: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.db_error,
+                result=None,
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def delete_user(self, user_id: UUID):
+        try:
+            result = self.db_session.execute(select(User).where(User.id == user_id))
+            user = result.scalars().first()
+            if not user:
+                return GlobalConstants.return_api_response(
+                    message=f"User with ID {user_id} not found.",
+                    result=[],
+                    status_code=status.HTTP_400_BAD_REQUEST
+                )
+            self.db_session.delete(user)
+            self.db_session.commit()
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.success,
+                result=None,
+                status_code=status.HTTP_200_OK
+            )
+        except SQLAlchemyError as e:
+            self.db_session.rollback()
+            print(f"{GlobalConstants.api_response_messages.error_in} delete_user service: ", e)
+            return GlobalConstants.return_api_response(
+                message=GlobalConstants.api_response_messages.db_error,
+                result=None,
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )

to_dos/app/utils/exception.py

+class OAuthException(Exception):
+    """
+    Custom exception class to handle OAuth-related errors.
+    """
+    def __init__(self,detail=None, status_code=None):
+        """
+        Initialize the OAuthException with details.
+        
+        :param error_description: Optional detailed description of the error.
+        :param status_code: Optional HTTP status code associated with the error.
+        """
+        self.detail = detail
+        self.status_code = status_code
+        super().__init__(self.__str__())
+
+
+

to_dos/main.py

+from app import create_app
+import uvicorn
+from fastapi.middleware.cors import CORSMiddleware
+
+app = create_app()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],                
+    allow_credentials=True,             
+    allow_methods=["*"],                
+    allow_headers=["*"],               
+)
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000) 
\ No newline at end of file

to_dos/requirements.txt

+fastapi==0.115.4
+uvicorn==0.32.0
+sqlalchemy==2.0.31
+databases==0.9.0
+asyncpg==0.30.0
+pydantic==2.9.2
+psycopg2-binary==2.9.6
+pydantic[email]==2.9.2
+python-dotenv==1.0.0
+python-jose==3.3.0
+pytest==8.3.5
+httpx==0.27.2
+requests==2.32.3
+cryptography==43.0.1
+pandas==2.2.2
+jwt
+python-jose[cryptography] 
+passlib[bcrypt]
\ No newline at end of file

to_dos/sonar-project.properties

+sonar.projectKey=fastapi_application
+sonar.projectName=FastAPI Application
+sonar.projectVersion=1.0
+
+sonar.sources=app
+sonar.tests=tests
+
+sonar.python.coverage.reportPaths=coverage.xml
+sonar.python.xunit.reportPaths=xunit.xml
+
+sonar.host.url=http://localhost:9000
+sonar.login=admin
+sonar.password=admin
\ No newline at end of file