@openui5/sap.ui.core 1.91.0 → 1.93.2

package/src/sap/ui/model/odata/v4/ODataBinding.js

@@ -19,6 +19,18 @@ sap.ui.define([
 		// Whether a path segment is an index or contains a transient predicate
 		rIndexOrTransientPredicate = /\/\d|\(\$uid=/;
 
+	/*
+	 * Tells whether the first given change reason has precedence over the second one.
+	 *
+	 * @param {string} sChangeReason0 - A change reason
+	 * @param {string} sChangeReason1  - A change reason
+	 * @returns {boolean} Whether the first given change reason has precedence over the second one
+	 */
+	function hasPrecedenceOver(sChangeReason0, sChangeReason1) {
+		return aChangeReasonPrecedence.indexOf(sChangeReason0)
+			> aChangeReasonPrecedence.indexOf(sChangeReason1);
+	}
+
 	/**
 	 * A mixin for all OData V4 bindings.
 	 *
@@ -59,11 +71,11 @@ sap.ui.define([
 	};
 
 	/**
-	 * Throws an Error that the response is discarded if the current cache not the expected one.
-	 * The error has the property <code>canceled : true</code>
+	 * Throws an error that the response is being ignored if the current cache is not the expected
+	 * one. The error has the property <code>canceled : true</code>
 	 *
 	 * @param {sap.ui.model.odata.v4.lib._Cache} oExpectedCache - The expected cache
-	 * @throws {Error} If the cache has changed
+	 * @throws {Error} If the current cache is not the expected one
 	 *
 	 * @private
 	 */
@@ -71,7 +83,8 @@ sap.ui.define([
 		var oError;
 
 		if (this.oCache !== oExpectedCache) {
-			oError = new Error("Response discarded: cache is inactive");
+			oError = new Error(this + " is ignoring response from inactive cache: "
+				+ oExpectedCache);
 			oError.canceled = true;
 			throw oError;
 		}
@@ -171,14 +184,19 @@ sap.ui.define([
 	/**
 	 * Throws an Error if the binding's root binding is suspended.
 	 *
-	 * @throws {Error} If the binding's root binding is suspended
+	 * @param {boolean} [bIfNoResumeChangeReason]
+	 *   Whether to accept a suspended root binding as long as no <code>sResumeChangeReason</code>
+	 *   is known for this binding (which must not be a root itself) or any of its dependents
+	 * @throws {Error} If the binding's root binding is suspended, except if
+	 *   <code>bIfNoResumeChangeReason</code> is used as described
 	 *
 	 * @private
 	 */
-	ODataBinding.prototype.checkSuspended = function () {
+	ODataBinding.prototype.checkSuspended = function (bIfNoResumeChangeReason) {
 		var oRootBinding = this.getRootBinding();
 
-		if (oRootBinding && oRootBinding.isSuspended()) {
+		if (oRootBinding && oRootBinding.isSuspended()
+				&& (!bIfNoResumeChangeReason || this.isRoot() || this.getResumeChangeReason())) {
 			throw new Error("Must not call method when the binding's root binding is suspended: "
 				+ this);
 		}
@@ -668,6 +686,32 @@ sap.ui.define([
 		return sPath;
 	};
 
+	/**
+	 * Returns the "strongest" change reason that {@link #resume} would fire for this binding or any
+	 * of its dependents.
+	 *
+	 * @returns {sap.ui.model.ChangeReason}
+	 *   The "strongest" change reason, or <code>undefined</code>
+	 *
+	 * @private
+	 * @see #getDependentBindings
+	 * @see #setResumeChangeReason
+	 */
+	ODataBinding.prototype.getResumeChangeReason = function () {
+		var sStrongestChangeReason = this.sResumeChangeReason;
+
+		this.getDependentBindings().forEach(function (oDependentBinding) {
+			var sDependentChangeReason = oDependentBinding.getResumeChangeReason();
+
+			if (sDependentChangeReason
+					&& hasPrecedenceOver(sDependentChangeReason, sStrongestChangeReason)) {
+				sStrongestChangeReason = sDependentChangeReason;
+			}
+		});
+
+		return sStrongestChangeReason;
+	};
+
 	/**
 	 * Returns a promise which resolves as soon as this binding is resumed.
 	 *
@@ -1002,6 +1046,43 @@ sap.ui.define([
 		}
 	};
 
+	/**
+	 * Requests side effects for the given absolute paths.
+	 *
+	 * @param {string} sGroupId
+	 *   The effective group ID
+	 * @param {string[]} aAbsolutePaths
+	 *   The absolute paths to request side effects for
+	 * @returns {sap.ui.base.SyncPromise}
+	 *   A promise resolving without a defined result, or rejecting with an error if loading of side
+	 *   effects fails, or <code>undefined</code> if there is nothing to do
+	 *
+	 * @private
+	 */
+	ODataBinding.prototype.requestAbsoluteSideEffects = function (sGroupId, aAbsolutePaths) {
+		var aPaths = [],
+			sMetaPath = _Helper.getMetaPath(this.getResolvedPath());
+
+		aAbsolutePaths.some(function (sAbsolutePath) {
+			var sRelativePath = _Helper.getRelativePath(sAbsolutePath, sMetaPath);
+
+			if (sRelativePath !== undefined) {
+				aPaths.push(sRelativePath);
+			} else if (_Helper.hasPathPrefix(sMetaPath, sAbsolutePath)) {
+				aPaths = [""]; // "refresh"
+				return true; // break
+			}
+		});
+
+		if (aPaths.length) {
+			if (this.requestSideEffects) {
+				return this.requestSideEffects(sGroupId, aPaths);
+			}
+			return this.refreshInternal("", sGroupId, true);
+		}
+		// return undefined;
+	};
+
 	/**
 	 * Refreshes the binding and returns a promise to wait for it. See {@link #refresh} for details.
 	 * Use {@link #refresh} if you do not need the promise.
@@ -1109,8 +1190,7 @@ sap.ui.define([
 	 * @private
 	 */
 	ODataBinding.prototype.setResumeChangeReason = function (sChangeReason) {
-		if (aChangeReasonPrecedence.indexOf(sChangeReason) >
-				aChangeReasonPrecedence.indexOf(this.sResumeChangeReason)) {
+		if (hasPrecedenceOver(sChangeReason, this.sResumeChangeReason)) {
 			this.sResumeChangeReason = sChangeReason;
 		}
 	};

package/src/sap/ui/model/odata/v4/ODataContextBinding.js

@@ -106,7 +106,7 @@ sap.ui.define([
 	 * @mixes sap.ui.model.odata.v4.ODataParentBinding
 	 * @public
 	 * @since 1.37.0
-	 * @version 1.91.0
+	 * @version 1.93.2
 	 *
 	 * @borrows sap.ui.model.odata.v4.ODataBinding#getGroupId as #getGroupId
 	 * @borrows sap.ui.model.odata.v4.ODataBinding#getRootBinding as #getRootBinding
@@ -257,6 +257,8 @@ sap.ui.define([
 	 * @param {boolean} [bIgnoreETag]
 	 *   Whether the entity's ETag should be actively ignored (If-Match:*); supported for bound
 	 *   actions only
+	 * @param {function} [fnOnStrictHandlingFailed]
+	 *   Callback for strict handling; supported for actions only
 	 * @returns {Promise}
 	 *   A promise that is resolved without data or a return value context when the operation call
 	 *   succeeded, or rejected with an instance of <code>Error</code> in case of failure. A return
@@ -268,7 +270,8 @@ sap.ui.define([
 	 * @private
 	 * @see #execute for details
 	 */
-	ODataContextBinding.prototype._execute = function (oGroupLock, mParameters, bIgnoreETag) {
+	ODataContextBinding.prototype._execute = function (oGroupLock, mParameters, bIgnoreETag,
+			fnOnStrictHandlingFailed) {
 		var oMetaModel = this.oModel.getMetaModel(),
 			oOperationMetadata,
 			oPromise,
@@ -302,7 +305,7 @@ sap.ui.define([
 				}
 				oOperationMetadata = aOperationMetadata[0];
 				return that.createCacheAndRequest(oGroupLock, sResolvedPath, oOperationMetadata,
-					mParameters, fnGetEntity, bIgnoreETag);
+					mParameters, fnGetEntity, bIgnoreETag, fnOnStrictHandlingFailed);
 			}).then(function (oResponseEntity) {
 				var sContextPredicate, oOldValue, sResponsePredicate;
 
@@ -566,17 +569,25 @@ sap.ui.define([
 	 * @param {boolean} [bIgnoreETag]
 	 *   Whether the entity's ETag should be actively ignored (If-Match:*); supported for bound
 	 *   actions only
+	 * @param {function} [fnOnStrictHandlingFailed]
+	 *   Callback for strict handling; supported for actions only
 	 * @returns {SyncPromise}
 	 *   The request promise
 	 * @throws {Error}
-	 *   If a collection-valued parameter for an operation other than a V4 action is encountered,
-	 *   or if the given metadata is neither an "Action" nor a "Function", or if
-	 *   <code>bIgnoreETag</code> is used for an operation other than a bound action
+	 *   If
+	 *   <ul>
+	 *    <li> the given metadata is neither an "Action" nor a "Function",
+	 *    <li> a collection-valued parameter for an operation other than a V4 action is encountered,
+	 *    <li> <code>bIgnoreETag</code> is used for an operation other than a bound action,
+	 *    <li> <code>fnOnStrictHandlingFailed</code> is given but the given metadata is not an
+	 *         "Action",
+	 *    <li> <code>fnOnStrictHandlingFailed</code> is given and it does not return a promise.
+	 *   </ul>
 	 *
 	 * @private
 	 */
 	ODataContextBinding.prototype.createCacheAndRequest = function (oGroupLock, sPath,
-		oOperationMetadata, mParameters, fnGetEntity, bIgnoreETag) {
+		oOperationMetadata, mParameters, fnGetEntity, bIgnoreETag, fnOnStrictHandlingFailed) {
 		var bAction = oOperationMetadata.$kind === "Action",
 			oCache,
 			vEntity = fnGetEntity,
@@ -607,6 +618,35 @@ sap.ui.define([
 			return sOriginalResourcePath;
 		}
 
+		/*
+		 * Calls back into the application with the messages whether to repeat the action.
+		 * @param {Error} oError The error from the failed request
+		 * @returns {Promise} A promise resolving with a boolean
+		 * @throws {Error} If <code>fnOnStrictHandlingFailed</code> does not return a promise
+		 */
+		function onStrictHandling(oError) {
+			var oRawMessages, oResult;
+
+			_Helper.adjustTargetsInError(oError, oOperationMetadata,
+				that.oParameterContext.getPath(),
+				that.bRelative ? that.oContext.getPath() : undefined);
+			oError.error.$ignoreTopLevel = true;
+			oRawMessages = _Helper.extractMessages(oError);
+
+			oResult = fnOnStrictHandlingFailed(
+				oRawMessages.bound.concat(oRawMessages.unbound).map(function (oRawMessage) {
+					return that.oModel.createUI5Message(oRawMessage);
+			}));
+
+			if (!(oResult instanceof Promise)) {
+				throw new Error("Not a promise: " + oResult);
+			}
+			return oResult;
+		}
+
+		if (fnOnStrictHandlingFailed && oOperationMetadata.$kind !== "Action") {
+			throw new Error("Not an action: " + sPath);
+		}
 		if (!bAction && oOperationMetadata.$kind !== "Function") {
 			throw new Error("Not an operation: " + sPath);
 		}
@@ -636,8 +676,10 @@ sap.ui.define([
 			sMetaPath);
 		this.oCache = oCache;
 		this.oCachePromise = SyncPromise.resolve(oCache);
+
 		return bAction
-			? oCache.post(oGroupLock, mParameters, vEntity, bIgnoreETag)
+			? oCache.post(oGroupLock, mParameters, vEntity, bIgnoreETag,
+				fnOnStrictHandlingFailed && onStrictHandling)
 			: oCache.fetchValue(oGroupLock);
 	};
 
@@ -741,14 +783,31 @@ sap.ui.define([
 	 *   IDs as specified in {@link sap.ui.model.odata.v4.ODataModel}.
 	 * @param {boolean} [bIgnoreETag]
 	 *   Whether the entity's ETag should be actively ignored (If-Match:*); supported for bound
-	 *   actions only, since 1.90.0
+	 *   actions only, since 1.90.0. Ignored if there is no ETag (since 1.93.0).
+	 * @param {function} [fnOnStrictHandlingFailed]
+	 *   If this callback is given for an action, the preference "handling=strict" is applied. If
+	 *   the service responds with the HTTP status code 412 and a
+	 *   "Preference-applied: handling=strict" header, the details from the OData error response are
+	 *   extracted and passed to the callback as an array of {@link sap.ui.core.message.Message}
+	 *   items. The callback has to return a <code>Promise</code> resolving with a
+	 *   <code>boolean</code> value in order to indicate whether the bound action should either be
+	 *   repeated <b>without</b> applying the preference or rejected with an <code>Error</code>
+	 *   instance <code>oError</code> where <code>oError.canceled === true</code>.
+	 *   Since 1.92.0.
 	 * @returns {Promise}
 	 *   A promise that is resolved without data or with a return value context when the operation
-	 *   call succeeded, or rejected with an instance of <code>Error</code> in case of failure,
-	 *   for instance if the operation metadata is not found, if overloading is not supported, if a
-	 *   collection-valued function parameter is encountered, or if <code>bIgnoreETag</code> is used
-	 *   for an operation other than a bound action.
-	 *
+	 *   call succeeded, or rejected with an <code>Error</code> instance <code>oError</code> in case
+	 *   of failure, for instance if the operation metadata is not found, if overloading is not
+	 *   supported, if a collection-valued function parameter is encountered, or if
+	 *   <code>bIgnoreETag</code> is used for an operation other than a bound action. It is also
+	 *   rejected if <code>fnOnStrictHandlingFailed</code> is supplied and
+	 *   <ul>
+	 *    <li> is used for an operation other than an action,
+	 *    <li> another request that applies the preference "handling=strict" exists in a different
+	 *      change set of the same $batch request,
+	 *    <li> returns a <code>Promise</code> that resolves with <code>false</code>. In this case
+	 *      <code>oError.canceled === true</code>.
+	 *   </ul>
 	 *   A return value context is a {@link sap.ui.model.odata.v4.Context} which represents a bound
 	 *   operation response. It is created only if the operation is bound and has a single entity
 	 *   return value from the same entity set as the operation's binding parameter and has a
@@ -765,12 +824,15 @@ sap.ui.define([
 	 *   {@link sap.ui.model.Binding#isResolved}) or relative to a transient context (see
 	 *   {@link sap.ui.model.odata.v4.Context#isTransient}), or if deferred operation bindings are
 	 *   nested, or if the OData resource path for a deferred operation binding's context cannot be
-	 *   determined.
+	 *   determined, or if <code>fnOnStrictHandlingFailed</code> is called and does not return a
+	 *   <code>Promise</code>.
+
 	 *
 	 * @public
 	 * @since 1.37.0
 	 */
-	ODataContextBinding.prototype.execute = function (sGroupId, bIgnoreETag) {
+	ODataContextBinding.prototype.execute = function (sGroupId, bIgnoreETag,
+			fnOnStrictHandlingFailed) {
 		var sResolvedPath = this.getResolvedPath();
 
 		this.checkSuspended();
@@ -792,7 +854,8 @@ sap.ui.define([
 		}
 
 		return this._execute(this.lockGroup(sGroupId, true),
-			_Helper.publicClone(this.oOperation.mParameters, true), bIgnoreETag);
+			_Helper.publicClone(this.oOperation.mParameters, true), bIgnoreETag,
+				fnOnStrictHandlingFailed);
 	};
 
 	/**
@@ -804,7 +867,7 @@ sap.ui.define([
 	 *   Some absolute path
 	 * @param {sap.ui.model.odata.v4.ODataPropertyBinding} [oListener]
 	 *   A property binding which registers itself as listener at the cache
-	 * @param {boolean} [bCached=false]
+	 * @param {boolean} [bCached]
 	 *   Whether to return cached values only and not trigger a request
 	 * @returns {sap.ui.base.SyncPromise}
 	 *   A promise on the outcome of the cache's <code>fetchValue</code> call; it is rejected in
@@ -1192,7 +1255,8 @@ sap.ui.define([
 			that = this;
 
 		/*
-		 * Adds an error handler to the given promise which reports errors to the model.
+		 * Adds an error handler to the given promise which reports errors to the model and ignores
+		 * cancellations.
 		 *
 		 * @param {Promise} oPromise - A promise
 		 * @return {Promise} A promise including an error handler
@@ -1200,7 +1264,9 @@ sap.ui.define([
 		function reportError(oPromise) {
 			return oPromise.catch(function (oError) {
 				oModel.reportError("Failed to request side effects", sClassName, oError);
-				throw oError;
+				if (!oError.canceled) {
+					throw oError;
+				}
 			});
 		}
 
@@ -1297,7 +1363,7 @@ sap.ui.define([
 	ODataContextBinding.prototype.setContext = function (oContext) {
 		if (this.oContext !== oContext) {
 			if (this.bRelative && (this.oContext || oContext)) {
-				this.checkSuspended();
+				this.checkSuspended(true);
 				if (this.oElementContext) {
 					this.oElementContext.destroy();
 					this.oElementContext = null;