@sapui5/sap.fe.core 1.98.0 → 1.99.0

package/src/sap/fe/core/actions/operations.ts

@@ -0,0 +1,1162 @@
+import MessageBox from "sap/m/MessageBox";
+import Dialog from "sap/m/Dialog";
+import JSONModel from "sap/ui/model/json/JSONModel";
+import XMLTemplateProcessor from "sap/ui/core/XMLTemplateProcessor";
+import XMLPreprocessor from "sap/ui/core/util/XMLPreprocessor";
+import Fragment from "sap/ui/core/Fragment";
+import messageHandling from "sap/fe/core/actions/messageHandling";
+import BusyLocker from "sap/fe/core/BusyLocker";
+import CommonUtils from "sap/fe/core/CommonUtils";
+import Log from "sap/base/Log";
+import FELibrary from "sap/fe/core/library";
+import FPMHelper from "sap/fe/core/helpers/FPMHelper";
+import Button from "sap/m/Button";
+import { generate } from "sap/fe/core/helpers/StableIdHelper";
+
+const Constants = FELibrary.Constants,
+	InvocationGrouping = FELibrary.InvocationGrouping;
+const Action = (MessageBox as any).Action;
+
+/**
+ * Calls a bound action for one or multiple contexts.
+ *
+ * @function
+ * @static
+ * @name sap.fe.core.actions.operations.callBoundAction
+ * @memberof sap.fe.core.actions.operations
+ * @param {string} sActionName The name of the action to be called
+ * @param {sap.ui.model.odata.v4.Context} contexts Either one context or an array with contexts for which the action is to be be called
+ * @param {sap.ui.model.odata.v4.Model} oModel OData Model
+ * @param {object} oAppComponent The AppComponent
+ * @param {map} [mParameters] Optional, can contain the following attributes:
+ * @param {map} [mParameters.actionParameters] A map of parameters to be sent for every action call
+ * @param {map} [mParameters.mBindingParameters] A map of binding parameters that would be part of $select and $expand coming from side effects for bound actions
+ * @param {Array} [mParameters.additionalSideEffect] Array of property paths to be requested in addition to actual target properties of the side effect
+ * @param {boolean} [mParameters.showActionParameterDialog] If set and if parameters exist the user retrieves a dialog to fill in parameters, if actionParameters are passed they are shown to the user
+ * @param {string} [mParameters.label] A human-readable label for the action
+ * @param {string} [mParameters.invocationGrouping] Mode how actions are to be called: Changeset to put all action calls into one changeset, Isolated to put them into separate changesets, defaults to Isolated
+ * @param {Function} [mParameters.onSubmitted] Function which is called once the actions are submitted with an array of promises
+ * @param {map} [mParameters.defaultParameters] Can contain default parameters from FLP user defaults
+ * @param {sap.ui.core.Element} [mParameters.parentControl] If specified the dialogs are added as dependent of the parent control
+ * @param {boolean} [mParameters.bGetBoundContext] If specified the action promise returns the bound context
+ * @returns {Promise} Promise resolves with an array of response objects (TODO: to be changed)
+ * @private
+ * @ui5-restricted
+ */
+function callBoundAction(sActionName: string, contexts: any, oModel: any, oAppComponent: object, mParameters: any) {
+	if (!contexts || contexts.length === 0) {
+		//In Freestyle apps bound actions can have no context
+		return Promise.reject("Bound actions always requires at least one context");
+	}
+	// we expect either one context or an array of contexts
+	if (Array.isArray(contexts)) {
+		mParameters.bReturnAsArray = true;
+	} else {
+		//action needs to be called on this context from the dependent binding so UI fields are updated with response data
+		contexts = [contexts];
+	}
+	const oMetaModel = oModel.getMetaModel(),
+		sActionPath = oMetaModel.getMetaPath(contexts[0].getPath()) + "/" + sActionName,
+		oBoundAction = oMetaModel.createBindingContext(sActionPath + "/@$ui5.overload/0");
+	mParameters.aContexts = contexts;
+	mParameters.isCriticalAction = getIsActionCritical(oMetaModel, sActionPath, contexts, oBoundAction);
+	return callAction(sActionName, oModel, oBoundAction, oAppComponent, mParameters);
+}
+/**
+ * Calls an action import.
+ *
+ * @function
+ * @static
+ * @name sap.fe.core.actions.operations.callActionImport
+ * @memberof sap.fe.core.actions.operations
+ * @param {string} sActionName The name of the action import to be called
+ * @param {sap.ui.model.odata.v4.ODataModel} oModel An instance of an OData v4 model
+ * @param {object} oAppComponent The AppComponent
+ * @param {map} [mParameters] Optional, can contain the following attributes:
+ * @param {map} [mParameters.actionParameters] A map of parameters to be sent with the action import
+ * @param {string} [mParameters.label] A human-readable label for the action
+ * @param {boolean} [mParameters.showActionParameterDialog] If set and if parameters exist the user retrieves a dialog to fill in parameters, if actionParameters are passed they are shown to the user
+ * @param {Function} [mParameters.onSubmitted] Function which is called once the actions are submitted with an array of promises
+ * @param {map} [mParameters.defaultParameters] Can contain default parameters from FLP user defaults
+ * @returns {Promise} Promise resolves with an array of response objects (TODO: to be changed)
+ * @private
+ * @ui5-restricted
+ */
+function callActionImport(sActionName: string, oModel: any, oAppComponent: object, mParameters: any) {
+	if (!oModel) {
+		return Promise.reject("Action expects a model/context for execution");
+	}
+	const oMetaModel = oModel.getMetaModel(),
+		sActionPath = oModel.bindContext("/" + sActionName).getPath(),
+		oActionImport = oMetaModel.createBindingContext("/" + oMetaModel.createBindingContext(sActionPath).getObject("$Action") + "/0");
+	mParameters.isCriticalAction = getIsActionCritical(oMetaModel, sActionPath + "/@$ui5.overload");
+	return callAction(sActionName, oModel, oActionImport, oAppComponent, mParameters);
+}
+function callBoundFunction(sFunctionName: string, context: any, oModel: any) {
+	if (!context) {
+		return Promise.reject("Bound functions always requires a context");
+	}
+	const oMetaModel = oModel.getMetaModel(),
+		sFunctionPath = oMetaModel.getMetaPath(context.getPath()) + "/" + sFunctionName,
+		oBoundFunction = oMetaModel.createBindingContext(sFunctionPath);
+	return _executeFunction(sFunctionName, oModel, oBoundFunction, context);
+}
+/**
+ * Calls a function import.
+ *
+ * @function
+ * @static
+ * @name sap.fe.core.actions.operations.callFunctionImport
+ * @memberof sap.fe.core.actions.operations
+ * @param {string} sFunctionName The name of the function to be called
+ * @param {sap.ui.model.odata.v4.ODataModel} oModel An instance of an OData v4 model
+ * @returns {Promise} Promise resolves
+ * @private
+ */
+function callFunctionImport(sFunctionName: string, oModel: any) {
+	if (!sFunctionName) {
+		return Promise.resolve();
+	}
+	const oMetaModel = oModel.getMetaModel(),
+		sFunctionPath = oModel.bindContext("/" + sFunctionName).getPath(),
+		oFunctionImport = oMetaModel.createBindingContext(
+			"/" + oMetaModel.createBindingContext(sFunctionPath).getObject("$Function") + "/0"
+		);
+	return _executeFunction(sFunctionName, oModel, oFunctionImport);
+}
+function _executeFunction(sFunctionName: any, oModel: any, oFunction: any, context?: any) {
+	let sGroupId;
+	if (!oFunction || !oFunction.getObject()) {
+		return Promise.reject(new Error("Function " + sFunctionName + " not found"));
+	}
+	if (context) {
+		oFunction = oModel.bindContext(sFunctionName + "(...)", context);
+		sGroupId = "functionGroup";
+	} else {
+		oFunction = oModel.bindContext("/" + sFunctionName + "(...)");
+		sGroupId = "functionImport";
+	}
+	const oFunctionPromise = oFunction.execute(sGroupId);
+	oModel.submitBatch(sGroupId);
+	return oFunctionPromise.then(function() {
+		return oFunction.getBoundContext();
+	});
+}
+function callAction(sActionName: any, oModel: any, oAction: any, oAppComponent: any, mParameters: any) {
+	return new Promise(function(resolve: (value: any) => void, reject: (reason?: any) => void) {
+		let aActionParameters = mParameters.actionParameters || [];
+		let mActionExecutionParameters: any = {};
+		let fnDialog;
+		let oActionPromise;
+		const sActionLabel = mParameters.label;
+		let bShowActionParameterDialog = mParameters.showActionParameterDialog;
+		const aContexts = mParameters.aContexts;
+		const bIsCreateAction = mParameters.bIsCreateAction;
+		const bIsCriticalAction = mParameters.isCriticalAction;
+		let oMetaModel;
+		let sMetaPath;
+		let sMessagesPath: any;
+		let iMessageSideEffect;
+		if (!oAction || !oAction.getObject()) {
+			return reject(new Error("Action " + sActionName + " not found"));
+		}
+		if (bShowActionParameterDialog || aActionParameters.length > 0) {
+			aActionParameters = prepareActionParameters(oAction, aActionParameters);
+			if (!aActionParameters || aActionParameters.length === 0) {
+				bShowActionParameterDialog = false;
+			}
+		}
+		if (bShowActionParameterDialog) {
+			fnDialog = showActionParameterDialog;
+		} else if (bIsCriticalAction) {
+			fnDialog = confirmCriticalAction;
+		}
+		mActionExecutionParameters = {
+			fnOnSubmitted: mParameters.onSubmitted,
+			fnOnResponse: mParameters.onResponse,
+			actionName: sActionName,
+			model: oModel,
+			aActionParameters: aActionParameters,
+			bGetBoundContext: mParameters.bGetBoundContext,
+			defaultValuesExtensionFunction: mParameters.defaultValuesExtensionFunction
+		};
+		if (oAction.getObject("$IsBound")) {
+			if (mParameters.additionalSideEffect && mParameters.additionalSideEffect.pathExpressions) {
+				oMetaModel = oModel.getMetaModel();
+				sMetaPath = oMetaModel.getMetaPath(aContexts[0].getPath());
+				sMessagesPath = oMetaModel.getObject(sMetaPath + "/@com.sap.vocabularies.Common.v1.Messages/$Path");
+
+				if (sMessagesPath) {
+					iMessageSideEffect = mParameters.additionalSideEffect.pathExpressions.findIndex(function(exp: any) {
+						return exp.$PropertyPath === sMessagesPath;
+					});
+
+					if (iMessageSideEffect > -1) {
+						// the message path is annotated as side effect. As there's no binding for it and the model does currently not allow
+						// to add it at a later point of time we have to take care it's part of the $select of the POST, therefore moving it
+						mParameters.mBindingParameters = mParameters.mBindingParameters || {};
+
+						if (
+							oAction.getObject("$ReturnType/$Type/" + sMessagesPath) &&
+							(!mParameters.mBindingParameters.$select ||
+								mParameters.mBindingParameters.$select.split(",").indexOf(sMessagesPath) === -1)
+						) {
+							mParameters.mBindingParameters.$select = mParameters.mBindingParameters.$select
+								? mParameters.mBindingParameters.$select + "," + sMessagesPath
+								: sMessagesPath;
+
+							if (mParameters.additionalSideEffect.triggerActions.length === 0) {
+								// no trigger action therefore no need to request messages again
+								mParameters.additionalSideEffect.pathExpressions.splice(iMessageSideEffect, 1);
+							}
+						}
+					}
+				}
+			}
+
+			mActionExecutionParameters.aContexts = aContexts;
+			mActionExecutionParameters.mBindingParameters = mParameters.mBindingParameters;
+			mActionExecutionParameters.additionalSideEffect = mParameters.additionalSideEffect;
+			mActionExecutionParameters.bGrouped = mParameters.invocationGrouping === InvocationGrouping.ChangeSet;
+			mActionExecutionParameters.bReturnAsArray = mParameters.bReturnAsArray;
+			mActionExecutionParameters.internalModelContext = mParameters.internalModelContext;
+			mActionExecutionParameters.operationAvailableMap = mParameters.operationAvailableMap;
+			mActionExecutionParameters.bObjectPage = mParameters.bObjectPage;
+		}
+		if (bIsCreateAction) {
+			mActionExecutionParameters.bIsCreateAction = bIsCreateAction;
+		}
+		if (fnDialog) {
+			oActionPromise = fnDialog(
+				sActionName,
+				oAppComponent,
+				sActionLabel,
+				mActionExecutionParameters,
+				aActionParameters,
+				oAction,
+				mParameters.parentControl,
+				mParameters.entitySetName,
+				mParameters.messageHandler
+			);
+		} else {
+			oActionPromise = _executeAction(oAppComponent, mActionExecutionParameters);
+		}
+		return oActionPromise
+			.then(function(oOperationResult: any) {
+				resolve(oOperationResult);
+			})
+			.catch(function(oOperationResult: any) {
+				reject(oOperationResult);
+			});
+	});
+}
+function confirmCriticalAction(
+	sActionName: any,
+	oAppComponent: any,
+	sActionLabel: any,
+	mParameters: any,
+	aActionParameters: any,
+	oActionContext: any,
+	oParentControl: any,
+	entitySetName: any,
+	messageHandler: any
+) {
+	return new Promise<void>((resolve, reject) => {
+		let boundActionName = sActionName ? sActionName : null;
+		boundActionName =
+			boundActionName.indexOf(".") >= 0 ? boundActionName.split(".")[boundActionName.split(".").length - 1] : boundActionName;
+		const suffixResourceKey = boundActionName && entitySetName ? entitySetName + "|" + boundActionName : "";
+		const oResourceBundle = oParentControl.getController().oResourceBundle;
+		const sConfirmationText = CommonUtils.getTranslatedText(
+			"C_OPERATIONS_ACTION_CONFIRM_MESSAGE",
+			oResourceBundle,
+			null,
+			suffixResourceKey
+		);
+
+		MessageBox.confirm(sConfirmationText, {
+			onClose: function(sAction: any) {
+				if (sAction === Action.OK) {
+					return _executeAction(oAppComponent, mParameters)
+						.then(function(oOperation: any) {
+							resolve(oOperation);
+						})
+						.catch(function(oError: any) {
+							messageHandler
+								.showMessageDialog()
+								.then(function() {
+									reject(oError);
+								})
+								.catch(function() {
+									reject(oError);
+								});
+						});
+				} else {
+					resolve();
+				}
+			}
+		});
+	});
+}
+function showActionParameterDialog(
+	sActionName: any,
+	oAppComponent: any,
+	sActionLabel: any,
+	mParameters: any,
+	aActionParameters: any,
+	oActionContext: any,
+	oParentControl: any,
+	entitySetName: any,
+	messageHandler: any
+) {
+	const sPath = _getPath(oActionContext, sActionName),
+		metaModel = oActionContext.getModel().oModel.getMetaModel(),
+		entitySetContext = metaModel.createBindingContext(sPath),
+		sActionNamePath = oActionContext.getObject("$IsBound")
+			? oActionContext.getPath().split("/@$ui5.overload/0")[0]
+			: oActionContext.getPath().split("/0")[0],
+		actionNameContext = metaModel.createBindingContext(sActionNamePath),
+		sFragmentName = "sap/fe/core/controls/ActionParameterDialog";
+	return new Promise(function(resolve: (value: any) => void, reject: (reason?: any) => void) {
+		const oFragment = XMLTemplateProcessor.loadTemplate(sFragmentName, "fragment");
+		const oParameterModel = new JSONModel({
+			$displayMode: {}
+		});
+		let aFieldInvalid: any[] = [];
+		let aFormElements: any[] = [];
+		const mFieldValueMap: any = {};
+		const validateRequiredProperties = function() {
+			return Promise.all(
+				aFormElements
+					.filter(function(oFormElement: any) {
+						const oField = oFormElement.getFields()[0];
+						return oField.getRequired() && oField.getValueState() !== "Error";
+					})
+					.map(function(oFormElement: any) {
+						const value = oFormElement.getFields()[0].isA("sap.ui.mdc.MultiValueField")
+							? oFormElement.getFields()[0].getItems()
+							: oFormElement.getFields()[0].getValue();
+						if (value === undefined || value === null || value === "") {
+							return oFormElement.getLabel().getText();
+						}
+					})
+			).then(function(aResults: any[]) {
+				aResults = aResults.filter(function(result: any) {
+					return result !== undefined;
+				});
+				return aResults;
+			});
+		};
+		const _validateMessages = function(aActionParameters: any, aFieldInvalid: any, bClearTarget?: boolean) {
+			const oMessageManager = sap.ui.getCore().getMessageManager();
+			const aMessages = oMessageManager.getMessageModel().getData();
+
+			aFieldInvalid = aFieldInvalid || [];
+
+			aActionParameters.forEach(function(oActionParameters: any) {
+				const sParameter = oActionParameters.$Name;
+				aMessages.forEach(function(oMessage: any) {
+					const sParam = sParameter.replace("-inner", "");
+					if (
+						oMessage.controlIds.length > 0 &&
+						(oMessage.getControlId().includes("APD_::" + sParameter) ||
+							(oMessage.getControlId().includes("APD_::" + sParameter + "inner") &&
+								aFieldInvalid.indexOf("APD_::" + sParam) < 0))
+					) {
+						if (bClearTarget) {
+							oMessageManager.removeMessages(oMessage);
+						} else {
+							aFieldInvalid.push("APD_::" + sParam);
+						}
+					}
+					// Handle messages related to input with invalid token
+					if (oMessage.target.includes("APD_::" + sParameter)) {
+						aFieldInvalid.push("APD_::" + sParam);
+						oMessage.target = bClearTarget ? "" : oMessage.target;
+						if (bClearTarget) {
+							oMessageManager.removeMessages(oMessage);
+						}
+					}
+				});
+			});
+			return aFieldInvalid;
+		};
+		const oController = {
+			handleChange: function(oEvent: any) {
+				messageHandler.removeTransitionMessages();
+				const oField = oEvent.getSource();
+				const sFieldId = oEvent.getParameter("id");
+				const oFieldPromise = oEvent.getParameter("promise");
+				if (oFieldPromise) {
+					mFieldValueMap[sFieldId] = oFieldPromise.then(function() {
+						return oField.getValue();
+					});
+				}
+				_validateMessages(aActionParameters, aFieldInvalid);
+			}
+		};
+
+		return Promise.resolve(
+			XMLPreprocessor.process(
+				oFragment,
+				{ name: sFragmentName },
+				{
+					bindingContexts: {
+						action: oActionContext,
+						actionName: actionNameContext,
+						entitySet: entitySetContext
+					},
+					models: {
+						action: oActionContext.getModel(),
+						actionName: actionNameContext.getModel(),
+						entitySet: entitySetContext.getModel(),
+						metaModel: entitySetContext.getModel()
+					}
+				}
+			)
+		)
+			.then(function(oFragment: any) {
+				// TODO: move the dialog into the fragment and move the handlers to the oController
+				let aContexts: any[];
+				const aFunctionParams: any[] = [];
+				let oOperationBinding: any;
+				return CommonUtils.setUserDefaults(oAppComponent, aActionParameters, oParameterModel, true).then(function() {
+					// TODO: move the dialog into the fragment and move the handlers to the oController
+					return Fragment.load({ definition: oFragment, controller: oController }).then(function(oDialogContent: any) {
+						const oResourceBundle = oParentControl.getController().oResourceBundle;
+						const oDialog = new Dialog(undefined, {
+							title:
+								sActionLabel ||
+								CommonUtils.getTranslatedText("C_OPERATIONS_ACTION_PARAMETER_DIALOG_TITLE", oResourceBundle),
+							content: [oDialogContent],
+							escapeHandler: function() {
+								oDialog.close();
+								messageHandler.removeTransitionMessages();
+								reject();
+							},
+							beginButton: new Button(generate(["fe", "APD_", sActionName, "Action", "Ok"]), {
+								text: sActionLabel || CommonUtils.getTranslatedText("C_COMMON_DIALOG_OK", oResourceBundle),
+								type: "Emphasized",
+								press: function() {
+									validateRequiredProperties()
+										.then(function(aEmptyMandatoryFields: any[]) {
+											if (aEmptyMandatoryFields.length) {
+												const oMessages = [];
+												for (let i = 0; i < aEmptyMandatoryFields.length; i++) {
+													oMessages.push({
+														text: CommonUtils.getTranslatedText(
+															"C_OPERATIONS_ACTION_PARAMETER_DIALOG_MISSING_MANDATORY_MSG",
+															oResourceBundle,
+															aEmptyMandatoryFields[i]
+														),
+														code: 200,
+														type: "Error"
+													});
+												}
+												messageHandler.showMessageDialog({
+													customMessages: oMessages
+												});
+												return;
+											}
+
+											aFieldInvalid = _validateMessages(aActionParameters, aFieldInvalid);
+
+											if (aFieldInvalid.length > 0) {
+												return messageHandling.showUnboundMessages();
+											}
+											BusyLocker.lock(oDialog);
+											return Promise.all(
+												Object.keys(mFieldValueMap).map(function(sKey: string) {
+													return mFieldValueMap[sKey];
+												})
+											)
+												.then(function() {
+													// TODO: due to using the search and value helps on the action dialog transient messages could appear
+													// we need an UX design for those to show them to the user - for now remove them before continuing
+													messageHandler.removeTransitionMessages();
+													// move parameter values from Dialog (SimpleForm) to mParameters.actionParameters so that they are available in the operation bindings for all contexts
+													let vParameterValue;
+													const oParameterContext = oOperationBinding && oOperationBinding.getParameterContext();
+													for (const i in aActionParameters) {
+														if (aActionParameters[i].$isCollection) {
+															const aMVFContent = oDialog
+																	.getModel("mvfview")
+																	.getProperty("/" + aActionParameters[i].$Name),
+																aKeyValues = [];
+															for (const j in aMVFContent) {
+																aKeyValues.push(aMVFContent[j].Key);
+															}
+															vParameterValue = aKeyValues;
+														} else {
+															vParameterValue = oParameterContext.getProperty(aActionParameters[i].$Name);
+														}
+														aActionParameters[i].value = vParameterValue;
+														vParameterValue = undefined;
+													}
+													return _executeAction(oAppComponent, mParameters)
+														.then(function(oOperation: any) {
+															oDialog.close();
+															resolve(oOperation);
+														})
+														.catch(function(oError: any) {
+															throw oError;
+														});
+												})
+												.catch(function() {
+													const oMessageManager = sap.ui.getCore().getMessageManager();
+													const bHasEtagMessage = messageHandling.modifyETagMessagesOnly(
+														oMessageManager,
+														oResourceBundle
+													);
+
+													messageHandler.showMessages({
+														bHasEtagMessage: bHasEtagMessage,
+														context: mParameters.aContexts[0],
+														isActionParameterDialogOpen: true,
+														messagePageNavigationCallback: function() {
+															oDialog.close();
+														}
+													});
+													if (oDialog && bHasEtagMessage) {
+														oDialog.close(); //close the action parameter dialog after refresh of the context after etag mismatch
+													}
+												})
+												.finally(function() {
+													BusyLocker.unlock(oDialog);
+												});
+										})
+										.catch(function() {
+											return messageHandler.showMessageDialog();
+										});
+								}
+							}),
+							endButton: new Button(generate(["fe", "APD_", sActionName, "Action", "Cancel"]), {
+								text: CommonUtils.getTranslatedText("C_COMMON_ACTION_PARAMETER_DIALOG_CANCEL", oResourceBundle),
+								press: function() {
+									_validateMessages(aActionParameters, aFieldInvalid, true);
+									oDialog.close();
+									messageHandler.removeTransitionMessages();
+									reject(Constants.CancelActionDialog);
+								}
+							}),
+							beforeOpen: function(oEvent: any) {
+								// clone event for actionWrapper as oEvent.oSource gets lost during processing of beforeOpen event handler
+								const oCloneEvent = Object.assign({}, oEvent);
+
+								messageHandler.removeTransitionMessages();
+								const getDefaultValuesFunction = function() {
+									const oMetaModel = oDialog.getModel().getMetaModel(),
+										sActionPath = oActionContext.sPath && oActionContext.sPath.split("/@")[0],
+										sDefaultValuesFunction = oMetaModel.getObject(
+											sActionPath + "@com.sap.vocabularies.Common.v1.DefaultValuesFunction"
+										);
+									return sDefaultValuesFunction;
+								};
+								const fnSetDefaultsAndOpenDialog = function(sBindingParameter?: any) {
+									const sBoundFunctionName = getDefaultValuesFunction();
+									const prefillParameter = function(sParamName: any, vParamDefaultValue: any) {
+										return new Promise(resolve => {
+											// Case 1: There is a ParameterDefaultValue annotation
+											if (vParamDefaultValue !== undefined) {
+												if (aContexts.length > 0 && vParamDefaultValue.$Path) {
+													const oPromise = CommonUtils.requestSingletonProperty(
+														vParamDefaultValue.$Path,
+														oOperationBinding.getModel()
+													);
+													oPromise
+														.then(function(oValue: any) {
+															if (oValue === null) {
+																return oOperationBinding
+																	.getParameterContext()
+																	.requestProperty(vParamDefaultValue.$Path);
+															}
+															return oValue;
+														})
+														.then(function(vParamValue: any) {
+															if (aContexts.length > 1) {
+																// For multi select, need to loop over aContexts (as contexts cannot be retrieved via binding parameter of the operation binding)
+																let sPathForContext = vParamDefaultValue.$Path;
+																if (sPathForContext.indexOf(sBindingParameter + "/") === 0) {
+																	sPathForContext = sPathForContext.replace(sBindingParameter + "/", "");
+																}
+																for (let i = 1; i < aContexts.length; i++) {
+																	if (aContexts[i].getProperty(sPathForContext) !== vParamValue) {
+																		// if the values from the contexts are not all the same, do not prefill
+																		resolve({
+																			paramName: sParamName,
+																			value: undefined,
+																			bNoPossibleValue: true
+																		});
+																	}
+																}
+															}
+															resolve({ paramName: sParamName, value: vParamValue });
+														})
+														.catch(function() {
+															// Simply clear parameter default if an error has occurred
+															Log.error(
+																"Error while reading default action parameter",
+																sParamName,
+																mParameters.actionName
+															);
+															resolve({
+																paramName: sParamName,
+																value: undefined,
+																bLatePropertyError: true
+															});
+														});
+												} else {
+													// Case 1.2: ParameterDefaultValue defines a fixed string value (i.e. vParamDefaultValue = 'someString')
+													resolve({ paramName: sParamName, value: vParamDefaultValue });
+												}
+											} else {
+												// Case 2: There is no ParameterDefaultValue annotation (=> look into the FLP User Defaults)
+												if (oParameterModel && (oParameterModel as any).oData[sParamName]) {
+													resolve({
+														paramName: sParamName,
+														value: (oParameterModel as any).oData[sParamName]
+													});
+												} else {
+													resolve({ paramName: sParamName, value: undefined });
+												}
+											}
+										});
+									};
+
+									const getParameterDefaultValue = function(sParamName: any) {
+										const oMetaModel = oDialog.getModel().getMetaModel(),
+											sActionPath = oActionContext.sPath && oActionContext.sPath.split("/@")[0],
+											sActionParameterAnnotationTarget = sActionPath + "/" + sParamName + "@",
+											oParameterAnnotations = oMetaModel.getObject(sActionParameterAnnotationTarget),
+											oParameterDefaultValue =
+												oParameterAnnotations &&
+												oParameterAnnotations["@com.sap.vocabularies.UI.v1.ParameterDefaultValue"]; // either { $Path: 'somePath' } or 'someString'
+										return oParameterDefaultValue;
+									};
+
+									const aCurrentParamDefaultValue = [];
+									let sParamName, vParameterDefaultValue;
+									for (const i in aActionParameters) {
+										sParamName = aActionParameters[i].$Name;
+										vParameterDefaultValue = getParameterDefaultValue(sParamName);
+										aCurrentParamDefaultValue.push(prefillParameter(sParamName, vParameterDefaultValue));
+									}
+
+									if (oActionContext.getObject("$IsBound") && aContexts.length > 0) {
+										if (sBoundFunctionName && sBoundFunctionName.length > 0 && typeof sBoundFunctionName === "string") {
+											for (const i in aContexts) {
+												aFunctionParams.push(
+													callBoundFunction(sBoundFunctionName, aContexts[i], mParameters.model)
+												);
+											}
+										}
+									}
+
+									const aPrefillParamPromises = Promise.all(aCurrentParamDefaultValue);
+									let aExecFunctionPromises: Promise<any[]> = Promise.resolve([]);
+									let oExecFunctionFromManifestPromise;
+									if (aFunctionParams && aFunctionParams.length > 0) {
+										aExecFunctionPromises = Promise.all(aFunctionParams);
+									}
+									if (mParameters.defaultValuesExtensionFunction) {
+										const sModule = mParameters.defaultValuesExtensionFunction
+												.substring(0, mParameters.defaultValuesExtensionFunction.lastIndexOf(".") || -1)
+												.replace(/\./gi, "/"),
+											sFunctionName = mParameters.defaultValuesExtensionFunction.substring(
+												mParameters.defaultValuesExtensionFunction.lastIndexOf(".") + 1,
+												mParameters.defaultValuesExtensionFunction.length
+											);
+										oExecFunctionFromManifestPromise = FPMHelper.actionWrapper(oCloneEvent, sModule, sFunctionName, {
+											"contexts": aContexts
+										});
+									}
+
+									Promise.all([aPrefillParamPromises, aExecFunctionPromises, oExecFunctionFromManifestPromise])
+										.then(function(aPromises: [any[], any[], any]) {
+											const aCurrentParamDefaultValue: any = aPromises[0];
+											const aFunctionParams = aPromises[1];
+											const oFunctionParamsFromManifest = aPromises[2];
+											let sDialogParamName;
+											for (const i in aActionParameters) {
+												sDialogParamName = aActionParameters[i].$Name;
+												if (
+													oFunctionParamsFromManifest &&
+													oFunctionParamsFromManifest.hasOwnProperty(sDialogParamName)
+												) {
+													oOperationBinding.setParameter(
+														aActionParameters[i].$Name,
+														oFunctionParamsFromManifest[sDialogParamName]
+													);
+												} else if (
+													aCurrentParamDefaultValue[i] &&
+													aCurrentParamDefaultValue[i].value !== undefined
+												) {
+													oOperationBinding.setParameter(
+														aActionParameters[i].$Name,
+														aCurrentParamDefaultValue[i].value
+													);
+													// if the default value had not been previously determined due to different contexts, we do nothing else
+												} else if (sBoundFunctionName && !aCurrentParamDefaultValue[i].bNoPossibleValue) {
+													if (aContexts.length > 1) {
+														// we check if the function retrieves the same param value for all the contexts:
+														let j = 0;
+														while (j < aContexts.length - 1) {
+															if (
+																aFunctionParams[j] &&
+																aFunctionParams[j + 1] &&
+																aFunctionParams[j].getObject(sDialogParamName) ===
+																	aFunctionParams[j + 1].getObject(sDialogParamName)
+															) {
+																j++;
+															} else {
+																break;
+															}
+														}
+														//param values are all the same:
+														if (j === aContexts.length - 1) {
+															oOperationBinding.setParameter(
+																aActionParameters[i].$Name,
+																aFunctionParams[j].getObject(sDialogParamName)
+															);
+														}
+													} else {
+														//Only one context, then the default param values are to be verified from the function:
+
+														if (aFunctionParams[0] && aFunctionParams[0].getObject(sDialogParamName)) {
+															oOperationBinding.setParameter(
+																aActionParameters[i].$Name,
+																aFunctionParams[0].getObject(sDialogParamName)
+															);
+														}
+													}
+												}
+											}
+											const bErrorFound = aCurrentParamDefaultValue.some(function(oValue: any) {
+												if (oValue.bLatePropertyError) {
+													return oValue.bLatePropertyError;
+												}
+											});
+											// If at least one Default Property is a Late Property and an eTag error was raised.
+											if (bErrorFound) {
+												const sText = CommonUtils.getTranslatedText(
+													"C_APP_COMPONENT_SAPFE_ETAG_LATE_PROPERTY",
+													oResourceBundle
+												);
+												MessageBox.warning(sText, { contentWidth: "25em" } as any);
+											}
+										})
+										.catch();
+								};
+
+								if (oActionContext.getObject("$IsBound") && aContexts.length > 0) {
+									const aParameters = oActionContext.getObject("$Parameter"),
+										sBindingParameter = aParameters[0] && aParameters[0].$Name;
+									aContexts[0]
+										.requestObject()
+										.then(function(oContextObject: any) {
+											if (oContextObject) {
+												oOperationBinding.setParameter(sBindingParameter, oContextObject);
+											}
+											fnSetDefaultsAndOpenDialog(sBindingParameter);
+										})
+										.catch(function(oError: any) {
+											Log.error("Error while retrieving the parameter", oError);
+										});
+								} else {
+									fnSetDefaultsAndOpenDialog();
+								}
+							},
+							afterClose: function() {
+								oDialog.destroy();
+							}
+						});
+						aFormElements = oDialogContent
+							.getAggregation("form")
+							.getAggregation("formContainers")[0]
+							.getAggregation("formElements");
+						oDialog.setModel(oActionContext.getModel().oModel);
+						oDialog.setModel(oParameterModel, "paramsModel");
+						oDialog.bindElement({
+							path: "/",
+							model: "paramsModel"
+						});
+						// empty model to add elements dynamically depending on number of MVF fields defined on the dialog
+						const oMVFModel = new JSONModel({});
+						oDialog.setModel(oMVFModel, "mvfview");
+
+						let sActionPath = sActionName + "(...)";
+						aContexts = mParameters.aContexts || [];
+						if (!aContexts.length) {
+							sActionPath = "/" + sActionPath;
+						}
+						oDialog.bindElement({
+							path: sActionPath
+						});
+						if (oParentControl) {
+							// if there is a parent control specified add the dialog as dependent
+							oParentControl.addDependent(oDialog);
+						}
+						if (aContexts.length > 0) {
+							oDialog.setBindingContext(aContexts[0]); // use context of first selected line item
+						}
+						oOperationBinding = oDialog.getObjectBinding();
+						oDialog.open();
+					});
+				});
+			})
+			.catch(reject);
+	});
+}
+function prepareActionParameters(oAction: any, aPredefinedParameters: any) {
+	// check if parameters exist at all
+	const aParameters = getActionParameters(oAction);
+	aPredefinedParameters = aPredefinedParameters || [];
+
+	if (aPredefinedParameters.length > 0) {
+		// TODO: merge the predefined once with the real existing one
+	}
+
+	return aParameters;
+}
+function getActionParameters(oAction: any) {
+	const aParameters = oAction.getObject("$Parameter") || [];
+	if (aParameters && aParameters.length) {
+		if (oAction.getObject("$IsBound")) {
+			//in case of bound actions, ignore the first parameter and consider the rest
+			return aParameters.slice(1, aParameters.length) || [];
+		}
+	}
+	return aParameters;
+}
+function getIsActionCritical(oMetaModel: any, sPath: any, contexts?: any, oBoundAction?: any) {
+	const vActionCritical = oMetaModel.getObject(sPath + "@com.sap.vocabularies.Common.v1.IsActionCritical");
+	let sCriticalPath = vActionCritical && vActionCritical.$Path;
+	if (!sCriticalPath) {
+		// the static value scenario for isActionCritical
+		return !!vActionCritical;
+	}
+	const aBindingParams = oBoundAction && oBoundAction.getObject("$Parameter"),
+		aPaths = sCriticalPath && sCriticalPath.split("/"),
+		bCondition =
+			aBindingParams && aBindingParams.length && typeof aBindingParams === "object" && sCriticalPath && contexts && contexts.length;
+	if (bCondition) {
+		//in case binding patameters are there in path need to remove eg: - _it/isVerified => need to remove _it and the path should be isVerified
+		aBindingParams.filter(function(oParams: any) {
+			const index = aPaths && aPaths.indexOf(oParams.$Name);
+			if (index > -1) {
+				aPaths.splice(index, 1);
+			}
+		});
+		sCriticalPath = aPaths.join("/");
+		return contexts[0].getObject(sCriticalPath);
+	} else if (sCriticalPath) {
+		//if scenario is path based return the path value
+		return contexts[0].getObject(sCriticalPath);
+	}
+}
+function _executeAction(oAppComponent: any, mParameters: any) {
+	const aContexts = mParameters.aContexts || [];
+	const oModel = mParameters.model;
+	const iExistingMessages = messageHandling.getMessages().length || 0;
+	const aActionParameters = mParameters.aActionParameters || [];
+	const sActionName = mParameters.actionName;
+	const fnOnSubmitted = mParameters.fnOnSubmitted;
+	const fnOnResponse = mParameters.fnOnResponse;
+	const bIsCreateAction = mParameters.bIsCreateAction;
+	let bActionParametersExist = false;
+	let oAction: any;
+
+	function fnDifferentiate(promise: any) {
+		return promise.then(
+			function(response: any) {
+				const aMessages = messageHandling.getMessages();
+				// Action Dialog must remain open if there are response error-messages, because in the java stack the dialog would be closed immediately.
+				if (aMessages.length > iExistingMessages && aMessages[aMessages.length - 1].type === "Error") {
+					return { response: response, status: "rejected" };
+				}
+				return { response: response, status: "resolved" };
+			},
+			function(response: any) {
+				return { response: response, status: "rejected" };
+			}
+		);
+	}
+
+	function setActionParameterDefaultValue() {
+		if (aActionParameters && aActionParameters.length) {
+			bActionParametersExist = true;
+			for (let j = 0; j < aActionParameters.length; j++) {
+				if (!aActionParameters[j].value) {
+					switch (aActionParameters[j].$Type) {
+						case "Edm.String":
+							aActionParameters[j].value = "";
+							break;
+						case "Edm.Boolean":
+							aActionParameters[j].value = false;
+							break;
+						case "Edm.Byte":
+						case "Edm.Int16":
+						case "Edm.Int32":
+						case "Edm.Int64":
+							aActionParameters[j].value = 0;
+							break;
+						// tbc
+						default:
+							break;
+					}
+				}
+				oAction.setParameter(aActionParameters[j].$Name, aActionParameters[j].value);
+			}
+		}
+	}
+
+	if (aContexts.length) {
+		return new Promise(function(resolve: (value: any) => void, reject: (reason?: any) => void) {
+			const mBindingParameters = mParameters.mBindingParameters;
+			const bGrouped = mParameters.bGrouped;
+			const bReturnAsArray = mParameters.bReturnAsArray;
+			const bGetBoundContext = mParameters.bGetBoundContext;
+			const aActionPromises: any[] = [];
+			let oActionPromise;
+			let i;
+			let sGroupId: string;
+			const fnExecuteAction = function(oAction: any, index: any, oSideEffect: any) {
+				setActionParameterDefaultValue();
+				// For invocation grouping "isolated" need batch group per action call
+				sGroupId = !bGrouped ? "$auto." + index : oAction.getUpdateGroupId();
+				oActionPromise = bGetBoundContext
+					? oAction.execute(sGroupId).then(function() {
+							return oAction.getBoundContext();
+					  })
+					: oAction.execute(sGroupId);
+				aActionPromises.push(oActionPromise);
+				const oSideEffectsService = oAppComponent.getSideEffectsService();
+				// trigger actions from side effects
+				if (oSideEffect && oSideEffect.triggerActions && oSideEffect.triggerActions.length) {
+					oSideEffect.triggerActions.forEach(function(sTriggerAction: any) {
+						if (sTriggerAction) {
+							oSideEffectsService.executeAction(sTriggerAction, oSideEffect.context, sGroupId);
+						}
+					});
+				}
+				// request side effects for this action
+				// as we move the messages request to POST $select we need to be prepared for an empty array
+				if (oSideEffect && oSideEffect.pathExpressions && oSideEffect.pathExpressions.length > 0) {
+					oSideEffectsService
+						.requestSideEffects(oSideEffect.pathExpressions, oSideEffect.context, sGroupId)
+						.then(function() {
+							if (mParameters.operationAvailableMap && mParameters.internalModelContext) {
+								CommonUtils.setActionEnablement(
+									mParameters.internalModelContext,
+									JSON.parse(mParameters.operationAvailableMap),
+									mParameters.aContexts
+								);
+							}
+						})
+						.catch(function(oError: any) {
+							Log.error("Error while requesting side effects", oError);
+						});
+				}
+			};
+			const fnExecuteSingleAction = function(oAction: any, index: any, oSideEffect: any) {
+				const oPromise = new Promise<void>(resolve => {
+					let oLocalPromise;
+					const aLocalPromise = [];
+					setActionParameterDefaultValue();
+					// For invocation grouping "isolated" need batch group per action call
+					sGroupId = "apiMode" + index;
+					oActionPromise = bGetBoundContext
+						? oAction.execute(sGroupId).then(function() {
+								return oAction.getBoundContext();
+						  })
+						: oAction.execute(sGroupId);
+
+					aActionPromises.push(oActionPromise);
+					aLocalPromise.push(oActionPromise);
+					const oSideEffectsService = oAppComponent.getSideEffectsService();
+					// trigger actions from side effects
+					if (oSideEffect && oSideEffect.triggerActions && oSideEffect.triggerActions.length) {
+						oSideEffect.triggerActions.forEach(function(sTriggerAction: any) {
+							if (sTriggerAction) {
+								oLocalPromise = oSideEffectsService.executeAction(sTriggerAction, oSideEffect.context, sGroupId);
+								aLocalPromise.push(oLocalPromise);
+							}
+						});
+					}
+					// request side effects for this action
+					// as we move the messages request to POST $select we need to be prepared for an empty array
+					if (oSideEffect && oSideEffect.pathExpressions && oSideEffect.pathExpressions.length > 0) {
+						oLocalPromise = oSideEffectsService.requestSideEffects(oSideEffect.pathExpressions, oSideEffect.context, sGroupId);
+						aLocalPromise.push(oLocalPromise);
+						oLocalPromise
+							.then(function() {
+								if (mParameters.operationAvailableMap && mParameters.internalModelContext) {
+									CommonUtils.setActionEnablement(
+										mParameters.internalModelContext,
+										JSON.parse(mParameters.operationAvailableMap),
+										mParameters.aContexts
+									);
+								}
+							})
+							.catch(function(oError: any) {
+								Log.error("Error while requesting side effects", oError);
+							});
+					}
+					oModel.submitBatch(sGroupId);
+					Promise.all(aLocalPromise)
+						.then(function() {
+							return resolve();
+						})
+						.catch(function() {
+							return resolve();
+						});
+				});
+				return oPromise;
+			};
+
+			function fnExecuteSequentially(aContexts: any) {
+				// One action and its side effects are completed before the next action is executed
+				(
+					fnOnSubmitted ||
+					function noop() {
+						/**/
+					}
+				)(aActionPromises);
+				function processOneAction(context: any, i: any) {
+					oAction = oModel.bindContext(sActionName + "(...)", context, mBindingParameters);
+					return fnExecuteSingleAction(oAction, i, {
+						context: context,
+						pathExpressions: mParameters.additionalSideEffect && mParameters.additionalSideEffect.pathExpressions,
+						triggerActions: mParameters.additionalSideEffect && mParameters.additionalSideEffect.triggerActions
+					});
+				}
+
+				let oActionAndSideEffectPromise = Promise.resolve();
+				let j = 0;
+				aContexts.forEach(function(context: any) {
+					const id = ++j;
+					oActionAndSideEffectPromise = oActionAndSideEffectPromise.then(function() {
+						return processOneAction(context, id);
+					});
+				});
+				oActionAndSideEffectPromise
+					.then(function() {
+						fnHandleResults();
+					})
+					.catch();
+			}
+
+			if (mParameters.bObjectPage && !bGrouped) {
+				// For invocation grouping "isolated" called from ObjectPage, ensure that each action and matching side effects
+				// are processed before the next set is submitted. Workaround until JSON batch is available.
+				fnExecuteSequentially(aContexts);
+			} else {
+				for (i = 0; i < aContexts.length; i++) {
+					oAction = oModel.bindContext(sActionName + "(...)", aContexts[i], mBindingParameters);
+					fnExecuteAction(oAction, aContexts.length <= 1 ? null : i, {
+						context: aContexts[i],
+						pathExpressions: mParameters.additionalSideEffect && mParameters.additionalSideEffect.pathExpressions,
+						triggerActions: mParameters.additionalSideEffect && mParameters.additionalSideEffect.triggerActions
+					});
+				}
+				(
+					fnOnSubmitted ||
+					function noop() {
+						/**/
+					}
+				)(aActionPromises);
+				fnHandleResults();
+			}
+
+			function fnHandleResults() {
+				Promise.all(aActionPromises.map(fnDifferentiate))
+					.then(function(results: any[]) {
+						const aRejectedItems = [];
+						const aResolvedItems = [];
+						let iResultCount;
+						for (iResultCount = 0; iResultCount < results.length; iResultCount++) {
+							if (results[iResultCount].status === "rejected") {
+								aRejectedItems.push(results[iResultCount].response);
+							}
+							if (results[iResultCount].status === "resolved") {
+								if (bIsCreateAction && bActionParametersExist) {
+									//only used for NewAction
+									results[iResultCount].bConsiderDocumentModified = true;
+									aResolvedItems.push(results[iResultCount]);
+								} else {
+									aResolvedItems.push(results[iResultCount].response);
+								}
+							}
+						}
+						if (!results || (results && results.length === 0)) {
+							reject(true);
+						}
+						if (aRejectedItems.length === 0) {
+							if (bReturnAsArray) {
+								resolve(aResolvedItems);
+							} else {
+								// context is given directly without an array so also no array is expected
+								resolve(aResolvedItems[0]);
+							}
+						} else {
+							reject({
+								resolvedItems: aResolvedItems,
+								rejectedItems: aRejectedItems
+							});
+						}
+					})
+					.catch(reject);
+			}
+		}).finally(function() {
+			(
+				fnOnResponse ||
+				function noop() {
+					/**/
+				}
+			)();
+		});
+	} else {
+		oAction = oModel.bindContext("/" + sActionName + "(...)");
+		setActionParameterDefaultValue();
+		const oActionPromise = oAction.execute("actionImport");
+		oModel.submitBatch("actionImport");
+		// trigger onSubmitted "event"
+		(
+			fnOnSubmitted ||
+			function noop() {
+				/**/
+			}
+		)(oActionPromise);
+		return oActionPromise.finally(function() {
+			(
+				fnOnResponse ||
+				function noop() {
+					/**/
+				}
+			)();
+		});
+	}
+}
+function _getPath(oActionContext: any, sActionName: any) {
+	let sPath = oActionContext.getPath();
+	sPath = oActionContext.getObject("$IsBound") ? sPath.split("@$ui5.overload")[0] : sPath.split("/0")[0];
+	return sPath.split("/" + sActionName)[0];
+}
+
+/**
+ * Static functions to call OData actions (bound/import) and functions (bound/import)
+ *
+ * @namespace
+ * @alias sap.fe.core.actions.operations
+ * @private
+ * @experimental This module is only for experimental use! <br/><b>This is only a POC and maybe deleted</b>
+ * @since 1.56.0
+ */
+const operations = {
+	callBoundAction: callBoundAction,
+	callActionImport: callActionImport,
+	callBoundFunction: callBoundFunction,
+	callFunctionImport: callFunctionImport
+};
+
+export default operations;