@sap/open.fe 1.94.0

package/packages/sap.fe.core/src/sap/fe/core/services/SideEffectsServiceFactory-dbg.js

@@ -0,0 +1,731 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/ui/core/service/ServiceFactory", "sap/ui/core/service/Service", "sap/fe/core/converters/MetaModelConverter", "sap/base/Log"], function (ServiceFactory, Service, MetaModelConverter, Log) {
+  "use strict";
+
+  var convertTypes = MetaModelConverter.convertTypes;
+
+  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var SideEffectsService = /*#__PURE__*/function (_Service) {
+    _inherits(SideEffectsService, _Service);
+
+    var _super = _createSuper(SideEffectsService);
+
+    function SideEffectsService() {
+      _classCallCheck(this, SideEffectsService);
+
+      return _super.apply(this, arguments);
+    }
+
+    _createClass(SideEffectsService, [{
+      key: "init",
+      value: // !: means that we know it will be assigned before usage
+      function init() {
+        this._oSideEffectsType = {
+          oData: {
+            entities: {},
+            actions: {}
+          },
+          control: {}
+        };
+        this._bInitialized = false;
+        this.initPromise = Promise.resolve(this);
+      }
+      /**
+       * Adds a SideEffects control
+       * SideEffects definition is added by a control to keep data up to date
+       * These SideEffects get limited scope compared with SideEffects coming from an OData service:
+       * - Only one SideEffects definition can be defined for the combination entity type - control Id
+       * - Only SideEffects source properties are recognized and used to trigger SideEffects
+       *
+       * Ensure the sourceControlId matches the associated SAPUI5 control ID.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {string} sEntityType Name of the entity type
+       * @param {object} oSideEffect SideEffects definition
+       */
+
+    }, {
+      key: "addControlSideEffects",
+      value: function addControlSideEffects(sEntityType, oSideEffect) {
+        if (oSideEffect.sourceControlId) {
+          var oControlSideEffect = _objectSpread(_objectSpread({}, oSideEffect), {}, {
+            fullyQualifiedName: sEntityType + "/SideEffectsForControl/" + oSideEffect.sourceControlId
+          });
+
+          var mEntityControlSideEffects = this._oSideEffectsType.control[sEntityType] || {};
+          mEntityControlSideEffects[oControlSideEffect.sourceControlId] = oControlSideEffect;
+          this._oSideEffectsType.control[sEntityType] = mEntityControlSideEffects;
+        }
+      }
+      /**
+       * Executes SideEffects action.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {string} sTriggerAction Name of the action
+       * @param {object} oContext Context
+       * @param {string} sGroupId The group ID to be used for the request
+       */
+
+    }, {
+      key: "executeAction",
+      value: function executeAction(sTriggerAction, oContext, sGroupId) {
+        var oTriggerAction = oContext.getModel().bindContext(sTriggerAction + "(...)", oContext);
+        oTriggerAction.execute(sGroupId || oContext.getBinding().getUpdateGroupId());
+      }
+      /**
+       * Gets converted OData metaModel.
+       *
+       * @private
+       * @ui5-restricted
+       * @returns {object} Converted OData metaModel
+       */
+
+    }, {
+      key: "getConvertedMetaModel",
+      value: function getConvertedMetaModel() {
+        var oContext = this.getContext();
+        var oComponent = oContext.scopeObject;
+        var oMetaModel = oComponent.getModel().getMetaModel();
+        return convertTypes(oMetaModel, this._oCapabilities);
+      }
+      /**
+       * Gets the entity type of a context.
+       *
+       * @function
+       * @name getEntityTypeFromContext
+       * @param {object} oContext Context
+       * @returns {string | undefined } Entity Type
+       */
+
+    }, {
+      key: "getEntityTypeFromContext",
+      value: function getEntityTypeFromContext(oContext) {
+        var oMetaModel = oContext.getModel().getMetaModel(),
+            sMetaPath = oMetaModel.getMetaPath(oContext.getPath()),
+            sEntityType = oMetaModel.getObject(sMetaPath)["$Type"];
+        return sEntityType;
+      }
+      /**
+       * Gets the SideEffects that come from an OData service.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {string} sEntityTypeName Name of the entity type
+       * @returns {object} SideEffects dictionary
+       */
+
+    }, {
+      key: "getODataEntitySideEffects",
+      value: function getODataEntitySideEffects(sEntityTypeName) {
+        return this._oSideEffectsType.oData.entities[sEntityTypeName] || {};
+      }
+      /**
+       * Gets the SideEffects that come from an OData service.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {string} sActionName Name of the action
+       * @param {object} oContext Context
+       * @returns {object} SideEffects definition
+       */
+
+    }, {
+      key: "getODataActionSideEffects",
+      value: function getODataActionSideEffects(sActionName, oContext) {
+        if (oContext) {
+          var sEntityType = this.getEntityTypeFromContext(oContext);
+
+          if (sEntityType) {
+            var _this$_oSideEffectsTy;
+
+            return (_this$_oSideEffectsTy = this._oSideEffectsType.oData.actions[sEntityType]) === null || _this$_oSideEffectsTy === void 0 ? void 0 : _this$_oSideEffectsTy[sActionName];
+          }
+        }
+
+        return undefined;
+      }
+      /**
+       * Generates the dictionary for the SideEffects.
+       *
+       * @private
+       * @ui5-restricted
+       * @param oCapabilities The current capabilities
+       */
+
+    }, {
+      key: "initializeSideEffects",
+      value: function initializeSideEffects(oCapabilities) {
+        var _this = this;
+
+        this._oCapabilities = oCapabilities;
+
+        if (!this._bInitialized) {
+          var oConvertedMetaModel = this.getConvertedMetaModel();
+          oConvertedMetaModel.entityTypes.forEach(function (entityType) {
+            _this._oSideEffectsType.oData.entities[entityType.fullyQualifiedName] = _this._retrieveODataEntitySideEffects(entityType);
+            _this._oSideEffectsType.oData.actions[entityType.fullyQualifiedName] = _this._retrieveODataActionsSideEffects(entityType); // only bound actions are analyzed since unbound ones don't get SideEffects
+          });
+          this._bInitialized = true;
+        }
+      }
+      /**
+       * Removes all SideEffects related to a control.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {string} sControlId Control Id
+       */
+
+    }, {
+      key: "removeControlSideEffects",
+      value: function removeControlSideEffects(sControlId) {
+        var _this2 = this;
+
+        Object.keys(this._oSideEffectsType.control).forEach(function (sEntityType) {
+          if (_this2._oSideEffectsType.control[sEntityType][sControlId]) {
+            delete _this2._oSideEffectsType.control[sEntityType][sControlId];
+          }
+        });
+      }
+      /**
+       * Request SideEffects on a specific context.
+       *
+       * @function
+       * @name requestSideEffects
+       * @param {Array} aPathExpressions Targets of SideEffects to be executed
+       * @param {object} oContext Context where SideEffects need to be executed
+       * @param {string} sGroupId The group ID to be used for the request
+       * @returns {Promise} Promise on SideEffects request
+       */
+
+    }, {
+      key: "requestSideEffects",
+      value: function requestSideEffects(aPathExpressions, oContext, sGroupId) {
+        this._logRequest(aPathExpressions, oContext);
+
+        var oPromise;
+        /**
+         * Context.requestSideEffects either returns a promise or throws a new error. This return is caught if an error is thrown
+         * to avoid breaking the promise chain.
+         */
+
+        try {
+          oPromise = oContext.requestSideEffects(aPathExpressions, sGroupId);
+        } catch (e) {
+          oPromise = Promise.reject(e);
+        }
+
+        return oPromise;
+      }
+      /**
+       * Request SideEffects for a navigation property on a specific context.
+       *
+       * @function
+       * @name requestSideEffectsForNavigationProperty
+       * @param {string} sNavigationProperty Navigation property
+       * @param {object} oContext Context where SideEffects need to be executed
+       * @returns {object} SideEffects request on SAPUI5 context
+       */
+
+    }, {
+      key: "requestSideEffectsForNavigationProperty",
+      value: function requestSideEffectsForNavigationProperty(sNavigationProperty, oContext) {
+        var _this3 = this;
+
+        var sBaseEntityType = this.getEntityTypeFromContext(oContext);
+
+        if (sBaseEntityType) {
+          var aSideEffects = this.getODataEntitySideEffects(sBaseEntityType);
+          var aTargets = [];
+          Object.keys(aSideEffects).filter( // Keep relevant SideEffects
+          function (sAnnotationName) {
+            var oSideEffects = aSideEffects[sAnnotationName];
+            return (oSideEffects.SourceProperties || []).some(function (oPropertyPath) {
+              return oPropertyPath.value.indexOf(sNavigationProperty) > -1;
+            }) || (oSideEffects.SourceEntities || []).some(function (oNavigationPropertyPath) {
+              return oNavigationPropertyPath.value === sNavigationProperty;
+            });
+          }).forEach(function (sAnnotationName) {
+            var oSideEffects = aSideEffects[sAnnotationName];
+
+            if (oSideEffects.TriggerAction) {
+              _this3.executeAction(oSideEffects.TriggerAction, oContext);
+            }
+
+            (oSideEffects.TargetEntities || []).concat(oSideEffects.TargetProperties || []).forEach(function (mTarget) {
+              return aTargets.push(mTarget);
+            });
+          }); // Remove duplicate properties
+
+          aTargets = this._removeDuplicateTargets(aTargets);
+
+          if (aTargets.length > 0) {
+            return this.requestSideEffects(aTargets, oContext).catch(function (oError) {
+              return Log.error("SideEffects - Error while processing SideEffects for Navigation Property " + sNavigationProperty, oError);
+            });
+          }
+        }
+
+        return Promise.resolve();
+      }
+      /**
+       * Gets the SideEffects that come from controls.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {string} sEntityTypeName Entity type Name
+       * @returns {object} SideEffects dictionary
+       */
+
+    }, {
+      key: "getControlEntitySideEffects",
+      value: function getControlEntitySideEffects(sEntityTypeName) {
+        return this._oSideEffectsType.control[sEntityTypeName] || {};
+      }
+      /**
+       * Adds the text properties required for SideEffects
+       * If a property has an associated text then this text needs to be added as targetProperties.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {object} oSideEffect SideEffects definition
+       * @param {object} mEntityType Entity type
+       * @returns {object} SideEffects definition with added text properties
+       */
+
+    }, {
+      key: "_addRequiredTextProperties",
+      value: function _addRequiredTextProperties(oSideEffect, mEntityType) {
+        var aInitialProperties = oSideEffect.TargetProperties || [],
+            aEntitiesRequested = (oSideEffect.TargetEntities || []).map(function (navigation) {
+          return navigation.$NavigationPropertyPath;
+        });
+        var aDerivedProperties = [];
+        aInitialProperties.forEach(function (sPropertyPath) {
+          var bIsStarProperty = sPropertyPath.endsWith("*"),
+              // Can be '*' or '.../navProp/*'
+          sNavigationPropertyPath = sPropertyPath.substring(0, sPropertyPath.lastIndexOf("/")),
+              sRelativePath = sNavigationPropertyPath ? sNavigationPropertyPath + "/" : "",
+              mTarget = mEntityType.resolvePath(sNavigationPropertyPath) || mEntityType;
+
+          if (mTarget) {
+            var _targetType;
+
+            // mTarget can be an entity type, navigationProperty or or a complexType
+            var aTargetEntityProperties = mTarget.entityProperties || ((_targetType = mTarget.targetType) === null || _targetType === void 0 ? void 0 : _targetType.properties) || mTarget.targetType.entityProperties;
+
+            if (aTargetEntityProperties) {
+              if (bIsStarProperty) {
+                if (aTargetEntityProperties) {
+                  // Add all required properties behind the *
+                  aEntitiesRequested.push(sNavigationPropertyPath);
+                  aDerivedProperties = aDerivedProperties.concat(aTargetEntityProperties.map(function (mProperty) {
+                    return {
+                      navigationPath: sRelativePath,
+                      property: mProperty
+                    };
+                  }));
+                }
+              } else {
+                aDerivedProperties.push({
+                  property: aTargetEntityProperties.find(function (mProperty) {
+                    return mProperty.name === sPropertyPath.split("/").pop();
+                  }),
+                  navigationPath: sRelativePath
+                });
+              }
+            } else {
+              Log.info("SideEffects - The entity type associated to property path " + sPropertyPath + " cannot be resolved");
+            }
+          } else {
+            Log.info("SideEffects - The property path " + sPropertyPath + " cannot be resolved");
+          }
+        });
+        aDerivedProperties.forEach(function (mPropertyInfo) {
+          if (mPropertyInfo.property) {
+            var _mPropertyInfo$proper, _mPropertyInfo$proper2, _mPropertyInfo$proper3;
+
+            var sTargetTextPath = (_mPropertyInfo$proper = mPropertyInfo.property.annotations) === null || _mPropertyInfo$proper === void 0 ? void 0 : (_mPropertyInfo$proper2 = _mPropertyInfo$proper.Common) === null || _mPropertyInfo$proper2 === void 0 ? void 0 : (_mPropertyInfo$proper3 = _mPropertyInfo$proper2.Text) === null || _mPropertyInfo$proper3 === void 0 ? void 0 : _mPropertyInfo$proper3.path,
+                sTextPathFromInitialEntity = mPropertyInfo.navigationPath + sTargetTextPath;
+            /**
+             * The property Text must be added only if the property is
+             * - not part of a star property (.i.e '*' or 'navigation/*') or a targeted Entity
+             * - not include into the initial targeted properties of SideEffects
+             *  Indeed in the two listed cases, the property containing text will be/is requested by initial SideEffects configuration.
+             */
+
+            if (sTargetTextPath && aEntitiesRequested.indexOf(sTextPathFromInitialEntity.substring(0, sTextPathFromInitialEntity.lastIndexOf("/"))) === -1 && aInitialProperties.indexOf(sTextPathFromInitialEntity) === -1) {
+              oSideEffect.TargetProperties.push(sTextPathFromInitialEntity);
+            }
+          }
+        });
+        return oSideEffect;
+      }
+      /**
+       * Converts SideEffects to expected format
+       *  - Converts SideEffects targets to expected format
+       *  - Removes binding parameter from SideEffects targets properties
+       *  - Adds the text properties
+       *  - Replaces TargetProperties having reference to Source Properties for a SideEffects.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {object} oSideEffects SideEffects definition
+       * @param {string} sEntityType Name of the entity type
+       * @param {string} sBindingParameter Name of the binding parameter
+       * @returns {object} SideEffects definition
+       */
+
+    }, {
+      key: "_convertSideEffects",
+      value: function _convertSideEffects(oSideEffects, sEntityType, sBindingParameter) {
+        var mEntityType = this.getConvertedMetaModel().entityTypes.find(function (oEntityType) {
+          return oEntityType.fullyQualifiedName === sEntityType;
+        });
+
+        var oTempSideEffects = this._removeBindingParameter(this._convertTargetsFormat(oSideEffects), sBindingParameter);
+
+        return mEntityType ? this._replaceReferencedProperties(this._addRequiredTextProperties(oTempSideEffects, mEntityType), mEntityType) : oTempSideEffects;
+      }
+      /**
+       * Converts SideEffects targets (TargetEntities and TargetProperties) to expected format
+       *  - TargetProperties as array of string
+       *  - TargetEntities as array of object with property $NavigationPropertyPath.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {object} oSideEffects SideEffects definition
+       * @returns {object} Converted SideEffects
+       */
+
+    }, {
+      key: "_convertTargetsFormat",
+      value: function _convertTargetsFormat(oSideEffects) {
+        var TargetProperties = (oSideEffects.TargetProperties || []).reduce(function (aTargetProperties, vTarget) {
+          var sTarget = typeof vTarget === "string" && vTarget || vTarget.type === "PropertyPath" && vTarget.value;
+
+          if (sTarget) {
+            aTargetProperties.push(sTarget);
+          } else {
+            Log.error("SideEffects - Error while processing TargetProperties for SideEffects" + oSideEffects.fullyQualifiedName);
+          }
+
+          return aTargetProperties;
+        }, []),
+            TargetEntities = (oSideEffects.TargetEntities || []).map(function (mTargetEntity) {
+          /**
+           *  SideEffects that comes from SAP FE get TargetEntities with $NavigationPropertyPath whereas
+           *  ones coming from the converted OData model gets a NavigationPropertyPath format
+           *
+           */
+          return {
+            "$NavigationPropertyPath": mTargetEntity.$NavigationPropertyPath || mTargetEntity.value || ""
+          };
+        });
+        return _objectSpread(_objectSpread({}, oSideEffects), {
+          TargetProperties: TargetProperties,
+          TargetEntities: TargetEntities
+        });
+      }
+      /**
+       * Gets SideEffects related to an entity type or action that come from an OData Service
+       * Internal routine to get, from converted oData metaModel, SideEffects related to a specific entity type or action
+       * and to convert these SideEffects with expected format.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {object} oSource Entity type or action
+       * @returns {object} Array of SideEffects
+       */
+
+    }, {
+      key: "_getSideEffectsFromSource",
+      value: function _getSideEffectsFromSource(oSource) {
+        var _this4 = this;
+
+        var aSideEffects = [];
+        var authorizedTypes = ["EntityType", "Action"];
+
+        if (oSource._type && authorizedTypes.indexOf(oSource._type) > -1) {
+          var mEntityType = oSource._type === "EntityType" ? oSource : oSource.sourceEntityType;
+
+          if (mEntityType) {
+            var _oSource$annotations;
+
+            var mCommonAnnotation = ((_oSource$annotations = oSource.annotations) === null || _oSource$annotations === void 0 ? void 0 : _oSource$annotations.Common) || {};
+            var mBindingParameter = (oSource.parameters || []).find(function (mParameter) {
+              return mParameter.type === (mEntityType || oSource).fullyQualifiedName;
+            });
+            var sBindingParameter = mBindingParameter ? mBindingParameter.fullyQualifiedName.split("/")[1] : "";
+            Object.keys(mCommonAnnotation).filter(function (sAnnotationName) {
+              return mCommonAnnotation[sAnnotationName].$Type === "com.sap.vocabularies.Common.v1.SideEffectsType";
+            }).forEach(function (sAnnotationName) {
+              aSideEffects.push(_this4._convertSideEffects(mCommonAnnotation[sAnnotationName], mEntityType.fullyQualifiedName, sBindingParameter));
+            });
+          }
+        }
+
+        return aSideEffects;
+      }
+      /**
+       * Logs SideEffects request.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {Array} aPathExpressions SideEffects targets
+       * @param {object} oContext Context
+       */
+
+    }, {
+      key: "_logRequest",
+      value: function _logRequest(aPathExpressions, oContext) {
+        var sTargetPaths = aPathExpressions.reduce(function (sPaths, mTarget) {
+          return sPaths + "\n\t\t" + (mTarget.$NavigationPropertyPath || mTarget || "");
+        }, "");
+        Log.debug("SideEffects - Request:\n\tContext path : " + oContext.getPath() + "\n\tProperty paths :" + sTargetPaths);
+      }
+      /**
+       * Removes name of binding parameter on SideEffects targets.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {object} oSideEffects SideEffects definition
+       * @param {string} sBindingParameterName Name of binding parameter
+       * @returns {object} SideEffects definition
+       */
+
+    }, {
+      key: "_removeBindingParameter",
+      value: function _removeBindingParameter(oSideEffects, sBindingParameterName) {
+        if (sBindingParameterName) {
+          var aTargets = ["TargetProperties", "TargetEntities"];
+          aTargets.forEach(function (sTarget) {
+            var mTarget = oSideEffects[sTarget];
+
+            if (mTarget) {
+              mTarget = mTarget.map(function (mProperty) {
+                var bNavigationPropertyPath = mProperty.$NavigationPropertyPath !== undefined; // Need to test with undefined since  mProperty.$NavigationPropertyPath could be "" (empty string)
+
+                var sValue = (bNavigationPropertyPath ? mProperty.$NavigationPropertyPath : mProperty).replace(new RegExp("^" + sBindingParameterName + "?."), "");
+                return bNavigationPropertyPath ? {
+                  $NavigationPropertyPath: sValue
+                } : sValue;
+              });
+            }
+
+            oSideEffects[sTarget] = mTarget;
+          });
+        }
+
+        return oSideEffects;
+      }
+      /**
+       * Remove duplicates in SideEffects targets.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {Array} aTargets SideEffects targets
+       * @returns {Array} SideEffects targets without duplicates
+       */
+
+    }, {
+      key: "_removeDuplicateTargets",
+      value: function _removeDuplicateTargets(aTargets) {
+        return aTargets.filter(function (mTarget, iIndex, aTargets) {
+          return aTargets.findIndex(function (mSearchTarget) {
+            return mSearchTarget === mTarget || mTarget.$NavigationPropertyPath && mSearchTarget.$NavigationPropertyPath === mTarget.$NavigationPropertyPath // NavigationPropertyPath
+            ;
+          }) === iIndex;
+        });
+      }
+      /**
+       * Replaces TargetProperties having reference to Source Properties for a SideEffects
+       * If a SideEffects Source Property is an navigation entity reference, the SideEffects Target Properties cannot be a property of this navigation entity.
+       * Indeed this configuration leads to error into the OData V4 Model since response cannot be processed because this would mean that we merge properties of the new target into the old target of the navigation property.
+       * In order to request new value of these target properties the SideEffects will request for the entire Entity instead of just a set of properties.
+       * For the first version, we remove all navigation properties and replace them by targetEntities. This change could be improved in next version.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {object} oSideEffect SideEffects definition
+       * @param {object} mEntityType  Entity type
+       * @returns {object} SideEffects definition without referenced target properties
+       */
+
+    }, {
+      key: "_replaceReferencedProperties",
+      value: function _replaceReferencedProperties(oSideEffect, mEntityType) {
+        var bSideEffectsChanged = false;
+        var aEntities = (oSideEffect.TargetEntities || []).map(function (mNavigation) {
+          return mNavigation.$NavigationPropertyPath;
+        }) || [],
+            aProperties = [];
+        oSideEffect.TargetProperties.forEach(function (sPropertyPath) {
+          var bTargetChanged = false;
+          var iLastPathSeparatorIndex = sPropertyPath.lastIndexOf("/");
+
+          if (iLastPathSeparatorIndex !== -1) {
+            var sNavigationPath = sPropertyPath.substring(0, iLastPathSeparatorIndex);
+            var oTarget = mEntityType.resolvePath(sNavigationPath);
+
+            if (oTarget && oTarget._type === "NavigationProperty") {
+              //Test if it's not a property bound on complexType (_ComplexType/MyProperty)
+              bSideEffectsChanged = true;
+              bTargetChanged = true;
+
+              if (!aEntities.includes(sNavigationPath)) {
+                aEntities.push(sNavigationPath);
+              }
+            }
+          }
+
+          if (!bTargetChanged) {
+            aProperties.push(sPropertyPath);
+          }
+        });
+
+        if (bSideEffectsChanged) {
+          oSideEffect.TargetProperties = aProperties;
+          oSideEffect.TargetEntities = aEntities.map(function (sNavigationPath) {
+            return {
+              $NavigationPropertyPath: sNavigationPath
+            };
+          });
+        }
+
+        return oSideEffect;
+      }
+      /**
+       * Gets SideEffects action type that come from an OData Service
+       * Internal routine to get, from converted oData metaModel, SideEffects on actions
+       * related to a specific entity type and to convert these SideEffects with
+       * expected format.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {object} mEntityType Entity type
+       * @returns {object} Entity type SideEffects dictionary
+       */
+
+    }, {
+      key: "_retrieveODataActionsSideEffects",
+      value: function _retrieveODataActionsSideEffects(mEntityType) {
+        var _this5 = this;
+
+        var oSideEffects = {};
+        var aActions = mEntityType.actions;
+
+        if (aActions) {
+          Object.keys(aActions).forEach(function (sActionName) {
+            var oAction = mEntityType.actions[sActionName];
+            var triggerActions = [];
+            var pathExpressions = [];
+            var aTargets = [];
+
+            _this5._getSideEffectsFromSource(oAction).forEach(function (oSideEffect) {
+              var sTriggerAction = oSideEffect.TriggerAction;
+              aTargets = aTargets.concat(oSideEffect.TargetEntities || []).concat(oSideEffect.TargetProperties || []);
+
+              if (sTriggerAction && triggerActions.indexOf(sTriggerAction) === -1) {
+                triggerActions.push(sTriggerAction);
+              }
+            });
+
+            pathExpressions = _this5._removeDuplicateTargets(aTargets);
+            oSideEffects[sActionName] = {
+              pathExpressions: pathExpressions,
+              triggerActions: triggerActions
+            };
+          });
+        }
+
+        return oSideEffects;
+      }
+      /**
+       * Gets SideEffects entity type that come from an OData Service
+       * Internal routine to get, from converted oData metaModel, SideEffects
+       * related to a specific entity type and to convert these SideEffects with
+       * expected format.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {object} mEntityType Entity type
+       * @returns {object} Entity type SideEffects dictionary
+       */
+
+    }, {
+      key: "_retrieveODataEntitySideEffects",
+      value: function _retrieveODataEntitySideEffects(mEntityType) {
+        var oEntitySideEffects = {};
+
+        this._getSideEffectsFromSource(mEntityType).forEach(function (oSideEffects) {
+          oEntitySideEffects[oSideEffects.fullyQualifiedName] = oSideEffects;
+        });
+
+        return oEntitySideEffects;
+      }
+    }, {
+      key: "getInterface",
+      value: function getInterface() {
+        return this;
+      }
+    }]);
+
+    return SideEffectsService;
+  }(Service);
+
+  var SideEffectsServiceFactory = /*#__PURE__*/function (_ServiceFactory) {
+    _inherits(SideEffectsServiceFactory, _ServiceFactory);
+
+    var _super2 = _createSuper(SideEffectsServiceFactory);
+
+    function SideEffectsServiceFactory() {
+      _classCallCheck(this, SideEffectsServiceFactory);
+
+      return _super2.apply(this, arguments);
+    }
+
+    _createClass(SideEffectsServiceFactory, [{
+      key: "createInstance",
+      value: function createInstance(oServiceContext) {
+        var SideEffectsServiceService = new SideEffectsService(oServiceContext);
+        return SideEffectsServiceService.initPromise;
+      }
+    }]);
+
+    return SideEffectsServiceFactory;
+  }(ServiceFactory);
+
+  return SideEffectsServiceFactory;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["SideEffectsServiceFactory.ts"],"names":["SideEffectsService","_oSideEffectsType","oData","entities","actions","control","_bInitialized","initPromise","Promise","resolve","sEntityType","oSideEffect","sourceControlId","oControlSideEffect","fullyQualifiedName","mEntityControlSideEffects","sTriggerAction","oContext","sGroupId","oTriggerAction","getModel","bindContext","execute","getBinding","getUpdateGroupId","getContext","oComponent","scopeObject","oMetaModel","getMetaModel","convertTypes","_oCapabilities","sMetaPath","getMetaPath","getPath","getObject","sEntityTypeName","sActionName","getEntityTypeFromContext","undefined","oCapabilities","oConvertedMetaModel","getConvertedMetaModel","entityTypes","forEach","entityType","_retrieveODataEntitySideEffects","_retrieveODataActionsSideEffects","sControlId","Object","keys","aPathExpressions","_logRequest","oPromise","requestSideEffects","e","reject","sNavigationProperty","sBaseEntityType","aSideEffects","getODataEntitySideEffects","aTargets","filter","sAnnotationName","oSideEffects","SourceProperties","some","oPropertyPath","value","indexOf","SourceEntities","oNavigationPropertyPath","TriggerAction","executeAction","TargetEntities","concat","TargetProperties","mTarget","push","_removeDuplicateTargets","length","catch","oError","Log","error","mEntityType","aInitialProperties","aEntitiesRequested","map","navigation","$NavigationPropertyPath","aDerivedProperties","sPropertyPath","bIsStarProperty","endsWith","sNavigationPropertyPath","substring","lastIndexOf","sRelativePath","resolvePath","aTargetEntityProperties","entityProperties","targetType","properties","mProperty","navigationPath","property","find","name","split","pop","info","mPropertyInfo","sTargetTextPath","annotations","Common","Text","path","sTextPathFromInitialEntity","sBindingParameter","oEntityType","oTempSideEffects","_removeBindingParameter","_convertTargetsFormat","_replaceReferencedProperties","_addRequiredTextProperties","reduce","aTargetProperties","vTarget","sTarget","type","mTargetEntity","oSource","authorizedTypes","_type","sourceEntityType","mCommonAnnotation","mBindingParameter","parameters","mParameter","$Type","_convertSideEffects","sTargetPaths","sPaths","debug","sBindingParameterName","bNavigationPropertyPath","sValue","replace","RegExp","iIndex","findIndex","mSearchTarget","bSideEffectsChanged","aEntities","mNavigation","aProperties","bTargetChanged","iLastPathSeparatorIndex","sNavigationPath","oTarget","includes","aActions","oAction","triggerActions","pathExpressions","_getSideEffectsFromSource","oEntitySideEffects","Service","SideEffectsServiceFactory","oServiceContext","SideEffectsServiceService","ServiceFactory"],"mappings":"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","sourceRoot":".","sourcesContent":["import { ServiceFactory, Service, ServiceContext } from \"sap/ui/core/service\";\nimport { ConverterOutput, EntityType, NavigationProperty, Property } from \"@sap-ux/annotation-converter\";\nimport { Context, ODataMetaModel } from \"sap/ui/model/odata/v4\";\nimport { convertTypes, EnvironmentCapabilities } from \"sap/fe/core/converters/MetaModelConverter\";\nimport { CommonAnnotationTypes, QualifiedName } from \"@sap-ux/vocabularies-types/dist/generated/Common\";\nimport { Action, NavigationPropertyPath, PropertyPath } from \"@sap-ux/vocabularies-types\";\nimport { Log } from \"sap/base\";\n\ntype SideEffectsSettings = {};\n\ntype SideEffectsTargetEntityType = {\n\t$NavigationPropertyPath: string;\n};\ntype SideEffectsTarget = SideEffectsTargetEntityType | string;\n\ntype SideEffectsTargetType = {\n\tTargetProperties: string[];\n\tTargetEntities: SideEffectsTargetEntityType[];\n};\n\ntype BaseAnnotationSideEffectsType = {\n\tTargetProperties: string[];\n\tTargetEntities: NavigationPropertyPath[];\n\tfullyQualifiedName: string;\n};\n\ntype BaseSideEffectsType = {\n\tfullyQualifiedName: string;\n} & SideEffectsTargetType;\n\ntype ActionSideEffectsType = {\n\tpathExpressions: SideEffectsTarget[];\n\ttriggerActions?: QualifiedName[];\n};\n\nexport type ControlSideEffectsType = Partial<BaseSideEffectsType> & {\n\tfullyQualifiedName: string;\n\tSourceProperties: string[];\n\tsourceControlId: string;\n};\n\nexport type ODataSideEffectsType = BaseSideEffectsType & {\n\tSourceProperties?: PropertyPath[];\n\tSourceEntities?: NavigationPropertyPath[];\n\tTriggerAction?: QualifiedName;\n};\n\nexport type SideEffectsType = ControlSideEffectsType | ODataSideEffectsType;\n\nexport type ODataSideEffectsEntityDictionary = Record<string, ODataSideEffectsType>;\nexport type ODataSideEffectsActionDictionary = Record<string, ActionSideEffectsType>;\nexport type ControlSideEffectsEntityDictionary = Record<string, ControlSideEffectsType>;\n\ntype SideEffectsOriginRegistry = {\n\toData: {\n\t\tentities: {\n\t\t\t[entity: string]: Record<string, ODataSideEffectsType>;\n\t\t};\n\t\tactions: {\n\t\t\t[entity: string]: Record<string, ActionSideEffectsType>;\n\t\t};\n\t};\n\tcontrol: {\n\t\t[entity: string]: Record<string, ControlSideEffectsType>;\n\t};\n};\n\ntype ExtractorPropertyInfo = {\n\tproperty: Property;\n\tnavigationPath?: string;\n};\n\nclass SideEffectsService extends Service<SideEffectsSettings> {\n\tinitPromise!: Promise<any>;\n\t_oSideEffectsType!: SideEffectsOriginRegistry;\n\t_oCapabilities!: EnvironmentCapabilities | undefined;\n\t_bInitialized!: Boolean;\n\t// !: means that we know it will be assigned before usage\n\tinit() {\n\t\tthis._oSideEffectsType = {\n\t\t\toData: {\n\t\t\t\tentities: {},\n\t\t\t\tactions: {}\n\t\t\t},\n\t\t\tcontrol: {}\n\t\t};\n\t\tthis._bInitialized = false;\n\t\tthis.initPromise = Promise.resolve(this);\n\t}\n\n\t/**\n\t * Adds a SideEffects control\n\t * SideEffects definition is added by a control to keep data up to date\n\t * These SideEffects get limited scope compared with SideEffects coming from an OData service:\n\t * - Only one SideEffects definition can be defined for the combination entity type - control Id\n\t * - Only SideEffects source properties are recognized and used to trigger SideEffects\n\t *\n\t * Ensure the sourceControlId matches the associated SAPUI5 control ID.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {string} sEntityType Name of the entity type\n\t * @param {object} oSideEffect SideEffects definition\n\t */\n\tpublic addControlSideEffects(sEntityType: string, oSideEffect: Omit<ControlSideEffectsType, \"fullyQualifiedName\">): void {\n\t\tif (oSideEffect.sourceControlId) {\n\t\t\tconst oControlSideEffect: ControlSideEffectsType = {\n\t\t\t\t...oSideEffect,\n\t\t\t\tfullyQualifiedName: sEntityType + \"/SideEffectsForControl/\" + oSideEffect.sourceControlId\n\t\t\t};\n\t\t\tconst mEntityControlSideEffects = this._oSideEffectsType.control[sEntityType] || {};\n\t\t\tmEntityControlSideEffects[oControlSideEffect.sourceControlId] = oControlSideEffect;\n\t\t\tthis._oSideEffectsType.control[sEntityType] = mEntityControlSideEffects;\n\t\t}\n\t}\n\n\t/**\n\t * Executes SideEffects action.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {string} sTriggerAction Name of the action\n\t * @param {object} oContext Context\n\t * @param {string} sGroupId The group ID to be used for the request\n\t */\n\tpublic executeAction(sTriggerAction: String, oContext: Context, sGroupId?: string) {\n\t\tconst oTriggerAction: any = oContext.getModel().bindContext(sTriggerAction + \"(...)\", oContext);\n\t\toTriggerAction.execute(sGroupId || (oContext as any).getBinding().getUpdateGroupId());\n\t}\n\n\t/**\n\t * Gets converted OData metaModel.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @returns {object} Converted OData metaModel\n\t */\n\tpublic getConvertedMetaModel(): ConverterOutput {\n\t\tconst oContext = this.getContext();\n\t\tconst oComponent = oContext.scopeObject as any;\n\t\tconst oMetaModel: ODataMetaModel = oComponent.getModel().getMetaModel();\n\t\treturn convertTypes(oMetaModel, this._oCapabilities);\n\t}\n\n\t/**\n\t * Gets the entity type of a context.\n\t *\n\t * @function\n\t * @name getEntityTypeFromContext\n\t * @param {object} oContext Context\n\t * @returns {string | undefined } Entity Type\n\t */\n\tpublic getEntityTypeFromContext(oContext: Context): string | undefined {\n\t\tconst oMetaModel = oContext.getModel().getMetaModel(),\n\t\t\tsMetaPath = (oMetaModel as any).getMetaPath(oContext.getPath()),\n\t\t\tsEntityType = oMetaModel.getObject(sMetaPath)[\"$Type\"];\n\t\treturn sEntityType;\n\t}\n\n\t/**\n\t * Gets the SideEffects that come from an OData service.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {string} sEntityTypeName Name of the entity type\n\t * @returns {object} SideEffects dictionary\n\t */\n\tpublic getODataEntitySideEffects(sEntityTypeName: string): Record<string, ODataSideEffectsType> {\n\t\treturn this._oSideEffectsType.oData.entities[sEntityTypeName] || {};\n\t}\n\n\t/**\n\t * Gets the SideEffects that come from an OData service.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {string} sActionName Name of the action\n\t * @param {object} oContext Context\n\t * @returns {object} SideEffects definition\n\t */\n\tpublic getODataActionSideEffects(sActionName: string, oContext?: Context): ActionSideEffectsType | undefined {\n\t\tif (oContext) {\n\t\t\tconst sEntityType = this.getEntityTypeFromContext(oContext);\n\t\t\tif (sEntityType) {\n\t\t\t\treturn this._oSideEffectsType.oData.actions[sEntityType]?.[sActionName];\n\t\t\t}\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Generates the dictionary for the SideEffects.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param oCapabilities The current capabilities\n\t */\n\tpublic initializeSideEffects(oCapabilities?: EnvironmentCapabilities): void {\n\t\tthis._oCapabilities = oCapabilities;\n\t\tif (!this._bInitialized) {\n\t\t\tconst oConvertedMetaModel = this.getConvertedMetaModel();\n\t\t\toConvertedMetaModel.entityTypes.forEach(entityType => {\n\t\t\t\tthis._oSideEffectsType.oData.entities[entityType.fullyQualifiedName] = this._retrieveODataEntitySideEffects(entityType);\n\t\t\t\tthis._oSideEffectsType.oData.actions[entityType.fullyQualifiedName] = this._retrieveODataActionsSideEffects(entityType); // only bound actions are analyzed since unbound ones don't get SideEffects\n\t\t\t});\n\t\t\tthis._bInitialized = true;\n\t\t}\n\t}\n\n\t/**\n\t * Removes all SideEffects related to a control.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {string} sControlId Control Id\n\t */\n\tpublic removeControlSideEffects(sControlId: string): void {\n\t\tObject.keys(this._oSideEffectsType.control).forEach(sEntityType => {\n\t\t\tif (this._oSideEffectsType.control[sEntityType][sControlId]) {\n\t\t\t\tdelete this._oSideEffectsType.control[sEntityType][sControlId];\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * Request SideEffects on a specific context.\n\t *\n\t * @function\n\t * @name requestSideEffects\n\t * @param {Array} aPathExpressions Targets of SideEffects to be executed\n\t * @param {object} oContext Context where SideEffects need to be executed\n\t * @param {string} sGroupId The group ID to be used for the request\n\t * @returns {Promise} Promise on SideEffects request\n\t */\n\tpublic requestSideEffects(aPathExpressions: SideEffectsTarget[], oContext: Context, sGroupId?: string): Promise<any> {\n\t\tthis._logRequest(aPathExpressions, oContext);\n\t\tlet oPromise: Promise<any>;\n\t\t/**\n\t\t * Context.requestSideEffects either returns a promise or throws a new error. This return is caught if an error is thrown\n\t\t * to avoid breaking the promise chain.\n\t\t */\n\t\ttry {\n\t\t\toPromise = (oContext as any).requestSideEffects(aPathExpressions, sGroupId) as Promise<any>;\n\t\t} catch (e) {\n\t\t\toPromise = Promise.reject(e);\n\t\t}\n\t\treturn oPromise;\n\t}\n\n\t/**\n\t * Request SideEffects for a navigation property on a specific context.\n\t *\n\t * @function\n\t * @name requestSideEffectsForNavigationProperty\n\t * @param {string} sNavigationProperty Navigation property\n\t * @param {object} oContext Context where SideEffects need to be executed\n\t * @returns {object} SideEffects request on SAPUI5 context\n\t */\n\tpublic requestSideEffectsForNavigationProperty(sNavigationProperty: string, oContext: Context): Promise<any> {\n\t\tconst sBaseEntityType = this.getEntityTypeFromContext(oContext);\n\t\tif (sBaseEntityType) {\n\t\t\tconst aSideEffects = this.getODataEntitySideEffects(sBaseEntityType);\n\t\t\tlet aTargets: SideEffectsTarget[] = [];\n\t\t\tObject.keys(aSideEffects)\n\t\t\t\t.filter(\n\t\t\t\t\t// Keep relevant SideEffects\n\t\t\t\t\tsAnnotationName => {\n\t\t\t\t\t\tconst oSideEffects: ODataSideEffectsType = aSideEffects[sAnnotationName];\n\t\t\t\t\t\treturn (\n\t\t\t\t\t\t\t(oSideEffects.SourceProperties || []).some(\n\t\t\t\t\t\t\t\toPropertyPath => oPropertyPath.value.indexOf(sNavigationProperty) > -1\n\t\t\t\t\t\t\t) ||\n\t\t\t\t\t\t\t(oSideEffects.SourceEntities || []).some(\n\t\t\t\t\t\t\t\toNavigationPropertyPath => oNavigationPropertyPath.value === sNavigationProperty\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t)\n\t\t\t\t.forEach(sAnnotationName => {\n\t\t\t\t\tconst oSideEffects: ODataSideEffectsType = aSideEffects[sAnnotationName];\n\t\t\t\t\tif (oSideEffects.TriggerAction) {\n\t\t\t\t\t\tthis.executeAction(oSideEffects.TriggerAction, oContext);\n\t\t\t\t\t}\n\t\t\t\t\t((oSideEffects.TargetEntities as any[]) || [])\n\t\t\t\t\t\t.concat((oSideEffects.TargetProperties as any[]) || [])\n\t\t\t\t\t\t.forEach(mTarget => aTargets.push(mTarget));\n\t\t\t\t});\n\t\t\t// Remove duplicate properties\n\t\t\taTargets = this._removeDuplicateTargets(aTargets);\n\t\t\tif (aTargets.length > 0) {\n\t\t\t\treturn this.requestSideEffects(aTargets, oContext).catch(oError =>\n\t\t\t\t\tLog.error(\"SideEffects - Error while processing SideEffects for Navigation Property \" + sNavigationProperty, oError)\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t\treturn Promise.resolve();\n\t}\n\n\t/**\n\t * Gets the SideEffects that come from controls.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {string} sEntityTypeName Entity type Name\n\t * @returns {object} SideEffects dictionary\n\t */\n\tpublic getControlEntitySideEffects(sEntityTypeName: string): Record<string, ControlSideEffectsType> {\n\t\treturn this._oSideEffectsType.control[sEntityTypeName] || {};\n\t}\n\n\t/**\n\t * Adds the text properties required for SideEffects\n\t * If a property has an associated text then this text needs to be added as targetProperties.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {object} oSideEffect SideEffects definition\n\t * @param {object} mEntityType Entity type\n\t * @returns {object} SideEffects definition with added text properties\n\t */\n\tprivate _addRequiredTextProperties(oSideEffect: BaseSideEffectsType, mEntityType: EntityType): BaseSideEffectsType {\n\t\tconst aInitialProperties: string[] = (oSideEffect.TargetProperties || []) as string[],\n\t\t\taEntitiesRequested: string[] = (oSideEffect.TargetEntities || []).map(navigation => navigation.$NavigationPropertyPath);\n\t\tlet aDerivedProperties: ExtractorPropertyInfo[] = [];\n\n\t\taInitialProperties.forEach(sPropertyPath => {\n\t\t\tconst bIsStarProperty = sPropertyPath.endsWith(\"*\"), // Can be '*' or '.../navProp/*'\n\t\t\t\tsNavigationPropertyPath: string = sPropertyPath.substring(0, sPropertyPath.lastIndexOf(\"/\")),\n\t\t\t\tsRelativePath = sNavigationPropertyPath ? sNavigationPropertyPath + \"/\" : \"\",\n\t\t\t\tmTarget: any = mEntityType.resolvePath(sNavigationPropertyPath) || mEntityType;\n\n\t\t\tif (mTarget) {\n\t\t\t\t// mTarget can be an entity type, navigationProperty or or a complexType\n\t\t\t\tconst aTargetEntityProperties: Property[] =\n\t\t\t\t\t(mTarget as EntityType).entityProperties ||\n\t\t\t\t\t(mTarget as Property).targetType?.properties ||\n\t\t\t\t\t(mTarget as NavigationProperty).targetType.entityProperties;\n\t\t\t\tif (aTargetEntityProperties) {\n\t\t\t\t\tif (bIsStarProperty) {\n\t\t\t\t\t\tif (aTargetEntityProperties) {\n\t\t\t\t\t\t\t// Add all required properties behind the *\n\t\t\t\t\t\t\taEntitiesRequested.push(sNavigationPropertyPath);\n\t\t\t\t\t\t\taDerivedProperties = aDerivedProperties.concat(\n\t\t\t\t\t\t\t\taTargetEntityProperties.map(mProperty => {\n\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\tnavigationPath: sRelativePath,\n\t\t\t\t\t\t\t\t\t\tproperty: mProperty\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\taDerivedProperties.push({\n\t\t\t\t\t\t\tproperty: aTargetEntityProperties.find(\n\t\t\t\t\t\t\t\tmProperty => mProperty.name === sPropertyPath.split(\"/\").pop()\n\t\t\t\t\t\t\t) as Property,\n\t\t\t\t\t\t\tnavigationPath: sRelativePath\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tLog.info(\"SideEffects - The entity type associated to property path \" + sPropertyPath + \" cannot be resolved\");\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tLog.info(\"SideEffects - The property path \" + sPropertyPath + \" cannot be resolved\");\n\t\t\t}\n\t\t});\n\n\t\taDerivedProperties.forEach(mPropertyInfo => {\n\t\t\tif (mPropertyInfo.property) {\n\t\t\t\tconst sTargetTextPath = (mPropertyInfo.property.annotations?.Common?.Text as any)?.path,\n\t\t\t\t\tsTextPathFromInitialEntity = mPropertyInfo.navigationPath + sTargetTextPath;\n\t\t\t\t/**\n\t\t\t\t * The property Text must be added only if the property is\n\t\t\t\t * - not part of a star property (.i.e '*' or 'navigation/*') or a targeted Entity\n\t\t\t\t * - not include into the initial targeted properties of SideEffects\n\t\t\t\t *  Indeed in the two listed cases, the property containing text will be/is requested by initial SideEffects configuration.\n\t\t\t\t */\n\n\t\t\t\tif (\n\t\t\t\t\tsTargetTextPath &&\n\t\t\t\t\taEntitiesRequested.indexOf(sTextPathFromInitialEntity.substring(0, sTextPathFromInitialEntity.lastIndexOf(\"/\"))) ===\n\t\t\t\t\t\t-1 &&\n\t\t\t\t\taInitialProperties.indexOf(sTextPathFromInitialEntity) === -1\n\t\t\t\t) {\n\t\t\t\t\toSideEffect.TargetProperties.push(sTextPathFromInitialEntity);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\n\t\treturn oSideEffect;\n\t}\n\t/**\n\t * Converts SideEffects to expected format\n\t *  - Converts SideEffects targets to expected format\n\t *  - Removes binding parameter from SideEffects targets properties\n\t *  - Adds the text properties\n\t *  - Replaces TargetProperties having reference to Source Properties for a SideEffects.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {object} oSideEffects SideEffects definition\n\t * @param {string} sEntityType Name of the entity type\n\t * @param {string} sBindingParameter Name of the binding parameter\n\t * @returns {object} SideEffects definition\n\t */\n\tprivate _convertSideEffects(\n\t\toSideEffects: BaseSideEffectsType | BaseAnnotationSideEffectsType,\n\t\tsEntityType: string | undefined,\n\t\tsBindingParameter?: string\n\t): ODataSideEffectsType {\n\t\tconst mEntityType = (this.getConvertedMetaModel() as ConverterOutput).entityTypes.find(oEntityType => {\n\t\t\treturn oEntityType.fullyQualifiedName === sEntityType;\n\t\t});\n\t\tconst oTempSideEffects = this._removeBindingParameter(this._convertTargetsFormat(oSideEffects), sBindingParameter);\n\t\treturn mEntityType\n\t\t\t? this._replaceReferencedProperties(this._addRequiredTextProperties(oTempSideEffects, mEntityType), mEntityType)\n\t\t\t: oTempSideEffects;\n\t}\n\n\t/**\n\t * Converts SideEffects targets (TargetEntities and TargetProperties) to expected format\n\t *  - TargetProperties as array of string\n\t *  - TargetEntities as array of object with property $NavigationPropertyPath.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {object} oSideEffects SideEffects definition\n\t * @returns {object} Converted SideEffects\n\t */\n\tprivate _convertTargetsFormat(oSideEffects: BaseSideEffectsType | BaseAnnotationSideEffectsType): BaseSideEffectsType {\n\t\tconst TargetProperties: string[] = ((oSideEffects.TargetProperties as any[]) || []).reduce(function(aTargetProperties, vTarget) {\n\t\t\t\tconst sTarget = (typeof vTarget === \"string\" && vTarget) || (vTarget.type === \"PropertyPath\" && vTarget.value);\n\t\t\t\tif (sTarget) {\n\t\t\t\t\taTargetProperties.push(sTarget);\n\t\t\t\t} else {\n\t\t\t\t\tLog.error(\"SideEffects - Error while processing TargetProperties for SideEffects\" + oSideEffects.fullyQualifiedName);\n\t\t\t\t}\n\t\t\t\treturn aTargetProperties;\n\t\t\t}, []),\n\t\t\tTargetEntities: SideEffectsTargetEntityType[] = ((oSideEffects.TargetEntities as any[]) || []).map(mTargetEntity => {\n\t\t\t\t/**\n\t\t\t\t *  SideEffects that comes from SAP FE get TargetEntities with $NavigationPropertyPath whereas\n\t\t\t\t *  ones coming from the converted OData model gets a NavigationPropertyPath format\n\t\t\t\t *\n\t\t\t\t */\n\t\t\t\treturn { \"$NavigationPropertyPath\": mTargetEntity.$NavigationPropertyPath || mTargetEntity.value || \"\" };\n\t\t\t});\n\t\treturn { ...oSideEffects, ...{ TargetProperties, TargetEntities } };\n\t}\n\n\t/**\n\t * Gets SideEffects related to an entity type or action that come from an OData Service\n\t * Internal routine to get, from converted oData metaModel, SideEffects related to a specific entity type or action\n\t * and to convert these SideEffects with expected format.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {object} oSource Entity type or action\n\t * @returns {object} Array of SideEffects\n\t */\n\tprivate _getSideEffectsFromSource(oSource: any): ODataSideEffectsType[] {\n\t\tconst aSideEffects: ODataSideEffectsType[] = [];\n\t\tconst authorizedTypes = [\"EntityType\", \"Action\"];\n\t\tif (oSource._type && authorizedTypes.indexOf(oSource._type) > -1) {\n\t\t\tconst mEntityType: EntityType | undefined = oSource._type === \"EntityType\" ? oSource : oSource.sourceEntityType;\n\t\t\tif (mEntityType) {\n\t\t\t\tconst mCommonAnnotation: any = oSource.annotations?.Common || {};\n\t\t\t\tconst mBindingParameter = ((oSource as Action).parameters || []).find(\n\t\t\t\t\tmParameter => mParameter.type === (mEntityType || oSource).fullyQualifiedName\n\t\t\t\t);\n\t\t\t\tconst sBindingParameter = mBindingParameter ? mBindingParameter.fullyQualifiedName.split(\"/\")[1] : \"\";\n\t\t\t\tObject.keys(mCommonAnnotation)\n\t\t\t\t\t.filter(sAnnotationName => mCommonAnnotation[sAnnotationName].$Type === CommonAnnotationTypes.SideEffectsType)\n\t\t\t\t\t.forEach(sAnnotationName => {\n\t\t\t\t\t\taSideEffects.push(\n\t\t\t\t\t\t\tthis._convertSideEffects(mCommonAnnotation[sAnnotationName], mEntityType.fullyQualifiedName, sBindingParameter)\n\t\t\t\t\t\t);\n\t\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn aSideEffects;\n\t}\n\n\t/**\n\t * Logs SideEffects request.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {Array} aPathExpressions SideEffects targets\n\t * @param {object} oContext Context\n\t */\n\tprivate _logRequest(aPathExpressions: SideEffectsTarget[], oContext: Context) {\n\t\tconst sTargetPaths = aPathExpressions.reduce(function(sPaths, mTarget) {\n\t\t\treturn sPaths + \"\\n\\t\\t\" + ((mTarget as SideEffectsTargetEntityType).$NavigationPropertyPath || mTarget || \"\");\n\t\t}, \"\");\n\t\tLog.debug(\"SideEffects - Request:\\n\\tContext path : \" + oContext.getPath() + \"\\n\\tProperty paths :\" + sTargetPaths);\n\t}\n\n\t/**\n\t * Removes name of binding parameter on SideEffects targets.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {object} oSideEffects SideEffects definition\n\t * @param {string} sBindingParameterName Name of binding parameter\n\t * @returns {object} SideEffects definition\n\t */\n\tprivate _removeBindingParameter(oSideEffects: BaseSideEffectsType, sBindingParameterName?: string): BaseSideEffectsType {\n\t\tif (sBindingParameterName) {\n\t\t\tconst aTargets = [\"TargetProperties\", \"TargetEntities\"];\n\t\t\taTargets.forEach(sTarget => {\n\t\t\t\tlet mTarget = (oSideEffects as any)[sTarget];\n\t\t\t\tif (mTarget) {\n\t\t\t\t\tmTarget = mTarget.map((mProperty: any) => {\n\t\t\t\t\t\tconst bNavigationPropertyPath = mProperty.$NavigationPropertyPath !== undefined; // Need to test with undefined since  mProperty.$NavigationPropertyPath could be \"\" (empty string)\n\t\t\t\t\t\tconst sValue = (bNavigationPropertyPath ? mProperty.$NavigationPropertyPath : mProperty).replace(\n\t\t\t\t\t\t\tnew RegExp(\"^\" + sBindingParameterName + \"?.\"),\n\t\t\t\t\t\t\t\"\"\n\t\t\t\t\t\t);\n\t\t\t\t\t\treturn bNavigationPropertyPath ? { $NavigationPropertyPath: sValue } : sValue;\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\t(oSideEffects as any)[sTarget] = mTarget;\n\t\t\t});\n\t\t}\n\t\treturn oSideEffects;\n\t}\n\n\t/**\n\t * Remove duplicates in SideEffects targets.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {Array} aTargets SideEffects targets\n\t * @returns {Array} SideEffects targets without duplicates\n\t */\n\tprivate _removeDuplicateTargets(aTargets: SideEffectsTarget[]): SideEffectsTarget[] {\n\t\treturn aTargets.filter(\n\t\t\t(mTarget: any, iIndex, aTargets) =>\n\t\t\t\taTargets.findIndex((mSearchTarget: any) => {\n\t\t\t\t\treturn (\n\t\t\t\t\t\tmSearchTarget === mTarget || // PropertyPath\n\t\t\t\t\t\t(mTarget.$NavigationPropertyPath && mSearchTarget.$NavigationPropertyPath === mTarget.$NavigationPropertyPath) // NavigationPropertyPath\n\t\t\t\t\t);\n\t\t\t\t}) === iIndex\n\t\t);\n\t}\n\n\t/**\n\t * Replaces TargetProperties having reference to Source Properties for a SideEffects\n\t * If a SideEffects Source Property is an navigation entity reference, the SideEffects Target Properties cannot be a property of this navigation entity.\n\t * Indeed this configuration leads to error into the OData V4 Model since response cannot be processed because this would mean that we merge properties of the new target into the old target of the navigation property.\n\t * In order to request new value of these target properties the SideEffects will request for the entire Entity instead of just a set of properties.\n\t * For the first version, we remove all navigation properties and replace them by targetEntities. This change could be improved in next version.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {object} oSideEffect SideEffects definition\n\t * @param {object} mEntityType  Entity type\n\t * @returns {object} SideEffects definition without referenced target properties\n\t */\n\tprivate _replaceReferencedProperties(oSideEffect: BaseSideEffectsType, mEntityType: EntityType): BaseSideEffectsType {\n\t\tlet bSideEffectsChanged: boolean = false;\n\t\tconst aEntities: string[] =\n\t\t\t\t(oSideEffect.TargetEntities || []).map(mNavigation => {\n\t\t\t\t\treturn mNavigation.$NavigationPropertyPath;\n\t\t\t\t}) || [],\n\t\t\taProperties: string[] = [];\n\n\t\toSideEffect.TargetProperties.forEach(sPropertyPath => {\n\t\t\tlet bTargetChanged = false;\n\t\t\tconst iLastPathSeparatorIndex = sPropertyPath.lastIndexOf(\"/\");\n\t\t\tif (iLastPathSeparatorIndex !== -1) {\n\t\t\t\tconst sNavigationPath = sPropertyPath.substring(0, iLastPathSeparatorIndex);\n\t\t\t\tconst oTarget = mEntityType.resolvePath(sNavigationPath);\n\t\t\t\tif (oTarget && oTarget._type === \"NavigationProperty\") {\n\t\t\t\t\t//Test if it's not a property bound on complexType (_ComplexType/MyProperty)\n\t\t\t\t\tbSideEffectsChanged = true;\n\t\t\t\t\tbTargetChanged = true;\n\t\t\t\t\tif (!aEntities.includes(sNavigationPath)) {\n\t\t\t\t\t\taEntities.push(sNavigationPath);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!bTargetChanged) {\n\t\t\t\taProperties.push(sPropertyPath);\n\t\t\t}\n\t\t});\n\n\t\tif (bSideEffectsChanged) {\n\t\t\toSideEffect.TargetProperties = aProperties;\n\t\t\toSideEffect.TargetEntities = aEntities.map(sNavigationPath => {\n\t\t\t\treturn {\n\t\t\t\t\t$NavigationPropertyPath: sNavigationPath\n\t\t\t\t};\n\t\t\t});\n\t\t}\n\n\t\treturn oSideEffect;\n\t}\n\n\t/**\n\t * Gets SideEffects action type that come from an OData Service\n\t * Internal routine to get, from converted oData metaModel, SideEffects on actions\n\t * related to a specific entity type and to convert these SideEffects with\n\t * expected format.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {object} mEntityType Entity type\n\t * @returns {object} Entity type SideEffects dictionary\n\t */\n\tprivate _retrieveODataActionsSideEffects(mEntityType: EntityType): Record<string, ActionSideEffectsType> {\n\t\tconst oSideEffects: Record<string, ActionSideEffectsType> = {};\n\t\tconst aActions = mEntityType.actions;\n\t\tif (aActions) {\n\t\t\tObject.keys(aActions).forEach(sActionName => {\n\t\t\t\tconst oAction = mEntityType.actions[sActionName];\n\t\t\t\tconst triggerActions: String[] = [];\n\t\t\t\tlet pathExpressions: SideEffectsTarget[] = [];\n\t\t\t\tlet aTargets: SideEffectsTarget[] = [];\n\n\t\t\t\tthis._getSideEffectsFromSource(oAction).forEach(oSideEffect => {\n\t\t\t\t\tconst sTriggerAction = oSideEffect.TriggerAction;\n\t\t\t\t\taTargets = aTargets.concat(oSideEffect.TargetEntities || []).concat((oSideEffect.TargetProperties as any[]) || []);\n\t\t\t\t\tif (sTriggerAction && triggerActions.indexOf(sTriggerAction) === -1) {\n\t\t\t\t\t\ttriggerActions.push(sTriggerAction);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t\tpathExpressions = this._removeDuplicateTargets(aTargets);\n\t\t\t\toSideEffects[sActionName] = { pathExpressions, triggerActions };\n\t\t\t});\n\t\t}\n\t\treturn oSideEffects;\n\t}\n\n\t/**\n\t * Gets SideEffects entity type that come from an OData Service\n\t * Internal routine to get, from converted oData metaModel, SideEffects\n\t * related to a specific entity type and to convert these SideEffects with\n\t * expected format.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {object} mEntityType Entity type\n\t * @returns {object} Entity type SideEffects dictionary\n\t */\n\tprivate _retrieveODataEntitySideEffects(mEntityType: EntityType): Record<string, ODataSideEffectsType> {\n\t\tconst oEntitySideEffects: Record<string, ODataSideEffectsType> = {};\n\t\tthis._getSideEffectsFromSource(mEntityType).forEach(oSideEffects => {\n\t\t\toEntitySideEffects[oSideEffects.fullyQualifiedName] = oSideEffects;\n\t\t});\n\t\treturn oEntitySideEffects;\n\t}\n\n\tgetInterface(): any {\n\t\treturn this;\n\t}\n}\n\nclass SideEffectsServiceFactory extends ServiceFactory<SideEffectsSettings> {\n\tcreateInstance(oServiceContext: ServiceContext<SideEffectsSettings>) {\n\t\tconst SideEffectsServiceService = new SideEffectsService(oServiceContext);\n\t\treturn SideEffectsServiceService.initPromise;\n\t}\n}\n\nexport default SideEffectsServiceFactory;\n"]}