@genesislcap/pbc-notify-ui 1.0.0

package/dist/esm/services/alert.service.js

@@ -0,0 +1,30 @@
+import { __awaiter, __decorate, __param } from "tslib";
+import { DI } from '@microsoft/fast-foundation';
+import { Connect } from '@genesislcap/foundation-comms';
+let AlertServiceImpl = class AlertServiceImpl {
+    constructor(connect) {
+        this.connect = connect;
+    }
+    getAlerts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let alerts = [];
+            yield this.connect.request('REQ_NOTIFY_ALERT', { REQUEST: true }).then(data => {
+                alerts = data.REPLY;
+            });
+            return alerts;
+        });
+    }
+    dismissNotifyAlert(alertId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.connect.commitEvent('EVENT_DISMISS_NOTIFY_ALERT', {
+                DETAILS: {
+                    ALERT_ID: alertId,
+                },
+            });
+        });
+    }
+};
+AlertServiceImpl = __decorate([
+    __param(0, Connect)
+], AlertServiceImpl);
+export const AlertService = DI.createInterface(x => x.singleton(AlertServiceImpl));

package/dist/esm/services/notify.service.js

@@ -0,0 +1,18 @@
+import { __awaiter, __decorate } from "tslib";
+import { Connect } from '@genesislcap/foundation-comms';
+import { DI } from '@microsoft/fast-foundation';
+class NotifyServiceImpl {
+    getNotifyRouteTopics() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.connect.request('REQ_NOTIFY_ROUTE_TOPICS', { REQUEST: { NOTIFY_ROUTE_ID: '' } });
+            if (!response.REPLY) {
+                return [];
+            }
+            return response.REPLY[0].TOPICS;
+        });
+    }
+}
+__decorate([
+    Connect
+], NotifyServiceImpl.prototype, "connect", void 0);
+export const NotifyService = DI.createInterface(x => x.singleton(NotifyServiceImpl));

package/dist/esm/services/rule-template.service.js

@@ -0,0 +1,64 @@
+import { __awaiter, __decorate, __param } from "tslib";
+import { Connect } from '@genesislcap/foundation-comms';
+import { DI } from '@microsoft/fast-foundation';
+let RuleTemplateServiceImpl = class RuleTemplateServiceImpl {
+    constructor(connect) {
+        this.connect = connect;
+    }
+    createRuleTemplate(ruleTemplate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.connect.commitEvent('EVENT_NOTIFICATION_RULE_TEMPLATE_CREATE', {
+                DETAILS: ruleTemplate,
+                IGNORE_WARNINGS: true,
+                VALIDATE: false,
+            });
+        });
+    }
+    editRuleTemplate(ruleTemplate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.connect.commitEvent('EVENT_NOTIFICATION_RULE_TEMPLATE_UPDATE', {
+                DETAILS: ruleTemplate,
+                IGNORE_WARNINGS: true,
+                VALIDATE: false,
+            });
+        });
+    }
+    getRuleTemplates() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let ruleTemplates = [];
+            yield this.connect.request('REQ_NOTIFICATION_RULE_TEMPLATE', { REQUEST: true }).then(data => {
+                ruleTemplates = data.REPLY;
+            });
+            return ruleTemplates;
+        });
+    }
+    getRuleTemplateDetails(dynamicRuleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let ruleTemplateDetails = {};
+            yield this.connect.request('REQ_NOTIFICATION_RULE_TEMPLATE_DETAILS', {
+                REQUEST: {
+                    ID: dynamicRuleId
+                }
+            }).then(data => {
+                if (!data.REPLY) {
+                    return;
+                }
+                ruleTemplateDetails = data.REPLY[0];
+            });
+            return ruleTemplateDetails;
+        });
+    }
+    deleteRuleTemplate(dynamicRuleId) {
+        return this.connect.commitEvent('EVENT_NOTIFICATION_RULE_TEMPLATE_DELETE', {
+            DETAILS: {
+                ID: dynamicRuleId
+            },
+            IGNORE_WARNINGS: true,
+            VALIDATE: false,
+        });
+    }
+};
+RuleTemplateServiceImpl = __decorate([
+    __param(0, Connect)
+], RuleTemplateServiceImpl);
+export const RuleTemplateService = DI.createInterface(x => x.singleton(RuleTemplateServiceImpl));

package/dist/esm/services/rule.service.js

@@ -0,0 +1,109 @@
+import { __awaiter, __decorate } from "tslib";
+import { Connect } from '@genesislcap/foundation-comms';
+import { DI } from '@microsoft/fast-foundation';
+class RuleServiceImpl {
+    getRules() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.connect.request('REQ_NOTIFICATION_RULE', { REQUEST: true });
+            return response.REPLY;
+        });
+    }
+    getRuleDetails(ruleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.connect.request('REQ_NOTIFICATION_RULE_DETAILS', {
+                REQUEST: {
+                    ID: ruleId
+                }
+            });
+            if (!response.REPLY) {
+                return;
+            }
+            return response.REPLY[0];
+        });
+    }
+    createRule(rule) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.connect.commitEvent('EVENT_NOTIFICATION_RULE_CREATE', {
+                DETAILS: rule,
+                IGNORE_WARNINGS: true,
+                VALIDATE: false,
+            });
+        });
+    }
+    updateRule(rule) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.connect.commitEvent('EVENT_NOTIFICATION_RULE_UPDATE', {
+                DETAILS: rule,
+                IGNORE_WARNINGS: true,
+                VALIDATE: false,
+            });
+        });
+    }
+    deleteRule(ruleId) {
+        this.connect.commitEvent('EVENT_NOTIFICATION_RULE_DELETE', {
+            DETAILS: {
+                ID: ruleId
+            },
+            IGNORE_WARNINGS: true,
+            VALIDATE: false,
+        });
+    }
+    subscribeRule(dynamicRuleId, parameterDetails) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!dynamicRuleId) {
+                console.error('Invalid dynamicRuleId');
+                return;
+            }
+            return yield this.connect.commitEvent('EVENT_NOTIFICATION_RULE_SUBSCRIBE', {
+                DETAILS: {
+                    DYNAMIC_RULE_ID: dynamicRuleId,
+                    PARAMETER_DETAILS: parameterDetails
+                },
+                IGNORE_WARNINGS: true,
+                VALIDATE: false,
+            });
+        });
+    }
+    unsubscribeRule(dynamicRuleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!dynamicRuleId) {
+                console.error('Invalid dynamicRuleId');
+                return;
+            }
+            return yield this.connect.commitEvent('EVENT_NOTIFICATION_RULE_UNSUBSCRIBE', this.createDynamicRuleIDParams(dynamicRuleId));
+        });
+    }
+    enableRule(dynamicRuleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!dynamicRuleId) {
+                console.error('Invalid dynamicRuleId');
+                return;
+            }
+            return yield this.connect.commitEvent('EVENT_NOTIFICATION_RULE_ENABLE', this.createDynamicRuleIDParams(dynamicRuleId));
+        });
+    }
+    disableRule(dynamicRuleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!dynamicRuleId) {
+                console.error('Invalid dynamicRuleId');
+                return;
+            }
+            return yield this.connect.commitEvent('EVENT_NOTIFICATION_RULE_DISABLE', this.createDynamicRuleIDParams(dynamicRuleId)).then((data) => {
+                console.log(data);
+            });
+        });
+    }
+    createDynamicRuleIDParams(dynamicRuleId) {
+        return {
+            DETAILS: {
+                ID: dynamicRuleId,
+            },
+            IGNORE_WARNINGS: true,
+            VALIDATE: false,
+        };
+    }
+}
+__decorate([
+    Connect
+], RuleServiceImpl.prototype, "connect", void 0);
+export const RuleService = DI.createInterface(x => x.singleton(RuleServiceImpl));

package/dist/esm/services/system.service.js

@@ -0,0 +1,28 @@
+import { __awaiter, __decorate } from "tslib";
+import { Connect } from '@genesislcap/foundation-comms';
+import { DI } from '@microsoft/fast-foundation';
+class SystemServiceImpl {
+    getResources() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.connect.request('SYSTEM_TABLES');
+            return response.REPLY.map(table => table.TABLE_NAME).sort();
+        });
+    }
+    getFields(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!resource) {
+                return [];
+            }
+            const response = yield this.connect.request('SYSTEM_TABLE_FIELDS', {
+                REQUEST: {
+                    TABLE_NAME: resource
+                }
+            });
+            return response.REPLY.sort((a, b) => a.FIELD_NAME.localeCompare(b.FIELD_NAME));
+        });
+    }
+}
+__decorate([
+    Connect
+], SystemServiceImpl.prototype, "connect", void 0);
+export const SystemService = DI.createInterface(x => x.singleton(SystemServiceImpl));

package/dist/esm/styles/index.js

@@ -0,0 +1 @@
+export * from './styles';

package/dist/esm/styles/styles.js

@@ -0,0 +1,13 @@
+import { css } from '@microsoft/fast-element';
+export const mixinScreen = (display = 'block') => `
+  contain: content;
+  display: ${display};
+  height: 100%;
+  width: 100%;
+  overflow-y: auto;
+`;
+export const notificationDashboardStyles = css `
+  :host {
+    display: flex;
+  }
+`;

package/dist/esm/utils/index.js

@@ -0,0 +1 @@
+export * from './logger';

package/dist/esm/utils/logger.js

@@ -0,0 +1,2 @@
+import { createLogger } from '@genesislcap/foundation-logger';
+export const logger = createLogger('foundation-notification-dashboard');

package/index.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8"/>
+    <title>{{htmlWebpackPlugin.options.title}}</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+</head>
+<style>
+    html,
+    body {
+        width: 100%;
+        height: 100%;
+        padding: 0;
+        margin: 0;
+    }
+    :not(:defined) {
+        visibility: hidden;
+    }
+</style>
+<body>
+<foundation-notify></foundation-notify>
+{{#if insertEntryPoint}}
+<script type="module" src="/src/index.ts"></script>
+{{/if}}
+</body>
+</html>

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@genesislcap/pbc-notify-ui",
+  "description": "Genesis PBC Notify UI",
+  "version": "1.0.0",
+  "license": "SEE LICENSE IN license.txt",
+  "main": "dist/esm/index.js",
+  "types": "dist/foundation-notify.d.ts",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "config": {
+    "PORT": 5070
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/foundation-notify.d.ts",
+      "default": "./dist/esm/index.js"
+    },
+    "./e2e": {
+      "default": "./test/e2e/index.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "e2e": [
+        "./test/e2e/index.ts"
+      ]
+    }
+  },
+  "scripts": {
+    "bootstrap": "npm install --no-fund --no-audit",
+    "bootstrap:ci": "npm ci --no-fund --no-audit",
+    "build": "genx build -b ts",
+    "build:webpack": "genx build",
+    "build:webpack:stats": "genx analyze",
+    "clean": "rimraf dist tsconfig.tsbuildinfo",
+    "dev": "genx dev -e API_HOST",
+    "dev:docker": "npm run dev -- --host 0.0.0.0",
+    "dev:intellij": "genx dev -e",
+    "dev:no-open": "npm run dev -- --no-open",
+    "dev:https": "npm run dev -- --https",
+    "dev:webpack": "npm run dev -- -b webpack",
+    "serve": "genx serve",
+    "test": "genx test",
+    "test:coverage": "genx test --coverage",
+    "test:coverage:browser": "genx test --coverage --browser",
+    "test:e2e": "genx test --e2e",
+    "test:e2e:debug": "genx test --e2e --debug",
+    "test:e2e:ui": "genx test --e2e --interactive",
+    "test:unit:browser": "genx test --browser",
+    "test:unit:browser:watch": "genx test --browser --watch",
+    "test:unit:watch": "genx test --watch",
+    "test:debug": "genx test --debug"
+  },
+  "devDependencies": {
+    "@genesislcap/foundation-testing": "~14",
+    "@genesislcap/genx": "~14",
+    "playwright-lighthouse": "^3.1.0",
+    "rimraf": "^3.0.2",
+    "tslib": "^2.3.1"
+  },
+  "peerDependencies": {
+    "@genesislcap/foundation-entity-management": "~14",
+    "@genesislcap/foundation-layout": "~14",
+    "@genesislcap/foundation-logger": "~14",
+    "@genesislcap/foundation-ui": "~14",
+    "@genesislcap/foundation-zero": "~14",
+    "@genesislcap/foundation-comms": "~14",
+    "@microsoft/fast-components": "^2.21.3",
+    "@microsoft/fast-element": "^1.7.0",
+    "@microsoft/fast-foundation": "^2.33.2",
+    "@microsoft/fast-router": "^0.4.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "customElements": "dist/custom-elements.json"
+}