263 lines
10 KiB
Python
263 lines
10 KiB
Python
import logging
|
|
|
|
from celery import shared_task
|
|
from django.utils import timezone
|
|
|
|
from apps.organizations.models import Hospital
|
|
|
|
from .kpi_models import KPIReportType
|
|
from .kpi_service import KPICalculationService
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
@shared_task(bind=True, ignore_result=True)
|
|
def calculate_daily_kpis(self):
|
|
today = timezone.now()
|
|
year = today.year
|
|
month = today.month
|
|
|
|
hospitals = Hospital.objects.filter(status="active")
|
|
report_types = [rt[0] for rt in KPIReportType.choices]
|
|
|
|
for hospital in hospitals:
|
|
for report_type in report_types:
|
|
try:
|
|
KPICalculationService.generate_monthly_report(
|
|
report_type=report_type,
|
|
hospital=hospital,
|
|
year=year,
|
|
month=month,
|
|
)
|
|
logger.info(f"Daily KPI calculated: {report_type} for {hospital.name} ({year}-{month:02d})")
|
|
except Exception as e:
|
|
logger.exception(f"Failed daily KPI: {report_type} for {hospital.name}: {e}")
|
|
|
|
|
|
# =============================================================================
|
|
# AI-Powered Analytics — Async Celery Tasks
|
|
# =============================================================================
|
|
|
|
|
|
@shared_task(bind=True, ignore_result=True, max_retries=2, default_retry_delay=60)
|
|
def generate_executive_summary_task(
|
|
self, user_id=None, hospital_id=None, department_id=None, period="30d", force_refresh=False
|
|
):
|
|
"""
|
|
Async task: Generate AI executive summary and cache it.
|
|
Called by Celery beat daily, or manually when user forces refresh.
|
|
"""
|
|
from apps.analytics.services.ai_analytics import ExecutiveSummaryGenerator
|
|
|
|
# Build a mock user-like object for role scoping (admin sees all)
|
|
class _User:
|
|
def __init__(self, uid):
|
|
self.id = uid
|
|
self.hospital = None
|
|
self.department = None
|
|
|
|
def is_px_admin(self):
|
|
return True
|
|
|
|
user = _User(user_id) if user_id else _User("system")
|
|
|
|
try:
|
|
result = ExecutiveSummaryGenerator.generate(
|
|
user,
|
|
hospital_id=hospital_id,
|
|
department_id=department_id,
|
|
period=period,
|
|
force_refresh=force_refresh,
|
|
)
|
|
logger.info(
|
|
f"Executive summary generated: {period} for hospital={hospital_id}, "
|
|
f"risk={result.get('risk_level', 'unknown')}"
|
|
)
|
|
except Exception as e:
|
|
logger.exception(f"Failed to generate executive summary: {e}")
|
|
self.retry(exc=e)
|
|
|
|
|
|
@shared_task(bind=True, ignore_result=True, max_retries=2, default_retry_delay=60)
|
|
def generate_action_recommendations_task(self, user_id=None, hospital_id=None, department_id=None):
|
|
"""
|
|
Async task: Generate AI action recommendations from complaint clusters.
|
|
"""
|
|
from apps.analytics.services.ai_analytics import ActionRecommendationEngine
|
|
|
|
class _User:
|
|
def __init__(self, uid):
|
|
self.id = uid
|
|
self.hospital = None
|
|
self.department = None
|
|
|
|
def is_px_admin(self):
|
|
return True
|
|
|
|
user = _User(user_id) if user_id else _User("system")
|
|
|
|
try:
|
|
results = ActionRecommendationEngine.generate_recommendations(
|
|
user, hospital_id=hospital_id, department_id=department_id, limit=5
|
|
)
|
|
logger.info(f"Action recommendations generated: {len(results)} recommendations")
|
|
except Exception as e:
|
|
logger.exception(f"Failed to generate action recommendations: {e}")
|
|
self.retry(exc=e)
|
|
|
|
|
|
@shared_task(bind=True, ignore_result=True)
|
|
def precompute_dashboard_cache_task(self):
|
|
"""
|
|
Async task: Pre-compute all cacheable analytics data for all active hospitals.
|
|
Run daily at 3 AM. Users can trigger on-demand refresh via dashboard button.
|
|
"""
|
|
from apps.analytics.services.ai_analytics import (
|
|
ExecutiveSummaryGenerator,
|
|
EarlyWarningSystem,
|
|
ComplaintVolumeForecaster,
|
|
SLABreachPredictor,
|
|
ActionRecommendationEngine,
|
|
)
|
|
from django.contrib.auth import get_user_model
|
|
|
|
User = get_user_model()
|
|
admin_users = User.objects.filter(is_active=True, role="px_admin")
|
|
|
|
if not admin_users.exists():
|
|
# Fallback: use first superuser
|
|
admin_users = User.objects.filter(is_active=True, is_superuser=True)
|
|
|
|
hospitals = list(Hospital.objects.filter(status="active"))
|
|
|
|
for admin in admin_users[:3]: # limit to first 3 admins
|
|
for hospital in hospitals:
|
|
try:
|
|
ExecutiveSummaryGenerator.generate(admin, hospital_id=str(hospital.id), period="30d")
|
|
EarlyWarningSystem.detect(admin, hospital_id=str(hospital.id), limit=5)
|
|
ComplaintVolumeForecaster.forecast(admin, hospital_id=str(hospital.id), forecast_days=30)
|
|
SLABreachPredictor.predict(admin, hospital_id=str(hospital.id), limit=10)
|
|
ActionRecommendationEngine.generate_recommendations(admin, hospital_id=str(hospital.id), limit=5)
|
|
logger.info(f"Precomputed analytics for admin={admin.id}, hospital={hospital.id}")
|
|
except Exception as e:
|
|
logger.exception(f"Failed to precompute for admin={admin.id}, hospital={hospital.id}: {e}")
|
|
|
|
|
|
# =============================================================================
|
|
# Hourly AI Analytics Pre-computation Tasks
|
|
# =============================================================================
|
|
|
|
|
|
def _get_system_admin():
|
|
"""Return a mock admin user for background tasks."""
|
|
|
|
class _User:
|
|
def __init__(self, uid):
|
|
self.id = uid
|
|
self.hospital = None
|
|
self.department = None
|
|
|
|
def is_px_admin(self):
|
|
return True
|
|
|
|
return _User("system")
|
|
|
|
|
|
@shared_task(bind=True, ignore_result=True, max_retries=2, default_retry_delay=60)
|
|
def precompute_executive_summary_task(self, hospital_id=None, period="30d"):
|
|
"""Pre-compute executive summary for a single hospital."""
|
|
from apps.analytics.services.ai_analytics import ExecutiveSummaryGenerator
|
|
|
|
user = _get_system_admin()
|
|
try:
|
|
result = ExecutiveSummaryGenerator.generate(user, hospital_id=hospital_id, period=period, force_refresh=True)
|
|
logger.info(
|
|
f"Precomputed executive summary: period={period} hospital={hospital_id} "
|
|
f"risk={result.get('risk_level', 'unknown')}"
|
|
)
|
|
except Exception as e:
|
|
logger.exception(f"Failed precompute_executive_summary_task: {e}")
|
|
self.retry(exc=e)
|
|
|
|
|
|
@shared_task(bind=True, ignore_result=True, max_retries=2, default_retry_delay=60)
|
|
def precompute_early_warning_task(self, hospital_id=None, limit=5):
|
|
"""Pre-compute early warning system for a single hospital."""
|
|
from apps.analytics.services.ai_analytics import EarlyWarningSystem
|
|
|
|
user = _get_system_admin()
|
|
try:
|
|
results = EarlyWarningSystem.detect(user, hospital_id=hospital_id, limit=limit)
|
|
logger.info(f"Precomputed early warnings: hospital={hospital_id} count={len(results)}")
|
|
except Exception as e:
|
|
logger.exception(f"Failed precompute_early_warning_task: {e}")
|
|
self.retry(exc=e)
|
|
|
|
|
|
@shared_task(bind=True, ignore_result=True, max_retries=2, default_retry_delay=60)
|
|
def precompute_complaint_forecast_task(self, hospital_id=None, forecast_days=30):
|
|
"""Pre-compute complaint volume forecast for a single hospital."""
|
|
from apps.analytics.services.ai_analytics import ComplaintVolumeForecaster
|
|
|
|
user = _get_system_admin()
|
|
try:
|
|
result = ComplaintVolumeForecaster.forecast(user, hospital_id=hospital_id, forecast_days=forecast_days)
|
|
logger.info(f"Precomputed complaint forecast: hospital={hospital_id}")
|
|
except Exception as e:
|
|
logger.exception(f"Failed precompute_complaint_forecast_task: {e}")
|
|
self.retry(exc=e)
|
|
|
|
|
|
@shared_task(bind=True, ignore_result=True, max_retries=2, default_retry_delay=60)
|
|
def precompute_sla_breach_prediction_task(self, hospital_id=None, limit=10):
|
|
"""Pre-compute SLA breach predictions for a single hospital."""
|
|
from apps.analytics.services.ai_analytics import SLABreachPredictor
|
|
|
|
user = _get_system_admin()
|
|
try:
|
|
results = SLABreachPredictor.predict(user, hospital_id=hospital_id, limit=limit)
|
|
logger.info(f"Precomputed SLA breach predictions: hospital={hospital_id} count={len(results)}")
|
|
except Exception as e:
|
|
logger.exception(f"Failed precompute_sla_breach_prediction_task: {e}")
|
|
self.retry(exc=e)
|
|
|
|
|
|
@shared_task(bind=True, ignore_result=True, max_retries=2, default_retry_delay=60)
|
|
def precompute_action_recommendations_task(self, hospital_id=None, limit=5):
|
|
"""Pre-compute action recommendations for a single hospital."""
|
|
from apps.analytics.services.ai_analytics import ActionRecommendationEngine
|
|
|
|
user = _get_system_admin()
|
|
try:
|
|
results = ActionRecommendationEngine.generate_recommendations(user, hospital_id=hospital_id, limit=limit)
|
|
logger.info(f"Precomputed action recommendations: hospital={hospital_id} count={len(results)}")
|
|
except Exception as e:
|
|
logger.exception(f"Failed precompute_action_recommendations_task: {e}")
|
|
self.retry(exc=e)
|
|
|
|
|
|
@shared_task(bind=True, ignore_result=True)
|
|
def precompute_all_ai_analytics_task(self):
|
|
"""
|
|
Master task: pre-compute ALL AI analytics for every active hospital every hour.
|
|
Dispatches sub-tasks per hospital so failures are isolated.
|
|
"""
|
|
hospitals = list(Hospital.objects.filter(status="active").values_list("id", flat=True))
|
|
|
|
for hid in hospitals:
|
|
hospital_id = str(hid)
|
|
precompute_executive_summary_task.delay(hospital_id=hospital_id, period="30d")
|
|
precompute_early_warning_task.delay(hospital_id=hospital_id, limit=5)
|
|
precompute_complaint_forecast_task.delay(hospital_id=hospital_id, forecast_days=30)
|
|
precompute_sla_breach_prediction_task.delay(hospital_id=hospital_id, limit=10)
|
|
precompute_action_recommendations_task.delay(hospital_id=hospital_id, limit=5)
|
|
logger.info(f"Dispatched hourly AI precompute tasks for hospital={hospital_id}")
|
|
|
|
# Also run for global (no hospital filter)
|
|
precompute_executive_summary_task.delay(hospital_id=None, period="30d")
|
|
precompute_early_warning_task.delay(hospital_id=None, limit=5)
|
|
precompute_complaint_forecast_task.delay(hospital_id=None, forecast_days=30)
|
|
precompute_sla_breach_prediction_task.delay(hospital_id=None, limit=10)
|
|
precompute_action_recommendations_task.delay(hospital_id=None, limit=5)
|
|
logger.info("Dispatched hourly AI precompute tasks for global scope")
|