@valtimo/zgw 12.0.0

package/esm2022/lib/modules/documenten-api/components/documenten-api-columns/documenten-api-columns.component.mjs

@@ -0,0 +1,170 @@
+/*
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ChangeDetectionStrategy, Component, ViewChild, } from '@angular/core';
+import { BehaviorSubject, combineLatest, filter, map, Subject, switchMap, tap, } from 'rxjs';
+import { CarbonListModule, ConfirmationModalModule, MoveRowDirection, PendingChangesComponent, ViewType, } from '@valtimo/components';
+import { DocumentenApiColumnModalComponent } from '../documenten-api-column-modal/documenten-api-column-modal.component';
+import { CommonModule } from '@angular/common';
+import { TranslateModule } from '@ngx-translate/core';
+import { ButtonModule, TagModule } from 'carbon-components-angular';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../services";
+import * as i3 from "@angular/common";
+import * as i4 from "@valtimo/components";
+import * as i5 from "@ngx-translate/core";
+import * as i6 from "carbon-components-angular";
+export class DocumentenApiColumnsComponent extends PendingChangesComponent {
+    get documentDefinitionName$() {
+        return this._documentDefinitionName$;
+    }
+    constructor(route, zgwDocumentColumnService) {
+        super();
+        this.route = route;
+        this.zgwDocumentColumnService = zgwDocumentColumnService;
+        this._reload$ = new BehaviorSubject(null);
+        this._documentDefinitionName$ = this.route.params.pipe(map(params => params?.name), filter(docDefName => !!docDefName));
+        this.loading$ = new BehaviorSubject(true);
+        this.usedKeys$ = new BehaviorSubject([]);
+        this._documentStatuses = [];
+        this.documentStatuses$ = combineLatest([
+            this._documentDefinitionName$,
+            this._reload$,
+        ]).pipe(tap(([_, reload]) => {
+            if (reload === null) {
+                this.loading$.next(true);
+            }
+        }), switchMap(([documentDefinitionName]) => this.zgwDocumentColumnService.getConfiguredColumns(documentDefinitionName)), tap(statuses => {
+            this._documentStatuses = statuses;
+            this.usedKeys$.next(statuses.map(status => status.key));
+            this.loading$.next(false);
+        }));
+        this.fields$ = new BehaviorSubject([]);
+        this.ACTION_ITEMS = [
+            {
+                label: 'interface.edit',
+                callback: this.openEditModal.bind(this),
+                type: 'normal',
+            },
+            {
+                label: 'interface.delete',
+                callback: this.openDeleteModal.bind(this),
+                type: 'danger',
+            },
+        ];
+        this.CARBON_THEME = 'g10';
+        this.statusModalType$ = new BehaviorSubject('closed');
+        this.prefillStatus$ = new BehaviorSubject(undefined);
+        this.columnToUpdate$ = new BehaviorSubject(undefined);
+        this.showDisableModal$ = new Subject();
+        this._documentDefinitionName$.subscribe(documentDefinitionName => {
+            zgwDocumentColumnService.getConfiguredColumns(documentDefinitionName).subscribe(configuredColumns => {
+                console.log(configuredColumns);
+            }, error => {
+                console.error(error);
+            });
+        });
+    }
+    ngAfterViewInit() {
+        this.initFields();
+    }
+    openDeleteModal(status) {
+        this.columnToUpdate$.next(status);
+        this.showDisableModal$.next(true);
+    }
+    openEditModal(status) {
+        this.prefillStatus$.next(status);
+        this.statusModalType$.next('edit');
+    }
+    openAddModal() {
+        this.statusModalType$.next('add');
+    }
+    closeModal(closeModalEvent) {
+        if (closeModalEvent === 'closeAndRefresh') {
+            this.reload();
+        }
+        this.statusModalType$.next('closed');
+    }
+    confirmDeleteStatus(status) {
+        this.documentDefinitionName$
+            .pipe(switchMap(documentDefinitionName => this.zgwDocumentColumnService.deleteConfiguredColumn(documentDefinitionName, status.key)))
+            .subscribe(() => {
+            this.reload();
+        });
+    }
+    onMoveRowClick(event) {
+        const { direction, index } = event;
+        const orderedStatuses = direction === MoveRowDirection.UP
+            ? this.swapStatuses(this._documentStatuses, index - 1, index)
+            : this.swapStatuses(this._documentStatuses, index, index + 1);
+        this.documentDefinitionName$
+            .pipe(switchMap(documentDefinitionName => this.zgwDocumentColumnService.updateConfiguredColumns(documentDefinitionName, orderedStatuses)))
+            .subscribe(() => {
+            this.reload(true);
+        });
+    }
+    reload(noAnimation = false) {
+        this._reload$.next(noAnimation ? 'noAnimation' : null);
+    }
+    swapStatuses(statuses, index1, index2) {
+        const temp = [...statuses];
+        temp[index1] = temp.splice(index2, 1, temp[index1])[0];
+        return temp;
+    }
+    initFields() {
+        this.fields$.next([
+            {
+                key: 'title',
+                label: 'dossierManagement.statuses.columns.title',
+                viewType: ViewType.TEXT,
+            },
+            {
+                key: 'key',
+                label: 'dossierManagement.statuses.columns.key',
+                viewType: ViewType.TEXT,
+            },
+            {
+                key: 'visibleInCaseListByDefault',
+                label: 'dossierManagement.statuses.columns.visible',
+                viewType: ViewType.BOOLEAN,
+            },
+            {
+                viewType: ViewType.TEMPLATE,
+                template: this.colorColumnTemplate,
+                key: 'color',
+                label: 'dossierManagement.statuses.columns.color',
+            },
+        ]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: DocumentenApiColumnsComponent, deps: [{ token: i1.ActivatedRoute }, { token: i2.DocumentenApiColumnService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.3", type: DocumentenApiColumnsComponent, isStandalone: true, selector: "valtimo-documenten-api-columns", viewQueries: [{ propertyName: "colorColumnTemplate", first: true, predicate: ["colorColumnTemplate"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<!--\n  ~ Copyright 2015-2024 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<valtimo-carbon-list\n  *ngIf=\"{\n    loading: loading$ | async,\n    documentStatuses: documentStatuses$ | async\n  } as obs\"\n  [fields]=\"fields$ | async\"\n  [header]=\"false\"\n  [loading]=\"obs.loading\"\n  [movingRowsEnabled]=\"true\"\n  [actionItems]=\"ACTION_ITEMS\"\n  (rowClicked)=\"openEditModal($event)\"\n  (moveRow)=\"onMoveRowClick($event)\"\n>\n  <ng-container\n    carbonToolbarContent\n    *ngTemplateOutlet=\"buttons; context: {obs: obs}\"\n  ></ng-container>\n</valtimo-carbon-list>\n\n<valtimo-documenten-api-column-modal\n  [type]=\"statusModalType$ | async\"\n  [usedKeys]=\"usedKeys$ | async\"\n  [documentDefinitionName]=\"documentDefinitionName$ | async\"\n  (closeModalEvent)=\"closeModal($event)\"\n></valtimo-documenten-api-column-modal>\n\n<valtimo-confirmation-modal\n  confirmButtonTextTranslationKey=\"interface.delete\"\n  confirmButtonType=\"danger\"\n  contentTranslationKey=\"dossierManagement.statuses.deleteText\"\n  [outputOnConfirm]=\"columnToUpdate$ | async\"\n  [showModalSubject$]=\"showDisableModal$\"\n  titleTranslationKey=\"interface.delete\"\n  (confirmEvent)=\"confirmDeleteStatus($event)\"\n></valtimo-confirmation-modal>\n\n<ng-template #buttons let-obs=\"obs\">\n  <div class=\"dossier-management-search-fields__buttons\">\n    <button cdsButton=\"primary\" [disabled]=\"obs.loading\" (click)=\"openAddModal()\">\n      <svg cdsIcon=\"add\" size=\"16\" class=\"cds--btn__icon\"></svg>\n\n      {{ 'dossierManagement.statuses.add' | translate }}\n    </button>\n  </div>\n</ng-template>\n\n<ng-template #colorColumnTemplate let-data=\"data\">\n  <cds-tag class=\"cds-tag--no-margin\" [type]=\"data?.item?.tagType\">\n    {{ 'interface.tagType.' + data?.item?.tagType | translate }}\n  </cds-tag>\n</ng-template>\n", styles: ["::ng-deep .cds-tag--no-margin{margin:0}\n/*!\n * Copyright 2015-2024 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "component", type: DocumentenApiColumnModalComponent, selector: "valtimo-documenten-api-column-modal", inputs: ["type", "prefill", "usedKeys", "documentDefinitionName"], outputs: ["closeModalEvent"] }, { kind: "ngmodule", type: CarbonListModule }, { kind: "component", type: i4.CarbonListComponent, selector: "valtimo-carbon-list", inputs: ["items", "fields", "tableTranslations", "paginatorConfig", "pagination", "loading", "actions", "actionItems", "header", "hideColumnHeader", "initialSortState", "isSearchable", "enableSingleSelection", "lastColumnTemplate", "paginationIdentifier", "showSelectionColumn", "striped", "hideToolbar", "lockedTooltipTranslationKey", "movingRowsEnabled"], outputs: ["rowClicked", "paginationClicked", "paginationSet", "search", "sortChanged", "moveRow", "itemsReordered"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: ConfirmationModalModule }, { kind: "component", type: i4.ConfirmationModalComponent, selector: "valtimo-confirmation-modal", inputs: ["titleTranslationKey", "title", "content", "contentTranslationKey", "confirmButtonText", "confirmButtonTextTranslationKey", "confirmButtonType", "showOptionalButton", "optionalButtonText", "optionalButtonTextTranslationKey", "optionalButtonType", "cancelButtonText", "cancelButtonTextTranslationKey", "cancelButtonType", "showModalSubject$", "outputOnConfirm", "outputOnOptional", "spacerAfterCancelButton"], outputs: ["confirmEvent", "optionalEvent", "cancelEvent"] }, { kind: "ngmodule", type: TagModule }, { kind: "component", type: i6.Tag, selector: "cds-tag, ibm-tag", inputs: ["type", "size", "class"] }, { kind: "ngmodule", type: ButtonModule }, { kind: "directive", type: i6.Button, selector: "[cdsButton], [ibmButton]", inputs: ["ibmButton", "cdsButton", "size", "skeleton", "iconOnly", "isExpressive"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: DocumentenApiColumnsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'valtimo-documenten-api-columns', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                        CommonModule,
+                        DocumentenApiColumnModalComponent,
+                        CarbonListModule,
+                        TranslateModule,
+                        ConfirmationModalModule,
+                        TagModule,
+                        ButtonModule,
+                    ], template: "<!--\n  ~ Copyright 2015-2024 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<valtimo-carbon-list\n  *ngIf=\"{\n    loading: loading$ | async,\n    documentStatuses: documentStatuses$ | async\n  } as obs\"\n  [fields]=\"fields$ | async\"\n  [header]=\"false\"\n  [loading]=\"obs.loading\"\n  [movingRowsEnabled]=\"true\"\n  [actionItems]=\"ACTION_ITEMS\"\n  (rowClicked)=\"openEditModal($event)\"\n  (moveRow)=\"onMoveRowClick($event)\"\n>\n  <ng-container\n    carbonToolbarContent\n    *ngTemplateOutlet=\"buttons; context: {obs: obs}\"\n  ></ng-container>\n</valtimo-carbon-list>\n\n<valtimo-documenten-api-column-modal\n  [type]=\"statusModalType$ | async\"\n  [usedKeys]=\"usedKeys$ | async\"\n  [documentDefinitionName]=\"documentDefinitionName$ | async\"\n  (closeModalEvent)=\"closeModal($event)\"\n></valtimo-documenten-api-column-modal>\n\n<valtimo-confirmation-modal\n  confirmButtonTextTranslationKey=\"interface.delete\"\n  confirmButtonType=\"danger\"\n  contentTranslationKey=\"dossierManagement.statuses.deleteText\"\n  [outputOnConfirm]=\"columnToUpdate$ | async\"\n  [showModalSubject$]=\"showDisableModal$\"\n  titleTranslationKey=\"interface.delete\"\n  (confirmEvent)=\"confirmDeleteStatus($event)\"\n></valtimo-confirmation-modal>\n\n<ng-template #buttons let-obs=\"obs\">\n  <div class=\"dossier-management-search-fields__buttons\">\n    <button cdsButton=\"primary\" [disabled]=\"obs.loading\" (click)=\"openAddModal()\">\n      <svg cdsIcon=\"add\" size=\"16\" class=\"cds--btn__icon\"></svg>\n\n      {{ 'dossierManagement.statuses.add' | translate }}\n    </button>\n  </div>\n</ng-template>\n\n<ng-template #colorColumnTemplate let-data=\"data\">\n  <cds-tag class=\"cds-tag--no-margin\" [type]=\"data?.item?.tagType\">\n    {{ 'interface.tagType.' + data?.item?.tagType | translate }}\n  </cds-tag>\n</ng-template>\n", styles: ["::ng-deep .cds-tag--no-margin{margin:0}\n/*!\n * Copyright 2015-2024 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n"] }]
+        }], ctorParameters: () => [{ type: i1.ActivatedRoute }, { type: i2.DocumentenApiColumnService }], propDecorators: { colorColumnTemplate: [{
+                type: ViewChild,
+                args: ['colorColumnTemplate']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"documenten-api-columns.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/valtimo/zgw/src/lib/modules/documenten-api/components/documenten-api-columns/documenten-api-columns.component.ts","../../../../../../../../../projects/valtimo/zgw/src/lib/modules/documenten-api/components/documenten-api-columns/documenten-api-columns.component.html"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2024 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  TemplateRef,\n  ViewChild,\n} from '@angular/core';\nimport {DocumentenApiColumnService} from '../../services';\nimport {\n  ConfiguredColumn,\n  DocumentenApiColumnModalType,\n  DocumentenApiColumnModalTypeCloseEvent,\n} from '../../models';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  filter,\n  map,\n  Observable,\n  Subject,\n  switchMap,\n  tap,\n} from 'rxjs';\nimport {ActivatedRoute} from '@angular/router';\nimport {\n  ActionItem,\n  CarbonListModule,\n  ColumnConfig,\n  ConfirmationModalModule,\n  MoveRowDirection,\n  MoveRowEvent,\n  PendingChangesComponent,\n  ViewType,\n} from '@valtimo/components';\nimport {DocumentenApiColumnModalComponent} from '../documenten-api-column-modal/documenten-api-column-modal.component';\nimport {CommonModule} from '@angular/common';\nimport {TranslateModule} from '@ngx-translate/core';\nimport {ButtonModule, TagModule} from 'carbon-components-angular';\n\n@Component({\n  selector: 'valtimo-documenten-api-columns',\n  templateUrl: './documenten-api-columns.component.html',\n  styleUrls: ['./documenten-api-columns.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    CommonModule,\n    DocumentenApiColumnModalComponent,\n    CarbonListModule,\n    TranslateModule,\n    ConfirmationModalModule,\n    TagModule,\n    ButtonModule,\n  ],\n})\nexport class DocumentenApiColumnsComponent\n  extends PendingChangesComponent\n  implements AfterViewInit\n{\n  @ViewChild('colorColumnTemplate') colorColumnTemplate: TemplateRef<any>;\n\n  private readonly _reload$ = new BehaviorSubject<null | 'noAnimation'>(null);\n\n  private readonly _documentDefinitionName$: Observable<string> = this.route.params.pipe(\n    map(params => params?.name),\n    filter(docDefName => !!docDefName)\n  );\n\n  public get documentDefinitionName$(): Observable<string> {\n    return this._documentDefinitionName$;\n  }\n\n  public readonly loading$ = new BehaviorSubject<boolean>(true);\n\n  public readonly usedKeys$ = new BehaviorSubject<string[]>([]);\n\n  private _documentStatuses: ConfiguredColumn[] = [];\n\n  public readonly documentStatuses$: Observable<ConfiguredColumn[]> = combineLatest([\n    this._documentDefinitionName$,\n    this._reload$,\n  ]).pipe(\n    tap(([_, reload]) => {\n      if (reload === null) {\n        this.loading$.next(true);\n      }\n    }),\n    switchMap(([documentDefinitionName]) =>\n      this.zgwDocumentColumnService.getConfiguredColumns(documentDefinitionName)\n    ),\n    tap(statuses => {\n      this._documentStatuses = statuses;\n      this.usedKeys$.next(statuses.map(status => status.key));\n      this.loading$.next(false);\n    })\n  );\n\n  public readonly fields$ = new BehaviorSubject<ColumnConfig[]>([]);\n\n  public readonly ACTION_ITEMS: ActionItem[] = [\n    {\n      label: 'interface.edit',\n      callback: this.openEditModal.bind(this),\n      type: 'normal',\n    },\n    {\n      label: 'interface.delete',\n      callback: this.openDeleteModal.bind(this),\n      type: 'danger',\n    },\n  ];\n\n  public readonly CARBON_THEME = 'g10';\n\n  public readonly statusModalType$ = new BehaviorSubject<DocumentenApiColumnModalType>('closed');\n  public readonly prefillStatus$ = new BehaviorSubject<ConfiguredColumn>(undefined);\n\n  public readonly columnToUpdate$ = new BehaviorSubject<ConfiguredColumn>(undefined);\n  public readonly showDisableModal$ = new Subject<boolean>();\n\n  constructor(\n    private readonly route: ActivatedRoute,\n    private readonly zgwDocumentColumnService: DocumentenApiColumnService\n  ) {\n    super();\n\n    this._documentDefinitionName$.subscribe(documentDefinitionName => {\n      zgwDocumentColumnService.getConfiguredColumns(documentDefinitionName).subscribe(\n        configuredColumns => {\n          console.log(configuredColumns);\n        },\n        error => {\n          console.error(error);\n        }\n      );\n    });\n  }\n\n  public ngAfterViewInit(): void {\n    this.initFields();\n  }\n\n  public openDeleteModal(status: ConfiguredColumn): void {\n    this.columnToUpdate$.next(status);\n    this.showDisableModal$.next(true);\n  }\n\n  public openEditModal(status: ConfiguredColumn): void {\n    this.prefillStatus$.next(status);\n    this.statusModalType$.next('edit');\n  }\n\n  public openAddModal(): void {\n    this.statusModalType$.next('add');\n  }\n\n  public closeModal(closeModalEvent: DocumentenApiColumnModalTypeCloseEvent): void {\n    if (closeModalEvent === 'closeAndRefresh') {\n      this.reload();\n    }\n\n    this.statusModalType$.next('closed');\n  }\n\n  public confirmDeleteStatus(status: ConfiguredColumn): void {\n    this.documentDefinitionName$\n      .pipe(\n        switchMap(documentDefinitionName =>\n          this.zgwDocumentColumnService.deleteConfiguredColumn(documentDefinitionName, status.key)\n        )\n      )\n      .subscribe(() => {\n        this.reload();\n      });\n  }\n\n  public onMoveRowClick(event: MoveRowEvent): void {\n    const {direction, index} = event;\n\n    const orderedStatuses: ConfiguredColumn[] =\n      direction === MoveRowDirection.UP\n        ? this.swapStatuses(this._documentStatuses, index - 1, index)\n        : this.swapStatuses(this._documentStatuses, index, index + 1);\n\n    this.documentDefinitionName$\n      .pipe(\n        switchMap(documentDefinitionName =>\n          this.zgwDocumentColumnService.updateConfiguredColumns(\n            documentDefinitionName,\n            orderedStatuses\n          )\n        )\n      )\n      .subscribe(() => {\n        this.reload(true);\n      });\n  }\n\n  private reload(noAnimation = false): void {\n    this._reload$.next(noAnimation ? 'noAnimation' : null);\n  }\n\n  private swapStatuses(\n    statuses: ConfiguredColumn[],\n    index1: number,\n    index2: number\n  ): ConfiguredColumn[] {\n    const temp = [...statuses];\n    temp[index1] = temp.splice(index2, 1, temp[index1])[0];\n\n    return temp;\n  }\n\n  private initFields(): void {\n    this.fields$.next([\n      {\n        key: 'title',\n        label: 'dossierManagement.statuses.columns.title',\n        viewType: ViewType.TEXT,\n      },\n      {\n        key: 'key',\n        label: 'dossierManagement.statuses.columns.key',\n        viewType: ViewType.TEXT,\n      },\n      {\n        key: 'visibleInCaseListByDefault',\n        label: 'dossierManagement.statuses.columns.visible',\n        viewType: ViewType.BOOLEAN,\n      },\n      {\n        viewType: ViewType.TEMPLATE,\n        template: this.colorColumnTemplate,\n        key: 'color',\n        label: 'dossierManagement.statuses.columns.color',\n      },\n    ]);\n  }\n}\n","<!--\n  ~ Copyright 2015-2024 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<valtimo-carbon-list\n  *ngIf=\"{\n    loading: loading$ | async,\n    documentStatuses: documentStatuses$ | async\n  } as obs\"\n  [fields]=\"fields$ | async\"\n  [header]=\"false\"\n  [loading]=\"obs.loading\"\n  [movingRowsEnabled]=\"true\"\n  [actionItems]=\"ACTION_ITEMS\"\n  (rowClicked)=\"openEditModal($event)\"\n  (moveRow)=\"onMoveRowClick($event)\"\n>\n  <ng-container\n    carbonToolbarContent\n    *ngTemplateOutlet=\"buttons; context: {obs: obs}\"\n  ></ng-container>\n</valtimo-carbon-list>\n\n<valtimo-documenten-api-column-modal\n  [type]=\"statusModalType$ | async\"\n  [usedKeys]=\"usedKeys$ | async\"\n  [documentDefinitionName]=\"documentDefinitionName$ | async\"\n  (closeModalEvent)=\"closeModal($event)\"\n></valtimo-documenten-api-column-modal>\n\n<valtimo-confirmation-modal\n  confirmButtonTextTranslationKey=\"interface.delete\"\n  confirmButtonType=\"danger\"\n  contentTranslationKey=\"dossierManagement.statuses.deleteText\"\n  [outputOnConfirm]=\"columnToUpdate$ | async\"\n  [showModalSubject$]=\"showDisableModal$\"\n  titleTranslationKey=\"interface.delete\"\n  (confirmEvent)=\"confirmDeleteStatus($event)\"\n></valtimo-confirmation-modal>\n\n<ng-template #buttons let-obs=\"obs\">\n  <div class=\"dossier-management-search-fields__buttons\">\n    <button cdsButton=\"primary\" [disabled]=\"obs.loading\" (click)=\"openAddModal()\">\n      <svg cdsIcon=\"add\" size=\"16\" class=\"cds--btn__icon\"></svg>\n\n      {{ 'dossierManagement.statuses.add' | translate }}\n    </button>\n  </div>\n</ng-template>\n\n<ng-template #colorColumnTemplate let-data=\"data\">\n  <cds-tag class=\"cds-tag--no-margin\" [type]=\"data?.item?.tagType\">\n    {{ 'interface.tagType.' + data?.item?.tagType | translate }}\n  </cds-tag>\n</ng-template>\n"]}

package/esm2022/lib/modules/documenten-api/components/documenten-api-documents/documenten-api-documents.component.mjs

@@ -0,0 +1,256 @@
+/*
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component, ViewChild } from '@angular/core';
+import { Filter16, TagGroup16, Upload16 } from '@carbon/icons';
+import { TranslateModule } from '@ngx-translate/core';
+import { CarbonListModule, ViewType, } from '@valtimo/components';
+import { ButtonModule, IconModule } from 'carbon-components-angular';
+import moment from 'moment';
+import { BehaviorSubject, combineLatest, of, Subject } from 'rxjs';
+import { catchError, filter, map, switchMap, take, tap } from 'rxjs/operators';
+import { DocumentenApiMetadataModalComponent } from '../documenten-api-metadata-modal/documenten-api-metadata-modal.component';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@valtimo/resource";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "@valtimo/config";
+import * as i5 from "@valtimo/security";
+import * as i6 from "@valtimo/document";
+import * as i7 from "carbon-components-angular";
+import * as i8 from "../../services/documenten-api-document.service";
+import * as i9 from "@angular/common";
+import * as i10 from "@valtimo/components";
+export class DossierDetailTabDocumentenApiDocumentsComponent {
+    constructor(route, router, uploadProviderService, downloadService, translateService, configService, userProviderService, fileSortService, iconService, documentenApiDocumentService) {
+        this.route = route;
+        this.router = router;
+        this.uploadProviderService = uploadProviderService;
+        this.downloadService = downloadService;
+        this.translateService = translateService;
+        this.configService = configService;
+        this.userProviderService = userProviderService;
+        this.fileSortService = fileSortService;
+        this.iconService = iconService;
+        this.documentenApiDocumentService = documentenApiDocumentService;
+        this.actionItems = [
+            {
+                label: 'document.download',
+                callback: this.onDownloadActionClick.bind(this),
+                type: 'normal',
+            },
+            {
+                label: 'document.delete',
+                callback: this.onDeleteActionClick.bind(this),
+                type: 'danger',
+            },
+        ];
+        this.fieldsConfig = [
+            // TODO: Refactor this once admin page config is implemented
+            'title',
+            'fileName',
+            'format',
+            'size',
+            'description',
+            'createdOn',
+            'createdBy',
+            'author',
+            'informatieobjecttype',
+            'actions',
+        ];
+        this._documentDefinitionName$ = this.route.params.pipe(map(params => params?.documentDefinitionName), filter(documentDefinitionName => !!documentDefinitionName));
+        this._documentId$ = this.route.params.pipe(map(params => params?.documentId), filter(documentId => !!documentId));
+        this.uploadProcessLinkedSet = false;
+        this.acceptedFiles = this.configService?.config?.caseFileUploadAcceptedFiles || null;
+        this.maxFileSize = this.configService?.config?.caseFileSizeUploadLimitMB || 5;
+        this.fileToBeUploaded$ = new BehaviorSubject(null);
+        this.hideModal$ = new Subject();
+        this.modalDisabled$ = new BehaviorSubject(false);
+        this.showModal$ = new Subject();
+        this.uploading$ = new BehaviorSubject(false);
+        this.loading$ = new BehaviorSubject(true);
+        this._refetch$ = new BehaviorSubject(null);
+        this.relatedFiles$ = combineLatest([
+            this._documentId$,
+            this._refetch$,
+        ]).pipe(tap(() => this.loading$.next(true)), switchMap(([documentId]) => combineLatest([
+            this.documentenApiDocumentService.getZakenApiDocuments(documentId),
+            this.translateService.stream('key'),
+        ])), map(([relatedFiles]) => {
+            const translatedFiles = relatedFiles?.map(file => ({
+                ...file,
+                createdBy: file.createdBy || this.translateService.instant('list.automaticallyGenerated'),
+                language: this.translateService.instant(`document.${file.language}`),
+                confidentialityLevel: this.translateService.instant(`document.${file.confidentialityLevel}`),
+                status: this.translateService.instant(`document.${file.status}`),
+                format: this.translateService.instant(`document.${file.format}`),
+            }));
+            return translatedFiles || [];
+        }), map(relatedFiles => this.fileSortService.sortRelatedFilesByDateDescending(relatedFiles)), map(relatedFiles => {
+            moment.locale(this.translateService.currentLang);
+            return relatedFiles.map(file => ({
+                ...file,
+                createdOn: moment(new Date(file.createdOn)).format('L'),
+                size: `${this.bytesToMegabytes(file.sizeInBytes)}`,
+            }));
+        }), tap(() => {
+            this.loading$.next(false);
+        }), catchError(() => {
+            this.showZaakLinkWarning = true;
+            this.loading$.next(false);
+            return of([]);
+        }));
+    }
+    ngOnInit() {
+        this.refetchDocuments();
+        this.setUploadProcessLinked();
+        this.isUserAdmin();
+        this.iconService.registerAll([Filter16, TagGroup16, Upload16]);
+    }
+    ngAfterViewInit() {
+        const fieldOptions = [
+            { key: 'title', label: 'document.inputTitle' },
+            { key: 'description', label: 'document.inputDescription' },
+            { key: 'fileName', label: 'document.filename' },
+            {
+                viewType: ViewType.TEMPLATE,
+                label: 'document.size',
+                key: 'size',
+                template: this.sizeTemplate,
+            },
+            { key: 'format', label: 'document.format' },
+            { key: 'createdOn', label: 'document.createdOn' },
+            { key: 'createdBy', label: 'document.createdBy' },
+            { key: 'author', label: 'document.author' },
+            { key: 'keywords', label: 'document.trefwoorden' },
+            { key: 'informatieobjecttype', label: 'document.informatieobjecttype' },
+            { key: 'language', label: 'document.language' },
+            { key: 'identification', label: 'document.id' },
+            { key: 'confidentialityLevel', label: 'document.confidentialityLevel' },
+            { key: 'receiptDate', label: 'document.receiptDate' },
+            { key: 'sendDate', label: 'document.sendDate' },
+            { key: 'status', label: 'document.status' },
+        ];
+        this.fields = [...this.getFields(fieldOptions, this.fieldsConfig)];
+    }
+    bytesToMegabytes(bytes) {
+        const megabytes = bytes / (1024 * 1024);
+        if (megabytes < 1) {
+            return `${Math.ceil(megabytes * 1000)} KB`;
+        }
+        else if (megabytes < 1000) {
+            return megabytes.toFixed(2) + ' MB';
+        }
+        return (megabytes / 1000).toFixed(2) + ' GB';
+    }
+    getUploadButtonTooltip() {
+        if (this.uploadProcessLinkedSet && this.uploadProcessLinked) {
+            return 'Upload';
+        }
+        else if (this.isAdmin) {
+            return 'dossier.documenten.noProcessLinked.adminRole';
+        }
+        return 'dossier.documenten.noProcessLinked.regularUser';
+    }
+    isUserAdmin() {
+        this.userProviderService.getUserSubject().subscribe(userIdentity => {
+            this.isAdmin = userIdentity.roles.includes('ROLE_ADMIN');
+        }, error => {
+            this.isAdmin = false;
+        });
+    }
+    metadataSet(metadata) {
+        this.uploading$.next(true);
+        this.hideModal$.next(null);
+        combineLatest([this.fileToBeUploaded$, this._documentId$])
+            .pipe(take(1))
+            .pipe(tap(([file, documentId]) => {
+            if (!file)
+                return;
+            this.uploadProviderService
+                .uploadFileWithMetadata(file, documentId, metadata)
+                .subscribe(() => {
+                this.refetchDocuments();
+                this.uploading$.next(false);
+                this.fileToBeUploaded$.next(null);
+            });
+        }))
+            .subscribe();
+    }
+    onDeleteActionClick(item) {
+        this.loading$.next(true);
+        this.documentenApiDocumentService.deleteDocument(item).subscribe(() => {
+            // TODO: Use refetchDocuments() or should we just remove the document from relatedFiles$?
+            this.refetchDocuments();
+        });
+    }
+    onDownloadActionClick(file) {
+        this.downloadDocument(file, true);
+    }
+    onFileSelected(event) {
+        this.fileToBeUploaded$.next(event.target.files[0]);
+        this.showModal$.next(null);
+    }
+    onNavigateToCaseAdminClick() {
+        this._documentDefinitionName$.pipe(take(1)).subscribe(documentDefinitionName => {
+            this.router.navigate([`/dossier-management/dossier/${documentDefinitionName}`]);
+        });
+    }
+    onRowClick(event) {
+        this.downloadDocument(event, false);
+    }
+    onUploadButtonClick() {
+        this.fileInput.nativeElement.click();
+    }
+    refetchDocuments() {
+        this._refetch$.next(null);
+    }
+    downloadDocument(relatedFile, forceDownload) {
+        this.downloadService.downloadFile(`/api/v1/documenten-api/${relatedFile.pluginConfigurationId}/files/${relatedFile.fileId}/download`, relatedFile.fileName, forceDownload);
+    }
+    getFields(fieldOptions, fieldsConfig) {
+        return fieldOptions.filter(fieldOption => fieldsConfig.includes(fieldOption.key));
+    }
+    setUploadProcessLinked() {
+        this._documentDefinitionName$
+            .pipe(switchMap(documentDefinitionName => this.uploadProviderService.checkUploadProcessLink(documentDefinitionName)), take(1), tap(() => {
+            this.uploadProcessLinkedSet = true;
+        }))
+            .subscribe((linked) => {
+            this.uploadProcessLinked = linked;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: DossierDetailTabDocumentenApiDocumentsComponent, deps: [{ token: i1.ActivatedRoute }, { token: i1.Router }, { token: i2.UploadProviderService }, { token: i2.DownloadService }, { token: i3.TranslateService }, { token: i4.ConfigService }, { token: i5.UserProviderService }, { token: i6.FileSortService }, { token: i7.IconService }, { token: i8.DocumentenApiDocumentService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.3", type: DossierDetailTabDocumentenApiDocumentsComponent, isStandalone: true, selector: "valtimo-dossier-detail-tab-documenten-api-documents", viewQueries: [{ propertyName: "fileInput", first: true, predicate: ["fileInput"], descendants: true }, { propertyName: "sizeTemplate", first: true, predicate: ["sizeTemplate"], descendants: true }], ngImport: i0, template: "<!--\n  ~ Copyright 2015-2024 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<div\n  class=\"carbon-document-table-wrapper\"\n  *ngIf=\"{\n    loading: loading$ | async,\n    uploading: uploading$ | async,\n    relatedFiles: relatedFiles$ | async\n  } as obs\"\n>\n  @if (!obs.loading && !obs.uploading && obs.relatedFiles) {\n    <ng-container\n      *ngTemplateOutlet=\"list; context: {relatedFiles: obs.relatedFiles}\"\n    ></ng-container>\n  } @else {\n    <ng-container *ngTemplateOutlet=\"listLoading\"></ng-container>\n  }\n</div>\n\n<valtimo-documenten-api-metadata-modal\n  [disabled$]=\"modalDisabled$\"\n  [file$]=\"fileToBeUploaded$\"\n  [hide$]=\"hideModal$\"\n  [show$]=\"showModal$\"\n  (metadata)=\"metadataSet($event)\"\n></valtimo-documenten-api-metadata-modal>\n\n<ng-template #list let-relatedFiles=\"relatedFiles\">\n  <valtimo-carbon-list\n    [actionItems]=\"actionItems\"\n    [items]=\"relatedFiles\"\n    [fields]=\"fields\"\n    (rowClicked)=\"onRowClick($event)\"\n    hideColumnHeader\n  >\n    <div carbonToolbarContent>\n      <input\n        [accept]=\"acceptedFiles\"\n        (change)=\"onFileSelected($event)\"\n        hidden\n        type=\"file\"\n        #fileInput\n      />\n\n      <ng-container *ngTemplateOutlet=\"uploadButton\"></ng-container>\n    </div>\n\n    @if (showZaakLinkWarning && isAdmin) {\n      <valtimo-no-results\n        [action]=\"navigateToCaseAdminButton\"\n        description=\"{{ 'dossier.documenten.noZaakFound' | translate }}\"\n        title=\"{{ 'dossier.documenten.noZaakFoundTitle' | translate }}\"\n      ></valtimo-no-results>\n    } @else {\n      <valtimo-no-results\n        [action]=\"uploadButton\"\n        description=\"{{ 'dossier.documenten.noFiles' | translate }}\"\n        title=\"{{ 'dossier.documenten.noFilesTitle' | translate }}\"\n      ></valtimo-no-results>\n    }\n  </valtimo-carbon-list>\n</ng-template>\n\n<ng-template #listLoading>\n  <valtimo-carbon-list [items]=\"[]\" [fields]=\"fields\" [loading]=\"true\" hideColumnHeader>\n    <div carbonToolbarContent>\n      <ng-container *ngTemplateOutlet=\"uploadButton; context: {disabled: true}\"></ng-container>\n    </div>\n  </valtimo-carbon-list>\n</ng-template>\n\n<ng-template #downloadButton let-index=\"index\" let-item=\"item\">\n  <div\n    *ngIf=\"{isDownloading: indexesIncludeIndex(downloadingFileIndexes$ | async, index)} as vars\"\n    class=\"download-button-container\"\n  >\n    <button\n      *ngIf=\"!vars.isDownloading\"\n      cdsButton=\"primary\"\n      size=\"sm\"\n      (click)=\"downloadDocument(item, index)\"\n    >\n      {{ 'interface.download' | translate }}\n\n      <svg class=\"cds--btn__icon\" cdsIcon=\"download\" size=\"16\"></svg>\n    </button>\n\n    <cds-loading size=\"sm\" *ngIf=\"vars.isDownloading\"></cds-loading>\n  </div>\n</ng-template>\n\n<ng-template #dossierListActions>\n  <input [accept]=\"acceptedFiles\" (change)=\"onFileSelected($event)\" hidden type=\"file\" #fileInput />\n  <ng-container *ngTemplateOutlet=\"uploadButton\"></ng-container>\n</ng-template>\n\n<ng-template #uploadButton let-disabled=\"disabled\">\n  <button\n    [disabled]=\"(uploadProcessLinkedSet && !uploadProcessLinked) || showZaakLinkWarning || disabled\"\n    [vTooltip]=\"getUploadButtonTooltip() | translate\"\n    (click)=\"onUploadButtonClick()\"\n    cdsButton=\"primary\"\n  >\n    {{ 'Upload' | translate }}\n    <svg class=\"cds--btn__icon\" cdsIcon=\"upload\" size=\"16\"></svg>\n  </button>\n</ng-template>\n\n<ng-template #navigateToCaseAdminButton>\n  <button (click)=\"onNavigateToCaseAdminClick()\" cdsButton=\"primary\">\n    {{ 'dossier.documenten.navigateToCaseAdmin' | translate }}\n    <svg class=\"cds--btn__icon\" cdsIcon=\"settings\" size=\"16\"></svg>\n  </button>\n</ng-template>\n\n<ng-template #sizeTemplate let-data=\"data\">\n  <div class=\"documenten-api-documents-filesize-template\">\n    {{ bytesToMegabytes(data.item.sizeInBytes) }}\n  </div>\n</ng-template>\n", styles: [".hidden{display:none}.loading-container{padding:var(--cds-grid-margin);display:flex;align-items:center;justify-content:center}.carbon-document-table-wrapper{margin:0}.documenten-api-documents-filesize-template{text-align:right}\n/*!\n * Copyright 2015-2024 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i9.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i9.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "pipe", type: i9.AsyncPipe, name: "async" }, { kind: "ngmodule", type: CarbonListModule }, { kind: "component", type: i10.CarbonListComponent, selector: "valtimo-carbon-list", inputs: ["items", "fields", "tableTranslations", "paginatorConfig", "pagination", "loading", "actions", "actionItems", "header", "hideColumnHeader", "initialSortState", "isSearchable", "enableSingleSelection", "lastColumnTemplate", "paginationIdentifier", "showSelectionColumn", "striped", "hideToolbar", "lockedTooltipTranslationKey", "movingRowsEnabled"], outputs: ["rowClicked", "paginationClicked", "paginationSet", "search", "sortChanged", "moveRow", "itemsReordered"] }, { kind: "component", type: i10.CarbonNoResultsComponent, selector: "valtimo-no-results", inputs: ["action", "description", "illustration", "title"] }, { kind: "component", type: DocumentenApiMetadataModalComponent, selector: "valtimo-documenten-api-metadata-modal", inputs: ["show$", "hide$", "disabled$", "file$", "documentTitle", "disableDocumentTitle", "filename", "disableFilename", "author", "disableAuthor", "status", "disableStatus", "language", "disableLanguage", "documentType", "disableDocumentType", "description", "disableDescription", "confidentialityLevel", "disableConfidentialityLevel", "trefwoorden", "disableTrefwoorden"], outputs: ["metadata"] }, { kind: "ngmodule", type: ButtonModule }, { kind: "directive", type: i7.Button, selector: "[cdsButton], [ibmButton]", inputs: ["ibmButton", "cdsButton", "size", "skeleton", "iconOnly", "isExpressive"] }, { kind: "ngmodule", type: IconModule }, { kind: "directive", type: i7.IconDirective, selector: "[cdsIcon], [ibmIcon]", inputs: ["ibmIcon", "cdsIcon", "size", "title", "ariaLabel", "ariaLabelledBy", "ariaHidden", "isFocusable"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i3.TranslatePipe, name: "translate" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: DossierDetailTabDocumentenApiDocumentsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'valtimo-dossier-detail-tab-documenten-api-documents', standalone: true, imports: [
+                        CommonModule,
+                        CarbonListModule,
+                        DocumentenApiMetadataModalComponent,
+                        ButtonModule,
+                        IconModule,
+                        TranslateModule,
+                    ], template: "<!--\n  ~ Copyright 2015-2024 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<div\n  class=\"carbon-document-table-wrapper\"\n  *ngIf=\"{\n    loading: loading$ | async,\n    uploading: uploading$ | async,\n    relatedFiles: relatedFiles$ | async\n  } as obs\"\n>\n  @if (!obs.loading && !obs.uploading && obs.relatedFiles) {\n    <ng-container\n      *ngTemplateOutlet=\"list; context: {relatedFiles: obs.relatedFiles}\"\n    ></ng-container>\n  } @else {\n    <ng-container *ngTemplateOutlet=\"listLoading\"></ng-container>\n  }\n</div>\n\n<valtimo-documenten-api-metadata-modal\n  [disabled$]=\"modalDisabled$\"\n  [file$]=\"fileToBeUploaded$\"\n  [hide$]=\"hideModal$\"\n  [show$]=\"showModal$\"\n  (metadata)=\"metadataSet($event)\"\n></valtimo-documenten-api-metadata-modal>\n\n<ng-template #list let-relatedFiles=\"relatedFiles\">\n  <valtimo-carbon-list\n    [actionItems]=\"actionItems\"\n    [items]=\"relatedFiles\"\n    [fields]=\"fields\"\n    (rowClicked)=\"onRowClick($event)\"\n    hideColumnHeader\n  >\n    <div carbonToolbarContent>\n      <input\n        [accept]=\"acceptedFiles\"\n        (change)=\"onFileSelected($event)\"\n        hidden\n        type=\"file\"\n        #fileInput\n      />\n\n      <ng-container *ngTemplateOutlet=\"uploadButton\"></ng-container>\n    </div>\n\n    @if (showZaakLinkWarning && isAdmin) {\n      <valtimo-no-results\n        [action]=\"navigateToCaseAdminButton\"\n        description=\"{{ 'dossier.documenten.noZaakFound' | translate }}\"\n        title=\"{{ 'dossier.documenten.noZaakFoundTitle' | translate }}\"\n      ></valtimo-no-results>\n    } @else {\n      <valtimo-no-results\n        [action]=\"uploadButton\"\n        description=\"{{ 'dossier.documenten.noFiles' | translate }}\"\n        title=\"{{ 'dossier.documenten.noFilesTitle' | translate }}\"\n      ></valtimo-no-results>\n    }\n  </valtimo-carbon-list>\n</ng-template>\n\n<ng-template #listLoading>\n  <valtimo-carbon-list [items]=\"[]\" [fields]=\"fields\" [loading]=\"true\" hideColumnHeader>\n    <div carbonToolbarContent>\n      <ng-container *ngTemplateOutlet=\"uploadButton; context: {disabled: true}\"></ng-container>\n    </div>\n  </valtimo-carbon-list>\n</ng-template>\n\n<ng-template #downloadButton let-index=\"index\" let-item=\"item\">\n  <div\n    *ngIf=\"{isDownloading: indexesIncludeIndex(downloadingFileIndexes$ | async, index)} as vars\"\n    class=\"download-button-container\"\n  >\n    <button\n      *ngIf=\"!vars.isDownloading\"\n      cdsButton=\"primary\"\n      size=\"sm\"\n      (click)=\"downloadDocument(item, index)\"\n    >\n      {{ 'interface.download' | translate }}\n\n      <svg class=\"cds--btn__icon\" cdsIcon=\"download\" size=\"16\"></svg>\n    </button>\n\n    <cds-loading size=\"sm\" *ngIf=\"vars.isDownloading\"></cds-loading>\n  </div>\n</ng-template>\n\n<ng-template #dossierListActions>\n  <input [accept]=\"acceptedFiles\" (change)=\"onFileSelected($event)\" hidden type=\"file\" #fileInput />\n  <ng-container *ngTemplateOutlet=\"uploadButton\"></ng-container>\n</ng-template>\n\n<ng-template #uploadButton let-disabled=\"disabled\">\n  <button\n    [disabled]=\"(uploadProcessLinkedSet && !uploadProcessLinked) || showZaakLinkWarning || disabled\"\n    [vTooltip]=\"getUploadButtonTooltip() | translate\"\n    (click)=\"onUploadButtonClick()\"\n    cdsButton=\"primary\"\n  >\n    {{ 'Upload' | translate }}\n    <svg class=\"cds--btn__icon\" cdsIcon=\"upload\" size=\"16\"></svg>\n  </button>\n</ng-template>\n\n<ng-template #navigateToCaseAdminButton>\n  <button (click)=\"onNavigateToCaseAdminClick()\" cdsButton=\"primary\">\n    {{ 'dossier.documenten.navigateToCaseAdmin' | translate }}\n    <svg class=\"cds--btn__icon\" cdsIcon=\"settings\" size=\"16\"></svg>\n  </button>\n</ng-template>\n\n<ng-template #sizeTemplate let-data=\"data\">\n  <div class=\"documenten-api-documents-filesize-template\">\n    {{ bytesToMegabytes(data.item.sizeInBytes) }}\n  </div>\n</ng-template>\n", styles: [".hidden{display:none}.loading-container{padding:var(--cds-grid-margin);display:flex;align-items:center;justify-content:center}.carbon-document-table-wrapper{margin:0}.documenten-api-documents-filesize-template{text-align:right}\n/*!\n * Copyright 2015-2024 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n"] }]
+        }], ctorParameters: () => [{ type: i1.ActivatedRoute }, { type: i1.Router }, { type: i2.UploadProviderService }, { type: i2.DownloadService }, { type: i3.TranslateService }, { type: i4.ConfigService }, { type: i5.UserProviderService }, { type: i6.FileSortService }, { type: i7.IconService }, { type: i8.DocumentenApiDocumentService }], propDecorators: { fileInput: [{
+                type: ViewChild,
+                args: ['fileInput']
+            }], sizeTemplate: [{
+                type: ViewChild,
+                args: ['sizeTemplate']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"documenten-api-documents.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/valtimo/zgw/src/lib/modules/documenten-api/components/documenten-api-documents/documenten-api-documents.component.ts","../../../../../../../../../projects/valtimo/zgw/src/lib/modules/documenten-api/components/documenten-api-documents/documenten-api-documents.component.html"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2024 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {AfterViewInit, Component, ElementRef, OnInit, TemplateRef, ViewChild} from '@angular/core';\nimport {ActivatedRoute, Router} from '@angular/router';\nimport {Filter16, TagGroup16, Upload16} from '@carbon/icons';\nimport {TranslateModule, TranslateService} from '@ngx-translate/core';\nimport {\n  ActionItem,\n  CarbonListModule,\n  ColumnConfig,\n  DocumentenApiMetadata,\n  ViewType,\n} from '@valtimo/components';\nimport {ConfigService} from '@valtimo/config';\nimport {FileSortService} from '@valtimo/document';\nimport {DownloadService, UploadProviderService} from '@valtimo/resource';\nimport {UserProviderService} from '@valtimo/security';\nimport {ButtonModule, IconModule, IconService} from 'carbon-components-angular';\nimport moment from 'moment';\nimport {BehaviorSubject, combineLatest, Observable, of, Subject} from 'rxjs';\nimport {catchError, filter, map, switchMap, take, tap} from 'rxjs/operators';\nimport {DocumentenApiRelatedFile, DocumentenApiRelatedFileListItem} from '../../models';\nimport {DocumentenApiDocumentService} from '../../services/documenten-api-document.service';\nimport {DocumentenApiMetadataModalComponent} from '../documenten-api-metadata-modal/documenten-api-metadata-modal.component';\nimport {CommonModule} from '@angular/common';\n\n@Component({\n  selector: 'valtimo-dossier-detail-tab-documenten-api-documents',\n  templateUrl: './documenten-api-documents.component.html',\n  styleUrls: ['./documenten-api-documents.component.scss'],\n  standalone: true,\n  imports: [\n    CommonModule,\n    CarbonListModule,\n    DocumentenApiMetadataModalComponent,\n    ButtonModule,\n    IconModule,\n    TranslateModule,\n  ],\n})\nexport class DossierDetailTabDocumentenApiDocumentsComponent implements OnInit, AfterViewInit {\n  @ViewChild('fileInput') fileInput: ElementRef;\n  @ViewChild('sizeTemplate') public sizeTemplate: TemplateRef<any>;\n\n  public fields: ColumnConfig[];\n  public actionItems: ActionItem[] = [\n    {\n      label: 'document.download',\n      callback: this.onDownloadActionClick.bind(this),\n      type: 'normal',\n    },\n    {\n      label: 'document.delete',\n      callback: this.onDeleteActionClick.bind(this),\n      type: 'danger',\n    },\n  ];\n  public fieldsConfig = [\n    // TODO: Refactor this once admin page config is implemented\n    'title',\n    'fileName',\n    'format',\n    'size',\n    'description',\n    'createdOn',\n    'createdBy',\n    'author',\n    'informatieobjecttype',\n    'actions',\n  ];\n\n  private readonly _documentDefinitionName$: Observable<string> = this.route.params.pipe(\n    map(params => params?.documentDefinitionName),\n    filter(documentDefinitionName => !!documentDefinitionName)\n  );\n\n  private readonly _documentId$: Observable<string> = this.route.params.pipe(\n    map(params => params?.documentId),\n    filter(documentId => !!documentId)\n  );\n\n  public isAdmin: boolean;\n  public showZaakLinkWarning: boolean;\n  public uploadProcessLinkedSet = false;\n  public uploadProcessLinked!: boolean;\n\n  public readonly acceptedFiles: string | null =\n    this.configService?.config?.caseFileUploadAcceptedFiles || null;\n  public readonly maxFileSize: number = this.configService?.config?.caseFileSizeUploadLimitMB || 5;\n\n  public readonly fileToBeUploaded$ = new BehaviorSubject<File | null>(null);\n  public readonly hideModal$ = new Subject<null>();\n  public readonly modalDisabled$ = new BehaviorSubject<boolean>(false);\n  public readonly showModal$ = new Subject<null>();\n\n  public readonly uploading$ = new BehaviorSubject<boolean>(false);\n  public readonly loading$ = new BehaviorSubject<boolean>(true);\n\n  private readonly _refetch$ = new BehaviorSubject<null>(null);\n\n  public relatedFiles$: Observable<Array<DocumentenApiRelatedFileListItem>> = combineLatest([\n    this._documentId$,\n    this._refetch$,\n  ]).pipe(\n    tap(() => this.loading$.next(true)),\n    switchMap(([documentId]) =>\n      combineLatest([\n        this.documentenApiDocumentService.getZakenApiDocuments(documentId),\n        this.translateService.stream('key'),\n      ])\n    ),\n    map(([relatedFiles]) => {\n      const translatedFiles = relatedFiles?.map(file => ({\n        ...file,\n        createdBy: file.createdBy || this.translateService.instant('list.automaticallyGenerated'),\n        language: this.translateService.instant(`document.${file.language}`),\n        confidentialityLevel: this.translateService.instant(\n          `document.${file.confidentialityLevel}`\n        ),\n        status: this.translateService.instant(`document.${file.status}`),\n        format: this.translateService.instant(`document.${file.format}`),\n      }));\n      return translatedFiles || [];\n    }),\n    map(relatedFiles => this.fileSortService.sortRelatedFilesByDateDescending(relatedFiles)),\n    map(relatedFiles => {\n      moment.locale(this.translateService.currentLang);\n      return relatedFiles.map(file => ({\n        ...file,\n        createdOn: moment(new Date(file.createdOn)).format('L'),\n        size: `${this.bytesToMegabytes(file.sizeInBytes)}`,\n      }));\n    }),\n    tap(() => {\n      this.loading$.next(false);\n    }),\n    catchError(() => {\n      this.showZaakLinkWarning = true;\n      this.loading$.next(false);\n      return of([]);\n    })\n  );\n\n  constructor(\n    private readonly route: ActivatedRoute,\n    private readonly router: Router,\n    private readonly uploadProviderService: UploadProviderService,\n    private readonly downloadService: DownloadService,\n    private readonly translateService: TranslateService,\n    private readonly configService: ConfigService,\n    private readonly userProviderService: UserProviderService,\n    private readonly fileSortService: FileSortService,\n    private readonly iconService: IconService,\n    private readonly documentenApiDocumentService: DocumentenApiDocumentService\n  ) {}\n\n  ngOnInit(): void {\n    this.refetchDocuments();\n    this.setUploadProcessLinked();\n    this.isUserAdmin();\n    this.iconService.registerAll([Filter16, TagGroup16, Upload16]);\n  }\n\n  public ngAfterViewInit(): void {\n    const fieldOptions = [\n      {key: 'title', label: 'document.inputTitle'},\n      {key: 'description', label: 'document.inputDescription'},\n      {key: 'fileName', label: 'document.filename'},\n      {\n        viewType: ViewType.TEMPLATE,\n        label: 'document.size',\n        key: 'size',\n        template: this.sizeTemplate,\n      },\n      {key: 'format', label: 'document.format'},\n      {key: 'createdOn', label: 'document.createdOn'},\n      {key: 'createdBy', label: 'document.createdBy'},\n      {key: 'author', label: 'document.author'},\n      {key: 'keywords', label: 'document.trefwoorden'},\n      {key: 'informatieobjecttype', label: 'document.informatieobjecttype'},\n      {key: 'language', label: 'document.language'},\n      {key: 'identification', label: 'document.id'},\n      {key: 'confidentialityLevel', label: 'document.confidentialityLevel'},\n      {key: 'receiptDate', label: 'document.receiptDate'},\n      {key: 'sendDate', label: 'document.sendDate'},\n      {key: 'status', label: 'document.status'},\n    ];\n\n    this.fields = [...this.getFields(fieldOptions, this.fieldsConfig)];\n  }\n\n  public bytesToMegabytes(bytes: number): string {\n    const megabytes = bytes / (1024 * 1024);\n    if (megabytes < 1) {\n      return `${Math.ceil(megabytes * 1000)} KB`;\n    } else if (megabytes < 1000) {\n      return megabytes.toFixed(2) + ' MB';\n    }\n\n    return (megabytes / 1000).toFixed(2) + ' GB';\n  }\n\n  public getUploadButtonTooltip(): string {\n    if (this.uploadProcessLinkedSet && this.uploadProcessLinked) {\n      return 'Upload';\n    } else if (this.isAdmin) {\n      return 'dossier.documenten.noProcessLinked.adminRole';\n    }\n\n    return 'dossier.documenten.noProcessLinked.regularUser';\n  }\n\n  public isUserAdmin() {\n    this.userProviderService.getUserSubject().subscribe(\n      userIdentity => {\n        this.isAdmin = userIdentity.roles.includes('ROLE_ADMIN');\n      },\n      error => {\n        this.isAdmin = false;\n      }\n    );\n  }\n\n  public metadataSet(metadata: DocumentenApiMetadata): void {\n    this.uploading$.next(true);\n    this.hideModal$.next(null);\n\n    combineLatest([this.fileToBeUploaded$, this._documentId$])\n      .pipe(take(1))\n      .pipe(\n        tap(([file, documentId]) => {\n          if (!file) return;\n\n          this.uploadProviderService\n            .uploadFileWithMetadata(file, documentId, metadata)\n            .subscribe(() => {\n              this.refetchDocuments();\n              this.uploading$.next(false);\n              this.fileToBeUploaded$.next(null);\n            });\n        })\n      )\n      .subscribe();\n  }\n\n  public onDeleteActionClick(item: DocumentenApiRelatedFile): void {\n    this.loading$.next(true);\n    this.documentenApiDocumentService.deleteDocument(item).subscribe(() => {\n      // TODO: Use refetchDocuments() or should we just remove the document from relatedFiles$?\n      this.refetchDocuments();\n    });\n  }\n\n  public onDownloadActionClick(file: DocumentenApiRelatedFile): void {\n    this.downloadDocument(file, true);\n  }\n\n  public onFileSelected(event: any): void {\n    this.fileToBeUploaded$.next(event.target.files[0]);\n    this.showModal$.next(null);\n  }\n\n  public onNavigateToCaseAdminClick(): void {\n    this._documentDefinitionName$.pipe(take(1)).subscribe(documentDefinitionName => {\n      this.router.navigate([`/dossier-management/dossier/${documentDefinitionName}`]);\n    });\n  }\n\n  public onRowClick(event: any): void {\n    this.downloadDocument(event, false);\n  }\n\n  public onUploadButtonClick(): void {\n    this.fileInput.nativeElement.click();\n  }\n\n  public refetchDocuments(): void {\n    this._refetch$.next(null);\n  }\n\n  private downloadDocument(relatedFile: DocumentenApiRelatedFile, forceDownload: boolean): void {\n    this.downloadService.downloadFile(\n      `/api/v1/documenten-api/${relatedFile.pluginConfigurationId}/files/${relatedFile.fileId}/download`,\n      relatedFile.fileName,\n      forceDownload\n    );\n  }\n\n  private getFields(fieldOptions, fieldsConfig) {\n    return fieldOptions.filter(fieldOption => fieldsConfig.includes(fieldOption.key));\n  }\n\n  private setUploadProcessLinked(): void {\n    this._documentDefinitionName$\n      .pipe(\n        switchMap(documentDefinitionName =>\n          this.uploadProviderService.checkUploadProcessLink(documentDefinitionName)\n        ),\n        take(1),\n        tap(() => {\n          this.uploadProcessLinkedSet = true;\n        })\n      )\n      .subscribe((linked: boolean) => {\n        this.uploadProcessLinked = linked;\n      });\n  }\n}\n","<!--\n  ~ Copyright 2015-2024 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<div\n  class=\"carbon-document-table-wrapper\"\n  *ngIf=\"{\n    loading: loading$ | async,\n    uploading: uploading$ | async,\n    relatedFiles: relatedFiles$ | async\n  } as obs\"\n>\n  @if (!obs.loading && !obs.uploading && obs.relatedFiles) {\n    <ng-container\n      *ngTemplateOutlet=\"list; context: {relatedFiles: obs.relatedFiles}\"\n    ></ng-container>\n  } @else {\n    <ng-container *ngTemplateOutlet=\"listLoading\"></ng-container>\n  }\n</div>\n\n<valtimo-documenten-api-metadata-modal\n  [disabled$]=\"modalDisabled$\"\n  [file$]=\"fileToBeUploaded$\"\n  [hide$]=\"hideModal$\"\n  [show$]=\"showModal$\"\n  (metadata)=\"metadataSet($event)\"\n></valtimo-documenten-api-metadata-modal>\n\n<ng-template #list let-relatedFiles=\"relatedFiles\">\n  <valtimo-carbon-list\n    [actionItems]=\"actionItems\"\n    [items]=\"relatedFiles\"\n    [fields]=\"fields\"\n    (rowClicked)=\"onRowClick($event)\"\n    hideColumnHeader\n  >\n    <div carbonToolbarContent>\n      <input\n        [accept]=\"acceptedFiles\"\n        (change)=\"onFileSelected($event)\"\n        hidden\n        type=\"file\"\n        #fileInput\n      />\n\n      <ng-container *ngTemplateOutlet=\"uploadButton\"></ng-container>\n    </div>\n\n    @if (showZaakLinkWarning && isAdmin) {\n      <valtimo-no-results\n        [action]=\"navigateToCaseAdminButton\"\n        description=\"{{ 'dossier.documenten.noZaakFound' | translate }}\"\n        title=\"{{ 'dossier.documenten.noZaakFoundTitle' | translate }}\"\n      ></valtimo-no-results>\n    } @else {\n      <valtimo-no-results\n        [action]=\"uploadButton\"\n        description=\"{{ 'dossier.documenten.noFiles' | translate }}\"\n        title=\"{{ 'dossier.documenten.noFilesTitle' | translate }}\"\n      ></valtimo-no-results>\n    }\n  </valtimo-carbon-list>\n</ng-template>\n\n<ng-template #listLoading>\n  <valtimo-carbon-list [items]=\"[]\" [fields]=\"fields\" [loading]=\"true\" hideColumnHeader>\n    <div carbonToolbarContent>\n      <ng-container *ngTemplateOutlet=\"uploadButton; context: {disabled: true}\"></ng-container>\n    </div>\n  </valtimo-carbon-list>\n</ng-template>\n\n<ng-template #downloadButton let-index=\"index\" let-item=\"item\">\n  <div\n    *ngIf=\"{isDownloading: indexesIncludeIndex(downloadingFileIndexes$ | async, index)} as vars\"\n    class=\"download-button-container\"\n  >\n    <button\n      *ngIf=\"!vars.isDownloading\"\n      cdsButton=\"primary\"\n      size=\"sm\"\n      (click)=\"downloadDocument(item, index)\"\n    >\n      {{ 'interface.download' | translate }}\n\n      <svg class=\"cds--btn__icon\" cdsIcon=\"download\" size=\"16\"></svg>\n    </button>\n\n    <cds-loading size=\"sm\" *ngIf=\"vars.isDownloading\"></cds-loading>\n  </div>\n</ng-template>\n\n<ng-template #dossierListActions>\n  <input [accept]=\"acceptedFiles\" (change)=\"onFileSelected($event)\" hidden type=\"file\" #fileInput />\n  <ng-container *ngTemplateOutlet=\"uploadButton\"></ng-container>\n</ng-template>\n\n<ng-template #uploadButton let-disabled=\"disabled\">\n  <button\n    [disabled]=\"(uploadProcessLinkedSet && !uploadProcessLinked) || showZaakLinkWarning || disabled\"\n    [vTooltip]=\"getUploadButtonTooltip() | translate\"\n    (click)=\"onUploadButtonClick()\"\n    cdsButton=\"primary\"\n  >\n    {{ 'Upload' | translate }}\n    <svg class=\"cds--btn__icon\" cdsIcon=\"upload\" size=\"16\"></svg>\n  </button>\n</ng-template>\n\n<ng-template #navigateToCaseAdminButton>\n  <button (click)=\"onNavigateToCaseAdminClick()\" cdsButton=\"primary\">\n    {{ 'dossier.documenten.navigateToCaseAdmin' | translate }}\n    <svg class=\"cds--btn__icon\" cdsIcon=\"settings\" size=\"16\"></svg>\n  </button>\n</ng-template>\n\n<ng-template #sizeTemplate let-data=\"data\">\n  <div class=\"documenten-api-documents-filesize-template\">\n    {{ bytesToMegabytes(data.item.sizeInBytes) }}\n  </div>\n</ng-template>\n"]}