271 lines
8.1 KiB
TypeScript
271 lines
8.1 KiB
TypeScript
import express from 'express';
|
|
import {db} from '../db/index.js';
|
|
import {dismissedAlerts} from '../db/schema.js';
|
|
import {eq, and} from 'drizzle-orm';
|
|
import chalk from 'chalk';
|
|
import fetch from 'node-fetch';
|
|
import type {Request, Response, NextFunction} from 'express';
|
|
|
|
const dbIconSymbol = '🚨';
|
|
const getTimeStamp = (): string => chalk.gray(`[${new Date().toLocaleTimeString()}]`);
|
|
const formatMessage = (level: string, colorFn: chalk.Chalk, message: string): string => {
|
|
return `${getTimeStamp()} ${colorFn(`[${level.toUpperCase()}]`)} ${chalk.hex('#dc2626')(`[${dbIconSymbol}]`)} ${message}`;
|
|
};
|
|
const logger = {
|
|
info: (msg: string): void => {
|
|
console.log(formatMessage('info', chalk.cyan, msg));
|
|
},
|
|
warn: (msg: string): void => {
|
|
console.warn(formatMessage('warn', chalk.yellow, msg));
|
|
},
|
|
error: (msg: string, err?: unknown): void => {
|
|
console.error(formatMessage('error', chalk.redBright, msg));
|
|
if (err) console.error(err);
|
|
},
|
|
success: (msg: string): void => {
|
|
console.log(formatMessage('success', chalk.greenBright, msg));
|
|
},
|
|
debug: (msg: string): void => {
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
console.debug(formatMessage('debug', chalk.magenta, msg));
|
|
}
|
|
}
|
|
};
|
|
|
|
interface CacheEntry {
|
|
data: any;
|
|
timestamp: number;
|
|
expiresAt: number;
|
|
}
|
|
|
|
class AlertCache {
|
|
private cache: Map<string, CacheEntry> = new Map();
|
|
private readonly CACHE_DURATION = 5 * 60 * 1000;
|
|
|
|
set(key: string, data: any): void {
|
|
const now = Date.now();
|
|
this.cache.set(key, {
|
|
data,
|
|
timestamp: now,
|
|
expiresAt: now + this.CACHE_DURATION
|
|
});
|
|
}
|
|
|
|
get(key: string): any | null {
|
|
const entry = this.cache.get(key);
|
|
if (!entry) {
|
|
return null;
|
|
}
|
|
|
|
if (Date.now() > entry.expiresAt) {
|
|
this.cache.delete(key);
|
|
return null;
|
|
}
|
|
|
|
return entry.data;
|
|
}
|
|
}
|
|
|
|
const alertCache = new AlertCache();
|
|
|
|
const GITHUB_RAW_BASE = 'https://raw.githubusercontent.com';
|
|
const REPO_OWNER = 'LukeGus';
|
|
const REPO_NAME = 'Termix-Docs';
|
|
const ALERTS_FILE = 'main/termix-alerts.json';
|
|
|
|
interface TermixAlert {
|
|
id: string;
|
|
title: string;
|
|
message: string;
|
|
expiresAt: string;
|
|
priority?: 'low' | 'medium' | 'high' | 'critical';
|
|
type?: 'info' | 'warning' | 'error' | 'success';
|
|
actionUrl?: string;
|
|
actionText?: string;
|
|
}
|
|
|
|
async function fetchAlertsFromGitHub(): Promise<TermixAlert[]> {
|
|
const cacheKey = 'termix_alerts';
|
|
const cachedData = alertCache.get(cacheKey);
|
|
if (cachedData) {
|
|
return cachedData;
|
|
}
|
|
|
|
try {
|
|
const url = `${GITHUB_RAW_BASE}/${REPO_OWNER}/${REPO_NAME}/${ALERTS_FILE}`;
|
|
|
|
const response = await fetch(url, {
|
|
headers: {
|
|
'Accept': 'application/json',
|
|
'User-Agent': 'TermixAlertChecker/1.0'
|
|
}
|
|
});
|
|
|
|
if (!response.ok) {
|
|
throw new Error(`GitHub raw content error: ${response.status} ${response.statusText}`);
|
|
}
|
|
|
|
const alerts: TermixAlert[] = await response.json() as TermixAlert[];
|
|
|
|
const now = new Date();
|
|
|
|
const validAlerts = alerts.filter(alert => {
|
|
const expiryDate = new Date(alert.expiresAt);
|
|
const isValid = expiryDate > now;
|
|
return isValid;
|
|
});
|
|
|
|
alertCache.set(cacheKey, validAlerts);
|
|
return validAlerts;
|
|
} catch (error) {
|
|
logger.error('Failed to fetch alerts from GitHub', error);
|
|
return [];
|
|
}
|
|
}
|
|
|
|
const router = express.Router();
|
|
|
|
// Route: Get all active alerts
|
|
// GET /alerts
|
|
router.get('/', async (req, res) => {
|
|
try {
|
|
const alerts = await fetchAlertsFromGitHub();
|
|
res.json({
|
|
alerts,
|
|
cached: alertCache.get('termix_alerts') !== null,
|
|
total_count: alerts.length
|
|
});
|
|
} catch (error) {
|
|
logger.error('Failed to get alerts', error);
|
|
res.status(500).json({error: 'Failed to fetch alerts'});
|
|
}
|
|
});
|
|
|
|
// Route: Get alerts for a specific user (excluding dismissed ones)
|
|
// GET /alerts/user/:userId
|
|
router.get('/user/:userId', async (req, res) => {
|
|
try {
|
|
const {userId} = req.params;
|
|
|
|
if (!userId) {
|
|
return res.status(400).json({error: 'User ID is required'});
|
|
}
|
|
|
|
const allAlerts = await fetchAlertsFromGitHub();
|
|
|
|
const dismissedAlertRecords = await db
|
|
.select({alertId: dismissedAlerts.alertId})
|
|
.from(dismissedAlerts)
|
|
.where(eq(dismissedAlerts.userId, userId));
|
|
|
|
const dismissedAlertIds = new Set(dismissedAlertRecords.map(record => record.alertId));
|
|
|
|
const userAlerts = allAlerts.filter(alert => !dismissedAlertIds.has(alert.id));
|
|
|
|
res.json({
|
|
alerts: userAlerts,
|
|
total_count: userAlerts.length,
|
|
dismissed_count: dismissedAlertIds.size
|
|
});
|
|
} catch (error) {
|
|
logger.error('Failed to get user alerts', error);
|
|
res.status(500).json({error: 'Failed to fetch user alerts'});
|
|
}
|
|
});
|
|
|
|
// Route: Dismiss an alert for a user
|
|
// POST /alerts/dismiss
|
|
router.post('/dismiss', async (req, res) => {
|
|
try {
|
|
const {userId, alertId} = req.body;
|
|
|
|
if (!userId || !alertId) {
|
|
logger.warn('Missing userId or alertId in dismiss request');
|
|
return res.status(400).json({error: 'User ID and Alert ID are required'});
|
|
}
|
|
|
|
const existingDismissal = await db
|
|
.select()
|
|
.from(dismissedAlerts)
|
|
.where(and(
|
|
eq(dismissedAlerts.userId, userId),
|
|
eq(dismissedAlerts.alertId, alertId)
|
|
));
|
|
|
|
if (existingDismissal.length > 0) {
|
|
logger.warn(`Alert ${alertId} already dismissed by user ${userId}`);
|
|
return res.status(409).json({error: 'Alert already dismissed'});
|
|
}
|
|
|
|
const result = await db.insert(dismissedAlerts).values({
|
|
userId,
|
|
alertId
|
|
});
|
|
|
|
logger.success(`Alert ${alertId} dismissed by user ${userId}. Insert result: ${JSON.stringify(result)}`);
|
|
res.json({message: 'Alert dismissed successfully'});
|
|
} catch (error) {
|
|
logger.error('Failed to dismiss alert', error);
|
|
res.status(500).json({error: 'Failed to dismiss alert'});
|
|
}
|
|
});
|
|
|
|
// Route: Get dismissed alerts for a user
|
|
// GET /alerts/dismissed/:userId
|
|
router.get('/dismissed/:userId', async (req, res) => {
|
|
try {
|
|
const {userId} = req.params;
|
|
|
|
if (!userId) {
|
|
return res.status(400).json({error: 'User ID is required'});
|
|
}
|
|
|
|
const dismissedAlertRecords = await db
|
|
.select({
|
|
alertId: dismissedAlerts.alertId,
|
|
dismissedAt: dismissedAlerts.dismissedAt
|
|
})
|
|
.from(dismissedAlerts)
|
|
.where(eq(dismissedAlerts.userId, userId));
|
|
|
|
res.json({
|
|
dismissed_alerts: dismissedAlertRecords,
|
|
total_count: dismissedAlertRecords.length
|
|
});
|
|
} catch (error) {
|
|
logger.error('Failed to get dismissed alerts', error);
|
|
res.status(500).json({error: 'Failed to fetch dismissed alerts'});
|
|
}
|
|
});
|
|
|
|
// Route: Undismiss an alert for a user (remove from dismissed list)
|
|
// DELETE /alerts/dismiss
|
|
router.delete('/dismiss', async (req, res) => {
|
|
try {
|
|
const {userId, alertId} = req.body;
|
|
|
|
if (!userId || !alertId) {
|
|
return res.status(400).json({error: 'User ID and Alert ID are required'});
|
|
}
|
|
|
|
const result = await db
|
|
.delete(dismissedAlerts)
|
|
.where(and(
|
|
eq(dismissedAlerts.userId, userId),
|
|
eq(dismissedAlerts.alertId, alertId)
|
|
));
|
|
|
|
if (result.changes === 0) {
|
|
return res.status(404).json({error: 'Dismissed alert not found'});
|
|
}
|
|
|
|
logger.success(`Alert ${alertId} undismissed by user ${userId}`);
|
|
res.json({message: 'Alert undismissed successfully'});
|
|
} catch (error) {
|
|
logger.error('Failed to undismiss alert', error);
|
|
res.status(500).json({error: 'Failed to undismiss alert'});
|
|
}
|
|
});
|
|
|
|
export default router;
|