pharmacy-erp 1.0.0

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

@@ -0,0 +1,150 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func
+from typing import List, Optional
+from datetime import datetime, timedelta
+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.inventory.models import InventoryMovement
+from app.modules.inventory.schemas import StockAdjustment, InventoryMovementResponse
+from app.modules.medicines.models import Medicine, MedicineBatch
+from app.modules.organizations.models import Branch
+
+router = APIRouter(tags=["inventory"])
+
+@router.get("/stock")
+async def get_stock(db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    query = select(
+        Medicine,
+        func.sum(MedicineBatch.quantity_remaining).label("total_quantity")
+    ).outerjoin(MedicineBatch, Medicine.id == MedicineBatch.medicine_id)\
+     .group_by(Medicine.id)
+    result = await db.execute(query)
+    
+    return [
+        {
+            "medicine": med,
+            "total_quantity": qty or 0
+        }
+        for med, qty in result.all()
+    ]
+
+@router.get("/stock/{medicine_id}")
+async def get_medicine_stock(medicine_id: UUID, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    query = select(MedicineBatch).where(MedicineBatch.medicine_id == medicine_id, MedicineBatch.quantity_remaining > 0)
+    result = await db.execute(query)
+    batches = result.scalars().all()
+    return batches
+
+@router.post("/adjustments")
+async def create_stock_adjustment(
+    adjustment: StockAdjustment, 
+    db: AsyncSession = Depends(get_db), 
+    current_user: User = Depends(get_current_user)
+):
+    query = select(MedicineBatch).where(MedicineBatch.id == adjustment.batch_id, MedicineBatch.medicine_id == adjustment.medicine_id)
+    result = await db.execute(query)
+    batch = result.scalars().first()
+    if not batch:
+        raise HTTPException(status_code=404, detail="Batch not found")
+        
+    branch_result = await db.execute(select(Branch))
+    branch = branch_result.scalars().first()
+    if not branch:
+        raise HTTPException(status_code=400, detail="No branch found")
+        
+    movement = InventoryMovement(
+        medicine_id=adjustment.medicine_id,
+        batch_id=adjustment.batch_id,
+        branch_id=branch.id,
+        movement_type=adjustment.adjustment_type,
+        quantity=adjustment.quantity,
+        notes=adjustment.reason,
+        created_by=current_user.id
+    )
+    
+    if adjustment.adjustment_type in ["IN", "ADD"]:
+        batch.quantity_remaining += adjustment.quantity
+    elif adjustment.adjustment_type in ["OUT", "SUBTRACT", "REMOVE"]:
+        if batch.quantity_remaining < adjustment.quantity:
+            raise HTTPException(status_code=400, detail="Insufficient quantity in batch")
+        batch.quantity_remaining -= adjustment.quantity
+        
+    db.add(movement)
+    await db.commit()
+    await db.refresh(movement)
+    return movement
+
+@router.get("/movements", response_model=List[InventoryMovementResponse])
+async def list_movements(
+    medicine_id: Optional[UUID] = None,
+    db: AsyncSession = Depends(get_db), 
+    current_user: User = Depends(get_current_user)
+):
+    query = select(InventoryMovement).order_by(InventoryMovement.created_at.desc())
+    if medicine_id:
+        query = query.where(InventoryMovement.medicine_id == medicine_id)
+    result = await db.execute(query)
+    return result.scalars().all()
+
+@router.get("/alerts/low-stock")
+async def get_low_stock_alerts(db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    query = select(
+        Medicine,
+        func.coalesce(func.sum(MedicineBatch.quantity_remaining), 0).label("total_quantity")
+    ).outerjoin(MedicineBatch, Medicine.id == MedicineBatch.medicine_id)\
+     .group_by(Medicine.id)\
+     .having(func.coalesce(func.sum(MedicineBatch.quantity_remaining), 0) <= Medicine.reorder_level)\
+     .having(func.coalesce(func.sum(MedicineBatch.quantity_remaining), 0) > 0)
+    
+    result = await db.execute(query)
+    return [
+        {
+            "medicine": med,
+            "total_quantity": qty or 0,
+            "reorder_level": med.reorder_level
+        }
+        for med, qty in result.all()
+    ]
+
+@router.get("/alerts/out-of-stock")
+async def get_out_of_stock_alerts(db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    query = select(
+        Medicine,
+        func.coalesce(func.sum(MedicineBatch.quantity_remaining), 0).label("total_quantity")
+    ).outerjoin(MedicineBatch, Medicine.id == MedicineBatch.medicine_id)\
+     .group_by(Medicine.id)\
+     .having(func.coalesce(func.sum(MedicineBatch.quantity_remaining), 0) <= 0)
+    
+    result = await db.execute(query)
+    return [
+        {
+            "medicine": med,
+            "total_quantity": 0,
+            "reorder_level": med.reorder_level
+        }
+        for med, qty in result.all()
+    ]
+
+@router.get("/alerts/expiring")
+async def get_expiring_alerts(db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    ninety_days_from_now = datetime.utcnow() + timedelta(days=90)
+    query = select(MedicineBatch).where(
+        MedicineBatch.expiry_date <= ninety_days_from_now,
+        MedicineBatch.expiry_date >= datetime.utcnow(),
+        MedicineBatch.quantity_remaining > 0
+    )
+    result = await db.execute(query)
+    return result.scalars().all()
+
+@router.get("/alerts/expired")
+async def get_expired_alerts(db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    query = select(MedicineBatch).where(
+        MedicineBatch.expiry_date < datetime.utcnow(),
+        MedicineBatch.quantity_remaining > 0
+    )
+    result = await db.execute(query)
+    return result.scalars().all()

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

@@ -0,0 +1,24 @@
+from pydantic import BaseModel
+from typing import Optional
+from uuid import UUID
+from datetime import datetime
+from decimal import Decimal
+
+class StockAdjustment(BaseModel):
+    medicine_id: UUID
+    batch_id: UUID
+    quantity: Decimal
+    reason: str
+    adjustment_type: str
+
+class InventoryMovementResponse(BaseModel):
+    id: UUID
+    medicine_id: UUID
+    batch_id: UUID
+    movement_type: str
+    quantity: Decimal
+    notes: Optional[str] = None
+    created_at: datetime
+    
+    class Config:
+        from_attributes = True

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

@@ -0,0 +1,54 @@
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy import String, Boolean, Numeric, ForeignKey, Integer, DateTime
+from app.core.database import Base
+import uuid
+from datetime import datetime
+
+class MedicineCategory(Base):
+    __tablename__ = "medicine_categories"
+    name_en: Mapped[str] = mapped_column(String)
+    name_ar: Mapped[str] = mapped_column(String, nullable=True)
+    parent_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("medicine_categories.id"), nullable=True)
+    category_level: Mapped[int] = mapped_column(Integer, default=1)
+    icon: Mapped[str] = mapped_column(String, nullable=True)
+    sort_order: Mapped[int] = mapped_column(Integer, default=0)
+
+class Medicine(Base):
+    __tablename__ = "medicines"
+    sku: Mapped[str] = mapped_column(String, unique=True)
+    barcode: Mapped[str] = mapped_column(String, unique=True, nullable=True)
+    name_en: Mapped[str] = mapped_column(String)
+    name_ar: Mapped[str] = mapped_column(String, nullable=True)
+    generic_name: Mapped[str] = mapped_column(String, nullable=True)
+    brand_name: Mapped[str] = mapped_column(String, nullable=True)
+    strength: Mapped[str] = mapped_column(String, nullable=True)
+    dosage_form: Mapped[str] = mapped_column(String, nullable=True)
+    category_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("medicine_categories.id"), nullable=True)
+    manufacturer: Mapped[str] = mapped_column(String, nullable=True)
+    description: Mapped[str] = mapped_column(String, nullable=True)
+    base_unit: Mapped[str] = mapped_column(String)
+    units_per_pack: Mapped[int] = mapped_column(Integer, default=1)
+    allow_loose_sale: Mapped[bool] = mapped_column(Boolean, default=False)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
+    requires_prescription: Mapped[bool] = mapped_column(Boolean, default=False)
+    is_controlled: Mapped[bool] = mapped_column(Boolean, default=False)
+    is_cold_chain: Mapped[bool] = mapped_column(Boolean, default=False)
+    reorder_level: Mapped[int] = mapped_column(Integer, default=0)
+    max_stock: Mapped[int] = mapped_column(Integer, default=0)
+    selling_price: Mapped[float] = mapped_column(Numeric(10, 2))
+    image_url: Mapped[str] = mapped_column(String, nullable=True)
+
+class MedicineBatch(Base):
+    __tablename__ = "medicine_batches"
+    medicine_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("medicines.id"))
+    batch_number: Mapped[str] = mapped_column(String)
+    expiry_date: Mapped[datetime] = mapped_column(DateTime)
+    purchase_price: Mapped[float] = mapped_column(Numeric(10, 2))
+    quantity_received: Mapped[float] = mapped_column(Numeric(10, 2))
+    quantity_remaining: Mapped[float] = mapped_column(Numeric(10, 2))
+    supplier_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("suppliers.id"), nullable=True)
+    production_date: Mapped[datetime] = mapped_column(DateTime, nullable=True)
+    received_date: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
+    status: Mapped[str] = mapped_column(String, default="ACTIVE")
+    notes: Mapped[str] = mapped_column(String, nullable=True)