@sapui5/sap.fe.core 1.108.2 → 1.108.6

package/src/sap/fe/core/controllerextensions/editFlow/operations.ts

@@ -9,7 +9,9 @@ import { generate } from "sap/fe/core/helpers/StableIdHelper";
 import FELibrary from "sap/fe/core/library";
 import Button from "sap/m/Button";
 import Dialog from "sap/m/Dialog";
+import type Label from "sap/m/Label";
 import MessageBox from "sap/m/MessageBox";
+import type Event from "sap/ui/base/Event";
 import type Control from "sap/ui/core/Control";
 import Core from "sap/ui/core/Core";
 import Fragment from "sap/ui/core/Fragment";
@@ -17,9 +19,14 @@ import { MessageType } from "sap/ui/core/library";
 import Message from "sap/ui/core/message/Message";
 import XMLPreprocessor from "sap/ui/core/util/XMLPreprocessor";
 import XMLTemplateProcessor from "sap/ui/core/XMLTemplateProcessor";
+import type Field from "sap/ui/mdc/Field";
+import type MultiValueFieldItem from "sap/ui/mdc/field/MultiValueFieldItem";
+import type MultiValueField from "sap/ui/mdc/MultiValueField";
+import type Context from "sap/ui/model/Context";
 import JSONModel from "sap/ui/model/json/JSONModel";
+import type AppComponent from "../../AppComponent";
 import operationsHelper from "../../operationsHelper";
-import MessageHandler from "../MessageHandler";
+import type MessageHandler from "../MessageHandler";
 
 const Constants = FELibrary.Constants,
 	InvocationGrouping = FELibrary.InvocationGrouping;
@@ -51,7 +58,7 @@ const Action = (MessageBox as any).Action;
  * @private
  * @ui5-restricted
  */
-function callBoundAction(sActionName: string, contexts: any, oModel: any, oAppComponent: object, mParameters: any) {
+function callBoundAction(sActionName: string, contexts: any, oModel: any, oAppComponent: AppComponent, 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");
@@ -122,7 +129,7 @@ function callBoundAction(sActionName: string, contexts: any, oModel: any, oAppCo
  * @private
  * @ui5-restricted
  */
-function callActionImport(sActionName: string, oModel: any, oAppComponent: object, mParameters: any) {
+function callActionImport(sActionName: string, oModel: any, oAppComponent: AppComponent, mParameters: any) {
 	if (!oModel) {
 		return Promise.reject("Action expects a model/context for execution");
 	}
@@ -180,7 +187,7 @@ function _executeFunction(sFunctionName: any, oModel: any, oFunction: any, conte
 		return oFunction.getBoundContext();
 	});
 }
-function callAction(sActionName: any, oModel: any, oAction: any, oAppComponent: any, mParameters: any) {
+function callAction(sActionName: any, oModel: any, oAction: any, oAppComponent: AppComponent, mParameters: any) {
 	return new Promise(async function (resolve: (value: any) => void, reject: (reason?: any) => void) {
 		let mActionExecutionParameters: any = {};
 		let fnDialog;
@@ -210,6 +217,7 @@ function callAction(sActionName: any, oModel: any, oAction: any, oAppComponent:
 		// The parameter ResultIsActiveEntity is always hidden in the dialog! Hence if
 		// this is the only parameter, this is treated as no parameter here because the
 		// dialog would be empty!
+		// FIXME: Should only ignore this if this is a 'create' action, otherwise it is just some normal parameter that happens to have this name
 		const bActionNeedsParameterDialog =
 			aActionParameters.length > 0 && !(aActionParameters.length === 1 && aActionParameters[0].$Name === "ResultIsActiveEntity");
 
@@ -352,10 +360,10 @@ function callAction(sActionName: any, oModel: any, oAction: any, oAppComponent:
 						(element: any) => element.name === mActionExecutionParameters.aActionParameters[i].$Name
 					)?.value;
 				}
-			} else if (oStartupParameters) {
+			} else {
 				for (const i in mActionExecutionParameters.aActionParameters) {
 					mActionExecutionParameters.aActionParameters[i].value =
-						oStartupParameters[mActionExecutionParameters.aActionParameters[i].$Name][0];
+						oStartupParameters[mActionExecutionParameters.aActionParameters[i].$Name]?.[0];
 				}
 			}
 			let oOperationResult: any;
@@ -368,7 +376,7 @@ function callAction(sActionName: any, oModel: any, oAction: any, oAppComponent:
 					mParameters.messageHandler
 				);
 
-				const messages = sap.ui.getCore().getMessageManager().getMessageModel().getData();
+				const messages = Core.getMessageManager().getMessageModel().getData();
 				if (
 					mActionExecutionParameters.internalModelContext &&
 					mActionExecutionParameters.internalModelContext.getProperty("412Executed") &&
@@ -418,7 +426,7 @@ function callAction(sActionName: any, oModel: any, oAction: any, oAppComponent:
 }
 function confirmCriticalAction(
 	sActionName: any,
-	oAppComponent: any,
+	oAppComponent: AppComponent,
 	sActionLabel: any,
 	mParameters: any,
 	aActionParameters: any,
@@ -464,7 +472,7 @@ function confirmCriticalAction(
 }
 
 async function executeAPMAction(
-	oAppComponent: any,
+	oAppComponent: AppComponent,
 	mParameters: any,
 	oParentControl: any,
 	messageHandler: MessageHandler,
@@ -481,7 +489,7 @@ async function executeAPMAction(
 		throw aResult;
 	}
 
-	const messages = sap.ui.getCore().getMessageManager().getMessageModel().getData();
+	const messages = Core.getMessageManager().getMessageModel().getData();
 	if (
 		mParameters.internalModelContext &&
 		mParameters.internalModelContext.getProperty("412Executed") &&
@@ -638,12 +646,26 @@ function actionParameterShowMessageCallback(
  *
  */
 
+// this type is meant to describe the meta information for one ActionParameter (i.e. its object in metaModel)
+type ActionParameter = {
+	$Name: string;
+	$isCollection: boolean;
+	// currently runtime information is written into the metamodel:
+	// - in the press handler of the action button on the parameter dialog, the value of each parameter is added
+	// - in setActionParameterDefaultValue, this information is used and transferred to the context (in ODataModel) created for the action execution
+	// this is quite odd, and it would make much more sense to take the value from actionParameterInfos
+	// - however, setActionParameterDefaultValue (or rather the surrounding _executeAction) is also called from other places
+	// => for the time being, adding value here to avoid ts errors, subject to refactoring
+	// in case of Field, the value is string, in case of MultiValueField, it's MultiValueFieldItem[]
+	value: string | MultiValueFieldItem[];
+};
+
 function showActionParameterDialog(
 	sActionName: any,
-	oAppComponent: any,
+	oAppComponent: AppComponent,
 	sActionLabel: any,
 	mParameters: any,
-	aActionParameters: any,
+	aActionParameters: ActionParameter[],
 	aParameterValues: any,
 	oActionContext: any,
 	oParentControl: any,
@@ -660,84 +682,112 @@ function showActionParameterDialog(
 		bIsCreateAction = mParameters.isCreateAction,
 		sFragmentName = "sap/fe/core/controls/ActionParameterDialog";
 	return new Promise(async function (resolve, reject) {
-		const oFragment = XMLTemplateProcessor.loadTemplate(sFragmentName, "fragment");
-		const oParameterModel = new JSONModel({
-			$displayMode: {}
-		});
-		let aFieldInvalid: any[] = [];
-		let aFormElements: any[] = [];
-		const mFieldValueMap: any = {};
-		const validateRequiredProperties = async function () {
-			const aResults = await Promise.all(
-				aFormElements
-					.filter(function (oFormElement: any) {
-						const oField = oFormElement.getFields()[0];
-						return oField.getRequired();
-					})
-					.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 === "" || (Array.isArray(value) && !value.length)) {
-							return oFormElement;
-						}
-					})
+		type ActionParameterInfo = {
+			parameter: ActionParameter;
+			field: Field | MultiValueField;
+			isMultiValue: boolean;
+			value?: string | MultiValueFieldItem[];
+			validationPromise?: Promise<string | MultiValueFieldItem[]>;
+		};
+		let actionParameterInfos: ActionParameterInfo[]; // to be filled after fragment (for action parameter dialog) is loaded. Actually only needed during dialog processing, i.e. could be moved into the controller and directly initialized there, but only after moving all handlers (esp. press handler for action button) to controller.
+
+		const messageManager = Core.getMessageManager();
+
+		// in case of missing mandaotory parameter, message currently differs per parameter, as it superfluously contains the label as parameter. Possiblky this could be removed in future, in that case, interface could be simplified to ActionParameterInfo[], string
+		const _addMessageForActionParameter = (messageParameters: { actionParameterInfo: ActionParameterInfo; message: string }[]) => {
+			messageManager.addMessages(
+				messageParameters.map((messageParameter) => {
+					const binding = messageParameter.actionParameterInfo.field.getBinding(
+						messageParameter.actionParameterInfo.isMultiValue ? "items" : "value"
+					);
+					return new Message({
+						message: messageParameter.message,
+						type: "Error",
+						processor: binding?.getModel(),
+						persistent: true,
+						target: binding?.getResolvedPath()
+					});
+				})
 			);
-			return aResults.filter(function (result: any) {
-				return result !== undefined;
-			});
 		};
-		const _validateMessages = function (actionParameters: any, invalidFields: any, bClearTarget?: boolean) {
-			const oMessageManager = Core.getMessageManager();
-			const aMessages = oMessageManager.getMessageModel().getData();
 
-			invalidFields = invalidFields || [];
+		const _removeMessagesForActionParamter = (parameter: ActionParameter) => {
+			const allMessages = messageManager.getMessageModel().getData();
+			const controlId = generate(["APD_", parameter.$Name]);
+			// also remove messages assigned to inner controls, but avoid removing messages for different paramters (with name being substring of another parameter name)
+			const relevantMessages = allMessages.filter((msg: Message) =>
+				msg.getControlIds().some((id: string) => controlId.split("-").includes(id))
+			);
+			messageManager.removeMessages(relevantMessages);
+		};
 
-			if (!aMessages.length) {
-				invalidFields = [];
-			}
-			actionParameters.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`) && invalidFields.indexOf(`APD_::${sParam}`) < 0))
-					) {
-						if (bClearTarget) {
-							oMessageManager.removeMessages(oMessage);
-						} else {
-							invalidFields.push(`APD_::${sParam}`);
-						}
-					}
-					// Handle messages related to input with invalid token
-					if (oMessage.target.includes(`APD_::${sParameter}`)) {
-						invalidFields.push(`APD_::${sParam}`);
-						oMessage.target = bClearTarget ? "" : oMessage.target;
-						if (bClearTarget) {
-							oMessageManager.removeMessages(oMessage);
-						}
-					}
-				});
-			});
-			return invalidFields;
+		const _validateRequiredProperties = async function (oResourceBundle: ResourceBundle) {
+			const requiredParameterInfos = actionParameterInfos.filter((actionParameterInfo) => actionParameterInfo.field.getRequired());
+			// before validation of required fields is not complete, we cannot know the values and thus cannot validate they are provided
+			const validationResults = await Promise.allSettled(
+				requiredParameterInfos.map((actionParameterInfo) => actionParameterInfo.validationPromise)
+			);
+
+			const validRequiredFields = validationResults
+				.map((validationResult, index) => ({
+					validationResult: validationResult,
+					index: index
+				}))
+				.filter((validationResult) => validationResult.validationResult.status === "fulfilled")
+				.map((validationResult) => requiredParameterInfos[validationResult.index]);
+
+			const emptyRequiredFields = validRequiredFields.filter((actionParameterInfo) =>
+				actionParameterInfo.isMultiValue ? !(actionParameterInfo.value as MultiValueFieldItem[]).length : !actionParameterInfo.value
+			);
+			if (!emptyRequiredFields.length) return true;
+
+			// message contains label per field for historical reason (originally, it was shown in additional popup, now it's directly added to the field)
+			// if this was not the case (and hopefully, in future this might be subject to change), interface of _addMessageForActionParameter could be simplified to just pass emptyRequiredFields and a constant message here
+			_addMessageForActionParameter(
+				emptyRequiredFields.map((actionParameterInfo) => ({
+					actionParameterInfo: actionParameterInfo,
+					message: CommonUtils.getTranslatedText("C_OPERATIONS_ACTION_PARAMETER_DIALOG_MISSING_MANDATORY_MSG", oResourceBundle, [
+						(actionParameterInfo.field.getParent()?.getAggregation("label") as Label).getText()
+					])
+				}))
+			);
+
+			// Set the focus on the dialog's first erroneous required control
+			emptyRequiredFields[0].field.focus();
+
+			return false;
 		};
+
 		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();
-					});
+			handleChange: async function (oEvent: Event) {
+				const field = oEvent.getSource();
+				const actionParameterInfo = actionParameterInfos.find(
+					(actionParameterInfo) => actionParameterInfo.field === field
+				) as ActionParameterInfo;
+				// field value is being changed, thus existing messages related to that field are not valid anymore
+				_removeMessagesForActionParamter(actionParameterInfo.parameter);
+				// adapt info. Promise is resolved to value or rejected with exception containing message
+				actionParameterInfo.validationPromise = oEvent.getParameter("promise") as Promise<string>;
+
+				try {
+					actionParameterInfo.value = await actionParameterInfo.validationPromise;
+				} catch (error) {
+					delete actionParameterInfo.value;
+					_addMessageForActionParameter([
+						{
+							actionParameterInfo: actionParameterInfo,
+							message: (error as { message: string }).message
+						}
+					]);
 				}
-				_validateMessages(aActionParameters, aFieldInvalid);
 			}
 		};
 
+		const oFragment = XMLTemplateProcessor.loadTemplate(sFragmentName, "fragment");
+		const oParameterModel = new JSONModel({
+			$displayMode: {}
+		});
+
 		try {
 			const createdFragment = await XMLPreprocessor.process(
 				oFragment,
@@ -762,20 +812,38 @@ function showActionParameterDialog(
 			// eslint-disable-next-line prefer-const
 			let oOperationBinding: any;
 			await CommonUtils.setUserDefaults(oAppComponent, aActionParameters, oParameterModel, true);
-			const oDialogContent = (await Fragment.load({ definition: createdFragment, controller: oController })) as Control;
+			const oDialogContent = (await Fragment.load({
+				definition: createdFragment,
+				controller: oController
+			})) as Control;
+
+			actionParameterInfos = aActionParameters.map((actionParameter) => {
+				const field = Core.byId(generate(["APD_", actionParameter.$Name])) as Field | MultiValueField;
+				const isMultiValue = field.isA("sap.ui.mdc.MultiValueField");
+				return {
+					parameter: actionParameter,
+					field: field,
+					isMultiValue: isMultiValue
+				};
+			});
+
 			const oResourceBundle = oParentControl.getController().oResourceBundle;
+			let actionResult = {
+				dialogCancelled: true, // to be set to false in case of successful action exection
+				result: undefined
+			};
 			const oDialog = new Dialog(undefined, {
 				title: sActionLabel || CommonUtils.getTranslatedText("C_OPERATIONS_ACTION_PARAMETER_DIALOG_TITLE", oResourceBundle),
 				content: [oDialogContent],
 				escapeHandler: function () {
 					// escape handler is meant to possibly suppress or postpone closing the dialog on escape (by calling "reject" on the provided object, or "resolve" only when
 					// done with all tasks to happen before dialog can be closed). It's not intended to explicetly close the dialog here (that happens automatically when no
-					// escapeHandler is provided or the resolve-calllback is calle) or for own wrap up tasks (like removing validition messages - this should happen in the
+					// escapeHandler is provided or the resolve-callback is called) or for own wrap up tasks (like removing validition messages - this should happen in the
 					// afterClose).
 					// TODO: Move wrap up tasks to afterClose, and remove this method completely. Take care to also adapt end button press handler accordingly.
+					// Currently only still needed to differentiate closing dialog after successful execution (uses resolve) from user cancellation (using reject)
 					oDialog.close();
-					messageHandler.removeTransitionMessages();
-					reject(Constants.CancelActionDialog);
+					//		reject(Constants.CancelActionDialog);
 				},
 				beginButton: new Button(generate(["fe", "APD_", sActionName, "Action", "Ok"]), {
 					text: bIsCreateAction
@@ -784,37 +852,13 @@ function showActionParameterDialog(
 					type: "Emphasized",
 					press: async function () {
 						try {
-							const aEmptyMandatoryFields = await validateRequiredProperties();
-							if (aEmptyMandatoryFields.length) {
-								for (let i = 0; i < aEmptyMandatoryFields.length; i++) {
-									aEmptyMandatoryFields[i].getFields()[0].setValueState("Error");
-									aEmptyMandatoryFields[i]
-										.getFields()[0]
-										.setValueStateText(
-											CommonUtils.getTranslatedText(
-												"C_OPERATIONS_ACTION_PARAMETER_DIALOG_MISSING_MANDATORY_MSG",
-												oResourceBundle,
-												aEmptyMandatoryFields[i].getLabel().getText()
-											)
-										);
-								}
+							if (!(await _validateRequiredProperties(oResourceBundle))) {
 								return;
 							}
 
-							aFieldInvalid = _validateMessages(aActionParameters, aFieldInvalid);
-
-							if (aFieldInvalid.length > 0) {
-								await messageHandling.showUnboundMessages();
-								return;
-							}
 							BusyLocker.lock(oDialog);
 
 							try {
-								await Promise.all(
-									Object.keys(mFieldValueMap).map(function (sKey: string) {
-										return mFieldValueMap[sKey];
-									})
-								);
 								// 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();
@@ -832,7 +876,7 @@ function showActionParameterDialog(
 									} else {
 										vParameterValue = oParameterContext.getProperty(aActionParameters[i].$Name);
 									}
-									aActionParameters[i].value = vParameterValue;
+									aActionParameters[i].value = vParameterValue; // writing the current value (ueser input!) into the metamodel => should be refactored to use ActionParameterInfos instead. Used in setActionParameterDefaultValue
 									vParameterValue = undefined;
 								}
 								mParameters.label = sActionLabel;
@@ -847,8 +891,11 @@ function showActionParameterDialog(
 										oDialog,
 										false
 									);
+									actionResult = {
+										dialogCancelled: false,
+										result: aResult
+									};
 									oDialog.close();
-									resolve(aResult);
 								} catch (oError: any) {
 									const messages = sap.ui.getCore().getMessageManager().getMessageModel().getData();
 									if (
@@ -887,7 +934,10 @@ function showActionParameterDialog(
 
 											mParameters.internalModelContext.setProperty("strictHandlingFails", []);
 											mParameters.internalModelContext.setProperty("processedMessageIds", []);
-											resolve(aResult);
+											actionResult = {
+												dialogCancelled: false,
+												result: aResult
+											};
 										} catch {
 											if (
 												mParameters.internalModelContext &&
@@ -959,13 +1009,7 @@ function showActionParameterDialog(
 					text: CommonUtils.getTranslatedText("C_COMMON_ACTION_PARAMETER_DIALOG_CANCEL", oResourceBundle),
 					press: function () {
 						// TODO: cancel button should just close the dialog (similar to using escape). All wrap up tasks should be moved to afterClose.
-						// Assumption: _validateMessages is only called to remove exisitng validation messages (is user first enters invalid parameter, and later cancels).
-						// If this assumption is correct, this needs also to be done when leaving the dialog with escape, i.e. should be moved to afterClose.
-						_validateMessages(aActionParameters, aFieldInvalid, true);
 						oDialog.close();
-						// should not be done here, but after close, as the same should happen when leaving with escape
-						messageHandler.removeTransitionMessages();
-						reject(Constants.CancelActionDialog);
 					}
 				}),
 				// TODO: beforeOpen is just an event, i.e. not waiting for the Promise to be resolved. Check if tasks of this function need to be done before opening the dialog
@@ -986,63 +1030,60 @@ function showActionParameterDialog(
 					};
 					const fnSetDefaultsAndOpenDialog = async function (sBindingParameter?: any) {
 						const sBoundFunctionName = getDefaultValuesFunction();
-						const prefillParameter = function (sParamName: any, vParamDefaultValue: any) {
-							// eslint-disable-next-line promise/param-names
-							return new Promise(async function (inResolve) {
-								// Case 1: There is a ParameterDefaultValue annotation
-								if (vParamDefaultValue !== undefined) {
-									if (aContexts.length > 0 && vParamDefaultValue.$Path) {
-										try {
-											let vParamValue = await CommonUtils.requestSingletonProperty(
-												vParamDefaultValue.$Path,
-												oOperationBinding.getModel()
-											);
-											if (vParamValue === null) {
-												vParamValue = await oOperationBinding
-													.getParameterContext()
-													.requestProperty(vParamDefaultValue.$Path);
+						const prefillParameter = async function (sParamName: any, vParamDefaultValue: any) {
+							// Case 1: There is a ParameterDefaultValue annotation
+							if (vParamDefaultValue !== undefined) {
+								if (aContexts.length > 0 && vParamDefaultValue.$Path) {
+									try {
+										let vParamValue = await CommonUtils.requestSingletonProperty(
+											vParamDefaultValue.$Path,
+											oOperationBinding.getModel()
+										);
+										if (vParamValue === null) {
+											vParamValue = await oOperationBinding
+												.getParameterContext()
+												.requestProperty(vParamDefaultValue.$Path);
+										}
+										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}/`, "");
 											}
-											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
-														inResolve({
-															paramName: sParamName,
-															value: undefined,
-															bNoPossibleValue: true
-														});
-													}
+											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
+													return {
+														paramName: sParamName,
+														value: undefined,
+														bNoPossibleValue: true
+													};
 												}
 											}
-											inResolve({ paramName: sParamName, value: vParamValue });
-										} catch (oError) {
-											Log.error("Error while reading default action parameter", sParamName, mParameters.actionName);
-											inResolve({
-												paramName: sParamName,
-												value: undefined,
-												bLatePropertyError: true
-											});
 										}
-									} else {
-										// Case 1.2: ParameterDefaultValue defines a fixed string value (i.e. vParamDefaultValue = 'someString')
-										inResolve({ paramName: sParamName, value: vParamDefaultValue });
+										return { paramName: sParamName, value: vParamValue };
+									} catch (oError) {
+										Log.error("Error while reading default action parameter", sParamName, mParameters.actionName);
+										return {
+											paramName: sParamName,
+											value: undefined,
+											bLatePropertyError: true
+										};
 									}
-								} else if (oParameterModel && (oParameterModel as any).oData[sParamName]) {
-									// Case 2: There is no ParameterDefaultValue annotation (=> look into the FLP User Defaults)
-
-									inResolve({
-										paramName: sParamName,
-										value: (oParameterModel as any).oData[sParamName]
-									});
 								} else {
-									inResolve({ paramName: sParamName, value: undefined });
+									// Case 1.2: ParameterDefaultValue defines a fixed string value (i.e. vParamDefaultValue = 'someString')
+									return { paramName: sParamName, value: vParamDefaultValue };
 								}
-							});
+							} else if (oParameterModel && (oParameterModel as any).oData[sParamName]) {
+								// Case 2: There is no ParameterDefaultValue annotation (=> look into the FLP User Defaults)
+
+								return {
+									paramName: sParamName,
+									value: (oParameterModel as any).oData[sParamName]
+								};
+							} else {
+								return { paramName: sParamName, value: undefined };
+							}
 						};
 
 						const getParameterDefaultValue = function (sParamName: any) {
@@ -1184,16 +1225,28 @@ function showActionParameterDialog(
 					};
 
 					await fnAsyncBeforeOpen();
+
+					// adding defaulted values only here after they are not set to the fields
+					for (const actionParameterInfo of actionParameterInfos) {
+						const value = actionParameterInfo.isMultiValue
+							? (actionParameterInfo.field as MultiValueField).getItems()
+							: (actionParameterInfo.field as Field).getValue();
+						actionParameterInfo.value = value;
+						actionParameterInfo.validationPromise = Promise.resolve(value);
+					}
 				},
 				afterClose: function () {
+					// when the dialog is cancelled, messages need to be removed in case the same action should be executed again
+					aActionParameters.forEach(_removeMessagesForActionParamter);
 					oDialog.destroy();
+					if (actionResult.dialogCancelled) {
+						reject(Constants.CancelActionDialog);
+					} else {
+						resolve(actionResult.result);
+					}
 				}
 			});
 			mParameters.oDialog = oDialog;
-			aFormElements = (oDialogContent as any)
-				.getAggregation("form")
-				.getAggregation("formContainers")[0]
-				.getAggregation("formElements");
 			oDialog.setModel(oActionContext.getModel().oModel);
 			oDialog.setModel(oParameterModel, "paramsModel");
 			oDialog.bindElement({
@@ -1411,6 +1464,7 @@ function executeDependingOnSelectedContexts(
 							messageHandler,
 							oResourceBundle
 						);
+
 						return Promise.reject();
 					})
 			: oAction
@@ -1531,45 +1585,36 @@ function _executeAction(oAppComponent: any, mParameters: any, oParentControl?: a
 				fnRequestSideEffects(oAppComponent, oSideEffect, mParameters, sGroupId);
 			};
 			const fnExecuteSingleAction = function (actionContext: any, current_context_index: any, oSideEffect: any, iContextLength: any) {
-				// eslint-disable-next-line promise/param-names
-				return new Promise<void>((actionResolve) => {
-					const aLocalPromise: any = [];
-					setActionParameterDefaultValue();
-					// For invocation grouping "isolated" need batch group per action call
-					sGroupId = `apiMode${current_context_index}`;
-					mParameters.requestSideEffects = fnRequestSideEffects.bind(
-						operations,
-						oAppComponent,
-						oSideEffect,
-						mParameters,
-						sGroupId,
-						aLocalPromise
-					);
-					oActionPromise = executeDependingOnSelectedContexts(
-						actionContext,
-						mParameters,
-						bGetBoundContext,
-						sGroupId,
-						oResourceBundle,
-						messageHandler,
-						iContextLength,
-						current_context_index
-					);
-					aActionPromises.push(oActionPromise);
-					aLocalPromise.push(oActionPromise);
-					fnRequestSideEffects(oAppComponent, oSideEffect, mParameters, sGroupId, aLocalPromise);
-					oModel.submitBatch(sGroupId);
-					Promise.all(aLocalPromise)
-						.then(function () {
-							return actionResolve();
-						})
-						.catch(function () {
-							return actionResolve();
-						});
-				});
+				const aLocalPromise: any = [];
+				setActionParameterDefaultValue();
+				// For invocation grouping "isolated" need batch group per action call
+				sGroupId = `apiMode${current_context_index}`;
+				mParameters.requestSideEffects = fnRequestSideEffects.bind(
+					operations,
+					oAppComponent,
+					oSideEffect,
+					mParameters,
+					sGroupId,
+					aLocalPromise
+				);
+				oActionPromise = executeDependingOnSelectedContexts(
+					actionContext,
+					mParameters,
+					bGetBoundContext,
+					sGroupId,
+					oResourceBundle,
+					messageHandler,
+					iContextLength,
+					current_context_index
+				);
+				aActionPromises.push(oActionPromise);
+				aLocalPromise.push(oActionPromise);
+				fnRequestSideEffects(oAppComponent, oSideEffect, mParameters, sGroupId, aLocalPromise);
+				oModel.submitBatch(sGroupId);
+				return Promise.allSettled(aLocalPromise);
 			};
 
-			function fnExecuteSequentially(contextsToExecute: any) {
+			async function fnExecuteSequentially(contextsToExecute: Context[]) {
 				// One action and its side effects are completed before the next action is executed
 				(
 					fnOnSubmitted ||
@@ -1591,22 +1636,13 @@ function _executeAction(oAppComponent: any, mParameters: any, oParentControl?: a
 					);
 				}
 
-				let oActionAndSideEffectPromise = Promise.resolve();
-				let j = 0;
-				contextsToExecute.forEach(function (context: any) {
-					const id = ++j;
-					oActionAndSideEffectPromise = oActionAndSideEffectPromise.then(function () {
-						return processOneAction(context, id, aContexts.length);
-					});
-				});
+				// serialization: processOneAction to be called for each entry in contextsToExecute only after the promise returned from the one before has been resolved
+				await contextsToExecute.reduce(async (promise: Promise<void>, context: Context, id: int): Promise<void> => {
+					await promise;
+					await processOneAction(context, id + 1, aContexts.length);
+				}, Promise.resolve());
 
-				oActionAndSideEffectPromise
-					.then(function () {
-						fnHandleResults();
-					})
-					.catch(function (oError: any) {
-						Log.error(oError);
-					});
+				fnHandleResults();
 			}
 
 			if (!bGrouped) {