@eqproject/eqp-attachments 3.0.1 → 3.0.2

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

@@ -0,0 +1,254 @@
+import { FilterConfig, InputType, WherePartType } from './filterConfig.model';
+import { BaseFieldModel, BaseType } from './base-field.model';
+import { FieldSizeClass } from './common-enum.model';
+export class FilterField extends BaseFieldModel {
+    constructor(filterID, fieldClass, label, propertyName, propertyValue, inputType, wherePartType, cvlConfig, preventRemoval) {
+        super();
+        this.filterID = filterID;
+        if (fieldClass)
+            this.fieldSizeClass = fieldClass;
+        this.display = label;
+        this.key = propertyName;
+        this.value = propertyValue;
+        this.inputType = inputType;
+        this.wherePartType = wherePartType;
+        this.preventRemoval = preventRemoval;
+        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;
+        this.placeholder = label;
+    }
+    /**
+     * Identificativo univoco del filtro
+     */
+    filterID;
+    /**
+     * Permette di definire la classe css da applicare
+     * al filtro
+     */
+    fieldSizeClass = FieldSizeClass.SMALL;
+    /**
+     *
+     */
+    customFieldSizeClasses;
+    /**
+     * 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 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;
+    /**
+     * Definisce il placeholder che verrà utilizzato nel campo del singolo filtro
+     */
+    placeholder;
+    /**
+     * Permette di definire il template esterno da renderizzare come filtro.
+     */
+    externalTemplate;
+    /**
+     * 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 FilterField(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.value = 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
+     */
+    // public enumData?: any;
+    /**
+     * 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;
+    static createFilterFields(baseFields) {
+        if (Array.isArray(baseFields)) {
+            const filterFields = [];
+            baseFields.forEach(field => {
+                filterFields.push(this.createFilterField(field));
+            });
+            return filterFields;
+        }
+        else {
+            return this.createFilterField(baseFields);
+        }
+    }
+    static createFilterField(baseField) {
+        const filterField = new FilterField();
+        filterField.filterID = baseField.key + "_ID";
+        filterField.key = baseField.key;
+        filterField.display = baseField.display;
+        filterField.value = baseField.value;
+        filterField.enumModel = baseField.enumModel;
+        filterField.inputType = BaseTypeConverterFilter.convertToInputType(baseField.baseType);
+        filterField.wherePartType = WherePartType.Equal;
+        filterField.baseType = null;
+        return filterField;
+    }
+    static createFilterConfigs(filterFields) {
+        if (Array.isArray(filterFields)) {
+            const filterConfigs = [];
+            filterFields.forEach(field => {
+                filterConfigs.push(this.createFilterConfig(field));
+            });
+            return filterConfigs;
+        }
+        else {
+            return this.createFilterConfig(filterFields);
+        }
+    }
+    static createFilterConfig(filterField) {
+        const filterConfig = new FilterConfig();
+        filterConfig.FilterID = filterField.filterID ?? (filterField.key + "_ID");
+        filterConfig.PropertyName = filterField.key;
+        filterConfig.Label = filterField.display;
+        filterConfig.PropertyObject = filterField.value;
+        filterConfig.EnumData = filterField.enumModel;
+        filterConfig.Externaltemplate = filterField.externalTemplate;
+        filterConfig.ArrayData = filterField.arrayData;
+        filterConfig.ArrayKeyProperty = filterField.arrayKeyProperty;
+        filterConfig.ArrayValueProperty = filterField.arrayValueProperty;
+        filterConfig.BindLookupFullObject = filterField.bindLookupFullObject;
+        filterConfig.ChildElementPropertyName = filterField.childElementPropertyName;
+        filterConfig.CustomAppliedFilterInfoFunction = filterField.customAppliedFilterInfoFunction;
+        filterConfig.CustomFilterClasses = filterField.customFieldSizeClasses;
+        filterConfig.CustomWherePartFunction = filterField.customWherePartFunction;
+        filterConfig.CvlConfig = filterField.cvlConfig;
+        filterConfig.EnumSearchText = filterField.enumSearchText;
+        filterConfig.FilterClass = filterField.fieldSizeClass;
+        filterConfig.IsEnumMultiSelect = filterField.isEnumMultiSelect;
+        filterConfig.IsEnumSearchable = filterField.isEnumSearchable;
+        filterConfig.IsLookupMultiple = filterField.isLookupMultiple;
+        filterConfig.LookupEntityType = filterField.lookupEntityType;
+        filterConfig.LookupFullUrlHttpCall = filterField.lookupEntityType;
+        filterConfig.LookupSearchText = filterField.lookupSearchText;
+        filterConfig.DataFilter = filterField.dataFilter;
+        filterConfig.PreventRemoval = filterField.preventRemoval;
+        filterConfig.ShowEnumCancelButton = filterField.showEnumCancelButton;
+        filterConfig.ShowLookupCancelButton = filterField.showLookupCancelButton;
+        filterConfig.ValidationProperties = filterField.validationProperties;
+        filterConfig.InputType = filterField.inputType ?? InputType.Text;
+        filterConfig.WherePartType = filterField.wherePartType ?? WherePartType.Equal;
+        return filterConfig;
+    }
+}
+export class BaseTypeConverterFilter {
+    static convertToInputType(baseType) {
+        switch (baseType) {
+            case BaseType.Text:
+                return InputType.Text;
+            case BaseType.Number:
+                return InputType.Number;
+            case BaseType.Date:
+                return InputType.Date;
+            case BaseType.Enum:
+                return InputType.CvlEnum;
+            case BaseType.Boolean:
+                return InputType.Boolean;
+            default:
+                return undefined;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filterField.model.js","sourceRoot":"","sources":["../../../../../../../projects/eqp-attachments/src/lib/directives/eqp-common/models/filterField.model.ts"],"names":[],"mappings":"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","sourcesContent":["\r\nimport { FilterConfig, FilterCvlConfig, FilterSizeClass, InputType, ValidationObject, WherePartType } from './filterConfig.model';\r\nimport { TemplateRef } from '@angular/core';\r\nimport { LinqPredicateDTO } from './linqFilterResult.model';\r\nimport { BaseFieldModel, BaseType } from './base-field.model';\r\nimport { FieldSizeClass } from './common-enum.model';\r\n\r\nexport class FilterField extends BaseFieldModel {\r\n  constructor(filterID?: string,\r\n    fieldClass?: FieldSizeClass,\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    super();\r\n    this.filterID = filterID;\r\n    if (fieldClass) this.fieldSizeClass = fieldClass;\r\n\r\n    this.display = label;\r\n    this.key = propertyName;\r\n    this.value = propertyValue;\r\n    this.inputType = inputType;\r\n    this.wherePartType = wherePartType;\r\n    this.preventRemoval = preventRemoval;\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    this.placeholder = label;\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 fieldSizeClass?: FieldSizeClass = FieldSizeClass.SMALL;\r\n\r\n  /**\r\n   *\r\n   */\r\n  public customFieldSizeClasses?: string;\r\n\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 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   * Definisce il placeholder che verrà utilizzato nel campo del singolo filtro\r\n   */\r\n  public placeholder?: string;\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 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?: FieldSizeClass,\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  ): FilterField {\r\n    let filter: FilterField = new FilterField(\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.value = 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  static createFilterFields(baseField: BaseFieldModel): FilterField;\r\n  static createFilterFields(baseFields: BaseFieldModel[]): FilterField[];\r\n  static createFilterFields(baseFields: BaseFieldModel | BaseFieldModel[]): FilterField | FilterField[] {\r\n    if (Array.isArray(baseFields)) {\r\n      const filterFields: FilterField[] = [];\r\n      baseFields.forEach(field => {\r\n        filterFields.push(this.createFilterField(field));\r\n      });\r\n      return filterFields;\r\n    } else {\r\n      return this.createFilterField(baseFields);\r\n    }\r\n  }\r\n\r\n  private static createFilterField(baseField: BaseFieldModel): FilterField {\r\n    const filterField: FilterField = new FilterField();\r\n    filterField.filterID = baseField.key + \"_ID\";\r\n    filterField.key = baseField.key;\r\n    filterField.display = baseField.display;\r\n    filterField.value = baseField.value;\r\n    filterField.enumModel = baseField.enumModel;\r\n    filterField.inputType = BaseTypeConverterFilter.convertToInputType(baseField.baseType);\r\n    filterField.wherePartType = WherePartType.Equal;\r\n    filterField.baseType = null;\r\n\r\n    return filterField;\r\n  }\r\n\r\n  public static createFilterConfigs(filterField: FilterField): FilterConfig;\r\n  public static createFilterConfigs(filterFields: FilterField[]): FilterConfig[];\r\n  public static createFilterConfigs(filterFields: FilterField | FilterField[]): FilterConfig | FilterConfig[] {\r\n    if (Array.isArray(filterFields)) {\r\n      const filterConfigs: FilterConfig[] = [];\r\n      filterFields.forEach(field => {\r\n        filterConfigs.push(this.createFilterConfig(field));\r\n      });\r\n      return filterConfigs;\r\n    } else {\r\n      return this.createFilterConfig(filterFields);\r\n    }\r\n  }\r\n\r\n  private static createFilterConfig(filterField: FilterField): FilterConfig {\r\n    const filterConfig: FilterConfig = new FilterConfig();\r\n\r\n    filterConfig.FilterID = filterField.filterID ?? (filterField.key + \"_ID\");\r\n    filterConfig.PropertyName = filterField.key;\r\n    filterConfig.Label = filterField.display;\r\n    filterConfig.PropertyObject = filterField.value;\r\n    filterConfig.EnumData = filterField.enumModel;\r\n    filterConfig.Externaltemplate = filterField.externalTemplate;\r\n    filterConfig.ArrayData = filterField.arrayData;\r\n    filterConfig.ArrayKeyProperty = filterField.arrayKeyProperty;\r\n    filterConfig.ArrayValueProperty = filterField.arrayValueProperty;\r\n    filterConfig.BindLookupFullObject = filterField.bindLookupFullObject;\r\n    filterConfig.ChildElementPropertyName = filterField.childElementPropertyName;\r\n    filterConfig.CustomAppliedFilterInfoFunction = filterField.customAppliedFilterInfoFunction;\r\n    filterConfig.CustomFilterClasses = filterField.customFieldSizeClasses;\r\n    filterConfig.CustomWherePartFunction = filterField.customWherePartFunction;\r\n    filterConfig.CvlConfig = filterField.cvlConfig;\r\n    filterConfig.EnumSearchText = filterField.enumSearchText;\r\n    filterConfig.FilterClass = filterField.fieldSizeClass as unknown as FilterSizeClass;\r\n    filterConfig.IsEnumMultiSelect = filterField.isEnumMultiSelect;\r\n    filterConfig.IsEnumSearchable = filterField.isEnumSearchable;\r\n    filterConfig.IsLookupMultiple = filterField.isLookupMultiple;\r\n    filterConfig.LookupEntityType = filterField.lookupEntityType;\r\n    filterConfig.LookupFullUrlHttpCall = filterField.lookupEntityType;\r\n    filterConfig.LookupSearchText = filterField.lookupSearchText;\r\n    filterConfig.DataFilter = filterField.dataFilter;\r\n    filterConfig.PreventRemoval = filterField.preventRemoval;\r\n    filterConfig.ShowEnumCancelButton = filterField.showEnumCancelButton;\r\n    filterConfig.ShowLookupCancelButton = filterField.showLookupCancelButton;\r\n    filterConfig.ValidationProperties = filterField.validationProperties;\r\n    filterConfig.InputType = filterField.inputType ?? InputType.Text;\r\n    filterConfig.WherePartType = filterField.wherePartType ?? WherePartType.Equal;\r\n\r\n    return filterConfig;\r\n  }\r\n}\r\n\r\nexport class BaseTypeConverterFilter {\r\n  static convertToInputType(baseType: BaseType): InputType | undefined {\r\n    switch (baseType) {\r\n      case BaseType.Text:\r\n        return InputType.Text;\r\n      case BaseType.Number:\r\n        return InputType.Number;\r\n      case BaseType.Date:\r\n        return InputType.Date;\r\n      case BaseType.Enum:\r\n        return InputType.CvlEnum;\r\n      case BaseType.Boolean:\r\n        return InputType.Boolean;\r\n      default:\r\n        return undefined;\r\n    }\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,168 @@
+import { FieldSizeClass } from "./common-enum.model";
+import { BaseFieldModel, BaseType } from "./base-field.model";
+export class FormField extends BaseFieldModel {
+    required = false;
+    showInForm = true;
+    booleanLabelPosition = BoolLabelPosition.After;
+    formFieldType;
+    lookupObject;
+    selectObject;
+    validationProperties;
+    placeholder;
+    externalTemplate;
+    fieldSizeClass = FieldSizeClass.SMALL;
+    customFieldSizeClasses;
+    dependentFieldKey;
+    orderPosition;
+    dependentValidation;
+    static createFormFields(baseFields) {
+        if (Array.isArray(baseFields)) {
+            const formFields = [];
+            baseFields.forEach(field => {
+                formFields.push(this.createFormField(field));
+            });
+            return formFields;
+        }
+        else {
+            return this.createFormField(baseFields);
+        }
+    }
+    static createFormField(baseField) {
+        const formField = new FormField();
+        formField.key = baseField.key;
+        formField.display = baseField.display;
+        formField.value = baseField.value;
+        formField.enumModel = baseField.enumModel;
+        formField.formFieldType = BaseTypeConverter.convertToFormFieldType(baseField.baseType);
+        formField.baseType = null;
+        return formField;
+    }
+}
+export var FormFieldType;
+(function (FormFieldType) {
+    FormFieldType[FormFieldType["Text"] = 1] = "Text";
+    FormFieldType[FormFieldType["Number"] = 2] = "Number";
+    FormFieldType[FormFieldType["Date"] = 3] = "Date";
+    FormFieldType[FormFieldType["Enum"] = 4] = "Enum";
+    FormFieldType[FormFieldType["Boolean"] = 5] = "Boolean";
+    FormFieldType[FormFieldType["ExternalTemplate"] = 6] = "ExternalTemplate";
+    FormFieldType[FormFieldType["Cvl"] = 7] = "Cvl";
+    FormFieldType[FormFieldType["Lookup"] = 8] = "Lookup";
+    FormFieldType[FormFieldType["DateTime"] = 9] = "DateTime";
+    FormFieldType[FormFieldType["DateRange"] = 10] = "DateRange";
+})(FormFieldType || (FormFieldType = {}));
+export var BoolLabelPosition;
+(function (BoolLabelPosition) {
+    BoolLabelPosition["Before"] = "before";
+    BoolLabelPosition["After"] = "after";
+})(BoolLabelPosition || (BoolLabelPosition = {}));
+export class LookupObject {
+    fullUrlHttpCall;
+    lookupEntityType;
+    showLookupCancelButton = true;
+    isLookupSearchable = false;
+    isLookupMultiple = false;
+    placeholder;
+    bindLabel = "Label";
+    bindKey = "ID";
+    items;
+    notFoundText = "Nessun risultato trovato";
+    genericAddComponent;
+    isMultiple = false;
+    isSearchable = true;
+    isClearable = true;
+    isVirtualScroll = false;
+    isReadonly = false;
+    isRequired = false;
+    isDisabled = false;
+    entityType;
+    formGroupInput;
+    formControlNameInput;
+    ngModelInput;
+    isSearchWhileComposing = false;
+    bindCompleteObject = true;
+    appendToInput;
+    disableReloadOnLookupAddingCompleteParent = false;
+    showOptionTooltip = false;
+    sortList = false;
+    dataFilter;
+    customConfig;
+    complexDataFilter;
+    initialItems;
+    ngModelOptions = null;
+    isEditable = false;
+    isMultiline = false;
+    dropdownPosition = "auto";
+    selectOnTab = false;
+    addButtonText = "Crea nuovo";
+    editButtonText = "Modifica";
+    selectAll = false;
+    selectAllText = "Seleziona tutto";
+    groupBy = "";
+    groupValue = () => true;
+    groupByProperty;
+    selectableGroup = false;
+    selectableGroupAsModel = false;
+    clearAllText = "Elimina";
+    customOption;
+    customLabel;
+    manipulateDataFn;
+    compareFunction = (iteratedObject, bindedObject) => {
+        if (iteratedObject == null || bindedObject == null)
+            return true;
+        const iteratedKeyProperty = iteratedObject.Key != null ? "Key" : this.bindKey;
+        const bindedKeyProperty = bindedObject?.Key != null ? "Key" : this.bindKey;
+        return iteratedObject[iteratedKeyProperty] === bindedObject ||
+            iteratedObject[iteratedKeyProperty] === bindedObject[bindedKeyProperty];
+    };
+}
+export class SelectObject {
+    isEnumMultiSelect;
+    showEnumCancelButton;
+    isEnumSearchable;
+    enumSearchText;
+    arrayData;
+    arrayKeyProperty;
+    arrayValueProperty;
+    enumData;
+    enumDataToExclude;
+    ngModelOptions;
+    ngModelInput;
+    isRequired;
+    isMultiLanguage;
+    multilanguagePrefixKey;
+    isAlphabeticalOrderable;
+    suffixIcon;
+    prefixIcon;
+    isReadonly;
+    isSearchWhileComposing;
+    appendToInput;
+    dropdownPosition;
+    selectOnTab;
+    selectAll;
+    selectAllText;
+    selectableGroupAsModel;
+    clearAllText;
+    customOption;
+    customLabel;
+    class;
+}
+export class BaseTypeConverter {
+    static convertToFormFieldType(baseType) {
+        switch (baseType) {
+            case BaseType.Text:
+                return FormFieldType.Text;
+            case BaseType.Number:
+                return FormFieldType.Number;
+            case BaseType.Date:
+                return FormFieldType.Date;
+            case BaseType.Enum:
+                return FormFieldType.Enum;
+            case BaseType.Boolean:
+                return FormFieldType.Boolean;
+            default:
+                return undefined;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form.model.js","sourceRoot":"","sources":["../../../../../../../projects/eqp-attachments/src/lib/directives/eqp-common/models/form.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { TemplateRef } from \"@angular/core\";\r\nimport { FieldSizeClass } from \"./common-enum.model\";\r\nimport { BaseFieldModel, BaseType } from \"./base-field.model\";\r\nimport { ValidationObject } from \"./filterConfig.model\";\r\nimport { ComplexLinqPredicateDTO, LinqPredicateDTO, LookupCustomConfig, LookupDTO } from \"./linqFilterResult.model\";\r\nimport { DropdownPosition } from \"@ng-select/ng-select\";\r\nimport { DynamicLoaderDirectiveData } from \"../dynamic-loader/dynamic-loader.directive\";\r\n\r\nexport class FormField extends BaseFieldModel {\r\n  required?: boolean = false;\r\n  showInForm?: boolean = true;\r\n  booleanLabelPosition?: BoolLabelPosition = BoolLabelPosition.After;\r\n  formFieldType?: FormFieldType;\r\n  lookupObject?: LookupObject;\r\n  selectObject?: SelectObject;\r\n  validationProperties?: ValidationObject;\r\n  placeholder?: string;\r\n  externalTemplate?: TemplateRef<any>;\r\n  fieldSizeClass?: FieldSizeClass = FieldSizeClass.SMALL;\r\n  customFieldSizeClasses?: string;\r\n  dependentFieldKey?: string;\r\n  orderPosition?: number;\r\n  dependentValidation?: (value: any) => boolean;\r\n\r\n  static createFormFields(baseField: BaseFieldModel): FormField;\r\n  static createFormFields(baseFields: BaseFieldModel[]): FormField[];\r\n  static createFormFields(baseFields: BaseFieldModel | BaseFieldModel[]): FormField | FormField[] {\r\n    if (Array.isArray(baseFields)) {\r\n      const formFields: FormField[] = [];\r\n      baseFields.forEach(field => {\r\n        formFields.push(this.createFormField(field));\r\n      });\r\n      return formFields;\r\n    } else {\r\n      return this.createFormField(baseFields);\r\n    }\r\n  }\r\n\r\n  private static createFormField(baseField: BaseFieldModel): FormField {\r\n    const formField: FormField = new FormField();\r\n    formField.key = baseField.key;\r\n    formField.display = baseField.display;\r\n    formField.value = baseField.value;\r\n    formField.enumModel = baseField.enumModel;\r\n    formField.formFieldType = BaseTypeConverter.convertToFormFieldType(baseField.baseType);\r\n    formField.baseType = null;\r\n\r\n    return formField;\r\n  }\r\n}\r\n\r\nexport enum FormFieldType {\r\n  Text = 1,\r\n  Number = 2,\r\n  Date = 3,\r\n  Enum = 4,\r\n  Boolean = 5,\r\n  ExternalTemplate = 6,\r\n  Cvl = 7,\r\n  Lookup = 8,\r\n  DateTime = 9,\r\n  DateRange = 10\r\n}\r\n\r\nexport enum BoolLabelPosition {\r\n  Before = 'before',\r\n  After = 'after'\r\n}\r\n\r\nexport class LookupObject {\r\n  fullUrlHttpCall: string;\r\n  lookupEntityType: string;\r\n  showLookupCancelButton?: boolean = true;\r\n  isLookupSearchable?: boolean = false;\r\n  isLookupMultiple?: boolean = false;\r\n  placeholder?: string;\r\n  bindLabel?: string = \"Label\";\r\n  bindKey?: string = \"ID\";\r\n  items?: Array<any> | null;\r\n  notFoundText?: string = \"Nessun risultato trovato\";\r\n  genericAddComponent?: DynamicLoaderDirectiveData;\r\n  isMultiple?: boolean = false;\r\n  isSearchable?: boolean = true;\r\n  isClearable?: boolean = true;\r\n  isVirtualScroll?: boolean = false;\r\n  isReadonly?: boolean = false;\r\n  isRequired?: boolean = false;\r\n  isDisabled?: boolean = false;\r\n  entityType?: string;\r\n  formGroupInput?: any;\r\n  formControlNameInput?: any;\r\n  ngModelInput?: any;\r\n  isSearchWhileComposing?: boolean = false;\r\n  bindCompleteObject?: boolean = true;\r\n  appendToInput?: string;\r\n  disableReloadOnLookupAddingCompleteParent?: boolean = false;\r\n  showOptionTooltip?: boolean = false;\r\n  sortList?: boolean = false;\r\n  dataFilter?: Array<LinqPredicateDTO> | null;\r\n  customConfig?: LookupCustomConfig | null;\r\n  complexDataFilter?: Array<ComplexLinqPredicateDTO> | null;\r\n  initialItems?: Array<any> | null;\r\n  ngModelOptions?: any = null;\r\n  isEditable?: boolean = false;\r\n  isMultiline?: boolean = false;\r\n  dropdownPosition?: DropdownPosition = \"auto\";\r\n  selectOnTab?: boolean = false;\r\n  addButtonText?: string = \"Crea nuovo\";\r\n  editButtonText?: string = \"Modifica\";\r\n  selectAll?: boolean = false;\r\n  selectAllText?: string = \"Seleziona tutto\";\r\n  groupBy?: string | ((value: any) => any) = \"\";\r\n  groupValue?: (groupKey: string, children: any[]) => Object = () => true;\r\n  groupByProperty?: string;\r\n  selectableGroup?: boolean = false;\r\n  selectableGroupAsModel?: boolean = false;\r\n  clearAllText?: string = \"Elimina\";\r\n  customOption?: TemplateRef<any>;\r\n  customLabel?: TemplateRef<any>;\r\n  manipulateDataFn?: ((items: any) => LookupDTO[]) | undefined;\r\n  compareFunction?: (iteratedObject: any, bindedObject: any) => boolean = (iteratedObject, bindedObject) => {\r\n    if (iteratedObject == null || bindedObject == null) return true;\r\n    const iteratedKeyProperty = iteratedObject.Key != null ? \"Key\" : this.bindKey;\r\n    const bindedKeyProperty = bindedObject?.Key != null ? \"Key\" : this.bindKey;\r\n    return iteratedObject[iteratedKeyProperty] === bindedObject ||\r\n      iteratedObject[iteratedKeyProperty] === bindedObject[bindedKeyProperty];\r\n  };\r\n}\r\n\r\nexport class SelectObject {\r\n  isEnumMultiSelect?: boolean;\r\n  showEnumCancelButton?: boolean;\r\n  isEnumSearchable?: boolean;\r\n  enumSearchText?: string;\r\n  arrayData?: any;\r\n  arrayKeyProperty?: string;\r\n  arrayValueProperty?: string;\r\n  enumData?: any;\r\n  enumDataToExclude?: Array<any>;\r\n  ngModelOptions?: any;\r\n  ngModelInput?: any;\r\n  isRequired?: boolean;\r\n  isMultiLanguage?: boolean;\r\n  multilanguagePrefixKey?: string;\r\n  isAlphabeticalOrderable?: boolean;\r\n  suffixIcon?: string;\r\n  prefixIcon?: string;\r\n  isReadonly?: boolean;\r\n  isSearchWhileComposing?: boolean;\r\n  appendToInput?: string | undefined;\r\n  dropdownPosition?: \"bottom\" | \"top\" | \"auto\";\r\n  selectOnTab?: boolean;\r\n  selectAll?: boolean;\r\n  selectAllText?: string;\r\n  selectableGroupAsModel?: boolean;\r\n  clearAllText?: string;\r\n  customOption?: TemplateRef<any>;\r\n  customLabel?: TemplateRef<any>;\r\n  class?: string;\r\n}\r\n\r\n\r\nexport class BaseTypeConverter {\r\n  static convertToFormFieldType(baseType: BaseType): FormFieldType | undefined {\r\n    switch (baseType) {\r\n      case BaseType.Text:\r\n        return FormFieldType.Text;\r\n      case BaseType.Number:\r\n        return FormFieldType.Number;\r\n      case BaseType.Date:\r\n        return FormFieldType.Date;\r\n      case BaseType.Enum:\r\n        return FormFieldType.Enum;\r\n      case BaseType.Boolean:\r\n        return FormFieldType.Boolean;\r\n      default:\r\n        return undefined;\r\n    }\r\n  }\r\n}\r\n\r\n"]}

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

@@ -0,0 +1,73 @@
+/**
+ * Classe utilizzata per la definizione di filtri avanzati.
+ * Si basa sul concetto del LinqPredicate documentato nella guida EqProject.
+ *
+ * Ciascun oggetto LinqPredicateDTO può contenenere la definizione di N filtri diversi (di tipo LinqFilterDTO) che potranno essere messi tutti in OR tra loro.
+ * In presenza di più oggetti di tipo LinqPredicateDTO tutti i LinqPredicateDTO saranni invece messi in AND tra loro.
+ * In questo modo sarà possibile realizzare condizioni complesse
+ */
+export class LinqPredicateDTO {
+    /**
+     * Elenco di filtri di uno stesso predicato.
+     * Tutti i filtri contenuti in questa proprietà saranno considerati parte di tante OR
+     */
+    PropertyFilters;
+}
+/**
+ * Permette di definire ogni singola condizione di una where part.
+ */
+export class LinqFilterDTO {
+    /**
+     * Nome della proprietà su cui applicare il filtro
+     */
+    PropertyName;
+    /**
+     * Valore della proprietà su cui applicare il filtro
+     */
+    PropertyValue;
+    /**
+     * Tipo di relazione. Identifica cioè l'operatore di confronto della where part
+     */
+    RelationType;
+    /**
+     * Se RelationType = ContainsElement o NotContainsElement allora in questa proprietà ci verrà definito
+     * il nome della proprietà degli oggetti della lista su cui applicare l'operatore Any
+     */
+    ListElementPropertyName;
+    static createFilter(propertyName, propertyValue, relationType, listElementPropertyName = null) {
+        let filter = new LinqFilterDTO();
+        filter.ListElementPropertyName = listElementPropertyName;
+        filter.PropertyName = propertyName;
+        filter.RelationType = relationType;
+        filter.PropertyValue = propertyValue;
+        return filter;
+    }
+}
+export class LookupCustomConfig {
+    LabelProperties;
+    IncludeFullObject;
+}
+export class ComplexLinqPredicateDTO {
+    Predicates;
+    /**
+     * Ricostruisce l'array di predicati complessi a partire dalla matrice di LinqPredicateDTO passata nel parametro.
+     * Ogni riga della matrice diventerà un elemento della lista restituita.
+     * Ogni elemento delle lista conterrà i dati della riga della matrice.
+     * @param complexPredicates Restituisce un array di oggetti di tipo ComplexLinqPredicateDTO
+     */
+    static CreateComplexPredicate(complexPredicates) {
+        let results = new Array();
+        complexPredicates.forEach(cp => {
+            let complexPredicate = new ComplexLinqPredicateDTO();
+            complexPredicate.Predicates = cp;
+            results.push(complexPredicate);
+        });
+        return results;
+    }
+}
+export class LookupDTO {
+    ID;
+    Label;
+    FullObject;
+}
+//# sourceMappingURL=data:application/json;base64,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