@sap-ux/ui5-test-writer 0.9.3 → 0.9.4

package/dist/types.d.ts

@@ -107,6 +107,9 @@ export type BodySectionFeatureData = {
     fields: SectionFormField[];
     tableColumns: TableColumnFeatureData;
     subSections: BodySubSectionFeatureData[];
+    actions?: ActionButtonState[];
+    createButton?: ButtonState;
+    deleteButton?: ButtonState;
 };
 export type ObjectPageFeatures = {
     name?: string;
@@ -115,6 +118,8 @@ export type ObjectPageFeatures = {
     headerDescription?: string;
     headerSections?: HeaderSectionFeatureData[];
     bodySections?: BodySectionFeatureData[];
+    headerActions?: ActionButtonState[];
+    editButton?: ButtonState;
 };
 export type ListReportFeatures = {
     name?: string;
@@ -135,6 +140,10 @@ export type ListReportFeatures = {
 };
 export interface ActionButtonState {
     label: string;
+    /**
+     * For List Report actions: the full OData binding path (e.g. "namespace.ActionName(entityType=@odata.context)").
+     * For Object Page actions extracted from the spec model: the method name only (e.g. "Copy").
+     */
     action: string;
     visible: boolean;
     /**
@@ -153,6 +162,16 @@ export interface ActionButtonState {
      * The invocation grouping type if specified (e.g., "Isolated", "ChangeSet").
      */
     invocationGrouping?: string;
+    /**
+     * OData schema namespace used as the `service` parameter in iCheckAction({ service, action, unbound }).
+     * Populated for Object Page actions extracted via the spec model + metadata.
+     */
+    service?: string;
+    /**
+     * Whether the action is unbound (not bound to a specific entity instance).
+     * Populated for Object Page actions extracted via the spec model + metadata.
+     */
+    unbound?: boolean;
 }
 export type FPMFeatures = {
     name?: string;

package/dist/utils/actionUtils.d.ts

@@ -0,0 +1,137 @@
+import type { ConvertedMetadata } from '@sap-ux/vocabularies-types';
+import type { ActionButtonState, ButtonState, ButtonVisibilityResult } from '../types';
+import type { DataFieldForAction } from '@sap-ux/vocabularies-types/vocabularies/UI';
+import type { OperationAvailable } from '@sap-ux/vocabularies-types/vocabularies/Core';
+import type { DeleteRestrictionsType, InsertRestrictionsType, UpdateRestrictionsType } from '@sap-ux/vocabularies-types/vocabularies/Capabilities';
+import type { Logger } from '@sap-ux/logger';
+type OperationAvailableWithPaths = OperationAvailable & {
+    $Path?: string;
+    path?: string;
+};
+type RestrictionValueWithPaths = (boolean | {
+    $Path?: string;
+    path?: string;
+}) | undefined;
+/**
+ * Extracts the action method name from a fully qualified action string.
+ *
+ * @param actionName The fully qualified action name
+ * @returns The action method name
+ */
+export declare function extractActionMethodName(actionName: string): string;
+/**
+ * Finds the Core.OperationAvailable annotation for a specific action.
+ *
+ * @param metadata The converted metadata
+ * @param actionMethodName The action method name
+ * @returns The OperationAvailable annotation value or undefined if not found
+ */
+export declare function findOperationAvailableAnnotation(metadata: ConvertedMetadata, actionMethodName: string): OperationAvailableWithPaths | undefined;
+/**
+ * Analyzes Core.OperationAvailable annotation to determine action availability.
+ * Single-entity bound actions (requiring row selection) are disabled by default when no annotation is present.
+ *
+ * @param operationAvailable The OperationAvailable annotation value
+ * @param isEntityBound Whether the action is bound to a single entity (requires row selection to enable)
+ * @returns Object containing enabled state and optional dynamic path
+ */
+export declare function analyzeOperationAvailability(operationAvailable: OperationAvailableWithPaths | undefined, isEntityBound?: boolean): {
+    enabled: boolean | 'dynamic';
+    dynamicPath?: string;
+};
+/**
+ * Extracts the enum member value from an annotation.
+ *
+ * @param enumValue The enum value object
+ * @returns The extracted enum value string
+ */
+export declare function extractEnumMemberValue(enumValue: unknown): string | undefined;
+/**
+ * Builds an ActionButtonState object from a DataFieldForAction annotation item.
+ *
+ * @param item The DataFieldForAction annotation item
+ * @param metadata The converted metadata
+ * @returns ActionButtonState for the action
+ */
+export declare function buildActionButtonState(item: DataFieldForAction, metadata: ConvertedMetadata): ActionButtonState;
+/**
+ * Builds an ActionButtonState from a spec model aggregation key.
+ *
+ * Key format: "DataFieldForAction::<namespace>.<Method>::<namespace>.<EntityType>"
+ * Example:    "DataFieldForAction::com.example.Copy::com.example.POEntity".
+ *
+ * @param aggregationKey The spec model aggregation key for the action
+ * @param label Display label from the spec model item description
+ * @param convertedMetadata The converted OData metadata
+ * @param schemaNamespace The OData schema namespace (used as service identifier)
+ * @returns ActionButtonState or undefined if the key is not a DataFieldForAction key
+ */
+export declare function buildActionStateFromSpecModelKey(aggregationKey: string, label: string | undefined, convertedMetadata: ConvertedMetadata, schemaNamespace: string): ActionButtonState | undefined;
+/**
+ * Analyzes a restriction value (Insertable, Deletable, or Updatable) to determine button state.
+ *
+ * @param value The annotation value — boolean, path object, or undefined
+ * @returns ButtonState indicating visibility and enabled state
+ */
+export declare function analyzeRestrictionValue(value: RestrictionValueWithPaths): ButtonState;
+/**
+ * Analyzes InsertRestrictions annotation to determine create button visibility and enabled state.
+ *
+ * @param restriction The InsertRestrictions annotation for the entity set
+ * @returns ButtonState indicating visibility and enabled state based on the Insertable value
+ */
+export declare function analyzeInsertRestrictions(restriction: InsertRestrictionsType | undefined): ButtonState;
+/**
+ * Analyzes DeleteRestrictions annotation to determine delete button visibility and enabled state.
+ *
+ * @param restriction The DeleteRestrictions annotation for the entity set
+ * @returns ButtonState indicating visibility and enabled state based on the Deletable value
+ */
+export declare function analyzeDeleteRestrictions(restriction: DeleteRestrictionsType | undefined): ButtonState;
+/**
+ * Analyzes UpdateRestrictions annotation to determine edit button visibility and enabled state.
+ *
+ * @param restriction The UpdateRestrictions annotation for the entity set
+ * @returns ButtonState indicating visibility and enabled state based on the Updatable value
+ */
+export declare function analyzeUpdateRestrictions(restriction: UpdateRestrictionsType | undefined): ButtonState;
+/**
+ * Checks the visibility and enabled state of create and delete buttons for a given entity set
+ * by analyzing OData Capabilities annotations in the metadata.
+ *
+ * @param metadataXml The OData metadata XML content as a string
+ * @param entitySetName The name of the entity set to check
+ * @returns ButtonVisibilityResult containing the state of create and delete buttons
+ * @throws {Error} If metadata cannot be parsed or entity set is not found
+ */
+export declare function checkButtonVisibility(metadataXml: string, entitySetName: string): ButtonVisibilityResult;
+/**
+ * Checks the visibility and enabled state of the edit button for a given entity set
+ * by analyzing UpdateRestrictions in the metadata.
+ *
+ * @param metadataXml The OData metadata XML content as a string
+ * @param entitySetName The name of the entity set to check
+ * @returns ButtonState for the edit button
+ * @throws {Error} If metadata cannot be parsed or entity set is not found
+ */
+export declare function checkEditVisibility(metadataXml: string, entitySetName: string): ButtonState;
+/**
+ * Safely checks button visibility with error handling.
+ *
+ * @param metadata The OData metadata XML content
+ * @param entitySetName The name of the entity set
+ * @param log Optional logger instance
+ * @returns Button visibility result or undefined if error occurs
+ */
+export declare function safeCheckButtonVisibility(metadata: string, entitySetName: string, log?: Logger): ButtonVisibilityResult | undefined;
+/**
+ * Safely checks edit button visibility with error handling.
+ *
+ * @param metadata The OData metadata XML content
+ * @param entitySetName The name of the entity set
+ * @param log Optional logger instance
+ * @returns ButtonState for the edit button, or undefined if error occurs
+ */
+export declare function safeCheckEditVisibility(metadata: string, entitySetName: string, log?: Logger): ButtonState | undefined;
+export {};
+//# sourceMappingURL=actionUtils.d.ts.map

package/dist/utils/actionUtils.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractActionMethodName = extractActionMethodName;
+exports.findOperationAvailableAnnotation = findOperationAvailableAnnotation;
+exports.analyzeOperationAvailability = analyzeOperationAvailability;
+exports.extractEnumMemberValue = extractEnumMemberValue;
+exports.buildActionButtonState = buildActionButtonState;
+exports.buildActionStateFromSpecModelKey = buildActionStateFromSpecModelKey;
+exports.analyzeRestrictionValue = analyzeRestrictionValue;
+exports.analyzeInsertRestrictions = analyzeInsertRestrictions;
+exports.analyzeDeleteRestrictions = analyzeDeleteRestrictions;
+exports.analyzeUpdateRestrictions = analyzeUpdateRestrictions;
+exports.checkButtonVisibility = checkButtonVisibility;
+exports.checkEditVisibility = checkEditVisibility;
+exports.safeCheckButtonVisibility = safeCheckButtonVisibility;
+exports.safeCheckEditVisibility = safeCheckEditVisibility;
+const edmx_parser_1 = require("@sap-ux/edmx-parser");
+const annotation_converter_1 = require("@sap-ux/annotation-converter");
+const DATA_FIELD_FOR_ACTION = 'DataFieldForAction';
+/**
+ * Extracts the action method name from a fully qualified action string.
+ *
+ * @param actionName The fully qualified action name
+ * @returns The action method name
+ */
+function extractActionMethodName(actionName) {
+    const match = /\.([^.()]+)\(/.exec(actionName);
+    if (match?.[1]) {
+        return match[1];
+    }
+    const lastDotIndex = actionName.lastIndexOf('.');
+    const parenIndex = actionName.indexOf('(');
+    if (lastDotIndex >= 0 && parenIndex >= 0 && parenIndex > lastDotIndex) {
+        return actionName.substring(lastDotIndex + 1, parenIndex);
+    }
+    // Handle namespace-qualified name without parentheses (spec model key format: "namespace.Method")
+    if (lastDotIndex >= 0) {
+        return actionName.substring(lastDotIndex + 1);
+    }
+    return actionName;
+}
+/**
+ * Finds the Core.OperationAvailable annotation for a specific action.
+ *
+ * @param metadata The converted metadata
+ * @param actionMethodName The action method name
+ * @returns The OperationAvailable annotation value or undefined if not found
+ */
+function findOperationAvailableAnnotation(metadata, actionMethodName) {
+    if (metadata.actions) {
+        const foundAction = metadata.actions.find((action) => action.name === actionMethodName || action.fullyQualifiedName?.includes(`.${actionMethodName}(`));
+        if (foundAction?.annotations?.Core?.OperationAvailable !== undefined) {
+            return foundAction.annotations.Core.OperationAvailable;
+        }
+    }
+    if (metadata.entityContainer?.annotations) {
+        const annotations = metadata.entityContainer.annotations;
+        const matchingKey = Object.keys(annotations).find((key) => key === actionMethodName || key.endsWith(`.${actionMethodName}`));
+        if (matchingKey && annotations[matchingKey]?.Core?.OperationAvailable !== undefined) {
+            return annotations[matchingKey].Core.OperationAvailable;
+        }
+    }
+    return undefined;
+}
+/**
+ * Analyzes Core.OperationAvailable annotation to determine action availability.
+ * Single-entity bound actions (requiring row selection) are disabled by default when no annotation is present.
+ *
+ * @param operationAvailable The OperationAvailable annotation value
+ * @param isEntityBound Whether the action is bound to a single entity (requires row selection to enable)
+ * @returns Object containing enabled state and optional dynamic path
+ */
+function analyzeOperationAvailability(operationAvailable, isEntityBound) {
+    if (operationAvailable === undefined) {
+        return { enabled: !isEntityBound };
+    }
+    if (typeof operationAvailable === 'boolean') {
+        return { enabled: operationAvailable };
+    }
+    if (typeof operationAvailable === 'object' && operationAvailable !== null) {
+        const pathRecord = operationAvailable;
+        const path = pathRecord.$Path ?? pathRecord.path;
+        if (path) {
+            return { enabled: 'dynamic', dynamicPath: path };
+        }
+    }
+    return { enabled: true };
+}
+/**
+ * Extracts the enum member value from an annotation.
+ *
+ * @param enumValue The enum value object
+ * @returns The extracted enum value string
+ */
+function extractEnumMemberValue(enumValue) {
+    if (typeof enumValue === 'string') {
+        return enumValue;
+    }
+    const enumRecord = enumValue;
+    if (enumRecord?.$EnumMember) {
+        const parts = enumRecord.$EnumMember.split('/');
+        return parts[1] ?? enumRecord.$EnumMember;
+    }
+    return undefined;
+}
+/**
+ * Builds an ActionButtonState object from a DataFieldForAction annotation item.
+ *
+ * @param item The DataFieldForAction annotation item
+ * @param metadata The converted metadata
+ * @returns ActionButtonState for the action
+ */
+function buildActionButtonState(item, metadata) {
+    const actionString = item.Action || '';
+    const actionMethod = extractActionMethodName(actionString);
+    const operationAvailable = findOperationAvailableAnnotation(metadata, actionMethod);
+    // Bound actions whose binding parameter is a single entity (not a collection) require
+    // row selection to be invoked, so they are disabled by default (no row selected).
+    // Collection-bound actions operate on the entity set and are always enabled.
+    const actionTarget = item.ActionTarget;
+    const isEntityBound = actionTarget?.isBound === true && actionTarget?.parameters?.[0]?.isCollection !== true;
+    const { enabled, dynamicPath } = analyzeOperationAvailability(operationAvailable, isEntityBound);
+    return {
+        label: item.Label || '',
+        action: actionString,
+        visible: true,
+        enabled,
+        dynamicPath,
+        invocationGrouping: item.InvocationGrouping ? extractEnumMemberValue(item.InvocationGrouping) : undefined
+    };
+}
+/**
+ * Builds an ActionButtonState from a spec model aggregation key.
+ *
+ * Key format: "DataFieldForAction::<namespace>.<Method>::<namespace>.<EntityType>"
+ * Example:    "DataFieldForAction::com.example.Copy::com.example.POEntity".
+ *
+ * @param aggregationKey The spec model aggregation key for the action
+ * @param label Display label from the spec model item description
+ * @param convertedMetadata The converted OData metadata
+ * @param schemaNamespace The OData schema namespace (used as service identifier)
+ * @returns ActionButtonState or undefined if the key is not a DataFieldForAction key
+ */
+function buildActionStateFromSpecModelKey(aggregationKey, label, convertedMetadata, schemaNamespace) {
+    const keyParts = aggregationKey.split('::');
+    if (keyParts[0] !== DATA_FIELD_FOR_ACTION || !keyParts[1]) {
+        return undefined;
+    }
+    const actionFullName = keyParts[1]; // "namespace.Method"
+    const actionMethod = extractActionMethodName(actionFullName);
+    const actionDefinition = convertedMetadata.actions?.find((action) => action.name === actionMethod || action.fullyQualifiedName?.includes(`.${actionMethod}(`));
+    const firstParameter = actionDefinition?.parameters?.[0];
+    const isEntityBound = actionDefinition?.isBound === true && firstParameter?.isCollection !== true;
+    const operationAvailable = findOperationAvailableAnnotation(convertedMetadata, actionMethod);
+    const { enabled, dynamicPath } = analyzeOperationAvailability(operationAvailable, isEntityBound);
+    return {
+        label: label ?? '',
+        action: actionMethod,
+        service: schemaNamespace,
+        unbound: !isEntityBound,
+        visible: true,
+        enabled,
+        dynamicPath
+    };
+}
+/**
+ * Analyzes a restriction value (Insertable, Deletable, or Updatable) to determine button state.
+ *
+ * @param value The annotation value — boolean, path object, or undefined
+ * @returns ButtonState indicating visibility and enabled state
+ */
+function analyzeRestrictionValue(value) {
+    const defaultState = { visible: true, enabled: true };
+    if (value === undefined || value === null) {
+        return defaultState;
+    }
+    if (typeof value === 'boolean') {
+        return { visible: value, enabled: value };
+    }
+    if (typeof value === 'object') {
+        const path = value.$Path ?? value.path;
+        if (path) {
+            return { visible: true, enabled: 'dynamic', dynamicPath: path };
+        }
+    }
+    return defaultState;
+}
+/**
+ * Analyzes InsertRestrictions annotation to determine create button visibility and enabled state.
+ *
+ * @param restriction The InsertRestrictions annotation for the entity set
+ * @returns ButtonState indicating visibility and enabled state based on the Insertable value
+ */
+function analyzeInsertRestrictions(restriction) {
+    const value = restriction ? restriction['Insertable'] : undefined;
+    return analyzeRestrictionValue(value);
+}
+/**
+ * Analyzes DeleteRestrictions annotation to determine delete button visibility and enabled state.
+ *
+ * @param restriction The DeleteRestrictions annotation for the entity set
+ * @returns ButtonState indicating visibility and enabled state based on the Deletable value
+ */
+function analyzeDeleteRestrictions(restriction) {
+    const value = restriction ? restriction['Deletable'] : undefined;
+    return analyzeRestrictionValue(value);
+}
+/**
+ * Analyzes UpdateRestrictions annotation to determine edit button visibility and enabled state.
+ *
+ * @param restriction The UpdateRestrictions annotation for the entity set
+ * @returns ButtonState indicating visibility and enabled state based on the Updatable value
+ */
+function analyzeUpdateRestrictions(restriction) {
+    const value = restriction ? restriction['Updatable'] : undefined;
+    return analyzeRestrictionValue(value);
+}
+/**
+ * Checks the visibility and enabled state of create and delete buttons for a given entity set
+ * by analyzing OData Capabilities annotations in the metadata.
+ *
+ * @param metadataXml The OData metadata XML content as a string
+ * @param entitySetName The name of the entity set to check
+ * @returns ButtonVisibilityResult containing the state of create and delete buttons
+ * @throws {Error} If metadata cannot be parsed or entity set is not found
+ */
+function checkButtonVisibility(metadataXml, entitySetName) {
+    try {
+        const convertedMetadata = (0, annotation_converter_1.convert)((0, edmx_parser_1.parse)(metadataXml));
+        const entitySet = convertedMetadata.entitySets.find((es) => es.name === entitySetName);
+        if (!entitySet) {
+            throw new Error(`Entity set '${entitySetName}' not found in metadata`);
+        }
+        const insertRestrictions = entitySet.annotations?.Capabilities?.InsertRestrictions;
+        const deleteRestrictions = entitySet.annotations?.Capabilities?.DeleteRestrictions;
+        return {
+            create: analyzeInsertRestrictions(insertRestrictions),
+            delete: analyzeDeleteRestrictions(deleteRestrictions)
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to analyze button visibility: ${errorMessage}`);
+    }
+}
+/**
+ * Checks the visibility and enabled state of the edit button for a given entity set
+ * by analyzing UpdateRestrictions in the metadata.
+ *
+ * @param metadataXml The OData metadata XML content as a string
+ * @param entitySetName The name of the entity set to check
+ * @returns ButtonState for the edit button
+ * @throws {Error} If metadata cannot be parsed or entity set is not found
+ */
+function checkEditVisibility(metadataXml, entitySetName) {
+    try {
+        const convertedMetadata = (0, annotation_converter_1.convert)((0, edmx_parser_1.parse)(metadataXml));
+        const entitySet = convertedMetadata.entitySets.find((es) => es.name === entitySetName);
+        if (!entitySet) {
+            throw new Error(`Entity set '${entitySetName}' not found in metadata`);
+        }
+        const updateRestrictions = entitySet.annotations?.Capabilities?.UpdateRestrictions;
+        return analyzeUpdateRestrictions(updateRestrictions);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to analyze edit visibility: ${errorMessage}`);
+    }
+}
+/**
+ * Safely checks button visibility with error handling.
+ *
+ * @param metadata The OData metadata XML content
+ * @param entitySetName The name of the entity set
+ * @param log Optional logger instance
+ * @returns Button visibility result or undefined if error occurs
+ */
+function safeCheckButtonVisibility(metadata, entitySetName, log) {
+    try {
+        return checkButtonVisibility(metadata, entitySetName);
+    }
+    catch (error) {
+        log?.debug(`Failed to check button visibility: ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
+    }
+}
+/**
+ * Safely checks edit button visibility with error handling.
+ *
+ * @param metadata The OData metadata XML content
+ * @param entitySetName The name of the entity set
+ * @param log Optional logger instance
+ * @returns ButtonState for the edit button, or undefined if error occurs
+ */
+function safeCheckEditVisibility(metadata, entitySetName, log) {
+    try {
+        return checkEditVisibility(metadata, entitySetName);
+    }
+    catch (error) {
+        log?.debug(`Failed to check edit visibility: ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
+    }
+}
+//# sourceMappingURL=actionUtils.js.map

package/dist/utils/listReportUtils.d.ts

@@ -1,8 +1,11 @@
 import type { Logger } from '@sap-ux/logger';
 import type { TreeAggregations, TreeModel } from '@sap/ux-specification/dist/types/src/parser';
-import type { ActionButtonsResult, ActionButtonState, ButtonState, ButtonVisibilityResult, FEV4ManifestTarget, ListReportFeatures } from '../types';
+import type { ActionButtonsResult, ActionButtonState, ButtonState, FEV4ManifestTarget, ListReportFeatures } from '../types';
+import { safeCheckButtonVisibility } from './actionUtils';
 import type { PageWithModelV4 } from '@sap/ux-specification/dist/types/src/parser/application';
 import type { Manifest } from '@sap-ux/project-access';
+export { checkButtonVisibility, safeCheckEditVisibility } from './actionUtils';
+export { safeCheckButtonVisibility };
 /**
  * Builds a button state object from button visibility result.
  *
@@ -14,15 +17,6 @@ export declare function buildButtonState(buttonState?: ButtonState): {
     enabled?: boolean | 'dynamic';
     dynamicPath?: string;
 };
-/**
- * Safely checks button visibility with error handling.
- *
- * @param metadata - The OData metadata XML content
- * @param entitySetName - The name of the entity set
- * @param log - Optional logger instance
- * @returns Button visibility result or undefined if error occurs
- */
-export declare function safeCheckButtonVisibility(metadata: string, entitySetName: string, log?: Logger): ButtonVisibilityResult | undefined;
 /**
  * Safely checks action button states with error handling.
  *
@@ -67,16 +61,6 @@ export declare function getListReportFeatures(listReportPage: PageWithModelV4, l
  * @returns The toolbar actions aggregation object.
  */
 export declare function getToolBarActions(pageModel: TreeModel): TreeAggregations;
-/**
- * Checks the visibility and enabled state of create and delete buttons for a given entity set
- * by analyzing OData Capabilities annotations in the metadata.
- *
- * @param metadataXml The OData metadata XML content as a string
- * @param entitySetName The name of the entity set to check
- * @returns ButtonVisibilityResult containing the state of create and delete buttons
- * @throws {Error} If metadata cannot be parsed or entity set is not found
- */
-export declare function checkButtonVisibility(metadataXml: string, entitySetName: string): ButtonVisibilityResult;
 /**
  * Retrieves filter field names from the page model using ux-specification.
  *

package/dist/utils/listReportUtils.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeCheckButtonVisibility = exports.safeCheckEditVisibility = exports.checkButtonVisibility = void 0;
 exports.buildButtonState = buildButtonState;
-exports.safeCheckButtonVisibility = safeCheckButtonVisibility;
 exports.safeCheckActionButtonStates = safeCheckActionButtonStates;
 exports.isALPManifestTarget = isALPManifestTarget;
 exports.isALPFromManifest = isALPFromManifest;
 exports.getListReportFeatures = getListReportFeatures;
 exports.getToolBarActions = getToolBarActions;
-exports.checkButtonVisibility = checkButtonVisibility;
 exports.getFilterFieldNames = getFilterFieldNames;
 exports.checkActionButtonStates = checkActionButtonStates;
 exports.getToolBarActionNames = getToolBarActionNames;
@@ -15,6 +14,11 @@ exports.getToolBarActionItems = getToolBarActionItems;
 const modelUtils_1 = require("./modelUtils");
 const edmx_parser_1 = require("@sap-ux/edmx-parser");
 const annotation_converter_1 = require("@sap-ux/annotation-converter");
+const actionUtils_1 = require("./actionUtils");
+Object.defineProperty(exports, "safeCheckButtonVisibility", { enumerable: true, get: function () { return actionUtils_1.safeCheckButtonVisibility; } });
+var actionUtils_2 = require("./actionUtils");
+Object.defineProperty(exports, "checkButtonVisibility", { enumerable: true, get: function () { return actionUtils_2.checkButtonVisibility; } });
+Object.defineProperty(exports, "safeCheckEditVisibility", { enumerable: true, get: function () { return actionUtils_2.safeCheckEditVisibility; } });
 /**
  * Builds a button state object from button visibility result.
  *
@@ -28,23 +32,6 @@ function buildButtonState(buttonState) {
         dynamicPath: buttonState?.enabled === 'dynamic' ? buttonState.dynamicPath : undefined
     };
 }
-/**
- * Safely checks button visibility with error handling.
- *
- * @param metadata - The OData metadata XML content
- * @param entitySetName - The name of the entity set
- * @param log - Optional logger instance
- * @returns Button visibility result or undefined if error occurs
- */
-function safeCheckButtonVisibility(metadata, entitySetName, log) {
-    try {
-        return checkButtonVisibility(metadata, entitySetName);
-    }
-    catch (error) {
-        log?.debug(`Failed to check button visibility: ${error instanceof Error ? error.message : String(error)}`);
-        return undefined;
-    }
-}
 /**
  * Safely checks action button states with error handling.
  *
@@ -103,7 +90,7 @@ function isALPFromManifest(manifest, targetKey) {
  */
 function getListReportFeatures(listReportPage, log, metadata, manifest) {
     const buttonVisibility = metadata && listReportPage.entitySet
-        ? safeCheckButtonVisibility(metadata, listReportPage.entitySet, log)
+        ? (0, actionUtils_1.safeCheckButtonVisibility)(metadata, listReportPage.entitySet, log)
         : undefined;
     const toolbarActions = getToolBarActionNames(listReportPage.model, log);
     return {
@@ -133,34 +120,6 @@ function getToolBarActions(pageModel) {
     const actionAggregations = (0, modelUtils_1.getAggregations)(actions);
     return actionAggregations;
 }
-/**
- * Checks the visibility and enabled state of create and delete buttons for a given entity set
- * by analyzing OData Capabilities annotations in the metadata.
- *
- * @param metadataXml The OData metadata XML content as a string
- * @param entitySetName The name of the entity set to check
- * @returns ButtonVisibilityResult containing the state of create and delete buttons
- * @throws {Error} If metadata cannot be parsed or entity set is not found
- */
-function checkButtonVisibility(metadataXml, entitySetName) {
-    try {
-        const convertedMetadata = (0, annotation_converter_1.convert)((0, edmx_parser_1.parse)(metadataXml));
-        const entitySet = convertedMetadata.entitySets.find((es) => es.name === entitySetName);
-        if (!entitySet) {
-            throw new Error(`Entity set '${entitySetName}' not found in metadata`);
-        }
-        const insertRestrictions = entitySet.annotations?.Capabilities?.InsertRestrictions;
-        const deleteRestrictions = entitySet.annotations?.Capabilities?.DeleteRestrictions;
-        return {
-            create: analyzeRestriction(insertRestrictions, 'Insertable'),
-            delete: analyzeRestriction(deleteRestrictions, 'Deletable')
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to analyze button visibility: ${errorMessage}`);
-    }
-}
 /**
  * Retrieves filter field names from the page model using ux-specification.
  *
@@ -182,33 +141,6 @@ function getFilterFieldNames(pageModel, log) {
     }
     return filterBarItems;
 }
-/**
- * Analyzes a capability restriction annotation to determine button state.
- *
- * @param restriction The restriction annotation object (InsertRestrictions or DeleteRestrictions)
- * @param propertyName The property name to check ('Insertable' or 'Deletable')
- * @returns ButtonState for the button
- */
-function analyzeRestriction(restriction, propertyName) {
-    const defaultState = { visible: true, enabled: true };
-    if (!restriction) {
-        return defaultState;
-    }
-    const value = restriction[propertyName];
-    if (value === undefined || value === null) {
-        return defaultState;
-    }
-    if (typeof value === 'boolean') {
-        return { visible: value, enabled: value };
-    }
-    if (typeof value === 'object' && value !== null) {
-        const path = value.$Path ?? value.path;
-        if (path) {
-            return { visible: true, enabled: 'dynamic', dynamicPath: path };
-        }
-    }
-    return defaultState;
-}
 /**
  * Checks the state of action buttons defined in UI.LineItem annotations for a given entity set.
  *
@@ -235,8 +167,8 @@ function checkActionButtonStates(metadataXml, entitySetName, actionNames) {
         }
         const dataFieldForActions = lineItemAnnotation.filter((item) => item.$Type === 'com.sap.vocabularies.UI.v1.DataFieldForAction');
         const actions = actionNames
-            ? findActionStates(dataFieldForActions, actionNames, convertedMetadata, entityType.name)
-            : extractAllActionStates(dataFieldForActions, convertedMetadata, entityType.name);
+            ? findActionStates(dataFieldForActions, actionNames, convertedMetadata)
+            : extractAllActionStates(dataFieldForActions, convertedMetadata);
         return { actions, entityType: entityType.name };
     }
     catch (error) {
@@ -250,18 +182,17 @@ function checkActionButtonStates(metadataXml, entitySetName, actionNames) {
  * @param dataFieldForActions List of DataFieldForAction items from UI.LineItem
  * @param actionNames List of action names to find
  * @param metadata The converted metadata
- * @param entityTypeName The entity type name
  * @returns List of action button states for the specified actions
  */
-function findActionStates(dataFieldForActions, actionNames, metadata, entityTypeName) {
+function findActionStates(dataFieldForActions, actionNames, metadata) {
     const actionStates = [];
     for (const actionName of actionNames) {
         const item = dataFieldForActions.find((dfa) => {
-            const actionMethod = extractActionMethodName(dfa.Action || '');
+            const actionMethod = (0, actionUtils_1.extractActionMethodName)(dfa.Action || '');
             return actionMethod === actionName || dfa.Label === actionName;
         });
         if (item) {
-            actionStates.push(buildActionButtonState(item, metadata, entityTypeName));
+            actionStates.push((0, actionUtils_1.buildActionButtonState)(item, metadata));
         }
     }
     return actionStates;
@@ -271,117 +202,10 @@ function findActionStates(dataFieldForActions, actionNames, metadata, entityType
  *
  * @param dataFieldForActions List of DataFieldForAction items from UI.LineItem
  * @param metadata The converted metadata
- * @param entityTypeName The entity type name
  * @returns List of all action button states
  */
-function extractAllActionStates(dataFieldForActions, metadata, entityTypeName) {
-    return dataFieldForActions.map((item) => buildActionButtonState(item, metadata, entityTypeName));
-}
-/**
- * Builds an ActionButtonState object from a DataFieldForAction item.
- *
- * @param item The DataFieldForAction item
- * @param metadata The converted metadata
- * @param entityTypeName The entity type name
- * @returns ActionButtonState for the action
- */
-function buildActionButtonState(item, metadata, entityTypeName) {
-    const actionMethod = extractActionMethodName(item.Action || '');
-    const operationAvailable = findOperationAvailableAnnotation(metadata, entityTypeName, actionMethod);
-    // Bound actions whose binding parameter is a single entity (not a collection) require
-    // row selection to be invoked, so they are disabled by default (no row selected).
-    // Collection-bound actions operate on the entity set and are always enabled.
-    const isEntityBound = item.ActionTarget?.isBound === true && item.ActionTarget?.parameters?.[0]?.isCollection !== true;
-    const { enabled, dynamicPath } = analyzeOperationAvailability(operationAvailable, isEntityBound);
-    return {
-        label: item.Label || '',
-        action: item.Action || '',
-        visible: true,
-        enabled,
-        dynamicPath,
-        invocationGrouping: item.InvocationGrouping ? extractEnumMemberValue(item.InvocationGrouping) : undefined
-    };
-}
-/**
- * Analyzes Core.OperationAvailable annotation to determine action availability.
- * Single-entity bound actions (requiring row selection) are disabled by default when no annotation is present.
- *
- * @param operationAvailable The OperationAvailable annotation value
- * @param isEntityBound Whether the action is bound to a single entity (requires row selection to enable)
- * @returns Object containing enabled state and optional dynamic path
- */
-function analyzeOperationAvailability(operationAvailable, isEntityBound) {
-    if (operationAvailable === undefined) {
-        return { enabled: !isEntityBound };
-    }
-    if (typeof operationAvailable === 'boolean') {
-        return { enabled: operationAvailable };
-    }
-    if (typeof operationAvailable === 'object' && operationAvailable !== null) {
-        const path = operationAvailable.$Path ?? operationAvailable.path;
-        if (path) {
-            return { enabled: 'dynamic', dynamicPath: path };
-        }
-    }
-    return { enabled: true };
-}
-/**
- * Extracts the action method name from a fully qualified action string.
- *
- * @param actionName The fully qualified action name
- * @returns The action method name
- */
-function extractActionMethodName(actionName) {
-    const match = /\.([^.()]+)\(/.exec(actionName);
-    if (match?.[1]) {
-        return match[1];
-    }
-    const lastDotIndex = actionName.lastIndexOf('.');
-    const parenIndex = actionName.indexOf('(');
-    if (lastDotIndex !== -1 && parenIndex !== -1) {
-        return actionName.substring(lastDotIndex + 1, parenIndex);
-    }
-    return actionName;
-}
-/**
- * Finds the Core.OperationAvailable annotation for a specific action.
- *
- * @param metadata The converted metadata
- * @param entityTypeName The entity type name
- * @param actionMethodName The action method name
- * @returns The OperationAvailable annotation value or undefined if not found
- */
-function findOperationAvailableAnnotation(metadata, entityTypeName, actionMethodName) {
-    if (metadata.actions) {
-        const action = metadata.actions.find((a) => a.name === actionMethodName || a.fullyQualifiedName?.includes(`.${actionMethodName}(`));
-        if (action?.annotations?.Core?.OperationAvailable !== undefined) {
-            return action.annotations.Core.OperationAvailable;
-        }
-    }
-    if (metadata.entityContainer?.annotations) {
-        const annotations = metadata.entityContainer.annotations;
-        const matchingKey = Object.keys(annotations).find((key) => key.includes(actionMethodName));
-        if (matchingKey && annotations[matchingKey]?.Core?.OperationAvailable !== undefined) {
-            return annotations[matchingKey].Core.OperationAvailable;
-        }
-    }
-    return undefined;
-}
-/**
- * Extracts the enum member value from an annotation.
- *
- * @param enumValue The enum value object
- * @returns The extracted enum value string
- */
-function extractEnumMemberValue(enumValue) {
-    if (typeof enumValue === 'string') {
-        return enumValue;
-    }
-    if (enumValue?.$EnumMember) {
-        const parts = enumValue.$EnumMember.split('/');
-        return parts[1] ?? enumValue.$EnumMember;
-    }
-    return undefined;
+function extractAllActionStates(dataFieldForActions, metadata) {
+    return dataFieldForActions.map((item) => (0, actionUtils_1.buildActionButtonState)(item, metadata));
 }
 /**
  * Retrieves toolbar action names from the page model using ux-specification.

package/dist/utils/modelUtils.js

@@ -62,7 +62,7 @@ async function getAppFeatures(basePath, fs, log, metadata, manifest) {
         }
         if (objectPages) {
             log?.warn('Extracting Object Page features from application model');
-            featureData.objectPages = await (0, objectPageUtils_1.getObjectPageFeatures)(objectPages, listReportPage?.name, log);
+            featureData.objectPages = await (0, objectPageUtils_1.getObjectPageFeatures)(objectPages, listReportPage?.name, log, projectMetadata);
             log?.warn('objectPages features extracted: ' + JSON.stringify(featureData.objectPages));
         }
         if (fpmPage) {

package/dist/utils/objectPageUtils.d.ts

@@ -8,9 +8,10 @@ import type { PageWithModelV4 } from '@sap/ux-specification/dist/types/src/parse
  * @param objectPages - the array of object pages extracted from the application model
  * @param listReportPageKey - the key of the List Report page in the application model, used to find navigation routes to object pages
  * @param log - optional logger instance
+ * @param metadata - optional metadata for the OPA test generation
  * @returns a record of object page feature data
  */
-export declare function getObjectPageFeatures(objectPages: PageWithModelV4[], listReportPageKey?: string, log?: Logger): Promise<ObjectPageFeatures[]>;
+export declare function getObjectPageFeatures(objectPages: PageWithModelV4[], listReportPageKey?: string, log?: Logger, metadata?: string): Promise<ObjectPageFeatures[]>;
 /**
  * Retrieves all Object Page definitions from the given application model, as long as the page is reachable via standard navigation routes.
  *

package/dist/utils/objectPageUtils.js

@@ -5,29 +5,43 @@ exports.getObjectPages = getObjectPages;
 const modelUtils_1 = require("./modelUtils");
 const tableUtils_1 = require("./tableUtils");
 const page_1 = require("@sap/ux-specification/dist/types/src/common/page");
+const edmx_parser_1 = require("@sap-ux/edmx-parser");
+const annotation_converter_1 = require("@sap-ux/annotation-converter");
+const actionUtils_1 = require("./actionUtils");
 /**
  * Extracts feature data for object pages from the application model.
  *
  * @param objectPages - the array of object pages extracted from the application model
  * @param listReportPageKey - the key of the List Report page in the application model, used to find navigation routes to object pages
  * @param log - optional logger instance
+ * @param metadata - optional metadata for the OPA test generation
  * @returns a record of object page feature data
  */
-async function getObjectPageFeatures(objectPages, listReportPageKey, log) {
+async function getObjectPageFeatures(objectPages, listReportPageKey, log, metadata) {
     const objectPageFeatures = [];
     if (!objectPages || objectPages.length === 0) {
         log?.warn('Object Pages not found in application model. Dynamic tests will not be generated for Object Pages.');
         return objectPageFeatures;
     }
     // attempt to get individual feature data for each object page
+    const convertedMetadata = metadata ? (0, annotation_converter_1.convert)((0, edmx_parser_1.parse)(metadata)) : undefined;
+    const schemaNamespace = convertedMetadata?.namespace ?? '';
     for (const objectPage of objectPages) {
         const pageFeatureData = {};
         pageFeatureData.name = objectPage.name;
         pageFeatureData.navigationParents = getObjectPageNavigationParents(objectPage.name, objectPages, listReportPageKey);
         // extract header sections (facets)
         pageFeatureData.headerSections = extractObjectPageHeaderSectionsData(objectPage);
-        // extract body sections
-        pageFeatureData.bodySections = extractObjectPageBodySectionsData(objectPage);
+        // extract body sections (includes section-level actions and standard create/delete buttons)
+        pageFeatureData.bodySections = extractObjectPageBodySectionsData(objectPage, convertedMetadata, schemaNamespace, metadata, log);
+        // extract header-level actions
+        pageFeatureData.headerActions = convertedMetadata
+            ? extractHeaderActions(objectPage, convertedMetadata, schemaNamespace)
+            : [];
+        // determine edit button visibility from UpdateRestrictions on the OP entity set
+        if (metadata && objectPage.entitySet) {
+            pageFeatureData.editButton = (0, actionUtils_1.safeCheckEditVisibility)(metadata, objectPage.entitySet, log);
+        }
         objectPageFeatures.push(pageFeatureData);
     }
     return objectPageFeatures;
@@ -110,9 +124,13 @@ function extractObjectPageHeaderSectionsData(objectPage) {
  * Extracts body sections data from an object page model.
  *
  * @param objectPage - object page from the application model
+ * @param convertedMetadata - optional converted OData metadata for action extraction
+ * @param schemaNamespace - optional OData schema namespace used as service identifier in action assertions
+ * @param metadata - optional raw metadata XML for resolving standard button visibility (Create/Delete)
+ * @param log - optional logger instance
  * @returns body sections data including sub-sections
  */
-function extractObjectPageBodySectionsData(objectPage) {
+function extractObjectPageBodySectionsData(objectPage, convertedMetadata, schemaNamespace, metadata, log) {
     const bodySections = [];
     if (objectPage.model) {
         const sectionsAggregation = (0, modelUtils_1.getAggregations)(objectPage.model.root)['sections'];
@@ -120,20 +138,81 @@ function extractObjectPageBodySectionsData(objectPage) {
         Object.entries(sections).forEach(([sectionKey, section]) => {
             const sectionId = getSectionIdentifier(section) ?? sectionKey;
             const subSections = extractBodySubSectionsData(section, sectionId);
-            bodySections.push({
+            const navigationProperty = getNavigationPropertyFromKey(sectionKey);
+            const sectionData = {
                 id: sectionId,
-                navigationProperty: getNavigationPropertyFromKey(sectionKey),
+                navigationProperty,
                 isTable: !!section.isTable,
                 custom: !!section.custom,
-                order: section?.order ?? -1, // put a negative order number to signal that order was not in spec
+                order: section?.order ?? -1,
                 fields: section.custom || section.isTable ? [] : extractFormFields(section),
                 tableColumns: section.custom || !section.isTable ? {} : (0, tableUtils_1.extractTableColumnsFromNode)(section),
-                subSections
-            });
+                subSections,
+                actions: !section.custom && convertedMetadata && schemaNamespace
+                    ? extractSectionActions(section, convertedMetadata, schemaNamespace)
+                    : []
+            };
+            // For table sections, resolve Create/Delete visibility from target entity set
+            if (section.isTable && navigationProperty && metadata && convertedMetadata) {
+                const targetEntitySet = resolveNavigationTargetEntitySet(convertedMetadata, objectPage.entitySet, navigationProperty);
+                if (targetEntitySet) {
+                    const buttonVisibility = (0, actionUtils_1.safeCheckButtonVisibility)(metadata, targetEntitySet, log);
+                    sectionData.createButton = buttonVisibility?.create;
+                    sectionData.deleteButton = buttonVisibility?.delete;
+                }
+            }
+            bodySections.push(sectionData);
         });
     }
     return bodySections;
 }
+/**
+ * Extracts header-level action button states from an object page model.
+ *
+ * @param objectPage - object page from the application model
+ * @param convertedMetadata - converted OData metadata for resolving action availability
+ * @param schemaNamespace - OData schema namespace used as service identifier in action assertions
+ * @returns array of action button states for the header toolbar
+ */
+function extractHeaderActions(objectPage, convertedMetadata, schemaNamespace) {
+    if (!objectPage.model) {
+        return [];
+    }
+    const headerAgg = (0, modelUtils_1.getAggregations)(objectPage.model.root)['header'];
+    const actionsAgg = (0, modelUtils_1.getAggregations)(headerAgg)['actions'];
+    const actionEntries = (0, modelUtils_1.getAggregations)(actionsAgg);
+    return Object.entries(actionEntries)
+        .map(([key, item]) => (0, actionUtils_1.buildActionStateFromSpecModelKey)(key, item.description, convertedMetadata, schemaNamespace))
+        .filter((actionState) => actionState !== undefined);
+}
+/**
+ * Extracts section-level action button states from a body section.
+ * For table sections, actions are extracted from the table toolbar; for form sections from the form actions aggregation.
+ *
+ * @param section - body section entry from the application model
+ * @param convertedMetadata - converted OData metadata for resolving action availability
+ * @param schemaNamespace - OData schema namespace used as service identifier in action assertions
+ * @returns array of action button states for the section toolbar
+ */
+function extractSectionActions(section, convertedMetadata, schemaNamespace) {
+    let actionsAgg;
+    if (section.isTable) {
+        const tableAgg = (0, modelUtils_1.getAggregations)(section)['table'];
+        const toolBarAgg = (0, modelUtils_1.getAggregations)(tableAgg)['toolBar'];
+        actionsAgg = (0, modelUtils_1.getAggregations)(toolBarAgg)['actions'];
+    }
+    else {
+        const formAgg = (0, modelUtils_1.getAggregations)(section)['form'];
+        actionsAgg = (0, modelUtils_1.getAggregations)(formAgg)['actions'];
+    }
+    if (!actionsAgg) {
+        return [];
+    }
+    const actionEntries = (0, modelUtils_1.getAggregations)(actionsAgg);
+    return Object.entries(actionEntries)
+        .map(([key, item]) => (0, actionUtils_1.buildActionStateFromSpecModelKey)(key, item.description, convertedMetadata, schemaNamespace))
+        .filter((actionState) => actionState !== undefined);
+}
 /**
  * Extracts sub-sections data from a body section.
  *
@@ -193,6 +272,27 @@ function getNavigationPropertyFromKey(sectionKey) {
     const prefix = sectionKey.split('::')[0];
     return prefix.startsWith('_') ? prefix : undefined;
 }
+/**
+ * Resolves the target entity set name for a navigation property by looking up navigation
+ * property bindings in the source entity set's metadata.
+ *
+ * @param convertedMetadata - converted OData metadata
+ * @param sourceEntitySetName - the name of the source entity set (the Object Page's entity set)
+ * @param navigationProperty - the navigation property name (e.g. '_Booking')
+ * @returns the target entity set name, or undefined if resolution fails
+ */
+function resolveNavigationTargetEntitySet(convertedMetadata, sourceEntitySetName, navigationProperty) {
+    if (!sourceEntitySetName) {
+        return undefined;
+    }
+    const sourceEntitySet = convertedMetadata.entitySets.find((es) => es.name === sourceEntitySetName);
+    if (!sourceEntitySet?.navigationPropertyBinding) {
+        return undefined;
+    }
+    const navPropName = navigationProperty.startsWith('_') ? navigationProperty.substring(1) : navigationProperty;
+    const binding = sourceEntitySet.navigationPropertyBinding[navPropName];
+    return binding?.name;
+}
 /**
  * Gets the identifier of a section for OPA5 tests.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sap-ux/ui5-test-writer",
   "description": "SAP UI5 tests writer",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/SAP/open-ux-tools.git",

package/templates/v4/integration/ObjectPageJourney.js

@@ -39,6 +39,26 @@ sap.ui.define([
             Then.onThe<%- name%>.iSeeThisPage();
         });
 
+<% if (headerActions?.length > 0 && !isStandalone) { -%>
+        opaTest("Check header actions of the Object Page", function (Given, When, Then) {
+<% if (editButton?.visible) { -%>
+            // Ensure the opened entity is not in Draft state before uncommenting
+            // Then.onThe<%- name%>.onHeader().iCheckEdit({ visible: true });
+            // When.onThe<%- name%>.onHeader().iPressEdit();
+<% } -%>
+<%     headerActions.forEach(function(action) { -%>
+<%     if (action.visible) { -%>
+<%         if (action.enabled === 'dynamic') { -%>
+            Then.onThe<%- name%>.onHeader().iCheckAction("<%- action.label %>" /* , { enabled: true } */);
+<%         } else { -%>
+            Then.onThe<%- name%>.onHeader().iCheckAction("<%- action.label %>", { enabled: <%- action.enabled === true %> });
+<%         } -%>
+            // When.onThe<%- name%>.onHeader().iPressAction("<%- action.label %>");
+<%     } -%>
+<%     }); -%>
+        });
+<% } -%>
+
 <% if (headerSections?.length > 0) { -%>
         opaTest("Check header facets of the Object Page", function (Given, When, Then) {
 <% headerSections.forEach(function(section) { -%>
@@ -70,6 +90,37 @@ sap.ui.define([
             When.onThe<%- name%>.iPressSectionIconTabFilterButton("<%- section.id %>");
 <% } -%>
             Then.onThe<%- name%>.iCheckSection({ section: "<%- section.id %>" });
+<%  if (section.actions && section.actions.length > 0) { -%>
+<%      section.actions.forEach(function(action) { -%>
+<%      if (action.visible) { -%>
+<%          if (section.isTable && section.navigationProperty) { -%>
+<%              if (action.enabled === 'dynamic') { -%>
+            Then.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iCheckAction("<%- action.label %>" /* , { enabled: true } */);
+<%              } else { -%>
+            Then.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iCheckAction("<%- action.label %>", { enabled: <%- action.enabled === true %> });
+<%              } -%>
+            // When.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iPressAction("<%- action.label %>");
+<%          } else { -%>
+<%              if (action.enabled === 'dynamic') { -%>
+            Then.onThe<%- name%>.onForm({ section: "<%- section.id %>" }).iCheckAction("<%- action.label %>" /* , { enabled: true } */);
+<%              } else { -%>
+            Then.onThe<%- name%>.onForm({ section: "<%- section.id %>" }).iCheckAction("<%- action.label %>", { enabled: <%- action.enabled === true %> });
+<%              } -%>
+            // When.onThe<%- name%>.onForm({ section: "<%- section.id %>" }).iPressAction("<%- action.label %>");
+<%          } -%>
+<%      } -%>
+<%      }); -%>
+<%  } -%>
+<% if (section.isTable && section.navigationProperty) { -%>
+<% if (section.createButton?.visible) { -%>
+            Then.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iCheckCreate({ visible: true });
+            // When.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iPressCreate();
+<% } -%>
+<% if (section.deleteButton?.visible) { -%>
+            Then.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iCheckDelete({ visible: true });
+            // When.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iPressDelete();
+<% } -%>
+<% } -%>
 <% if (section?.subSections?.length > 0) { -%>
 <% section.subSections.forEach(function(subSection) { -%>
             //When.onThe<%- name%>.iGoToSection({ section: "<%- section.id %>", subSection: "<%- subSection.id %>" });