@sapui5/sap.suite.ui.generic.template 1.153.0 → 1.154.0

package/src/sap/suite/ui/generic/template/lib/ai/EasyFilterBarHandler.js

@@ -1,3 +1,9 @@
+/*
+* SAP UI development toolkit for HTML5 (SAPUI5)
+
+		(c) Copyright 2009-2015 SAP SE. All rights reserved
+	
+*/
 sap.ui.define([
     "sap/ui/base/Object",
     "sap/base/util/extend",
@@ -31,6 +37,16 @@ sap.ui.define([
 
         var bApplyingGrouplevels = false;
 
+        // Last resolved sap.ui.model.Filter tree from a non-simplified complexFilterApplied.
+        // Pushed into oBindingParams.filters on every onBeforeRebindTable until cleared.
+        var oComplexFilter = null;
+
+        // Snapshot of the simplified conditions last APPLIED by EasyFilter. Used on switch-back
+        // SFB->EasyFilter to detect whether the user diverged the SFB from the applied EasyFilter
+        // state; if so the table is marked dirty (grey overlay) without a search.
+        // Shape: [{ field, operator, values }]. null = nothing applied.
+        var aAppliedEasyFilterConditions = null;
+
         // fnValueHelpPromiseReject;
         // Tracks the filterMode that was saved in the most recently loaded variant.
         // Used in onFilterSwitch to compare against the current toggle state without
@@ -46,6 +62,7 @@ sap.ui.define([
         // afterVariantLoad fires as a side effect of the subsequent setUiState call.
         var bFiltersResetByUser = false;
 
+
         /**
          * Calls setVariantCreationByUserAllowed(bAllowed) on the SmartVariantManagement control
          * that owns the SmartFilterBar. Disabling creation blocks both Save and Save As in the VM
@@ -246,7 +263,8 @@ sap.ui.define([
             }
 
             oEasyFilterMetadata = {
-                version: 1,
+                // version field omitted: only .fields is consumed by setFilterBarMetadata().
+                // TODO(UXIEC-4979): remove version concept entirely once cleanup ticket lands.
                 entitySet: sEntitySet,
                 fields : []
             };
@@ -361,6 +379,9 @@ sap.ui.define([
                 }
             });
 
+            // Adding custom filter fields (ControlConfiguration entries) invisible to OData metadata
+            fnAppendCustomFilterMetadata(oOwnerFilterControl, oEasyFilterMetadata.fields);
+
              // Adding Editing status filter
              if (oTemplateUtils.oComponentUtils.isDraftEnabled()) {
                 var oEditStateControl = oController.byId("editStateFilter");
@@ -396,7 +417,7 @@ sap.ui.define([
          * Later the key field is set in the SFB and table is filtered with the same. Description cannot be used for filtering.
          * @param {*} oFilterItemForQuery A Property from the easy filter metadata
          * @param {*} oValueList Value list object of the filter item
-         * @returns
+         * @returns {Promise} Promise resolving with the value list data array
          */
         function fnGetValueListValues(oFilterItemForQuery, oValueList, oSFBModel) {
 
@@ -484,9 +505,22 @@ sap.ui.define([
             var aSelectOptions = [];
             var oEditStateFilter = 0;
 
+            // Build lookup of custom filter keys to exclude from OData selectOptions.
+            // Custom filters are applied directly to the live control — they must not
+            // be routed through the OData $filter pipeline as they are not OData properties.
+            var mCustomFilterKeys = {};
+            if (oEasyFilterMetadata) {
+                oEasyFilterMetadata.fields.forEach(function(oField) {
+                    if (oField.isCustomFilter) { mCustomFilterKeys[oField.name] = true; }
+                });
+            }
+
             oAIFilters.forEach(function (oFilterItem) {
                 if (oFilterItem.key === "EditState") {
                     oEditStateFilter = oFilterItem.keySpecificSelectedValues[0].selectedValues[0]; // Edit state generally should not have more than one filter value
+                } else if (mCustomFilterKeys[oFilterItem.key]) {
+                    // Custom filter — value applied directly to control via fnApplyCustomFilterActivations.
+                    // Do NOT build an OData selectOption — this key is not an OData property.
                 } else {
                     var oFilter = {
                         PropertyName: oFilterItem.key,
@@ -614,6 +648,9 @@ sap.ui.define([
                 oEasyFilter.setAppId(oController.getOwnerComponent().getAppComponent().getManifestEntry("sap.app").id);
                 oEasyFilter.setFilterBarMetadata(oEasyFilterMetadata.fields);
                 oEasyFilter.easyfilter = oTemplateUtils.oServices.oFioriAIHandler.fioriaiLib.EasyFilter;
+                // Complex filter (V2) is the default; setEasyFilterVersion(2) is called unconditionally.
+                // TODO(UXIEC-4979): remove once the version concept is cleaned up server-side.
+                oEasyFilter.setEasyFilterVersion(2);
 
                 // Register callbacks on SmartFilterBarWrapper so filterMode and query are
                 // included in the genericData bucket when a variant is saved or loaded.
@@ -678,6 +715,31 @@ sap.ui.define([
                 oSmartFilterbar.getSmartVariant().currentVariantSetModified(true);
             }
             bFiltersResetByUser = true;
+            oComplexFilter = null;
+            aAppliedEasyFilterConditions = null;
+
+            // Simplified conditions are written into the SmartFilterBar (see fnTokensChanged setState),
+            // so clearing the module vars alone is not enough — the SFB still holds the old values and
+            // would re-apply them on the next rebind. Clear the SFB's own filter state too (symmetric
+            // inverse of the setState write): empty selectOptions + reset custom-filter appExtension.
+            // Mirrors FeV4 onClearFilters, which calls _clearFilterValuesWithOptions before triggerSearch.
+            var oSmartFilterBarWrapper = oTemplateUtils.oCommonUtils.getControlStateWrapperById(oSmartFilterbar.getId(), "SmartFilterBar");
+            var oSmartFilterBarVariant = oSmartFilterBarWrapper.getState();
+            oSmartFilterBarVariant.selectOptions = [];
+            if (oSmartFilterBarVariant.customFilters && oSmartFilterBarVariant.customFilters.appExtension) {
+                Object.keys(oSmartFilterBarVariant.customFilters.appExtension).forEach(function(sKey) {
+                    oSmartFilterBarVariant.customFilters.appExtension[sKey] = "";
+                });
+            }
+            oSmartFilterBarWrapper.setState(oSmartFilterBarVariant);
+
+            // Honour the control's mandatoryMissing signal (as FeV4 does): when a mandatory filter is
+            // unset, do not fire a select-all search — the control keeps the table overlay instead.
+            if (oEvent && typeof oEvent.getParameter === "function" && oEvent.getParameter("mandatoryMissing") === true) {
+                return;
+            }
+            // Rebind with cleared state (select all). Covers Clear All and empty-query Go.
+            oSmartFilterbar.search();
 		}
 
 		function fnAfterQueryProcessing(oEvent) {
@@ -697,6 +759,8 @@ sap.ui.define([
             if (oEvent.getParameter("reset")) {
                 bTokensModifiedByUser = false;
                 fnSetCreationAllowed(false);
+                oComplexFilter = null;
+                aAppliedEasyFilterConditions = null;
                 return;
             }
 			var oSmartFilterbar = oState.oSmartFilterbar;
@@ -713,6 +777,44 @@ sap.ui.define([
                 if (oSmartFilterbar.getSmartVariant()) {
                     oSmartFilterbar.getSmartVariant().currentVariantSetModified(true);
                 }
+
+                // Special handling for custom filter token removal by user:
+                // When the user unchecks/removes a custom filter token, clear the live
+                // control value directly and return early — do NOT rebuild the entire SFB
+                // variant state, which would wipe other correctly-set standard tokens.
+                if (oEasyFilterMetadata) {
+                    var bHasCustomTokenModified = false;
+                    oEasyFilterMetadata.fields.forEach(function(oField) {
+                        if (!oField.isCustomFilter) { return; }
+                        var oRemainingToken = (oFiltersFromAI || []).find(function(t) { return t.key === oField.name; });
+                        if (oRemainingToken) { return; } // token still present — nothing to clear
+                        // Only treat as a removal if the control currently holds a value.
+                        // Without this guard, fields that were never activated would trigger the
+                        // early-return path and silently skip standard OData token removal.
+                        if (typeof oSmartFilterbar.determineFilterItemByName === "function") {
+                            oSmartFilterbar.determineFilterItemByName(oField.name);
+                        }
+                        var oControl = typeof oSmartFilterbar.getControlByKey === "function" ? oSmartFilterbar.getControlByKey(oField.name) : null;
+                        if (!oControl || oControl.bIsDestroyed) { return; }
+                        var sMetaName = oControl.getMetadata && oControl.getMetadata().getName();
+                        var bHasValue = (sMetaName === "sap.m.ComboBox" || sMetaName === "sap.m.Select")
+                            ? !!oControl.getSelectedKey()
+                            : (typeof oControl.getValue === "function" && !!oControl.getValue());
+                        if (!bHasValue) { return; } // control is already empty — not a removal
+                        bHasCustomTokenModified = true;
+                        if (sMetaName === "sap.m.ComboBox" || sMetaName === "sap.m.Select") {
+                            oControl.setSelectedKey(null);
+                        } else if (typeof oControl.setValue === "function") {
+                            oControl.setValue("");
+                        }
+                        oLogger.info("EasyFilterBarHandler: user removed custom filter token '" + oField.name + "', control cleared");
+                    });
+                    if (bHasCustomTokenModified) {
+                        bTokensModifiedByUser = false;
+                        oSmartFilterbar.search();
+                        return;
+                    }
+                }
             } else {
                 // AI-resolved result path: reset the user-edit flag and re-enable Save/SaveAs.
                 fnSetCreationAllowed(true);
@@ -736,27 +838,35 @@ sap.ui.define([
 				oSmartFilterBarVariant.customFilters.editState = oVariantDataFromAI.oEditStateFilter;
 			}
 
-            //checking if the variant of SFB has previous semantic dates and if there are new filter values from easy filter then update the SFB variant
-            if (oSmartFilterBarVariant.semanticDates?.Dates) {
-                oSmartFilterBarVariant.semanticDates.Dates.forEach(function (semanticDate) {
-                    var propertyName = semanticDate.PropertyName;
+            // [BUG-09] Build/update semanticDates for date fields — handles both update-in-place and create-from-scratch.
+            (oVariantDataFromAI.aSelectOptions || []).forEach(function(oSelectOption) {
+                if (!oSelectOption || !oSelectOption.PropertyName || !Array.isArray(oSelectOption.Ranges) || !oSelectOption.Ranges.length) { return; }
+                var oRange = oSelectOption.Ranges[0];
+                var sOperator = oRange.Option || "BT";
+                if (sOperator !== "GT" && sOperator !== "GE" && sOperator !== "LT" && sOperator !== "LE" && sOperator !== "BT") { return; }
 
-                    // Find matching property in aSelectOptions
-                    var matchingSelectOption = oVariantDataFromAI.aSelectOptions.find(function (selectOption) {
-                        return selectOption.PropertyName === propertyName;
-                    });
+                var sPropertyName = oSelectOption.PropertyName;
+                var dateData;
 
-                    // If matching property found and has ranges
-                    if (matchingSelectOption?.Ranges?.length > 0) {
-                        var { Low: value1 = null, High: value2 = null } = matchingSelectOption.Ranges[0];
-                        // Update the semantic date data in the smart filter bar
-                        var dateData = semanticDate.Data;
-                        dateData.operation = "DATERANGE";
-                        dateData.value1 = value1;
-                        dateData.value2 = value2 || value1; // Use value1 if value2 is null/empty
-                    }
-                });
-            }
+                if (oSmartFilterBarVariant.semanticDates && Array.isArray(oSmartFilterBarVariant.semanticDates.Dates)) {
+                    var oExisting = oSmartFilterBarVariant.semanticDates.Dates.find(function(d) { return d.PropertyName === sPropertyName; });
+                    if (oExisting) { dateData = oExisting.Data; }
+                }
+                if (!dateData) {
+                    if (!oSmartFilterBarVariant.semanticDates) { oSmartFilterBarVariant.semanticDates = { Dates: [] }; }
+                    if (!Array.isArray(oSmartFilterBarVariant.semanticDates.Dates)) { oSmartFilterBarVariant.semanticDates.Dates = []; }
+                    dateData = { operation: "DATERANGE", value1: null, value2: null, key: sPropertyName, tokenText: "", calendarType: "Gregorian" };
+                    oSmartFilterBarVariant.semanticDates.Dates.push({ PropertyName: sPropertyName, Data: dateData });
+                }
+
+                if (sOperator === "GT" || sOperator === "GE") {
+                    dateData.operation = "FROM"; dateData.value1 = oRange.Low; dateData.value2 = null;
+                } else if (sOperator === "LT" || sOperator === "LE") {
+                    dateData.operation = "TO"; dateData.value1 = oRange.Low; dateData.value2 = null;
+                } else {
+                    dateData.operation = "DATERANGE"; dateData.value1 = oRange.Low; dateData.value2 = oRange.High || oRange.Low;
+                }
+            });
 
 			oSmartFilterBarWrapper.setState(oSmartFilterBarVariant);
 			// currentVariantSetModified intentionally omitted — pressing Go with the same
@@ -766,6 +876,11 @@ sap.ui.define([
 			fnInjectCustomFiltersOnRebind(aSelectOptionsNeedingInjection);
 			fnSyncCustomFieldInputValues(aSelectOptionsNeedingInjection, oSmartFilterbar);
 
+			// Apply values for custom ControlConfiguration filters (isCustomFilter:true).
+			// Must run after setState so standard SFB filters are already applied,
+			// and before search() so the rebind picks up the custom control value.
+			fnApplyCustomFilterActivations(oFiltersFromAI, oSmartFilterbar);
+
 			// Apply sorters/groupLevels bundled with tokens after SFB state is set but
 			// before triggering search, to prevent a premature rebind with incomplete filters.
 			var aBundledSorters = oEvent.getParameter("sorters");
@@ -780,6 +895,118 @@ sap.ui.define([
 			oSmartFilterbar.search();
 		}
 
+        /**
+         * Infers a type hint and optional allowed-values list from a live SAPUI5 control instance.
+         * codeList is only set for controls that expose a finite set of selectable items (ComboBox, Select).
+         * @param {sap.ui.core.Control} oControl - The live control from getControlByKey()
+         * @returns {object} Descriptor with dataType string and optional codeList array
+         */
+        function fnInferControlTypeInfo(oControl) {
+            var sMetaName = oControl && oControl.getMetadata && oControl.getMetadata().getName();
+            if (!sMetaName) {
+                return { dataType: "Edm.String", type: "ValueHelp" };
+            }
+            // ComboBox / Select — fixed item list → MenuWithCheckBox (same as OData fixed-values fields)
+            if (sMetaName === "sap.m.ComboBox" || sMetaName === "sap.m.Select") {
+                var aItems = oControl.getItems ? oControl.getItems() : [];
+                var aCodeList = aItems.map(function(oItem) {
+                    return { value: oItem.getKey(), description: oItem.getText() };
+                });
+                return { dataType: "Edm.String", type: "MenuWithCheckBox", codeList: aCodeList };
+            }
+            // DatePicker → Calendar (same as OData Edm.DateTime date fields)
+            if (sMetaName === "sap.m.DatePicker") {
+                return { dataType: "Edm.DateTime", type: "Calendar" };
+            }
+            // DateRangeSelection → Calendar with range restriction
+            if (sMetaName === "sap.m.DateRangeSelection") {
+                return { dataType: "Edm.DateTime", type: "Calendar", filterRestriction: "SingleRange" };
+            }
+            // RatingIndicator — no dedicated token type, use ValueHelp fallback
+            if (sMetaName === "sap.m.RatingIndicator") {
+                return { dataType: "Edm.Int32", type: "ValueHelp" };
+            }
+            // MultiInput / Input → ValueHelp (free-text)
+            return { dataType: "Edm.String", type: "ValueHelp" };
+        }
+
+        /**
+         * Reads the custom ControlConfiguration keys from the SFB's _CUSTOM filter-data bucket,
+         * resolves each control via getControlByKey(), builds a PropertyMetadata-compatible
+         * descriptor with isCustomFilter:true, and appends it to aFields.
+         * Fields whose key is already present in aFields (OData field with same name) are skipped.
+         * @param {sap.ui.comp.smartfilterbar.SmartFilterBar} oSmartFilterbar
+         * @param {Array} aFields - The fields array of the in-progress oEasyFilterMetadata
+         */
+        function fnAppendCustomFilterMetadata(oSmartFilterbar, aFields) {
+            // Strategy: getAllFilterItems returns ALL filter items including ControlConfiguration entries.
+            // Items whose name is NOT already in mExisting (OData fields) AND not present in the OData
+            // metamodel AND have a live custom control are pure frontend custom filters.
+            var mExisting = {};
+            aFields.forEach(function(oField) { mExisting[oField.name] = true; });
+
+            // Get metamodel for OData property existence double-check.
+            // Some fields (e.g. OverallSDProcessStatus) may be absent from mFilterProperties but
+            // ARE in the OData metadata — they must not be treated as custom filters.
+            // All calls are guarded with typeof checks so this works in test environments
+            // where the mock SFB does not expose getEntitySet or getODataEntitySet.
+            var oModel = typeof oSmartFilterbar.getModel === "function" ? oSmartFilterbar.getModel() : null;
+            var oMetaModel = oModel && typeof oModel.getMetaModel === "function" ? oModel.getMetaModel() : null;
+            var sEntitySet = typeof oSmartFilterbar.getEntitySet === "function" ? oSmartFilterbar.getEntitySet() : null;
+            var oEntitySetMeta = (oMetaModel && sEntitySet && typeof oMetaModel.getODataEntitySet === "function") ? oMetaModel.getODataEntitySet(sEntitySet) : null;
+            var oEntityType = (oMetaModel && oEntitySetMeta && typeof oMetaModel.getODataEntityType === "function") ? oMetaModel.getODataEntityType(oEntitySetMeta.entityType) : null;
+
+            var aAllItems = oSmartFilterbar.getAllFilterItems(true) || [];
+
+            aAllItems.forEach(function(oFilterItem) {
+                var sKey = oFilterItem.getName && oFilterItem.getName();
+                if (!sKey) { return; }
+                if (mExisting[sKey]) {
+                    return; // OData-backed field — already in fields array
+                }
+                // Double-check OData metamodel — field may be OData-backed but absent from mFilterProperties
+                if (oEntityType && oMetaModel) {
+                    var oODataProp = oMetaModel.getODataProperty(oEntityType, sKey);
+                    if (oODataProp) {
+                        return; // Exists in OData metadata — not a custom filter
+                    }
+                }
+                // Not in OData metadata at all — check if it has a live custom control
+                if (typeof oSmartFilterbar.determineFilterItemByName === "function") {
+                    oSmartFilterbar.determineFilterItemByName(sKey);
+                }
+                if (typeof oSmartFilterbar.getControlByKey !== "function") {
+                    return; // SFB does not support custom controls
+                }
+                var oControl = oSmartFilterbar.getControlByKey(sKey);
+                if (!oControl || oControl.bIsDestroyed) {
+                    return; // No custom control or destroyed — skip
+                }
+                var sLabel = oFilterItem.getLabel ? (oFilterItem.getLabel() || sKey) : sKey;
+                var oTypeInfo = fnInferControlTypeInfo(oControl);
+                // type comes directly from fnInferControlTypeInfo — MenuWithCheckBox, Calendar, or ValueHelp
+                var sTokenType = oTypeInfo.type || "ValueHelp";
+                var oDescriptor = {
+                    name: sKey,
+                    label: sLabel,
+                    dataType: oTypeInfo.dataType,
+                    filterable: true,
+                    sortable: false,
+                    groupable: false,
+                    required: false,
+                    type: sTokenType,
+                    isCustomFilter: true
+                };
+                if (oTypeInfo.codeList && oTypeInfo.codeList.length > 0) {
+                    oDescriptor.codeList = oTypeInfo.codeList;
+                }
+                if (oTypeInfo.filterRestriction) {
+                    oDescriptor.filterRestriction = oTypeInfo.filterRestriction;
+                }
+                aFields.push(oDescriptor);
+            });
+        }
+
         /**
          * Returns the subset of aSelectOptions whose property names landed in SFB's _CUSTOM
          * bucket after setState — meaning SFB could not route them through its standard filter
@@ -874,6 +1101,116 @@ sap.ui.define([
             });
         }
 
+        /**
+         * For each AI token whose field is marked isCustomFilter:true in oEasyFilterMetadata,
+         * locates the live control on the SmartFilterBar via getControlByKey() and sets its value
+         * using a type-dispatched setter.  Does NOT call search() — the caller (fnTokensChanged)
+         * is responsible for the single search() call at the end of its flow.
+         * @param {Array}  aAITokens      - Raw token list from oEvent.getParameter("tokens")
+         * @param {object} oSmartFilterbar - The SmartFilterBar control instance
+         */
+        function fnApplyCustomFilterActivations(aAITokens, oSmartFilterbar) {
+            if (!aAITokens || !aAITokens.length || !oEasyFilterMetadata) {
+                return;
+            }
+
+            // Build a lookup of custom filter keys from the current metadata snapshot
+            var mCustomFilterKeys = {};
+            oEasyFilterMetadata.fields.forEach(function(oField) {
+                if (oField.isCustomFilter) {
+                    mCustomFilterKeys[oField.name] = true;
+                }
+            });
+
+            if (Object.keys(mCustomFilterKeys).length === 0) {
+                return;
+            }
+
+            aAITokens.forEach(function(oToken) {
+                var sKey = oToken.key;
+                if (!mCustomFilterKeys[sKey]) {
+                    return; // standard OData token — handled by the existing pipeline
+                }
+
+                // Force instantiation in case the control hasn't been rendered yet
+                if (typeof oSmartFilterbar.determineFilterItemByName === "function") {
+                    oSmartFilterbar.determineFilterItemByName(sKey);
+                }
+                var oControl = oSmartFilterbar.getControlByKey(sKey);
+                if (!oControl || oControl.bIsDestroyed) {
+                    oLogger.warning("EasyFilterBarHandler: control for custom filter '" + sKey + "' is null or destroyed — skipping");
+                    return;
+                }
+
+                // Extract the first value the LLM produced for this key
+                var sValue = null;
+                if (oToken.keySpecificSelectedValues && oToken.keySpecificSelectedValues.length > 0) {
+                    var oFirstGroup = oToken.keySpecificSelectedValues[0];
+                    if (oFirstGroup.selectedValues && oFirstGroup.selectedValues.length > 0) {
+                        var oVal = oFirstGroup.selectedValues[0];
+                        if (oVal && typeof oVal === "object" && oVal.value !== undefined) {
+                            // Plain object with a .value property (e.g. {value:"editable",description:"Editable"})
+                            sValue = String(oVal.value);
+                        } else {
+                            // Primitive string OR boxed String object — String() unwraps both
+                            sValue = String(oVal);
+                        }
+                    }
+                }
+
+                if (sValue === null || sValue === undefined) {
+                    return;
+                }
+
+                // Validate against codeList when available to guard against hallucinated values
+                var oFieldMeta = oEasyFilterMetadata.fields.find(function(f) { return f.name === sKey; });
+                if (oFieldMeta && Array.isArray(oFieldMeta.codeList)) {
+                    var bValid = oFieldMeta.codeList.some(function(oEntry) {
+                        return String(oEntry.value) === sValue;
+                    });
+                    if (!bValid) {
+                        oLogger.warning("EasyFilterBarHandler: LLM produced value '" + sValue + "' for custom filter '" + sKey + "' which is not in the allowed list — skipping");
+                        return;
+                    }
+                }
+
+                // Type-dispatched setter
+                var sMetaName = oControl.getMetadata && oControl.getMetadata().getName();
+                try {
+                    if (sMetaName === "sap.m.ComboBox" || sMetaName === "sap.m.Select") {
+                        oControl.setSelectedKey(sValue);
+                    } else if (sMetaName === "sap.m.DatePicker") {
+                        // sValue is an ISO string from the LLM — setDateValue(Date) is the
+                        // reliable setter regardless of the control's displayFormat/valueFormat config.
+                        // setValue() silently rejects ISO strings when valueFormat is not set.
+                        var oDate = new Date(sValue);
+                        if (!isNaN(oDate.getTime())) {
+                            oControl.setDateValue(oDate);
+                        } else {
+                            oControl.setValue(sValue); // fallback: locale-format string
+                        }
+                    } else if (sMetaName === "sap.m.DateRangeSelection") {
+                        // For DateRangeSelection the LLM produces a single value (start date).
+                        // Use setDateValue for the same reason as DatePicker.
+                        var oRangeDate = new Date(sValue);
+                        if (!isNaN(oRangeDate.getTime())) {
+                            oControl.setDateValue(oRangeDate);
+                        } else {
+                            oControl.setValue(sValue);
+                        }
+                    } else if (sMetaName === "sap.m.RatingIndicator") {
+                        oControl.setValue(parseInt(sValue, 10));
+                    } else if (typeof oControl.setValue === "function") {
+                        oControl.setValue(sValue);
+                    } else {
+                        oLogger.warning("EasyFilterBarHandler: no setter found for control type '" + sMetaName + "' on custom filter '" + sKey + "'");
+                    }
+                } catch (e) {
+                    oLogger.error("EasyFilterBarHandler: error setting value on custom filter '" + sKey + "': " + e.message);
+                }
+            });
+        }
+
         /**
          * Event handler for the EasyFilterBarContainer's tokensChangedByUser event.
          * Fired when the user manually deletes or modifies a token (distinct from AI-resolved tokens).
@@ -966,15 +1303,229 @@ sap.ui.define([
         }
 
 		/**
-		 * Event handler for the EasyFilter control's showValueHelp event.
-		 * Identifies the input field for which the value help is requested and triggers the value help opening from SFB.
-		 * @param {sap.ui.base.Event} oEvent - The showValueHelp event fired by the EasyFilter control
-		 * @param {object} oState - The current controller state object
+		 * Main handler for the complexFilterApplied event fired by EasyFilterBarContainer (V2).
+		 * Two paths, distinguished by the event params:
+		 *   Simplified   — conditions[] present: mapped to AI-token shape and routed through
+		 *                  fnTokensChanged, which writes them into the SmartFilterBar (setState) and
+		 *                  triggers search(). They are applied via the SFB's own selectOptions, not
+		 *                  injected in onBeforeRebindTable. oComplexFilter is cleared.
+		 *   Non-simplified — currentFilterExpression present: built into a sap.ui.model.Filter tree
+		 *                  via fnBuildFilterFromExpression() and stored in oComplexFilter. Injection
+		 *                  happens in onBeforeRebindTable (ControllerImplementation) so it persists
+		 *                  across all subsequent rebinds (sort, group, pagination) without re-hooking.
 		 */
+		function fnBuildFilterFromExpression(oExpr) {
+			if (!oExpr) { return null; }
+			if (oExpr.AND) {
+				return new Filter({ filters: oExpr.AND.map(fnBuildFilterFromExpression).filter(Boolean), and: true });
+			}
+			if (oExpr.OR) {
+				return new Filter({ filters: oExpr.OR.map(fnBuildFilterFromExpression).filter(Boolean), and: false });
+			}
+			// Leaf node format: { FieldName: [["OPERATOR", "value"], ...], ... }
+			// A leaf may carry MORE THAN ONE field key — the EasyFilterBarContainer emits a
+			// multi-field leaf to mean "FieldA AND FieldB" (FilterExpressionLeaf is a
+			// Record<string, conditions[]>). Build a Filter per field and AND them together.
+			// Within a single field, multiple tuples are OR'd together.
+			var aKeys = Object.keys(oExpr);
+			if (!aKeys.length) { return null; }
+			var fnBuildFieldFilter = function(sField) {
+				var aTuples = oExpr[sField];
+				if (!Array.isArray(aTuples) || !aTuples.length) { return null; }
+				if (aTuples.length === 1) {
+					return new Filter({ path: sField, operator: aTuples[0][0], value1: aTuples[0][1], value2: aTuples[0][2] });
+				}
+				// Multiple tuples → OR them within the same field.
+				return new Filter({
+					filters: aTuples.map(function(aTuple) {
+						return new Filter({ path: sField, operator: aTuple[0], value1: aTuple[1], value2: aTuple[2] });
+					}),
+					and: false
+				});
+			};
+			var aFieldFilters = aKeys.map(fnBuildFieldFilter).filter(Boolean);
+			if (!aFieldFilters.length) { return null; }
+			if (aFieldFilters.length === 1) { return aFieldFilters[0]; }
+			// Multiple fields in one leaf → AND them together.
+			return new Filter({ filters: aFieldFilters, and: true });
+		}
+
+		function fnComplexFilterApplied(oEvent) {
+			var aSorters     = oEvent.getParameter("sorters")     || [];
+			var aGroupLevels = oEvent.getParameter("groupLevels") || [];
+			fnApplySortersToTable(aSorters);
+			fnApplyGroupLevelsToTable(aGroupLevels);
+
+			var aConditions = oEvent.getParameter("conditions");   // undefined on non-simplified path
+
+			// Clear previous state before storing new one.
+			oComplexFilter = null;
+
+			if (Array.isArray(aConditions)) {
+				// Snapshot the applied simplified conditions: used on switch-back to detect
+				// whether the user diverged the SFB from this applied state and should see the dirty overlay.
+				aAppliedEasyFilterConditions = aConditions.map(function(oCondition) {
+					return {
+						field: oCondition.field,
+						operator: oCondition.operator,
+						values: (Array.isArray(oCondition.values) ? oCondition.values : [oCondition.values]).slice()
+					};
+				});
+				// Simplified path: conditions can be expressed as classic SFB filters.
+				// Map them to the AI-token shape and route through fnTokensChanged so they are
+				// written into the SmartFilterBar (setState) — this keeps the SFB fields populated
+				// and visible on switch to classic. (The control suppresses tokensChanged on the V2
+				// path, so without this the SFB stays empty.) fnTokensChanged also triggers search().
+				var aTokens = aConditions.map(function(oCondition) {
+					var aVals = Array.isArray(oCondition.values) ? oCondition.values : [oCondition.values];
+					return {
+						key: oCondition.field,
+						keySpecificSelectedValues: [{ operator: oCondition.operator, selectedValues: aVals }]
+					};
+				});
+				fnTokensChanged({
+					getParameter: function(sParam) {
+						if (sParam === "reset") { return false; }
+						if (sParam === "tokens") { return aTokens; }
+						return undefined;
+					}
+				});
+				return;
+			}
+
+			// Non-simplified path: cannot be represented as classic SFB conditions (cross-field OR,
+			// universal lambda). Build a Filter tree and inject it via onBeforeRebindTable.
+			// No simplified SFB snapshot applies here — clear it so switch-back doesn't use stale data.
+			// Non-simplified path — clear snapshot so switch-back doesn't use stale data.
+			aAppliedEasyFilterConditions = null;
+			// [BUG-07] Clear stale SFB selectOptions from a prior simplified query before setting oComplexFilter.
+			var oSmartFilterBarWrapper = oTemplateUtils.oCommonUtils.getControlStateWrapperById(oState.oSmartFilterbar.getId(), "SmartFilterBar");
+			var oSFBState = oSmartFilterBarWrapper.getState();
+			oSFBState.selectOptions = [];
+			if (oSFBState.customFilters && oSFBState.customFilters.appExtension) {
+				Object.keys(oSFBState.customFilters.appExtension).forEach(function(sKey) {
+					oSFBState.customFilters.appExtension[sKey] = "";
+				});
+			}
+			oSmartFilterBarWrapper.setState(oSFBState);
+
+			var oExpression = oEvent.getParameter("currentFilterExpression");
+			// TODO: remove fallback once updated EasyFilterBarContainer bundle is deployed to all systems.
+			// Deployed bundle on older servers predates the commit that added currentFilterExpression to
+			// the complexFilterApplied event payload — fall back to reading it from the control instance.
+			if (!oExpression) {
+				oExpression = oEvent.getSource() && oEvent.getSource().currentFilterExpression;
+			}
+			if (oExpression) {
+				oComplexFilter = fnBuildFilterFromExpression(oExpression);
+			} else {
+				oLogger.warning("fnComplexFilterApplied: currentFilterExpression is empty — non-simplified filter not applied.");
+			}
+
+			oState.oSmartFilterbar.search();
+		}
+
+		/**
+		 * Decide whether switching back from classic SFB to EasyFilter should mark the table
+		 * dirty (grey overlay) — only when the current classic filter conditions diverge from
+		 * the applied EasyFilter conditions.
+		 *
+		 * Returns true ONLY when a simplified EasyFilter result was applied (snapshot present) AND the
+		 * SFB's current filter state no longer matches that snapshot (user changed it in classic mode).
+		 * When they match, or when nothing was applied, returns false so switching alone never greys the
+		 * table (no false-overlay regression).
+		 * @returns {boolean}
+		 */
+		function fnIsTableDirtyOnSwitchBack() {
+			if (!aAppliedEasyFilterConditions || !aAppliedEasyFilterConditions.length) {
+				return false; // nothing was applied via EasyFilter -> classic is authoritative, no overlay
+			}
+			// Normalize date values to YYYY-MM-DD — applied snapshot stores ISO strings,
+			// SFB Ranges[].Low/High may be UI5 Date objects with locale-dependent String() output.
+			var fnNormDateToISO = function(v) {
+				var s = String(v);
+				var oISO = s.match(/^(\d{4}-\d{2}-\d{2})/);
+				if (oISO) { return oISO[1]; }
+				var d = new Date(s);
+				if (!isNaN(d.getTime())) {
+					return d.getUTCFullYear() + "-" + String(d.getUTCMonth() + 1).padStart(2, "0") + "-" + String(d.getUTCDate()).padStart(2, "0");
+				}
+				return s;
+			};
+			var fnNormalizeApplied = function(aConds) {
+				var m = {};
+				aConds.forEach(function(oCond) {
+					var aVals = (Array.isArray(oCond.values) ? oCond.values : [oCond.values]).map(fnNormDateToISO);
+					m[oCond.field] = (m[oCond.field] || []).concat(aVals);
+				});
+				Object.keys(m).forEach(function(k) { m[k] = m[k].slice().sort(); });
+				return m;
+			};
+			var fnNormalizeSelectOptions = function(aSelectOptions) {
+				var m = {};
+				(aSelectOptions || []).forEach(function(oSO) {
+					if (!oSO || !oSO.PropertyName || !Array.isArray(oSO.Ranges)) { return; }
+					// Skip SFB-internal / non-filter pseudo-entries that the SmartFilterBar adds to its
+					// own selectOptions (e.g. "<entitySet>.basicSearch", "$"-prefixed, "_CUSTOM"). These are
+					// not OData filter fields and must not count as divergence (would cause a false overlay).
+					if (oSO.PropertyName.indexOf("basicSearch") > -1 ||
+						oSO.PropertyName.charAt(0) === "$" ||
+						oSO.PropertyName.indexOf("_CUSTOM") > -1) { return; }
+					var aVals = [];
+					oSO.Ranges.forEach(function(oRange) {
+						aVals.push(fnNormDateToISO(oRange.Low));
+						if (oRange.High && oRange.High !== oRange.Low) { aVals.push(fnNormDateToISO(oRange.High)); }
+					});
+					m[oSO.PropertyName] = (m[oSO.PropertyName] || []).concat(aVals);
+				});
+				Object.keys(m).forEach(function(k) { m[k] = m[k].slice().sort(); });
+				return m;
+			};
+			var oApplied = fnNormalizeApplied(aAppliedEasyFilterConditions);
+			var oSmartFilterBarWrapper = oTemplateUtils.oCommonUtils.getControlStateWrapperById(oState.oSmartFilterbar.getId(), "SmartFilterBar");
+			var oCurrentState = oSmartFilterBarWrapper.getState();
+			var oCurrent = fnNormalizeSelectOptions(oCurrentState && oCurrentState.selectOptions);
+			// Diverged if the field sets differ or any field's value set differs.
+			var aAppliedKeys = Object.keys(oApplied);
+			if (aAppliedKeys.length !== Object.keys(oCurrent).length) { return true; }
+			return aAppliedKeys.some(function(sField) {
+				var aA = oApplied[sField] || [];
+				var aC = oCurrent[sField] || [];
+				return aA.length !== aC.length || aA.some(function(v, i) { return v !== aC[i]; });
+			});
+		}
+
+
 		function fnShowValueHelp(oEvent) {
 			var oSmartFilterbar = oState.oSmartFilterbar;
             var sKey = oEvent.getParameter("key");
             fnValueHelpPromiseResolve = oEvent.getParameter("resolve");
+
+            // For custom filters (isCustomFilter:true), the SFB has no value help dialog.
+            // Resolve immediately with the codeList items so EasyFilter can show them as suggestions.
+            if (oEasyFilterMetadata) {
+                var oFieldMeta = oEasyFilterMetadata.fields.find(function(oField) { return oField.name === sKey; });
+                if (oFieldMeta && oFieldMeta.isCustomFilter) {
+                    if (typeof fnValueHelpPromiseResolve === "function") {
+                        if (Array.isArray(oFieldMeta.codeList)) {
+                            var aTokens = oFieldMeta.codeList.map(function(oEntry) {
+                                return {
+                                    operator: "EQ",
+                                    selectedValues: [{ value: String(oEntry.value), description: oEntry.description || String(oEntry.value) }]
+                                };
+                            });
+                            fnValueHelpPromiseResolve(aTokens);
+                        } else {
+                            // No fixed item list (e.g. DatePicker, free-text Input) — resolve with empty
+                            // so the caller's promise does not hang.
+                            fnValueHelpPromiseResolve([]);
+                        }
+                        fnValueHelpPromiseResolve = null;
+                    }
+                    return; // Skip SFB value help entirely for custom filters
+                }
+            }
+
 			oSmartFilterbar.associateValueLists();
             try {
                 oSmartFilterbar.ensureLoadedValueHelp(sKey);
@@ -1186,8 +1737,12 @@ sap.ui.define([
             handleVariantLoad : fnHandleVariantLoad,
             onDataFetcher,
             getLoadedVariantFilterMode: function() { return sLoadedVariantFilterMode; },
+            getComplexFilter: function() { return oComplexFilter; },
+            isTableDirtyOnSwitchBack: fnIsTableDirtyOnSwitchBack,
+            hasAppliedEasyFilterConditions: function() { return !!(aAppliedEasyFilterConditions && aAppliedEasyFilterConditions.length); },
             attachSmartTableStateChangeHandler: fnAttachSmartTableStateChangeHandler,
-            detachSmartTableStateChangeHandler: fnDetachSmartTableStateChangeHandler
+            detachSmartTableStateChangeHandler: fnDetachSmartTableStateChangeHandler,
+            onComplexFilterApplied: fnComplexFilterApplied
         };
     }