bakery-admin/bakery-ia
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add new alert architecture

Browse Source
This commit is contained in:
Urtzi Alfaro
2025-08-23 10:19:58 +02:00
parent 1a9839240e
commit 4b4268d640
45 changed files with 6518 additions and 1590 deletions
Download Patch File Download Diff File Expand all files Collapse all files

187
services/production/README.md
View File

@@ -1,187 +0,0 @@
# Production Service
Production planning and batch management service for the bakery management system.
## Overview
The Production Service handles all production-related operations including:
- **Production Planning**: Calculate daily requirements using demand forecasts and inventory levels
- **Batch Management**: Track production batches from start to finish
- **Capacity Management**: Equipment, staff, and time scheduling
- **Quality Control**: Yield tracking, waste management, efficiency metrics
- **Alert System**: Comprehensive monitoring and notifications
## Features
### Core Capabilities
- Daily production requirements calculation
- Production batch lifecycle management
- Real-time capacity planning and utilization
- Quality control tracking and metrics
- Comprehensive alert system with multiple severity levels
- Integration with inventory, orders, recipes, and sales services
### API Endpoints
#### Dashboard & Planning
- `GET /api/v1/tenants/{tenant_id}/production/dashboard-summary` - Production dashboard data
- `GET /api/v1/tenants/{tenant_id}/production/daily-requirements` - Daily production planning
- `GET /api/v1/tenants/{tenant_id}/production/requirements` - Requirements for procurement
#### Batch Management
- `POST /api/v1/tenants/{tenant_id}/production/batches` - Create production batch
- `GET /api/v1/tenants/{tenant_id}/production/batches/active` - Get active batches
- `GET /api/v1/tenants/{tenant_id}/production/batches/{batch_id}` - Get batch details
- `PUT /api/v1/tenants/{tenant_id}/production/batches/{batch_id}/status` - Update batch status
#### Scheduling & Capacity
- `GET /api/v1/tenants/{tenant_id}/production/schedule` - Production schedule
- `GET /api/v1/tenants/{tenant_id}/production/capacity/status` - Capacity status
#### Alerts & Monitoring
- `GET /api/v1/tenants/{tenant_id}/production/alerts` - Production alerts
- `POST /api/v1/tenants/{tenant_id}/production/alerts/{alert_id}/acknowledge` - Acknowledge alerts
#### Analytics
- `GET /api/v1/tenants/{tenant_id}/production/metrics/yield` - Yield metrics
## Service Integration
### Shared Clients Used
- **InventoryServiceClient**: Stock levels, ingredient availability
- **OrdersServiceClient**: Demand requirements, customer orders
- **RecipesServiceClient**: Recipe requirements, ingredient calculations
- **SalesServiceClient**: Historical sales data
- **NotificationServiceClient**: Alert notifications
### Authentication
Uses shared authentication patterns with tenant isolation:
- JWT token validation
- Tenant access verification
- User permission checks
## Configuration
Key configuration options in `app/core/config.py`:
### Production Planning
- `PLANNING_HORIZON_DAYS`: Days ahead for planning (default: 7)
- `PRODUCTION_BUFFER_PERCENTAGE`: Safety buffer for production (default: 10%)
- `MINIMUM_BATCH_SIZE`: Minimum batch size (default: 1.0)
- `MAXIMUM_BATCH_SIZE`: Maximum batch size (default: 100.0)
### Capacity Management
- `DEFAULT_WORKING_HOURS_PER_DAY`: Standard working hours (default: 12)
- `MAX_OVERTIME_HOURS`: Maximum overtime allowed (default: 4)
- `CAPACITY_UTILIZATION_TARGET`: Target utilization (default: 85%)
### Quality Control
- `MINIMUM_YIELD_PERCENTAGE`: Minimum acceptable yield (default: 85%)
- `QUALITY_SCORE_THRESHOLD`: Minimum quality score (default: 8.0)
### Alert Thresholds
- `CAPACITY_EXCEEDED_THRESHOLD`: Capacity alert threshold (default: 100%)
- `PRODUCTION_DELAY_THRESHOLD_MINUTES`: Delay alert threshold (default: 60)
- `LOW_YIELD_ALERT_THRESHOLD`: Low yield alert (default: 80%)
## Database Models
### ProductionBatch
- Complete batch tracking from planning to completion
- Status management (pending, in_progress, completed, etc.)
- Cost tracking and yield calculations
- Quality metrics integration
### ProductionSchedule
- Daily production scheduling
- Capacity planning and tracking
- Staff and equipment assignments
- Performance metrics
### ProductionCapacity
- Resource availability tracking
- Equipment and staff capacity
- Maintenance scheduling
- Utilization monitoring
### QualityCheck
- Quality control measurements
- Pass/fail tracking
- Defect recording
- Corrective action management
### ProductionAlert
- Comprehensive alert system
- Multiple severity levels
- Action recommendations
- Resolution tracking
## Alert System
### Alert Types
- **Capacity Exceeded**: When production requirements exceed available capacity
- **Production Delay**: When batches are delayed beyond thresholds
- **Cost Spike**: When production costs exceed normal ranges
- **Low Yield**: When yield percentages fall below targets
- **Quality Issues**: When quality scores consistently decline
- **Equipment Maintenance**: When equipment needs maintenance
### Severity Levels
- **Critical**: WhatsApp + Email + Dashboard + SMS
- **High**: WhatsApp + Email + Dashboard
- **Medium**: Email + Dashboard
- **Low**: Dashboard only
## Development
### Setup
```bash
# Install dependencies
pip install -r requirements.txt
# Set up database
# Configure DATABASE_URL environment variable
# Run migrations
alembic upgrade head
# Start service
uvicorn app.main:app --reload
```
### Testing
```bash
# Run tests
pytest
# Run with coverage
pytest --cov=app
```
### Docker
```bash
# Build image
docker build -t production-service .
# Run container
docker run -p 8000:8000 production-service
```
## Deployment
The service is designed for containerized deployment with:
- Health checks at `/health`
- Structured logging
- Metrics collection
- Database migrations
- Service discovery integration
## Architecture
Follows Domain-Driven Microservices Architecture:
- Clean separation of concerns
- Repository pattern for data access
- Service layer for business logic
- API layer for external interface
- Shared infrastructure for cross-cutting concerns

18
services/production/app/main.py
View File

@@ -14,6 +14,7 @@ import structlog
from app.core.config import settings
from app.core.database import init_database, get_db_health
from app.api.production import router as production_router
from app.services.production_alert_service import ProductionAlertService
# Configure logging
logger = structlog.get_logger()
@@ -25,6 +26,16 @@ async def lifespan(app: FastAPI):
# Startup
try:
await init_database()
logger.info("Database initialized")
# Initialize alert service
alert_service = ProductionAlertService(settings)
await alert_service.start()
logger.info("Production alert service started")
# Store alert service in app state
app.state.alert_service = alert_service
logger.info("Production service started successfully")
except Exception as e:
logger.error("Failed to initialize production service", error=str(e))
@@ -34,6 +45,13 @@ async def lifespan(app: FastAPI):
# Shutdown
logger.info("Production service shutting down")
try:
# Stop alert service
if hasattr(app.state, 'alert_service'):
await app.state.alert_service.stop()
logger.info("Alert service stopped")
except Exception as e:
logger.error("Error during shutdown", error=str(e))
# Create FastAPI application

795
services/production/app/services/production_alert_service.py Normal file
View File

@@ -0,0 +1,795 @@
# services/production/app/services/production_alert_service.py
"""
Production-specific alert and recommendation detection service
Monitors production capacity, delays, quality issues, and optimization opportunities
"""
import json
from typing import List, Dict, Any, Optional
from uuid import UUID
from datetime import datetime, timedelta
import structlog
from apscheduler.triggers.cron import CronTrigger
from shared.alerts.base_service import BaseAlertService, AlertServiceMixin
from shared.alerts.templates import format_item_message
logger = structlog.get_logger()
class ProductionAlertService(BaseAlertService, AlertServiceMixin):
"""Production service alert and recommendation detection"""
def setup_scheduled_checks(self):
"""Production-specific scheduled checks for alerts and recommendations"""
# Production capacity checks - every 10 minutes during business hours (alerts)
self.scheduler.add_job(
self.check_production_capacity,
CronTrigger(minute='*/10', hour='6-20'),
id='capacity_check',
misfire_grace_time=60,
max_instances=1
)
# Production delays - every 5 minutes during production hours (alerts)
self.scheduler.add_job(
self.check_production_delays,
CronTrigger(minute='*/5', hour='4-22'),
id='delay_check',
misfire_grace_time=30,
max_instances=1
)
# Quality issues check - every 15 minutes (alerts)
self.scheduler.add_job(
self.check_quality_issues,
CronTrigger(minute='*/15'),
id='quality_check',
misfire_grace_time=60,
max_instances=1
)
# Equipment monitoring - every 3 minutes (alerts)
self.scheduler.add_job(
self.check_equipment_status,
CronTrigger(minute='*/3'),
id='equipment_check',
misfire_grace_time=30,
max_instances=1
)
# Efficiency recommendations - every 30 minutes (recommendations)
self.scheduler.add_job(
self.generate_efficiency_recommendations,
CronTrigger(minute='*/30'),
id='efficiency_recs',
misfire_grace_time=120,
max_instances=1
)
# Energy optimization - every hour (recommendations)
self.scheduler.add_job(
self.generate_energy_recommendations,
CronTrigger(minute='0'),
id='energy_recs',
misfire_grace_time=300,
max_instances=1
)
logger.info("Production alert schedules configured",
service=self.config.SERVICE_NAME)
async def check_production_capacity(self):
"""Check if production plan exceeds capacity (alerts)"""
try:
self._checks_performed += 1
query = """
WITH capacity_analysis AS (
SELECT
p.tenant_id,
p.planned_date,
SUM(p.planned_quantity) as total_planned,
MAX(pc.daily_capacity) as max_daily_capacity,
COUNT(DISTINCT p.equipment_id) as equipment_count,
AVG(pc.efficiency_percent) as avg_efficiency,
CASE
WHEN SUM(p.planned_quantity) > MAX(pc.daily_capacity) * 1.2 THEN 'severe_overload'
WHEN SUM(p.planned_quantity) > MAX(pc.daily_capacity) THEN 'overload'
WHEN SUM(p.planned_quantity) > MAX(pc.daily_capacity) * 0.9 THEN 'near_capacity'
ELSE 'normal'
END as capacity_status,
(SUM(p.planned_quantity) / MAX(pc.daily_capacity)) * 100 as capacity_percentage
FROM production_schedule p
JOIN production_capacity pc ON pc.equipment_id = p.equipment_id
WHERE p.planned_date >= CURRENT_DATE
AND p.planned_date <= CURRENT_DATE + INTERVAL '3 days'
AND p.status IN ('planned', 'in_progress')
AND p.tenant_id = $1
GROUP BY p.tenant_id, p.planned_date
)
SELECT * FROM capacity_analysis
WHERE capacity_status != 'normal'
ORDER BY capacity_percentage DESC
"""
# Check production capacity without tenant dependencies
try:
from sqlalchemy import text
# Simplified query using only existing production tables
simplified_query = text("""
SELECT
pb.tenant_id,
DATE(pb.planned_start_time) as planned_date,
COUNT(*) as batch_count,
SUM(pb.planned_quantity) as total_planned,
'capacity_check' as capacity_status
FROM production_batches pb
WHERE pb.planned_start_time >= CURRENT_DATE
AND pb.planned_start_time <= CURRENT_DATE + INTERVAL '3 days'
AND pb.status IN ('planned', 'pending', 'in_progress')
GROUP BY pb.tenant_id, DATE(pb.planned_start_time)
HAVING COUNT(*) > 10 -- Alert if more than 10 batches per day
ORDER BY total_planned DESC
""")
async with self.db_manager.get_session() as session:
result = await session.execute(simplified_query)
capacity_issues = result.fetchall()
for issue in capacity_issues:
await self._process_capacity_issue(issue.tenant_id, issue)
except Exception as e:
logger.debug("Simplified capacity check failed", error=str(e))
except Exception as e:
# Skip capacity checks if tables don't exist (graceful degradation)
if "does not exist" in str(e):
logger.debug("Capacity check skipped - missing tables", error=str(e))
else:
logger.error("Capacity check failed", error=str(e))
self._errors_count += 1
async def _process_capacity_issue(self, tenant_id: UUID, issue: Dict[str, Any]):
"""Process capacity overload issue"""
try:
status = issue['capacity_status']
percentage = issue['capacity_percentage']
if status == 'severe_overload':
template_data = self.format_spanish_message(
'order_overload',
percentage=int(percentage - 100)
)
await self.publish_item(tenant_id, {
'type': 'severe_capacity_overload',
'severity': 'urgent',
'title': template_data['title'],
'message': template_data['message'],
'actions': template_data['actions'],
'metadata': {
'planned_date': issue['planned_date'].isoformat(),
'capacity_percentage': float(percentage),
'overload_percentage': float(percentage - 100),
'equipment_count': issue['equipment_count']
}
}, item_type='alert')
elif status == 'overload':
severity = self.get_business_hours_severity('high')
await self.publish_item(tenant_id, {
'type': 'capacity_overload',
'severity': severity,
'title': f'⚠️ Capacidad Excedida: {percentage:.0f}%',
'message': f'Producción planificada para {issue["planned_date"]} excede capacidad en {percentage-100:.0f}%.',
'actions': ['Redistribuir cargas', 'Ampliar turnos', 'Subcontratar', 'Posponer pedidos'],
'metadata': {
'planned_date': issue['planned_date'].isoformat(),
'capacity_percentage': float(percentage),
'equipment_count': issue['equipment_count']
}
}, item_type='alert')
elif status == 'near_capacity':
severity = self.get_business_hours_severity('medium')
await self.publish_item(tenant_id, {
'type': 'near_capacity',
'severity': severity,
'title': f'📊 Cerca de Capacidad Máxima: {percentage:.0f}%',
'message': f'Producción del {issue["planned_date"]} está al {percentage:.0f}% de capacidad. Monitorear de cerca.',
'actions': ['Revisar planificación', 'Preparar contingencias', 'Optimizar eficiencia'],
'metadata': {
'planned_date': issue['planned_date'].isoformat(),
'capacity_percentage': float(percentage)
}
}, item_type='alert')
except Exception as e:
logger.error("Error processing capacity issue", error=str(e))
async def check_production_delays(self):
"""Check for production delays (alerts)"""
try:
self._checks_performed += 1
# Simplified query without customer_orders dependency
query = """
SELECT
pb.id, pb.tenant_id, pb.product_name, pb.batch_number,
pb.planned_end_time as planned_completion_time, pb.actual_start_time,
pb.actual_end_time as estimated_completion_time, pb.status,
EXTRACT(minutes FROM (NOW() - pb.planned_end_time)) as delay_minutes,
COALESCE(pb.priority::text, 'medium') as priority_level,
1 as affected_orders -- Default to 1 since we can't count orders
FROM production_batches pb
WHERE pb.status IN ('in_progress', 'delayed')
AND (
(pb.planned_end_time < NOW() AND pb.status = 'in_progress')
OR pb.status = 'delayed'
)
AND pb.planned_end_time > NOW() - INTERVAL '24 hours'
ORDER BY
CASE COALESCE(pb.priority::text, 'medium')
WHEN 'urgent' THEN 1 WHEN 'high' THEN 2 ELSE 3
END,
delay_minutes DESC
"""
from sqlalchemy import text
async with self.db_manager.get_session() as session:
result = await session.execute(text(query))
delays = result.fetchall()
for delay in delays:
await self._process_production_delay(delay)
except Exception as e:
# Skip delay checks if tables don't exist (graceful degradation)
if "does not exist" in str(e):
logger.debug("Production delay check skipped - missing tables", error=str(e))
else:
logger.error("Production delay check failed", error=str(e))
self._errors_count += 1
async def _process_production_delay(self, delay: Dict[str, Any]):
"""Process production delay"""
try:
delay_minutes = delay['delay_minutes']
priority = delay['priority_level']
affected_orders = delay['affected_orders']
# Determine severity based on delay time and priority
if delay_minutes > 120 or priority == 'urgent':
severity = 'urgent'
elif delay_minutes > 60 or priority == 'high':
severity = 'high'
elif delay_minutes > 30:
severity = 'medium'
else:
severity = 'low'
template_data = self.format_spanish_message(
'production_delay',
batch_name=f"{delay['product_name']} #{delay['batch_number']}",
delay_minutes=int(delay_minutes)
)
await self.publish_item(delay['tenant_id'], {
'type': 'production_delay',
'severity': severity,
'title': template_data['title'],
'message': template_data['message'],
'actions': template_data['actions'],
'metadata': {
'batch_id': str(delay['id']),
'product_name': delay['product_name'],
'batch_number': delay['batch_number'],
'delay_minutes': delay_minutes,
'priority_level': priority,
'affected_orders': affected_orders,
'planned_completion': delay['planned_completion_time'].isoformat()
}
}, item_type='alert')
except Exception as e:
logger.error("Error processing production delay",
batch_id=str(delay.get('id')),
error=str(e))
async def check_quality_issues(self):
"""Check for quality control issues (alerts)"""
try:
self._checks_performed += 1
# Fixed query using actual quality_checks table structure
query = """
SELECT
qc.id, qc.tenant_id, qc.batch_id, qc.check_type as test_type,
qc.quality_score as result_value,
qc.target_weight as min_acceptable,
(qc.target_weight * (1 + qc.tolerance_percentage/100)) as max_acceptable,
CASE
WHEN qc.pass_fail = false AND qc.defect_count > 5 THEN 'critical'
WHEN qc.pass_fail = false THEN 'major'
ELSE 'minor'
END as qc_severity,
qc.created_at,
pb.product_name, pb.batch_number,
COUNT(*) OVER (PARTITION BY qc.batch_id) as total_failures
FROM quality_checks qc
JOIN production_batches pb ON pb.id = qc.batch_id
WHERE qc.pass_fail = false -- Use pass_fail instead of status
AND qc.created_at > NOW() - INTERVAL '4 hours'
AND qc.corrective_action_needed = true -- Use this instead of acknowledged
ORDER BY
CASE
WHEN qc.pass_fail = false AND qc.defect_count > 5 THEN 1
WHEN qc.pass_fail = false THEN 2
ELSE 3
END,
qc.created_at DESC
"""
from sqlalchemy import text
async with self.db_manager.get_session() as session:
result = await session.execute(text(query))
quality_issues = result.fetchall()
for issue in quality_issues:
await self._process_quality_issue(issue)
except Exception as e:
# Skip quality checks if tables don't exist (graceful degradation)
if "does not exist" in str(e) or "column" in str(e).lower() and "does not exist" in str(e).lower():
logger.debug("Quality check skipped - missing tables or columns", error=str(e))
else:
logger.error("Quality check failed", error=str(e))
self._errors_count += 1
async def _process_quality_issue(self, issue: Dict[str, Any]):
"""Process quality control failure"""
try:
qc_severity = issue['qc_severity']
total_failures = issue['total_failures']
# Map QC severity to alert severity
if qc_severity == 'critical' or total_failures > 2:
severity = 'urgent'
elif qc_severity == 'major':
severity = 'high'
else:
severity = 'medium'
await self.publish_item(issue['tenant_id'], {
'type': 'quality_control_failure',
'severity': severity,
'title': f'❌ Fallo Control Calidad: {issue["product_name"]}',
'message': f'Lote {issue["batch_number"]} falló en {issue["test_type"]}. Valor: {issue["result_value"]} (rango: {issue["min_acceptable"]}-{issue["max_acceptable"]})',
'actions': ['Revisar lote', 'Repetir prueba', 'Ajustar proceso', 'Documentar causa'],
'metadata': {
'quality_check_id': str(issue['id']),
'batch_id': str(issue['batch_id']),
'test_type': issue['test_type'],
'result_value': float(issue['result_value']),
'min_acceptable': float(issue['min_acceptable']),
'max_acceptable': float(issue['max_acceptable']),
'qc_severity': qc_severity,
'total_failures': total_failures
}
}, item_type='alert')
# Mark as acknowledged to avoid duplicates
await self.db_manager.execute(
"UPDATE quality_checks SET acknowledged = true WHERE id = $1",
issue['id']
)
except Exception as e:
logger.error("Error processing quality issue",
quality_check_id=str(issue.get('id')),
error=str(e))
async def check_equipment_status(self):
"""Check equipment status and failures (alerts)"""
# Equipment tables don't exist in production database - skip this check
logger.debug("Equipment check skipped - equipment tables not available in production database")
return
async def _process_equipment_issue(self, equipment: Dict[str, Any]):
"""Process equipment issue"""
try:
status = equipment['status']
efficiency = equipment.get('efficiency_percent', 100)
days_to_maintenance = equipment.get('days_to_maintenance', 30)
if status == 'error':
template_data = self.format_spanish_message(
'equipment_failure',
equipment_name=equipment['name']
)
await self.publish_item(equipment['tenant_id'], {
'type': 'equipment_failure',
'severity': 'urgent',
'title': template_data['title'],
'message': template_data['message'],
'actions': template_data['actions'],
'metadata': {
'equipment_id': str(equipment['id']),
'equipment_name': equipment['name'],
'equipment_type': equipment['type'],
'error_count': equipment.get('error_count', 0),
'last_reading': equipment.get('last_reading').isoformat() if equipment.get('last_reading') else None
}
}, item_type='alert')
elif status == 'maintenance_required' or days_to_maintenance <= 1:
severity = 'high' if days_to_maintenance <= 1 else 'medium'
await self.publish_item(equipment['tenant_id'], {
'type': 'maintenance_required',
'severity': severity,
'title': f'🔧 Mantenimiento Requerido: {equipment["name"]}',
'message': f'Equipo {equipment["name"]} requiere mantenimiento en {days_to_maintenance} días.',
'actions': ['Programar mantenimiento', 'Revisar historial', 'Preparar repuestos', 'Planificar parada'],
'metadata': {
'equipment_id': str(equipment['id']),
'days_to_maintenance': days_to_maintenance,
'last_maintenance': equipment.get('last_maintenance').isoformat() if equipment.get('last_maintenance') else None
}
}, item_type='alert')
elif efficiency < 80:
severity = 'medium' if efficiency < 70 else 'low'
await self.publish_item(equipment['tenant_id'], {
'type': 'low_equipment_efficiency',
'severity': severity,
'title': f'📉 Baja Eficiencia: {equipment["name"]}',
'message': f'Eficiencia del {equipment["name"]} bajó a {efficiency:.1f}%. Revisar funcionamiento.',
'actions': ['Revisar configuración', 'Limpiar equipo', 'Calibrar sensores', 'Revisar mantenimiento'],
'metadata': {
'equipment_id': str(equipment['id']),
'efficiency_percent': float(efficiency),
'temperature': equipment.get('temperature'),
'vibration_level': equipment.get('vibration_level')
}
}, item_type='alert')
except Exception as e:
logger.error("Error processing equipment issue",
equipment_id=str(equipment.get('id')),
error=str(e))
async def generate_efficiency_recommendations(self):
"""Generate production efficiency recommendations"""
try:
self._checks_performed += 1
# Analyze production patterns for efficiency opportunities
query = """
WITH efficiency_analysis AS (
SELECT
pb.tenant_id, pb.product_name,
AVG(EXTRACT(minutes FROM (pb.actual_completion_time - pb.actual_start_time))) as avg_production_time,
AVG(pb.planned_duration_minutes) as avg_planned_duration,
COUNT(*) as batch_count,
AVG(pb.yield_percentage) as avg_yield,
EXTRACT(hour FROM pb.actual_start_time) as start_hour
FROM production_batches pb
WHERE pb.status = 'completed'
AND pb.actual_completion_time > CURRENT_DATE - INTERVAL '30 days'
AND pb.tenant_id = $1
GROUP BY pb.tenant_id, pb.product_name, EXTRACT(hour FROM pb.actual_start_time)
HAVING COUNT(*) >= 3
),
recommendations AS (
SELECT *,
CASE
WHEN avg_production_time > avg_planned_duration * 1.2 THEN 'reduce_production_time'
WHEN avg_yield < 85 THEN 'improve_yield'
WHEN start_hour BETWEEN 14 AND 16 AND avg_production_time > avg_planned_duration * 1.1 THEN 'avoid_afternoon_production'
ELSE null
END as recommendation_type,
(avg_production_time - avg_planned_duration) / avg_planned_duration * 100 as efficiency_loss_percent
FROM efficiency_analysis
)
SELECT * FROM recommendations
WHERE recommendation_type IS NOT NULL
AND efficiency_loss_percent > 10
ORDER BY efficiency_loss_percent DESC
"""
tenants = await self.get_active_tenants()
for tenant_id in tenants:
try:
from sqlalchemy import text
async with self.db_manager.get_session() as session:
result = await session.execute(text(query), {"tenant_id": tenant_id})
recommendations = result.fetchall()
for rec in recommendations:
await self._generate_efficiency_recommendation(tenant_id, rec)
except Exception as e:
logger.error("Error generating efficiency recommendations",
tenant_id=str(tenant_id),
error=str(e))
except Exception as e:
logger.error("Efficiency recommendations failed", error=str(e))
self._errors_count += 1
async def _generate_efficiency_recommendation(self, tenant_id: UUID, rec: Dict[str, Any]):
"""Generate specific efficiency recommendation"""
try:
if not self.should_send_recommendation(tenant_id, rec['recommendation_type']):
return
rec_type = rec['recommendation_type']
efficiency_loss = rec['efficiency_loss_percent']
if rec_type == 'reduce_production_time':
template_data = self.format_spanish_message(
'production_efficiency',
suggested_time=f"{rec['start_hour']:02d}:00",
savings_percent=efficiency_loss
)
await self.publish_item(tenant_id, {
'type': 'production_efficiency',
'severity': 'medium',
'title': template_data['title'],
'message': template_data['message'],
'actions': template_data['actions'],
'metadata': {
'product_name': rec['product_name'],
'avg_production_time': float(rec['avg_production_time']),
'avg_planned_duration': float(rec['avg_planned_duration']),
'efficiency_loss_percent': float(efficiency_loss),
'batch_count': rec['batch_count'],
'recommendation_type': rec_type
}
}, item_type='recommendation')
elif rec_type == 'improve_yield':
await self.publish_item(tenant_id, {
'type': 'yield_improvement',
'severity': 'medium',
'title': f'📈 Mejorar Rendimiento: {rec["product_name"]}',
'message': f'Rendimiento promedio del {rec["product_name"]} es {rec["avg_yield"]:.1f}%. Oportunidad de mejora.',
'actions': ['Revisar receta', 'Optimizar proceso', 'Entrenar personal', 'Verificar ingredientes'],
'metadata': {
'product_name': rec['product_name'],
'avg_yield': float(rec['avg_yield']),
'batch_count': rec['batch_count'],
'recommendation_type': rec_type
}
}, item_type='recommendation')
elif rec_type == 'avoid_afternoon_production':
await self.publish_item(tenant_id, {
'type': 'schedule_optimization',
'severity': 'low',
'title': f'⏰ Optimizar Horario: {rec["product_name"]}',
'message': f'Producción de {rec["product_name"]} en horario {rec["start_hour"]}:00 muestra menor eficiencia.',
'actions': ['Cambiar horario', 'Analizar causas', 'Revisar personal', 'Optimizar ambiente'],
'metadata': {
'product_name': rec['product_name'],
'start_hour': rec['start_hour'],
'efficiency_loss_percent': float(efficiency_loss),
'recommendation_type': rec_type
}
}, item_type='recommendation')
except Exception as e:
logger.error("Error generating efficiency recommendation",
product_name=rec.get('product_name'),
error=str(e))
async def generate_energy_recommendations(self):
"""Generate energy optimization recommendations"""
try:
# Analyze energy consumption patterns
query = """
SELECT
e.tenant_id, e.name as equipment_name, e.type,
AVG(ec.energy_consumption_kwh) as avg_energy,
EXTRACT(hour FROM ec.recorded_at) as hour_of_day,
COUNT(*) as readings_count
FROM equipment e
JOIN energy_consumption ec ON ec.equipment_id = e.id
WHERE ec.recorded_at > CURRENT_DATE - INTERVAL '30 days'
AND e.tenant_id = $1
GROUP BY e.tenant_id, e.id, EXTRACT(hour FROM ec.recorded_at)
HAVING COUNT(*) >= 10
ORDER BY avg_energy DESC
"""
tenants = await self.get_active_tenants()
for tenant_id in tenants:
try:
from sqlalchemy import text
async with self.db_manager.get_session() as session:
result = await session.execute(text(query), {"tenant_id": tenant_id})
energy_data = result.fetchall()
# Analyze for peak hours and optimization opportunities
await self._analyze_energy_patterns(tenant_id, energy_data)
except Exception as e:
logger.error("Error generating energy recommendations",
tenant_id=str(tenant_id),
error=str(e))
except Exception as e:
logger.error("Energy recommendations failed", error=str(e))
self._errors_count += 1
async def _analyze_energy_patterns(self, tenant_id: UUID, energy_data: List[Dict[str, Any]]):
"""Analyze energy consumption patterns for optimization"""
try:
if not energy_data:
return
# Group by equipment and find peak hours
equipment_data = {}
for record in energy_data:
equipment = record['equipment_name']
if equipment not in equipment_data:
equipment_data[equipment] = []
equipment_data[equipment].append(record)
for equipment, records in equipment_data.items():
# Find peak consumption hours
peak_hour_record = max(records, key=lambda x: x['avg_energy'])
off_peak_records = [r for r in records if r['hour_of_day'] < 7 or r['hour_of_day'] > 22]
if off_peak_records and peak_hour_record['avg_energy'] > 0:
min_off_peak = min(off_peak_records, key=lambda x: x['avg_energy'])
potential_savings = ((peak_hour_record['avg_energy'] - min_off_peak['avg_energy']) /
peak_hour_record['avg_energy']) * 100
if potential_savings > 15: # More than 15% potential savings
template_data = self.format_spanish_message(
'energy_optimization',
start_time=f"{min_off_peak['hour_of_day']:02d}:00",
end_time=f"{min_off_peak['hour_of_day']+2:02d}:00",
savings_euros=potential_savings * 0.15 # Rough estimate
)
await self.publish_item(tenant_id, {
'type': 'energy_optimization',
'severity': 'low',
'title': template_data['title'],
'message': template_data['message'],
'actions': template_data['actions'],
'metadata': {
'equipment_name': equipment,
'peak_hour': peak_hour_record['hour_of_day'],
'optimal_hour': min_off_peak['hour_of_day'],
'potential_savings_percent': float(potential_savings),
'peak_consumption': float(peak_hour_record['avg_energy']),
'optimal_consumption': float(min_off_peak['avg_energy'])
}
}, item_type='recommendation')
except Exception as e:
logger.error("Error analyzing energy patterns", error=str(e))
async def register_db_listeners(self, conn):
"""Register production-specific database listeners"""
try:
await conn.add_listener('production_alerts', self.handle_production_db_alert)
logger.info("Database listeners registered",
service=self.config.SERVICE_NAME)
except Exception as e:
logger.error("Failed to register database listeners",
service=self.config.SERVICE_NAME,
error=str(e))
async def handle_production_db_alert(self, connection, pid, channel, payload):
"""Handle production alert from database trigger"""
try:
data = json.loads(payload)
tenant_id = UUID(data['tenant_id'])
template_data = self.format_spanish_message(
'production_delay',
batch_name=f"{data['product_name']} #{data.get('batch_number', 'N/A')}",
delay_minutes=data['delay_minutes']
)
await self.publish_item(tenant_id, {
'type': 'production_delay',
'severity': 'high',
'title': template_data['title'],
'message': template_data['message'],
'actions': template_data['actions'],
'metadata': {
'batch_id': data['batch_id'],
'delay_minutes': data['delay_minutes'],
'trigger_source': 'database'
}
}, item_type='alert')
except Exception as e:
logger.error("Error handling production DB alert", error=str(e))
async def start_event_listener(self):
"""Listen for production-affecting events"""
try:
# Subscribe to inventory events that might affect production
await self.rabbitmq_client.consume_events(
"bakery_events",
f"production.inventory.{self.config.SERVICE_NAME}",
"inventory.critical_shortage",
self.handle_inventory_shortage
)
logger.info("Event listeners started",
service=self.config.SERVICE_NAME)
except Exception as e:
logger.error("Failed to start event listeners",
service=self.config.SERVICE_NAME,
error=str(e))
async def handle_inventory_shortage(self, message):
"""Handle critical inventory shortage affecting production"""
try:
shortage = json.loads(message.body)
tenant_id = UUID(shortage['tenant_id'])
# Check if this ingredient affects any current production
affected_batches = await self.get_affected_production_batches(
shortage['ingredient_id']
)
if affected_batches:
await self.publish_item(tenant_id, {
'type': 'production_ingredient_shortage',
'severity': 'high',
'title': f'🚨 Falta Ingrediente para Producción',
'message': f'Escasez de {shortage["ingredient_name"]} afecta {len(affected_batches)} lotes en producción.',
'actions': ['Buscar ingrediente alternativo', 'Pausar producción', 'Contactar proveedor urgente', 'Reorganizar plan'],
'metadata': {
'ingredient_id': shortage['ingredient_id'],
'ingredient_name': shortage['ingredient_name'],
'affected_batches': [str(b) for b in affected_batches],
'shortage_amount': shortage.get('shortage_amount', 0)
}
}, item_type='alert')
except Exception as e:
logger.error("Error handling inventory shortage event", error=str(e))
async def get_affected_production_batches(self, ingredient_id: str) -> List[str]:
"""Get production batches affected by ingredient shortage"""
try:
query = """
SELECT DISTINCT pb.id
FROM production_batches pb
JOIN recipe_ingredients ri ON ri.recipe_id = pb.recipe_id
WHERE ri.ingredient_id = $1
AND pb.status IN ('planned', 'in_progress')
AND pb.planned_completion_time > NOW()
"""
from sqlalchemy import text
async with self.db_manager.get_session() as session:
result_rows = await session.execute(text(query), {"ingredient_id": ingredient_id})
result = result_rows.fetchall()
return [str(row['id']) for row in result]
except Exception as e:
logger.error("Error getting affected production batches",
ingredient_id=ingredient_id,
error=str(e))
return []

8
services/production/requirements.txt
View File

@@ -15,6 +15,14 @@ httpx==0.25.2
# Logging and monitoring
structlog==23.2.0
prometheus-client==0.19.0
# Message queues and Redis
aio-pika==9.3.1
redis>=4.0.0
# Scheduling
APScheduler==3.10.4
# Date and time utilities
python-dateutil==2.8.2