@acorex/modules 20.7.16 → 20.7.17

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

@@ -8121,7 +8121,7 @@ class AXPMetaDataFormWidgetEditComponent extends AXPValueWidgetComponent {
                 return false;
             }
             return groups.some((group) => {
-                const fields = group.fields || [];
+                const fields = (group.parameters || group.fields || []);
                 return fields.length > 0 && fields.some((field) => field != null);
             });
         }, ...(ngDevMode ? [{ debugName: "hasDefinitions" }] : []));
@@ -8178,10 +8178,11 @@ class AXPMetaDataFormWidgetEditComponent extends AXPValueWidgetComponent {
     convertGroupsToFormDefinition(groups) {
         const formGroups = [];
         groups.forEach((group) => {
+            // Support both: group.parameters (form-definition) or group.fields (meta-data-selector)
+            const parameters = group.parameters;
             const fields = group.fields || [];
             const validFields = fields.filter((field) => field != null);
-            if (validFields.length > 0) {
-                const parameters = validFields.map((field) => this.convertMetadataToFieldDefinition(field));
+            if (parameters && parameters.length > 0) {
                 formGroups.push({
                     name: this.sanitizeGroupName(group.name || 'default'),
                     title: group.title || group.name,
@@ -8190,6 +8191,16 @@ class AXPMetaDataFormWidgetEditComponent extends AXPValueWidgetComponent {
                     parameters,
                 });
             }
+            else if (validFields.length > 0) {
+                const params = validFields.map((field) => this.convertMetadataToFieldDefinition(field));
+                formGroups.push({
+                    name: this.sanitizeGroupName(group.name || 'default'),
+                    title: group.title || group.name,
+                    description: group.description,
+                    look: groups.length > 1 ? 'group' : 'container',
+                    parameters: params,
+                });
+            }
         });
         return { groups: formGroups };
     }
@@ -8397,9 +8408,8 @@ class ShowMetaDataFormPopupCommand {
                 };
             }
             const finalId = evaluatedInput.id;
-            // Get current entity record to get the metadata expression value
-            const [moduleName, entityName] = entity.split('.');
-            const currentRecord = await this.findRecord(entity, finalId);
+            // Get current entity record (override findRecord to use custom data sources)
+            const currentRecord = await this.findRecord(entity, finalId, evaluatedInput);
             if (!currentRecord) {
                 return {
                     success: false,
@@ -8408,45 +8418,14 @@ class ShowMetaDataFormPopupCommand {
                     },
                 };
             }
-            // Note: pathValue might be null/undefined, but the metadata expression evaluator will handle it
-            // The expression will return an empty array if pathValue is not available
-            // Resolve entity to get metadata expression and determine if it's category or entity lookup
-            const entityDef = await this.entityRegistry.resolve(moduleName, entityName);
-            const metaDataFormExt = entityDef.extensions?.metaDataForm?.[field];
-            if (!metaDataFormExt) {
-                return {
-                    success: false,
-                    message: {
-                        text: await this.translationService.translateAsync('@data-management:metadata-definitions.messages.meta-data-form-not-configured'),
-                    },
-                };
-            }
-            // Get path property to determine metadata source type
-            const props = entityDef.properties || [];
-            const pathProperty = props.find((p) => p.name === path);
-            const targetEntity = pathProperty?.schema?.interface?.options?.['entity'];
-            if (!targetEntity) {
-                return {
-                    success: false,
-                    message: {
-                        text: await this.translationService.translateAsync('@data-management:metadata-definitions.messages.invalid-path-field'),
-                    },
-                };
-            }
-            // Build metadata expression based on target entity type
-            let metadataExpression;
-            if (targetEntity.endsWith('Category')) {
-                // Category lookup - use fromCategory
-                metadataExpression = `{{ metadata.fromCategory("${entity}", context.eval('${path}')) }}`;
-            }
-            else {
-                // Relationship lookup - use fromEntity
-                metadataExpression = `{{ metadata.fromEntity("${targetEntity}", context.eval('${path}')) }}`;
-            }
+            // Resolve groups (override resolveGroups to load from custom APIs)
+            const { groups: resolvedGroups, dialogTitle: resolvedTitle } = await this.resolveGroups(evaluatedInput, currentRecord);
             // Get current meta data form value
             const currentMetaDataValue = currentRecord[field] || {};
             // Build dialog title
-            const dialogTitle = title || metaDataFormExt.title || await this.translationService.translateAsync('@data-management:metadata-definitions.components.meta-data-form.title');
+            const dialogTitle = title ||
+                resolvedTitle ||
+                (await this.translationService.translateAsync('@data-management:metadata-definitions.components.meta-data-form.title'));
             // Open dialog with meta-data-form-editor widget
             const result = await this.layoutBuilder
                 .create()
@@ -8462,13 +8441,13 @@ class ShowMetaDataFormPopupCommand {
                     .content((layout) => {
                     layout.flex((flex) => {
                         flex.setDirection('column').setGap('16px');
-                        // Add meta-data-form-editor widget with metadata expression
+                        // Add meta-data-form-editor widget with groups (expression or array)
                         flex.formField('', (fieldBuilder) => {
                             fieldBuilder
                                 .path(field)
                                 .setShowLabel(false)
                                 .customWidget('meta-data-form-editor', {
-                                groups: metadataExpression,
+                                groups: resolvedGroups,
                             });
                         });
                     });
@@ -8512,11 +8491,43 @@ class ShowMetaDataFormPopupCommand {
     //#region ---- Overridable Methods ----
     /**
      * Loads a record by entity and id. Override to use custom data sources or key handling.
+     * @param input - Optional; overrides can use input.data or other fields to return custom record.
      */
-    findRecord(entity, id) {
+    findRecord(entity, id, input) {
         const dataAccessor = this.entityService.withEntity(entity).data();
         return dataAccessor.byKey(id);
     }
+    /**
+     * Resolves groups for the meta-data-form-editor.
+     * Override to load groups from custom APIs instead of entity metadata.
+     * @returns Expression string (evaluated at runtime) or groups array; dialogTitle is optional fallback.
+     */
+    async resolveGroups(input, currentRecord) {
+        const { entity, field = META_DATA_FORM_FIELD, path } = input;
+        const [moduleName, entityName] = entity.split('.');
+        const entityDef = await this.entityRegistry.resolve(moduleName, entityName);
+        const metaDataFormExt = entityDef.extensions?.metaDataForm?.[field];
+        if (!metaDataFormExt) {
+            throw new Error(await this.translationService.translateAsync('@data-management:metadata-definitions.messages.meta-data-form-not-configured'));
+        }
+        const props = entityDef.properties || [];
+        const pathProperty = props.find((p) => p.name === path);
+        const targetEntity = pathProperty?.schema?.interface?.options?.['entity'];
+        if (!targetEntity) {
+            throw new Error(await this.translationService.translateAsync('@data-management:metadata-definitions.messages.invalid-path-field'));
+        }
+        let metadataExpression;
+        if (targetEntity.endsWith('Category')) {
+            metadataExpression = `{{ metadata.fromCategory("${entity}", context.eval('${path}')) }}`;
+        }
+        else {
+            metadataExpression = `{{ metadata.fromEntity("${targetEntity}", context.eval('${path}')) }}`;
+        }
+        return {
+            groups: metadataExpression,
+            dialogTitle: metaDataFormExt.title,
+        };
+    }
     /**
      * Persists meta-data form changes. Override to use custom persistence or validation.
      */