@valtimo/zgw 12.5.1 → 12.7.0

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

@@ -16,7 +16,6 @@
 import { ChangeDetectionStrategy, Component, ViewChild } from '@angular/core';
 import { BehaviorSubject, combineLatest, filter, map, startWith, Subject, switchMap, tap, } from 'rxjs';
 import { CarbonListComponent, CarbonListModule, ConfirmationModalModule, 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, IconModule, TagModule } from 'carbon-components-angular';
@@ -148,7 +147,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
             type: Component,
             args: [{ selector: 'valtimo-documenten-api-tags', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
                         CommonModule,
-                        DocumentenApiColumnModalComponent,
                         CarbonListModule,
                         TranslateModule,
                         ConfirmationModalModule,
@@ -161,4 +159,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 type: ViewChild,
                 args: [CarbonListComponent]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"documenten-api-tags.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/valtimo/zgw/src/lib/modules/documenten-api/components/documenten-api-tags/documenten-api-tags.component.ts","../../../../../../../../../projects/valtimo/zgw/src/lib/modules/documenten-api/components/documenten-api-tags/documenten-api-tags.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 {ChangeDetectionStrategy, Component, ViewChild} from '@angular/core';\nimport {DocumentenApiColumnModalTypeCloseEvent} from '../../models';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  filter,\n  map,\n  Observable,\n  startWith,\n  Subject,\n  switchMap,\n  tap,\n} from 'rxjs';\nimport {ActivatedRoute} from '@angular/router';\nimport {\n  ActionItem,\n  CarbonListComponent,\n  CarbonListItem,\n  CarbonListModule,\n  ColumnConfig,\n  ConfirmationModalModule,\n  Pagination,\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, IconModule, TagModule} from 'carbon-components-angular';\nimport {DocumentenApiTagService} from '../../services/documenten-api-tag.service';\nimport {DocumentenApiTag} from '../../models/documenten-api-tag.model';\nimport {DocumentenApiTagModalComponent} from '../documenten-api-tag-modal/documenten-api-tag-modal.component';\nimport {Page} from '@valtimo/document';\n\n@Component({\n  selector: 'valtimo-documenten-api-tags',\n  templateUrl: './documenten-api-tags.component.html',\n  styleUrls: ['./documenten-api-tags.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    DocumentenApiTagModalComponent,\n    IconModule,\n  ],\n})\nexport class DocumentenApiTagsComponent {\n  @ViewChild(CarbonListComponent) carbonList: CarbonListComponent;\n\n  private readonly _reload$ = new BehaviorSubject<null | 'noAnimation'>(null);\n  private readonly _documentDefinitionName$: Observable<string> = this.route.params.pipe(\n    map(params => params?.name),\n    filter(docDefName => !!docDefName)\n  );\n\n  public readonly loading$ = new BehaviorSubject<boolean>(true);\n  public readonly fields$ = new BehaviorSubject<ColumnConfig[]>([]);\n  public readonly addModalClosed$ = new BehaviorSubject<boolean>(true);\n  public readonly showDeleteMultipleModal$ = new BehaviorSubject<boolean>(false);\n  public readonly showDeleteModal$ = new Subject<boolean>();\n  public readonly selectedRowKeys$ = new BehaviorSubject<Array<string>>([]);\n  public readonly searchTerm$ = new BehaviorSubject<string>('');\n  public readonly tagToDelete$ = new BehaviorSubject<DocumentenApiTag | null>(null);\n\n  public get documentDefinitionName$(): Observable<string> {\n    return this._documentDefinitionName$;\n  }\n\n  public readonly documentTags$: Observable<DocumentenApiTag[]> = combineLatest([\n    this._documentDefinitionName$,\n    this.searchTerm$,\n    this._reload$,\n  ]).pipe(\n    tap(([_1, _2, reload]) => {\n      if (reload === null) {\n        this.loading$.next(true);\n      }\n    }),\n    switchMap(([documentDefinitionName, searchTerm]) =>\n      this.documentenApiTagService.getTagsForAdmin(documentDefinitionName, {\n        page: this.pagination.page - 1,\n        size: this.pagination.size,\n        search: searchTerm,\n      })\n    ),\n    map((tagPage: Page<DocumentenApiTag>) => {\n      this.pagination = {\n        ...this.pagination,\n        collectionSize: tagPage.totalElements,\n      };\n\n      return tagPage.content;\n    }),\n    startWith([]),\n    tap(() => {\n      this.loading$.next(false);\n    })\n  );\n\n  public readonly ACTION_ITEMS: ActionItem[] = [\n    {\n      label: 'interface.delete',\n      callback: this.openDeleteModal.bind(this),\n      type: 'danger',\n    },\n  ];\n\n  public readonly FIELDS: ColumnConfig[] = [\n    {\n      key: 'value',\n      label: 'zgw.tags.fields.value',\n      viewType: ViewType.TEXT,\n    },\n  ];\n\n  public pagination: Pagination = {\n    collectionSize: 0,\n    page: 1,\n    size: 10,\n  };\n\n  constructor(\n    private readonly route: ActivatedRoute,\n    private readonly documentenApiTagService: DocumentenApiTagService\n  ) {}\n\n  public openDeleteModal(tag: DocumentenApiTag): void {\n    this.tagToDelete$.next(tag);\n    this.showDeleteModal$.next(true);\n  }\n\n  public openAddModal(): void {\n    this.addModalClosed$.next(false);\n  }\n\n  public closeModal(closeModalEvent: DocumentenApiColumnModalTypeCloseEvent): void {\n    if (closeModalEvent === 'closeAndRefresh') {\n      this.reload();\n    }\n    this.addModalClosed$.next(true);\n  }\n\n  public showDeleteMultipleModal(): void {\n    this.setSelectedRoleKeys();\n    this.showDeleteMultipleModal$.next(true);\n  }\n\n  private setSelectedRoleKeys(): void {\n    this.selectedRowKeys$.next(\n      this.carbonList.selectedItems.map((item: CarbonListItem) => item.value)\n    );\n  }\n\n  public paginationClicked(page: number): void {\n    this.pagination = {...this.pagination, page};\n    this.reload();\n  }\n\n  public paginationSet(size: number): void {\n    this.pagination = {...this.pagination, size};\n    this.reload();\n  }\n\n  public confirmDeleteTag(tag: DocumentenApiTag): void {\n    this.documentDefinitionName$\n      .pipe(\n        switchMap(documentDefinitionName =>\n          this.documentenApiTagService.deleteTag(documentDefinitionName, tag.value)\n        )\n      )\n      .subscribe(() => {\n        this.reload();\n      });\n  }\n\n  public confirmDeleteMultipleTag(tagsToDelete: {\n    documentDefinitionName: string;\n    tagIds: string[];\n    itemsOnCurrentPage: number;\n  }): void {\n    this.documentenApiTagService\n      .deleteTags(tagsToDelete.documentDefinitionName, tagsToDelete.tagIds)\n      .subscribe(() => {\n        const lastPage = Math.ceil(\n          (this.pagination.collectionSize as number) / this.pagination.size\n        );\n        if (\n          tagsToDelete.itemsOnCurrentPage <= tagsToDelete.tagIds.length &&\n          this.pagination.page > 1 &&\n          this.pagination.page === lastPage\n        ) {\n          this.pagination = {...this.pagination, page: this.pagination.page - 1};\n        }\n        this.reload();\n      });\n  }\n\n  public searchTermEntered(searchTerm: string): void {\n    this.pagination = {...this.pagination, page: 1};\n    this.searchTerm$.next(searchTerm);\n  }\n\n  private reload(noAnimation = false): void {\n    this._reload$.next(noAnimation ? 'noAnimation' : null);\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<ng-container\n  *ngIf=\"{\n    loading: loading$ | async,\n    documentTags: documentTags$ | async,\n    addModalClosed: addModalClosed$ | async,\n    documentDefinitionName: documentDefinitionName$ | async,\n    selectedRowKeys: selectedRowKeys$ | async,\n    searchTerm: searchTerm$ | async,\n    showDeleteModal: showDeleteModal$ | async,\n    tagToDelete: tagToDelete$ | async,\n  } as obs\"\n>\n  <valtimo-carbon-list\n    [items]=\"obs.documentTags\"\n    [fields]=\"FIELDS\"\n    [header]=\"false\"\n    [loading]=\"obs.loading\"\n    [actionItems]=\"ACTION_ITEMS\"\n    [showSelectionColumn]=\"true\"\n    [isSearchable]=\"true\"\n    [pagination]=\"pagination\"\n    (paginationClicked)=\"paginationClicked($event)\"\n    (paginationSet)=\"paginationSet($event)\"\n    (search)=\"searchTermEntered($event)\"\n  >\n    <ng-container carbonToolbarContent *ngTemplateOutlet=\"addButtton\"></ng-container>\n\n    <ng-container carbonToolbarActions>\n      <button cdsButton=\"primary\" (click)=\"showDeleteMultipleModal()\">\n        {{ 'interface.delete' | translate }}\n        <svg class=\"cds--btn__icon\" cdsIcon=\"trash-can\" size=\"16\"></svg>\n      </button>\n    </ng-container>\n\n    <valtimo-no-results\n      *ngIf=\"obs.searchTerm === ''\"\n      [action]=\"addButtton\"\n      title=\"{{ 'zgw.tags.list.noResultsTitle' | translate }}\"\n      description=\"{{ 'zgw.tags.list.noResultsDescription' | translate }}\"\n    ></valtimo-no-results>\n\n    <valtimo-no-results\n      *ngIf=\"obs.searchTerm !== ''\"\n      title=\"{{ 'zgw.tags.search.noResultsTitle' | translate }}\"\n      description=\"{{ 'zgw.tags.search.noResultsDescription' | translate }}\"\n      illustration=\"valtimo-layout/img/emptystate-no-result.svg\"\n    ></valtimo-no-results>\n  </valtimo-carbon-list>\n\n  <valtimo-documenten-api-tag-modal\n    [open]=\"!obs.addModalClosed\"\n    [documentDefinitionName]=\"obs.documentDefinitionName\"\n    (closeModalEvent)=\"closeModal($event)\"\n  ></valtimo-documenten-api-tag-modal>\n\n  <valtimo-confirmation-modal\n    confirmButtonTextTranslationKey=\"interface.delete\"\n    confirmButtonType=\"danger\"\n    contentTranslationKey=\"zgw.tags.deleteText\"\n    [showModalSubject$]=\"showDeleteModal$\"\n    titleTranslationKey=\"interface.delete\"\n    [outputOnConfirm]=\"obs.tagToDelete\"\n    (confirmEvent)=\"confirmDeleteTag($event)\"\n  ></valtimo-confirmation-modal>\n\n  <valtimo-confirmation-modal\n    confirmButtonTextTranslationKey=\"interface.delete\"\n    confirmButtonType=\"danger\"\n    [contentTranslationKey]=\"\n      obs.selectedRowKeys.length > 1 ? 'zgw.tags.deleteMultipleText' : 'zgw.tags.deleteText'\n    \"\n    [showModalSubject$]=\"showDeleteMultipleModal$\"\n    titleTranslationKey=\"interface.delete\"\n    [outputOnConfirm]=\"{\n      documentDefinitionName: obs.documentDefinitionName,\n      tagIds: obs.selectedRowKeys,\n      itemsOnCurrentPage: obs.documentTags.length,\n    }\"\n    (confirmEvent)=\"confirmDeleteMultipleTag($event)\"\n  ></valtimo-confirmation-modal>\n\n  <ng-template #addButtton>\n    <button cdsButton=\"primary\" [disabled]=\"obs.loading\" (click)=\"openAddModal()\">\n      <svg cdsIcon=\"add\" size=\"16\" class=\"cds--btn__icon\"></svg>\n      {{ 'zgw.tags.add' | translate }}\n    </button>\n  </ng-template>\n</ng-container>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"documenten-api-tags.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/valtimo/zgw/src/lib/modules/documenten-api/components/documenten-api-tags/documenten-api-tags.component.ts","../../../../../../../../../projects/valtimo/zgw/src/lib/modules/documenten-api/components/documenten-api-tags/documenten-api-tags.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 {ChangeDetectionStrategy, Component, ViewChild} from '@angular/core';\nimport {DocumentenApiColumnModalTypeCloseEvent} from '../../models';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  filter,\n  map,\n  Observable,\n  startWith,\n  Subject,\n  switchMap,\n  tap,\n} from 'rxjs';\nimport {ActivatedRoute} from '@angular/router';\nimport {\n  ActionItem,\n  CarbonListComponent,\n  CarbonListItem,\n  CarbonListModule,\n  ColumnConfig,\n  ConfirmationModalModule,\n  Pagination,\n  ViewType,\n} from '@valtimo/components';\nimport {CommonModule} from '@angular/common';\nimport {TranslateModule} from '@ngx-translate/core';\nimport {ButtonModule, IconModule, TagModule} from 'carbon-components-angular';\nimport {DocumentenApiTagService} from '../../services/documenten-api-tag.service';\nimport {DocumentenApiTag} from '../../models/documenten-api-tag.model';\nimport {DocumentenApiTagModalComponent} from '../documenten-api-tag-modal/documenten-api-tag-modal.component';\nimport {Page} from '@valtimo/document';\n\n@Component({\n  selector: 'valtimo-documenten-api-tags',\n  templateUrl: './documenten-api-tags.component.html',\n  styleUrls: ['./documenten-api-tags.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    CommonModule,\n    CarbonListModule,\n    TranslateModule,\n    ConfirmationModalModule,\n    TagModule,\n    ButtonModule,\n    DocumentenApiTagModalComponent,\n    IconModule,\n  ],\n})\nexport class DocumentenApiTagsComponent {\n  @ViewChild(CarbonListComponent) carbonList: CarbonListComponent;\n\n  private readonly _reload$ = new BehaviorSubject<null | 'noAnimation'>(null);\n  private readonly _documentDefinitionName$: Observable<string> = this.route.params.pipe(\n    map(params => params?.name),\n    filter(docDefName => !!docDefName)\n  );\n\n  public readonly loading$ = new BehaviorSubject<boolean>(true);\n  public readonly fields$ = new BehaviorSubject<ColumnConfig[]>([]);\n  public readonly addModalClosed$ = new BehaviorSubject<boolean>(true);\n  public readonly showDeleteMultipleModal$ = new BehaviorSubject<boolean>(false);\n  public readonly showDeleteModal$ = new Subject<boolean>();\n  public readonly selectedRowKeys$ = new BehaviorSubject<Array<string>>([]);\n  public readonly searchTerm$ = new BehaviorSubject<string>('');\n  public readonly tagToDelete$ = new BehaviorSubject<DocumentenApiTag | null>(null);\n\n  public get documentDefinitionName$(): Observable<string> {\n    return this._documentDefinitionName$;\n  }\n\n  public readonly documentTags$: Observable<DocumentenApiTag[]> = combineLatest([\n    this._documentDefinitionName$,\n    this.searchTerm$,\n    this._reload$,\n  ]).pipe(\n    tap(([_1, _2, reload]) => {\n      if (reload === null) {\n        this.loading$.next(true);\n      }\n    }),\n    switchMap(([documentDefinitionName, searchTerm]) =>\n      this.documentenApiTagService.getTagsForAdmin(documentDefinitionName, {\n        page: this.pagination.page - 1,\n        size: this.pagination.size,\n        search: searchTerm,\n      })\n    ),\n    map((tagPage: Page<DocumentenApiTag>) => {\n      this.pagination = {\n        ...this.pagination,\n        collectionSize: tagPage.totalElements,\n      };\n\n      return tagPage.content;\n    }),\n    startWith([]),\n    tap(() => {\n      this.loading$.next(false);\n    })\n  );\n\n  public readonly ACTION_ITEMS: ActionItem[] = [\n    {\n      label: 'interface.delete',\n      callback: this.openDeleteModal.bind(this),\n      type: 'danger',\n    },\n  ];\n\n  public readonly FIELDS: ColumnConfig[] = [\n    {\n      key: 'value',\n      label: 'zgw.tags.fields.value',\n      viewType: ViewType.TEXT,\n    },\n  ];\n\n  public pagination: Pagination = {\n    collectionSize: 0,\n    page: 1,\n    size: 10,\n  };\n\n  constructor(\n    private readonly route: ActivatedRoute,\n    private readonly documentenApiTagService: DocumentenApiTagService\n  ) {}\n\n  public openDeleteModal(tag: DocumentenApiTag): void {\n    this.tagToDelete$.next(tag);\n    this.showDeleteModal$.next(true);\n  }\n\n  public openAddModal(): void {\n    this.addModalClosed$.next(false);\n  }\n\n  public closeModal(closeModalEvent: DocumentenApiColumnModalTypeCloseEvent): void {\n    if (closeModalEvent === 'closeAndRefresh') {\n      this.reload();\n    }\n    this.addModalClosed$.next(true);\n  }\n\n  public showDeleteMultipleModal(): void {\n    this.setSelectedRoleKeys();\n    this.showDeleteMultipleModal$.next(true);\n  }\n\n  private setSelectedRoleKeys(): void {\n    this.selectedRowKeys$.next(\n      this.carbonList.selectedItems.map((item: CarbonListItem) => item.value)\n    );\n  }\n\n  public paginationClicked(page: number): void {\n    this.pagination = {...this.pagination, page};\n    this.reload();\n  }\n\n  public paginationSet(size: number): void {\n    this.pagination = {...this.pagination, size};\n    this.reload();\n  }\n\n  public confirmDeleteTag(tag: DocumentenApiTag): void {\n    this.documentDefinitionName$\n      .pipe(\n        switchMap(documentDefinitionName =>\n          this.documentenApiTagService.deleteTag(documentDefinitionName, tag.value)\n        )\n      )\n      .subscribe(() => {\n        this.reload();\n      });\n  }\n\n  public confirmDeleteMultipleTag(tagsToDelete: {\n    documentDefinitionName: string;\n    tagIds: string[];\n    itemsOnCurrentPage: number;\n  }): void {\n    this.documentenApiTagService\n      .deleteTags(tagsToDelete.documentDefinitionName, tagsToDelete.tagIds)\n      .subscribe(() => {\n        const lastPage = Math.ceil(\n          (this.pagination.collectionSize as number) / this.pagination.size\n        );\n        if (\n          tagsToDelete.itemsOnCurrentPage <= tagsToDelete.tagIds.length &&\n          this.pagination.page > 1 &&\n          this.pagination.page === lastPage\n        ) {\n          this.pagination = {...this.pagination, page: this.pagination.page - 1};\n        }\n        this.reload();\n      });\n  }\n\n  public searchTermEntered(searchTerm: string): void {\n    this.pagination = {...this.pagination, page: 1};\n    this.searchTerm$.next(searchTerm);\n  }\n\n  private reload(noAnimation = false): void {\n    this._reload$.next(noAnimation ? 'noAnimation' : null);\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<ng-container\n  *ngIf=\"{\n    loading: loading$ | async,\n    documentTags: documentTags$ | async,\n    addModalClosed: addModalClosed$ | async,\n    documentDefinitionName: documentDefinitionName$ | async,\n    selectedRowKeys: selectedRowKeys$ | async,\n    searchTerm: searchTerm$ | async,\n    showDeleteModal: showDeleteModal$ | async,\n    tagToDelete: tagToDelete$ | async,\n  } as obs\"\n>\n  <valtimo-carbon-list\n    [items]=\"obs.documentTags\"\n    [fields]=\"FIELDS\"\n    [header]=\"false\"\n    [loading]=\"obs.loading\"\n    [actionItems]=\"ACTION_ITEMS\"\n    [showSelectionColumn]=\"true\"\n    [isSearchable]=\"true\"\n    [pagination]=\"pagination\"\n    (paginationClicked)=\"paginationClicked($event)\"\n    (paginationSet)=\"paginationSet($event)\"\n    (search)=\"searchTermEntered($event)\"\n  >\n    <ng-container carbonToolbarContent *ngTemplateOutlet=\"addButtton\"></ng-container>\n\n    <ng-container carbonToolbarActions>\n      <button cdsButton=\"primary\" (click)=\"showDeleteMultipleModal()\">\n        {{ 'interface.delete' | translate }}\n        <svg class=\"cds--btn__icon\" cdsIcon=\"trash-can\" size=\"16\"></svg>\n      </button>\n    </ng-container>\n\n    <valtimo-no-results\n      *ngIf=\"obs.searchTerm === ''\"\n      [action]=\"addButtton\"\n      title=\"{{ 'zgw.tags.list.noResultsTitle' | translate }}\"\n      description=\"{{ 'zgw.tags.list.noResultsDescription' | translate }}\"\n    ></valtimo-no-results>\n\n    <valtimo-no-results\n      *ngIf=\"obs.searchTerm !== ''\"\n      title=\"{{ 'zgw.tags.search.noResultsTitle' | translate }}\"\n      description=\"{{ 'zgw.tags.search.noResultsDescription' | translate }}\"\n      illustration=\"valtimo-layout/img/emptystate-no-result.svg\"\n    ></valtimo-no-results>\n  </valtimo-carbon-list>\n\n  <valtimo-documenten-api-tag-modal\n    [open]=\"!obs.addModalClosed\"\n    [documentDefinitionName]=\"obs.documentDefinitionName\"\n    (closeModalEvent)=\"closeModal($event)\"\n  ></valtimo-documenten-api-tag-modal>\n\n  <valtimo-confirmation-modal\n    confirmButtonTextTranslationKey=\"interface.delete\"\n    confirmButtonType=\"danger\"\n    contentTranslationKey=\"zgw.tags.deleteText\"\n    [showModalSubject$]=\"showDeleteModal$\"\n    titleTranslationKey=\"interface.delete\"\n    [outputOnConfirm]=\"obs.tagToDelete\"\n    (confirmEvent)=\"confirmDeleteTag($event)\"\n  ></valtimo-confirmation-modal>\n\n  <valtimo-confirmation-modal\n    confirmButtonTextTranslationKey=\"interface.delete\"\n    confirmButtonType=\"danger\"\n    [contentTranslationKey]=\"\n      obs.selectedRowKeys.length > 1 ? 'zgw.tags.deleteMultipleText' : 'zgw.tags.deleteText'\n    \"\n    [showModalSubject$]=\"showDeleteMultipleModal$\"\n    titleTranslationKey=\"interface.delete\"\n    [outputOnConfirm]=\"{\n      documentDefinitionName: obs.documentDefinitionName,\n      tagIds: obs.selectedRowKeys,\n      itemsOnCurrentPage: obs.documentTags.length,\n    }\"\n    (confirmEvent)=\"confirmDeleteMultipleTag($event)\"\n  ></valtimo-confirmation-modal>\n\n  <ng-template #addButtton>\n    <button cdsButton=\"primary\" [disabled]=\"obs.loading\" (click)=\"openAddModal()\">\n      <svg cdsIcon=\"add\" size=\"16\" class=\"cds--btn__icon\"></svg>\n      {{ 'zgw.tags.add' | translate }}\n    </button>\n  </ng-template>\n</ng-container>\n"]}

package/esm2022/lib/modules/documenten-api/components/documenten-api-upload-field-model/documenten-api-upload-field-modal.component.mjs

@@ -0,0 +1,182 @@
+/*
+ * 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, EventEmitter, Input, Output, } from '@angular/core';
+import { CONFIDENTIALITY_LEVELS, LANGUAGE_ITEMS, STATUS_ITEMS, } from '../../models';
+import { BehaviorSubject, combineLatest, map, of, Subscription, switchMap } from 'rxjs';
+import { CARBON_CONSTANTS } from '@valtimo/components';
+import { ReactiveFormsModule, Validators } from '@angular/forms';
+import { ButtonModule, CheckboxModule, ComboBoxModule, InputModule, ModalModule, ToggleModule, } from 'carbon-components-angular';
+import { TranslateModule } from '@ngx-translate/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "../../services";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "@valtimo/document";
+import * as i5 from "@angular/common";
+import * as i6 from "carbon-components-angular";
+export class DocumentenApiUploadFieldModalComponent {
+    set prefill(field) {
+        if (field) {
+            this.key = field.key;
+            this.defaultValue.setValue(field.defaultValue);
+            this.visible.setValue(field.visible);
+            this.readonly.setValue(field.readonly);
+        }
+    }
+    get defaultValue() {
+        return this.formGroup?.get('defaultValue');
+    }
+    get selectedDefaultValue() {
+        return this.formGroup?.get('selectedDefaultValue');
+    }
+    get visible() {
+        return this.formGroup?.get('visible');
+    }
+    get readonly() {
+        return this.formGroup?.get('readonly');
+    }
+    get invalid() {
+        return !!this.formGroup?.invalid;
+    }
+    constructor(fb, documentenApiDocumentService, translateService, documentService) {
+        this.fb = fb;
+        this.documentenApiDocumentService = documentenApiDocumentService;
+        this.translateService = translateService;
+        this.documentService = documentService;
+        this.closeModalEvent = new EventEmitter();
+        this.formGroup = this.fb.group({
+            defaultValue: this.fb.control('', [Validators.maxLength(256)]),
+            selectedDefaultValue: this.fb.control(null),
+            visible: this.fb.control(true, [Validators.required]),
+            readonly: this.fb.control(false, [Validators.required]),
+        });
+        this.disabled$ = new BehaviorSubject(false);
+        this.confidentialityLevelItems$ = combineLatest([
+            this.defaultValue.valueChanges,
+            this.translateService.stream('key'),
+        ]).pipe(map(([selectedItem]) => CONFIDENTIALITY_LEVELS.map(item => ({
+            id: item,
+            content: this.translateService.instant(`document.${item}`),
+            selected: selectedItem === item,
+        }))));
+        this.languageItems$ = combineLatest([
+            this.defaultValue.valueChanges,
+            this.translateService.stream('key'),
+        ]).pipe(map(([selectedItem]) => LANGUAGE_ITEMS.map(item => ({
+            id: item,
+            content: this.translateService.instant(`document.${item}`),
+            selected: selectedItem === item,
+        }))));
+        this.statusItems$ = combineLatest([
+            this.defaultValue.valueChanges,
+            this.translateService.stream('key'),
+        ]).pipe(map(([selectedItem]) => STATUS_ITEMS.map(item => ({
+            id: item,
+            content: this.translateService.instant(`document.${item}`),
+            selected: selectedItem === item,
+        }))));
+        this.documentTypeItems$ = combineLatest([
+            this.defaultValue.valueChanges,
+            this.translateService.stream('key'),
+        ]).pipe(switchMap(([selectedItem]) => combineLatest([
+            this.documentService.getDocumentTypes(this.documentDefinitionName),
+            of(selectedItem),
+        ])), map(([documentTypes, selectedItem]) => documentTypes.map(item => ({
+            id: item.url,
+            content: item.name,
+            selected: selectedItem === item.url,
+        }))));
+        this._subscriptions = new Subscription();
+    }
+    ngOnDestroy() {
+        this._subscriptions.unsubscribe();
+    }
+    onClose() {
+        this.close();
+    }
+    clear() {
+        this.selectedDefaultValue.setValue(null);
+        this.defaultValue.setValue(null);
+    }
+    saveUploadField() {
+        this.disable();
+        const formField = {
+            key: this.key,
+            defaultValue: this.selectedDefaultValue?.value?.id || this.defaultValue.value,
+            visible: this.visible.value,
+            readonly: this.readonly.value,
+        };
+        this.documentenApiDocumentService
+            .updateUploadField(this.documentDefinitionName, formField)
+            .subscribe({
+            next: () => {
+                this.enable();
+                this.closeAndRefresh();
+                this.resetForm();
+            },
+            error: () => {
+                this.enable(false);
+            },
+        });
+    }
+    resetForm() {
+        this.formGroup.reset();
+    }
+    disable() {
+        this.disabled$.next(true);
+        this.formGroup.disable();
+    }
+    enable(delay = true) {
+        setTimeout(() => {
+            this.disabled$.next(false);
+            this.formGroup.enable();
+        }, delay ? CARBON_CONSTANTS.modalAnimationMs : 0);
+    }
+    close() {
+        this.closeModalEvent.emit('close');
+        this.resetForm();
+    }
+    closeAndRefresh() {
+        this.closeModalEvent.emit('closeAndRefresh');
+        this.resetForm();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DocumentenApiUploadFieldModalComponent, deps: [{ token: i1.FormBuilder }, { token: i2.DocumentenApiDocumentService }, { token: i3.TranslateService }, { token: i4.DocumentService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: DocumentenApiUploadFieldModalComponent, isStandalone: true, selector: "valtimo-documenten-api-upload-field-modal", inputs: { documentDefinitionName: "documentDefinitionName", type: "type", prefill: "prefill" }, outputs: { closeModalEvent: "closeModalEvent" }, 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<cds-modal\n  valtimoCdsModal\n  *ngIf=\"{\n    disabled: disabled$ | async,\n    languageItems: languageItems$ | async,\n    confidentialityLevelItems: confidentialityLevelItems$ | async,\n    statusItems: statusItems$ | async,\n    documentTypeItems: documentTypeItems$ | async,\n  } as obs\"\n  [open]=\"type !== 'closed'\"\n  size=\"sm\"\n>\n  <cds-modal-header showCloseButton=\"true\" (closeSelect)=\"onClose()\">\n    <h3 cdsModalHeaderHeading>\n      {{\n        ('zgw.uploadFields.editModal.header' | translate) +\n          ' - ' +\n          ('zgw.uploadFields.keys.' + key | translate)\n      }}\n    </h3>\n  </cds-modal-header>\n\n  <section cdsModalContent>\n    <form [formGroup]=\"formGroup\" class=\"uploadField-form\">\n      @if (key === 'taal') {\n        <cds-combo-box\n          formControlName=\"selectedDefaultValue\"\n          [label]=\"'zgw.uploadFields.fields.defaultValue' | translate\"\n          [dropUp]=\"false\"\n          (clear)=\"clear()\"\n        >\n          <cds-dropdown-list [items]=\"obs.languageItems\"></cds-dropdown-list>\n        </cds-combo-box>\n      } @else if (key === 'vertrouwelijkheidaanduiding') {\n        <cds-combo-box\n          formControlName=\"selectedDefaultValue\"\n          [label]=\"'zgw.uploadFields.fields.defaultValue' | translate\"\n          [dropUp]=\"false\"\n          (clear)=\"clear()\"\n        >\n          <cds-dropdown-list [items]=\"obs.confidentialityLevelItems\"></cds-dropdown-list>\n        </cds-combo-box>\n      } @else if (key === 'status') {\n        <cds-combo-box\n          formControlName=\"selectedDefaultValue\"\n          [label]=\"'zgw.uploadFields.fields.defaultValue' | translate\"\n          [dropUp]=\"false\"\n          (clear)=\"clear()\"\n        >\n          <cds-dropdown-list [items]=\"obs.statusItems\"></cds-dropdown-list>\n        </cds-combo-box>\n      } @else if (key === 'informatieobjecttype') {\n        <cds-combo-box\n          formControlName=\"selectedDefaultValue\"\n          [label]=\"'zgw.uploadFields.fields.defaultValue' | translate\"\n          [dropUp]=\"false\"\n          (clear)=\"clear()\"\n        >\n          <cds-dropdown-list [items]=\"obs.documentTypeItems\"></cds-dropdown-list>\n        </cds-combo-box>\n      } @else if (\n        key === 'filename' ||\n        key === 'bestandsnaam' ||\n        key === 'titel' ||\n        key === 'beschrijving' ||\n        key === 'trefwoorden'\n      ) {\n        <cds-label>\n          {{ 'zgw.uploadFields.fields.defaultValue' | translate }}\n          <input cdsText formControlName=\"defaultValue\" />\n        </cds-label>\n      }\n      <div class=\"toggle-group\">\n        <cds-toggle\n          formControlName=\"visible\"\n          [label]=\"'zgw.uploadFields.fields.visible' | translate\"\n          [onText]=\"'interface.on' | translate\"\n          [offText]=\"'interface.off' | translate\"\n        ></cds-toggle>\n        <cds-toggle\n          formControlName=\"readonly\"\n          [label]=\"'zgw.uploadFields.fields.readonly' | translate\"\n          [onText]=\"'interface.on' | translate\"\n          [offText]=\"'interface.off' | translate\"\n        ></cds-toggle>\n      </div>\n    </form>\n  </section>\n\n  <cds-modal-footer>\n    <button cdsButton=\"secondary\" (click)=\"onClose()\" [disabled]=\"obs.disabled\">\n      {{ 'interface.cancel' | translate }}\n    </button>\n\n    <button cdsButton=\"primary\" [disabled]=\"invalid || obs.disabled\" (click)=\"saveUploadField()\">\n      {{ 'interface.save' | translate }}\n    </button>\n  </cds-modal-footer>\n</cds-modal>\n", styles: [".toggle-group{display:flex;flex-direction:column;margin-top:16px}\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: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }, { kind: "ngmodule", type: ModalModule }, { kind: "component", type: i6.Modal, selector: "cds-modal, ibm-modal", inputs: ["size", "theme", "ariaLabel", "open", "trigger", "hasScrollingContent"], outputs: ["overlaySelected", "close"] }, { kind: "component", type: i6.ModalHeader, selector: "cds-modal-header, ibm-modal-header", inputs: ["theme", "closeLabel", "showCloseButton"], outputs: ["closeSelect"] }, { kind: "component", type: i6.ModalFooter, selector: "cds-modal-footer, ibm-modal-footer" }, { kind: "directive", type: i6.ModalContent, selector: "[cdsModalContent], [ibmModalContent]", inputs: ["hasForm"] }, { kind: "directive", type: i6.ModalHeaderHeading, selector: "[cdsModalHeaderHeading], [ibmModalHeaderHeading]" }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i3.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: InputModule }, { kind: "component", type: i6.Label, selector: "cds-label, ibm-label", inputs: ["labelInputID", "disabled", "skeleton", "helperText", "invalidText", "invalid", "warn", "warnText", "ariaLabel"] }, { kind: "directive", type: i6.TextInput, selector: "[cdsText], [ibmText]", inputs: ["theme", "size", "invalid", "warn", "skeleton"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "ngmodule", type: ButtonModule }, { kind: "directive", type: i6.Button, selector: "[cdsButton], [ibmButton]", inputs: ["ibmButton", "cdsButton", "size", "skeleton", "iconOnly", "isExpressive"] }, { kind: "ngmodule", type: ToggleModule }, { kind: "component", type: i6.Toggle, selector: "cds-toggle, ibm-toggle", inputs: ["offText", "onText", "label", "size", "hideLabel", "skeleton"] }, { kind: "ngmodule", type: CheckboxModule }, { kind: "ngmodule", type: ComboBoxModule }, { kind: "component", type: i6.ComboBox, selector: "cds-combo-box, ibm-combo-box", inputs: ["placeholder", "openMenuAria", "closeMenuAria", "clearSelectionsTitle", "clearSelectionsAria", "clearSelectionTitle", "clearSelectionAria", "id", "labelId", "items", "type", "size", "itemValueKey", "label", "hideLabel", "helperText", "appendInline", "invalid", "invalidText", "warn", "warnText", "maxLength", "theme", "selectionFeedback", "autocomplete", "dropUp", "disabled"], outputs: ["selected", "submit", "close", "search", "clear"] }, { kind: "component", type: i6.DropdownList, selector: "cds-dropdown-list, ibm-dropdown-list", inputs: ["ariaLabel", "items", "listTpl", "type", "showTitles"], outputs: ["select", "scroll", "blurIntent"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DocumentenApiUploadFieldModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'valtimo-documenten-api-upload-field-modal', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                        CommonModule,
+                        ModalModule,
+                        TranslateModule,
+                        InputModule,
+                        ReactiveFormsModule,
+                        ButtonModule,
+                        ToggleModule,
+                        CheckboxModule,
+                        ComboBoxModule,
+                    ], 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<cds-modal\n  valtimoCdsModal\n  *ngIf=\"{\n    disabled: disabled$ | async,\n    languageItems: languageItems$ | async,\n    confidentialityLevelItems: confidentialityLevelItems$ | async,\n    statusItems: statusItems$ | async,\n    documentTypeItems: documentTypeItems$ | async,\n  } as obs\"\n  [open]=\"type !== 'closed'\"\n  size=\"sm\"\n>\n  <cds-modal-header showCloseButton=\"true\" (closeSelect)=\"onClose()\">\n    <h3 cdsModalHeaderHeading>\n      {{\n        ('zgw.uploadFields.editModal.header' | translate) +\n          ' - ' +\n          ('zgw.uploadFields.keys.' + key | translate)\n      }}\n    </h3>\n  </cds-modal-header>\n\n  <section cdsModalContent>\n    <form [formGroup]=\"formGroup\" class=\"uploadField-form\">\n      @if (key === 'taal') {\n        <cds-combo-box\n          formControlName=\"selectedDefaultValue\"\n          [label]=\"'zgw.uploadFields.fields.defaultValue' | translate\"\n          [dropUp]=\"false\"\n          (clear)=\"clear()\"\n        >\n          <cds-dropdown-list [items]=\"obs.languageItems\"></cds-dropdown-list>\n        </cds-combo-box>\n      } @else if (key === 'vertrouwelijkheidaanduiding') {\n        <cds-combo-box\n          formControlName=\"selectedDefaultValue\"\n          [label]=\"'zgw.uploadFields.fields.defaultValue' | translate\"\n          [dropUp]=\"false\"\n          (clear)=\"clear()\"\n        >\n          <cds-dropdown-list [items]=\"obs.confidentialityLevelItems\"></cds-dropdown-list>\n        </cds-combo-box>\n      } @else if (key === 'status') {\n        <cds-combo-box\n          formControlName=\"selectedDefaultValue\"\n          [label]=\"'zgw.uploadFields.fields.defaultValue' | translate\"\n          [dropUp]=\"false\"\n          (clear)=\"clear()\"\n        >\n          <cds-dropdown-list [items]=\"obs.statusItems\"></cds-dropdown-list>\n        </cds-combo-box>\n      } @else if (key === 'informatieobjecttype') {\n        <cds-combo-box\n          formControlName=\"selectedDefaultValue\"\n          [label]=\"'zgw.uploadFields.fields.defaultValue' | translate\"\n          [dropUp]=\"false\"\n          (clear)=\"clear()\"\n        >\n          <cds-dropdown-list [items]=\"obs.documentTypeItems\"></cds-dropdown-list>\n        </cds-combo-box>\n      } @else if (\n        key === 'filename' ||\n        key === 'bestandsnaam' ||\n        key === 'titel' ||\n        key === 'beschrijving' ||\n        key === 'trefwoorden'\n      ) {\n        <cds-label>\n          {{ 'zgw.uploadFields.fields.defaultValue' | translate }}\n          <input cdsText formControlName=\"defaultValue\" />\n        </cds-label>\n      }\n      <div class=\"toggle-group\">\n        <cds-toggle\n          formControlName=\"visible\"\n          [label]=\"'zgw.uploadFields.fields.visible' | translate\"\n          [onText]=\"'interface.on' | translate\"\n          [offText]=\"'interface.off' | translate\"\n        ></cds-toggle>\n        <cds-toggle\n          formControlName=\"readonly\"\n          [label]=\"'zgw.uploadFields.fields.readonly' | translate\"\n          [onText]=\"'interface.on' | translate\"\n          [offText]=\"'interface.off' | translate\"\n        ></cds-toggle>\n      </div>\n    </form>\n  </section>\n\n  <cds-modal-footer>\n    <button cdsButton=\"secondary\" (click)=\"onClose()\" [disabled]=\"obs.disabled\">\n      {{ 'interface.cancel' | translate }}\n    </button>\n\n    <button cdsButton=\"primary\" [disabled]=\"invalid || obs.disabled\" (click)=\"saveUploadField()\">\n      {{ 'interface.save' | translate }}\n    </button>\n  </cds-modal-footer>\n</cds-modal>\n", styles: [".toggle-group{display:flex;flex-direction:column;margin-top:16px}\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.FormBuilder }, { type: i2.DocumentenApiDocumentService }, { type: i3.TranslateService }, { type: i4.DocumentService }], propDecorators: { documentDefinitionName: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], prefill: [{
+                type: Input
+            }], closeModalEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"documenten-api-upload-field-modal.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/valtimo/zgw/src/lib/modules/documenten-api/components/documenten-api-upload-field-model/documenten-api-upload-field-modal.component.ts","../../../../../../../../../projects/valtimo/zgw/src/lib/modules/documenten-api/components/documenten-api-upload-field-model/documenten-api-upload-field-modal.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  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Output,\n} from '@angular/core';\nimport {\n  CONFIDENTIALITY_LEVELS,\n  DocumentenApiColumnModalTypeCloseEvent,\n  LANGUAGE_ITEMS,\n  STATUS_ITEMS,\n} from '../../models';\nimport {BehaviorSubject, combineLatest, map, Observable, of, Subscription, switchMap} from 'rxjs';\nimport {CARBON_CONSTANTS} from '@valtimo/components';\nimport {AbstractControl, FormBuilder, ReactiveFormsModule, Validators} from '@angular/forms';\nimport {\n  ButtonModule,\n  CheckboxModule,\n  ComboBoxModule,\n  InputModule,\n  ListItem,\n  ModalModule,\n  ToggleModule,\n} from 'carbon-components-angular';\nimport {TranslateModule, TranslateService} from '@ngx-translate/core';\nimport {CommonModule} from '@angular/common';\nimport {DocumentenApiDocumentService} from '../../services';\nimport {DocumentenApiUploadField} from '../../models/documenten-api-upload-field.model';\nimport {DocumentService} from '@valtimo/document';\n\n@Component({\n  selector: 'valtimo-documenten-api-upload-field-modal',\n  styleUrl: './documenten-api-upload-field-modal.component.scss',\n  templateUrl: './documenten-api-upload-field-modal.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    CommonModule,\n    ModalModule,\n    TranslateModule,\n    InputModule,\n    ReactiveFormsModule,\n    ButtonModule,\n    ToggleModule,\n    CheckboxModule,\n    ComboBoxModule,\n  ],\n})\nexport class DocumentenApiUploadFieldModalComponent implements OnDestroy {\n  @Input() public documentDefinitionName!: string;\n  @Input() public type!: string;\n  protected key: string;\n\n  @Input() public set prefill(field: DocumentenApiUploadField) {\n    if (field) {\n      this.key = field.key;\n      this.defaultValue.setValue(field.defaultValue);\n      this.visible.setValue(field.visible);\n      this.readonly.setValue(field.readonly);\n    }\n  }\n\n  @Output() public closeModalEvent = new EventEmitter<DocumentenApiColumnModalTypeCloseEvent>();\n\n  public readonly formGroup = this.fb.group({\n    defaultValue: this.fb.control('', [Validators.maxLength(256)]),\n    selectedDefaultValue: this.fb.control(null),\n    visible: this.fb.control(true, [Validators.required]),\n    readonly: this.fb.control(false, [Validators.required]),\n  });\n\n  public readonly disabled$ = new BehaviorSubject<boolean>(false);\n\n  public readonly confidentialityLevelItems$: Observable<Array<ListItem>> = combineLatest([\n    this.defaultValue.valueChanges,\n    this.translateService.stream('key'),\n  ]).pipe(\n    map(([selectedItem]) =>\n      CONFIDENTIALITY_LEVELS.map(item => ({\n        id: item,\n        content: this.translateService.instant(`document.${item}`),\n        selected: selectedItem === item,\n      }))\n    )\n  );\n  public readonly languageItems$: Observable<Array<ListItem>> = combineLatest([\n    this.defaultValue.valueChanges,\n    this.translateService.stream('key'),\n  ]).pipe(\n    map(([selectedItem]) =>\n      LANGUAGE_ITEMS.map(item => ({\n        id: item,\n        content: this.translateService.instant(`document.${item}`),\n        selected: selectedItem === item,\n      }))\n    )\n  );\n  public readonly statusItems$: Observable<Array<ListItem>> = combineLatest([\n    this.defaultValue.valueChanges,\n    this.translateService.stream('key'),\n  ]).pipe(\n    map(([selectedItem]) =>\n      STATUS_ITEMS.map(item => ({\n        id: item,\n        content: this.translateService.instant(`document.${item}`),\n        selected: selectedItem === item,\n      }))\n    )\n  );\n  public readonly documentTypeItems$: Observable<Array<ListItem>> = combineLatest([\n    this.defaultValue.valueChanges,\n    this.translateService.stream('key'),\n  ]).pipe(\n    switchMap(([selectedItem]) =>\n      combineLatest([\n        this.documentService.getDocumentTypes(this.documentDefinitionName),\n        of(selectedItem),\n      ])\n    ),\n    map(([documentTypes, selectedItem]) =>\n      documentTypes.map(item => ({\n        id: item.url,\n        content: item.name,\n        selected: selectedItem === item.url,\n      }))\n    )\n  );\n\n  public get defaultValue(): AbstractControl<string> {\n    return this.formGroup?.get('defaultValue');\n  }\n\n  public get selectedDefaultValue(): AbstractControl<ListItem> {\n    return this.formGroup?.get('selectedDefaultValue');\n  }\n\n  public get visible(): AbstractControl<boolean> {\n    return this.formGroup?.get('visible');\n  }\n\n  public get readonly(): AbstractControl<boolean> {\n    return this.formGroup?.get('readonly');\n  }\n\n  public get invalid(): boolean {\n    return !!this.formGroup?.invalid;\n  }\n\n  private readonly _subscriptions = new Subscription();\n\n  constructor(\n    private readonly fb: FormBuilder,\n    private readonly documentenApiDocumentService: DocumentenApiDocumentService,\n    private readonly translateService: TranslateService,\n    private readonly documentService: DocumentService\n  ) {}\n\n  public ngOnDestroy(): void {\n    this._subscriptions.unsubscribe();\n  }\n\n  public onClose(): void {\n    this.close();\n  }\n\n  public clear(): void {\n    this.selectedDefaultValue.setValue(null);\n    this.defaultValue.setValue(null);\n  }\n\n  public saveUploadField(): void {\n    this.disable();\n\n    const formField = {\n      key: this.key,\n      defaultValue: this.selectedDefaultValue?.value?.id || this.defaultValue.value,\n      visible: this.visible.value,\n      readonly: this.readonly.value,\n    } as DocumentenApiUploadField;\n\n    this.documentenApiDocumentService\n      .updateUploadField(this.documentDefinitionName, formField)\n      .subscribe({\n        next: () => {\n          this.enable();\n          this.closeAndRefresh();\n          this.resetForm();\n        },\n        error: () => {\n          this.enable(false);\n        },\n      });\n  }\n\n  private resetForm(): void {\n    this.formGroup.reset();\n  }\n\n  private disable(): void {\n    this.disabled$.next(true);\n    this.formGroup.disable();\n  }\n\n  private enable(delay = true): void {\n    setTimeout(\n      () => {\n        this.disabled$.next(false);\n        this.formGroup.enable();\n      },\n      delay ? CARBON_CONSTANTS.modalAnimationMs : 0\n    );\n  }\n\n  private close(): void {\n    this.closeModalEvent.emit('close');\n    this.resetForm();\n  }\n\n  private closeAndRefresh(): void {\n    this.closeModalEvent.emit('closeAndRefresh');\n    this.resetForm();\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<cds-modal\n  valtimoCdsModal\n  *ngIf=\"{\n    disabled: disabled$ | async,\n    languageItems: languageItems$ | async,\n    confidentialityLevelItems: confidentialityLevelItems$ | async,\n    statusItems: statusItems$ | async,\n    documentTypeItems: documentTypeItems$ | async,\n  } as obs\"\n  [open]=\"type !== 'closed'\"\n  size=\"sm\"\n>\n  <cds-modal-header showCloseButton=\"true\" (closeSelect)=\"onClose()\">\n    <h3 cdsModalHeaderHeading>\n      {{\n        ('zgw.uploadFields.editModal.header' | translate) +\n          ' - ' +\n          ('zgw.uploadFields.keys.' + key | translate)\n      }}\n    </h3>\n  </cds-modal-header>\n\n  <section cdsModalContent>\n    <form [formGroup]=\"formGroup\" class=\"uploadField-form\">\n      @if (key === 'taal') {\n        <cds-combo-box\n          formControlName=\"selectedDefaultValue\"\n          [label]=\"'zgw.uploadFields.fields.defaultValue' | translate\"\n          [dropUp]=\"false\"\n          (clear)=\"clear()\"\n        >\n          <cds-dropdown-list [items]=\"obs.languageItems\"></cds-dropdown-list>\n        </cds-combo-box>\n      } @else if (key === 'vertrouwelijkheidaanduiding') {\n        <cds-combo-box\n          formControlName=\"selectedDefaultValue\"\n          [label]=\"'zgw.uploadFields.fields.defaultValue' | translate\"\n          [dropUp]=\"false\"\n          (clear)=\"clear()\"\n        >\n          <cds-dropdown-list [items]=\"obs.confidentialityLevelItems\"></cds-dropdown-list>\n        </cds-combo-box>\n      } @else if (key === 'status') {\n        <cds-combo-box\n          formControlName=\"selectedDefaultValue\"\n          [label]=\"'zgw.uploadFields.fields.defaultValue' | translate\"\n          [dropUp]=\"false\"\n          (clear)=\"clear()\"\n        >\n          <cds-dropdown-list [items]=\"obs.statusItems\"></cds-dropdown-list>\n        </cds-combo-box>\n      } @else if (key === 'informatieobjecttype') {\n        <cds-combo-box\n          formControlName=\"selectedDefaultValue\"\n          [label]=\"'zgw.uploadFields.fields.defaultValue' | translate\"\n          [dropUp]=\"false\"\n          (clear)=\"clear()\"\n        >\n          <cds-dropdown-list [items]=\"obs.documentTypeItems\"></cds-dropdown-list>\n        </cds-combo-box>\n      } @else if (\n        key === 'filename' ||\n        key === 'bestandsnaam' ||\n        key === 'titel' ||\n        key === 'beschrijving' ||\n        key === 'trefwoorden'\n      ) {\n        <cds-label>\n          {{ 'zgw.uploadFields.fields.defaultValue' | translate }}\n          <input cdsText formControlName=\"defaultValue\" />\n        </cds-label>\n      }\n      <div class=\"toggle-group\">\n        <cds-toggle\n          formControlName=\"visible\"\n          [label]=\"'zgw.uploadFields.fields.visible' | translate\"\n          [onText]=\"'interface.on' | translate\"\n          [offText]=\"'interface.off' | translate\"\n        ></cds-toggle>\n        <cds-toggle\n          formControlName=\"readonly\"\n          [label]=\"'zgw.uploadFields.fields.readonly' | translate\"\n          [onText]=\"'interface.on' | translate\"\n          [offText]=\"'interface.off' | translate\"\n        ></cds-toggle>\n      </div>\n    </form>\n  </section>\n\n  <cds-modal-footer>\n    <button cdsButton=\"secondary\" (click)=\"onClose()\" [disabled]=\"obs.disabled\">\n      {{ 'interface.cancel' | translate }}\n    </button>\n\n    <button cdsButton=\"primary\" [disabled]=\"invalid || obs.disabled\" (click)=\"saveUploadField()\">\n      {{ 'interface.save' | translate }}\n    </button>\n  </cds-modal-footer>\n</cds-modal>\n"]}

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

@@ -0,0 +1,118 @@
+/*
+ * 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, startWith, switchMap, tap, } from 'rxjs';
+import { CarbonListComponent, CarbonListModule, ConfirmationModalModule, ViewType, } from '@valtimo/components';
+import { CommonModule } from '@angular/common';
+import { TranslateModule } from '@ngx-translate/core';
+import { ButtonModule, IconModule } from 'carbon-components-angular';
+import { DocumentenApiUploadFieldModalComponent } from '../documenten-api-upload-field-model/documenten-api-upload-field-modal.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../services";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "@angular/common";
+import * as i5 from "@valtimo/components";
+export class DocumentenApiUploadFieldsComponent {
+    get documentDefinitionName$() {
+        return this._documentDefinitionName$;
+    }
+    constructor(route, documentenApiDocumentService, translateService) {
+        this.route = route;
+        this.documentenApiDocumentService = documentenApiDocumentService;
+        this.translateService = translateService;
+        this._reload$ = new BehaviorSubject(null);
+        this._documentDefinitionName$ = this.route.params.pipe(map(params => params?.name), filter(docDefName => !!docDefName));
+        this.loading$ = new BehaviorSubject(true);
+        this.fields$ = new BehaviorSubject([]);
+        this.uploadFieldModalType$ = new BehaviorSubject('closed');
+        this.prefill$ = new BehaviorSubject(undefined);
+        this.documentUploadFields$ = combineLatest([
+            this._documentDefinitionName$,
+            this._reload$,
+            this.translateService.stream('key'),
+        ]).pipe(tap(([_, reload]) => {
+            if (reload === null) {
+                this.loading$.next(true);
+            }
+        }), switchMap(([documentDefinitionName]) => this.documentenApiDocumentService.getUploadFields(documentDefinitionName)), map(fields => fields.map(field => ({
+            ...field,
+            field: this.translateService.instant(`zgw.uploadFields.keys.${field.key}`),
+        }))), startWith([]), tap(() => {
+            this.loading$.next(false);
+        }));
+        this.ACTION_ITEMS = [
+            {
+                label: 'interface.edit',
+                callback: this.openEditModal.bind(this),
+                type: 'normal',
+            },
+        ];
+        this.FIELDS = [
+            {
+                key: 'field',
+                label: 'zgw.uploadFields.fields.field',
+                viewType: ViewType.TEXT,
+            },
+            {
+                key: 'defaultValue',
+                label: 'zgw.uploadFields.fields.defaultValue',
+                viewType: ViewType.TEXT,
+            },
+            {
+                key: 'visible',
+                label: 'zgw.uploadFields.fields.visible',
+                viewType: ViewType.BOOLEAN,
+            },
+            {
+                key: 'readonly',
+                label: 'zgw.uploadFields.fields.readonly',
+                viewType: ViewType.BOOLEAN,
+            },
+        ];
+    }
+    openEditModal(uploadField) {
+        this.prefill$.next(uploadField);
+        this.uploadFieldModalType$.next('edit');
+    }
+    closeModal(closeModalEvent) {
+        if (closeModalEvent === 'closeAndRefresh') {
+            this.reload();
+        }
+        this.uploadFieldModalType$.next('closed');
+    }
+    reload(noAnimation = false) {
+        this._reload$.next(noAnimation ? 'noAnimation' : null);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DocumentenApiUploadFieldsComponent, deps: [{ token: i1.ActivatedRoute }, { token: i2.DocumentenApiDocumentService }, { token: i3.TranslateService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: DocumentenApiUploadFieldsComponent, isStandalone: true, selector: "valtimo-documenten-api-upload-fields", viewQueries: [{ propertyName: "carbonList", first: true, predicate: CarbonListComponent, 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<ng-container\n  *ngIf=\"{\n    loading: loading$ | async,\n    documentUploadFields: documentUploadFields$ | async,\n    uploadFieldModalType: uploadFieldModalType$ | async,\n    documentDefinitionName: documentDefinitionName$ | async,\n    prefill: prefill$ | async,\n  } as obs\"\n>\n  <valtimo-carbon-list\n    [items]=\"obs.documentUploadFields\"\n    [fields]=\"FIELDS\"\n    [header]=\"false\"\n    [loading]=\"obs.loading\"\n    [actionItems]=\"ACTION_ITEMS\"\n  >\n    <valtimo-no-results\n      title=\"{{ 'zgw.uploadFields.list.noResultsTitle' | translate }}\"\n      description=\"{{ 'zgw.uploadFields.list.noResultsDescription' | translate }}\"\n    ></valtimo-no-results>\n  </valtimo-carbon-list>\n\n  <valtimo-documenten-api-upload-field-modal\n    [prefill]=\"obs.prefill\"\n    [documentDefinitionName]=\"obs.documentDefinitionName\"\n    [type]=\"obs.uploadFieldModalType\"\n    (closeModalEvent)=\"closeModal($event)\"\n  ></valtimo-documenten-api-upload-field-modal>\n</ng-container>\n", styles: ["::ng-deep .cds-upload-field--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: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }, { kind: "ngmodule", type: CarbonListModule }, { kind: "component", type: i5.CarbonListComponent, selector: "valtimo-carbon-list", inputs: ["items", "fields", "tableTranslations", "paginatorConfig", "pagination", "loading", "actions", "actionItems", "header", "hideColumnHeader", "initialSortState", "sortState", "isSearchable", "enableSingleSelection", "lastColumnTemplate", "paginationIdentifier", "showSelectionColumn", "striped", "hideToolbar", "lockedTooltipTranslationKey", "movingRowsEnabled", "dragAndDrop", "dragAndDropDisabled"], outputs: ["rowClicked", "paginationClicked", "paginationSet", "search", "sortChanged", "moveRow", "itemsReordered"] }, { kind: "component", type: i5.CarbonNoResultsComponent, selector: "valtimo-no-results", inputs: ["action", "description", "illustration", "title", "smallPadding", "collapseVertically", "alwaysRenderVertically"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i3.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: ConfirmationModalModule }, { kind: "ngmodule", type: ButtonModule }, { kind: "ngmodule", type: IconModule }, { kind: "component", type: DocumentenApiUploadFieldModalComponent, selector: "valtimo-documenten-api-upload-field-modal", inputs: ["documentDefinitionName", "type", "prefill"], outputs: ["closeModalEvent"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DocumentenApiUploadFieldsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'valtimo-documenten-api-upload-fields', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                        CommonModule,
+                        CarbonListModule,
+                        TranslateModule,
+                        ConfirmationModalModule,
+                        ButtonModule,
+                        IconModule,
+                        DocumentenApiUploadFieldModalComponent,
+                    ], 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<ng-container\n  *ngIf=\"{\n    loading: loading$ | async,\n    documentUploadFields: documentUploadFields$ | async,\n    uploadFieldModalType: uploadFieldModalType$ | async,\n    documentDefinitionName: documentDefinitionName$ | async,\n    prefill: prefill$ | async,\n  } as obs\"\n>\n  <valtimo-carbon-list\n    [items]=\"obs.documentUploadFields\"\n    [fields]=\"FIELDS\"\n    [header]=\"false\"\n    [loading]=\"obs.loading\"\n    [actionItems]=\"ACTION_ITEMS\"\n  >\n    <valtimo-no-results\n      title=\"{{ 'zgw.uploadFields.list.noResultsTitle' | translate }}\"\n      description=\"{{ 'zgw.uploadFields.list.noResultsDescription' | translate }}\"\n    ></valtimo-no-results>\n  </valtimo-carbon-list>\n\n  <valtimo-documenten-api-upload-field-modal\n    [prefill]=\"obs.prefill\"\n    [documentDefinitionName]=\"obs.documentDefinitionName\"\n    [type]=\"obs.uploadFieldModalType\"\n    (closeModalEvent)=\"closeModal($event)\"\n  ></valtimo-documenten-api-upload-field-modal>\n</ng-container>\n", styles: ["::ng-deep .cds-upload-field--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.DocumentenApiDocumentService }, { type: i3.TranslateService }], propDecorators: { carbonList: [{
+                type: ViewChild,
+                args: [CarbonListComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"documenten-api-upload-fields.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/valtimo/zgw/src/lib/modules/documenten-api/components/documenten-api-upload-fields/documenten-api-upload-fields.component.ts","../../../../../../../../../projects/valtimo/zgw/src/lib/modules/documenten-api/components/documenten-api-upload-fields/documenten-api-upload-fields.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 {ChangeDetectionStrategy, Component, ViewChild} from '@angular/core';\nimport {DocumentenApiColumnModalType, DocumentenApiColumnModalTypeCloseEvent} from '../../models';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  filter,\n  map,\n  Observable,\n  startWith,\n  Subject,\n  switchMap,\n  tap,\n} from 'rxjs';\nimport {ActivatedRoute} from '@angular/router';\nimport {\n  ActionItem,\n  CarbonListComponent,\n  CarbonListItem,\n  CarbonListModule,\n  ColumnConfig,\n  ConfirmationModalModule,\n  ViewType,\n} from '@valtimo/components';\nimport {CommonModule} from '@angular/common';\nimport {TranslateModule, TranslateService} from '@ngx-translate/core';\nimport {ButtonModule, IconModule} from 'carbon-components-angular';\nimport {\n  DOCUMENTEN_API_UPLOAD_KEYS,\n  DocumentenApiUploadField,\n} from '../../models/documenten-api-upload-field.model';\nimport {DocumentenApiDocumentService} from '../../services';\nimport {DocumentenApiUploadFieldModalComponent} from '../documenten-api-upload-field-model/documenten-api-upload-field-modal.component';\n\n@Component({\n  selector: 'valtimo-documenten-api-upload-fields',\n  templateUrl: './documenten-api-upload-fields.component.html',\n  styleUrls: ['./documenten-api-upload-fields.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    CommonModule,\n    CarbonListModule,\n    TranslateModule,\n    ConfirmationModalModule,\n    ButtonModule,\n    IconModule,\n    DocumentenApiUploadFieldModalComponent,\n  ],\n})\nexport class DocumentenApiUploadFieldsComponent {\n  @ViewChild(CarbonListComponent) carbonList: CarbonListComponent;\n\n  private readonly _reload$ = new BehaviorSubject<null | 'noAnimation'>(null);\n  private readonly _documentDefinitionName$: Observable<string> = this.route.params.pipe(\n    map(params => params?.name),\n    filter(docDefName => !!docDefName)\n  );\n\n  public readonly loading$ = new BehaviorSubject<boolean>(true);\n  public readonly fields$ = new BehaviorSubject<ColumnConfig[]>([]);\n  public readonly uploadFieldModalType$ = new BehaviorSubject<DocumentenApiColumnModalType>(\n    'closed'\n  );\n  public readonly prefill$ = new BehaviorSubject<DocumentenApiUploadField | undefined>(undefined);\n\n  public get documentDefinitionName$(): Observable<string> {\n    return this._documentDefinitionName$;\n  }\n\n  public readonly documentUploadFields$: Observable<string[]> = combineLatest([\n    this._documentDefinitionName$,\n    this._reload$,\n    this.translateService.stream('key'),\n  ]).pipe(\n    tap(([_, reload]) => {\n      if (reload === null) {\n        this.loading$.next(true);\n      }\n    }),\n    switchMap(([documentDefinitionName]) =>\n      this.documentenApiDocumentService.getUploadFields(documentDefinitionName)\n    ),\n    map(fields =>\n      fields.map(field => ({\n        ...field,\n        field: this.translateService.instant(`zgw.uploadFields.keys.${field.key}`),\n      }))\n    ),\n    startWith([]),\n    tap(() => {\n      this.loading$.next(false);\n    })\n  );\n\n  public readonly ACTION_ITEMS: ActionItem[] = [\n    {\n      label: 'interface.edit',\n      callback: this.openEditModal.bind(this),\n      type: 'normal',\n    },\n  ];\n\n  public readonly FIELDS: ColumnConfig[] = [\n    {\n      key: 'field',\n      label: 'zgw.uploadFields.fields.field',\n      viewType: ViewType.TEXT,\n    },\n    {\n      key: 'defaultValue',\n      label: 'zgw.uploadFields.fields.defaultValue',\n      viewType: ViewType.TEXT,\n    },\n    {\n      key: 'visible',\n      label: 'zgw.uploadFields.fields.visible',\n      viewType: ViewType.BOOLEAN,\n    },\n    {\n      key: 'readonly',\n      label: 'zgw.uploadFields.fields.readonly',\n      viewType: ViewType.BOOLEAN,\n    },\n  ];\n\n  constructor(\n    private readonly route: ActivatedRoute,\n    private readonly documentenApiDocumentService: DocumentenApiDocumentService,\n    private readonly translateService: TranslateService\n  ) {}\n\n  public openEditModal(uploadField: DocumentenApiUploadField): void {\n    this.prefill$.next(uploadField);\n    this.uploadFieldModalType$.next('edit');\n  }\n\n  public closeModal(closeModalEvent: DocumentenApiColumnModalTypeCloseEvent): void {\n    if (closeModalEvent === 'closeAndRefresh') {\n      this.reload();\n    }\n    this.uploadFieldModalType$.next('closed');\n  }\n\n  private reload(noAnimation = false): void {\n    this._reload$.next(noAnimation ? 'noAnimation' : null);\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<ng-container\n  *ngIf=\"{\n    loading: loading$ | async,\n    documentUploadFields: documentUploadFields$ | async,\n    uploadFieldModalType: uploadFieldModalType$ | async,\n    documentDefinitionName: documentDefinitionName$ | async,\n    prefill: prefill$ | async,\n  } as obs\"\n>\n  <valtimo-carbon-list\n    [items]=\"obs.documentUploadFields\"\n    [fields]=\"FIELDS\"\n    [header]=\"false\"\n    [loading]=\"obs.loading\"\n    [actionItems]=\"ACTION_ITEMS\"\n  >\n    <valtimo-no-results\n      title=\"{{ 'zgw.uploadFields.list.noResultsTitle' | translate }}\"\n      description=\"{{ 'zgw.uploadFields.list.noResultsDescription' | translate }}\"\n    ></valtimo-no-results>\n  </valtimo-carbon-list>\n\n  <valtimo-documenten-api-upload-field-modal\n    [prefill]=\"obs.prefill\"\n    [documentDefinitionName]=\"obs.documentDefinitionName\"\n    [type]=\"obs.uploadFieldModalType\"\n    (closeModalEvent)=\"closeModal($event)\"\n  ></valtimo-documenten-api-upload-field-modal>\n</ng-container>\n"]}

package/esm2022/lib/modules/documenten-api/components/index.mjs

@@ -18,8 +18,10 @@ export * from './documenten-api-columns/documenten-api-columns.component';
 export * from './documenten-api-documents/documenten-api-documents.component';
 export * from './documenten-api-filter/documenten-api-filter.component';
 export * from './documenten-api-link-upload-process/dossier-management-link-process.component';
+export * from './documenten-api-metadata-modal/documenten-api-metadata-modal.component';
 export * from './documenten-api-tag-modal/documenten-api-tag-modal.component';
 export * from './documenten-api-tags/documenten-api-tags.component';
-export * from './documenten-api-metadata-modal/documenten-api-metadata-modal.component';
+export * from './documenten-api-upload-field-model/documenten-api-upload-field-modal.component';
+export * from './documenten-api-upload-fields/documenten-api-upload-fields.component';
 export * from './documenten-api-version/documenten-api-version.component';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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