refactor: migrate modules from re-exports to canonical implementations
Move actual code implementations into module directories: - orders: 5 services, 4 models, order/invoice schemas - inventory: 3 services, 2 models, 30+ schemas - customers: 3 services, 2 models, customer schemas - messaging: 3 services, 2 models, message/notification schemas - monitoring: background_tasks_service - marketplace: 5+ services including letzshop submodule - dev_tools: code_quality_service, test_runner_service - billing: billing_service - contracts: definition.py Legacy files in app/services/, models/database/, models/schema/ now re-export from canonical module locations for backwards compatibility. Architecture validator passes with 0 errors. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
@@ -1,701 +1,37 @@
|
||||
# app/services/admin_notification_service.py
|
||||
"""
|
||||
Admin notification service.
|
||||
LEGACY LOCATION - Re-exports from module for backwards compatibility.
|
||||
|
||||
Provides functionality for:
|
||||
- Creating and managing admin notifications
|
||||
- Managing platform alerts
|
||||
- Notification statistics and queries
|
||||
The canonical implementation is now in:
|
||||
app/modules/messaging/services/admin_notification_service.py
|
||||
|
||||
This file exists to maintain backwards compatibility with code that
|
||||
imports from the old location. All new code should import directly
|
||||
from the module:
|
||||
|
||||
from app.modules.messaging.services import admin_notification_service
|
||||
"""
|
||||
|
||||
import logging
|
||||
from datetime import datetime, timedelta
|
||||
from typing import Any
|
||||
|
||||
from sqlalchemy import and_, case, func, or_
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from models.database.admin import AdminNotification, PlatformAlert
|
||||
from models.schema.admin import AdminNotificationCreate, PlatformAlertCreate
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# NOTIFICATION TYPES
|
||||
# ============================================================================
|
||||
|
||||
class NotificationType:
|
||||
"""Notification type constants."""
|
||||
|
||||
SYSTEM_ALERT = "system_alert"
|
||||
IMPORT_FAILURE = "import_failure"
|
||||
EXPORT_FAILURE = "export_failure"
|
||||
ORDER_SYNC_FAILURE = "order_sync_failure"
|
||||
VENDOR_ISSUE = "vendor_issue"
|
||||
CUSTOMER_MESSAGE = "customer_message"
|
||||
VENDOR_MESSAGE = "vendor_message"
|
||||
SECURITY_ALERT = "security_alert"
|
||||
PERFORMANCE_ALERT = "performance_alert"
|
||||
ORDER_EXCEPTION = "order_exception"
|
||||
CRITICAL_ERROR = "critical_error"
|
||||
|
||||
|
||||
class Priority:
|
||||
"""Priority level constants."""
|
||||
|
||||
LOW = "low"
|
||||
NORMAL = "normal"
|
||||
HIGH = "high"
|
||||
CRITICAL = "critical"
|
||||
|
||||
|
||||
class AlertType:
|
||||
"""Platform alert type constants."""
|
||||
|
||||
SECURITY = "security"
|
||||
PERFORMANCE = "performance"
|
||||
CAPACITY = "capacity"
|
||||
INTEGRATION = "integration"
|
||||
DATABASE = "database"
|
||||
SYSTEM = "system"
|
||||
|
||||
|
||||
class Severity:
|
||||
"""Alert severity constants."""
|
||||
|
||||
INFO = "info"
|
||||
WARNING = "warning"
|
||||
ERROR = "error"
|
||||
CRITICAL = "critical"
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# ADMIN NOTIFICATION SERVICE
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class AdminNotificationService:
|
||||
"""Service for managing admin notifications."""
|
||||
|
||||
def create_notification(
|
||||
self,
|
||||
db: Session,
|
||||
notification_type: str,
|
||||
title: str,
|
||||
message: str,
|
||||
priority: str = Priority.NORMAL,
|
||||
action_required: bool = False,
|
||||
action_url: str | None = None,
|
||||
metadata: dict[str, Any] | None = None,
|
||||
) -> AdminNotification:
|
||||
"""
|
||||
Create a new admin notification.
|
||||
|
||||
Args:
|
||||
db: Database session
|
||||
notification_type: Type of notification
|
||||
title: Notification title
|
||||
message: Notification message
|
||||
priority: Priority level (low, normal, high, critical)
|
||||
action_required: Whether action is required
|
||||
action_url: URL to relevant admin page
|
||||
metadata: Additional contextual data
|
||||
|
||||
Returns:
|
||||
Created AdminNotification
|
||||
"""
|
||||
notification = AdminNotification(
|
||||
type=notification_type,
|
||||
title=title,
|
||||
message=message,
|
||||
priority=priority,
|
||||
action_required=action_required,
|
||||
action_url=action_url,
|
||||
notification_metadata=metadata,
|
||||
)
|
||||
db.add(notification)
|
||||
db.flush()
|
||||
|
||||
logger.info(
|
||||
f"Created notification: {notification_type} - {title} (priority: {priority})"
|
||||
)
|
||||
|
||||
return notification
|
||||
|
||||
def create_from_schema(
|
||||
self,
|
||||
db: Session,
|
||||
data: AdminNotificationCreate,
|
||||
) -> AdminNotification:
|
||||
"""Create notification from Pydantic schema."""
|
||||
return self.create_notification(
|
||||
db=db,
|
||||
notification_type=data.type,
|
||||
title=data.title,
|
||||
message=data.message,
|
||||
priority=data.priority,
|
||||
action_required=data.action_required,
|
||||
action_url=data.action_url,
|
||||
metadata=data.metadata,
|
||||
)
|
||||
|
||||
def get_notifications(
|
||||
self,
|
||||
db: Session,
|
||||
priority: str | None = None,
|
||||
is_read: bool | None = None,
|
||||
notification_type: str | None = None,
|
||||
skip: int = 0,
|
||||
limit: int = 50,
|
||||
) -> tuple[list[AdminNotification], int, int]:
|
||||
"""
|
||||
Get paginated admin notifications.
|
||||
|
||||
Returns:
|
||||
Tuple of (notifications, total_count, unread_count)
|
||||
"""
|
||||
query = db.query(AdminNotification)
|
||||
|
||||
# Apply filters
|
||||
if priority:
|
||||
query = query.filter(AdminNotification.priority == priority)
|
||||
|
||||
if is_read is not None:
|
||||
query = query.filter(AdminNotification.is_read == is_read)
|
||||
|
||||
if notification_type:
|
||||
query = query.filter(AdminNotification.type == notification_type)
|
||||
|
||||
# Get counts
|
||||
total = query.count()
|
||||
unread_count = (
|
||||
db.query(AdminNotification)
|
||||
.filter(AdminNotification.is_read == False) # noqa: E712
|
||||
.count()
|
||||
)
|
||||
|
||||
# Get paginated results ordered by priority and date
|
||||
priority_order = case(
|
||||
(AdminNotification.priority == "critical", 1),
|
||||
(AdminNotification.priority == "high", 2),
|
||||
(AdminNotification.priority == "normal", 3),
|
||||
(AdminNotification.priority == "low", 4),
|
||||
else_=5,
|
||||
)
|
||||
|
||||
notifications = (
|
||||
query.order_by(
|
||||
AdminNotification.is_read, # Unread first
|
||||
priority_order,
|
||||
AdminNotification.created_at.desc(),
|
||||
)
|
||||
.offset(skip)
|
||||
.limit(limit)
|
||||
.all()
|
||||
)
|
||||
|
||||
return notifications, total, unread_count
|
||||
|
||||
def get_unread_count(self, db: Session) -> int:
|
||||
"""Get count of unread notifications."""
|
||||
return (
|
||||
db.query(AdminNotification)
|
||||
.filter(AdminNotification.is_read == False) # noqa: E712
|
||||
.count()
|
||||
)
|
||||
|
||||
def get_recent_notifications(
|
||||
self,
|
||||
db: Session,
|
||||
limit: int = 5,
|
||||
) -> list[AdminNotification]:
|
||||
"""Get recent unread notifications for header dropdown."""
|
||||
priority_order = case(
|
||||
(AdminNotification.priority == "critical", 1),
|
||||
(AdminNotification.priority == "high", 2),
|
||||
(AdminNotification.priority == "normal", 3),
|
||||
(AdminNotification.priority == "low", 4),
|
||||
else_=5,
|
||||
)
|
||||
|
||||
return (
|
||||
db.query(AdminNotification)
|
||||
.filter(AdminNotification.is_read == False) # noqa: E712
|
||||
.order_by(priority_order, AdminNotification.created_at.desc())
|
||||
.limit(limit)
|
||||
.all()
|
||||
)
|
||||
|
||||
def mark_as_read(
|
||||
self,
|
||||
db: Session,
|
||||
notification_id: int,
|
||||
user_id: int,
|
||||
) -> AdminNotification | None:
|
||||
"""Mark a notification as read."""
|
||||
notification = (
|
||||
db.query(AdminNotification)
|
||||
.filter(AdminNotification.id == notification_id)
|
||||
.first()
|
||||
)
|
||||
|
||||
if notification and not notification.is_read:
|
||||
notification.is_read = True
|
||||
notification.read_at = datetime.utcnow()
|
||||
notification.read_by_user_id = user_id
|
||||
db.flush()
|
||||
|
||||
return notification
|
||||
|
||||
def mark_all_as_read(
|
||||
self,
|
||||
db: Session,
|
||||
user_id: int,
|
||||
) -> int:
|
||||
"""Mark all unread notifications as read. Returns count of updated."""
|
||||
now = datetime.utcnow()
|
||||
count = (
|
||||
db.query(AdminNotification)
|
||||
.filter(AdminNotification.is_read == False) # noqa: E712
|
||||
.update(
|
||||
{
|
||||
AdminNotification.is_read: True,
|
||||
AdminNotification.read_at: now,
|
||||
AdminNotification.read_by_user_id: user_id,
|
||||
}
|
||||
)
|
||||
)
|
||||
db.flush()
|
||||
return count
|
||||
|
||||
def delete_old_notifications(
|
||||
self,
|
||||
db: Session,
|
||||
days: int = 30,
|
||||
) -> int:
|
||||
"""Delete notifications older than specified days."""
|
||||
cutoff = datetime.utcnow() - timedelta(days=days)
|
||||
count = (
|
||||
db.query(AdminNotification)
|
||||
.filter(
|
||||
and_(
|
||||
AdminNotification.is_read == True, # noqa: E712
|
||||
AdminNotification.created_at < cutoff,
|
||||
)
|
||||
)
|
||||
.delete()
|
||||
)
|
||||
db.flush()
|
||||
return count
|
||||
|
||||
def delete_notification(
|
||||
self,
|
||||
db: Session,
|
||||
notification_id: int,
|
||||
) -> bool:
|
||||
"""
|
||||
Delete a notification by ID.
|
||||
|
||||
Returns:
|
||||
True if notification was deleted, False if not found.
|
||||
"""
|
||||
notification = (
|
||||
db.query(AdminNotification)
|
||||
.filter(AdminNotification.id == notification_id)
|
||||
.first()
|
||||
)
|
||||
|
||||
if notification:
|
||||
db.delete(notification)
|
||||
db.flush()
|
||||
logger.info(f"Deleted notification {notification_id}")
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
# =========================================================================
|
||||
# CONVENIENCE METHODS FOR CREATING SPECIFIC NOTIFICATION TYPES
|
||||
# =========================================================================
|
||||
|
||||
def notify_import_failure(
|
||||
self,
|
||||
db: Session,
|
||||
vendor_name: str,
|
||||
job_id: int,
|
||||
error_message: str,
|
||||
vendor_id: int | None = None,
|
||||
) -> AdminNotification:
|
||||
"""Create notification for import job failure."""
|
||||
return self.create_notification(
|
||||
db=db,
|
||||
notification_type=NotificationType.IMPORT_FAILURE,
|
||||
title=f"Import Failed: {vendor_name}",
|
||||
message=error_message,
|
||||
priority=Priority.HIGH,
|
||||
action_required=True,
|
||||
action_url=f"/admin/marketplace/letzshop?vendor_id={vendor_id}&tab=jobs"
|
||||
if vendor_id
|
||||
else "/admin/marketplace",
|
||||
metadata={"vendor_name": vendor_name, "job_id": job_id, "vendor_id": vendor_id},
|
||||
)
|
||||
|
||||
def notify_order_sync_failure(
|
||||
self,
|
||||
db: Session,
|
||||
vendor_name: str,
|
||||
error_message: str,
|
||||
vendor_id: int | None = None,
|
||||
) -> AdminNotification:
|
||||
"""Create notification for order sync failure."""
|
||||
return self.create_notification(
|
||||
db=db,
|
||||
notification_type=NotificationType.ORDER_SYNC_FAILURE,
|
||||
title=f"Order Sync Failed: {vendor_name}",
|
||||
message=error_message,
|
||||
priority=Priority.HIGH,
|
||||
action_required=True,
|
||||
action_url=f"/admin/marketplace/letzshop?vendor_id={vendor_id}&tab=jobs"
|
||||
if vendor_id
|
||||
else "/admin/marketplace/letzshop",
|
||||
metadata={"vendor_name": vendor_name, "vendor_id": vendor_id},
|
||||
)
|
||||
|
||||
def notify_order_exception(
|
||||
self,
|
||||
db: Session,
|
||||
vendor_name: str,
|
||||
order_number: str,
|
||||
exception_count: int,
|
||||
vendor_id: int | None = None,
|
||||
) -> AdminNotification:
|
||||
"""Create notification for order item exceptions."""
|
||||
return self.create_notification(
|
||||
db=db,
|
||||
notification_type=NotificationType.ORDER_EXCEPTION,
|
||||
title=f"Order Exception: {order_number}",
|
||||
message=f"{exception_count} item(s) need attention for order {order_number} ({vendor_name})",
|
||||
priority=Priority.NORMAL,
|
||||
action_required=True,
|
||||
action_url=f"/admin/marketplace/letzshop?vendor_id={vendor_id}&tab=exceptions"
|
||||
if vendor_id
|
||||
else "/admin/marketplace/letzshop",
|
||||
metadata={
|
||||
"vendor_name": vendor_name,
|
||||
"order_number": order_number,
|
||||
"exception_count": exception_count,
|
||||
"vendor_id": vendor_id,
|
||||
},
|
||||
)
|
||||
|
||||
def notify_critical_error(
|
||||
self,
|
||||
db: Session,
|
||||
error_type: str,
|
||||
error_message: str,
|
||||
details: dict[str, Any] | None = None,
|
||||
) -> AdminNotification:
|
||||
"""Create notification for critical application errors."""
|
||||
return self.create_notification(
|
||||
db=db,
|
||||
notification_type=NotificationType.CRITICAL_ERROR,
|
||||
title=f"Critical Error: {error_type}",
|
||||
message=error_message,
|
||||
priority=Priority.CRITICAL,
|
||||
action_required=True,
|
||||
action_url="/admin/logs",
|
||||
metadata=details,
|
||||
)
|
||||
|
||||
def notify_vendor_issue(
|
||||
self,
|
||||
db: Session,
|
||||
vendor_name: str,
|
||||
issue_type: str,
|
||||
message: str,
|
||||
vendor_id: int | None = None,
|
||||
) -> AdminNotification:
|
||||
"""Create notification for vendor-related issues."""
|
||||
return self.create_notification(
|
||||
db=db,
|
||||
notification_type=NotificationType.VENDOR_ISSUE,
|
||||
title=f"Vendor Issue: {vendor_name}",
|
||||
message=message,
|
||||
priority=Priority.HIGH,
|
||||
action_required=True,
|
||||
action_url=f"/admin/vendors/{vendor_id}" if vendor_id else "/admin/vendors",
|
||||
metadata={
|
||||
"vendor_name": vendor_name,
|
||||
"issue_type": issue_type,
|
||||
"vendor_id": vendor_id,
|
||||
},
|
||||
)
|
||||
|
||||
def notify_security_alert(
|
||||
self,
|
||||
db: Session,
|
||||
title: str,
|
||||
message: str,
|
||||
details: dict[str, Any] | None = None,
|
||||
) -> AdminNotification:
|
||||
"""Create notification for security-related alerts."""
|
||||
return self.create_notification(
|
||||
db=db,
|
||||
notification_type=NotificationType.SECURITY_ALERT,
|
||||
title=title,
|
||||
message=message,
|
||||
priority=Priority.CRITICAL,
|
||||
action_required=True,
|
||||
action_url="/admin/audit",
|
||||
metadata=details,
|
||||
)
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# PLATFORM ALERT SERVICE
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class PlatformAlertService:
|
||||
"""Service for managing platform-wide alerts."""
|
||||
|
||||
def create_alert(
|
||||
self,
|
||||
db: Session,
|
||||
alert_type: str,
|
||||
severity: str,
|
||||
title: str,
|
||||
description: str | None = None,
|
||||
affected_vendors: list[int] | None = None,
|
||||
affected_systems: list[str] | None = None,
|
||||
auto_generated: bool = True,
|
||||
) -> PlatformAlert:
|
||||
"""Create a new platform alert."""
|
||||
now = datetime.utcnow()
|
||||
|
||||
alert = PlatformAlert(
|
||||
alert_type=alert_type,
|
||||
severity=severity,
|
||||
title=title,
|
||||
description=description,
|
||||
affected_vendors=affected_vendors,
|
||||
affected_systems=affected_systems,
|
||||
auto_generated=auto_generated,
|
||||
first_occurred_at=now,
|
||||
last_occurred_at=now,
|
||||
)
|
||||
db.add(alert)
|
||||
db.flush()
|
||||
|
||||
logger.info(f"Created platform alert: {alert_type} - {title} ({severity})")
|
||||
|
||||
return alert
|
||||
|
||||
def create_from_schema(
|
||||
self,
|
||||
db: Session,
|
||||
data: PlatformAlertCreate,
|
||||
) -> PlatformAlert:
|
||||
"""Create alert from Pydantic schema."""
|
||||
return self.create_alert(
|
||||
db=db,
|
||||
alert_type=data.alert_type,
|
||||
severity=data.severity,
|
||||
title=data.title,
|
||||
description=data.description,
|
||||
affected_vendors=data.affected_vendors,
|
||||
affected_systems=data.affected_systems,
|
||||
auto_generated=data.auto_generated,
|
||||
)
|
||||
|
||||
def get_alerts(
|
||||
self,
|
||||
db: Session,
|
||||
severity: str | None = None,
|
||||
alert_type: str | None = None,
|
||||
is_resolved: bool | None = None,
|
||||
skip: int = 0,
|
||||
limit: int = 50,
|
||||
) -> tuple[list[PlatformAlert], int, int, int]:
|
||||
"""
|
||||
Get paginated platform alerts.
|
||||
|
||||
Returns:
|
||||
Tuple of (alerts, total_count, active_count, critical_count)
|
||||
"""
|
||||
query = db.query(PlatformAlert)
|
||||
|
||||
# Apply filters
|
||||
if severity:
|
||||
query = query.filter(PlatformAlert.severity == severity)
|
||||
|
||||
if alert_type:
|
||||
query = query.filter(PlatformAlert.alert_type == alert_type)
|
||||
|
||||
if is_resolved is not None:
|
||||
query = query.filter(PlatformAlert.is_resolved == is_resolved)
|
||||
|
||||
# Get counts
|
||||
total = query.count()
|
||||
active_count = (
|
||||
db.query(PlatformAlert)
|
||||
.filter(PlatformAlert.is_resolved == False) # noqa: E712
|
||||
.count()
|
||||
)
|
||||
critical_count = (
|
||||
db.query(PlatformAlert)
|
||||
.filter(
|
||||
and_(
|
||||
PlatformAlert.is_resolved == False, # noqa: E712
|
||||
PlatformAlert.severity == Severity.CRITICAL,
|
||||
)
|
||||
)
|
||||
.count()
|
||||
)
|
||||
|
||||
# Get paginated results
|
||||
severity_order = case(
|
||||
(PlatformAlert.severity == "critical", 1),
|
||||
(PlatformAlert.severity == "error", 2),
|
||||
(PlatformAlert.severity == "warning", 3),
|
||||
(PlatformAlert.severity == "info", 4),
|
||||
else_=5,
|
||||
)
|
||||
|
||||
alerts = (
|
||||
query.order_by(
|
||||
PlatformAlert.is_resolved, # Unresolved first
|
||||
severity_order,
|
||||
PlatformAlert.last_occurred_at.desc(),
|
||||
)
|
||||
.offset(skip)
|
||||
.limit(limit)
|
||||
.all()
|
||||
)
|
||||
|
||||
return alerts, total, active_count, critical_count
|
||||
|
||||
def resolve_alert(
|
||||
self,
|
||||
db: Session,
|
||||
alert_id: int,
|
||||
user_id: int,
|
||||
resolution_notes: str | None = None,
|
||||
) -> PlatformAlert | None:
|
||||
"""Resolve a platform alert."""
|
||||
alert = db.query(PlatformAlert).filter(PlatformAlert.id == alert_id).first()
|
||||
|
||||
if alert and not alert.is_resolved:
|
||||
alert.is_resolved = True
|
||||
alert.resolved_at = datetime.utcnow()
|
||||
alert.resolved_by_user_id = user_id
|
||||
alert.resolution_notes = resolution_notes
|
||||
db.flush()
|
||||
|
||||
logger.info(f"Resolved platform alert {alert_id}")
|
||||
|
||||
return alert
|
||||
|
||||
def get_statistics(self, db: Session) -> dict[str, int]:
|
||||
"""Get alert statistics."""
|
||||
today_start = datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0)
|
||||
|
||||
total = db.query(PlatformAlert).count()
|
||||
active = (
|
||||
db.query(PlatformAlert)
|
||||
.filter(PlatformAlert.is_resolved == False) # noqa: E712
|
||||
.count()
|
||||
)
|
||||
critical = (
|
||||
db.query(PlatformAlert)
|
||||
.filter(
|
||||
and_(
|
||||
PlatformAlert.is_resolved == False, # noqa: E712
|
||||
PlatformAlert.severity == Severity.CRITICAL,
|
||||
)
|
||||
)
|
||||
.count()
|
||||
)
|
||||
resolved_today = (
|
||||
db.query(PlatformAlert)
|
||||
.filter(
|
||||
and_(
|
||||
PlatformAlert.is_resolved == True, # noqa: E712
|
||||
PlatformAlert.resolved_at >= today_start,
|
||||
)
|
||||
)
|
||||
.count()
|
||||
)
|
||||
|
||||
return {
|
||||
"total_alerts": total,
|
||||
"active_alerts": active,
|
||||
"critical_alerts": critical,
|
||||
"resolved_today": resolved_today,
|
||||
}
|
||||
|
||||
def increment_occurrence(
|
||||
self,
|
||||
db: Session,
|
||||
alert_id: int,
|
||||
) -> PlatformAlert | None:
|
||||
"""Increment occurrence count for repeated alert."""
|
||||
alert = db.query(PlatformAlert).filter(PlatformAlert.id == alert_id).first()
|
||||
|
||||
if alert:
|
||||
alert.occurrence_count += 1
|
||||
alert.last_occurred_at = datetime.utcnow()
|
||||
db.flush()
|
||||
|
||||
return alert
|
||||
|
||||
def find_similar_active_alert(
|
||||
self,
|
||||
db: Session,
|
||||
alert_type: str,
|
||||
title: str,
|
||||
) -> PlatformAlert | None:
|
||||
"""Find an active alert with same type and title."""
|
||||
return (
|
||||
db.query(PlatformAlert)
|
||||
.filter(
|
||||
and_(
|
||||
PlatformAlert.alert_type == alert_type,
|
||||
PlatformAlert.title == title,
|
||||
PlatformAlert.is_resolved == False, # noqa: E712
|
||||
)
|
||||
)
|
||||
.first()
|
||||
)
|
||||
|
||||
def create_or_increment_alert(
|
||||
self,
|
||||
db: Session,
|
||||
alert_type: str,
|
||||
severity: str,
|
||||
title: str,
|
||||
description: str | None = None,
|
||||
affected_vendors: list[int] | None = None,
|
||||
affected_systems: list[str] | None = None,
|
||||
) -> PlatformAlert:
|
||||
"""Create alert or increment occurrence if similar exists."""
|
||||
existing = self.find_similar_active_alert(db, alert_type, title)
|
||||
|
||||
if existing:
|
||||
self.increment_occurrence(db, existing.id)
|
||||
return existing
|
||||
|
||||
return self.create_alert(
|
||||
db=db,
|
||||
alert_type=alert_type,
|
||||
severity=severity,
|
||||
title=title,
|
||||
description=description,
|
||||
affected_vendors=affected_vendors,
|
||||
affected_systems=affected_systems,
|
||||
)
|
||||
|
||||
|
||||
# Singleton instances
|
||||
admin_notification_service = AdminNotificationService()
|
||||
platform_alert_service = PlatformAlertService()
|
||||
from app.modules.messaging.services.admin_notification_service import (
|
||||
admin_notification_service,
|
||||
AdminNotificationService,
|
||||
platform_alert_service,
|
||||
PlatformAlertService,
|
||||
# Constants
|
||||
NotificationType,
|
||||
Priority,
|
||||
AlertType,
|
||||
Severity,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
"admin_notification_service",
|
||||
"AdminNotificationService",
|
||||
"platform_alert_service",
|
||||
"PlatformAlertService",
|
||||
# Constants
|
||||
"NotificationType",
|
||||
"Priority",
|
||||
"AlertType",
|
||||
"Severity",
|
||||
]
|
||||
|
||||
Reference in New Issue
Block a user