feat(notif): allow users to enable/disable specific agents (#1172)

* refactor(ui): add tabs to user notification settings

* feat(notif): allow users to enable/disable specific agents

* fix(ui): only enforce required fields when agent is enabled

* fix(ui): hide unavailable notification agents

* feat(notif): mention admin users for admin Discord notifications

* fix(ui): modify styling of PGP key textareas to suit expected input

* fix(notif): mention all admins when there are multiple and fix rebase error

* fix: add missing form values, and fix Yup validation

* refactor: reduce repeated logic/code in email notif agent

* refactor: move 'Notification Types' label into NotificationTypeSelector component

* fix(email): correct inconsistencies in email template formatting

* refactor: use bitfields for storing user-enabled notif agent types

* feat: improve notification agent logging

* fix(ui): mark string fields as nullable so empty values are not type errors

* fix: add validation for PGP-related inputs

* fix: correctly fetch user in user settings & log mentioned IDs for Discord notifs

* fix(ui): fix mobile nav dropdown text & add hover effect to button-style tabs

* fix(notif): process admin email notifications asynchronously

* fix(logging): log name of notification type instead of its enum value

* fix: mark required fields and pass all user settings values to API

* fix(frontend): call mutate after changing email/Discord/Telegram global notif settings

* refactor: get global notif settings from relevant API endpoints instead of adding to public settings

* fix(notif): fall back to email notifications being enabled (default) if user settings do not exist

* fix(notif): do not set notifyUser for MEDIA_PENDING or MEDIA_AUTO_APPROVED

* fix: expose notif enabled settings in user notif endpoints & remove global enable notif setting

* fix(notif): remove unnecessary allowed_mentions object from Discord payload

* fix(notif): use form values for email test notification

* fix: make suggested changes and regenerate DB migration

* fix: loosen validation of PGP keys

* fix: fix user profile settings routes

* fix: remove route guard from profile pages

server/lib/notifications/agents/telegram.ts

@@ -3,6 +3,7 @@ import { hasNotificationType, Notification } from '..';
 import { MediaType } from '../../../constants/media';
 import logger from '../../../logger';
 import { getSettings, NotificationAgentTelegram } from '../../settings';
+import { NotificationAgentType } from '../agenttypes';
 import { BaseAgent, NotificationAgent, NotificationPayload } from './agent';
 
 interface TelegramMessagePayload {
@@ -155,62 +156,98 @@ class TelegramAgent
     type: Notification,
     payload: NotificationPayload
   ): Promise<boolean> {
-    logger.debug('Sending Telegram notification', { label: 'Notifications' });
+    const endpoint = `${this.baseUrl}bot${this.getSettings().options.botAPI}/${
+      payload.image ? 'sendPhoto' : 'sendMessage'
+    }`;
+
+    // Send system notification
     try {
-      const endpoint = `${this.baseUrl}bot${
-        this.getSettings().options.botAPI
-      }/${payload.image ? 'sendPhoto' : 'sendMessage'}`;
+      logger.debug('Sending Telegram notification', {
+        label: 'Notifications',
+        type: Notification[type],
+        subject: payload.subject,
+      });
 
-      // Send system notification
-      await (payload.image
-        ? axios.post(endpoint, {
-            photo: payload.image,
-            caption: this.buildMessage(type, payload),
-            parse_mode: 'MarkdownV2',
-            chat_id: `${this.getSettings().options.chatId}`,
-            disable_notification: this.getSettings().options.sendSilently,
-          } as TelegramPhotoPayload)
-        : axios.post(endpoint, {
-            text: this.buildMessage(type, payload),
-            parse_mode: 'MarkdownV2',
-            chat_id: `${this.getSettings().options.chatId}`,
-            disable_notification: this.getSettings().options.sendSilently,
-          } as TelegramMessagePayload));
-
-      // Send user notification
-      if (
-        payload.notifyUser &&
-        (payload.notifyUser.settings?.enableNotifications ?? true) &&
-        payload.notifyUser.settings?.telegramChatId &&
-        payload.notifyUser.settings?.telegramChatId !==
-          this.getSettings().options.chatId
-      ) {
-        await (payload.image
-          ? axios.post(endpoint, {
+      await axios.post(
+        endpoint,
+        payload.image
+          ? ({
               photo: payload.image,
               caption: this.buildMessage(type, payload),
               parse_mode: 'MarkdownV2',
-              chat_id: `${payload.notifyUser.settings.telegramChatId}`,
-              disable_notification:
-                payload.notifyUser.settings.telegramSendSilently,
+              chat_id: this.getSettings().options.chatId,
+              disable_notification: this.getSettings().options.sendSilently,
             } as TelegramPhotoPayload)
-          : axios.post(endpoint, {
+          : ({
               text: this.buildMessage(type, payload),
               parse_mode: 'MarkdownV2',
-              chat_id: `${payload.notifyUser.settings.telegramChatId}`,
-              disable_notification:
-                payload.notifyUser.settings.telegramSendSilently,
-            } as TelegramMessagePayload));
-      }
-
-      return true;
+              chat_id: `${this.getSettings().options.chatId}`,
+              disable_notification: this.getSettings().options.sendSilently,
+            } as TelegramMessagePayload)
+      );
     } catch (e) {
       logger.error('Error sending Telegram notification', {
         label: 'Notifications',
-        message: e.message,
+        type: Notification[type],
+        subject: payload.subject,
+        errorMessage: e.message,
+        response: e.response.data,
       });
       return false;
     }
+
+    if (
+      payload.notifyUser &&
+      payload.notifyUser.settings?.hasNotificationAgentEnabled(
+        NotificationAgentType.TELEGRAM
+      ) &&
+      payload.notifyUser.settings?.telegramChatId &&
+      payload.notifyUser.settings?.telegramChatId !==
+        this.getSettings().options.chatId
+    ) {
+      // Send notification to the user who submitted the request
+      logger.debug('Sending Telegram notification', {
+        label: 'Notifications',
+        recipient: payload.notifyUser.displayName,
+        type: Notification[type],
+        subject: payload.subject,
+      });
+
+      try {
+        await axios.post(
+          endpoint,
+          payload.image
+            ? ({
+                photo: payload.image,
+                caption: this.buildMessage(type, payload),
+                parse_mode: 'MarkdownV2',
+                chat_id: payload.notifyUser.settings.telegramChatId,
+                disable_notification:
+                  payload.notifyUser.settings.telegramSendSilently,
+              } as TelegramPhotoPayload)
+            : ({
+                text: this.buildMessage(type, payload),
+                parse_mode: 'MarkdownV2',
+                chat_id: payload.notifyUser.settings.telegramChatId,
+                disable_notification:
+                  payload.notifyUser.settings.telegramSendSilently,
+              } as TelegramMessagePayload)
+        );
+      } catch (e) {
+        logger.error('Error sending Telegram notification', {
+          label: 'Notifications',
+          recipient: payload.notifyUser.displayName,
+          type: Notification[type],
+          subject: payload.subject,
+          errorMessage: e.message,
+          response: e.response.data,
+        });
+
+        return false;
+      }
+    }
+
+    return true;
   }
 }