@sapui5/sap.fe.macros 1.141.2 → 1.143.0

package/src/sap/fe/macros/filterBar/UOMValidationDelegate.js

@@ -0,0 +1,376 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2025 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/CommonUtils", "sap/fe/core/helpers/ResourceModelHelper", "sap/ui/core/Element", "sap/ui/core/Messaging", "sap/ui/core/message/ControlMessageProcessor", "sap/ui/core/message/Message", "sap/ui/core/message/MessageType", "sap/ui/mdc/enums/FilterBarValidationStatus", "../DelegateUtil", "../filter/FilterUtils"], function (CommonUtils, ResourceModelHelper, UI5Element, Messaging, ControlMessageProcessor, Message, MessageType, FilterBarValidationStatus, DelegateUtil, FilterUtils) {
+  "use strict";
+
+  /**
+   * UOMValidationDelegate
+   *
+   * A FilterBarDelegate extension that adds UOM validation behavior to MDC FilterBars including adaptation and personalization variants used in the Table and Chart or FilterBar P13n.
+   *
+   * The delegate inspects filter fields for an associated Measures or ISOCurrency or Unit annotation and enforces
+   * when a value is entered for the leading (measure) field, a corresponding UOM value
+   * either exists or is requested from the user. It updates the FilterField value states and required
+   * flags, manages message suppression for live searches, and can reorder the visible UOM field next to
+   * its leading field in personalization state when required.
+   *
+   * Key behaviors:
+   * - Works with three FilterBar contexts:
+   *   - Main (normal) FilterBar
+   *   - FilterBar P13n (adaptation UI for FilterBar)
+   *   - Table or Chart P13n (adaptation UI for Table or Chart FilterBar)
+   * - Discovers UOM relationships using the converted filter field metadata and the Measures.ISOCurrency or Measures.Unit
+   *   annotation on the corresponding property.
+   * - Determines the validation trigger by inspecting the FilterBar "reason" such as Enter or Go and live mode.
+   * - Sets the value state and value state text on the leading (measure) field and marks the UOM FilterField
+   *   as required when the leading field has a value but no UOM.
+   * - Resets value states when no relevant conditions are present.
+   *
+   * Usage:
+   * - The delegate exposes determineValidationState(filterBar, validationType) which returns a Promise
+   *   resolving to a FilterBarValidationStatus. This method is intended to be invoked by the FilterBar
+   *   validation lifecycle to decide whether a search should be triggered or whether missing values
+   *   should be presented to the user.
+   */
+  // Type alias representing possible adaptation control element types (FilterBar | Table | Chart)
+
+  const UOMValidationDelegate = {
+    /**
+     * Function which determines the validation state of the FilterFields on a given FilterBar control.
+     * @param filterBar FilterBar control which can be a P13n FilterBar or a regular one
+     * @param _mValidation String which consists which type of validation is happening
+     * @returns A Promise with a Validation Status which determines if the search is triggered or not
+     */
+    determineValidationState: async function (filterBar, _mValidation) {
+      const adaptationControlElement = UI5Element.getElementById(filterBar.getAssociation("adaptationControl", null));
+      const filterType = getFilterBarType(filterBar, adaptationControlElement);
+      const {
+        hasError,
+        hasWarning
+      } = await UOMValidationDelegate.validateAllUOMFields(filterBar, filterBar._sReason, filterType, adaptationControlElement);
+      if (!hasError && !hasWarning) {
+        return new Promise(resolve => {
+          //After discussions with MDC we need to use this as a temporary workaround to solve the timing issues related to setting the messages to the filterfield and update of the filterfield valuestate
+          //TODO: Remove this workaround once MDC provides an API to set the messages to the filterbar. Will be tracked via BLI.
+          setTimeout(() => {
+            resolve(filterBar.checkFilters());
+          }, 0);
+        });
+      }
+      //if warning or liveMode, we don't open message box
+      filterBar.setShowMessages(!hasWarning && !filterBar.getLiveMode());
+      return hasError ? FilterBarValidationStatus.FieldInErrorState : filterBar.checkFilters();
+    },
+    validateAllUOMFields: async function (filterBar, reason, filterType, adaptationControlElement) {
+      let hasError = false,
+        hasWarning = false;
+      let entityTypePath;
+      let controlForMetaModel;
+      adaptationControlElement = adaptationControlElement ?? UI5Element.getElementById(filterBar.getAssociation("adaptationControl", null));
+      filterType = filterType ?? getFilterBarType(filterBar, adaptationControlElement);
+      if (filterType === FilterType.FILTERBAR_P13N || filterType === FilterType.TABLE_CHART_P13N) {
+        entityTypePath = DelegateUtil.getCustomData(adaptationControlElement, "entityType");
+        controlForMetaModel = adaptationControlElement;
+      } else {
+        entityTypePath = DelegateUtil.getCustomData(filterBar, "entityType");
+        controlForMetaModel = filterBar;
+      }
+      const view = CommonUtils.getTargetView(controlForMetaModel);
+      const appComponent = view && CommonUtils.getAppComponent(view);
+      const disableStrictUomFiltering = appComponent?.getManifestEntry("sap.fe")?.app?.disableStrictUomFiltering;
+      if (disableStrictUomFiltering === true) {
+        return {
+          hasError: false,
+          hasWarning: false
+        };
+      }
+      const internalModel = controlForMetaModel?.getModel("internal");
+      const filterBarId = filterBar.getId();
+      const allUomValidationMessages = internalModel?.getProperty("/uomValidationMessages") || {};
+      const filterBarUomValidationMessages = allUomValidationMessages[filterBarId] || {};
+
+      // Clear existing UOM validation messages for this filterBar from the message model
+      removeMessages(internalModel, filterBarId, filterBarUomValidationMessages);
+      const model = await DelegateUtil.fetchModel(controlForMetaModel);
+      const metaModel = model?.getMetaModel();
+      const resourceModel = ResourceModelHelper.getResourceModel(controlForMetaModel);
+      const allUOMProperties = getUOMProperties(entityTypePath, filterBar, metaModel);
+      if (!allUOMProperties.length || !allUOMProperties.some(uomProp => filterBar?.getConditions()?.[uomProp?.field?.fieldKey]?.length > 0)) {
+        uomStateMap = {};
+        return {
+          hasError: false,
+          hasWarning: false
+        };
+      }
+      for (const {
+        field,
+        uomProperty
+      } of allUOMProperties) {
+        if (uomProperty) {
+          const {
+            hasError: fieldHasError,
+            hasWarning: fieldHasWarning
+          } = validateFilterField(filterBar, field, uomProperty, filterType, resourceModel, adaptationControlElement, reason, internalModel);
+          if (fieldHasError) hasError = true;
+          if (fieldHasWarning) hasWarning = true;
+        }
+      }
+      uomStateMap = {};
+      return {
+        hasError,
+        hasWarning
+      };
+    }
+  };
+  /**
+   * Interface representing a unit of measure (UOM) property and its associated field.
+   * Used to track relationships between measure fields and their corresponding UOM fields.
+   * @interface
+   */
+  /**
+   * Enumeration of possible FilterBar types in the application.
+   * Used to determine the validation behavior based on the context where the filter is being used.
+   * @enum {string}
+   */
+  var FilterType = /*#__PURE__*/function (FilterType) {
+    /** Regular FilterBar instance (not in personalization mode) */
+    FilterType["MAIN"] = "Main";
+    /** FilterBar in personalization mode for filter adaptation */
+    FilterType["FILTERBAR_P13N"] = "FilterP13n";
+    /** FilterBar in personalization mode for Table or Chart adaptation */
+    FilterType["TABLE_CHART_P13N"] = "TableChartP13n";
+    return FilterType;
+  }(FilterType || {});
+  let uomStateMap = {};
+  let controlMessageProcessor;
+  /**
+   * Determines the FilterType for a given FilterBar and an optional adaptation control element.
+   *
+   * The function classifies the filter bar into one of three FilterType values:
+   * - FilterType.MAIN: When the provided filterBar is not an adaptation such when it is not an AdaptationFilterBar.
+   * - FilterType.FILTERBAR_P13N: When the provided filterBar is an AdaptationFilterBar but the adaptationControlElement
+   *   is not a Table or Chart.
+   * - FilterType.TABLE_CHART_P13N: When the provided filterBar is an AdaptationFilterBar and the
+   *   adaptationControlElement is a Table or Chart.
+   * @param filterBar The FilterBar instance to inspect. Expected to implement isA().
+   * @param adaptationControlElement The control associated with the adaptation workflow which may be a FilterBar, Table, or Chart. Used to distinguish table or chart personalization from general filter bar personalization.
+   * @returns The resolved FilterType enum value representing how the filter bar should be treated.
+   */
+  function getFilterBarType(filterBar, adaptationControlElement) {
+    if (filterBar.isA("sap.ui.mdc.filterbar.p13n.AdaptationFilterBar")) {
+      if (adaptationControlElement?.isA("sap.ui.mdc.Table") || adaptationControlElement?.isA("sap.ui.mdc.Chart")) {
+        return FilterType.TABLE_CHART_P13N;
+      }
+      return FilterType.FILTERBAR_P13N;
+    }
+    return FilterType.MAIN;
+  }
+
+  /**
+   * Determines whether an error state check should be performed based on the triggering reason,
+   * the type of filter context, and the filter bar's configuration.
+   *
+   * The function returns true for explicit user actions (for example, "Enter", "Go", or "Variant"),
+   * when the filter bar is of the table or chart personalization type, or when the filter bar
+   * personalization is active and the filter bar is in live mode.
+   * @param reason A string describing the event or user action that triggered validation. For example, "Enter", "Go", or "Variant".
+   * @param filterType The FilterType enum value indicating the current filter context which is used to detect personalization contexts.
+   * @param filterBar Optional FilterBar instance. When provided, its live mode is consulted for certain personalization types.
+   * @returns True if an error state should be checked given the inputs. Otherwise, false.
+   */
+  function shouldCheckErrorState(reason, filterType, filterBar) {
+    return reason === "Enter" || reason === "Go" || reason === "Variant" || filterBar?.getLiveMode() || filterType === FilterType.TABLE_CHART_P13N;
+  }
+
+  /**
+   * Removes existing UOM validation messages for a specific filterBar from the message model
+   * and clears the uomValidationMessages property in the internal model.
+   * @param internalModel The internal JSONModel containing the validation messages
+   * @param filterBarId The ID of the filterBar whose messages should be removed
+   * @param filterBarUomValidationMessages The current UOM validation messages for this filterBar
+   */
+  function removeMessages(internalModel, filterBarId, filterBarUomValidationMessages) {
+    if (Object.keys(filterBarUomValidationMessages).length > 0) {
+      const allMessages = Messaging.getMessageModel().getData();
+      const messagesToRemove = allMessages.filter(m => Object.values(filterBarUomValidationMessages).includes(m.getId()));
+      if (messagesToRemove.length) {
+        Messaging.removeMessages(messagesToRemove);
+      }
+      // Clear the uomValidationMessages property for this specific filterBar
+      if (internalModel) {
+        const allUomValidationMessages = internalModel.getProperty("/uomValidationMessages") || {};
+        const updatedMessages = {
+          ...allUomValidationMessages
+        };
+        delete updatedMessages[filterBarId];
+        internalModel.setProperty("/uomValidationMessages", updatedMessages);
+      }
+    }
+  }
+
+  /**
+   * Function to validate the fields.
+   * @param filterBar The control on which the fields exist and whose ID will be used as message storage key
+   * @param field The field to be evaluated which has a fieldKey and label
+   * @param field.fieldKey
+   * @param field.label
+   * @param uomProperty The UOM property if any exists for the field
+   * @param uomProperty.path
+   * @param uomProperty.label
+   * @param filterType The type of the filterBar
+   * @param resourceModel
+   * @param adaptationControlElement
+   * @param reason
+   * @param internalModel The internal JSONModel for message storage
+   * @returns An object consisting of whether we have an error or a warning state
+   */
+  function validateFilterField(filterBar, field, uomProperty, filterType, resourceModel, adaptationControlElement, reason, internalModel) {
+    const {
+      fieldKey,
+      label
+    } = field;
+    const associatedUOMPropertyPath = uomProperty.path;
+    const filterBarConditions = filterBar.getConditions();
+    const isFieldNameInConditions = !!filterBarConditions?.[fieldKey]?.length;
+    const isUOMInConditions = associatedUOMPropertyPath ? filterBarConditions?.[associatedUOMPropertyPath]?.length === 1 : false;
+    const doesUOMHaveMultipleConditions = associatedUOMPropertyPath ? filterBarConditions?.[associatedUOMPropertyPath]?.length > 1 : false;
+    const leadingFilterField = filterBar.getFilterItems().find(item => item.getPropertyKey() === fieldKey);
+    const uomFilterField = filterBar.getFilterItems().find(item => item.getPropertyKey() === associatedUOMPropertyPath);
+    const messageText = doesUOMHaveMultipleConditions ? resourceModel?.getText?.("FILTERFIELD_VALUE_UOM_MULTIPLE", [uomFilterField?.getLabel() ?? uomProperty?.label]) : resourceModel?.getText?.("FILTERFIELD_VALUE_NO_UOM", [leadingFilterField?.getLabel() ?? label, uomFilterField?.getLabel() ?? uomProperty?.label]);
+    if (!isFieldNameInConditions || isFieldNameInConditions && isUOMInConditions) {
+      return {
+        hasError: false,
+        hasWarning: false
+      };
+    }
+    const isError = shouldCheckErrorState(reason, filterType, filterType === FilterType.FILTERBAR_P13N ? adaptationControlElement : filterBar);
+    setMessages(leadingFilterField, uomFilterField, isError ? MessageType.Error : MessageType.Warning, messageText, internalModel, filterBar);
+    return {
+      hasError: isError,
+      hasWarning: !isError
+    };
+  }
+
+  /**
+   * Updates the UI state for a leading filter field and its associated UOM filter field.
+   * Sets the ValueState and optional ValueStateText on the leading filter (if present),
+   * and sets the required flag as well as ValueState and ValueStateText on the UOM filter (if present).
+   * @param leadingFilterField The primary (leading) MDCFilterField to update. Only its value state and text are modified.
+   * @param uomFilterField The UOM MDCFilterField to update. Its required flag, value state, and text are modified.
+   * @param messageType The ValueState to apply such as None, Warning, Error, or Success.
+   * @param message Optional descriptive text to display for the value state.
+   * @param internalModel The internal JSONModel for message storage.
+   * @param filterBar The FilterBar whose ID will be used as the key for message storage in the internal model.
+   */
+  function setMessages(leadingFilterField, uomFilterField, messageType, message, internalModel, filterBar) {
+    const messages = [];
+    controlMessageProcessor ??= new ControlMessageProcessor();
+
+    // Get current UOM validation messages from internal model
+    const filterBarId = filterBar?.getId() ?? "";
+    const allUomValidationMessages = internalModel?.getProperty("/uomValidationMessages") || {};
+    const filterBarUomValidationMessages = allUomValidationMessages[filterBarId] || {};
+    let leadingMsg;
+    if (leadingFilterField) {
+      const fieldId = leadingFilterField.getId();
+      // Check if message already exists for this field in this filterBar's context
+      if (!filterBarUomValidationMessages[fieldId]) {
+        leadingMsg = new Message({
+          message: message,
+          processor: controlMessageProcessor,
+          type: messageType,
+          target: fieldId + "/conditions"
+        });
+        messages.push(leadingMsg);
+        // Store message ID in filterBar's validation messages
+        filterBarUomValidationMessages[fieldId] = leadingMsg.getId();
+      }
+    }
+    if (uomFilterField && uomStateMap[uomFilterField.getId()] !== undefined) {
+      if (uomStateMap[uomFilterField.getId()]?.messageType === MessageType.None) {
+        setMessageForUOMField(uomFilterField, messageType, message, messages, filterBarUomValidationMessages);
+      }
+    } else if (uomFilterField) {
+      setMessageForUOMField(uomFilterField, messageType, message, messages, filterBarUomValidationMessages);
+    }
+
+    // Update internal model with new messages for this filterBar
+    if (internalModel) {
+      const updatedAllMessages = {
+        ...allUomValidationMessages
+      };
+      updatedAllMessages[filterBarId] = filterBarUomValidationMessages;
+      internalModel.setProperty("/uomValidationMessages", updatedAllMessages);
+    }
+    if (messages.length) {
+      Messaging.addMessages(messages);
+    }
+  }
+  function setMessageForUOMField(uomField, messageType, message, messages, uomValidationMessages) {
+    const fieldId = uomField.getId();
+    // Check if message already exists for this field
+    if (uomValidationMessages[fieldId]) {
+      return undefined;
+    }
+    const msg = new Message({
+      message: message,
+      processor: controlMessageProcessor,
+      type: messageType,
+      target: fieldId + "/conditions"
+    });
+    messages.push(msg);
+    uomStateMap[fieldId] = {
+      messageType
+    };
+
+    // Store message ID in uomValidationMessages
+    uomValidationMessages[fieldId] = msg.getId();
+    return msg;
+  }
+
+  /**
+   * Retrieves UOM-related properties from a filter control's metadata.
+   * Processes filter fields to identify measure fields with associated UOM fields
+   * through ISOCurrency or Unit annotations.
+   * @param entityTypePath Path to the entity type containing the filter fields
+   * @param filterControl The filter control to inspect for UOM properties
+   * @param metaModel ODataMetaModel
+   * @returns Array of UOMProperty objects containing measure field information
+   * and their associated UOM field details
+   */
+  function getUOMProperties(entityTypePath, filterControl, metaModel) {
+    const includeHidden = filterControl.isA("sap.ui.mdc.filterbar.vh.FilterBar") ? true : undefined;
+    const filterFields = FilterUtils.getConvertedFilterFields(filterControl, entityTypePath, includeHidden, metaModel);
+    const converterContext = FilterUtils.createConverterContext(filterControl, entityTypePath, metaModel);
+    return filterFields.map(filterFieldInfo => {
+      const annotationPath = filterFieldInfo.annotationPath;
+      if (annotationPath) {
+        const propertyAnnotations = converterContext.getConvertedTypes().resolvePath(annotationPath).target;
+        const uomProperty = propertyAnnotations?.annotations.Measures;
+        if (uomProperty?.ISOCurrency || uomProperty?.Unit) {
+          let uomPropertyObject;
+          const uomPath = uomProperty?.ISOCurrency?.path || uomProperty?.Unit?.path;
+          if (uomPath) {
+            const uomLabel = filterFields.find(ff => ff.key === uomPath)?.label;
+            uomPropertyObject = {
+              path: uomPath,
+              label: uomLabel ?? uomProperty?.ISOCurrency?.$target?.annotations?.Common?.Label ?? uomProperty?.Unit?.$target?.annotations?.Common?.Label
+            };
+          }
+          return {
+            field: {
+              fieldKey: filterFieldInfo.key ?? "",
+              label: filterFieldInfo.label ?? ""
+            },
+            uomProperty: uomPropertyObject
+          };
+        }
+      }
+      return null;
+    }).filter(Boolean);
+  }
+  return UOMValidationDelegate;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["UOMValidationDelegate","determineValidationState","filterBar","_mValidation","adaptationControlElement","UI5Element","getElementById","getAssociation","filterType","getFilterBarType","hasError","hasWarning","validateAllUOMFields","_sReason","Promise","resolve","setTimeout","checkFilters","setShowMessages","getLiveMode","FilterBarValidationStatus","FieldInErrorState","reason","entityTypePath","controlForMetaModel","FilterType","FILTERBAR_P13N","TABLE_CHART_P13N","DelegateUtil","getCustomData","view","CommonUtils","getTargetView","appComponent","getAppComponent","disableStrictUomFiltering","getManifestEntry","app","internalModel","getModel","filterBarId","getId","allUomValidationMessages","getProperty","filterBarUomValidationMessages","removeMessages","model","fetchModel","metaModel","getMetaModel","resourceModel","ResourceModelHelper","getResourceModel","allUOMProperties","getUOMProperties","length","some","uomProp","getConditions","field","fieldKey","uomStateMap","uomProperty","fieldHasError","fieldHasWarning","validateFilterField","controlMessageProcessor","isA","MAIN","shouldCheckErrorState","Object","keys","allMessages","Messaging","getMessageModel","getData","messagesToRemove","filter","m","values","includes","updatedMessages","setProperty","label","associatedUOMPropertyPath","path","filterBarConditions","isFieldNameInConditions","isUOMInConditions","doesUOMHaveMultipleConditions","leadingFilterField","getFilterItems","find","item","getPropertyKey","uomFilterField","messageText","getText","getLabel","isError","setMessages","MessageType","Error","Warning","messageType","message","messages","ControlMessageProcessor","leadingMsg","fieldId","Message","processor","type","target","push","undefined","None","setMessageForUOMField","updatedAllMessages","addMessages","uomField","uomValidationMessages","msg","filterControl","includeHidden","filterFields","FilterUtils","getConvertedFilterFields","converterContext","createConverterContext","map","filterFieldInfo","annotationPath","propertyAnnotations","getConvertedTypes","resolvePath","annotations","Measures","ISOCurrency","Unit","uomPropertyObject","uomPath","uomLabel","ff","key","$target","Common","Label","Boolean"],"sourceRoot":".","sources":["UOMValidationDelegate.ts"],"sourcesContent":["/**\n * UOMValidationDelegate\n *\n * A FilterBarDelegate extension that adds UOM validation behavior to MDC FilterBars including adaptation and personalization variants used in the Table and Chart or FilterBar P13n.\n *\n * The delegate inspects filter fields for an associated Measures or ISOCurrency or Unit annotation and enforces\n * when a value is entered for the leading (measure) field, a corresponding UOM value\n * either exists or is requested from the user. It updates the FilterField value states and required\n * flags, manages message suppression for live searches, and can reorder the visible UOM field next to\n * its leading field in personalization state when required.\n *\n * Key behaviors:\n * - Works with three FilterBar contexts:\n *   - Main (normal) FilterBar\n *   - FilterBar P13n (adaptation UI for FilterBar)\n *   - Table or Chart P13n (adaptation UI for Table or Chart FilterBar)\n * - Discovers UOM relationships using the converted filter field metadata and the Measures.ISOCurrency or Measures.Unit\n *   annotation on the corresponding property.\n * - Determines the validation trigger by inspecting the FilterBar \"reason\" such as Enter or Go and live mode.\n * - Sets the value state and value state text on the leading (measure) field and marks the UOM FilterField\n *   as required when the leading field has a value but no UOM.\n * - Resets value states when no relevant conditions are present.\n *\n * Usage:\n * - The delegate exposes determineValidationState(filterBar, validationType) which returns a Promise\n *   resolving to a FilterBarValidationStatus. This method is intended to be invoked by the FilterBar\n *   validation lifecycle to decide whether a search should be triggered or whether missing values\n *   should be presented to the user.\n */\nimport type { Property, PropertyPath } from \"@sap-ux/vocabularies-types\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport type ResourceModel from \"sap/fe/core/ResourceModel\";\nimport type { FilterField } from \"sap/fe/core/converters/controls/ListReport/FilterBar\";\nimport * as ResourceModelHelper from \"sap/fe/core/helpers/ResourceModelHelper\";\nimport type Control from \"sap/ui/core/Control\";\nimport UI5Element from \"sap/ui/core/Element\";\nimport Messaging from \"sap/ui/core/Messaging\";\nimport ControlMessageProcessor from \"sap/ui/core/message/ControlMessageProcessor\";\nimport Message from \"sap/ui/core/message/Message\";\nimport MessageType from \"sap/ui/core/message/MessageType\";\nimport type Chart from \"sap/ui/mdc/Chart\";\nimport type FilterBar from \"sap/ui/mdc/FilterBar\";\nimport type MDCFilterField from \"sap/ui/mdc/FilterField\";\nimport type Table from \"sap/ui/mdc/Table\";\nimport FilterBarValidationStatus from \"sap/ui/mdc/enums/FilterBarValidationStatus\";\nimport type JSONModel from \"sap/ui/model/json/JSONModel\";\nimport type ODataMetaModel from \"sap/ui/model/odata/v4/ODataMetaModel\";\nimport DelegateUtil from \"../DelegateUtil\";\nimport type { IFilterControl } from \"../filter/FilterUtils\";\nimport FilterUtils from \"../filter/FilterUtils\";\n\n// Type alias representing possible adaptation control element types (FilterBar | Table | Chart)\ntype AdaptationElement = FilterBar | Table | Chart;\n\nconst UOMValidationDelegate = {\n\t/**\n\t * Function which determines the validation state of the FilterFields on a given FilterBar control.\n\t * @param filterBar FilterBar control which can be a P13n FilterBar or a regular one\n\t * @param _mValidation String which consists which type of validation is happening\n\t * @returns A Promise with a Validation Status which determines if the search is triggered or not\n\t */\n\tdetermineValidationState: async function (filterBar: FilterBar, _mValidation: string): Promise<FilterBarValidationStatus> {\n\t\tconst adaptationControlElement = UI5Element.getElementById(filterBar.getAssociation(\"adaptationControl\", null) as string);\n\t\tconst filterType = getFilterBarType(filterBar, adaptationControlElement as AdaptationElement);\n\t\tconst { hasError, hasWarning } = await UOMValidationDelegate.validateAllUOMFields(\n\t\t\tfilterBar,\n\t\t\tfilterBar._sReason,\n\t\t\tfilterType,\n\t\t\tadaptationControlElement\n\t\t);\n\t\tif (!hasError && !hasWarning) {\n\t\t\treturn new Promise((resolve) => {\n\t\t\t\t//After discussions with MDC we need to use this as a temporary workaround to solve the timing issues related to setting the messages to the filterfield and update of the filterfield valuestate\n\t\t\t\t//TODO: Remove this workaround once MDC provides an API to set the messages to the filterbar. Will be tracked via BLI.\n\t\t\t\tsetTimeout(() => {\n\t\t\t\t\tresolve(filterBar.checkFilters());\n\t\t\t\t}, 0);\n\t\t\t});\n\t\t}\n\t\t//if warning or liveMode, we don't open message box\n\t\tfilterBar.setShowMessages(!hasWarning && !filterBar.getLiveMode());\n\t\treturn hasError ? FilterBarValidationStatus.FieldInErrorState : filterBar.checkFilters();\n\t},\n\tvalidateAllUOMFields: async function (\n\t\tfilterBar: FilterBar,\n\t\treason?: string,\n\t\tfilterType?: FilterType,\n\t\tadaptationControlElement?: UI5Element\n\t): Promise<{ hasError: boolean; hasWarning: boolean }> {\n\t\tlet hasError = false,\n\t\t\thasWarning = false;\n\t\tlet entityTypePath: string | undefined;\n\t\tlet controlForMetaModel: UI5Element | undefined;\n\t\tadaptationControlElement =\n\t\t\tadaptationControlElement ?? UI5Element.getElementById(filterBar.getAssociation(\"adaptationControl\", null) as string);\n\t\tfilterType = filterType ?? getFilterBarType(filterBar, adaptationControlElement as AdaptationElement);\n\t\tif (filterType === FilterType.FILTERBAR_P13N || filterType === FilterType.TABLE_CHART_P13N) {\n\t\t\tentityTypePath = DelegateUtil.getCustomData<string>(adaptationControlElement as FilterBar, \"entityType\") as string;\n\t\t\tcontrolForMetaModel = adaptationControlElement;\n\t\t} else {\n\t\t\tentityTypePath = DelegateUtil.getCustomData<string>(filterBar, \"entityType\") as string;\n\t\t\tcontrolForMetaModel = filterBar;\n\t\t}\n\t\tconst view = CommonUtils.getTargetView(controlForMetaModel as Control);\n\t\tconst appComponent = view && CommonUtils.getAppComponent(view);\n\t\tconst disableStrictUomFiltering = appComponent?.getManifestEntry(\"sap.fe\")?.app?.disableStrictUomFiltering;\n\t\tif (disableStrictUomFiltering === true) {\n\t\t\treturn { hasError: false, hasWarning: false };\n\t\t}\n\n\t\tconst internalModel = controlForMetaModel?.getModel(\"internal\");\n\t\tconst filterBarId = filterBar.getId();\n\t\tconst allUomValidationMessages = internalModel?.getProperty(\"/uomValidationMessages\") || {};\n\t\tconst filterBarUomValidationMessages = allUomValidationMessages[filterBarId] || {};\n\n\t\t// Clear existing UOM validation messages for this filterBar from the message model\n\t\tremoveMessages(internalModel as JSONModel, filterBarId, filterBarUomValidationMessages);\n\t\tconst model = await DelegateUtil.fetchModel(controlForMetaModel as AdaptationElement);\n\t\tconst metaModel = model?.getMetaModel() as ODataMetaModel;\n\t\tconst resourceModel = ResourceModelHelper.getResourceModel(controlForMetaModel as Control);\n\t\tconst allUOMProperties = getUOMProperties(entityTypePath, filterBar as IFilterControl, metaModel);\n\t\tif (\n\t\t\t!allUOMProperties.length ||\n\t\t\t!allUOMProperties.some((uomProp: UOMProperty) => filterBar?.getConditions()?.[uomProp?.field?.fieldKey]?.length > 0)\n\t\t) {\n\t\t\tuomStateMap = {};\n\t\t\treturn { hasError: false, hasWarning: false };\n\t\t}\n\t\tfor (const { field, uomProperty } of allUOMProperties) {\n\t\t\tif (uomProperty) {\n\t\t\t\tconst { hasError: fieldHasError, hasWarning: fieldHasWarning } = validateFilterField(\n\t\t\t\t\tfilterBar,\n\t\t\t\t\tfield,\n\t\t\t\t\tuomProperty,\n\t\t\t\t\tfilterType,\n\t\t\t\t\tresourceModel,\n\t\t\t\t\tadaptationControlElement,\n\t\t\t\t\treason as string,\n\t\t\t\t\tinternalModel as JSONModel\n\t\t\t\t);\n\n\t\t\t\tif (fieldHasError) hasError = true;\n\t\t\t\tif (fieldHasWarning) hasWarning = true;\n\t\t\t}\n\t\t}\n\t\tuomStateMap = {};\n\t\treturn { hasError, hasWarning };\n\t}\n};\n/**\n * Interface representing a unit of measure (UOM) property and its associated field.\n * Used to track relationships between measure fields and their corresponding UOM fields.\n * @interface\n */\ninterface UOMProperty {\n\t/**\n\t * The main measure field information\n\t */\n\tfield: {\n\t\t/** Unique identifier for the field */\n\t\tfieldKey: string;\n\t\t/** Display label for the field */\n\t\tlabel: string;\n\t};\n\t/**\n\t * Optional associated unit of measure (UOM) field information\n\t */\n\tuomProperty?: {\n\t\t/** Path to the UOM field */\n\t\tpath: string;\n\t\t/** Display label for the UOM field */\n\t\tlabel: string;\n\t};\n}\n\n/**\n * Enumeration of possible FilterBar types in the application.\n * Used to determine the validation behavior based on the context where the filter is being used.\n * @enum {string}\n */\nenum FilterType {\n\t/** Regular FilterBar instance (not in personalization mode) */\n\tMAIN = \"Main\",\n\t/** FilterBar in personalization mode for filter adaptation */\n\tFILTERBAR_P13N = \"FilterP13n\",\n\t/** FilterBar in personalization mode for Table or Chart adaptation */\n\tTABLE_CHART_P13N = \"TableChartP13n\"\n}\n\nlet uomStateMap: Record<string, { messageType?: MessageType }> = {};\nlet controlMessageProcessor: ControlMessageProcessor | undefined;\n/**\n * Determines the FilterType for a given FilterBar and an optional adaptation control element.\n *\n * The function classifies the filter bar into one of three FilterType values:\n * - FilterType.MAIN: When the provided filterBar is not an adaptation such when it is not an AdaptationFilterBar.\n * - FilterType.FILTERBAR_P13N: When the provided filterBar is an AdaptationFilterBar but the adaptationControlElement\n *   is not a Table or Chart.\n * - FilterType.TABLE_CHART_P13N: When the provided filterBar is an AdaptationFilterBar and the\n *   adaptationControlElement is a Table or Chart.\n * @param filterBar The FilterBar instance to inspect. Expected to implement isA().\n * @param adaptationControlElement The control associated with the adaptation workflow which may be a FilterBar, Table, or Chart. Used to distinguish table or chart personalization from general filter bar personalization.\n * @returns The resolved FilterType enum value representing how the filter bar should be treated.\n */\nfunction getFilterBarType(filterBar: FilterBar, adaptationControlElement: FilterBar | Table | Chart): FilterType {\n\tif (filterBar.isA(\"sap.ui.mdc.filterbar.p13n.AdaptationFilterBar\")) {\n\t\tif ((adaptationControlElement as Table)?.isA(\"sap.ui.mdc.Table\") || (adaptationControlElement as Chart)?.isA(\"sap.ui.mdc.Chart\")) {\n\t\t\treturn FilterType.TABLE_CHART_P13N;\n\t\t}\n\t\treturn FilterType.FILTERBAR_P13N;\n\t}\n\treturn FilterType.MAIN;\n}\n\n/**\n * Determines whether an error state check should be performed based on the triggering reason,\n * the type of filter context, and the filter bar's configuration.\n *\n * The function returns true for explicit user actions (for example, \"Enter\", \"Go\", or \"Variant\"),\n * when the filter bar is of the table or chart personalization type, or when the filter bar\n * personalization is active and the filter bar is in live mode.\n * @param reason A string describing the event or user action that triggered validation. For example, \"Enter\", \"Go\", or \"Variant\".\n * @param filterType The FilterType enum value indicating the current filter context which is used to detect personalization contexts.\n * @param filterBar Optional FilterBar instance. When provided, its live mode is consulted for certain personalization types.\n * @returns True if an error state should be checked given the inputs. Otherwise, false.\n */\nfunction shouldCheckErrorState(reason: string, filterType: FilterType, filterBar: FilterBar | undefined): boolean {\n\treturn (\n\t\treason === \"Enter\" ||\n\t\treason === \"Go\" ||\n\t\treason === \"Variant\" ||\n\t\t(filterBar?.getLiveMode() as boolean) ||\n\t\tfilterType === FilterType.TABLE_CHART_P13N\n\t);\n}\n\n/**\n * Removes existing UOM validation messages for a specific filterBar from the message model\n * and clears the uomValidationMessages property in the internal model.\n * @param internalModel The internal JSONModel containing the validation messages\n * @param filterBarId The ID of the filterBar whose messages should be removed\n * @param filterBarUomValidationMessages The current UOM validation messages for this filterBar\n */\nfunction removeMessages(\n\tinternalModel: JSONModel | undefined,\n\tfilterBarId: string,\n\tfilterBarUomValidationMessages: Record<string, string>\n): void {\n\tif (Object.keys(filterBarUomValidationMessages).length > 0) {\n\t\tconst allMessages: Message[] = Messaging.getMessageModel().getData();\n\t\tconst messagesToRemove = allMessages.filter((m) => Object.values(filterBarUomValidationMessages).includes(m.getId()));\n\t\tif (messagesToRemove.length) {\n\t\t\tMessaging.removeMessages(messagesToRemove);\n\t\t}\n\t\t// Clear the uomValidationMessages property for this specific filterBar\n\t\tif (internalModel) {\n\t\t\tconst allUomValidationMessages = internalModel.getProperty(\"/uomValidationMessages\") || {};\n\t\t\tconst updatedMessages = { ...allUomValidationMessages };\n\t\t\tdelete updatedMessages[filterBarId];\n\t\t\tinternalModel.setProperty(\"/uomValidationMessages\", updatedMessages);\n\t\t}\n\t}\n}\n\n/**\n * Function to validate the fields.\n * @param filterBar The control on which the fields exist and whose ID will be used as message storage key\n * @param field The field to be evaluated which has a fieldKey and label\n * @param field.fieldKey\n * @param field.label\n * @param uomProperty The UOM property if any exists for the field\n * @param uomProperty.path\n * @param uomProperty.label\n * @param filterType The type of the filterBar\n * @param resourceModel\n * @param adaptationControlElement\n * @param reason\n * @param internalModel The internal JSONModel for message storage\n * @returns An object consisting of whether we have an error or a warning state\n */\nfunction validateFilterField(\n\tfilterBar: FilterBar,\n\tfield: { fieldKey: string; label: string },\n\tuomProperty: { path: string; label: string },\n\tfilterType: FilterType,\n\tresourceModel: ResourceModel,\n\tadaptationControlElement: UI5Element | undefined,\n\treason: string,\n\tinternalModel?: JSONModel\n): { hasError: boolean; hasWarning: boolean } {\n\tconst { fieldKey, label } = field;\n\tconst associatedUOMPropertyPath = uomProperty.path;\n\tconst filterBarConditions = filterBar.getConditions();\n\tconst isFieldNameInConditions = !!filterBarConditions?.[fieldKey]?.length;\n\tconst isUOMInConditions = associatedUOMPropertyPath ? filterBarConditions?.[associatedUOMPropertyPath]?.length === 1 : false;\n\tconst doesUOMHaveMultipleConditions = associatedUOMPropertyPath ? filterBarConditions?.[associatedUOMPropertyPath]?.length > 1 : false;\n\tconst leadingFilterField = filterBar.getFilterItems().find((item) => item.getPropertyKey() === fieldKey);\n\tconst uomFilterField = filterBar.getFilterItems().find((item) => item.getPropertyKey() === associatedUOMPropertyPath);\n\tconst messageText = doesUOMHaveMultipleConditions\n\t\t? resourceModel?.getText?.(\"FILTERFIELD_VALUE_UOM_MULTIPLE\", [uomFilterField?.getLabel() ?? uomProperty?.label])\n\t\t: resourceModel?.getText?.(\"FILTERFIELD_VALUE_NO_UOM\", [\n\t\t\t\tleadingFilterField?.getLabel() ?? label,\n\t\t\t\tuomFilterField?.getLabel() ?? uomProperty?.label\n\t\t  ]);\n\tif (!isFieldNameInConditions || (isFieldNameInConditions && isUOMInConditions)) {\n\t\treturn { hasError: false, hasWarning: false };\n\t}\n\n\tconst isError = shouldCheckErrorState(\n\t\treason,\n\t\tfilterType,\n\t\tfilterType === FilterType.FILTERBAR_P13N ? (adaptationControlElement as FilterBar) : filterBar\n\t);\n\tsetMessages(\n\t\tleadingFilterField,\n\t\tuomFilterField,\n\t\tisError ? MessageType.Error : MessageType.Warning,\n\t\tmessageText,\n\t\tinternalModel as JSONModel,\n\t\tfilterBar\n\t);\n\treturn { hasError: isError, hasWarning: !isError };\n}\n\n/**\n * Updates the UI state for a leading filter field and its associated UOM filter field.\n * Sets the ValueState and optional ValueStateText on the leading filter (if present),\n * and sets the required flag as well as ValueState and ValueStateText on the UOM filter (if present).\n * @param leadingFilterField The primary (leading) MDCFilterField to update. Only its value state and text are modified.\n * @param uomFilterField The UOM MDCFilterField to update. Its required flag, value state, and text are modified.\n * @param messageType The ValueState to apply such as None, Warning, Error, or Success.\n * @param message Optional descriptive text to display for the value state.\n * @param internalModel The internal JSONModel for message storage.\n * @param filterBar The FilterBar whose ID will be used as the key for message storage in the internal model.\n */\nfunction setMessages(\n\tleadingFilterField: MDCFilterField | undefined,\n\tuomFilterField: MDCFilterField | undefined,\n\tmessageType: MessageType,\n\tmessage: string | undefined,\n\tinternalModel?: JSONModel,\n\tfilterBar?: FilterBar\n): void {\n\tconst messages: Message | Message[] = [];\n\tcontrolMessageProcessor ??= new ControlMessageProcessor();\n\n\t// Get current UOM validation messages from internal model\n\tconst filterBarId = filterBar?.getId() ?? \"\";\n\tconst allUomValidationMessages = internalModel?.getProperty(\"/uomValidationMessages\") || {};\n\tconst filterBarUomValidationMessages: Record<string, string> = allUomValidationMessages[filterBarId] || {};\n\n\tlet leadingMsg: Message | undefined;\n\tif (leadingFilterField) {\n\t\tconst fieldId = leadingFilterField.getId();\n\t\t// Check if message already exists for this field in this filterBar's context\n\t\tif (!filterBarUomValidationMessages[fieldId]) {\n\t\t\tleadingMsg = new Message({\n\t\t\t\tmessage: message,\n\t\t\t\tprocessor: controlMessageProcessor,\n\t\t\t\ttype: messageType,\n\t\t\t\ttarget: fieldId + \"/conditions\"\n\t\t\t});\n\t\t\tmessages.push(leadingMsg);\n\t\t\t// Store message ID in filterBar's validation messages\n\t\t\tfilterBarUomValidationMessages[fieldId] = leadingMsg.getId();\n\t\t}\n\t}\n\tif (uomFilterField && uomStateMap[uomFilterField.getId()] !== undefined) {\n\t\tif (uomStateMap[uomFilterField.getId()]?.messageType === MessageType.None) {\n\t\t\tsetMessageForUOMField(uomFilterField, messageType, message, messages, filterBarUomValidationMessages);\n\t\t}\n\t} else if (uomFilterField) {\n\t\tsetMessageForUOMField(uomFilterField, messageType, message, messages, filterBarUomValidationMessages);\n\t}\n\n\t// Update internal model with new messages for this filterBar\n\tif (internalModel) {\n\t\tconst updatedAllMessages = { ...allUomValidationMessages };\n\t\tupdatedAllMessages[filterBarId] = filterBarUomValidationMessages;\n\t\tinternalModel.setProperty(\"/uomValidationMessages\", updatedAllMessages);\n\t}\n\tif (messages.length) {\n\t\tMessaging.addMessages(messages);\n\t}\n}\n\nfunction setMessageForUOMField(\n\tuomField: MDCFilterField,\n\tmessageType: MessageType,\n\tmessage: string | undefined,\n\tmessages: Message[],\n\tuomValidationMessages: Record<string, string>\n): Message | undefined {\n\tconst fieldId = uomField.getId();\n\t// Check if message already exists for this field\n\tif (uomValidationMessages[fieldId]) {\n\t\treturn undefined;\n\t}\n\tconst msg = new Message({\n\t\tmessage: message,\n\t\tprocessor: controlMessageProcessor,\n\t\ttype: messageType,\n\t\ttarget: fieldId + \"/conditions\"\n\t});\n\tmessages.push(msg);\n\tuomStateMap[fieldId] = { messageType };\n\n\t// Store message ID in uomValidationMessages\n\tuomValidationMessages[fieldId] = msg.getId();\n\treturn msg;\n}\n\n/**\n * Retrieves UOM-related properties from a filter control's metadata.\n * Processes filter fields to identify measure fields with associated UOM fields\n * through ISOCurrency or Unit annotations.\n * @param entityTypePath Path to the entity type containing the filter fields\n * @param filterControl The filter control to inspect for UOM properties\n * @param metaModel ODataMetaModel\n * @returns Array of UOMProperty objects containing measure field information\n * and their associated UOM field details\n */\nfunction getUOMProperties(\n\tentityTypePath: string | undefined,\n\tfilterControl: IFilterControl,\n\tmetaModel?: ODataMetaModel | undefined\n): UOMProperty[] {\n\tconst includeHidden = filterControl.isA(\"sap.ui.mdc.filterbar.vh.FilterBar\") ? true : undefined;\n\tconst filterFields = FilterUtils.getConvertedFilterFields(filterControl, entityTypePath, includeHidden, metaModel);\n\tconst converterContext = FilterUtils.createConverterContext(filterControl, entityTypePath, metaModel);\n\treturn filterFields\n\t\t.map((filterFieldInfo: FilterField) => {\n\t\t\tconst annotationPath = filterFieldInfo.annotationPath;\n\t\t\tif (annotationPath) {\n\t\t\t\tconst propertyAnnotations = converterContext.getConvertedTypes().resolvePath<Property>(annotationPath).target;\n\t\t\t\tconst uomProperty = propertyAnnotations?.annotations.Measures;\n\t\t\t\tif (uomProperty?.ISOCurrency || uomProperty?.Unit) {\n\t\t\t\t\tlet uomPropertyObject;\n\t\t\t\t\tconst uomPath =\n\t\t\t\t\t\t(uomProperty as { ISOCurrency?: { path: string } })?.ISOCurrency?.path ||\n\t\t\t\t\t\t(uomProperty as { Unit?: { path: string } })?.Unit?.path;\n\t\t\t\t\tif (uomPath) {\n\t\t\t\t\t\tconst uomLabel = filterFields.find((ff) => ff.key === uomPath)?.label;\n\t\t\t\t\t\tuomPropertyObject = {\n\t\t\t\t\t\t\tpath: uomPath,\n\t\t\t\t\t\t\tlabel:\n\t\t\t\t\t\t\t\tuomLabel ??\n\t\t\t\t\t\t\t\t(uomProperty?.ISOCurrency as unknown as PropertyPath)?.$target?.annotations?.Common?.Label ??\n\t\t\t\t\t\t\t\t(uomProperty?.Unit as unknown as PropertyPath)?.$target?.annotations?.Common?.Label\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\t\t\t\t\treturn {\n\t\t\t\t\t\tfield: { fieldKey: filterFieldInfo.key ?? \"\", label: filterFieldInfo.label ?? \"\" },\n\t\t\t\t\t\tuomProperty: uomPropertyObject\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn null;\n\t\t})\n\t\t.filter(Boolean) as UOMProperty[];\n}\n\nexport default UOMValidationDelegate;\n"],"mappings":"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","ignoreList":[]}