diff --git a/CHANGELOG.md b/CHANGELOG.md index ce1837b..1e340f6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -37,6 +37,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - **Dashboard** — "Recent Processing Runs" table now reads from the new `/processing-runs` endpoint; shows account name and a *View all logs* link. ### Added +- **Apprise alerting**: New `NotificationService` using [Apprise](https://github.com/caronc/apprise) for multi-channel push notifications (Telegram, Slack, Discord, webhooks, and 80+ other services via a single URL scheme). + - `send_user_notification` — sends to all enabled per-user Apprise channels on processing errors or failures. + - `send_admin_notification` — sends to all enabled admin-wide channels for system events. + - `test_notification` — validates an Apprise URL by dispatching a test message. +- **`NotificationConfig` model**: Added `name` (friendly label) and `apprise_url` (nullable Apprise URL) columns. +- **`AdminNotificationConfig` model**: New table (`admin_notification_configs`) for system-wide admin alert channels with `name`, `apprise_url`, `is_enabled`, `notify_on_errors`, `notify_on_system_events`, and `description` fields. +- **Notifications API** (`/api/v1/notifications`): Full CRUD endpoints (GET/POST/PUT/DELETE) plus a `/test` endpoint for user notification configs. +- **Admin Notifications API** (`/api/v1/admin/notifications`): Full CRUD + `/test` endpoints for admin notification configs, superuser-only. +- **Task integration**: `process_mail_account` now calls `send_user_notification` on Gmail credential revocation, per-email forwarding failures, and unhandled processing exceptions. + +### Changed +- `NotificationConfigBase` schema: `name` is now a required field; `apprise_url` is an optional field; `config` (channel-specific JSON) is now optional with a default of `{}` (previously required). Existing clients must be updated to supply `name`. + + - **Configurable Gmail import labels**: Users can now define which Gmail labels are applied to imported messages from the Settings page. The default setup is opinionated: `{{source_email}}` (rendered to the mailbox address each message came from) plus `imported`, and a reset button restores those defaults instantly. - **Prometheus metrics** (`/metrics` endpoint on the FastAPI backend, scraped every 15 s): - **HTTP layer** — `http_requests_total` (counter, labelled `method`/`endpoint`/`status_code`) and `http_request_duration_seconds` (histogram). Path segments that are numeric IDs are normalised to `{id}` to avoid label-set explosion. diff --git a/backend/app/api/v1/endpoints/admin.py b/backend/app/api/v1/endpoints/admin.py index 78bc6af..13bb1cd 100644 --- a/backend/app/api/v1/endpoints/admin.py +++ b/backend/app/api/v1/endpoints/admin.py @@ -16,6 +16,7 @@ from app.models.database_models import ( ProcessingRun, SubscriptionPlan, SubscriptionTier, + AdminNotificationConfig, ) from app.models.schemas import ( AdminUserListResponse, @@ -24,11 +25,17 @@ from app.models.schemas import ( SubscriptionPlanResponse, SubscriptionPlanCreate, SubscriptionPlanUpdate, + AdminNotificationConfigCreate, + AdminNotificationConfigUpdate, + AdminNotificationConfigResponse, + NotificationTestRequest, + NotificationTestResponse, AdminProcessingRunResponse, AdminProcessingLogResponse, PaginatedAdminRunsResponse, PaginatedAdminLogsResponse, ) +from app.services.notification_service import test_notification router = APIRouter() @@ -291,6 +298,115 @@ async def delete_plan( await db.commit() +# ── Admin notification config management ────────────────────────────────────── + + +@router.get("/notifications", response_model=List[AdminNotificationConfigResponse]) +async def list_admin_notification_configs( + current_user: User = Depends(get_current_superuser), + db: AsyncSession = Depends(get_db), +): + """List all admin notification configurations (admin only)""" + result = await db.execute(select(AdminNotificationConfig)) + return result.scalars().all() + + +@router.post( + "/notifications", + response_model=AdminNotificationConfigResponse, + status_code=status.HTTP_201_CREATED, +) +async def create_admin_notification_config( + config_in: AdminNotificationConfigCreate, + current_user: User = Depends(get_current_superuser), + db: AsyncSession = Depends(get_db), +): + """Create a new admin notification configuration (admin only)""" + config = AdminNotificationConfig(**config_in.dict()) + db.add(config) + await db.commit() + await db.refresh(config) + return config + + +@router.get( + "/notifications/{config_id}", response_model=AdminNotificationConfigResponse +) +async def get_admin_notification_config( + config_id: int, + current_user: User = Depends(get_current_superuser), + db: AsyncSession = Depends(get_db), +): + """Get a specific admin notification configuration (admin only)""" + result = await db.execute( + select(AdminNotificationConfig).where(AdminNotificationConfig.id == config_id) + ) + config = result.scalar_one_or_none() + if not config: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail="Admin notification config not found", + ) + return config + + +@router.put( + "/notifications/{config_id}", response_model=AdminNotificationConfigResponse +) +async def update_admin_notification_config( + config_id: int, + config_in: AdminNotificationConfigUpdate, + current_user: User = Depends(get_current_superuser), + db: AsyncSession = Depends(get_db), +): + """Update an admin notification configuration (admin only)""" + result = await db.execute( + select(AdminNotificationConfig).where(AdminNotificationConfig.id == config_id) + ) + config = result.scalar_one_or_none() + if not config: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail="Admin notification config not found", + ) + + update_data = config_in.dict(exclude_unset=True) + for field, value in update_data.items(): + setattr(config, field, value) + + await db.commit() + await db.refresh(config) + return config + + +@router.delete("/notifications/{config_id}", status_code=status.HTTP_204_NO_CONTENT) +async def delete_admin_notification_config( + config_id: int, + current_user: User = Depends(get_current_superuser), + db: AsyncSession = Depends(get_db), +): + """Delete an admin notification configuration (admin only)""" + result = await db.execute( + select(AdminNotificationConfig).where(AdminNotificationConfig.id == config_id) + ) + config = result.scalar_one_or_none() + if not config: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail="Admin notification config not found", + ) + await db.delete(config) + await db.commit() + + +@router.post("/notifications/test", response_model=NotificationTestResponse) +async def test_admin_notification_config( + request: NotificationTestRequest, + current_user: User = Depends(get_current_superuser), +): + """Test an admin notification channel by sending a test message (admin only)""" + success, message = await test_notification(request.apprise_url) + return NotificationTestResponse(success=success, message=message) # ── Admin Logs ───────────────────────────────────────────────────────────────── diff --git a/backend/app/api/v1/endpoints/notifications.py b/backend/app/api/v1/endpoints/notifications.py index 77b5480..4706028 100644 --- a/backend/app/api/v1/endpoints/notifications.py +++ b/backend/app/api/v1/endpoints/notifications.py @@ -1,7 +1,7 @@ """Notification configuration endpoints""" from typing import List -from fastapi import APIRouter, Depends, status +from fastapi import APIRouter, Depends, HTTPException, status from sqlalchemy.ext.asyncio import AsyncSession from sqlalchemy import select @@ -10,8 +10,12 @@ from app.core.deps import get_current_active_user from app.models.database_models import User, NotificationConfig from app.models.schemas import ( NotificationConfigCreate, + NotificationConfigUpdate, NotificationConfigResponse, + NotificationTestRequest, + NotificationTestResponse, ) +from app.services.notification_service import test_notification router = APIRouter() @@ -24,7 +28,7 @@ async def create_notification_config( current_user: User = Depends(get_current_active_user), db: AsyncSession = Depends(get_db), ): - """Create notification configuration""" + """Create a new notification configuration""" config = NotificationConfig(user_id=current_user.id, **config_in.dict()) db.add(config) await db.commit() @@ -37,8 +41,94 @@ async def list_notification_configs( current_user: User = Depends(get_current_active_user), db: AsyncSession = Depends(get_db), ): - """List all notification configurations""" + """List all notification configurations for the current user""" result = await db.execute( select(NotificationConfig).where(NotificationConfig.user_id == current_user.id) ) return result.scalars().all() + + +@router.get("/{config_id}", response_model=NotificationConfigResponse) +async def get_notification_config( + config_id: int, + current_user: User = Depends(get_current_active_user), + db: AsyncSession = Depends(get_db), +): + """Get a specific notification configuration""" + result = await db.execute( + select(NotificationConfig).where( + NotificationConfig.id == config_id, + NotificationConfig.user_id == current_user.id, + ) + ) + config = result.scalar_one_or_none() + if not config: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail="Notification config not found", + ) + return config + + +@router.put("/{config_id}", response_model=NotificationConfigResponse) +async def update_notification_config( + config_id: int, + config_in: NotificationConfigUpdate, + current_user: User = Depends(get_current_active_user), + db: AsyncSession = Depends(get_db), +): + """Update a notification configuration""" + result = await db.execute( + select(NotificationConfig).where( + NotificationConfig.id == config_id, + NotificationConfig.user_id == current_user.id, + ) + ) + config = result.scalar_one_or_none() + if not config: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail="Notification config not found", + ) + + update_data = config_in.dict(exclude_unset=True) + for field, value in update_data.items(): + setattr(config, field, value) + + await db.commit() + await db.refresh(config) + return config + + +@router.delete("/{config_id}", status_code=status.HTTP_204_NO_CONTENT) +async def delete_notification_config( + config_id: int, + current_user: User = Depends(get_current_active_user), + db: AsyncSession = Depends(get_db), +): + """Delete a notification configuration""" + result = await db.execute( + select(NotificationConfig).where( + NotificationConfig.id == config_id, + NotificationConfig.user_id == current_user.id, + ) + ) + config = result.scalar_one_or_none() + if not config: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail="Notification config not found", + ) + + await db.delete(config) + await db.commit() + + +@router.post("/test", response_model=NotificationTestResponse) +async def test_notification_config( + request: NotificationTestRequest, + current_user: User = Depends(get_current_active_user), +): + """Test a notification channel by sending a test message""" + success, message = await test_notification(request.apprise_url) + return NotificationTestResponse(success=success, message=message) diff --git a/backend/app/models/database_models.py b/backend/app/models/database_models.py index c4d50fd..192d182 100644 --- a/backend/app/models/database_models.py +++ b/backend/app/models/database_models.py @@ -295,6 +295,11 @@ class NotificationConfig(Base): Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False ) + name = Column(String(255), nullable=False, default="My Notification") + apprise_url = Column( + Text, nullable=True + ) # The Apprise URL e.g. tgram://token/chatid + # Channel details channel: Column[str] = Column(SQLEnum(NotificationChannel), nullable=False) is_enabled = Column(Boolean, default=True) @@ -608,3 +613,29 @@ class AppSetting(Base): onupdate=lambda: datetime.now(timezone.utc), nullable=False, ) + + +class AdminNotificationConfig(Base): + """System-wide admin notification channels""" + + __tablename__ = "admin_notification_configs" + + id = Column(Integer, primary_key=True, index=True) + name = Column(String(255), nullable=False) + apprise_url = Column(Text, nullable=False) + is_enabled = Column(Boolean, default=True) + notify_on_errors = Column(Boolean, default=True) + notify_on_system_events = Column(Boolean, default=True) + description = Column(Text, nullable=True) + + created_at = Column( + DateTime(timezone=True), + default=lambda: datetime.now(timezone.utc), + nullable=False, + ) + updated_at = Column( + DateTime(timezone=True), + default=lambda: datetime.now(timezone.utc), + onupdate=lambda: datetime.now(timezone.utc), + nullable=False, + ) diff --git a/backend/app/models/schemas.py b/backend/app/models/schemas.py index 20f7704..609b32b 100644 --- a/backend/app/models/schemas.py +++ b/backend/app/models/schemas.py @@ -289,9 +289,16 @@ class PaginatedAdminLogsResponse(BaseModel): # Notification Config Schemas class NotificationConfigBase(BaseModel): + name: str = Field( + ..., max_length=255, description="Friendly name for this notification channel" + ) channel: NotificationChannel + apprise_url: Optional[str] = Field(None, description="Apprise notification URL") is_enabled: bool = True - config: Dict[str, Any] + config: Dict[str, Any] = Field( + default_factory=dict, + description="Legacy channel-specific configuration (deprecated in favour of apprise_url)", + ) notify_on_errors: bool = True notify_on_success: bool = False notify_threshold: int = Field(default=3, gt=0, le=100) @@ -302,6 +309,9 @@ class NotificationConfigCreate(NotificationConfigBase): class NotificationConfigUpdate(BaseModel): + name: Optional[str] = Field(None, max_length=255) + channel: Optional[NotificationChannel] = None + apprise_url: Optional[str] = None is_enabled: Optional[bool] = None config: Optional[Dict[str, Any]] = None notify_on_errors: Optional[bool] = None @@ -318,6 +328,46 @@ class NotificationConfigResponse(NotificationConfigBase): model_config = ConfigDict(from_attributes=True) +class NotificationTestRequest(BaseModel): + apprise_url: str = Field(..., description="Apprise URL to test") + + +class NotificationTestResponse(BaseModel): + success: bool + message: str + + +# Admin Notification Config Schemas +class AdminNotificationConfigBase(BaseModel): + name: str = Field(..., max_length=255) + apprise_url: str = Field(..., description="Apprise notification URL") + is_enabled: bool = True + notify_on_errors: bool = True + notify_on_system_events: bool = True + description: Optional[str] = None + + +class AdminNotificationConfigCreate(AdminNotificationConfigBase): + pass + + +class AdminNotificationConfigUpdate(BaseModel): + name: Optional[str] = Field(None, max_length=255) + apprise_url: Optional[str] = None + is_enabled: Optional[bool] = None + notify_on_errors: Optional[bool] = None + notify_on_system_events: Optional[bool] = None + description: Optional[str] = None + + +class AdminNotificationConfigResponse(AdminNotificationConfigBase): + id: int + created_at: datetime + updated_at: datetime + + model_config = ConfigDict(from_attributes=True) + + # Subscription Schemas class SubscriptionPlanResponse(BaseModel): id: int diff --git a/backend/app/services/notification_service.py b/backend/app/services/notification_service.py new file mode 100644 index 0000000..5927199 --- /dev/null +++ b/backend/app/services/notification_service.py @@ -0,0 +1,143 @@ +""" +Notification service using Apprise for multi-channel alerting. + +Supports: +- User-specific notifications (per-user Apprise URLs) +- Admin-wide system notifications (system-level alerts) +- Test notifications to verify configuration +""" + +import logging + +import apprise + +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy import select + +from app.models.database_models import NotificationConfig, AdminNotificationConfig + +logger = logging.getLogger(__name__) + + +async def send_user_notification( + db: AsyncSession, + user_id: int, + title: str, + body: str, + notify_on_error: bool = True, +) -> int: + """ + Send a notification to all enabled notification channels for a given user. + + Args: + db: Database session + user_id: The user to notify + title: Notification title/subject + body: Notification body text + notify_on_error: If True, only sends to channels with notify_on_errors=True + If False, only sends to channels with notify_on_success=True + + Returns: + Number of channels notified successfully + """ + result = await db.execute( + select(NotificationConfig).where( + NotificationConfig.user_id == user_id, + NotificationConfig.is_enabled == True, # noqa: E712 + NotificationConfig.apprise_url.isnot(None), + ) + ) + configs = result.scalars().all() + + if not configs: + return 0 + + sent = 0 + for config in configs: + if notify_on_error and not config.notify_on_errors: + continue + if not notify_on_error and not config.notify_on_success: + continue + + try: + success = await _send_apprise(config.apprise_url or "", title, body) + if success: + sent += 1 + except Exception as exc: + logger.warning( + "Failed to send notification via channel %s (user %s): %s", + config.id, + user_id, + exc, + ) + + return sent + + +async def send_admin_notification( + db: AsyncSession, + title: str, + body: str, +) -> int: + """ + Send a notification to all enabled admin notification channels. + + Returns: + Number of channels notified successfully + """ + result = await db.execute( + select(AdminNotificationConfig).where( + AdminNotificationConfig.is_enabled == True, # noqa: E712 + AdminNotificationConfig.notify_on_errors == True, # noqa: E712 + ) + ) + configs = result.scalars().all() + + if not configs: + return 0 + + sent = 0 + for config in configs: + try: + success = await _send_apprise(config.apprise_url or "", title, body) + if success: + sent += 1 + except Exception as exc: + logger.warning( + "Failed to send admin notification via channel %s: %s", + config.id, + exc, + ) + + return sent + + +async def test_notification(apprise_url: str) -> tuple[bool, str]: + """ + Send a test notification to the given Apprise URL. + + Returns: + (success, message) tuple + """ + try: + success = await _send_apprise( + apprise_url, + title="InboxRescue: Test Notification", + body="This is a test notification from InboxRescue. Your notification channel is configured correctly!", + ) + if success: + return True, "Test notification sent successfully" + return False, "Notification delivery failed (check your Apprise URL)" + except Exception as exc: + return False, f"Error sending test notification: {exc}" + + +async def _send_apprise(url: str, title: str, body: str) -> bool: + """Internal helper – create an Apprise instance, load the URL, and notify.""" + ap = apprise.Apprise() + if not ap.add(url): + logger.warning("Apprise could not parse URL: %s", url[:60]) + return False + + result = await ap.async_notify(title=title, body=body) + return bool(result) diff --git a/backend/app/workers/tasks.py b/backend/app/workers/tasks.py index 417129a..1db3cb6 100644 --- a/backend/app/workers/tasks.py +++ b/backend/app/workers/tasks.py @@ -34,6 +34,7 @@ from app.models.database_models import ( from app.services.mail_processor import MailProcessor from app.services.gmail_service import GmailService from app.services.config_service import ConfigService +from app.services.notification_service import send_user_notification from app.core.config import settings from sqlalchemy import select, delete @@ -272,6 +273,18 @@ async def process_mail_account(account_id: int): f"Gmail credentials revoked for user {account.user_id}. " "User must re-authorise." ) + try: + await send_user_notification( + db=db, + user_id=account.user_id, + title="InboxRescue: Gmail Authorization Expired", + body=f"Your Gmail credentials for account '{account.name}' have been revoked. Please re-authorize Gmail access in Settings.", + notify_on_error=True, + ) + except Exception as notify_exc: + logger.warning( + f"Failed to send revocation notification: {notify_exc}" + ) logger.error(f"Error delivering email: {e}") error_msg = str(e) emails_failed += 1 @@ -340,6 +353,16 @@ async def process_mail_account(account_id: int): account.status = AccountStatus.ERROR # type: ignore[assignment] account.last_error_at = datetime.now(timezone.utc) # type: ignore[assignment] account.last_error_message = f"{emails_failed} emails failed to forward" # type: ignore[assignment] + try: + await send_user_notification( + db=db, + user_id=account.user_id, + title="InboxRescue: Mail Forwarding Failures", + body=f"Mail account '{account.name}': {emails_failed} email(s) failed to forward.", + notify_on_error=True, + ) + except Exception as notify_exc: + logger.warning(f"Failed to send notification: {notify_exc}") await db.commit() @@ -392,6 +415,20 @@ async def process_mail_account(account_id: int): account.last_error_at = datetime.now(timezone.utc) # type: ignore[assignment] account.last_error_message = str(e) # type: ignore[assignment] + # Notify user about the error + try: + await send_user_notification( + db=db, + user_id=account.user_id, + title="InboxRescue: Mail Processing Error", + body=f"Error processing mail account '{account.name}': {e}", + notify_on_error=True, + ) + except Exception as notify_exc: + logger.warning( + f"Failed to send error notification: {notify_exc}" + ) + await db.commit() diff --git a/docs/TODO.md b/docs/TODO.md index f8c50e7..d41cfdb 100644 --- a/docs/TODO.md +++ b/docs/TODO.md @@ -205,7 +205,7 @@ Comprehensive task breakdown for repository improvements and production readines - [x] **Debug email**: "Send Debug Email" button in Settings injects a test message (from christian@docuelevate.org, dated today, labelled `test` + `imported`, placed in inbox) to verify end-to-end Gmail API delivery - [x] **Logging & reporting**: per-email ProcessingLog capture in worker; user `/logs` page; admin `/admin/logs` page; GDPR masking utilities (`gdpr.py`) - [ ] Implement GDPR data export endpoint -- [ ] Complete notification service integration (Apprise) +- [x] Complete notification service integration (Apprise) - [ ] Add advanced email filtering - [ ] Implement OAuth2 for Gmail (instead of App Passwords) - [ ] Add attachment handling improvements @@ -248,6 +248,9 @@ because the API client layer is missing. - [ ] Error boundary components - [ ] Loading skeletons / proper loading states - [ ] Notification preferences UI +- [x] Notification channels page (`/notifications`) with full CRUD, wizard, and test button +- [x] Apprise-powered notification wizard for Telegram, Discord, Slack, Email, Webhook, and custom URLs +- [x] Admin system alert channels section (`/admin` page) with full CRUD and test - [ ] Subscription management / billing UI ### Admin Interface ✅ diff --git a/frontend/src/app/admin/page.tsx b/frontend/src/app/admin/page.tsx index 61f277e..667364b 100644 --- a/frontend/src/app/admin/page.tsx +++ b/frontend/src/app/admin/page.tsx @@ -2,17 +2,225 @@ import { AuthGuard } from '@/components/AuthGuard'; import { DashboardLayout } from '@/components/DashboardLayout'; -import { useQuery } from '@tanstack/react-query'; -import { adminApi } from '@/lib/api'; +import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'; +import { + adminApi, + adminNotificationsApi, + AdminNotificationConfig, + AdminNotificationConfigCreate, + AdminNotificationConfigUpdate, +} from '@/lib/api'; import { useAuthStore } from '@/store/authStore'; import { useRouter } from 'next/navigation'; -import { useEffect } from 'react'; -import { Users, Mail, Activity, Shield } from 'lucide-react'; +import { useEffect, useState } from 'react'; +import { + Users, + Mail, + Activity, + Shield, + Bell, + Plus, + Edit2, + Trash2, + Send, + CheckCircle, + XCircle, + Loader2, + X, +} from 'lucide-react'; import Link from 'next/link'; +// ── Admin Notification Modal ───────────────────────────────────────────── + +interface AdminNotificationModalProps { + config?: AdminNotificationConfig | null; + onClose: () => void; +} + +function AdminNotificationModal({ config, onClose }: AdminNotificationModalProps) { + const queryClient = useQueryClient(); + const isEdit = !!config; + + const [formData, setFormData] = useState({ + name: config?.name ?? '', + apprise_url: config?.apprise_url ?? '', + is_enabled: config?.is_enabled ?? true, + notify_on_errors: config?.notify_on_errors ?? true, + notify_on_system_events: config?.notify_on_system_events ?? true, + description: config?.description ?? '', + }); + const [error, setError] = useState(''); + + const onSuccess = () => { + queryClient.invalidateQueries({ queryKey: ['admin-notifications'] }); + onClose(); + }; + + const createMutation = useMutation({ + mutationFn: (data: AdminNotificationConfigCreate) => adminNotificationsApi.create(data), + onSuccess, + onError: () => setError('Failed to save. Please check the Apprise URL and try again.'), + }); + + const updateMutation = useMutation({ + mutationFn: (data: AdminNotificationConfigUpdate) => + adminNotificationsApi.update(config!.id, data), + onSuccess, + onError: () => setError('Failed to save. Please check the Apprise URL and try again.'), + }); + + const isPending = createMutation.isPending || updateMutation.isPending; + + const handleSubmit = (e: React.FormEvent) => { + e.preventDefault(); + setError(''); + if (!formData.name.trim() || !formData.apprise_url.trim()) { + setError('Name and Apprise URL are required.'); + return; + } + if (isEdit) { + updateMutation.mutate(formData); + } else { + createMutation.mutate(formData); + } + }; + + return ( +
+
+
+

+ {isEdit ? 'Edit System Alert Channel' : 'Add System Alert Channel'} +

+ +
+ +
+
+ + setFormData((p) => ({ ...p, name: e.target.value }))} + placeholder="e.g. Admin Telegram Alert" + className="w-full px-3 py-2 border border-gray-300 rounded-md text-sm focus:outline-none focus:ring-2 focus:ring-purple-500" + /> +
+ +
+ + setFormData((p) => ({ ...p, apprise_url: e.target.value }))} + placeholder="tgram://bot_token/chat_id/" + className="w-full px-3 py-2 border border-gray-300 rounded-md text-sm focus:outline-none focus:ring-2 focus:ring-purple-500" + /> +

+ Any valid{' '} + + Apprise + {' '} + notification URL. +

+
+ +
+ + setFormData((p) => ({ ...p, description: e.target.value || null }))} + placeholder="What is this channel used for?" + className="w-full px-3 py-2 border border-gray-300 rounded-md text-sm focus:outline-none focus:ring-2 focus:ring-purple-500" + /> +
+ +
+

Triggers

+ + + +
+ + {error &&

{error}

} + +
+ + +
+
+
+
+ ); +} + +// ── Admin Page ─────────────────────────────────────────────────────────── + export default function AdminPage() { const { user } = useAuthStore(); const router = useRouter(); + const queryClient = useQueryClient(); + + const [showNotifModal, setShowNotifModal] = useState(false); + const [editingNotif, setEditingNotif] = useState(null); + const [testingNotifId, setTestingNotifId] = useState(null); + const [notifTestResults, setNotifTestResults] = useState< + Record + >({}); useEffect(() => { if (user && !user.is_superuser) { @@ -26,6 +234,60 @@ export default function AdminPage() { enabled: !!user?.is_superuser, }); + const { data: adminNotifications, isLoading: notifLoading } = useQuery({ + queryKey: ['admin-notifications'], + queryFn: adminNotificationsApi.list, + enabled: !!user?.is_superuser, + }); + + const deleteNotifMutation = useMutation({ + mutationFn: adminNotificationsApi.delete, + onSuccess: () => { + queryClient.invalidateQueries({ queryKey: ['admin-notifications'] }); + }, + }); + + const handleEditNotif = (config: AdminNotificationConfig) => { + setEditingNotif(config); + setShowNotifModal(true); + }; + + const handleDeleteNotif = async (id: number) => { + if (!confirm('Delete this system alert channel?')) return; + try { + await deleteNotifMutation.mutateAsync(id); + } catch { + alert('Failed to delete channel'); + } + }; + + const handleTestNotif = async (config: AdminNotificationConfig) => { + setTestingNotifId(config.id); + try { + const result = await adminNotificationsApi.test(config.apprise_url); + setNotifTestResults((prev) => ({ ...prev, [config.id]: result })); + } catch { + setNotifTestResults((prev) => ({ + ...prev, + [config.id]: { success: false, message: 'Test request failed' }, + })); + } finally { + setTestingNotifId(null); + setTimeout(() => { + setNotifTestResults((prev) => { + const next = { ...prev }; + delete next[config.id]; + return next; + }); + }, 5000); + } + }; + + const handleCloseNotifModal = () => { + setShowNotifModal(false); + setEditingNotif(null); + }; + // AuthGuard must always render so it can fetch the current user and handle // unauthenticated redirects. The early-return that was here prevented // AuthGuard from ever mounting on a direct navigation to /admin, leaving a @@ -127,9 +389,165 @@ export default function AdminPage() { + + {/* System Alert Channels */} +
+
+
+

+ + System Alert Channels +

+

+ Admin-level channels that receive system-wide error and event notifications. +

+
+ +
+ + {notifLoading ? ( +
+
+
+ ) : adminNotifications && adminNotifications.length > 0 ? ( +
+ {adminNotifications.map((config) => { + const testResult = notifTestResults[config.id]; + const isTesting = testingNotifId === config.id; + return ( +
+
+
+
+

+ {config.name} +

+ {config.description && ( +

+ {config.description} +

+ )} +
+ + {config.is_enabled ? ( + + ) : ( + + )} + {config.is_enabled ? 'On' : 'Off'} + +
+ +
+ {config.notify_on_errors && ( + + On Errors + + )} + {config.notify_on_system_events && ( + + System Events + + )} +
+ + {testResult && ( +
+ {testResult.success ? ( + + ) : ( + + )} + {testResult.message} +
+ )} + +
+ + + +
+
+
+ ); + })} +
+ ) : ( +
+ +

No system alert channels configured yet.

+ +
+ )} +
)} + + {showNotifModal && ( + + )} ); } + diff --git a/frontend/src/app/notifications/page.tsx b/frontend/src/app/notifications/page.tsx new file mode 100644 index 0000000..0a2b159 --- /dev/null +++ b/frontend/src/app/notifications/page.tsx @@ -0,0 +1,347 @@ +'use client'; + +import { useState } from 'react'; +import { AuthGuard } from '@/components/AuthGuard'; +import { DashboardLayout } from '@/components/DashboardLayout'; +import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'; +import { notificationsApi, NotificationConfig, NotificationConfigCreate, NotificationConfigUpdate } from '@/lib/api'; +import { NotificationWizard } from '@/components/NotificationWizard'; +import { Plus, Edit2, Trash2, Bell, Send, CheckCircle, XCircle, Loader2 } from 'lucide-react'; + +const CHANNEL_DISPLAY: Record = { + telegram: { icon: '🤖', label: 'Telegram', color: 'bg-blue-100 text-blue-800' }, + discord: { icon: '💬', label: 'Discord', color: 'bg-indigo-100 text-indigo-800' }, + slack: { icon: '💼', label: 'Slack', color: 'bg-yellow-100 text-yellow-800' }, + email: { icon: '📧', label: 'Email', color: 'bg-green-100 text-green-800' }, + webhook: { icon: '🔗', label: 'Webhook', color: 'bg-purple-100 text-purple-800' }, + custom: { icon: '⚙️', label: 'Custom', color: 'bg-gray-100 text-gray-800' }, +}; + +export default function NotificationsPage() { + const [showWizard, setShowWizard] = useState(false); + const [editingConfig, setEditingConfig] = useState(null); + const [testingId, setTestingId] = useState(null); + const [testResults, setTestResults] = useState>({}); + const queryClient = useQueryClient(); + + const { data: notifications, isLoading } = useQuery({ + queryKey: ['notifications'], + queryFn: notificationsApi.list, + }); + + const createMutation = useMutation({ + mutationFn: (data: NotificationConfigCreate) => notificationsApi.create(data), + onSuccess: () => { + queryClient.invalidateQueries({ queryKey: ['notifications'] }); + setShowWizard(false); + setEditingConfig(null); + }, + }); + + const updateMutation = useMutation({ + mutationFn: ({ id, data }: { id: number; data: NotificationConfigUpdate }) => + notificationsApi.update(id, data), + onSuccess: () => { + queryClient.invalidateQueries({ queryKey: ['notifications'] }); + setShowWizard(false); + setEditingConfig(null); + }, + }); + + const deleteMutation = useMutation({ + mutationFn: notificationsApi.delete, + onSuccess: () => { + queryClient.invalidateQueries({ queryKey: ['notifications'] }); + }, + }); + + const toggleMutation = useMutation({ + mutationFn: ({ id, is_enabled }: { id: number; is_enabled: boolean }) => + notificationsApi.update(id, { is_enabled }), + onSuccess: () => { + queryClient.invalidateQueries({ queryKey: ['notifications'] }); + }, + }); + + const handleWizardComplete = (config: { + name: string; + channel: string; + apprise_url: string; + notify_on_errors: boolean; + notify_on_success: boolean; + }) => { + if (editingConfig) { + updateMutation.mutate({ id: editingConfig.id, data: config }); + } else { + createMutation.mutate(config); + } + }; + + const handleEdit = (config: NotificationConfig) => { + setEditingConfig(config); + setShowWizard(true); + }; + + const handleDelete = async (id: number) => { + if (!confirm('Delete this notification channel?')) return; + try { + await deleteMutation.mutateAsync(id); + } catch { + alert('Failed to delete notification channel'); + } + }; + + const handleTest = async (config: NotificationConfig) => { + if (!config.apprise_url) return; + setTestingId(config.id); + try { + const result = await notificationsApi.test(config.apprise_url); + setTestResults((prev) => ({ ...prev, [config.id]: result })); + } catch { + setTestResults((prev) => ({ + ...prev, + [config.id]: { success: false, message: 'Test request failed' }, + })); + } finally { + setTestingId(null); + setTimeout(() => { + setTestResults((prev) => { + const next = { ...prev }; + delete next[config.id]; + return next; + }); + }, 5000); + } + }; + + const handleOpenWizard = () => { + setEditingConfig(null); + setShowWizard(true); + }; + + const handleCancelWizard = () => { + setShowWizard(false); + setEditingConfig(null); + }; + + if (showWizard) { + return ( + + +
+
+ +
+
+ + + ); + } + + return ( + + +
+ {/* Header */} +
+
+

+ + Notification Channels +

+

+ Get alerts when emails are processed or errors occur. +

+
+ +
+ + {/* Content */} + {isLoading ? ( +
+
+
+ ) : notifications && notifications.length > 0 ? ( +
+ {notifications.map((config) => { + const channel = CHANNEL_DISPLAY[config.channel] ?? CHANNEL_DISPLAY.custom; + const testResult = testResults[config.id]; + const isTesting = testingId === config.id; + + return ( +
+
+
+
+ {channel.icon} +
+

+ {config.name} +

+ + {channel.label} + +
+
+ +
+ +
+ {config.notify_on_errors && ( + + On Errors + + )} + {config.notify_on_success && ( + + On Success + + )} + {!config.notify_on_errors && !config.notify_on_success && ( + + No triggers set + + )} +
+ + {testResult && ( +
+ {testResult.success ? ( + + ) : ( + + )} + {testResult.message} +
+ )} + +
+ + + +
+
+
+ ); + })} +
+ ) : ( +
+ +

+ No notification channels yet +

+

+ Add a channel to receive alerts when emails are processed or errors occur. +

+ +
+ )} + + {/* Info box */} +
+

About Notifications

+

+ Notifications are powered by{' '} + + Apprise + + , which supports 80+ notification services including Telegram, Discord, Slack, email, + and many more. Each channel can be configured independently with different triggers. +

+
+
+ + + ); +} diff --git a/frontend/src/components/DashboardLayout.tsx b/frontend/src/components/DashboardLayout.tsx index c7c8c94..c915120 100644 --- a/frontend/src/components/DashboardLayout.tsx +++ b/frontend/src/components/DashboardLayout.tsx @@ -15,6 +15,7 @@ import { Shield, Users, CreditCard, + Bell FileText, Activity } from 'lucide-react'; @@ -37,6 +38,7 @@ export function DashboardLayout({ children }: DashboardLayoutProps) { const navigation = [ { name: 'Dashboard', href: '/dashboard', icon: LayoutDashboard }, { name: 'Mail Accounts', href: '/accounts', icon: Mail }, + { name: 'Notifications', href: '/notifications', icon: Bell }, { name: 'Logs', href: '/logs', icon: FileText }, { name: 'Settings', href: '/settings', icon: Settings }, ]; diff --git a/frontend/src/components/NotificationWizard.tsx b/frontend/src/components/NotificationWizard.tsx new file mode 100644 index 0000000..1a7e17c --- /dev/null +++ b/frontend/src/components/NotificationWizard.tsx @@ -0,0 +1,390 @@ +'use client'; + +import { useState } from 'react'; +import { ArrowLeft, Bell, Check, Eye, EyeOff, Send } from 'lucide-react'; + +interface NotificationWizardProps { + onComplete: (config: { + name: string; + channel: string; + apprise_url: string; + notify_on_errors: boolean; + notify_on_success: boolean; + }) => void; + onCancel: () => void; + initialData?: { + name: string; + channel: string; + apprise_url: string | null; + notify_on_errors: boolean; + notify_on_success: boolean; + } | null; +} + +const CHANNEL_OPTIONS = [ + { id: 'telegram', icon: '🤖', label: 'Telegram', description: 'Instant messages via Telegram bot' }, + { id: 'discord', icon: '💬', label: 'Discord', description: 'Server notifications via Discord webhook' }, + { id: 'slack', icon: '💼', label: 'Slack', description: 'Team alerts via Slack webhook' }, + { id: 'email', icon: '📧', label: 'Email', description: 'Email notifications via SMTP' }, + { id: 'webhook', icon: '🔗', label: 'Webhook', description: 'POST to any HTTP endpoint' }, + { id: 'custom', icon: '⚙️', label: 'Custom Apprise URL', description: 'Advanced: any supported Apprise format' }, +]; + +interface ChannelField { + key: string; + label: string; + placeholder: string; + type?: 'text' | 'password'; + hint?: string; + optional?: boolean; +} + +const CHANNEL_FIELDS: Record = { + telegram: [ + { + key: 'bot_token', + label: 'Bot Token', + placeholder: '110201543:AAHdqTcvCH1vGWJxfSeofSAs0K5PALDsaw', + hint: 'Get from @BotFather on Telegram', + }, + { + key: 'chat_id', + label: 'Chat ID', + placeholder: '12345678', + hint: 'Your Telegram chat or group ID', + }, + ], + discord: [ + { + key: 'webhook_url', + label: 'Discord Webhook URL', + placeholder: 'https://discord.com/api/webhooks/123456789/abcdef...', + hint: 'Paste the full webhook URL from Discord server settings → Integrations', + }, + ], + slack: [ + { + key: 'webhook_url', + label: 'Slack Webhook URL', + placeholder: 'https://hooks.slack.com/services/T00000000/B00000000/XXXX...', + hint: 'Create an Incoming Webhook in your Slack app settings', + }, + ], + email: [ + { key: 'username', label: 'Username / Email', placeholder: 'user@example.com' }, + { key: 'password', label: 'SMTP Password', placeholder: '••••••••', type: 'password' }, + { key: 'host', label: 'SMTP Host', placeholder: 'smtp.example.com' }, + { key: 'port', label: 'SMTP Port', placeholder: '587', optional: true }, + ], + webhook: [ + { + key: 'url', + label: 'Webhook URL', + placeholder: 'https://hooks.example.com/...', + hint: 'Full HTTP(S) URL — receives a JSON POST with notification data', + }, + ], + custom: [ + { + key: 'apprise_url', + label: 'Apprise URL', + placeholder: 'tgram://bot_token/chat_id/', + hint: 'Any valid Apprise notification URL — see apprise.readthedocs.io', + }, + ], +}; + +function buildAppriseUrl(channel: string, fields: Record): string { + switch (channel) { + case 'telegram': + if (!fields.bot_token || !fields.chat_id) return ''; + return `tgram://${fields.bot_token}/${fields.chat_id}/`; + case 'discord': { + const match = (fields.webhook_url ?? '').match( + /discord\.com\/api\/webhooks\/(\d+)\/([^/?]+)/ + ); + if (match) return `discord://${match[1]}/${match[2]}/`; + return ''; + } + case 'slack': { + const match = (fields.webhook_url ?? '').match( + /hooks\.slack\.com\/services\/([^/]+)\/([^/]+)\/([^/?]+)/ + ); + if (match) return `slack://${match[1]}/${match[2]}/${match[3]}/`; + return ''; + } + case 'email': + if (!fields.username || !fields.password || !fields.host) return ''; + return `mailto://${encodeURIComponent(fields.username)}:${encodeURIComponent(fields.password)}@${fields.host}${ + fields.port ? `:${fields.port}` : '' + }`; + case 'webhook': + return fields.url || ''; + case 'custom': + return fields.apprise_url || ''; + default: + return ''; + } +} + +export function NotificationWizard({ onComplete, onCancel, initialData }: NotificationWizardProps) { + const [step, setStep] = useState<1 | 2 | 3>(initialData ? 3 : 1); + const [selectedChannel, setSelectedChannel] = useState(initialData?.channel ?? ''); + const [fields, setFields] = useState>({}); + const [name, setName] = useState(initialData?.name ?? ''); + const [notifyOnErrors, setNotifyOnErrors] = useState(initialData?.notify_on_errors ?? true); + const [notifyOnSuccess, setNotifyOnSuccess] = useState(initialData?.notify_on_success ?? false); + const [showUrl, setShowUrl] = useState(false); + + const builtUrl = buildAppriseUrl(selectedChannel, fields); + const effectiveUrl = builtUrl || initialData?.apprise_url || ''; + + const handleChannelSelect = (channelId: string) => { + setSelectedChannel(channelId); + setFields({}); + setStep(2); + }; + + const handleFieldChange = (key: string, value: string) => { + setFields((prev) => ({ ...prev, [key]: value })); + }; + + const canProceedStep2 = () => { + const hasAnyField = Object.values(fields).some((v) => v.trim()); + if (initialData?.apprise_url && !hasAnyField) return true; + const channelFields = CHANNEL_FIELDS[selectedChannel] ?? []; + return channelFields.every((f) => f.optional || (fields[f.key] ?? '').trim().length > 0); + }; + + const handleSubmit = () => { + if (!effectiveUrl || !name.trim()) return; + onComplete({ + name: name.trim(), + channel: selectedChannel, + apprise_url: effectiveUrl, + notify_on_errors: notifyOnErrors, + notify_on_success: notifyOnSuccess, + }); + }; + + // ── Step 1: Choose channel ───────────────────────────────────────────── + if (step === 1) { + return ( +
+
+

+ + Choose Notification Channel +

+

Select how you want to receive alerts.

+
+ +
+ {CHANNEL_OPTIONS.map((channel) => ( + + ))} +
+ + +
+ ); + } + + // ── Step 2: Fill in fields ───────────────────────────────────────────── + if (step === 2) { + const channelOption = CHANNEL_OPTIONS.find((c) => c.id === selectedChannel); + const channelFields = CHANNEL_FIELDS[selectedChannel] ?? []; + + return ( +
+ + +
+ {channelOption?.icon} +
+

{channelOption?.label}

+

{channelOption?.description}

+
+
+ + {initialData?.apprise_url && ( +

+ Leave all fields blank to keep the existing URL unchanged. +

+ )} + +
+ {channelFields.map((field) => ( +
+ + handleFieldChange(field.key, e.target.value)} + placeholder={field.placeholder} + className="w-full px-3 py-2 border border-gray-300 rounded-md text-sm focus:outline-none focus:ring-2 focus:ring-blue-500" + /> + {field.hint &&

{field.hint}

} +
+ ))} +
+ +
+ + +
+
+ ); + } + + // ── Step 3: Preview + preferences ───────────────────────────────────── + return ( +
+ + +
+

+ + Final Setup +

+

+ Name your channel and set notification preferences. +

+
+ +
+ + setName(e.target.value)} + placeholder="e.g. My Telegram Alert" + className="w-full px-3 py-2 border border-gray-300 rounded-md text-sm focus:outline-none focus:ring-2 focus:ring-blue-500" + /> +
+ + {effectiveUrl && ( +
+
+

Apprise URL

+ +
+

+ {showUrl ? effectiveUrl : '•'.repeat(effectiveUrl.length)} +

+
+ )} + +
+

Notify me when:

+ + +
+ +
+ + +
+
+ ); +} diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts index 9407d5e..b007342 100644 --- a/frontend/src/lib/api.ts +++ b/frontend/src/lib/api.ts @@ -624,4 +624,135 @@ export const adminApi = { }, }; +// ── Notification Types ────────────────────────────────────────────────── + +export interface NotificationConfig { + id: number; + user_id: number; + name: string; + channel: string; + apprise_url: string | null; + is_enabled: boolean; + config: Record; + notify_on_errors: boolean; + notify_on_success: boolean; + notify_threshold: number; + created_at: string; + updated_at: string; +} + +export interface NotificationConfigCreate { + name: string; + channel: string; + apprise_url?: string | null; + is_enabled?: boolean; + config?: Record; + notify_on_errors?: boolean; + notify_on_success?: boolean; + notify_threshold?: number; +} + +export interface NotificationConfigUpdate { + name?: string; + channel?: string; + apprise_url?: string | null; + is_enabled?: boolean; + config?: Record; + notify_on_errors?: boolean; + notify_on_success?: boolean; + notify_threshold?: number; +} + +export interface AdminNotificationConfig { + id: number; + name: string; + apprise_url: string; + is_enabled: boolean; + notify_on_errors: boolean; + notify_on_system_events: boolean; + description: string | null; + created_at: string; + updated_at: string; +} + +export interface AdminNotificationConfigCreate { + name: string; + apprise_url: string; + is_enabled?: boolean; + notify_on_errors?: boolean; + notify_on_system_events?: boolean; + description?: string | null; +} + +export interface AdminNotificationConfigUpdate { + name?: string; + apprise_url?: string; + is_enabled?: boolean; + notify_on_errors?: boolean; + notify_on_system_events?: boolean; + description?: string | null; +} + +// ── Notifications API ─────────────────────────────────────────────────── + +export const notificationsApi = { + async list(): Promise { + const response = await api.get('/notifications'); + return response.data; + }, + + async create(data: NotificationConfigCreate): Promise { + const response = await api.post('/notifications', data); + return response.data; + }, + + async update(id: number, data: NotificationConfigUpdate): Promise { + const response = await api.put(`/notifications/${id}`, data); + return response.data; + }, + + async delete(id: number): Promise { + await api.delete(`/notifications/${id}`); + }, + + async test(apprise_url: string): Promise<{ success: boolean; message: string }> { + const response = await api.post<{ success: boolean; message: string }>( + '/notifications/test', + { apprise_url } + ); + return response.data; + }, +}; + +// ── Admin Notifications API ───────────────────────────────────────────── + +export const adminNotificationsApi = { + async list(): Promise { + const response = await api.get('/admin/notifications'); + return response.data; + }, + + async create(data: AdminNotificationConfigCreate): Promise { + const response = await api.post('/admin/notifications', data); + return response.data; + }, + + async update(id: number, data: AdminNotificationConfigUpdate): Promise { + const response = await api.put(`/admin/notifications/${id}`, data); + return response.data; + }, + + async delete(id: number): Promise { + await api.delete(`/admin/notifications/${id}`); + }, + + async test(apprise_url: string): Promise<{ success: boolean; message: string }> { + const response = await api.post<{ success: boolean; message: string }>( + '/admin/notifications/test', + { apprise_url } + ); + return response.data; + }, +}; + export default api;