Merge pull request #32 from AmRo045/dev

Fix sync job & improve notification channel logic

Author: AmRo045

package.json

@@ -1,6 +1,6 @@
 {
   "name": "outline-admin",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "private": true,
   "scripts": {
     "compile": "tsc -p tsconfig.scripts.json && tscpaths -p tsconfig.scripts.tscpaths.json -s ./dist -o ./dist",

scripts/health-check.ts

@@ -9,7 +9,7 @@ import { sendNotificationViaTelegramChannel } from "@/src/core/actions/notificat
 
 let logger = createLogger(LoggerContext.HealthCheckJob);
 
-async function handleUnavailableServer(server: any) {
+async function handleUnavailableServer(server: any, errorMessage: string) {
     const healthCheck = server.healthCheck;
     const now = new Date();
 
@@ -37,7 +37,7 @@ async function handleUnavailableServer(server: any) {
     if (healthCheck.notification === HealthCheckNotificationType.Telegram && server.healthCheck.notificationConfig) {
         try {
             logger.info("Sending Telegram notification...");
-            await sendNotificationViaTelegramChannel(server);
+            await sendNotificationViaTelegramChannel(server, errorMessage);
 
             await prisma.healthCheck.update({
                 where: { serverId: server.id },
@@ -107,7 +107,13 @@ async function checkServerHealth(server: any) {
         if (!response.ok) {
             logger.error(`[${server.name}] HTTP ${response.status} - ${response.statusText}`);
 
-            return await handleUnavailableServer(server);
+            const errorText = await response.text();
+            const errorMessage = JSON.stringify({
+                status: response.status,
+                message: errorText
+            });
+
+            return await handleUnavailableServer(server, errorMessage);
         }
 
         logger.info(`[${server.name}] Healthy (${response.status}) — ${duration.toFixed(0)}ms`);
@@ -130,7 +136,7 @@ async function checkServerHealth(server: any) {
         });
     } catch (error: any) {
         logger.error(`[${server.name}] Error:`, error.message);
-        await handleUnavailableServer(server);
+        await handleUnavailableServer(server, error.message);
     }
 }
 

src/components/notification-channel-form.tsx

@@ -100,11 +100,13 @@ export default function NotificationChannelForm({ channel }: Props) {
         let config = null;
 
         if (data.type === "Telegram") {
+            const messageTemplate = data.telegramMessageTemplate ?? "";
+
             config = JSON.stringify({
                 apiUrl: data.telegramApiUrl!,
                 botToken: data.telegramBotToken!,
                 chatId: data.telegramChatId!,
-                messageTemplate: data.telegramMessageTemplate!
+                messageTemplate: messageTemplate.length > 0 ? messageTemplate : app.defaultTelegramNotificationTemplate
             });
         }
 
@@ -261,15 +263,13 @@ export default function NotificationChannelForm({ channel }: Props) {
 
                             <Textarea
                                 color="primary"
-                                description="Available placeholders: {{serverName}} {{serverHostnameOrIp}}"
+                                description="Available placeholders: {{serverName}} {{serverHostnameOrIp}} {{errorMessage}}"
                                 errorMessage={formState.errors.telegramMessageTemplate?.message}
                                 isInvalid={!!formState.errors.telegramMessageTemplate}
-                                label="Message template"
-                                placeholder={`e.g. "{{serverName}} ({{serverHostnameOrIp}})" is out of reach!`}
+                                label="Message template (Markdown)"
+                                placeholder={`e.g. ${app.defaultTelegramNotificationTemplate}`}
                                 variant="underlined"
-                                {...register("telegramMessageTemplate", {
-                                    required: "Message template is required"
-                                })}
+                                {...register("telegramMessageTemplate")}
                             />
                         </div>
                     )}

src/core/actions/notification-channel.ts

@@ -6,6 +6,7 @@ import { Telegraf } from "telegraf";
 
 import prisma from "@/prisma/db";
 import { ServerWithHealthCheck, TelegramNotificationChannelConfig } from "@/src/core/definitions";
+import { app } from "@/src/core/config";
 
 export async function createNotificationChannel(data: any): Promise<void> {
     await prisma.notificationChannel.create({ data });
@@ -67,7 +68,10 @@ export async function deleteNotificationChannel(id: number): Promise<void> {
     revalidatePath(`/notification-channels/${id}`);
 }
 
-export async function sendNotificationViaTelegramChannel(server: ServerWithHealthCheck): Promise<void> {
+export async function sendNotificationViaTelegramChannel(
+    server: ServerWithHealthCheck,
+    errorMessage: string
+): Promise<void> {
     const channel = await getNotificationChannelById(server.healthCheck!.notificationChannelId!);
 
     if (!channel) {
@@ -85,10 +89,16 @@ export async function sendNotificationViaTelegramChannel(server: ServerWithHealt
     const userId = config.chatId;
 
     const message = config.messageTemplate
+        .replaceAll("{{errorMessage}}", errorMessage)
         .replaceAll("{{serverName}}", server.name)
         .replaceAll("{{serverHostnameOrIp}}", server.hostnameOrIp);
 
-    await bot.telegram.sendMessage(userId, message);
+    await bot.telegram.sendMessage(userId, message, {
+        parse_mode: "Markdown",
+        link_preview_options: {
+            is_disabled: true
+        }
+    });
 }
 
 export async function testTelegramNotificationChannel(
@@ -116,10 +126,7 @@ export async function testTelegramNotificationChannel(
     }
 
     if (!config.messageTemplate) {
-        return {
-            ok: false,
-            message: "Message Template is required"
-        };
+        config.messageTemplate = app.defaultTelegramNotificationTemplate;
     }
 
     try {
@@ -132,10 +139,16 @@ export async function testTelegramNotificationChannel(
         const userId = config.chatId;
 
         const message = config.messageTemplate
+            .replaceAll("{{errorMessage}}", "Example server error message")
             .replaceAll("{{serverName}}", "Example Server")
             .replaceAll("{{serverHostnameOrIp}}", "10.11.12.13");
 
-        await bot.telegram.sendMessage(userId, message);
+        await bot.telegram.sendMessage(userId, message, {
+            parse_mode: "Markdown",
+            link_preview_options: {
+                is_disabled: true
+            }
+        });
 
         return {
             ok: true,

src/core/config.ts

@@ -15,6 +15,16 @@ export const app = {
     description:
         "Outline Admin is a web interface for the Outline Manager API, providing a simple and user-friendly UI for managing VPN servers.",
 
+    defaultTelegramNotificationTemplate: `⚠️ OUTLINE ADMIN ⚠️
+
+**\`{{serverName}}\`** (\`{{serverHostnameOrIp}}\`) is out of reach!
+
+
+[[Error]]:
+\`\`\`
+{{errorMessage}}
+\`\`\``,
+
     links: {
         github: "https://github.com/AmRo045/OutlineAdmin",
         x: "https://x.com/AmRo045",

src/core/outline/outline-sync-service.ts

@@ -44,6 +44,25 @@ export class OutlineSyncService {
             this.logger.info("Getting server usage metrics...");
             const metrics = await this.client.metricsTransfer();
 
+            const allMetrics = Object.values(metrics.bytesTransferredByUserId);
+            const totalUsageMetrics = allMetrics.reduce(
+                (previousValue, currentValue) => previousValue + currentValue,
+                0
+            );
+
+            this.logger.info("Updating server info in local database...");
+            await prisma.server.update({
+                where: { id: this.server.id },
+                data: {
+                    name: remoteServerInfo.name,
+                    hostnameOrIp: remoteServerInfo.hostnameForAccessKeys,
+                    hostnameForNewAccessKeys: remoteServerInfo.hostnameForAccessKeys,
+                    portForNewAccessKeys: remoteServerInfo.portForNewAccessKeys,
+                    isMetricsEnabled: remoteServerInfo.metricsEnabled,
+                    totalDataUsage: totalUsageMetrics
+                }
+            });
+
             await this.syncAccessKeys(metrics);
         }
     }