441 lines
16 KiB
Python
441 lines
16 KiB
Python
# services/suppliers/app/repositories/supplier_repository.py
|
|
"""
|
|
Supplier repository for database operations
|
|
"""
|
|
|
|
from typing import List, Optional, Dict, Any
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy import and_, or_, func, select
|
|
from uuid import UUID
|
|
from datetime import datetime
|
|
|
|
from app.models.suppliers import Supplier, SupplierStatus, SupplierType
|
|
from app.repositories.base import BaseRepository
|
|
|
|
|
|
class SupplierRepository(BaseRepository[Supplier]):
|
|
"""Repository for supplier management operations"""
|
|
|
|
def __init__(self, db: AsyncSession):
|
|
super().__init__(Supplier, db)
|
|
|
|
async def get_by_name(self, tenant_id: UUID, name: str) -> Optional[Supplier]:
|
|
"""Get supplier by name within tenant"""
|
|
stmt = select(self.model).filter(
|
|
and_(
|
|
self.model.tenant_id == tenant_id,
|
|
self.model.name == name
|
|
)
|
|
)
|
|
result = await self.db.execute(stmt)
|
|
return result.scalar_one_or_none()
|
|
|
|
async def get_by_supplier_code(self, tenant_id: UUID, supplier_code: str) -> Optional[Supplier]:
|
|
"""Get supplier by supplier code within tenant"""
|
|
stmt = select(self.model).filter(
|
|
and_(
|
|
self.model.tenant_id == tenant_id,
|
|
self.model.supplier_code == supplier_code
|
|
)
|
|
)
|
|
result = await self.db.execute(stmt)
|
|
return result.scalar_one_or_none()
|
|
|
|
async def search_suppliers(
|
|
self,
|
|
tenant_id: UUID,
|
|
search_term: Optional[str] = None,
|
|
supplier_type: Optional[SupplierType] = None,
|
|
status: Optional[SupplierStatus] = None,
|
|
limit: int = 50,
|
|
offset: int = 0
|
|
) -> List[Supplier]:
|
|
"""Search suppliers with filters"""
|
|
stmt = select(self.model).filter(self.model.tenant_id == tenant_id)
|
|
|
|
# Search term filter (name, contact person, email)
|
|
if search_term:
|
|
search_filter = or_(
|
|
self.model.name.ilike(f"%{search_term}%"),
|
|
self.model.contact_person.ilike(f"%{search_term}%"),
|
|
self.model.email.ilike(f"%{search_term}%")
|
|
)
|
|
stmt = stmt.filter(search_filter)
|
|
|
|
# Type filter
|
|
if supplier_type:
|
|
stmt = stmt.filter(self.model.supplier_type == supplier_type)
|
|
|
|
# Status filter
|
|
if status:
|
|
stmt = stmt.filter(self.model.status == status)
|
|
|
|
stmt = stmt.order_by(self.model.name).limit(limit).offset(offset)
|
|
result = await self.db.execute(stmt)
|
|
return result.scalars().all()
|
|
|
|
async def get_active_suppliers(self, tenant_id: UUID) -> List[Supplier]:
|
|
"""Get all active suppliers for a tenant"""
|
|
stmt = select(self.model).filter(
|
|
and_(
|
|
self.model.tenant_id == tenant_id,
|
|
self.model.status == SupplierStatus.active
|
|
)
|
|
).order_by(self.model.name)
|
|
result = await self.db.execute(stmt)
|
|
return result.scalars().all()
|
|
|
|
def get_suppliers_by_type(
|
|
self,
|
|
tenant_id: UUID,
|
|
supplier_type: SupplierType
|
|
) -> List[Supplier]:
|
|
"""Get suppliers by type"""
|
|
return (
|
|
self.db.query(self.model)
|
|
.filter(
|
|
and_(
|
|
self.model.tenant_id == tenant_id,
|
|
self.model.supplier_type == supplier_type,
|
|
self.model.status == SupplierStatus.active
|
|
)
|
|
)
|
|
.order_by(self.model.quality_rating.desc(), self.model.name)
|
|
.all()
|
|
)
|
|
|
|
def get_top_suppliers(
|
|
self,
|
|
tenant_id: UUID,
|
|
limit: int = 10
|
|
) -> List[Supplier]:
|
|
"""Get top suppliers by quality rating and order value"""
|
|
return (
|
|
self.db.query(self.model)
|
|
.filter(
|
|
and_(
|
|
self.model.tenant_id == tenant_id,
|
|
self.model.status == SupplierStatus.active
|
|
)
|
|
)
|
|
.order_by(
|
|
self.model.quality_rating.desc(),
|
|
self.model.total_amount.desc()
|
|
)
|
|
.limit(limit)
|
|
.all()
|
|
)
|
|
|
|
def update_supplier_stats(
|
|
self,
|
|
supplier_id: UUID,
|
|
total_orders_increment: int = 0,
|
|
total_amount_increment: float = 0.0,
|
|
new_quality_rating: Optional[float] = None,
|
|
new_delivery_rating: Optional[float] = None
|
|
) -> Optional[Supplier]:
|
|
"""Update supplier performance statistics"""
|
|
supplier = self.get_by_id(supplier_id)
|
|
if not supplier:
|
|
return None
|
|
|
|
# Update counters
|
|
if total_orders_increment:
|
|
supplier.total_orders += total_orders_increment
|
|
|
|
if total_amount_increment:
|
|
supplier.total_amount += total_amount_increment
|
|
|
|
# Update ratings (these should be calculated averages)
|
|
if new_quality_rating is not None:
|
|
supplier.quality_rating = new_quality_rating
|
|
|
|
if new_delivery_rating is not None:
|
|
supplier.delivery_rating = new_delivery_rating
|
|
|
|
supplier.updated_at = datetime.utcnow()
|
|
|
|
self.db.commit()
|
|
self.db.refresh(supplier)
|
|
return supplier
|
|
|
|
def get_suppliers_needing_review(
|
|
self,
|
|
tenant_id: UUID,
|
|
days_since_last_order: int = 30
|
|
) -> List[Supplier]:
|
|
"""Get suppliers that may need performance review"""
|
|
from datetime import datetime, timedelta
|
|
cutoff_date = datetime.utcnow() - timedelta(days=days_since_last_order)
|
|
|
|
return (
|
|
self.db.query(self.model)
|
|
.filter(
|
|
and_(
|
|
self.model.tenant_id == tenant_id,
|
|
self.model.status == SupplierStatus.active,
|
|
or_(
|
|
self.model.quality_rating < 3.0, # Poor rating
|
|
self.model.delivery_rating < 3.0, # Poor delivery
|
|
self.model.updated_at < cutoff_date # Long time since interaction
|
|
)
|
|
)
|
|
)
|
|
.order_by(self.model.quality_rating.asc())
|
|
.all()
|
|
)
|
|
|
|
async def get_supplier_statistics(self, tenant_id: UUID) -> Dict[str, Any]:
|
|
"""Get supplier statistics for dashboard"""
|
|
total_suppliers = await self.count_by_tenant(tenant_id)
|
|
|
|
# Get all suppliers for this tenant to avoid multiple queries and enum casting issues
|
|
all_stmt = select(self.model).filter(self.model.tenant_id == tenant_id)
|
|
all_result = await self.db.execute(all_stmt)
|
|
all_suppliers = all_result.scalars().all()
|
|
|
|
# Calculate statistics in Python to avoid database enum casting issues
|
|
active_suppliers = [s for s in all_suppliers if s.status == SupplierStatus.active]
|
|
pending_suppliers = [s for s in all_suppliers if s.status == SupplierStatus.pending_approval]
|
|
|
|
# Calculate averages from active suppliers
|
|
quality_ratings = [s.quality_rating for s in active_suppliers if s.quality_rating and s.quality_rating > 0]
|
|
avg_quality_rating = sum(quality_ratings) / len(quality_ratings) if quality_ratings else 0.0
|
|
|
|
delivery_ratings = [s.delivery_rating for s in active_suppliers if s.delivery_rating and s.delivery_rating > 0]
|
|
avg_delivery_rating = sum(delivery_ratings) / len(delivery_ratings) if delivery_ratings else 0.0
|
|
|
|
# Total spend for all suppliers
|
|
total_spend = sum(float(s.total_amount or 0) for s in all_suppliers)
|
|
|
|
return {
|
|
"total_suppliers": total_suppliers,
|
|
"active_suppliers": len(active_suppliers),
|
|
"pending_suppliers": len(pending_suppliers),
|
|
"avg_quality_rating": round(float(avg_quality_rating), 2),
|
|
"avg_delivery_rating": round(float(avg_delivery_rating), 2),
|
|
"total_spend": float(total_spend)
|
|
}
|
|
|
|
async def approve_supplier(
|
|
self,
|
|
supplier_id: UUID,
|
|
approved_by: UUID,
|
|
approval_date: Optional[datetime] = None
|
|
) -> Optional[Supplier]:
|
|
"""Approve a pending supplier"""
|
|
supplier = await self.get_by_id(supplier_id)
|
|
if not supplier or supplier.status != SupplierStatus.pending_approval:
|
|
return None
|
|
|
|
supplier.status = SupplierStatus.active
|
|
supplier.approved_by = approved_by
|
|
supplier.approved_at = approval_date or datetime.utcnow()
|
|
supplier.rejection_reason = None
|
|
supplier.updated_at = datetime.utcnow()
|
|
|
|
await self.db.commit()
|
|
await self.db.refresh(supplier)
|
|
return supplier
|
|
|
|
async def reject_supplier(
|
|
self,
|
|
supplier_id: UUID,
|
|
rejection_reason: str,
|
|
approved_by: UUID
|
|
) -> Optional[Supplier]:
|
|
"""Reject a pending supplier"""
|
|
supplier = await self.get_by_id(supplier_id)
|
|
if not supplier or supplier.status != SupplierStatus.pending_approval:
|
|
return None
|
|
|
|
supplier.status = SupplierStatus.inactive
|
|
supplier.rejection_reason = rejection_reason
|
|
supplier.approved_by = approved_by
|
|
supplier.approved_at = datetime.utcnow()
|
|
supplier.updated_at = datetime.utcnow()
|
|
|
|
await self.db.commit()
|
|
await self.db.refresh(supplier)
|
|
return supplier
|
|
async def hard_delete_supplier(self, supplier_id: UUID) -> Dict[str, Any]:
|
|
"""
|
|
Hard delete supplier and all associated data
|
|
Returns counts of deleted records
|
|
"""
|
|
from app.models.suppliers import (
|
|
SupplierPriceList, SupplierQualityReview,
|
|
SupplierAlert, SupplierScorecard, PurchaseOrderStatus, PurchaseOrder
|
|
)
|
|
from app.models.performance import SupplierPerformanceMetric
|
|
from sqlalchemy import delete
|
|
|
|
# Get supplier first
|
|
supplier = await self.get_by_id(supplier_id)
|
|
if not supplier:
|
|
return None
|
|
|
|
# Check for active purchase orders (block deletion if any exist)
|
|
active_statuses = [
|
|
PurchaseOrderStatus.draft,
|
|
PurchaseOrderStatus.pending_approval,
|
|
PurchaseOrderStatus.approved,
|
|
PurchaseOrderStatus.sent_to_supplier,
|
|
PurchaseOrderStatus.confirmed
|
|
]
|
|
|
|
stmt = select(PurchaseOrder).where(
|
|
PurchaseOrder.supplier_id == supplier_id,
|
|
PurchaseOrder.status.in_(active_statuses)
|
|
)
|
|
result = await self.db.execute(stmt)
|
|
active_pos = result.scalars().all()
|
|
|
|
if active_pos:
|
|
raise ValueError(
|
|
f"Cannot delete supplier with {len(active_pos)} active purchase orders. "
|
|
"Complete or cancel all purchase orders first."
|
|
)
|
|
|
|
# Count related records before deletion
|
|
stmt = select(SupplierPriceList).where(SupplierPriceList.supplier_id == supplier_id)
|
|
result = await self.db.execute(stmt)
|
|
price_lists_count = len(result.scalars().all())
|
|
|
|
stmt = select(SupplierQualityReview).where(SupplierQualityReview.supplier_id == supplier_id)
|
|
result = await self.db.execute(stmt)
|
|
quality_reviews_count = len(result.scalars().all())
|
|
|
|
stmt = select(SupplierPerformanceMetric).where(SupplierPerformanceMetric.supplier_id == supplier_id)
|
|
result = await self.db.execute(stmt)
|
|
metrics_count = len(result.scalars().all())
|
|
|
|
stmt = select(SupplierAlert).where(SupplierAlert.supplier_id == supplier_id)
|
|
result = await self.db.execute(stmt)
|
|
alerts_count = len(result.scalars().all())
|
|
|
|
stmt = select(SupplierScorecard).where(SupplierScorecard.supplier_id == supplier_id)
|
|
result = await self.db.execute(stmt)
|
|
scorecards_count = len(result.scalars().all())
|
|
|
|
# Delete related records (in reverse dependency order)
|
|
stmt = delete(SupplierScorecard).where(SupplierScorecard.supplier_id == supplier_id)
|
|
await self.db.execute(stmt)
|
|
|
|
stmt = delete(SupplierAlert).where(SupplierAlert.supplier_id == supplier_id)
|
|
await self.db.execute(stmt)
|
|
|
|
stmt = delete(SupplierPerformanceMetric).where(SupplierPerformanceMetric.supplier_id == supplier_id)
|
|
await self.db.execute(stmt)
|
|
|
|
stmt = delete(SupplierQualityReview).where(SupplierQualityReview.supplier_id == supplier_id)
|
|
await self.db.execute(stmt)
|
|
|
|
stmt = delete(SupplierPriceList).where(SupplierPriceList.supplier_id == supplier_id)
|
|
await self.db.execute(stmt)
|
|
|
|
# Delete the supplier itself
|
|
await self.delete(supplier_id)
|
|
|
|
await self.db.commit()
|
|
|
|
return {
|
|
"supplier_name": supplier.name,
|
|
"deleted_price_lists": price_lists_count,
|
|
"deleted_quality_reviews": quality_reviews_count,
|
|
"deleted_performance_metrics": metrics_count,
|
|
"deleted_alerts": alerts_count,
|
|
"deleted_scorecards": scorecards_count,
|
|
"deletion_timestamp": datetime.utcnow()
|
|
}
|
|
|
|
async def get_supplier_price_lists(
|
|
self,
|
|
supplier_id: UUID,
|
|
tenant_id: UUID,
|
|
is_active: bool = True
|
|
) -> List[Any]:
|
|
"""Get all price list items for a supplier"""
|
|
from app.models.suppliers import SupplierPriceList
|
|
|
|
stmt = select(SupplierPriceList).filter(
|
|
and_(
|
|
SupplierPriceList.supplier_id == supplier_id,
|
|
SupplierPriceList.tenant_id == tenant_id
|
|
)
|
|
)
|
|
|
|
if is_active:
|
|
stmt = stmt.filter(SupplierPriceList.is_active == True)
|
|
|
|
result = await self.db.execute(stmt)
|
|
return result.scalars().all()
|
|
|
|
async def get_supplier_price_list(
|
|
self,
|
|
price_list_id: UUID,
|
|
tenant_id: UUID
|
|
) -> Optional[Any]:
|
|
"""Get specific price list item"""
|
|
from app.models.suppliers import SupplierPriceList
|
|
|
|
stmt = select(SupplierPriceList).filter(
|
|
and_(
|
|
SupplierPriceList.id == price_list_id,
|
|
SupplierPriceList.tenant_id == tenant_id
|
|
)
|
|
)
|
|
result = await self.db.execute(stmt)
|
|
return result.scalar_one_or_none()
|
|
|
|
async def create_supplier_price_list(
|
|
self,
|
|
create_data: Dict[str, Any]
|
|
) -> Any:
|
|
"""Create a new price list item"""
|
|
from app.models.suppliers import SupplierPriceList
|
|
|
|
price_list = SupplierPriceList(**create_data)
|
|
self.db.add(price_list)
|
|
await self.db.commit()
|
|
await self.db.refresh(price_list)
|
|
return price_list
|
|
|
|
async def update_supplier_price_list(
|
|
self,
|
|
price_list_id: UUID,
|
|
update_data: Dict[str, Any]
|
|
) -> Any:
|
|
"""Update a price list item"""
|
|
from app.models.suppliers import SupplierPriceList
|
|
|
|
stmt = select(SupplierPriceList).filter(SupplierPriceList.id == price_list_id)
|
|
result = await self.db.execute(stmt)
|
|
price_list = result.scalar_one_or_none()
|
|
|
|
if not price_list:
|
|
raise ValueError("Price list item not found")
|
|
|
|
# Update fields
|
|
for key, value in update_data.items():
|
|
if hasattr(price_list, key):
|
|
setattr(price_list, key, value)
|
|
|
|
await self.db.commit()
|
|
await self.db.refresh(price_list)
|
|
return price_list
|
|
|
|
async def delete_supplier_price_list(
|
|
self,
|
|
price_list_id: UUID
|
|
) -> bool:
|
|
"""Delete a price list item"""
|
|
from app.models.suppliers import SupplierPriceList
|
|
from sqlalchemy import delete
|
|
|
|
stmt = delete(SupplierPriceList).filter(SupplierPriceList.id == price_list_id)
|
|
result = await self.db.execute(stmt)
|
|
|
|
await self.db.commit()
|
|
return result.rowcount > 0
|