Upload 24 files

app/config/settings.py

@@ -0,0 +1,11 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+MONGODB_URL = os.getenv("MONGODB_URL", "mongodb://localhost:27017")
+DATABASE_NAME = os.getenv("DATABASE_NAME", "expense_tracker")
+COLLECTION_NAME = os.getenv("COLLECTION_NAME", "monthly_records")
+
+# CORS
+ALLOWED_ORIGINS = [o.strip() for o in os.getenv("ALLOWED_ORIGINS", "http://localhost:3000").split(",") if o.strip()]

app/database/connection.py

@@ -0,0 +1,27 @@
+from typing import Optional
+from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorDatabase, AsyncIOMotorCollection
+from . import __init__  # noqa: F401
+from ..config.settings import MONGODB_URL, DATABASE_NAME, COLLECTION_NAME
+
+_client: Optional[AsyncIOMotorClient] = None
+_db: Optional[AsyncIOMotorDatabase] = None
+_collection: Optional[AsyncIOMotorCollection] = None
+
+async def connect_to_mongo() -> None:
+    global _client, _db, _collection
+    _client = AsyncIOMotorClient(MONGODB_URL)
+    _db = _client[DATABASE_NAME]
+    _collection = _db[COLLECTION_NAME]
+
+async def close_mongo_connection() -> None:
+    global _client
+    if _client:
+        _client.close()
+
+def get_db() -> AsyncIOMotorDatabase:
+    assert _db is not None, "DB not initialized. Call connect_to_mongo() first."
+    return _db
+
+def get_collection() -> AsyncIOMotorCollection:
+    assert _collection is not None, "Collection not initialized. Call connect_to_mongo() first."
+    return _collection

app/main.py

@@ -0,0 +1,29 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from .routes.records import router as records_router
+from .database.connection import connect_to_mongo, close_mongo_connection
+from .services.record_service import RecordService
+from .config.settings import ALLOWED_ORIGINS
+
+app = FastAPI(title="Expense Tracker API", version="1.0.0")
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=ALLOWED_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.on_event("startup")
+async def startup_event():
+    await connect_to_mongo()
+    await RecordService().ensure_indexes()
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    await close_mongo_connection()
+
+app.include_router(records_router)

app/models/monthly_record.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import List, Optional
+from pydantic import BaseModel, Field, field_validator
+
+# ----- Pydantic Models -----
+
+class ExpenseCategory(BaseModel):
+    category_id: str
+    name: str
+    amount: float = 0.0
+    color: str = "#cccccc"
+
+class MonthlyRecord(BaseModel):
+    id: Optional[str] = Field(None, alias="_id")
+    month: str
+    year: int
+    month_key: str
+    salary: float
+    expenses: List[ExpenseCategory] = []
+    total_expenses: float = 0.0
+    remaining: float = 0.0
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = {
+        "populate_by_name": True,
+        "json_encoders": {},
+    }
+
+class MonthlyRecordCreate(BaseModel):
+    month: str
+    year: int
+    salary: float
+    expenses: List[ExpenseCategory] = []
+
+class MonthlyRecordUpdate(BaseModel):
+    salary: Optional[float] = None
+    expenses: Optional[List[ExpenseCategory]] = None
+
+# ----- Helpers -----
+
+MONTHS = [
+    "January","February","March","April","May","June",
+    "July","August","September","October","November","December"
+]
+
+def normalize_month_name(name: str) -> str:
+    # Capitalize properly if user sends 'august'
+    return name.strip().capitalize()
+
+def month_key_from(month: str, year: int) -> str:
+    month_norm = normalize_month_name(month)
+    idx = MONTHS.index(month_norm) + 1
+    return f"{year:04d}-{idx:02d}"

app/routes/records.py

@@ -0,0 +1,50 @@
+from fastapi import APIRouter, Depends, Query
+from typing import List, Dict, Any
+
+from ..services.record_service import RecordService
+from ..models.monthly_record import MonthlyRecordCreate, MonthlyRecordUpdate
+
+router = APIRouter(prefix="/api/v1", tags=["records"])
+
+def get_service() -> RecordService:
+    return RecordService()
+
+@router.get("/records/{month_key}")
+async def get_record(month_key: str, svc: RecordService = Depends(get_service)) -> Dict[str, Any]:
+    return await svc.get_by_month_key(month_key)
+
+@router.get("/records")
+async def list_records(
+    limit: int = Query(12, ge=1, le=200),
+    skip: int = Query(0, ge=0),
+    svc: RecordService = Depends(get_service),
+) -> List[Dict[str, Any]]:
+    return await svc.list(limit=limit, skip=skip)
+
+@router.post("/records", status_code=201)
+async def create_record(payload: MonthlyRecordCreate, svc: RecordService = Depends(get_service)) -> Dict[str, Any]:
+    return await svc.create(payload)
+
+@router.put("/records/{month_key}")
+async def update_record(month_key: str, payload: MonthlyRecordUpdate, svc: RecordService = Depends(get_service)) -> Dict[str, Any]:
+    return await svc.update(month_key, payload)
+
+@router.delete("/records/{month_key}", status_code=204)
+async def delete_record(month_key: str, svc: RecordService = Depends(get_service)) -> None:
+    await svc.delete(month_key)
+
+# Default categories
+DEFAULT_CATEGORIES = [
+    {"category_id": "housing", "name": "Housing (Rent/Mortgage)", "amount": 0.0, "color": "#4299e1"},
+    {"category_id": "utilities", "name": "Utilities (Water/Power/Internet)", "amount": 0.0, "color": "#805ad5"},
+    {"category_id": "groceries", "name": "Food & Groceries", "amount": 0.0, "color": "#48bb78"},
+    {"category_id": "transport", "name": "Transport (Fuel/Taxi/Transit)", "amount": 0.0, "color": "#ed8936"},
+    {"category_id": "health", "name": "Healthcare/Pharmacy", "amount": 0.0, "color": "#f56565"},
+    {"category_id": "education", "name": "Education/Books", "amount": 0.0, "color": "#38b2ac"},
+    {"category_id": "family", "name": "Family/Children", "amount": 0.0, "color": "#d69e2e"},
+    {"category_id": "misc", "name": "Miscellaneous", "amount": 0.0, "color": "#a0aec0"},
+]
+
+@router.get("/categories/default")
+async def default_categories() -> List[dict]:
+    return DEFAULT_CATEGORIES

app/services/record_service.py

@@ -0,0 +1,99 @@
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+from fastapi import HTTPException, status
+from bson import ObjectId
+
+from ..database.connection import get_collection
+from ..models.monthly_record import (
+    MonthlyRecord, MonthlyRecordCreate, MonthlyRecordUpdate,
+    ExpenseCategory, month_key_from, normalize_month_name
+)
+
+class RecordService:
+    def __init__(self):
+        self.col = get_collection()
+
+    async def ensure_indexes(self) -> None:
+        # Unique index on month_key for quick lookup
+        await self.col.create_index("month_key", unique=True)
+
+    def _calc_totals(self, salary: float, expenses: List[ExpenseCategory]) -> Dict[str, float]:
+        total_expenses = round(sum(e.amount for e in expenses), 2)
+        remaining = round(salary - total_expenses, 2)
+        return {"total_expenses": total_expenses, "remaining": remaining}
+
+    def _serialize(self, doc: Dict[str, Any]) -> Dict[str, Any]:
+        if not doc:
+            return doc
+        doc["_id"] = str(doc["_id"])
+        return doc
+
+    async def get_by_month_key(self, month_key: str) -> Dict[str, Any]:
+        doc = await self.col.find_one({"month_key": month_key})
+        if not doc:
+            raise HTTPException(status_code=404, detail="No record found for this month")
+        return self._serialize(doc)
+
+    async def list(self, limit: int = 12, skip: int = 0) -> List[Dict[str, Any]]:
+        cursor = self.col.find({}).sort("month_key", 1).skip(skip).limit(limit)
+        return [self._serialize(d) async for d in cursor]
+
+    async def create(self, payload: MonthlyRecordCreate) -> Dict[str, Any]:
+        month = normalize_month_name(payload.month)
+        month_key = month_key_from(month, payload.year)
+        now = datetime.now(timezone.utc)
+
+        totals = self._calc_totals(payload.salary, payload.expenses)
+
+        doc = {
+            "month": month,
+            "year": payload.year,
+            "month_key": month_key,
+            "salary": float(payload.salary),
+            "expenses": [e.model_dump() for e in payload.expenses],
+            "total_expenses": totals["total_expenses"],
+            "remaining": totals["remaining"],
+            "created_at": now,
+            "updated_at": now,
+        }
+
+        try:
+            result = await self.col.insert_one(doc)
+        except Exception as e:
+            # likely duplicate month_key
+            raise HTTPException(status_code=400, detail=str(e))
+
+        created = await self.col.find_one({"_id": result.inserted_id})
+        return self._serialize(created)
+
+    async def update(self, month_key: str, payload: MonthlyRecordUpdate) -> Dict[str, Any]:
+        existing = await self.col.find_one({"month_key": month_key})
+        if not existing:
+            raise HTTPException(status_code=404, detail="No record found for this month")
+
+        salary = payload.salary if payload.salary is not None else existing["salary"]
+        expenses = payload.expenses if payload.expenses is not None else existing["expenses"]
+        # If expenses came as pydantic models, convert to dicts
+        expenses_list = [e.model_dump() if hasattr(e, "model_dump") else e for e in expenses]
+
+        totals = self._calc_totals(salary, [ExpenseCategory(**e) for e in expenses_list])
+
+        update_doc = {
+            "$set": {
+                "salary": float(salary),
+                "expenses": expenses_list,
+                "total_expenses": totals["total_expenses"],
+                "remaining": totals["remaining"],
+                "updated_at": datetime.now(timezone.utc),
+            }
+        }
+
+        await self.col.update_one({"month_key": month_key}, update_doc)
+        updated = await self.col.find_one({"month_key": month_key})
+        return self._serialize(updated)
+
+    async def delete(self, month_key: str) -> None:
+        result = await self.col.delete_one({"month_key": month_key})
+        if result.deleted_count == 0:
+            raise HTTPException(status_code=404, detail="No record found for this month")