@eqproject/eqp-attachments 3.0.0 → 3.0.2

package/esm2022/lib/directives/eqp-common/models/filterConfig.model.mjs

@@ -0,0 +1,318 @@
+/**
+ * Classe utilizzata per la configurazione di filtri custom
+ */
+export class FilterConfig {
+    constructor(filterID, filterClass, label, propertyName, propertyValue, inputType, wherePartType, cvlConfig, preventRemoval) {
+        this.FilterID = filterID;
+        if (filterClass)
+            this.FilterClass = filterClass;
+        this.Label = label;
+        this.PropertyName = propertyName;
+        this.PropertyObject = propertyValue;
+        this.InputType = inputType;
+        this.WherePartType = wherePartType;
+        this.PreventRemoval = preventRemoval;
+        this.EnumData = cvlConfig?.EnumData;
+        this.ArrayData = cvlConfig?.ArrayData;
+        this.ArrayKeyProperty = cvlConfig?.ArrayKeyProperty;
+        this.ArrayValueProperty = cvlConfig?.ArrayValueProperty;
+        this.IsEnumSearchable = cvlConfig?.IsSearchable;
+        this.ShowEnumCancelButton = cvlConfig?.ShowCancelButton;
+        this.EnumSearchText = cvlConfig?.SearchText;
+        this.IsEnumMultiSelect = cvlConfig?.IsMultiSelect;
+        this.BindLookupFullObject = cvlConfig?.BindFullObject;
+    }
+    /**
+     * Identificativo univoco del filtro
+     */
+    FilterID;
+    /**
+     * Permette di definire la classe css da applicare
+     * al filtro
+     */
+    FilterClass = FilterSizeClass.SMALL;
+    /**
+     *
+     */
+    CustomFilterClasses;
+    /**
+     * Etichetta da mostrare per il filtro
+     */
+    Label;
+    /**
+     * Valore della proprietà dell'oggetto su cui andrà applicato il filtro
+     */
+    PropertyName;
+    /**
+     * Valore da usare per il filtro.
+     */
+    PropertyObject;
+    /**
+     * Definisce il tipo di filtro da applicare (valori ammessi in base all'enumeratore InputType)
+     */
+    InputType;
+    /**
+     * Definisce il tipo di operatore logico da utilizzare per la where part
+     */
+    WherePartType;
+    /**
+     * Se il filtro è di tipo CVL o CVLEnum allora in questa proprietà ci va definita la configurazione della cvl.
+     * La cvl verrà renderizzata con una eqp-select
+     */
+    CvlConfig;
+    /**
+     * Permette di definire il template esterno da renderizzare come filtro.
+     */
+    Externaltemplate;
+    /**
+     * Permette di disabilitare la cancellazione del filtro all'utente.
+     * Di default assume il valore FALSE (se true allora nel riepilogo dei filtri applicati non sarà mostrato il pulsante X)
+     */
+    PreventRemoval = false;
+    /**
+     * Permette di definire una funzione custom esterna da richiamare per il filtro corrente quando vengono premuti i pulsanti APPLICA FILTRI
+     * o RESET
+     */
+    CustomWherePartFunction;
+    /**
+     * Permette di definire la funzione custom per restituire il valore del filtro applicato, da mostrare nell'header della card
+     *
+     */
+    CustomAppliedFilterInfoFunction;
+    /**
+     * Per i filtri di tipo ContainsElement e NotContainsElement che si basano sull'applicazione di una where part con l'operatore
+     * Linq ANY allora questa proprietà permette di definire il nome della proprietà degli oggetti figli su cui applicare la where part.
+     * In questo caso dentro PropertyName ci andrà il nome della proprietà contenente la lista di child.
+     *
+     * (Es: PropertyName = 'Users' e ChildElementPropertyName = 'Role' per filtrare i record che contengono una lista di utenti con uno specifico)
+     */
+    ChildElementPropertyName;
+    static CreateStandardFilterConfig(filterID, label, propertyName, type, wherePartType, filterClass, filterCvlConfig, externaltemplate, customWherePartFunction, childElementPropertyName, filterValue, preventRemoval) {
+        let filter = new FilterConfig(filterID, filterClass, label, propertyName, null, type, wherePartType, filterCvlConfig, preventRemoval);
+        if (externaltemplate)
+            filter.Externaltemplate = externaltemplate;
+        if (customWherePartFunction)
+            filter.CustomWherePartFunction = customWherePartFunction;
+        if (childElementPropertyName)
+            filter.ChildElementPropertyName = childElementPropertyName;
+        if (filterValue)
+            filter.PropertyObject = filterValue;
+        return filter;
+    }
+    /**
+     * Se la CVL si basa su un enumeratore allora in questa proprietà va definito il type dell'enumeratore da usare.
+     * In questo modo la sorgente dati della CVL sarà l'insieme dei valori definiti per l'enumeratore
+     */
+    EnumData;
+    /**
+     * Se la CVL si basa su un array allora in questa proprietà va definito l'array da mostrare come sorgente dati della CVL
+     */
+    ArrayData;
+    /**
+     * Nel caso di ArrayData definito permette di indicare la proprietà degli oggetti dell'array da bindare al filtro
+     */
+    ArrayKeyProperty;
+    /**
+     * Nel caso di ArrayData definito permette di indicare la proprietà degli oggetti da visualizzare nel filtro
+     */
+    ArrayValueProperty;
+    /**
+     * Se TRUE allora mostra il campo di ricerca all'interno della CVL (default: TRUE)
+     */
+    IsEnumSearchable = false;
+    /**
+     * Se TRUE allora mostra il pulsante per pulire la selezione della CVL (default: TRUE)
+     */
+    ShowEnumCancelButton = true;
+    /**
+     * Permette di definire l'etichetta per il campo di ricerca della CVL (default: 'Cerca')
+     */
+    EnumSearchText = "Cerca";
+    /**
+     * Permette di definire la multi selezione dei valori della CVL (default: false)
+     */
+    IsEnumMultiSelect = false;
+    /**
+     * Se TRUE allora mostra il campo di ricerca all'interno della lookup (default: TRUE)
+     */
+    IsLookupSearchable = false;
+    /**
+     * Se TRUE allora mostra il pulsante per pulire la selezione della lookup (default: TRUE)
+     */
+    ShowLookupCancelButton = true;
+    /**
+     * Permette di definire l'etichetta per il campo di ricerca della Lookup (default: 'Cerca')
+     */
+    LookupSearchText = "Cerca";
+    /**
+     * Permette di definire la multi selezione dei valori della lookup (default: false)
+     */
+    IsLookupMultiple = false;
+    /**
+     * Permette di definire se nella lookup il binding deve considerare tutto l'oggetto
+     * (default: true)
+     */
+    BindLookupFullObject = true;
+    /**
+     * Permette di definire l'entità della lookup
+     */
+    LookupEntityType = null;
+    /**
+     * Permette di definire l'url per effettuare la chiamata che popola la lookup
+     */
+    LookupFullUrlHttpCall = null;
+    /**
+     * Permette di definire (in maniera opzionale) gli eventuali predicati standard da applicare nel recuperare gli item per la lookup
+     */
+    DataFilter = null;
+    /**
+     * Permette di definire un oggetto contenente la funzione di validazione e la label del suggerimento per validare il campo del filtro
+     */
+    ValidationProperties;
+}
+/**
+ * Classe che permette di configurare una eqp-select (CVL) per uno specifico filtro
+ */
+export class FilterCvlConfig {
+    /**
+     * Se la CVL si basa su un enumeratore allora in questa proprietà va definito il type dell'enumeratore da usare.
+     * In questo modo la sorgente dati della CVL sarà l'insieme dei valori definiti per l'enumeratore
+     */
+    EnumData;
+    /**
+     * Se la CVL si basa su un array allora in questa proprietà va definito l'array da mostrare come sorgente dati della CVL
+     */
+    ArrayData;
+    /**
+     * Nel caso di ArrayData definito permette di indicare la proprietà degli oggetti dell'array da bindare al filtro
+     */
+    ArrayKeyProperty;
+    /**
+     * Nel caso di ArrayData definito permette di indicare la proprietà degli oggetti da visualizzare nel filtro
+     */
+    ArrayValueProperty;
+    /**
+     * Se TRUE allora mostra il campo di ricerca all'interno della CVL (default: TRUE)
+     */
+    IsSearchable = false;
+    /**
+     * Se TRUE allora mostra il pulsante per pulire la selezione della CVL (default: TRUE)
+     */
+    ShowCancelButton = true;
+    /**
+     * Permette di definire l'etichetta per il campo di ricerca (default: 'Cerca')
+     */
+    SearchText = "Cerca";
+    /**
+     * Permette di definire la multi selezione dei valori della CVL (default: false)
+     */
+    IsMultiSelect = false;
+    /**
+     * Permette di definire se nella CVL il binding deve considera tutto l'oggetto o solo la proprietà
+     * definita dentro ArrayKeyProperty
+     * (default: true)
+     */
+    BindFullObject = true;
+    /**
+     * Dati gli opportuni parametri restituisce un oggetto FilterCvlConfig pronto all'uso.
+     * @param enumData Type dell'enumeratore da usare nella cvl (opzionale)
+     * @param arrayData Array da usare nella cvl (opzionale)
+     * @param arrayKeyProperty Nome della proprietà da usare come binding (opzionale)
+     * @param arrayValueProperty Nome della proprietà da mostrare nella CVL (opzionale)
+     * @param isMultiSelect Attiva o disattiva la multiselezione (opzionale)
+     * @param isSearchable Attiva o disattiva la ricerca nella CVL (opzionale)
+     * @param showCancelButton Attiva o disattiva il pulsante per pulire la selezione nella CVL (opzionale)
+     * @param searchText Definisce l'etichetta del campo di ricerca (opzionale)
+     * @returns Valida i parametri e restituisce un oggetto di tipo FilterCvlConfig
+     */
+    static CreateFilterCVLConfig(enumData, arrayData, arrayKeyProperty, arrayValueProperty, isMultiSelect, isSearchable, showCancelButton, searchText, bindFullObject) {
+        let cvlConfig = new FilterCvlConfig();
+        if ((enumData == null || enumData == undefined) && (arrayData == null || arrayData == undefined)) {
+            throw new Error("It's mandatory to define one of the enumData or enumArray properties");
+        }
+        cvlConfig.ArrayData = arrayData;
+        cvlConfig.EnumData = enumData;
+        cvlConfig.ArrayKeyProperty = arrayKeyProperty;
+        cvlConfig.ArrayValueProperty = arrayValueProperty;
+        if (isMultiSelect != null)
+            cvlConfig.IsMultiSelect = isMultiSelect;
+        if (isSearchable != null)
+            cvlConfig.IsSearchable = isSearchable;
+        if (showCancelButton != null)
+            cvlConfig.ShowCancelButton = showCancelButton;
+        if (searchText)
+            cvlConfig.SearchText = searchText;
+        if (bindFullObject != null)
+            cvlConfig.BindFullObject = bindFullObject;
+        return cvlConfig;
+    }
+}
+/**
+ * Classe utilizzata per memorizzare le informazioni sui filtri salvati nel local storage.
+ * Utilizzata solo se per la direttiva eqp-filters è stato richiesto il salvataggio dei filtri
+ */
+export class SavedFilterItem {
+    FilterName;
+    PreventRemoval;
+}
+export var InputType;
+(function (InputType) {
+    InputType[InputType["Text"] = 1] = "Text";
+    InputType[InputType["Number"] = 2] = "Number";
+    InputType[InputType["Date"] = 3] = "Date";
+    InputType[InputType["Datetime"] = 4] = "Datetime";
+    InputType[InputType["CvlEnum"] = 5] = "CvlEnum";
+    InputType[InputType["Cvl"] = 6] = "Cvl";
+    InputType[InputType["Boolean"] = 7] = "Boolean";
+    InputType[InputType["BooleanCvl"] = 8] = "BooleanCvl";
+    InputType[InputType["CustomTemplate"] = 9] = "CustomTemplate";
+    InputType[InputType["DateRange"] = 10] = "DateRange";
+    InputType[InputType["Lookup"] = 11] = "Lookup";
+})(InputType || (InputType = {}));
+export var WherePartType;
+(function (WherePartType) {
+    WherePartType[WherePartType["Equal"] = 1] = "Equal";
+    WherePartType[WherePartType["NotEqual"] = 2] = "NotEqual";
+    WherePartType[WherePartType["StringContains"] = 3] = "StringContains";
+    WherePartType[WherePartType["StringNotContains"] = 4] = "StringNotContains";
+    WherePartType[WherePartType["GreaterThan"] = 5] = "GreaterThan";
+    WherePartType[WherePartType["GreaterThanOrEqual"] = 6] = "GreaterThanOrEqual";
+    WherePartType[WherePartType["LessThan"] = 7] = "LessThan";
+    WherePartType[WherePartType["LessThanOrEqual"] = 8] = "LessThanOrEqual";
+    WherePartType[WherePartType["ContainsElement"] = 9] = "ContainsElement";
+    WherePartType[WherePartType["NotContainsElement"] = 10] = "NotContainsElement";
+})(WherePartType || (WherePartType = {}));
+export var FilterSizeClass;
+(function (FilterSizeClass) {
+    FilterSizeClass[FilterSizeClass["SMALL"] = 1] = "SMALL";
+    FilterSizeClass[FilterSizeClass["MEDIUM"] = 2] = "MEDIUM";
+    FilterSizeClass[FilterSizeClass["LARGE"] = 3] = "LARGE";
+    FilterSizeClass[FilterSizeClass["CUSTOM"] = 4] = "CUSTOM";
+})(FilterSizeClass || (FilterSizeClass = {}));
+/**
+ * Enumeratore usato come input del componente eqp-filter.
+ * Permette di indicare la complessità dell'oggetto da restituire quando viene premuto
+ * il pulsante Applica FIltri.
+ * La documentazione delle due tipologie è stata riportata nel metodo createFilterValue del componente
+ * eqp-filters.component.ts
+ */
+export var FilterResultType;
+(function (FilterResultType) {
+    FilterResultType[FilterResultType["BASIC"] = 1] = "BASIC";
+    FilterResultType[FilterResultType["ADVANCED"] = 2] = "ADVANCED";
+})(FilterResultType || (FilterResultType = {}));
+/**
+ * Utilizzato per battezzare il comportamento e l'aspetto grafico della direttiva eqp-filters.
+ * WITH_CARD: viene renderizzata una card espandibile e i filtri sono visualizzati nel mat-card-content. Quando si applicano i filtri nel card-header vengono riepilogati i filtri applicati
+ * WITH_BUTTON: viene renderizzato un pulsante (con lo stesso stile del card-header precedente). Alla pressione del pulsante si apre una modale contenente tutti i filtri. Quando si applicano o resettano i filtri la modale si chiude e nel pulsante vengono riepilogati i filtri applicati
+ */
+export var FilterMode;
+(function (FilterMode) {
+    FilterMode[FilterMode["WITH_CARD"] = 1] = "WITH_CARD";
+    FilterMode[FilterMode["WITH_BUTTON"] = 2] = "WITH_BUTTON";
+})(FilterMode || (FilterMode = {}));
+export class ValidationObject {
+    Valid;
+    HintLabel;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filterConfig.model.js","sourceRoot":"","sources":["../../../../../../../projects/eqp-attachments/src/lib/directives/eqp-common/models/filterConfig.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { TemplateRef } from \"@angular/core\";\r\nimport { LinqPredicateDTO } from './linqFilterResult.model';\r\n\r\n/**\r\n * Classe utilizzata per la configurazione di filtri custom\r\n */\r\nexport class FilterConfig {\r\n  constructor(filterID?: string,\r\n    filterClass?: FilterSizeClass,\r\n    label?: string,\r\n    propertyName?: string,\r\n    propertyValue?: any,\r\n    inputType?: InputType,\r\n    wherePartType?: WherePartType,\r\n    cvlConfig?: FilterCvlConfig,\r\n    preventRemoval?: boolean) {\r\n\r\n    this.FilterID = filterID;\r\n    if (filterClass) this.FilterClass = filterClass;\r\n\r\n    this.Label = label;\r\n    this.PropertyName = propertyName;\r\n    this.PropertyObject = propertyValue;\r\n    this.InputType = inputType;\r\n    this.WherePartType = wherePartType;\r\n    this.PreventRemoval = preventRemoval;\r\n    this.EnumData = cvlConfig?.EnumData;\r\n    this.ArrayData = cvlConfig?.ArrayData;\r\n    this.ArrayKeyProperty = cvlConfig?.ArrayKeyProperty;\r\n    this.ArrayValueProperty = cvlConfig?.ArrayValueProperty;\r\n    this.IsEnumSearchable = cvlConfig?.IsSearchable;\r\n    this.ShowEnumCancelButton = cvlConfig?.ShowCancelButton;\r\n    this.EnumSearchText = cvlConfig?.SearchText;\r\n    this.IsEnumMultiSelect = cvlConfig?.IsMultiSelect;\r\n    this.BindLookupFullObject = cvlConfig?.BindFullObject;\r\n  }\r\n\r\n  /**\r\n   * Identificativo univoco del filtro\r\n   */\r\n  public FilterID: string;\r\n\r\n  /**\r\n   * Permette di definire la classe css da applicare\r\n   * al filtro\r\n   */\r\n  public FilterClass?: FilterSizeClass = FilterSizeClass.SMALL;\r\n\r\n  /**\r\n   *\r\n   */\r\n  public CustomFilterClasses?: string;\r\n\r\n  /**\r\n   * Etichetta da mostrare per il filtro\r\n   */\r\n  public Label: string;\r\n\r\n  /**\r\n   * Valore della proprietà dell'oggetto su cui andrà applicato il filtro\r\n   */\r\n  public PropertyName?: string;\r\n\r\n  /**\r\n   * Valore da usare per il filtro.\r\n   */\r\n  public PropertyObject?: any;\r\n\r\n  /**\r\n   * Definisce il tipo di filtro da applicare (valori ammessi in base all'enumeratore InputType)\r\n   */\r\n  public InputType: InputType;\r\n\r\n  /**\r\n   * Definisce il tipo di operatore logico da utilizzare per la where part\r\n   */\r\n  public WherePartType?: WherePartType;\r\n\r\n  /**\r\n   * Se il filtro è di tipo CVL o CVLEnum allora in questa proprietà ci va definita la configurazione della cvl.\r\n   * La cvl verrà renderizzata con una eqp-select\r\n   */\r\n  public CvlConfig?: FilterCvlConfig;\r\n\r\n  /**\r\n   * Permette di definire il template esterno da renderizzare come filtro.\r\n   */\r\n  public Externaltemplate?: TemplateRef<any>;\r\n\r\n  /**\r\n   * Permette di disabilitare la cancellazione del filtro all'utente.\r\n   * Di default assume il valore FALSE (se true allora nel riepilogo dei filtri applicati non sarà mostrato il pulsante X)\r\n   */\r\n  public PreventRemoval?: boolean = false;\r\n\r\n  /**\r\n   * Permette di definire una funzione custom esterna da richiamare per il filtro corrente quando vengono premuti i pulsanti APPLICA FILTRI\r\n   * o RESET\r\n   */\r\n  public CustomWherePartFunction?: (filterConfig: FilterConfig, isResetAll?: boolean, isRemoveFilter?: boolean) => any;\r\n\r\n  /**\r\n   * Permette di definire la funzione custom per restituire il valore del filtro applicato, da mostrare nell'header della card\r\n   *\r\n   */\r\n  public CustomAppliedFilterInfoFunction?: (\r\n    filterConfig: FilterConfig,\r\n    isResetAll?: boolean,\r\n    isRemoveFilter?: boolean\r\n  ) => any;\r\n\r\n  /**\r\n   * Per i filtri di tipo ContainsElement e NotContainsElement che si basano sull'applicazione di una where part con l'operatore\r\n   * Linq ANY allora questa proprietà permette di definire il nome della proprietà degli oggetti figli su cui applicare la where part.\r\n   * In questo caso dentro PropertyName ci andrà il nome della proprietà contenente la lista di child.\r\n   *\r\n   * (Es: PropertyName = 'Users' e ChildElementPropertyName = 'Role' per filtrare i record che contengono una lista di utenti con uno specifico)\r\n   */\r\n  public ChildElementPropertyName?: string;\r\n\r\n  public static CreateStandardFilterConfig(\r\n    filterID: string,\r\n    label: string,\r\n    propertyName: string,\r\n    type: InputType,\r\n    wherePartType: WherePartType,\r\n    filterClass?: FilterSizeClass,\r\n    filterCvlConfig?: FilterCvlConfig,\r\n    externaltemplate?: TemplateRef<any>,\r\n    customWherePartFunction?: (filterConfig: FilterConfig, isResetAll?: boolean, isRemoveFilter?: boolean) => any,\r\n    childElementPropertyName?: string,\r\n    filterValue?: any,\r\n    preventRemoval?: boolean\r\n  ): FilterConfig {\r\n    let filter: FilterConfig = new FilterConfig(\r\n      filterID,\r\n      filterClass,\r\n      label,\r\n      propertyName,\r\n      null,\r\n      type,\r\n      wherePartType,\r\n      filterCvlConfig,\r\n      preventRemoval\r\n    );\r\n\r\n    if (externaltemplate) filter.Externaltemplate = externaltemplate;\r\n\r\n    if (customWherePartFunction) filter.CustomWherePartFunction = customWherePartFunction;\r\n\r\n    if (childElementPropertyName) filter.ChildElementPropertyName = childElementPropertyName;\r\n\r\n    if (filterValue) filter.PropertyObject = filterValue;\r\n\r\n    return filter;\r\n  }\r\n\r\n  /**\r\n   * Se la CVL si basa su un enumeratore allora in questa proprietà va definito il type dell'enumeratore da usare.\r\n   * In questo modo la sorgente dati della CVL sarà l'insieme dei valori definiti per l'enumeratore\r\n   */\r\n  public EnumData?: any;\r\n\r\n  /**\r\n   * Se la CVL si basa su un array allora in questa proprietà va definito l'array da mostrare come sorgente dati della CVL\r\n   */\r\n  public ArrayData?: any;\r\n\r\n  /**\r\n   * Nel caso di ArrayData definito permette di indicare la proprietà degli oggetti dell'array da bindare al filtro\r\n   */\r\n  public ArrayKeyProperty?: any;\r\n\r\n  /**\r\n   * Nel caso di ArrayData definito permette di indicare la proprietà degli oggetti da visualizzare nel filtro\r\n   */\r\n  public ArrayValueProperty?: any;\r\n\r\n  /**\r\n   * Se TRUE allora mostra il campo di ricerca all'interno della CVL (default: TRUE)\r\n   */\r\n  public IsEnumSearchable?: boolean = false;\r\n\r\n  /**\r\n   * Se TRUE allora mostra il pulsante per pulire la selezione della CVL (default: TRUE)\r\n   */\r\n  public ShowEnumCancelButton?: boolean = true;\r\n\r\n  /**\r\n   * Permette di definire l'etichetta per il campo di ricerca della CVL (default: 'Cerca')\r\n   */\r\n  public EnumSearchText?: string = \"Cerca\";\r\n\r\n  /**\r\n   * Permette di definire la multi selezione dei valori della CVL (default: false)\r\n   */\r\n  public IsEnumMultiSelect?: boolean = false;\r\n\r\n  /**\r\n   * Se TRUE allora mostra il campo di ricerca all'interno della lookup (default: TRUE)\r\n   */\r\n  public IsLookupSearchable?: boolean = false;\r\n\r\n  /**\r\n   * Se TRUE allora mostra il pulsante per pulire la selezione della lookup (default: TRUE)\r\n   */\r\n  public ShowLookupCancelButton?: boolean = true;\r\n\r\n  /**\r\n   * Permette di definire l'etichetta per il campo di ricerca della Lookup (default: 'Cerca')\r\n   */\r\n  public LookupSearchText?: string = \"Cerca\";\r\n\r\n  /**\r\n   * Permette di definire la multi selezione dei valori della lookup (default: false)\r\n   */\r\n  public IsLookupMultiple?: boolean = false;\r\n\r\n  /**\r\n   * Permette di definire se nella lookup il binding deve considerare tutto l'oggetto\r\n   * (default: true)\r\n   */\r\n  public BindLookupFullObject?: boolean = true;\r\n\r\n  /**\r\n   * Permette di definire l'entità della lookup\r\n   */\r\n  public LookupEntityType?: string = null;\r\n\r\n  /**\r\n   * Permette di definire l'url per effettuare la chiamata che popola la lookup\r\n   */\r\n  public LookupFullUrlHttpCall?: string = null;\r\n\r\n  /**\r\n   * Permette di definire (in maniera opzionale) gli eventuali predicati standard da applicare nel recuperare gli item per la lookup\r\n   */\r\n  public DataFilter?: Array<LinqPredicateDTO> | null = null;\r\n\r\n  /**\r\n   * Permette di definire un oggetto contenente la funzione di validazione e la label del suggerimento per validare il campo del filtro\r\n   */\r\n  public ValidationProperties?: ValidationObject;\r\n}\r\n\r\n/**\r\n * Classe che permette di configurare una eqp-select (CVL) per uno specifico filtro\r\n */\r\nexport class FilterCvlConfig {\r\n  /**\r\n   * Se la CVL si basa su un enumeratore allora in questa proprietà va definito il type dell'enumeratore da usare.\r\n   * In questo modo la sorgente dati della CVL sarà l'insieme dei valori definiti per l'enumeratore\r\n   */\r\n  public EnumData?: any;\r\n\r\n  /**\r\n   * Se la CVL si basa su un array allora in questa proprietà va definito l'array da mostrare come sorgente dati della CVL\r\n   */\r\n  public ArrayData?: any;\r\n\r\n  /**\r\n   * Nel caso di ArrayData definito permette di indicare la proprietà degli oggetti dell'array da bindare al filtro\r\n   */\r\n  public ArrayKeyProperty?: any;\r\n\r\n  /**\r\n   * Nel caso di ArrayData definito permette di indicare la proprietà degli oggetti da visualizzare nel filtro\r\n   */\r\n  public ArrayValueProperty?: any;\r\n\r\n  /**\r\n   * Se TRUE allora mostra il campo di ricerca all'interno della CVL (default: TRUE)\r\n   */\r\n  public IsSearchable?: boolean = false;\r\n\r\n  /**\r\n   * Se TRUE allora mostra il pulsante per pulire la selezione della CVL (default: TRUE)\r\n   */\r\n  public ShowCancelButton?: boolean = true;\r\n\r\n  /**\r\n   * Permette di definire l'etichetta per il campo di ricerca (default: 'Cerca')\r\n   */\r\n  public SearchText?: string = \"Cerca\";\r\n\r\n  /**\r\n   * Permette di definire la multi selezione dei valori della CVL (default: false)\r\n   */\r\n  public IsMultiSelect?: boolean = false;\r\n\r\n  /**\r\n   * Permette di definire se nella CVL il binding deve considera tutto l'oggetto o solo la proprietà\r\n   * definita dentro ArrayKeyProperty\r\n   * (default: true)\r\n   */\r\n  public BindFullObject?: boolean = true;\r\n\r\n  /**\r\n   * Dati gli opportuni parametri restituisce un oggetto FilterCvlConfig pronto all'uso.\r\n   * @param enumData Type dell'enumeratore da usare nella cvl (opzionale)\r\n   * @param arrayData Array da usare nella cvl (opzionale)\r\n   * @param arrayKeyProperty Nome della proprietà da usare come binding (opzionale)\r\n   * @param arrayValueProperty Nome della proprietà da mostrare nella CVL (opzionale)\r\n   * @param isMultiSelect Attiva o disattiva la multiselezione (opzionale)\r\n   * @param isSearchable Attiva o disattiva la ricerca nella CVL (opzionale)\r\n   * @param showCancelButton Attiva o disattiva il pulsante per pulire la selezione nella CVL (opzionale)\r\n   * @param searchText Definisce l'etichetta del campo di ricerca (opzionale)\r\n   * @returns Valida i parametri e restituisce un oggetto di tipo FilterCvlConfig\r\n   */\r\n  static CreateFilterCVLConfig(\r\n    enumData?: any,\r\n    arrayData?: any,\r\n    arrayKeyProperty?: any,\r\n    arrayValueProperty?: any,\r\n    isMultiSelect?: boolean,\r\n    isSearchable?: boolean,\r\n    showCancelButton?: boolean,\r\n    searchText?: string,\r\n    bindFullObject?: boolean\r\n  ): FilterCvlConfig {\r\n    let cvlConfig: FilterCvlConfig = new FilterCvlConfig();\r\n\r\n    if ((enumData == null || enumData == undefined) && (arrayData == null || arrayData == undefined)) {\r\n      throw new Error(\"It's mandatory to define one of the enumData or enumArray properties\");\r\n    }\r\n\r\n    cvlConfig.ArrayData = arrayData;\r\n    cvlConfig.EnumData = enumData;\r\n    cvlConfig.ArrayKeyProperty = arrayKeyProperty;\r\n    cvlConfig.ArrayValueProperty = arrayValueProperty;\r\n\r\n    if (isMultiSelect != null) cvlConfig.IsMultiSelect = isMultiSelect;\r\n\r\n    if (isSearchable != null) cvlConfig.IsSearchable = isSearchable;\r\n\r\n    if (showCancelButton != null) cvlConfig.ShowCancelButton = showCancelButton;\r\n\r\n    if (searchText) cvlConfig.SearchText = searchText;\r\n\r\n    if (bindFullObject != null) cvlConfig.BindFullObject = bindFullObject;\r\n\r\n    return cvlConfig;\r\n  }\r\n}\r\n\r\n/**\r\n * Classe utilizzata per memorizzare le informazioni sui filtri salvati nel local storage.\r\n * Utilizzata solo se per la direttiva eqp-filters è stato richiesto il salvataggio dei filtri\r\n */\r\nexport class SavedFilterItem {\r\n  public FilterName: string;\r\n  public PreventRemoval: boolean;\r\n}\r\n\r\nexport enum InputType {\r\n  Text = 1,\r\n  Number = 2,\r\n  Date = 3,\r\n  Datetime = 4,\r\n  CvlEnum = 5,\r\n  Cvl = 6,\r\n  Boolean = 7,\r\n  BooleanCvl = 8,\r\n  CustomTemplate = 9,\r\n  DateRange = 10,\r\n  Lookup = 11\r\n}\r\n\r\nexport enum WherePartType {\r\n  Equal = 1,\r\n  NotEqual = 2,\r\n  StringContains = 3,\r\n  StringNotContains = 4,\r\n  GreaterThan = 5,\r\n  GreaterThanOrEqual = 6,\r\n  LessThan = 7,\r\n  LessThanOrEqual = 8,\r\n  ContainsElement = 9,\r\n  NotContainsElement = 10\r\n}\r\n\r\nexport enum FilterSizeClass {\r\n  SMALL = 1,\r\n  MEDIUM = 2,\r\n  LARGE = 3,\r\n  CUSTOM = 4\r\n}\r\n\r\n/**\r\n * Enumeratore usato come input del componente eqp-filter.\r\n * Permette di indicare la complessità dell'oggetto da restituire quando viene premuto\r\n * il pulsante Applica FIltri.\r\n * La documentazione delle due tipologie è stata riportata nel metodo createFilterValue del componente\r\n * eqp-filters.component.ts\r\n */\r\nexport enum FilterResultType {\r\n  BASIC = 1,\r\n  ADVANCED = 2\r\n}\r\n\r\n/**\r\n * Utilizzato per battezzare il comportamento e l'aspetto grafico della direttiva eqp-filters.\r\n * WITH_CARD: viene renderizzata una card espandibile e i filtri sono visualizzati nel mat-card-content. Quando si applicano i filtri nel card-header vengono riepilogati i filtri applicati\r\n * WITH_BUTTON: viene renderizzato un pulsante (con lo stesso stile del card-header precedente). Alla pressione del pulsante si apre una modale contenente tutti i filtri. Quando si applicano o resettano i filtri la modale si chiude e nel pulsante vengono riepilogati i filtri applicati\r\n */\r\nexport enum FilterMode {\r\n  WITH_CARD = 1,\r\n  WITH_BUTTON = 2\r\n}\r\n\r\nexport class ValidationObject {\r\n  public Valid?: Function;\r\n  public HintLabel?: string;\r\n}\r\n\r\n"]}