@sapui5/sap.suite.ui.generic.template 1.126.0 → 1.127.1

package/src/sap/suite/ui/generic/template/lib/CommonEventHandlers.js

@@ -1322,16 +1322,19 @@ sap.ui.define(["sap/ui/base/Object",
 			var oSmartTableHandler = oServices.oPresentationControlHandlerFactory.getPresentationControlHandler(oSmartTable);
 			var oTable = oSmartTable.getTable();
 			var aItems = oTable.getRows ? oTable.getRows() : oTable.getItems();
-			aItems.forEach(function(oItem) {
-				var oColumn = oSmartTableHandler.getColumnByKey(sColumnKey);
-				var oCell = oColumn && oItem.getCells()[oTable.indexOfColumn(oColumn)];
-				oCell && oCell.bindProperty("visible", {
-					path: sPath,
-					formatter: function (bIsHidden) {
-						return !bIsHidden;
-					}
+			var oColumn = oSmartTableHandler.getColumnByKey(sColumnKey);
+			//if the column is visible in the table, then only we bind the visible property of the cell
+			if (oColumn && oColumn.getVisible()){
+				aItems.forEach(function(oItem) {
+					var oCell = oItem.getCells()[oTable.indexOfColumn(oColumn)];
+					oCell && oCell.bindProperty("visible", {
+						path: sPath,
+						formatter: function (bIsHidden) {
+							return !bIsHidden;
+						}
+					});
 				});
-			});
+			}
 		}
 
 		// callback for the onBeforeRebindTable event of a smart table
@@ -1350,6 +1353,7 @@ sap.ui.define(["sap/ui/base/Object",
 			var oSmartTable = oEvent.getSource();
 			var oTable = oSmartTable.getTable();
 			var bIsMTable = controlHelper.isMTable(oTable);
+			var bIsTreeTable = controlHelper.isTreeTable(oTable);
 			var oColumns = oTable.getColumns();
 
 			if (!oCallbacks || (oCallbacks && oCallbacks.isPopinWithoutHeader) && bIsMTable) { //Setting popin display without header
@@ -1374,6 +1378,12 @@ sap.ui.define(["sap/ui/base/Object",
 				};
 			}
 
+			//For tree table, set the parameters "rootLevel" and "numberOfExpandedLevels"
+			if (bIsTreeTable) {
+				oBindingParams.parameters.rootLevel = oBindingParams.parameters.rootLevel || 0;
+				oBindingParams.parameters.numberOfExpandedLevels = oBindingParams.parameters.numberOfExpandedLevels || oCallbacks.numberOfExpandedLevels || 0;
+			}
+
 			//Get all the CustomData associated with Smarttable and create an object which is a key value pair of each custom data
 			var aCustomData = oSmartTable.getCustomData();
 			var oCustomData = {};
@@ -1505,7 +1515,6 @@ sap.ui.define(["sap/ui/base/Object",
 					var oLineItems = oEntityType[sLineItemAnnotation] || []; // some tests in safety net run without any lineitem annotation - seems to work somehow at least for tree table;
 					for (var index = 0; index < oLineItems.length; index++) {
 						switch (oLineItems[index].RecordType) {
-							default: break;
 							case "com.sap.vocabularies.UI.v1.DataFieldWithIntentBasedNavigation":
 							case "com.sap.vocabularies.UI.v1.DataFieldWithNavigationPath":
 								var aDataFieldsWithNavigation = fnGetDataFieldsWithNavigation(oLineItems[index], oMetaModel, oEntityType);
@@ -1540,6 +1549,7 @@ sap.ui.define(["sap/ui/base/Object",
 									}
 								}
 								break;
+							default: break;
 						}
 					}
 
@@ -2645,6 +2655,47 @@ sap.ui.define(["sap/ui/base/Object",
 			oController.onBeforeExportTableExtension(oExportParams);
 		}
 
+		/**
+		 * This method is called when the user interacts with EasyFilter field (Enter on the input field or Go button press).
+		 * The AI easy filter is triggered and the result filters are applied to the SmartFilterBar.
+		 * @param {object} oEasyFilterInputField - The EasyFilter input field which has the value entered by the user
+		 * @param {object} oState - oState of the component
+		 */
+		function fnHandleEasyFilterChange(oEasyFilterInputField, oState) {
+
+			var oSmartFilterbar = oState.oSmartFilterbar;
+			FESRHelper.setSemanticStepname(oEasyFilterInputField, "press", "fe2:ai:search");
+			var oAIFilterQueryHandlerPromise = oState.oEasyFilterBarHandler.triggerEasyFilterQuery(oEasyFilterInputField, oSmartFilterbar);
+
+			oAIFilterQueryHandlerPromise.then(function(oFiltersFromAI) {
+
+				var sSmartFilterBarId = oSmartFilterbar.getId();
+				var oSmartFilterBarWrapper = oCommonUtils.getControlStateWrapperById(sSmartFilterBarId, "SmartFilterBar");
+				var oSmartFilterBarVariant = oSmartFilterBarWrapper.getState();
+				var oVariantDataFromAI = oState.oEasyFilterBarHandler.getSFBVariantData(oFiltersFromAI);
+
+				// restore the custom filters to the initial state for now
+				// To check if other objects in oSmartFilterBarVariant needs to be modified
+				var aAppExtension = Object.keys(oSmartFilterBarVariant.customFilters.appExtension);
+				if ( aAppExtension.length > 0 ) {
+					aAppExtension.forEach(function(sKey) {
+						oSmartFilterBarVariant.customFilters.appExtension[sKey] = "";
+					});
+				}
+				oSmartFilterBarVariant.selectOptions = oVariantDataFromAI.aSelectOptions;
+				if (oComponentUtils.isDraftEnabled()) {
+					oSmartFilterBarVariant.customFilters.editState = oVariantDataFromAI.oEditStateFilter;
+				}
+
+				oSmartFilterBarWrapper.setState(oSmartFilterBarVariant);
+				oSmartFilterbar.getSmartVariant() && oSmartFilterbar.getSmartVariant().currentVariantSetModified(true);
+				oSmartFilterbar.search();
+			}, function(oError) {
+				oLogger.error("Error occurred while applying the AI filters", oError);
+			});
+			oComponentUtils.getBusyHelper().setBusy(oAIFilterQueryHandlerPromise);
+		}
+
 		/* eslint-disable */
 		var fnBuildSelectionVariantForNavigation = testableHelper.testable(fnBuildSelectionVariantForNavigation, "fnBuildSelectionVariantForNavigation");
 		var fnEvaluateParameters = testableHelper.testable(fnEvaluateParameters, "fnEvaluateParameters");
@@ -2695,7 +2746,8 @@ sap.ui.define(["sap/ui/base/Object",
 			handleSideEffectForField: fnHandleSideEffectForField,
 			onSmartFieldModeToggled: onSmartFieldModeToggled,
 			onRenderTeamsContactCollabOptions: fnRenderTeamsContactCollabOptions,
-			hideTableCells: fnHideTableCells
+			hideTableCells: fnHideTableCells,
+			onEasyFilterChange: fnHandleEasyFilterChange
 		};
 	}
 

package/src/sap/suite/ui/generic/template/lib/ContactCardDetailHelper.js

@@ -55,7 +55,7 @@ sap.ui.define([
                 },
                 afterOpen: function (oEvent) {
                     var oPopover = oEvent.getSource();
-                    var oToolbar = oPopover.getContent()[0].getItems()[1].getItems()[1];
+                    var oToolbar = oPopover.getContent()[0].getItems()[1].getItems()[0];
                     oToolbar.getContent().forEach(function(oItem){
                         if (controlHelper.isButton(oItem)) {
                             var sType = oItem.data("type");

package/src/sap/suite/ui/generic/template/lib/ContextMenuHandler.js

@@ -28,14 +28,14 @@ sap.ui.define([
 		//Type definitions
 
 		/**
-		 * @typedef {Object} FocusInfo Information about the applicable records for the context menu
+		 * @typedef {object} sap.suite.ui.generic.template.lib.ContextMenuHandler.FocusInfo Information about the applicable records for the context menu
 		 * @property {sap.ui.model.Context} focussedBindingContext - Binding context of the currently focussed row
 		 * @property {Array<sap.ui.model.Context>} applicableContexts - Array of contexts applicable to the context menu
 		 * @property {boolean} doesApplicableEqualSelected - If the focussed row is part of selected rows
 		 */
 
 		/**
-		 * @typedef {Object} ContextMenuEntry Context menu entry
+		 * @typedef {object} sap.suite.ui.generic.template.lib.ContextMenuHandler.ContextMenuEntry Context menu entry
 		 * @property {string} text - Text
 		 * @property {string} icon - Icon
 		 * @property {string} key - Uniquely identifiable key
@@ -79,12 +79,12 @@ sap.ui.define([
 		 *  Note: When the current entry has children, please pass "oHandlerPromise" as null.
 		 * 
 		 * @param {string} sPathToItems Binding path for the items
-		 * @param {Array<ContextMenuEntry>} aItems Array which stores all context menu entries
+		 * @param {Array<sap.suite.ui.generic.template.lib.ContextMenuHandler.ContextMenuEntry>} aItems Array which stores all context menu entries
 		 * @param {string} sText Text of the context menu item
 		 * @param {string} sIcon Icon for the context menu item
 		 * @param {boolean} bStartsSection Defines whether a visual separator should be rendered before the item
 		 * @param {Promise<Function|boolean>} oHandlerPromise Optional parameter. A promise which resolves the press handler method to the current menu item
-		 * @param {Array<ContextMenuEntry>} aChildren Child entries for the current menu item
+		 * @param {Array<sap.suite.ui.generic.template.lib.ContextMenuHandler.ContextMenuEntry>} aChildren Child entries for the current menu item
 		 */
 		function fnAddMenuItem(sPathToItems, aItems, sText, sIcon, bStartsSection, oHandlerPromise, aChildren){
 			iCreatedMenuItemsCounter++;
@@ -261,8 +261,8 @@ sap.ui.define([
 
 		/**
 		 * Adds the toolbar buttons and menu buttons to the context menu
-		 * @param {FocusInfo} oFocusInfo Focus info
-		 * @param {Array<ContextMenuEntry>} aItems Array of context menu items
+		 * @param {sap.suite.ui.generic.template.lib.ContextMenuHandler.FocusInfo} oFocusInfo Focus info
+		 * @param {Array<sap.suite.ui.generic.template.lib.ContextMenuHandler.ContextMenuEntry>} aItems Array of context menu items
 		 */
 		function fnAddToolbarButtonsToContextMenu(oFocusInfo, aItems){
 			var aStandardActions = oCommonUtils.getToolbarCustomData(oSourceControl);
@@ -356,9 +356,8 @@ sap.ui.define([
 		/**
 		 * Opens all the eligible contexts in new tab.
 		 * Also, validates the maximum allowed number of records to be opened.
-		 * @param {FocusInfo} oFocusInfo 
+		 * @param {sap.suite.ui.generic.template.lib.ContextMenuHandler.FocusInfo} oFocusInfo 
 		 * @param {Array<sap.ui.model.Context>} aNavigableContexts 
-		 * @returns 
 		 */
 		function fnOpenNavigableContextsInNewTab (oFocusInfo, aNavigableContexts) {
 			if (oFocusInfo.applicableContexts.length > MAX_RECORDS_OPEN_IN_NEW_TAB) {
@@ -396,7 +395,7 @@ sap.ui.define([
 		 *   c. The controller is configured with onListNavigationExtension (i.e custom navigation logic written by app).
 		 * //TODO: These negative scenarios need to be revisited
 		 * 
-		 * @param {FocusInfo} oFocusInfo 
+		 * @param {sap.suite.ui.generic.template.lib.ContextMenuHandler.FocusInfo} oFocusInfo 
 		 * @returns {Promise<Function|undefined>} Promise which resolves the handler method
 		 */
 		function getHandlePromiseForOpenInNewTab (oFocusInfo) {
@@ -419,8 +418,8 @@ sap.ui.define([
 
 		/**
 		 * Adds "Open in wew tab/window" entry to context menu
-		 * @param {FocusInfo} oFocusInfo 
-		 * @param {Array<ContextMenuEntry>} aItems 
+		 * @param {sap.suite.ui.generic.template.lib.ContextMenuHandler.FocusInfo} oFocusInfo 
+		 * @param {Array<sap.suite.ui.generic.template.lib.ContextMenuHandler.ContextMenuEntry>} aItems 
 		 */
 		function fnAddOpenInNewTabToContextMenu(oFocusInfo, aItems) {
 			var oHandlePromise = getHandlePromiseForOpenInNewTab(oFocusInfo);
@@ -450,7 +449,7 @@ sap.ui.define([
 			oTemplatePrivateModel.setProperty(sModelPath + "/items", aContextMenuItems);
 			if (aContextMenuItems.length === 0) {
 				oEvent.preventDefault();
-			}			
+			}
 		}
 
 		function onContextMenu(oEvent){

package/src/sap/suite/ui/generic/template/lib/CreateWithDialogHandler.js

@@ -172,8 +172,8 @@ sap.ui.define([
 			if (!oPredefinedValues) {
 				var oGetDefaultValuesPromise = oTemplateUtils.oServices.oCRUDManager.getDefaultValues(oEventSource, oPredefinedValues);
 				if (oGetDefaultValuesPromise instanceof Promise) {
-					var fnGetPredefinedValues = function (aResponse) {
-						openDialog(oCreateWithDialog, oEventSource, aResponse[0], oTable, oParentContext);
+					var fnGetPredefinedValues = function (mDefaultValues) {
+						openDialog(oCreateWithDialog, oEventSource, mDefaultValues, oTable, oParentContext);
 					};
 					oGetDefaultValuesPromise.then(fnGetPredefinedValues, fnGetPredefinedValues);
 				} else {

package/src/sap/suite/ui/generic/template/lib/PageLeaveHandler.js

@@ -37,23 +37,23 @@ sap.ui.define(["sap/ui/base/Object",
 				onDraftPopupOk: function () {
 					var selectedItem = getSelectedKey(oDraftPopup);
 					switch (selectedItem) {
-						case "draftPopupOptionSave": {
+						case "draftPopupOptionSave":
 							var oBeforeSavePromise = Promise.resolve(getComponent().oController.beforeSaveExtension());
 							oBeforeSavePromise.then(fnSaveDraft.bind(null, oTemplateContract, sMode), Function.prototype);
 							oDraftPopup.close();
-						} break;
-						case "draftPopupOptionKeep": {
+							break;
+						case "draftPopupOptionKeep":
 							oTemplateContract.oAppComponent.getApplicationController().synchronizeDraftAsync().then(function() {
 								fnOnDiscardOrKeepDraftConfirmed();
 							}).finally(function() {
 								oDraftPopup.close();
 							});
-						} break;
-						case "draftPopupOptionDiscard": {
+							break;
+						case "draftPopupOptionDiscard":
 							var discardDraftPromise = fnDiscardDraft(sMode).then(fnOnDiscardOrKeepDraftConfirmed);
 							discardDraftPromise.catch(fnOnDiscardOrKeepDraftCancel);
 							oDraftPopup.close();
-						} break;
+							break;
 						default:
 							break;
 					}

package/src/sap/suite/ui/generic/template/lib/SideEffectUtil.js

@@ -12,9 +12,9 @@ sap.ui.define(["sap/suite/ui/generic/template/js/AnnotationHelper",
 
 	/***
 	 * To trigger side effect on value change , only the fieldGroup Ids of single source property is required
-	 * @param {*} oSmartField
+	 * @param {sap.ui.comp.smartfield.SmartField} oSmartField
 	 * @param {*} oComputedMetaData
-	 * @returns : array of fieldGroupID assigned for a property (oComputedMetaData.path)
+	 * @returns {string[]|null} array of fieldGroupID assigned for a property (oComputedMetaData.path)
 	 */
 	function fnGetFieldGroupIdOnlyForSingleSource(oSmartField, oComputedMetaData) {
 		var oSideEffect;
@@ -88,12 +88,10 @@ sap.ui.define(["sap/suite/ui/generic/template/js/AnnotationHelper",
 	 * Triggers side effect from generic template layer for a field. This method gets triggerd from two sources
 	 * 	1. changeModelValue (SmartField)
 	 * 	2. fieldChange (SmartTable) - in this case get the source smart field from 'changeEvent'
-	 * @param {*} oEvent
+	 * @param {sap.ui.base.Event} oEvent
 	 * @param {*} oComponentUtils
-	 * @param {*} bIsSideEffectTypeComputed
-	 * @returns
+	 * @param {boolean} bIsSideEffectTypeComputed
 	 */
-
 	function fnHandleSideEffectForField(oEvent, oComponentUtils, bIsSideEffectTypeComputed) {
 		
 		if (!oComponentUtils.isDraftEnabled()) {
@@ -114,7 +112,7 @@ sap.ui.define(["sap/suite/ui/generic/template/js/AnnotationHelper",
 
 	/**
 	 * Calculate and assign fieldGroup Id(s) for a smart Field
-	 * @param {*} oSmartField
+	 * @param {sap.ui.comp.smartfield.SmartField} oSmartField
 	 * @param {*} oMetaModel
 	 * @param {*} sEntitySet
 	 */

package/src/sap/suite/ui/generic/template/lib/TemplateAssembler.js

@@ -274,6 +274,7 @@ sap.ui.define(["sap/ui/core/mvc/ControllerExtension",
 						oTemplateUtils.oServices.oApplicationController.registerView(oView);
 						oTemplateUtils.oServices.oDataLossHandler = oAppRegistryEntry.oTemplateContract.oDataLossHandler;
 						oTemplateUtils.oServices.oInsightsFECardProvider = oAppRegistryEntry.oTemplateContract.oInsightsFECardProvider;
+						oTemplateUtils.oServices.oFioriAIHandler = oAppRegistryEntry.oTemplateContract.oFioriAIHandler;
 						oTemplateUtils.oCommonUtils = new CommonUtils(oRet, oTemplateUtils.oServices, oTemplateUtils.oComponentUtils);
 						oTemplateUtils.oInfoObjectHandler = new InfoObjectHandler(oRet, oTemplateUtils);
 						oTemplateUtils.oServices.oCRUDManager = new CRUDManager(oRet,

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

@@ -0,0 +1,323 @@
+sap.ui.define([
+    "sap/ui/base/Object",
+    "sap/base/util/extend",
+    "sap/suite/ui/generic/template/lib/filterHelper",
+    "sap/ui/core/library"
+], function(BaseObject, extend, filterHelper, SapCoreLibrary) {
+    'use strict';
+
+    /*
+     * This is a handler class for EasyFilterBar.
+     * It gets initialized when the Fiori AI is enabled and provides the EasyFilterBar capabilities to the floorplan.
+     * 
+     */
+    var oEasyFilterMetadata;
+
+    function getMethods(oState, oController, oTemplateUtils) {
+        var ValueState = SapCoreLibrary.ValueState;
+        var mCodeList = {};
+
+        /**
+         * This method prepares the metadata calculation after the smart filter bar is initialized
+         * @returns A promise which returns the prepared metadata
+         */
+        function fnGetEasyFilterSearchMetadata() {
+            if (oEasyFilterMetadata) {
+                return Promise.resolve(oEasyFilterMetadata);
+            } else {
+                return new Promise(function(fnResolve) {
+                    // In case the smart filter bar is already initialized then do not use "attachInitialized" as this event will never get triggered again
+                    if (oState.oSmartFilterbar.isInitialised()) {
+                        fnPrepareSearchMetadata().then(function(oMetadata){
+                                fnResolve(oMetadata);
+                            }
+                        );
+                    } else {
+                        oState.oSmartFilterbar.attachInitialized(function() {
+                            fnPrepareSearchMetadata().then(function(oMetadata) {
+                                fnResolve(oMetadata);
+                            });
+                        },this);
+                    }
+                });
+            }
+        }
+        /**
+         * This method prepares the metadata for each filterable field from the smart filter bar
+         *
+         * @returns Filterbar metadata which is required for the EasyFilter search
+         */
+        function fnPrepareSearchMetadata()  {
+
+            var aPromise = [];
+            var oOwnerFilterControl = oState.oSmartFilterbar;
+            var oSFBModel = oOwnerFilterControl.getModel();
+            var oSFBMetaModel = oSFBModel.getMetaModel();
+            var oEditStateFilterItem;
+            var sEntitySet = oController.getOwnerComponent().getEntitySet();
+
+            var mFilterProperties = {}; // todo : Add the properties from navigation entites
+            var oEntityType = oTemplateUtils.oCommonUtils.getMetaModelEntityType(sEntitySet);
+            oEntityType.property.map(function (oProperty) {
+                if (filterHelper.isPropertyFilterable(oProperty)) {
+                    var bIsCodeListRequired = "";
+                    oProperty.extensions && oProperty.extensions.forEach(function(oExtension) {
+                        if (oExtension.name === "value-list" && oExtension.value === "fixed-values") {
+                            bIsCodeListRequired = true;
+                        }
+                    });
+                    mFilterProperties[oProperty.name] = {
+                        name: oProperty.name,
+                        //label: oProperty.label,  Name is added from the filter item control
+                        dataType: oProperty.type,
+                        filterable: true,
+                        sortable: false,
+                        codeList : bIsCodeListRequired
+                        //,required: oProperty.required (TO-DO)
+                    };
+                }
+            });
+
+            oEasyFilterMetadata = {
+                version: 1,
+                entitySet: sEntitySet,
+                fields : []
+            };
+
+            oOwnerFilterControl.getAllFilterItems().forEach(function (oFilterItem) {
+                //check if the filter item from the filter control is a property of the entity type , if then push it to the easy filter metadata
+                // todo : Add the properties from navigation entites
+                var oFilterItemForQuery = mFilterProperties[oFilterItem.getName()];
+                if (oFilterItemForQuery) {
+                    oFilterItemForQuery.label = oFilterItem.getLabel();
+                    // codeList is set to true for fixed value list and codelist is fetched
+                    if (oFilterItemForQuery.codeList) {
+                        var oProperty = oSFBMetaModel.getODataProperty(oEntityType, oFilterItemForQuery.name , true);
+                        var oPropertyContext = oSFBMetaModel.createBindingContext(oProperty);
+                        var oVHPromise = oSFBMetaModel.getODataValueLists(oPropertyContext);
+                        aPromise.push(oVHPromise);
+                        oVHPromise.then(function(oValueList) {
+                            if (mCodeList[oFilterItemForQuery.name]) {
+                                oFilterItemForQuery.codeList = mCodeList[oFilterItemForQuery.name];
+                            } else {
+                                oFilterItemForQuery.codeList = function() {
+                                    return fnGetValueListValues(oFilterItemForQuery, oValueList, oSFBModel);
+                                };
+                            }
+                            oEasyFilterMetadata.fields.push(oFilterItemForQuery);
+                        });
+                    } else {
+                        oEasyFilterMetadata.fields.push(oFilterItemForQuery);
+                    }
+                } else if (oFilterItem.getName() === "EditState") {// For draft scenarios
+                    oEditStateFilterItem = oFilterItem;
+                }
+            });
+
+             // Adding Editing status filter
+             if (oTemplateUtils.oComponentUtils.isDraftEnabled()) {
+                var oEditStateControl = oController.byId("editStateFilter");
+                if (oEditStateControl) {
+                    var oEditingStatusCodeList = oEditStateControl.getItems().map(function(oItem) {
+                        return {
+                            value : oItem.getKey(),
+                            description : oItem.getText()
+                        };
+                    });
+                   var oEditStateFilterMetadata = {
+                        name: oEditStateFilterItem.getName(),
+                        label: oEditStateFilterItem.getLabel(),
+                        dataType: "Edm.String",
+                        filterable: true,
+                        required: false,
+                        sortable: false,
+                        codeList : oEditingStatusCodeList
+                    };
+                    oEasyFilterMetadata.fields.push(oEditStateFilterMetadata);
+                }
+            }
+
+            return Promise.allSettled(aPromise).then(function() {
+                return oEasyFilterMetadata;
+            });
+        }
+
+        /**
+         * This method is used to trigger the EasyFilter search of the fiori AI reuse library
+         * @param {*} oEasyFilterControl EasyFilter control of the floorplan
+         * @returns Promise which resolves to AI filters
+         */
+        function fnTriggerEasyFilterQuery(oEasyFilterControl) {
+
+            var sEasyFilterQuery = oEasyFilterControl.getValue();
+            if (sEasyFilterQuery.length === 0) {
+                // Resolving with an empty array will reset the SFB filters and trigger a fresh GET call
+                return Promise.resolve([]);
+            } else {
+                var oEasyFilterMetadataPromise = fnGetEasyFilterSearchMetadata();
+                var oResultPromise = new Promise(function(fnResolve, fnReject) {
+                    oEasyFilterMetadataPromise.then(function(oEasyFilterMetadata) {
+                        var oFioriAIFilterQueryPromise =  oTemplateUtils.oServices.oFioriAIHandler.fioriaiLib.EasyFilter.easyFilter(sEasyFilterQuery, oEasyFilterMetadata);
+                        oFioriAIFilterQueryPromise.then(function(oResponse) {
+                            if (oResponse.success) {
+                                if (oResponse.data.version === 1) {
+                                    // In cases where user filters with some random string and the no valuable filter is availabel then simply reject
+                                    if (oResponse.data.unclear || !oResponse.data.filter) {
+                                        var sUnclearInputMessage = oResponse.data.unclear ? "Unclear input: " + oResponse.data.unclear : "Unclear input";
+                                        oEasyFilterControl.setValueStateText(sUnclearInputMessage);
+                                        oEasyFilterControl.setValueState(ValueState.Warning);
+                                        fnReject(oResponse);
+                                    } else if (oResponse.data.filter) {
+                                        // Commenting out for v4 parity
+                                        //oEasyFilterControl.setValueState(ValueState.Success);
+                                        fnResolve(oResponse.data.filter);
+                                    }
+                                } else if (oResponse.data.version === 2) {
+                                    // to-do for version 2
+                                }
+                            }  else {
+                                oEasyFilterControl.setValueStateText(oResponse.message);
+                                oEasyFilterControl.setValueState(ValueState.Warning);
+                                fnReject(oResponse);
+                            }
+                        },fnReject);
+                    });
+                });
+                return oResultPromise;
+            }
+        }
+
+        /**
+         * This method reads the values of the valuehelp entity from the backend and fills the code list of each property.
+         * Once the values are filled then the fioriAI uses it for getting the ID of the user entered description in the search field
+         * 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
+         */
+        function fnGetValueListValues(oFilterItemForQuery, oValueList, oSFBModel) {
+
+            if (mCodeList[oFilterItemForQuery.name]) {
+                return mCodeList[oFilterItemForQuery.name];
+            }
+
+            return new Promise(function(fnResolve, fnReject) {
+
+                var oValueListDefaultBinding = oValueList[""];
+                // Cases where the default binding is not available ignore for now
+                if (oValueListDefaultBinding) {
+                    var sSelect = oValueListDefaultBinding.Parameters && oValueListDefaultBinding.Parameters.map(function(oParam) {
+                        return oParam.ValueListProperty.String;
+                    }).join(",");
+
+                    var fnSuccess = function(oResponse) {
+                        var mValueListData = [];
+                        oResponse.results && oResponse.results.forEach(function(oItem) {
+                            mValueListData.push({
+                                value : oItem[sValueProperty],
+                                description : sDescriptionProperty ? oItem[sDescriptionProperty] : undefined
+                            });
+                        });
+                        mCodeList[oFilterItemForQuery.name] = mValueListData;
+                        oEasyFilterMetadata.fields.forEach(function (oField) {
+                            if (oField.name === oFilterItemForQuery.name) {
+                                oField.codeList = mValueListData;
+                            }
+                         });
+                        fnResolve(mValueListData);
+                    };
+
+                    oSFBModel.read("/" + oValueListDefaultBinding.CollectionPath.String, {
+                        $select : sSelect,
+                        success : fnSuccess,
+                        error : fnReject
+                    });
+
+                    var sValueProperty;
+                    var sDescriptionProperty;
+
+                    oValueListDefaultBinding.Parameters && oValueListDefaultBinding.Parameters.forEach(function(oParam) {
+                        if (oParam.LocalDataProperty && (oParam.LocalDataProperty.PropertyPath === oFilterItemForQuery.name)) {
+                            sValueProperty = oParam.ValueListProperty.String;
+                        } else {
+                            sDescriptionProperty = oParam.ValueListProperty.String;
+                        }
+                    });
+                }
+            });
+        }
+
+        /**
+         * This method is used to convert the AI filters to the selectOptions for the SmartFilterBar
+         * It also identifies the values of edit state filter in case of draft
+         * @param {*} oAIFilters
+         * @returns array of selectOptions
+         */
+        function fnGetSFBVariantData(oAIFilters) {
+
+            // Each filter from AI will be converted to a selectOption and added to the SmartVariantManagement state
+            // Case 1 : AI Query "Show P1 = a"
+            // ------- AI response "P1 = Ranges [a]" .
+            // ------- Converted to selectOptions [ {Property = P1, Ranges = [ a ] } ].
+            // ------- Filtered as P1 = a.
+            // Case 1.a : AI Query "Show P1 = a , b"
+            // ------- AI response "P1 = Ranges [a, b]" .
+            // ------- Converted to selectOptions [ {Property = P1, Ranges = [ a, b ] } ] .
+            // ------- FE filters as "a or b".
+            // Case 1.b : AI Query "Show P1 between a and b"
+            // ------- AI response  " [P1 = Ranges [a] , P1 = Ranges [b]]".
+            // ------- Converted to selectOptions [ {Property = P1, Ranges = [ a ] } , {Property = P2, Ranges = [ b ] } ] .
+            // ------- FE filters as "a and b" but (todo) currently it is "a or b".
+            // Case 2 : AI Query "Show P1 = a and P2 = b"
+            // ------- AI response "[P1 = Ranges [a] , P2 = Ranges [b]]"
+            // ------- Convert to selectOptions [ {Property = P1, Ranges = [ a ] } , {Property = P2, Ranges = [ b ] } ].
+            // ------- FE filters as "a and b".
+
+            var aSelectOptions = [];
+            var oEditStateFilter = 0;
+            oAIFilters.forEach(function(oFilterItem) {
+
+                if ( oFilterItem.name === "EditState") {
+                    oEditStateFilter  = oFilterItem.values[0]; // Edit state generally should not have more than one filter value
+                } else {
+                    var oFilter = {
+                        PropertyName : oFilterItem.name,
+                        Ranges : []
+                    };
+                    oFilterItem.values.forEach(function (oValue) {
+                        var oRange = {
+                            Sign : "I", // currently not considering "E"
+                            High : "" // Usually for "BT" High is required, but AI provides two separate filters (LT and GT) and FE converts it to two separate selectOptions
+                            // But this results in OR condition
+                            // todo : check if AI can provide BT filter or FE should handle it
+                        };
+                        if (oFilterItem.operator === "Contains") { // need to check for other operators if special handling is required
+                            oRange.Option = "CP";
+                        } else {
+                            oRange.Option = oFilterItem.operator;
+                        }
+                        oRange.Low = oValue;
+                        oFilter.Ranges.push(oRange);
+                    });
+                    aSelectOptions.push(oFilter);
+                }
+            });
+            return {
+                aSelectOptions: aSelectOptions,
+                oEditStateFilter : oEditStateFilter
+            };
+        }
+        return {
+            triggerEasyFilterQuery : fnTriggerEasyFilterQuery,
+            getSFBVariantData : fnGetSFBVariantData,
+            getEasyFilterSearchMetadata : fnGetEasyFilterSearchMetadata
+        };
+    }
+
+    return BaseObject.extend("sap.suite.ui.generic.template.lib.ai.EasyFilterBarHandler", {
+        constructor: function (oState, oController, oTemplateUtils) {
+            extend(this, getMethods(oState, oController, oTemplateUtils));
+        }
+    });
+    
+});