pharmacy-erp 1.0.0

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

@@ -0,0 +1,153 @@
+from pydantic import BaseModel
+from typing import Optional, List
+from datetime import datetime
+import uuid
+from decimal import Decimal
+
+class CategoryCreate(BaseModel):
+    name_en: str
+    name_ar: Optional[str] = None
+    parent_id: Optional[uuid.UUID] = None
+    category_level: int = 1
+    icon: Optional[str] = None
+    sort_order: int = 0
+
+class CategoryResponse(CategoryCreate):
+    id: uuid.UUID
+    category_level: int
+    icon: Optional[str] = None
+    sort_order: int
+    model_config = {"from_attributes": True}
+
+class CategoryUpdate(BaseModel):
+    name_en: Optional[str] = None
+    name_ar: Optional[str] = None
+    parent_id: Optional[uuid.UUID] = None
+    category_level: Optional[int] = None
+    icon: Optional[str] = None
+    sort_order: Optional[int] = None
+
+class CategoryTreeResponse(CategoryResponse):
+    children: List['CategoryTreeResponse'] = []
+    model_config = {"from_attributes": True}
+
+class MedicineCreate(BaseModel):
+    sku: str
+    name_en: str
+    name_ar: Optional[str] = None
+    base_unit: str
+    selling_price: Decimal
+    barcode: Optional[str] = None
+    category_id: Optional[uuid.UUID] = None
+    generic_name: Optional[str] = None
+    brand_name: Optional[str] = None
+    strength: Optional[str] = None
+    dosage_form: Optional[str] = None
+    manufacturer: Optional[str] = None
+    description: Optional[str] = None
+    units_per_pack: int = 1
+    allow_loose_sale: bool = False
+    requires_prescription: bool = False
+    is_controlled: bool = False
+    is_cold_chain: bool = False
+    reorder_level: int = 0
+    max_stock: int = 0
+    image_url: Optional[str] = None
+
+class MedicineUpdate(BaseModel):
+    sku: Optional[str] = None
+    name_en: Optional[str] = None
+    name_ar: Optional[str] = None
+    base_unit: Optional[str] = None
+    selling_price: Optional[Decimal] = None
+    barcode: Optional[str] = None
+    category_id: Optional[uuid.UUID] = None
+    generic_name: Optional[str] = None
+    brand_name: Optional[str] = None
+    strength: Optional[str] = None
+    dosage_form: Optional[str] = None
+    manufacturer: Optional[str] = None
+    description: Optional[str] = None
+    units_per_pack: Optional[int] = None
+    allow_loose_sale: Optional[bool] = None
+    requires_prescription: Optional[bool] = None
+    is_controlled: Optional[bool] = None
+    is_cold_chain: Optional[bool] = None
+    reorder_level: Optional[int] = None
+    max_stock: Optional[int] = None
+    image_url: Optional[str] = None
+    is_active: Optional[bool] = None
+
+class MedicineResponse(MedicineCreate):
+    id: uuid.UUID
+    selling_price: Decimal
+    is_active: bool
+    model_config = {"from_attributes": True}
+
+class InitialBatch(BaseModel):
+    batch_number: Optional[str] = None
+    quantity: Decimal
+    purchase_price: Decimal
+    production_date: Optional[datetime] = None
+    expiry_date: datetime
+    supplier_id: Optional[uuid.UUID] = None
+
+class MedicineCreateWithBatch(MedicineCreate):
+    initial_batch: Optional[InitialBatch] = None
+
+class BatchCreate(BaseModel):
+    batch_number: str
+    expiry_date: datetime
+    purchase_price: Decimal
+    quantity_received: Decimal
+    supplier_id: Optional[uuid.UUID] = None
+    production_date: Optional[datetime] = None
+    notes: Optional[str] = None
+
+class BatchUpdate(BaseModel):
+    expiry_date: Optional[datetime] = None
+    purchase_price: Optional[Decimal] = None
+    production_date: Optional[datetime] = None
+    notes: Optional[str] = None
+    status: Optional[str] = None  # ACTIVE, QUARANTINED, RECALLED, DAMAGED
+
+class BatchResponse(BaseModel):
+    id: uuid.UUID
+    medicine_id: uuid.UUID
+    batch_number: str
+    expiry_date: datetime
+    purchase_price: Decimal
+    quantity_received: Decimal
+    quantity_remaining: Decimal
+    received_date: datetime
+    is_active: bool
+    production_date: Optional[datetime] = None
+    supplier_id: Optional[uuid.UUID] = None
+    status: Optional[str] = "ACTIVE"
+    notes: Optional[str] = None
+    model_config = {"from_attributes": True}
+
+class BatchConflictResponse(BaseModel):
+    """Returned when a batch number already exists with a different expiry date"""
+    conflict: bool = True
+    message: str
+    existing_batch_number: str
+    existing_expiry_date: datetime
+    entered_expiry_date: datetime
+
+class MedicineDetailResponse(MedicineResponse):
+    batches: List[BatchResponse] = []
+    category_name: Optional[str] = None
+
+class BulkImportRowError(BaseModel):
+    row: int
+    field: Optional[str] = None
+    message: str
+
+class BulkImportResponse(BaseModel):
+    total_rows: int
+    successful: int
+    failed: int
+    errors: List[BulkImportRowError] = []
+    created_medicines: List[MedicineResponse] = []
+

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

@@ -0,0 +1,118 @@
+import io
+import csv
+from openpyxl import Workbook
+from openpyxl.styles import PatternFill, Font, Alignment
+from openpyxl.worksheet.datavalidation import DataValidation
+from openpyxl.utils import get_column_letter
+
+COLUMNS = [
+    {"header": "name_en *", "field": "name_en", "desc": "English name of the medicine (Required)"},
+    {"header": "name_ar", "field": "name_ar", "desc": "Arabic name"},
+    {"header": "sku", "field": "sku", "desc": "Stock Keeping Unit (Auto-generated if empty)"},
+    {"header": "barcode", "field": "barcode", "desc": "Barcode for scanning"},
+    {"header": "selling_price *", "field": "selling_price", "desc": "Selling price in base currency (Required)"},
+    {"header": "base_unit *", "field": "base_unit", "desc": "Base unit (Required)"},
+    {"header": "category", "field": "category", "desc": "Category name (Matched with existing)"},
+    {"header": "generic_name", "field": "generic_name", "desc": "Generic name / Scientific name"},
+    {"header": "brand_name", "field": "brand_name", "desc": "Brand name"},
+    {"header": "strength", "field": "strength", "desc": "Strength (e.g., 500mg)"},
+    {"header": "dosage_form", "field": "dosage_form", "desc": "Form of the medicine"},
+    {"header": "manufacturer", "field": "manufacturer", "desc": "Manufacturer name"},
+    {"header": "description", "field": "description", "desc": "Additional details"},
+    {"header": "units_per_pack", "field": "units_per_pack", "desc": "Number of units per pack (Default: 1)"},
+    {"header": "max_stock", "field": "max_stock", "desc": "Maximum stock allowed (Default: 0)"},
+    {"header": "initial_stock", "field": "initial_stock", "desc": "Initial stock quantity"},
+    {"header": "purchase_price", "field": "purchase_price", "desc": "Purchase price"},
+    {"header": "batch_number", "field": "batch_number", "desc": "Batch/Lot number"},
+    {"header": "expiry_date", "field": "expiry_date", "desc": "Expiry date YYYY-MM-DD"},
+]
+
+EXAMPLE_ROW = [
+    "Amoxicillin 500mg",
+    "أموكسيسيلين 500 ملغ",
+    "AMX-500",
+    "1234567890123",
+    "15.50",
+    "Box",
+    "Antibiotics",
+    "Amoxicillin",
+    "Amoxil",
+    "500mg",
+    "capsule",
+    "GSK",
+    "Broad-spectrum antibiotic",
+    "20",
+    "100",
+    "100",
+    "10.50",
+    "B-AMX-500",
+    "2027-12-31"
+]
+
+BASE_UNITS = ["Pack", "Tablet", "Bottle", "Box", "Tube", "Strip", "Vial", "Ampoule", "Piece"]
+DOSAGE_FORMS = ["tablet", "capsule", "syrup", "suspension", "injection", "infusion", "cream", "ointment", "gel", "drops", "eye_drops", "ear_drops", "nasal_spray", "inhaler", "suppository", "powder"]
+
+def generate_csv_template() -> io.BytesIO:
+    output = io.StringIO()
+    writer = csv.writer(output)
+    
+    headers = [col["header"] for col in COLUMNS]
+    descriptions = [col["desc"] for col in COLUMNS]
+    
+    writer.writerow(headers)
+    writer.writerow(EXAMPLE_ROW)
+    writer.writerow(descriptions)
+    
+    bio = io.BytesIO(output.getvalue().encode('utf-8'))
+    return bio
+
+def generate_xlsx_template() -> io.BytesIO:
+    wb = Workbook()
+    ws = wb.active
+    ws.title = "Medicines Import"
+    
+    headers = [col["header"] for col in COLUMNS]
+    descriptions = [col["desc"] for col in COLUMNS]
+    
+    ws.append(headers)
+    ws.append(EXAMPLE_ROW)
+    ws.append(descriptions)
+    
+    # Styles
+    header_fill = PatternFill(start_color="000080", end_color="000080", fill_type="solid")
+    header_font = Font(color="FFFFFF", bold=True)
+    example_fill = PatternFill(start_color="E2EFDA", end_color="E2EFDA", fill_type="solid")
+    desc_fill = PatternFill(start_color="FFF2CC", end_color="FFF2CC", fill_type="solid")
+    
+    for col_idx, cell in enumerate(ws[1], 1):
+        cell.fill = header_fill
+        cell.font = header_font
+        cell.alignment = Alignment(horizontal="center")
+        
+    for cell in ws[2]:
+        cell.fill = example_fill
+        
+    for cell in ws[3]:
+        cell.fill = desc_fill
+        
+    # Auto-fit columns
+    for col_idx, col in enumerate(COLUMNS, 1):
+        col_letter = get_column_letter(col_idx)
+        max_length = max(len(str(col["header"])), len(str(col["desc"])), len(str(EXAMPLE_ROW[col_idx-1])))
+        ws.column_dimensions[col_letter].width = max_length + 2
+        
+    # Data Validation
+    # base_unit is column 6 (F)
+    dv_base_unit = DataValidation(type="list", formula1=f'"{",".join(BASE_UNITS)}"', allow_blank=False)
+    ws.add_data_validation(dv_base_unit)
+    dv_base_unit.add(f"F4:F1000")
+    
+    # dosage_form is column 11 (K)
+    dv_dosage_form = DataValidation(type="list", formula1=f'"{",".join(DOSAGE_FORMS)}"', allow_blank=True)
+    ws.add_data_validation(dv_dosage_form)
+    dv_dosage_form.add(f"K4:K1000")
+    
+    bio = io.BytesIO()
+    wb.save(bio)
+    bio.seek(0)
+    return bio

package/backend/app/modules/notifications/__init__.py

@@ -0,0 +1 @@
+# Notifications module

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

@@ -0,0 +1,15 @@
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy import String, Boolean, ForeignKey, Text
+from app.core.database import Base
+import uuid
+
+class Notification(Base):
+    __tablename__ = "notifications"
+    user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"), nullable=True)
+    type: Mapped[str] = mapped_column(String)  # info, warning, danger, success
+    title: Mapped[str] = mapped_column(String)
+    title_ar: Mapped[str] = mapped_column(String, nullable=True)
+    message: Mapped[str] = mapped_column(Text)
+    message_ar: Mapped[str] = mapped_column(Text, nullable=True)
+    link: Mapped[str] = mapped_column(String, nullable=True)
+    is_read: Mapped[bool] = mapped_column(Boolean, default=False)

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

@@ -0,0 +1,89 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, update, delete, func, or_
+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.notifications.models import Notification
+from app.modules.notifications.schemas import NotificationResponse, UnreadCountResponse
+
+router = APIRouter(tags=["Notifications"])
+
+@router.get("/", response_model=List[NotificationResponse])
+async def get_notifications(
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    stmt = (
+        select(Notification)
+        .where(or_(Notification.user_id == current_user.id, Notification.user_id == None))
+        .order_by(Notification.created_at.desc())
+        .limit(50)
+    )
+    result = await db.execute(stmt)
+    return result.scalars().all()
+
+@router.get("/unread-count", response_model=UnreadCountResponse)
+async def get_unread_count(
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    stmt = (
+        select(func.count(Notification.id))
+        .where(
+            or_(Notification.user_id == current_user.id, Notification.user_id == None),
+            Notification.is_read == False
+        )
+    )
+    result = await db.execute(stmt)
+    count = result.scalar() or 0
+    return {"unread_count": count}
+
+@router.patch("/{id}/read")
+async def mark_as_read(
+    id: UUID,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    stmt = (
+        update(Notification)
+        .where(Notification.id == id)
+        .where(or_(Notification.user_id == current_user.id, Notification.user_id == None))
+        .values(is_read=True)
+    )
+    await db.execute(stmt)
+    await db.commit()
+    return {"status": "success"}
+
+@router.post("/read-all")
+async def mark_all_as_read(
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    stmt = (
+        update(Notification)
+        .where(or_(Notification.user_id == current_user.id, Notification.user_id == None))
+        .where(Notification.is_read == False)
+        .values(is_read=True)
+    )
+    await db.execute(stmt)
+    await db.commit()
+    return {"status": "success"}
+
+@router.delete("/{id}")
+async def delete_notification(
+    id: UUID,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    stmt = (
+        delete(Notification)
+        .where(Notification.id == id)
+        .where(or_(Notification.user_id == current_user.id, Notification.user_id == None))
+    )
+    await db.execute(stmt)
+    await db.commit()
+    return {"status": "success"}

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

@@ -0,0 +1,22 @@
+from pydantic import BaseModel, ConfigDict
+from typing import Optional
+from datetime import datetime
+from uuid import UUID
+
+class NotificationResponse(BaseModel):
+    id: UUID
+    user_id: Optional[UUID] = None
+    type: str
+    title: str
+    title_ar: Optional[str] = None
+    message: str
+    message_ar: Optional[str] = None
+    link: Optional[str] = None
+    is_read: bool
+    created_at: datetime
+    updated_at: datetime
+    
+    model_config = ConfigDict(from_attributes=True)
+
+class UnreadCountResponse(BaseModel):
+    unread_count: int

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

@@ -0,0 +1,16 @@
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy import String, Boolean
+from app.core.database import Base
+
+class Branch(Base):
+    __tablename__ = "branches"
+    name: Mapped[str] = mapped_column(String)
+    name_ar: Mapped[str] = mapped_column(String, nullable=True)
+    code: Mapped[str] = mapped_column(String, unique=True)
+    address: Mapped[str] = mapped_column(String, nullable=True)
+    phone: Mapped[str] = mapped_column(String, nullable=True)
+    email: Mapped[str] = mapped_column(String, nullable=True)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
+    currency: Mapped[str] = mapped_column(String, default="SAR")
+    timezone: Mapped[str] = mapped_column(String, default="Asia/Riyadh")
+    locale: Mapped[str] = mapped_column(String, default="ar_SA")

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

@@ -0,0 +1,49 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from typing import List
+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.organizations.models import Branch
+from app.modules.organizations.schemas import BranchCreate, BranchUpdate, BranchResponse
+
+router = APIRouter()
+
+@router.post("/", response_model=BranchResponse)
+async def create_branch(branch: BranchCreate, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    db_branch = Branch(**branch.model_dump())
+    db.add(db_branch)
+    await db.commit()
+    await db.refresh(db_branch)
+    return db_branch
+
+@router.get("/", response_model=List[BranchResponse])
+async def list_branches(db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    result = await db.execute(select(Branch))
+    return result.scalars().all()
+
+@router.get("/{id}", response_model=BranchResponse)
+async def get_branch(id: uuid.UUID, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    result = await db.execute(select(Branch).where(Branch.id == id))
+    branch = result.scalar_one_or_none()
+    if not branch:
+        raise HTTPException(status_code=404, detail="Branch not found")
+    return branch
+
+@router.put("/{id}", response_model=BranchResponse)
+async def update_branch(id: uuid.UUID, branch: BranchUpdate, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+    result = await db.execute(select(Branch).where(Branch.id == id))
+    db_branch = result.scalar_one_or_none()
+    if not db_branch:
+        raise HTTPException(status_code=404, detail="Branch not found")
+    
+    update_data = branch.model_dump(exclude_unset=True)
+    for key, value in update_data.items():
+        setattr(db_branch, key, value)
+        
+    await db.commit()
+    await db.refresh(db_branch)
+    return db_branch

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

@@ -0,0 +1,31 @@
+from pydantic import BaseModel, EmailStr
+from typing import Optional
+import uuid
+
+class BranchCreate(BaseModel):
+    name: str
+    code: str
+    name_ar: Optional[str] = None
+    address: Optional[str] = None
+    phone: Optional[str] = None
+    email: Optional[EmailStr] = None
+    currency: str = "SAR"
+    timezone: str = "Asia/Riyadh"
+    locale: str = "ar_SA"
+
+class BranchUpdate(BaseModel):
+    name: Optional[str] = None
+    code: Optional[str] = None
+    name_ar: Optional[str] = None
+    address: Optional[str] = None
+    phone: Optional[str] = None
+    email: Optional[EmailStr] = None
+    currency: Optional[str] = None
+    timezone: Optional[str] = None
+    locale: Optional[str] = None
+    is_active: Optional[bool] = None
+
+class BranchResponse(BranchCreate):
+    id: uuid.UUID
+    is_active: bool
+    model_config = {"from_attributes": True}