@sapui5/sap.fe.macros 1.139.0 → 1.141.0

package/src/sap/fe/macros/filter/FilterUtils.ts

@@ -1,4 +1,4 @@
-import type { EntityType, Property } from "@sap-ux/vocabularies-types";
+import type { EntityType,Property } from "@sap-ux/vocabularies-types";
 import type { PropertyPath } from "@sap-ux/vocabularies-types/Edm";
 import { CommonAnnotationTypes } from "@sap-ux/vocabularies-types/vocabularies/Common";
 import type { SelectionFields } from "@sap-ux/vocabularies-types/vocabularies/UI";
@@ -8,13 +8,13 @@ import type AppComponent from "sap/fe/core/AppComponent";
 import type { BaseTreeModifier } from "sap/fe/core/CommonUtils";
 import CommonUtils from "sap/fe/core/CommonUtils";
 import ConverterContext from "sap/fe/core/converters/ConverterContext";
-import type { BaseManifestSettings } from "sap/fe/core/converters/ManifestSettings";
+import type { BaseManifestSettings,HiddenDraft } from "sap/fe/core/converters/ManifestSettings";
 import ManifestWrapper from "sap/fe/core/converters/ManifestWrapper";
 import * as MetaModelConverter from "sap/fe/core/converters/MetaModelConverter";
 import type { IDiagnostics } from "sap/fe/core/converters/TemplateConverter";
 import type { TableVisualization } from "sap/fe/core/converters/controls/Common/Table";
 import type { PropertyTypeConfig } from "sap/fe/core/converters/controls/Common/table/Columns";
-import type { FilterField, PropertyInfo, PropertyInfoExternal } from "sap/fe/core/converters/controls/ListReport/FilterBar";
+import type { FilterField,PropertyInfo,PropertyInfoExternal } from "sap/fe/core/converters/controls/ListReport/FilterBar";
 import * as FilterBarConverter from "sap/fe/core/converters/controls/ListReport/FilterBar";
 import { getAllCustomAggregates } from "sap/fe/core/helpers/MetaModelFunction";
 import ModelHelper from "sap/fe/core/helpers/ModelHelper";
@@ -326,19 +326,35 @@ const oFilterUtils = {
 				aIgnoreProperties.concat(aParameters)
 			) as { filters: Filter }
 		).filters;
-		const currState = oIFilter?.getCurrentState?.();
-		const hasEditStateFieldVisible = currState?.items?.some((cs: { [key: string]: string }) => cs?.key === "$editState");
-		const hasEditStateMetadata = Array.isArray(aPropertiesMetadata) && aPropertiesMetadata?.some((cs) => cs?.key === "$editState");
+		const hasEditStateMetadata = aPropertiesMetadata?.filter((property) => property.name === "$editState");
 		let editStateFilter: Filter | undefined;
-		if (!aIgnoreProperties.includes("$editState") && hasEditStateFieldVisible === true && hasEditStateMetadata) {
+		if (!aIgnoreProperties.includes("$editState") && hasEditStateMetadata && hasEditStateMetadata.length > 0) {
 			if (mConditions.hasOwnProperty("$editState")) {
 				const editStateValue = mConditions["$editState"];
 				editStateFilter = EDITSTATE.getFilterForEditState(editStateValue?.[0]?.values?.[0]);
 			} else {
 				editStateFilter = EDITSTATE.getFilterForEditState("");
 			}
+		} else {
+			const view = CommonUtils.getTargetView(oIFilter);
+			const appComponent = CommonUtils.getAppComponent(view);
+			const isHiddenDraftEnabled = (appComponent.getEnvironmentCapabilities()?.getCapabilities()?.HiddenDraft as HiddenDraft)
+				?.enabled;
+			if (
+				isHiddenDraftEnabled &&
+				oIFilter.hasOwnProperty("disableDraftEditStateFilter") &&
+				oIFilter.getProperty("disableDraftEditStateFilter")
+			) {
+				editStateFilter = EDITSTATE.getFilterForEditState("ALL");
+			}
 		}
 		let aFilters = oFilter ? [oFilter] : [];
+
+		//( Transform DateTimeOffset precision 7 filters
+		if (oIFilter.isA<FilterBar>("sap.ui.mdc.FilterBar")) {
+			this._transformDateTimeOffsetFilters(aFilters, mConditions, oIFilter as FilterBar);
+		}
+
 		if (editStateFilter) {
 			const hasEditStateFilter = this.hasEditStateFilterRecursively(aFilters);
 			if (hasEditStateFilter) {
@@ -354,6 +370,274 @@ const oFilterUtils = {
 		}
 		return aFilters;
 	},
+
+	/**
+	 * Transforms DateTimeOffset precision 7 filters by converting EQ operators to BT operators
+	 * with microsecond precision range from .0000000 to .9990000.
+	 * @param aFilters Array of filter objects to transform
+	 * @param mConditions Filter conditions from the filter bar
+	 * @param oFilterBar The filter bar instance to access property information
+	 */
+	_transformDateTimeOffsetFilters: function (
+		aFilters: Filter[],
+		mConditions: Record<string, ConditionObject[]>,
+		oFilterBar: FilterBar
+	): void {
+		if (!aFilters || !Array.isArray(aFilters) || !mConditions) {
+			return;
+		}
+
+		// Handle nested filter structure - when multiple filters are defined,
+		// they may be contained within aFilters[0].aFilters
+		let actualFilters: Filter[] = aFilters;
+		const firstFilter = aFilters[0] as Filter & { aFilters?: Filter[] };
+		if (firstFilter?.aFilters && firstFilter.aFilters.length > 0) {
+			actualFilters = firstFilter.aFilters;
+		}
+
+		// Get property helper to access property metadata
+		const oPropertyHelper = oFilterBar.getPropertyHelper();
+		if (!oPropertyHelper) {
+			return;
+		}
+
+		// Create a set of condition paths that are DateTimeOffset precision 7
+		const dateTimeOffsetPaths: Set<string> = new Set<string>();
+
+		Object.keys(mConditions).forEach(function (sConditionPath: string): void {
+			if (mConditions[sConditionPath] && mConditions[sConditionPath].length > 0) {
+				// Use the full condition path for property helper
+				const propertyInfo = oPropertyHelper.getProperty(sConditionPath) as
+					| {
+							dataType?: string;
+							constraints?: { precision?: number };
+							typeConfig?: {
+								typeInstance?: {
+									constraints?: { precision?: number };
+									getName(): string;
+								};
+							};
+					  }
+					| undefined;
+
+				// Check if property is DateTimeOffset with precision 7
+				const isDateTimeOffset: boolean =
+					(propertyInfo?.dataType?.includes("DateTimeOffset") ?? false) ||
+					(propertyInfo?.typeConfig?.typeInstance?.getName().includes("DateTimeOffset") ?? false);
+				const precision: number | undefined =
+					propertyInfo?.constraints?.precision ?? propertyInfo?.typeConfig?.typeInstance?.constraints?.precision;
+
+				if (isDateTimeOffset && precision === 7) {
+					dateTimeOffsetPaths.add(sConditionPath);
+				}
+			}
+		});
+
+		// Transform filters recursively to handle all nested structures
+		this._transformDateTimeOffSetFilterValueRecursively(actualFilters, dateTimeOffsetPaths);
+	},
+
+	/**
+	 * Recursively transforms filters to handle all possible nested aFilters structures.
+	 * @param aFilters Array of filter objects to transform
+	 * @param dateTimeOffsetPaths Set of condition paths that are DateTimeOffset precision 7
+	 */
+	_transformDateTimeOffSetFilterValueRecursively: function (aFilters: Filter[], dateTimeOffsetPaths: Set<string>): void {
+		for (let i = 0; i < aFilters.length; i++) {
+			const filter: Filter = aFilters[i];
+
+			// Check if this filter has nested aFilters (multiple conditions for same field)
+			const filterWithNestedFilters = filter as Filter & { aFilters?: Filter[]; bAnd?: boolean };
+			if (filterWithNestedFilters.aFilters && filterWithNestedFilters.aFilters.length > 0) {
+				// Recursively transform nested filters for deeper nesting levels
+				this._transformDateTimeOffSetFilterValueRecursively(filterWithNestedFilters.aFilters, dateTimeOffsetPaths);
+				continue;
+			}
+
+			const filterPath: string | undefined = filter.getPath();
+			const filterOperator: FilterOperator | undefined = filter.getOperator() as FilterOperator | undefined;
+			const filterValue1: unknown = filter.getValue1();
+
+			// Handle undefined filterOperator gracefully
+			if (filterOperator === undefined) {
+				Log.warning(
+					"FilterUtils._transformDateTimeOffsetFilters: Filter operator is undefined, skipping filter transformation",
+					`filterPath: ${filterPath}, filterValue1: ${filterValue1}`
+				);
+				continue; // Skip this filter and continue with next one
+			}
+
+			if (filterOperator === "EQ" && filterValue1 !== undefined && filterValue1 !== null) {
+				// For direct properties - check if the path matches any condition path
+				if (filterPath && dateTimeOffsetPaths.has(filterPath)) {
+					const transformedFilter: Filter | null = this._transformDateTimeOffSetFilterValue(filter);
+					if (transformedFilter) {
+						aFilters[i] = transformedFilter;
+					}
+				}
+			} else if (filterOperator === "Any") {
+				const nestedFilter = filter.getCondition();
+				if (!nestedFilter) {
+					continue;
+				}
+
+				// Check if the nested filter has multiple conditions (aFilters array)
+				const nestedFilterWithMultipleConditions = nestedFilter as Filter & { aFilters?: Filter[]; bAnd?: boolean };
+				if (nestedFilterWithMultipleConditions.aFilters && nestedFilterWithMultipleConditions.aFilters.length > 0) {
+					// Handle multiple conditions within navigation property
+					let hasTransformation = false;
+
+					for (let j = 0; j < nestedFilterWithMultipleConditions.aFilters.length; j++) {
+						const subFilter: Filter = nestedFilterWithMultipleConditions.aFilters[j];
+
+						// Check for further nesting within sub-filters
+						const subFilterWithNesting = subFilter as Filter & { aFilters?: Filter[] };
+						if (subFilterWithNesting.aFilters && subFilterWithNesting.aFilters.length > 0) {
+							// Recursively handle deeper nesting levels
+							this._transformDateTimeOffSetFilterValueRecursively(subFilterWithNesting.aFilters, dateTimeOffsetPaths);
+							continue;
+						}
+
+						const subFilterPath: string | undefined = subFilter.getPath();
+						const subFilterOperator: FilterOperator | undefined = subFilter.getOperator() as FilterOperator | undefined;
+						const subFilterValue1: unknown = subFilter.getValue1();
+
+						// Handle undefined subFilterOperator gracefully
+						if (subFilterOperator === undefined) {
+							Log.warning(
+								"FilterUtils._transformDateTimeOffsetFilters: Filter operator is undefined, skipping filter transformation",
+								`filterPath: ${subFilterPath}, filterValue1: ${subFilterValue1}`
+							);
+							continue; // Skip this sub-filter
+						}
+
+						if (subFilterOperator === "EQ" && subFilterValue1 !== undefined && subFilterValue1 !== null) {
+							// Check if any condition path matches the navigation pattern
+							const matchingConditionPath: string | undefined = Array.from(dateTimeOffsetPaths).find(function (
+								sConditionPath: string
+							): boolean {
+								// Extract navigation and property parts from condition path
+								const pathParts: string[] = sConditionPath.split("/");
+								if (pathParts.length === 2) {
+									const navigationPart: string = pathParts[0].replace("*", ""); // "_Item*" -> "_Item"
+									const propertyPart: string = pathParts[1]; // "BillingDocumentDate"
+
+									// Check if filter navigation matches and sub filter ends with property
+									return filterPath === navigationPart && Boolean(subFilterPath?.endsWith(propertyPart));
+								}
+								return false;
+							});
+
+							if (matchingConditionPath) {
+								const transformedSubFilter: Filter | null = this._transformDateTimeOffSetFilterValue(subFilter);
+								if (transformedSubFilter) {
+									nestedFilterWithMultipleConditions.aFilters[j] = transformedSubFilter;
+									hasTransformation = true;
+								}
+							}
+						}
+					}
+
+					// If any transformation occurred, recreate the Any filter with updated nested conditions
+					if (hasTransformation) {
+						aFilters[i] = new Filter({
+							path: filterPath,
+							operator: "Any",
+							variable: filter.getVariable(),
+							condition: new Filter({
+								filters: nestedFilterWithMultipleConditions.aFilters,
+								and: nestedFilterWithMultipleConditions.bAnd ?? true
+							})
+						});
+					}
+				} else {
+					// Handle single condition within navigation property
+					const nestedFilterPath: string | undefined = nestedFilter.getPath();
+					const nestedFilterOperator: FilterOperator | undefined = nestedFilter.getOperator() as FilterOperator | undefined;
+
+					const nestedFilterValue1: unknown = nestedFilter.getValue1();
+
+					// Handle undefined nestedFilterOperator gracefully
+
+					if (nestedFilterOperator === undefined) {
+						Log.warning(
+							"FilterUtils._transformDateTimeOffsetFilters: Filter operator is undefined, skipping filter transformation",
+							`filterPath: ${nestedFilterPath}, filterValue1: ${nestedFilterValue1}`
+						);
+						continue; // Skip this nested filter
+					}
+
+					if (nestedFilterOperator === "EQ" && nestedFilterValue1 !== undefined && nestedFilterValue1 !== null) {
+						// Check if any condition path matches the navigation pattern
+						const matchingConditionPath: string | undefined = Array.from(dateTimeOffsetPaths).find(function (
+							sConditionPath: string
+						): boolean {
+							// Extract navigation and property parts from condition path
+							const pathParts: string[] = sConditionPath.split("/");
+							if (pathParts.length === 2) {
+								const navigationPart: string = pathParts[0].replace("*", ""); // "_Item*" -> "_Item"
+								const propertyPart: string = pathParts[1]; // "RequestedDeliveryDate"
+
+								// Check if filter navigation matches and nested filter ends with property
+								return filterPath === navigationPart && Boolean(nestedFilterPath?.endsWith(propertyPart));
+							}
+							return false;
+						});
+
+						if (matchingConditionPath) {
+							const transformedNestedFilter: Filter | null = this._transformDateTimeOffSetFilterValue(nestedFilter);
+							if (transformedNestedFilter) {
+								// Create new Any filter with transformed nested filter
+								aFilters[i] = new Filter({
+									path: filterPath,
+									operator: "Any",
+									variable: filter.getVariable(),
+									condition: transformedNestedFilter
+								});
+							}
+						}
+					}
+				}
+			}
+		}
+	},
+
+	/**
+	 * Transforms a single filter value from EQ to BT with microsecond precision.
+	 * @param filter The filter object to transform
+	 * @returns The transformed filter or null if no transformation needed
+	 */
+	_transformDateTimeOffSetFilterValue: function (filter: Filter): Filter | null {
+		const originalValue: string | undefined = filter.getValue1()?.toString();
+
+		if (!originalValue) {
+			return null;
+		}
+
+		// Parse the datetime value: 2025-08-13T15:19:15.0000000+02:00 or 2025-08-13T15:19:15.0000000Z
+		const dateTimeMatch: RegExpMatchArray | null = originalValue.match(
+			/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{0,7}))?([+-]\d{2}:\d{2}|Z)$/
+		);
+
+		if (dateTimeMatch) {
+			const dateTimePart: string = dateTimeMatch[1];
+			const timezone: string = dateTimeMatch[3];
+
+			// Create microsecond range values
+			const startValue = `${dateTimePart}.0000000${timezone}`;
+			const endValue = `${dateTimePart}.9990000${timezone}`;
+
+			// Return new BT filter with microsecond range
+			return new Filter({
+				path: filter.getPath(),
+				operator: FilterOperator.BT,
+				value1: startValue,
+				value2: endValue
+			});
+		}
+
+		return null;
+	},
 	hasEditStateFilterRecursively: function (filters: Filter[]): boolean {
 		return filters.some((filter): boolean => {
 			if (filter.getPath() === "$editState") {