@sapui5/sap.fe.core 1.101.0 → 1.103.0

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

@@ -1,321 +0,0 @@
-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;