@sapui5/sap.fe.core 1.97.0 → 1.98.0

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

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