ps-toolkit-ui 1.21.42 → 1.21.51

package/esm2015/lib/components/table/row/table.row.component.js

@@ -0,0 +1,450 @@
+import { Component, EventEmitter, HostListener, Input, Output, ViewChild } from '@angular/core';
+import { InputType, Method, PermissionAccessTypeEnum, PermissionInputActionEnum, PermissionInputTypeEnum, PermissionTypeEnum, TableOptionType, TableRowStatus } from '../../../classes/enum.class';
+import { InputClass } from '../../../classes/form.class';
+import { RequestClass } from '../../../classes/request.class';
+import { HelperClass } from '../../../classes/helper.class';
+import { PsToolkitUiConfigService } from '../../../services/config.service';
+import * as $ from 'jquery';
+import { PermissionClass } from '../../../classes/permission.class';
+import 'jquery-ui-dist/jquery-ui';
+export class TableRowComponent {
+    constructor(service) {
+        this.service = service;
+        this.confirmShow = new EventEmitter();
+        this.changeRows = new EventEmitter();
+        this.loadParent = new EventEmitter();
+        this.showChildren = null;
+        this.addChildren = null;
+        this.group = null;
+        this.children = [];
+        this.options = [];
+    }
+    get tableRowStatus() { return TableRowStatus; }
+    get type() { return InputType; }
+    get tableOptionType() { return TableOptionType; }
+    mouseOut(e) {
+        $(e.target).find('.options-con').removeClass('show-group');
+    }
+    ngOnInit() {
+        this.row.subTable = this.table.subTable != null ? HelperClass.clone(this.table.subTable) : null;
+        this.group = new InputClass(this.table.environment, this.table.l, 'ShowOptions', 'fas fa-ellipsis-vertical', InputType.Icon, 'blue m-h-5 h-25 d-ib va-m f-u');
+        this.group.onFocusIn = (e) => {
+            $(e.target).closest('.options-con').addClass('show-group');
+        };
+        this.group.onFocusOut = (e) => {
+            // $(e.target).closest('.options-con').removeClass('show-group');
+        };
+        if (this.table.hasChildren) {
+            if (!this.table.childrenAutoLoad) {
+                this.children = this.getChildren();
+            }
+            if (this.table.permissions.hasAccess(PermissionAccessTypeEnum.Insert)) {
+                this.addChildren = new InputClass(this.table.environment, this.table.l, this.table.name + 'AddSubsetTitle', 'fad fa-plus fa-rotate-90', InputType.Icon, 'green m-h-5 h-25 d-ib va-m f-u');
+                this.addChildren.onClick = () => {
+                    this.table.form.onSuccessBase = () => {
+                        this.table.modal.hide();
+                        this.showChildren.type = InputType.Icon;
+                        this.loadChildren(this.row.Data.Id);
+                    };
+                    this.table.showInsertModal(this.row.Data.Id, this.level, this.row.Data);
+                };
+            }
+        }
+        if (this.table.hasChildren || this.row.subTable != null) {
+            this.showChildren = new InputClass(this.table.environment, this.table.l, this.table.name + 'SubsetTitle', 'fad fa-angle-left f-s-22', this.row.Data.CountChild > 0 || (!this.table.childrenAutoLoad && this.children.length > 0) || this.row.subTable != null ? InputType.Icon : InputType.Hidden, 'h-25 m-h-5 d-ib va-m f-u');
+            this.showChildren.onClick = () => {
+                var _a, _b;
+                if ($(this.childrenDiv.nativeElement).is(':visible')) {
+                    $(this.childrenDiv.nativeElement).slideUp();
+                    this.showChildren.icon = 'fad fa-angle-left f-s-22';
+                }
+                else if (this.table.hasChildren && this.children.length === 0) {
+                    this.loadChildren(this.row.Data.Id);
+                }
+                else if (this.row.subTable != null && this.row.subTable.permissions == null) {
+                    const acc = this.table.permissions.Accesses.find(x => x.Action === this.row.subTable.name);
+                    const ps = new PermissionClass();
+                    ps.RelatedId = this.row.Data.Id;
+                    ps.Area = acc.Area;
+                    ps.Controller = acc.Controller;
+                    ps.Action = acc.Action;
+                    ps.Accesses = (_b = (_a = this.table.permissions.Accesses) === null || _a === void 0 ? void 0 : _a.filter(x => x.ParentId === acc.Id)) !== null && _b !== void 0 ? _b : [];
+                    this.row.subTable.permissions = ps;
+                    this.row.subTable.set();
+                    $(this.childrenDiv.nativeElement).slideDown();
+                    this.showChildren.icon = 'fad fa-angle-down f-s-22';
+                }
+                else {
+                    $(this.childrenDiv.nativeElement).slideDown();
+                    this.showChildren.icon = 'fad fa-angle-down f-s-22';
+                }
+            };
+        }
+        if (this.table.sortable) {
+            this.setSortRow();
+        }
+        this.setOptions();
+    }
+    loadChildren(p) {
+        const data = this.table.searchData();
+        // tslint:disable-next-line
+        data['Page'] = 1;
+        // tslint:disable-next-line
+        data['PerPage'] = -1;
+        // tslint:disable-next-line
+        data['Level'] = this.level;
+        new RequestClass(this.table.environment, this.table.l).send(this.table.url + `/${p}`, Method.Post, data, this.showChildren, (result) => {
+            this.children = result.List;
+            setTimeout(() => {
+                $(this.childrenDiv.nativeElement).slideDown();
+                this.showChildren.icon = 'fad fa-angle-down f-s-22';
+            }, 50);
+        }, () => { });
+    }
+    check() {
+        this.row.checked = !this.row.checked;
+        if (this.table.onChangeCheck) {
+            this.table.onChangeCheck(this.row);
+        }
+    }
+    onChangeRows(e) {
+        return this.changeRows.emit(e);
+    }
+    onConfirmShow(e) {
+        return this.confirmShow.emit(e);
+    }
+    setSortRow() {
+        setTimeout(() => {
+            if (this.table.hasChildren) {
+                // @ts-ignore
+                $(this.childrenDiv.nativeElement).sortable({
+                    axis: 'y',
+                    items: '.row',
+                    handle: '> .handle-con > .handle.handle-sortable',
+                    update: () => {
+                        const data = [];
+                        // @ts-ignore
+                        $(this.childrenDiv.nativeElement).sortable('toArray', { attribute: 'data-id' }).forEach(x => {
+                            data.push(parseInt(x, 10));
+                        });
+                        const p = new PermissionClass();
+                        p.Area = this.table.permissions.Area;
+                        p.Controller = this.table.permissions.Controller;
+                        p.Action = 'sort';
+                        new RequestClass(this.table.environment, this.table.l).send(p.getUrl().toLowerCase(), Method.Post, { Ids: data }, null, () => {
+                            if (this.table.onSort) {
+                                this.table.onSort();
+                            }
+                        }, () => { });
+                    }
+                });
+            }
+        }, 500);
+    }
+    setOptions() {
+        var _a, _b, _c, _d;
+        const opts = [];
+        for (const option of ((_b = (_a = this.row.Options) === null || _a === void 0 ? void 0 : _a.filter(x => x.Type === PermissionTypeEnum.Option && x.InputAction === PermissionInputActionEnum.Input)) !== null && _b !== void 0 ? _b : [])) {
+            const inp = new InputClass(this.table.environment, this.table.l, null, null, InputType.Check, 'h-25 without-border m-h-5 p-0 w-u', this.row.Data[option.Action] === true);
+            inp.row = this.row;
+            inp.tooltip = option.Name;
+            inp.onChange = () => {
+                this.row.Data[option.Action] = !inp.data();
+                new RequestClass(this.table.environment, this.table.l).send(this.table.getOptionUrl(option.Url, this.table.permissions.RelatedId, this.row.Data.Id), Method.Post, null, null, () => {
+                    this.table.load();
+                }, () => {
+                    this.table.load();
+                });
+            };
+            inp.displayLabel = false;
+            opts.push(inp);
+        }
+        if (this.addChildren !== null && (this.table.level === null || this.table.level > this.level)) {
+            opts.push(this.addChildren);
+        }
+        for (const option of ((_d = (_c = this.row.Options) === null || _c === void 0 ? void 0 : _c.filter(x => x.Type === PermissionTypeEnum.Option && x.InputAction !== PermissionInputActionEnum.Input)) !== null && _d !== void 0 ? _d : [])) {
+            const opt = new InputClass(this.table.environment, this.table.l, option.Name, option.Icon, option.InputType === PermissionInputTypeEnum.Icon ? InputType.Icon : InputType.Button, 'blue h-25 m-h-5 d-ib va-m f-u');
+            opt.row = this.row;
+            if (option.AccessType === PermissionAccessTypeEnum.Update) {
+                if (this.table.form) {
+                    opt.onClick = () => {
+                        this.table.form.url = this.table.getOptionUrl(option.Url, this.table.permissions.RelatedId, this.row.Data.Id);
+                        if (this.table.hasChildren && this.row.Data.ParentId != null) {
+                            this.table.form.onSuccessBase = () => {
+                                this.table.modal.hide();
+                                if (this.table.childrenAutoLoad) {
+                                    this.loadParent.emit(this.row.Data.ParentId);
+                                }
+                                else {
+                                    this.table.load();
+                                }
+                            };
+                        }
+                        else {
+                            this.table.form.onSuccessBase = () => {
+                                if (!this.table.form.onTop) {
+                                    this.table.modal.hide();
+                                }
+                                this.table.form.clear(this.table.insertAccess != null);
+                                this.table.load();
+                            };
+                        }
+                        this.edit(opt, option);
+                    };
+                }
+                else {
+                    opt.url = this.table.getOptionUrl(option.Url, this.table.permissions.RelatedId, this.row.Data.Id);
+                }
+            }
+            else if (option.AccessType === PermissionAccessTypeEnum.Delete) {
+                opt.class = opt.class.replace('blue', 'red');
+                opt.onClick = () => {
+                    if (this.table.form) {
+                        this.table.form.clear(this.table.insertAccess != null);
+                    }
+                    if (this.table.permissions.Type === PermissionTypeEnum.Form) {
+                        this.table.rows = this.table.rows.filter(x => x.Data.Id !== this.row.Data.Id);
+                        if (this.table.onLoad) {
+                            this.table.onLoad(this.table.rows);
+                        }
+                        this.changeRows.emit(this.row.Data);
+                    }
+                    else {
+                        this.confirmShow.emit({
+                            action: option.Action,
+                            data: this.table.hasChildren ? { Level: this.level } : null,
+                            url: this.table.getOptionUrl(option.Url, this.table.permissions.RelatedId, this.row.Data.Id),
+                            accept: () => {
+                                if (this.table.hasChildren && this.table.childrenAutoLoad && this.row.Data.ParentId != null) {
+                                    this.loadParent.emit(this.row.Data.ParentId);
+                                }
+                                else {
+                                    this.table.load();
+                                }
+                            }
+                        });
+                    }
+                };
+            }
+            else if (option.AccessType === PermissionAccessTypeEnum.Report) {
+                opt.url = this.table.getOptionUrl('/report' + option.Url, this.table.permissions.RelatedId, this.row.Data.Id);
+                opt.queryParams = { reportId: HelperClass.random(20) };
+                opt.urlNewTab = true;
+            }
+            else if (option.InputAction === PermissionInputActionEnum.Link || option.InputAction === PermissionInputActionEnum.LinkNewTab) {
+                opt.url = option.Url.replace('{}', this.row.Data.Id);
+                opt.urlNewTab = option.InputAction === PermissionInputActionEnum.LinkNewTab;
+            }
+            else if (option.InputAction === PermissionInputActionEnum.Modal) {
+                opt.modal = this.table.optionsActions.find(x => x.name === option.Action);
+                opt.onClick = () => {
+                    var _a;
+                    if (opt.modal.table) {
+                        const p = new PermissionClass();
+                        p.RelatedId = this.row.Data.Id;
+                        p.Area = this.table.permissions.Area;
+                        p.Controller = this.table.permissions.Controller;
+                        p.Action = option.Action;
+                        p.Accesses = this.getPermission(option.Id, this.row.Options);
+                        opt.modal.table.permissions = p;
+                        if (opt.modal.table.form) {
+                            opt.modal.table.form.url = option.Url.replace('{}', this.row.Data.Id) + '-insert';
+                            opt.modal.table.form.baseUrl = option.Url.replace('{}', this.row.Data.Id) + '-insert';
+                        }
+                        opt.modal.table.relatedRow = this.row.Data;
+                        opt.modal.table.set();
+                    }
+                    if (opt.modal.form) {
+                        opt.modal.form.name = option.Name;
+                        opt.modal.form.url = option.Url.replace('{}', this.row.Data.Id) + '-update';
+                        opt.modal.form.loadData(option.Url.replace('{}', this.row.Data.Id) + '-get');
+                        opt.modal.form.onSuccessBase = () => {
+                            opt.modal.hide();
+                        };
+                    }
+                    if (opt.modal.accordion) {
+                        for (const r of opt.modal.accordion.rows) {
+                            if (r.table) {
+                                const options = JSON.parse(JSON.stringify((_a = this.row.Options) !== null && _a !== void 0 ? _a : []));
+                                const rowOption = options.find(x => x.ParentId === option.Id && x.Action === r.name);
+                                if (rowOption) {
+                                    const p = new PermissionClass();
+                                    p.RelatedId = this.row.Data.Id;
+                                    p.Area = this.table.permissions.Area;
+                                    p.Controller = option.Controller;
+                                    p.Action = r.name;
+                                    p.Accesses = options.filter(x => x.ParentId === rowOption.Id);
+                                    r.table.permissions = p;
+                                    if (r.table.form) {
+                                        r.table.form.url = option.Url + 'insert';
+                                        r.table.form.baseUrl = option.Url + 'insert';
+                                    }
+                                    r.table.set();
+                                }
+                            }
+                        }
+                    }
+                };
+            }
+            else if (option.InputAction === PermissionInputActionEnum.File) {
+                const p = new PermissionClass();
+                p.RelatedId = this.table.permissions.RelatedId;
+                p.Area = this.table.permissions.Area;
+                p.Controller = option.Controller;
+                p.Action = option.Action;
+                opt.url = '/file' + this.table.getOptionUrl(option.Url, this.table.permissions.RelatedId, this.row.Data.Id);
+                opt.urlNewTab = true;
+            }
+            else if (option.InputAction === PermissionInputActionEnum.Confirm) {
+                opt.onClick = () => {
+                    const p = new PermissionClass();
+                    p.RelatedId = this.table.permissions.RelatedId;
+                    p.Area = this.table.permissions.Area;
+                    p.Controller = option.Controller;
+                    p.Action = option.Action;
+                    this.table.showConfirm(this.table.l(option.Action + 'Confirm'), this.table.getOptionUrl(option.Url, this.table.permissions.RelatedId, this.row.Data.Id), null, () => {
+                        this.table.load();
+                    });
+                };
+            }
+            else if (option.InputAction === PermissionInputActionEnum.OnClick) {
+                opt.onClick = (btn) => {
+                    this.table.optionsActions.find(x => x.name === option.Action).onClick(btn);
+                };
+            }
+            opts.push(opt);
+        }
+        this.options = opts;
+        // return (this.addChildren !== null && (this.table.level === null || this.table.level > this.level) ? [this.addChildren] : [])
+        //   .concat(this.table.options.filter(x => x.condition == null ||
+        //     (x.condition.startsWith('!') ? !this.row.Data[x.condition.substring(1)] : this.row.Data[x.condition])).map((o) => {
+        //     const i = HelperClass.clone(o);
+        //     if (i.url){
+        //       i.url = i.url.replace('{}', this.row.Data.Id);
+        //     }
+        //     i.row = this.row.Data;
+        //     i.class = i.class + ' m-h-5 h-25 d-ib va-m f-u';
+        //     return i;
+        // })).concat(this.table.hasStatus ? [this.optStatus] : [])
+        //     .concat(this.table.permissions.hasAccess('Update') ? [this.optEdit] : [])
+        //     .concat(this.table.permissions.hasAccess('Delete') ? [this.optDelete] : []);
+    }
+    getPermission(parentId, list) {
+        const children = list.filter(item => item.ParentId === parentId);
+        return children.reduce((acc, child) => {
+            acc.push(child);
+            acc.push(...this.getPermission(child.Id, list));
+            return acc;
+        }, []);
+    }
+    getCell(col) {
+        return this.table.getCell(this.row, col);
+    }
+    getCol(n) {
+        let c = this.row.Data;
+        n.split('.').forEach((x) => {
+            c = c[x];
+        });
+        return c;
+    }
+    edit(opt, option) {
+        this.table.form.isEdit = true;
+        if (this.table.permissions.Type === PermissionTypeEnum.Form) {
+            this.table.form.name = opt.name;
+            this.table.form.setData(this.row.Data);
+            this.table.form.setButtons(this.table.form.onTop, true, false, true);
+            this.table.form.inputs.filter(x => x.inEditDisabled).forEach(x => x.disabled = true);
+            this.table.form.inputs.filter(x => !x.inEditVisible).forEach(x => x.visible = false);
+            this.table.form.inputs.forEach(x => x.required = x.inEditRequired);
+            if (this.table.form.onLoad) {
+                this.table.form.onLoad(this.row.Data);
+            }
+        }
+        else {
+            const data = new FormData();
+            if (this.table.hasChildren) {
+                data.append('Level', this.level.toString());
+            }
+            new RequestClass(this.table.environment, this.table.l).send(this.table.getOptionUrl(option.Url.replace('update', 'get'), this.table.permissions.RelatedId, this.row.Data.Id), Method.Post, data, opt, (result) => {
+                this.table.form.name = opt.name;
+                this.table.form.setData(result);
+                this.table.form.setButtons(this.table.form.onTop, true, false, true);
+                this.table.form.inputs.filter(x => x.inEditDisabled).forEach(x => x.disabled = true);
+                this.table.form.inputs.filter(x => !x.inEditVisible).forEach(x => x.visible = false);
+                this.table.form.inputs.forEach(x => x.required = x.inEditRequired);
+                if (this.table.modal) {
+                    this.table.modal.show(this.row.Data);
+                }
+                if (this.table.form.onLoad) {
+                    this.table.form.onLoad(result);
+                }
+            }, () => { });
+        }
+    }
+    getChildren() {
+        return this.row.Data.Id ? this.table.rows.filter(x => x.Data.ParentId === this.row.Data.Id) : [];
+    }
+    getStatuses() {
+        return this.row.Statuses && this.row.Statuses.includes(TableRowStatus.Unread) ? 'unread ' : '';
+    }
+    selectRow(e) {
+        if (this.table.withSelect) {
+            if ($(e.target).closest('.handle-con').hasClass('handle-con') || $(e.target).closest('.options-cell').hasClass('options-cell')) {
+                return;
+            }
+            const s = this.table.rows.find(x => x.selected);
+            if (s) {
+                s.selected = false;
+            }
+            this.row.selected = true;
+            if (this.table.onSelectRow) {
+                this.table.onSelectRow(this.row.Data);
+            }
+        }
+    }
+    dblclickRow(e) {
+        if (this.table.withSelect) {
+            if ($(e.target).closest('.handle-con').hasClass('handle-con') || $(e.target).closest('.options-cell').hasClass('options-cell')) {
+                return;
+            }
+            const s = this.table.rows.find(x => x.selected);
+            if (s) {
+                s.selected = false;
+            }
+            this.row.selected = true;
+            if (this.table.onDblClickRow) {
+                this.table.onDblClickRow(this.row.Data);
+            }
+        }
+    }
+    rightClickRow(e) {
+        e.preventDefault();
+        if (this.table.withSelect && this.table.onRightClickRow) {
+            this.table.onRightClickRow(this.row.Data);
+        }
+    }
+    onContextMenu(event) {
+        event.preventDefault(); // Prevents the default context menu for the entire component
+    }
+}
+TableRowComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-table-row',
+                template: "<div class=\"w-100 row-con\">\r\n  <div [attr.data-id]=\"row.Data.Id\" [className]=\"(table.name ? table.name + '-row ' : '') + (table.hasChildren || row.subTable != null ? 'with-handle-children ' : '') + (table.sortable ? 'with-handle-sortable ' : '') + getStatuses() + (table.withCheck ? 'with-handle-check ' : '') + (table.withSelect ? 'selectable ' : '') + (row.selected ? 'select ' : '') + (this.table.getRowClass ? this.table.getRowClass(row) + ' ' : '') + 'row underline p-r'\" (click)=\"selectRow($event)\" (dblclick)=\"dblclickRow($event)\" (contextmenu)=\"rightClickRow($event)\" (mouseout)=\"mouseOut($event)\" [style]=\"{minHeight: table.height + 'px' }\">\r\n    <div class=\"handle-con\">\r\n      <div class=\"handle handle-sortable\" *ngIf=\"table.sortable\"><i class=\"fad fa-grip-vertical\"></i></div>\r\n      <div class=\"handle handle-check\" *ngIf=\"table.withCheck\"><i (click)=\"check()\" [className]=\"(row.checked ? 'fa-solid fa-square-check c-green' : 'fa-regular fa-square') + ' check-row'\"></i></div>\r\n      <div class=\"handle handle-children\" *ngIf=\"(table.hasChildren && (table.level === null || table.level > level)) || row.subTable != null\"><lib-form-icon *ngIf=\"showChildren != null && showChildren.type === type.Icon\" [inp]=\"showChildren\"></lib-form-icon></div>\r\n    </div>\r\n    <div [className]=\"col.name + '-cell ' + col.class + ' item cell w-100'\" *ngFor=\"let col of table.cols\" attr.data-col=\"{{table.l(col.name)}}:\" [innerHTML]=\"getCell(col) | safeHtml\"></div>\r\n    <div class=\"cell options-cell\" *ngIf=\"options.length > 0\">\r\n      <div [className]=\"(table.optionType == tableOptionType.Show ? 'show ' : '') + (table.optionType == tableOptionType.Group ? 'group ' : '') + 'options-con'\">\r\n        <div class=\"options\">\r\n          <div class=\"option f-r\" *ngFor=\"let opt of options\">\r\n            <lib-form-button *ngIf=\"opt.type == type.Button\" [inp]=\"opt\"></lib-form-button>\r\n            <lib-form-icon *ngIf=\"opt.type == type.Icon\" [inp]=\"opt\"></lib-form-icon>\r\n            <lib-form-checkbox *ngIf=\"opt.type == type.Check\" [inp]=\"opt\"></lib-form-checkbox>\r\n          </div>\r\n        </div>\r\n        <div class=\"option f-r\" *ngIf=\"table.optionType == tableOptionType.Group\">\r\n          <lib-form-icon [inp]=\"group\"></lib-form-icon>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <div #childrenDiv *ngIf=\"table.hasChildren && (table.level === null || table.level > level)\" class=\"children rightline\">\r\n    <lib-table-row (loadParent)=\"loadChildren($event)\" (confirmShow)=\"onConfirmShow($event)\" [level]=\"level + 1\" (changeRows)=\"onChangeRows($event)\" [id]=\"child.id ? child.id : ''\" [table]=\"table\" [row]=\"child\" *ngFor=\"let child of children\"></lib-table-row>\r\n  </div>\r\n  <div #childrenDiv *ngIf=\"row.subTable != null\" class=\"children\">\r\n    <lib-table [table]=\"row.subTable\"></lib-table>\r\n  </div>\r\n</div>\r\n",
+                styles: [".row{align-items:center;display:flex;flex-wrap:wrap;justify-content:right;position:relative}.row.unread{background-image:linear-gradient(90deg,rgba(221,238,234,.0196078431372549),rgba(221,238,234,.5215686274509804),rgba(221,238,234,.0196078431372549))}.row.row-red{background-color:var(--red-white)}.row.row-green{background-color:var(--green-white)}.row.row-blue{background-color:var(--blue-white)}.row.row-yellow{background-color:var(--yellow-white)}.row.with-handle-check,.row.with-handle-children,.row.with-handle-sortable{padding-right:30px}.row.with-handle-children.with-handle-check,.row.with-handle-sortable.with-handle-check,.row.with-handle-sortable.with-handle-children{padding-right:60px}.row.with-handle-sortable.with-handle-children.with-handle-check{padding-right:90px}.row.selectable{-khtml-user-select:none;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none;border-radius:var(--border-radius-base);cursor:pointer}.row.selectable.select,.row.selectable:hover{background-color:var(--green-white)}.row .cell{align-items:center;display:flex;flex-wrap:wrap;float:right;font-size:12px;font-weight:var(--font-normal);justify-content:center;line-height:20px;margin:10px 0;padding:0 10px;text-align:center}.row.unread .cell{font-size:12.5px!important;font-weight:var(--font-bold)!important}.row .cell.one-line{-webkit-line-clamp:1}.row .cell.one-line,.row .cell.two-line{-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.row .cell.two-line{-webkit-line-clamp:2}.row .cell.three-line{-webkit-box-orient:vertical;-webkit-line-clamp:3;display:-webkit-box;overflow:hidden}.row .cell:not(.options-cell){overflow-wrap:anywhere}.row .cell.options-cell{margin-left:auto;margin-right:auto;padding:7.5px 0}.row .handle-con{height:100%;position:absolute;right:0;top:0}.row .handle-con .handle{align-items:center;display:flex;float:right;height:100%;justify-content:center;width:30px}.row .handle-con .handle i{cursor:pointer;font-size:16px}.row .cell:before{font-size:9px;margin-left:5px}.row .cell:empty:before{display:none}.row .cell .options-con{align-items:center;background:linear-gradient(270deg,transparent,#fff 80px,#fff);display:flex;height:100%;justify-content:end;left:0;opacity:0;position:absolute;top:0;visibility:hidden}.row.row-red .cell .options-con{background:linear-gradient(270deg,transparent,var(--red-white) 80px,var(--red-white))}.row.row-green .cell .options-con{background:linear-gradient(270deg,transparent,var(--green-white) 80px,var(--green-white))}.row .cell .options-con.show{opacity:1;position:relative;visibility:visible}.row:hover>.cell>.options-con{opacity:1;visibility:visible}.row .cell .options-con:not(.show) .options .option:first-child{margin-right:150px}.row .cell .options-con:not(.group) .options .option:last-child{margin-left:10px}.row .cell .options-con.group .options{overflow:hidden;width:0}.row .cell .options-con.group.show-group .options{overflow:unset;width:100%}.row .cell .options-con.group.show-group>.option{width:0}.children{display:none;float:right;margin-right:3%;position:relative;width:94%}.children.rightline:after{right:-20px}::ng-deep .row .cell .check-row{cursor:pointer;font-size:18px;height:30px;line-height:30px}::ng-deep .row .cell .status{-khtml-user-select:none;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none;border-radius:var(--border-radius-base);cursor:default;display:inline-block;font-size:12px;line-height:16px;padding:2px 10px;vertical-align:middle}::ng-deep .row .cell .status.blue{background-color:var(--blue-white);color:var(--blue)}::ng-deep .row .cell .status.green{background-color:var(--green-white);color:var(--green)}::ng-deep .row .cell .status.red{background-color:var(--red-white);color:var(--red)}::ng-deep .row .cell .status.gray{background-color:var(--black-white);color:var(--black)}::ng-deep .row .cell .status.yellow{background-color:var(--yellow-white);color:var(--yellow)}::ng-deep .row .cell .plaque{-khtml-user-select:none;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none;background-color:#fff;background-image:url(\"data:image/png;base64,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\");background-position:50%;background-repeat:no-repeat;background-size:contain;border-radius:var(--border-radius-base);cursor:pointer;float:right;font-size:14px;height:30px;width:140px}::ng-deep .row .cell .color{border-radius:var(--border-radius-base);float:right;padding:0 10px}::ng-deep .row .cell .plaque.plaque-m{background-image:url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAABVCAYAAABn7bJ/AAAACXBIWXMAAAsTAAALEwEAmpwYAAANlmlUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4gPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNi4wLWMwMDIgNzkuMTY0NDYwLCAyMDIwLzA1LzEyLTE2OjA0OjE3ICAgICAgICAiPiA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPiA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvbW0vIiB4bWxuczpzdEV2dD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL3NUeXBlL1Jlc291cmNlRXZlbnQjIiB4bWxuczpzdFJlZj0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL3NUeXBlL1Jlc291cmNlUmVmIyIgeG1sbnM6cGhvdG9zaG9wPSJodHRwOi8vbnMuYWRvYmUuY29tL3Bob3Rvc2hvcC8xLjAvIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iIHhtbG5zOnRpZmY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vdGlmZi8xLjAvIiB4bWxuczpleGlmPSJodHRwOi8vbnMuYWRvYmUuY29tL2V4aWYvMS4wLyIgeG1wOkNyZWF0b3JUb29sPSJBZG9iZSBQaG90b3Nob3AgQ0MgMjAxNyAoV2luZG93cykiIHhtcDpDcmVhdGVEYXRlPSIyMDE5LTEyLTAzVDE4OjUwOjQ1KzAzOjMwIiB4bXA6TWV0YWRhdGFEYXRlPSIyMDIxLTA2LTEwVDE0OjM1OjA1KzA0OjMwIiB4bXA6TW9kaWZ5RGF0ZT0iMjAyMS0wNi0xMFQxNDozNTowNSswNDozMCIgeG1wTU06SW5zdGFuY2VJRD0ieG1wLmlpZDpjOWI2MmM5Mi1hNmQ4LWY4NGUtYTM3OS0wZWJmZTZkOTYzNzQiIHhtcE1NOkRvY3VtZW50SUQ9ImFkb2JlOmRvY2lkOnBob3Rvc2hvcDpkNmZhOTJjMi1mNGM1LTFjNDktYTUzMy05MmY1Mzk2MDVjNTMiIHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRpZDo2ODQyNGMwNy1lMDE1LWY5NGQtODFjZC1mZjE2OGEzOGYwODciIHBob3Rvc2hvcDpDb2xvck1vZGU9IjMiIHBob3Rvc2hvcDpJQ0NQcm9maWxlPSJzUkdCIElFQzYxOTY2LTIuMSIgZGM6Zm9ybWF0PSJpbWFnZS9wbmciIHRpZmY6T3JpZW50YXRpb249IjEiIHRpZmY6WFJlc29sdXRpb249IjcyMDAwMC8xMDAwMCIgdGlmZjpZUmVzb2x1dGlvbj0iNzIwMDAwLzEwMDAwIiB0aWZmOlJlc29sdXRpb25Vbml0PSIyIiBleGlmOkNvbG9yU3BhY2U9IjEiIGV4aWY6UGl4ZWxYRGltZW5zaW9uPSI0MDAiIGV4aWY6UGl4ZWxZRGltZW5zaW9uPSI4NSI+IDx4bXBNTTpIaXN0b3J5PiA8cmRmOlNlcT4gPHJkZjpsaSBzdEV2dDphY3Rpb249ImNyZWF0ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6Njg0MjRjMDctZTAxNS1mOTRkLTgxY2QtZmYxNjhhMzhmMDg3IiBzdEV2dDp3aGVuPSIyMDE5LTEyLTAzVDE4OjUwOjQ1KzAzOjMwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ0MgMjAxNyAoV2luZG93cykiLz4gPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOmJiYzEwYzI2LTNlOGYtNzk0NS05YTYxLWNlZjc0Yjg5ZmIyNiIgc3RFdnQ6d2hlbj0iMjAxOS0xMi0wM1QxODo1MDo0NSswMzozMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENDIDIwMTcgKFdpbmRvd3MpIiBzdEV2dDpjaGFuZ2VkPSIvIi8+IDxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpkMmY2YTViYy0yZGQ1LTlkNDEtOGYxYi02OTFkYTJlNmQzMDYiIHN0RXZ0OndoZW49IjIwMjEtMDYtMTBUMTQ6MzQ6MzgrMDQ6MzAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCAyMS4yIChXaW5kb3dzKSIgc3RFdnQ6Y2hhbmdlZD0iLyIvPiA8cmRmOmxpIHN0RXZ0OmFjdGlvbj0iY29udmVydGVkIiBzdEV2dDpwYXJhbWV0ZXJzPSJmcm9tIGltYWdlL3BuZyB0byBhcHBsaWNhdGlvbi92bmQuYWRvYmUucGhvdG9zaG9wIi8+IDxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJkZXJpdmVkIiBzdEV2dDpwYXJhbWV0ZXJzPSJjb252ZXJ0ZWQgZnJvbSBpbWFnZS9wbmcgdG8gYXBwbGljYXRpb24vdm5kLmFkb2JlLnBob3Rvc2hvcCIvPiA8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6ZGIzMTM2ZmEtN2RkZC03YTQ5LTgzNjQtYjZmYWI3ZGVlZmE5IiBzdEV2dDp3aGVuPSIyMDIxLTA2LTEwVDE0OjM0OjM4KzA0OjMwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgMjEuMiAoV2luZG93cykiIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4gPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOmM3Y2U3NTk1LWM3NDUtOTg0Yi1hMmI1LTQ1MjA4N2E0MTBkOCIgc3RFdnQ6d2hlbj0iMjAyMS0wNi0xMFQxNDozNTowNSswNDozMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIDIxLjIgKFdpbmRvd3MpIiBzdEV2dDpjaGFuZ2VkPSIvIi8+IDxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJjb252ZXJ0ZWQiIHN0RXZ0OnBhcmFtZXRlcnM9ImZyb20gYXBwbGljYXRpb24vdm5kLmFkb2JlLnBob3Rvc2hvcCB0byBpbWFnZS9wbmciLz4gPHJkZjpsaSBzdEV2dDphY3Rpb249ImRlcml2ZWQiIHN0RXZ0OnBhcmFtZXRlcnM9ImNvbnZlcnRlZCBmcm9tIGFwcGxpY2F0aW9uL3ZuZC5hZG9iZS5waG90b3Nob3AgdG8gaW1hZ2UvcG5nIi8+IDxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpjOWI2MmM5Mi1hNmQ4LWY4NGUtYTM3OS0wZWJmZTZkOTYzNzQiIHN0RXZ0OndoZW49IjIwMjEtMDYtMTBUMTQ6MzU6MDUrMDQ6MzAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCAyMS4yIChXaW5kb3dzKSIgc3RFdnQ6Y2hhbmdlZD0iLyIvPiA8L3JkZjpTZXE+IDwveG1wTU06SGlzdG9yeT4gPHhtcE1NOkRlcml2ZWRGcm9tIHN0UmVmOmluc3RhbmNlSUQ9InhtcC5paWQ6YzdjZTc1OTUtYzc0NS05ODRiLWEyYjUtNDUyMDg3YTQxMGQ4IiBzdFJlZjpkb2N1bWVudElEPSJhZG9iZTpkb2NpZDpwaG90b3Nob3A6NTMxYzM1ZDUtMzExNy02NzQ4LWE5OGEtYTlmOGEyYzVmMGU0IiBzdFJlZjpvcmlnaW5hbERvY3VtZW50SUQ9InhtcC5kaWQ6Njg0MjRjMDctZTAxNS1mOTRkLTgxY2QtZmYxNjhhMzhmMDg3Ii8+IDxwaG90b3Nob3A6RG9jdW1lbnRBbmNlc3RvcnM+IDxyZGY6QmFnPiA8cmRmOmxpPjUxNjAzQkE4NTUzMTE3NEFEOTU5RTFCMjgwNkNFMjFFPC9yZGY6bGk+IDwvcmRmOkJhZz4gPC9waG90b3Nob3A6RG9jdW1lbnRBbmNlc3RvcnM+IDwvcmRmOkRlc2NyaXB0aW9uPiA8L3JkZjpSREY+IDwveDp4bXBtZXRhPiA8P3hwYWNrZXQgZW5kPSJyIj8+D6fWAwAAOJhJREFUeAHtwQmgbmdZ2Pv/87zvWuub9nD2cM5JQhICIWEOQREBKVooor2CtThgqzJYQNSrdeyVWoVrlaJo9Tp7FWtVEIfWOouo1AFUBsMkgyEhkOGcPZx99t7fsNZ63+e5+ztbPHLJsENOjMb1+8kB/pZzjah8/2g0esr6+jrLy8tIUBKZEAIFimUjpwQC2QyPiiAUEghFJLcJBMwdHHDHzJAgIODmmBkhRoqiwCzjZqSUiaIgAgrOARFEBMtGEEFcMAcRSCkhIiBCaluKskREwB1VBRGaukZUCarMiSoiAu5YNtydvyWACG5GNiMWAREOCCKCqJCT4Z5p25YYC2IoUFXMDDNDAHfn71IVcjbMEyoBRChiwNzBnKzQpJYgioigCIoQQyBlQ9xRUczB3EDA3XERDEdUUFUkGUVR0LYt5o6qco45oSwQIOeMiDDn7rg7ZoaK4EC2jOOUMaIasJxRVdydZIk2Z4pQEGOBuyOAm4FzjjjnuDjZDERIlhERYgjEEBERcMctU7ctKIgqOKgKQRRBcHPMnI+hQjIjWSKUkWiCZkei4u6YGSaOO4gKqgoh4OaoOSqKp8xHOYcccBwHQowIICLg0NQ1Lk4sChBBRSFnEEGcc4RD5kZrGcOIIZBxBEE1EIMSMrjDLLVkjBAjQRVxUAdFIBvGIRdAABEMSKlFgiJBEIfogho4jgk0lpCghBARExDwbMwpf8M4x3EkKClnzIyyKlFVLBuYIQi1t4SgBAnknAmqKCAIbo67k91xd1SVlDIhBNwNVUVUUVXmZtMpZVnStC0xRlSVnDMxRnKb+ChxQMAAxyEIqGIpEYIiIogIKoqZYSmhoogqjqAxgjupabBsqAiCkFMiWcLd0BAgCCKKmxFiJAbFszGbNbg42Q3VQIyBqizJZpgb3mSsNTQoKWcQQAREMDfcjbLXo6pKUkrklMg5gzkaFAdUhFiW5GTgTpSAODRtQ9M2aAggQkotuFH1ehhOURQIYGakNmFmiAaqqoe7o+64OylnMMfdUYeggolQpxpUqYZ93Ax1IZYFljKpbWnbFncnFJFer4cgRA3Udc3NN9/M9ub2De7+vLIq31jPauaEIiLmeM5XLCwsvP7kyYsfPOj32N3doa0bqlEPXe6RpjWSMu20pT/o4yq4OKZOQYE2MKtn5JwRATMHBwlCLApSSvSGPYIGmrqhPxowm86YTiaUZUlV9piN9xGcpfVVbj21yXhWM+iVtLMaa1s0RMydUBSUvR65aZAQGA5H7J7ZhqKgDIHZ/gQcesMB7k5qW0KMtE2Dm6EIljKGE1RxERwnaqCoSlQDHkGC0NQNGgL1eEIsCzQoVVUxnUxpxjXD4RAzYzqZICL8XaKCALGILCwtMplMGe/vMxqNSDmBO5SR2K84x5woymQ8ITctuOPZCa7MmRsZpz8cYm6EskDLgsnZXQoJuBkhRkQEDYG2aWjqmrLXQ0WoZzNCCMy5GSEENARySlRlRegXTNoZZSxQF/bO7FD1+7g4sSopqxIhsHNqk1gWqCjNbIYgzIlzjlSRWERchKrfw1WZ7O2BO2RHciaoEquSWJW0OSEqNNOa3LSoCp7Bs4NwjrsjKvQXRhSDHjVGaDPt/j5Nkyj7FRIVCYrGgGqgbVs0llg26jNnwRxxzhEEcFBFqoJq0Cc3DUWvx2w8JtcNqNIbDXEzVBQRYby7hwAigjjniIO54RH6SwtIUNq2pRj2cXfqyRTLGZkkcCgXhsSqILlhLrR7e3hKFKFEZi3mjosgQTCc7EbZ6zEYDknqMKqYbG7j+zPUBBEl9CLSK6Bf4gmkTqSUSJMpiKCiuBm4UxYlMUZm9Yyi36MaDGhzIjUN4pBmNbhTrS3QzBp6VUUsItOze9SzmhgjlhI4IAE3Q0QYDIfUsxkG9AcDUtPg7rg7EgK5bVERqn6f1LY4UM+mkB1xzhNBBExB+xX90YicG0QFFWV8dhdxRyVgOOLOcHGRXGcm+/sIYGa4GThUZUmvKCEqHoWcMxoDo5VlUtNQFCX7Z3fZ3zlLURZ4NkSV5E7Rq7CcaSYz3A03Q1pwczQqGiNN2zBYXIAgtG1LbzggT6c0dUPV7yPA3tldhosj+v0+u7u7hBiBQDudIi6AYzlTVhVmTrLMcDRABfb29ymrEgGauiFoIPZK2qZFQ6Ts9xjvnKWIJZYzbV0jCAIIoCqAUI76ZHWqwYCmbXAzaBKpbSl7PTQobZtopjOKoqCqKlLbYmZccskDGPVHvOMd1zGdTp+tIfyymxEF8JxlVC5/7yc/6ZoH33rz+7j+lvdjuszsdIuVLdy6C20LIhArqhZSbimqina8h++fgTZj1gLKxwgFod8HTwwmFZO9TSwYwc+Q6jFIn1ApVNvksxNII/RUw8VLiUWpaWpFrCLIiN5AmdmEECKD5RFz9XRK79iQvf2zuBseItqvGAyHLAxH7GxtYbURshFMcBcQkKAEARdhcWmJ2hJFWVCUFW3b4rOaZtJgZoAQ+30GoyEaI4RAESN52tI2LQIUMTKnGphLbUvZ71Mu9AgaCGWJ5ERIJbUnqkEfd6Ps9+kPhkzHE7K1hFCg1LglxARRwVVwM5RACIHRcEjOCQ2BlDPRBQSKsmRheYnJdIIWBU1u0RDIKeEihKA4B8TJ4lSjPgtLi4wnU0JZUMRAfxqZTad4TkhRQFmwuLiIAE1O5PGM4IJkBzGCBuZUFXDMHHNnuLAIAr3+gHo2Y4pwjkA5GKBVZDgakdtMns2wlIkoZoKYgApSCjiUVUXOCURYXj5G07bYbIaZEYoeVu9R9gcMFhYY7+/Rr3pgTpq0+HSKqBA0EIvAXMqZ4WiEqrK3u8twNEJESNLS1jVVWSG9HrO6Zmlpmdl4TDBo2hZxCCHg7oAz5+4UvQpiYFgOMJxSSwoK9if7yCwTRAijAfVsRlGWjAYjzmxvQdMSE7gpYFihmBmqgVgWzNVNQ4iR4XDIrKmZ7YzRJtNbXMTNiDEyV5QFrTmTvX3UBPFMDBHcEVXKfp+2rimrit6gjwdlMBiQUqKdTHF3lpaWmTg0Tc1Cb8R+2qfenyH9PpgQXCGDZkWrEl0e0NYNVVWxvHyMzVtuRbLR6/XYbxNtM6M/HDAaLXB2Z4fBYEAzm2Epo6oEFI2KcCjjaIxU/YpqNGQyHYMZIQlFjIwnE8qyT1EWVLGgqRsm+/vkWQsGAcHdKUNEoqBFZGdnh83pFrrYI168iJ3eI21P0dO34RH8bEJ6ysVXXEa/HJBTpgolu2fOYG3C20ypEQekEEI/kFOm6vcIRQQVer0ek/0J/aKHW4Zen14sGZQVboaMQF3R1umHCksZV0eKkhDUNQTMjMHCiFiVXjcNg9FQUkrM6saXhktMSTAasrCwQDRkvHUGCQFcKGMhMQQIgTIWmBsaI9Wgj+VE0evRWxwxnU5pJhOKJLgrSSLD5RELS4sIQtu27G1tk1NGXVATds/s8e7Nd7F6fJ2rHvUI/vr66187PnPmKVHjnwoHyl757U9+wlO+7a93buamD95EeeyRpNFVVHKM1oXUTtEQERVUFcsZz4YGJWcDAVVBVcA5x0WYEw6YgTi4kIQDGSxTlgpWkCkx9unVe4zTAsM45Ce+5VNffvK4T245a1UgvCy64r30UrOQs1vIbhUHRCQfqIJqHVxSFonESBR9Wds0LycbMYRaM1lFEA6oJEQyItSpWQxFUaPyimwZA7Lbd1YtY88WYxHHBCFD5SJkvGosDQsN415iF/fogIgkDqhq5oClXFFoytGrnHNMbapUNcUYazOPMYY6tW0lIZJSrsT4FkEIIi9VyAFJIIgTLXhyiCKacMfMo4okd4s556CqWURxAVRpLQ/cHRXJUbTGjIAkDpgQOWBCMJHo4hgEV4m0mWjUhgdEUNXMgaBap5SqlHJVio6LEGt3i8yJJA6oanb3wIHG8lCDJkFyyrly9xBjqEU0u3kgCEn8P5Pt5ZZyjCHUmBHRWh1ElIzjUcAdHFQ1cSDnXLVNU5VFMXEIoiFnvHKcEMLL3P2luU2VQFYkqTuqml0FB4Jqcg6IgEBq20o1ZHMLli26e4hFUYtIFpFXtG37beRMryjHbdtWIcYa94hI4qPcYyiKOlmuUmorcUkaQracg+OxCHGMCE1giECqmypKqMWdKFIrinDAIQcOiTDngENIbVsR9D+J+7dpTkGLWIcYa3fH3aObBTeLbhY0xBpCFhxE+KgQQm1mgTmBbFapaE4pVSqSRDWLCHOOk3KuEHkZ5t+mSFKVrCIJB3WiKWlW6qIA6uTUpiqK1gGpLaUQQ6xNiB4keLb/7Nm+LarWZhYUyeAE0YQTXUgcMCG6CKjgQnCgadthlRmLSE5uVeyVtUOwbFGdFJDaco6iikDiQBAl5Ry1jGlvMl5/9/ve+zk//VM/+fDt06dZu/wiznzkFLk2WCh49OOu5fM+9/O44qIHAIpI/I9ilmL2RkUAASUZRIcQYIYIrhrdHfDvMfNv9pyDumdEsV4RMCO6NN4mVDW5WXT3oBoyB9w9E0iiOnHUEf/3ye37zF1DCO0stwMxZ0jcUZfYFqJ18EpEXxjqpGWy/8dCwPFSBQUplAOqmtx65q4aQg4iTcKrNucBApo9ly4TFUmmErMQklsl7qhIUtEsTpZsRI1p9+zZE7/9+t/+hte97hcrKSOf9KQncP273/v+M6c3niLAV179sAf/oIWWD7z3JmT9qciJp2ODi6AMEA3aCG6cIwLmnCMCOIiCOx9DOM8BzyAOWoI7iINlRDmguEOVx9RTZX2hzx/82Gc/4hFXLb9nY3sjqORY4CFJPVxZfuAGf2NjayPgsL62njmwuXE6rK0fzxs72wFzHDi+spq5C6e3NoOI4DjZvQoh1MeXVzK3Y2NzM6yvrWWOaHNzI6ytrWfuxOkzW0EcEAF31ldWM0ewsbUZ1lfXMn/H6c3NICqsr6xmjmBjYzOsr6/l09ub4fjKWuYCOb21GY6vruWNra2wvrqaOXB6azMcX13Lp7e3grnFIJrWV1bz6a3NcHx1LXMPbJzZDtksiggnVlZrbsfG1mZYX13LHNjY2goIrK+s5o3trbC+spo5sLG9FdZXVvPpzc2AACIcX1nNHNHG5kZYX1vP3I6Nne3g5hxfWc0c0cbWZlhfXcunNzeDC1FF0vrKauYObG5uhLW19cwnaGNjI6yvr2cOnNreqjggkI6vrGZux+mtzSDA+upa5g6c3tkOlnNUDen4sZXMEZ3a3KgQ4cTqWs3fsbG1GdZX1zJHcPMttywmz9Xll1y68fo/+v0v/Kx/+YzX0hr9WLK/P+Xpn/0MvvabvuGLF4cLpy5ZXX/3YHFh00XiiZXVmiM4vbWpDioidnxl1fgbt25tViqST6ysJo5gY3tL3B1RYf3Yqp8+syUcOH5s1Tmws7Ely+urfurMthgm0fDKhMX1VecINjY3w/raWuYOnDqzVYl5Or66lvk7bvrwh4+VRTE5efJk/TP//Wdf+mVf+iXfsXLyOA+45BLe8da3/4KsLqz7w659MH/8v9+MHr+MwckvZTZ4JLK4QmlTapliNkRVmDN3VIQ5c0c4IGD8/4iAGXOiipBwS7hXqEZMMoLizBAy3i4iZYvtt6wdG/DmH/uMSx98cfEROp1O5wL58Vf/5Pe96Plf/rUcOL66xiu/57u/7dHXXPvr1157zdvo3KWv+fdfe90P/Nfvf/Tjn/AE3v/e9xKpMqc3TzMn/Yfj7TVEG9HuOzZZoZAWPOMIqhwQ3B1VxczAnRwEDyDO33JAOOQOSCZKRrxHyqAR3EtQiLmlbB/AZO0DUMxos5FyXUFBp9PpXCjPeNrTX76yuvq121tbPO7xj+dBD37Im6+99pq38U/M6Z1taeo6PuDERS13w7Oe9ayX/sB//f5f+8gtN7O6ukpcXjzGma2zzIV8DB/V9B99CunfQtxbAwIeJ4DwdzkQOBQdes6dMhGUhmAljpCD0diAGPcY2Bi7uWW8H6AViioT1Wo6nU7nArrs0kvPrJ48zvbWFuXigN5wsMs/QceXV1xE7IqHXbX+86/+Gf3Uxz/+FEewvrZ+AwdmkwknL1snxjAiYMAmLlP82E1w7XVw8i3Y3ggPfWo1hNvnQHAIBs4dyxoRZsQcASeFRGIVl7MQzzB+y234Hz0TmgXEGsQ00el0OhdYb9hnLg76qHrmnyh3z8DGz//S68KnPv7xHMW0ni3QK4i9kllbE2sbk2SKAppH5OkDmE1vZTpbhryOtAVFk3ARwJkTBMeZUyALNMoB4RwHxME5T3sgE3JSRBpSrMFWaQhkrZC9q0AcQouLkCRUdDqdzgW0vbURwJjLbUvUUPNP3Bc/+wsyR5SUaml9jaKqMHeik1leWWS2ext12xBToExDpqkPjeAqNBpAFdw5xx1EOMcdRMBBzUEFw8EEVJgTc7ASlxZzBykABQM8AAuIDUAbCEYKJYlQ0el0OhfQyup6nu1PmJMggNM5ul6/vzfePYsOEmsrq8TSjcn2lP1aKI5D7p1m2p6B/RbaMUSBWQJVEMAcYoSUQARUwByRSFknlIbJsIQ6QqWQHW9riFM0GfgE6/VgFiHfDLHgjDcEbka4DLcpCaWQWNPpdDoXmJSROTcjq0Y6R9ZMZwMQBoMhzXRGNAyPAXp9PBmyW/OowcWMTiR8XNB4Yn9JwJwQFBEhpURRlOSccDeK3ohpcgprcW/ZL4QRPXrTRJGN3WVhMjPWUkRjwyZKJQUjWsYI/VHJh9+/wm1tAqHT6XTuNWkyYy7NagrRms6RlUUxWVpawlNGgJjV0SKCOWlSM6qdr3ji5/GET6nYu21KTgnrjcg5EYKiokwmE4aDITkbqZ0RFpdRIsPc0BZgTcazM0tGLZmLysD2NBFUGcTEdgtl6NGTmqnD8ZPH+d63v4uf3L4R1vvMOZ1Op3MvMA4lIziZzpG5edi66RaOra1wcv0EUVSZnd2D6RSGBTFUPO7Ew3m4KlzMkRiO3bzHjX/wRvoXrXPJkz4FespcAoKBrHKnHjBchmQgdDqdzr1GRJgreyXZLNA5stS2FXMi5Dahkg0pAqAgwhhj3MyYswQ0Dg5kIAEZMMCAzDmz33ozp1/1wyTZ5dSf/Sm3fMePwdSZEwN3yA5uBm0DrUE2sATmzG0lQJ05EQF3Op1O50La3N4Ig2OLzLU4JgQ6R9brVbtaFYgqoqDBhMHCAlL1wVvaUiFwzkwhKeCGi0F0XAwj42IYmXNOnSLedD0PvGiJi8rI7EM3ks9sYoACbXAaAVcHyaCQFbIYCOfsVxkEcDqdTudesbaynqfNjLlYlSS8onN0IpT9PkVZkrMRUaVNhjc1REAMNc7pKYgIiCA4jiGqCHOCBGGu9/mfxn5vjzd86w9z8uoH84hveh7h4jUcEAEBFDAEjQoYGSEhDBDmmiqDGyB0Op3OveG27VMV5syVRQHudI5u2tSLs/E+C4MB7k6ciTFpW6JDMiispQyRuRpQAWdOgIADAcEABxTIwzWWvuBLeEheZ+XKS6ke9QhqwAARcOeA04oSiRRAS8BwPmq1KUAUcDqdTufeEMxZ6A2Y27ltg14s9ugcmYmE4foqvcURjhOLpJShQKsAocB1xC0//xtcfWyLG2WRxRa8HZOzUZQFqNLUDWVZkHPGcyb2h7QqnFxZpr7uvdz0B3/GkvQ4XbS4JNYoGc8yWgjBYWqQhkKfimZ3j8GxSP2XI1heBDHmhE6n07mw1tdO1rtnzjJXVT08W6BzZP2y3IsGzf4EWekRo5T4/pSmriFE+tUS9U/8LIPb3kwxOE6zJzAU2ralcSFWBfVsBlUPd2iamn6/R2oabjGjKEvausH6PULb0tYt+0sL7DYNw9mYqlxlU/aJVQvNSWT2YWQwZnr1i2D1ibC3CeYIkul0Op0LzTjHHUQ10zmyPJ6Fs7dtENfXUFHitJ+xScs5CkU5pi/b0N5CPLtHYgnZ6yFkIpFc71OipGaKIBQIs2afSKREyPWEAiU1E+YKlLy9QZbA1GfEtMExMjae0QOWaUm7iWo2A3FA6HQ6nXtLORwwVxYFZhboHJmqZg64O4gQQ24YWMMWB/o9toew218BVmmL40y0x1JTEzXgONEF80wQYU4QIo6IIEBwDjhRFNwxMzQEBq4EiQw8MvCaGZmCPiVCGwfsLAh4AoROp9O5t7SpYa4oSyznQOfoBGJZEELA3YmSHXFFGWEuDNoZvTYCfS5rI2dRjJqYI47jOIIggLmjKI5jGIIAgmMIICiC4LmlJNBqS6YlkqnLTGNjegmmQZF4FsQAodPpdO4Np3bOVLEomNsbjyli0dA5MssWqqqi1+vh7kToMZYGw6CtWdk7w84gcNOxIbsCjUdE1nF3PkoQwHFA+CgBHOeQICCc425EC0wLI7qgbmwNa8pUUk8iBGWhTtBzzhFBhE6n07mgTiwfq3vDIR8ldO4Odw91XaOquDuxskzQGZBAlrnZruLb16/mFSf+Gad7fSQNUG+5PYLgOEdRJqGNjuSAArNeQ5GElTFUtsj1xxah3gOvgR6dTqdzb9jbPsOcmOEqic6RiWrOKWNmqAix0YJcBaBhlHYZJ7gxrkEYAQpeAlNAuEeKDFGBCtwhJ/DE6Z5C24dpCxiI0ul0OveW3CbmVANmFrkLIsI/AieAUxwqgBcCP8QnwN25IyGE7DiT8ZilxUWi24jKdoiAy23IaB+JF2OWiJOG0DopGPeMQGjIVlDVhrjQqlDFlskQwjTTm02ZxCGO0ul0OvcWT5m55eVlUkol/3itAl8PPBN4CPAW4N8DAvwgMAN+kgvJDMzJZiBCVJnSNIkEaBxglhFvwDOCY8HIKgj3VAFJSZoAwXAaj1CDITRFCZ7BM+DgQqfT6VxIt2xtDqq1JfgQ7DVTUOEfqQFwPbDEeU8E/gzY5dAnAT/JBdQqJQc0BAQhuk8Jo0hxekSyHpIDISSyJ7JmTB1EcO4hVxAnS+KjEgKt4DitFOAtuHFI6HQ6nQspBamSZebG0ykaY+YfpxaYAUt8vEUO3cgFVvV6k5VLT6LJMTM0JxgNR5RVgbU1CCACCLggLuCAAw444IADDjjggAMOOOCAAw444BxwznEBF3ABB8RBOOCA0Ol0OveWy5ZXz5QmzK2trJJTqvjHqQWuAJ4L/Ba37yVAxQWU2lTNpjPMDBUhhhjYPXuWaT0hFAUZp9PpdO6vqqJkbrK3R0Bqju4LgRcDBjgwBc4Cp4GbgfcDv8Y998nAw4HjQA8YA6eAdwHv4LwpcD3wfuBngM8Enst5lwNvAD6NC6Rp6kFd1yytLuJAFBGKfoUwRlXJCLjT6XQ690f72zvMtXVD0JA5mlXgZ4HInXsP8MnAlLvvq4EXANdwx94OfA/wB8AfAldx6JXAa4HvAr4V+LccehLwY8CLuACKopgsLCwSQ8DNUDNjzjBy24IZiNDpdDr3S0GZE8CFo9oHPht4DvCj3LGHA38MVBzdM4C3Aj8AXMOduxb4OeDdwFWc98scej/wJcDnAxMOvRD4Ii4Ah7Bz2yn2d86iIaAxRpq9CU5Cg4IKOJ1Op3O/FMuCc1Rx98DR1MDrgdcCXwH8F+7YY4HrgMdw174V+C3gsdw9x/hYnwo8hvN+CRhz3muAh3IP5ZwjBiICIqiZ4RwSVUAAp9PpdO6PQlUyl91wdz5B/wH4Ru7Y1cDbgR8FngZEPpYAPw68nAvnFcAjgB8AbgPW+Vi/xT0UVJMOK7SIuBkx50w57BOY4Qi4gwg4nU6nc7+TceaGgwGOBz5x3wNcD/wc0Of2vQh4EXALcD2wA1TA1cDlXFifCXwmd+yBwM8DXwJkPgEhxGZldZXogpuhrkbVlJg67g3qFa4N4g5e4JLpdDqd+4Nbd7YGGgJzoSzI7pF75n8AVwM/zZ27GHgy8DnA04HLuW88B1jgE9SmdrC5sYGZIRpQVWE6nuI4IoArYBxSwOl0Op37g4uWVyf1dMrceG+fKFpzz30YeB7wYOA7gd8GPsI/PNcDjwd2+ES5M1xYpD8cYpZRc2dpcZFYlpg7uIEIh5xOp9O5X6lb5jwbIsIF9EHgpcBnAZcCnwO8nX84Xgf8OfdAiLFuZjP2d3dRVVQU6qYhzaYIB1TB6XQ6nfslS8acinAP/XPgB4A/Ad4PvB/4PeA7gCuBXwceC3wR8C7ue58DvAn4UeCZfAKy5ardHWNtQlRQN9ifjoEMCJ1Op3N/FmJkbjAc4JYDd9+zgLcDbwC+Gngi8BDgIcBTgZcCHwD+N3A18AvAo4Dnc996JPCpwIuAXwXeBzyfu8McCqU3HGApoxzoxRKJPTQGPGc6nU7n/kqEc8wcRDN3z38E/ifwGO7ak4H3Al/GoVcDv84/HFcBPwm8iiNS1bS4tsZwYQFzRwUYLoyIRUHbNKBKp9Pp3G+VkbnUtoQYMkf3PcD/zXkN8H3A04AHAVcCzwJ+io/108AXcuiLgcTfn9cCzwauBB4IPBn4LmCb874O+AWOIITQgDPe30dEUFFlvD+mnY4pVBEHhE6n07nfOb27ExZXjzE3aWpStpKjeQLw9Zz3RuAq4OuANwA3ANcD/wt4AfBE4H2c91rgIcAe8K3c+24FngE8B/hl4HrgQ8AfA98CPBj4Zc77AuALuAtmFnY3t6hnM0IIKO70hgNCLGktgwo4nU6nc/9jxvjsLoccUTJH8xrOeyPw6cCHuGNvAq4BNjjvRzj0CuAm7j0T4BHA73DHdoBnAz/DeT8DVNyJsionS+vrSAjMqaVMWOwxKApIDS4g7rg4CAidTqdz/3B8eSW3uxPmogjqZO7as4DLObQNfBZHUwOXAdsceirwr4DPBwIXzp8BZzjvOcAZjubLgNMcqoCv4k6klKu2qfGcEQcNQdnZOsP+dEwoShyn0+l07q+kF5grexUp55K79mWc99PAlKN5CPBpwB7n/QrwOuASLoyXA18KDDj0NuB/cfd8L+d9IXeiaZrBZHMHz4YLRBXBcsYxJCidTqdzf1YtjqAALSLZreKuXcN5v83tuwp4GPAQ4DHA44CruHcl4NuAFwAVh36Ou+9XgFdw6BLuRFmVk+HJVWJRYW5EM2NxeYn6zJSxOZjT6XQ690en9rarejKBFmZNTYix5q6d4Lz3cfteB1zD368/4dDTOe+93H03AGeBJWCROyExMhotkJsGBNRdGO/tsT/ZA3dElU6n07k/ym5hMBox1+8PsJwjd804L3D7dvn79z4OCecF7r4AKIecOzGZTpdP3fwRbFajGogawFrHMVQVo9PpdO6fCrQORWSunc1Q1cRdOw0scOghwA18vFcB1wHbwAzYBSbAFvAk4Js49FPACzj0QeAKPnEFh27hvKuBX+PuuRxY4NAed6KKYa83WqAcDHAzojsMlhbpnzpLwwEzOp1O534pG2duPc3cbDwliGbu2luAB3PomcDv8vF+FfhVbt+/4rxF4NnAMrDHPXMxh34P+BoOPRf4Hu6ef8N5N3AnAppjCODgBooI0/0xs3YKOKjgzBlgOAoo4PwtaTlPQATEOc85JIAATqfT6dzX1o+t5ejCXFWWYM4RvJrzngcscHSfBjyX854N/CLwE8CjuWceyaFfB5xDjwC+iLvnazjvNdyJpk2D/VObNOMxMSgaTfDZGMfBAyIQHMQGiPcpfAYyQawED4CgzQnUFCQj0hCsRXNAyJzjEXFBqUEaoAQUcDqdTue+srF7JvTXjjHXX1igsTTgrv0O8E4ODYA/ApS7dhz4Tc57NfDVXDiXAJ/Oof+X834GuJKj+Q1giUNbwI9yZ8zAQSQgIsQyF8RegALcImIOJFwUJRDMabUE74Huge4hvobLBLzAfYBYBkpMZiAZrAJ3BENQnMihTKfT6dxX6iBDqSrmdqcTUOWInge8hUPXAH8GfBFwPbfvycDPAQuc943AFrAFfCdQAcZ5zscyoAVaIAMJSMAMGAPbgHHo64AvBoZAAbwNeA7wG9y+E8Crgc/ivOcDmTsRi1gvHF+l7FfknIm1QbnQQ/sRsQI3xcIM14zZIm0egPdwbUBqRFqsPI2HGvIQGJHDPlCDKGDMuQ8xW8JpIcwAA4ROp9O5r5TGeP/UaeaGvT5qZI7mrcA3Aa/k0CcDHwB+Cfht4K+BADwG+EzgM/lYTwO2OPQa4DVABBxwbp9xdPvAE4HrOLQA/DrwRuDXgLcBCbgceAbwucCQ874f+F/cBY8KZcSCYAqRMlA3M2w30Vvq0XgErcEzbitABt0DcSSXSBpgEoA+UIBM8WIHDPAhWABXQHBRkARhG2wA3gOMTqfTuU80CdHIXKUBd+Nu+G4OvZJDAnw+8PncsTHw74A38PESF9Y7gM8EfhZY59BTgKdw574L+BaOoGnTYG9zk+L4OhIVbXPC3aEEzwqUmEWgQD1SpZJgBXPiiloESWBCyJmgDl6g3kfaAjGQuAPlTVB+CAlnCblAXAGn0+l07ivHV9dy4ZyzubFJEYuau+e7gccBv89dex1wFfAa/v78LnA18N+4a38BPA34Fo6o0FCvnbyI4WiR3GYintAAWoDTYi6oDQixR949w3Rzg3jxg5DRAPcpQcZYrEGG+NZpbDKDYoS1DRIz5dISpn3aogUEz4tQXwLFBsSz4JFOp9O5r6S6Za4sShA+EW8Bngp8OvAs4LHACcCADwFvBX4RuI77xhngucB3AV8IPB64AgjAJnAd8JvAr3N3pcTZ7TMEc2ShIGoQ2olhY2BlhmiGvEieOZceD1z5oBHXbczYbguClHgreBHxpuCqi5S1tRH9Y1cjTcGHP3wzf/2eWyjXriCPlrFyE+Ie2CmQBAQ6nU7nviRFYG5hcQEzC9wFd+cO/CHwh/zD9T7g5VxAbka7O6YtK8KxVVQISFLmJEzxuIcT4SPbfPmzH87vv/ZLuPS4wcYGEUW8wmUFbtjmy7/wcfzJf/tSXvLcS3jZf7qMP/+1z+Hrv+kE9d4H8GYEeRE8gAsggNPpdDr3pYWVFeZcwLJFOkcmMUIEVHB31BOEuIxIhDgG3SeEANawyGnOaR3CAtn3CXETfA/KxEq1ByRe/Hmv4UmXfR83feg0r3jRZ3PRccWnmxBmEHdB94EMrnQ6nc59aW/3LHN7kzFahETnyBrPg2p9jeHKMZJlYkliXMxwCWg+iZiTdBuqSJbjzNXeA78N92UaGUJ1GtKUcRsB44qrV3jIY0/wyMtXeP073sXN47NUYYXBXmJaXcysOAvWgFeA0+l0OvcVa1rmrE2IS6ZzZOrken9MU/VYHPWILoK1U7Aa2gLNfbKUIDXQMuepBG0oqAmskRqFXNCMB0DJq3/iWTz8AWu84X++n6c/7zfg2iux0YTp3oCcFLQAHBDunNPpdDr3poWVY8yVRYGbBTpHVsZiUhaRtmkREdRjxWj1GCwqyfcRWyDMFmBmBN8BDOmdhmqF2a0wfveNgMLoLEV/xjaJ5zzvl/nN37mRJ3/uRTzuMx4KH+rT6hqzU6dobzgN3geNHBJAAAEEEEAAodPpdO5t07195uq6QVQznSMLMdSj4QK4gztqGDllaA0kYa5EAijksAgoQzW4dZuXvORB/NhPP4HjfYNTE9aXEisoHzoV+Jf/5rX8yds3+fNfeRZf/YWX0nv3Nt/+jY/je7/7oaw0uzCOgAACCCCAAAooIHQ6nc69rZnOmCuqEhMPdI6sruvF7Y/cgqcEKkSzxPj0PkwhFgUpzsjFLhyreMM7Nxn+6o3ceutlUP0lx9ZmnLzicor2faAn+dU/bbk5v414qYJdyrOe/0a+7+UND32UsvR7U04cv4T1hQ0kKXgAacGVj+HOOQKI0Ol0OvcmV2FuaXERyxbpHJ05OIhzQIgBQ7wAIiKChyk57hJPHuO3f+9mfus1b0ceeC39y67gO//ze/Hxu6guWaW4dp3Xvf42Xve6m9DLroYHKXu7p/jyF/4pHBe4fIGv+MZfg3oClz4QKR0MFMfcEVHMjDlVRYDsTqfT6dyb+sMBc2f39giqic6ReTZ6y4uMjh3DciYiQtACJYAYaETMyGkCSw9EV5fw8iZs72JYfyBckpB2iDc1nJzC6uUwFeLOlFCOyFdNcTkB00i+zMCGYAI5EUQQVTDDUkYEEFCcTqfT+ftQNzVzKbUgdO4Od3JqURHcnZhFyWYYNU4DbZ+CRSQ4s+kpfG8DLl2gGRp+2y7M9piFCDKDQQ8dLODDXZI7Mushg23SqZthZwEu7cFSSdivkDAhT/bw7RmyvoAOC6TlgJBO7SBVgRwb4nQ6nc6949a9M4P+0iJzg+GQnHKkc2RFjHW7P2X3zA6LF11MzOKYJOYEBe8RrI/V21x0qXL5+kN4919N2Jtt88gHj7j0xCrV+oBZu8t7/+IMN37wFPHKJZwxUZXpbRdz6QOVBz2uz1ve9SHGew0DFphOAidOrPGAaxf5q7d+kPGGIccihWWu+ZQr2drd5yO37QBCp9Pp3BsEyWWvYm5/fx8NmugcmbszJwIigooYlIk5rRdBM5Nqxuz0LXzDMy/hTT/8NB5YDeDUTbzy/3oEv/lDT+UlT13iZ77hU7jhd5/Nc559CWnrI0SLNGePQTrDL7/q0fzhj3863/i5V8A7AnujNdL2hH/3xOP8xQ89kZ/7ln8B1zf49hajsMlf/uiT+aovW4Fbt0AqBAE3Op1O50I6ubBc79+6yZwmo5DQ0DkyFc0ccANxR2PqoS3nOA0wBhGwBcgDzilvg+JGFo4t8Pb3/zVP/2c/zKWP/R9ki3z9cz4VWqMOQt58Gy/5gmM87sGXkOoZX/3iazlxdQ0bp6HI1HHC3LOeeYJXvfLh8MGGNo2YaibuF+AK4nQ6nc69xZqWuaIsyWaBzt3mOHMarICsnBNaCBMggC1hNmIuYzA7RrGTOK5rXP6kh/H8F58kKPz+/34b7PVgUzh+Uvne//gveMWP/Q7XPv1HWFlc4Ou+5Fq44TSwgC5l3vnXm3zvD7+er3vh43je//ko9q5rOZMzUg+BEjA6nU7n3tJfXWZuMBqQc67oHFnGSg4IjglERJGSc5Irc+IBzyXiibmxXAx1YGc25fGPuYg3/Ny/5sGXn+RlL38b3/5db0Q//ZOx93yY537lI6m0pHTlgVf2mNb7vPj5j+WVP/9utv5yQtX2GJ5Y5Otf9mYWFi7mp17+GYxvuIVbP7iBFRkkAwruCCQ6nU7nAtrYPxsGCyPmdnZ3iWWs6RyZFjHHxQEUETNHU6gZnhhAv6ClAB+grQA1EnaZKy1BuU15XPjLd9/E0z/rx/nrG3d43osfxkWffAn29ps4eaXxH77yMdx68zYPuvJRfNWLv4A/fPMZFnslX/VvHgXjbYZeMlhIhAed4IVf9wf88Ztu4Rf+++fzSQ+9mN3mVvAGUBAws0in0+lcQCnnanNzg7ler082D3SOzLKHqtenqirMMkqRmZydQmqRKJAGBFEIO0ihzC2TYFxzggErawUfvGHI457+ixRhxi1/9GU85tMmfM2XPJpjwwWe/pW/yr967k/xjC/7b3z2836Uv/irD/DtX/EprD1unZ3phJP0OHaigMUVPvcFb+CmD+8AwrCowBUsI3Q6nc6FF1zqQX/AXK8qmU2ni3SOzHGyZRQhaCDOJvto1YMI4tuQI24J1uC333oz3iu50aewdjmv/pWPkAan4ZPX2bml4PFf/At8+zf/HzzpU57G5tmWr/mO3+Rd71uFh10GaQobU77qP72Jl35FyQOu7fNb77yVhR+5Cd1chwdFtm69mWc+//f56q94Km948y6sLIAKZg5Op9PpXFDHl4/l3LTM1eMpMYSazpGVGibNtGYWZ+jSMWJ9djq78jGP6Z364Eeg3aKMJY0YcknJ69+4xe/+wg48dAAPG/I9P/VOkABXLqDHlJtvG/GC5/4u8dg6ZhNMPkLvxFV4E2h7t9E7/jDe+v4Jz3r+L6FXXIQ3ket+/030LlmEcge98hjvvHHKl7/4DfCQTFxbIu3tgyrmFuh0Op0L6K1vecunvvcv38ncB977PhZ6wzN0juw973nP02085dhll3Lbbbe9RevJ7DU+mdIrIN3yIQbNJsd6y/jkGL76EMIVj6RMPXS2CyfX4OSl6CxS7BpxGAlXLiJLU1hfRS+5Ais2SLqPxZaZ3UZeK+ChVyG+CtUAu3KJWbWLtGNkXCKrwMOXYbiMt32YRpbI9BfLXTqdTucCetX3vepNzI1Krnv3X/IX733Hv6ZzZP/hm7/5uzkwGowY7+//sO61zU9vbZ7ioY96KNgGsw/8OMOz72Q9HKOne8jyh2hLx5sBsVLKcp8oivUqrEwQe9AfEospIfdxvQSJmap9MKHsEcNZClNC1dKrAr3gqCxQ+SWoO1qsUPQTEYfCoXBGcYx4k+l0Op0L5AUv+fLt1/z8azn5yAfRW1+CpSEv+uoXv+J3//yP/jWdu/SUp/5z//CHbuJR1zyas2fOvG5vf//VIlyEs/GDD3/sRV8pQ+Hdb78J6hOMLn0C7WCVJD0kLBBwshmOgAqeDTfDHQKKtAkXR0IEMzQoqOAIDqSUCCqAE4qCuQxIyuAOCF7U5NmYpTLx9S988u9evubvkdZiVa5+pE2pCqWnXFQx1U1FzlhKwXKOBGUwGm07kOq60mRks8icCJZzwB0XwbJFjZIMif3hYNeUkPEoDs1kOjDziBvaL5MKWUORAlpLNqxNUZ1kySsJUreWhhwwtyAh5BhCPanrYwvLyxtBpZ7u7694MjSE5DlHjSH1+v3dtmkrDZpFlGY2G6h7jjHWqppSTlXdpqEAEjUVRVl7ThRVWWfzmNqmIjsSlLJfjZu6GcYQajESBqqa27YdIGBm0d1RkaQh5GRWZctVURTjqqomopoEmI0ni03bDLN7KHpVndq2KstqUpXlbjOdDXLbVjggggTJZh5wJ7tXRCGGorY2RdxZWFy8tW1mw7qpB9m9SnhVVtVE3RPmaAi5CnF3Np4tiioOWE5BVBDRbGZBREiWqqLfm5hb6FW93dlsutjO6qGGkMpeNclmwWZtHA0XNlQl7U8m66GIGYec2pDNKss5hkJrDSGJCHNlWU1ySqGuZ4u9fn+3rZuqaZphLMu63x/uprqpomqd3YJli0pInlN0tyAhZHMLbc6VqcSgmvqDwZm2bgYCGQFxaHI7aMyG/X5vO6K1uFPXzbAKcawiuWmagarmbDngEELIHKjrekAZ6Q0Hu1G0nozHK0EkiYac3KqcUxXLsg5FUYsIRRHHaVpXs+l0sdBQi5M5YO4hi1eqmt2dsijH5h7LqhrX0+kioojm3NbNAFGKIk7KWI7buh2aWzhQW/bo7sFxRMDdUA3Zm1RVVTmOZagbt9iEMBiEeGayu3dMizLXuV3UEFJZVZNBKLZn++NFAVRDbtqmEgF3MLOgqhkBgpLdK40hFWU5aXMaeNPi2SLmiJCs0lj0+3Uw6lLDuJnVwzRtBwIEkew4SQjujqlHHFwIyysrH5nMxis/+IM/8C1veeOfMzc4vkTGyeqkM3ss9Bf5on/7xTf8s8c9/qf7w9Hmzt7exYJnXBAV3AxEmBMRpCwyIsQi1qlpq+l0uqwiuSiLSVn1Jqltq9Jl0rbtwN2ZExHMLKhqdndaS4Ny2J8Iks1yiEWsQ4i5bdsqp7bMKQU3iVV/sFeWcWLZgpuHdjar3DxokOwOni1I0JxzKs2JEjRpCDlWZZPMyqqqJrlpYlPX/bZNgxhC44Cqpl6/txdizKluKmlzMrdo2YLhwfGAw+rKyg0fvPGGJ3z3f3nlC2679TaueujViMiH3vdX773K3RsRjuO6QVnJDz306mtesrx8gne8423sbJ8mHuthyWC/YTCA6RSycbtEIPQhTUECaAl5BhjnSARPEHtAgDQBFMj8HX1AgRmQOScolBGsgSgwBcz5OAIIYBxdpYBD7XycCkiAAc5dU+EccxAOOR9DVJEiYHXLkRSKlAU+rvkYAgQgA87dI5znfCwVKBSaDM7RRAUVaDK3KwAOCIcyRxMAB4x7TjlkgAIOOB+rEHAgOUclgxLajLeZ26O9Em8THgSazJEoIEDm4wlQBshAyiAccu6cACIgQHb+lgDO0RWAAVFhUWE/wZSPVwVoMxhHI4ADpYI7tM7HiUAJTDi6KCACrSFRiVVBO66Z6x1fIjUNZa9Hsz8l7c+4x4RDzn1PAeOOCSCAcST9wYDHftJjmU4m777uunc8NrVtwwGB44TeDqRMTv4jD33IlS++6OIl6rYhtTCpE3U7Q0UAwXFijLg5IjAY9MkKtWdGgxH7u2dpU6KsKnLdoiIUwx6xdcZnxwxHfXLT0NYtQRU3R0QQYDZUNFQUEnA3qjJidaadJVJbg8AEZzRaIMRI1MDcztYWqKBBkWRIAlFBRMiWcVXKXkUMgf7CiHo2ZX/nLAmjtzDEUsKLQH9xARGhrhuCCM1kQrM3RTWgBsFBXBAXcCcu9EAEAWJVsru7izsITjUckuqGUb/PbDajbRpEhGwG7pwjAtkpyoJq0KdtE6Eq6A36NE3DrKlJKWGzGTEEql6PoizREGjqmvHZXUJZ4ObILKOqiICL4DgGDIZD5rSMhDKwt7dH27Z4ypQxkgX6wyH9XkXbZuo24SlRTyY4QnBQhLkiRAxIlhksLVBWFfVsRtM04E6a1jjQX+5jAlVZ4gL7e/uIOSEE2lmDZCdqAe5oCMQYadqWEAJFUZCzYWI0qaEMBbNmxmhxkbIomEwmuDuzyZRCI54dc0NVyRgSI7gzXFygNxiwP9mjKEuaumY2maDZKWNJSi1lVTEcDdmvZ8ymUyQ77oIA6o644gaxjAR16qbFo7KwtISZIcB4fx9FKGLE3ZEYISi9fo/dnbPktkVFwB1aA3eKssQsQwgUVUXdzChiQTHosz8eg2XKosTMmU0nLC4tU5QF+5MxMQTmJnt7gIAIAaEsSnDHcma0vMRsNmM6HrOwvEQzq6lnM0SV4WhEaltUHERomoYYI22TyCmjIiCgKmScoIFer6KuG8p+SY6Qc6ae1aQmMRiMiKKQHc+ZLFBUJfVkSq5bggY0KDlnVBVVRUIgFBHcqaczYlUQqsh4PCaoUhYFoShIbaJXljSzmv1cgzuFCzgECQgK2RB3YlHQYgyGQ+q6xsiIKpYS/cEAc6NAkWQ0OVMO+8zaGksZy0YvFnjKpOxoDIQYKcuSnBIaAmVVsb+3h4pAVLJlYojEoiClhKVErCrq6RTcCS64O3MiQowRy5kYIxoCIQb2Z2McsJwREUSEqtcDEdwdaxJN0+IOCgggqgjgZiCChoCGQNmvUFGm0ylNU4MqKoKKEEIgxAgh4DlTFAXj/X1SSpgZASEiuAhz7s5gOMTcKYqC3d1d6umUtmn+/IPXf/AJ7m78jf8P+QM5bjYv2GAAAAAASUVORK5CYII=\")}::ng-deep .row .cell .plaque.plaque-f{background-image:url(\"data:image/png;base64,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\")}::ng-deep .row .cell .plaque.plaque-g{background-image:url(\"data:image/png;base64,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\")}::ng-deep .row .cell .plaque.p{background-color:#ffc913}::ng-deep .row .cell .plaque.g{background-color:#e20600}::ng-deep .row .cell .plaque .part1{float:left;height:30px;line-height:33px;margin-left:13px;width:32px}::ng-deep .row .cell .plaque.plaque-m .part1{margin-left:13px;width:42px}::ng-deep .row .cell .plaque.plaque-f .part1{float:right;margin-left:0;margin-right:28px;width:64px}::ng-deep .row .cell .plaque.plaque-g .part1{float:right;margin-left:0;margin-right:28px;width:112px}::ng-deep .row .cell .plaque .part2{float:left;height:30px;line-height:30px;width:25px}::ng-deep .row .cell .plaque.plaque-m .part2{line-height:33px;width:57px}::ng-deep .row .cell .plaque.plaque-f .part2{float:right;font-size:12px;line-height:30px;width:48px}::ng-deep .row .cell .plaque .part3{float:left;height:30px;line-height:33px;width:42px}::ng-deep .row .cell .plaque .part4{float:left;height:20px;margin-top:8px;width:28px}.row .cell.show-data-col:before{content:attr(data-col)}@media (max-width:1400px){.row .cell.show-data-col-1400:before{content:attr(data-col)}}@media (max-width:1300px){.row .cell.show-data-col-1300:before{content:attr(data-col)}}@media (max-width:1200px){.row .cell.show-data-col-1200:before{content:attr(data-col)}}@media (max-width:1100px){.row .cell.show-data-col-1100:before{content:attr(data-col)}}@media (max-width:1000px){.row .cell.show-data-col-1000:before{content:attr(data-col)}}@media (max-width:900px){.row .cell.show-data-col-900:before{content:attr(data-col)}}@media (max-width:800px){.row .cell.show-data-col-800:before{content:attr(data-col)}}@media (max-width:700px){.row .cell.show-data-col-700:before{content:attr(data-col)}}@media (max-width:600px){.row .cell.show-data-col-600:before{content:attr(data-col)}}@media (max-width:500px){.row .cell.show-data-col-500:before{content:attr(data-col)}}@media (max-width:400px){.row .cell.show-data-col-400:before{content:attr(data-col)}}"]
+            },] }
+];
+TableRowComponent.ctorParameters = () => [
+    { type: PsToolkitUiConfigService }
+];
+TableRowComponent.propDecorators = {
+    confirmShow: [{ type: Output }],
+    changeRows: [{ type: Output }],
+    level: [{ type: Input }],
+    table: [{ type: Input }],
+    row: [{ type: Input }],
+    loadParent: [{ type: Output }],
+    childrenDiv: [{ type: ViewChild, args: ['childrenDiv',] }],
+    onContextMenu: [{ type: HostListener, args: ['contextmenu', ['$event'],] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.row.component.js","sourceRoot":"D:/PsToolkit/UI/projects/ps-toolkit-ui/src/","sources":["lib/components/table/row/table.row.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, ElementRef, EventEmitter, HostListener, Input, OnInit, Output, ViewChild} from '@angular/core';\r\nimport * as _ from 'lodash';\r\nimport {TableClass, TableCollClass} from '../../../classes/table.class';\r\nimport {\r\n  EnumUtils, FileIcons,\r\n  InputType,\r\n  Method, PermissionAccessTypeEnum,\r\n  PermissionInputActionEnum,\r\n  PermissionInputTypeEnum,\r\n  PermissionTypeEnum,\r\n  TableCollType,\r\n  TableOptionType, TableRowStatus\r\n} from '../../../classes/enum.class';\r\nimport {InputClass} from '../../../classes/form.class';\r\nimport {RequestClass} from '../../../classes/request.class';\r\nimport {HelperClass} from '../../../classes/helper.class';\r\nimport {PsToolkitUiConfigService} from '../../../services/config.service';\r\nimport * as $ from 'jquery';\r\nimport {PermissionClass} from '../../../classes/permission.class';\r\nimport 'jquery-ui-dist/jquery-ui';\r\n\r\n@Component({\r\n  selector: 'lib-table-row',\r\n  templateUrl: './table.row.component.html',\r\n  styleUrls: ['./table.row.component.css']\r\n})\r\nexport class TableRowComponent implements OnInit{\r\n  @Output()\r\n  confirmShow = new EventEmitter<object>();\r\n  @Output()\r\n  changeRows = new EventEmitter<object>();\r\n  @Input()\r\n  level: number;\r\n  @Input()\r\n  table: TableClass;\r\n  @Input()\r\n  row;\r\n  @Output()\r\n  loadParent = new EventEmitter<string>();\r\n  get tableRowStatus(): typeof TableRowStatus { return TableRowStatus; }\r\n  get type(): typeof InputType { return InputType; }\r\n  get tableOptionType(): typeof TableOptionType{ return TableOptionType; }\r\n  showChildren: InputClass = null;\r\n  addChildren: InputClass = null;\r\n  group: InputClass = null;\r\n  children: any[] = [];\r\n  options: any[] = [];\r\n  @ViewChild('childrenDiv') childrenDiv: ElementRef;\r\n  constructor(public service: PsToolkitUiConfigService) {\r\n  }\r\n  mouseOut(e): void{\r\n    $(e.target).find('.options-con').removeClass('show-group');\r\n  }\r\n  ngOnInit(): void {\r\n    this.row.subTable = this.table.subTable != null ? HelperClass.clone(this.table.subTable) : null;\r\n    this.group = new InputClass(this.table.environment, this.table.l, 'ShowOptions', 'fas fa-ellipsis-vertical', InputType.Icon, 'blue m-h-5 h-25 d-ib va-m f-u');\r\n    this.group.onFocusIn = (e) => {\r\n      $(e.target).closest('.options-con').addClass('show-group');\r\n    };\r\n    this.group.onFocusOut = (e) => {\r\n      // $(e.target).closest('.options-con').removeClass('show-group');\r\n    };\r\n    if (this.table.hasChildren){\r\n      if (!this.table.childrenAutoLoad){\r\n        this.children = this.getChildren();\r\n      }\r\n      if (this.table.permissions.hasAccess(PermissionAccessTypeEnum.Insert)){\r\n        this.addChildren = new InputClass(this.table.environment, this.table.l, this.table.name + 'AddSubsetTitle',\r\n          'fad fa-plus fa-rotate-90', InputType.Icon,\r\n          'green m-h-5 h-25 d-ib va-m f-u');\r\n        this.addChildren.onClick = () => {\r\n          this.table.form.onSuccessBase = () => {\r\n            this.table.modal.hide();\r\n            this.showChildren.type = InputType.Icon;\r\n            this.loadChildren(this.row.Data.Id);\r\n          };\r\n          this.table.showInsertModal(this.row.Data.Id, this.level, this.row.Data);\r\n        };\r\n      }\r\n    }\r\n    if (this.table.hasChildren || this.row.subTable != null){\r\n      this.showChildren = new InputClass(this.table.environment, this.table.l, this.table.name + 'SubsetTitle', 'fad fa-angle-left f-s-22',\r\n        this.row.Data.CountChild > 0 || (!this.table.childrenAutoLoad && this.children.length > 0) || this.row.subTable != null ? InputType.Icon : InputType.Hidden, 'h-25 m-h-5 d-ib va-m f-u');\r\n      this.showChildren.onClick = () => {\r\n        if ($(this.childrenDiv.nativeElement).is(':visible')){\r\n          $(this.childrenDiv.nativeElement).slideUp();\r\n          this.showChildren.icon = 'fad fa-angle-left f-s-22';\r\n        } else if (this.table.hasChildren && this.children.length === 0){\r\n          this.loadChildren(this.row.Data.Id);\r\n        } else if (this.row.subTable != null && this.row.subTable.permissions == null){\r\n          const acc = this.table.permissions.Accesses.find(x => x.Action === this.row.subTable.name);\r\n          const ps = new PermissionClass();\r\n          ps.RelatedId = this.row.Data.Id;\r\n          ps.Area = acc.Area;\r\n          ps.Controller = acc.Controller;\r\n          ps.Action = acc.Action;\r\n          ps.Accesses = this.table.permissions.Accesses?.filter(x => x.ParentId === acc.Id) ?? [];\r\n          this.row.subTable.permissions = ps;\r\n          this.row.subTable.set();\r\n          $(this.childrenDiv.nativeElement).slideDown();\r\n          this.showChildren.icon = 'fad fa-angle-down f-s-22';\r\n        } else {\r\n          $(this.childrenDiv.nativeElement).slideDown();\r\n          this.showChildren.icon = 'fad fa-angle-down f-s-22';\r\n        }\r\n      };\r\n    }\r\n    if (this.table.sortable){\r\n      this.setSortRow();\r\n    }\r\n    this.setOptions();\r\n  }\r\n  loadChildren(p): void{\r\n    const data = this.table.searchData();\r\n    // tslint:disable-next-line\r\n    data['Page'] = 1;\r\n    // tslint:disable-next-line\r\n    data['PerPage'] = -1;\r\n    // tslint:disable-next-line\r\n    data['Level'] = this.level;\r\n    new RequestClass(this.table.environment, this.table.l).send(this.table.url + `/${p}`, Method.Post,\r\n      data, this.showChildren, (result) => {\r\n        this.children = result.List;\r\n        setTimeout(() => {\r\n          $(this.childrenDiv.nativeElement).slideDown();\r\n          this.showChildren.icon = 'fad fa-angle-down f-s-22';\r\n        }, 50);\r\n      }, () => {});\r\n  }\r\n  check(): void{\r\n    this.row.checked = !this.row.checked;\r\n    if (this.table.onChangeCheck){\r\n      this.table.onChangeCheck(this.row);\r\n    }\r\n  }\r\n  onChangeRows(e): void{\r\n    return this.changeRows.emit(e);\r\n  }\r\n  onConfirmShow(e): void{\r\n    return this.confirmShow.emit(e);\r\n  }\r\n  setSortRow(): void{\r\n    setTimeout(() => {\r\n      if (this.table.hasChildren) {\r\n        // @ts-ignore\r\n        $(this.childrenDiv.nativeElement).sortable({\r\n          axis: 'y',\r\n          items: '.row',\r\n          handle: '> .handle-con > .handle.handle-sortable',\r\n          update: () => {\r\n            const data = [];\r\n            // @ts-ignore\r\n            $(this.childrenDiv.nativeElement).sortable('toArray', {attribute: 'data-id'}).forEach(x => {\r\n              data.push(parseInt(x, 10));\r\n            });\r\n            const p = new PermissionClass();\r\n            p.Area = this.table.permissions.Area;\r\n            p.Controller = this.table.permissions.Controller;\r\n            p.Action = 'sort';\r\n            new RequestClass(this.table.environment, this.table.l).send(p.getUrl().toLowerCase(), Method.Post, {Ids: data}, null, () => {\r\n              if (this.table.onSort){\r\n                this.table.onSort();\r\n              }\r\n            }, () => {});\r\n          }\r\n        });\r\n      }\r\n    }, 500);\r\n  }\r\n  setOptions(): void{\r\n    const opts = [];\r\n    for (const option of (this.row.Options?.filter(x => x.Type === PermissionTypeEnum.Option && x.InputAction === PermissionInputActionEnum.Input) ?? [])){\r\n      const inp = new InputClass(this.table.environment, this.table.l, null, null, InputType.Check, 'h-25 without-border m-h-5 p-0 w-u', this.row.Data[option.Action] === true);\r\n      inp.row = this.row;\r\n      inp.tooltip = option.Name;\r\n      inp.onChange = () => {\r\n        this.row.Data[option.Action] = !inp.data();\r\n        new RequestClass(this.table.environment, this.table.l).send(this.table.getOptionUrl(option.Url, this.table.permissions.RelatedId, this.row.Data.Id), Method.Post, null, null, () => {\r\n          this.table.load();\r\n        }, () => {\r\n          this.table.load();\r\n        });\r\n      };\r\n      inp.displayLabel = false;\r\n      opts.push(inp);\r\n    }\r\n    if (this.addChildren !== null && (this.table.level === null || this.table.level > this.level)){\r\n      opts.push(this.addChildren);\r\n    }\r\n    for (const option of (this.row.Options?.filter(x => x.Type === PermissionTypeEnum.Option && x.InputAction !== PermissionInputActionEnum.Input) ?? [])){\r\n      const opt = new InputClass(this.table.environment, this.table.l, option.Name, option.Icon,\r\n        option.InputType === PermissionInputTypeEnum.Icon ? InputType.Icon : InputType.Button, 'blue h-25 m-h-5 d-ib va-m f-u');\r\n      opt.row = this.row;\r\n      if (option.AccessType === PermissionAccessTypeEnum.Update){\r\n        if (this.table.form){\r\n          opt.onClick = () => {\r\n            this.table.form.url = this.table.getOptionUrl(option.Url, this.table.permissions.RelatedId, this.row.Data.Id);\r\n            if (this.table.hasChildren && this.row.Data.ParentId != null) {\r\n              this.table.form.onSuccessBase = () => {\r\n                this.table.modal.hide();\r\n                if (this.table.childrenAutoLoad){\r\n                  this.loadParent.emit(this.row.Data.ParentId);\r\n                }else{\r\n                  this.table.load();\r\n                }\r\n              };\r\n            } else {\r\n              this.table.form.onSuccessBase = () => {\r\n                if (!this.table.form.onTop){\r\n                  this.table.modal.hide();\r\n                }\r\n                this.table.form.clear(this.table.insertAccess != null);\r\n                this.table.load();\r\n              };\r\n            }\r\n            this.edit(opt, option);\r\n          };\r\n        } else {\r\n          opt.url = this.table.getOptionUrl(option.Url, this.table.permissions.RelatedId, this.row.Data.Id);\r\n        }\r\n      }\r\n      else if (option.AccessType === PermissionAccessTypeEnum.Delete){\r\n        opt.class = opt.class.replace('blue', 'red');\r\n        opt.onClick = () => {\r\n          if (this.table.form){\r\n            this.table.form.clear(this.table.insertAccess != null);\r\n          }\r\n          if (this.table.permissions.Type === PermissionTypeEnum.Form){\r\n            this.table.rows = this.table.rows.filter(x => x.Data.Id !== this.row.Data.Id);\r\n            if (this.table.onLoad){\r\n              this.table.onLoad(this.table.rows);\r\n            }\r\n            this.changeRows.emit(this.row.Data);\r\n          } else {\r\n            this.confirmShow.emit({\r\n              action: option.Action,\r\n              data: this.table.hasChildren ? {Level: this.level} : null,\r\n              url: this.table.getOptionUrl(option.Url, this.table.permissions.RelatedId, this.row.Data.Id),\r\n              accept: () => {\r\n                if (this.table.hasChildren && this.table.childrenAutoLoad && this.row.Data.ParentId != null ){\r\n                  this.loadParent.emit(this.row.Data.ParentId);\r\n                }else{\r\n                  this.table.load();\r\n                }\r\n              }});\r\n          }\r\n        };\r\n      }\r\n      else if (option.AccessType === PermissionAccessTypeEnum.Report){\r\n        opt.url = this.table.getOptionUrl('/report' + option.Url, this.table.permissions.RelatedId, this.row.Data.Id);\r\n        opt.queryParams = {reportId: HelperClass.random(20)};\r\n        opt.urlNewTab = true;\r\n      }\r\n      else if (option.InputAction === PermissionInputActionEnum.Link || option.InputAction === PermissionInputActionEnum.LinkNewTab){\r\n        opt.url = option.Url.replace('{}', this.row.Data.Id);\r\n        opt.urlNewTab = option.InputAction === PermissionInputActionEnum.LinkNewTab;\r\n      }\r\n      else if (option.InputAction === PermissionInputActionEnum.Modal){\r\n        opt.modal = this.table.optionsActions.find(x => x.name === option.Action);\r\n        opt.onClick = () => {\r\n          if (opt.modal.table){\r\n            const p = new PermissionClass();\r\n            p.RelatedId = this.row.Data.Id;\r\n            p.Area = this.table.permissions.Area;\r\n            p.Controller = this.table.permissions.Controller;\r\n            p.Action = option.Action;\r\n            p.Accesses = this.getPermission(option.Id, this.row.Options);\r\n            opt.modal.table.permissions = p;\r\n            if (opt.modal.table.form){\r\n              opt.modal.table.form.url = option.Url.replace('{}', this.row.Data.Id) + '-insert';\r\n              opt.modal.table.form.baseUrl = option.Url.replace('{}', this.row.Data.Id) + '-insert';\r\n            }\r\n            opt.modal.table.relatedRow = this.row.Data;\r\n            opt.modal.table.set();\r\n          }\r\n          if (opt.modal.form){\r\n            opt.modal.form.name = option.Name;\r\n            opt.modal.form.url = option.Url.replace('{}', this.row.Data.Id) + '-update';\r\n            opt.modal.form.loadData(option.Url.replace('{}', this.row.Data.Id) + '-get');\r\n            opt.modal.form.onSuccessBase = () => {\r\n              opt.modal.hide();\r\n            };\r\n          }\r\n          if (opt.modal.accordion){\r\n            for (const r of opt.modal.accordion.rows){\r\n              if (r.table){\r\n                const options = JSON.parse(JSON.stringify(this.row.Options ?? []));\r\n                const rowOption = options.find(x => x.ParentId === option.Id && x.Action === r.name);\r\n                if (rowOption){\r\n                  const p = new PermissionClass();\r\n                  p.RelatedId = this.row.Data.Id;\r\n                  p.Area = this.table.permissions.Area;\r\n                  p.Controller = option.Controller;\r\n                  p.Action = r.name;\r\n                  p.Accesses = options.filter(x => x.ParentId === rowOption.Id);\r\n                  r.table.permissions = p;\r\n                  if (r.table.form){\r\n                    r.table.form.url = option.Url + 'insert';\r\n                    r.table.form.baseUrl = option.Url + 'insert';\r\n                  }\r\n                  r.table.set();\r\n                }\r\n              }\r\n            }\r\n          }\r\n        };\r\n      }\r\n      else if (option.InputAction === PermissionInputActionEnum.File){\r\n        const p = new PermissionClass();\r\n        p.RelatedId = this.table.permissions.RelatedId;\r\n        p.Area = this.table.permissions.Area;\r\n        p.Controller = option.Controller;\r\n        p.Action = option.Action;\r\n        opt.url = '/file' + this.table.getOptionUrl(option.Url, this.table.permissions.RelatedId, this.row.Data.Id);\r\n        opt.urlNewTab = true;\r\n      }\r\n      else if (option.InputAction === PermissionInputActionEnum.Confirm){\r\n        opt.onClick = () => {\r\n          const p = new PermissionClass();\r\n          p.RelatedId = this.table.permissions.RelatedId;\r\n          p.Area = this.table.permissions.Area;\r\n          p.Controller = option.Controller;\r\n          p.Action = option.Action;\r\n          this.table.showConfirm(this.table.l(option.Action + 'Confirm'), this.table.getOptionUrl(option.Url, this.table.permissions.RelatedId, this.row.Data.Id), null, () => {\r\n            this.table.load();\r\n          });\r\n        };\r\n      }\r\n      else if (option.InputAction === PermissionInputActionEnum.OnClick){\r\n        opt.onClick = (btn) => {\r\n          this.table.optionsActions.find(x => x.name === option.Action).onClick(btn);\r\n        };\r\n      }\r\n      opts.push(opt);\r\n    }\r\n    this.options = opts;\r\n    // return (this.addChildren !== null && (this.table.level === null || this.table.level > this.level) ? [this.addChildren] : [])\r\n    //   .concat(this.table.options.filter(x => x.condition == null ||\r\n    //     (x.condition.startsWith('!') ? !this.row.Data[x.condition.substring(1)] : this.row.Data[x.condition])).map((o) => {\r\n    //     const i = HelperClass.clone(o);\r\n    //     if (i.url){\r\n    //       i.url = i.url.replace('{}', this.row.Data.Id);\r\n    //     }\r\n    //     i.row = this.row.Data;\r\n    //     i.class = i.class + ' m-h-5 h-25 d-ib va-m f-u';\r\n    //     return i;\r\n    // })).concat(this.table.hasStatus ? [this.optStatus] : [])\r\n    //     .concat(this.table.permissions.hasAccess('Update') ? [this.optEdit] : [])\r\n    //     .concat(this.table.permissions.hasAccess('Delete') ? [this.optDelete] : []);\r\n  }\r\n  getPermission(parentId, list): any {\r\n    const children = list.filter(item => item.ParentId === parentId);\r\n    return children.reduce((acc, child) => {\r\n      acc.push(child);\r\n      acc.push(...this.getPermission(child.Id, list));\r\n      return acc;\r\n    }, []);\r\n  }\r\n  getCell(col: TableCollClass): any{\r\n    return this.table.getCell(this.row, col);\r\n  }\r\n  getCol(n): string{\r\n    let c = this.row.Data;\r\n    n.split('.').forEach((x) => {\r\n      c = c[x];\r\n    });\r\n    return c;\r\n  }\r\n  edit(opt: InputClass, option: PermissionClass): void{\r\n    this.table.form.isEdit = true;\r\n    if (this.table.permissions.Type === PermissionTypeEnum.Form){\r\n      this.table.form.name = opt.name;\r\n      this.table.form.setData(this.row.Data);\r\n      this.table.form.setButtons(this.table.form.onTop, true, false, true);\r\n      this.table.form.inputs.filter(x => x.inEditDisabled).forEach(x => x.disabled = true);\r\n      this.table.form.inputs.filter(x => !x.inEditVisible).forEach(x => x.visible = false);\r\n      this.table.form.inputs.forEach(x => x.required = x.inEditRequired);\r\n      if (this.table.form.onLoad){\r\n        this.table.form.onLoad(this.row.Data);\r\n      }\r\n    }else{\r\n      const data = new FormData();\r\n      if (this.table.hasChildren){\r\n        data.append('Level', this.level.toString());\r\n      }\r\n      new RequestClass(this.table.environment, this.table.l).send(this.table.getOptionUrl(option.Url.replace('update', 'get'), this.table.permissions.RelatedId, this.row.Data.Id), Method.Post,\r\n        data, opt, (result) => {\r\n          this.table.form.name = opt.name;\r\n          this.table.form.setData(result);\r\n          this.table.form.setButtons(this.table.form.onTop, true, false, true);\r\n          this.table.form.inputs.filter(x => x.inEditDisabled).forEach(x => x.disabled = true);\r\n          this.table.form.inputs.filter(x => !x.inEditVisible).forEach(x => x.visible = false);\r\n          this.table.form.inputs.forEach(x => x.required = x.inEditRequired);\r\n          if (this.table.modal){\r\n            this.table.modal.show(this.row.Data);\r\n          }\r\n          if (this.table.form.onLoad){\r\n            this.table.form.onLoad(result);\r\n          }\r\n        }, () => {});\r\n    }\r\n  }\r\n  getChildren(): any[]{\r\n    return this.row.Data.Id ? this.table.rows.filter(x => x.Data.ParentId === this.row.Data.Id) : [];\r\n  }\r\n  getStatuses(): string{\r\n    return this.row.Statuses && this.row.Statuses.includes(TableRowStatus.Unread) ? 'unread ' : '';\r\n  }\r\n  selectRow(e): void{\r\n    if (this.table.withSelect){\r\n      if ($(e.target).closest('.handle-con').hasClass('handle-con') || $(e.target).closest('.options-cell').hasClass('options-cell')){\r\n        return;\r\n      }\r\n      const s = this.table.rows.find(x => x.selected);\r\n      if (s){\r\n        s.selected = false;\r\n      }\r\n      this.row.selected = true;\r\n      if (this.table.onSelectRow){\r\n        this.table.onSelectRow(this.row.Data);\r\n      }\r\n    }\r\n  }\r\n  dblclickRow(e): void{\r\n    if (this.table.withSelect){\r\n      if ($(e.target).closest('.handle-con').hasClass('handle-con') || $(e.target).closest('.options-cell').hasClass('options-cell')){\r\n        return;\r\n      }\r\n      const s = this.table.rows.find(x => x.selected);\r\n      if (s){\r\n        s.selected = false;\r\n      }\r\n      this.row.selected = true;\r\n      if (this.table.onDblClickRow){\r\n        this.table.onDblClickRow(this.row.Data);\r\n      }\r\n    }\r\n  }\r\n  rightClickRow(e): void{\r\n    e.preventDefault();\r\n    if (this.table.withSelect && this.table.onRightClickRow){\r\n      this.table.onRightClickRow(this.row.Data);\r\n    }\r\n  }\r\n  @HostListener('contextmenu', ['$event'])\r\n  onContextMenu(event: MouseEvent): void {\r\n    event.preventDefault(); // Prevents the default context menu for the entire component\r\n  }\r\n}\r\n"]}