@sapui5/sap.fe.core 1.99.0 → 1.101.1

package/src/sap/fe/core/helpers/MassEditHelper.ts

@@ -0,0 +1,803 @@
+import Log from "sap/base/Log";
+import CommonUtils from "sap/fe/core/CommonUtils";
+import { BindingExpression, ExpressionOrPrimitive } from "sap/fe/core/helpers/BindingExpression";
+import PageController from "sap/fe/core/PageController";
+import { DataModelObjectPath, enhanceDataModelPath } from "sap/fe/core/templating/DataModelPathHelper";
+import { hasValueHelpWithFixedValues } from "sap/fe/core/templating/PropertyHelper";
+import { FieldProperties } from "sap/fe/macros/field/FieldProperties";
+import { getTextBinding, setEditStyleProperties } from "sap/fe/macros/field/FieldTemplating";
+import Button from "sap/m/Button";
+import Dialog from "sap/m/Dialog";
+import Core from "sap/ui/core/Core";
+import Fragment from "sap/ui/core/Fragment";
+import XMLPreprocessor from "sap/ui/core/util/XMLPreprocessor";
+import XMLTemplateProcessor from "sap/ui/core/XMLTemplateProcessor";
+import EditMode from "sap/ui/mdc/enum/EditMode";
+import Table from "sap/ui/mdc/Table";
+import JSONModel from "sap/ui/model/json/JSONModel";
+import Context from "sap/ui/model/odata/v4/Context";
+import { CoreEx } from "types/extension_types";
+import Any, { AnyType } from "../controls/Any";
+import { convertMetaModelContext, getInvolvedDataModelObjects } from "../converters/MetaModelConverter";
+import { isReadOnlyExpression } from "../templating/FieldControlHelper";
+import { getEditMode, getRequiredExpression, isCollectionField } from "../templating/UIFormatters";
+
+/* This class contains helpers to be used for mass edit functionality */
+type TextArrangementInfo = {
+	textArrangement: string;
+	valuePath: string;
+	descriptionPath?: string;
+	value: string;
+	description: string;
+	fullText: string;
+};
+
+const MassEditHelper = {
+	/**
+	 * Initializes the value at final or deepest level path with a blank array.
+	 * Return an empty array pointing to the final or deepest level path.
+	 *
+	 * @param {string} sPath Property path
+	 * @param {Array} aValues Array instance where the default data needs to be added
+	 * @returns {Array}
+	 */
+	initLastLevelOfPropertyPath: function (sPath: string, aValues: any) {
+		let aFinalPath: any;
+		let index = 0;
+		const aPaths = sPath.split("/");
+		let sFullPath = "";
+		aPaths.forEach(function (sPropertyPath: string) {
+			if (!aValues[sPropertyPath] && index === 0) {
+				aValues[sPropertyPath] = {};
+				aFinalPath = aValues[sPropertyPath];
+				sFullPath = sFullPath + sPropertyPath;
+				index++;
+			} else if (!aFinalPath[sPropertyPath]) {
+				sFullPath = sFullPath + "/" + sPropertyPath;
+				if (sFullPath !== sPath) {
+					aFinalPath[sPropertyPath] = {};
+					aFinalPath = aFinalPath[sPropertyPath];
+				} else {
+					aFinalPath[sPropertyPath] = [];
+				}
+			}
+		});
+		return aFinalPath;
+	},
+
+	/**
+	 * Method to get unique values for given array values.
+	 *
+	 * @param {string} sValue Property value
+	 * @param {number} index Index of the property value
+	 * @param {Array} self Instance of the array
+	 * @returns {boolean}
+	 */
+	getUniqueValues: function (sValue: string, index: number, self: any[]) {
+		if (sValue) {
+			return self.indexOf(sValue) === index;
+		}
+	},
+
+	/**
+	 * Gets the property value for a multi-level path (for example: _Materials/Material_Details gets the value of Material_Details under _Materials Object).
+	 * Returns the propertyValue, which can be of any type (string, number, etc..).
+	 *
+	 * @param {string} sDataPropertyPath Property path
+	 * @param {object} oValues Object of property values
+	 * @returns {*}
+	 */
+	getValueForMultiLevelPath: function (sDataPropertyPath: string, oValues: any) {
+		if (sDataPropertyPath && sDataPropertyPath.indexOf("/") > 0) {
+			const aPropertyPaths = sDataPropertyPath.split("/");
+			let Result: any;
+			aPropertyPaths.forEach(function (sPath: string) {
+				Result = oValues && oValues[sPath] ? oValues[sPath] : Result && Result[sPath];
+			});
+			return Result;
+		}
+	},
+
+	/**
+	 * Gets the key path for the key of a combo box that must be selected initially when the dialog opens:
+	 * => If propertyValue for all selected contexts is different, then < Keep Existing Values > is preselected.
+	 * => If propertyValue for all selected contexts is the same, then the propertyValue is preselected.
+	 * => If propertyValue for all selected contexts is empty, then < Leave Blank > is preselected.
+	 *
+	 *
+	 * @param {Array} aContexts Contexts for mass edit
+	 * @param {string} sDataPropertyPath Data property path
+	 * @returns {string}
+	 */
+	getDefaultSelectionPathComboBox: function (aContexts: any[], sDataPropertyPath: string) {
+		if (sDataPropertyPath && aContexts.length > 0) {
+			const oSelectedContext = aContexts,
+				aPropertyValues: any[] = [];
+			oSelectedContext.forEach(function (oContext: any) {
+				const oDataObject = oContext.getObject();
+				const sMultiLevelPathCondition =
+					sDataPropertyPath.indexOf("/") > -1 && oDataObject.hasOwnProperty(sDataPropertyPath.split("/")[0]);
+				if (oContext && (oDataObject.hasOwnProperty(sDataPropertyPath) || sMultiLevelPathCondition)) {
+					aPropertyValues.push(oContext.getObject(sDataPropertyPath));
+				}
+			});
+			const aUniquePropertyValues = aPropertyValues.filter(MassEditHelper.getUniqueValues);
+			if (aUniquePropertyValues.length > 1) {
+				return "Default/" + sDataPropertyPath;
+			} else if (aUniquePropertyValues.length === 0) {
+				return "Empty/" + sDataPropertyPath;
+			} else if (aUniquePropertyValues.length === 1) {
+				return sDataPropertyPath;
+			}
+		}
+	},
+
+	/**
+	 * Checks hidden annotation value [both static and path based] for table's selected context.
+	 *
+	 * @param {*} hiddenValue Hidden annotation value / path for field
+	 * @param {Array} aContexts Contexts for mass edit
+	 * @returns {boolean}
+	 */
+	getHiddenValueForContexts: function (hiddenValue: any, aContexts: any[]) {
+		if (hiddenValue && hiddenValue.$Path) {
+			return !aContexts.some(function (oSelectedContext: any) {
+				return oSelectedContext.getObject(hiddenValue.$Path) === false;
+			});
+		}
+		return hiddenValue;
+	},
+
+	getInputType: function (propertyInfo: any, dataFieldConverted: any, oDataModelPath: DataModelObjectPath): string {
+		const editStyleProperties = {} as FieldProperties;
+		let inputType!: string;
+		if (propertyInfo) {
+			setEditStyleProperties(editStyleProperties, dataFieldConverted, oDataModelPath, true);
+			inputType = editStyleProperties?.editStyle || "";
+		}
+		const isValidForMassEdit =
+			inputType &&
+			["DatePicker", "TimePicker", "DateTimePicker", "RatingIndicator"].indexOf(inputType) === -1 &&
+			!isCollectionField(oDataModelPath) &&
+			!hasValueHelpWithFixedValues(propertyInfo);
+
+		return (isValidForMassEdit || "") && inputType;
+	},
+
+	getIsFieldGrp: function (dataFieldConverted: any): boolean {
+		return (
+			dataFieldConverted &&
+			dataFieldConverted.$Type === "com.sap.vocabularies.UI.v1.DataFieldForAnnotation" &&
+			dataFieldConverted.Target &&
+			dataFieldConverted.Target.value &&
+			dataFieldConverted.Target.value.indexOf("FieldGroup") > -1
+		);
+	},
+
+	/**
+	 * Initializes a JSON Model for properties of dialog fields [label, visiblity, dataproperty, etc.].
+	 *
+	 * @param {object} oTable Instance of Table
+	 * @param {Array} aContexts Contexts for mass edit
+	 * @param {Array} aDataArray Array containing data related to the dialog used by both the static and the runtime model
+	 * @returns {object}
+	 */
+	prepareDataForDialog: function (oTable: Table, aContexts: any[], aDataArray: any[]) {
+		const oMetaModel = oTable && (oTable.getModel().getMetaModel() as any),
+			sCurrentEntitySetName = oTable.data("metaPath"),
+			aTableFields = MassEditHelper.getTableFields(oTable),
+			oEntityTypeContext = oMetaModel.getContext(sCurrentEntitySetName + "/@"),
+			oEntitySetContext = oMetaModel.getContext(sCurrentEntitySetName),
+			oDataModelObjectPath = getInvolvedDataModelObjects(oEntityTypeContext);
+
+		const oDataFieldModel = new JSONModel();
+		let oResult;
+		let sLabelText;
+		let bValueHelpEnabled;
+		let sUnitPropertyPath;
+		let bValueHelpEnabledForUnit;
+		let oTextBinding;
+
+		aTableFields.forEach(function (oColumnInfo: any) {
+			const sDataPropertyPath = oColumnInfo.dataProperty;
+			if (sDataPropertyPath) {
+				let oPropertyInfo = sDataPropertyPath && oMetaModel.getObject(sCurrentEntitySetName + "/" + sDataPropertyPath + "@");
+				bValueHelpEnabled =
+					sDataPropertyPath &&
+					oMetaModel.getObject(sCurrentEntitySetName + "/" + sDataPropertyPath + "@") &&
+					oMetaModel.getObject(sCurrentEntitySetName + "/" + sDataPropertyPath + "@")[
+						"@com.sap.vocabularies.Common.v1.ValueList"
+					];
+				sUnitPropertyPath =
+					(oPropertyInfo && oPropertyInfo["@Org.OData.Measures.V1.Unit"] && oPropertyInfo["@Org.OData.Measures.V1.Unit"].$Path) ||
+					(oPropertyInfo &&
+						oPropertyInfo["@Org.OData.Measures.V1.ISOCurrency"] &&
+						oPropertyInfo["@Org.OData.Measures.V1.ISOCurrency"].$Path);
+				sLabelText = oColumnInfo.label || (oPropertyInfo && oPropertyInfo["@com.sap.vocabularies.Common.v1.Label"]);
+				bValueHelpEnabledForUnit =
+					sUnitPropertyPath &&
+					oMetaModel.getObject(sCurrentEntitySetName + "/" + sUnitPropertyPath + "@") &&
+					oMetaModel.getObject(sCurrentEntitySetName + "/" + sUnitPropertyPath + "@")[
+						"@com.sap.vocabularies.Common.v1.ValueList"
+					];
+				if (oDataModelObjectPath) {
+					oDataModelObjectPath.targetObject = oDataModelObjectPath.targetEntityType.entityProperties.filter(function (
+						oProperty: any
+					) {
+						return oProperty.name === sDataPropertyPath;
+					});
+				}
+				oDataModelObjectPath.targetObject = oDataModelObjectPath.targetObject[0] || {};
+				oTextBinding = getTextBinding(oDataModelObjectPath, {}, true) || {};
+				const oFieldContext = oMetaModel.getContext(oColumnInfo.annotationPath),
+					oDataFieldConverted = convertMetaModelContext(oFieldContext),
+					oPropertyContext = oMetaModel.getContext(sCurrentEntitySetName + "/" + sDataPropertyPath + "@"),
+					oInterface = oPropertyContext && oPropertyContext.getInterface();
+
+				let oDataModelPath = getInvolvedDataModelObjects(oFieldContext, oEntitySetContext);
+				if (oDataFieldConverted?.Value?.path?.length > 0) {
+					oDataModelPath = enhanceDataModelPath(oDataModelPath, sDataPropertyPath);
+				}
+				const bHiddenField =
+					MassEditHelper.getHiddenValueForContexts(
+						oFieldContext && oFieldContext.getObject()["@com.sap.vocabularies.UI.v1.Hidden"],
+						aContexts
+					) || false;
+				const isImage = oPropertyInfo && oPropertyInfo["@com.sap.vocabularies.UI.v1.IsImageURL"];
+
+				oInterface.context = {
+					getModel: function () {
+						return oInterface.getModel();
+					},
+					getPath: function () {
+						return sCurrentEntitySetName + "/" + sDataPropertyPath;
+					}
+				};
+				oPropertyInfo =
+					(oDataFieldConverted && oDataFieldConverted.Value && oDataFieldConverted.Value.$target) ||
+					(oDataFieldConverted && oDataFieldConverted.Target && oDataFieldConverted.Target.$target);
+				// Datafield is not included in the FieldControl calculation, needs to be implemented
+
+				const chartProperty = oPropertyInfo && oPropertyInfo.term && oPropertyInfo.term === "com.sap.vocabularies.UI.v1.Chart";
+				const isAction = !!oDataFieldConverted.Action;
+				const isFieldGrp = MassEditHelper.getIsFieldGrp(oDataFieldConverted);
+
+				if (isImage || bHiddenField || chartProperty || isAction || isFieldGrp) {
+					return;
+				}
+
+				// EditMode and InputType
+				const propertyForFieldControl = oPropertyInfo && oPropertyInfo.Value ? oPropertyInfo.Value : oPropertyInfo;
+				const expBinding = getEditMode(propertyForFieldControl, oDataModelPath, false, false, oDataFieldConverted, true);
+				const editModeValues = Object.keys(EditMode);
+				const editModeIsStatic = !!expBinding && editModeValues.includes(expBinding as EditMode);
+				const editable = !!expBinding && ((editModeIsStatic && expBinding === EditMode.Editable) || !editModeIsStatic);
+
+				if (!editable) {
+					return;
+				}
+
+				const inputType = MassEditHelper.getInputType(oPropertyInfo, oDataFieldConverted, oDataModelPath);
+
+				if (inputType) {
+					const isReadOnly = isReadOnlyExpression(oPropertyInfo);
+
+					oResult = {
+						"label": sLabelText + ":",
+						"dataProperty": sDataPropertyPath,
+						"isValueHelpEnabled": bValueHelpEnabled ? bValueHelpEnabled : false,
+						"unitProperty": sUnitPropertyPath ? sUnitPropertyPath : false,
+						"isValueHelpEnabledForUnit": bValueHelpEnabledForUnit ? bValueHelpEnabledForUnit : false,
+						"propertyPathForValueHelp": sCurrentEntitySetName + "/" + sDataPropertyPath,
+						"propertyPathForValueHelpUnit": sCurrentEntitySetName + "/" + sUnitPropertyPath,
+						"isFieldRequired": getRequiredExpression(oPropertyInfo, oDataFieldConverted, true),
+						"defaultSelectionPath": sDataPropertyPath
+							? MassEditHelper.getDefaultSelectionPathComboBox(aContexts, sDataPropertyPath)
+							: false,
+						"defaultSelectionUnitPath": sUnitPropertyPath
+							? MassEditHelper.getDefaultSelectionPathComboBox(aContexts, sUnitPropertyPath)
+							: false,
+						"entitySet": sCurrentEntitySetName,
+						"textBinding": oTextBinding,
+						"nullable": oPropertyInfo.nullable !== undefined ? oPropertyInfo.nullable : true,
+						"isPropertyReadOnly": isReadOnly !== undefined ? isReadOnly : false,
+						"inputType": inputType,
+						"editMode": editable ? expBinding : undefined
+					};
+					aDataArray.push(oResult);
+				}
+			}
+		});
+		oDataFieldModel.setData(aDataArray);
+		return oDataFieldModel;
+	},
+
+	getTableFields: function (oTable: any) {
+		const aColumns = (oTable && oTable.getColumns()) || [];
+		const columnsData = oTable && oTable.getParent().getTableDefinition().columns;
+		return aColumns.map(function (oColumn: any) {
+			const sDataProperty = oColumn && oColumn.getDataProperty(),
+				aRealtedColumnInfo =
+					columnsData &&
+					columnsData.filter(function (oColumnInfo: any) {
+						return oColumnInfo.name === sDataProperty && oColumnInfo.type === "Annotation";
+					});
+			return {
+				"dataProperty": sDataProperty,
+				"label": oColumn.getHeader(),
+				"annotationPath": aRealtedColumnInfo && aRealtedColumnInfo[0] && aRealtedColumnInfo[0].annotationPath
+			};
+		});
+	},
+
+	getDefaultTextsForDialog: function (oResourceBundle: any, iSelectedContexts: any, oTable: any) {
+		// The confirm button text is "Save" for table in Display mode and "Apply" for table in edit mode. This can be later exposed if needed.
+		const bDisplayMode = oTable.data("displayModePropertyBinding") === "true";
+
+		return {
+			"keepExistingPrefix": "< Keep",
+			"leaveBlankValue": "< Leave Blank >",
+			"clearFieldValue": "< Clear Values >",
+			"massEditTitle": oResourceBundle.getText("C_MASS_EDIT_DIALOG_TITLE", iSelectedContexts.toString()),
+			"applyButtonText": bDisplayMode
+				? oResourceBundle.getText("C_MASS_EDIT_SAVE_BUTTON_TEXT")
+				: oResourceBundle.getText("C_MASS_EDIT_APPLY_BUTTON_TEXT"),
+			"cancelButtonText": oResourceBundle.getText("C_MASS_EDIT_CANCEL_BUTTON_TEXT")
+		};
+	},
+
+	/**
+	 * Adds a suffix to the 'keep existing' property of the comboBox.
+	 *
+	 * @param {string} sInputType InputType of the field
+	 * @returns {string}
+	 */
+	getSuffixForKeepExisiting: function (sInputType: string) {
+		let sResult = "Values";
+
+		switch (sInputType) {
+			//TODO - Add for other control types as well (Radio Button, Email, Input, MDC Fields, Image etc.)
+			case "DatePicker":
+				sResult = "Dates";
+				break;
+			case "CheckBox":
+				sResult = "Settings";
+				break;
+		}
+		return sResult;
+	},
+
+	/**
+	 * Adds default values to the model [Keep Existing Values, Leave Blank].
+	 *
+	 * @param {Array} aValues Array instance where the default data needs to be added
+	 * @param {Array} aContexts Contexts for mass edit
+	 * @param {object} oDefaultValues Default values from Application Manifest
+	 * @param {object} oPropertyInfo Property information
+	 * @param {boolean} bUOMField
+	 */
+	setDefaultValuesToDialog: function (aValues: any[], aContexts: any[], oDefaultValues: any, oPropertyInfo: any, bUOMField?: boolean) {
+		const sPropertyPath = bUOMField ? oPropertyInfo.unitProperty : oPropertyInfo.dataProperty,
+			sInputType = oPropertyInfo.inputType,
+			bPropertyRequired = oPropertyInfo.isFieldRequired;
+		const sSuffixForKeepExisting = MassEditHelper.getSuffixForKeepExisiting(sInputType);
+		//TODO - Add <<Use Value Help or control implmentation>> and related key by checking if value help is enabled for property or Unit.
+		//TODO - Add option Apply to Empty Fields only for Both Value Help and controls.
+		const bValueExistsForPropertyPath = aContexts.some(function (oSelectedContext: any) {
+			return oSelectedContext.getObject(sPropertyPath);
+		});
+		if (bValueExistsForPropertyPath) {
+			if (bPropertyRequired !== "true" && !bUOMField) {
+				aValues.unshift({ text: oDefaultValues.clearFieldValue, key: "ClearFieldValue/" + sPropertyPath });
+			}
+		} else {
+			aValues.unshift({ text: oDefaultValues.leaveBlankValue, key: "Empty/" + sPropertyPath });
+		}
+		aValues.unshift({
+			text: oDefaultValues.keepExistingPrefix + " " + sSuffixForKeepExisting + " >",
+			key: "Default/" + sPropertyPath
+		});
+	},
+
+	getTextArrangementInfo: function (
+		sProperty: any,
+		oTextBinding: any,
+		sCurrentEntitySet: any,
+		oSelectedContext: any
+	): TextArrangementInfo | undefined {
+		const oMetaModel = oSelectedContext.getModel().getMetaModel();
+		const sDisplayMode = CommonUtils.computeDisplayMode(oMetaModel.getObject(sCurrentEntitySet + "/" + sProperty + "@"));
+		let sDescriptionPath, sValue, sDescriptionValue, sFullText;
+		if (oTextBinding && (oTextBinding.path || (oTextBinding.parameters && oTextBinding.parameters.length)) && sProperty) {
+			if (oTextBinding.path) {
+				if (sDisplayMode === "Description") {
+					sValue = oSelectedContext.getObject(sProperty);
+					sDescriptionValue = oSelectedContext.getObject(oTextBinding.path);
+					sFullText = sDescriptionValue;
+				} else if (sDisplayMode === "Value") {
+					sValue = oSelectedContext.getObject(sProperty);
+					sFullText = sValue;
+				}
+			} else if (oTextBinding.parameters) {
+				oTextBinding.parameters.forEach(function (oProps: any) {
+					if (oProps.path && oProps.path !== sProperty) {
+						sDescriptionPath = oProps.path;
+					}
+				});
+				sValue = oSelectedContext.getObject(sProperty);
+				sDescriptionValue = oSelectedContext.getObject(sDescriptionPath);
+				if (sDisplayMode === "ValueDescription" && sValue && sDescriptionValue) {
+					sFullText = sValue + " (" + sDescriptionValue + ")";
+				} else if (sDisplayMode === "DescriptionValue" && sDescriptionValue && sValue) {
+					sFullText = sDescriptionValue + " (" + sValue + ")";
+				}
+			}
+			return {
+				"textArrangement": sDisplayMode,
+				"valuePath": sProperty,
+				"descriptionPath": sDescriptionPath,
+				"value": sValue,
+				"description": sDescriptionValue,
+				"fullText": sFullText
+			};
+		}
+		return undefined;
+	},
+
+	/**
+	 * Return the visibility valuue for the ManagedObject Any.
+	 *
+	 * @param {AnyType} any The ManagedObject Any to be used to calculate the visible value of the binding.
+	 * @returns {boolean} Returns true if the mass edit field is editable.
+	 */
+	isEditable: function (any: AnyType): boolean {
+		const binding = any.getBinding("any");
+		const value = (binding as any).getExternalValue();
+		return value === EditMode.Editable;
+	},
+
+	/**
+	 * Calculate and update the visibility of mass edit field on change of the ManagedObject Any binding.
+	 *
+	 * @param {JSONModel} oDialogDataModel Model to be used runtime.
+	 * @param {string} dataProperty Field name.
+	 */
+	onContextEditableChange: function (oDialogDataModel: JSONModel, dataProperty: string): void {
+		const objectsForVisibility = oDialogDataModel.getProperty("/values/" + dataProperty + "/objectsForVisibility") || [];
+		const editable = objectsForVisibility.some(MassEditHelper.isEditable);
+
+		if (editable) {
+			oDialogDataModel.setProperty("/values/" + dataProperty + "/visible", editable);
+		}
+	},
+
+	/**
+	 * Update Managed Object Any for visibility of the mass edit fields.
+	 *
+	 * @param {AnyType} mOToUse The ManagedObject Any to be used to calculate the visible value of the binding.
+	 * @param {JSONModel} oDialogDataModel Model to be used runtime.
+	 * @param {string} dataProperty Field name.
+	 * @param {any} values Values of the field.
+	 */
+	updateOnContextChange: function (mOToUse: AnyType, oDialogDataModel: JSONModel, dataProperty: string, values: any) {
+		const binding = mOToUse.getBinding("any");
+
+		values.objectsForVisibility = values.objectsForVisibility || [];
+		values.objectsForVisibility.push(mOToUse);
+
+		binding.attachChange(MassEditHelper.onContextEditableChange.bind(null, oDialogDataModel, dataProperty));
+	},
+
+	/**
+	 * Get bound object to calculate the visibility of contexts.
+	 *
+	 * @param {BindingExpression<boolean> | ExpressionOrPrimitive<boolean>} expBinding Binding String object.
+	 * @param {object} context Context the binding value.
+	 * @returns {AnyType} The ManagedObject Any to be used to calculate the visible value of the binding.
+	 */
+	getBoundObject: function (expBinding: BindingExpression<string> | ExpressionOrPrimitive<string>, context: Context): AnyType {
+		const mOToUse = new Any({ any: expBinding });
+		const model = context.getModel();
+		mOToUse.setModel(model);
+		mOToUse.setBindingContext(context);
+
+		return mOToUse;
+	},
+
+	/**
+	 * Get the visibility of the field.
+	 *
+	 * @param {BindingExpression<boolean> | ExpressionOrPrimitive<boolean>} expBinding Binding String object.
+	 * @param {JSONModel} oDialogDataModel Model to be used runtime.
+	 * @param {string} dataProperty Field name.
+	 * @param {any} values Values of the field.
+	 * @param {object} context Context the binding value.
+	 * @returns {boolean} Returns true if the mass edit field is editable.
+	 */
+	getFieldVisiblity: function (
+		expBinding: BindingExpression<string> | ExpressionOrPrimitive<string>,
+		oDialogDataModel: JSONModel,
+		dataProperty: string,
+		values: any,
+		context: Context
+	): boolean {
+		const mOToUse = MassEditHelper.getBoundObject(expBinding, context);
+		const isContextEditable = MassEditHelper.isEditable(mOToUse);
+
+		if (!isContextEditable) {
+			MassEditHelper.updateOnContextChange(mOToUse, oDialogDataModel, dataProperty, values);
+		}
+		return isContextEditable;
+	},
+
+	/**
+	 * Initializes a runtime model:
+	 * => The model consists of values shown in the comboBox of the dialog (Leave Blank, Keep Existing Values, or any property value for the selected context, etc.)
+	 * => The model will capture runtime changes in the results property (the value entered in the comboBox).
+	 *
+	 * @param {Array} aContexts Contexts for mass edit
+	 * @param {Array} aDataArray Array containing data related to the dialog used by both the static and the runtime model
+	 * @param {object} oDefaultValues Default values from i18n
+	 * @returns {object}
+	 */
+	setRuntimeModelOnDialog: function (aContexts: any[], aDataArray: any[], oDefaultValues: any) {
+		const aValues: any[] = [];
+		const aUnitData: any[] = [];
+		const aResults: any[] = [];
+		const aReadOnlyFieldInfo: any[] = [];
+		const oDistinctValueMap: any = {};
+		const oData = { "values": aValues, "unitData": aUnitData, "results": aResults, "readablePropertyData": aReadOnlyFieldInfo };
+		const oDialogDataModel = new JSONModel(oData);
+		let sPropertyName;
+		aDataArray.forEach(function (oData: any) {
+			let oTextInfo;
+			if (oData.dataProperty && oData.dataProperty.indexOf("/") > -1) {
+				const aFinalPath = MassEditHelper.initLastLevelOfPropertyPath(oData.dataProperty, aValues);
+				const aPropertyPaths = oData.dataProperty.split("/");
+				let sPropertyKey;
+				for (let i = 0; i < aContexts.length; i++) {
+					const sMultiLevelPathValue = aContexts[i].getObject(oData.dataProperty);
+					sPropertyKey = oData.dataProperty + "/" + sMultiLevelPathValue;
+					if (!oDistinctValueMap[sPropertyKey] && aFinalPath[aPropertyPaths[aPropertyPaths.length - 1]]) {
+						oTextInfo = MassEditHelper.getTextArrangementInfo(
+							oData.dataProperty,
+							oData.textBinding,
+							oData.entitySet,
+							aContexts[i]
+						);
+						aFinalPath[aPropertyPaths[aPropertyPaths.length - 1]].push({
+							"text": (oTextInfo && oTextInfo.fullText) || sMultiLevelPathValue,
+							"key": oData.dataProperty,
+							"textInfo": oTextInfo
+						});
+						oDistinctValueMap[sPropertyKey] = sMultiLevelPathValue;
+					}
+				}
+			} else {
+				aValues[oData.dataProperty] = aValues[oData.dataProperty] || [];
+				if (oData.unitProperty) {
+					aUnitData[oData.unitProperty] = aUnitData[oData.unitProperty] || [];
+				}
+				for (let i = 0; i < aContexts.length; i++) {
+					const oDataObject = aContexts[i].getObject();
+					sPropertyName = oData.dataProperty + "/" + oDataObject[oData.dataProperty];
+					if (oData.dataProperty && oDataObject[oData.dataProperty] && !oDistinctValueMap[sPropertyName]) {
+						oTextInfo = MassEditHelper.getTextArrangementInfo(
+							oData.dataProperty,
+							oData.textBinding,
+							oData.entitySet,
+							aContexts[i]
+						);
+						aValues[oData.dataProperty].push({
+							"text": (oTextInfo && oTextInfo.fullText) || oDataObject[oData.dataProperty],
+							"key": oData.dataProperty,
+							"textInfo": oTextInfo
+						});
+						oDistinctValueMap[sPropertyName] = oDataObject[oData.dataProperty];
+					}
+					if (oData.unitProperty && oDataObject[oData.unitProperty]) {
+						sPropertyName = oData.unitProperty + "/" + oDataObject[oData.unitProperty];
+						if (!oDistinctValueMap[sPropertyName]) {
+							oTextInfo = MassEditHelper.getTextArrangementInfo(
+								oData.unitProperty,
+								oData.textBinding,
+								oData.entitySet,
+								aContexts[i]
+							);
+							aUnitData[oData.unitProperty].push({
+								"text": (oTextInfo && oTextInfo.fullText) || oDataObject[oData.unitProperty],
+								"key": oData.unitProperty,
+								"textInfo": oTextInfo
+							});
+							oDistinctValueMap[sPropertyName] = oDataObject[oData.unitProperty];
+						}
+					}
+				}
+			}
+		});
+		aDataArray.forEach(function (oData: any) {
+			let values: any;
+			if (oData.dataProperty.indexOf("/") > -1) {
+				const sMultiLevelPropPathValue = MassEditHelper.getValueForMultiLevelPath(oData.dataProperty, aValues);
+				if (!sMultiLevelPropPathValue) {
+					sMultiLevelPropPathValue.push({ text: oDefaultValues.leaveBlankValue, key: "Empty/" + oData.dataProperty });
+				} else {
+					MassEditHelper.setDefaultValuesToDialog(sMultiLevelPropPathValue, aContexts, oDefaultValues, oData);
+				}
+				values = sMultiLevelPropPathValue;
+			} else if (aValues[oData.dataProperty] && aValues[oData.dataProperty].length) {
+				MassEditHelper.setDefaultValuesToDialog(aValues[oData.dataProperty], aContexts, oDefaultValues, oData);
+				values = aValues[oData.dataProperty];
+			}
+			if (aUnitData[oData.unitProperty] && aUnitData[oData.unitProperty].length) {
+				MassEditHelper.setDefaultValuesToDialog(aUnitData[oData.unitProperty], aContexts, oDefaultValues, oData, true);
+			} else if (
+				(oData.dataProperty && aValues[oData.dataProperty] && !aValues[oData.dataProperty].length) ||
+				(oData.unitProperty && aUnitData[oData.unitProperty] && !aUnitData[oData.unitProperty].length)
+			) {
+				const bClearFieldOrBlankValueExists =
+					aValues[oData.dataProperty] &&
+					aValues[oData.dataProperty].some(function (obj: any) {
+						return obj.text === "< Clear Values >" || obj.text === "< Leave Blank >";
+					});
+				if (oData.dataProperty && !bClearFieldOrBlankValueExists) {
+					aValues[oData.dataProperty].push({ text: oDefaultValues.leaveBlankValue, key: "Empty/" + oData.dataProperty });
+				}
+				const bClearFieldOrBlankUnitValueExists =
+					aUnitData[oData.unitProperty] &&
+					aUnitData[oData.unitProperty].some(function (obj: any) {
+						return obj.text === "< Clear Values >" || obj.text === "< Leave Blank >";
+					});
+				if (oData.unitProperty && !bClearFieldOrBlankUnitValueExists) {
+					aUnitData[oData.unitProperty].push({
+						text: oDefaultValues.leaveBlankValue,
+						key: "Empty/" + oData.unitProperty
+					});
+				}
+			}
+			if (oData.isPropertyReadOnly && typeof oData.isPropertyReadOnly === "boolean") {
+				aReadOnlyFieldInfo.push({ "property": oData.dataProperty, value: oData.isPropertyReadOnly, type: "Default" });
+			} else if (
+				oData.isPropertyReadOnly &&
+				oData.isPropertyReadOnly.operands &&
+				oData.isPropertyReadOnly.operands[0] &&
+				oData.isPropertyReadOnly.operands[0].operand1 &&
+				oData.isPropertyReadOnly.operands[0].operand2
+			) {
+				// This needs to be refactored in accordance with the ReadOnlyExpression change
+				aReadOnlyFieldInfo.push({
+					"property": oData.dataProperty,
+					propertyPath: oData.isPropertyReadOnly.operands[0].operand1.path,
+					propertyValue: oData.isPropertyReadOnly.operands[0].operand2.value,
+					type: "Path"
+				});
+			}
+
+			// Setting visbility of the mass edit field.
+			if (oData.editMode) {
+				values.visible =
+					oData.editMode === EditMode.Editable ||
+					aContexts.some(
+						MassEditHelper.getFieldVisiblity.bind(MassEditHelper, oData.editMode, oDialogDataModel, oData.dataProperty, values)
+					);
+			} else {
+				values.visible = true;
+			}
+		});
+		return oDialogDataModel;
+	},
+
+	/**
+	 * Create the mass edit dialog.
+	 *
+	 * @param {object} oTable Instance of Table
+	 * @param {Array} aContexts Contexts for mass edit
+	 * @param {object} oController Controller for the view
+	 * @returns {object} Promise returning instance of dialog.
+	 */
+	createDialog: function (oTable: Table, aContexts: any[], oController: PageController) {
+		const sFragmentName = "sap/fe/core/controls/massEdit/MassEditDialog",
+			aDataArray: any[] = [],
+			oResourceBundle = (Core as CoreEx).getLibraryResourceBundle("sap.fe.core"),
+			oDefaultValues = MassEditHelper.getDefaultTextsForDialog(oResourceBundle, aContexts.length, oTable),
+			oDataFieldModel = MassEditHelper.prepareDataForDialog(oTable, aContexts, aDataArray),
+			oDialogDataModel = MassEditHelper.setRuntimeModelOnDialog(aContexts, aDataArray, oDefaultValues);
+
+		return new Promise(function (resolve: (value: any) => void, reject: (reason?: any) => void) {
+			const oFragment = XMLTemplateProcessor.loadTemplate(sFragmentName, "fragment");
+			return Promise.resolve(
+				XMLPreprocessor.process(
+					oFragment,
+					{ name: sFragmentName },
+					{
+						bindingContexts: {
+							dataFieldModel: oDataFieldModel.createBindingContext("/")
+						},
+						models: {
+							dataFieldModel: oDataFieldModel
+						}
+					}
+				)
+			)
+				.then(function (oFragment: any) {
+					return Fragment.load({ definition: oFragment }).then(function (oDialogContent: any) {
+						const oDialog = new Dialog({
+							title: oDefaultValues.massEditTitle,
+							content: [oDialogContent],
+							beginButton: new Button({
+								text: oDefaultValues.applyButtonText,
+								type: "Emphasized",
+								press: function (oEvent: any) {
+									const oDialog = oEvent.getSource().getParent();
+									const oModel = oDialog.getModel("fieldsInfo");
+									const aResults = oModel.getProperty("/results");
+									const aPropertyReadableInfo = oModel.getProperty("/readablePropertyData");
+									const changePromise: any[] = [];
+									let bReadOnlyField = false;
+									let groupId;
+									let index = 0;
+									aContexts.forEach(function (oSelectedContext: any) {
+										aResults.forEach(function (oResult: any) {
+											//TODO - Add save implementation for Value Help.
+											if (aPropertyReadableInfo) {
+												bReadOnlyField = aPropertyReadableInfo.some(function (oPropertyInfo: any) {
+													if (oResult.keyValue === oPropertyInfo.property) {
+														if (oPropertyInfo.type === "Default") {
+															return oPropertyInfo.value === true;
+														} else if (
+															oPropertyInfo.type === "Path" &&
+															oPropertyInfo.propertyValue &&
+															oPropertyInfo.propertyPath
+														) {
+															return (
+																oSelectedContext.getObject(oPropertyInfo.propertyPath) ===
+																oPropertyInfo.propertyValue
+															);
+														}
+													}
+												});
+											}
+											groupId = "$auto." + index;
+											index += 1;
+											if (oResult.keyValue && oResult.value !== "Default" && !bReadOnlyField) {
+												changePromise.push(oSelectedContext.setProperty(oResult.keyValue, oResult.value, groupId));
+											}
+										});
+									});
+									return Promise.all(changePromise)
+										.then(function (oRes: any[]) {
+											const oListBinding = oTable.getRowBinding(),
+												oExtensionAPI = oController && (oController.getExtensionAPI() as any);
+											return oExtensionAPI.refresh(oListBinding.getPath()).then(function () {
+												oDialog.close();
+												oDialog.destroy();
+												return oRes;
+											});
+										})
+										.catch(function (oError: any) {
+											//TODO - Add error handling part for the Dialog
+											oDialog.close();
+											oDialog.destroy();
+											Log.error("Mass Edit: Something went wrong in updating entries.", oError);
+										});
+								}
+							}),
+							endButton: new Button({
+								text: oDefaultValues.cancelButtonText,
+								press: function (oEvent: any) {
+									const oDialog = oEvent.getSource().getParent();
+									oDialog.close();
+									oDialog.destroy();
+								}
+							})
+						});
+						oDialog.setModel(oDialogDataModel, "fieldsInfo");
+						resolve(oDialog);
+					});
+				})
+				.catch(reject);
+		});
+	}
+};
+
+export default MassEditHelper;