@sapui5/sap.fe.core 1.97.0 → 1.99.1

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

@@ -0,0 +1,385 @@
+import ODataModelAnnotationHelper from "sap/ui/model/odata/v4/AnnotationHelper";
+import CommonUtils from "sap/fe/core/CommonUtils";
+import mLibrary from "sap/m/library";
+import { generate } from "sap/fe/core/helpers/StableIdHelper";
+import ModelHelper from "sap/fe/core/helpers/ModelHelper";
+import { compileBinding, fn, ref } from "sap/fe/core/helpers/BindingExpression";
+import { UIAnnotationTerms, UIAnnotationTypes } from "@sap-ux/vocabularies-types";
+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 navigation collection is insertable.
+	 *
+	 * @function
+	 * @static
+	 * @name sap.fe.core.AnnotationHelper.getNavigationInsertableRestrictions
+	 * @memberof sap.fe.core.AnnotationHelper
+	 * @param oCollection
+	 * @param {string} sCurrentCollectionName The name of the navigation collection
+	 * @param {Array} aRestrictedProperties Array of RestrictedProperties of NavigationRestrictions of the root collection
+	 * @param {boolean} bInsertable Insertable value of the navigation collection
+	 * @param bCreationRow
+	 * @returns {string} Expression if insertable or insertable path, false otherwise
+	 * @private
+	 * @ui5-restricted
+	 */
+	getNavigationInsertableRestrictions: function(
+		oCollection: any,
+		sCurrentCollectionName: string,
+		aRestrictedProperties: any[],
+		bInsertable: boolean | any,
+		bCreationRow: any
+	) {
+		// If insertable = true via NavigationRestriction of root collection, navigation collection is insertable
+		// If NOT insertable via NavigationRestriction of root collection, navigation collection is NOT insertable
+		// If insertable property is undefined for the NavigationRestrictions of the root collection,
+		// 	then insertable property of the navigation collection is considered.
+		// 	If insertable = true, navigation collection is insertable
+		// 	If insertable = false, navigation collection is NOT insertable
+		// If Insertable is undefined via navigation restriction of root collection
+		// 	and Insertable is undefined at navigation collection,
+		// 	then navigation collection is insertable.
+		let i,
+			oNavigationProperty,
+			sPath = "";
+		for (i in aRestrictedProperties) {
+			oNavigationProperty = aRestrictedProperties[i];
+			if (
+				oNavigationProperty.NavigationProperty.$NavigationPropertyPath === sCurrentCollectionName &&
+				oNavigationProperty.InsertRestrictions
+			) {
+				if (oNavigationProperty.InsertRestrictions.Insertable && oNavigationProperty.InsertRestrictions.Insertable.$Path) {
+					if (bCreationRow) {
+						sPath = oCollection.$Partner + "/";
+					}
+					return (
+						"{= ${" + sPath + oNavigationProperty.InsertRestrictions.Insertable.$Path + "}  && ${ui>/editMode} === 'Editable' }"
+					);
+				}
+				return oNavigationProperty.InsertRestrictions.Insertable ? "{= ${ui>/editMode} === 'Editable' }" : false;
+			}
+		}
+		if (bInsertable && bInsertable.$Path && bInsertable.$Path.indexOf("/") > -1) {
+			const aSplitInsertablePath = bInsertable.$Path.split("/");
+			const sNavigationPath = aSplitInsertablePath[0];
+			const sPartner = oCollection.$Partner;
+			if (sNavigationPath !== sPartner) {
+				// check for parent property
+				return "{= ${ui>/editMode} === 'Editable'}";
+			}
+			if (bCreationRow) {
+				sCurrentCollectionName = "";
+			} else {
+				sCurrentCollectionName = sCurrentCollectionName + "/";
+			}
+			return "{=  ${ui>/editMode} === 'Editable' && ${" + sCurrentCollectionName + bInsertable.$Path + "}}";
+		}
+		return "{= " + (bInsertable !== false) + " && ${ui>/editMode} === 'Editable'}";
+	},
+	/**
+	 * Checks if the footer is visible or not.
+	 *
+	 * @function
+	 * @static
+	 * @name sap.fe.core.AnnotationHelper.showFooter
+	 * @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
+	 **/
+	showFooter: 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>/editMode} === 'Editable') " : " ") +
+				"&& ${internal>isCreateDialogOpen} !== true}"
+			);
+		} else {
+			return "{= " + (bConsiderEditable ? "${ui>/editMode} === 'Editable' && " : "") + "${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"
+		];
+		return aActions.indexOf(oAction.type) < 0;
+	},
+	/**
+	 * Method returns whether footer is visible or not on object / sub object page.
+	 *
+	 * @function
+	 * @name getFooterVisible
+	 * @param {Array} oFooterActions The footer action object coming from convertor
+	 * @param {Array} aDataFields Data field array for normal footer visiblity processing
+	 * @returns {boolean} `true` if custom actions are present otherwise call function showFooter
+	 */
+	getFooterVisible: function(oFooterActions: any[], aDataFields: any[]) {
+		let bCustomActionFlag = false;
+		oFooterActions.forEach(function(action: any) {
+			const isCustomAction = AnnotationHelper.isManifestAction(action);
+			if (isCustomAction) {
+				bCustomActionFlag = true;
+			}
+		});
+		if (bCustomActionFlag) {
+			return true;
+		} else {
+			return this.showFooter(aDataFields, 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;

package/src/sap/fe/core/AppComponent.js

@@ -1,6 +1,7 @@
 /*!
- * SAPUI5
- * (c) Copyright 2009-2021 SAP SE. All rights reserved.
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+        (c) Copyright 2009-2021 SAP SE. All rights reserved
+    
  */
 
 // ----------------------------------------------------------------------------------
@@ -286,7 +287,8 @@ sap.ui.define(
 				}
 
 				// Adding Semantic Date Operators
-				SemanticDateOperators.addSemanticDateOperators();
+				// Commenting since it is not needed for SingleRange
+				// SemanticDateOperators.addSemanticDateOperators();
 
 				// the init function configures the routing according to the settings above
 				// it will call the createContent function to instantiate the RootView and add it to the UIComponent aggregations
@@ -377,6 +379,7 @@ sap.ui.define(
 				var oMainModel = this.oModels[undefined];
 				var oHeaders = jQuery.extend({}, oMainModel.oRequestor.mHeaders);
 				// As we need to cleanup the application / handle the dirty object we need to call our cleanup before the models are destroyed
+				this.getRoutingService().beforeExit();
 				UIComponent.prototype.destroy.apply(this, arguments);
 				oMainModel.oRequestor.mHeaders = oHeaders;
 			},