@acorex/modules 18.1.6 → 18.2.1

package/fesm2022/acorex-modules-template-management.mjs

@@ -2,39 +2,36 @@ import { AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
 import * as i0 from '@angular/core';
 import { inject, Injector, Injectable, NgModule } from '@angular/core';
 import { AXMEntityCrudServiceImpl, AXP_MENU_PROVIDER, AXPEntityQueryType, AXPEntityCommandScope } from '@acorex/platform/common';
+import { AXTranslationService } from '@acorex/core/translation';
 import { AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
 
-class AXMTemplateModuleEntityLoader {
+class AXMTemplateModuleEntityProvider {
     constructor() {
         this.injector = inject(Injector);
     }
     async get(moduleName, entityName) {
-        return new Promise(async (resolve) => {
+        if (moduleName == 'template-management') {
             switch (entityName) {
                 case 'template': {
                     const entity = (await Promise.resolve().then(function () { return textTemplate_entity; })).templateEntityFactory;
-                    resolve(entity(this.injector));
-                    break;
+                    return entity(this.injector);
                 }
                 case 'variable': {
                     const entity = (await Promise.resolve().then(function () { return templateVariable_entity; })).textTemplateVariableEntityFactory;
-                    resolve(entity(this.injector));
-                    break;
+                    return entity(this.injector);
                 }
                 case 'category': {
                     const entity = (await Promise.resolve().then(function () { return category_entity; })).textTemplateCategoryEntityFactory;
-                    resolve(entity(this.injector));
-                    break;
+                    return entity(this.injector);
                 }
-                default:
-                    resolve(null);
             }
-        });
+        }
+        return null;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTemplateModuleEntityLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTemplateModuleEntityLoader }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTemplateModuleEntityProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTemplateModuleEntityProvider }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTemplateModuleEntityLoader, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTemplateModuleEntityProvider, decorators: [{
             type: Injectable
         }] });
 
@@ -68,38 +65,42 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
         }], ctorParameters: () => [] });
 
 class AXMTextTemplateManagmentModuleMenuProvider {
+    constructor() {
+        this.translateService = inject(AXTranslationService);
+    }
     async items() {
+        const scope = '#text-template'; // Scope used for translation lookup
         return [
             {
                 items: [
                     {
                         priority: 9001,
-                        text: 'Text Template Management',
+                        text: `${scope}.module-name`,
                         icon: 'fa-solid fa-code',
                         data: {
                         // requiredPermission: 'demo.admin.settings',
                         },
                         children: [
                             {
-                                text: 'Template',
+                                text: `${scope}.templates`,
                                 path: '/demo/m/template-management/e/template/list',
                                 icon: 'fa-solid fa-file-code',
                                 data: {
-                                //requiredPermission: '',
+                                // requiredPermission: '',
                                 },
                             },
                             {
-                                text: 'Category',
+                                text: `${scope}.category`,
                                 path: '/demo/m/template-management/e/category/list',
                                 icon: 'fa-solid fa-layer-group',
                                 data: {
-                                //requiredPermission: '',
+                                // requiredPermission: '',
                                 },
                             },
                         ],
                     },
-                ]
-            }
+                ],
+            },
         ];
     }
 }
@@ -110,7 +111,7 @@ class AXMTemplateManagementModule {
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTemplateManagementModule, providers: [
             {
                 provide: AXP_ENTITY_DEFINITION_LOADER,
-                useClass: AXMTemplateModuleEntityLoader,
+                useClass: AXMTemplateModuleEntityProvider,
                 multi: true,
             },
             {
@@ -137,7 +138,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
                     providers: [
                         {
                             provide: AXP_ENTITY_DEFINITION_LOADER,
-                            useClass: AXMTemplateModuleEntityLoader,
+                            useClass: AXMTemplateModuleEntityProvider,
                             multi: true,
                         },
                         {
@@ -159,37 +160,49 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
 
 async function textTemplateCategoryEntityFactory(injector) {
     const dataService = injector.get(AXMTextTemplateCategoryService);
+    const moduleName = 'template-management';
+    const scope = `#${moduleName}`;
     const entityDef = {
-        module: 'template-management',
-        name: 'textTemplateCategory',
-        source: 'template-management.textTemplateCategory',
-        title: 'Category',
+        module: moduleName,
+        name: 'category',
+        source: 'templateManagement.category',
+        title: `#common.category`,
         formats: {
-            individual: 'Category',
-            plural: 'Categories',
+            individual: '#common.category',
+            plural: '#common.categories',
         },
         relatedEntities: [],
         groups: [
             {
                 id: 'category',
-                title: 'Category',
+                title: '#common.category',
             },
         ],
         properties: [
             {
                 name: 'name',
-                title: 'Name',
+                title: '#common.name',
                 groupId: 'category',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
                 schema: {
                     dataType: 'string',
                     interface: {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
                 name: 'title',
-                title: 'Title',
+                title: '#common.title',
                 groupId: 'category',
                 schema: {
                     dataType: 'string',
@@ -197,13 +210,19 @@ async function textTemplateCategoryEntityFactory(injector) {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
         ],
         columns: [{ name: 'name' }, { name: 'title' }],
         commands: {
             create: {
                 execute: async (data) => {
-                    return await dataService.insertOne(data);
+                    const res = await dataService.insertOne(data);
+                    return { id: res };
                 },
             },
             delete: {
@@ -342,28 +361,28 @@ async function textTemplateCategoryEntityFactory(injector) {
                 list: {
                     actions: [
                         {
-                            title: 'Create New',
+                            title: `#common.create #common.category`,
                             command: 'create-entity',
                             priority: 'primary',
                             type: 'create',
                             scope: AXPEntityCommandScope.TypeLevel,
                         },
                         {
-                            title: 'Delete Items',
+                            title: '#common.deleteItems',
                             command: 'delete-entity',
                             priority: 'primary',
                             type: 'delete',
                             scope: AXPEntityCommandScope.Selected,
                         },
                         {
-                            title: 'Details',
+                            title: '#common.detail',
                             command: 'open-entity',
                             priority: 'primary',
                             type: 'view',
                             scope: AXPEntityCommandScope.Individual,
                         },
                         {
-                            title: 'Delete',
+                            title: '#common.delete',
                             command: 'delete-entity',
                             priority: 'primary',
                             type: 'delete',
@@ -373,7 +392,7 @@ async function textTemplateCategoryEntityFactory(injector) {
                     views: [
                         {
                             name: 'all',
-                            title: 'All Items',
+                            title: '#common.allItem',
                             fixed: true,
                             columns: [],
                             conditions: [],
@@ -435,6 +454,11 @@ async function templateEntityFactory(injector) {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
                 name: 'title',
@@ -446,6 +470,11 @@ async function templateEntityFactory(injector) {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
                 name: 'content',
@@ -457,6 +486,11 @@ async function templateEntityFactory(injector) {
                         type: AXPWidgetsCatalog.richText,
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
                 name: 'category.id',
@@ -472,6 +506,11 @@ async function templateEntityFactory(injector) {
                         },
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
                 name: 'category.title',
@@ -504,13 +543,19 @@ async function templateEntityFactory(injector) {
                         },
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
         ],
         columns: [{ name: 'name' }, { name: 'title' }, { name: 'category.title' }, { name: 'type' }],
         commands: {
             create: {
                 execute: async (data) => {
-                    return await dataService.insertOne(data);
+                    const res = await dataService.insertOne(data);
+                    return { id: res };
                 },
             },
             delete: {
@@ -784,18 +829,18 @@ async function textTemplateVariableEntityFactory(injector) {
     const entityDef = {
         module: 'template-management',
         name: 'textTemplateVariable',
-        source: 'template-management.textTemplateVariable',
+        source: 'template-management.variable',
         title: 'Template Variables',
         formats: {
             individual: 'TemplateVariable',
-            plural: 'TemplateVariables'
+            plural: 'TemplateVariables',
         },
         relatedEntities: [],
         groups: [
             {
                 id: 'templateVariable',
-                title: 'TemplateVariable'
-            }
+                title: 'TemplateVariable',
+            },
         ],
         properties: [
             {
@@ -805,9 +850,9 @@ async function textTemplateVariableEntityFactory(injector) {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text
-                    }
-                }
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
             },
             {
                 name: 'title',
@@ -816,9 +861,9 @@ async function textTemplateVariableEntityFactory(injector) {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text
-                    }
-                }
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
             },
             {
                 name: 'type',
@@ -827,9 +872,9 @@ async function textTemplateVariableEntityFactory(injector) {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select
-                    }
-                }
+                        type: AXPWidgetsCatalog.select,
+                    },
+                },
             },
             {
                 name: 'required',
@@ -838,36 +883,37 @@ async function textTemplateVariableEntityFactory(injector) {
                 schema: {
                     dataType: 'boolean',
                     interface: {
-                        type: AXPWidgetsCatalog.toggle
-                    }
-                }
-            }
+                        type: AXPWidgetsCatalog.toggle,
+                    },
+                },
+            },
         ],
-        columns: [{ name: 'name' }, { name: 'title' }, { name: 'requirement' }],
+        columns: [{ name: 'name' }, { name: 'title' }, { name: 'required' }],
         commands: {
             create: {
                 execute: async (data) => {
                     const item = await dataService.getOne(data.globalTemplateId);
                     (item.templateVariables ??= []).push(data);
                     return await dataService.updateOne(data.globalTemplateId, item);
-                }
+                },
             },
             delete: {
                 execute: async (id) => {
                     //    await await dataService.templateVariableDataProvider.deleteOne(id);
                     return Promise.resolve();
-                }
+                },
             },
             update: {
                 execute: async (data) => {
+                    console.log(data);
                     return new Promise((resolve) => {
                         setTimeout(async () => {
                             //   await dataService.templateVariableDataProvider.updateOne(data.id, data);
                             resolve(data);
                         }, 1000);
                     });
-                }
-            }
+                },
+            },
         },
         queries: {
             byKey: {
@@ -879,15 +925,15 @@ async function textTemplateVariableEntityFactory(injector) {
                         }, 500);
                     });
                 },
-                type: AXPEntityQueryType.Single
+                type: AXPEntityQueryType.Single,
             },
             list: {
                 execute: async (e) => {
                     if (e.filter != null && e.filter.filters != null && e.filter.filters[0].value != null) {
                         const parentItem = await dataService.getOne(e.filter?.filters[0].value);
                         return {
-                            totalCount: parentItem.templateVariables.length,
-                            items: parentItem.templateVariables
+                            totalCount: parentItem.templateVariables?.length ?? 0,
+                            items: parentItem.templateVariables ?? [],
                         };
                     }
                     else {
@@ -895,16 +941,16 @@ async function textTemplateVariableEntityFactory(injector) {
                         return [];
                     }
                 },
-                type: AXPEntityQueryType.List
-            }
+                type: AXPEntityQueryType.List,
+            },
         },
         interfaces: {
             master: {
                 create: {
                     sections: [
                         {
-                            id: 'templateVariable'
-                        }
+                            id: 'templateVariable',
+                        },
                     ],
                     properties: [
                         {
@@ -912,44 +958,44 @@ async function textTemplateVariableEntityFactory(injector) {
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
                         },
                         {
                             name: 'title',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
                         },
                         {
-                            name: 'requirement',
+                            name: 'required',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
-                        }
-                    ]
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
                 },
                 update: {
                     sections: [
                         {
-                            id: 'templateVariable'
+                            id: 'templateVariable',
                         },
                         {
-                            id: 'schema'
+                            id: 'schema',
                         },
                         {
-                            id: 'interface'
-                        }
+                            id: 'interface',
+                        },
                     ],
                     properties: [
                         {
@@ -957,49 +1003,49 @@ async function textTemplateVariableEntityFactory(injector) {
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
                         },
                         {
                             name: 'title',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
                         },
                         {
                             name: 'schema.nullable',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
                         },
                         {
-                            name: 'requirement',
+                            name: 'required',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
-                        }
-                    ]
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
                 },
                 single: {
                     title: '{{title}}',
                     sections: [
                         {
-                            id: 'templateVariable'
-                        }
+                            id: 'templateVariable',
+                        },
                     ],
                     properties: [
                         {
@@ -1007,33 +1053,33 @@ async function textTemplateVariableEntityFactory(injector) {
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
                         },
                         {
                             name: 'title',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
                         },
                         {
-                            name: 'requirement',
+                            name: 'required',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 12
-                                    }
-                                }
-                            }
-                        }
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
                     ],
-                    actions: []
+                    actions: [],
                 },
                 list: {
                     actions: [
@@ -1042,29 +1088,29 @@ async function textTemplateVariableEntityFactory(injector) {
                             command: 'create-entity',
                             priority: 'primary',
                             type: 'create',
-                            scope: AXPEntityCommandScope.TypeLevel
+                            scope: AXPEntityCommandScope.TypeLevel,
                         },
                         {
                             title: 'Delete Items',
                             command: 'delete-entity',
                             priority: 'primary',
                             type: 'delete',
-                            scope: AXPEntityCommandScope.Selected
-                        },
-                        {
-                            title: 'Details',
-                            command: 'open-entity',
-                            priority: 'primary',
-                            type: 'view',
-                            scope: AXPEntityCommandScope.Individual
+                            scope: AXPEntityCommandScope.Selected,
                         },
+                        // {
+                        //   title: 'Update',
+                        //   command: 'update-entity',
+                        //   priority: 'primary',
+                        //   type: 'view',
+                        //   scope: AXPEntityCommandScope.Individual
+                        // },
                         {
                             title: 'Delete',
                             command: 'delete-entity',
                             priority: 'primary',
                             type: 'delete',
-                            scope: AXPEntityCommandScope.Individual
-                        }
+                            scope: AXPEntityCommandScope.Individual,
+                        },
                     ],
                     views: [
                         {
@@ -1073,12 +1119,12 @@ async function textTemplateVariableEntityFactory(injector) {
                             fixed: true,
                             columns: [],
                             conditions: [],
-                            sorts: []
-                        }
-                    ]
-                }
-            }
-        }
+                            sorts: [],
+                        },
+                    ],
+                },
+            },
+        },
     };
     return entityDef;
 }
@@ -1092,5 +1138,5 @@ var templateVariable_entity = /*#__PURE__*/Object.freeze({
  * Generated bundle index. Do not edit.
  */
 
-export { AXMTemplateManagementModule, AXMTemplateModuleEntityLoader, AXMTextTemplateCategoryService, AXMTextTemplateCategoryServiceImpl, AXMTextTemplateService, AXMTextTemplateServiceImpl, CATEGORY_SOURCE_NAME, TEMPLATE_SOURCE_NAME, templateEntityFactory, textTemplateCategoryEntityFactory, textTemplateVariableEntityFactory };
+export { AXMTemplateManagementModule, AXMTemplateModuleEntityProvider, AXMTextTemplateCategoryService, AXMTextTemplateCategoryServiceImpl, AXMTextTemplateService, AXMTextTemplateServiceImpl, CATEGORY_SOURCE_NAME, TEMPLATE_SOURCE_NAME, templateEntityFactory, textTemplateCategoryEntityFactory, textTemplateVariableEntityFactory };
 //# sourceMappingURL=acorex-modules-template-management.mjs.map