858 lines
30 KiB
Python
858 lines
30 KiB
Python
"""
|
|
POS Operations API Endpoints
|
|
BUSINESS layer - Sync operations, webhooks, reconciliation, and test connection
|
|
"""
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, Path, Query, Body, Request, Header
|
|
from typing import Optional, Dict, Any
|
|
from uuid import UUID
|
|
from datetime import datetime
|
|
import structlog
|
|
import json
|
|
|
|
from app.core.database import get_db
|
|
from shared.auth.decorators import get_current_user_dep
|
|
from shared.auth.access_control import require_user_role, admin_role_required, service_only_access
|
|
from shared.routing import RouteBuilder
|
|
from app.services.pos_transaction_service import POSTransactionService
|
|
from app.services.pos_config_service import POSConfigurationService
|
|
from app.services.pos_webhook_service import POSWebhookService
|
|
from app.services.pos_sync_service import POSSyncService
|
|
from app.services.tenant_deletion_service import POSTenantDeletionService
|
|
|
|
router = APIRouter()
|
|
logger = structlog.get_logger()
|
|
route_builder = RouteBuilder('pos')
|
|
|
|
|
|
# ============================================================================
|
|
# Sync Operations
|
|
# ============================================================================
|
|
|
|
@router.post(
|
|
route_builder.build_operations_route("sync"),
|
|
response_model=dict
|
|
)
|
|
@require_user_role(['member', 'admin', 'owner'])
|
|
async def trigger_sync(
|
|
sync_request: Dict[str, Any],
|
|
tenant_id: UUID = Path(...),
|
|
current_user: dict = Depends(get_current_user_dep),
|
|
db=Depends(get_db)
|
|
):
|
|
"""Trigger manual synchronization with POS system (Member+)"""
|
|
try:
|
|
sync_type = sync_request.get("sync_type", "incremental")
|
|
data_types = sync_request.get("data_types", ["transactions"])
|
|
config_id = sync_request.get("config_id")
|
|
|
|
if not config_id:
|
|
raise HTTPException(status_code=400, detail="config_id is required")
|
|
|
|
# Get POS configuration to determine system type
|
|
config_service = POSConfigurationService()
|
|
configs = await config_service.get_configurations_by_tenant(tenant_id, skip=0, limit=100)
|
|
config = next((c for c in configs if str(c.id) == str(config_id)), None)
|
|
|
|
if not config:
|
|
raise HTTPException(status_code=404, detail="POS configuration not found")
|
|
|
|
# Create sync job
|
|
sync_service = POSSyncService(db)
|
|
sync_log = await sync_service.create_sync_job(
|
|
tenant_id=tenant_id,
|
|
pos_config_id=UUID(config_id),
|
|
pos_system=config.pos_system,
|
|
sync_type=sync_type,
|
|
data_types=data_types
|
|
)
|
|
|
|
logger.info("Manual sync triggered",
|
|
tenant_id=tenant_id,
|
|
config_id=config_id,
|
|
sync_id=str(sync_log.id),
|
|
sync_type=sync_type,
|
|
user_id=current_user.get("user_id"))
|
|
|
|
return {
|
|
"message": "Sync triggered successfully",
|
|
"sync_id": str(sync_log.id),
|
|
"status": "queued",
|
|
"sync_type": sync_type,
|
|
"data_types": data_types,
|
|
"estimated_duration": "5-10 minutes"
|
|
}
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error("Failed to trigger sync", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(status_code=500, detail=f"Failed to trigger sync: {str(e)}")
|
|
|
|
|
|
@router.get(
|
|
route_builder.build_operations_route("sync-status"),
|
|
response_model=dict
|
|
)
|
|
@require_user_role(['viewer', 'member', 'admin', 'owner'])
|
|
async def get_sync_status(
|
|
tenant_id: UUID = Path(...),
|
|
config_id: Optional[UUID] = Query(None),
|
|
limit: int = Query(10, ge=1, le=100),
|
|
current_user: dict = Depends(get_current_user_dep),
|
|
db=Depends(get_db)
|
|
):
|
|
"""Get synchronization status and recent sync history"""
|
|
try:
|
|
transaction_service = POSTransactionService()
|
|
sync_service = POSSyncService(db)
|
|
|
|
# Get sync metrics from transaction service
|
|
sync_metrics = await transaction_service.get_sync_metrics(tenant_id)
|
|
|
|
# Get last successful sync time
|
|
sync_status = sync_metrics["sync_status"]
|
|
last_successful_sync = sync_status.get("last_sync_at")
|
|
|
|
# Calculate sync success rate
|
|
total = sync_metrics["total_transactions"]
|
|
synced = sync_status.get("synced", 0)
|
|
success_rate = (synced / total * 100) if total > 0 else 100.0
|
|
|
|
# Calculate actual average duration from sync logs
|
|
average_duration_minutes = await sync_service.calculate_average_duration(
|
|
tenant_id=tenant_id,
|
|
pos_config_id=config_id,
|
|
days=30
|
|
)
|
|
|
|
return {
|
|
"current_sync": None,
|
|
"last_successful_sync": last_successful_sync.isoformat() if last_successful_sync else None,
|
|
"recent_syncs": [], # Could be enhanced with actual sync history
|
|
"sync_health": {
|
|
"status": "healthy" if success_rate > 90 else "degraded" if success_rate > 70 else "unhealthy",
|
|
"success_rate": round(success_rate, 2),
|
|
"average_duration_minutes": average_duration_minutes,
|
|
"last_error": None,
|
|
"total_transactions": total,
|
|
"synced_count": synced,
|
|
"pending_count": sync_status.get("pending", 0),
|
|
"failed_count": sync_status.get("failed", 0)
|
|
}
|
|
}
|
|
except Exception as e:
|
|
logger.error("Failed to get sync status", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(status_code=500, detail=f"Failed to get sync status: {str(e)}")
|
|
|
|
|
|
@router.get(
|
|
route_builder.build_operations_route("sync-logs"),
|
|
response_model=dict
|
|
)
|
|
@require_user_role(['viewer', 'member', 'admin', 'owner'])
|
|
async def get_sync_logs(
|
|
tenant_id: UUID = Path(...),
|
|
config_id: Optional[UUID] = Query(None),
|
|
limit: int = Query(50, ge=1, le=200),
|
|
offset: int = Query(0, ge=0),
|
|
status: Optional[str] = Query(None),
|
|
sync_type: Optional[str] = Query(None),
|
|
current_user: dict = Depends(get_current_user_dep),
|
|
db=Depends(get_db)
|
|
):
|
|
"""Get detailed sync logs"""
|
|
try:
|
|
sync_service = POSSyncService(db)
|
|
|
|
logs_data = await sync_service.get_sync_logs(
|
|
tenant_id=tenant_id,
|
|
config_id=config_id,
|
|
status=status,
|
|
sync_type=sync_type,
|
|
limit=limit,
|
|
offset=offset
|
|
)
|
|
|
|
return logs_data
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to get sync logs", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(status_code=500, detail=f"Failed to get sync logs: {str(e)}")
|
|
|
|
|
|
@router.post(
|
|
route_builder.build_operations_route("resync-failed"),
|
|
response_model=dict
|
|
)
|
|
@admin_role_required
|
|
async def resync_failed_transactions(
|
|
tenant_id: UUID = Path(...),
|
|
days_back: int = Query(7, ge=1, le=90),
|
|
current_user: dict = Depends(get_current_user_dep),
|
|
db=Depends(get_db)
|
|
):
|
|
"""Resync failed transactions from the specified time period (Admin/Owner only)"""
|
|
try:
|
|
# Get active POS configuration for tenant
|
|
config_service = POSConfigurationService()
|
|
configs = await config_service.get_configurations_by_tenant(
|
|
tenant_id=tenant_id,
|
|
is_active=True,
|
|
skip=0,
|
|
limit=1
|
|
)
|
|
|
|
if not configs:
|
|
raise HTTPException(status_code=404, detail="No active POS configuration found")
|
|
|
|
config = configs[0]
|
|
|
|
# Create resync job
|
|
sync_service = POSSyncService(db)
|
|
sync_log = await sync_service.create_sync_job(
|
|
tenant_id=tenant_id,
|
|
pos_config_id=config.id,
|
|
pos_system=config.pos_system,
|
|
sync_type="resync_failed",
|
|
data_types=["transactions"]
|
|
)
|
|
|
|
logger.info("Resync failed transactions requested",
|
|
tenant_id=tenant_id,
|
|
days_back=days_back,
|
|
sync_id=str(sync_log.id),
|
|
user_id=current_user.get("user_id"))
|
|
|
|
return {
|
|
"message": "Resync job queued successfully",
|
|
"job_id": str(sync_log.id),
|
|
"scope": f"Failed transactions from last {days_back} days",
|
|
"estimated_transactions": 0
|
|
}
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error("Failed to queue resync job", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(status_code=500, detail=f"Failed to queue resync job: {str(e)}")
|
|
|
|
|
|
@router.post(
|
|
route_builder.build_operations_route("test-connection"),
|
|
response_model=dict
|
|
)
|
|
@admin_role_required
|
|
async def test_pos_connection(
|
|
tenant_id: UUID = Path(...),
|
|
config_id: UUID = Query(...),
|
|
current_user: dict = Depends(get_current_user_dep),
|
|
db=Depends(get_db)
|
|
):
|
|
"""Test connection to POS system (Admin/Owner only)"""
|
|
try:
|
|
config_service = POSConfigurationService()
|
|
|
|
# Get the configuration to verify it exists
|
|
configurations = await config_service.get_configurations_by_tenant(
|
|
tenant_id=tenant_id,
|
|
skip=0,
|
|
limit=100
|
|
)
|
|
|
|
config = next((c for c in configurations if str(c.id) == str(config_id)), None)
|
|
|
|
if not config:
|
|
raise HTTPException(status_code=404, detail="Configuration not found")
|
|
|
|
# For demo purposes, we assume connection is successful if config exists
|
|
# In production, this would actually test the POS API connection
|
|
is_connected = config.is_connected and config.is_active
|
|
|
|
return {
|
|
"success": is_connected,
|
|
"status": "success" if is_connected else "failed",
|
|
"message": f"Connection test {'successful' if is_connected else 'failed'} for {config.pos_system}",
|
|
"tested_at": datetime.utcnow().isoformat(),
|
|
"config_id": str(config_id),
|
|
"pos_system": config.pos_system,
|
|
"health_status": config.health_status
|
|
}
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error("Failed to test POS connection", error=str(e),
|
|
tenant_id=tenant_id, config_id=config_id)
|
|
raise HTTPException(status_code=500, detail=f"Failed to test connection: {str(e)}")
|
|
|
|
|
|
# ============================================================================
|
|
# Webhook Operations
|
|
# ============================================================================
|
|
|
|
@router.post(
|
|
route_builder.build_webhook_route("{pos_system}"),
|
|
response_model=dict
|
|
)
|
|
async def receive_webhook(
|
|
request: Request,
|
|
pos_system: str = Path(..., description="POS system name"),
|
|
content_type: Optional[str] = Header(None),
|
|
x_signature: Optional[str] = Header(None),
|
|
x_webhook_signature: Optional[str] = Header(None),
|
|
authorization: Optional[str] = Header(None),
|
|
db=Depends(get_db)
|
|
):
|
|
"""
|
|
Receive webhooks from POS systems
|
|
Supports Square, Toast, and Lightspeed webhook formats
|
|
Includes signature verification, database logging, and duplicate detection
|
|
"""
|
|
webhook_service = POSWebhookService(db)
|
|
start_time = datetime.utcnow()
|
|
|
|
try:
|
|
# Validate POS system
|
|
supported_systems = ["square", "toast", "lightspeed"]
|
|
if pos_system.lower() not in supported_systems:
|
|
raise HTTPException(status_code=400, detail=f"Unsupported POS system: {pos_system}")
|
|
|
|
# Get request details
|
|
method = request.method
|
|
url_path = str(request.url.path)
|
|
query_params = dict(request.query_params)
|
|
headers = dict(request.headers)
|
|
|
|
# Get client IP
|
|
client_ip = None
|
|
if hasattr(request, 'client') and request.client:
|
|
client_ip = request.client.host
|
|
|
|
# Read payload
|
|
try:
|
|
body = await request.body()
|
|
raw_payload = body.decode('utf-8') if body else ""
|
|
payload_size = len(body) if body else 0
|
|
|
|
# Parse JSON if possible
|
|
parsed_payload = None
|
|
if raw_payload:
|
|
try:
|
|
parsed_payload = json.loads(raw_payload)
|
|
except json.JSONDecodeError:
|
|
logger.warning("Failed to parse webhook payload as JSON",
|
|
pos_system=pos_system, payload_size=payload_size)
|
|
except Exception as e:
|
|
logger.error("Failed to read webhook payload", error=str(e))
|
|
raise HTTPException(status_code=400, detail="Failed to read request payload")
|
|
|
|
# Determine signature from various header formats
|
|
signature = x_signature or x_webhook_signature or authorization
|
|
|
|
# Parse webhook event details
|
|
event_details = webhook_service.parse_webhook_event_details(pos_system, parsed_payload or {})
|
|
webhook_type = event_details.get("webhook_type") or "unknown"
|
|
event_id = event_details.get("event_id")
|
|
transaction_id = event_details.get("transaction_id")
|
|
order_id = event_details.get("order_id")
|
|
|
|
# Extract tenant_id from payload
|
|
tenant_id = None
|
|
if parsed_payload:
|
|
tenant_id = await webhook_service.extract_tenant_id_from_payload(pos_system, parsed_payload)
|
|
|
|
# Check for duplicate webhook
|
|
is_duplicate = False
|
|
if event_id:
|
|
is_duplicate, _ = await webhook_service.check_duplicate_webhook(
|
|
pos_system, event_id, tenant_id
|
|
)
|
|
|
|
# Verify webhook signature if tenant is identified
|
|
is_signature_valid = None
|
|
if signature and tenant_id:
|
|
webhook_secret = await webhook_service.get_webhook_secret(pos_system, tenant_id)
|
|
if webhook_secret:
|
|
is_signature_valid = await webhook_service.verify_webhook_signature(
|
|
pos_system, raw_payload, signature, webhook_secret
|
|
)
|
|
|
|
if not is_signature_valid:
|
|
logger.warning("Webhook signature verification failed",
|
|
pos_system=pos_system,
|
|
tenant_id=str(tenant_id))
|
|
|
|
# Log webhook receipt to database
|
|
webhook_log = await webhook_service.log_webhook(
|
|
pos_system=pos_system,
|
|
webhook_type=webhook_type,
|
|
method=method,
|
|
url_path=url_path,
|
|
query_params=query_params,
|
|
headers=headers,
|
|
raw_payload=raw_payload,
|
|
payload_size=payload_size,
|
|
content_type=content_type,
|
|
signature=signature,
|
|
is_signature_valid=is_signature_valid,
|
|
source_ip=client_ip,
|
|
event_id=event_id,
|
|
tenant_id=tenant_id,
|
|
transaction_id=transaction_id,
|
|
order_id=order_id
|
|
)
|
|
|
|
# Mark as duplicate if detected
|
|
if is_duplicate:
|
|
await webhook_service.update_webhook_status(
|
|
webhook_log.id,
|
|
status="duplicate",
|
|
error_message="Duplicate event already processed"
|
|
)
|
|
logger.info("Duplicate webhook ignored", event_id=event_id)
|
|
return _get_webhook_response(pos_system, success=True)
|
|
|
|
# Queue for async processing via RabbitMQ
|
|
try:
|
|
from shared.messaging import get_rabbitmq_client
|
|
import uuid as uuid_module
|
|
|
|
rabbitmq_client = get_rabbitmq_client()
|
|
if rabbitmq_client:
|
|
# Publish POS transaction event for async processing
|
|
event_payload = {
|
|
"event_id": str(uuid_module.uuid4()),
|
|
"event_type": f"pos.{webhook_type}",
|
|
"timestamp": datetime.utcnow().isoformat(),
|
|
"tenant_id": str(tenant_id) if tenant_id else None,
|
|
"data": {
|
|
"webhook_log_id": str(webhook_log.id),
|
|
"pos_system": pos_system,
|
|
"webhook_type": webhook_type,
|
|
"payload": webhook_data,
|
|
"event_id": event_id
|
|
}
|
|
}
|
|
|
|
await rabbitmq_client.publish_event(
|
|
exchange_name="pos.events",
|
|
routing_key=f"pos.{webhook_type}",
|
|
event_data=event_payload
|
|
)
|
|
|
|
logger.info("POS transaction queued for async processing",
|
|
event_id=event_payload["event_id"],
|
|
webhook_log_id=str(webhook_log.id))
|
|
|
|
# Update status to queued
|
|
processing_duration_ms = int((datetime.utcnow() - start_time).total_seconds() * 1000)
|
|
await webhook_service.update_webhook_status(
|
|
webhook_log.id,
|
|
status="queued",
|
|
processing_duration_ms=processing_duration_ms
|
|
)
|
|
else:
|
|
logger.warning("RabbitMQ client not available, marking as received only")
|
|
processing_duration_ms = int((datetime.utcnow() - start_time).total_seconds() * 1000)
|
|
await webhook_service.update_webhook_status(
|
|
webhook_log.id,
|
|
status="received",
|
|
processing_duration_ms=processing_duration_ms
|
|
)
|
|
|
|
except Exception as queue_error:
|
|
logger.error("Failed to queue POS transaction for async processing",
|
|
error=str(queue_error),
|
|
webhook_log_id=str(webhook_log.id))
|
|
# Mark as received even if queuing fails
|
|
processing_duration_ms = int((datetime.utcnow() - start_time).total_seconds() * 1000)
|
|
await webhook_service.update_webhook_status(
|
|
webhook_log.id,
|
|
status="received",
|
|
processing_duration_ms=processing_duration_ms
|
|
)
|
|
|
|
logger.info("Webhook processed and queued successfully",
|
|
pos_system=pos_system,
|
|
webhook_type=webhook_type,
|
|
event_id=event_id,
|
|
tenant_id=str(tenant_id) if tenant_id else None,
|
|
webhook_log_id=str(webhook_log.id))
|
|
|
|
# Return appropriate response based on POS system requirements
|
|
return _get_webhook_response(pos_system, success=True)
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error("Webhook processing failed",
|
|
error=str(e),
|
|
pos_system=pos_system,
|
|
exc_info=True)
|
|
|
|
# Return 500 to trigger POS system retry
|
|
raise HTTPException(status_code=500, detail="Webhook processing failed")
|
|
|
|
|
|
def _get_webhook_response(pos_system: str, success: bool = True) -> Dict[str, Any]:
|
|
"""Get POS-specific webhook response format"""
|
|
if pos_system.lower() == "square":
|
|
return {"status": "success" if success else "error"}
|
|
elif pos_system.lower() == "toast":
|
|
return {"success": success}
|
|
elif pos_system.lower() == "lightspeed":
|
|
return {"received": success}
|
|
else:
|
|
return {"status": "received" if success else "error"}
|
|
|
|
|
|
@router.get(
|
|
route_builder.build_webhook_route("{pos_system}/status"),
|
|
response_model=dict
|
|
)
|
|
async def get_webhook_status(pos_system: str = Path(..., description="POS system name")):
|
|
"""Get webhook endpoint status for a POS system"""
|
|
try:
|
|
supported_systems = ["square", "toast", "lightspeed"]
|
|
if pos_system.lower() not in supported_systems:
|
|
raise HTTPException(status_code=400, detail=f"Unsupported POS system: {pos_system}")
|
|
|
|
return {
|
|
"pos_system": pos_system,
|
|
"status": "active",
|
|
"endpoint": f"/api/v1/webhooks/{pos_system}",
|
|
"supported_events": _get_supported_events(pos_system),
|
|
"last_received": None,
|
|
"total_received": 0
|
|
}
|
|
except Exception as e:
|
|
logger.error("Failed to get webhook status", error=str(e), pos_system=pos_system)
|
|
raise HTTPException(status_code=500, detail=f"Failed to get webhook status: {str(e)}")
|
|
|
|
|
|
def _get_supported_events(pos_system: str) -> Dict[str, Any]:
|
|
"""Get supported webhook events for each POS system"""
|
|
events = {
|
|
"square": [
|
|
"payment.created",
|
|
"payment.updated",
|
|
"order.created",
|
|
"order.updated",
|
|
"order.fulfilled",
|
|
"inventory.count.updated"
|
|
],
|
|
"toast": [
|
|
"OrderCreated",
|
|
"OrderUpdated",
|
|
"OrderPaid",
|
|
"OrderCanceled",
|
|
"OrderVoided"
|
|
],
|
|
"lightspeed": [
|
|
"order.created",
|
|
"order.updated",
|
|
"order.paid",
|
|
"sale.created",
|
|
"sale.updated"
|
|
]
|
|
}
|
|
|
|
return {
|
|
"events": events.get(pos_system.lower(), []),
|
|
"format": "JSON",
|
|
"authentication": "signature_verification"
|
|
}
|
|
|
|
|
|
# ============================================================================
|
|
# Tenant Data Deletion Operations (Internal Service Only)
|
|
# ============================================================================
|
|
|
|
@router.delete(
|
|
route_builder.build_base_route("tenant/{tenant_id}", include_tenant_prefix=False),
|
|
response_model=dict
|
|
)
|
|
@service_only_access
|
|
async def delete_tenant_data(
|
|
tenant_id: str = Path(..., description="Tenant ID to delete data for"),
|
|
current_user: dict = Depends(get_current_user_dep),
|
|
db=Depends(get_db)
|
|
):
|
|
"""
|
|
Delete all POS data for a tenant (Internal service only)
|
|
|
|
This endpoint is called by the orchestrator during tenant deletion.
|
|
It permanently deletes all POS-related data including:
|
|
- POS configurations
|
|
- POS transactions and items
|
|
- Webhook logs
|
|
- Sync logs
|
|
- Audit logs
|
|
|
|
**WARNING**: This operation is irreversible!
|
|
|
|
Returns:
|
|
Deletion summary with counts of deleted records
|
|
"""
|
|
try:
|
|
logger.info("pos.tenant_deletion.api_called", tenant_id=tenant_id)
|
|
|
|
deletion_service = POSTenantDeletionService(db)
|
|
result = await deletion_service.safe_delete_tenant_data(tenant_id)
|
|
|
|
if not result.success:
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=f"Tenant data deletion failed: {', '.join(result.errors)}"
|
|
)
|
|
|
|
return {
|
|
"message": "Tenant data deletion completed successfully",
|
|
"summary": result.to_dict()
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error("pos.tenant_deletion.api_error",
|
|
tenant_id=tenant_id,
|
|
error=str(e),
|
|
exc_info=True)
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=f"Failed to delete tenant data: {str(e)}"
|
|
)
|
|
|
|
|
|
@router.get(
|
|
route_builder.build_base_route("tenant/{tenant_id}/deletion-preview", include_tenant_prefix=False),
|
|
response_model=dict
|
|
)
|
|
@service_only_access
|
|
async def preview_tenant_data_deletion(
|
|
tenant_id: str = Path(..., description="Tenant ID to preview deletion for"),
|
|
current_user: dict = Depends(get_current_user_dep),
|
|
db=Depends(get_db)
|
|
):
|
|
"""
|
|
Preview what data would be deleted for a tenant (dry-run)
|
|
|
|
This endpoint shows counts of all data that would be deleted
|
|
without actually deleting anything. Useful for:
|
|
- Confirming deletion scope before execution
|
|
- Auditing and compliance
|
|
- Troubleshooting
|
|
|
|
Returns:
|
|
Dictionary with entity names and their counts
|
|
"""
|
|
try:
|
|
logger.info("pos.tenant_deletion.preview_called", tenant_id=tenant_id)
|
|
|
|
deletion_service = POSTenantDeletionService(db)
|
|
preview = await deletion_service.get_tenant_data_preview(tenant_id)
|
|
|
|
total_records = sum(preview.values())
|
|
|
|
return {
|
|
"tenant_id": tenant_id,
|
|
"service": "pos",
|
|
"preview": preview,
|
|
"total_records": total_records,
|
|
"warning": "These records will be permanently deleted and cannot be recovered"
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error("pos.tenant_deletion.preview_error",
|
|
tenant_id=tenant_id,
|
|
error=str(e),
|
|
exc_info=True)
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=f"Failed to preview tenant data deletion: {str(e)}"
|
|
)
|
|
|
|
|
|
# ================================================================
|
|
# POS TO SALES SYNC ENDPOINTS
|
|
# ================================================================
|
|
|
|
@router.post(
|
|
"/tenants/{tenant_id}/pos/transactions/{transaction_id}/sync-to-sales",
|
|
summary="Sync single transaction to sales",
|
|
description="Manually sync a specific POS transaction to the sales service"
|
|
)
|
|
async def sync_transaction_to_sales(
|
|
tenant_id: UUID = Path(..., description="Tenant ID"),
|
|
transaction_id: UUID = Path(..., description="Transaction ID to sync"),
|
|
current_user: Dict[str, Any] = Depends(get_current_user_dep)
|
|
):
|
|
"""
|
|
Sync a single POS transaction to the sales service
|
|
|
|
This endpoint:
|
|
- Creates sales records for each item in the transaction
|
|
- Automatically decreases inventory stock
|
|
- Updates sync status flags
|
|
- Returns detailed sync results
|
|
"""
|
|
try:
|
|
from app.services.pos_transaction_service import POSTransactionService
|
|
|
|
transaction_service = POSTransactionService()
|
|
|
|
result = await transaction_service.sync_transaction_to_sales(
|
|
transaction_id=transaction_id,
|
|
tenant_id=tenant_id
|
|
)
|
|
|
|
if result.get("success"):
|
|
logger.info("Transaction synced to sales via API",
|
|
transaction_id=transaction_id,
|
|
tenant_id=tenant_id,
|
|
user_id=current_user.get("user_id"))
|
|
|
|
return {
|
|
"success": True,
|
|
"message": "Transaction synced successfully",
|
|
**result
|
|
}
|
|
else:
|
|
logger.warning("Transaction sync failed via API",
|
|
transaction_id=transaction_id,
|
|
tenant_id=tenant_id,
|
|
error=result.get("error"))
|
|
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=result.get("error", "Failed to sync transaction")
|
|
)
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error("Failed to sync transaction to sales",
|
|
error=str(e),
|
|
transaction_id=transaction_id,
|
|
tenant_id=tenant_id,
|
|
exc_info=True)
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=f"Failed to sync transaction: {str(e)}"
|
|
)
|
|
|
|
|
|
@router.post(
|
|
"/tenants/{tenant_id}/pos/transactions/sync-all-to-sales",
|
|
summary="Batch sync unsynced transactions",
|
|
description="Sync all unsynced POS transactions to the sales service"
|
|
)
|
|
async def sync_all_transactions_to_sales(
|
|
tenant_id: UUID = Path(..., description="Tenant ID"),
|
|
limit: int = Query(50, ge=1, le=200, description="Max transactions to sync in one batch"),
|
|
current_user: Dict[str, Any] = Depends(get_current_user_dep)
|
|
):
|
|
"""
|
|
Batch sync all unsynced POS transactions to the sales service
|
|
|
|
This endpoint:
|
|
- Finds all unsynced completed transactions
|
|
- Syncs each one to the sales service
|
|
- Creates sales records and decreases inventory
|
|
- Returns summary with success/failure counts
|
|
|
|
Use this to:
|
|
- Manually trigger sync after POS webhooks are received
|
|
- Recover from sync failures
|
|
- Initial migration of historical POS data
|
|
"""
|
|
try:
|
|
from app.services.pos_transaction_service import POSTransactionService
|
|
|
|
transaction_service = POSTransactionService()
|
|
|
|
result = await transaction_service.sync_unsynced_transactions(
|
|
tenant_id=tenant_id,
|
|
limit=limit
|
|
)
|
|
|
|
logger.info("Batch sync completed via API",
|
|
tenant_id=tenant_id,
|
|
total=result.get("total_transactions"),
|
|
synced=result.get("synced"),
|
|
failed=result.get("failed"),
|
|
user_id=current_user.get("user_id"))
|
|
|
|
return {
|
|
"success": True,
|
|
"message": f"Synced {result.get('synced')} of {result.get('total_transactions')} transactions",
|
|
**result
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to batch sync transactions to sales",
|
|
error=str(e),
|
|
tenant_id=tenant_id,
|
|
exc_info=True)
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=f"Failed to batch sync transactions: {str(e)}"
|
|
)
|
|
|
|
|
|
@router.get(
|
|
"/tenants/{tenant_id}/pos/transactions/sync-status",
|
|
summary="Get sync status summary",
|
|
description="Get summary of synced vs unsynced transactions"
|
|
)
|
|
async def get_sync_status(
|
|
tenant_id: UUID = Path(..., description="Tenant ID"),
|
|
current_user: Dict[str, Any] = Depends(get_current_user_dep)
|
|
):
|
|
"""
|
|
Get sync status summary for POS transactions
|
|
|
|
Returns counts of:
|
|
- Total completed transactions
|
|
- Synced transactions
|
|
- Unsynced transactions
|
|
- Failed sync attempts
|
|
"""
|
|
try:
|
|
from app.services.pos_transaction_service import POSTransactionService
|
|
|
|
transaction_service = POSTransactionService()
|
|
|
|
# Get counts for different sync states
|
|
total_completed = await transaction_service.count_transactions_by_tenant(
|
|
tenant_id=tenant_id,
|
|
status="completed"
|
|
)
|
|
|
|
synced = await transaction_service.count_transactions_by_tenant(
|
|
tenant_id=tenant_id,
|
|
status="completed",
|
|
is_synced=True
|
|
)
|
|
|
|
unsynced = await transaction_service.count_transactions_by_tenant(
|
|
tenant_id=tenant_id,
|
|
status="completed",
|
|
is_synced=False
|
|
)
|
|
|
|
return {
|
|
"total_completed_transactions": total_completed,
|
|
"synced_to_sales": synced,
|
|
"pending_sync": unsynced,
|
|
"sync_rate": round((synced / total_completed * 100) if total_completed > 0 else 0, 2)
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to get sync status",
|
|
error=str(e),
|
|
tenant_id=tenant_id,
|
|
exc_info=True)
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=f"Failed to get sync status: {str(e)}"
|
|
)
|