@ohioepa/oepa-ui-lib 1.1.0

package/esm2022/lib/document/document-editor/document-editor.component.mjs

@@ -0,0 +1,225 @@
+import { Component, Input, ViewChild } from '@angular/core';
+import { SectionModalComponent } from '../section-modal/section-modal.component';
+import { ConfirmationModalComponent } from '../../confirmation-modal/confirmation-modal.component';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-bootstrap/modal";
+import * as i2 from "ngx-toastr";
+import * as i3 from "../document.service";
+import * as i4 from "@angular/common";
+import * as i5 from "ngx-bootstrap/tabs";
+import * as i6 from "../document-section/document-section.component";
+export class DocumentEditorComponent {
+    modalService;
+    toastr;
+    documentService;
+    document;
+    allowRemoveSection = false;
+    showSectionOptions = false;
+    documentSectionTabs;
+    busy = false;
+    static selectedTabIndex = 0;
+    constructor(modalService, toastr, documentService) {
+        this.modalService = modalService;
+        this.toastr = toastr;
+        this.documentService = documentService;
+    }
+    ngOnInit() {
+        // TODO add check for DSWSWIMSSystemAdmin to the NPDES code
+        // this.userAccountService.retrieveAccountForCurrentUser().subscribe((account) => {
+        //   if (account && account.roleList) {
+        //     account.roleList.forEach(role => {
+        //       if (role.name == 'DSWSWIMSSystemAdmin') {
+        //         this.showSectionOptions = true;
+        //       }
+        //     });
+        //   } else {
+        //     alert('No Account could be found in the OepaAccountService!');
+        //   }
+        // });
+    }
+    ngAfterViewInit() {
+        if (this.documentSectionTabs?.tabs[DocumentEditorComponent.selectedTabIndex]) {
+            this.documentSectionTabs.tabs[DocumentEditorComponent.selectedTabIndex].active = true;
+        }
+    }
+    onSectionTabSelect(index) {
+        console.log(index);
+        console.log(DocumentEditorComponent.selectedTabIndex);
+        DocumentEditorComponent.selectedTabIndex = index;
+        if (this.documentSectionTabs?.tabs[DocumentEditorComponent.selectedTabIndex]) {
+            this.documentService.updateSelectedSectionName(this.documentSectionTabs.tabs[DocumentEditorComponent.selectedTabIndex].heading);
+        }
+        else if (this.documentSectionTabs?.tabs[DocumentEditorComponent.selectedTabIndex]) {
+            this.editSection(this.documentSectionTabs.tabs[DocumentEditorComponent.selectedTabIndex]);
+        }
+    }
+    moveSectionUp(section) {
+        if (section.sequence && section.sequence > 1) {
+            let clone = Object.assign({}, this.document);
+            if (clone.sections) {
+                clone.sections.splice(section.sequence - 2, 0, clone.sections.splice(section.sequence - 1, 1)[0]);
+                this.resequence(clone);
+                this.documentService.updateDocumentGroup(clone).subscribe({
+                    next: () => {
+                        this.documentService.updateDcoumentID(clone.id || '');
+                    }, error: err => {
+                        this.toastr.error('Failed updating document: ' + err, 'ERROR');
+                    }
+                });
+            }
+        }
+        else {
+            this.toastr.info('Cannot move top section up', '', { disableTimeOut: false, timeOut: 5000 });
+        }
+    }
+    insertAboveSection(section) {
+        if (section.sequence) {
+            let newSection = this.newSection(section.sequence - 1 || 1);
+            this.insertSection(section.sequence - 1, newSection);
+        }
+    }
+    moveSectionDown(section) {
+        if (section.sequence && this.document && this.document.sections && section.sequence < this.document.sections.length - 1) {
+            let clone = Object.assign({}, this.document);
+            if (clone.sections) {
+                clone.sections.splice(section.sequence, 0, clone.sections.splice(section.sequence - 1, 1)[0]);
+                this.resequence(clone);
+                this.documentService.updateDocumentGroup(clone).subscribe({
+                    next: () => {
+                        this.documentService.updateDcoumentID(clone.id || '');
+                    }, error: err => {
+                        this.toastr.error('Failed updating document: ' + err, 'ERROR');
+                    }
+                });
+            }
+        }
+        else {
+            this.toastr.info('Cannot move bottom section down', '', { disableTimeOut: false, timeOut: 5000 });
+        }
+    }
+    insertBelowSection(section) {
+        if (section.sequence) {
+            let newSection = this.newSection(section.sequence + 1);
+            this.insertSection(section.sequence, newSection);
+        }
+    }
+    newSection(sequence) {
+        return {
+            documentID: this.document?.id,
+            sequence: sequence,
+            name: 'Section ' + sequence,
+            groups: [
+                {
+                    name: 'Group 1',
+                    parts: [
+                        {
+                            name: 'Paragraph 1',
+                            text: {
+                                text: ''
+                            }
+                        }
+                    ]
+                }
+            ]
+        };
+    }
+    insertSection(insertIndex, newSection) {
+        const initialState = {
+            label: 'Insert Section',
+            section: newSection
+        };
+        let modal = this.modalService.show(SectionModalComponent, { initialState, ignoreBackdropClick: true });
+        modal.content.onSectionSave.subscribe(updatedSection => {
+            this.busy = true;
+            let clone = Object.assign({}, this.document);
+            if (clone.sections) {
+                clone.sections.splice(insertIndex, 0, updatedSection);
+                this.resequence(clone);
+                this.documentService.updateDocument(clone).subscribe({
+                    next: () => {
+                        this.documentService.updateDcoumentID(clone.id || '');
+                        this.busy = false;
+                    }, error: err => {
+                        this.toastr.error('Failed updating section: ' + err, 'ERROR');
+                        this.busy = false;
+                    }
+                });
+            }
+        });
+    }
+    resequence(document) {
+        let sequence = 1;
+        if (document.sections) {
+            document.sections.forEach(section => {
+                section.sequence = sequence++;
+            });
+        }
+    }
+    deleteSection(section) {
+        const initialState = {
+            headerText: 'Delete Section',
+            bodyText: 'Delete Section ' + section.name + '?',
+            confirmBtnLabel: 'Yes',
+            cancelBtnLabel: 'No'
+        };
+        let modal = this.modalService.show(ConfirmationModalComponent, { initialState, ignoreBackdropClick: true });
+        modal.content.confirmClicked.subscribe(() => {
+            this.busy = true;
+            let clone = Object.assign({}, this.document);
+            if (clone.sections) {
+                clone.sections = clone.sections.filter(keep => {
+                    keep.id != section.id;
+                });
+                this.resequence(clone);
+                this.documentService.updateDocument(clone).subscribe({
+                    next: () => {
+                        this.documentService.deleteDocumentSection(section).subscribe({
+                            next: () => {
+                                this.documentService.updateDcoumentID(clone.id || '');
+                                this.busy = false;
+                            }, error: err => {
+                                this.toastr.error('Failed deleting section: ' + err, 'ERROR');
+                                this.busy = false;
+                            }
+                        });
+                    }, error: err => {
+                        this.toastr.error('Failed updating document: ' + err, 'ERROR');
+                        this.busy = false;
+                    }
+                });
+            }
+        });
+    }
+    editSection(section) {
+        const initialState = {
+            label: 'Edit Section Attributes',
+            section: section
+        };
+        let modal = this.modalService.show(SectionModalComponent, { initialState, ignoreBackdropClick: true });
+        modal.content.onSectionSave.subscribe(updatedSection => {
+            this.busy = true;
+            this.documentService.updateDocumentSection(updatedSection).subscribe(() => {
+                this.busy = false;
+            }, err => {
+                this.toastr.error('Failed updating section: ' + err, 'ERROR');
+                this.busy = false;
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DocumentEditorComponent, deps: [{ token: i1.BsModalService }, { token: i2.ToastrService }, { token: i3.DocumentService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: DocumentEditorComponent, selector: "oepa-document-editor", inputs: { document: "document", allowRemoveSection: "allowRemoveSection", showSectionOptions: "showSectionOptions" }, viewQueries: [{ propertyName: "documentSectionTabs", first: true, predicate: ["documentSectionTabs"], descendants: true }], ngImport: i0, template: "<div *ngIf=\"document\">\n    <div *ngIf=\"document.sections && document.sections.length > 0\">\n        <div class=\"row\">\n            <div class=\"col-sm-4\">\n                <button type=\"button\" class=\"btn btn-primary btn-sm\"\n                    (click)=\"insertBelowSection(document.sections[document.sections.length-1])\">\n                    Add new section\n                </button>\n            </div>\n            <div class=\"col-sm-8\">\n            </div>\n            <div class=\"col-sm-12\" class=\"row\">\n                <tabset #documentSectionTabs>\n                    <tab *ngFor=\"let s of document.sections; let i = index;\" (selectTab)=\"onSectionTabSelect(i)\"\n                        [removable]=\"allowRemoveSection\" (removed)=\"deleteSection(s)\">\n                        <ng-template tabHeading>\n                            <span>\n                                <span>{{s.name}}</span>\n                                <span *ngIf=\"showSectionOptions\">&nbsp;<i class=\"bi bi-pencil-fill\"\n                                        (click)=\"editSection(s)\"></i> &nbsp;<i class=\"bi bi-x-lg\"\n                                        (click)=\"deleteSection(s)\"></i></span>\n                            </span>\n                        </ng-template>\n                        <oepa-document-section [section]=\"s\" (onMoveUp)=\"moveSectionUp($event)\"\n                            (onInsertAbove)=\"insertAboveSection($event)\" (onMoveDown)=\"moveSectionDown($event)\"\n                            (onInsertBelow)=\"insertBelowSection($event)\" (onDelete)=\"deleteSection($event)\">\n                        </oepa-document-section>\n                    </tab>\n                </tabset>\n            </div>\n        </div>\n    </div>\n</div>", styles: [""], dependencies: [{ kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i5.TabDirective, selector: "tab, [tab]", inputs: ["heading", "id", "disabled", "removable", "customClass", "active"], outputs: ["selectTab", "deselect", "removed"], exportAs: ["tab"] }, { kind: "component", type: i5.TabsetComponent, selector: "tabset", inputs: ["vertical", "justified", "type"] }, { kind: "directive", type: i5.TabHeadingDirective, selector: "[tabHeading]" }, { kind: "component", type: i6.DocumentSectionComponent, selector: "oepa-document-section", inputs: ["section"], outputs: ["onMoveUp", "onInsertAbove", "onMoveDown", "onInsertBelow", "onDelete"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DocumentEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'oepa-document-editor', template: "<div *ngIf=\"document\">\n    <div *ngIf=\"document.sections && document.sections.length > 0\">\n        <div class=\"row\">\n            <div class=\"col-sm-4\">\n                <button type=\"button\" class=\"btn btn-primary btn-sm\"\n                    (click)=\"insertBelowSection(document.sections[document.sections.length-1])\">\n                    Add new section\n                </button>\n            </div>\n            <div class=\"col-sm-8\">\n            </div>\n            <div class=\"col-sm-12\" class=\"row\">\n                <tabset #documentSectionTabs>\n                    <tab *ngFor=\"let s of document.sections; let i = index;\" (selectTab)=\"onSectionTabSelect(i)\"\n                        [removable]=\"allowRemoveSection\" (removed)=\"deleteSection(s)\">\n                        <ng-template tabHeading>\n                            <span>\n                                <span>{{s.name}}</span>\n                                <span *ngIf=\"showSectionOptions\">&nbsp;<i class=\"bi bi-pencil-fill\"\n                                        (click)=\"editSection(s)\"></i> &nbsp;<i class=\"bi bi-x-lg\"\n                                        (click)=\"deleteSection(s)\"></i></span>\n                            </span>\n                        </ng-template>\n                        <oepa-document-section [section]=\"s\" (onMoveUp)=\"moveSectionUp($event)\"\n                            (onInsertAbove)=\"insertAboveSection($event)\" (onMoveDown)=\"moveSectionDown($event)\"\n                            (onInsertBelow)=\"insertBelowSection($event)\" (onDelete)=\"deleteSection($event)\">\n                        </oepa-document-section>\n                    </tab>\n                </tabset>\n            </div>\n        </div>\n    </div>\n</div>" }]
+        }], ctorParameters: () => [{ type: i1.BsModalService }, { type: i2.ToastrService }, { type: i3.DocumentService }], propDecorators: { document: [{
+                type: Input
+            }], allowRemoveSection: [{
+                type: Input
+            }], showSectionOptions: [{
+                type: Input
+            }], documentSectionTabs: [{
+                type: ViewChild,
+                args: ['documentSectionTabs', { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"document-editor.component.js","sourceRoot":"","sources":["../../../../../../projects/oepa-ui-lib/src/lib/document/document-editor/document-editor.component.ts","../../../../../../projects/oepa-ui-lib/src/lib/document/document-editor/document-editor.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, Input, ViewChild, AfterViewInit } from '@angular/core';\nimport { PortalDocument } from '../portal-document';\nimport { PortalDocumentSection } from '../portal-document-section';\nimport { DocumentService } from '../document.service';\nimport { BsModalService } from 'ngx-bootstrap/modal';\nimport { ToastrService } from 'ngx-toastr';\nimport { SectionModalComponent } from '../section-modal/section-modal.component';\nimport { TabsetComponent } from 'ngx-bootstrap/tabs';\nimport { ConfirmationModalComponent } from '../../confirmation-modal/confirmation-modal.component';\n\n@Component({\n  selector: 'oepa-document-editor',\n  templateUrl: './document-editor.component.html',\n  styleUrls: ['./document-editor.component.css']\n})\nexport class DocumentEditorComponent implements OnInit, AfterViewInit {\n\n  @Input() document: PortalDocument | undefined;\n  @Input() allowRemoveSection = false;\n  @Input() showSectionOptions: boolean = false;\n\n  @ViewChild('documentSectionTabs', { static: false }) documentSectionTabs?: TabsetComponent;\n\n  public busy = false;\n  private static selectedTabIndex = 0;\n\n  constructor(private modalService: BsModalService,\n    private toastr: ToastrService,\n    private documentService: DocumentService) {\n\n  }\n\n  ngOnInit() {\n    // TODO add check for DSWSWIMSSystemAdmin to the NPDES code\n    // this.userAccountService.retrieveAccountForCurrentUser().subscribe((account) => {\n    //   if (account && account.roleList) {\n    //     account.roleList.forEach(role => {\n    //       if (role.name == 'DSWSWIMSSystemAdmin') {\n    //         this.showSectionOptions = true;\n    //       }\n    //     });\n    //   } else {\n    //     alert('No Account could be found in the OepaAccountService!');\n    //   }\n    // });\n  }\n\n\n  ngAfterViewInit(): void {\n    if (this.documentSectionTabs?.tabs[DocumentEditorComponent.selectedTabIndex]) {\n      this.documentSectionTabs.tabs[DocumentEditorComponent.selectedTabIndex].active = true;\n    }\n  }\n\n  public onSectionTabSelect(index: number) {\n    console.log(index)\n    console.log(DocumentEditorComponent.selectedTabIndex)\n    DocumentEditorComponent.selectedTabIndex = index;\n    if (this.documentSectionTabs?.tabs[DocumentEditorComponent.selectedTabIndex]) {\n      this.documentService.updateSelectedSectionName(this.documentSectionTabs.tabs[DocumentEditorComponent.selectedTabIndex].heading);\n    } else if (this.documentSectionTabs?.tabs[DocumentEditorComponent.selectedTabIndex]) {\n      this.editSection(this.documentSectionTabs.tabs[DocumentEditorComponent.selectedTabIndex]);\n    }\n  }\n\n  public moveSectionUp(section: PortalDocumentSection) {\n    if (section.sequence && section.sequence > 1) {\n      let clone = Object.assign({}, this.document);\n      if (clone.sections) {\n        clone.sections.splice(section.sequence - 2, 0, clone.sections.splice(section.sequence - 1, 1)[0]);\n        this.resequence(clone);\n        this.documentService.updateDocumentGroup(clone).subscribe({\n          next: () => {\n            this.documentService.updateDcoumentID(clone.id || '');\n          }, error: err => {\n            this.toastr.error('Failed updating document: ' + err, 'ERROR');\n          }\n        });\n      }\n    } else {\n      this.toastr.info('Cannot move top section up', '', { disableTimeOut: false, timeOut: 5000 });\n    }\n\n  }\n\n  public insertAboveSection(section: PortalDocumentSection) {\n    if (section.sequence) {\n      let newSection = this.newSection(section.sequence - 1 || 1);\n      this.insertSection(section.sequence - 1, newSection);\n    }\n  }\n\n  public moveSectionDown(section: PortalDocumentSection) {\n    if (section.sequence && this.document && this.document.sections && section.sequence < this.document.sections.length - 1) {\n      let clone = Object.assign({}, this.document);\n      if (clone.sections) {\n        clone.sections.splice(section.sequence, 0, clone.sections.splice(section.sequence - 1, 1)[0]);\n        this.resequence(clone);\n        this.documentService.updateDocumentGroup(clone).subscribe({\n          next: () => {\n            this.documentService.updateDcoumentID(clone.id || '');\n          }, error: err => {\n            this.toastr.error('Failed updating document: ' + err, 'ERROR');\n          }\n        });\n      }\n    } else {\n      this.toastr.info('Cannot move bottom section down', '', { disableTimeOut: false, timeOut: 5000 });\n    }\n  }\n\n  public insertBelowSection(section: PortalDocumentSection) {\n    if (section.sequence) {\n      let newSection = this.newSection(section.sequence + 1);\n      this.insertSection(section.sequence, newSection);\n    }\n  }\n\n  private newSection(sequence: number): PortalDocumentSection {\n    return {\n      documentID: this.document?.id,\n      sequence: sequence,\n      name: 'Section ' + sequence,\n      groups: [\n        {\n          name: 'Group 1',\n          parts: [\n            {\n              name: 'Paragraph 1',\n              text: {\n                text: ''\n              }\n            }\n          ]\n        }\n      ]\n    }\n  }\n  private insertSection(insertIndex: number, newSection: PortalDocumentSection) {\n    const initialState = {\n      label: 'Insert Section',\n      section: newSection\n    }\n    let modal = this.modalService.show(SectionModalComponent, { initialState, ignoreBackdropClick: true });\n    (<SectionModalComponent>modal.content).onSectionSave.subscribe(updatedSection => {\n      this.busy = true;\n      let clone = Object.assign({}, this.document);\n      if (clone.sections) {\n        clone.sections.splice(insertIndex, 0, updatedSection);\n        this.resequence(clone);\n        this.documentService.updateDocument(clone).subscribe({\n          next: () => {\n            this.documentService.updateDcoumentID(clone.id || '');\n            this.busy = false;\n          }, error: err => {\n            this.toastr.error('Failed updating section: ' + err, 'ERROR');\n            this.busy = false;\n          }\n        });\n      }\n    });\n  }\n\n  private resequence(document: PortalDocument) {\n    let sequence = 1;\n    if (document.sections) {\n      document.sections.forEach(section => {\n        section.sequence = sequence++;\n      });\n    }\n  }\n\n  public deleteSection(section: PortalDocumentSection) {\n    const initialState = {\n      headerText: 'Delete Section',\n      bodyText: 'Delete Section ' + section.name + '?',\n      confirmBtnLabel: 'Yes',\n      cancelBtnLabel: 'No'\n    }\n    let modal = this.modalService.show(ConfirmationModalComponent, { initialState, ignoreBackdropClick: true });\n    (<ConfirmationModalComponent>modal.content).confirmClicked.subscribe(() => {\n      this.busy = true;\n      let clone = Object.assign({}, this.document);\n      if (clone.sections) {\n        clone.sections = clone.sections.filter(keep => {\n          keep.id != section.id;\n        });\n        this.resequence(clone);\n        this.documentService.updateDocument(clone).subscribe({\n          next: () => {\n            this.documentService.deleteDocumentSection(section).subscribe({\n              next: () => {\n                this.documentService.updateDcoumentID(clone.id || '');\n                this.busy = false;\n              }, error: err => {\n                this.toastr.error('Failed deleting section: ' + err, 'ERROR');\n                this.busy = false;\n              }\n            });\n          }, error: err => {\n            this.toastr.error('Failed updating document: ' + err, 'ERROR');\n            this.busy = false;\n          }\n        });\n      }\n    });\n  }\n\n  public editSection(section: PortalDocumentSection) {\n    const initialState = {\n      label: 'Edit Section Attributes',\n      section: section\n    }\n    let modal = this.modalService.show(SectionModalComponent, { initialState, ignoreBackdropClick: true });\n    (<SectionModalComponent>modal.content).onSectionSave.subscribe(updatedSection => {\n      this.busy = true;\n      this.documentService.updateDocumentSection(updatedSection).subscribe(() => {\n        this.busy = false;\n      }, err => {\n        this.toastr.error('Failed updating section: ' + err, 'ERROR');\n        this.busy = false;\n      })\n    });\n  }\n\n}\n","<div *ngIf=\"document\">\n    <div *ngIf=\"document.sections && document.sections.length > 0\">\n        <div class=\"row\">\n            <div class=\"col-sm-4\">\n                <button type=\"button\" class=\"btn btn-primary btn-sm\"\n                    (click)=\"insertBelowSection(document.sections[document.sections.length-1])\">\n                    Add new section\n                </button>\n            </div>\n            <div class=\"col-sm-8\">\n            </div>\n            <div class=\"col-sm-12\" class=\"row\">\n                <tabset #documentSectionTabs>\n                    <tab *ngFor=\"let s of document.sections; let i = index;\" (selectTab)=\"onSectionTabSelect(i)\"\n                        [removable]=\"allowRemoveSection\" (removed)=\"deleteSection(s)\">\n                        <ng-template tabHeading>\n                            <span>\n                                <span>{{s.name}}</span>\n                                <span *ngIf=\"showSectionOptions\">&nbsp;<i class=\"bi bi-pencil-fill\"\n                                        (click)=\"editSection(s)\"></i> &nbsp;<i class=\"bi bi-x-lg\"\n                                        (click)=\"deleteSection(s)\"></i></span>\n                            </span>\n                        </ng-template>\n                        <oepa-document-section [section]=\"s\" (onMoveUp)=\"moveSectionUp($event)\"\n                            (onInsertAbove)=\"insertAboveSection($event)\" (onMoveDown)=\"moveSectionDown($event)\"\n                            (onInsertBelow)=\"insertBelowSection($event)\" (onDelete)=\"deleteSection($event)\">\n                        </oepa-document-section>\n                    </tab>\n                </tabset>\n            </div>\n        </div>\n    </div>\n</div>"]}

package/esm2022/lib/document/document-event-entity-type.mjs

@@ -0,0 +1,7 @@
+export var DocumentEventEntityType;
+(function (DocumentEventEntityType) {
+    DocumentEventEntityType[DocumentEventEntityType["Section"] = 0] = "Section";
+    DocumentEventEntityType[DocumentEventEntityType["Group"] = 1] = "Group";
+    DocumentEventEntityType[DocumentEventEntityType["Part"] = 2] = "Part";
+})(DocumentEventEntityType || (DocumentEventEntityType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jdW1lbnQtZXZlbnQtZW50aXR5LXR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9vZXBhLXVpLWxpYi9zcmMvbGliL2RvY3VtZW50L2RvY3VtZW50LWV2ZW50LWVudGl0eS10eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLHVCQUlYO0FBSkQsV0FBWSx1QkFBdUI7SUFDL0IsMkVBQU8sQ0FBQTtJQUNQLHVFQUFLLENBQUE7SUFDTCxxRUFBSSxDQUFBO0FBQ1IsQ0FBQyxFQUpXLHVCQUF1QixLQUF2Qix1QkFBdUIsUUFJbEMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBEb2N1bWVudEV2ZW50RW50aXR5VHlwZSB7XG4gICAgU2VjdGlvbixcbiAgICBHcm91cCxcbiAgICBQYXJ0XG59Il19

package/esm2022/lib/document/document-event-type.mjs

@@ -0,0 +1,7 @@
+export var DocumentEventType;
+(function (DocumentEventType) {
+    DocumentEventType[DocumentEventType["Create"] = 0] = "Create";
+    DocumentEventType[DocumentEventType["Update"] = 1] = "Update";
+    DocumentEventType[DocumentEventType["Delete"] = 2] = "Delete";
+})(DocumentEventType || (DocumentEventType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jdW1lbnQtZXZlbnQtdHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL29lcGEtdWktbGliL3NyYy9saWIvZG9jdW1lbnQvZG9jdW1lbnQtZXZlbnQtdHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxpQkFJWDtBQUpELFdBQVksaUJBQWlCO0lBQ3pCLDZEQUFNLENBQUE7SUFDTiw2REFBTSxDQUFBO0lBQ04sNkRBQU0sQ0FBQTtBQUNWLENBQUMsRUFKVyxpQkFBaUIsS0FBakIsaUJBQWlCLFFBSTVCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gRG9jdW1lbnRFdmVudFR5cGUge1xuICAgIENyZWF0ZSxcbiAgICBVcGRhdGUsXG4gICAgRGVsZXRlXG59Il19

package/esm2022/lib/document/document-event.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jdW1lbnQtZXZlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9vZXBhLXVpLWxpYi9zcmMvbGliL2RvY3VtZW50L2RvY3VtZW50LWV2ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEb2N1bWVudEV2ZW50RW50aXR5VHlwZSB9IGZyb20gXCIuL2RvY3VtZW50LWV2ZW50LWVudGl0eS10eXBlXCI7XG5pbXBvcnQgeyBEb2N1bWVudEV2ZW50VHlwZSB9IGZyb20gXCIuL2RvY3VtZW50LWV2ZW50LXR5cGVcIjtcblxuZXhwb3J0IGludGVyZmFjZSBEb2N1bWVudEV2ZW50IHtcbiAgICBldmVudFR5cGU/OiBEb2N1bWVudEV2ZW50VHlwZTtcbiAgICBlbnRpdHlUeXBlPzogRG9jdW1lbnRFdmVudEVudGl0eVR5cGU7XG4gICAgZW50aXR5SUQ/OiBzdHJpbmc7XG4gICAgY29uZmlybWF0aW9uTWVzc2FnZT86IHN0cmluZztcbiAgICBlbnRpdHk/OiBhbnk7XG59Il19

package/esm2022/lib/document/document-group/document-group.component.mjs

@@ -0,0 +1,210 @@
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import { GroupModalComponent } from '../group-modal/group-modal.component';
+import { DocumentEventType } from '../document-event-type';
+import { DocumentEventEntityType } from '../document-event-entity-type';
+import { ConfirmationModalComponent } from '../../confirmation-modal/confirmation-modal.component';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-bootstrap/modal";
+import * as i2 from "ngx-toastr";
+import * as i3 from "../document.service";
+import * as i4 from "@angular/common";
+import * as i5 from "ngx-bootstrap/tooltip";
+import * as i6 from "../document-part-editor/document-part-editor.component";
+export class DocumentGroupComponent {
+    modalService;
+    toastr;
+    documentService;
+    group;
+    onMoveUp = new EventEmitter();
+    onInsertAbove = new EventEmitter();
+    onMoveDown = new EventEmitter();
+    onInsertBelow = new EventEmitter();
+    onDelete = new EventEmitter();
+    busy = false;
+    constructor(modalService, toastr, documentService) {
+        this.modalService = modalService;
+        this.toastr = toastr;
+        this.documentService = documentService;
+    }
+    ngOnInit() {
+    }
+    moveUp() {
+        this.onMoveUp.emit(this.group);
+    }
+    insertAbove() {
+        this.onInsertAbove.emit(this.group);
+    }
+    moveDown() {
+        this.onMoveDown.emit(this.group);
+    }
+    insertBelow() {
+        this.onInsertBelow.emit(this.group);
+    }
+    delete() {
+        this.onDelete.emit(this.group);
+    }
+    movePartUp(part) {
+        if (part.sequence && part.sequence > 1) {
+            let clone = Object.assign({}, this.group);
+            if (clone.parts && clone.documentID) {
+                clone.parts.splice(part.sequence - 2, 0, clone.parts.splice(part.sequence - 1, 1)[0]);
+                this.resequence(clone);
+                this.documentService.updateDocumentGroup(clone).subscribe({
+                    next: () => {
+                        this.documentService.updateDcoumentID(clone.documentID || '');
+                    }, error: err => {
+                        this.toastr.error('Failed updating group: ' + err, 'ERROR');
+                    }
+                });
+            }
+        }
+    }
+    insertAbovePart(part) {
+        if (part.sequence) {
+            let newPart = this.newPart(part.sequence - 1 || 1);
+            this.insertPart(part.sequence - 1, newPart);
+        }
+    }
+    movePartDown(part) {
+        if (part.sequence && this.group.parts && part.sequence < this.group.parts.length) {
+            let clone = Object.assign({}, this.group);
+            if (clone.parts && clone.documentID) {
+                clone.parts.splice(part.sequence, 0, clone.parts.splice(part.sequence - 1, 1)[0]);
+                this.resequence(clone);
+                this.documentService.updateDocumentGroup(clone).subscribe({
+                    next: () => {
+                        this.documentService.updateDcoumentID(clone.documentID || '');
+                    }, error: err => {
+                        this.toastr.error('Failed updating group: ' + err, 'ERROR');
+                    }
+                });
+            }
+        }
+    }
+    insertBelowPart(part) {
+        if (part.sequence) {
+            let newPart = this.newPart(part.sequence + 1);
+            this.insertPart(part.sequence, newPart);
+        }
+    }
+    newPart(sequence) {
+        return {
+            groupID: this.group.id,
+            documentID: this.group.documentID,
+            sequence: sequence,
+            name: 'Paragraph ' + sequence,
+            display: true,
+            required: true
+        };
+    }
+    insertPart(insertIndex, newPart) {
+        const initialState = {
+            headerText: 'Insert Paragraph',
+            bodyText: 'Insert new paragraph?'
+        };
+        let modal = this.modalService.show(ConfirmationModalComponent, { initialState, ignoreBackdropClick: true });
+        modal.content.confirmClicked.subscribe(() => {
+            let clone = Object.assign({}, this.group);
+            if (clone.parts && clone.documentID) {
+                clone.parts.splice(insertIndex, 0, newPart);
+                this.resequence(clone);
+                this.documentService.createDocumentPart(newPart).subscribe({
+                    next: partID => {
+                        newPart.id = partID;
+                        this.documentService.updateDocumentGroup(clone).subscribe({
+                            next: () => {
+                                this.documentService.updateDcoumentID(clone.documentID || '');
+                            }, error: err => {
+                                this.toastr.error('Failed updating group: ' + err, 'ERROR');
+                            }
+                        });
+                    }, error: err => {
+                        this.toastr.error('Failed inserting paragraph: ' + err, 'ERROR');
+                    }
+                });
+            }
+        });
+    }
+    deletePart(part) {
+        let bodyText = 'Delete paragraph ' + part.name + '?';
+        const eventOverride = this.documentService.isOverriddenEvent({ eventType: DocumentEventType.Delete, entityType: DocumentEventEntityType.Part });
+        if (eventOverride && eventOverride.confirmationMessage) {
+            bodyText = eventOverride.confirmationMessage;
+        }
+        const initialState = {
+            headerText: 'Delete Paragraph',
+            bodyText: bodyText,
+            confirmBtnLabel: 'Yes',
+            cancelBtnLabel: 'No'
+        };
+        let modal = this.modalService.show(ConfirmationModalComponent, { initialState, ignoreBackdropClick: true });
+        modal.content.confirmClicked.subscribe(() => {
+            this.doDeletePart(part);
+        });
+    }
+    doDeletePart(part) {
+        let clone = Object.assign({}, this.group);
+        if (clone.parts && clone.documentID) {
+            clone.parts = clone.parts.filter(keep => {
+                keep.id != part.id;
+            });
+            this.resequence(clone);
+            this.documentService.updateDocumentGroup(clone).subscribe({
+                next: () => {
+                    this.documentService.deleteDocumentPart(part).subscribe({
+                        next: () => {
+                            this.documentService.updateDcoumentID(clone.documentID || '');
+                        }, error: err => {
+                            this.toastr.error('Failed deleting paragraph: ' + err, 'ERROR');
+                        }
+                    });
+                }, error: err => {
+                    this.toastr.error('Failed updating group: ' + err, 'ERROR');
+                }
+            });
+        }
+    }
+    resequence(group) {
+        let sequence = 1;
+        if (group.parts) {
+            group.parts.forEach(part => {
+                part.sequence = sequence++;
+            });
+        }
+    }
+    editGroup(group) {
+        const initialState = {
+            label: 'Edit Group Attributes',
+            group: group
+        };
+        let modal = this.modalService.show(GroupModalComponent, { initialState, ignoreBackdropClick: true });
+        modal.content.onGroupSave.subscribe(updatedGroup => {
+            this.busy = true;
+            this.documentService.updateDocumentGroup(updatedGroup).subscribe(() => {
+                this.busy = false;
+            }, err => {
+                this.toastr.error('Failed updating group: ' + err, 'ERROR');
+                this.busy = false;
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DocumentGroupComponent, deps: [{ token: i1.BsModalService }, { token: i2.ToastrService }, { token: i3.DocumentService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: DocumentGroupComponent, selector: "oepa-document-group", inputs: { group: "group" }, outputs: { onMoveUp: "onMoveUp", onInsertAbove: "onInsertAbove", onMoveDown: "onMoveDown", onInsertBelow: "onInsertBelow", onDelete: "onDelete" }, ngImport: i0, template: "<div *ngIf=\"group\" class=\"card\">\n        <div *ngIf=\"!group.isCollapsed\" class=\"row\">\n            <div class=\"col-sm-10\">\n                <div *ngIf=\"group.parts && group.parts.length > 0\">\n                    <div *ngFor=\"let p of group.parts\" class=\"row\">\n                        <div class=\"col-sm-12\">\n                            <oepa-document-part-editor [part]=\"p\" (onMoveUp)=\"movePartUp($event)\"\n                                (onInsertAbove)=\"insertAbovePart($event)\" (onMoveDown)=\"movePartDown($event)\"\n                                (onInsertBelow)=\"insertBelowPart($event)\" (onDelete)=\"deletePart($event)\">\n                            </oepa-document-part-editor>\n                        </div>\n                    </div>\n                </div>\n            </div>\n            <div class=\"col-sm-2 alert alert-info\" role=\"alert\">\n                <div class=\"row\">\n                    <div class=\"col-sm-12\">\n                        <button [id]=\"'deleteGroup'+group.sequence\" class=\"btn\" (click)=\"this.delete()\" tooltip=\"Delete Group\">\n                            <i class=\"bi bi-trash\"></i> \n                        </button>\n                        &nbsp;{{group.name || ''}}\n                    </div>\n                    <div class=\"col-sm-12\">\n                        <button [id]=\"'moveGroupUp'+group.sequence\" class=\"btn\" (click)=\"moveUp()\" tooltip=\"Move Group Up\">\n                            <i class=\"bi bi-chevron-double-up\"></i>\n                        </button>\n                        <button [id]=\"'insertaboveGroup'+group.sequence\" class=\"btn\" (click)=\"insertAbove()\" tooltip=\"Insert Group Above\">\n                            <i class=\"bi bi-arrow-up-circle\"></i>\n                        </button>\n                    </div>\n                    <div class=\"col-sm-12\">\n                        <button [id]=\"'moveGroupDown'+group.sequence\" class=\"btn\" (click)=\"moveDown()\" tooltip=\"Move Group Down\">\n                            <i class=\"bi bi-chevron-double-down\"></i>\n                        </button>\n                        <button [id]=\"'insertBelowGroup'+group.sequence\" class=\"btn\" (click)=\"insertBelow()\" tooltip=\"Insert Group Below\">\n                            <i class=\"bi bi-arrow-down-circle\"></i>\n                        </button>\n                    </div>\n                </div>\n            </div>\n        </div>\n</div>", styles: [""], dependencies: [{ kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i5.TooltipDirective, selector: "[tooltip], [tooltipHtml]", inputs: ["adaptivePosition", "tooltip", "placement", "triggers", "container", "containerClass", "boundariesElement", "isOpen", "isDisabled", "delay", "tooltipHtml", "tooltipPlacement", "tooltipIsOpen", "tooltipEnable", "tooltipAppendToBody", "tooltipAnimation", "tooltipClass", "tooltipContext", "tooltipPopupDelay", "tooltipFadeDuration", "tooltipTrigger"], outputs: ["tooltipChange", "onShown", "onHidden", "tooltipStateChanged"], exportAs: ["bs-tooltip"] }, { kind: "component", type: i6.DocumentPartEditorComponent, selector: "oepa-document-part-editor", inputs: ["part", "editing"], outputs: ["partChange", "onMoveUp", "onInsertAbove", "onMoveDown", "onInsertBelow", "onDelete"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DocumentGroupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'oepa-document-group', template: "<div *ngIf=\"group\" class=\"card\">\n        <div *ngIf=\"!group.isCollapsed\" class=\"row\">\n            <div class=\"col-sm-10\">\n                <div *ngIf=\"group.parts && group.parts.length > 0\">\n                    <div *ngFor=\"let p of group.parts\" class=\"row\">\n                        <div class=\"col-sm-12\">\n                            <oepa-document-part-editor [part]=\"p\" (onMoveUp)=\"movePartUp($event)\"\n                                (onInsertAbove)=\"insertAbovePart($event)\" (onMoveDown)=\"movePartDown($event)\"\n                                (onInsertBelow)=\"insertBelowPart($event)\" (onDelete)=\"deletePart($event)\">\n                            </oepa-document-part-editor>\n                        </div>\n                    </div>\n                </div>\n            </div>\n            <div class=\"col-sm-2 alert alert-info\" role=\"alert\">\n                <div class=\"row\">\n                    <div class=\"col-sm-12\">\n                        <button [id]=\"'deleteGroup'+group.sequence\" class=\"btn\" (click)=\"this.delete()\" tooltip=\"Delete Group\">\n                            <i class=\"bi bi-trash\"></i> \n                        </button>\n                        &nbsp;{{group.name || ''}}\n                    </div>\n                    <div class=\"col-sm-12\">\n                        <button [id]=\"'moveGroupUp'+group.sequence\" class=\"btn\" (click)=\"moveUp()\" tooltip=\"Move Group Up\">\n                            <i class=\"bi bi-chevron-double-up\"></i>\n                        </button>\n                        <button [id]=\"'insertaboveGroup'+group.sequence\" class=\"btn\" (click)=\"insertAbove()\" tooltip=\"Insert Group Above\">\n                            <i class=\"bi bi-arrow-up-circle\"></i>\n                        </button>\n                    </div>\n                    <div class=\"col-sm-12\">\n                        <button [id]=\"'moveGroupDown'+group.sequence\" class=\"btn\" (click)=\"moveDown()\" tooltip=\"Move Group Down\">\n                            <i class=\"bi bi-chevron-double-down\"></i>\n                        </button>\n                        <button [id]=\"'insertBelowGroup'+group.sequence\" class=\"btn\" (click)=\"insertBelow()\" tooltip=\"Insert Group Below\">\n                            <i class=\"bi bi-arrow-down-circle\"></i>\n                        </button>\n                    </div>\n                </div>\n            </div>\n        </div>\n</div>" }]
+        }], ctorParameters: () => [{ type: i1.BsModalService }, { type: i2.ToastrService }, { type: i3.DocumentService }], propDecorators: { group: [{
+                type: Input
+            }], onMoveUp: [{
+                type: Output
+            }], onInsertAbove: [{
+                type: Output
+            }], onMoveDown: [{
+                type: Output
+            }], onInsertBelow: [{
+                type: Output
+            }], onDelete: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"document-group.component.js","sourceRoot":"","sources":["../../../../../../projects/oepa-ui-lib/src/lib/document/document-group/document-group.component.ts","../../../../../../projects/oepa-ui-lib/src/lib/document/document-group/document-group.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, Input, Output, EventEmitter } from '@angular/core';\nimport { PortalDocumentGroup } from '../portal-document-group';\nimport { PortalDocumentPart } from '../portal-document-part';\nimport { DocumentService } from '../document.service';\nimport { BsModalService } from 'ngx-bootstrap/modal';\nimport { ToastrService } from 'ngx-toastr';\nimport { GroupModalComponent } from '../group-modal/group-modal.component';\nimport { DocumentEventType } from '../document-event-type';\nimport { DocumentEventEntityType } from '../document-event-entity-type';\nimport { DocumentEvent } from '../document-event';\nimport { ConfirmationModalComponent } from '../../confirmation-modal/confirmation-modal.component';\n\n@Component({\n  selector: 'oepa-document-group',\n  templateUrl: './document-group.component.html',\n  styleUrls: ['./document-group.component.css']\n})\nexport class DocumentGroupComponent implements OnInit {\n  @Input() group!: PortalDocumentGroup;\n\n  @Output() onMoveUp:  EventEmitter<PortalDocumentGroup> = new EventEmitter<PortalDocumentGroup>();\n  @Output() onInsertAbove: EventEmitter<PortalDocumentGroup> = new EventEmitter<PortalDocumentGroup>();\n  @Output() onMoveDown: EventEmitter<PortalDocumentGroup> = new EventEmitter<PortalDocumentGroup>();\n  @Output() onInsertBelow: EventEmitter<PortalDocumentGroup> = new EventEmitter<PortalDocumentGroup>();\n  @Output() onDelete: EventEmitter<PortalDocumentGroup> = new EventEmitter<PortalDocumentGroup>();\n\n\n  public busy = false;\n\n  constructor(private modalService: BsModalService,\n    private toastr: ToastrService,\n    private documentService: DocumentService) { }\n\n  ngOnInit() {\n  }\n\n  public moveUp() {\n    this.onMoveUp.emit(this.group);\n  }\n\n  public insertAbove() {\n    this.onInsertAbove.emit(this.group);\n  }\n\n  public moveDown() {\n    this.onMoveDown.emit(this.group);\n  }\n\n  public insertBelow() {\n    this.onInsertBelow.emit(this.group);\n  }\n\n  public delete() {\n    this.onDelete.emit(this.group);\n  }\n\n  public movePartUp(part: PortalDocumentPart) {\n    if (part.sequence && part.sequence > 1) {\n      let clone = Object.assign({}, this.group);\n      if (clone.parts && clone.documentID) {\n        clone.parts.splice(part.sequence - 2, 0, clone.parts.splice(part.sequence - 1, 1)[0]);\n        this.resequence(clone);\n        this.documentService.updateDocumentGroup(clone).subscribe({\n          next: () => {\n          this.documentService.updateDcoumentID(clone.documentID || '');\n        }, error: err => {\n          this.toastr.error('Failed updating group: ' + err, 'ERROR');\n        }});\n      }\n    }\n  }\n\n  public insertAbovePart(part: PortalDocumentPart) {\n    if (part.sequence) {\n      let newPart = this.newPart(part.sequence - 1 || 1);\n      this.insertPart(part.sequence -1, newPart);\n    }\n  }\n\n  public movePartDown(part: PortalDocumentPart) {\n    if (part.sequence && this.group.parts && part.sequence < this.group.parts.length) {\n      let clone = Object.assign({}, this.group);\n      if (clone.parts && clone.documentID) {\n        clone.parts.splice(part.sequence, 0, clone.parts.splice(part.sequence -  1, 1)[0]);\n        this.resequence(clone);\n        this.documentService.updateDocumentGroup(clone).subscribe({\n          next: () => {\n          this.documentService.updateDcoumentID(clone.documentID || '');\n        }, error: err => {\n          this.toastr.error('Failed updating group: ' + err, 'ERROR');\n        }});\n      }\n    }\n  }\n\n  public insertBelowPart(part: PortalDocumentPart) {\n    if (part.sequence) {\n      let newPart = this.newPart(part.sequence + 1);\n      this.insertPart(part.sequence, newPart);\n    }\n  }\n\n  private newPart(sequence: number) : PortalDocumentPart {\n    return {\n      groupID: this.group.id,\n      documentID: this.group.documentID,\n      sequence: sequence,\n      name: 'Paragraph ' + sequence,\n      display: true,\n      required: true\n    };\n  }\n\n  private insertPart(insertIndex: number, newPart: PortalDocumentPart) {\n    const initialState = {\n      headerText: 'Insert Paragraph',\n      bodyText: 'Insert new paragraph?'\n    }\n    let modal = this.modalService.show(ConfirmationModalComponent, {initialState, ignoreBackdropClick: true});\n    (<ConfirmationModalComponent>modal.content).confirmClicked.subscribe(() => {\n      let clone = Object.assign({}, this.group);\n      if (clone.parts && clone.documentID) {\n        clone.parts.splice(insertIndex, 0, newPart);\n        this.resequence(clone);\n        this.documentService.createDocumentPart(newPart).subscribe({\n          next: partID => {\n          newPart.id = partID;\n          this.documentService.updateDocumentGroup(clone).subscribe({\n            next: () => {\n            this.documentService.updateDcoumentID(clone.documentID || '');\n          }, error: err => {\n            this.toastr.error('Failed updating group: ' + err, 'ERROR');\n          }});\n        }, error: err => {\n          this.toastr.error('Failed inserting paragraph: ' + err, 'ERROR');\n        }});\n      }\n    });\n  }\n\n  public deletePart(part: PortalDocumentPart) {\n    let bodyText = 'Delete paragraph ' + part.name + '?';\n    const eventOverride: DocumentEvent | undefined = this.documentService.isOverriddenEvent({eventType: DocumentEventType.Delete, entityType: DocumentEventEntityType.Part});\n    if (eventOverride && eventOverride.confirmationMessage) {\n      bodyText = eventOverride.confirmationMessage;\n    }\n    const initialState = {\n      headerText: 'Delete Paragraph',\n      bodyText: bodyText,\n      confirmBtnLabel: 'Yes',\n      cancelBtnLabel: 'No'\n    }\n    let modal = this.modalService.show(ConfirmationModalComponent, {initialState, ignoreBackdropClick: true});\n    (<ConfirmationModalComponent>modal.content).confirmClicked.subscribe(() => {\n      this.doDeletePart(part);\n    });\n  }\n\n  private doDeletePart(part: PortalDocumentPart) {\n    let clone = Object.assign({}, this.group);\n    if (clone.parts && clone.documentID) {\n      clone.parts = clone.parts.filter(keep => {\n        keep.id != part.id;\n      });\n      this.resequence(clone);\n      this.documentService.updateDocumentGroup(clone).subscribe({\n        next: () => {\n        this.documentService.deleteDocumentPart(part).subscribe({\n          next: () => {\n          this.documentService.updateDcoumentID(clone.documentID || '');\n        }, error: err => {\n          this.toastr.error('Failed deleting paragraph: ' + err, 'ERROR');\n        }});\n      }, error: err => {\n        this.toastr.error('Failed updating group: ' + err, 'ERROR');\n      }});\n    }\n  }\n\n  private resequence(group: PortalDocumentGroup) {\n    let sequence = 1;\n    if (group.parts) {\n      group.parts.forEach(part => {\n        part.sequence = sequence++;\n      });\n    }\n  }\n\n  public editGroup(group: PortalDocumentGroup) {\n    const initialState = {\n      label: 'Edit Group Attributes',\n      group: group\n    }\n    let modal = this.modalService.show(GroupModalComponent, {initialState, ignoreBackdropClick: true});\n    (<GroupModalComponent>modal.content).onGroupSave.subscribe(updatedGroup => {\n      this.busy = true;\n      this.documentService.updateDocumentGroup(updatedGroup).subscribe(() => {\n        this.busy = false;\n      }, err => {\n        this.toastr.error('Failed updating group: ' + err, 'ERROR');\n        this.busy = false;\n      })\n    });\n  }\n\n}\n","<div *ngIf=\"group\" class=\"card\">\n        <div *ngIf=\"!group.isCollapsed\" class=\"row\">\n            <div class=\"col-sm-10\">\n                <div *ngIf=\"group.parts && group.parts.length > 0\">\n                    <div *ngFor=\"let p of group.parts\" class=\"row\">\n                        <div class=\"col-sm-12\">\n                            <oepa-document-part-editor [part]=\"p\" (onMoveUp)=\"movePartUp($event)\"\n                                (onInsertAbove)=\"insertAbovePart($event)\" (onMoveDown)=\"movePartDown($event)\"\n                                (onInsertBelow)=\"insertBelowPart($event)\" (onDelete)=\"deletePart($event)\">\n                            </oepa-document-part-editor>\n                        </div>\n                    </div>\n                </div>\n            </div>\n            <div class=\"col-sm-2 alert alert-info\" role=\"alert\">\n                <div class=\"row\">\n                    <div class=\"col-sm-12\">\n                        <button [id]=\"'deleteGroup'+group.sequence\" class=\"btn\" (click)=\"this.delete()\" tooltip=\"Delete Group\">\n                            <i class=\"bi bi-trash\"></i> \n                        </button>\n                        &nbsp;{{group.name || ''}}\n                    </div>\n                    <div class=\"col-sm-12\">\n                        <button [id]=\"'moveGroupUp'+group.sequence\" class=\"btn\" (click)=\"moveUp()\" tooltip=\"Move Group Up\">\n                            <i class=\"bi bi-chevron-double-up\"></i>\n                        </button>\n                        <button [id]=\"'insertaboveGroup'+group.sequence\" class=\"btn\" (click)=\"insertAbove()\" tooltip=\"Insert Group Above\">\n                            <i class=\"bi bi-arrow-up-circle\"></i>\n                        </button>\n                    </div>\n                    <div class=\"col-sm-12\">\n                        <button [id]=\"'moveGroupDown'+group.sequence\" class=\"btn\" (click)=\"moveDown()\" tooltip=\"Move Group Down\">\n                            <i class=\"bi bi-chevron-double-down\"></i>\n                        </button>\n                        <button [id]=\"'insertBelowGroup'+group.sequence\" class=\"btn\" (click)=\"insertBelow()\" tooltip=\"Insert Group Below\">\n                            <i class=\"bi bi-arrow-down-circle\"></i>\n                        </button>\n                    </div>\n                </div>\n            </div>\n        </div>\n</div>"]}

package/esm2022/lib/document/document-part/document-part.component.mjs

@@ -0,0 +1,19 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../document-part-editor/document-part-editor.component";
+export class DocumentPartComponent {
+    part;
+    constructor() { }
+    ngOnInit() {
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DocumentPartComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: DocumentPartComponent, selector: "oepa-document-part", inputs: { part: "part" }, ngImport: i0, template: "<div *ngIf=\"part\">\n    <oepa-document-part-editor [part]=\"part\"></oepa-document-part-editor>\n</div>\n<div *ngIf=\"part.parts && part.parts.length > 0\">\n    <div *ngFor=\"let p of part.parts\">\n        <oepa-document-part-editor [part]=\"p\"></oepa-document-part-editor>\n    </div>\n</div>\n", styles: [""], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.DocumentPartEditorComponent, selector: "oepa-document-part-editor", inputs: ["part", "editing"], outputs: ["partChange", "onMoveUp", "onInsertAbove", "onMoveDown", "onInsertBelow", "onDelete"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DocumentPartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'oepa-document-part', template: "<div *ngIf=\"part\">\n    <oepa-document-part-editor [part]=\"part\"></oepa-document-part-editor>\n</div>\n<div *ngIf=\"part.parts && part.parts.length > 0\">\n    <div *ngFor=\"let p of part.parts\">\n        <oepa-document-part-editor [part]=\"p\"></oepa-document-part-editor>\n    </div>\n</div>\n" }]
+        }], ctorParameters: () => [], propDecorators: { part: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jdW1lbnQtcGFydC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9vZXBhLXVpLWxpYi9zcmMvbGliL2RvY3VtZW50L2RvY3VtZW50LXBhcnQvZG9jdW1lbnQtcGFydC5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9vZXBhLXVpLWxpYi9zcmMvbGliL2RvY3VtZW50L2RvY3VtZW50LXBhcnQvZG9jdW1lbnQtcGFydC5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFVLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQzs7OztBQVF6RCxNQUFNLE9BQU8scUJBQXFCO0lBQ3ZCLElBQUksQ0FBc0I7SUFFbkMsZ0JBQWdCLENBQUM7SUFFakIsUUFBUTtJQUNSLENBQUM7d0dBTlUscUJBQXFCOzRGQUFyQixxQkFBcUIsb0ZDUmxDLDhTQVFBOzs0RkRBYSxxQkFBcUI7a0JBTGpDLFNBQVM7K0JBQ0Usb0JBQW9CO3dEQUtyQixJQUFJO3NCQUFaLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIE9uSW5pdCwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFBvcnRhbERvY3VtZW50UGFydCB9IGZyb20gJy4uL3BvcnRhbC1kb2N1bWVudC1wYXJ0JztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnb2VwYS1kb2N1bWVudC1wYXJ0JyxcbiAgdGVtcGxhdGVVcmw6ICcuL2RvY3VtZW50LXBhcnQuY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi9kb2N1bWVudC1wYXJ0LmNvbXBvbmVudC5jc3MnXVxufSlcbmV4cG9ydCBjbGFzcyBEb2N1bWVudFBhcnRDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuICBASW5wdXQoKSBwYXJ0ITogUG9ydGFsRG9jdW1lbnRQYXJ0O1xuXG4gIGNvbnN0cnVjdG9yKCkgeyB9XG5cbiAgbmdPbkluaXQoKSB7XG4gIH1cblxufVxuIiwiPGRpdiAqbmdJZj1cInBhcnRcIj5cbiAgICA8b2VwYS1kb2N1bWVudC1wYXJ0LWVkaXRvciBbcGFydF09XCJwYXJ0XCI+PC9vZXBhLWRvY3VtZW50LXBhcnQtZWRpdG9yPlxuPC9kaXY+XG48ZGl2ICpuZ0lmPVwicGFydC5wYXJ0cyAmJiBwYXJ0LnBhcnRzLmxlbmd0aCA+IDBcIj5cbiAgICA8ZGl2ICpuZ0Zvcj1cImxldCBwIG9mIHBhcnQucGFydHNcIj5cbiAgICAgICAgPG9lcGEtZG9jdW1lbnQtcGFydC1lZGl0b3IgW3BhcnRdPVwicFwiPjwvb2VwYS1kb2N1bWVudC1wYXJ0LWVkaXRvcj5cbiAgICA8L2Rpdj5cbjwvZGl2PlxuIl19