@openui5/sap.ui.core 1.111.2 → 1.112.2

package/src/sap/ui/model/odata/v4/lib/_AggregationCache.js

@@ -211,14 +211,8 @@ sap.ui.define([
 	 * @see sap.ui.model.odata.v4.lib._CollectionCache#requestSideEffects
 	 */
 	_AggregationCache.prototype.beforeUpdateSelected = function (sPredicate, oNewValue) {
-		var oElement = this.aElements.$byPredicate[sPredicate],
-			sNodeProperty = this.oAggregation.$NodeProperty;
-
-		if (oElement[sNodeProperty] !== oNewValue[sNodeProperty]) {
-			throw new Error("Unexpected structural change: " + sNodeProperty
-				+ " from " + JSON.stringify(oElement[sNodeProperty])
-				+ " to " + JSON.stringify(oNewValue[sNodeProperty]));
-		}
+		_AggregationHelper.checkNodeProperty(this.aElements.$byPredicate[sPredicate], oNewValue,
+			this.oAggregation.$NodeProperty, true);
 	};
 
 	/**
@@ -383,12 +377,12 @@ sap.ui.define([
 
 			iCount = aSpliced.length;
 			this.aElements.$count = aElements.$count + iCount;
-			aSpliced.forEach(function (oElement, i) {
+			aSpliced.forEach(function (oElement) {
 				var sPredicate = _Helper.getPrivateAnnotation(oElement, "predicate");
 
 				if (!_Helper.hasPrivateAnnotation(oElement, "placeholder")) {
 					if (bStale) {
-						that.replaceByPlaceholder(iIndex + i, oElement, sPredicate);
+						that.turnIntoPlaceholder(oElement, sPredicate);
 					} else {
 						that.aElements.$byPredicate[sPredicate] = oElement;
 						if (_Helper.hasPrivateAnnotation(oElement, "expanding")) {
@@ -617,7 +611,7 @@ sap.ui.define([
 
 	/**
 	 * Determines the list of elements determined by the given predicates. All other elements are
-	 * replaced by placeholders (lazily).
+	 * turned into placeholders (lazily).
 	 *
 	 * @param {string[]} aPredicates
 	 *   The key predicates of the elements to request side effects for
@@ -636,7 +630,7 @@ sap.ui.define([
 			mPredicates[sPredicate] = true;
 		});
 
-		return this.aElements.filter(function (oElement, i) {
+		return this.aElements.filter(function (oElement) {
 			var sPredicate = _Helper.getPrivateAnnotation(oElement, "predicate");
 
 			if (mPredicates[sPredicate]) {
@@ -644,7 +638,7 @@ sap.ui.define([
 				return true; // keep and request
 			}
 
-			that.replaceByPlaceholder(i, oElement, sPredicate);
+			that.turnIntoPlaceholder(oElement, sPredicate);
 		});
 	};
 
@@ -783,19 +777,28 @@ sap.ui.define([
 	 * @private
 	 */
 	_AggregationCache.prototype.readCount = function (oGroupLock) {
-		var fnResolve = this.oCountPromise && this.oCountPromise.$resolve,
-			sResourcePath = this.sResourcePath + "/$count",
-			sSeparator = "?";
+		var mQueryOptions,
+			fnResolve = this.oCountPromise && this.oCountPromise.$resolve,
+			sResourcePath;
 
 		if (fnResolve) {
 			delete this.oCountPromise.$resolve;
-			if (this.mQueryOptions.$filter) {
-				sResourcePath += "?$filter=" + this.mQueryOptions.$filter;
-				sSeparator = "&";
-			}
+
+			mQueryOptions = Object.assign({}, this.mQueryOptions);
+			// // drop collection related system query options (except $filter,$search)
+			delete mQueryOptions.$apply;
+			delete mQueryOptions.$count;
+			// keep mQueryOptions.$filter;
+			delete mQueryOptions.$expand;
+			delete mQueryOptions.$orderby;
 			if (this.oAggregation.search) {
-				sResourcePath += sSeparator + "$search=" + this.oAggregation.search;
+				// Note: A recursive hierarchy cannot be combined with "$search"
+				mQueryOptions.$search = this.oAggregation.search;
 			}
+			delete mQueryOptions.$select;
+			// Note: sMetaPath only needed for $filter by V42, but V42 cannot work here!
+			sResourcePath = this.sResourcePath + "/$count"
+				+ this.oRequestor.buildQueryString(/*sMetaPath*/null, mQueryOptions);
 
 			return this.oRequestor.request("GET", sResourcePath, oGroupLock.getUnlockedCopy())
 				.then(fnResolve); // Note: $count is already of type number here
@@ -964,51 +967,41 @@ sap.ui.define([
 	_AggregationCache.prototype.refreshKeptElements = function () {};
 
 	/**
-	 * Replaces the given element, which is at the given position and has the given predicate, with
-	 * a placeholder which keeps all private annotations plus the hierarchy node value. The original
-	 * element is removed from its corresponding cache and must not be used any longer.
+	 * Returns the cache's URL.
+	 *
+	 * @returns {string} The URL
+	 *
+	 * @public
+	 * @see sap.ui.model.odata.v4.lib._AggregationCache#getDownloadUrl
+	 */
+	// @override sap.ui.model.odata.v4.lib._Cache#toString
+	_AggregationCache.prototype.toString = function () {
+		return this.sDownloadUrl;
+	};
+
+	/**
+	 * Turns the given element, which has the given predicate, into a placeholder which keeps all
+	 * private annotations plus the hierarchy node value. The original element is removed from its
+	 * corresponding cache and must not be used any longer.
 	 *
-	 * @param {number} iIndex - Its index
 	 * @param {object} oElement - An element
 	 * @param {string} sPredicate - Its predicate
 	 *
 	 * @private
 	 */
-	_AggregationCache.prototype.replaceByPlaceholder = function (iIndex, oElement, sPredicate) {
-		var sNodeProperty = this.oAggregation.$NodeProperty,
-			oPlaceholder;
-
+	_AggregationCache.prototype.turnIntoPlaceholder = function (oElement, sPredicate) {
 		if (_Helper.hasPrivateAnnotation(oElement, "placeholder")) {
 			return;
 		}
 
+		_Helper.setPrivateAnnotation(oElement, "placeholder", 1); // not an initial placeholder
 		_AggregationHelper.markSplicedStale(oElement);
-		this.aElements[iIndex] = oPlaceholder = {
-			"@$ui5._" : Object.assign(oElement["@$ui5._"], {placeholder : true}),
-			"@$ui5.node.isExpanded" : oElement["@$ui5.node.isExpanded"],
-			"@$ui5.node.level" : oElement["@$ui5.node.level"]
-		};
-		oPlaceholder[sNodeProperty] = oElement[sNodeProperty];
 		delete this.aElements.$byPredicate[sPredicate];
-
 		// drop original element from its cache's collection
 		_Helper.getPrivateAnnotation(oElement, "parent")
 			.drop(_Helper.getPrivateAnnotation(oElement, "index"), sPredicate);
 	};
 
-	/**
-	 * Returns the cache's URL.
-	 *
-	 * @returns {string} The URL
-	 *
-	 * @public
-	 * @see sap.ui.model.odata.v4.lib._AggregationCache#getDownloadUrl
-	 */
-	// @override sap.ui.model.odata.v4.lib._Cache#toString
-	_AggregationCache.prototype.toString = function () {
-		return this.sDownloadUrl;
-	};
-
 	//*********************************************************************************************
 	// "static" functions
 	//*********************************************************************************************
@@ -1099,11 +1092,10 @@ sap.ui.define([
 	// @override sap.ui.model.odata.v4.lib._Cache#calculateKeyPredicate
 	_AggregationCache.calculateKeyPredicateRH = function (oGroupNode, oAggregation, oElement,
 			mTypeForMetaPath, sMetaPath) {
-		var sDistanceFromRootProperty = oAggregation.$DistanceFromRootProperty,
-			sDrillStateProperty = oAggregation.$DrillStateProperty,
+		var sDistanceFromRoot,
 			bIsExpanded,
 			iLevel = 1,
-			sLimitedDescendantCountProperty = oAggregation.$LimitedDescendantCountProperty,
+			sLimitedDescendantCount,
 			sPredicate;
 
 		if (!(sMetaPath in mTypeForMetaPath)) {
@@ -1116,7 +1108,7 @@ sap.ui.define([
 			return sPredicate;
 		}
 
-		switch (oElement[sDrillStateProperty]) {
+		switch (_Helper.drillDown(oElement, oAggregation.$DrillStateProperty)) {
 			case "expanded":
 				bIsExpanded = true;
 				break;
@@ -1130,21 +1122,30 @@ sap.ui.define([
 			default: // "leaf"
 				// bIsExpanded = undefined;
 		}
+		_Helper.deleteProperty(oElement, oAggregation.$DrillStateProperty);
 		if (oGroupNode) {
 			iLevel = oGroupNode["@$ui5.node.level"] + 1;
-		} else if (oElement[sDistanceFromRootProperty]) { // Edm.Int64
-			iLevel = parseInt(oElement[sDistanceFromRootProperty]) + 1;
+		} else {
+			sDistanceFromRoot = _Helper.drillDown(oElement, oAggregation.$DistanceFromRootProperty);
+			if (sDistanceFromRoot) { // Edm.Int64
+				_Helper.deleteProperty(oElement, oAggregation.$DistanceFromRootProperty);
+				iLevel = parseInt(sDistanceFromRoot) + 1;
+			}
 		}
 		// set the node values
 		_AggregationHelper.setAnnotations(oElement, bIsExpanded, /*bIsTotal*/undefined, iLevel);
-		if (oElement[sLimitedDescendantCountProperty]
-			&& oElement[sLimitedDescendantCountProperty] !== "0") { // Edm.Int64
-			_Helper.setPrivateAnnotation(oElement, "descendants",
-				parseInt(oElement[sLimitedDescendantCountProperty]));
+
+		if (oAggregation.$LimitedDescendantCountProperty) {
+			sLimitedDescendantCount
+				= _Helper.drillDown(oElement, oAggregation.$LimitedDescendantCountProperty);
+			if (sLimitedDescendantCount) {
+				_Helper.deleteProperty(oElement, oAggregation.$LimitedDescendantCountProperty);
+				if (sLimitedDescendantCount !== "0") { // Edm.Int64
+					_Helper.setPrivateAnnotation(oElement, "descendants",
+						parseInt(sLimitedDescendantCount));
+				}
+			}
 		}
-		delete oElement[sDistanceFromRootProperty];
-		delete oElement[sDrillStateProperty];
-		delete oElement[sLimitedDescendantCountProperty];
 
 		return sPredicate;
 	};

package/src/sap/ui/model/odata/v4/lib/_AggregationHelper.js

@@ -165,20 +165,20 @@ sap.ui.define([
 					throw new Error("Unexpected structural change: " + sAnnotation);
 				}
 			});
-			if (sNodeProperty in oPlaceholder
-					&& oPlaceholder[sNodeProperty] !== oElement[sNodeProperty]) {
-				throw new Error("Unexpected structural change: " + sNodeProperty
-					+ " from " + JSON.stringify(oPlaceholder[sNodeProperty])
-					+ " to " + JSON.stringify(oElement[sNodeProperty]));
+			if (sNodeProperty) {
+				_AggregationHelper.checkNodeProperty(oPlaceholder, oElement, sNodeProperty);
 			}
 
 			_Helper.copyPrivateAnnotation(oPlaceholder, "spliced", oElement);
-			if ("@$ui5.node.isExpanded" in oPlaceholder) {
+			if (_Helper.getPrivateAnnotation(oPlaceholder, "placeholder") === 1) {
 				if ((oPlaceholder["@$ui5.node.isExpanded"] === undefined)
 						!== (oElement["@$ui5.node.isExpanded"] === undefined)) {
 					throw new Error("Not a leaf anymore (or vice versa)");
 				}
-				oElement["@$ui5.node.isExpanded"] = oPlaceholder["@$ui5.node.isExpanded"];
+				if (oPlaceholder["@$ui5.node.isExpanded"] !== undefined) {
+					// restore previous expansion state
+					oElement["@$ui5.node.isExpanded"] = oPlaceholder["@$ui5.node.isExpanded"];
+				}
 			}
 		},
 
@@ -535,6 +535,31 @@ sap.ui.define([
 			return mQueryOptions;
 		},
 
+		/**
+		 * Checks that the NodeProperty ("the hierarchy node value") has not changed.
+		 *
+		 * @param {object} oOld
+		 *   The old node object
+		 * @param {object} oNew
+		 *   The new node object
+		 * @param {string} sNodeProperty
+		 *   The path to the property which provides the hierarchy node value
+		 * @param {boolean} [bMandatory]
+		 *   Whether a hierarchy node value is mandatory for the old node object (else it may be
+		 *   missing because old node object is just a placeholder)
+		 * @throws {Error} In case of a structural change
+		 */
+		checkNodeProperty : function (oOld, oNew, sNodeProperty, bMandatory) {
+			var vNewNodeID = _Helper.drillDown(oNew, sNodeProperty),
+				vOldNodeID = _Helper.drillDown(oOld, sNodeProperty);
+
+			if ((bMandatory || vOldNodeID !== undefined) && vOldNodeID !== vNewNodeID) {
+				throw new Error("Unexpected structural change: " + sNodeProperty
+					+ " from " + JSON.stringify(vOldNodeID)
+					+ " to " + JSON.stringify(vNewNodeID));
+			}
+		},
+
 		/**
 		 * Checks that the given value is of the given type. If <code>vType</code> is a string, then
 		 * <code>typeof vValue === vType<code> must hold. If <code>vType</code> is an array (of

package/src/sap/ui/model/odata/v4/lib/_Cache.js

@@ -341,6 +341,49 @@ sap.ui.define([
 		this.oPendingRequestsPromise.$count += 1;
 	};
 
+	/**
+	 * Adds a collection below a transient element.
+	 *
+	 * @param {string} sPath
+	 *   The collection path
+	 * @param {string[]} [aSelect]
+	 *   The binding's $select if it would create a cache; later used for updateSelected (either
+	 *   taking this aSelect or calculating it from the path)
+	 * @returns {object[]}
+	 *   The elements collection (either from the initial data or empty)
+	 * @throws {Error} If the cache is shared
+	 *
+	 * @public
+	 */
+	_Cache.prototype.addTransientCollection = function (sPath, aSelect) {
+		var aElements,
+			aSegments = sPath.split("/"),
+			sName = aSegments.pop(),
+			oParent = this.fetchValue(_GroupLock.$cached, aSegments.join("/")).getResult(),
+			oPostBody = _Helper.getPrivateAnnotation(oParent, "postBody"),
+			that = this;
+
+		this.checkSharedRequest();
+		if (sName in oParent) {
+			throw new Error("Deep create with initial data is not supported yet");
+		}
+		aElements = oParent[sName] = [];
+		aElements.$count = aElements.$created = 0;
+		aElements.$byPredicate = {};
+		// allow creating on demand when there is a create in the child list
+		aElements.$postBodyCollection = function () {
+			aElements.$postBodyCollection = oPostBody[sName] = [];
+		};
+		aElements.$select = aSelect;
+		// add the collection type to mTypeForMetaPath
+		this.fetchTypes().then(function (mTypeForMetaPath) {
+			that.oRequestor.fetchType(mTypeForMetaPath,
+				that.sMetaPath + "/" + _Helper.getMetaPath(sPath));
+		});
+
+		return aElements;
+	};
+
 	/**
 	 * Adjusts the indexes in the collection.
 	 *
@@ -407,6 +450,31 @@ sap.ui.define([
 		return sPredicate;
 	};
 
+	/**
+	 * Cancels all nested creates within the given element.
+	 *
+	 * @param {object} oElement - The entity data in the cache
+	 * @param {string} sPostPath - The request path of the POST request
+	 * @param {string} sGroupId - The group ID of the POST request
+	 *
+	 * @private
+	 */
+	_Cache.prototype.cancelNestedCreates = function (oElement, sPostPath, sGroupId) {
+		Object.keys(oElement).forEach(function (sKey) {
+			var oError,
+				vProperty = oElement[sKey];
+
+			if (vProperty && vProperty.$postBodyCollection) {
+				oError = new Error("Deep create of " + sKey + " canceled with POST " + sPostPath
+					+ "; group: " + sGroupId);
+				oError.canceled = true;
+				vProperty.forEach(function (oChildElement) {
+					_Helper.getPrivateAnnotation(oChildElement, "reject")(oError);
+				});
+			}
+		});
+	};
+
 	/**
 	 * Throws an error if the cache shares requests.
 	 *
@@ -483,11 +551,15 @@ sap.ui.define([
 				return true;
 			}
 
+			that.cancelNestedCreates(oEntityData, oPostPathPromise.getResult(),
+				oGroupLock.getGroupId());
 			_Helper.removeByPath(that.mPostRequests, sPath, oEntityData);
 			aCollection.splice(iIndex, 1);
 			aCollection.$created -= 1;
 			if (!oEntityData["@$ui5.context.isInactive"]) {
-				that.iActiveElements -= 1;
+				if (!sPath) {
+					that.iActiveElements -= 1;
+				}
 				addToCount(that.mChangeListeners, sPath, aCollection, -1);
 			}
 			delete aCollection.$byPredicate[sTransientPredicate];
@@ -516,6 +588,7 @@ sap.ui.define([
 			]).then(function (aResult) {
 				var oCreatedEntity = aResult[0],
 					sPredicate,
+					sResultingPath,
 					aSelect;
 
 				_Helper.deletePrivateAnnotation(oEntityData, "postBody");
@@ -538,13 +611,18 @@ sap.ui.define([
 						// contexts still use the transient predicate to access the data
 					} // else: transient element was not kept by #reset, leave it like that!
 				}
-				// update the cache with the POST response (note that a deep create is not supported
-				// because updateSelected does not handle key predicates, ETags and $count)
-				aSelect = _Helper.getQueryOptionsForPath(that.mQueryOptions, sPath).$select;
-				_Helper.updateSelected(that.mChangeListeners,
-					_Helper.buildPath(sPath, sPredicate || sTransientPredicate), oEntityData,
+				// update the cache with the POST response
+				aSelect = _Helper.getQueryOptionsForPath(
+					that.mLateQueryOptions || that.mQueryOptions, sPath
+				).$select;
+				sResultingPath = _Helper.buildPath(sPath, sPredicate || sTransientPredicate);
+				// update selected properties (incl. single-valued navigation properties), ETags,
+				// and predicates
+				_Helper.updateSelected(that.mChangeListeners, sResultingPath, oEntityData,
 					oCreatedEntity, aSelect, /*fnCheckKeyPredicate*/ undefined,
 					/*bOkIfMissing*/ true);
+				// update properties from collections in a deep create
+				that.updateNestedCreates(sResultingPath, oEntityData, oCreatedEntity);
 
 				that.removePendingRequest();
 				fnResolve(true);
@@ -597,7 +675,9 @@ sap.ui.define([
 				_Helper.publicClone(oEntityData, true));
 			oEntityData["@$ui5.context.isInactive"] = true;
 		} else {
-			this.iActiveElements += 1;
+			if (!sPath) {
+				this.iActiveElements += 1;
+			}
 			addToCount(this.mChangeListeners, sPath, aCollection, 1);
 		}
 
@@ -611,6 +691,19 @@ sap.ui.define([
 		aCollection.$byPredicate = aCollection.$byPredicate || {};
 		aCollection.$byPredicate[sTransientPredicate] = oEntityData;
 		that.adjustIndexes(sPath, aCollection, 0, 1, 0, true);
+		if (aCollection.$postBodyCollection) { // within a deep create
+			if (typeof aCollection.$postBodyCollection === "function") {
+				aCollection.$postBodyCollection(); // creation on demand
+			}
+			_Helper.setPrivateAnnotation(oEntityData, "transient", sGroupId);
+			if (bAtEndOfCreated) {
+				aCollection.$postBodyCollection.push(oPostBody);
+			} else {
+				aCollection.$postBodyCollection.unshift(oPostBody);
+			}
+			oGroupLock.unlock();
+			return _Helper.addDeepCreatePromise(oEntityData);
+		}
 
 		return oPostPathPromise.then(function (sPostPath) {
 			sPostPath += that.oRequestor.buildQueryString(that.sMetaPath, that.mQueryOptions, true);
@@ -973,7 +1066,8 @@ sap.ui.define([
 				throw new Error("GET " + sRequestPath + ": Key predicate changed from "
 					+ sOldPredicate + " to " + sNewPredicate);
 			}
-			// we expect the server to always or never send an ETag for this entity
+			// only check for ETag change if the cache contains one; otherwise either the cache
+			// element is empty (via #createEmptyElement) or the server did not send one last time
 			if (oResource["@odata.etag"] && oData["@odata.etag"] !== oResource["@odata.etag"]) {
 				throw new Error("GET " + sRequestPath + ": ETag changed");
 			}
@@ -1071,6 +1165,27 @@ sap.ui.define([
 	 * @public
 	 */
 
+	/**
+	 * Returns the value at the given path and removes it from the cache.
+	 *
+	 * @param {string} sPath - The relative path of the property
+	 * @returns {any} The value
+	 * @throws {Error} If the cache is shared
+	 *
+	 * @public
+	 */
+	_Cache.prototype.getAndRemoveValue = function (sPath) {
+		var aSegments = sPath.split("/"),
+			sName = aSegments.pop(),
+			oParent = this.fetchValue(_GroupLock.$cached, aSegments.join("/")).getResult(),
+			vValue = oParent[sName];
+
+		this.checkSharedRequest();
+		delete oParent[sName];
+
+		return vValue;
+	};
+
 	/**
 	 * Returns an array containing all current elements of a collection or single cache for the
 	 * given relative path; the array is annotated with the collection's $count. If there are
@@ -2203,6 +2318,60 @@ sap.ui.define([
 		});
 	};
 
+	/**
+	 * Creates key predicates and updates listeners for nested entity collections after a deep
+	 * create.
+	 *
+	 * @param {string} sPath - The path of the created entity within the cache
+	 * @param {object} oEntity - The entity in the cache
+	 * @param {object} oCreatedEntity - The created entity from the response
+	 *
+	 * @private
+	 */
+	_Cache.prototype.updateNestedCreates = function (sPath, oEntity, oCreatedEntity) {
+		var that = this;
+
+		Object.keys(oEntity).forEach(function (sSegment) {
+			var vCollection = oEntity[sSegment],
+				sCollectionPath,
+				aCreatedCollection,
+				aSelect;
+
+			if (vCollection && vCollection.$postBodyCollection) {
+				aCreatedCollection = oCreatedEntity[sSegment];
+				if (aCreatedCollection) { // otherwise no create was called in nested list binding
+					sCollectionPath = sPath + "/" + sSegment;
+					aSelect = vCollection.$select
+						|| _Helper.getQueryOptionsForPath(that.mQueryOptions, sCollectionPath)
+							.$select;
+					aCreatedCollection.forEach(function (oCreatedChildEntity, i) {
+						var oChildEntity = vCollection[i],
+							sPredicate
+								= _Helper.getPrivateAnnotation(oCreatedChildEntity, "predicate"),
+							fnResolve = _Helper.getPrivateAnnotation(oChildEntity, "resolve"),
+							sTransientPredicate = _Helper.getPrivateAnnotation(oChildEntity,
+								"transientPredicate");
+
+						_Helper.updateTransientPaths(that.mChangeListeners, sTransientPredicate,
+							sPredicate);
+						vCollection.$byPredicate[sPredicate] = oChildEntity;
+						_Helper.updateSelected(that.mChangeListeners, sCollectionPath + sPredicate,
+							oChildEntity, oCreatedChildEntity, aSelect,
+							/*fnCheckKeyPredicate*/undefined, true);
+						_Helper.deletePrivateAnnotation(oChildEntity, "postBody");
+						_Helper.deletePrivateAnnotation(oChildEntity, "reject");
+						_Helper.deletePrivateAnnotation(oChildEntity, "resolve");
+						_Helper.deletePrivateAnnotation(oChildEntity, "transient");
+						delete oChildEntity["@$ui5.context.isTransient"];
+						fnResolve(oChildEntity); // resolve the create promise
+					});
+				}
+				delete vCollection.$postBodyCollection;
+				delete vCollection.$select;
+			}
+		});
+	};
+
 	/**
 	 * Processes the response from the server. All arrays are annotated by their length, influenced
 	 * by the annotations "@odata.count" and "@odata.nextLink". Recursively calculates the key
@@ -2868,7 +3037,9 @@ sap.ui.define([
 			if (sPredicate) {
 				oKeptElement = aElements.$byPredicate[sPredicate];
 				if (oKeptElement) {
-					// we expect the server to always or never send an ETag for this entity
+					// only check for ETag change if the cache contains one; otherwise either the
+					// cache element is empty (via #createEmptyElement) or the server did not send
+					// one last time
 					if (!oKeptElement["@odata.etag"]
 							|| oElement["@odata.etag"] === oKeptElement["@odata.etag"]) {
 						if (iCreated && aElements.lastIndexOf(oKeptElement, iCreated - 1) >= 0) {
@@ -3126,10 +3297,8 @@ sap.ui.define([
 		}
 
 		/*
-		 * Tells whether a refresh is needed for the given predicate. Transient predicates,
-		 * elements with pending changes, and empty elements just created via
-		 * {@link sap.ui.model.odata.v4.ODataModel#getKeepAliveContext} but not yet read, need no
-		 * refresh.
+		 * Tells whether a refresh is needed for the given predicate. Transient predicates and
+		 * elements with pending changes need no refresh.
 		 *
 		 * @param {string} sPredicate - A key predicate
 		 * @returns {boolean} - Whether a refresh is needed
@@ -3138,7 +3307,6 @@ sap.ui.define([
 			var oElement = that.aElements.$byPredicate[sPredicate];
 
 			return _Helper.getPrivateAnnotation(oElement, "predicate") === sPredicate
-				&& Object.keys(oElement).length > 1 // entity has key properties
 				&& !that.hasPendingChangesForPath(sPredicate);
 		}
 
@@ -3469,6 +3637,17 @@ sap.ui.define([
 		this.oBackup = null;
 	};
 
+	/**
+	 * Sets the cache's elements to the given collection after a deep create.
+	 *
+	 * @param {object} aElements - The elements from the deep create
+	 */
+	_CollectionCache.prototype.setPersistedCollection = function (aElements) {
+		this.aElements = aElements;
+		this.iActiveElements = aElements.$created;
+		this.iLimit = aElements.length;
+	};
+
 	//*********************************************************************************************
 	// PropertyCache
 	//*********************************************************************************************
@@ -3769,24 +3948,42 @@ sap.ui.define([
 				? {"If-Match" : bIgnoreETag && "@odata.etag" in oEntity ? "*" : oEntity}
 				: {},
 			sHttpMethod = "POST",
+			oRequestLock,
 			that = this;
 
+		/*
+		 * Synchronous callback called when the request is put on the wire. Locks the group (for
+		 * bound actions) so that further requests created via {@link ODataModel#submitBatch} wait
+		 * until this request has returned.
+		 */
+		function onSubmit() {
+			oRequestLock = that.oRequestor.lockGroup(oGroupLock.getGroupId(), that, true);
+		}
+
 		function post(oGroupLock0) {
 			that.bPosting = true;
 
 			// BEWARE! Avoid finally here! BCP: 2070200175
 			return SyncPromise.all([
 				that.oRequestor.request(sHttpMethod,
-					that.sResourcePath + that.sQueryString, oGroupLock0, mHeaders, oData),
+					that.sResourcePath + that.sQueryString, oGroupLock0, mHeaders, oData,
+					oEntity && onSubmit),
 				that.fetchTypes()
 			]).then(function (aResult) {
 				that.buildOriginalResourcePath(aResult[0], aResult[1], fnGetOriginalResourcePath);
 				that.visitResponse(aResult[0], aResult[1]);
 				that.bPosting = false;
+				if (oRequestLock) {
+					oRequestLock.unlock();
+				}
 
 				return aResult[0];
 			}, function (oError) {
 				that.bPosting = false;
+				if (oRequestLock) {
+					oRequestLock.unlock();
+					oRequestLock = undefined; // in case we fail again before next submit
+				}
 				if (fnOnStrictHandlingFailed && oError.strictHandlingFailed) {
 					return fnOnStrictHandlingFailed(oError).then(function (bConfirm) {
 						var oCanceledError;