@sapui5/sap.suite.ui.generic.template 1.147.2 → 1.148.1

package/src/sap/suite/ui/generic/template/lib/CommonEventHandlers.js

@@ -95,6 +95,7 @@ sap.ui.define(["sap/ui/base/Object",
 		}
 
 		var mVirtualItems = Object.create(null); // cache for virtual items passed to onListNavigateExtension.
+		var mCellHideRowsUpdateHandlers = Object.create(null); // keyed by SmartTable ID: stores rowsUpdated/updateFinished handler for cell hiding
 		var oCurrentPaginatorInfo; // store paginator info while using the pagination
 		function getPaginatorInfo(oTable, oRow, oState){
 			var oRet = oCurrentPaginatorInfo;
@@ -173,7 +174,10 @@ sap.ui.define(["sap/ui/base/Object",
 					oCurrentPaginatorInfo = oRet; // make sure that the navigation below does not create a new paginator info but reuses the existing one
 					onListNavigate(oSourceItem, oState, oTargetContext, true, oViewProxy);
 				};
-				if (bIsActive && bIsEditItem){ // in this case oListBinding (and thus oContext which was derived from it) points to the active version, but we are already in the draft version
+				var oComponent = oController.getOwnerComponent();
+				var bOpenInEditMode = !!oComponent.getEditFlow && oComponent.getEditFlow() === "direct";
+
+				if (bIsActive && bIsEditItem && !bOpenInEditMode){ // in this case oListBinding (and thus oContext which was derived from it) points to the active version, but we are already in the draft version
 					oServices.oApplication.registerContext(oContext, oComponentUtils.getViewLevel() + 1); // determine the sibling context
 					var oSiblingPromise = oServices.oApplication.getDraftSiblingPromise(oContext);        // as the "real" target of this pagination
 					oSiblingPromise.then(fnPaginateImpl);
@@ -1359,50 +1363,96 @@ sap.ui.define(["sap/ui/base/Object",
 		/**
 		 * This method is called in the onDataReceived event of the specified SmartTable.
 		 * It handles everything which can be done regarding hiding of cells at this point in time.
+		 * It also ensures that cell-level hiding is reapplied when rows are updated (e.g. after
+		 * scrolling in a GridTable or after the SmartTable rebuilds its inner table columns).
 		*/
 		function fnHideTableCells(oSmartTable, oHiddenColumnInfo) {
+			if (!oHiddenColumnInfo.columnKeyToCellHiddenPath) {
+				return;
+			}
+			fnApplyCellHiddenBindings(oSmartTable, oHiddenColumnInfo);
+			// Ensure that cell hiding is reapplied whenever the inner table updates its rows.
+			// This is needed because row controls may be recreated (e.g. when the SmartTable
+			// rebuilds columns after setUiState or deactivateColumns), which causes previously
+			// applied cell-level bindings to be lost.
+			fnAttachRowsUpdateHandler(oSmartTable, oHiddenColumnInfo);
+		}
+
+		/**
+		 * Applies cell-level visible bindings for all column keys in columnKeyToCellHiddenPath.
+		 */
+		function fnApplyCellHiddenBindings(oSmartTable, oHiddenColumnInfo) {
 			for (var sColumnKey in oHiddenColumnInfo.columnKeyToCellHiddenPath) {
 				var sPath = oHiddenColumnInfo.columnKeyToCellHiddenPath[sColumnKey];
 				fnHandleTableCellVisibility(oSmartTable, sColumnKey, sPath);
 			}
 		}
 
+		/**
+		 * Attaches a one-time event handler to the inner table's row update event so that
+		 * cell-level hiding is reapplied when rows are recreated. The handler re-attaches
+		 * itself on every dataReceived to keep working across rebinds.
+		 */
+		function fnAttachRowsUpdateHandler(oSmartTable, oHiddenColumnInfo) {
+			var oTable = oSmartTable.getTable();
+			var sSmartTableId = oSmartTable.getId();
+			var sEventName = controlHelper.isUiTable(oTable) ? "rowsUpdated" : "updateFinished";
+			// Detach any previously attached handler to avoid duplicates
+			if (mCellHideRowsUpdateHandlers[sSmartTableId]) {
+				oTable.detachEvent(sEventName, mCellHideRowsUpdateHandlers[sSmartTableId]);
+			}
+			mCellHideRowsUpdateHandlers[sSmartTableId] = function () {
+				fnApplyCellHiddenBindings(oSmartTable, oHiddenColumnInfo);
+			};
+			oTable.attachEvent(sEventName, mCellHideRowsUpdateHandlers[sSmartTableId]);
+		}
+
 		/**
 		 * This method is called for each Row of Table,to control the visibility of the Cell based on the Hidden property in LineItem.
 		 */
 		function fnHandleTableCellVisibility(oSmartTable, sColumnKey, sPath) {
 			var oSmartTableHandler = oServices.oPresentationControlHandlerFactory.getPresentationControlHandler(oSmartTable);
 			var oTable = oSmartTable.getTable();
-			var aItems = oTable.getRows ? oTable.getRows() : oTable.getItems();
+			var aItems = controlHelper.isUiTable(oTable) ? oTable.getRows() : oTable.getItems();
 			var oColumn = oSmartTableHandler.getColumnByKey(sColumnKey);
 			//if the column is visible in the table, then only we bind the visible property of the cell
 			if (oColumn && oColumn.getVisible()){
 				aItems.forEach(function(oItem) {
 					var oCell = oItem.getCells()[oTable.indexOfColumn(oColumn)];
-					oCell && oCell.bindProperty("visible", {
-						path: sPath,
-						formatter: function (bIsHidden) {
-							return !bIsHidden;
+					if (oCell) {
+						// Only apply the binding if it is not already set with the correct path.
+						// This avoids unnecessary teardown/recreation during scroll (rowsUpdated),
+						// while still applying the binding to new cell instances created after a
+						// column rebuild. If a different visible binding already exists (e.g. from
+						// the application), we overwrite it with the cell-hiding binding.
+						var oExistingBinding = oCell.getBindingInfo("visible");
+						if (!oExistingBinding || oExistingBinding.parts[0].path !== sPath) {
+							oCell.bindProperty("visible", {
+								path: sPath,
+								formatter: function (bIsHidden) {
+									return !bIsHidden;
+								}
+							});
 						}
-					});
+					}
 				});
 			}
 		}
 
 		function fnAddMultiEditFieldGroupProperties(oEntityType, sAnnotationPath, aProperties) {
 			if (!sAnnotationPath) { return; }
-			
+
 			// Remove leading '@' if present
-			var sPath = sAnnotationPath.charAt(0) === "@" 
-				? sAnnotationPath.substring(1) 
+			var sPath = sAnnotationPath.charAt(0) === "@"
+				? sAnnotationPath.substring(1)
 				: sAnnotationPath;
-			
+
 			var oFieldGroup = oEntityType[sPath];
-			
+
 			if (oFieldGroup && oFieldGroup.Data && Array.isArray(oFieldGroup.Data)) {
 				oFieldGroup.Data
-					.map(function(oField) { 
-						return oField.Value && oField.Value.Path; 
+					.map(function(oField) {
+						return oField.Value && oField.Value.Path;
 					})
 					.filter(Boolean)
 					.forEach(function(sProp) {
@@ -1647,9 +1697,9 @@ sap.ui.define(["sap/ui/base/Object",
 							}
 						}
 					}
-					
+
 					fnAddMultiEditFieldGroupProperties(oEntityType, oCallbacks.multiEditAnnotationPath, aProperties);
-					
+
 				}
 				// sortOrder Annotation of presentation variant - only relevant for sap.m.Table
 				var oVariant = oSmartTable.fetchVariant();
@@ -1707,7 +1757,10 @@ sap.ui.define(["sap/ui/base/Object",
 			var bOpenInEditMode = !!oComponent.getEditFlow && oComponent.getEditFlow() === "direct";
 			if (bOpenInEditMode){
 				var sEntitySet = oTable.getEntitySet();
-				var oEditPromise = CRUDHelper.directEdit(oServices.oTransactionController, sEntitySet, oBindingContext.sPath, oBindingContext.getModel(), oServices.oApplication, oCommonUtils, oServices.oViewDependencyHelper, oViewProxy, bOpenInEditMode);
+				// oBindingContext is passed directly; the OData model and binding path are resolved inside directEdit.
+				// sAppId is derived here because oController is not accessible inside CRUDHelper.
+				var sAppId = oComponent.getAppComponent().getId();
+				var oEditPromise = CRUDHelper.directEdit(oServices.oTransactionController, sEntitySet, oBindingContext, oServices.oApplication, sAppId, oCommonUtils, oServices.oViewDependencyHelper, oViewProxy, bOpenInEditMode);
 				oEditPromise.then(function(oResult){
 					oCommonUtils.navigateFromListItem(oResult.context, bReplace, true);
 				}, function(oError){
@@ -2719,7 +2772,7 @@ sap.ui.define(["sap/ui/base/Object",
 
 		/**
 		 * Function modifies dataUrl, where we remove all 1:n properties from dataUrl.
-		 * 
+		 *
 		 * @param {*} oExportEvent - event handler for export.
 		 * @param {*} aNavRestriction - list of 1:n navigation properties
 		 */
@@ -2785,7 +2838,7 @@ sap.ui.define(["sap/ui/base/Object",
 					if (oColumn.columnId && typeof oColumn.property === "string") {
 						// checking for additional column.
 						// in general, additional column don't have column Id.
-						var bHasAdditionalColumns = i < oExportEvent.mParameters.exportSettings.workbook.columns.length - 2 && !oExportEvent.mParameters.exportSettings.workbook.columns[i + 1].columnId;
+						var bHasAdditionalColumns = i < oExportEvent.mParameters.exportSettings.workbook.columns.length - 1 && !oExportEvent.mParameters.exportSettings.workbook.columns[i + 1].columnId;
 						if (bHasAdditionalColumns) {
 							const sNavProperty = metadataAnalyser.checkFor1ToNProperty(oTable, sEntitySet, oColumn.property) || metadataAnalyser.checkFor1ToNProperty(oTable, sEntitySet, oExportEvent.mParameters.exportSettings.workbook.columns[i + 1].property);
 							if (sNavProperty) {
@@ -2895,6 +2948,10 @@ sap.ui.define(["sap/ui/base/Object",
 		var fnRenderTeamsContactCollabOptions = testableHelper.testable(fnRenderTeamsContactCollabOptions, "fnRenderTeamsContactCollabOptions");
 		var removeUnsupportedColumnsToExport = testableHelper.testable(removeUnsupportedColumnsToExport, "removeUnsupportedColumnsToExport");
 		var fnAddMultiEditFieldGroupProperties = testableHelper.testable(fnAddMultiEditFieldGroupProperties,"fnAddMultiEditFieldGroupProperties");
+		var fnHideTableCells = testableHelper.testable(fnHideTableCells, "fnHideTableCells");
+		var fnApplyCellHiddenBindings = testableHelper.testable(fnApplyCellHiddenBindings, "fnApplyCellHiddenBindings");
+		var fnAttachRowsUpdateHandler = testableHelper.testable(fnAttachRowsUpdateHandler, "fnAttachRowsUpdateHandler");
+		var fnHandleTableCellVisibility = testableHelper.testable(fnHandleTableCellVisibility, "fnHandleTableCellVisibility");
 		/* eslint-enable */
 
 		return {

package/src/sap/suite/ui/generic/template/lib/CommonUtils.js

@@ -2,6 +2,7 @@ sap.ui.define(["sap/ui/base/Object",
 	"sap/ui/core/mvc/ControllerExtension",
 	"sap/m/MessageBox",
 	"sap/fe/navigation/SelectionVariant",
+	"sap/fe/navigation/library",
 	"sap/suite/ui/generic/template/genericUtilities/controlHelper",
 	"sap/suite/ui/generic/template/genericUtilities/metadataAnalyser",
 	"sap/suite/ui/generic/template/genericUtilities/testableHelper",
@@ -22,6 +23,7 @@ sap.ui.define(["sap/ui/base/Object",
 	ControllerExtension,
 	MessageBox,
 	SelectionVariant,
+	FENavLibrary,
 	controlHelper,
 	metadataAnalyser,
 	testableHelper,
@@ -1018,6 +1020,7 @@ sap.ui.define(["sap/ui/base/Object",
 			var oSelectionVariant, sSelectionVariantPrepared, sParameter, sSemanticObject, aSelVariantPropertyNames, aSelOptionPropertyNames, aParameterNames;
 			var oEventParameters = oEvent.getParameters();
 			var oNavigationHandler = oServices.oApplication.getNavigationHandler();
+			var SuppressionBehavior = FENavLibrary.SuppressionBehavior;
 			// fill oSelectionVariant with the selectOptions from sSelectionVariant
 			oSelectionVariant = oNavigationHandler.mixAttributesAndSelectionVariant({}, sSelectionVariant);
 			//Invoke the "beforeSmartLinkPopoverOpensExtension" method to determine whether FE can process the event.
@@ -1065,7 +1068,7 @@ sap.ui.define(["sap/ui/base/Object",
 					}
 				});
 				// add the resulting selectOptions and parameters (if any!) in oSelectionVariant with the ones of the semanticObject in oEventParameters as selectOptions to oSelectionVariant
-				oSelectionVariant = oNavigationHandler.mixAttributesAndSelectionVariant(mSemanticAttributesOfEventSemanticObject, oSelectionVariant.toJSONString());
+				oSelectionVariant = oNavigationHandler.mixAttributesAndSelectionVariant(mSemanticAttributesOfEventSemanticObject, oSelectionVariant.toJSONString(), SuppressionBehavior.ignoreEmptyString);
 				// Remove sensitive data from the context
 				oSelectionVariant = fnRemovePropertiesFromNavigationContext(oSelectionVariant, oEvent.getSource(), oState);
 				var oObjectInfo = {

package/src/sap/suite/ui/generic/template/lib/ComponentUtils.js

@@ -1,6 +1,7 @@
 sap.ui.define([
 	"sap/ui/base/Object",
 	"sap/ui/model/base/ManagedObjectModel",
+	"sap/ui/core/routing/History",
 	"sap/suite/ui/generic/template/genericUtilities/controlHelper",
 	"sap/suite/ui/generic/template/genericUtilities/FeLogger",
 	"sap/suite/ui/generic/template/genericUtilities/oDataModelHelper",
@@ -15,6 +16,7 @@ sap.ui.define([
 ], function(
 	BaseObject,
 	ManagedObjectModel,
+	History,
 	controlHelper,
 	FeLogger,
 	oDataModelHelper,
@@ -552,7 +554,14 @@ sap.ui.define([
 				} else {
 					var oElementBinding = oComponentContainer.getElementBinding();
 					if (oElementBinding){
-						if (sLogicalBindingPath === sBindingPath) {
+						// NEW: Force rebind on browser back for nested pages
+						var bIsBrowserBack = false;
+						if (History && History.getInstance() && !bIsComponentCurrentlyActive) {
+							var bIsNestedPage = oTreeNode.level > 1;
+							bIsBrowserBack = History.getInstance().getDirection() === "Backwards" && bIsNestedPage;
+						}
+
+						if (sLogicalBindingPath === sBindingPath && !bIsBrowserBack) {
 							/*
 							* component is already bound to this object - no rebound to avoid that 1:1, 1:N and expands are read
 							* again
@@ -1098,20 +1107,21 @@ sap.ui.define([
 		}
 
 		function fnGetOutboundNavigationIntent(oInternalManifest, sOutbound) {
-            var oManifestOutbounds = oInternalManifest["sap.app"].crossNavigation && oInternalManifest["sap.app"].crossNavigation.outbounds;
-            return (oManifestOutbounds && oManifestOutbounds[sOutbound]) || Object.create(null);
-        }
+			var oManifestOutbounds = oInternalManifest["sap.app"].crossNavigation && oInternalManifest["sap.app"].crossNavigation.outbounds;
+			return (oManifestOutbounds && oManifestOutbounds[sOutbound]) || Object.create(null);
+		}
 
 		function fnCanNavigateToSubEntitySet(sEntitySet) {
 			var aSubPages = oTreeNode.page.pages;
+			var sCreationEntitySet = oTreeNode.page.component?.settings?.creationEntitySet;
 			return !!(aSubPages && aSubPages.some(function (oSubPage) {
-				return sEntitySet === oSubPage.entitySet;
+				return sEntitySet === oSubPage.entitySet || sCreationEntitySet === oSubPage.entitySet;
 			}));
 		}
 
-        function fnIsStateHandlingSuspended() {
+		function fnIsStateHandlingSuspended() {
 			return oComponentRegistryEntry.oTemplateContract.bStateHandlingSuspended;
-        }
+		}
 		
 		function fnGetUI5VersionInfo() {
 			var oTemplatePrivateGlobalModel = getTemplatePrivateGlobalModel();

package/src/sap/suite/ui/generic/template/lib/StableIdDefinition.js

@@ -3,63 +3,63 @@ sap.ui.define(["sap/suite/ui/generic/template/genericUtilities/FeError"],functio
 
 	/* This class aims to provide the structure of all stable ids created by Fiori elements.
 	 * Currently still missing: Legacy ids not yet migrated.
-	 * 
-	 * In Fiori elements apps, the controls created depend on the annotations and manifest settings. Therefore, stable ids given by Fiori elements cannot be just fixed strings in all cases, but must 
-	 * be generated out of annotations and manifest settings. When these settings are changed, this can be considered as a change to the app, that might allow a change of the generated ids. However, 
-	 * some changes should be considered as being compatible, e.g. adding a new section to the ObjectPage. In such a case, the ids of any controls not related to the change, e.g. controls on other 
+	 *
+	 * In Fiori elements apps, the controls created depend on the annotations and manifest settings. Therefore, stable ids given by Fiori elements cannot be just fixed strings in all cases, but must
+	 * be generated out of annotations and manifest settings. When these settings are changed, this can be considered as a change to the app, that might allow a change of the generated ids. However,
+	 * some changes should be considered as being compatible, e.g. adding a new section to the ObjectPage. In such a case, the ids of any controls not related to the change, e.g. controls on other
 	 * sections, must not be changed.
 	 * To achieve this, all possible ids are classified as types and subtypes corresponding to Fiori elements features, using parameters for all input derived from annotations or manifest settings.
-	 * 
+	 *
 	 * Originally, the stable ids were created within the xml fragments, sometimes using different formatters (AnnotationHelpers). With the library growing more and more, this made it quite cumbersome
 	 * to understand which possible ids might be created (and in fact, several unwanted possibilities of clashes were introduced).
 	 * Therefore, the so-called stable id concept introduced a more generic approach to build stable ids. With this, all stable ids should be generated using the StableIdHelper method getStableId,
 	 * which in turn uses this class as definition for the rules how to create the ids.
-	 * 
-	 * Of course, all ids used before must not be changed. Therefore, this class allows to describe how those ids were created. All these ids are referred to as legacy ids, while all newer ids are 
+	 *
+	 * Of course, all ids used before must not be changed. Therefore, this class allows to describe how those ids were created. All these ids are referred to as legacy ids, while all newer ids are
 	 * referred to as standard ids.
 	 *
-	 * 
+	 *
 	 * The returned JSON object contains two properties:
 	 * 1. parameters: An array of all possible parameters. First character of the parameter describes the type - as in most cases (for standard always) they become directly part of the generated id,
 	 * 	most parameter names start with s. In case of new (standard) ids with multiple parameters the order here defines the order used in the generated id, therefore new parameters may only be
-	 * 	added to the end. 
-	 * 2. types: JSON-object. Its properties define the types. New property names can be added (for new ids), but existing ones must not be changed.  
+	 * 	added to the end.
+	 * 2. types: JSON-object. Its properties define the types. New property names can be added (for new ids), but existing ones must not be changed.
 	 * 		subTypes: JSON-object. The properties of the type object are the possible subTypes. The same rules as for types apply for subTypes. (subTyoes are only introduced to create better
-	 * 				structure. However, depth is fixed, i.e. each stable id belongs to one type and subType). 
+	 * 				structure. However, depth is fixed, i.e. each stable id belongs to one type and subType).
 	 * 				The subType object describes the actual definition of the stable id. It has the properties (all of them optional):
 	 * 			parameters: parameter names relevant (and mandatory) for this id. Only names defined in the parameters array are allowed.
 	 * 			optionalParameters: optional parameter names relevant for this id. Only names defined in the parameters array are allowed.
 	 * 			value: Only relevant for legacy ids!
-	 * 				Can be a string (in case of legacy ids without parameters) used as id or a function returning the stable id. In this case, the function is called with a json object as parameter, 
-	 * 				with properties according to the parameters and optionalParameters defined. 
-	 * 				The function may return undefined, in this case the id is created as standard id. (This may be used for legacy ids enhanced with optional parameters for new feature - e.g. multiple 
-	 * 				views on ALP: Single view existed before the stable id concept, so ids for single table are legacy, but multiple views (with optional parameter sQuickVariantKey) was only 
+	 * 				Can be a string (in case of legacy ids without parameters) used as id or a function returning the stable id. In this case, the function is called with a json object as parameter,
+	 * 				with properties according to the parameters and optionalParameters defined.
+	 * 				The function may return undefined, in this case the id is created as standard id. (This may be used for legacy ids enhanced with optional parameters for new feature - e.g. multiple
+	 * 				views on ALP: Single view existed before the stable id concept, so ids for single table are legacy, but multiple views (with optional parameter sQuickVariantKey) was only
 	 * 				introduced later, so new ids used here should be standard.)
 	 * 				If the function needs to indicate that no stable id could be generated (and it should also not be generated as standard id), it may throw an error. Currently, in this case the id
 	 * 				would be undefined, which would make UI5 generate an id which is not stable (and tools would know that it's not stable).
-	 * 
+	 *
 	 * Some ids are also used as parameters for other ids. This makes sense especially in case of nested collections (e.g. columns of tables on OP: To avoid clashes for tables in different section,
-	 * some information of the section must be part of the id for the table. Now, several tables could have columns for properties with same name (esp. for were common names - like "id") - to avoid 
-	 * clashes here, we need to take the section information into account. But we don't want to think of this explicitly over and again, therefore we just take the id of the smart table as parameter 
+	 * some information of the section must be part of the id for the table. Now, several tables could have columns for properties with same name (esp. for were common names - like "id") - to avoid
+	 * clashes here, we need to take the section information into account. But we don't want to think of this explicitly over and again, therefore we just take the id of the smart table as parameter
 	 * for the id of the column.
-	 * Parameters in ids currently using other ids [type/subType] as values: 
+	 * Parameters in ids currently using other ids [type/subType] as values:
 	 * - sSmartTableId: ListReportTable/SmartTable, ALPTable/SmartTable, ObjectPageTable/SmartTable, all also used directly
 	 * - sFacet: ObjectPage/HeaderFacet, ObjectPage/EditableHeaderFacet, ObjectPage/StandardFacet, ObjectPage/Facet, not used directly
-	 * - sDataField: 
+	 * - sDataField:
 	 * 		- ObjectPage/DataField: not used directly
-	 * 		- MultiEditDialog/DataField: currently no direct usage under investigation, if id for smartMultiEdit.Field becomes necessary, this id must be used there directly (see also comment in 
-	 * 			MultiEditDialog.fragment)  
+	 * 		- MultiEditDialog/DataField: currently no direct usage under investigation, if id for smartMultiEdit.Field becomes necessary, this id must be used there directly (see also comment in
+	 * 			MultiEditDialog.fragment)
 	 * 		- Remark: TableColumn/DataField in contrast is the (directly used) id of a table column build from a DataField
-	 * 
+	 *
 	 */
-	
-	
+
+
 	// Ids for facets are constructed in a very special way, therefore the needed functions are separated here. Don't do the same for other ids!
 	// Actually there are no controls using these ids directly as there id, but only as a part (i.e. as parameter sFacet)
-	
-	// getHeaderFacets provides the ids for facets pointed to from annotation UI.HeaderFacets 
+
+	// getHeaderFacets provides the ids for facets pointed to from annotation UI.HeaderFacets
 	// In header (i.e. in display mode), ids start always with header::headerEditable::
-	// In edit mode, in the section to edit the header fields, ids start with headerEditable:: 
+	// In edit mode, in the section to edit the header fields, ids start with headerEditable::
 	function getHeaderFacetId(oParams){
 		if (oParams.sAnnotationId) {
 			return "headerEditable::" + oParams.sAnnotationId;
@@ -70,17 +70,17 @@ sap.ui.define(["sap/suite/ui/generic/template/genericUtilities/FeError"],functio
 			return "headerEditable::" + oParams.sAnnotationPath;
 		}
 	}
-	
+
 	function getStandardFacetId(oParams){
 		if (oParams.sAnnotationId) {
 			return oParams.sAnnotationId;
 		}
 		if (oParams.sRecordType !== "com.sap.vocabularies.UI.v1.ReferenceFacet") {
 			throw new FeError();
-		} 
+		}
 		return oParams.sAnnotationPath;
 	}
-	
+
 	// getFacetId is only a wrapper for headerFacets (pointed to from annotation UI.HeaderFacets) and normal facets (pointed to from annotation UI.Facets)
 	function getFacetId(oParams){
 		return oParams.bIsHeaderFacet ? getHeaderFacetId(oParams) : getStandardFacetId(oParams);
@@ -279,7 +279,7 @@ sap.ui.define(["sap/suite/ui/generic/template/genericUtilities/FeError"],functio
 						} else {
 							if (oParams.sRecordType !== "com.sap.vocabularies.UI.v1.ReferenceFacet"){
 								throw new FeError();
-							} 
+							}
 							return "header::headerEditable::" + oParams.sAnnotationPath;
 						}
 					}
@@ -287,7 +287,7 @@ sap.ui.define(["sap/suite/ui/generic/template/genericUtilities/FeError"],functio
 				EditableHeaderFacet: {
 					parameters: ["sRecordType"],
 					optionalParameters: ["sAnnotationPath", "sAnnotationId"],
-					value: getHeaderFacetId 
+					value: getHeaderFacetId
 				},
 				StandardFacet: {
 					parameters: ["sRecordType"],
@@ -379,6 +379,7 @@ sap.ui.define(["sap/suite/ui/generic/template/genericUtilities/FeError"],functio
 					value: "template::Share"
 				},
 				ActivateMenu: {},
+				ActivateAndBackMenu: {},
 				ApplyMenu: {}
 			},
 			ObjectPageSection: {
@@ -608,7 +609,7 @@ sap.ui.define(["sap/suite/ui/generic/template/genericUtilities/FeError"],functio
 				},
 				ImplementingComponentContainerContent: {
 					value: function(){ return "template::ImplementingComponentContent"; }
-				}				
+				}
 			},
 			Action: {
 				Global: {

package/src/sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillAIOrchestrator.js

@@ -0,0 +1,185 @@
+sap.ui.define([
+    "sap/suite/ui/generic/template/genericUtilities/FeLogger",
+    "sap/suite/ui/generic/template/genericUtilities/FeError"
+], function(FeLogger, FeError) {
+    "use strict";
+
+    var sClassName = "lib.ai.EasyFill.EasyFillAIOrchestrator";
+    var oLogger = new FeLogger(sClassName).getLogger();
+
+    /**
+     * EasyFillAIOrchestrator
+     *
+     * Responsible for:
+     * 1. Submitting user input text to the AI (LLM) service and returning parsed results.
+     * 2. Post-processing the AI response: date conversion, splitting simple vs. collection fields.
+     * 3. Building the complete field mapping payload (entity fields + collection fields) to send to the LLM.
+     *
+     * This module contains no UI logic — it only bridges the user input and AI service.
+     * All UI state updates after the AI call are handled by the caller (EasyFillHandler / EasyFillDialogController).
+     */
+    return {
+
+        /**
+         * Builds the complete LLM field mapping by combining main entity fields and collection (table) fields.
+         * Delegates to EasyFillFieldCollector for the actual metadata extraction.
+         *
+         * @param {object} oTemplateUtils - FE template utilities (used for entity type lookup)
+         * @param {object} oController - MVC controller instance
+         * @param {object} oObjectPage - the ObjectPage control
+         * @param {object} oObjectPageModel - the OData model of the ObjectPage
+         * @param {object} oObjectPageContext - current ObjectPage binding context
+         * @param {object} oFieldCollector - EasyFillFieldCollector instance
+         * @param {object} mCollectionState - mutable collection state object (passed into appendCollectionMap)
+         * @returns {object} mFieldMapping — flat map of all fields to send to the LLM
+         */
+        buildFieldMapping: function(oTemplateUtils, oController, oObjectPage, oObjectPageModel, oObjectPageContext, oFieldCollector, mCollectionState) {
+            var oEntityType = oTemplateUtils.oCommonUtils.getMetaModelEntityType(
+                oController.getOwnerComponent().getEntitySet()
+            );
+
+            /**
+             * Resolves the display label for an OData property.
+             * Prefers the Common.Label annotation, falls back to sap:label attribute.
+             *
+             * @param {object} oProperty - OData property metadata
+             * @returns {string} label string
+             */
+            var fnGetLabel = function(oProperty) {
+                if (oProperty["com.sap.vocabularies.Common.v1.Label"]) {
+                    // Use the annotation helper to format the label expression
+                    try {
+                        var AnnotationHelperModel = sap.ui.require("sap/ui/model/odata/AnnotationHelper");
+                        if (AnnotationHelperModel) {
+                            return AnnotationHelperModel.format(oObjectPageContext, oProperty["com.sap.vocabularies.Common.v1.Label"]);
+                        }
+                    } catch (e) {
+                        oLogger.warning("buildFieldMapping: could not format annotation label for " + oProperty.name);
+                    }
+                }
+                return oProperty["sap:label"] || oProperty.name;
+            };
+
+            // Build entity set field map (simple fields)
+            var mFieldMapping = oFieldCollector.getEntitySetMap(oEntityType, oObjectPageContext, fnGetLabel);
+
+            // Append collection (SmartTable) fields and update collection state tracking maps
+            oFieldCollector.appendCollectionMap(
+                mFieldMapping,
+                oObjectPage,
+                oObjectPageModel,
+                oTemplateUtils,
+                mCollectionState,
+                fnGetLabel
+            );
+
+            return mFieldMapping;
+        },
+
+        /**
+         * Sends the user's free-text input to the AI service and returns the structured result.
+         * The AI service is accessed via oTemplateUtils.oServices.oFioriAIHandler.
+         *
+         * @param {string} sInputText - the user's free-text input from the EasyFill textarea
+         * @param {object} mFieldMapping - the complete field mapping built by buildFieldMapping()
+         * @param {object} oTemplateUtils - FE template utilities (used to access oFioriAIHandler)
+         * @returns {Promise<object>} AI service result: { success: boolean, data: object }
+         */
+        submitToAI: async function(sInputText, mFieldMapping, oTemplateUtils) {
+            oLogger.debug("submitToAI: sending input to AI service");
+            try {
+                var aiCallResult = await oTemplateUtils.oServices.oFioriAIHandler.fioriaiLib.EasyFill.extractFieldValuesFromText(
+                    sInputText,
+                    mFieldMapping
+                );
+                return aiCallResult;
+            } catch (e) {
+                oLogger.error("submitToAI: AI call failed: " + (e && e.message));
+                return { success: false, data: {} };
+            }
+        },
+
+        /**
+         * Converts date-like string values in the AI response to JavaScript Date objects,
+         * based on the OData data type declared in the field mapping.
+         * Handles Edm.DateTimeOffset and Edm.DateTime types.
+         *
+         * @param {object} aiCallResult - the raw AI service result ({ success, data })
+         * @param {object} mFieldMapping - the field mapping used during the AI call
+         */
+        formatDateValues: function(aiCallResult, mFieldMapping) {
+            if (!aiCallResult || !aiCallResult.success || !aiCallResult.data) {
+                return;
+            }
+            Object.keys(aiCallResult.data).forEach(function(sKey) {
+                var oFieldMeta = mFieldMapping[sKey];
+                if (!oFieldMeta) { return; }
+                var sDataType = oFieldMeta.dataType;
+                if (sDataType === "Edm.DateTimeOffset" || sDataType === "Edm.DateTime") {
+                    var vValue = aiCallResult.data[sKey];
+                    if (vValue && typeof vValue === "string") {
+                        aiCallResult.data[sKey] = new Date(vValue);
+                        oLogger.debug("formatDateValues: converted field '" + sKey + "' to Date");
+                    }
+                }
+            });
+        },
+
+        /**
+         * Splits the flat AI response data into two buckets:
+         * - simpleFields: scalar field values for the main entity (SmartForm fields)
+         * - collectionFields: row-level updates for SmartTable collections
+         *
+         * Collection fields are identified by the isCollection flag in the field mapping.
+         * Currently only the first valid collection is processed (single-table limitation).
+         *
+         * @param {object} oAiData - the AI response data map { fieldName: value | rowArray }
+         * @param {object} mFieldMapping - the complete field mapping
+         * @param {object} oFieldCollector - EasyFillFieldCollector (used for SmartTable validation)
+         * @param {object} oObjectPage - the ObjectPage control (used for SmartTable validation)
+         * @returns {{ simpleFields: object, collectionFields: object }}
+         */
+        splitAIResultByCollection: function(oAiData, mFieldMapping, oFieldCollector, oObjectPage) {
+            var oSplitResult = {
+                simpleFields: {},
+                collectionFields: {}
+            };
+
+            Object.keys(oAiData || {}).forEach(function(sFieldName) {
+                var oFieldMeta = mFieldMapping[sFieldName];
+                var vFieldValue = oAiData[sFieldName];
+
+                // Determine if this field value is a collection (array of row updates)
+                var aCollectionRows = null;
+                if (Array.isArray(vFieldValue)) {
+                    aCollectionRows = vFieldValue;
+                } else if (vFieldValue && Array.isArray(vFieldValue.rows)) {
+                    aCollectionRows = vFieldValue.rows;
+                }
+
+                if (oFieldMeta && oFieldMeta.isCollection === true && aCollectionRows) {
+                    // Validate that each row update has at least a context path or row index for binding
+                    var aRowUpdates = aCollectionRows.filter(function(oRow) {
+                        return oRow && typeof oRow === "object" &&
+                            (typeof oRow._contextPath === "string" || typeof oRow._rowIndex === "number");
+                    });
+
+                    // Single-table limitation: only the first valid collection is accepted.
+                    // Future work: extend collectionFields structure to support multiple tables.
+                    var oValidation = oFieldCollector.isValidSmartTable(oFieldMeta.entitySet, oObjectPage);
+                    if (aRowUpdates.length > 0 &&
+                        Object.keys(oSplitResult.collectionFields).length === 0 &&
+                        oValidation.isValid) {
+                        oSplitResult.collectionFields[sFieldName] = aRowUpdates;
+                        oLogger.debug("splitAIResultByCollection: accepted collection field '" + sFieldName + "' with " + aRowUpdates.length + " rows");
+                    }
+                } else {
+                    // Scalar field → goes to simpleFields
+                    oSplitResult.simpleFields[sFieldName] = vFieldValue;
+                }
+            });
+
+            return oSplitResult;
+        }
+    };
+});