7336308522

Committed 27 Dec 2023 07:57AM UTC coverage: 26.164% (-0.007%) from 26.171%

Build # 7336308522

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #54 from OSWeDev/master_mde_2

Master mde 2

Run Details

4415 of 20180 branches covered (0.0%)

Branch coverage included in aggregate %.

0 of 10 new or added lines in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

9559 of 33230 relevant lines covered (28.77%)

722.16 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

2.73

/src/shared/modules/DAO/vos/datatable/DatatableField.ts

import IDistantVOBase from '../../../../../shared/modules/IDistantVOBase';
import ModuleTable from '../../../../../shared/modules/ModuleTable';
import WeightHandler from '../../../../tools/WeightHandler';
import Alert from '../../../Alert/vos/Alert';
import ModuleTableField from '../../../ModuleTableField';
import VOsTypesManager from '../../../VO/manager/VOsTypesManager';
import ICRUDComponentField from '../../interface/ICRUDComponentField';

/**
 * On utilise le design pattern Fluent_interface : https://en.wikipedia.org/wiki/Fluent_interface
 */
export default abstract class DatatableField<T, U> implements IDistantVOBase {

    public static REF_RANGES_FIELD_TYPE: string = "RefRanges";
    public static MANY_TO_MANY_FIELD_TYPE: string = "ManyToMany";
    public static MANY_TO_ONE_FIELD_TYPE: string = "ManyToOne";
    public static ONE_TO_MANY_FIELD_TYPE: string = "OneToMany";
    public static SIMPLE_FIELD_TYPE: string = "Simple";
    public static COMPUTED_FIELD_TYPE: string = "COMPUTED";
    public static COMPONENT_FIELD_TYPE: string = "COMPONENT";
    public static INPUT_FIELD_TYPE: string = "INPUT";
    public static FILE_FIELD_TYPE: string = "FILE";
    public static VAR_FIELD_TYPE: string = "VAR";
    public static SELECT_BOX_FIELD_TYPE: string = "SELECT_BOX";
    public static CRUD_ACTIONS_FIELD_TYPE: string = "CRUD_ACTIONS";


    // Pour éviter les liens d'import on stocke au chargement de l'appli ici et on type pas... à améliorer certainement plus tard
    public static VueAppBase = null;

    public static computed_value: { [datatable_field_uid: string]: (field_value: any, moduleTableField: ModuleTableField<any>, vo: IDistantVOBase, datatable_field_uid: string) => any } = {};

    /**
     * Field uniquement côté client..... a voir si on a pas plus propre comme système
     */
    public vue_component: ICRUDComponentField = null;

    public id: number;
    public _type: string;

    public _vo_type_id: string;

    public vo_type_full_name: string;


    /**
     * Surcharges du ModuleTableField
     */
    public field_type: string;
    public enum_values: { [value: number]: string };
    public segmentation_type: number;
    public is_inclusive_data: boolean;
    public is_inclusive_ihm: boolean;
    public return_min_value: boolean;
    public format_localized_time: boolean;
    public return_max_value: boolean;
    public max_range_offset: number;

    public tooltip: string = null;

    /**
     * Used in the CREATE or UPDATE views
     */
    public is_required: boolean = false;

    /**
     * Used in the CREATE or UPDATE views to show infos that are not editable
     */
    public is_readonly: boolean = false;

    /**
     * Show/Hide field from datatable
     */
    public hidden: boolean = false;

    /**
     * Show/Hide field from export
     */
    public hiden_export: boolean = false;

    /**
     * Show/Hide field from print
     */
    public hidden_print: boolean = false;

    /**
     * Force Toggle Button to be visible
     */
    public force_toggle_button: boolean = false;

    /**
     * Used in the CREATE or UPDATE views
     */
    public translatable_place_holder: string = null;
    public translatable_title_custom: string = null;

    public select_options_enabled: number[] = null;

    /**
     * BEWARE : Only update for view datatables purposes with viewing multiple times the same field, on different angles.
     * On create or update tables, let it same as datatable_field_uid
     */
    public _module_table_field_id: string;

    abstract get translatable_title(): string;

    public validate: (data: any) => string;
    /**
     * @returns true si seul le field du champ est modifié, false si d'autres champs sont modifiés => forcera un reload global du vo
     */
    public onChange: (vo: IDistantVOBase) => boolean | Promise<boolean>;
    public onEndOfChange: (vo: IDistantVOBase) => boolean | Promise<boolean>;
    public isVisibleUpdateOrCreate: (vo: IDistantVOBase) => boolean;

    public validate_input: (input_value: U, field: DatatableField<T, U>, vo: any) => Alert[] = null;

    //definit comment trier le field si besoin
    public sort: (vos: IDistantVOBase[]) => void;
    public sortEnum: (opts: number[]) => void;

    //definit la fonction qui permet de filtrer
    public sieve: (vos: IDistantVOBase[]) => IDistantVOBase[];
    public sieveCondition: (e: any) => boolean;
    public sieveEnum: (opts: number[]) => number[];

    public semaphore_auto_update_datatable_field_uid_with_vo_type: boolean = false;

    /**
     *
     * @param type Pour identifier hors contexte typescript le type réel de l'objet...
     * @param datatable_field_uid uid au sein de la datatable pour ce field. Permet d'identifier la colonne. Un nom compatible avec un nom de field
     * @param translatable_title Le titre du field, à passer à la traduction au dernier moment
     */
    public type: string;
    public datatable_field_uid: string;

    get module_table_field_id(): string {
        return this._module_table_field_id;
    }

    set module_table_field_id(module_table_field_id: string) {
        this._module_table_field_id = module_table_field_id;

        this.update_moduleTableField();
    }

    public setModuleTable(moduleTable: ModuleTable<any>): this {
        this.vo_type_full_name = moduleTable.full_name;
        this.vo_type_id = moduleTable.vo_type;
        return this;
    }

    get vo_type_id(): string {
        return this._vo_type_id;
    }

    set vo_type_id(vo_type_id: string) {
        if (!vo_type_id) {
            return;
        }

        this._vo_type_id = vo_type_id;

        this.update_moduleTableField();
    }

    get moduleTable(): ModuleTable<any> {
        if (!this.vo_type_id) {
            return null;
        }

        return VOsTypesManager.moduleTables_by_voType[this.vo_type_id];
    }

    get moduleTableField(): ModuleTableField<T> {
        if (!this.moduleTable) {
            return null;
        }

        return this.moduleTable.getFieldFromId(this.module_table_field_id);
    }

    public auto_update_datatable_field_uid_with_vo_type() {
        if (!this.semaphore_auto_update_datatable_field_uid_with_vo_type) {
            this.semaphore_auto_update_datatable_field_uid_with_vo_type = true;
            this.datatable_field_uid = (this.vo_type_id ? this.vo_type_id : this.type) + '___' + this.datatable_field_uid;
        }
        return this;
    }

    public hide(): this {
        this.hidden = true;
        this.hidden_print = true;

        return this;
    }

    public show(): this {
        this.hidden = false;
        this.hidden_print = false;

        return this;
    }

    public set_tooltip(tooltip: string): this {
        this.tooltip = tooltip;

        return this;
    }

    public hide_print(): this {
        this.hidden_print = true;

        return this;
    }

    public set_force_toggle_button(): this {
        this.force_toggle_button = true;

        return this;
    }

    public hide_export(): this {
        this.hiden_export = true;

        return this;
    }


    public setIsVisibleUpdateOrCreate<P extends IDistantVOBase>(isVisibleUpdateOrCreate: (vo: P) => boolean): this {
        this.isVisibleUpdateOrCreate = isVisibleUpdateOrCreate;
        return this;
    }

    public setOnChange<P extends IDistantVOBase>(onChange: (vo: P) => boolean | Promise<boolean>): this {
        this.onChange = onChange;

        return this;
    }

    public setOnEndOfChange<P extends IDistantVOBase>(onEndOfChange: (vo: P) => boolean | Promise<boolean>): this {
        this.onEndOfChange = onEndOfChange;

        return this;
    }

    /**
     * permet de definir une fonction de tri
     * @param fonctionComparaison
     * @returns datatable avec la fonction de tri
     */
    public setSort<P extends IDistantVOBase>(fonctionComparaison: (vo1: P, vo2: P) => number): this {
        this.sort = (vos: P[]): P[] => vos.sort(fonctionComparaison);

        return this;
    }

    public setSortEnum(fonctionComparaison: (opts: number[]) => void): DatatableField<T, U> {
        this.sortEnum = fonctionComparaison;

        return this;
    }

    /**
     * permet de definir une fonction de filtrage sur les elts à afficher (sieve: passer au tamis)
     * par defaut laisse tout passer (pas de tri)
     * @param condition - la condition pour garder les elements
     * (ex: (vo) => vo_ids.includes(vo.id) ou (vo) => vo.id>10)
     * @returns datafield
     */
    public setSieveCondition<P extends IDistantVOBase>(condition: (vos: P) => boolean = null): this {

        this.sieve = (vos: P[]): P[] => vos.filter((elt) => true);
        this.sieveCondition = (e) => true;

        if (condition != null) {
            this.sieve = (vos: P[]): P[] => vos.filter(condition);
            this.sieveCondition = condition;
        }

        return this;
    }

    public setSieveEnum(condition: (opts: number[]) => number[]): DatatableField<T, U> {

        this.sieveEnum = condition;

        return this;
    }

    /**
     * applique tri et filtrage aux options
     * @param options liste d'options non triée/filtrée
     * @returns liste d'options triée/filtrée
     */
    public triFiltrage(options: { [id: number]: IDistantVOBase; }) {

        if (!options) {
            return;
        }

        //transforme les options en arrays pour le tri
        let optionsArray: IDistantVOBase[] = Object.values(options);

        // tri en fonction de la fonction de tri, Sinon on va trier par weight si c'est un objet avec un weight
        if (this.sort && optionsArray) {
            this.sort(optionsArray);
        } else if (optionsArray && optionsArray[0] && optionsArray[0]['weight']) {
            optionsArray = WeightHandler.getInstance().sortByWeight(optionsArray as any);
        }

        //s'il y a une fonction de filtrage on filtre
        if (this.sieve) {
            optionsArray = this.sieve(optionsArray);
        }
        return optionsArray;
    }

    public triFiltrageEnum(opts: number[]): number[] {
        if (this.sortEnum) {
            this.sortEnum(opts);
        }

        if (this.sieveEnum) {
            opts = this.sieveEnum(opts);
        }

        return opts;
    }

    public setValidator(validator: (data: any) => string): this {
        this.validate = validator;

        return this;
    }

    public setValidatInputFunc(validate_input: (input_value: U, field: DatatableField<T, U>, vo: any) => Alert[]): this {
        this.validate_input = validate_input;

        return this;
    }

    /**
     * BEWARE : Only update for view datatables purposes with viewing multiple times the same field, on different angles.
     * On create or update tables, let it same as module_table_field_id
     */
    public setUID_for_readDuplicateOnly(datatable_field_uid: string): this {
        this.datatable_field_uid = datatable_field_uid;
        return this;
    }

    /**
     * Force required
     */
    public required(): this {
        this.is_required = true;
        return this;
    }

    /**
     * Force readonly
     */
    public readonly(): this {
        this.is_readonly = true;
        return this;
    }

    /**
     * @param code_text Code du translatable text associé
     */
    public setPlaceholder(code_text: string): this {
        this.translatable_place_holder = code_text;
        return this;
    }

    /**
     * @param code_text Code du translatable text associé
     */
    public setTranslatableTitle(code_text: string): this {
        this.translatable_title_custom = code_text;
        return this;
    }

    get alert_path(): string {
        if (!this.vo_type_full_name) {
            return this.datatable_field_uid;
        }
        return this.vo_type_full_name + '.' + this.datatable_field_uid;
    }

    /**
     * A modifier pour gérer le dataToIHM en fonction des types d'entrée sortie.
     * Par défaut on renvoie sans modification. Attention au typage.
     */
    public dataToReadIHM(e: T, vo: IDistantVOBase): U {
        return e as any;
    }

    /**
     * A modifier pour gérer le dataToIHM en fonction des types d'entrée sortie.
     * Par défaut on renvoie comme le read.
     */
    public dataToUpdateIHM(e: T, vo: IDistantVOBase): U {
        return this.dataToReadIHM(e, vo);
    }

    /**
     * A modifier pour gérer le dataToIHM en fonction des types d'entrée sortie.
     * Par défaut on renvoie comme le read.
     */
    public dataToCreateIHM(e: T, vo: IDistantVOBase): U {
        return this.dataToReadIHM(e, vo);
    }

    /**
     * A modifier pour gérer le IHMToData en fonction des types d'entrée sortie.
     * Par défaut on renvoie sans modification. Attention au typage.
     */
    public ReadIHMToData(e: U, vo: IDistantVOBase): T {
        return e as any;
    }

    /**
     * A modifier pour gérer le IHMToData en fonction des types d'entrée sortie.
     * Par défaut on renvoie comme le read.
     */
    public UpdateIHMToData(e: U, vo: IDistantVOBase): T {
        return this.ReadIHMToData(e, vo);
    }

    /**
     * A modifier pour gérer le IHMToData en fonction des types d'entrée sortie.
     * Par défaut on renvoie comme le read.
     */
    public CreateIHMToData(e: U, vo: IDistantVOBase): T {
        return this.ReadIHMToData(e, vo);
    }

    public getValidationTextCodeBase(): string {
        return "";
    }


    public dataToHumanReadableField(e: IDistantVOBase): U {
        return null;
    }

    /**
     * n'affiche que les vos dont les ids sont renseignés
     * @param options les id des vos à afficher
     * @returns le datatableField modifié
     */
    public async setSelectOptionsEnabled(options: number[]): Promise<DatatableField<T, U>> {
        this.select_options_enabled = Array.from(options);

        if (!!this.vue_component) {
            // on informe
            this.vue_component.$data.select_options_enabled = Array.from(options);
            await this.vue_component.on_reload_field_value();
        }

        return this;
    }

    public setComputedValueFunc(computed_value: (field_value: any, moduleTableField: ModuleTableField<any>, vo: IDistantVOBase, datatable_field_uid: string) => any): this {
        DatatableField.computed_value[this.datatable_field_uid] = computed_value;

        return this;
    }

    protected init(_type: string, type: string, datatable_field_uid: string) {
        this._type = _type;
        this.type = type;
        this.datatable_field_uid = datatable_field_uid;
        this.module_table_field_id = datatable_field_uid;
        this.validate = null;
        this.onChange = null;
        this.onEndOfChange = null;
        this.isVisibleUpdateOrCreate = () => true;
    }

    private update_moduleTableField() {
        if (this.moduleTableField) {
            this.is_required = this.moduleTableField.field_required;
            this.validate = (this.validate != null) ? this.validate : this.moduleTableField.validate;
            this.field_type = (this.field_type != null) ? this.field_type : this.moduleTableField.field_type;
            this.enum_values = (this.enum_values != null) ? this.enum_values : this.moduleTableField.enum_values;
            this.segmentation_type = (this.segmentation_type != null) ? this.segmentation_type : this.moduleTableField.segmentation_type;
            this.is_inclusive_data = (this.is_inclusive_data != null) ? this.is_inclusive_data : this.moduleTableField.is_inclusive_data;
            this.is_inclusive_ihm = (this.is_inclusive_ihm != null) ? this.is_inclusive_ihm : this.moduleTableField.is_inclusive_ihm;
            this.return_min_value = (this.return_min_value != null) ? this.return_min_value : this.moduleTableField.return_min_value;
            this.format_localized_time = (this.format_localized_time != null) ? this.format_localized_time : this.moduleTableField.format_localized_time;
            this.return_max_value = (this.return_max_value != null) ? this.return_max_value : this.moduleTableField.return_max_value;
            this.max_range_offset = (this.max_range_offset != null) ? this.max_range_offset : this.moduleTableField.max_range_offset;
        }
    }
}

1	import IDistantVOBase from '../../../../../shared/modules/IDistantVOBase';
2	import ModuleTable from '../../../../../shared/modules/ModuleTable';
3	import WeightHandler from '../../../../tools/WeightHandler';	3✔
4	import Alert from '../../../Alert/vos/Alert';
5	import ModuleTableField from '../../../ModuleTableField';
6	import VOsTypesManager from '../../../VO/manager/VOsTypesManager';	6✔
7	import ICRUDComponentField from '../../interface/ICRUDComponentField';
8
9	/**
10	* On utilise le design pattern Fluent_interface : https://en.wikipedia.org/wiki/Fluent_interface
11	*/
12	export default abstract class DatatableField<T, U> implements IDistantVOBase {	3✔
13
14	public static REF_RANGES_FIELD_TYPE: string = "RefRanges";
15	public static MANY_TO_MANY_FIELD_TYPE: string = "ManyToMany";
16	public static MANY_TO_ONE_FIELD_TYPE: string = "ManyToOne";
17	public static ONE_TO_MANY_FIELD_TYPE: string = "OneToMany";
18	public static SIMPLE_FIELD_TYPE: string = "Simple";
19	public static COMPUTED_FIELD_TYPE: string = "COMPUTED";
20	public static COMPONENT_FIELD_TYPE: string = "COMPONENT";
21	public static INPUT_FIELD_TYPE: string = "INPUT";
22	public static FILE_FIELD_TYPE: string = "FILE";
23	public static VAR_FIELD_TYPE: string = "VAR";
24	public static SELECT_BOX_FIELD_TYPE: string = "SELECT_BOX";
25	public static CRUD_ACTIONS_FIELD_TYPE: string = "CRUD_ACTIONS";
26
27
28	// Pour éviter les liens d'import on stocke au chargement de l'appli ici et on type pas... à améliorer certainement plus tard
29	public static VueAppBase = null;
30
31	public static computed_value: { [datatable_field_uid: string]: (field_value: any, moduleTableField: ModuleTableField<any>, vo: IDistantVOBase, datatable_field_uid: string) => any } = {};
32
33	/**	×
34	* Field uniquement côté client..... a voir si on a pas plus propre comme système
35	*/
36	public vue_component: ICRUDComponentField = null;	×
37
38	public id: number;	×
39	public _type: string;	×
40
41	public _vo_type_id: string;	×
42
43	public vo_type_full_name: string;
44
45
46	/**	×
47	* Surcharges du ModuleTableField
48	*/
49	public field_type: string;	×
50	public enum_values: { [value: number]: string };	×
51	public segmentation_type: number;	×
52	public is_inclusive_data: boolean;	×
53	public is_inclusive_ihm: boolean;	×
54	public return_min_value: boolean;	×
55	public format_localized_time: boolean;	×
56	public return_max_value: boolean;	×
57	public max_range_offset: number;	×
58
59	public tooltip: string = null;
60
61	/**	×
62	* Used in the CREATE or UPDATE views
63	*/
64	public is_required: boolean = false;
65
66	/**	×
67	* Used in the CREATE or UPDATE views to show infos that are not editable
68	*/
69	public is_readonly: boolean = false;
70
71	/**	×
72	* Show/Hide field from datatable
73	*/
74	public hidden: boolean = false;
75
76	/**	×
77	* Show/Hide field from export
78	*/
79	public hiden_export: boolean = false;
80
81	/**	×
82	* Show/Hide field from print
83	*/
84	public hidden_print: boolean = false;
85
86	/**	×
87	* Force Toggle Button to be visible
88	*/
89	public force_toggle_button: boolean = false;
90
91	/**	×
92	* Used in the CREATE or UPDATE views
93	*/
94	public translatable_place_holder: string = null;	×
95	public translatable_title_custom: string = null;	×
96
97	public select_options_enabled: number[] = null;
98
99	/**	×
100	* BEWARE : Only update for view datatables purposes with viewing multiple times the same field, on different angles.
101	* On create or update tables, let it same as datatable_field_uid
102	*/
103	public _module_table_field_id: string;	×
104
105	abstract get translatable_title(): string;
106
107	public validate: (data: any) => string;
108	/**	×
109	* @returns true si seul le field du champ est modifié, false si d'autres champs sont modifiés => forcera un reload global du vo
110	*/
111	public onChange: (vo: IDistantVOBase) => boolean \| Promise<boolean>;	×
112	public onEndOfChange: (vo: IDistantVOBase) => boolean \| Promise<boolean>;	×
113	public isVisibleUpdateOrCreate: (vo: IDistantVOBase) => boolean;	×
114
115	public validate_input: (input_value: U, field: DatatableField<T, U>, vo: any) => Alert[] = null;
116
117	//definit comment trier le field si besoin	×
UNCOV 118	public sort: (vos: IDistantVOBase[]) => void;	×
119	public sortEnum: (opts: number[]) => void;
120
121	//definit la fonction qui permet de filtrer	×
122	public sieve: (vos: IDistantVOBase[]) => IDistantVOBase[];	×
123	public sieveCondition: (e: any) => boolean;	×
NEW 124	public sieveEnum: (opts: number[]) => number[];	×
125
126	public semaphore_auto_update_datatable_field_uid_with_vo_type: boolean = false;
127
128	/**	×
129	*
130	* @param type Pour identifier hors contexte typescript le type réel de l'objet...
131	* @param datatable_field_uid uid au sein de la datatable pour ce field. Permet d'identifier la colonne. Un nom compatible avec un nom de field
132	* @param translatable_title Le titre du field, à passer à la traduction au dernier moment
133	*/
134	public type: string;	×
135	public datatable_field_uid: string;
136
137	get module_table_field_id(): string {
138	return this._module_table_field_id;	×
139	}
140
141	set module_table_field_id(module_table_field_id: string) {
142	this._module_table_field_id = module_table_field_id;	×
143
144	this.update_moduleTableField();	×
145	}
146
147	public setModuleTable(moduleTable: ModuleTable<any>): this {
148	this.vo_type_full_name = moduleTable.full_name;	×
149	this.vo_type_id = moduleTable.vo_type;	×
150	return this;	×
151	}
152
153	get vo_type_id(): string {
154	return this._vo_type_id;	×
155	}
156
157	set vo_type_id(vo_type_id: string) {
158	if (!vo_type_id) {	×
159	return;	×
160	}
161
162	this._vo_type_id = vo_type_id;	×
163
164	this.update_moduleTableField();	×
165	}
166
167	get moduleTable(): ModuleTable<any> {
168	if (!this.vo_type_id) {	×
169	return null;	×
170	}
171
172	return VOsTypesManager.moduleTables_by_voType[this.vo_type_id];	×
173	}
174
175	get moduleTableField(): ModuleTableField<T> {
176	if (!this.moduleTable) {	×
177	return null;	×
178	}
179
180	return this.moduleTable.getFieldFromId(this.module_table_field_id);	×
181	}
182
183	public auto_update_datatable_field_uid_with_vo_type() {
184	if (!this.semaphore_auto_update_datatable_field_uid_with_vo_type) {	×
185	this.semaphore_auto_update_datatable_field_uid_with_vo_type = true;	×
186	this.datatable_field_uid = (this.vo_type_id ? this.vo_type_id : this.type) + '___' + this.datatable_field_uid;	×
187	}
188	return this;	×
189	}
190
191	public hide(): this {
192	this.hidden = true;	×
193	this.hidden_print = true;	×
194
195	return this;	×
196	}
197
198	public show(): this {
199	this.hidden = false;	×
200	this.hidden_print = false;	×
201
202	return this;	×
203	}
204
205	public set_tooltip(tooltip: string): this {
206	this.tooltip = tooltip;	×
207
208	return this;	×
209	}
210
211	public hide_print(): this {
212	this.hidden_print = true;	×
213
214	return this;	×
215	}
216
217	public set_force_toggle_button(): this {
218	this.force_toggle_button = true;	×
219
220	return this;	×
221	}
222
223	public hide_export(): this {
224	this.hiden_export = true;	×
225
226	return this;	×
227	}
228
229
230	public setIsVisibleUpdateOrCreate<P extends IDistantVOBase>(isVisibleUpdateOrCreate: (vo: P) => boolean): this {
231	this.isVisibleUpdateOrCreate = isVisibleUpdateOrCreate;	×
232	return this;	×
233	}
234
235	public setOnChange<P extends IDistantVOBase>(onChange: (vo: P) => boolean \| Promise<boolean>): this {
236	this.onChange = onChange;	×
237
238	return this;	×
239	}
240
241	public setOnEndOfChange<P extends IDistantVOBase>(onEndOfChange: (vo: P) => boolean \| Promise<boolean>): this {
242	this.onEndOfChange = onEndOfChange;	×
243
244	return this;	×
245	}
246
247	/**
248	* permet de definir une fonction de tri
249	* @param fonctionComparaison
250	* @returns datatable avec la fonction de tri
251	*/
252	public setSort<P extends IDistantVOBase>(fonctionComparaison: (vo1: P, vo2: P) => number): this {
253	this.sort = (vos: P[]): P[] => vos.sort(fonctionComparaison);	×
254
255	return this;	×
256	}
257
258	public setSortEnum(fonctionComparaison: (opts: number[]) => void): DatatableField<T, U> {
NEW 259	this.sortEnum = fonctionComparaison;	×
260
NEW 261	return this;	×
262	}
263
264	/**
265	* permet de definir une fonction de filtrage sur les elts à afficher (sieve: passer au tamis)
266	* par defaut laisse tout passer (pas de tri)
267	* @param condition - la condition pour garder les elements
268	* (ex: (vo) => vo_ids.includes(vo.id) ou (vo) => vo.id>10)
269	* @returns datafield
270	*/
271	public setSieveCondition<P extends IDistantVOBase>(condition: (vos: P) => boolean = null): this {	×
272
273	this.sieve = (vos: P[]): P[] => vos.filter((elt) => true);	×
274	this.sieveCondition = (e) => true;	×
275
276	if (condition != null) {	×
277	this.sieve = (vos: P[]): P[] => vos.filter(condition);	×
278	this.sieveCondition = condition;	×
279	}
280
281	return this;	×
282	}
283
284	public setSieveEnum(condition: (opts: number[]) => number[]): DatatableField<T, U> {
285
NEW 286	this.sieveEnum = condition;	×
287
NEW 288	return this;	×
289	}
290
291	/**
292	* applique tri et filtrage aux options
293	* @param options liste d'options non triée/filtrée
294	* @returns liste d'options triée/filtrée
295	*/
296	public triFiltrage(options: { [id: number]: IDistantVOBase; }) {
297
298	if (!options) {	×
299	return;	×
300	}
301
302	//transforme les options en arrays pour le tri
303	let optionsArray: IDistantVOBase[] = Object.values(options);	×
304
305	// tri en fonction de la fonction de tri, Sinon on va trier par weight si c'est un objet avec un weight
306	if (this.sort && optionsArray) {	×
307	this.sort(optionsArray);	×
308	} else if (optionsArray && optionsArray[0] && optionsArray[0]['weight']) {	×
309	optionsArray = WeightHandler.getInstance().sortByWeight(optionsArray as any);	×
310	}
311
312	//s'il y a une fonction de filtrage on filtre
313	if (this.sieve) {	×
314	optionsArray = this.sieve(optionsArray);	×
315	}
316	return optionsArray;	×
317	}
318
319	public triFiltrageEnum(opts: number[]): number[] {
NEW 320	if (this.sortEnum) {	×
NEW 321	this.sortEnum(opts);	×
322	}
323
NEW 324	if (this.sieveEnum) {	×
NEW 325	opts = this.sieveEnum(opts);	×
326	}
327
NEW 328	return opts;	×
329	}
330
331	public setValidator(validator: (data: any) => string): this {
332	this.validate = validator;	×
333
334	return this;	×
335	}
336
337	public setValidatInputFunc(validate_input: (input_value: U, field: DatatableField<T, U>, vo: any) => Alert[]): this {
338	this.validate_input = validate_input;	×
339
340	return this;	×
341	}
342
343	/**
344	* BEWARE : Only update for view datatables purposes with viewing multiple times the same field, on different angles.
345	* On create or update tables, let it same as module_table_field_id
346	*/
347	public setUID_for_readDuplicateOnly(datatable_field_uid: string): this {
348	this.datatable_field_uid = datatable_field_uid;	×
349	return this;	×
350	}
351
352	/**
353	* Force required
354	*/
355	public required(): this {
356	this.is_required = true;	×
357	return this;	×
358	}
359
360	/**
361	* Force readonly
362	*/
363	public readonly(): this {
364	this.is_readonly = true;	×
365	return this;	×
366	}
367
368	/**
369	* @param code_text Code du translatable text associé
370	*/
371	public setPlaceholder(code_text: string): this {
372	this.translatable_place_holder = code_text;	×
373	return this;	×
374	}
375
376	/**
377	* @param code_text Code du translatable text associé
378	*/
379	public setTranslatableTitle(code_text: string): this {
380	this.translatable_title_custom = code_text;	×
381	return this;	×
382	}
383
384	get alert_path(): string {
385	if (!this.vo_type_full_name) {	×
386	return this.datatable_field_uid;	×
387	}
388	return this.vo_type_full_name + '.' + this.datatable_field_uid;	×
389	}
390
391	/**
392	* A modifier pour gérer le dataToIHM en fonction des types d'entrée sortie.
393	* Par défaut on renvoie sans modification. Attention au typage.
394	*/
395	public dataToReadIHM(e: T, vo: IDistantVOBase): U {
396	return e as any;	×
397	}
398
399	/**
400	* A modifier pour gérer le dataToIHM en fonction des types d'entrée sortie.
401	* Par défaut on renvoie comme le read.
402	*/
403	public dataToUpdateIHM(e: T, vo: IDistantVOBase): U {
404	return this.dataToReadIHM(e, vo);	×
405	}
406
407	/**
408	* A modifier pour gérer le dataToIHM en fonction des types d'entrée sortie.
409	* Par défaut on renvoie comme le read.
410	*/
411	public dataToCreateIHM(e: T, vo: IDistantVOBase): U {
412	return this.dataToReadIHM(e, vo);	×
413	}
414
415	/**
416	* A modifier pour gérer le IHMToData en fonction des types d'entrée sortie.
417	* Par défaut on renvoie sans modification. Attention au typage.
418	*/
419	public ReadIHMToData(e: U, vo: IDistantVOBase): T {
420	return e as any;	×
421	}
422
423	/**
424	* A modifier pour gérer le IHMToData en fonction des types d'entrée sortie.
425	* Par défaut on renvoie comme le read.
426	*/
427	public UpdateIHMToData(e: U, vo: IDistantVOBase): T {
428	return this.ReadIHMToData(e, vo);	×
429	}
430
431	/**
432	* A modifier pour gérer le IHMToData en fonction des types d'entrée sortie.
433	* Par défaut on renvoie comme le read.
434	*/
435	public CreateIHMToData(e: U, vo: IDistantVOBase): T {
436	return this.ReadIHMToData(e, vo);	×
437	}
438
439	public getValidationTextCodeBase(): string {
440	return "";	×
441	}
442
443
444	public dataToHumanReadableField(e: IDistantVOBase): U {
445	return null;	×
446	}
447
448	/**
449	* n'affiche que les vos dont les ids sont renseignés
450	* @param options les id des vos à afficher
451	* @returns le datatableField modifié
452	*/
453	public async setSelectOptionsEnabled(options: number[]): Promise<DatatableField<T, U>> {
454	this.select_options_enabled = Array.from(options);	×
455
456	if (!!this.vue_component) {	×
457	// on informe
458	this.vue_component.$data.select_options_enabled = Array.from(options);	×
459	await this.vue_component.on_reload_field_value();	×
460	}
461
462	return this;	×
463	}
464
465	public setComputedValueFunc(computed_value: (field_value: any, moduleTableField: ModuleTableField<any>, vo: IDistantVOBase, datatable_field_uid: string) => any): this {
466	DatatableField.computed_value[this.datatable_field_uid] = computed_value;	×
467
468	return this;	×
469	}
470
471	protected init(_type: string, type: string, datatable_field_uid: string) {
472	this._type = _type;	×
473	this.type = type;	×
474	this.datatable_field_uid = datatable_field_uid;	×
475	this.module_table_field_id = datatable_field_uid;	×
476	this.validate = null;	×
477	this.onChange = null;	×
478	this.onEndOfChange = null;	×
479	this.isVisibleUpdateOrCreate = () => true;	×
480	}
481
482	private update_moduleTableField() {
483	if (this.moduleTableField) {	×
484	this.is_required = this.moduleTableField.field_required;	×
485	this.validate = (this.validate != null) ? this.validate : this.moduleTableField.validate;	×
486	this.field_type = (this.field_type != null) ? this.field_type : this.moduleTableField.field_type;	×
487	this.enum_values = (this.enum_values != null) ? this.enum_values : this.moduleTableField.enum_values;	×
488	this.segmentation_type = (this.segmentation_type != null) ? this.segmentation_type : this.moduleTableField.segmentation_type;	×
489	this.is_inclusive_data = (this.is_inclusive_data != null) ? this.is_inclusive_data : this.moduleTableField.is_inclusive_data;	×
490	this.is_inclusive_ihm = (this.is_inclusive_ihm != null) ? this.is_inclusive_ihm : this.moduleTableField.is_inclusive_ihm;	×
491	this.return_min_value = (this.return_min_value != null) ? this.return_min_value : this.moduleTableField.return_min_value;	×
492	this.format_localized_time = (this.format_localized_time != null) ? this.format_localized_time : this.moduleTableField.format_localized_time;	×
493	this.return_max_value = (this.return_max_value != null) ? this.return_max_value : this.moduleTableField.return_max_value;	×
494	this.max_range_offset = (this.max_range_offset != null) ? this.max_range_offset : this.moduleTableField.max_range_offset;	×
495	}
496	}
497	}	3✔

OSWeDev / OSWeDev / 7336308522

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous