@sap/open.fe 1.97.0 → 1.98.0

package/packages/sap.fe.core/src/sap/fe/core/helpers/AppStartupHelper.ts

@@ -0,0 +1,388 @@
+import { ODataModel, ODataMetaModel, Context } from "sap/ui/model/odata/v4";
+import { Filter, FilterOperator } from "sap/ui/model";
+import { Router } from "sap/ui/core/routing";
+import { ModelHelper } from "sap/fe/core/helpers";
+
+type ValuedKey = {
+	name: string;
+	value: string;
+};
+
+type PageInfo = {
+	pattern: string;
+	contextPath: string;
+	draftMode: Boolean;
+	technicalKeys: ValuedKey[] | undefined;
+	semanticKeys: ValuedKey[] | undefined;
+	target: string;
+};
+
+/**
+ * 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: string[], oStartupParameters: any): ValuedKey[] | undefined {
+	let bAllFound = true;
+	const aKeys = aKeyNames.map(name => {
+		if (oStartupParameters[name] && oStartupParameters[name].length === 1) {
+			return { name, value: oStartupParameters[name][0] as string };
+		} else {
+			// A unique key value couldn't be found in the startup parameters
+			bAllFound = false;
+			return { 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: ValuedKey[], bDraftMode: Boolean, oMetaModel: ODataMetaModel): Filter {
+	const bFilterCaseSensitive = ModelHelper.isFilteringCaseSensitive(oMetaModel);
+
+	let bFilterOnActiveEntity = false;
+	const aFilters = aKeys.map(key => {
+		if (key.name === "IsActiveEntity") {
+			bFilterOnActiveEntity = true;
+		}
+		return new Filter({
+			path: key.name,
+			operator: FilterOperator.EQ,
+			value1: key.value,
+			caseSensitive: bFilterCaseSensitive
+		});
+	});
+	if (bDraftMode && !bFilterOnActiveEntity) {
+		const 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: PageInfo[], oModel: ODataModel): Promise<Context[][]> {
+	// Load the respective objects for all object pages found in aExternallyNavigablePages
+	const aContextPromises = aStartupPages.map(pageInfo => {
+		const aKeys = pageInfo.semanticKeys || pageInfo.technicalKeys || [];
+		const 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
+		const oListBind = oModel.bindList(pageInfo.contextPath, undefined, undefined, oFilter, {
+			"$select": aKeys
+				.map(key => {
+					return key.name;
+				})
+				.join(",")
+		} as any);
+		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: any, oStartupParameters: any, oMetaModel: ODataMetaModel): PageInfo[][] {
+	const aRoutes: any[] = oManifestRouting.routes;
+	const mPagesByLevel: Record<number, PageInfo[]> = {};
+
+	aRoutes.forEach(oRoute => {
+		let sPattern: string = oRoute.pattern.replace(":?query:", "");
+		if (sPattern.endsWith("/")) {
+			sPattern = sPattern.substr(0, sPattern.length - 1);
+		}
+
+		if (sPattern) {
+			// Ignore level-0 routes (ListReport)
+			sPattern = sPattern.replace(/\(\{[^\}]*\}\)/g, "(#)"); // Replace keys with #
+
+			// Get the rightmost target for this route
+			const sTargetName: string = Array.isArray(oRoute.target) ? oRoute.target[oRoute.target.length - 1] : oRoute.target;
+			const oTarget = oManifestRouting.targets[sTargetName];
+
+			const aPatternSegments = sPattern.split("/");
+			const 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?.options?.settings?.allowDeepLinking) {
+				const sContextPath: string =
+					oTarget.options.settings.contextPath ||
+					(oTarget.options.settings.entitySet && "/" + oTarget.options.settings.entitySet);
+				const oEntityType = sContextPath && oMetaModel.getObject("/$EntityContainer" + sContextPath + "/");
+
+				if (oEntityType) {
+					// Get the semantic key values for the entity
+					const aSemanticKeyNames: any = oMetaModel.getObject(
+						"/$EntityContainer" + sContextPath + "/@com.sap.vocabularies.Common.v1.SemanticKey"
+					);
+					const aSemantickKeys = aSemanticKeyNames
+						? _getKeysFromStartupParams(
+								aSemanticKeyNames.map((semKey: any) => {
+									return semKey.$PropertyPath as string;
+								}),
+								oStartupParameters
+						  )
+						: undefined;
+
+					// Get the technical keys only if we couldn't find the semantic key values, and on first level OP
+					const 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
+						const 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,
+							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
+	const aReachablePages: PageInfo[][] = [];
+	let 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: any, oStartupParameters: any, oMetaModel: ODataMetaModel): PageInfo[] {
+	// Find all pages that can be reached with the startup parameters
+	const aReachablePages = _getReachablePages(oManifestRouting, oStartupParameters, oMetaModel);
+
+	if (aReachablePages.length === 0) {
+		return [];
+	}
+
+	// Find the longest sequence of pages that can be reached (recursively)
+	let result: PageInfo[] = [];
+	const current: PageInfo[] = [];
+
+	function findRecursive(level: number) {
+		const aCurrentLevelPages = aReachablePages[level];
+		const 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: PageInfo[], aContexts: Context[]): { hash?: string; context?: Context } {
+	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
+		let hash = aStartupPages[aStartupPages.length - 1].pattern;
+		aContexts.forEach(function(oContext) {
+			hash = hash.replace("(#)", "(" + oContext.getPath().split("(")[1]);
+		});
+
+		return { 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: any,
+	oStartupParameters: any,
+	oModel: ODataModel
+): Promise<{ hash?: string; context?: Context }> {
+	let aStartupPages: PageInfo[];
+
+	return oModel
+		.getMetaModel()
+		.requestObject("/$EntityContainer/")
+		.then(() => {
+			// 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((aValues: Context[][]) => {
+			if (aValues.length) {
+				// Make sure we only get 1 context per promise, and flatten the array
+				const aContexts: Context[] = [];
+				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: any, sContextPath: string, oRouter: Router, oMetaModel: ODataMetaModel): Promise<String> {
+	return oMetaModel.requestObject(sContextPath + "@").then(function(oEntitySetAnnotations: any) {
+		let sMetaPath = "";
+		let 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) {
+			const bNewActionOperationAvailable = oMetaModel.getObject(sMetaPath);
+			if (bNewActionOperationAvailable === false) {
+				bCreatable = false;
+			}
+		} else {
+			const 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: any, sContextPath: string, oRouter: Router): string {
+	let sDefaultCreateHash =
+		oStartupParameters && oStartupParameters.preferredMode ? (oStartupParameters.preferredMode[0] as string) : "create";
+	let 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));
+	}
+}
+
+const AppStartupHelper = {
+	_getKeysFromStartupParams,
+	_createFilterFromKeys,
+	_requestObjectsFromParameters,
+	_getReachablePages,
+	_getStartupPagesFromStartupParams,
+	_getDeepLinkObject,
+	getDeepLinkStartupHash,
+	getCreateStartupHash,
+	getDefaultCreateHash
+};
+
+export default AppStartupHelper;