@terreno/announcements 57.4.0

package/dist/announcementsApp.js

@@ -0,0 +1,820 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnnouncementsApp = void 0;
+var api_1 = require("@terreno/api");
+var express_1 = require("express");
+var luxon_1 = require("luxon");
+var helpRoutes_1 = require("./helpRoutes");
+var announcement_1 = require("./models/announcement");
+var announcementAcknowledgement_1 = require("./models/announcementAcknowledgement");
+var announcementClickEvent_1 = require("./models/announcementClickEvent");
+var announcementImpression_1 = require("./models/announcementImpression");
+var overview_1 = require("./overview");
+var pending_1 = require("./pending");
+var DEFAULT_BASE_PATH = "/announcements";
+var defaultIsStaff = function (user) { return user.admin === true; };
+var parsePlatform = function (req) {
+    var _a, _b;
+    var queryPlatform = req.query.platform;
+    if ((0, announcementImpression_1.isValidPlatform)(queryPlatform)) {
+        return queryPlatform;
+    }
+    var userAgent = (_b = (_a = req.get("user-agent")) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : "";
+    if (userAgent.includes("iphone") || userAgent.includes("ipad")) {
+        return "ios";
+    }
+    if (userAgent.includes("android")) {
+        return "android";
+    }
+    return "web";
+};
+var requireAdmin = function (user) {
+    if (!(user === null || user === void 0 ? void 0 : user.admin)) {
+        throw new api_1.APIError({ status: 403, title: "Admin access required" });
+    }
+};
+var requireOverviewAccess = function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+    var permissions_1, permissions_1_1, permission, isAllowed, e_1_1;
+    var e_1, _c;
+    var permissions = _b.permissions, user = _b.user;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                if (permissions.length === 0) {
+                    throw new api_1.APIError({ status: 403, title: "Admin access required" });
+                }
+                _d.label = 1;
+            case 1:
+                _d.trys.push([1, 6, 7, 8]);
+                permissions_1 = __values(permissions), permissions_1_1 = permissions_1.next();
+                _d.label = 2;
+            case 2:
+                if (!!permissions_1_1.done) return [3 /*break*/, 5];
+                permission = permissions_1_1.value;
+                return [4 /*yield*/, permission("list", user)];
+            case 3:
+                isAllowed = _d.sent();
+                if (!isAllowed) {
+                    throw new api_1.APIError({ status: 403, title: "Admin access required" });
+                }
+                _d.label = 4;
+            case 4:
+                permissions_1_1 = permissions_1.next();
+                return [3 /*break*/, 2];
+            case 5: return [3 /*break*/, 8];
+            case 6:
+                e_1_1 = _d.sent();
+                e_1 = { error: e_1_1 };
+                return [3 /*break*/, 8];
+            case 7:
+                try {
+                    if (permissions_1_1 && !permissions_1_1.done && (_c = permissions_1.return)) _c.call(permissions_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+                return [7 /*endfinally*/];
+            case 8: return [2 /*return*/];
+        }
+    });
+}); };
+var getUserId = function (user) {
+    var _a;
+    var userId = (_a = user._id) !== null && _a !== void 0 ? _a : user.id;
+    if (!userId) {
+        throw new api_1.APIError({ status: 401, title: "Authentication required" });
+    }
+    return String(userId);
+};
+var hasPrimaryAction = function (announcement) {
+    var _a, _b, _c, _d;
+    var label = (_b = (_a = announcement.primaryAction) === null || _a === void 0 ? void 0 : _a.label) === null || _b === void 0 ? void 0 : _b.trim();
+    var url = (_d = (_c = announcement.primaryAction) === null || _c === void 0 ? void 0 : _c.url) === null || _d === void 0 ? void 0 : _d.trim();
+    return Boolean(label && url);
+};
+var resolveClickPlatform = function (req, bodyPlatform) {
+    if (bodyPlatform !== undefined && bodyPlatform !== null) {
+        if (!(0, announcementImpression_1.isValidPlatform)(bodyPlatform)) {
+            throw new api_1.APIError({ status: 400, title: "Invalid platform" });
+        }
+        return bodyPlatform;
+    }
+    return parsePlatform(req);
+};
+var requireVisibleAnnouncement = function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+    var visible;
+    var announcement = _b.announcement, isStaff = _b.isStaff, matchAudience = _b.matchAudience, platform = _b.platform, queryVersion = _b.queryVersion, user = _b.user;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (!announcement) {
+                    throw new api_1.APIError({ status: 404, title: "Announcement not found" });
+                }
+                return [4 /*yield*/, (0, pending_1.isAnnouncementVisibleToUser)({
+                        announcement: announcement,
+                        isStaff: isStaff,
+                        matchAudience: matchAudience,
+                        platform: platform,
+                        queryVersion: queryVersion,
+                        user: user,
+                    })];
+            case 1:
+                visible = _c.sent();
+                if (!visible) {
+                    throw new api_1.APIError({ status: 404, title: "Announcement not found" });
+                }
+                return [2 /*return*/, announcement];
+        }
+    });
+}); };
+var AnnouncementsApp = /** @class */ (function () {
+    function AnnouncementsApp(options) {
+        this.options = options !== null && options !== void 0 ? options : {};
+    }
+    AnnouncementsApp.prototype.adminContribution = function () {
+        return {
+            customScreens: [
+                {
+                    displayName: "Overview",
+                    group: "Announcements",
+                    icon: "bullhorn",
+                    name: "announcements",
+                },
+            ],
+            models: [
+                {
+                    admin: {
+                        defaultSort: "-priority,-publishedAt",
+                        displayName: "All announcements",
+                        group: "Announcements",
+                        listDisplayLinks: ["title"],
+                        listFields: [
+                            "title",
+                            "status",
+                            "priority",
+                            "version",
+                            "publishedAt",
+                            "expiresAt",
+                            "acknowledgementPolicy",
+                        ],
+                        searchFields: ["title"],
+                        sortableFields: ["title", "status", "priority", "version", "publishedAt", "created"],
+                    },
+                    model: announcement_1.Announcement,
+                    routePath: "/announcements",
+                },
+                {
+                    admin: {
+                        adminPermissions: {
+                            create: [],
+                            delete: [],
+                            list: [api_1.Permissions.IsAdmin],
+                            read: [api_1.Permissions.IsAdmin],
+                            update: [],
+                        },
+                        defaultSort: "-acknowledgedAt",
+                        displayName: "Acknowledgements",
+                        group: "Announcements",
+                        listFields: ["userId", "announcementId", "version", "acknowledgedAt"],
+                    },
+                    model: announcementAcknowledgement_1.AnnouncementAcknowledgement,
+                    routePath: "/announcement-acknowledgements",
+                },
+                {
+                    admin: {
+                        adminPermissions: {
+                            create: [],
+                            delete: [],
+                            list: [api_1.Permissions.IsAdmin],
+                            read: [api_1.Permissions.IsAdmin],
+                            update: [],
+                        },
+                        defaultSort: "-viewedAt",
+                        displayName: "Impressions",
+                        group: "Announcements",
+                        listFields: ["userId", "announcementId", "version", "viewedAt", "platform"],
+                    },
+                    model: announcementImpression_1.AnnouncementImpression,
+                    routePath: "/announcement-impressions",
+                },
+                {
+                    admin: {
+                        adminPermissions: {
+                            create: [],
+                            delete: [],
+                            list: [api_1.Permissions.IsAdmin],
+                            read: [api_1.Permissions.IsAdmin],
+                            update: [],
+                        },
+                        defaultSort: "-clickedAt",
+                        displayName: "Click events",
+                        group: "Announcements",
+                        listFields: ["userId", "announcementId", "version", "action", "clickedAt", "platform"],
+                    },
+                    model: announcementClickEvent_1.AnnouncementClickEvent,
+                    routePath: "/announcement-click-events",
+                },
+            ],
+        };
+    };
+    AnnouncementsApp.prototype.register = function (app, openApi) {
+        var _this = this;
+        var _a, _b, _c, _d, _e, _f;
+        var basePath = (_a = this.options.basePath) !== null && _a !== void 0 ? _a : DEFAULT_BASE_PATH;
+        var defaultAcknowledgementPolicy = (_b = this.options.defaultAcknowledgementPolicy) !== null && _b !== void 0 ? _b : "dismiss-only";
+        var overviewPermissions = (_c = this.options.adminOverviewPermissions) !== null && _c !== void 0 ? _c : [api_1.Permissions.IsAdmin];
+        var matchAudience = (_d = this.options.matchAudience) !== null && _d !== void 0 ? _d : (function () { return true; });
+        var isStaff = (_e = this.options.isStaff) !== null && _e !== void 0 ? _e : defaultIsStaff;
+        var matchesAnnouncementAudience = function (user, announcement) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!(0, pending_1.matchAudienceByType)({ announcement: announcement, isStaff: isStaff, user: user })) {
+                    return [2 /*return*/, false];
+                }
+                return [2 /*return*/, matchAudience(user, announcement)];
+            });
+        }); };
+        var routerOptions = __assign(__assign({}, (openApi ? { openApi: openApi } : {})), { permissions: __assign({ create: [api_1.Permissions.IsAdmin], delete: [api_1.Permissions.IsAdmin], list: [api_1.Permissions.IsAdmin], read: [api_1.Permissions.IsAdmin], update: [api_1.Permissions.IsAdmin] }, this.options.permissions), queryFields: ["status", "priority", "title"], sort: "-priority,-publishedAt" });
+        var userRouter = (0, express_1.Router)();
+        userRouter.get("/pending", (0, api_1.authenticateMiddleware)(), (0, api_1.asyncHandler)(function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+            var user, userId, platform, queryVersion, published, audienceFiltered, published_1, published_1_1, announcement, matches, e_2_1, acknowledgements, impressions, pending, current, remainingCount;
+            var e_2, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        user = req.user;
+                        if (!user) {
+                            throw new api_1.APIError({ status: 401, title: "Authentication required" });
+                        }
+                        userId = getUserId(user);
+                        platform = parsePlatform(req);
+                        queryVersion = (0, pending_1.parseQueryVersion)(req.query.version);
+                        return [4 /*yield*/, announcement_1.Announcement.find({ status: "published" }).lean()];
+                    case 1:
+                        published = (_b.sent());
+                        audienceFiltered = [];
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 7, 8, 9]);
+                        published_1 = __values(published), published_1_1 = published_1.next();
+                        _b.label = 3;
+                    case 3:
+                        if (!!published_1_1.done) return [3 /*break*/, 6];
+                        announcement = published_1_1.value;
+                        return [4 /*yield*/, matchesAnnouncementAudience(user, announcement)];
+                    case 4:
+                        matches = _b.sent();
+                        if (matches) {
+                            audienceFiltered.push(announcement);
+                        }
+                        _b.label = 5;
+                    case 5:
+                        published_1_1 = published_1.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_2_1 = _b.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (published_1_1 && !published_1_1.done && (_a = published_1.return)) _a.call(published_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 9: return [4 /*yield*/, announcementAcknowledgement_1.AnnouncementAcknowledgement.find({ userId: userId }).select("announcementId version")];
+                    case 10:
+                        acknowledgements = _b.sent();
+                        return [4 /*yield*/, announcementImpression_1.AnnouncementImpression.find({ userId: userId }).select("announcementId version")];
+                    case 11:
+                        impressions = _b.sent();
+                        pending = (0, pending_1.selectPendingAnnouncements)({
+                            acknowledgements: acknowledgements.map(function (ack) { return ({
+                                announcementId: ack.announcementId.toString(),
+                                version: ack.version,
+                            }); }),
+                            announcements: audienceFiltered,
+                            defaultAcknowledgementPolicy: defaultAcknowledgementPolicy,
+                            impressions: impressions.map(function (impression) { return ({
+                                announcementId: impression.announcementId.toString(),
+                                version: impression.version,
+                            }); }),
+                            platform: platform,
+                            queryVersion: queryVersion,
+                        });
+                        current = pending[0]
+                            ? (0, announcement_1.toAnnouncementPublic)(pending[0], defaultAcknowledgementPolicy)
+                            : null;
+                        remainingCount = Math.max(pending.length - (current ? 1 : 0), 0);
+                        api_1.logger.info("Pending announcements fetched", {
+                            currentId: current === null || current === void 0 ? void 0 : current.id,
+                            platform: platform,
+                            remainingCount: remainingCount,
+                            userId: userId,
+                        });
+                        return [2 /*return*/, res.json({ data: { current: current, remainingCount: remainingCount } })];
+                }
+            });
+        }); }));
+        userRouter.get("/feed", (0, api_1.authenticateMiddleware)(), (0, api_1.asyncHandler)(function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+            var user, platform, queryVersion, limit, page, published, visible, published_2, published_2_1, announcement, matchesAudience, e_3_1, sorted, start, pageItems;
+            var e_3, _a;
+            var _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        user = req.user;
+                        if (!user) {
+                            throw new api_1.APIError({ status: 401, title: "Authentication required" });
+                        }
+                        platform = parsePlatform(req);
+                        queryVersion = (0, pending_1.parseQueryVersion)(req.query.version);
+                        limit = Math.min(Math.max(Number((_b = req.query.limit) !== null && _b !== void 0 ? _b : 20), 1), 100);
+                        page = Math.max(Number((_c = req.query.page) !== null && _c !== void 0 ? _c : 1), 1);
+                        return [4 /*yield*/, announcement_1.Announcement.find({ status: "published" }).lean()];
+                    case 1:
+                        published = (_d.sent());
+                        visible = [];
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 7, 8, 9]);
+                        published_2 = __values(published), published_2_1 = published_2.next();
+                        _d.label = 3;
+                    case 3:
+                        if (!!published_2_1.done) return [3 /*break*/, 6];
+                        announcement = published_2_1.value;
+                        return [4 /*yield*/, matchesAnnouncementAudience(user, announcement)];
+                    case 4:
+                        matchesAudience = _d.sent();
+                        if (!matchesAudience) {
+                            return [3 /*break*/, 5];
+                        }
+                        if (!(0, pending_1.isAnnouncementVisibleNow)({ announcement: announcement })) {
+                            return [3 /*break*/, 5];
+                        }
+                        if (!(0, pending_1.matchesPlatform)({ announcement: announcement, platform: platform })) {
+                            return [3 /*break*/, 5];
+                        }
+                        if (!(0, pending_1.passesMinBuildNumber)({ announcement: announcement, queryVersion: queryVersion })) {
+                            return [3 /*break*/, 5];
+                        }
+                        visible.push(announcement);
+                        _d.label = 5;
+                    case 5:
+                        published_2_1 = published_2.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_3_1 = _d.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (published_2_1 && !published_2_1.done && (_a = published_2.return)) _a.call(published_2);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 9:
+                        sorted = visible.sort(function (left, right) {
+                            var _a, _b, _c, _d;
+                            if (right.priority !== left.priority) {
+                                return right.priority - left.priority;
+                            }
+                            var rightPublished = (_b = (_a = right.publishedAt) === null || _a === void 0 ? void 0 : _a.getTime()) !== null && _b !== void 0 ? _b : 0;
+                            var leftPublished = (_d = (_c = left.publishedAt) === null || _c === void 0 ? void 0 : _c.getTime()) !== null && _d !== void 0 ? _d : 0;
+                            return rightPublished - leftPublished;
+                        });
+                        start = (page - 1) * limit;
+                        pageItems = sorted
+                            .slice(start, start + limit)
+                            .map(function (announcement) { return (0, announcement_1.toAnnouncementPublic)(announcement, defaultAcknowledgementPolicy); });
+                        return [2 /*return*/, res.json({
+                                data: pageItems,
+                                page: page,
+                                total: sorted.length,
+                            })];
+                }
+            });
+        }); }));
+        userRouter.post("/:id/acknowledge", (0, api_1.authenticateMiddleware)(), (0, api_1.asyncHandler)(function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+            var user, userId, announcement, _a, existing;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        user = req.user;
+                        if (!user) {
+                            throw new api_1.APIError({ status: 401, title: "Authentication required" });
+                        }
+                        userId = getUserId(user);
+                        _a = requireVisibleAnnouncement;
+                        _b = {};
+                        return [4 /*yield*/, announcement_1.Announcement.findById(req.params.id)];
+                    case 1: return [4 /*yield*/, _a.apply(void 0, [(_b.announcement = _c.sent(),
+                                _b.isStaff = isStaff,
+                                _b.matchAudience = matchAudience,
+                                _b.platform = parsePlatform(req),
+                                _b.queryVersion = (0, pending_1.parseQueryVersion)(req.query.version),
+                                _b.user = user,
+                                _b)])];
+                    case 2:
+                        announcement = _c.sent();
+                        return [4 /*yield*/, (0, api_1.findOneOrNoneFor)(announcementAcknowledgement_1.AnnouncementAcknowledgement, {
+                                announcementId: announcement._id,
+                                userId: userId,
+                                version: announcement.version,
+                            })];
+                    case 3:
+                        existing = _c.sent();
+                        if (!!existing) return [3 /*break*/, 5];
+                        return [4 /*yield*/, announcementAcknowledgement_1.AnnouncementAcknowledgement.create({
+                                acknowledgedAt: luxon_1.DateTime.utc().toJSDate(),
+                                announcementId: announcement._id,
+                                userId: userId,
+                                version: announcement.version,
+                            })];
+                    case 4:
+                        _c.sent();
+                        _c.label = 5;
+                    case 5: return [2 /*return*/, res.json({ data: { acknowledged: true } })];
+                }
+            });
+        }); }));
+        userRouter.post("/:id/impression", (0, api_1.authenticateMiddleware)(), (0, api_1.asyncHandler)(function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+            var user, userId, bodyPlatform, platform, announcement, _a;
+            var _b;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        user = req.user;
+                        if (!user) {
+                            throw new api_1.APIError({ status: 401, title: "Authentication required" });
+                        }
+                        userId = getUserId(user);
+                        bodyPlatform = (_c = req.body) === null || _c === void 0 ? void 0 : _c.platform;
+                        platform = (0, announcementImpression_1.isValidPlatform)(bodyPlatform) ? bodyPlatform : parsePlatform(req);
+                        _a = requireVisibleAnnouncement;
+                        _b = {};
+                        return [4 /*yield*/, announcement_1.Announcement.findById(req.params.id)];
+                    case 1: return [4 /*yield*/, _a.apply(void 0, [(_b.announcement = _d.sent(),
+                                _b.isStaff = isStaff,
+                                _b.matchAudience = matchAudience,
+                                _b.platform = platform,
+                                _b.queryVersion = (0, pending_1.parseQueryVersion)(req.query.version),
+                                _b.user = user,
+                                _b)])];
+                    case 2:
+                        announcement = _d.sent();
+                        return [4 /*yield*/, announcementImpression_1.AnnouncementImpression.create({
+                                announcementId: announcement._id,
+                                platform: platform,
+                                userId: userId,
+                                version: announcement.version,
+                                viewedAt: luxon_1.DateTime.utc().toJSDate(),
+                            })];
+                    case 3:
+                        _d.sent();
+                        return [2 /*return*/, res.json({ data: { recorded: true } })];
+                }
+            });
+        }); }));
+        userRouter.post("/:id/click", (0, api_1.authenticateMiddleware)(), (0, api_1.asyncHandler)(function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+            var user, userId, body, platform, announcement, _a;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        user = req.user;
+                        if (!user) {
+                            throw new api_1.APIError({ status: 401, title: "Authentication required" });
+                        }
+                        userId = getUserId(user);
+                        body = req.body;
+                        platform = resolveClickPlatform(req, body.platform);
+                        _a = requireVisibleAnnouncement;
+                        _b = {};
+                        return [4 /*yield*/, announcement_1.Announcement.findById(req.params.id)];
+                    case 1: return [4 /*yield*/, _a.apply(void 0, [(_b.announcement = _c.sent(),
+                                _b.isStaff = isStaff,
+                                _b.matchAudience = matchAudience,
+                                _b.platform = platform,
+                                _b.queryVersion = (0, pending_1.parseQueryVersion)(req.query.version),
+                                _b.user = user,
+                                _b)])];
+                    case 2:
+                        announcement = _c.sent();
+                        if (!(0, announcementClickEvent_1.isValidClickAction)(body.action)) {
+                            throw new api_1.APIError({ status: 400, title: "Invalid click action" });
+                        }
+                        if (!hasPrimaryAction(announcement)) {
+                            throw new api_1.APIError({ status: 400, title: "Announcement has no primary action" });
+                        }
+                        return [4 /*yield*/, announcementClickEvent_1.AnnouncementClickEvent.create({
+                                action: body.action,
+                                announcementId: announcement._id,
+                                clickedAt: luxon_1.DateTime.utc().toJSDate(),
+                                platform: platform,
+                                userId: userId,
+                                version: announcement.version,
+                            })];
+                    case 3:
+                        _c.sent();
+                        return [2 /*return*/, res.json({ data: { recorded: true } })];
+                }
+            });
+        }); }));
+        var adminRouter = (0, express_1.Router)();
+        var routeOpenApi = openApi ? { openApi: openApi } : undefined;
+        adminRouter.get("/config", __spreadArray([
+            (0, api_1.authenticateMiddleware)()
+        ], __read((routeOpenApi
+            ? [
+                (0, api_1.createOpenApiBuilder)(routeOpenApi)
+                    .withTags(["announcements"])
+                    .withSummary("Get announcement plugin configuration")
+                    .withResponse(200, {
+                    data: {
+                        properties: {
+                            defaultAcknowledgementPolicy: {
+                                description: '"required" or "dismiss-only"',
+                                type: "string",
+                            },
+                        },
+                        type: "object",
+                    },
+                })
+                    .build(),
+            ]
+            : [])), false), (0, api_1.asyncHandler)(function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                requireAdmin(req.user);
+                return [2 /*return*/, res.json({ data: { defaultAcknowledgementPolicy: defaultAcknowledgementPolicy } })];
+            });
+        }); }));
+        adminRouter.get("/overview", __spreadArray([
+            (0, api_1.authenticateMiddleware)()
+        ], __read((routeOpenApi
+            ? [
+                (0, api_1.createOpenApiBuilder)(routeOpenApi)
+                    .withTags(["announcements"])
+                    .withSummary("Admin overview of announcements with aggregate metrics")
+                    .withQueryParameter("page", { type: "number" }, { required: false })
+                    .withQueryParameter("limit", { type: "number" }, { required: false })
+                    .withResponse(200, {
+                    data: {
+                        items: {
+                            properties: {
+                                _id: { type: "string" },
+                                acknowledgementPolicy: { type: "string" },
+                                audienceType: { type: "string" },
+                                displayMode: { type: "string" },
+                                expiresAt: { type: "string" },
+                                metrics: {
+                                    properties: {
+                                        acknowledgements: { type: "number" },
+                                        clicks: { type: "number" },
+                                        impressions: { type: "number" },
+                                    },
+                                    type: "object",
+                                },
+                                priority: { type: "number" },
+                                publishedAt: { type: "string" },
+                                status: { type: "string" },
+                                title: { type: "string" },
+                                version: { type: "number" },
+                            },
+                            type: "object",
+                        },
+                        type: "array",
+                    },
+                    limit: { type: "number" },
+                    more: { type: "boolean" },
+                    page: { type: "number" },
+                    total: { type: "number" },
+                    totals: {
+                        properties: {
+                            acknowledgements: { type: "number" },
+                            announcements: { type: "number" },
+                            archived: { type: "number" },
+                            clicks: { type: "number" },
+                            draft: { type: "number" },
+                            impressions: { type: "number" },
+                            published: { type: "number" },
+                        },
+                        type: "object",
+                    },
+                })
+                    .build(),
+            ]
+            : [])), false), (0, api_1.asyncHandler)(function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+            var _a, limit, page, overview;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, requireOverviewAccess({ permissions: overviewPermissions, user: req.user })];
+                    case 1:
+                        _b.sent();
+                        _a = (0, overview_1.parseOverviewPagination)(req.query), limit = _a.limit, page = _a.page;
+                        return [4 /*yield*/, (0, overview_1.fetchAnnouncementOverview)({
+                                defaultAcknowledgementPolicy: defaultAcknowledgementPolicy,
+                                limit: limit,
+                                page: page,
+                            })];
+                    case 2:
+                        overview = _b.sent();
+                        return [2 /*return*/, res.json(overview)];
+                }
+            });
+        }); }));
+        adminRouter.post("/:id/publish", (0, api_1.authenticateMiddleware)(), (0, api_1.asyncHandler)(function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+            var announcement;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        requireAdmin(req.user);
+                        return [4 /*yield*/, announcement_1.Announcement.findById(req.params.id)];
+                    case 1:
+                        announcement = _a.sent();
+                        if (!announcement) {
+                            throw new api_1.APIError({ status: 404, title: "Announcement not found" });
+                        }
+                        if (announcement.status !== "draft") {
+                            throw new api_1.APIError({
+                                status: 400,
+                                title: "Only draft announcements can be published",
+                            });
+                        }
+                        announcement.status = "published";
+                        announcement.publishedAt = luxon_1.DateTime.utc().toJSDate();
+                        return [4 /*yield*/, announcement.save()];
+                    case 2:
+                        _a.sent();
+                        api_1.logger.info("Announcement published", { announcementId: announcement._id.toString() });
+                        return [2 /*return*/, res.json({ data: announcement })];
+                }
+            });
+        }); }));
+        adminRouter.post("/:id/archive", (0, api_1.authenticateMiddleware)(), (0, api_1.asyncHandler)(function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+            var announcement;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        requireAdmin(req.user);
+                        return [4 /*yield*/, announcement_1.Announcement.findById(req.params.id)];
+                    case 1:
+                        announcement = _a.sent();
+                        if (!announcement) {
+                            throw new api_1.APIError({ status: 404, title: "Announcement not found" });
+                        }
+                        if (announcement.status !== "published") {
+                            throw new api_1.APIError({
+                                status: 400,
+                                title: "Only published announcements can be archived",
+                            });
+                        }
+                        announcement.status = "archived";
+                        announcement.archivedAt = luxon_1.DateTime.utc().toJSDate();
+                        return [4 /*yield*/, announcement.save()];
+                    case 2:
+                        _a.sent();
+                        api_1.logger.info("Announcement archived", { announcementId: announcement._id.toString() });
+                        return [2 /*return*/, res.json({ data: announcement })];
+                }
+            });
+        }); }));
+        app.use(basePath, userRouter);
+        app.use(basePath, adminRouter);
+        if ((_f = this.options.help) === null || _f === void 0 ? void 0 : _f.enabled) {
+            (0, helpRoutes_1.registerAnnouncementHelpRoutes)({
+                app: app,
+                basePath: basePath,
+                defaultAcknowledgementPolicy: defaultAcknowledgementPolicy,
+                isStaff: isStaff,
+                matchAudience: matchAudience,
+            });
+        }
+        app.use(basePath, (0, api_1.modelRouter)(announcement_1.Announcement, routerOptions));
+        app.use("/announcement-acknowledgements", (0, api_1.modelRouter)(announcementAcknowledgement_1.AnnouncementAcknowledgement, {
+            permissions: {
+                create: [],
+                delete: [],
+                list: [api_1.Permissions.IsAdmin],
+                read: [api_1.Permissions.IsAdmin],
+                update: [],
+            },
+            populatePaths: [
+                { fields: ["title", "version", "status"], path: "announcementId" },
+                { fields: ["email", "name"], path: "userId" },
+            ],
+        }));
+        app.use("/announcement-impressions", (0, api_1.modelRouter)(announcementImpression_1.AnnouncementImpression, {
+            permissions: {
+                create: [],
+                delete: [],
+                list: [api_1.Permissions.IsAdmin],
+                read: [api_1.Permissions.IsAdmin],
+                update: [],
+            },
+            populatePaths: [
+                { fields: ["title", "version", "status"], path: "announcementId" },
+                { fields: ["email", "name"], path: "userId" },
+            ],
+        }));
+        app.use("/announcement-click-events", (0, api_1.modelRouter)(announcementClickEvent_1.AnnouncementClickEvent, {
+            permissions: {
+                create: [],
+                delete: [],
+                list: [api_1.Permissions.IsAdmin],
+                read: [api_1.Permissions.IsAdmin],
+                update: [],
+            },
+            populatePaths: [
+                { fields: ["title", "version", "status"], path: "announcementId" },
+                { fields: ["email", "name"], path: "userId" },
+            ],
+        }));
+        api_1.logger.info("AnnouncementsApp registered", { basePath: basePath, defaultAcknowledgementPolicy: defaultAcknowledgementPolicy });
+    };
+    return AnnouncementsApp;
+}());
+exports.AnnouncementsApp = AnnouncementsApp;