481 lines
16 KiB
Python
481 lines
16 KiB
Python
from collections import Counter
|
|
from copy import deepcopy
|
|
import json
|
|
import logging
|
|
|
|
from django.utils import timezone
|
|
|
|
from external_api_adapter import request as external_api_request
|
|
from farm_hub.models import FarmHub
|
|
from notifications.models import FarmNotification
|
|
from notifications.services import create_notification_for_farm_uuid, get_recent_notifications_for_farm
|
|
|
|
from .defaults import EMPTY_ALERT_TIMELINE, EMPTY_ALERT_TRACKER, EMPTY_ANOMALY_CARD, EMPTY_RECOMMENDATIONS
|
|
from .models import AnomalyDetection, FarmAlert, FarmAlertTrackerSnapshot, Recommendation
|
|
|
|
|
|
LEVEL_ALIAS_MAP = {
|
|
"danger": "error",
|
|
"critical": "error",
|
|
"warn": "warning",
|
|
}
|
|
|
|
TRACKER_AI_NOTIFICATION_SOURCE = "farm_alerts_tracker_ai"
|
|
logger = logging.getLogger("farm_alerts")
|
|
|
|
|
|
class AlertService:
|
|
@staticmethod
|
|
def normalize_level(level):
|
|
normalized = str(level or "info").strip().lower()
|
|
normalized = LEVEL_ALIAS_MAP.get(normalized, normalized)
|
|
if normalized not in {"info", "warning", "error", "success"}:
|
|
return "info"
|
|
return normalized
|
|
|
|
@staticmethod
|
|
def create_alert(
|
|
title: str,
|
|
description: str = "",
|
|
color: str = "info",
|
|
avatar_icon: str = "",
|
|
avatar_color: str = "",
|
|
farm_uuid=None,
|
|
) -> FarmAlert:
|
|
farm = None
|
|
if farm_uuid:
|
|
try:
|
|
farm = FarmHub.objects.get(farm_uuid=farm_uuid)
|
|
except FarmHub.DoesNotExist:
|
|
pass
|
|
|
|
alert = FarmAlert.objects.create(
|
|
farm=farm,
|
|
title=title,
|
|
description=description,
|
|
color=AlertService.normalize_level(color),
|
|
avatar_icon=avatar_icon,
|
|
avatar_color=avatar_color,
|
|
)
|
|
|
|
AlertService._send_notification(alert, farm)
|
|
return alert
|
|
|
|
@staticmethod
|
|
def persist_incoming_alerts(*, farm, alerts):
|
|
saved_alerts = []
|
|
for alert_data in alerts:
|
|
title = alert_data.get("title") or alert_data.get("message") or "Incoming alert"
|
|
level = AlertService.normalize_level(alert_data.get("level"))
|
|
saved_alerts.append(
|
|
FarmAlert.objects.create(
|
|
farm=farm,
|
|
external_alert_id=alert_data.get("alert_id", ""),
|
|
title=title[:255],
|
|
description=alert_data.get("message", ""),
|
|
color=level,
|
|
suggested_action=alert_data.get("suggested_action", ""),
|
|
source_metric_type=alert_data.get("source_metric_type", ""),
|
|
occurred_at=alert_data.get("timestamp"),
|
|
payload=alert_data.get("payload") or {},
|
|
raw_alert=alert_data,
|
|
is_active=level != "success",
|
|
)
|
|
)
|
|
return saved_alerts
|
|
|
|
@staticmethod
|
|
def _send_notification(alert: FarmAlert, farm) -> None:
|
|
if farm is None:
|
|
return
|
|
|
|
FarmNotification.objects.create(
|
|
farm=farm,
|
|
title=alert.title,
|
|
message=alert.description,
|
|
level=alert.color,
|
|
source_alert_id=alert.external_alert_id,
|
|
source_metric_type=alert.source_metric_type,
|
|
suggested_action=alert.suggested_action,
|
|
payload=alert.payload,
|
|
metadata={"alert_uuid": str(alert.uuid), "color": alert.color},
|
|
)
|
|
|
|
|
|
def serialize_notifications_for_ai(*, farm, since_days=3, limit=5):
|
|
notifications = get_recent_notifications_for_farm(farm=farm, since_days=since_days, limit=limit)
|
|
notifications = [item for item in notifications if item.metadata.get("source") != TRACKER_AI_NOTIFICATION_SOURCE]
|
|
return [
|
|
{
|
|
"id": notification.id,
|
|
"farm_uuid": str(notification.farm.farm_uuid),
|
|
"endpoint": notification.endpoint,
|
|
"level": notification.level,
|
|
"title": notification.title,
|
|
"message": notification.message,
|
|
"suggested_action": notification.suggested_action,
|
|
"source_alert_id": notification.source_alert_id,
|
|
"source_metric_type": notification.source_metric_type,
|
|
"payload": notification.payload,
|
|
"created_at": notification.created_at.isoformat(),
|
|
"updated_at": notification.updated_at.isoformat(),
|
|
}
|
|
for notification in notifications
|
|
]
|
|
|
|
|
|
def save_tracker_notifications(*, farm_uuid, notifications):
|
|
saved_notifications = []
|
|
for notification_data in notifications:
|
|
title = notification_data.get("title") or ""
|
|
message = notification_data.get("message") or ""
|
|
if not title and not message:
|
|
continue
|
|
|
|
source_alert_id = notification_data.get("source_alert_id", "")
|
|
existing = FarmNotification.objects.filter(
|
|
farm__farm_uuid=farm_uuid,
|
|
endpoint="tracker",
|
|
title=title,
|
|
message=message,
|
|
source_alert_id=source_alert_id,
|
|
).first()
|
|
if existing:
|
|
saved_notifications.append(existing)
|
|
continue
|
|
|
|
saved_notifications.append(
|
|
create_notification_for_farm_uuid(
|
|
farm_uuid=farm_uuid,
|
|
endpoint="tracker",
|
|
title=title,
|
|
message=message,
|
|
level=AlertService.normalize_level(notification_data.get("level")),
|
|
suggested_action=notification_data.get("suggested_action", ""),
|
|
source_alert_id=source_alert_id,
|
|
source_metric_type=notification_data.get("source_metric_type", ""),
|
|
payload=notification_data.get("payload") or {},
|
|
metadata={"source": TRACKER_AI_NOTIFICATION_SOURCE},
|
|
)
|
|
)
|
|
return saved_notifications
|
|
|
|
|
|
def build_tracker_context(*, farm):
|
|
recent_notifications = serialize_notifications_for_ai(farm=farm, since_days=3, limit=5)
|
|
payload = {"farm_uuid": str(farm.farm_uuid)}
|
|
|
|
if recent_notifications:
|
|
counts = Counter(
|
|
AlertService.normalize_level(notification.get("level"))
|
|
for notification in recent_notifications
|
|
if notification.get("level")
|
|
)
|
|
payload["recent_notifications"] = recent_notifications
|
|
payload["structured_context"] = {
|
|
"farm_uuid": str(farm.farm_uuid),
|
|
"notifications_count": len(recent_notifications),
|
|
"recent_notifications_count": len(recent_notifications),
|
|
"recent_notifications_window_days": 3,
|
|
"recent_notifications_limit": 5,
|
|
"notification_levels": dict(counts),
|
|
}
|
|
|
|
return payload
|
|
|
|
|
|
def serialize_alerts_for_ai(*, farm, since=None, limit=50):
|
|
queryset = FarmAlert.objects.filter(farm=farm).order_by("-created_at", "-id")
|
|
if since is not None:
|
|
queryset = queryset.filter(created_at__gt=since)
|
|
|
|
alerts = queryset[:limit]
|
|
return [
|
|
{
|
|
"alert_id": alert.external_alert_id,
|
|
"level": alert.color,
|
|
"title": alert.title,
|
|
"message": alert.description,
|
|
"suggested_action": alert.suggested_action,
|
|
"source_metric_type": alert.source_metric_type,
|
|
"timestamp": alert.occurred_at.isoformat() if alert.occurred_at else None,
|
|
"payload": alert.payload,
|
|
}
|
|
for alert in alerts
|
|
]
|
|
|
|
|
|
def get_tracker_notifications(*, farm, limit=10):
|
|
return list(
|
|
FarmNotification.objects.filter(farm=farm, endpoint="tracker")
|
|
.order_by("-created_at", "-id")[:limit]
|
|
)
|
|
|
|
|
|
def get_tracker_source_updated_at(*, farm):
|
|
latest_alert = FarmAlert.objects.filter(farm=farm).order_by("-created_at", "-id").values_list("created_at", flat=True).first()
|
|
latest_notification = (
|
|
FarmNotification.objects.filter(farm=farm)
|
|
.exclude(metadata__source=TRACKER_AI_NOTIFICATION_SOURCE)
|
|
.order_by("-updated_at", "-id")
|
|
.values_list("updated_at", flat=True)
|
|
.first()
|
|
)
|
|
candidates = [item for item in (latest_alert, latest_notification) if item is not None]
|
|
if not candidates:
|
|
return None
|
|
return max(candidates)
|
|
|
|
|
|
def get_or_create_tracker_snapshot(*, farm):
|
|
snapshot, _ = FarmAlertTrackerSnapshot.objects.get_or_create(farm=farm)
|
|
return snapshot
|
|
|
|
|
|
def update_tracker_snapshot(*, farm, adapter_payload, source_updated_at):
|
|
snapshot = get_or_create_tracker_snapshot(farm=farm)
|
|
notifications_payload = adapter_payload.get("notifications") or []
|
|
save_tracker_notifications(farm_uuid=farm.farm_uuid, notifications=notifications_payload)
|
|
|
|
raw_llm_response = adapter_payload.get("raw_llm_response", "")
|
|
if not raw_llm_response:
|
|
raw_llm_response = json.dumps(adapter_payload, ensure_ascii=False)
|
|
|
|
snapshot.service_id = adapter_payload.get("service_id", "farm_alerts")
|
|
snapshot.tracker = adapter_payload.get("tracker") or {}
|
|
snapshot.headline = adapter_payload.get("headline", "")
|
|
snapshot.overview = adapter_payload.get("overview", "")
|
|
snapshot.status_level = AlertService.normalize_level(adapter_payload.get("status_level"))
|
|
snapshot.raw_llm_response = raw_llm_response
|
|
snapshot.structured_context = adapter_payload.get("structured_context") or {}
|
|
snapshot.last_ai_synced_at = timezone.now()
|
|
snapshot.last_source_update_at = source_updated_at
|
|
snapshot.save(
|
|
update_fields=[
|
|
"service_id",
|
|
"tracker",
|
|
"headline",
|
|
"overview",
|
|
"status_level",
|
|
"raw_llm_response",
|
|
"structured_context",
|
|
"last_ai_synced_at",
|
|
"last_source_update_at",
|
|
"updated_at",
|
|
]
|
|
)
|
|
return snapshot
|
|
|
|
|
|
def build_tracker_response_from_snapshot(*, farm):
|
|
snapshot = FarmAlertTrackerSnapshot.objects.filter(farm=farm).first()
|
|
notifications = get_tracker_notifications(farm=farm, limit=10)
|
|
if snapshot is None:
|
|
return {
|
|
"farm_uuid": str(farm.farm_uuid),
|
|
"service_id": "farm_alerts",
|
|
"tracker": {},
|
|
"headline": "",
|
|
"overview": "",
|
|
"status_level": "info",
|
|
"notifications": notifications,
|
|
"raw_llm_response": "",
|
|
"structured_context": {},
|
|
}
|
|
|
|
return {
|
|
"farm_uuid": str(farm.farm_uuid),
|
|
"service_id": snapshot.service_id,
|
|
"tracker": snapshot.tracker or {},
|
|
"headline": snapshot.headline,
|
|
"overview": snapshot.overview,
|
|
"status_level": AlertService.normalize_level(snapshot.status_level),
|
|
"notifications": notifications,
|
|
"raw_llm_response": snapshot.raw_llm_response,
|
|
"structured_context": snapshot.structured_context or {},
|
|
}
|
|
|
|
|
|
def sync_farm_tracker_with_ai(*, farm):
|
|
snapshot = FarmAlertTrackerSnapshot.objects.filter(farm=farm).first()
|
|
source_updated_at = get_tracker_source_updated_at(farm=farm)
|
|
if source_updated_at is None:
|
|
logger.info(
|
|
"farm=%s tracker sync proceeding without source data snapshot_exists=%s",
|
|
farm.farm_uuid,
|
|
snapshot is not None,
|
|
)
|
|
|
|
if (
|
|
source_updated_at is not None
|
|
and snapshot is not None
|
|
and snapshot.last_source_update_at is not None
|
|
and source_updated_at <= snapshot.last_source_update_at
|
|
):
|
|
logger.info(
|
|
"farm=%s tracker sync skipped: no changes source_updated_at=%s last_source_update_at=%s",
|
|
farm.farm_uuid,
|
|
source_updated_at,
|
|
snapshot.last_source_update_at,
|
|
)
|
|
return {"farm_uuid": str(farm.farm_uuid), "status": "skipped", "reason": "no_changes"}
|
|
|
|
tracker_payload = build_tracker_context(farm=farm)
|
|
logger.info(
|
|
"farm=%s tracker sync sending AI request recent_notifications=%s payload=%s",
|
|
farm.farm_uuid,
|
|
len(tracker_payload.get("recent_notifications", [])),
|
|
tracker_payload,
|
|
)
|
|
adapter_response = external_api_request(
|
|
"ai",
|
|
"/api/farm-alerts/tracker/",
|
|
method="POST",
|
|
payload=tracker_payload,
|
|
)
|
|
if adapter_response.status_code >= 400:
|
|
logger.warning(
|
|
"farm=%s tracker sync failed status_code=%s response=%s",
|
|
farm.farm_uuid,
|
|
adapter_response.status_code,
|
|
adapter_response.data,
|
|
)
|
|
raise ValueError(f"AI tracker sync failed with status {adapter_response.status_code}.")
|
|
|
|
adapter_data = adapter_response.data if isinstance(adapter_response.data, dict) else {}
|
|
logger.info(
|
|
"farm=%s tracker sync received AI response status_code=%s response=%s",
|
|
farm.farm_uuid,
|
|
adapter_response.status_code,
|
|
adapter_data,
|
|
)
|
|
payload = adapter_data.get("data")
|
|
if isinstance(payload, dict) and isinstance(payload.get("result"), dict):
|
|
payload = payload["result"]
|
|
elif not isinstance(payload, dict):
|
|
payload = adapter_data.get("result") if isinstance(adapter_data.get("result"), dict) else adapter_data
|
|
logger.info(
|
|
"farm=%s tracker sync normalized AI payload=%s",
|
|
farm.farm_uuid,
|
|
payload,
|
|
)
|
|
|
|
update_tracker_snapshot(
|
|
farm=farm,
|
|
adapter_payload=payload or {},
|
|
source_updated_at=source_updated_at,
|
|
)
|
|
logger.info("farm=%s tracker sync completed successfully", farm.farm_uuid)
|
|
return {"farm_uuid": str(farm.farm_uuid), "status": "synced"}
|
|
|
|
|
|
def sync_all_farm_alert_trackers():
|
|
farms = FarmHub.objects.all().order_by("id")
|
|
logger.info("farm alerts sync discovered %s farm(s) to process", farms.count())
|
|
results = []
|
|
for farm in farms:
|
|
results.append(sync_farm_tracker_with_ai(farm=farm))
|
|
return {"processed": len(results), "results": results}
|
|
def get_alert_tracker_data(farm=None):
|
|
if farm is None:
|
|
return deepcopy(EMPTY_ALERT_TRACKER)
|
|
|
|
alerts = list(FarmAlert.objects.filter(farm=farm, is_active=True)[:20])
|
|
if not alerts:
|
|
return deepcopy(EMPTY_ALERT_TRACKER)
|
|
|
|
counts = Counter(alert.title for alert in alerts)
|
|
alert_stats = []
|
|
for title, count in counts.most_common(3):
|
|
sample = next((alert for alert in alerts if alert.title == title), None)
|
|
alert_stats.append(
|
|
{
|
|
"title": title,
|
|
"count": str(count),
|
|
"avatarColor": sample.color if sample else "info",
|
|
"avatarIcon": sample.avatar_icon or "tabler-bell",
|
|
}
|
|
)
|
|
|
|
return {
|
|
"totalAlerts": len(alerts),
|
|
"radialBarValue": min(len(alerts) * 10, 100),
|
|
"alertStats": alert_stats,
|
|
"status": "success",
|
|
"source": "db",
|
|
"warnings": [],
|
|
}
|
|
|
|
|
|
def get_alert_timeline_data(farm=None):
|
|
if farm is None:
|
|
return deepcopy(EMPTY_ALERT_TIMELINE)
|
|
|
|
alerts = list(FarmAlert.objects.filter(farm=farm)[:10])
|
|
if not alerts:
|
|
return deepcopy(EMPTY_ALERT_TIMELINE)
|
|
|
|
return {
|
|
"alerts": [
|
|
{
|
|
"title": alert.title,
|
|
"description": alert.description,
|
|
"time": alert.created_at.strftime("%Y-%m-%d %H:%M"),
|
|
"color": alert.color,
|
|
}
|
|
for alert in alerts
|
|
],
|
|
"status": "success",
|
|
"source": "db",
|
|
"warnings": [],
|
|
}
|
|
|
|
|
|
def get_anomaly_detection_data(farm=None):
|
|
if farm is None:
|
|
return deepcopy(EMPTY_ANOMALY_CARD)
|
|
|
|
anomalies = list(AnomalyDetection.objects.filter(farm=farm)[:10])
|
|
if not anomalies:
|
|
return deepcopy(EMPTY_ANOMALY_CARD)
|
|
|
|
return {
|
|
"anomalies": [
|
|
{
|
|
"sensor": anomaly.sensor,
|
|
"value": anomaly.value,
|
|
"expected": anomaly.expected,
|
|
"deviation": anomaly.deviation,
|
|
"severity": anomaly.severity,
|
|
}
|
|
for anomaly in anomalies
|
|
],
|
|
"status": "success",
|
|
"source": "db",
|
|
"warnings": [],
|
|
}
|
|
|
|
|
|
def get_recommendations_list_data(farm=None):
|
|
if farm is None:
|
|
return deepcopy(EMPTY_RECOMMENDATIONS)
|
|
|
|
recommendations = list(Recommendation.objects.filter(farm=farm)[:10])
|
|
if not recommendations:
|
|
return deepcopy(EMPTY_RECOMMENDATIONS)
|
|
|
|
return {
|
|
"recommendations": [
|
|
{
|
|
"title": recommendation.title,
|
|
"subtitle": recommendation.subtitle,
|
|
"avatarIcon": recommendation.avatar_icon or "tabler-bulb",
|
|
"avatarColor": recommendation.avatar_color or "info",
|
|
}
|
|
for recommendation in recommendations
|
|
],
|
|
"status": "success",
|
|
"source": "db",
|
|
"warnings": [],
|
|
}
|