Joseph B. McQueen
44568044e8
Every add/remove of a favorite group or authorized user was rewriting
config.json — the same file that carries structural bot metadata and
was committed to git. This split ends the git-noise and lets ops
deploy fresh installs without a pre-populated user list.
Split
- config.json (committed) stays structural: server, per-bot labels,
integration + service-account ids, languages.
- config/authorized.json (gitignored) is the new mutable source of
truth: { admins: [personId...], bot: { <appName>: { <personId>:
{ id, displayName, email, avatar, groups: [...] } } } }.
- Seeded authorized.json with the current admins list and all
authorized users (3 on novi, 4 on techupdates) so this commit is
a pure move — no data lost, no downtime.
Helpers (lib/helpers.js)
- New getAuthorizedEntry(authorized, app, id) as the single lookup
point every consumer goes through, so nullability is uniform.
- isAuthorized() gains an authorized-doc arg (pure signature stays
testable): fails closed when the doc is missing / partially
loaded, so a broken deploy grants no access.
- isAdmin() now reads authorized.admins instead of config.admins.
Runtime (index.js)
- loadAuthorized() with an ENOENT fallback to { admins: [], bot: {} }
so a fresh deploy can bootstrap via the admin page instead of
requiring a hand-crafted authorized.json.
- All 8 previous config.webex.bot[app].authorized sites (favorites
read/add/remove, admin list/add/delete, isAuthorized) now go
through the authorized doc.
- Every mutation writes to config/authorized.json instead of
config/config.json.
Latent-bug fixup (uncovered while smoke-testing this refactor)
- The /user/:scope/:action fallthroughs used res.status(4xx)
without .send(...), so unknown scopes / unauthorized callers got
a hung request instead of a response. Added ".send(...)" bodies
so the response actually completes.
Docs + tests
- README updated: new "Authorized users" step in "Adding a new bot",
updated file-layout section, docker mount list adds
authorized.json.
- Test suite expanded from 48 → 53 with a new getAuthorizedEntry
group and the existing isAuthorized/isAdmin cases reshaped for
the new signatures.
Smoke tested the auth matrix end-to-end (admin + non-admin + signed-
out across /info, /admin/users, /user/groups/list): every path
returns the expected code and body.
Co-authored-by: Cursor <cursoragent@cursor.com>
1683 lines
69 KiB
JavaScript
1683 lines
69 KiB
JavaScript
#!/usr/bin/env node
|
||
|
||
import fs from 'fs';
|
||
import fetch from 'node-fetch';
|
||
import { Headers } from 'node-fetch';
|
||
import express from 'express';
|
||
import bodyParser from 'body-parser';
|
||
import multer from 'multer';
|
||
import sharp from 'sharp';
|
||
import { v4 as uuid } from 'uuid';
|
||
import cookieParser from 'cookie-parser';
|
||
import FormData from 'form-data';
|
||
import cron from "node-cron";
|
||
import PQueue from 'p-queue';
|
||
import * as helpers from './lib/helpers.js';
|
||
//import pLimit from "p-limit";
|
||
//const limit = pLimit(10);
|
||
const queue = new PQueue({ concurrency: 10 });
|
||
|
||
//Load the config files from storage.
|
||
// config.json = committed, structural (server port, bot labels, integration ids).
|
||
// authorized.json = gitignored, mutable per-user data:
|
||
// { admins: [personId...], bot: { <appName>: { <personId>: { ...profile, groups: [...] } } } }
|
||
// jobs.json = gitignored, runtime queue state.
|
||
// userPrefs.json = gitignored, per-recipient preferences (language, ...).
|
||
var config = JSON.parse(fs.readFileSync('./config/config.json'));
|
||
var jobs = JSON.parse(fs.readFileSync('./config/jobs.json'));
|
||
var userPrefs = JSON.parse(fs.readFileSync('./config/userPrefs.json'));
|
||
var authorized = loadAuthorized();
|
||
|
||
function loadAuthorized() {
|
||
try {
|
||
var doc = JSON.parse(fs.readFileSync('./config/authorized.json'));
|
||
doc.admins = Array.isArray(doc.admins) ? doc.admins : [];
|
||
doc.bot = (doc.bot && typeof doc.bot === 'object') ? doc.bot : {};
|
||
return doc;
|
||
} catch (err) {
|
||
// Missing file (fresh deploy) is fine — we start empty and the admin
|
||
// page can populate. Any other parse error is fatal because otherwise
|
||
// the whole authorization layer silently permits nothing.
|
||
if (err && err.code === 'ENOENT') {
|
||
console.log('loadAuthorized: authorized.json not found, starting empty.');
|
||
return { admins: [], bot: {} };
|
||
}
|
||
throw err;
|
||
}
|
||
}
|
||
|
||
// Returns the mutable per-user record for (appName, personId), creating the
|
||
// bot bucket if this is the first write. Never returns null when personId is
|
||
// truthy — callers use this to add favorites / users without null-checking.
|
||
// Read-only callers should prefer helpers.getAuthorizedEntry(authorized, ...).
|
||
function getOrCreateAuthorizedEntry(appName, personId) {
|
||
if (!authorized.bot[appName]) authorized.bot[appName] = {};
|
||
return authorized.bot[appName][personId] || null;
|
||
}
|
||
|
||
// Defensive init so code below can safely `.push`, `.filter`, and index into
|
||
// these regardless of what the on-disk jobs.json happens to contain.
|
||
jobs.building = jobs.building || {};
|
||
jobs.running = Array.isArray(jobs.running) ? jobs.running : [];
|
||
jobs.scheduled = Array.isArray(jobs.scheduled) ? jobs.scheduled : [];
|
||
jobs.completed = Array.isArray(jobs.completed) ? jobs.completed : [];
|
||
if (typeof jobs.lastJobNumber !== 'number') jobs.lastJobNumber = 0;
|
||
|
||
// Per-bot tokens live in their own gitignored file so adding a new bot is one
|
||
// JSON entry + an env-free restart. Shape:
|
||
// { "<appName>": { "token": "...", "enabled": true } }
|
||
var botTokens = loadBotTokens();
|
||
|
||
function loadBotTokens() {
|
||
try {
|
||
return JSON.parse(fs.readFileSync('./config/botTokens.json'));
|
||
} catch (err) {
|
||
console.log('loadBotTokens failed: ' + err.message);
|
||
return {};
|
||
}
|
||
}
|
||
|
||
function getBotToken(appName) {
|
||
return helpers.getBotToken(botTokens, appName);
|
||
}
|
||
|
||
function isBotEnabled(appName) {
|
||
return helpers.isBotEnabled(botTokens, appName);
|
||
}
|
||
|
||
// Returns the bot's config block if the bot is both defined in config.json AND
|
||
// has an enabled token entry. Returns null otherwise. Use this everywhere
|
||
// instead of reaching into config.webex.bot[...] directly so unknown or
|
||
// disabled bots can't crash the request.
|
||
function getBotConfig(appName) {
|
||
return helpers.getBotConfig(config, botTokens, appName);
|
||
}
|
||
|
||
// Cached bot profiles populated from Webex /people/me at startup so the
|
||
// front-end and the completion card can use the bot's actual displayName and
|
||
// avatar without hardcoding either in config.json.
|
||
// botProfiles[appName] = { displayName, avatar }
|
||
var botProfiles = {};
|
||
|
||
async function loadBotProfile(appName) {
|
||
var token = getBotToken(appName);
|
||
if (!token) return;
|
||
try {
|
||
var response = await fetchWithRateLimit('https://webexapis.com/v1/people/me', {
|
||
method: 'GET',
|
||
headers: { 'Authorization': 'Bearer ' + token }
|
||
});
|
||
if (!response.ok) {
|
||
logger('loadBotProfile', appName + ' /people/me failed: ' + response.status + ' ' + response.statusText);
|
||
return;
|
||
}
|
||
var data = await response.json();
|
||
botProfiles[appName] = {
|
||
displayName: data.displayName,
|
||
avatar: data.avatar,
|
||
personId: data.id,
|
||
emails: data.emails
|
||
};
|
||
logger('loadBotProfile', appName + ' = ' + data.displayName);
|
||
} catch (err) {
|
||
logger('loadBotProfile', appName + ' error: ' + (err && err.message || err));
|
||
}
|
||
}
|
||
|
||
function loadBotProfiles() {
|
||
var apps = Object.keys((config.webex && config.webex.bot) || {});
|
||
return Promise.allSettled(apps.filter(isBotEnabled).map(loadBotProfile));
|
||
}
|
||
|
||
function getBotProfile(appName) {
|
||
return botProfiles[appName] || null;
|
||
}
|
||
|
||
// Cached list of every Webex group in the org, used by the "Additional groups"
|
||
// dropdown on the compose page. findWebexGroup() paginates through ~10k groups
|
||
// 500 at a time, which used to run on every /user/groups/find request; we now
|
||
// refresh once at startup and once a day and serve everything else from
|
||
// memory. `refreshing` is a shared in-flight Promise so a concurrent refresh
|
||
// (e.g. the cron firing during a slow startup fetch) can't stampede.
|
||
var groupsCache = {
|
||
data: null,
|
||
lastRefreshed: null,
|
||
refreshing: null,
|
||
};
|
||
|
||
function refreshGroupsCache() {
|
||
if (groupsCache.refreshing) return groupsCache.refreshing;
|
||
var startedAt = Date.now();
|
||
logger('groupsCache', 'Refreshing group list from Webex...');
|
||
groupsCache.refreshing = findWebexGroup()
|
||
.then(function (groups) {
|
||
groupsCache.data = groups;
|
||
groupsCache.lastRefreshed = new Date();
|
||
logger('groupsCache',
|
||
'Cached ' + groups.length + ' groups in ' +
|
||
(Date.now() - startedAt) + 'ms.');
|
||
return groups;
|
||
})
|
||
.catch(function (err) {
|
||
logger('groupsCache', 'Refresh failed: ' + (err && err.message || err));
|
||
throw err;
|
||
})
|
||
.finally(function () {
|
||
groupsCache.refreshing = null;
|
||
});
|
||
return groupsCache.refreshing;
|
||
}
|
||
|
||
// Returns the cached groups if we have any; otherwise waits for whatever
|
||
// refresh is currently in flight (or kicks one off). Requests only ever block
|
||
// on the very first call after startup — every subsequent call resolves
|
||
// synchronously from memory.
|
||
function getGroupsFromCache() {
|
||
if (groupsCache.data) return Promise.resolve(groupsCache.data);
|
||
return refreshGroupsCache();
|
||
}
|
||
|
||
// Express middleware: 404s any /CollabCentral/:app/* request whose `:app` is
|
||
// not a known + enabled bot. Attaches the bot config to req.botConfig for
|
||
// downstream handlers.
|
||
function requireBot(req, res, next) {
|
||
var botCfg = getBotConfig(req.params.app);
|
||
if (!botCfg) {
|
||
logger("requireBot", "Unknown or disabled bot: " + req.params.app);
|
||
return res.status(404).send("Unknown bot: " + req.params.app);
|
||
}
|
||
req.botConfig = botCfg;
|
||
next();
|
||
}
|
||
|
||
// Building (draft) jobs are keyed by cookieId AND appName so a user who is
|
||
// authorized for more than one bot can have one independent draft per bot.
|
||
function buildingKey(req) {
|
||
return helpers.buildingKey(req.cookies && req.cookies.id, req.params.app);
|
||
}
|
||
|
||
function jobsForApp(arr, appName) {
|
||
return helpers.jobsForApp(arr, appName);
|
||
}
|
||
|
||
// Service-account OAuth tokens are rewritten in place by refreshToken(), so
|
||
// they live in their own file rather than mixed into config.json.
|
||
var serviceAccountToken = loadServiceAccountToken();
|
||
|
||
function loadServiceAccountToken() {
|
||
try {
|
||
return JSON.parse(fs.readFileSync('./config/token.json'));
|
||
} catch (err) {
|
||
console.log('loadServiceAccountToken failed: ' + err.message);
|
||
return {};
|
||
}
|
||
}
|
||
|
||
function saveServiceAccountToken(tokenObj) {
|
||
// Keep the in-memory copy in sync even if the disk write fails so the
|
||
// refreshed token is still usable for the rest of the process lifetime.
|
||
serviceAccountToken = tokenObj;
|
||
try {
|
||
fs.writeFileSync('./config/token.json', JSON.stringify(tokenObj, null, 4));
|
||
} catch (err) {
|
||
logger("saveServiceAccountToken", "Failed to persist token.json: " + err.message);
|
||
}
|
||
}
|
||
|
||
function getServiceAccountAccessToken() {
|
||
return serviceAccountToken && serviceAccountToken.access_token;
|
||
}
|
||
|
||
// Builds the Webex OAuth authorize URL for a given bot. The redirect_uri must
|
||
// match one of the URIs registered with the Webex integration in the Webex
|
||
// developer portal (one URI per bot). Returns null if required env vars are
|
||
// missing so callers can return an actionable error instead of a malformed URL.
|
||
function buildAuthUrl(appName) {
|
||
var url = helpers.buildAuthUrl({
|
||
clientId: process.env.WEBEX_INTEGRATION_CLIENT_ID,
|
||
template: process.env.OAUTH_CALLBACK_URL_TEMPLATE,
|
||
appName: appName,
|
||
});
|
||
if (!url) logger('buildAuthUrl', 'Missing WEBEX_INTEGRATION_CLIENT_ID or OAUTH_CALLBACK_URL_TEMPLATE env var.');
|
||
return url;
|
||
}
|
||
|
||
function getOAuthRedirectUri(appName) {
|
||
return helpers.getOAuthRedirectUri(process.env.OAUTH_CALLBACK_URL_TEMPLATE, appName);
|
||
}
|
||
|
||
//Load Express Server
|
||
var app = express();
|
||
app.use(bodyParser.json());
|
||
app.use(cookieParser());
|
||
|
||
var serverPort = process.env.SERVER_PORT || config.server.port;
|
||
var server = app.listen(serverPort, function () {
|
||
logger("startup", config.server.name + " running on port " + serverPort + ".");
|
||
loadBotProfiles()
|
||
.then(() => logger("startup", "Loaded " + Object.keys(botProfiles).length + " bot profile(s)."))
|
||
.catch(err => logger("startup", "loadBotProfiles error: " + (err && err.message || err)));
|
||
// Warm the groups cache in the background so the very first user hitting
|
||
// /user/groups/find gets an instant response. Failures are non-fatal:
|
||
// getGroupsFromCache() will simply try again on the first request.
|
||
refreshGroupsCache().catch(function () { /* logged inside */ });
|
||
});
|
||
server.setTimeout(3000000);
|
||
const upload = multer({ limits: { fileSize: 4000000 } }).fields(
|
||
[
|
||
{ name: 'uploadImage' },
|
||
{ name: 'uploadCSV' }
|
||
]
|
||
);
|
||
|
||
// Anchor both crons to a specific timezone so the schedule is deterministic
|
||
// regardless of the host/container clock. Override with CRON_TIMEZONE if the
|
||
// deployment moves to a different region.
|
||
var cronTimezone = process.env.CRON_TIMEZONE || 'America/New_York';
|
||
|
||
// Daily at 01:10 local time: prune completed jobs older than the retention
|
||
// window and rewrite jobs.json.
|
||
cron.schedule('0 10 1 * * *', async function () {
|
||
var jobFile = JSON.parse(fs.readFileSync('./config/jobs.json'));
|
||
var cleanJobs = await cleanCompletedJobs(jobFile);
|
||
saveConfig(cleanJobs, './config/jobs.json');
|
||
jobs = JSON.parse(fs.readFileSync('./config/jobs.json'));
|
||
|
||
}, { timezone: cronTimezone })
|
||
|
||
// Every minute: refresh the service-account token if it's inside the renewal
|
||
// window, and dispatch any scheduled jobs whose time has arrived.
|
||
cron.schedule('0 * * * * *', () => {
|
||
var renewBy = serviceAccountToken && serviceAccountToken.renewBy;
|
||
if (renewBy && new Date(new Date(renewBy) - 7200000) < new Date()) {
|
||
logger("refreshToken", "Renew by: " + new Date(renewBy).toLocaleString())
|
||
logger("refreshToken", "Renew after: " + new Date(new Date(renewBy) - 7200000).toLocaleString());
|
||
logger("refreshToken", "Refreshing token.")
|
||
refreshToken()
|
||
.then(response => {
|
||
logger("tokenRefresh", response);
|
||
})
|
||
.catch(error => logger("refreshToken", error));
|
||
}
|
||
checkScheduledJobs()
|
||
.catch(error => logger("checkScheduledJobs", error));
|
||
}, { timezone: cronTimezone })
|
||
|
||
// Daily at 03:00 local time: rebuild the org-wide groups cache. Offset from
|
||
// the 01:10 jobs cleanup so the two crons don't fight over the event loop.
|
||
cron.schedule('0 0 3 * * *', function () {
|
||
refreshGroupsCache().catch(function () { /* logged inside */ });
|
||
}, { timezone: cronTimezone })
|
||
|
||
//Routes to be used
|
||
// Validate the :app segment for every /CollabCentral/:app/* request. This
|
||
// runs before the static mount and all the per-route handlers below, so any
|
||
// unknown or disabled bot gets a clean 404 instead of crashing on undefined.
|
||
app.use('/CollabCentral/:app', requireBot)
|
||
app.use('/CollabCentral/:app', express.static('html'))
|
||
|
||
app.get('/status', function (req, res) {
|
||
res.status(200).send({ "status": "I'm alive!'" });
|
||
});
|
||
|
||
app.get('/CollabCentral/:app/authUrl', function (req, res) {
|
||
var url = buildAuthUrl(req.params.app);
|
||
if (!url) {
|
||
return res.status(500).send('OAuth is not configured. Check WEBEX_INTEGRATION_CLIENT_ID and OAUTH_CALLBACK_URL_TEMPLATE.');
|
||
}
|
||
res.send(url);
|
||
});
|
||
|
||
// Returns the bot's display metadata + whether the current cookie is authorized.
|
||
// The front-end uses this to drive page labels, icons, and the
|
||
// "you don't have access" view, so adding a new bot doesn't require any code
|
||
// changes in the HTML/JS.
|
||
app.get('/CollabCentral/:app/info', function (req, res) {
|
||
var appName = req.params.app;
|
||
var botCfg = req.botConfig; // populated by requireBot
|
||
var profile = getBotProfile(appName) || {};
|
||
var iconBase = botCfg.iconBase || appName;
|
||
var personId = req.cookies && req.cookies.id;
|
||
res.status(200).send({
|
||
appName: appName,
|
||
label: botCfg.label || appName,
|
||
displayName: profile.displayName || botCfg.label || appName,
|
||
iconUrl: '/CollabCentral/' + appName + '/' + iconBase + '.png',
|
||
faviconUrl: '/CollabCentral/' + appName + '/' + iconBase + '.ico',
|
||
avatarUrl: profile.avatar || null,
|
||
authorized: isAuthorized(appName, personId),
|
||
isAdmin: isAdmin(personId)
|
||
});
|
||
});
|
||
|
||
app.post('/CollabCentral/:app/jobs/:action', (req, res) => {
|
||
if (isAuthorized(req.params.app, req.cookies.id)) {
|
||
req.setTimeout(3000000);
|
||
if (req.params.action == "edit") {
|
||
logger("apiEndpoint(" + req.params.app + ")", "POST /jobs/edit");
|
||
buildJob(req, res)
|
||
.then(job => {
|
||
sendDirectMessage(job.senderId, job.message.raw, job.imageName, req.params.app)
|
||
.then(async function (result) {
|
||
jobs.building[buildingKey(req)].message.english = {
|
||
"text": result.text,
|
||
"markdown": result.markdown,
|
||
"html": result.html
|
||
}
|
||
// Remember the preview DM's Webex message id so
|
||
// /jobs/cancel can retract it and /jobs/runNow can
|
||
// treat it as "already delivered" (future).
|
||
if (result && result.id) {
|
||
jobs.building[buildingKey(req)].previewMessageId = result.id;
|
||
}
|
||
|
||
await buildTranslations(jobs.building[buildingKey(req)].message.english)
|
||
.then(result => {
|
||
jobs.building[buildingKey(req)].message = result;
|
||
})
|
||
.catch(error => console.log("Error translating: " + error));
|
||
|
||
res.status(200).send(job)
|
||
saveConfig(jobs, "./config/jobs.json")
|
||
})
|
||
.catch(error => console.log("Error sending message: " + error));
|
||
})
|
||
.catch(error => console.log("Error buildJob: " + error));
|
||
} else if (req.params.action == "runNow") {
|
||
logger("apiEndpoint(" + req.params.app + ")", "POST /jobs/runNow");
|
||
jobs.running.push(jobs.building[buildingKey(req)]);
|
||
delete jobs.building[buildingKey(req)];
|
||
processRunningQueue()
|
||
.catch(error => console.log("sendRunningMessages error: " + error))
|
||
res.status(204).redirect("/CollabCentral/" + req.params.app + "/monitorJobs.html");
|
||
} else if (req.params.action == "schedule") {
|
||
logger("apiEndpoint(" + req.params.app + ")", "POST /jobs/schedule");
|
||
jobs.scheduled.push(jobs.building[buildingKey(req)]);
|
||
delete jobs.building[buildingKey(req)];
|
||
saveConfig(jobs, './config/jobs.json')
|
||
res.status(204).redirect("/CollabCentral/" + req.params.app + "/monitorJobs.html");
|
||
} else if (req.params.action == "cancel") {
|
||
// Abandon the caller's in-progress "building" job for this bot.
|
||
// A building entry exists as soon as the user clicks "Review &
|
||
// send" (POST /jobs/edit) and lingers on the server until the
|
||
// user promotes it to running/scheduled — or until now, where
|
||
// this route just drops it on the floor. Idempotent: 200 whether
|
||
// or not a building entry actually existed for (personId, app),
|
||
// so the client can always fire this on "cancel" without needing
|
||
// to check state first.
|
||
//
|
||
// If the building job has a previewMessageId (captured during
|
||
// /jobs/edit), also retract that DM from the sender's own space
|
||
// so the review message doesn't hang around after they discarded
|
||
// the draft. Best-effort — a failed Webex delete is logged but
|
||
// does not fail the cancel.
|
||
logger("apiEndpoint(" + req.params.app + ")", "POST /jobs/cancel");
|
||
var key = buildingKey(req);
|
||
var job = jobs.building[key];
|
||
var hadJob = !!job;
|
||
if (hadJob) {
|
||
var previewId = job.previewMessageId;
|
||
delete jobs.building[key];
|
||
try {
|
||
saveConfig(jobs, './config/jobs.json');
|
||
} catch (err) {
|
||
logger('apiEndpoint(' + req.params.app + ')',
|
||
'jobs/cancel save failed: ' + (err && err.message || err));
|
||
return res.status(500).send('Failed to cancel job.');
|
||
}
|
||
if (previewId) {
|
||
// Fire-and-forget; we've already committed the cancel
|
||
// to disk and we don't want a slow Webex round trip to
|
||
// hold the response.
|
||
deleteWebexMessage(previewId, req.params.app);
|
||
}
|
||
}
|
||
return res.status(200).send({ cancelled: hadJob });
|
||
} else { res.status(404) }
|
||
} else { res.status(401).send("You are not authorized.") }
|
||
|
||
})
|
||
|
||
app.get('/CollabCentral/:app/jobs/list/:scope', (req, res) => {
|
||
if (!req.cookies || !isAuthorized(req.params.app, req.cookies.id)) {
|
||
return res.status(401).send("You are not authorized.");
|
||
}
|
||
var appName = req.params.app;
|
||
|
||
if (req.params.scope == "all") {
|
||
logger("apiEndpoint(" + appName + ")", "GET /jobs/list/all");
|
||
return res.status(200).send({
|
||
building: jobs.building[buildingKey(req)],
|
||
running: jobsForApp(jobs.running, appName),
|
||
scheduled: jobsForApp(jobs.scheduled, appName),
|
||
completed: jobsForApp(jobs.completed, appName)
|
||
});
|
||
}
|
||
|
||
if (req.params.scope == "building") {
|
||
logger("apiEndpoint(" + appName + ")", "GET /jobs/list/building");
|
||
return res.status(200).send(jobs.building[buildingKey(req)]);
|
||
}
|
||
|
||
if (req.params.scope == "running") {
|
||
logger("apiEndpoint(" + appName + ")", "GET /jobs/list/running");
|
||
var runningJobs = [];
|
||
for (var job of jobsForApp(jobs.running, appName)) {
|
||
var completedSends = 0;
|
||
for (var member of (job.memberList || [])) {
|
||
if (member.results) completedSends++;
|
||
}
|
||
runningJobs.push({
|
||
jobId: job.jobId,
|
||
senderDisplayName: job.senderDisplayName,
|
||
appName: job.appName,
|
||
startTime: job.startTime,
|
||
totalRecipients: (job.memberList || []).length,
|
||
completedRecipients: completedSends
|
||
});
|
||
}
|
||
return res.status(200).send(runningJobs);
|
||
}
|
||
|
||
if (req.params.scope == "scheduled") {
|
||
logger("apiEndpoint(" + appName + ")", "GET /jobs/list/scheduled");
|
||
var scheduledJobs = [];
|
||
for (var job of jobsForApp(jobs.scheduled, appName)) {
|
||
scheduledJobs.push({
|
||
senderDisplayName: job.senderDisplayName,
|
||
appName: job.appName,
|
||
message: job.message && job.message.english && job.message.english.html,
|
||
totalRecipients: (job.memberList || []).length,
|
||
scheduledFor: job.scheduledFor
|
||
});
|
||
}
|
||
return res.status(200).send(scheduledJobs);
|
||
}
|
||
|
||
if (req.params.scope == "completed") {
|
||
logger("apiEndpoint(" + appName + ")", "GET /jobs/list/completed");
|
||
return res.status(200).send(jobsForApp(jobs.completed, appName));
|
||
}
|
||
|
||
return res.status(404).send();
|
||
});
|
||
|
||
// Returns the full job object for a given jobId, but only if the job belongs
|
||
// to the requested bot. Looks across completed/running/scheduled so the same
|
||
// URL keeps working as a job moves through its lifecycle.
|
||
app.get('/CollabCentral/:app/jobs/detail/:jobId', (req, res) => {
|
||
if (!req.cookies || !isAuthorized(req.params.app, req.cookies.id)) {
|
||
return res.status(401).send("You are not authorized.");
|
||
}
|
||
var appName = req.params.app;
|
||
var jobId = req.params.jobId;
|
||
logger("apiEndpoint(" + appName + ")", "GET /jobs/detail/" + jobId);
|
||
|
||
var all = (jobs.completed || []).concat(jobs.running || [], jobs.scheduled || []);
|
||
var match = all.find(function (j) {
|
||
return j && j.appName === appName && String(j.jobId) === String(jobId);
|
||
});
|
||
if (!match) return res.status(404).send("Job not found.");
|
||
res.status(200).send(match);
|
||
});
|
||
|
||
app.get('/CollabCentral/:app/user/:scope/:action', (req, res) => {
|
||
console.log("Got /user/:scope/:action request.");
|
||
//console.log(req.cookies);
|
||
if (isAuthorized(req.params.app, req.cookies.id)) {
|
||
//console.log("Person is authorized for the request.")
|
||
if (req.params.scope == "groups") {
|
||
if (req.params.action == "list") {
|
||
logger("apiEndpoint(" + req.params.app + ")", "GET /user/groups/list");
|
||
var listEntry = helpers.getAuthorizedEntry(authorized, req.params.app, req.cookies.id);
|
||
res.status(200).send((listEntry && listEntry.groups) || []);
|
||
} else if (req.params.action == "find") {
|
||
logger("apiEndpoint(" + req.params.app + ")", "GET /user/groups/find");
|
||
getGroupsFromCache()
|
||
.then(function (groups) { res.status(200).send(groups); })
|
||
.catch(function (err) {
|
||
logger('apiEndpoint(' + req.params.app + ')',
|
||
'groups/find failed: ' + (err && err.message || err));
|
||
res.status(502).send('Failed to load groups from Webex.');
|
||
});
|
||
}
|
||
} else { res.status(404).send('Not found.'); }
|
||
} else { res.status(401).send('Unauthorized.'); }
|
||
})
|
||
|
||
// Add / remove a favorite group for the calling user. Favorites live inside
|
||
// authorized.json under `bot[app][personId].groups` so they survive restarts
|
||
// and are picklable in the compose page's Favorite Groups selector. Both
|
||
// endpoints validate that:
|
||
// - the caller is authorized for :app
|
||
// - :id looks like a Webex SCIM group id we know about (present in the
|
||
// cached org-wide group list) — this stops a bad actor from stuffing
|
||
// arbitrary strings into the config.
|
||
// Because index.js is single-process and node is single-threaded, concurrent
|
||
// requests here can't corrupt authorized.json — every read/mutate/write
|
||
// executes atomically within one handler.
|
||
app.post('/CollabCentral/:app/user/groups/add', async function (req, res) {
|
||
if (!isAuthorized(req.params.app, req.cookies.id)) return res.status(401).send('Unauthorized.');
|
||
var appName = req.params.app;
|
||
var personId = req.cookies.id;
|
||
var groupId = req.body && req.body.id;
|
||
if (!groupId) return res.status(400).send('Missing group id.');
|
||
|
||
var group;
|
||
try {
|
||
var allGroups = await getGroupsFromCache();
|
||
group = allGroups.find(function (g) { return g.id === groupId; });
|
||
} catch (err) {
|
||
logger('apiEndpoint(' + appName + ')',
|
||
'groups/add cache lookup failed: ' + (err && err.message || err));
|
||
return res.status(502).send('Group list unavailable.');
|
||
}
|
||
if (!group) return res.status(404).send('Unknown group id.');
|
||
|
||
var entry = helpers.getAuthorizedEntry(authorized, appName, personId);
|
||
// isAuthorized guarantees the entry exists but be defensive; a race
|
||
// between an admin removal and this request could otherwise crash.
|
||
if (!entry) return res.status(401).send('Unauthorized.');
|
||
var favorites = Array.isArray(entry.groups) ? entry.groups : [];
|
||
if (favorites.find(function (g) { return g.id === groupId; })) {
|
||
return res.status(200).send(favorites);
|
||
}
|
||
favorites.push({ name: group.displayName, id: group.id });
|
||
entry.groups = favorites;
|
||
try {
|
||
saveConfig(authorized, './config/authorized.json');
|
||
} catch (err) {
|
||
logger('apiEndpoint(' + appName + ')',
|
||
'groups/add save failed: ' + (err && err.message || err));
|
||
return res.status(500).send('Failed to save favorite.');
|
||
}
|
||
logger('apiEndpoint(' + appName + ')',
|
||
'groups/add ' + personId.slice(-8) + ' + "' + group.displayName + '"');
|
||
res.status(200).send(favorites);
|
||
});
|
||
|
||
app.post('/CollabCentral/:app/user/groups/remove', function (req, res) {
|
||
if (!isAuthorized(req.params.app, req.cookies.id)) return res.status(401).send('Unauthorized.');
|
||
var appName = req.params.app;
|
||
var personId = req.cookies.id;
|
||
var groupId = req.body && req.body.id;
|
||
if (!groupId) return res.status(400).send('Missing group id.');
|
||
|
||
var entry = helpers.getAuthorizedEntry(authorized, appName, personId);
|
||
if (!entry) return res.status(401).send('Unauthorized.');
|
||
var favorites = Array.isArray(entry.groups) ? entry.groups : [];
|
||
var before = favorites.length;
|
||
var removed = favorites.find(function (g) { return g.id === groupId; });
|
||
favorites = favorites.filter(function (g) { return g.id !== groupId; });
|
||
if (favorites.length === before) return res.status(200).send(favorites);
|
||
|
||
entry.groups = favorites;
|
||
try {
|
||
saveConfig(authorized, './config/authorized.json');
|
||
} catch (err) {
|
||
logger('apiEndpoint(' + appName + ')',
|
||
'groups/remove save failed: ' + (err && err.message || err));
|
||
return res.status(500).send('Failed to remove favorite.');
|
||
}
|
||
logger('apiEndpoint(' + appName + ')',
|
||
'groups/remove ' + personId.slice(-8) + ' - "' + (removed && removed.name || groupId) + '"');
|
||
res.status(200).send(favorites);
|
||
});
|
||
|
||
// ---- Admin: manage the authorized-user list for a bot ---------------------
|
||
//
|
||
// Admin authority lives in authorized.admins (personIds). Every admin route
|
||
// rejects with 403 for non-admin callers — 403 rather than 401 so the client
|
||
// can tell an admin-only route apart from a signed-out state (which would
|
||
// 401). Admin actions are cross-bot in concept but the routes are still
|
||
// :app-scoped because the resource being edited is per-bot (authorized users
|
||
// on THAT bot) and it keeps the OAuth session model unchanged (admin uses
|
||
// the same session cookie as any other page).
|
||
//
|
||
// requireAdmin returns null on success or an Express-response-sending
|
||
// function on failure, so each handler stays a straight-line function.
|
||
function requireAdmin(req, res) {
|
||
if (!req.cookies || !req.cookies.id) return res.status(401).send('Unauthorized.');
|
||
if (!isAdmin(req.cookies.id)) return res.status(403).send('Admin only.');
|
||
return null;
|
||
}
|
||
|
||
// Shape of a single row returned by the admin users endpoints. Kept in one
|
||
// helper so add / delete / list all produce identical output — the client
|
||
// can treat every response as an authoritative "here's the current state".
|
||
function adminUserRow(entry) {
|
||
var groups = Array.isArray(entry && entry.groups) ? entry.groups : [];
|
||
return {
|
||
id: entry.id,
|
||
displayName: entry.displayName || '',
|
||
email: entry.email || '',
|
||
avatar: entry.avatar || null,
|
||
groupCount: groups.length
|
||
};
|
||
}
|
||
|
||
function adminUsersList(appName) {
|
||
var bucket = (authorized.bot && authorized.bot[appName]) || {};
|
||
return Object.keys(bucket).map(function (id) { return adminUserRow(bucket[id]); });
|
||
}
|
||
|
||
app.get('/CollabCentral/:app/admin/users', function (req, res) {
|
||
if (requireAdmin(req, res)) return;
|
||
logger('apiEndpoint(' + req.params.app + ')', 'GET /admin/users');
|
||
res.status(200).send(adminUsersList(req.params.app));
|
||
});
|
||
|
||
app.post('/CollabCentral/:app/admin/users', async function (req, res) {
|
||
if (requireAdmin(req, res)) return;
|
||
var appName = req.params.app;
|
||
var email = req.body && req.body.email && String(req.body.email).trim();
|
||
if (!email) return res.status(400).send('Missing email.');
|
||
|
||
var person;
|
||
try {
|
||
person = await findPersonByEmail(email);
|
||
} catch (err) {
|
||
logger('apiEndpoint(' + appName + ')',
|
||
'admin/users lookup failed for "' + email + '": ' + (err && err.message || err));
|
||
return res.status(502).send('Failed to reach Webex directory.');
|
||
}
|
||
if (!person) return res.status(404).send('No Webex user found for that email.');
|
||
|
||
if (!authorized.bot[appName]) authorized.bot[appName] = {};
|
||
var bucket = authorized.bot[appName];
|
||
if (!bucket[person.id]) {
|
||
bucket[person.id] = {
|
||
id: person.id,
|
||
displayName: person.displayName,
|
||
email: person.email,
|
||
avatar: person.avatar,
|
||
groups: []
|
||
};
|
||
try {
|
||
saveConfig(authorized, './config/authorized.json');
|
||
} catch (err) {
|
||
logger('apiEndpoint(' + appName + ')',
|
||
'admin/users save failed: ' + (err && err.message || err));
|
||
return res.status(500).send('Failed to save.');
|
||
}
|
||
logger('apiEndpoint(' + appName + ')',
|
||
'admin/users + "' + person.displayName + '" <' + person.email + '>');
|
||
}
|
||
res.status(200).send({
|
||
user: adminUserRow(bucket[person.id]),
|
||
users: adminUsersList(appName)
|
||
});
|
||
});
|
||
|
||
app.delete('/CollabCentral/:app/admin/users/:id', function (req, res) {
|
||
if (requireAdmin(req, res)) return;
|
||
var appName = req.params.app;
|
||
var targetId = req.params.id;
|
||
var bucket = (authorized.bot && authorized.bot[appName]) || {};
|
||
if (!bucket[targetId]) {
|
||
return res.status(200).send({ removed: false, users: adminUsersList(appName) });
|
||
}
|
||
var name = bucket[targetId].displayName || targetId;
|
||
delete bucket[targetId];
|
||
try {
|
||
saveConfig(authorized, './config/authorized.json');
|
||
} catch (err) {
|
||
logger('apiEndpoint(' + appName + ')',
|
||
'admin/users delete save failed: ' + (err && err.message || err));
|
||
return res.status(500).send('Failed to save.');
|
||
}
|
||
logger('apiEndpoint(' + appName + ')', 'admin/users - "' + name + '"');
|
||
res.status(200).send({ removed: true, users: adminUsersList(appName) });
|
||
});
|
||
|
||
// Options for the session cookies set after a successful OAuth round-trip.
|
||
//
|
||
// httpOnly is deliberately false: js/app.js reads `id` (to decide whether to
|
||
// redirect to OAuth) and `displayName` (to render the user chip in the header)
|
||
// via document.cookie. Enabling httpOnly here hides the cookies from JS, which
|
||
// causes an infinite auth loop where every page load thinks the user is not
|
||
// signed in and kicks off a fresh OAuth exchange — burning Webex tokens until
|
||
// the CTS token limit is reached.
|
||
//
|
||
// sameSite is 'lax' rather than 'strict' so the cookie survives the OAuth
|
||
// redirect chain webexapis.com -> /oauth -> /sendMessage.html on all browsers.
|
||
const SESSION_COOKIE_OPTIONS = {
|
||
httpOnly: false,
|
||
secure: true,
|
||
sameSite: 'lax',
|
||
maxAge: 24 * 60 * 60 * 1000
|
||
};
|
||
|
||
app.get(`/CollabCentral/:app/oauth`, async function (req, res) {
|
||
var appName = req.params.app;
|
||
var authCode = req.query.code;
|
||
|
||
if (!process.env.WEBEX_INTEGRATION_CLIENT_ID || !process.env.WEBEX_INTEGRATION_CLIENT_SECRET || !process.env.OAUTH_CALLBACK_URL_TEMPLATE) {
|
||
logger("oauth", "Missing Webex integration env vars; cannot complete OAuth.");
|
||
return res.status(500).send("OAuth is not configured on the server.");
|
||
}
|
||
if (!authCode) {
|
||
return res.status(400).send("Missing OAuth `code` query parameter.");
|
||
}
|
||
|
||
var url = new URL("https://webexapis.com/v1/access_token");
|
||
var params = new URLSearchParams();
|
||
params.append('grant_type', 'authorization_code');
|
||
params.append('client_id', process.env.WEBEX_INTEGRATION_CLIENT_ID);
|
||
params.append('client_secret', process.env.WEBEX_INTEGRATION_CLIENT_SECRET);
|
||
params.append('code', authCode);
|
||
params.append('redirect_uri', getOAuthRedirectUri(appName));
|
||
|
||
var response;
|
||
try {
|
||
response = await fetchWithRateLimit(url, { method: 'POST', body: params });
|
||
} catch (error) {
|
||
logger("oauth", "Token exchange fetch failed: " + (error && error.message || error));
|
||
return res.status(502).send("Failed to reach Webex to complete OAuth.");
|
||
}
|
||
|
||
if (!response.ok) {
|
||
var errText = await response.text().catch(() => '');
|
||
logger("oauth", "Token exchange returned " + response.status + " " + response.statusText + " " + errText);
|
||
return res.status(401).send(response.statusText || "OAuth token exchange failed.");
|
||
}
|
||
|
||
var jsonData = await response.json();
|
||
var whoami;
|
||
try {
|
||
whoami = await whoAmI(jsonData.access_token);
|
||
} catch (err) {
|
||
logger("oauth", "whoAmI failed: " + (err && err.message || err));
|
||
return res.status(502).send("Failed to read your Webex profile after OAuth.");
|
||
}
|
||
logger("oauth", whoami.displayName + " successfully authed for " + appName + ".");
|
||
|
||
// Only the two cookies that the server (req.cookies.id, .displayName) and
|
||
// the client (getCookie('id'), getCookie('displayName')) actually read.
|
||
// Access/refresh tokens deliberately stay out of the browser: they never
|
||
// need to leave the server, and putting them in cookies would expose them
|
||
// to any XSS that might slip in later.
|
||
res
|
||
.cookie('id', whoami.id, SESSION_COOKIE_OPTIONS)
|
||
.cookie('displayName', whoami.displayName, SESSION_COOKIE_OPTIONS)
|
||
.redirect(301, '/CollabCentral/' + appName + '/sendMessage.html');
|
||
});
|
||
|
||
function buildJob(req, res) {
|
||
return new Promise(async function (resolve, reject) {
|
||
res.setTimeout(3000000)
|
||
var memberList = [];
|
||
var memberListPromises = [];
|
||
|
||
upload(req, res, async function (err) {
|
||
//console.log(req.files);
|
||
//console.log(req.body);
|
||
jobs.building[buildingKey(req)] = {
|
||
"appName": req.body.appName,
|
||
"senderId": req.cookies.id,
|
||
"senderDisplayName": req.cookies.displayName,
|
||
"groups": req.body.groups,
|
||
"message": {
|
||
"raw": req.body.message,
|
||
"english": {}
|
||
},
|
||
"memberList": []
|
||
}
|
||
// check for error thrown by multer- file size etc
|
||
|
||
if (err || req.files === undefined) {
|
||
//no file
|
||
} else {
|
||
if (req.files["uploadImage"]) {
|
||
for (var file of req.files["uploadImage"]) {
|
||
|
||
let fileName = uuid() + ".jpeg"
|
||
var image = await sharp(file.buffer).jpeg({ quality: 40, }).toFile('./uploads/' + fileName).catch(err => { console.log('error: ', err) })
|
||
jobs.building[buildingKey(req)].imageName = fileName;
|
||
logger("buildJob", "uploadImage " + file.originalname + " to " + fileName)
|
||
}
|
||
}
|
||
|
||
if (req.files["uploadCSV"]) {
|
||
for (var file of req.files["uploadCSV"]) {
|
||
let fileName = uuid() + ".csv";
|
||
fs.writeFileSync('./uploads/' + fileName, file.buffer)
|
||
jobs.building[buildingKey(req)].csv = fileName;
|
||
logger("buildJob", "uploadCSV " + file.originalname + " to " + fileName)
|
||
memberListPromises.push(buildPeopleList(fileName));
|
||
}
|
||
}
|
||
}
|
||
|
||
if (req.body.groups) {
|
||
logger("buildJob", "Locating groups: " + req.body.groups);
|
||
memberListPromises.push(collectGroupMembers(req.body.groups));
|
||
}
|
||
|
||
if (req.body.scheduledFor) {
|
||
logger("buildJob", "Scheduling for " + new Date(req.body.scheduledFor).toLocaleString())
|
||
jobs.building[buildingKey(req)].scheduledFor = req.body.scheduledFor;
|
||
saveConfig(jobs, "./config/jobs.json")
|
||
}
|
||
|
||
Promise.allSettled(memberListPromises)
|
||
.then(peoplePromises => {
|
||
console.log(JSON.stringify(peoplePromises))
|
||
for (var peopleList of peoplePromises) {
|
||
if (peopleList.status == "fulfilled") {
|
||
for (var person of peopleList.value) {
|
||
memberList.push(person);
|
||
}
|
||
}
|
||
}
|
||
//Make user members unique
|
||
var uniqueMembers = [...new Map(memberList.map((m) => [m.id, m])).values()];
|
||
jobs.building[buildingKey(req)].memberList = uniqueMembers;
|
||
var numSending = uniqueMembers.length.toString();
|
||
saveConfig(jobs, "./config/jobs.json")
|
||
resolve(jobs.building[buildingKey(req)]);
|
||
})
|
||
})
|
||
|
||
})
|
||
}
|
||
|
||
function collectGroupMembers(groupList) {
|
||
return new Promise(async function (resolve, reject) {
|
||
|
||
var groups = groupList.split(",");
|
||
var memberList = [];
|
||
|
||
for (var group of groups) {
|
||
try {
|
||
var memberCnt = 0;
|
||
var groupCnt = 0;
|
||
var groupData = await getGroupMembers(group);
|
||
|
||
for (var member of groupData.members) {
|
||
memberList.push(member);
|
||
memberCnt++;
|
||
}
|
||
if (groupData.groups.length > 0) {
|
||
for (var subGroup of groupData.groups) {
|
||
logger("collectGroupMembers", "Found new group: " + subGroup.name);
|
||
groupCnt++;
|
||
groups.push(subGroup.id);
|
||
}
|
||
}
|
||
logger("collectGroupMembers", "Found " + groupData.displayName + " Members: " + memberCnt)
|
||
} catch (error) {
|
||
console.log("Error groupData: " + error)
|
||
}
|
||
}
|
||
|
||
//console.log("Groups: " + groupList);
|
||
var uniqueMembers = [...new Map(memberList.map((m) => [m.id, m])).values()];
|
||
resolve(uniqueMembers);
|
||
})
|
||
}
|
||
|
||
function getGroupMembers(groupId) {
|
||
return new Promise(async function (resolve, reject) {
|
||
var groupMembers = { "members": [], "groups": [] };
|
||
var startIndex = 1;
|
||
var count = 500;
|
||
var memberSize = 10000;
|
||
|
||
var requestOptions = {
|
||
method: 'GET',
|
||
headers: {
|
||
'Authorization': `Bearer ` + getServiceAccountAccessToken(),
|
||
'Content-Type': `application/json`
|
||
}
|
||
};
|
||
|
||
while (memberSize > (groupMembers.members.length + groupMembers.groups.length)) {
|
||
var findGroupByIdUrl = 'https://webexapis.com/v1/groups/' + groupId + '/members?startIndex=' + startIndex + '&count=' + count;
|
||
try {
|
||
var groupResponse = await fetchWithRateLimit(findGroupByIdUrl, requestOptions);
|
||
if (groupResponse.ok) {
|
||
var groupData = await groupResponse.json();
|
||
groupMembers.displayName = groupData.displayName;
|
||
memberSize = groupData.memberSize;
|
||
for (var member of groupData.members) {
|
||
if (member.type == "group") {
|
||
|
||
groupMembers.groups.push({ "id": member.id, "name": member.displayName })
|
||
} else {
|
||
groupMembers.members.push(member)
|
||
}
|
||
}
|
||
startIndex = startIndex + count;
|
||
} else {
|
||
memberSize = 0;
|
||
reject(groupResponse.status + ": " + groupResponse.statusText);
|
||
}
|
||
} catch (error) {
|
||
console.log("Error findGroupById: " + error);
|
||
}
|
||
}
|
||
resolve(groupMembers);
|
||
})
|
||
}
|
||
|
||
function findWebexGroup() {
|
||
return new Promise(async function (resolve, reject) {
|
||
|
||
var groups = [];
|
||
var startIndex = 1;
|
||
var count = 500;
|
||
var groupSize = 10000;
|
||
|
||
|
||
var url = new URL("https://webexapis.com/v1/groups")
|
||
//var params = new URLSearchParams();
|
||
//url.searchParams.append("filter", "displayName contains " + searchTerm);
|
||
url.searchParams.append("attributes", "displayName");
|
||
url.searchParams.append("sortBy", "displayName");
|
||
url.searchParams.append("sortOrder", "ascending");
|
||
url.searchParams.append("includeMembers", "false");
|
||
url.searchParams.append("startIndex", startIndex);
|
||
url.searchParams.append("count", count);
|
||
//console.log(params.toString())
|
||
|
||
var requestOptions = {
|
||
method: 'GET',
|
||
headers: {
|
||
'Authorization': `Bearer ` + getServiceAccountAccessToken(),
|
||
'Content-Type': `application/json`
|
||
}
|
||
};
|
||
while (groupSize > groups.length) {
|
||
try {
|
||
var fetchedGroups = await fetchWithRateLimit(url, requestOptions);
|
||
if (fetchedGroups.ok) {
|
||
var groupData = await fetchedGroups.json();
|
||
groupSize = groupData.totalResults;
|
||
for (var group of groupData.groups) {
|
||
groups.push(group);
|
||
}
|
||
startIndex = startIndex + count;
|
||
url.searchParams.delete("startIndex");
|
||
url.searchParams.append("startIndex", startIndex);
|
||
} else {
|
||
return reject(fetchedGroups.status + ": " + fetchedGroups.statusText);
|
||
}
|
||
} catch (error) {
|
||
logger('findWebexGroup', 'page fetch failed: ' + (error && error.message || error));
|
||
return reject(error);
|
||
}
|
||
}
|
||
resolve(groups);
|
||
})
|
||
}
|
||
function whoAmI(bearerToken) {
|
||
return new Promise(async function (resolve, reject) {
|
||
logger("whoAmI", "Person is having an existential crisis of identity.")
|
||
var myHeaders = {
|
||
"Authorization": "Bearer " + bearerToken,
|
||
"Content-Type": "application/json"
|
||
}
|
||
var requestOptions = {
|
||
method: 'GET',
|
||
headers: myHeaders,
|
||
redirect: 'follow'
|
||
};
|
||
|
||
fetchWithRateLimit("https://webexapis.com/v1/people/me", requestOptions)
|
||
.then(async function (response) {
|
||
var userInfo = await response.json();
|
||
resolve(userInfo);
|
||
})
|
||
.catch(error => reject(error));
|
||
})
|
||
}
|
||
|
||
function buildPeopleList(fileName) {
|
||
return new Promise(async function (resolve, reject) {
|
||
var peoplePromises = [];
|
||
var peopleList = [];
|
||
if (fileName) {
|
||
var csvPeople = fs.readFileSync("./uploads/" + fileName, 'utf-8');
|
||
console.info(csvPeople);
|
||
csvPeople.split(/\r?\n/).forEach(line => {
|
||
peoplePromises.push(getPersonInfo(line));
|
||
|
||
})
|
||
|
||
Promise.allSettled(peoplePromises)
|
||
.then(peopleData => {
|
||
//console.log(JSON.stringify(peopleData))
|
||
var cnt = 0;
|
||
for (var person of peopleData) {
|
||
console.log(JSON.stringify(person))
|
||
cnt++;
|
||
if (person.status == "fulfilled") {
|
||
if (person.value) {
|
||
console.log("Found " + person.value.displayName)
|
||
peopleList.push({
|
||
"id": person.value.id,
|
||
"type": "peopleList",
|
||
"displayName": person.value.displayName
|
||
})
|
||
} else {
|
||
console.log(JSON.stringify(person))
|
||
}
|
||
} else {
|
||
console.log(cnt)
|
||
console.log(JSON.stringify(person))
|
||
}
|
||
}
|
||
console.log(JSON.stringify(peopleList))
|
||
resolve(peopleList);
|
||
})
|
||
.catch(error => reject(error));
|
||
}
|
||
|
||
})
|
||
}
|
||
|
||
function getPersonInfo(email) {
|
||
return new Promise(async function (resolve, reject) {
|
||
var myHeaders = {
|
||
"Authorization": "Bearer " + getServiceAccountAccessToken(),
|
||
"Content-Type": "application/json"
|
||
}
|
||
var requestOptions = {
|
||
method: 'GET',
|
||
headers: myHeaders,
|
||
redirect: 'follow'
|
||
};
|
||
|
||
fetchWithRateLimit("https://webexapis.com/v1/people?email=" + encodeURIComponent(email) + "&max=100", requestOptions)
|
||
.then(async function (response) {
|
||
console.log(email + ": " + response.status + ":" + response.statusText)
|
||
if (response.ok) {
|
||
var userInfo = await response.json();
|
||
resolve(userInfo.items[0]);
|
||
} else {
|
||
console.log(response.status + ": " + response.statusText)
|
||
try {
|
||
var stuff = await response.text();
|
||
} catch (error) {
|
||
console.log(error)
|
||
console.log(stuff)
|
||
}
|
||
reject();
|
||
}
|
||
|
||
})
|
||
.catch(error => {
|
||
|
||
reject(error)
|
||
});
|
||
|
||
|
||
})
|
||
}
|
||
|
||
function checkScheduledJobs() {
|
||
return new Promise(async function (resolve, reject) {
|
||
|
||
if (jobs.scheduled.length > 0) {
|
||
for (var i = 0; i < jobs.scheduled.length; i++) {
|
||
if (new Date(jobs.scheduled[i].scheduledFor) < new Date()) {
|
||
jobs.running.push(jobs.scheduled[i]);
|
||
delete jobs.scheduled[i];
|
||
} else { }
|
||
}
|
||
|
||
jobs.scheduled = jobs.scheduled.filter(elements => {
|
||
return (elements != null && elements !== undefined && elements !== "");
|
||
});
|
||
saveConfig(jobs, "./config/jobs.json");
|
||
processRunningQueue();
|
||
} else {
|
||
//console.log("No jobs scheduled.");
|
||
}
|
||
|
||
})
|
||
|
||
}
|
||
|
||
function processRunningQueue() {
|
||
return new Promise(async function (resolve, reject) {
|
||
var runningQueuePromises = [];
|
||
for (var i = 0; i < jobs.running.length; i++) {
|
||
jobs.lastJobNumber++;
|
||
jobs.running[i].jobId = jobs.lastJobNumber;
|
||
jobs.running[i].startTime = new Date();
|
||
jobs.running[i].queueNumber = i;
|
||
runningQueuePromises.push(sendQueueJobMessages(i));
|
||
}
|
||
|
||
Promise.allSettled(runningQueuePromises)
|
||
.then(promises => {
|
||
|
||
logger("processRunningQueue", "Completed");
|
||
jobs.running = jobs.running.filter(elements => { return (elements != null && elements !== undefined && elements !== ""); });
|
||
saveConfig(jobs, "./config/jobs.json")
|
||
resolve();
|
||
})
|
||
.catch(error => reject(error));
|
||
})
|
||
}
|
||
|
||
function sendQueueJobMessages(queueNumber) {
|
||
return new Promise(async function (resolve, reject) {
|
||
logger("sendQueueJobMessages", "Starting JobId:" + jobs.running[queueNumber].jobId + " Queue#" + queueNumber);
|
||
|
||
for (var x = 0; x < jobs.running[queueNumber].memberList.length; x++) {
|
||
await queue.onSizeLessThan(2);
|
||
if (userPrefs[jobs.running[queueNumber].memberList[x].id]) {
|
||
queue.add(() => sendRunningQueueMessage(jobs.running[queueNumber].memberList[x].id, jobs.running[queueNumber].message[userPrefs[jobs.running[queueNumber].memberList[x].id].language].markdown, jobs.running[queueNumber].imageName, queueNumber, x, jobs.running[queueNumber].appName));
|
||
} else {
|
||
queue.add(() => sendRunningQueueMessage(jobs.running[queueNumber].memberList[x].id, jobs.running[queueNumber].message.english.markdown, jobs.running[queueNumber].imageName, queueNumber, x, jobs.running[queueNumber].appName));
|
||
}
|
||
|
||
}
|
||
|
||
//console.log(membershipsPromise);
|
||
await queue.onIdle();
|
||
var endTime = new Date();
|
||
var startTime = jobs.running[queueNumber].startTime;
|
||
var successCnt = 0;
|
||
var msgTime = 0;
|
||
for (var z = 0; z < jobs.running[queueNumber].memberList.length; z++) {
|
||
if (jobs.running[queueNumber].memberList[z].msgTime) {
|
||
successCnt++;
|
||
msgTime += jobs.running[queueNumber].memberList[z].msgTime;
|
||
}
|
||
}
|
||
jobs.running[queueNumber].endTime = new Date();
|
||
jobs.running[queueNumber].stats = {
|
||
"totalTime": msToTime((endTime - startTime)),
|
||
"webexTime": msToTime(msgTime),
|
||
"averageTime": msToTime((msgTime / successCnt)),
|
||
"succeededMsgs": successCnt,
|
||
"totalMsgs": jobs.running[queueNumber].memberList.length,
|
||
"succeededMsgPct": (successCnt / jobs.running[queueNumber].memberList.length * 100)
|
||
}
|
||
|
||
jobs.running[queueNumber].endTime = new Date();
|
||
var cardDetails = buildJobCompletedCard(jobs.running[queueNumber]);
|
||
jobs.completed.push(jobs.running[queueNumber]);
|
||
logger("sendQueueJobMessages", "Completed JobId:" + jobs.running[queueNumber].jobId + " Queue#" + queueNumber)
|
||
|
||
await sendDirectCard(jobs.running[queueNumber].senderId, cardDetails, jobs.running[queueNumber].appName)
|
||
.then(msgResults => {
|
||
delete jobs.running[queueNumber];
|
||
})
|
||
.catch(error => {
|
||
//jobs.running[i].memberList[x].error = error;
|
||
reject(error);
|
||
})
|
||
|
||
resolve(queueNumber);
|
||
|
||
})
|
||
}
|
||
function sendRunningQueueMessage(toPersonId, message, imageName, jobNumber, memberNumber, appName) {
|
||
return new Promise(async function (resolve, reject) {
|
||
//logger("sendRunningQueueMessage", toPersonId + "\n" + message + "\n" + imageName + "\n" + jobNumber + "\n" + memberNumber + "\n" + appName)
|
||
logger("sendRunningQueueMessage", "Sending to " + toPersonId);
|
||
var startTime = new Date();
|
||
|
||
var myHeaders = new Headers();
|
||
myHeaders.append("Authorization", "Bearer " + getBotToken(appName));
|
||
var formdata = new FormData();
|
||
formdata.append("toPersonId", toPersonId);
|
||
formdata.append("markdown", message);
|
||
|
||
if (imageName) {
|
||
var stream = fs.createReadStream("./uploads/" + imageName);
|
||
//console.log(file);
|
||
formdata.append("files", stream, imageName);
|
||
};
|
||
|
||
//var myBody = JSON.stringify(myBodyJSON);
|
||
var requestOptions = {
|
||
method: 'POST',
|
||
headers: myHeaders,
|
||
body: formdata,
|
||
redirect: 'follow'
|
||
};
|
||
|
||
try {
|
||
|
||
const response = await fetchAndRetryIfNecessary(async () => (
|
||
await fetch("https://webexapis.com/v1/messages", requestOptions)
|
||
))
|
||
|
||
if (response.ok) {
|
||
var result = await response.json();
|
||
jobs.running[jobNumber].memberList[memberNumber].results = result;
|
||
jobs.running[jobNumber].memberList[memberNumber].msgTime = new Date() - startTime;
|
||
logger("sendRunningQueueMessage", "Sent successfully to " + toPersonId);
|
||
resolve(result)
|
||
} else {
|
||
var result = await response.text();
|
||
jobs.running[jobNumber].memberList[memberNumber].results = JSON.parse(result);
|
||
jobs.running[jobNumber].memberList[memberNumber].msgTime = new Date() - startTime;
|
||
resolve(JSON.parse(result));
|
||
}
|
||
|
||
} catch (error) {
|
||
logger("sendRunningQueueMessage", "Failed sending to " + toPersonId);
|
||
reject(error)
|
||
}
|
||
})
|
||
}
|
||
|
||
function sleep(milliseconds) {
|
||
return new Promise((resolve) => setTimeout(resolve, milliseconds))
|
||
}
|
||
|
||
function buildJobCompletedCard(job) {
|
||
var appName = job.appName;
|
||
var botCfg = (config.webex && config.webex.bot && config.webex.bot[appName]) || {};
|
||
var profile = getBotProfile(appName) || {};
|
||
|
||
// Per-bot identity: prefer the live profile from Webex /people/me, fall
|
||
// back to the configured label / appName so the card renders even before
|
||
// the profile loader finishes.
|
||
var botLabel = botCfg.label || profile.displayName || appName;
|
||
var botDisplayName = profile.displayName || botLabel;
|
||
var avatarUrl = profile.avatar || null;
|
||
var title = botLabel + " — Job Summary";
|
||
|
||
var stats = job.stats || {};
|
||
var successPct = (typeof stats.succeededMsgPct === "number")
|
||
? stats.succeededMsgPct.toFixed(1) + "%"
|
||
: (stats.succeededMsgPct + "%");
|
||
var startedStr = job.startTime ? new Date(job.startTime).toLocaleString() : "—";
|
||
var completedStr = job.endTime ? new Date(job.endTime).toLocaleString() : "—";
|
||
|
||
// Header columns: bot avatar (if known) + job summary title.
|
||
var headerColumns = [];
|
||
if (avatarUrl) {
|
||
headerColumns.push({
|
||
"type": "Column",
|
||
"width": "auto",
|
||
"items": [
|
||
{
|
||
"type": "Image",
|
||
"url": avatarUrl,
|
||
"altText": botDisplayName,
|
||
"style": "Person",
|
||
"size": "Small",
|
||
"spacing": "None"
|
||
}
|
||
]
|
||
});
|
||
}
|
||
headerColumns.push({
|
||
"type": "Column",
|
||
"width": "auto",
|
||
"items": [
|
||
{
|
||
"type": "TextBlock",
|
||
"text": title,
|
||
"wrap": true,
|
||
"size": "ExtraLarge",
|
||
"weight": "Bolder",
|
||
"spacing": "None",
|
||
"horizontalAlignment": "Left"
|
||
}
|
||
],
|
||
"verticalContentAlignment": "Center"
|
||
});
|
||
|
||
var jobCompletedCard = {
|
||
"type": "AdaptiveCard",
|
||
"$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
|
||
"version": "1.3",
|
||
"body": [
|
||
{ "type": "ColumnSet", "columns": headerColumns, "spacing": "None" },
|
||
{
|
||
"type": "TextBlock",
|
||
"text": (job.message && job.message.english && job.message.english.markdown) || "",
|
||
"wrap": true
|
||
},
|
||
{
|
||
"type": "FactSet",
|
||
"facts": [
|
||
{ "title": "JobID:", "value": (job.jobId !== undefined && job.jobId !== null) ? job.jobId.toString() : "—" },
|
||
{ "title": "Started:", "value": startedStr },
|
||
{ "title": "Completed:", "value": completedStr },
|
||
{ "title": "Duration:", "value": stats.totalTime || "—" },
|
||
{ "title": "Avg Message:", "value": stats.averageTime || "—" },
|
||
{ "title": "Webex Time:", "value": stats.webexTime || "—" },
|
||
{ "title": "Success", "value": (stats.succeededMsgs !== undefined ? (stats.succeededMsgs + "/" + stats.totalMsgs + " (" + successPct + ")") : "—") }
|
||
],
|
||
"separator": true
|
||
}
|
||
]
|
||
};
|
||
|
||
var message = "### " + title + "\n";
|
||
message += "**JobId:** " + (job.jobId !== undefined ? job.jobId : "—") + "\n";
|
||
message += "**Started:** " + startedStr + "\n";
|
||
message += "**Completed:** " + completedStr + "\n";
|
||
message += "**Duration:** " + (stats.totalTime || "—") + "\n";
|
||
message += "**Avg Message:** " + (stats.averageTime || "—") + "\n";
|
||
message += "**Webex Time:** " + (stats.webexTime || "—") + "\n";
|
||
message += "**Success:** " + (stats.succeededMsgs !== undefined ? (stats.succeededMsgs + "/" + stats.totalMsgs + " (" + successPct + ")") : "—") + "\n";
|
||
|
||
return { "card": jobCompletedCard, "message": message };
|
||
}
|
||
|
||
async function fetchWithRateLimit(url, requestOptions) {
|
||
const response = await fetch(url, requestOptions)
|
||
|
||
if (response.status === 429) {
|
||
//console.log(response.headers)
|
||
const secondsToWait = Number(response.headers.get('retry-after'))
|
||
console.log("Waiting for " + secondsToWait.toString() + " due to 429 message: " + url);
|
||
console.log(JSON.stringify(requestOptions));
|
||
await new Promise(resolve => setTimeout(resolve, secondsToWait * 1000))
|
||
console.log("Finished waiting for " + secondsToWait.toString() + " due to 429 message: " + url);
|
||
console.log(JSON.stringify(requestOptions))
|
||
return await fetchWithRateLimit(url, requestOptions)
|
||
}
|
||
return response
|
||
}
|
||
|
||
function getMillisToSleep(retryHeaderString) {
|
||
let millisToSleep = Math.round(parseFloat(retryHeaderString) * 1000)
|
||
if (isNaN(millisToSleep)) {
|
||
millisToSleep = Math.max(0, new Date(retryHeaderString) - new Date())
|
||
}
|
||
return millisToSleep
|
||
}
|
||
|
||
async function fetchAndRetryIfNecessary(callAPIFn) {
|
||
const response = await callAPIFn()
|
||
if (response.status === 429) {
|
||
const retryAfter = response.headers.get('retry-after')
|
||
const millisToSleep = getMillisToSleep(retryAfter)
|
||
await sleep(millisToSleep)
|
||
return fetchAndRetryIfNecessary(callAPIFn)
|
||
}
|
||
return response
|
||
}
|
||
|
||
// Look up a Webex person by email via /v1/people. Used by the admin UI so
|
||
// authorizing someone on a bot only requires their email — the id, display
|
||
// name, and avatar come from Webex. Resolves to null when the email doesn't
|
||
// match any account or when the Webex request fails; the caller distinguishes
|
||
// with its own 404/502 as appropriate.
|
||
function findPersonByEmail(email) {
|
||
return new Promise(function (resolve, reject) {
|
||
var url = 'https://webexapis.com/v1/people?email=' + encodeURIComponent(email);
|
||
var requestOptions = {
|
||
method: 'GET',
|
||
headers: {
|
||
'Authorization': 'Bearer ' + getServiceAccountAccessToken(),
|
||
'Content-Type': 'application/json'
|
||
}
|
||
};
|
||
fetchWithRateLimit(url, requestOptions)
|
||
.then(function (response) {
|
||
if (!response.ok) {
|
||
return reject(new Error('HTTP ' + response.status + ' from Webex /people'));
|
||
}
|
||
return response.json();
|
||
})
|
||
.then(function (body) {
|
||
var items = body && body.items;
|
||
if (!items || !items.length) return resolve(null);
|
||
var person = items[0];
|
||
resolve({
|
||
id: person.id,
|
||
displayName: person.displayName,
|
||
email: (person.emails && person.emails[0]) || email,
|
||
avatar: person.avatar || null
|
||
});
|
||
})
|
||
.catch(reject);
|
||
});
|
||
}
|
||
|
||
// Best-effort DELETE on a Webex message we previously sent (right now used
|
||
// only to retract the preview DM when the user cancels a draft). Never
|
||
// throws: the caller doesn't want a Webex hiccup here to bounce the whole
|
||
// cancel flow, so we swallow + log and let the caller move on.
|
||
function deleteWebexMessage(messageId, appName) {
|
||
return new Promise(function (resolve) {
|
||
var url = "https://webexapis.com/v1/messages/" + encodeURIComponent(messageId);
|
||
var requestOptions = {
|
||
method: 'DELETE',
|
||
headers: { "Authorization": "Bearer " + getBotToken(appName) }
|
||
};
|
||
fetchWithRateLimit(url, requestOptions)
|
||
.then(function (response) {
|
||
if (!response.ok) {
|
||
logger('deleteWebexMessage',
|
||
'HTTP ' + response.status + ' for ' + messageId);
|
||
}
|
||
resolve(response.ok);
|
||
})
|
||
.catch(function (err) {
|
||
logger('deleteWebexMessage',
|
||
'error for ' + messageId + ': ' + (err && err.message || err));
|
||
resolve(false);
|
||
});
|
||
});
|
||
}
|
||
|
||
function sendDirectMessage(toPersonId, message, imageName, appName) {
|
||
return new Promise(async function (resolve, reject) {
|
||
|
||
var startTime = new Date();
|
||
var myHeaders = new Headers();
|
||
myHeaders.append("Authorization", "Bearer " + getBotToken(appName));
|
||
var formdata = new FormData();
|
||
formdata.append("toPersonId", toPersonId);
|
||
formdata.append("markdown", message);
|
||
|
||
if (imageName) {
|
||
//var file = await fs.readFileSync("./uploads/" + imageName);
|
||
var stream = await fs.createReadStream("./uploads/" + imageName);
|
||
//console.log(file);
|
||
formdata.append("files", stream, imageName);
|
||
//formdata.set("files", new BlobFromStream(stream, content.length), imageName)
|
||
|
||
};
|
||
|
||
//var myBody = JSON.stringify(myBodyJSON);
|
||
var requestOptions = {
|
||
method: 'POST',
|
||
headers: myHeaders,
|
||
body: formdata,
|
||
redirect: 'follow'
|
||
};
|
||
|
||
fetchWithRateLimit("https://webexapis.com/v1/messages", requestOptions)
|
||
.then(response => response.text())
|
||
.then(result => {
|
||
var msgResult = JSON.parse(result);
|
||
resolve(msgResult)
|
||
})
|
||
.catch(error => reject(error));
|
||
});
|
||
}
|
||
|
||
function sendDirectCard(toPersonId, cardInfo, appName) {
|
||
return new Promise(async function (resolve, reject) {
|
||
|
||
var myHeaders = {
|
||
"Authorization": "Bearer " + getBotToken(appName),
|
||
"Content-Type": "application/json"
|
||
}
|
||
var body = {
|
||
toPersonId: toPersonId,
|
||
markdown: cardInfo.message,
|
||
attachments: [{ contentType: "application/vnd.microsoft.card.adaptive", content: cardInfo.card }]
|
||
}
|
||
|
||
var requestOptions = {
|
||
method: 'POST',
|
||
headers: myHeaders,
|
||
body: JSON.stringify(body),
|
||
redirect: 'follow'
|
||
};
|
||
//console.log("RequestOptions:" + JSON.stringify(requestOptions));
|
||
fetchWithRateLimit("https://webexapis.com/v1/messages", requestOptions)
|
||
.then(async function (response) {
|
||
var subData = await response.text();
|
||
//console.log(subData);
|
||
resolve(response);
|
||
})
|
||
.catch(error => reject(error));
|
||
|
||
});
|
||
}
|
||
function buildTranslations(message) {
|
||
return new Promise(async function (resolve, reject) {
|
||
logger("buildTranslations", "Started");
|
||
var translationPromises = [];
|
||
var translations = {
|
||
"english": {
|
||
"text": message.text,
|
||
"markdown": message.markdown,
|
||
"html": message.html
|
||
}
|
||
};
|
||
|
||
for (var language of config.languages) {
|
||
translationPromises.push(translateMessage(message.text, language, "text", "text"))
|
||
translationPromises.push(translateMessage(message.markdown, language, "text", "markdown"))
|
||
translationPromises.push(translateMessage(message.html, language, "html", "html"))
|
||
}
|
||
|
||
Promise.allSettled(translationPromises)
|
||
.then(results => {
|
||
//console.log(JSON.stringify(results))
|
||
for (var translation of results) {
|
||
if (translation.status == "fulfilled") {
|
||
if (translations[translation.value.name]) {
|
||
translations[translation.value.name][translation.value.messageType] = translation.value.translatedText;
|
||
} else {
|
||
translations[translation.value.name] = {};
|
||
translations[translation.value.name][translation.value.messageType] = translation.value.translatedText;
|
||
}
|
||
|
||
}
|
||
}
|
||
//console.log(JSON.stringify(translations));
|
||
logger("buildTranslations", "Completed")
|
||
resolve(translations);
|
||
})
|
||
})
|
||
}
|
||
|
||
function translateMessage(message, language, format, messageType) {
|
||
return new Promise(async function (resolve, reject) {
|
||
var urlSearchParams = {
|
||
q: message,
|
||
target: language.key,
|
||
format: format,
|
||
source: "en",
|
||
model: "nmt",
|
||
key: process.env.GOOGLE_TRANSLATE_API_KEY || ''
|
||
}
|
||
var translateUrl = "https://translation.googleapis.com/language/translate/v2?" + new URLSearchParams(urlSearchParams);
|
||
//console.log(translateUrl);
|
||
fetchWithRateLimit(translateUrl, { "method": "POST" })
|
||
.then(response => response.json())
|
||
.then(result => {
|
||
var languageResult = {
|
||
"name": language.name,
|
||
"key": language.key,
|
||
"format": format,
|
||
"messageType": messageType,
|
||
"translatedText": result.data.translations[0].translatedText
|
||
}
|
||
resolve(languageResult);
|
||
})
|
||
.catch(error => reject(error))
|
||
})
|
||
}
|
||
function refreshToken() {
|
||
return new Promise(async function (resolve, reject) {
|
||
var url = "https://webexapis.com/v1/access_token";
|
||
|
||
var params = new URLSearchParams();
|
||
params.append('grant_type', 'refresh_token');
|
||
params.append('client_id', process.env.WEBEX_SERVICE_ACCOUNT_CLIENT_ID || '');
|
||
params.append('client_secret', process.env.WEBEX_SERVICE_ACCOUNT_CLIENT_SECRET || '');
|
||
params.append('refresh_token', serviceAccountToken.refresh_token);
|
||
|
||
fetchWithRateLimit(url, { method: 'post', body: params })
|
||
.then(res => {
|
||
console.log(res.status);
|
||
return res.json();
|
||
})
|
||
.then(function (json) {
|
||
var updated = Object.assign({}, json, {
|
||
created: new Date().toLocaleString("en-US", { timeZoneName: "short", timeZone: "America/New_York" }),
|
||
renewBy: new Date(Date.now() + (json.expires_in * 1000)).toLocaleString("en-US", { timeZoneName: "short", timeZone: "America/New_York" }),
|
||
refreshBy: new Date(Date.now() + (json.refresh_token_expires_in * 1000)).toLocaleString("en-US", { timeZoneName: "short", timeZone: "America/New_York" })
|
||
});
|
||
saveServiceAccountToken(updated);
|
||
resolve("Refresh Success!\nExpires: " + updated.renewBy + "\nRefreshBy: " + updated.refreshBy);
|
||
})
|
||
.catch(err => reject(err));
|
||
})
|
||
}
|
||
|
||
function saveConfig(jsonObject, configFile) {
|
||
const jsonData = JSON.stringify(jsonObject, null, 4);
|
||
fs.writeFileSync(configFile, jsonData, (err) => {
|
||
if (err) {
|
||
throw err;
|
||
} else {
|
||
logger("saveConfig", "Wrote " + configFile);
|
||
}
|
||
})
|
||
}
|
||
|
||
// Retention window for completed jobs (re-exported from lib/helpers.js so
|
||
// index.js has a single symbol name callers can reason about). Bump this by
|
||
// editing helpers.js if you want a longer / shorter review window.
|
||
const COMPLETED_RETENTION_DAYS = helpers.COMPLETED_RETENTION_DAYS;
|
||
|
||
async function cleanCompletedJobs(jobs) {
|
||
var result = helpers.cleanCompletedJobs(jobs, COMPLETED_RETENTION_DAYS);
|
||
if (!Array.isArray(result.jobs.completed)) {
|
||
logger('cleanCompletedJobs', 'No completed array found – nothing to do.');
|
||
} else {
|
||
logger('cleanCompletedJobs',
|
||
'Removed ' + result.removed + ' job(s) older than ' + COMPLETED_RETENTION_DAYS +
|
||
' days (cutoff ' + result.cutoff.toISOString().split('T')[0] + '). Remaining: ' +
|
||
result.jobs.completed.length);
|
||
}
|
||
return result.jobs;
|
||
}
|
||
|
||
function isAuthorized(appName, personId) {
|
||
logger("isAuthorized", appName + " " + personId)
|
||
return helpers.isAuthorized(config, botTokens, authorized, appName, personId);
|
||
}
|
||
|
||
function isAdmin(personId) {
|
||
return helpers.isAdmin(authorized, personId);
|
||
}
|
||
|
||
function msToTime(duration) {
|
||
return helpers.msToTime(duration);
|
||
}
|
||
|
||
function logger(activeFunction, logLine) {
|
||
var d = new Date();
|
||
console.log(d.toLocaleString() + " " + activeFunction + ": " + logLine);
|
||
}
|
||
|
||
// gracefully shutdown (ctrl-c)
|
||
process.on('SIGINT', function () {
|
||
server.close(() => {
|
||
logger("shutdown", config.server.name + ' stopped!')
|
||
process.exit();
|
||
});
|
||
})
|