pharmacy-erp 1.0.0

package/backend/app/modules/cash_sessions/models.py

@@ -0,0 +1,19 @@
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy import String, Numeric, ForeignKey, DateTime
+from app.core.database import Base
+import uuid
+from datetime import datetime
+
+class CashSession(Base):
+    __tablename__ = "cash_sessions"
+    branch_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("branches.id"))
+    cashier_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"))
+    terminal_name: Mapped[str] = mapped_column(String)
+    status: Mapped[str] = mapped_column(String, default="OPEN")
+    opening_amount: Mapped[float] = mapped_column(Numeric(10, 2))
+    closing_amount: Mapped[float] = mapped_column(Numeric(10, 2), nullable=True)
+    expected_amount: Mapped[float] = mapped_column(Numeric(10, 2), nullable=True)
+    variance: Mapped[float] = mapped_column(Numeric(10, 2), nullable=True)
+    opened_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
+    closed_at: Mapped[datetime] = mapped_column(DateTime, nullable=True)
+    notes: Mapped[str] = mapped_column(String, nullable=True)

package/backend/app/modules/cash_sessions/router.py

@@ -0,0 +1,85 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from typing import List
+from uuid import UUID
+from datetime import datetime
+
+from app.core.database import get_db
+from app.core.deps import get_current_user
+from app.modules.auth.models import User
+from app.modules.cash_sessions.models import CashSession
+from app.modules.cash_sessions.schemas import CashSessionOpen, CashSessionClose, CashSessionResponse
+
+router = APIRouter(tags=["cash-sessions"])
+
+@router.post("/open", response_model=CashSessionResponse)
+async def open_session(data: CashSessionOpen, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    query = select(CashSession).where(
+        CashSession.cashier_id == current_user.id,
+        CashSession.status == "OPEN"
+    )
+    result = await db.execute(query)
+    if result.scalars().first():
+        raise HTTPException(status_code=400, detail="User already has an open cash session")
+        
+    session = CashSession(
+        branch_id=data.branch_id,
+        cashier_id=current_user.id,
+        terminal_name=data.terminal_name,
+        opening_amount=data.opening_amount,
+        status="OPEN"
+    )
+    db.add(session)
+    await db.commit()
+    await db.refresh(session)
+    return session
+
+@router.post("/{id}/close", response_model=CashSessionResponse)
+async def close_session(id: UUID, data: CashSessionClose, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    session = await db.get(CashSession, id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+        
+    if session.status != "OPEN":
+        raise HTTPException(status_code=400, detail="Session is not open")
+        
+    expected = session.opening_amount
+    variance = data.closing_amount - expected
+    
+    session.closing_amount = data.closing_amount
+    session.expected_amount = expected
+    session.variance = variance
+    session.status = "CLOSED"
+    session.closed_at = datetime.utcnow()
+    if data.notes:
+        session.notes = data.notes
+        
+    await db.commit()
+    await db.refresh(session)
+    return session
+
+@router.get("/active", response_model=CashSessionResponse)
+async def get_active_session(db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    query = select(CashSession).where(
+        CashSession.cashier_id == current_user.id,
+        CashSession.status == "OPEN"
+    )
+    result = await db.execute(query)
+    session = result.scalars().first()
+    if not session:
+        raise HTTPException(status_code=404, detail="No active session found")
+    return session
+
+@router.get("/", response_model=List[CashSessionResponse])
+async def list_sessions(db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    query = select(CashSession).order_by(CashSession.opened_at.desc())
+    result = await db.execute(query)
+    return result.scalars().all()
+
+@router.get("/{id}", response_model=CashSessionResponse)
+async def get_session(id: UUID, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    session = await db.get(CashSession, id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return session

package/backend/app/modules/cash_sessions/schemas.py

@@ -0,0 +1,31 @@
+from pydantic import BaseModel
+from typing import Optional
+from uuid import UUID
+from datetime import datetime
+from decimal import Decimal
+
+class CashSessionOpen(BaseModel):
+    branch_id: UUID
+    terminal_name: str
+    opening_amount: Decimal
+
+class CashSessionClose(BaseModel):
+    closing_amount: Decimal
+    notes: Optional[str] = None
+
+class CashSessionResponse(BaseModel):
+    id: UUID
+    branch_id: UUID
+    cashier_id: UUID
+    terminal_name: str
+    status: str
+    opening_amount: Decimal
+    closing_amount: Optional[Decimal] = None
+    expected_amount: Optional[Decimal] = None
+    variance: Optional[Decimal] = None
+    opened_at: datetime
+    closed_at: Optional[datetime] = None
+    notes: Optional[str] = None
+    
+    class Config:
+        from_attributes = True

package/backend/app/modules/customers/models.py

@@ -0,0 +1,37 @@
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy import String, Boolean, Numeric, ForeignKey, Enum as SAEnum
+from app.core.database import Base
+import enum
+
+
+class Customer(Base):
+    __tablename__ = "customers"
+    name: Mapped[str] = mapped_column(String)
+    name_ar: Mapped[str] = mapped_column(String, nullable=True)
+    phone: Mapped[str] = mapped_column(String, nullable=True)
+    email: Mapped[str] = mapped_column(String, nullable=True)
+    address: Mapped[str] = mapped_column(String, nullable=True)
+    credit_limit: Mapped[float] = mapped_column(Numeric(10, 2), default=0)
+    credit_balance: Mapped[float] = mapped_column(Numeric(10, 2), default=0)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
+    notes: Mapped[str] = mapped_column(String, nullable=True)
+
+    payments: Mapped[list["CustomerPayment"]] = relationship(back_populates="customer", lazy="selectin")
+
+
+class PaymentMethod(str, enum.Enum):
+    CASH = "CASH"
+    CARD = "CARD"
+    BANK_TRANSFER = "BANK_TRANSFER"
+
+
+class CustomerPayment(Base):
+    __tablename__ = "customer_payments"
+    customer_id: Mapped[str] = mapped_column(ForeignKey("customers.id"), index=True)
+    amount: Mapped[float] = mapped_column(Numeric(10, 2))
+    payment_method: Mapped[str] = mapped_column(String, default="CASH")
+    reference: Mapped[str] = mapped_column(String, nullable=True)
+    notes: Mapped[str] = mapped_column(String, nullable=True)
+    created_by: Mapped[str] = mapped_column(ForeignKey("users.id"), nullable=True)
+
+    customer: Mapped["Customer"] = relationship(back_populates="payments")

package/backend/app/modules/customers/router.py

@@ -0,0 +1,296 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, or_, func, desc
+from typing import List
+from uuid import UUID
+from decimal import Decimal
+
+from app.core.database import get_db
+from app.core.deps import get_current_user
+from app.modules.auth.models import User
+from app.modules.customers.models import Customer, CustomerPayment
+from app.modules.customers.schemas import (
+    CustomerCreate, CustomerUpdate, CustomerResponse,
+    PaymentCreate, PaymentResponse, CreditLedgerEntry, NotesUpdate,
+)
+
+router = APIRouter(tags=["customers"])
+
+
+# ══════════════════════════════════════════════════════════════════════════
+# CUSTOMER CRUD
+# ══════════════════════════════════════════════════════════════════════════
+
+@router.get("/", response_model=List[CustomerResponse])
+async def list_customers(
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    result = await db.execute(select(Customer).order_by(desc(Customer.created_at)))
+    return result.scalars().all()
+
+
+@router.get("/search", response_model=List[CustomerResponse])
+async def search_customers(
+    q: str,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    query = select(Customer).where(
+        or_(
+            Customer.name.ilike(f"%{q}%"),
+            Customer.name_ar.ilike(f"%{q}%"),
+            Customer.phone.ilike(f"%{q}%"),
+        )
+    )
+    result = await db.execute(query)
+    return result.scalars().all()
+
+
+@router.get("/{id}", response_model=CustomerResponse)
+async def get_customer(
+    id: UUID,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    customer = await db.get(Customer, str(id))
+    if not customer:
+        raise HTTPException(status_code=404, detail="Customer not found")
+    return customer
+
+
+@router.post("/", response_model=CustomerResponse)
+async def create_customer(
+    data: CustomerCreate,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    create_data = data.model_dump(exclude={"opening_balance"})
+    customer = Customer(**create_data)
+    # Set opening balance if provided
+    if data.opening_balance and data.opening_balance > 0:
+        customer.credit_balance = float(data.opening_balance)
+    db.add(customer)
+    await db.commit()
+    await db.refresh(customer)
+    return customer
+
+
+@router.put("/{id}", response_model=CustomerResponse)
+async def update_customer(
+    id: UUID,
+    data: CustomerUpdate,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    customer = await db.get(Customer, str(id))
+    if not customer:
+        raise HTTPException(status_code=404, detail="Customer not found")
+
+    for key, value in data.model_dump(exclude_unset=True).items():
+        setattr(customer, key, value)
+
+    await db.commit()
+    await db.refresh(customer)
+    return customer
+
+
+@router.delete("/{id}")
+async def delete_customer(
+    id: UUID,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    customer = await db.get(Customer, str(id))
+    if not customer:
+        raise HTTPException(status_code=404, detail="Customer not found")
+    customer.is_active = False
+    await db.commit()
+    return {"message": "Customer deactivated successfully"}
+
+
+# ══════════════════════════════════════════════════════════════════════════
+# PURCHASE HISTORY
+# ══════════════════════════════════════════════════════════════════════════
+
+@router.get("/{id}/purchases")
+async def get_customer_purchases(
+    id: UUID,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """Return all sales linked to this customer."""
+    from app.modules.sales.models import Sale, SaleItem
+
+    customer = await db.get(Customer, str(id))
+    if not customer:
+        raise HTTPException(status_code=404, detail="Customer not found")
+
+    result = await db.execute(
+        select(Sale)
+        .where(Sale.customer_id == str(id))
+        .order_by(desc(Sale.created_at))
+    )
+    sales = result.scalars().all()
+
+    purchases = []
+    for sale in sales:
+        # Get items count
+        items_result = await db.execute(
+            select(func.count()).where(SaleItem.sale_id == sale.id)
+        )
+        items_count = items_result.scalar() or 0
+
+        purchases.append({
+            "id": sale.id,
+            "invoice_number": sale.invoice_number,
+            "date": sale.created_at.isoformat(),
+            "items_count": items_count,
+            "total": float(sale.total_amount),
+            "paid": float(sale.total_amount) if sale.status == "COMPLETED" else 0,
+            "status": sale.status,
+            "payment_method": sale.payment_method,
+        })
+
+    return purchases
+
+
+# ══════════════════════════════════════════════════════════════════════════
+# PAYMENTS
+# ══════════════════════════════════════════════════════════════════════════
+
+@router.get("/{id}/payments", response_model=List[PaymentResponse])
+async def get_customer_payments(
+    id: UUID,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    customer = await db.get(Customer, str(id))
+    if not customer:
+        raise HTTPException(status_code=404, detail="Customer not found")
+
+    result = await db.execute(
+        select(CustomerPayment)
+        .where(CustomerPayment.customer_id == str(id))
+        .order_by(desc(CustomerPayment.created_at))
+    )
+    return result.scalars().all()
+
+
+@router.post("/{id}/payments", response_model=PaymentResponse)
+async def add_customer_payment(
+    id: UUID,
+    data: PaymentCreate,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    customer = await db.get(Customer, str(id))
+    if not customer:
+        raise HTTPException(status_code=404, detail="Customer not found")
+
+    if float(data.amount) <= 0:
+        raise HTTPException(status_code=400, detail="Payment amount must be positive")
+
+    # Create payment record
+    payment = CustomerPayment(
+        customer_id=str(id),
+        amount=float(data.amount),
+        payment_method=data.payment_method,
+        reference=data.reference,
+        notes=data.notes,
+        created_by=current_user.id,
+    )
+    db.add(payment)
+
+    # Reduce customer balance
+    new_balance = float(customer.credit_balance or 0) - float(data.amount)
+    customer.credit_balance = max(new_balance, 0)
+
+    await db.commit()
+    await db.refresh(payment)
+    return payment
+
+
+# ══════════════════════════════════════════════════════════════════════════
+# CREDIT LEDGER
+# ══════════════════════════════════════════════════════════════════════════
+
+@router.get("/{id}/credit-ledger")
+async def get_credit_ledger(
+    id: UUID,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """Build credit ledger from sales and payments, sorted by date."""
+    from app.modules.sales.models import Sale
+
+    customer = await db.get(Customer, str(id))
+    if not customer:
+        raise HTTPException(status_code=404, detail="Customer not found")
+
+    entries = []
+
+    # Sales that charged to credit (customer_id linked sales)
+    sales_result = await db.execute(
+        select(Sale)
+        .where(Sale.customer_id == str(id))
+        .order_by(Sale.created_at)
+    )
+    for sale in sales_result.scalars().all():
+        entries.append({
+            "date": sale.created_at.isoformat(),
+            "type": "SALE",
+            "reference": sale.invoice_number or f"SALE-{str(sale.id)[:8]}",
+            "debit": float(sale.total_amount),
+            "credit": None,
+            "sort_key": sale.created_at,
+        })
+
+    # Payments
+    payments_result = await db.execute(
+        select(CustomerPayment)
+        .where(CustomerPayment.customer_id == str(id))
+        .order_by(CustomerPayment.created_at)
+    )
+    for payment in payments_result.scalars().all():
+        entries.append({
+            "date": payment.created_at.isoformat(),
+            "type": "PAYMENT",
+            "reference": payment.reference or f"PAY-{str(payment.id)[:8]}",
+            "debit": None,
+            "credit": float(payment.amount),
+            "sort_key": payment.created_at,
+        })
+
+    # Sort by date and calculate running balance
+    entries.sort(key=lambda e: e["sort_key"])
+    balance = Decimal("0")
+    for entry in entries:
+        if entry["debit"]:
+            balance += Decimal(str(entry["debit"]))
+        if entry["credit"]:
+            balance -= Decimal(str(entry["credit"]))
+        entry["balance"] = float(balance)
+        del entry["sort_key"]
+
+    return entries
+
+
+# ══════════════════════════════════════════════════════════════════════════
+# NOTES
+# ══════════════════════════════════════════════════════════════════════════
+
+@router.patch("/{id}/notes", response_model=CustomerResponse)
+async def update_notes(
+    id: UUID,
+    data: NotesUpdate,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    customer = await db.get(Customer, str(id))
+    if not customer:
+        raise HTTPException(status_code=404, detail="Customer not found")
+    customer.notes = data.notes
+    await db.commit()
+    await db.refresh(customer)
+    return customer

package/backend/app/modules/customers/schemas.py

@@ -0,0 +1,72 @@
+from pydantic import BaseModel
+from typing import Optional, List
+from uuid import UUID
+from datetime import datetime
+from decimal import Decimal
+
+
+class CustomerBase(BaseModel):
+    name: str
+    name_ar: Optional[str] = None
+    phone: Optional[str] = None
+    email: Optional[str] = None
+    address: Optional[str] = None
+    credit_limit: Optional[Decimal] = Decimal("0")
+    notes: Optional[str] = None
+
+
+class CustomerCreate(CustomerBase):
+    opening_balance: Optional[Decimal] = Decimal("0")
+
+
+class CustomerUpdate(CustomerBase):
+    name: Optional[str] = None
+
+
+class CustomerResponse(CustomerBase):
+    id: UUID
+    credit_balance: Decimal
+    is_active: bool
+    created_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+# ── Payments ──────────────────────────────────────────────────────────────
+
+class PaymentCreate(BaseModel):
+    amount: Decimal
+    payment_method: str = "CASH"
+    reference: Optional[str] = None
+    notes: Optional[str] = None
+
+
+class PaymentResponse(BaseModel):
+    id: UUID
+    customer_id: UUID
+    amount: Decimal
+    payment_method: str
+    reference: Optional[str] = None
+    notes: Optional[str] = None
+    created_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+# ── Credit Ledger ─────────────────────────────────────────────────────────
+
+class CreditLedgerEntry(BaseModel):
+    date: datetime
+    type: str  # "SALE" or "PAYMENT"
+    reference: str
+    debit: Optional[Decimal] = None
+    credit: Optional[Decimal] = None
+    balance: Decimal
+
+
+# ── Notes ─────────────────────────────────────────────────────────────────
+
+class NotesUpdate(BaseModel):
+    notes: str

package/backend/app/modules/inventory/models.py

@@ -0,0 +1,16 @@
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy import String, Numeric, ForeignKey
+from app.core.database import Base
+import uuid
+
+class InventoryMovement(Base):
+    __tablename__ = "inventory_movements"
+    medicine_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("medicines.id"))
+    batch_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("medicine_batches.id"))
+    branch_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("branches.id"))
+    movement_type: Mapped[str] = mapped_column(String)
+    quantity: Mapped[float] = mapped_column(Numeric(10, 2))
+    reference_type: Mapped[str] = mapped_column(String, nullable=True)
+    reference_id: Mapped[str] = mapped_column(String, nullable=True)
+    notes: Mapped[str] = mapped_column(String, nullable=True)
+    created_by: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"))