@logboard/cli 1.0.0

package/controllers/UiController.js

@@ -0,0 +1,789 @@
+'use strict';
+const config = require('../config');
+const { getToday } = require('../lib/utils');
+
+class UiController {
+	constructor (logService, analyticsService) {
+		this.logs = logService;
+		this.analytics = analyticsService;
+	}
+
+	// Returns an org-scoped LogService for the current request
+	_logSvc (req) {
+		const LogService = require('../services/LogService');
+		return new LogService(this.logs.batchWriter, req.org);
+	}
+
+	// Returns an org-scoped AnalyticsService for the current request  
+	_analyticsSvc (req) {
+		const AnalyticsService = require('../services/AnalyticsService');
+		return new AnalyticsService(req.org);
+	}
+
+	async _base (req, extra = {}) {
+		try {
+			const { RoleConfigService } = require('../services/RoleConfigService');
+			const SettingsService = require('../services/SettingsService');
+			const org  = req.org || null;
+			const role = req.user?.role || 'viewer';
+
+			// Super-admin: no org context, use global settings only
+			if (role === 'super-admin') {
+				const { buildThemeSnippet } = require('../lib/theme');
+				let settings = {};
+				try { settings = await new SettingsService(null).get(); } catch {}
+				return {
+					user: req.user, allowedPages: [], allowedCards: [],
+					settings, appName: settings.appName || 'LogBoard',
+					appLogoUrl: settings.appLogoUrl || '/public/logo.png',
+					themeSnippet: buildThemeSnippet(settings), ...extra,
+				};
+			}
+
+			const rc = new RoleConfigService(org);
+			const [allowedPages, allowedCards, settings] = await Promise.all([
+				rc.getAllowedPages(role),
+				rc.getAllowedCards(role),
+				new SettingsService(org).get(),
+			]);
+			const { buildThemeSnippet } = require('../lib/theme');
+			return {
+				user: req.user,
+				allowedPages,
+				allowedCards,
+				settings,
+				appName: settings.appName || 'LogBoard',
+				appLogoUrl: settings.appLogoUrl || '/public/logo.png',
+				themeSnippet: buildThemeSnippet(settings),
+				...extra,
+			};
+		} catch {
+			return {
+				user: req.user,
+				allowedPages: null,
+				allowedCards: [],
+				settings: {},
+				appName: 'LogBoard',
+				appLogoUrl: '/public/logo.png',
+				themeSnippet: '',
+				...extra,
+			};
+		}
+	}
+
+	async loginPage (req, res) {
+		try {
+			const SettingsService = require('../services/SettingsService');
+			const s = await new SettingsService(req.org).get();
+			res.render('login', {
+				title: 'Login',
+				error: null,
+				settings: s,
+				themeSnippet: require('../lib/theme').buildThemeSnippet(s),
+				appName: s.appName || 'LogBoard',
+				appLogoUrl: s.appLogoUrl || '/public/logo.png',
+			});
+		} catch {
+			res.render('login', {
+				title: 'Login',
+				error: null,
+				settings: {},
+				appName: 'LogBoard',
+				appLogoUrl: '/public/logo.png',
+			});
+		}
+	}
+
+	async dashboard (req, res) {
+		try {
+			const { RoleConfigService } = require('../services/RoleConfigService');
+			const AnalyticsService = require('../services/AnalyticsService');
+			const role = req.user?.role || 'viewer';
+			const allowedApps = await new RoleConfigService(req.org).getAllowedApps(
+				role,
+			);
+			const [overview, hourly, errors, trend] = await Promise.all([
+				new AnalyticsService(req.org).getOverview(allowedApps),
+				new AnalyticsService(req.org).getHourlyVolume(
+					null,
+					getToday(),
+					allowedApps,
+				),
+				new AnalyticsService(req.org).getRecentErrors(10, allowedApps),
+				new AnalyticsService(req.org).getDailyTrend(null, 7, allowedApps),
+			]);
+			const bp = await this._base(req);
+			// Load per-user dashboard order
+			let dashOrder = null;
+			try {
+				const path = require('path'),
+					fsp = require('fs').promises;
+				const orderFile = path.join(
+					require('../config').DATA_DIR,
+					`dashorder-${ req.user.username }.json`,
+				);
+				const raw = await fsp.readFile(orderFile, 'utf8');
+				dashOrder = JSON.parse(raw);
+			} catch {}
+			res.render('dashboard', {
+				...bp,
+				title: 'Dashboard',
+				overview,
+				hourly,
+				errors,
+				trend,
+				today: getToday(),
+				dashOrder,
+			});
+		} catch (err) {
+			const bp = await this._base(req);
+			res.render('dashboard', {
+				...bp,
+				title: 'Dashboard',
+				overview: null,
+				hourly: null,
+				errors: [],
+				trend: [],
+				today: getToday(),
+				dashOrder: null,
+				renderError: err.message,
+			});
+		}
+	}
+
+	async logsPage (req, res) {
+		try {
+			const allServices = await this._logSvc(req).getServices();
+			// Per-service access control: filter by role's allowedApps
+			const { RoleConfigService } = require('../services/RoleConfigService');
+			const role = req.user?.role || 'viewer';
+			const allowedApps = await new RoleConfigService(req.org).getAllowedApps(
+				role,
+			);
+			const services = allowedApps.length
+				? allServices.filter((s) => allowedApps.includes(s.appName))
+				: allServices; // empty = all allowed
+			const { service, date, level, q, fromTime, toTime, fromDate, toDate }
+        = req.query;
+			let results = null;
+			// Enforce service access
+			if (service && allowedApps.length && !allowedApps.includes(service)) {
+				const bp2 = await this._base(req);
+				return res.render('logs', {
+					...bp2,
+					title: 'Logs',
+					services,
+					selected: {
+						service: '',
+						date: date || getToday(),
+						level: level || '',
+						q: q || '',
+						fromTime: '',
+						toTime: '',
+						fromDate: '',
+						toDate: '',
+					},
+					results: null,
+					today: getToday(),
+					accessError: `You do not have access to service: ${ service}`,
+				});
+			}
+			const effectiveDate
+        = date || (service ? getToday() : !fromDate ? getToday() : '');
+			// Search across all services when none selected but query/level provided
+			if (!service && (q || level) && effectiveDate) {
+				// Search all accessible services for the query
+				const allLines = [];
+				for (const { appName: svcName } of services.slice(0, 20)) {
+					try {
+						const r = await this._logSvc(req).search({
+							service: svcName,
+							date: effectiveDate,
+							level,
+							q,
+							limit: 50,
+						});
+						if (r && r.lines) {
+							// Tag each line with service name if not already tagged
+							r.lines.forEach((line) => {
+								try {
+									const p = JSON.parse(line);
+									if (!p.appName) { p.appName = svcName; }
+									allLines.push(JSON.stringify(p));
+								} catch {
+									allLines.push(line);
+								}
+							});
+						}
+					} catch {}
+				}
+				results = { lines: allLines.slice(0, 500), total: allLines.length };
+			} else if (service && effectiveDate) {
+				if (fromTime || toTime) {
+					results = await this._logSvc(req).searchTimeRange(service, effectiveDate, {
+						fromTime,
+						toTime,
+						level,
+						q,
+						limit: 500,
+					});
+				} else if (level || q) {
+					results = await this._logSvc(req).search({
+						service,
+						date: effectiveDate,
+						level,
+						q,
+						limit: 500,
+					});
+				} else {
+					results = await this._logSvc(req).tail(service, effectiveDate, 200);
+				}
+			} else if (service && fromDate && toDate) {
+				results = await this._logSvc(req).searchMultiDate(service, fromDate, toDate, {
+					level,
+					q,
+					limit: 500,
+				});
+			}
+			const bp = await this._base(req);
+			res.render('logs', {
+				...bp,
+				title: 'Logs',
+				services,
+				selected: {
+					service: service || '',
+					date: effectiveDate || getToday(),
+					level: level || '',
+					q: q || '',
+					fromTime: fromTime || '',
+					toTime: toTime || '',
+					fromDate: fromDate || '',
+					toDate: toDate || '',
+				},
+				results,
+				today: getToday(),
+			});
+		} catch (err) {
+			const bp = await this._base(req);
+			res.render('logs', {
+				...bp,
+				title: 'Logs',
+				services: [],
+				selected: {
+					service: '',
+					date: getToday(),
+					level: '',
+					q: '',
+					fromTime: '',
+					toTime: '',
+					fromDate: '',
+					toDate: '',
+				},
+				results: null,
+				today: getToday(),
+				renderError: err.message,
+			});
+		}
+	}
+
+	async livePage (req, res) {
+		try {
+			const services = await this._logSvc(req).getServices();
+			const bp = await this._base(req);
+			res.render('live', { ...bp, title: 'Live Stream', services });
+		} catch {
+			const bp = await this._base(req);
+			res.render('live', { ...bp, title: 'Live Stream', services: [] });
+		}
+	}
+
+	async insightsPage (req, res) {
+		try {
+			const { service, date } = req.query;
+			const today = getToday();
+			const selDate = date || today;
+			const ApiAnalyticsService = require('../services/ApiAnalyticsService');
+			const AnalyticsService = require('../services/AnalyticsService');
+			const _allowedInsights = await (async () => {
+				try {
+					const {
+						RoleConfigService,
+					} = require('../services/RoleConfigService');
+					return await new RoleConfigService(req.org).getAllowedApps(
+						req.user?.role || 'viewer',
+					);
+				} catch {
+					return [];
+				}
+			})();
+			const [logServices, apiServicesList, hourly, breakdown, topSvcs, trend]
+        = await Promise.all([
+        	this._logSvc(req).getServices(),
+        	new ApiAnalyticsService().getApiServices().catch(() => []),
+        	new AnalyticsService(req.org).getHourlyVolume(
+        		service || null,
+        		selDate,
+        		_allowedInsights,
+        	),
+        	new AnalyticsService(req.org).getLevelBreakdown(
+        		service || null,
+        		selDate,
+        	),
+        	new AnalyticsService(req.org).getTopServices(
+        		selDate,
+        		10,
+        		_allowedInsights,
+        	),
+        	new AnalyticsService(req.org).getDailyTrend(
+        		service || null,
+        		7,
+        		_allowedInsights,
+        	),
+        ]);
+			const bp = await this._base(req);
+			res.render('insights', {
+				...bp,
+				title: 'Insights',
+				logServices,
+				apiServices: apiServicesList,
+				selected: { service: service || '', date: selDate },
+				hourly,
+				breakdown,
+				topSvcs,
+				trend,
+				today,
+			});
+		} catch (err) {
+			const bp = await this._base(req);
+			res.render('insights', {
+				...bp,
+				title: 'Insights',
+				logServices: [],
+				apiServices: [],
+				selected: {},
+				hourly: null,
+				breakdown: null,
+				topSvcs: [],
+				trend: [],
+				today: getToday(),
+				renderError: err.message,
+			});
+		}
+	}
+
+	async healthPage (req, res) {
+		try {
+			const AnalyticsService = require('../services/AnalyticsService');
+			const { RoleConfigService } = require('../services/RoleConfigService');
+			let serviceHealth = [];
+			try {
+				const rawHealth     = await new AnalyticsService(req.org).getServiceHealth();
+				const allowedApps2  = await new RoleConfigService(req.org).getAllowedApps(req.user?.role || 'viewer');
+				serviceHealth = allowedApps2.length ? rawHealth.filter(s => allowedApps2.includes(s.appName)) : rawHealth;
+			} catch {}
+			const bp = await this._base(req);
+			res.render('health', {
+				...bp,
+				title: 'Health',
+				serviceHealth,
+			});
+		} catch (err) {
+			const bp = await this._base(req);
+			res.render('health', { ...bp, title: 'Health', serviceHealth: [], renderError: err.message });
+		}
+	}
+
+	async settingsPage (req, res) {
+		try {
+			const SettingsService = require('../services/SettingsService');
+			const AuthService = require('../services/AuthService');
+			const { PRESETS } = require('../lib/theme');
+			const [settings, totpStatus] = await Promise.all([
+				new SettingsService(req.org).get(),
+				new AuthService().getTotpStatus(req.user.username),
+			]);
+			const bp = await this._base(req);
+			res.render('settings', {
+				...bp,
+				title: 'Settings',
+				isAdmin: req.user.role === 'admin' || req.user.role === 'super-admin',
+				settings,
+				totpEnabled: totpStatus.enabled,
+				PRESETS,
+			});
+		} catch (err) {
+			res
+				.status(500)
+				.render('404', {
+					title: 'Error',
+					user: req.user || null,
+					settings: {},
+					appName: 'LogBoard',
+					appLogoUrl: '/public/logo.png',
+				});
+		}
+	}
+
+	async usersPage (req, res) {
+		try {
+			const UserService = require('../services/UserService');
+			const { RoleConfigService } = require('../services/RoleConfigService');
+			const [users, rolesData] = await Promise.all([
+				new UserService().getAll(),
+				new RoleConfigService(req.org).getRoles(),
+			]);
+			const bp = await this._base(req);
+			res.render('users', {
+				...bp,
+				title: 'Users',
+				users,
+				roles: Object.keys(rolesData),
+				rolesData,
+			});
+		} catch (err) {
+			res
+				.status(500)
+				.render('404', {
+					title: 'Error',
+					user: req.user || null,
+					settings: {},
+					appName: 'LogBoard',
+					appLogoUrl: '/public/logo.png',
+				});
+		}
+	}
+
+	async apiKeysPage (req, res) {
+		try {
+			const ApiKeyService = require('../services/ApiKeyService');
+			const keys = await new ApiKeyService().list();
+			const bp = await this._base(req);
+			const SCOPES = [
+				'logs:write',
+				'logs:read',
+				'analytics:read',
+				'health:read',
+				'stream:read',
+			];
+			res.render('api-keys', { ...bp, title: 'API Keys', keys, SCOPES });
+		} catch (err) {
+			res
+				.status(500)
+				.render('404', {
+					title: 'Error',
+					user: req.user || null,
+					settings: {},
+					appName: 'LogBoard',
+					appLogoUrl: '/public/logo.png',
+				});
+		}
+	}
+
+	async rolesPage (req, res) {
+		try {
+			const {
+				RoleConfigService,
+				ALL_PAGES,
+				ALL_CARDS,
+			} = require('../services/RoleConfigService');
+			const rolesData = await new RoleConfigService(req.org).getRoles();
+			const bp = await this._base(req);
+			res.render('roles', {
+				...bp,
+				title: 'Role Config',
+				rolesData,
+				allPages: ALL_PAGES,
+				allCards: ALL_CARDS,
+			});
+		} catch (err) {
+			res
+				.status(500)
+				.render('404', {
+					title: 'Error',
+					user: req.user || null,
+					settings: {},
+					appName: 'LogBoard',
+					appLogoUrl: '/public/logo.png',
+				});
+		}
+	}
+
+	async auditPage (req, res) {
+		try {
+			const AuditService = require('../services/AuditService'); const audit = new AuditService(req.org); const { q = '', limit = 200, action = '' } = req.query;
+			const { entries, total } = await audit.list({
+				limit: Number(limit),
+				q,
+				action,
+			});
+			const bp = await this._base(req);
+			res.render('audit', {
+				...bp,
+				title: 'Audit Log',
+				entries,
+				total,
+				q,
+				action,
+			});
+		} catch (err) {
+			res
+				.status(500)
+				.render('404', {
+					title: 'Error',
+					user: req.user || null,
+					settings: {},
+					appName: 'LogBoard',
+					appLogoUrl: '/public/logo.png',
+				});
+		}
+	}
+
+	async alertsPage (req, res) {
+		try {
+			const svc = require('../services/AlertRulesService');
+			const logSvcs = await this._logSvc(req).getServices();
+			const [rules, history] = await Promise.all([
+				svc.listRules(),
+				svc.getHistory(50),
+			]);
+			const bp = await this._base(req);
+			res.render('alerts', {
+				...bp,
+				title: 'Alert Rules',
+				rules,
+				history,
+				logServices: logSvcs,
+			});
+		} catch (err) {
+			console.log(err);
+			res
+				.status(500)
+				.render('404', {
+					title: 'Error',
+					user: req.user || null,
+					settings: {},
+					appName: 'LogBoard',
+					appLogoUrl: '/public/logo.png',
+				});
+		}
+	}
+
+	async archivePage (req, res) {
+		try {
+			const path = require('path'),
+				fs = require('fs');
+			const dir = config.ARCHIVE_DIR;
+			const files = fs.existsSync(dir)
+				? fs
+					.readdirSync(dir)
+					.filter((f) => f.endsWith('.tar.gz') || f.endsWith('.zip'))
+					.map((f) => {
+						const fp = path.join(dir, f),
+							st = fs.statSync(fp);
+						return { name: f, size: st.size, created: st.birthtime };
+					})
+					.sort((a, b) => new Date(b.created) - new Date(a.created))
+				: [];
+			const logSvcs = await this._logSvc(req).getServices();
+			const bp = await this._base(req);
+			res.render('archive', {
+				...bp,
+				title: 'Log Archive',
+				archives: files,
+				logServices: logSvcs,
+			});
+		} catch (err) {
+			res
+				.status(500)
+				.render('404', {
+					title: 'Error',
+					user: req.user || null,
+					settings: {},
+					appName: 'LogBoard',
+					appLogoUrl: '/public/logo.png',
+				});
+		}
+	}
+
+	// ── NEW PAGES ─────────────────────────────────────────────────────────────
+
+	async heatmapPage (req, res) {
+		try {
+			const { service } = req.query;
+			const services = await this._logSvc(req).getServices();
+			const AnalyticsService = require('../services/AnalyticsService');
+			const heatmapData = service
+				? await new AnalyticsService(req.org).getHeatmap(service)
+				: null;
+			const bp = await this._base(req);
+			res.render('heatmap', {
+				...bp,
+				title: 'Error Heatmap',
+				services,
+				service: service || '',
+				heatmapData,
+			});
+		} catch (err) {
+			const bp = await this._base(req);
+			res.render('heatmap', {
+				...bp,
+				title: 'Error Heatmap',
+				services: [],
+				service: '',
+				heatmapData: null,
+				renderError: err.message,
+			});
+		}
+	}
+
+	async diffPage (req, res) {
+		try {
+			const { service, dateA, dateB } = req.query;
+			const services = await this._logSvc(req).getServices();
+			let diffData = null;
+			if (service && dateA && dateB) { diffData = await this._logSvc(req).getDiff(service, dateA, dateB); }
+			const bp = await this._base(req);
+			res.render('diff', {
+				...bp,
+				title: 'Log Diff',
+				services,
+				service: service || '',
+				dateA: dateA || '',
+				dateB: dateB || '',
+				diffData,
+				today: getToday(),
+			});
+		} catch (err) {
+			const bp = await this._base(req);
+			res.render('diff', {
+				...bp,
+				title: 'Log Diff',
+				services: [],
+				service: '',
+				dateA: '',
+				dateB: '',
+				diffData: null,
+				today: getToday(),
+				renderError: err.message,
+			});
+		}
+	}
+
+	async serviceMapPage (req, res) {
+		try {
+			const { date } = req.query;
+			const today = getToday();
+			const mapData = await this._logSvc(req).getServiceMap(date || today);
+			const bp = await this._base(req);
+			res.render('service-map', {
+				...bp,
+				title: 'Service Map',
+				mapData,
+				date: date || today,
+				today,
+			});
+		} catch (err) {
+			const bp = await this._base(req);
+			res.render('service-map', {
+				...bp,
+				title: 'Service Map',
+				mapData: null,
+				date: getToday(),
+				today: getToday(),
+				renderError: err.message,
+			});
+		}
+	}
+
+	async customDashboardPage (req, res) {
+		try {
+			const DashboardService = require('../services/DashboardService');
+			const logSvcs = await this._logSvc(req).getServices();
+			const layout = await new DashboardService().getLayout(req.user.username);
+			const bp = await this._base(req);
+			res.render('custom-dashboard', {
+				...bp,
+				title: 'My Dashboard',
+				layout,
+				logServices: logSvcs,
+				today: getToday(),
+			});
+		} catch (err) {
+			const bp = await this._base(req);
+			res.render('custom-dashboard', {
+				...bp,
+				title: 'My Dashboard',
+				layout: [],
+				logServices: [],
+				today: getToday(),
+				renderError: err.message,
+			});
+		}
+	}
+
+	async bookmarksPage (req, res) {
+		try {
+			const BookmarkService = require('../services/BookmarkService');
+			const bookmarks = await BookmarkService.getAll(req.user.username);
+			const bp = await this._base(req);
+			res.render('bookmarks', { ...bp, title: 'Bookmarks', bookmarks });
+		} catch (err) {
+			const bp = await this._base(req);
+			res.render('bookmarks', {
+				...bp,
+				title: 'Bookmarks',
+				bookmarks: [],
+				renderError: err.message,
+			});
+		}
+	}
+
+	async savedSearchesPage (req, res) {
+		try {
+			const SavedSearchService = require('../services/SavedSearchService');
+			const services = await this._logSvc(req).getServices();
+			const searches = await SavedSearchService.getAll(req.user.username);
+			const bp = await this._base(req);
+			res.render('saved-searches', {
+				...bp,
+				title: 'Saved Searches',
+				searches,
+				logServices: services,
+				today: getToday(),
+			});
+		} catch (err) {
+			const bp = await this._base(req);
+			res.render('saved-searches', {
+				...bp,
+				title: 'Saved Searches',
+				searches: [],
+				logServices: [],
+				today: getToday(),
+				renderError: err.message,
+			});
+		}
+	}
+
+	async notificationsPage (req, res) {
+		try {
+			const NotifService = require('../services/NotificationService');
+			const notifs = await NotifService.getAll(100);
+			const bp = await this._base(req);
+			res.render('notifications', {
+				...bp,
+				title: 'Notifications',
+				notifications: notifs,
+			});
+		} catch (err) {
+			const bp = await this._base(req);
+			res.render('notifications', {
+				...bp,
+				title: 'Notifications',
+				notifications: [],
+				renderError: err.message,
+			});
+		}
+	}
+}
+
+module.exports = UiController;