@headless-adminapp/app 0.0.17-alpha.4 → 0.0.17-alpha.40

package/builders/CommandBuilder/FormCommandBuilder.js

@@ -0,0 +1,171 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormCommandBuilder = void 0;
+const utils_1 = require("./utils");
+var EnabledRules;
+(function (EnabledRules) {
+    function HasCreatePermisssion(context) {
+        var _a;
+        return !((_a = context.primaryControl.schema.restrictions) === null || _a === void 0 ? void 0 : _a.disableCreate);
+    }
+    EnabledRules.HasCreatePermisssion = HasCreatePermisssion;
+    function HasUpdatePermission(context) {
+        var _a;
+        return !((_a = context.primaryControl.schema.restrictions) === null || _a === void 0 ? void 0 : _a.disableUpdate);
+    }
+    EnabledRules.HasUpdatePermission = HasUpdatePermission;
+    function HasDeletePermission(context) {
+        var _a;
+        return !((_a = context.primaryControl.schema.restrictions) === null || _a === void 0 ? void 0 : _a.disableDelete);
+    }
+    EnabledRules.HasDeletePermission = HasDeletePermission;
+})(EnabledRules || (EnabledRules = {}));
+var FormCommandBuilder;
+(function (FormCommandBuilder) {
+    function createSaveCommand({ Icon, text, localizedTexts, }) {
+        return {
+            type: 'button',
+            Icon,
+            text,
+            localizedText: localizedTexts,
+            isQuickAction: true,
+            onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                yield context.primaryControl.save('save');
+            }),
+            hidden: [
+                (context) => {
+                    if (context.primaryControl.readonly) {
+                        return true;
+                    }
+                    if (context.primaryControl.recordId) {
+                        return !EnabledRules.HasUpdatePermission(context);
+                    }
+                    else {
+                        return !EnabledRules.HasCreatePermisssion(context);
+                    }
+                },
+            ],
+        };
+    }
+    FormCommandBuilder.createSaveCommand = createSaveCommand;
+    function createSaveAndCloseCommand({ Icon, text, localizedTexts, }) {
+        return {
+            type: 'button',
+            Icon,
+            text,
+            localizedText: localizedTexts,
+            onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                yield context.primaryControl.save('saveandclose');
+            }),
+            hidden: [
+                (context) => {
+                    if (context.primaryControl.readonly) {
+                        return true;
+                    }
+                    if (context.primaryControl.recordId) {
+                        return !EnabledRules.HasUpdatePermission(context);
+                    }
+                    else {
+                        return !EnabledRules.HasCreatePermisssion(context);
+                    }
+                },
+            ],
+        };
+    }
+    FormCommandBuilder.createSaveAndCloseCommand = createSaveAndCloseCommand;
+    FormCommandBuilder.defaultDeleteRecordStringSet = {
+        confirmation: {
+            text: 'Are you sure you want to delete this record?',
+            title: 'Delete record',
+            buttonConfirm: 'Delete',
+            buttonCancel: 'Cancel',
+        },
+        status: {
+            deleting: 'Deleting record',
+        },
+        successNotification: {
+            title: 'Record deleted',
+            text: 'Record deleted successfully',
+        },
+        errorNotification: {
+            title: 'Error',
+        },
+    };
+    function createDeleteCommand({ Icon, text, localizedTexts, stringSet, localizedStringSet, }) {
+        return {
+            Icon: Icon,
+            type: 'button',
+            text,
+            localizedText: localizedTexts,
+            danger: true,
+            hidden: (context) => {
+                if (!context.primaryControl.recordId) {
+                    return true;
+                }
+                return !EnabledRules.HasDeletePermission(context);
+            },
+            onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                const recordId = context.primaryControl.recordId;
+                if (!recordId) {
+                    return;
+                }
+                // if (typeof stringSet === 'function') {
+                //   stringSet = stringSet(context);
+                // }
+                const localizeSelector = (0, utils_1.createLocalizedSelector)(stringSet, localizedStringSet, context.locale.language);
+                try {
+                    const confirmResult = yield context.utility.openConfirmDialog({
+                        title: (0, utils_1.plurialize)(1, localizeSelector((s) => s.confirmation.title)),
+                        text: (0, utils_1.plurialize)(1, localizeSelector((s) => s.confirmation.text)),
+                        cancelButtonLabel: stringSet.confirmation.buttonCancel,
+                        confirmButtonLabel: stringSet.confirmation.buttonConfirm,
+                    });
+                    if (!(confirmResult === null || confirmResult === void 0 ? void 0 : confirmResult.confirmed)) {
+                        return;
+                    }
+                    context.utility.showProgressIndicator((0, utils_1.plurialize)(1, localizeSelector((s) => s.status.deleting)) + '...');
+                    yield context.dataService.deleteRecord(context.primaryControl.logicalName, recordId);
+                    context.utility.showNotification({
+                        title: (0, utils_1.plurialize)(1, localizeSelector((s) => s.successNotification.title)),
+                        text: (0, utils_1.plurialize)(1, localizeSelector((s) => s.successNotification.text)),
+                        type: 'success',
+                    });
+                    context.primaryControl.close();
+                }
+                catch (error) {
+                    context.utility.showNotification({
+                        title: stringSet.errorNotification.title,
+                        text: error.message,
+                        type: 'error',
+                    });
+                }
+                finally {
+                    context.utility.hideProgressIndicator();
+                }
+            }),
+        };
+    }
+    FormCommandBuilder.createDeleteCommand = createDeleteCommand;
+    function createRefreshCommand({ Icon, text, localizedTexts, }) {
+        return {
+            Icon,
+            type: 'button',
+            text,
+            localizedText: localizedTexts,
+            onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                yield context.primaryControl.refresh();
+            }),
+            hidden: (context) => !context.primaryControl.recordId,
+        };
+    }
+    FormCommandBuilder.createRefreshCommand = createRefreshCommand;
+})(FormCommandBuilder || (exports.FormCommandBuilder = FormCommandBuilder = {}));

package/builders/CommandBuilder/SubgridCommandBuilder.d.ts

@@ -0,0 +1,45 @@
+import { SubGridCommandItemExperience } from '@headless-adminapp/core/experience/view';
+import { Localized } from '@headless-adminapp/core/types';
+import { Icon } from '@headless-adminapp/icons';
+import { ViewCommandBuilder } from './ViewCommandBuilder';
+export declare namespace SubgridCommandBuilder {
+    function createNewRecordCommand({ Icon, text, localizedTexts, }: {
+        Icon: Icon;
+        text: string;
+        localizedTexts?: Record<string, string>;
+    }): SubGridCommandItemExperience;
+    function createEditRecordCommand({ Icon, text, localizedTexts, }: {
+        Icon: Icon;
+        text: string;
+        localizedTexts?: Record<string, string>;
+    }): SubGridCommandItemExperience;
+    function createDeleteRecordCommand({ Icon, localizedText, text, stringSet, localizedStringSet, }: {
+        Icon: Icon;
+        text: string;
+        localizedText?: Record<string, string>;
+        stringSet?: ViewCommandBuilder.DeleteRecordCommandStringSet;
+        localizedStringSet?: Localized<ViewCommandBuilder.DeleteRecordCommandStringSet>;
+    }): SubGridCommandItemExperience;
+    function createRefreshCommand({ Icon, localizedTexts, text, }: {
+        Icon: Icon;
+        text: string;
+        localizedTexts?: Record<string, string>;
+    }): SubGridCommandItemExperience;
+    function createExportCommand({ button, csv, excel, }: {
+        button: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        };
+        excel: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        };
+        csv: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        };
+    }): SubGridCommandItemExperience;
+}

package/builders/CommandBuilder/SubgridCommandBuilder.js

@@ -0,0 +1,240 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubgridCommandBuilder = void 0;
+const utils_1 = require("../utils");
+const utils_2 = require("./utils");
+const ViewCommandBuilder_1 = require("./ViewCommandBuilder");
+var EnabledRules;
+(function (EnabledRules) {
+    function HasCreatePermisssion(context) {
+        var _a;
+        return !((_a = context.secondaryControl.schema.restrictions) === null || _a === void 0 ? void 0 : _a.disableCreate);
+    }
+    EnabledRules.HasCreatePermisssion = HasCreatePermisssion;
+    function HasUpdatePermission(context) {
+        var _a;
+        return !((_a = context.secondaryControl.schema.restrictions) === null || _a === void 0 ? void 0 : _a.disableUpdate);
+    }
+    EnabledRules.HasUpdatePermission = HasUpdatePermission;
+    function HasDeletePermission(context) {
+        var _a;
+        return !((_a = context.secondaryControl.schema.restrictions) === null || _a === void 0 ? void 0 : _a.disableDelete);
+    }
+    EnabledRules.HasDeletePermission = HasDeletePermission;
+    function HasSingleRecordSelected(context) {
+        return context.secondaryControl.selectedIds.length === 1;
+    }
+    EnabledRules.HasSingleRecordSelected = HasSingleRecordSelected;
+    function HasAtLeastOneRecordSelected(context) {
+        return context.secondaryControl.selectedIds.length > 0;
+    }
+    EnabledRules.HasAtLeastOneRecordSelected = HasAtLeastOneRecordSelected;
+})(EnabledRules || (EnabledRules = {}));
+var SubgridCommandBuilder;
+(function (SubgridCommandBuilder) {
+    function createNewRecordCommand({ Icon, text, localizedTexts, }) {
+        return {
+            type: 'button',
+            Icon,
+            text,
+            localizedText: localizedTexts,
+            onClick: (context) => {
+                if (context.secondaryControl.associated) {
+                    context.navigation.openForm({
+                        logicalName: context.secondaryControl.schema.logicalName,
+                        parameters: {
+                            [context.secondaryControl.associated.refAttributeName]: {
+                                id: context.secondaryControl.associated.id,
+                                logicalName: context.secondaryControl.associated.logicalName,
+                                name: context.secondaryControl.associated.name,
+                            },
+                        },
+                    });
+                }
+                else {
+                    context.navigation.openForm({
+                        logicalName: context.secondaryControl.schema.logicalName,
+                    });
+                }
+            },
+            hidden: (context) => !EnabledRules.HasCreatePermisssion(context),
+        };
+    }
+    SubgridCommandBuilder.createNewRecordCommand = createNewRecordCommand;
+    function createEditRecordCommand({ Icon, text, localizedTexts, }) {
+        return {
+            type: 'button',
+            Icon,
+            text,
+            localizedText: localizedTexts,
+            isContextMenu: true,
+            onClick: (context) => {
+                context.secondaryControl.openRecord(context.secondaryControl.selectedIds[0]);
+            },
+            hidden: [(context) => !EnabledRules.HasSingleRecordSelected(context)],
+        };
+    }
+    SubgridCommandBuilder.createEditRecordCommand = createEditRecordCommand;
+    function plurialize(count, singular, plural) {
+        if (Array.isArray(singular)) {
+            plural = singular[1];
+            singular = singular[0];
+        }
+        let msg = count === 1 ? singular : plural !== null && plural !== void 0 ? plural : singular;
+        msg = msg.replace('{count}', count.toString());
+        return msg;
+    }
+    function createDeleteRecordCommand({ Icon, localizedText, text, stringSet = ViewCommandBuilder_1.ViewCommandBuilder.defaultDeleteRecordStringSet, localizedStringSet, }) {
+        return {
+            type: 'button',
+            Icon,
+            text,
+            localizedText,
+            danger: true,
+            isContextMenu: true,
+            onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                const recordIds = context.secondaryControl.selectedIds;
+                if (!recordIds.length) {
+                    return;
+                }
+                const localizeSelector = (0, utils_2.createLocalizedSelector)(stringSet, localizedStringSet, context.locale.language);
+                try {
+                    const confirmResult = yield context.utility.openConfirmDialog({
+                        title: plurialize(recordIds.length, localizeSelector((s) => s.confirmation.title)),
+                        text: plurialize(recordIds.length, localizeSelector((s) => s.confirmation.text)),
+                        cancelButtonLabel: localizeSelector((s) => s.confirmation.buttonCancel),
+                        confirmButtonLabel: localizeSelector((s) => s.confirmation.buttonConfirm),
+                    });
+                    if (!(confirmResult === null || confirmResult === void 0 ? void 0 : confirmResult.confirmed)) {
+                        return;
+                    }
+                    context.utility.showProgressIndicator(plurialize(recordIds.length, localizeSelector((s) => s.status.deleting)) + '...');
+                    for (const recordId of recordIds) {
+                        yield context.dataService.deleteRecord(context.secondaryControl.logicalName, recordId);
+                    }
+                    context.utility.showNotification({
+                        title: plurialize(recordIds.length, localizeSelector((s) => s.successNotification.title)),
+                        text: plurialize(recordIds.length, localizeSelector((s) => s.successNotification.text)),
+                        type: 'success',
+                    });
+                    context.secondaryControl.refresh();
+                }
+                catch (error) {
+                    context.utility.showNotification({
+                        title: localizeSelector((s) => s.errorNotification.title),
+                        text: error.message,
+                        type: 'error',
+                    });
+                }
+                finally {
+                    context.utility.hideProgressIndicator();
+                }
+            }),
+            hidden: [
+                (context) => !EnabledRules.HasAtLeastOneRecordSelected(context),
+                (context) => !EnabledRules.HasDeletePermission(context),
+            ],
+        };
+    }
+    SubgridCommandBuilder.createDeleteRecordCommand = createDeleteRecordCommand;
+    function createRefreshCommand({ Icon, localizedTexts, text, }) {
+        return {
+            type: 'button',
+            Icon,
+            text,
+            localizedText: localizedTexts,
+            onClick: (context) => {
+                context.secondaryControl.refresh();
+            },
+        };
+    }
+    SubgridCommandBuilder.createRefreshCommand = createRefreshCommand;
+    function createExportCommand({ button, csv, excel, }) {
+        return {
+            type: 'menu',
+            Icon: button.Icon,
+            text: button.text,
+            localizedTexts: button.localizedTexts,
+            items: [
+                [
+                    {
+                        Icon: excel.Icon,
+                        text: excel.text,
+                        localizedTexts: excel.localizedTexts,
+                        onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                            context.utility.showProgressIndicator('Exporting to Excel...');
+                            try {
+                                const result = yield (0, utils_1.retriveRecords)({
+                                    columnFilters: context.secondaryControl.columnFilter,
+                                    dataService: context.dataService,
+                                    gridColumns: context.secondaryControl.gridColumns,
+                                    schema: context.secondaryControl.schema,
+                                    schemaStore: context.stores.schemaStore,
+                                    view: context.secondaryControl.view,
+                                    search: context.secondaryControl.searchText,
+                                    extraFilter: context.secondaryControl.extraFilter,
+                                    sorting: context.secondaryControl.sorting,
+                                    skip: 0,
+                                    limit: 5000,
+                                });
+                                yield (0, utils_1.exportRecordsXLS)({
+                                    fileName: context.secondaryControl.view.name + '.xlsx',
+                                    gridColumns: context.secondaryControl.gridColumns,
+                                    records: result.records,
+                                    schema: context.secondaryControl.schema,
+                                    schemaStore: context.stores.schemaStore,
+                                });
+                            }
+                            finally {
+                                context.utility.hideProgressIndicator();
+                            }
+                        }),
+                    },
+                    {
+                        Icon: csv.Icon,
+                        text: csv.text,
+                        localizedTexts: csv.localizedTexts,
+                        onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                            context.utility.showProgressIndicator('Exporting to CSV...');
+                            try {
+                                const result = yield (0, utils_1.retriveRecords)({
+                                    columnFilters: context.secondaryControl.columnFilter,
+                                    dataService: context.dataService,
+                                    gridColumns: context.secondaryControl.gridColumns,
+                                    schema: context.secondaryControl.schema,
+                                    schemaStore: context.stores.schemaStore,
+                                    view: context.secondaryControl.view,
+                                    search: context.secondaryControl.searchText,
+                                    extraFilter: context.secondaryControl.extraFilter,
+                                    sorting: context.secondaryControl.sorting,
+                                    skip: 0,
+                                    limit: 5000,
+                                });
+                                yield (0, utils_1.exportRecordsCSV)({
+                                    fileName: context.secondaryControl.view.name + '.csv',
+                                    gridColumns: context.secondaryControl.gridColumns,
+                                    records: result.records,
+                                    schema: context.secondaryControl.schema,
+                                    schemaStore: context.stores.schemaStore,
+                                });
+                            }
+                            finally {
+                                context.utility.hideProgressIndicator();
+                            }
+                        }),
+                    },
+                ],
+            ],
+        };
+    }
+    SubgridCommandBuilder.createExportCommand = createExportCommand;
+})(SubgridCommandBuilder || (exports.SubgridCommandBuilder = SubgridCommandBuilder = {}));

package/builders/CommandBuilder/ViewCommandBuilder.d.ts

@@ -0,0 +1,63 @@
+import { EntityMainGridCommandItemExperience } from '@headless-adminapp/core/experience/view';
+import { Localized } from '@headless-adminapp/core/types';
+import { Icon } from '@headless-adminapp/icons';
+export declare namespace ViewCommandBuilder {
+    function createNewRecordCommand({ Icon, text, localizedTexts, }: {
+        Icon: Icon;
+        text: string;
+        localizedTexts?: Record<string, string>;
+    }): EntityMainGridCommandItemExperience;
+    function createEditRecordCommand({ Icon, text, localizedTexts, }: {
+        Icon: Icon;
+        text: string;
+        localizedTexts?: Record<string, string>;
+    }): EntityMainGridCommandItemExperience;
+    interface DeleteRecordCommandStringSet {
+        confirmation: {
+            title: string | [string, string];
+            text: string | [string, string];
+            buttonCancel: string;
+            buttonConfirm: string;
+        };
+        status: {
+            deleting: string | [string, string];
+        };
+        successNotification: {
+            title: string | [string, string];
+            text: string | [string, string];
+        };
+        errorNotification: {
+            title: string;
+        };
+    }
+    const defaultDeleteRecordStringSet: DeleteRecordCommandStringSet;
+    function createDeleteRecordCommand({ Icon, localizedText, text, stringSet, localizedStringSet, }: {
+        Icon: Icon;
+        text: string;
+        localizedText?: Record<string, string>;
+        stringSet?: DeleteRecordCommandStringSet;
+        localizedStringSet?: Localized<DeleteRecordCommandStringSet>;
+    }): EntityMainGridCommandItemExperience;
+    function createRefreshCommand({ Icon, localizedTexts, text, }: {
+        Icon: Icon;
+        text: string;
+        localizedTexts?: Record<string, string>;
+    }): EntityMainGridCommandItemExperience;
+    function createExportCommand({ button, csv, excel, }: {
+        button: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        };
+        excel: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        };
+        csv: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        };
+    }): EntityMainGridCommandItemExperience;
+}