@genesislcap/foundation-entity-management 11.3.0

package/dist/esm/profiles/profiles.js

@@ -0,0 +1,88 @@
+import { __awaiter, __decorate } from "tslib";
+import { Auth } from '@genesislcap/foundation-comms';
+import { customElement } from '@microsoft/fast-element';
+import { EntityManagement, styles, template } from '../entities';
+import { editProfileFormSchema } from './editProfileSchema';
+/**
+ * Main class which defined the profile management functionality
+ *
+ * @remarks
+ *
+ * Under the hood the profile-management is the entity-management micro-frontend configured for use
+ * with the `ALL_PROFILES` resource.
+ *
+ * @public
+ *
+ * @example
+ *
+ * You can use this class by forward declaring it in the template file where it is used, and then using
+ * it in a html template. It is recommended to wrap it in an error boundary.
+ * ```javascript
+ * <profile-management></profile-management>
+ * ```
+ *
+ */
+let Profiles = class Profiles extends EntityManagement {
+    /**
+     * Constructor will set the {@link EntityManagement.createEvent} {@link EntityManagement.deleteEvent} {@link EntityManagement.updateEvent} to match the permissions set from the server
+     */
+    constructor() {
+        super();
+        this.createEvent = this.auth.currentUser.hasPermission('INSERT_PROFILE')
+            ? 'EVENT_INSERT_PROFILE'
+            : '';
+        this.deleteEvent = this.auth.currentUser.hasPermission('DELETE_PROFILE')
+            ? 'EVENT_DELETE_PROFILE'
+            : '';
+        this.updateEvent = this.auth.currentUser.hasPermission('AMEND_PROFILE')
+            ? 'EVENT_AMEND_PROFILE'
+            : '';
+        this.persistColumnStateKey = 'entity_profiles_management';
+        this.updateFormUiSchema = editProfileFormSchema;
+        this.createFormUiSchema = editProfileFormSchema;
+        this.readEventFn = this.readProfileData.bind(this);
+        this.resourceName = 'ALL_PROFILES';
+        this.title = 'Profile Management';
+        this.entityLabel = 'Profile';
+    }
+    readProfileData(profile) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const selectedRightsReq = yield this.connect.request('PROFILE_RIGHT', {
+                REQUEST: {
+                    PROFILE_NAME: profile.PROFILE_NAME,
+                    RIGHT_CODE: '*',
+                },
+            });
+            const selectedUsersReq = yield this.connect.request('PROFILE_USER', {
+                REQUEST: {
+                    PROFILE_NAME: profile.PROFILE_NAME,
+                    USER_NAME: '*',
+                },
+            });
+            return {
+                RIGHT_CODES: selectedRightsReq.REPLY.map((v) => v.RIGHT_CODE),
+                USER_NAMES: Array.from(new Set(selectedUsersReq.REPLY.map((v) => v.USER_NAME))),
+                NAME: profile.PROFILE_NAME,
+            };
+        });
+    }
+    deleteEntity(e) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deleteReq = yield this.connect.commitEvent(this.deleteEvent, {
+                DETAILS: { NAME: e.detail.PROFILE_NAME },
+            });
+            this.errorNotify(deleteReq);
+        });
+    }
+};
+__decorate([
+    Auth
+], Profiles.prototype, "auth", void 0);
+Profiles = __decorate([
+    customElement({
+        name: 'profile-management',
+        template,
+        styles,
+    })
+], Profiles);
+export { Profiles };

package/dist/esm/types.js

@@ -0,0 +1,3 @@
+import { DI } from '@microsoft/fast-foundation';
+export const RESOURCE_NAME = DI.createInterface('resourceName');
+export const ENTITY_NAME = DI.createInterface('entityName');

package/dist/esm/users/users.js

@@ -0,0 +1,302 @@
+import { __awaiter, __decorate } from "tslib";
+import { Auth, Connect } from '@genesislcap/foundation-comms';
+import { ErrorBoundaryEvent, getErrorBuilder, getNotificationBuilder, } from '@genesislcap/foundation-errors';
+import { LifecycleMixin } from '@genesislcap/foundation-utils';
+import { GridProRendererTypes } from '@genesislcap/grid-pro';
+import { attr, css, customElement, FASTElement, observable } from '@microsoft/fast-element';
+import { logger } from '../entities';
+import { getErrorFormat } from '../utils';
+import { UsersTemplate } from './users.template';
+const defaultColumnConfig = {
+    enableCellChangeFlash: true,
+    enableRowGroup: false,
+    enablePivot: true,
+    enableValue: true,
+};
+/**
+ * Defines the default columns which are present on the user management component
+ *
+ * @remarks
+ *
+ * This is exported so you can override and mix-in custom columns along with the default
+ * @public
+ */
+export const UsersColumnConfig = [
+    Object.assign(Object.assign({}, defaultColumnConfig), { field: 'USER_NAME', headerName: 'Username' }),
+    Object.assign(Object.assign({}, defaultColumnConfig), { field: 'FIRST_NAME', headerName: 'First Name' }),
+    Object.assign(Object.assign({}, defaultColumnConfig), { field: 'LAST_NAME', headerName: 'Last Name' }),
+    Object.assign(Object.assign({}, defaultColumnConfig), { field: 'EMAIL_ADDRESS', headerName: 'Email' }),
+    Object.assign(Object.assign({}, defaultColumnConfig), { field: 'LAST_LOGIN', headerName: 'Last Login', valueFormatter: ({ value }) => value
+            ? new Intl.DateTimeFormat('default', {
+                year: 'numeric',
+                month: 'numeric',
+                day: 'numeric',
+                hour: 'numeric',
+                minute: 'numeric',
+            }).format(value)
+            : '' }),
+];
+/**
+ * Main class which defines the user management functionality
+ *
+ * @remarks
+ *
+ * Under the hood the user-management is the entity-management micro-frontend configured for use
+ * with the `ALL_USERS` resource.
+ *
+ * @public
+ *
+ * @example
+ *
+ * With no customisation required the user management micro-frontend can simply be dropped into the
+ * template as shown. However, it is advised to wrap it in an error boundary component.
+ * ```javascript
+ * <user-management></user-management>
+ * ```
+ * With this default example above the columns will be the {@link UsersColumnConfig} as well as the
+ * entity and status columns. The entity and status
+ * columns are always added regardless of the other columns which are configured.
+ *
+ * You can add in additional customisation options. For example you can define a custom column and
+ * then mix-in with the standard columns
+ * ```javascript
+ * import { Users, UsersColumnConfig, } from '@genesislcap/foundation-entity-management';
+ *
+ * const userColumns = [
+ *   {
+ *     field: 'ACCESS_TYPE',
+ *     headerName: 'Access Type',
+ *   },
+ * ];
+ *
+ * // Definition inside of the html template
+ * <user-management :columns=${() => [...UsersColumnConfig, ...userColumns]}></user-management>
+ * ```
+ */
+let Users = class Users extends LifecycleMixin(FASTElement) {
+    /**
+     * Returns a configuration for an optional status column
+     *
+     * @returns Column configuration for an optional status column
+     * @internal
+     */
+    statusColumn() {
+        return Object.assign(Object.assign({}, defaultColumnConfig), { headerName: 'Status', field: 'STATUS', minWidth: 135, width: 135, suppressSizeToFit: true, cellRendererSelector: this.statusRendererSelector.bind(this) });
+    }
+    /**
+     * Returns the config for an entity column if the entityID attribute is defined
+     *
+     * @returns Config for an entity column if the entityID is defined, else an empty array
+     * @internal
+     */
+    entityColumn() {
+        return this.entityID
+            ? [
+                Object.assign(Object.assign({}, defaultColumnConfig), { headerName: this.entityLabel, field: this.entityID }),
+            ]
+            : [];
+    }
+    /**
+     * Constructor will set the {@link Users.createEvent} {@link Users.deleteEvent} {@link Users.updateEvent} to match the permissions set from the server
+     */
+    constructor() {
+        super();
+        /**
+         * Configuring the resourceName from the entity-management, set to manage the users resource specifically
+         * @internal
+         */
+        this.resourceName = 'ALL_USERS';
+        /**
+         * Column definition, default to the UsersColumnConfig
+         */
+        this.columns = UsersColumnConfig;
+        this.additionalCreateFields = [];
+        this.additionalUpdateFields = [];
+        /**
+         * entityID used to control the definition of an optional entity column which is created with the {@link Users.entityColumn} function.
+         * @internal
+         */
+        this.entityID = 'COUNTERPARTY_ID';
+        /**
+         * entityID used to display label from the selector of entityID {@link Users.entityColumn} function.
+         * @internal
+         */
+        this.entityLabelKey = 'NAME';
+        /**
+         * entityID used to control the definition of an optional entity column which is created with the {@link Users.entityColumn} function.
+         * @internal
+         */
+        this.entityLabel = 'Counterparty';
+        /**
+         * Definition of the `DATASERVER` query which is used when managing Counterpartys
+         * @internal
+         */
+        this.availableEntitiesEndpoint = 'ALL_COUNTERPARTYS';
+        this.createEvent = this.auth.currentUser.hasPermission('INSERT_USER')
+            ? 'EVENT_INSERT_USER'
+            : '';
+        this.deleteEvent = this.auth.currentUser.hasPermission('DELETE_USER')
+            ? 'EVENT_DELETE_USER'
+            : '';
+        this.updateEvent = this.auth.currentUser.hasPermission('AMEND_USER') ? 'EVENT_AMEND_USER' : '';
+    }
+    connectedCallback() {
+        const _super = Object.create(null, {
+            connectedCallback: { get: () => super.connectedCallback }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.connectedCallback.call(this);
+            // retrieving access type of currently logged-in user
+            const userReq = yield this.connect.snapshot('ALL_USERS', {
+                CRITERIA_MATCH: `USER_NAME == '${this.auth.currentUser.username}'`,
+            });
+            if (userReq.ROW[0]) {
+                this.allAccessType = userReq.ROW[0].ACCESS_TYPE === 'ALL';
+                this.entityIdValue = userReq.ROW[0][this.entityID];
+            }
+        });
+    }
+    deepClone() {
+        const copy = super.deepClone();
+        copy.additionalCreateFields = structuredClone(this.additionalCreateFields);
+        copy.additionalUpdateFields = structuredClone(this.additionalUpdateFields);
+        copy.allAccessType = structuredClone(this.allAccessType);
+        copy.createEvent = structuredClone(this.createEvent);
+        copy.datasourceConfig = structuredClone(this.datasourceConfig);
+        copy.deleteEvent = structuredClone(this.deleteEvent);
+        copy.updateEvent = structuredClone(this.updateEvent);
+        // this.columns[number] might contain a function, so can't use structuredClone
+        copy.columns = this.columns ? [...this.columns].map((x) => (Object.assign({}, x))) : this.columns;
+        return copy;
+    }
+    /**
+     * Used as the callback function in {@link Users.statusColumn}
+     * @internal
+     */
+    statusRendererSelector(params) {
+        return {
+            component: GridProRendererTypes.action,
+            params: {
+                actionClick: () => this.changeStatus(params),
+                actionName: params.value === 'ENABLED' ? 'Deactivate' : 'Activate',
+                appearance: 'secondary-orange',
+            },
+        };
+    }
+    /**
+     * Changes the status of an entity
+     *
+     * @remarks
+     *
+     * The action which is run on the status button from {@link Users.statusRendererSelector}
+     *
+     * @internal
+     */
+    changeStatus(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isEnabled = params.data.STATUS === 'ENABLED';
+            // optimistically set value and store previous value
+            const previousValue = params.data.STATUS;
+            params.setValue(isEnabled ? 'DISABLED' : 'ENABLED');
+            const changeStatusRequest = yield this.connect.commitEvent(isEnabled ? 'EVENT_DISABLE_USER' : 'EVENT_ENABLE_USER', {
+                DETAILS: {
+                    USER_NAME: params.data.USER_NAME,
+                },
+            });
+            if (changeStatusRequest.ERROR) {
+                logger.error(changeStatusRequest.ERROR);
+                const notificationCloseTimeout = 5000;
+                changeStatusRequest.ERROR.forEach((err) => {
+                    this.$emit(ErrorBoundaryEvent.ERROR_BOUNDARY_EVENT, getErrorBuilder()
+                        .withTitle(err.CODE)
+                        .withErrorDetails(getErrorFormat(err))
+                        .withNotification(getNotificationBuilder()
+                        .withType('warning')
+                        .withAutoClose(true)
+                        .withCloseTimeout(notificationCloseTimeout)
+                        .build())
+                        .build());
+                });
+                // bring back original value
+                params.setValue(previousValue);
+            }
+        });
+    }
+    /**
+     * @internal
+     */
+    readUserData(user) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const userProfiles = yield this.connect.request('PROFILE_USER', {
+                REQUEST: {
+                    USER_NAME: user.USER_NAME,
+                },
+            });
+            const defaultValues = !this.allAccessType && ((_a = this.entityIdValue) === null || _a === void 0 ? void 0 : _a.length)
+                ? {
+                    ACCESS_TYPE: 'ENTITY',
+                    [this.entityID]: this.entityIdValue,
+                }
+                : {};
+            return Object.assign(Object.assign({}, defaultValues), { USER_PROFILES: (userProfiles.REPLY || []).map((profile) => profile.PROFILE_NAME), ADDRESS_LINE_1: user.ADDRESS_LINE1, ADDRESS_LINE_2: user.ADDRESS_LINE2, ADDRESS_LINE_3: user.ADDRESS_LINE3, ADDRESS_LINE_4: user.ADDRESS_LINE4 });
+        });
+    }
+};
+__decorate([
+    Connect
+], Users.prototype, "connect", void 0);
+__decorate([
+    Auth
+], Users.prototype, "auth", void 0);
+__decorate([
+    observable
+], Users.prototype, "datasourceConfig", void 0);
+__decorate([
+    attr
+], Users.prototype, "resourceName", void 0);
+__decorate([
+    observable
+], Users.prototype, "columns", void 0);
+__decorate([
+    observable
+], Users.prototype, "additionalCreateFields", void 0);
+__decorate([
+    observable
+], Users.prototype, "additionalUpdateFields", void 0);
+__decorate([
+    observable
+], Users.prototype, "allAccessType", void 0);
+__decorate([
+    observable
+], Users.prototype, "createEvent", void 0);
+__decorate([
+    observable
+], Users.prototype, "deleteEvent", void 0);
+__decorate([
+    observable
+], Users.prototype, "updateEvent", void 0);
+__decorate([
+    attr
+], Users.prototype, "entityID", void 0);
+__decorate([
+    attr
+], Users.prototype, "entityLabelKey", void 0);
+__decorate([
+    attr
+], Users.prototype, "entityLabel", void 0);
+__decorate([
+    attr
+], Users.prototype, "availableEntitiesEndpoint", void 0);
+Users = __decorate([
+    customElement({
+        name: 'user-management',
+        template: UsersTemplate,
+        styles: css `
+    :host {
+      height: 100%;
+    }
+  `,
+    })
+], Users);
+export { Users };

package/dist/esm/users/users.template.js

@@ -0,0 +1,90 @@
+import { html } from '@microsoft/fast-element';
+const conditionalSchemaEntry = (predicate, entry) => {
+    return predicate ? [entry] : [];
+};
+const editUserSchema = (edit, allAccessType, entityID, entityLabel, entityLabelKey, availableEntitiesEndpoint, additionalEntries = []) => ({
+    type: 'VerticalLayout',
+    elements: [
+        {
+            type: 'Control',
+            label: 'Username',
+            scope: '#/properties/USER_NAME',
+            options: {
+                readonly: edit,
+            },
+        },
+        {
+            type: 'Control',
+            label: 'Email',
+            scope: '#/properties/EMAIL_ADDRESS',
+        },
+        {
+            type: 'Control',
+            label: 'First Name',
+            scope: '#/properties/FIRST_NAME',
+        },
+        {
+            type: 'Control',
+            label: 'Last Name',
+            scope: '#/properties/LAST_NAME',
+        },
+        ...conditionalSchemaEntry(!edit, {
+            type: 'Control',
+            label: 'One Time Password',
+            scope: '#/properties/ONE_TIME_PASSWORD',
+        }),
+        {
+            type: 'Control',
+            label: 'User Profiles',
+            scope: '#/properties/USER_PROFILES',
+            options: {
+                allOptionsResourceName: 'ALL_PROFILES',
+                valueField: 'PROFILE_NAME',
+                labelField: 'PROFILE_NAME',
+            },
+        },
+        {
+            type: 'Control',
+            label: 'Access Type',
+            scope: '#/properties/ACCESS_TYPE',
+            options: {
+                hidden: !allAccessType,
+            },
+        },
+        {
+            type: 'Control',
+            scope: `#/properties/${entityID}`,
+            options: {
+                allOptionsResourceName: availableEntitiesEndpoint,
+                valueField: entityID,
+                labelField: entityLabelKey || entityID,
+                hidden: !allAccessType,
+            },
+            label: entityLabel,
+        },
+        ...additionalEntries.map((entry) => typeof entry === 'string'
+            ? {
+                type: 'Control',
+                scope: `#/properties/${entry}`,
+            }
+            : entry),
+    ],
+});
+export const UsersTemplate = html `
+  <entity-management
+    resourceName=${(x) => x.resourceName}
+    title="User Management"
+    entityLabel="User"
+    createEvent="${(x) => x.createEvent}"
+    :readEventFn=${(x) => (user) => x.readUserData(user)}
+    updateEvent="${(x) => x.updateEvent}"
+    deleteEvent="${(x) => x.deleteEvent}"
+    entityLabel="User Details"
+    :updateFormUiSchema=${(x) => editUserSchema(true, x.allAccessType, x.entityID, x.entityLabel, x.entityLabelKey, x.availableEntitiesEndpoint, x.additionalUpdateFields)}
+    :createFormUiSchema=${(x) => editUserSchema(false, x.allAccessType, x.entityID, x.entityLabel, x.entityLabelKey, x.availableEntitiesEndpoint, x.additionalCreateFields)}
+    persist-column-state-key="entity_users_management"
+    size-columns-to-fit
+    :columns=${(x) => [...x.columns, ...x.entityColumn(), x.statusColumn()]}
+    :datasourceConfig=${(x) => x.datasourceConfig}
+  ></entity-management>
+`;

package/dist/esm/utils/formatting.js

@@ -0,0 +1,6 @@
+/**
+ * Format the error as a string with a different format depending on whether
+ * `err` has a `FIELD` property or not
+ * @public
+ */
+export const getErrorFormat = (err) => (err.FIELD ? `${err.FIELD} - ${err.TEXT}` : `${err.TEXT}`);

package/dist/esm/utils/index.js

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