240 lines
8.8 KiB
Python
240 lines
8.8 KiB
Python
"""
|
|
POS Transaction Service - Business Logic Layer
|
|
"""
|
|
|
|
from typing import List, Optional, Dict, Any
|
|
from uuid import UUID
|
|
from datetime import datetime
|
|
from decimal import Decimal
|
|
import structlog
|
|
|
|
from app.repositories.pos_transaction_repository import POSTransactionRepository
|
|
from app.repositories.pos_transaction_item_repository import POSTransactionItemRepository
|
|
from app.schemas.pos_transaction import (
|
|
POSTransactionResponse,
|
|
POSTransactionDashboardSummary
|
|
)
|
|
from app.core.database import get_db_transaction
|
|
|
|
logger = structlog.get_logger()
|
|
|
|
|
|
class POSTransactionService:
|
|
"""Service layer for POS transaction operations"""
|
|
|
|
def __init__(self):
|
|
pass
|
|
|
|
async def get_transactions_by_tenant(
|
|
self,
|
|
tenant_id: UUID,
|
|
pos_system: Optional[str] = None,
|
|
start_date: Optional[datetime] = None,
|
|
end_date: Optional[datetime] = None,
|
|
status: Optional[str] = None,
|
|
is_synced: Optional[bool] = None,
|
|
skip: int = 0,
|
|
limit: int = 50
|
|
) -> List[POSTransactionResponse]:
|
|
"""Get POS transactions for a tenant with filtering"""
|
|
try:
|
|
async with get_db_transaction() as db:
|
|
repository = POSTransactionRepository(db)
|
|
|
|
transactions = await repository.get_transactions_by_tenant(
|
|
tenant_id=tenant_id,
|
|
pos_system=pos_system,
|
|
start_date=start_date,
|
|
end_date=end_date,
|
|
status=status,
|
|
is_synced=is_synced,
|
|
skip=skip,
|
|
limit=limit
|
|
)
|
|
|
|
# Convert to response schemas
|
|
responses = []
|
|
for transaction in transactions:
|
|
response = POSTransactionResponse.from_orm(transaction)
|
|
responses.append(response)
|
|
|
|
return responses
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to get transactions by tenant", error=str(e), tenant_id=tenant_id)
|
|
raise
|
|
|
|
async def count_transactions_by_tenant(
|
|
self,
|
|
tenant_id: UUID,
|
|
pos_system: Optional[str] = None,
|
|
start_date: Optional[datetime] = None,
|
|
end_date: Optional[datetime] = None,
|
|
status: Optional[str] = None,
|
|
is_synced: Optional[bool] = None
|
|
) -> int:
|
|
"""Count POS transactions for a tenant with filtering"""
|
|
try:
|
|
async with get_db_transaction() as db:
|
|
repository = POSTransactionRepository(db)
|
|
|
|
count = await repository.count_transactions_by_tenant(
|
|
tenant_id=tenant_id,
|
|
pos_system=pos_system,
|
|
start_date=start_date,
|
|
end_date=end_date,
|
|
status=status,
|
|
is_synced=is_synced
|
|
)
|
|
|
|
return count
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to count transactions by tenant", error=str(e), tenant_id=tenant_id)
|
|
raise
|
|
|
|
async def get_transaction_with_items(
|
|
self,
|
|
transaction_id: UUID,
|
|
tenant_id: UUID
|
|
) -> Optional[POSTransactionResponse]:
|
|
"""Get transaction with all its items"""
|
|
try:
|
|
async with get_db_transaction() as db:
|
|
repository = POSTransactionRepository(db)
|
|
|
|
transaction = await repository.get_transaction_with_items(
|
|
transaction_id=transaction_id,
|
|
tenant_id=tenant_id
|
|
)
|
|
|
|
if not transaction:
|
|
return None
|
|
|
|
return POSTransactionResponse.from_orm(transaction)
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to get transaction with items",
|
|
transaction_id=str(transaction_id),
|
|
error=str(e))
|
|
raise
|
|
|
|
async def get_dashboard_summary(
|
|
self,
|
|
tenant_id: UUID
|
|
) -> POSTransactionDashboardSummary:
|
|
"""Get dashboard summary for POS transactions"""
|
|
try:
|
|
async with get_db_transaction() as db:
|
|
repository = POSTransactionRepository(db)
|
|
|
|
# Get metrics from repository
|
|
metrics = await repository.get_dashboard_metrics(tenant_id)
|
|
|
|
# Get sync status
|
|
sync_status = await repository.get_sync_status_summary(tenant_id)
|
|
|
|
# Construct dashboard summary
|
|
return POSTransactionDashboardSummary(
|
|
total_transactions_today=metrics["total_transactions_today"],
|
|
total_transactions_this_week=metrics["total_transactions_this_week"],
|
|
total_transactions_this_month=metrics["total_transactions_this_month"],
|
|
revenue_today=Decimal(str(metrics["revenue_today"])),
|
|
revenue_this_week=Decimal(str(metrics["revenue_this_week"])),
|
|
revenue_this_month=Decimal(str(metrics["revenue_this_month"])),
|
|
average_transaction_value=Decimal(str(metrics["average_transaction_value"])),
|
|
status_breakdown=metrics["status_breakdown"],
|
|
payment_method_breakdown=metrics["payment_method_breakdown"],
|
|
sync_status=sync_status
|
|
)
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to get dashboard summary", error=str(e), tenant_id=tenant_id)
|
|
raise
|
|
|
|
async def get_sync_metrics(
|
|
self,
|
|
tenant_id: UUID
|
|
) -> Dict[str, Any]:
|
|
"""Get sync metrics for transactions"""
|
|
try:
|
|
async with get_db_transaction() as db:
|
|
repository = POSTransactionRepository(db)
|
|
|
|
sync_status = await repository.get_sync_status_summary(tenant_id)
|
|
|
|
# Calculate sync rate
|
|
total = sync_status["synced"] + sync_status["pending"] + sync_status["failed"]
|
|
sync_rate = (sync_status["synced"] / total * 100) if total > 0 else 0
|
|
|
|
return {
|
|
"sync_status": sync_status,
|
|
"sync_rate_percentage": round(sync_rate, 2),
|
|
"total_transactions": total
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to get sync metrics", error=str(e), tenant_id=tenant_id)
|
|
raise
|
|
|
|
async def calculate_transaction_analytics(
|
|
self,
|
|
tenant_id: UUID,
|
|
start_date: datetime,
|
|
end_date: datetime
|
|
) -> Dict[str, Any]:
|
|
"""Calculate analytics for transactions within a date range"""
|
|
try:
|
|
async with get_db_transaction() as db:
|
|
repository = POSTransactionRepository(db)
|
|
|
|
transactions = await repository.get_transactions_by_date_range(
|
|
tenant_id=tenant_id,
|
|
start_date=start_date.date(),
|
|
end_date=end_date.date(),
|
|
skip=0,
|
|
limit=10000 # Large limit for analytics
|
|
)
|
|
|
|
# Calculate analytics
|
|
total_revenue = Decimal("0")
|
|
total_transactions = len(transactions)
|
|
payment_methods = {}
|
|
order_types = {}
|
|
hourly_distribution = {}
|
|
|
|
for transaction in transactions:
|
|
if transaction.status == "completed":
|
|
total_revenue += transaction.total_amount
|
|
|
|
# Payment method breakdown
|
|
pm = transaction.payment_method or "unknown"
|
|
payment_methods[pm] = payment_methods.get(pm, 0) + 1
|
|
|
|
# Order type breakdown
|
|
ot = transaction.order_type or "unknown"
|
|
order_types[ot] = order_types.get(ot, 0) + 1
|
|
|
|
# Hourly distribution
|
|
hour = transaction.transaction_date.hour
|
|
hourly_distribution[hour] = hourly_distribution.get(hour, 0) + 1
|
|
|
|
avg_transaction_value = (total_revenue / total_transactions) if total_transactions > 0 else Decimal("0")
|
|
|
|
return {
|
|
"period": {
|
|
"start_date": start_date.isoformat(),
|
|
"end_date": end_date.isoformat()
|
|
},
|
|
"total_revenue": float(total_revenue),
|
|
"total_transactions": total_transactions,
|
|
"average_transaction_value": float(avg_transaction_value),
|
|
"payment_methods": payment_methods,
|
|
"order_types": order_types,
|
|
"hourly_distribution": hourly_distribution
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to calculate transaction analytics", error=str(e), tenant_id=tenant_id)
|
|
raise
|