@sapui5/sap.fe.core 1.98.0 → 1.101.0

package/src/sap/fe/core/AnnotationHelper.ts

@@ -0,0 +1,321 @@
+import { DataField, UIAnnotationTerms, UIAnnotationTypes } from "@sap-ux/vocabularies-types";
+import CommonUtils from "sap/fe/core/CommonUtils";
+import { ConverterAction } from "sap/fe/core/converters/controls/Common/Action";
+import { ManifestAction } from "sap/fe/core/converters/ManifestSettings";
+import { BindingExpression, compileBinding, Expression, fn, or, ref, resolveBindingString } from "sap/fe/core/helpers/BindingExpression";
+import ModelHelper from "sap/fe/core/helpers/ModelHelper";
+import { generate } from "sap/fe/core/helpers/StableIdHelper";
+import mLibrary from "sap/m/library";
+import ODataModelAnnotationHelper from "sap/ui/model/odata/v4/AnnotationHelper";
+const ButtonType = mLibrary.ButtonType;
+const AnnotationHelper = {
+	/* this helper can be activated to debug template processing
+			 debug: function (oContext) {
+			 //debugger;
+			 },
+			 */
+
+	getTargetContext: function (oTarget: any) {
+		const sTarget = oTarget.getObject(oTarget.getPath()),
+			sNavigationPath = ODataModelAnnotationHelper.getNavigationPath(oTarget.getPath());
+		return sNavigationPath + "/" + sTarget;
+	},
+
+	getNavigationContext: function (oContext: any) {
+		return ODataModelAnnotationHelper.getNavigationPath(oContext.getPath());
+	},
+	/**
+	 * Checks if the footer is visible or not.
+	 *
+	 * @function
+	 * @static
+	 * @name sap.fe.core.AnnotationHelper.getDataFieldBasedFooterVisibility
+	 * @memberof sap.fe.core.AnnotationHelper
+	 * @param {Array} aDataFields Array of DataFields in the identification
+	 * @param {boolean} bConsiderEditable Whether the edit mode binding is required or not
+	 * @returns {string} An expression if all the actions are ui.hidden, true otherwise
+	 * @private
+	 * @ui5-restricted
+	 **/
+	getDataFieldBasedFooterVisibility: function (aDataFields: any[], bConsiderEditable: boolean) {
+		let sHiddenExpression = "";
+		let sSemiHiddenExpression;
+		const aHiddenActionPath = [];
+
+		for (const i in aDataFields) {
+			const oDataField = aDataFields[i];
+			if (oDataField.$Type === UIAnnotationTypes.DataFieldForAction && oDataField.Determining === true) {
+				const hiddenExpression = oDataField[`@${UIAnnotationTerms.Hidden}`];
+				if (!hiddenExpression) {
+					return true;
+				} else if (hiddenExpression.$Path) {
+					if (aHiddenActionPath.indexOf(hiddenExpression.$Path) === -1) {
+						aHiddenActionPath.push(hiddenExpression.$Path);
+					}
+				}
+			}
+		}
+
+		if (aHiddenActionPath.length) {
+			for (let index = 0; index < aHiddenActionPath.length; index++) {
+				if (aHiddenActionPath[index]) {
+					sSemiHiddenExpression = "(%{" + aHiddenActionPath[index] + "} === true ? false : true )";
+				}
+				if (index == aHiddenActionPath.length - 1) {
+					sHiddenExpression = sHiddenExpression + sSemiHiddenExpression;
+				} else {
+					sHiddenExpression = sHiddenExpression + sSemiHiddenExpression + "||";
+				}
+			}
+			return (
+				"{= " +
+				(bConsiderEditable ? "(" : "") +
+				sHiddenExpression +
+				(bConsiderEditable ? " || ${ui>/isEditable}) " : " ") +
+				"&& ${internal>isCreateDialogOpen} !== true}"
+			);
+		} else {
+			return "{= " + (bConsiderEditable ? "${ui>/isEditable} && " : "") + "${internal>isCreateDialogOpen} !== true}";
+		}
+	},
+
+	/**
+	 * Returns the metamodel path correctly for bound actions. For unbound actions,
+	 *  an incorrect path is returned, but is ignored during templating.
+	 *
+	 * For example, for the bound action someNameSpace.SomeBoundAction of the entity set SomeEntitySet,
+	 * the string "/SomeEntitySet/someNameSpace.SomeBoundAction" is returned.
+	 *
+	 * @function
+	 * @static
+	 * @name sap.fe.core.AnnotationHelper.getActionContext
+	 * @memberof sap.fe.core.AnnotationHelper
+	 * @param {object} oAction The context object for the action
+	 * @returns {string} Correct metamodel path for bound and incorrect path for unbound actions
+	 * @private
+	 * @ui5-restricted
+	 **/
+	getActionContext: function (oAction: object) {
+		return CommonUtils.getActionPath(oAction, true);
+	},
+	/**
+	 * Returns the metamodel path correctly for overloaded bound actions. For unbound actions,
+	 * incorrect path is returned but during templating it is ignored.
+	 * e.g. for bound action someNameSpace.SomeBoundAction of entity set SomeEntitySet,
+	 * the string "/SomeEntitySet/someNameSpace.SomeBoundAction/@$ui5.overload/0" is returned.
+	 *
+	 * @function
+	 * @static
+	 * @name sap.fe.core.AnnotationHelper.getPathToBoundActionOverload
+	 * @memberof sap.fe.core.AnnotationHelper
+	 * @param {object} oAction The context object for the action
+	 * @returns {string} Correct metamodel path for bound action overload and incorrect path for unbound actions
+	 * @private
+	 * @ui5-restricted
+	 **/
+	getPathToBoundActionOverload: function (oAction: object) {
+		const sPath = CommonUtils.getActionPath(oAction, true);
+		return sPath + "/@$ui5.overload/0";
+	},
+	/**
+	 * Returns an expression to determine Emphasized  button type based on Criticality across all actions
+	 * If critical action is rendered, its considered to be the primary action. Hence template's default primary action is set back to Default.
+	 *
+	 * @function
+	 * @static
+	 * @name sap.fe.core.AnnotationHelper.buildEmphasizedButtonExpression
+	 * @memberof sap.fe.core.AnnotationHelper
+	 * @param {Array} aIdentification Array of all the DataFields in Identification
+	 * @returns {string} An expression to deduce if button type is Default or Emphasized
+	 * @private
+	 * @ui5-restricted
+	 **/
+	buildEmphasizedButtonExpression: function (aIdentification?: any[]) {
+		if (!aIdentification) {
+			return ButtonType.Emphasized;
+		}
+		let sFormatEmphasizedExpression: string | undefined;
+		let bIsAlwaysDefault: boolean,
+			sHiddenSimplePath,
+			sHiddenExpression = "";
+		aIdentification.forEach(function (oDataField: any) {
+			const oCriticalityProperty = oDataField.Criticality;
+			const oDataFieldHidden = oDataField["@com.sap.vocabularies.UI.v1.Hidden"];
+			if (oDataField.$Type === "com.sap.vocabularies.UI.v1.DataFieldForAction" && !bIsAlwaysDefault && oCriticalityProperty) {
+				if (!sFormatEmphasizedExpression && oDataFieldHidden === true) {
+					// if DataField is set to hidden, we can skip other checks and return Default button type
+					sFormatEmphasizedExpression = ButtonType.Emphasized;
+					return;
+				}
+				if (oDataFieldHidden && oDataFieldHidden.$Path) {
+					// when visibility of critical button is based on path, collect all paths for expression
+					sHiddenSimplePath = oDataFieldHidden.$Path;
+					if (sHiddenExpression) {
+						sHiddenExpression = sHiddenExpression + " && ";
+					}
+					sHiddenExpression = sHiddenExpression + "%{" + sHiddenSimplePath + "} === true";
+					sFormatEmphasizedExpression = "{= (" + sHiddenExpression + ") ? 'Emphasized' : 'Default' }";
+				}
+				switch (oCriticalityProperty.$EnumMember) {
+					// supported criticality are [Positive/3/'3'] and [Negative/1/'1']
+					case "com.sap.vocabularies.UI.v1.CriticalityType/Negative":
+					case "com.sap.vocabularies.UI.v1.CriticalityType/Positive":
+					case "1":
+					case 1:
+					case "3":
+					case 3:
+						if (!oDataFieldHidden) {
+							sFormatEmphasizedExpression = ButtonType.Default;
+							bIsAlwaysDefault = true;
+						}
+						sFormatEmphasizedExpression = sFormatEmphasizedExpression || ButtonType.Default;
+						break;
+					default:
+						sFormatEmphasizedExpression = ButtonType.Emphasized;
+				}
+				if (oCriticalityProperty.$Path) {
+					// when Criticality is set using a path, use the path for deducing the Emphsized type for default Primary Action
+					const sCombinedHiddenExpression = sHiddenExpression ? "!(" + sHiddenExpression + ") && " : "";
+					sFormatEmphasizedExpression =
+						"{= " +
+						sCombinedHiddenExpression +
+						"((${" +
+						oCriticalityProperty.$Path +
+						"} === 'com.sap.vocabularies.UI.v1.CriticalityType/Negative') || (${" +
+						oCriticalityProperty.$Path +
+						"} === '1') || (${" +
+						oCriticalityProperty.$Path +
+						"} === 1) " +
+						"|| (${" +
+						oCriticalityProperty.$Path +
+						"} === 'com.sap.vocabularies.UI.v1.CriticalityType/Positive') || (${" +
+						oCriticalityProperty.$Path +
+						"} === '3') || (${" +
+						oCriticalityProperty.$Path +
+						"} === 3)) ? " +
+						"'Default'" +
+						" : " +
+						"'Emphasized'" +
+						" }";
+				}
+			}
+		});
+		return sFormatEmphasizedExpression || ButtonType.Emphasized;
+	},
+	/**
+	 * Method to determine if the programming model is sticky.
+	 *
+	 * @function
+	 * @name isStickySessionSupported
+	 * @param {object} [vCollectionOrMetaModel] The collection or the metadata model
+	 * @param {object} [oInterface] Contains the context, used in oDataContext
+	 * @returns {boolean} `true` if sticky, `false` otherwise
+	 */
+	isStickySessionSupported: function (vCollectionOrMetaModel: object | undefined, oInterface: any | undefined) {
+		let oMetaModel;
+		if (oInterface) {
+			oMetaModel = oInterface.context.getModel();
+		} else {
+			oMetaModel = vCollectionOrMetaModel;
+		}
+		return ModelHelper.isStickySessionSupported(oMetaModel);
+	},
+	/**
+	 * Method returns Whether the action type is manifest or not.
+	 *
+	 * @function
+	 * @name isManifestActionVisible
+	 * @param {object} oAction The action object
+	 * @returns {boolean} `true` if action is coming from manifest, `false` otherwise
+	 */
+	isManifestAction: function (oAction: any) {
+		const aActions = [
+			"Primary",
+			"DefaultApply",
+			"Secondary",
+			"ForAction",
+			"ForNavigation",
+			"SwitchToActiveObject",
+			"SwitchToDraftObject",
+			"DraftActions"
+		];
+		return aActions.indexOf(oAction.type) < 0;
+	},
+	/**
+	 * Method returns whether footer is visible or not on object / subobject page.
+	 *
+	 * @function
+	 * @name getFooterVisible
+	 * @param {ConverterAction[]} footerActions The footer action object coming from the converter
+	 * @param {DataField[]} dataFields Data field array for normal footer visibility processing
+	 * @returns {boolean | BindingExpression<string>} `true` if any action is true, otherwise compiled Binding or `false`
+	 */
+	getFooterVisible: function (footerActions: ConverterAction[], dataFields: DataField[]): boolean | BindingExpression<string> {
+		const manifestActions = footerActions.filter((action) => AnnotationHelper.isManifestAction(action)) as ManifestAction[];
+		let customActionVisibility: Expression<boolean>;
+		if (manifestActions.length) {
+			// If we have manifest actions
+			const customActionIndividualVisibility = manifestActions.map((action) => {
+				return resolveBindingString<boolean>(action.visible as string | boolean, "boolean");
+			});
+			// construct the footer's visibility-binding out of all actions' visibility-bindings, first the binding of all custom actions ...
+			customActionVisibility = or(...customActionIndividualVisibility);
+			// and then the binding of all annotation actions inside the footer ...
+			const annotationActionVisibility = this.getDataFieldBasedFooterVisibility(dataFields, true);
+			// finally, return everything.
+			return compileBinding(or(customActionVisibility, resolveBindingString<boolean>(annotationActionVisibility, "boolean")));
+		}
+		return this.getDataFieldBasedFooterVisibility(dataFields, true);
+	},
+	/**
+	 * Build an expression calling an action handler via the FPM helper's actionWrapper function
+	 *
+	 * This function assumes that the 'FPM.actionWrapper()' function is available at runtime.
+	 *
+	 * @param {object} oAction Action metadata
+	 * @param {string} oAction.handlerModule Module containing the action handler method
+	 * @param {string} oAction.handlerMethod Action handler method name
+	 * @param {object} [oThis] `this` (if the function is called from a macro)
+	 * @param {string} oThis.id The table's ID
+	 * @returns {string} The action wrapper binding	expression
+	 */
+	buildActionWrapper: function (oAction: { handlerModule: string; handlerMethod: string }, oThis: { id: string } | undefined) {
+		const aParams: any[] = [ref("$event"), oAction.handlerModule, oAction.handlerMethod];
+
+		if (oThis && oThis.id) {
+			const oAdditionalParams = {
+				contexts: ref("${internal>selectedContexts}")
+			};
+			aParams.push(oAdditionalParams);
+		}
+		return compileBinding(fn("FPM.actionWrapper", aParams));
+	},
+
+	/**
+	 * Method returns an VariantBackReference expression based on variantManagement and oConverterContext value.
+	 *
+	 * @function
+	 * @name getVariantBackReference
+	 * @param {object} oViewData Object Containing View Data
+	 * @param {object} oConverterContext Object containing converted context
+	 * @returns {string}
+	 */
+	getVariantBackReference: function (oViewData: any, oConverterContext: any) {
+		if (oViewData && oViewData.variantManagement === "Page") {
+			return "fe::PageVariantManagement";
+		}
+		if (oViewData && oViewData.variantManagement === "Control") {
+			return generate([oConverterContext.filterBarId, "VariantManagement"]);
+		}
+		return undefined;
+	},
+	getDefaultPath: function (aViews: any) {
+		for (let i = 0; i < aViews.length; i++) {
+			if (aViews[i].defaultPath) {
+				return aViews[i].defaultPath;
+			}
+		}
+	}
+};
+
+export default AnnotationHelper;