aril 1.1.73 → 1.1.74

package/esm2022/ui/table/index.mjs

@@ -0,0 +1,131 @@
+import { JsonPipe, KeyValuePipe, NgFor, NgForOf, NgStyle, NgTemplateOutlet, SlicePipe } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { ButtonModule } from 'primeng/button';
+import { DropdownModule } from 'primeng/dropdown';
+import { CheckIcon } from 'primeng/icons/check';
+import { MenuModule } from 'primeng/menu';
+import { OrderListModule } from 'primeng/orderlist';
+import { OverlayPanelModule } from 'primeng/overlaypanel';
+import { SidebarModule } from 'primeng/sidebar';
+import { TableModule } from 'primeng/table';
+import { ToastModule } from 'primeng/toast';
+import { TooltipModule } from 'primeng/tooltip';
+import { ButtonComponent } from 'aril/ui/button';
+import { CalendarComponent } from 'aril/ui/calendar';
+import { CheckboxComponent } from 'aril/ui/checkbox';
+import { FieldComponent } from 'aril/ui/field';
+import { ARiLFormModule } from 'aril/ui/form';
+import { NumberComponent } from 'aril/ui/number';
+import { RadioButtonComponent } from 'aril/ui/radioButton';
+import { TextComponent } from 'aril/ui/text';
+import { ValueComponent } from 'aril/ui/value';
+import { GetColumnByFieldPipe, ParsePipe, SafePipe } from 'aril/util/pipes';
+import { ExportOverlayPanelComponent } from './src/export-overlay-panel.component';
+import { TableColumnComponent } from './src/table-column.component';
+import { TableComponent } from './src/table.component';
+import * as i0 from "@angular/core";
+export * from './src/interfaces';
+export * from './src/table-column.component';
+export * from './src/table.component';
+export * from './src/export-overlay-panel.component';
+const components = [TableComponent, TableColumnComponent];
+export class ARiLTableModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ARiLTableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: ARiLTableModule, declarations: [TableComponent, TableColumnComponent], imports: [ARiLFormModule,
+            ButtonComponent,
+            ButtonModule,
+            CalendarComponent,
+            CheckboxComponent,
+            CheckIcon,
+            DropdownModule,
+            FieldComponent,
+            FormsModule,
+            GetColumnByFieldPipe,
+            JsonPipe,
+            KeyValuePipe,
+            MenuModule,
+            NgFor,
+            NgForOf,
+            NgStyle,
+            NgTemplateOutlet,
+            NumberComponent,
+            OrderListModule,
+            OverlayPanelModule,
+            ParsePipe,
+            RadioButtonComponent,
+            ReactiveFormsModule,
+            SafePipe,
+            SidebarModule,
+            TableModule,
+            TextComponent,
+            ToastModule,
+            TooltipModule,
+            ValueComponent,
+            ExportOverlayPanelComponent,
+            SlicePipe], exports: [TableComponent, TableColumnComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ARiLTableModule, imports: [ARiLFormModule,
+            ButtonComponent,
+            ButtonModule,
+            CalendarComponent,
+            CheckboxComponent,
+            CheckIcon,
+            DropdownModule,
+            FieldComponent,
+            FormsModule,
+            MenuModule,
+            NumberComponent,
+            OrderListModule,
+            OverlayPanelModule,
+            RadioButtonComponent,
+            ReactiveFormsModule,
+            SidebarModule,
+            TableModule,
+            TextComponent,
+            ToastModule,
+            TooltipModule,
+            ValueComponent,
+            ExportOverlayPanelComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ARiLTableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        ARiLFormModule,
+                        ButtonComponent,
+                        ButtonModule,
+                        CalendarComponent,
+                        CheckboxComponent,
+                        CheckIcon,
+                        DropdownModule,
+                        FieldComponent,
+                        FormsModule,
+                        GetColumnByFieldPipe,
+                        JsonPipe,
+                        KeyValuePipe,
+                        MenuModule,
+                        NgFor,
+                        NgForOf,
+                        NgStyle,
+                        NgTemplateOutlet,
+                        NumberComponent,
+                        OrderListModule,
+                        OverlayPanelModule,
+                        ParsePipe,
+                        RadioButtonComponent,
+                        ReactiveFormsModule,
+                        SafePipe,
+                        SidebarModule,
+                        TableModule,
+                        TextComponent,
+                        ToastModule,
+                        TooltipModule,
+                        ValueComponent,
+                        ExportOverlayPanelComponent,
+                        SlicePipe
+                    ],
+                    exports: [components],
+                    declarations: [components]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/ui/table/src/export-overlay-panel.component.mjs

@@ -0,0 +1,321 @@
+import { Component, ViewChild, effect, input, signal } from '@angular/core';
+import { FormsModule, ReactiveFormsModule, Validators } from '@angular/forms';
+import { OrderListModule } from 'primeng/orderlist';
+import { OverlayPanel, OverlayPanelModule } from 'primeng/overlaypanel';
+import { ToastModule } from 'primeng/toast';
+import { TooltipModule } from 'primeng/tooltip';
+import { saveAs } from 'file-saver';
+import { catchError, concatMap, filter, finalize, firstValueFrom, from, interval, map, switchMap, take, throwError, toArray } from 'rxjs';
+import { API_CONFIGS } from 'aril/boot/config/api';
+import { ButtonComponent } from 'aril/ui/button';
+import { CheckboxComponent } from 'aril/ui/checkbox';
+import { FieldComponent } from 'aril/ui/field';
+import { ARiLFormModule } from 'aril/ui/form';
+import { RadioButtonComponent } from 'aril/ui/radioButton';
+import { TextComponent } from 'aril/ui/text';
+import { ExportType } from './interfaces';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/forms";
+import * as i3 from "primeng/api";
+import * as i4 from "@ngneat/transloco";
+import * as i5 from "aril/theme/layout";
+import * as i6 from "aril/ui/form";
+import * as i7 from "primeng/orderlist";
+import * as i8 from "primeng/overlaypanel";
+export class ExportOverlayPanelComponent {
+    constructor(http, fb, messageService, translocoService, selectionGroupService) {
+        this.http = http;
+        this.fb = fb;
+        this.messageService = messageService;
+        this.translocoService = translocoService;
+        this.selectionGroupService = selectionGroupService;
+        /**
+         * @see {@link ExportOptions}
+         */
+        this.exportConfig = input.required();
+        this.columns = input();
+        this.exportTypeOptions = [
+            { key: ExportType.Excel, label: 'Excel', fileExtension: '.xlsx' },
+            { key: ExportType.Csv, label: 'Csv', fileExtension: '.csv' }
+        ];
+        this.isLoadingForExport = signal(false);
+        this.isAllSelected = true;
+        this.toggleExport = (event) => this.op.toggle(event);
+        effect(() => {
+            if (this.exportConfig()) {
+                this.createExportForm();
+            }
+        });
+    }
+    createExportForm() {
+        const { exportLabel } = this.exportConfig();
+        this.exportForm = this.fb.group({
+            exportType: this.fb.control(ExportType.Excel, Validators.required),
+            exportLabel: this.fb.control(exportLabel, Validators.required),
+            columns: this.fb.array([])
+        });
+        this.columns()
+            ?._results.filter((col) => col.type() !== 'operations')
+            .filter((col) => {
+            const exportConfig = this.exportConfig();
+            const excludedFields = exportConfig?.excludedFields ?? [];
+            return !excludedFields.includes(col.field());
+        })
+            .forEach((col) => {
+            const colGroup = this.fb.group({
+                checked: this.fb.control(true),
+                title: this.fb.control(col.header()),
+                dataKey: this.fb.control(col.field())
+            });
+            this.exportForm.controls.columns.push(colGroup);
+        });
+        this.exportForm.controls.columns.valueChanges.subscribe((t) => (this.isAllSelected = t.every((a) => a.checked)));
+    }
+    get hostUrl() {
+        return `${globalThis.location.protocol}//${globalThis.location.host}`;
+    }
+    get currentPageReportText() {
+        const total = this.translocoService.translate('table.total');
+        const record = this.translocoService.translate('table.records');
+        const page = this.translocoService.translate('table.page');
+        return `${total} : {totalRecords} ${record} | ${page} : {currentPage} / {totalPages}`;
+    }
+    async export() {
+        const { exportType, exportLabel, columns } = this.exportForm.value;
+        const { route, params, pageSize, columnFieldValueMap, dateColumnFormatMap, computedColumnMap, customReqUrl, numberColumnScaleMap, treeChildName, headerNames, outputFields } = this.exportConfig();
+        const checkedColumns = columns.filter((t) => t.checked);
+        const fileExtension = this.exportTypeOptions.find((t) => t.key === exportType)?.fileExtension;
+        let columnFieldValueMapObj;
+        this.isLoadingForExport.set(true);
+        this.exportForm.disable();
+        this.messageService.add({
+            severity: 'success',
+            key: 'export-toast',
+            summary: this.translocoService.translate('messages.exporting'),
+            detail: this.translocoService.translate('messages.exportingDetail', {
+                url: `${this.hostUrl}/#/mng/control-management/export-requests`
+            }),
+            life: 10 * 1000
+        });
+        this.op?.hide();
+        if (columnFieldValueMap) {
+            const tempObj = {};
+            await firstValueFrom(from(Object.entries(columnFieldValueMap)).pipe(concatMap(([fieldName, value]) => {
+                if (!this.selectionGroupService.selectionGroups()[`${value.groupName}~${value.parentSelectionKey ?? 'ALL'}`]) {
+                    this.selectionGroupService.fetchEnum(value.groupName, value.parentSelectionKey);
+                }
+                const key = value.groupName + '~' + (value.parentSelectionKey ?? 'ALL');
+                return interval(10).pipe(filter(() => !this.selectionGroupService.isLoading(key)), take(1), map(() => {
+                    const selectionGroup = this.selectionGroupService.selectionGroups()[key];
+                    if (selectionGroup) {
+                        tempObj[fieldName] = selectionGroup.selectionItems.reduce((acc, item) => {
+                            acc[item.selectionKey] = item.selectionDisplay;
+                            return acc;
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        }, {});
+                    }
+                }));
+            }), toArray(), finalize(() => {
+                columnFieldValueMapObj = tempObj;
+            })));
+        }
+        const request = {
+            route: route,
+            params: params,
+            pageSize: pageSize,
+            exportType: exportType,
+            exportLabel: exportLabel,
+            computedColumnMap: computedColumnMap,
+            dateColumnFormatMap: dateColumnFormatMap,
+            columnFieldValueMap: columnFieldValueMapObj,
+            numberColumnScaleMap: numberColumnScaleMap ?? {},
+            headerNames: headerNames ?? checkedColumns.map((col) => col.title),
+            outputFields: outputFields ?? checkedColumns.map((col) => col.dataKey),
+            treeChildName: treeChildName
+        };
+        const apiUrl = customReqUrl ? API_CONFIGS.api.replace(/\/[^\/]+\/v1$/, `/${customReqUrl}/v1`) : API_CONFIGS.api;
+        const response = await firstValueFrom(this.http.post(`${apiUrl}/batch-exporters/export`, request).pipe(switchMap((res) => this.http.get(`${apiUrl}/bucket-objects/download`, {
+            params: { url: res.url },
+            responseType: 'blob'
+        })), catchError((error) => {
+            this.isLoadingForExport.set(false);
+            this.exportForm.enable();
+            if (error?.status === 400 || error?.status === 500) {
+                this.messageService.add({
+                    severity: 'error',
+                    summary: this.translocoService.translate('messages.exportUrlNotFound'),
+                    key: 'toast-root'
+                });
+            }
+            return throwError(() => error);
+        })));
+        saveAs(response, `${exportLabel}-${new Date().getTime()}${fileExtension}`);
+        this.isLoadingForExport.set(false);
+        this.exportForm.enable();
+        this.exportForm.reset();
+    }
+    onSelectAll(value) {
+        for (let i = 0; i < this.exportForm.controls.columns.length; i++) {
+            const formGroup = this.exportForm.controls.columns.at(i);
+            formGroup.controls.checked.setValue(value);
+        }
+    }
+    nativateToExportRequests() {
+        window.location.href = `${this.hostUrl}/#/mng/control-management/export-requests`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ExportOverlayPanelComponent, deps: [{ token: i1.HttpClient }, { token: i2.NonNullableFormBuilder }, { token: i3.MessageService }, { token: i4.TranslocoService }, { token: i5.SelectionGroupService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.1.2", type: ExportOverlayPanelComponent, isStandalone: true, selector: "aril-export-overlay-panel", inputs: { exportConfig: { classPropertyName: "exportConfig", publicName: "exportConfig", isSignal: true, isRequired: true, transformFunction: null }, columns: { classPropertyName: "columns", publicName: "columns", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "op", first: true, predicate: OverlayPanel, descendants: true }], ngImport: i0, template: `
+		<p-overlayPanel styleClass="export-overlay-panel" [baseZIndex]="1101">
+			@if (exportForm) {
+				<aril-form [formGroup]="exportForm" class="w-20rem">
+					<aril-field [label]="'Dosya Tipi'" [cols]="{ default: 12 }">
+						<aril-radio-button formControlName="exportType" [options]="exportTypeOptions" />
+					</aril-field>
+
+					<aril-field [label]="'Dosya İsmi'" [cols]="{ default: 12 }">
+						<aril-text class="w-full" formControlName="exportLabel" />
+					</aril-field>
+
+					@if (exportForm.controls.columns.length) {
+						<ng-container formArrayName="columns">
+							<p-orderList
+								#orderListRef
+								class="col-12"
+								[value]="exportForm.controls.columns.controls"
+								[listStyle]="{ 'max-height': '20rem' }"
+								filterBy="value.title"
+								[disabled]="isLoadingForExport()">
+								<ng-template pTemplate="filter">
+									<div class="flex align-items-center gap-3">
+										<aril-checkbox
+											[label]="''"
+											[ngModel]="isAllSelected"
+											[ngModelOptions]="{ standalone: true }"
+											(ngModelChange)="onSelectAll($event)"
+											[disabled]="isLoadingForExport()" />
+
+										<div class="p-orderlist-filter" [attr.data-pc-section]="'filter'">
+											<input
+												#filter
+												type="text"
+												role="textbox"
+												(keyup)="orderListRef.onFilterKeyup($event)"
+												[disabled]="orderListRef.disabled"
+												class="p-orderlist-filter-input p-inputtext p-component" />
+										</div>
+									</div>
+								</ng-template>
+								<ng-template let-col pTemplate="item">
+									<aril-checkbox [label]="col.value.title" [formControl]="col.controls.checked" />
+								</ng-template>
+							</p-orderList>
+						</ng-container>
+					}
+
+					<aril-button
+						class="col-12"
+						[label]="translocoService.translate('navigateToExportRequests')"
+						color="secondary"
+						(clickEvent)="nativateToExportRequests()" />
+
+					<aril-button
+						class="col-12"
+						[label]="translocoService.translate('messages.export')"
+						color="primary"
+						(clickEvent)="export()"
+						[disabled]="isLoadingForExport()" />
+				</aril-form>
+			}
+		</p-overlayPanel>
+	`, isInline: true, dependencies: [{ kind: "ngmodule", type: ARiLFormModule }, { kind: "component", type: i6.FormComponent, selector: "aril-form", inputs: ["formGroup"] }, { kind: "component", type: ButtonComponent, selector: "aril-button:not([click])", inputs: ["label", "loading", "disabled", "raised", "rounded", "text", "outlined", "badge", "size", "icon", "iconPos", "color"], outputs: ["clickEvent"] }, { kind: "component", type: CheckboxComponent, selector: "aril-checkbox[ngModel], aril-checkbox[formControl], aril-checkbox[formControlName]", inputs: ["label", "labelAsYesNo", "tabindex"] }, { kind: "component", type: FieldComponent, selector: "aril-field", inputs: ["label", "color", "labelWidth", "valueWidth", "labelPos", "markAsRequired", "cols", "infoData", "infoDataOverlayPanel"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: OrderListModule }, { kind: "component", type: i7.OrderList, selector: "p-orderList", inputs: ["header", "style", "styleClass", "tabindex", "ariaLabel", "ariaLabelledBy", "listStyle", "responsive", "filterBy", "filterPlaceholder", "filterLocale", "metaKeySelection", "dragdrop", "controlsPosition", "ariaFilterLabel", "filterMatchMode", "breakpoint", "stripedRows", "disabled", "trackBy", "selection", "value"], outputs: ["selectionChange", "onReorder", "onSelectionChange", "onFilterEvent", "onFocus", "onBlur"] }, { kind: "directive", type: i3.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "ngmodule", type: OverlayPanelModule }, { kind: "component", type: i8.OverlayPanel, selector: "p-overlayPanel", inputs: ["ariaLabel", "ariaLabelledBy", "dismissable", "showCloseIcon", "style", "styleClass", "appendTo", "autoZIndex", "ariaCloseLabel", "baseZIndex", "focusOnShow", "showTransitionOptions", "hideTransitionOptions"], outputs: ["onShow", "onHide"] }, { kind: "component", type: RadioButtonComponent, selector: "aril-radio-button[ngModel], aril-radio-button[formControl], aril-radio-button[formControlName]", inputs: ["options", "tabindex", "align"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "directive", type: i2.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i2.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "directive", type: i2.FormArrayName, selector: "[formArrayName]", inputs: ["formArrayName"] }, { kind: "component", type: TextComponent, selector: "aril-text[ngModel], aril-text[formControl], aril-text[formControlName]", inputs: ["placeholder", "tabindex", "icon", "iconPos", "size"] }, { kind: "ngmodule", type: ToastModule }, { kind: "ngmodule", type: TooltipModule }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ExportOverlayPanelComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    selector: 'aril-export-overlay-panel',
+                    imports: [
+                        ARiLFormModule,
+                        ButtonComponent,
+                        CheckboxComponent,
+                        FieldComponent,
+                        FormsModule,
+                        OrderListModule,
+                        OverlayPanelModule,
+                        RadioButtonComponent,
+                        ReactiveFormsModule,
+                        TextComponent,
+                        ToastModule,
+                        TooltipModule
+                    ],
+                    template: `
+		<p-overlayPanel styleClass="export-overlay-panel" [baseZIndex]="1101">
+			@if (exportForm) {
+				<aril-form [formGroup]="exportForm" class="w-20rem">
+					<aril-field [label]="'Dosya Tipi'" [cols]="{ default: 12 }">
+						<aril-radio-button formControlName="exportType" [options]="exportTypeOptions" />
+					</aril-field>
+
+					<aril-field [label]="'Dosya İsmi'" [cols]="{ default: 12 }">
+						<aril-text class="w-full" formControlName="exportLabel" />
+					</aril-field>
+
+					@if (exportForm.controls.columns.length) {
+						<ng-container formArrayName="columns">
+							<p-orderList
+								#orderListRef
+								class="col-12"
+								[value]="exportForm.controls.columns.controls"
+								[listStyle]="{ 'max-height': '20rem' }"
+								filterBy="value.title"
+								[disabled]="isLoadingForExport()">
+								<ng-template pTemplate="filter">
+									<div class="flex align-items-center gap-3">
+										<aril-checkbox
+											[label]="''"
+											[ngModel]="isAllSelected"
+											[ngModelOptions]="{ standalone: true }"
+											(ngModelChange)="onSelectAll($event)"
+											[disabled]="isLoadingForExport()" />
+
+										<div class="p-orderlist-filter" [attr.data-pc-section]="'filter'">
+											<input
+												#filter
+												type="text"
+												role="textbox"
+												(keyup)="orderListRef.onFilterKeyup($event)"
+												[disabled]="orderListRef.disabled"
+												class="p-orderlist-filter-input p-inputtext p-component" />
+										</div>
+									</div>
+								</ng-template>
+								<ng-template let-col pTemplate="item">
+									<aril-checkbox [label]="col.value.title" [formControl]="col.controls.checked" />
+								</ng-template>
+							</p-orderList>
+						</ng-container>
+					}
+
+					<aril-button
+						class="col-12"
+						[label]="translocoService.translate('navigateToExportRequests')"
+						color="secondary"
+						(clickEvent)="nativateToExportRequests()" />
+
+					<aril-button
+						class="col-12"
+						[label]="translocoService.translate('messages.export')"
+						color="primary"
+						(clickEvent)="export()"
+						[disabled]="isLoadingForExport()" />
+				</aril-form>
+			}
+		</p-overlayPanel>
+	`
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.NonNullableFormBuilder }, { type: i3.MessageService }, { type: i4.TranslocoService }, { type: i5.SelectionGroupService }], propDecorators: { op: [{
+                type: ViewChild,
+                args: [OverlayPanel]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"export-overlay-panel.component.js","sourceRoot":"","sources":["../../../../../projects/aril/ui/table/src/export-overlay-panel.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Component, ViewChild, effect, input, signal } from '@angular/core';\r\nimport { FormGroup, FormsModule, NonNullableFormBuilder, ReactiveFormsModule, Validators } from '@angular/forms';\r\n\r\nimport { MessageService } from 'primeng/api';\r\nimport { OrderListModule } from 'primeng/orderlist';\r\nimport { OverlayPanel, OverlayPanelModule } from 'primeng/overlaypanel';\r\nimport { ToastModule } from 'primeng/toast';\r\nimport { TooltipModule } from 'primeng/tooltip';\r\n\r\nimport { TranslocoService } from '@ngneat/transloco';\r\nimport { saveAs } from 'file-saver';\r\nimport {\r\n\tcatchError,\r\n\tconcatMap,\r\n\tfilter,\r\n\tfinalize,\r\n\tfirstValueFrom,\r\n\tfrom,\r\n\tinterval,\r\n\tmap,\r\n\tswitchMap,\r\n\ttake,\r\n\tthrowError,\r\n\ttoArray\r\n} from 'rxjs';\r\n\r\nimport { API_CONFIGS } from 'aril/boot/config/api';\r\nimport { SelectionGroupService } from 'aril/theme/layout';\r\nimport { ButtonComponent } from 'aril/ui/button';\r\nimport { CheckboxComponent } from 'aril/ui/checkbox';\r\nimport { FieldComponent } from 'aril/ui/field';\r\nimport { ARiLFormModule } from 'aril/ui/form';\r\nimport { RadioButtonComponent } from 'aril/ui/radioButton';\r\nimport { TextComponent } from 'aril/ui/text';\r\n\r\nimport {\r\n\tColForm,\r\n\tColumnFieldValueMap,\r\n\tExportForm,\r\n\tExportOptions,\r\n\tExportRequest,\r\n\tExportType,\r\n\tTableColumns\r\n} from './interfaces';\r\n\r\n@Component({\r\n\tstandalone: true,\r\n\tselector: 'aril-export-overlay-panel',\r\n\timports: [\r\n\t\tARiLFormModule,\r\n\t\tButtonComponent,\r\n\t\tCheckboxComponent,\r\n\t\tFieldComponent,\r\n\t\tFormsModule,\r\n\t\tOrderListModule,\r\n\t\tOverlayPanelModule,\r\n\t\tRadioButtonComponent,\r\n\t\tReactiveFormsModule,\r\n\t\tTextComponent,\r\n\t\tToastModule,\r\n\t\tTooltipModule\r\n\t],\r\n\ttemplate: `\r\n\t\t<p-overlayPanel styleClass=\"export-overlay-panel\" [baseZIndex]=\"1101\">\r\n\t\t\t@if (exportForm) {\r\n\t\t\t\t<aril-form [formGroup]=\"exportForm\" class=\"w-20rem\">\r\n\t\t\t\t\t<aril-field [label]=\"'Dosya Tipi'\" [cols]=\"{ default: 12 }\">\r\n\t\t\t\t\t\t<aril-radio-button formControlName=\"exportType\" [options]=\"exportTypeOptions\" />\r\n\t\t\t\t\t</aril-field>\r\n\r\n\t\t\t\t\t<aril-field [label]=\"'Dosya İsmi'\" [cols]=\"{ default: 12 }\">\r\n\t\t\t\t\t\t<aril-text class=\"w-full\" formControlName=\"exportLabel\" />\r\n\t\t\t\t\t</aril-field>\r\n\r\n\t\t\t\t\t@if (exportForm.controls.columns.length) {\r\n\t\t\t\t\t\t<ng-container formArrayName=\"columns\">\r\n\t\t\t\t\t\t\t<p-orderList\r\n\t\t\t\t\t\t\t\t#orderListRef\r\n\t\t\t\t\t\t\t\tclass=\"col-12\"\r\n\t\t\t\t\t\t\t\t[value]=\"exportForm.controls.columns.controls\"\r\n\t\t\t\t\t\t\t\t[listStyle]=\"{ 'max-height': '20rem' }\"\r\n\t\t\t\t\t\t\t\tfilterBy=\"value.title\"\r\n\t\t\t\t\t\t\t\t[disabled]=\"isLoadingForExport()\">\r\n\t\t\t\t\t\t\t\t<ng-template pTemplate=\"filter\">\r\n\t\t\t\t\t\t\t\t\t<div class=\"flex align-items-center gap-3\">\r\n\t\t\t\t\t\t\t\t\t\t<aril-checkbox\r\n\t\t\t\t\t\t\t\t\t\t\t[label]=\"''\"\r\n\t\t\t\t\t\t\t\t\t\t\t[ngModel]=\"isAllSelected\"\r\n\t\t\t\t\t\t\t\t\t\t\t[ngModelOptions]=\"{ standalone: true }\"\r\n\t\t\t\t\t\t\t\t\t\t\t(ngModelChange)=\"onSelectAll($event)\"\r\n\t\t\t\t\t\t\t\t\t\t\t[disabled]=\"isLoadingForExport()\" />\r\n\r\n\t\t\t\t\t\t\t\t\t\t<div class=\"p-orderlist-filter\" [attr.data-pc-section]=\"'filter'\">\r\n\t\t\t\t\t\t\t\t\t\t\t<input\r\n\t\t\t\t\t\t\t\t\t\t\t\t#filter\r\n\t\t\t\t\t\t\t\t\t\t\t\ttype=\"text\"\r\n\t\t\t\t\t\t\t\t\t\t\t\trole=\"textbox\"\r\n\t\t\t\t\t\t\t\t\t\t\t\t(keyup)=\"orderListRef.onFilterKeyup($event)\"\r\n\t\t\t\t\t\t\t\t\t\t\t\t[disabled]=\"orderListRef.disabled\"\r\n\t\t\t\t\t\t\t\t\t\t\t\tclass=\"p-orderlist-filter-input p-inputtext p-component\" />\r\n\t\t\t\t\t\t\t\t\t\t</div>\r\n\t\t\t\t\t\t\t\t\t</div>\r\n\t\t\t\t\t\t\t\t</ng-template>\r\n\t\t\t\t\t\t\t\t<ng-template let-col pTemplate=\"item\">\r\n\t\t\t\t\t\t\t\t\t<aril-checkbox [label]=\"col.value.title\" [formControl]=\"col.controls.checked\" />\r\n\t\t\t\t\t\t\t\t</ng-template>\r\n\t\t\t\t\t\t\t</p-orderList>\r\n\t\t\t\t\t\t</ng-container>\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t<aril-button\r\n\t\t\t\t\t\tclass=\"col-12\"\r\n\t\t\t\t\t\t[label]=\"translocoService.translate('navigateToExportRequests')\"\r\n\t\t\t\t\t\tcolor=\"secondary\"\r\n\t\t\t\t\t\t(clickEvent)=\"nativateToExportRequests()\" />\r\n\r\n\t\t\t\t\t<aril-button\r\n\t\t\t\t\t\tclass=\"col-12\"\r\n\t\t\t\t\t\t[label]=\"translocoService.translate('messages.export')\"\r\n\t\t\t\t\t\tcolor=\"primary\"\r\n\t\t\t\t\t\t(clickEvent)=\"export()\"\r\n\t\t\t\t\t\t[disabled]=\"isLoadingForExport()\" />\r\n\t\t\t\t</aril-form>\r\n\t\t\t}\r\n\t\t</p-overlayPanel>\r\n\t`\r\n})\r\nexport class ExportOverlayPanelComponent {\r\n\t@ViewChild(OverlayPanel) op!: OverlayPanel;\r\n\r\n\t/**\r\n\t * @see {@link ExportOptions}\r\n\t */\r\n\texportConfig = input.required<ExportOptions>();\r\n\tcolumns = input<TableColumns>();\r\n\r\n\texportForm!: FormGroup<ExportForm>;\r\n\texportTypeOptions = [\r\n\t\t{ key: ExportType.Excel, label: 'Excel', fileExtension: '.xlsx' },\r\n\t\t{ key: ExportType.Csv, label: 'Csv', fileExtension: '.csv' }\r\n\t];\r\n\tisLoadingForExport = signal<boolean>(false);\r\n\tisAllSelected = true;\r\n\r\n\tconstructor(\r\n\t\tprivate http: HttpClient,\r\n\t\tprivate fb: NonNullableFormBuilder,\r\n\t\tprivate messageService: MessageService,\r\n\t\tpublic translocoService: TranslocoService,\r\n\t\tprivate selectionGroupService: SelectionGroupService\r\n\t) {\r\n\t\teffect(() => {\r\n\t\t\tif (this.exportConfig()) {\r\n\t\t\t\tthis.createExportForm();\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\tprivate createExportForm(): void {\r\n\t\tconst { exportLabel } = this.exportConfig()!;\r\n\r\n\t\tthis.exportForm = this.fb.group<ExportForm>({\r\n\t\t\texportType: this.fb.control(ExportType.Excel, Validators.required),\r\n\t\t\texportLabel: this.fb.control(exportLabel, Validators.required),\r\n\t\t\tcolumns: this.fb.array<FormGroup<ColForm>>([])\r\n\t\t});\r\n\r\n\t\tthis.columns()\r\n\t\t\t?._results.filter((col) => col.type() !== 'operations')\r\n\t\t\t.filter((col) => {\r\n\t\t\t\tconst exportConfig = this.exportConfig();\r\n\t\t\t\tconst excludedFields = exportConfig?.excludedFields ?? [];\r\n\r\n\t\t\t\treturn !excludedFields.includes(col.field());\r\n\t\t\t})\r\n\t\t\t.forEach((col) => {\r\n\t\t\t\tconst colGroup = this.fb.group<ColForm>({\r\n\t\t\t\t\tchecked: this.fb.control(true),\r\n\t\t\t\t\ttitle: this.fb.control(col.header()),\r\n\t\t\t\t\tdataKey: this.fb.control(col.field())\r\n\t\t\t\t});\r\n\r\n\t\t\t\tthis.exportForm.controls.columns.push(colGroup);\r\n\t\t\t});\r\n\r\n\t\tthis.exportForm.controls.columns.valueChanges.subscribe((t) => (this.isAllSelected = t.every((a) => a.checked)));\r\n\t}\r\n\r\n\tget hostUrl(): string {\r\n\t\treturn `${globalThis.location.protocol}//${globalThis.location.host}`;\r\n\t}\r\n\r\n\tget currentPageReportText(): string {\r\n\t\tconst total = this.translocoService.translate('table.total');\r\n\t\tconst record = this.translocoService.translate('table.records');\r\n\t\tconst page = this.translocoService.translate('table.page');\r\n\t\treturn `${total} : {totalRecords} ${record} | ${page} : {currentPage} / {totalPages}`;\r\n\t}\r\n\r\n\tasync export() {\r\n\t\tconst { exportType, exportLabel, columns } = this.exportForm.value;\r\n\t\tconst {\r\n\t\t\troute,\r\n\t\t\tparams,\r\n\t\t\tpageSize,\r\n\t\t\tcolumnFieldValueMap,\r\n\t\t\tdateColumnFormatMap,\r\n\t\t\tcomputedColumnMap,\r\n\t\t\tcustomReqUrl,\r\n\t\t\tnumberColumnScaleMap,\r\n\t\t\ttreeChildName,\r\n\t\t\theaderNames,\r\n\t\t\toutputFields\r\n\t\t} = this.exportConfig()!;\r\n\r\n\t\tconst checkedColumns = columns!.filter((t) => t.checked);\r\n\t\tconst fileExtension = this.exportTypeOptions.find((t) => t.key === exportType)?.fileExtension;\r\n\r\n\t\tlet columnFieldValueMapObj: ColumnFieldValueMap | undefined;\r\n\r\n\t\tthis.isLoadingForExport.set(true);\r\n\t\tthis.exportForm.disable();\r\n\r\n\t\tthis.messageService.add({\r\n\t\t\tseverity: 'success',\r\n\t\t\tkey: 'export-toast',\r\n\t\t\tsummary: this.translocoService.translate('messages.exporting'),\r\n\t\t\tdetail: this.translocoService.translate('messages.exportingDetail', {\r\n\t\t\t\turl: `${this.hostUrl}/#/mng/control-management/export-requests`\r\n\t\t\t}),\r\n\t\t\tlife: 10 * 1000\r\n\t\t});\r\n\t\tthis.op?.hide();\r\n\r\n\t\tif (columnFieldValueMap) {\r\n\t\t\tconst tempObj = {} as ColumnFieldValueMap;\r\n\r\n\t\t\tawait firstValueFrom(\r\n\t\t\t\tfrom(Object.entries(columnFieldValueMap)).pipe(\r\n\t\t\t\t\tconcatMap(([fieldName, value]) => {\r\n\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\t!this.selectionGroupService.selectionGroups()[`${value.groupName}~${value.parentSelectionKey ?? 'ALL'}`]\r\n\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\tthis.selectionGroupService.fetchEnum(value.groupName, value.parentSelectionKey);\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tconst key = value.groupName + '~' + (value.parentSelectionKey ?? 'ALL');\r\n\r\n\t\t\t\t\t\treturn interval(10).pipe(\r\n\t\t\t\t\t\t\tfilter(() => !this.selectionGroupService.isLoading(key)),\r\n\t\t\t\t\t\t\ttake(1),\r\n\t\t\t\t\t\t\tmap(() => {\r\n\t\t\t\t\t\t\t\tconst selectionGroup = this.selectionGroupService.selectionGroups()[key];\r\n\t\t\t\t\t\t\t\tif (selectionGroup) {\r\n\t\t\t\t\t\t\t\t\ttempObj[fieldName] = selectionGroup.selectionItems.reduce((acc: Record<string, string>, item) => {\r\n\t\t\t\t\t\t\t\t\t\tacc[item.selectionKey] = item.selectionDisplay;\r\n\t\t\t\t\t\t\t\t\t\treturn acc;\r\n\t\t\t\t\t\t\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n\t\t\t\t\t\t\t\t\t}, {}) as any;\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t})\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t}),\r\n\t\t\t\t\ttoArray(),\r\n\t\t\t\t\tfinalize(() => {\r\n\t\t\t\t\t\tcolumnFieldValueMapObj = tempObj;\r\n\t\t\t\t\t})\r\n\t\t\t\t)\r\n\t\t\t);\r\n\t\t}\r\n\r\n\t\tconst request: ExportRequest = {\r\n\t\t\troute: route!,\r\n\t\t\tparams: params!,\r\n\t\t\tpageSize: pageSize!,\r\n\t\t\texportType: exportType!,\r\n\t\t\texportLabel: exportLabel!,\r\n\t\t\tcomputedColumnMap: computedColumnMap!,\r\n\t\t\tdateColumnFormatMap: dateColumnFormatMap!,\r\n\t\t\tcolumnFieldValueMap: columnFieldValueMapObj!,\r\n\t\t\tnumberColumnScaleMap: numberColumnScaleMap ?? {},\r\n\t\t\theaderNames: headerNames ?? checkedColumns.map((col) => col.title!),\r\n\t\t\toutputFields: outputFields ?? checkedColumns.map((col) => col.dataKey!),\r\n\t\t\ttreeChildName: treeChildName!\r\n\t\t};\r\n\r\n\t\tconst apiUrl = customReqUrl ? API_CONFIGS.api.replace(/\\/[^\\/]+\\/v1$/, `/${customReqUrl}/v1`) : API_CONFIGS.api;\r\n\t\tconst response = await firstValueFrom(\r\n\t\t\tthis.http.post<{ success: boolean; url: string }>(`${apiUrl}/batch-exporters/export`, request).pipe(\r\n\t\t\t\tswitchMap((res) =>\r\n\t\t\t\t\tthis.http.get(`${apiUrl}/bucket-objects/download`, {\r\n\t\t\t\t\t\tparams: { url: res.url },\r\n\t\t\t\t\t\tresponseType: 'blob'\r\n\t\t\t\t\t})\r\n\t\t\t\t),\r\n\t\t\t\tcatchError((error) => {\r\n\t\t\t\t\tthis.isLoadingForExport.set(false);\r\n\t\t\t\t\tthis.exportForm.enable();\r\n\t\t\t\t\tif (error?.status === 400 || error?.status === 500) {\r\n\t\t\t\t\t\tthis.messageService.add({\r\n\t\t\t\t\t\t\tseverity: 'error',\r\n\t\t\t\t\t\t\tsummary: this.translocoService.translate('messages.exportUrlNotFound'),\r\n\t\t\t\t\t\t\tkey: 'toast-root'\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t}\r\n\t\t\t\t\treturn throwError(() => error);\r\n\t\t\t\t})\r\n\t\t\t)\r\n\t\t);\r\n\r\n\t\tsaveAs(response, `${exportLabel}-${new Date().getTime()}${fileExtension}`);\r\n\t\tthis.isLoadingForExport.set(false);\r\n\t\tthis.exportForm.enable();\r\n\t\tthis.exportForm.reset();\r\n\t}\r\n\r\n\tonSelectAll(value: boolean): void {\r\n\t\tfor (let i = 0; i < this.exportForm.controls.columns.length; i++) {\r\n\t\t\tconst formGroup = this.exportForm.controls.columns.at(i);\r\n\t\t\tformGroup.controls.checked.setValue(value);\r\n\t\t}\r\n\t}\r\n\r\n\tnativateToExportRequests() {\r\n\t\twindow.location.href = `${this.hostUrl}/#/mng/control-management/export-requests`;\r\n\t}\r\n\r\n\ttoggleExport = (event: Event): void => this.op.toggle(event);\r\n}\r\n"]}

package/esm2022/ui/table/src/interfaces.mjs

@@ -0,0 +1,44 @@
+export var DateFormat;
+(function (DateFormat) {
+    DateFormat["Hour"] = "HH:mm";
+    DateFormat["Time"] = "dd/MMMM/yyyy HH:mm";
+    DateFormat["Second"] = "dd/MMMM/yyyy HH:mm:ss";
+    DateFormat["Minute"] = "dd/MMMM/yyyy HH:mm";
+    DateFormat["Day"] = "dd/MMMM/yyyy";
+    DateFormat["OnlyDay"] = "dd";
+    DateFormat["Month"] = "MMMM/yyyy";
+    DateFormat["MonthInt"] = "MM/yyyy";
+    DateFormat["OnlyMonth"] = "MMMM";
+    DateFormat["Year"] = "yyyy";
+})(DateFormat || (DateFormat = {}));
+export var ExportType;
+(function (ExportType) {
+    ExportType["Csv"] = "CSV";
+    ExportType["Excel"] = "EXCEL";
+})(ExportType || (ExportType = {}));
+export var FilterOperand;
+(function (FilterOperand) {
+    FilterOperand["EQ"] = "EQ";
+    FilterOperand["NOT_EQ"] = "NOT_EQ";
+    FilterOperand["IS_NULL"] = "IS_NULL";
+    FilterOperand["IS_NOT_NULL"] = "IS_NOT_NULL";
+    FilterOperand["IN"] = "IN";
+    FilterOperand["NOT_IN"] = "NOT_IN";
+    FilterOperand["LT"] = "LT";
+    FilterOperand["GT"] = "GT";
+    FilterOperand["LTE"] = "LTE";
+    FilterOperand["GTE"] = "GTE";
+    FilterOperand["STARTS"] = "STARTS";
+    FilterOperand["ENDS"] = "ENDS";
+    FilterOperand["LIKE"] = "LIKE";
+    FilterOperand["NOT_LIKE"] = "NOT_LIKE";
+})(FilterOperand || (FilterOperand = {}));
+export var ColumnFilterTypeEnum;
+(function (ColumnFilterTypeEnum) {
+    ColumnFilterTypeEnum["TEXT"] = "text";
+    ColumnFilterTypeEnum["NUMERIC"] = "numeric";
+    ColumnFilterTypeEnum["DATE"] = "date";
+    ColumnFilterTypeEnum["BOOLEAN"] = "boolean";
+    ColumnFilterTypeEnum["ENUM"] = "enum";
+})(ColumnFilterTypeEnum || (ColumnFilterTypeEnum = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/ui/table/src/table-column.component.mjs

@@ -0,0 +1,31 @@
+import { Component, ContentChild, TemplateRef, input } from '@angular/core';
+import { ColumnFilterTypeEnum } from './interfaces';
+import * as i0 from "@angular/core";
+export class TableColumnComponent {
+    constructor() {
+        this.type = input('text');
+        this.field = input.required();
+        this.header = input.required();
+        this.tAlign = input();
+        this.isShowHeaderTooltip = input(false);
+        this.tooltipTemplate = input();
+        this.width = input();
+        this.showFilter = input(false);
+        this.filterType = input(ColumnFilterTypeEnum.TEXT);
+        this.showTimeInDateFilters = input(false);
+        this.enumGroupName = input('');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: TableColumnComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "17.1.2", type: TableColumnComponent, selector: "aril-table-column", inputs: { type: { classPropertyName: "type", publicName: "type", isSignal: true, isRequired: false, transformFunction: null }, field: { classPropertyName: "field", publicName: "field", isSignal: true, isRequired: true, transformFunction: null }, header: { classPropertyName: "header", publicName: "header", isSignal: true, isRequired: true, transformFunction: null }, tAlign: { classPropertyName: "tAlign", publicName: "tAlign", isSignal: true, isRequired: false, transformFunction: null }, isShowHeaderTooltip: { classPropertyName: "isShowHeaderTooltip", publicName: "isShowHeaderTooltip", isSignal: true, isRequired: false, transformFunction: null }, tooltipTemplate: { classPropertyName: "tooltipTemplate", publicName: "tooltipTemplate", isSignal: true, isRequired: false, transformFunction: null }, width: { classPropertyName: "width", publicName: "width", isSignal: true, isRequired: false, transformFunction: null }, showFilter: { classPropertyName: "showFilter", publicName: "showFilter", isSignal: true, isRequired: false, transformFunction: null }, filterType: { classPropertyName: "filterType", publicName: "filterType", isSignal: true, isRequired: false, transformFunction: null }, showTimeInDateFilters: { classPropertyName: "showTimeInDateFilters", publicName: "showTimeInDateFilters", isSignal: true, isRequired: false, transformFunction: null }, enumGroupName: { classPropertyName: "enumGroupName", publicName: "enumGroupName", isSignal: true, isRequired: false, transformFunction: null } }, queries: [{ propertyName: "template", first: true, predicate: TemplateRef, descendants: true }], ngImport: i0, template: `<ng-content />`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: TableColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'aril-table-column',
+                    template: `<ng-content />`
+                }]
+        }], propDecorators: { template: [{
+                type: ContentChild,
+                args: [TemplateRef]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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