239 lines
9.1 KiB
Python
239 lines
9.1 KiB
Python
# services/inventory/app/repositories/ingredient_repository.py
|
|
"""
|
|
Ingredient Repository using Repository Pattern
|
|
"""
|
|
|
|
from typing import List, Optional, Dict, Any
|
|
from uuid import UUID
|
|
from datetime import datetime
|
|
from sqlalchemy import select, func, and_, or_, desc, asc
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
import structlog
|
|
|
|
from app.models.inventory import Ingredient, Stock
|
|
from app.schemas.inventory import IngredientCreate, IngredientUpdate
|
|
from shared.database.repository import BaseRepository
|
|
|
|
logger = structlog.get_logger()
|
|
|
|
|
|
class IngredientRepository(BaseRepository[Ingredient, IngredientCreate, IngredientUpdate]):
|
|
"""Repository for ingredient operations"""
|
|
|
|
def __init__(self, session: AsyncSession):
|
|
super().__init__(Ingredient, session)
|
|
|
|
async def create_ingredient(self, ingredient_data: IngredientCreate, tenant_id: UUID) -> Ingredient:
|
|
"""Create a new ingredient"""
|
|
try:
|
|
# Prepare data
|
|
create_data = ingredient_data.model_dump()
|
|
create_data['tenant_id'] = tenant_id
|
|
|
|
# Create record
|
|
record = await self.create(create_data)
|
|
logger.info(
|
|
"Created ingredient",
|
|
ingredient_id=record.id,
|
|
name=record.name,
|
|
category=record.category.value if record.category else None,
|
|
tenant_id=tenant_id
|
|
)
|
|
return record
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to create ingredient", error=str(e), tenant_id=tenant_id)
|
|
raise
|
|
|
|
async def get_ingredients_by_tenant(
|
|
self,
|
|
tenant_id: UUID,
|
|
skip: int = 0,
|
|
limit: int = 100,
|
|
filters: Optional[Dict[str, Any]] = None
|
|
) -> List[Ingredient]:
|
|
"""Get ingredients for a tenant with filtering"""
|
|
try:
|
|
query_filters = {'tenant_id': tenant_id}
|
|
if filters:
|
|
if filters.get('category'):
|
|
query_filters['category'] = filters['category']
|
|
if filters.get('is_active') is not None:
|
|
query_filters['is_active'] = filters['is_active']
|
|
if filters.get('is_perishable') is not None:
|
|
query_filters['is_perishable'] = filters['is_perishable']
|
|
|
|
ingredients = await self.get_multi(
|
|
skip=skip,
|
|
limit=limit,
|
|
filters=query_filters,
|
|
order_by='name'
|
|
)
|
|
return ingredients
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to get ingredients", error=str(e), tenant_id=tenant_id)
|
|
raise
|
|
|
|
async def search_ingredients(
|
|
self,
|
|
tenant_id: UUID,
|
|
search_term: str,
|
|
skip: int = 0,
|
|
limit: int = 50
|
|
) -> List[Ingredient]:
|
|
"""Search ingredients by name, sku, or barcode"""
|
|
try:
|
|
# Add tenant filter to search
|
|
query = select(self.model).where(
|
|
and_(
|
|
self.model.tenant_id == tenant_id,
|
|
or_(
|
|
self.model.name.ilike(f"%{search_term}%"),
|
|
self.model.sku.ilike(f"%{search_term}%"),
|
|
self.model.barcode.ilike(f"%{search_term}%"),
|
|
self.model.brand.ilike(f"%{search_term}%")
|
|
)
|
|
)
|
|
).offset(skip).limit(limit)
|
|
|
|
result = await self.session.execute(query)
|
|
return result.scalars().all()
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to search ingredients", error=str(e), tenant_id=tenant_id)
|
|
raise
|
|
|
|
async def get_low_stock_ingredients(self, tenant_id: UUID) -> List[Dict[str, Any]]:
|
|
"""Get ingredients with low stock levels"""
|
|
try:
|
|
# Query ingredients with their current stock levels
|
|
query = select(
|
|
Ingredient,
|
|
func.coalesce(func.sum(Stock.available_quantity), 0).label('current_stock')
|
|
).outerjoin(
|
|
Stock, and_(
|
|
Stock.ingredient_id == Ingredient.id,
|
|
Stock.is_available == True
|
|
)
|
|
).where(
|
|
Ingredient.tenant_id == tenant_id
|
|
).group_by(Ingredient.id).having(
|
|
func.coalesce(func.sum(Stock.available_quantity), 0) <= Ingredient.low_stock_threshold
|
|
)
|
|
|
|
result = await self.session.execute(query)
|
|
results = []
|
|
|
|
for ingredient, current_stock in result:
|
|
results.append({
|
|
'ingredient': ingredient,
|
|
'current_stock': float(current_stock) if current_stock else 0.0,
|
|
'threshold': ingredient.low_stock_threshold,
|
|
'needs_reorder': current_stock <= ingredient.reorder_point if current_stock else True
|
|
})
|
|
|
|
return results
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to get low stock ingredients", error=str(e), tenant_id=tenant_id)
|
|
raise
|
|
|
|
async def get_ingredients_needing_reorder(self, tenant_id: UUID) -> List[Dict[str, Any]]:
|
|
"""Get ingredients that need reordering"""
|
|
try:
|
|
query = select(
|
|
Ingredient,
|
|
func.coalesce(func.sum(Stock.available_quantity), 0).label('current_stock')
|
|
).outerjoin(
|
|
Stock, and_(
|
|
Stock.ingredient_id == Ingredient.id,
|
|
Stock.is_available == True
|
|
)
|
|
).where(
|
|
and_(
|
|
Ingredient.tenant_id == tenant_id,
|
|
Ingredient.is_active == True
|
|
)
|
|
).group_by(Ingredient.id).having(
|
|
func.coalesce(func.sum(Stock.available_quantity), 0) <= Ingredient.reorder_point
|
|
)
|
|
|
|
result = await self.session.execute(query)
|
|
results = []
|
|
|
|
for ingredient, current_stock in result:
|
|
results.append({
|
|
'ingredient': ingredient,
|
|
'current_stock': float(current_stock) if current_stock else 0.0,
|
|
'reorder_point': ingredient.reorder_point,
|
|
'reorder_quantity': ingredient.reorder_quantity
|
|
})
|
|
|
|
return results
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to get ingredients needing reorder", error=str(e), tenant_id=tenant_id)
|
|
raise
|
|
|
|
async def get_by_sku(self, tenant_id: UUID, sku: str) -> Optional[Ingredient]:
|
|
"""Get ingredient by SKU"""
|
|
try:
|
|
result = await self.session.execute(
|
|
select(self.model).where(
|
|
and_(
|
|
self.model.tenant_id == tenant_id,
|
|
self.model.sku == sku
|
|
)
|
|
)
|
|
)
|
|
return result.scalar_one_or_none()
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to get ingredient by SKU", error=str(e), sku=sku, tenant_id=tenant_id)
|
|
raise
|
|
|
|
async def get_by_barcode(self, tenant_id: UUID, barcode: str) -> Optional[Ingredient]:
|
|
"""Get ingredient by barcode"""
|
|
try:
|
|
result = await self.session.execute(
|
|
select(self.model).where(
|
|
and_(
|
|
self.model.tenant_id == tenant_id,
|
|
self.model.barcode == barcode
|
|
)
|
|
)
|
|
)
|
|
return result.scalar_one_or_none()
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to get ingredient by barcode", error=str(e), barcode=barcode, tenant_id=tenant_id)
|
|
raise
|
|
|
|
async def update_last_purchase_price(self, ingredient_id: UUID, price: float) -> Optional[Ingredient]:
|
|
"""Update the last purchase price for an ingredient"""
|
|
try:
|
|
update_data = {'last_purchase_price': price}
|
|
return await self.update(ingredient_id, update_data)
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to update last purchase price", error=str(e), ingredient_id=ingredient_id)
|
|
raise
|
|
|
|
async def get_ingredients_by_category(self, tenant_id: UUID, category: str) -> List[Ingredient]:
|
|
"""Get all ingredients in a specific category"""
|
|
try:
|
|
result = await self.session.execute(
|
|
select(self.model).where(
|
|
and_(
|
|
self.model.tenant_id == tenant_id,
|
|
self.model.category == category,
|
|
self.model.is_active == True
|
|
)
|
|
).order_by(self.model.name)
|
|
)
|
|
return result.scalars().all()
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to get ingredients by category", error=str(e), category=category, tenant_id=tenant_id)
|
|
raise |