@sapui5/sap.fe.core 1.97.0 → 1.100.0

package/src/sap/fe/core/helpers/AppStartupHelper.js

@@ -0,0 +1,373 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/ui/model/Filter", "sap/ui/model/FilterOperator", "./ModelHelper"], function (Filter, FilterOperator, ModelHelper) {
+  "use strict";
+
+  var AppStartupHelper = {
+    /**
+     * Retrieves a set of key values from startup parameters.
+     *
+     * @param aKeyNames The array of key names
+     * @param oStartupParameters The startup parameters
+     * @returns {any[]} An array of pairs {name, value} if all key values could be found in the startup parameters, undefined otherwise
+     */
+    _getKeysFromStartupParams: function (aKeyNames, oStartupParameters) {
+      var bAllFound = true;
+      var aKeys = aKeyNames.map(function (name) {
+        if (oStartupParameters[name] && oStartupParameters[name].length === 1) {
+          return {
+            name: name,
+            value: oStartupParameters[name][0]
+          };
+        } else {
+          // A unique key value couldn't be found in the startup parameters
+          bAllFound = false;
+          return {
+            name: name,
+            value: ""
+          };
+        }
+      });
+      return bAllFound ? aKeys : undefined;
+    },
+
+    /**
+     * Creates a filter from a list of key values.
+     *
+     * @param aKeys Array of semantic keys or technical keys (with values)
+     * @param bDraftMode True if the entity supports draft mode
+     * @param oMetaModel The metamodel
+     * @returns The filter
+     */
+    _createFilterFromKeys: function (aKeys, bDraftMode, oMetaModel) {
+      var bFilterCaseSensitive = ModelHelper.isFilteringCaseSensitive(oMetaModel);
+      var bFilterOnActiveEntity = false;
+      var aFilters = aKeys.map(function (key) {
+        if (key.name === "IsActiveEntity") {
+          bFilterOnActiveEntity = true;
+        }
+
+        return new Filter({
+          path: key.name,
+          operator: FilterOperator.EQ,
+          value1: key.value,
+          caseSensitive: bFilterCaseSensitive
+        });
+      });
+
+      if (bDraftMode && !bFilterOnActiveEntity) {
+        var oDraftFilter = new Filter({
+          filters: [new Filter("IsActiveEntity", "EQ", false), new Filter("SiblingEntity/IsActiveEntity", "EQ", null)],
+          and: false
+        });
+        aFilters.push(oDraftFilter);
+      }
+
+      return new Filter(aFilters, true);
+    },
+
+    /**
+     * Loads all contexts for a list of page infos.
+     *
+     * @param aStartupPages The list of page infos
+     * @param oModel The model used to load the contexts
+     * @returns A Promise for all contexts
+     */
+    _requestObjectsFromParameters: function (aStartupPages, oModel) {
+      var _this = this;
+
+      // Load the respective objects for all object pages found in aExternallyNavigablePages
+      var aContextPromises = aStartupPages.map(function (pageInfo) {
+        var aKeys = pageInfo.semanticKeys || pageInfo.technicalKeys || [];
+
+        var oFilter = _this._createFilterFromKeys(aKeys, pageInfo.draftMode, oModel.getMetaModel()); // only request a minimum of fields to boost backend performance since this is only used to check if an object exists
+
+
+        var oListBind = oModel.bindList(pageInfo.contextPath, undefined, undefined, oFilter, {
+          "$select": aKeys.map(function (key) {
+            return key.name;
+          }).join(",")
+        });
+        return oListBind.requestContexts(0, 2);
+      });
+      return Promise.all(aContextPromises);
+    },
+
+    /**
+     * Creates a PageInfo from a route if ti's reachable from the startup parameters.
+     *
+     * @param oRoute The route
+     * @param oManifestRouting The app manifest routing section
+     * @param oStartupParameters The startup parameters
+     * @param oMetaModel The app metamodel
+     * @returns A page info if the page is reachable, undefined otherwise
+     */
+    _getReachablePageInfoFromRoute: function (oRoute, oManifestRouting, oStartupParameters, oMetaModel) {
+      var _oTarget$options, _oTarget$options$sett;
+
+      // Remove trailing ':?query:' and '/'
+      var sPattern = oRoute.pattern.replace(":?query:", "");
+      sPattern = sPattern.replace(/\/$/, "");
+
+      if (!sPattern) {
+        return undefined; // Ignore level-0 routes (ListReport)
+      }
+
+      sPattern = sPattern.replace(/\(\{[^\}]*\}\)/g, "(#)"); // Replace keys with #
+      // Get the rightmost target for this route
+
+      var sTargetName = Array.isArray(oRoute.target) ? oRoute.target[oRoute.target.length - 1] : oRoute.target;
+      var oTarget = oManifestRouting.targets[sTargetName];
+      var aPatternSegments = sPattern.split("/");
+      var pageLevel = aPatternSegments.length - 1;
+
+      if (pageLevel !== 0 && (oTarget === null || oTarget === void 0 ? void 0 : (_oTarget$options = oTarget.options) === null || _oTarget$options === void 0 ? void 0 : (_oTarget$options$sett = _oTarget$options.settings) === null || _oTarget$options$sett === void 0 ? void 0 : _oTarget$options$sett.allowDeepLinking) !== true) {
+        // The first level of object page allows deep linking by default.
+        // Otherwise, the target must allow deep linking explicitely in the manifest
+        return undefined;
+      }
+
+      var sContextPath = oTarget.options.settings.contextPath || oTarget.options.settings.entitySet && "/" + oTarget.options.settings.entitySet;
+      var oEntityType = sContextPath && oMetaModel.getObject("/$EntityContainer" + sContextPath + "/");
+
+      if (!oEntityType) {
+        return undefined;
+      } // Get the semantic key values for the entity
+
+
+      var aSemanticKeyNames = oMetaModel.getObject("/$EntityContainer" + sContextPath + "/@com.sap.vocabularies.Common.v1.SemanticKey");
+      var aSemantickKeys = aSemanticKeyNames ? this._getKeysFromStartupParams(aSemanticKeyNames.map(function (semKey) {
+        return semKey.$PropertyPath;
+      }), oStartupParameters) : undefined; // Get the technical keys only if we couldn't find the semantic key values, and on first level OP
+
+      var aTechnicalKeys = !aSemantickKeys && pageLevel === 0 ? this._getKeysFromStartupParams(oEntityType["$Key"], oStartupParameters) : undefined;
+
+      if (aSemantickKeys === undefined && aTechnicalKeys === undefined) {
+        // We couldn't find the semantic/technical keys in the startup parameters
+        return undefined;
+      } // The startup parameters contain values for all semantic keys (or technical keys) --> we can store the page info in the corresponding level
+
+
+      var draftMode = oMetaModel.getObject("/$EntityContainer" + sContextPath + "@com.sap.vocabularies.Common.v1.DraftRoot") || oMetaModel.getObject("/$EntityContainer" + sContextPath + "@com.sap.vocabularies.Common.v1.DraftNode") ? true : false;
+      return {
+        pattern: sPattern,
+        contextPath: sContextPath,
+        draftMode: draftMode,
+        technicalKeys: aTechnicalKeys,
+        semanticKeys: aSemantickKeys,
+        target: sTargetName,
+        pageLevel: pageLevel
+      };
+    },
+
+    /**
+     * Returns the list of all pages that allow deeplink and that can be reached using the startup parameters.
+     *
+     * @param oManifestRouting The routing information from the app manifest
+     * @param oStartupParameters The startup parameters
+     * @param oMetaModel The metamodel
+     * @returns
+     */
+    _getReachablePages: function (oManifestRouting, oStartupParameters, oMetaModel) {
+      var _this2 = this;
+
+      var aRoutes = oManifestRouting.routes;
+      var mPagesByLevel = {};
+      aRoutes.forEach(function (oRoute) {
+        var oPageInfo = _this2._getReachablePageInfoFromRoute(oRoute, oManifestRouting, oStartupParameters, oMetaModel);
+
+        if (oPageInfo) {
+          if (!mPagesByLevel[oPageInfo.pageLevel]) {
+            mPagesByLevel[oPageInfo.pageLevel] = [];
+          }
+
+          mPagesByLevel[oPageInfo.pageLevel].push(oPageInfo);
+        }
+      }); // A page is reachable only if all its parents are also reachable
+      // So if we couldn't find any pages for a given level, all pages with a higher level won't be reachable anyway
+
+      var aReachablePages = [];
+      var level = 0;
+
+      while (mPagesByLevel[level]) {
+        aReachablePages.push(mPagesByLevel[level]);
+        level++;
+      }
+
+      return aReachablePages;
+    },
+
+    /**
+     * Get the list of startup pages.
+     *
+     * @param oManifestRouting The routing information from the app manifest
+     * @param oStartupParameters The startup parameters
+     * @param oMetaModel The metamodel
+     * @returns An array of startup page infos
+     */
+    _getStartupPagesFromStartupParams: function (oManifestRouting, oStartupParameters, oMetaModel) {
+      // Find all pages that can be reached with the startup parameters
+      var aReachablePages = this._getReachablePages(oManifestRouting, oStartupParameters, oMetaModel);
+
+      if (aReachablePages.length === 0) {
+        return [];
+      } // Find the longest sequence of pages that can be reached (recursively)
+
+
+      var result = [];
+      var current = [];
+
+      function findRecursive(level) {
+        var aCurrentLevelPages = aReachablePages[level];
+        var lastPage = current.length ? current[current.length - 1] : undefined;
+
+        if (aCurrentLevelPages) {
+          aCurrentLevelPages.forEach(function (nextPage) {
+            if (!lastPage || nextPage.pattern.indexOf(lastPage.pattern) === 0) {
+              // We only consider pages that can be reached from the page at the previous level,
+              // --> their pattern must be the pattern of the previous page with another segment appended
+              current.push(nextPage);
+              findRecursive(level + 1);
+              current.pop();
+            }
+          });
+        }
+
+        if (current.length > result.length) {
+          result = current.slice(); // We have found a sequence longer than our previous best --> store it as the new longest
+        }
+      }
+
+      findRecursive(0);
+      return result;
+    },
+
+    /**
+     * Creates the startup object from the list of pages and contexts.
+     *
+     * @param aStartupPages The pages
+     * @param aContexts The contexts
+     * @returns An object containing either a hash or a context to navigate to, or an empty object if no deep link was found
+     */
+    _getDeepLinkObject: function (aStartupPages, aContexts) {
+      if (aContexts.length === 1) {
+        return {
+          context: aContexts[0]
+        };
+      } else if (aContexts.length > 1) {
+        // Navigation to a deeper level --> use the pattern of the deepest object page
+        // and replace the parameters by the ID from the contexts
+        var hash = aStartupPages[aStartupPages.length - 1].pattern;
+        aContexts.forEach(function (oContext) {
+          hash = hash.replace("(#)", "(" + oContext.getPath().split("(")[1]);
+        });
+        return {
+          hash: hash
+        };
+      } else {
+        return {};
+      }
+    },
+
+    /**
+     * Calculates startup parameters for a deeplink case, from startup parameters and routing infoirmation.
+     *
+     * @param oManifestRouting The routing information from the app manifest
+     * @param oStartupParameters The startup parameters
+     * @param oModel The OData model
+     * @returns An object containing either a hash or a context to navigate to, or an empty object if no deep link was found
+     */
+    getDeepLinkStartupHash: function (oManifestRouting, oStartupParameters, oModel) {
+      var _this3 = this;
+
+      var aStartupPages;
+      return oModel.getMetaModel().requestObject("/$EntityContainer/").then(function () {
+        // Check if semantic keys are present in url parameters for every object page at each level
+        aStartupPages = _this3._getStartupPagesFromStartupParams(oManifestRouting, oStartupParameters, oModel.getMetaModel());
+        return _this3._requestObjectsFromParameters(aStartupPages, oModel);
+      }).then(function (aValues) {
+        if (aValues.length) {
+          // Make sure we only get 1 context per promise, and flatten the array
+          var aContexts = [];
+          aValues.forEach(function (aFoundContexts) {
+            if (aFoundContexts.length === 1) {
+              aContexts.push(aFoundContexts[0]);
+            }
+          });
+          return aContexts.length === aValues.length ? _this3._getDeepLinkObject(aStartupPages, aContexts) : {};
+        } else {
+          return {};
+        }
+      });
+    },
+
+    /**
+     * Calculates the new hash based on the startup parameters.
+     *
+     * @param oStartupParameters The startup parameter values (map parameter name -> array of values)
+     * @param sContextPath The context path for the startup of the app (generally the path to the main entity set)
+     * @param oRouter The router instance
+     * @param oMetaModel The meta model
+     * @returns A promise containing the hash to navigate to, or an empty string if there's no need to navigate
+     */
+    getCreateStartupHash: function (oStartupParameters, sContextPath, oRouter, oMetaModel) {
+      var _this4 = this;
+
+      return oMetaModel.requestObject(sContextPath + "@").then(function (oEntitySetAnnotations) {
+        var sMetaPath = "";
+        var bCreatable = true;
+
+        if (oEntitySetAnnotations["@com.sap.vocabularies.Common.v1.DraftRoot"] && oEntitySetAnnotations["@com.sap.vocabularies.Common.v1.DraftRoot"]["NewAction"]) {
+          sMetaPath = sContextPath + "@com.sap.vocabularies.Common.v1.DraftRoot/NewAction@Org.OData.Core.V1.OperationAvailable";
+        } else if (oEntitySetAnnotations["@com.sap.vocabularies.Session.v1.StickySessionSupported"] && oEntitySetAnnotations["@com.sap.vocabularies.Session.v1.StickySessionSupported"]["NewAction"]) {
+          sMetaPath = sContextPath + "@com.sap.vocabularies.Session.v1.StickySessionSupported/NewAction@Org.OData.Core.V1.OperationAvailable";
+        }
+
+        if (sMetaPath) {
+          var bNewActionOperationAvailable = oMetaModel.getObject(sMetaPath);
+
+          if (bNewActionOperationAvailable === false) {
+            bCreatable = false;
+          }
+        } else {
+          var oInsertRestrictions = oEntitySetAnnotations["@Org.OData.Capabilities.V1.InsertRestrictions"];
+
+          if (oInsertRestrictions && oInsertRestrictions.Insertable === false) {
+            bCreatable = false;
+          }
+        }
+
+        if (bCreatable) {
+          return _this4.getDefaultCreateHash(oStartupParameters, sContextPath, oRouter);
+        } else {
+          return "";
+        }
+      });
+    },
+
+    /**
+     * Calculates the hash to create a new object.
+     *
+     * @param oStartupParameters The startup parameter values (map parameter name -> array of values)
+     * @param sContextPath The context path of the entity set to be used for the creation
+     * @param oRouter The router instance
+     * @returns The hash
+     */
+    getDefaultCreateHash: function (oStartupParameters, sContextPath, oRouter) {
+      var sDefaultCreateHash = oStartupParameters && oStartupParameters.preferredMode ? oStartupParameters.preferredMode[0] : "create";
+      var sHash = "";
+      sDefaultCreateHash = sDefaultCreateHash.indexOf(":") !== -1 && sDefaultCreateHash.length > sDefaultCreateHash.indexOf(":") + 1 ? sDefaultCreateHash.substr(0, sDefaultCreateHash.indexOf(":")) : "create";
+      sHash = sContextPath.substring(1) + "(...)?i-action=" + sDefaultCreateHash;
+
+      if (oRouter.getRouteInfoByHash(sHash)) {
+        return sHash;
+      } else {
+        throw new Error("No route match for creating a new " + sContextPath.substring(1));
+      }
+    }
+  };
+  return AppStartupHelper;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["AppStartupHelper.ts"],"names":["AppStartupHelper","_getKeysFromStartupParams","aKeyNames","oStartupParameters","bAllFound","aKeys","map","name","length","value","undefined","_createFilterFromKeys","bDraftMode","oMetaModel","bFilterCaseSensitive","ModelHelper","isFilteringCaseSensitive","bFilterOnActiveEntity","aFilters","key","Filter","path","operator","FilterOperator","EQ","value1","caseSensitive","oDraftFilter","filters","and","push","_requestObjectsFromParameters","aStartupPages","oModel","aContextPromises","pageInfo","semanticKeys","technicalKeys","oFilter","draftMode","getMetaModel","oListBind","bindList","contextPath","join","requestContexts","Promise","all","_getReachablePageInfoFromRoute","oRoute","oManifestRouting","sPattern","pattern","replace","sTargetName","Array","isArray","target","oTarget","targets","aPatternSegments","split","pageLevel","options","settings","allowDeepLinking","sContextPath","entitySet","oEntityType","getObject","aSemanticKeyNames","aSemantickKeys","semKey","$PropertyPath","aTechnicalKeys","_getReachablePages","aRoutes","routes","mPagesByLevel","forEach","oPageInfo","aReachablePages","level","_getStartupPagesFromStartupParams","result","current","findRecursive","aCurrentLevelPages","lastPage","nextPage","indexOf","pop","slice","_getDeepLinkObject","aContexts","context","hash","oContext","getPath","getDeepLinkStartupHash","requestObject","then","aValues","aFoundContexts","getCreateStartupHash","oRouter","oEntitySetAnnotations","sMetaPath","bCreatable","bNewActionOperationAvailable","oInsertRestrictions","Insertable","getDefaultCreateHash","sDefaultCreateHash","preferredMode","sHash","substr","substring","getRouteInfoByHash","Error"],"mappings":"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","sourceRoot":".","sourcesContent":["import ODataMetaModel from \"sap/ui/model/odata/v4/ODataMetaModel\";\nimport ODataModel from \"sap/ui/model/odata/v4/ODataModel\";\nimport Context from \"sap/ui/model/odata/v4/Context\";\nimport Filter from \"sap/ui/model/Filter\";\nimport FilterOperator from \"sap/ui/model/FilterOperator\";\nimport Router from \"sap/ui/core/routing/Router\";\nimport ModelHelper from \"./ModelHelper\";\n\ntype ValuedKey = {\n\tname: string;\n\tvalue: string;\n};\n\ntype PageInfo = {\n\tpattern: string;\n\tcontextPath: string;\n\tdraftMode: Boolean;\n\ttechnicalKeys: ValuedKey[] | undefined;\n\tsemanticKeys: ValuedKey[] | undefined;\n\ttarget: string;\n\tpageLevel: number;\n};\n\nconst AppStartupHelper = {\n\t/**\n\t * Retrieves a set of key values from startup parameters.\n\t *\n\t * @param aKeyNames The array of key names\n\t * @param oStartupParameters The startup parameters\n\t * @returns {any[]} An array of pairs {name, value} if all key values could be found in the startup parameters, undefined otherwise\n\t */\n\t_getKeysFromStartupParams: function(aKeyNames: string[], oStartupParameters: any): ValuedKey[] | undefined {\n\t\tlet bAllFound = true;\n\t\tconst aKeys = aKeyNames.map(name => {\n\t\t\tif (oStartupParameters[name] && oStartupParameters[name].length === 1) {\n\t\t\t\treturn { name, value: oStartupParameters[name][0] as string };\n\t\t\t} else {\n\t\t\t\t// A unique key value couldn't be found in the startup parameters\n\t\t\t\tbAllFound = false;\n\t\t\t\treturn { name, value: \"\" };\n\t\t\t}\n\t\t});\n\n\t\treturn bAllFound ? aKeys : undefined;\n\t},\n\n\t/**\n\t * Creates a filter from a list of key values.\n\t *\n\t * @param aKeys Array of semantic keys or technical keys (with values)\n\t * @param bDraftMode True if the entity supports draft mode\n\t * @param oMetaModel The metamodel\n\t * @returns The filter\n\t */\n\t_createFilterFromKeys: function(aKeys: ValuedKey[], bDraftMode: Boolean, oMetaModel: ODataMetaModel): Filter {\n\t\tconst bFilterCaseSensitive = ModelHelper.isFilteringCaseSensitive(oMetaModel);\n\n\t\tlet bFilterOnActiveEntity = false;\n\t\tconst aFilters = aKeys.map(key => {\n\t\t\tif (key.name === \"IsActiveEntity\") {\n\t\t\t\tbFilterOnActiveEntity = true;\n\t\t\t}\n\t\t\treturn new Filter({\n\t\t\t\tpath: key.name,\n\t\t\t\toperator: FilterOperator.EQ,\n\t\t\t\tvalue1: key.value,\n\t\t\t\tcaseSensitive: bFilterCaseSensitive\n\t\t\t});\n\t\t});\n\t\tif (bDraftMode && !bFilterOnActiveEntity) {\n\t\t\tconst oDraftFilter = new Filter({\n\t\t\t\tfilters: [new Filter(\"IsActiveEntity\", \"EQ\", false), new Filter(\"SiblingEntity/IsActiveEntity\", \"EQ\", null)],\n\t\t\t\tand: false\n\t\t\t});\n\t\t\taFilters.push(oDraftFilter);\n\t\t}\n\n\t\treturn new Filter(aFilters, true);\n\t},\n\n\t/**\n\t * Loads all contexts for a list of page infos.\n\t *\n\t * @param aStartupPages The list of page infos\n\t * @param oModel The model used to load the contexts\n\t * @returns A Promise for all contexts\n\t */\n\t_requestObjectsFromParameters: function(aStartupPages: PageInfo[], oModel: ODataModel): Promise<Context[][]> {\n\t\t// Load the respective objects for all object pages found in aExternallyNavigablePages\n\t\tconst aContextPromises = aStartupPages.map(pageInfo => {\n\t\t\tconst aKeys = pageInfo.semanticKeys || pageInfo.technicalKeys || [];\n\t\t\tconst oFilter = this._createFilterFromKeys(aKeys, pageInfo.draftMode, oModel.getMetaModel());\n\n\t\t\t// only request a minimum of fields to boost backend performance since this is only used to check if an object exists\n\t\t\tconst oListBind = oModel.bindList(pageInfo.contextPath, undefined, undefined, oFilter, {\n\t\t\t\t\"$select\": aKeys\n\t\t\t\t\t.map(key => {\n\t\t\t\t\t\treturn key.name;\n\t\t\t\t\t})\n\t\t\t\t\t.join(\",\")\n\t\t\t} as any);\n\t\t\treturn oListBind.requestContexts(0, 2);\n\t\t});\n\n\t\treturn Promise.all(aContextPromises);\n\t},\n\n\t/**\n\t * Creates a PageInfo from a route if ti's reachable from the startup parameters.\n\t *\n\t * @param oRoute The route\n\t * @param oManifestRouting The app manifest routing section\n\t * @param oStartupParameters The startup parameters\n\t * @param oMetaModel The app metamodel\n\t * @returns A page info if the page is reachable, undefined otherwise\n\t */\n\t_getReachablePageInfoFromRoute: function(\n\t\toRoute: any,\n\t\toManifestRouting: any,\n\t\toStartupParameters: any,\n\t\toMetaModel: ODataMetaModel\n\t): PageInfo | undefined {\n\t\t// Remove trailing ':?query:' and '/'\n\t\tlet sPattern: string = oRoute.pattern.replace(\":?query:\", \"\");\n\t\tsPattern = sPattern.replace(/\\/$/, \"\");\n\n\t\tif (!sPattern) {\n\t\t\treturn undefined; // Ignore level-0 routes (ListReport)\n\t\t}\n\n\t\tsPattern = sPattern.replace(/\\(\\{[^\\}]*\\}\\)/g, \"(#)\"); // Replace keys with #\n\n\t\t// Get the rightmost target for this route\n\t\tconst sTargetName: string = Array.isArray(oRoute.target) ? oRoute.target[oRoute.target.length - 1] : oRoute.target;\n\t\tconst oTarget = oManifestRouting.targets[sTargetName];\n\n\t\tconst aPatternSegments = sPattern.split(\"/\");\n\t\tconst pageLevel = aPatternSegments.length - 1;\n\n\t\tif (pageLevel !== 0 && oTarget?.options?.settings?.allowDeepLinking !== true) {\n\t\t\t// The first level of object page allows deep linking by default.\n\t\t\t// Otherwise, the target must allow deep linking explicitely in the manifest\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst sContextPath: string =\n\t\t\toTarget.options.settings.contextPath || (oTarget.options.settings.entitySet && \"/\" + oTarget.options.settings.entitySet);\n\t\tconst oEntityType = sContextPath && oMetaModel.getObject(\"/$EntityContainer\" + sContextPath + \"/\");\n\n\t\tif (!oEntityType) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Get the semantic key values for the entity\n\t\tconst aSemanticKeyNames: any = oMetaModel.getObject(\n\t\t\t\"/$EntityContainer\" + sContextPath + \"/@com.sap.vocabularies.Common.v1.SemanticKey\"\n\t\t);\n\n\t\tconst aSemantickKeys = aSemanticKeyNames\n\t\t\t? this._getKeysFromStartupParams(\n\t\t\t\t\taSemanticKeyNames.map((semKey: any) => {\n\t\t\t\t\t\treturn semKey.$PropertyPath as string;\n\t\t\t\t\t}),\n\t\t\t\t\toStartupParameters\n\t\t\t  )\n\t\t\t: undefined;\n\n\t\t// Get the technical keys only if we couldn't find the semantic key values, and on first level OP\n\t\tconst aTechnicalKeys =\n\t\t\t!aSemantickKeys && pageLevel === 0 ? this._getKeysFromStartupParams(oEntityType[\"$Key\"], oStartupParameters) : undefined;\n\n\t\tif (aSemantickKeys === undefined && aTechnicalKeys === undefined) {\n\t\t\t// We couldn't find the semantic/technical keys in the startup parameters\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// The startup parameters contain values for all semantic keys (or technical keys) --> we can store the page info in the corresponding level\n\t\tconst draftMode =\n\t\t\toMetaModel.getObject(\"/$EntityContainer\" + sContextPath + \"@com.sap.vocabularies.Common.v1.DraftRoot\") ||\n\t\t\toMetaModel.getObject(\"/$EntityContainer\" + sContextPath + \"@com.sap.vocabularies.Common.v1.DraftNode\")\n\t\t\t\t? true\n\t\t\t\t: false;\n\n\t\treturn {\n\t\t\tpattern: sPattern,\n\t\t\tcontextPath: sContextPath,\n\t\t\tdraftMode,\n\t\t\ttechnicalKeys: aTechnicalKeys,\n\t\t\tsemanticKeys: aSemantickKeys,\n\t\t\ttarget: sTargetName,\n\t\t\tpageLevel\n\t\t};\n\t},\n\n\t/**\n\t * Returns the list of all pages that allow deeplink and that can be reached using the startup parameters.\n\t *\n\t * @param oManifestRouting The routing information from the app manifest\n\t * @param oStartupParameters The startup parameters\n\t * @param oMetaModel The metamodel\n\t * @returns\n\t */\n\t_getReachablePages: function(oManifestRouting: any, oStartupParameters: any, oMetaModel: ODataMetaModel): PageInfo[][] {\n\t\tconst aRoutes: any[] = oManifestRouting.routes;\n\t\tconst mPagesByLevel: Record<number, PageInfo[]> = {};\n\n\t\taRoutes.forEach(oRoute => {\n\t\t\tconst oPageInfo = this._getReachablePageInfoFromRoute(oRoute, oManifestRouting, oStartupParameters, oMetaModel);\n\n\t\t\tif (oPageInfo) {\n\t\t\t\tif (!mPagesByLevel[oPageInfo.pageLevel]) {\n\t\t\t\t\tmPagesByLevel[oPageInfo.pageLevel] = [];\n\t\t\t\t}\n\t\t\t\tmPagesByLevel[oPageInfo.pageLevel].push(oPageInfo);\n\t\t\t}\n\t\t});\n\n\t\t// A page is reachable only if all its parents are also reachable\n\t\t// So if we couldn't find any pages for a given level, all pages with a higher level won't be reachable anyway\n\t\tconst aReachablePages: PageInfo[][] = [];\n\t\tlet level = 0;\n\t\twhile (mPagesByLevel[level]) {\n\t\t\taReachablePages.push(mPagesByLevel[level]);\n\t\t\tlevel++;\n\t\t}\n\n\t\treturn aReachablePages;\n\t},\n\n\t/**\n\t * Get the list of startup pages.\n\t *\n\t * @param oManifestRouting The routing information from the app manifest\n\t * @param oStartupParameters The startup parameters\n\t * @param oMetaModel The metamodel\n\t * @returns An array of startup page infos\n\t */\n\t_getStartupPagesFromStartupParams: function(oManifestRouting: any, oStartupParameters: any, oMetaModel: ODataMetaModel): PageInfo[] {\n\t\t// Find all pages that can be reached with the startup parameters\n\t\tconst aReachablePages = this._getReachablePages(oManifestRouting, oStartupParameters, oMetaModel);\n\n\t\tif (aReachablePages.length === 0) {\n\t\t\treturn [];\n\t\t}\n\n\t\t// Find the longest sequence of pages that can be reached (recursively)\n\t\tlet result: PageInfo[] = [];\n\t\tconst current: PageInfo[] = [];\n\n\t\tfunction findRecursive(level: number) {\n\t\t\tconst aCurrentLevelPages = aReachablePages[level];\n\t\t\tconst lastPage = current.length ? current[current.length - 1] : undefined;\n\n\t\t\tif (aCurrentLevelPages) {\n\t\t\t\taCurrentLevelPages.forEach(function(nextPage) {\n\t\t\t\t\tif (!lastPage || nextPage.pattern.indexOf(lastPage.pattern) === 0) {\n\t\t\t\t\t\t// We only consider pages that can be reached from the page at the previous level,\n\t\t\t\t\t\t// --> their pattern must be the pattern of the previous page with another segment appended\n\t\t\t\t\t\tcurrent.push(nextPage);\n\t\t\t\t\t\tfindRecursive(level + 1);\n\t\t\t\t\t\tcurrent.pop();\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t\tif (current.length > result.length) {\n\t\t\t\tresult = current.slice(); // We have found a sequence longer than our previous best --> store it as the new longest\n\t\t\t}\n\t\t}\n\n\t\tfindRecursive(0);\n\n\t\treturn result;\n\t},\n\n\t/**\n\t * Creates the startup object from the list of pages and contexts.\n\t *\n\t * @param aStartupPages The pages\n\t * @param aContexts The contexts\n\t * @returns An object containing either a hash or a context to navigate to, or an empty object if no deep link was found\n\t */\n\t_getDeepLinkObject: function(aStartupPages: PageInfo[], aContexts: Context[]): { hash?: string; context?: Context } {\n\t\tif (aContexts.length === 1) {\n\t\t\treturn { context: aContexts[0] };\n\t\t} else if (aContexts.length > 1) {\n\t\t\t// Navigation to a deeper level --> use the pattern of the deepest object page\n\t\t\t// and replace the parameters by the ID from the contexts\n\t\t\tlet hash = aStartupPages[aStartupPages.length - 1].pattern;\n\t\t\taContexts.forEach(function(oContext) {\n\t\t\t\thash = hash.replace(\"(#)\", \"(\" + oContext.getPath().split(\"(\")[1]);\n\t\t\t});\n\n\t\t\treturn { hash };\n\t\t} else {\n\t\t\treturn {};\n\t\t}\n\t},\n\n\t/**\n\t * Calculates startup parameters for a deeplink case, from startup parameters and routing infoirmation.\n\t *\n\t * @param oManifestRouting The routing information from the app manifest\n\t * @param oStartupParameters The startup parameters\n\t * @param oModel The OData model\n\t * @returns An object containing either a hash or a context to navigate to, or an empty object if no deep link was found\n\t */\n\tgetDeepLinkStartupHash: function(\n\t\toManifestRouting: any,\n\t\toStartupParameters: any,\n\t\toModel: ODataModel\n\t): Promise<{ hash?: string; context?: Context }> {\n\t\tlet aStartupPages: PageInfo[];\n\n\t\treturn oModel\n\t\t\t.getMetaModel()\n\t\t\t.requestObject(\"/$EntityContainer/\")\n\t\t\t.then(() => {\n\t\t\t\t// Check if semantic keys are present in url parameters for every object page at each level\n\t\t\t\taStartupPages = this._getStartupPagesFromStartupParams(oManifestRouting, oStartupParameters, oModel.getMetaModel());\n\n\t\t\t\treturn this._requestObjectsFromParameters(aStartupPages, oModel);\n\t\t\t})\n\t\t\t.then((aValues: Context[][]) => {\n\t\t\t\tif (aValues.length) {\n\t\t\t\t\t// Make sure we only get 1 context per promise, and flatten the array\n\t\t\t\t\tconst aContexts: Context[] = [];\n\t\t\t\t\taValues.forEach(function(aFoundContexts) {\n\t\t\t\t\t\tif (aFoundContexts.length === 1) {\n\t\t\t\t\t\t\taContexts.push(aFoundContexts[0]);\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\n\t\t\t\t\treturn aContexts.length === aValues.length ? this._getDeepLinkObject(aStartupPages, aContexts) : {};\n\t\t\t\t} else {\n\t\t\t\t\treturn {};\n\t\t\t\t}\n\t\t\t});\n\t},\n\n\t/**\n\t * Calculates the new hash based on the startup parameters.\n\t *\n\t * @param oStartupParameters The startup parameter values (map parameter name -> array of values)\n\t * @param sContextPath The context path for the startup of the app (generally the path to the main entity set)\n\t * @param oRouter The router instance\n\t * @param oMetaModel The meta model\n\t * @returns A promise containing the hash to navigate to, or an empty string if there's no need to navigate\n\t */\n\tgetCreateStartupHash: function(\n\t\toStartupParameters: any,\n\t\tsContextPath: string,\n\t\toRouter: Router,\n\t\toMetaModel: ODataMetaModel\n\t): Promise<String> {\n\t\treturn oMetaModel.requestObject(sContextPath + \"@\").then((oEntitySetAnnotations: any) => {\n\t\t\tlet sMetaPath = \"\";\n\t\t\tlet bCreatable = true;\n\n\t\t\tif (\n\t\t\t\toEntitySetAnnotations[\"@com.sap.vocabularies.Common.v1.DraftRoot\"] &&\n\t\t\t\toEntitySetAnnotations[\"@com.sap.vocabularies.Common.v1.DraftRoot\"][\"NewAction\"]\n\t\t\t) {\n\t\t\t\tsMetaPath = sContextPath + \"@com.sap.vocabularies.Common.v1.DraftRoot/NewAction@Org.OData.Core.V1.OperationAvailable\";\n\t\t\t} else if (\n\t\t\t\toEntitySetAnnotations[\"@com.sap.vocabularies.Session.v1.StickySessionSupported\"] &&\n\t\t\t\toEntitySetAnnotations[\"@com.sap.vocabularies.Session.v1.StickySessionSupported\"][\"NewAction\"]\n\t\t\t) {\n\t\t\t\tsMetaPath =\n\t\t\t\t\tsContextPath + \"@com.sap.vocabularies.Session.v1.StickySessionSupported/NewAction@Org.OData.Core.V1.OperationAvailable\";\n\t\t\t}\n\n\t\t\tif (sMetaPath) {\n\t\t\t\tconst bNewActionOperationAvailable = oMetaModel.getObject(sMetaPath);\n\t\t\t\tif (bNewActionOperationAvailable === false) {\n\t\t\t\t\tbCreatable = false;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tconst oInsertRestrictions = oEntitySetAnnotations[\"@Org.OData.Capabilities.V1.InsertRestrictions\"];\n\t\t\t\tif (oInsertRestrictions && oInsertRestrictions.Insertable === false) {\n\t\t\t\t\tbCreatable = false;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (bCreatable) {\n\t\t\t\treturn this.getDefaultCreateHash(oStartupParameters, sContextPath, oRouter);\n\t\t\t} else {\n\t\t\t\treturn \"\";\n\t\t\t}\n\t\t});\n\t},\n\n\t/**\n\t * Calculates the hash to create a new object.\n\t *\n\t * @param oStartupParameters The startup parameter values (map parameter name -> array of values)\n\t * @param sContextPath The context path of the entity set to be used for the creation\n\t * @param oRouter The router instance\n\t * @returns The hash\n\t */\n\tgetDefaultCreateHash: function(oStartupParameters: any, sContextPath: string, oRouter: Router): string {\n\t\tlet sDefaultCreateHash =\n\t\t\toStartupParameters && oStartupParameters.preferredMode ? (oStartupParameters.preferredMode[0] as string) : \"create\";\n\t\tlet sHash = \"\";\n\n\t\tsDefaultCreateHash =\n\t\t\tsDefaultCreateHash.indexOf(\":\") !== -1 && sDefaultCreateHash.length > sDefaultCreateHash.indexOf(\":\") + 1\n\t\t\t\t? sDefaultCreateHash.substr(0, sDefaultCreateHash.indexOf(\":\"))\n\t\t\t\t: \"create\";\n\t\tsHash = sContextPath.substring(1) + \"(...)?i-action=\" + sDefaultCreateHash;\n\t\tif (oRouter.getRouteInfoByHash(sHash)) {\n\t\t\treturn sHash;\n\t\t} else {\n\t\t\tthrow new Error(\"No route match for creating a new \" + sContextPath.substring(1));\n\t\t}\n\t}\n};\n\nexport default AppStartupHelper;\n"]}