pharmacy-erp 1.0.0

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

@@ -0,0 +1,63 @@
+from fastapi import APIRouter, Depends, Query, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, desc
+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.sales.schemas import SaleCreate, SaleResponse
+from app.modules.sales.service import create_sale, return_sale
+from app.modules.sales.models import Sale
+import uuid
+from typing import List, Optional
+
+from app.modules.organizations.models import Branch
+
+router = APIRouter(tags=["Sales"])
+
+@router.post("", response_model=SaleResponse, include_in_schema=False)
+@router.post("/", response_model=SaleResponse)
+async def process_sale(sale_in: SaleCreate, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    branch_res = await db.execute(select(Branch).limit(1))
+    branch = branch_res.scalars().first()
+    if not branch:
+        branch = Branch(name="Main Branch", code="MAIN")
+        db.add(branch)
+        await db.commit()
+        await db.refresh(branch)
+    branch_id = branch.id
+    sale = await create_sale(db, sale_in, branch_id, current_user.id)
+    return sale
+
+@router.get("", response_model=List[SaleResponse], include_in_schema=False)
+@router.get("/", response_model=List[SaleResponse])
+async def list_sales(
+    start_date: Optional[str] = None,
+    end_date: Optional[str] = None,
+    status: Optional[str] = None,
+    search: Optional[str] = None,
+    db: AsyncSession = Depends(get_db), 
+    current_user: User = Depends(get_current_user)
+):
+    query = select(Sale).order_by(desc(Sale.created_at))
+    
+    if status and status != 'ALL':
+        query = query.where(Sale.status == status)
+    if search:
+        query = query.where(Sale.invoice_number.ilike(f"%{search}%"))
+        
+    result = await db.execute(query)
+    return result.scalars().all()
+
+@router.get("/{sale_id}", response_model=SaleResponse)
+async def get_sale(sale_id: uuid.UUID, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    result = await db.execute(select(Sale).where(Sale.id == sale_id))
+    sale = result.scalars().first()
+    if not sale:
+        raise HTTPException(status_code=404, detail="Sale not found")
+    return sale
+
+@router.post("/{sale_id}/return", response_model=SaleResponse)
+async def process_return(sale_id: uuid.UUID, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    sale = await return_sale(db, sale_id, current_user.id)
+    return sale
+

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

@@ -0,0 +1,42 @@
+from pydantic import BaseModel
+from typing import List, Optional
+import uuid
+from decimal import Decimal
+from datetime import datetime
+
+class SaleItemCreate(BaseModel):
+    medicine_id: uuid.UUID
+    quantity: Decimal
+    unit_price: Decimal
+
+class SaleCreate(BaseModel):
+    payment_method: str
+    items: List[SaleItemCreate]
+    customer_id: Optional[uuid.UUID] = None
+    cash_session_id: Optional[uuid.UUID] = None
+
+class CustomerSimple(BaseModel):
+    id: uuid.UUID
+    name: str
+    model_config = {"from_attributes": True}
+
+class SaleItemResponse(BaseModel):
+    id: uuid.UUID
+    medicine_id: uuid.UUID
+    batch_id: uuid.UUID
+    quantity: Decimal
+    unit_price: Decimal
+    line_total: Decimal
+    model_config = {"from_attributes": True}
+
+class SaleResponse(BaseModel):
+    id: uuid.UUID
+    invoice_number: str
+    total_amount: Decimal
+    status: str
+    payment_method: str
+    created_at: datetime
+    customer: Optional[CustomerSimple] = None
+    items: List[SaleItemResponse] = []
+    model_config = {"from_attributes": True}
+

package/backend/app/modules/sales/service.py

@@ -0,0 +1,128 @@
+from decimal import Decimal
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from app.modules.medicines.models import MedicineBatch
+from app.modules.sales.models import Sale, SaleItem
+from app.modules.inventory.models import InventoryMovement
+from app.core.exceptions import ValidationError
+import uuid
+from datetime import datetime
+
+async def create_sale(db: AsyncSession, sale_data, branch_id: uuid.UUID, cashier_id: uuid.UUID):
+    total_amount = Decimal('0.0')
+    sale_items = []
+    movements = []
+
+    for item in sale_data.items:
+        result = await db.execute(
+            select(MedicineBatch)
+            .where(MedicineBatch.medicine_id == item.medicine_id)
+            .where(MedicineBatch.quantity_remaining > 0)
+            .where(MedicineBatch.is_active == True)
+            .where(MedicineBatch.expiry_date > datetime.utcnow())
+            .where(MedicineBatch.status.in_(["ACTIVE", "NEAR_EXPIRY"]))
+            .order_by(MedicineBatch.expiry_date.asc())
+        )
+        batches = result.scalars().all()
+
+        qty_needed = Decimal(str(item.quantity))
+        
+        for batch in batches:
+            if qty_needed <= 0:
+                break
+                
+            available = Decimal(str(batch.quantity_remaining))
+            take = min(available, qty_needed)
+            
+            batch.quantity_remaining = float(available - take)
+            qty_needed -= take
+            
+            line_total = take * Decimal(str(item.unit_price))
+            sale_items.append(SaleItem(
+                medicine_id=item.medicine_id,
+                batch_id=batch.id,
+                quantity=float(take),
+                unit_price=float(item.unit_price),
+                line_total=float(line_total)
+            ))
+            total_amount += line_total
+            
+            movements.append(InventoryMovement(
+                medicine_id=item.medicine_id,
+                batch_id=batch.id,
+                branch_id=branch_id,
+                movement_type="SALE_OUT",
+                quantity=float(-take),
+                created_by=cashier_id
+            ))
+            
+        if qty_needed > 0:
+            raise ValidationError(f"Insufficient stock for medicine {item.medicine_id}")
+
+    invoice_number = f"INV-{uuid.uuid4().hex[:8].upper()}"
+
+    sale = Sale(
+        invoice_number=invoice_number,
+        branch_id=branch_id,
+        cashier_id=cashier_id,
+        status="COMPLETED",
+        subtotal=float(total_amount),
+        total_amount=float(total_amount),
+        payment_method=sale_data.payment_method,
+        customer_id=sale_data.customer_id,
+        cash_session_id=sale_data.cash_session_id
+    )
+    db.add(sale)
+    await db.flush()
+
+    for si in sale_items:
+        si.sale_id = sale.id
+        db.add(si)
+
+    for mv in movements:
+        mv.reference_id = str(sale.id)
+        mv.reference_type = "SALE"
+        db.add(mv)
+
+    await db.commit()
+    await db.refresh(sale)
+    return sale
+
+async def return_sale(db: AsyncSession, sale_id: uuid.UUID, cashier_id: uuid.UUID):
+    result = await db.execute(select(Sale).where(Sale.id == sale_id))
+    sale = result.scalars().first()
+    
+    if not sale:
+        raise ValidationError(f"Sale {sale_id} not found")
+        
+    if sale.status == "RETURNED":
+        raise ValidationError(f"Sale {sale_id} is already returned")
+        
+    items_result = await db.execute(select(SaleItem).where(SaleItem.sale_id == sale_id))
+    sale_items = items_result.scalars().all()
+    
+    from decimal import Decimal
+    for item in sale_items:
+        # Restore stock
+        batch_result = await db.execute(select(MedicineBatch).where(MedicineBatch.id == item.batch_id))
+        batch = batch_result.scalars().first()
+        if batch:
+            batch.quantity_remaining += Decimal(str(item.quantity))
+            
+        # Create return movement
+        mv = InventoryMovement(
+            medicine_id=item.medicine_id,
+            batch_id=item.batch_id,
+            branch_id=sale.branch_id,
+            movement_type="RETURN_IN",
+            quantity=Decimal(str(item.quantity)),
+            created_by=cashier_id,
+            reference_id=str(sale.id),
+            reference_type="SALE_RETURN"
+        )
+        db.add(mv)
+        
+    sale.status = "RETURNED"
+    await db.commit()
+    await db.refresh(sale)
+    return sale

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

@@ -0,0 +1,14 @@
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy import String, Boolean
+from app.core.database import Base
+
+class Supplier(Base):
+    __tablename__ = "suppliers"
+    name: Mapped[str] = mapped_column(String)
+    name_ar: Mapped[str] = mapped_column(String, nullable=True)
+    contact_person: 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)
+    payment_terms: Mapped[str] = mapped_column(String, nullable=True)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True)

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

@@ -0,0 +1,56 @@
+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 app.core.database import get_db
+from app.core.deps import get_current_user
+from app.modules.auth.models import User
+from app.modules.suppliers.models import Supplier
+from app.modules.suppliers.schemas import SupplierCreate, SupplierUpdate, SupplierResponse
+
+router = APIRouter(tags=["suppliers"])
+
+@router.get("/", response_model=List[SupplierResponse])
+async def list_suppliers(db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    result = await db.execute(select(Supplier))
+    return result.scalars().all()
+
+@router.get("/{id}", response_model=SupplierResponse)
+async def get_supplier(id: UUID, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    supplier = await db.get(Supplier, id)
+    if not supplier:
+        raise HTTPException(status_code=404, detail="Supplier not found")
+    return supplier
+
+@router.post("/", response_model=SupplierResponse)
+async def create_supplier(data: SupplierCreate, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    supplier = Supplier(**data.model_dump())
+    db.add(supplier)
+    await db.commit()
+    await db.refresh(supplier)
+    return supplier
+
+@router.put("/{id}", response_model=SupplierResponse)
+async def update_supplier(id: UUID, data: SupplierUpdate, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    supplier = await db.get(Supplier, id)
+    if not supplier:
+        raise HTTPException(status_code=404, detail="Supplier not found")
+    
+    for key, value in data.model_dump(exclude_unset=True).items():
+        setattr(supplier, key, value)
+        
+    await db.commit()
+    await db.refresh(supplier)
+    return supplier
+
+@router.delete("/{id}")
+async def delete_supplier(id: UUID, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    supplier = await db.get(Supplier, id)
+    if not supplier:
+        raise HTTPException(status_code=404, detail="Supplier not found")
+    
+    supplier.is_active = False
+    await db.commit()
+    return {"message": "Supplier deleted successfully"}

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

@@ -0,0 +1,27 @@
+from pydantic import BaseModel, EmailStr
+from typing import Optional
+from uuid import UUID
+from datetime import datetime
+
+class SupplierBase(BaseModel):
+    name: str
+    name_ar: Optional[str] = None
+    contact_person: Optional[str] = None
+    phone: Optional[str] = None
+    email: Optional[EmailStr] = None
+    address: Optional[str] = None
+    payment_terms: Optional[str] = None
+
+class SupplierCreate(SupplierBase):
+    pass
+
+class SupplierUpdate(SupplierBase):
+    pass
+
+class SupplierResponse(SupplierBase):
+    id: UUID
+    is_active: bool
+    created_at: datetime
+    
+    class Config:
+        from_attributes = True

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

@@ -0,0 +1,74 @@
+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 app.core.database import get_db
+from app.core.deps import get_current_user
+from app.modules.auth.models import User
+from pydantic import BaseModel, EmailStr
+from typing import Optional
+
+class UserUpdate(BaseModel):
+    full_name: Optional[str] = None
+    full_name_ar: Optional[str] = None
+    phone: Optional[str] = None
+    role: Optional[str] = None
+    is_active: Optional[bool] = None
+
+class UserResponse(BaseModel):
+    id: UUID
+    email: str
+    full_name: str
+    full_name_ar: Optional[str] = None
+    role: str
+    phone: Optional[str] = None
+    is_active: bool
+    
+    model_config = {"from_attributes": True}
+
+router = APIRouter(tags=["users"])
+
+@router.get("/", response_model=List[UserResponse])
+async def list_users(db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    if current_user.role != "admin":
+        raise HTTPException(status_code=403, detail="Not authorized")
+    result = await db.execute(select(User))
+    return result.scalars().all()
+
+@router.get("/{id}", response_model=UserResponse)
+async def get_user(id: UUID, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    user = await db.get(User, id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
+
+@router.put("/{id}", response_model=UserResponse)
+async def update_user(id: UUID, data: UserUpdate, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    if current_user.role != "admin" and current_user.id != id:
+        raise HTTPException(status_code=403, detail="Not authorized")
+        
+    user = await db.get(User, id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+        
+    for key, value in data.model_dump(exclude_unset=True).items():
+        setattr(user, key, value)
+        
+    await db.commit()
+    await db.refresh(user)
+    return user
+
+@router.delete("/{id}")
+async def delete_user(id: UUID, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    if current_user.role != "admin":
+        raise HTTPException(status_code=403, detail="Not authorized")
+        
+    user = await db.get(User, id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+        
+    user.is_active = False
+    await db.commit()
+    return {"message": "User deleted successfully"}