@huntsman-cancer-institute/cod 16.0.0 → 17.0.0

package/esm2022/components/attribute-container.component.mjs

@@ -1,121 +1,121 @@
-import { ChangeDetectorRef, Component, ElementRef, Input, Renderer2, HostBinding } from "@angular/core";
-import { Subscription } from "rxjs";
-import { NgbModal } from "@ng-bootstrap/ng-bootstrap";
-import { AttributeService } from "../services/attribute.service";
-import * as i0 from "@angular/core";
-import * as i1 from "../services/attribute.service";
-import * as i2 from "@ng-bootstrap/ng-bootstrap";
-import * as i3 from "@angular/common";
-import * as i4 from "@huntsman-cancer-institute/misc";
-import * as i5 from "./attribute-absolute.component";
-import * as i6 from "./attribute-flex.component";
-import * as i7 from "./attribute-edit.component";
-import * as i8 from "../pipes/is-group-attribute.pipe";
-/**
- * This component should be added on to any screen that displays a container with COD content.  This container
- * represents the one of the containers, which in turn contain attributes which display those values in the
- * attributeValueSet.
- */
-export class AttributeContainerComponent {
-    constructor(attributeService, elementRef, renderer, changeDetectorRef, modalService) {
-        this.attributeService = attributeService;
-        this.elementRef = elementRef;
-        this.renderer = renderer;
-        this.changeDetectorRef = changeDetectorRef;
-        this.modalService = modalService;
-        this.classList = "hci-attribute-configuration hci-cod d-flex flex-column flex-grow-1";
-        this.editInline = true;
-        this.editPopup = false;
-        this.editable = true;
-        this.windowDimension = {};
-        this.subscriptions = new Subscription();
-        this.getBusySubjects = () => {
-            let subjects = [];
-            //subjects.push(this.attributeService.getAttributeConfigurationLoadingSubject());
-            subjects.push(this.attributeService.getLoadingSubject());
-            return subjects;
-        };
-    }
-    /**
-     * Upon init, subscribe to the configuration and value set.
-     */
-    ngOnInit() {
-        if (!this.editable) {
-            this.editInline = false;
-            this.editPopup = false;
-        }
-        this.attributeService.setAttributeConfigurationById(this.idAttributeConfiguration, this.idAttributeValueSet, this.idParentObject);
-        this.subscriptions.add(this.attributeService.getAttributeConfigurationSubject().subscribe((attributeConfiguration) => {
-            if (attributeConfiguration) {
-                this.attributeConfiguration = attributeConfiguration;
-                if (this.idAttributeContainer !== undefined) {
-                    this.attributeContainer = this.getAttributeContainerById(this.idAttributeContainer);
-                }
-                if (this.indexOfContainer !== undefined) {
-                    if (this.attributeConfiguration.attributeContainers[this.indexOfContainer]) {
-                        this.attributeContainer = this.attributeConfiguration.attributeContainers[this.indexOfContainer];
-                    }
-                }
-            }
-        }));
-        this.subscriptions.add(this.attributeService.attributeConfigurationDimensionSubject.subscribe((windowDimension) => {
-            if (windowDimension) {
-                this.windowDimension = windowDimension;
-            }
-        }));
-        this.subscriptions.add(this.attributeService.getAttributeValueSet().subscribe((attributeValueSet) => {
-            this.attributeValueSet = attributeValueSet;
-            if (this.attributeValueSet) {
-                this.attributeService.notifyAttributes();
-            }
-        }));
-    }
-    set boundData(value) {
-        this.attributeService.setBoundData(value);
-    }
-    ngOnDestroy() {
-        this.subscriptions.unsubscribe();
-    }
-    ngOnChanges(changes) {
-        if (!this.editable) {
-            this.editInline = false;
-            this.editPopup = false;
-        }
-        if (changes.idAttributeContainer) {
-            this.idAttributeContainer = changes.idAttributeContainer.currentValue;
-            this.attributeContainer = this.getAttributeContainerById(this.idAttributeContainer);
-        }
-        if (changes.indexOfContainer) {
-            this.indexOfContainer = changes.indexOfContainer.currentValue;
-            if (this.attributeConfiguration && this.attributeConfiguration.attributeContainers[this.indexOfContainer]) {
-                this.attributeContainer = this.attributeConfiguration.attributeContainers[this.indexOfContainer];
-            }
-        }
-    }
-    getAttributeService() {
-        return this.attributeService;
-    }
-    edit(modal, editContainer) {
-        this.editContainer = editContainer;
-        this.modalService.open(modal, { windowClass: "modal-lg" }).result.then((result) => {
-            if (result === "Save") {
-                this.attributeService.updateAttributeValueSet();
-            }
-            else if (result === "Cancel") {
-                this.attributeService.clearUpdatedAttributeValues();
-            }
-        }, (reason) => { });
-    }
-    post() {
-        this.attributeService.updateAttributeValueSet();
-    }
-    getAttributeContainerById(idAttributeContainer) {
-        if (this.attributeConfiguration) {
-            return this.attributeConfiguration.attributeContainers.find(x => x.idAttributeContainer === idAttributeContainer);
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AttributeContainerComponent, deps: [{ token: i1.AttributeService }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }, { token: i2.NgbModal }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: AttributeContainerComponent, selector: "hci-attribute-container", inputs: { idAttributeValueSet: "idAttributeValueSet", idAttributeConfiguration: "idAttributeConfiguration", idAttributeContainer: "idAttributeContainer", indexOfContainer: "indexOfContainer", idParentObject: "idParentObject", attributeContainer: "attributeContainer", attributeConfiguration: "attributeConfiguration", attributeValueSet: "attributeValueSet", editInline: "editInline", editPopup: "editPopup", editable: "editable", boundData: "boundData" }, host: { properties: { "class": "this.classList" } }, usesOnChanges: true, ngImport: i0, template: `
+import { ChangeDetectorRef, Component, ElementRef, Input, Renderer2, HostBinding } from "@angular/core";
+import { Subscription } from "rxjs";
+import { NgbModal } from "@ng-bootstrap/ng-bootstrap";
+import { AttributeService } from "../services/attribute.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../services/attribute.service";
+import * as i2 from "@ng-bootstrap/ng-bootstrap";
+import * as i3 from "@angular/common";
+import * as i4 from "@huntsman-cancer-institute/misc";
+import * as i5 from "./attribute-absolute.component";
+import * as i6 from "./attribute-flex.component";
+import * as i7 from "./attribute-edit.component";
+import * as i8 from "../pipes/is-group-attribute.pipe";
+/**
+ * This component should be added on to any screen that displays a container with COD content.  This container
+ * represents the one of the containers, which in turn contain attributes which display those values in the
+ * attributeValueSet.
+ */
+export class AttributeContainerComponent {
+    constructor(attributeService, elementRef, renderer, changeDetectorRef, modalService) {
+        this.attributeService = attributeService;
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+        this.changeDetectorRef = changeDetectorRef;
+        this.modalService = modalService;
+        this.classList = "hci-attribute-configuration hci-cod d-flex flex-column flex-grow-1";
+        this.editInline = true;
+        this.editPopup = false;
+        this.editable = true;
+        this.windowDimension = {};
+        this.subscriptions = new Subscription();
+        this.getBusySubjects = () => {
+            let subjects = [];
+            //subjects.push(this.attributeService.getAttributeConfigurationLoadingSubject());
+            subjects.push(this.attributeService.getLoadingSubject());
+            return subjects;
+        };
+    }
+    /**
+     * Upon init, subscribe to the configuration and value set.
+     */
+    ngOnInit() {
+        if (!this.editable) {
+            this.editInline = false;
+            this.editPopup = false;
+        }
+        this.attributeService.setAttributeConfigurationById(this.idAttributeConfiguration, this.idAttributeValueSet, this.idParentObject);
+        this.subscriptions.add(this.attributeService.getAttributeConfigurationSubject().subscribe((attributeConfiguration) => {
+            if (attributeConfiguration) {
+                this.attributeConfiguration = attributeConfiguration;
+                if (this.idAttributeContainer !== undefined) {
+                    this.attributeContainer = this.getAttributeContainerById(this.idAttributeContainer);
+                }
+                if (this.indexOfContainer !== undefined) {
+                    if (this.attributeConfiguration.attributeContainers[this.indexOfContainer]) {
+                        this.attributeContainer = this.attributeConfiguration.attributeContainers[this.indexOfContainer];
+                    }
+                }
+            }
+        }));
+        this.subscriptions.add(this.attributeService.attributeConfigurationDimensionSubject.subscribe((windowDimension) => {
+            if (windowDimension) {
+                this.windowDimension = windowDimension;
+            }
+        }));
+        this.subscriptions.add(this.attributeService.getAttributeValueSet().subscribe((attributeValueSet) => {
+            this.attributeValueSet = attributeValueSet;
+            if (this.attributeValueSet) {
+                this.attributeService.notifyAttributes();
+            }
+        }));
+    }
+    set boundData(value) {
+        this.attributeService.setBoundData(value);
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    ngOnChanges(changes) {
+        if (!this.editable) {
+            this.editInline = false;
+            this.editPopup = false;
+        }
+        if (changes.idAttributeContainer) {
+            this.idAttributeContainer = changes.idAttributeContainer.currentValue;
+            this.attributeContainer = this.getAttributeContainerById(this.idAttributeContainer);
+        }
+        if (changes.indexOfContainer) {
+            this.indexOfContainer = changes.indexOfContainer.currentValue;
+            if (this.attributeConfiguration && this.attributeConfiguration.attributeContainers[this.indexOfContainer]) {
+                this.attributeContainer = this.attributeConfiguration.attributeContainers[this.indexOfContainer];
+            }
+        }
+    }
+    getAttributeService() {
+        return this.attributeService;
+    }
+    edit(modal, editContainer) {
+        this.editContainer = editContainer;
+        this.modalService.open(modal, { windowClass: "modal-lg" }).result.then((result) => {
+            if (result === "Save") {
+                this.attributeService.updateAttributeValueSet();
+            }
+            else if (result === "Cancel") {
+                this.attributeService.clearUpdatedAttributeValues();
+            }
+        }, (reason) => { });
+    }
+    post() {
+        this.attributeService.updateAttributeValueSet();
+    }
+    getAttributeContainerById(idAttributeContainer) {
+        if (this.attributeConfiguration) {
+            return this.attributeConfiguration.attributeContainers.find(x => x.idAttributeContainer === idAttributeContainer);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AttributeContainerComponent, deps: [{ token: i1.AttributeService }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }, { token: i2.NgbModal }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.2", type: AttributeContainerComponent, selector: "hci-attribute-container", inputs: { idAttributeValueSet: "idAttributeValueSet", idAttributeConfiguration: "idAttributeConfiguration", idAttributeContainer: "idAttributeContainer", indexOfContainer: "indexOfContainer", idParentObject: "idParentObject", attributeContainer: "attributeContainer", attributeConfiguration: "attributeConfiguration", attributeValueSet: "attributeValueSet", editInline: "editInline", editPopup: "editPopup", editable: "editable", boundData: "boundData" }, host: { properties: { "class": "this.classList" } }, usesOnChanges: true, ngImport: i0, template: `
     <hci-busy [getBusySubjects]="getBusySubjects"></hci-busy>
   
     <ng-container *ngIf="attributeContainer">
@@ -167,12 +167,12 @@ export class AttributeContainerComponent {
         <button class="btn btn-primary" (click)="close('Cancel')">Cancel</button>
       </div>
     </ng-template>
-  `, isInline: true, dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.BusyComponent, selector: "hci-busy", inputs: ["busy", "busySubjects", "getBusySubjects", "parentSelector", "rootClass", "icon", "iconSize", "showIcon", "mxAuto", "myAuto", "text", "template", "config"] }, { kind: "component", type: i5.AttributeAbsoluteComponent, selector: "hci-attribute-absolute" }, { kind: "component", type: i6.AttributeFlexComponent, selector: "hci-attribute-flex" }, { kind: "component", type: i7.AttributeEditComponent, selector: "hci-attribute-edit" }, { kind: "pipe", type: i8.IsGroupAttributePipe, name: "isGroupAttribute" }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AttributeContainerComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: "hci-attribute-container",
+  `, isInline: true, dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.BusyComponent, selector: "hci-busy", inputs: ["busy", "busySubjects", "getBusySubjects", "parentSelector", "rootClass", "icon", "iconSize", "showIcon", "mxAuto", "myAuto", "text", "template", "config"] }, { kind: "component", type: i5.AttributeAbsoluteComponent, selector: "hci-attribute-absolute" }, { kind: "component", type: i6.AttributeFlexComponent, selector: "hci-attribute-flex" }, { kind: "component", type: i7.AttributeEditComponent, selector: "hci-attribute-edit" }, { kind: "pipe", type: i8.IsGroupAttributePipe, name: "isGroupAttribute" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AttributeContainerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "hci-attribute-container",
                     template: `
     <hci-busy [getBusySubjects]="getBusySubjects"></hci-busy>
   
@@ -225,34 +225,34 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
         <button class="btn btn-primary" (click)="close('Cancel')">Cancel</button>
       </div>
     </ng-template>
-  `
-                }]
-        }], ctorParameters: function () { return [{ type: i1.AttributeService }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }, { type: i2.NgbModal }]; }, propDecorators: { classList: [{
-                type: HostBinding,
-                args: ["class"]
-            }], idAttributeValueSet: [{
-                type: Input
-            }], idAttributeConfiguration: [{
-                type: Input
-            }], idAttributeContainer: [{
-                type: Input
-            }], indexOfContainer: [{
-                type: Input
-            }], idParentObject: [{
-                type: Input
-            }], attributeContainer: [{
-                type: Input
-            }], attributeConfiguration: [{
-                type: Input
-            }], attributeValueSet: [{
-                type: Input
-            }], editInline: [{
-                type: Input
-            }], editPopup: [{
-                type: Input
-            }], editable: [{
-                type: Input
-            }], boundData: [{
-                type: Input
-            }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attribute-container.component.js","sourceRoot":"","sources":["../../../../projects/cod/src/components/attribute-container.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectorRef, Component, ContentChildren, ElementRef, Input, isDevMode,\r\n  QueryList, Renderer2, ViewChildren, SimpleChanges, HostBinding, TemplateRef\r\n} from \"@angular/core\";\r\nimport { Subject, Subscription } from \"rxjs\";\r\nimport {NgbModal, NgbPanel} from \"@ng-bootstrap/ng-bootstrap\";\r\nimport {AccordionNavComponent} from \"@huntsman-cancer-institute/misc\";\r\nimport {AttributeService} from \"../services/attribute.service\";\r\nimport {AttributeConfiguration} from \"../model/attribute-configuration.entity\";\r\nimport {AttributeValueSet} from \"../model/attribute-value-set.entity\";\r\nimport {AttributeContainer} from \"../model/attribute-container.entity\";\r\n\r\n/**\r\n * This component should be added on to any screen that displays a container with COD content.  This container\r\n * represents the one of the containers, which in turn contain attributes which display those values in the\r\n * attributeValueSet.\r\n */\r\n@Component({\r\n  selector: \"hci-attribute-container\",\r\n  template: `\r\n    <hci-busy [getBusySubjects]=\"getBusySubjects\"></hci-busy>\r\n  \r\n    <ng-container *ngIf=\"attributeContainer\">\r\n      <div *ngIf=\"editPopup\" [id]=\"'id-attribute-container-' + attributeContainer.idAttributeContainer + '-header'\"\r\n           class=\"d-flex attribute-container-header {{'sort-order-' + attributeContainer.sortOrder}}\">\r\n        <div class=\"ml-auto mr-0\" (click)=\"edit(editModal, attributeContainer)\">\r\n          <i class=\"fas fa-pencil\"></i>\r\n        </div>\r\n      </div>\r\n      <div class=\"d-flex flex-grow-1 y-auto\" style=\"flex: 1 1 1px;\">\r\n        <div class=\"attribute-container\"\r\n             [class.col-md-12]=\"attributeContainer.isAutoLayout && attributeContainer.isAutoLayout === 'Y'\"\r\n             [class.flex]=\"attributeContainer.isAutoLayout && attributeContainer.isAutoLayout === 'Y'\"\r\n             [class.flex-wrap]=\"attributeContainer.isAutoLayout && attributeContainer.isAutoLayout === 'Y'\"\r\n             [class.absolute]=\"!attributeContainer.isAutoLayout || attributeContainer.isAutoLayout === 'N'\">\r\n          <ng-container *ngFor=\"let attribute of attributeContainer.graphicalAttributes | isGroupAttribute: false\">\r\n            <ng-container *ngIf=\"attributeContainer.isAutoLayout && attributeContainer.isAutoLayout === 'Y' && attribute.codeAttributeDataType !== 'LINE'\">\r\n              <hci-attribute-flex [id]=\"'id-attribute-' + attribute.idAttribute\"\r\n                                  [attribute]=\"attribute\"\r\n                                  [editInline]=\"editInline\"\r\n                                  [class.attribute]=\"true\"\r\n                                  [class.col-4]=\"attribute.codeAttributeDataType !== 'GA' && attribute.codeAttributeDataType !== 'LINE'\"\r\n                                  [class.col-12]=\"attribute.codeAttributeDataType === 'GA' || attribute.codeAttributeDataType === 'LINE'\"></hci-attribute-flex>\r\n            </ng-container>\r\n            <ng-container *ngIf=\"!attributeContainer.isAutoLayout || attributeContainer.isAutoLayout === 'N'\">\r\n              <hci-attribute-absolute [id]=\"'id-attribute-' + attribute.idAttribute\"\r\n                                      [attribute]=\"attribute\"\r\n                                      [editInline]=\"editInline\"\r\n                                      [class.attribute]=\"true\"></hci-attribute-absolute>\r\n            </ng-container>\r\n          </ng-container>\r\n        </div>\r\n      </div>\r\n    </ng-container>\r\n\r\n    <ng-template #editModal let-close=\"close\">\r\n      <div class=\"modal-header\">\r\n        {{editContainer.containerName}}\r\n      </div>\r\n      <div class=\"modal-body d-flex flex-column hci-cod-edit\">\r\n        <ng-container *ngFor=\"let attribute of editContainer.graphicalAttributes | isGroupAttribute: false\">\r\n          <hci-attribute-edit [id]=\"'edit-id-attribute-' + attribute.idAttribute\"\r\n                              [attribute]=\"attribute\"\r\n                              class=\"attribute\"></hci-attribute-edit>\r\n        </ng-container>\r\n      </div>\r\n      <div class=\"modal-footer\">\r\n        <button class=\"btn btn-primary\" (click)=\"close('Save')\">Save</button>\r\n        <button class=\"btn btn-primary\" (click)=\"close('Cancel')\">Cancel</button>\r\n      </div>\r\n    </ng-template>\r\n  `\r\n})\r\nexport class AttributeContainerComponent {\r\n  @HostBinding(\"class\") classList: string = \"hci-attribute-configuration hci-cod d-flex flex-column flex-grow-1\";\r\n\r\n  @Input() idAttributeValueSet: number;\r\n  @Input() idAttributeConfiguration: number;\r\n  @Input() idAttributeContainer: number;\r\n  @Input() indexOfContainer: number;\r\n  @Input() idParentObject: number;\r\n\r\n  @Input() attributeContainer: AttributeContainer;\r\n  @Input() attributeConfiguration: AttributeConfiguration;\r\n  @Input() attributeValueSet: AttributeValueSet;\r\n  \r\n  @Input() editInline: boolean = true;\r\n  @Input() editPopup: boolean =  false;\r\n  @Input() editable: boolean = true;\r\n\r\n  editContainer: AttributeContainer;\r\n\r\n  windowDimension: any = {};\r\n\r\n  subscriptions: Subscription = new Subscription();\r\n  \r\n  getBusySubjects: Function = () => {\r\n    let subjects: any[] = [];\r\n  \r\n    //subjects.push(this.attributeService.getAttributeConfigurationLoadingSubject());\r\n    subjects.push(this.attributeService.getLoadingSubject());\r\n    \r\n    return subjects;\r\n  };\r\n\r\n  constructor(private attributeService: AttributeService,\r\n              private elementRef: ElementRef,\r\n              private renderer: Renderer2,\r\n              private changeDetectorRef: ChangeDetectorRef,\r\n              private modalService: NgbModal) {}\r\n\r\n  /**\r\n   * Upon init, subscribe to the configuration and value set.\r\n   */\r\n  ngOnInit() {\r\n    if (! this.editable) {\r\n      this.editInline = false;\r\n      this.editPopup = false;\r\n    }\r\n    \r\n    this.attributeService.setAttributeConfigurationById(this.idAttributeConfiguration, this.idAttributeValueSet, this.idParentObject);\r\n\r\n    this.subscriptions.add(this.attributeService.getAttributeConfigurationSubject().subscribe((attributeConfiguration: AttributeConfiguration) => {\r\n      if(attributeConfiguration) {\r\n        this.attributeConfiguration = attributeConfiguration;\r\n\r\n        if (this.idAttributeContainer !== undefined) {\r\n          this.attributeContainer = this.getAttributeContainerById(this.idAttributeContainer);\r\n        }\r\n\r\n        if (this.indexOfContainer !== undefined) {\r\n          if (this.attributeConfiguration.attributeContainers[this.indexOfContainer]) {\r\n            this.attributeContainer = this.attributeConfiguration.attributeContainers[this.indexOfContainer];\r\n          }\r\n        }\r\n      }\r\n    }));\r\n\r\n    this.subscriptions.add(this.attributeService.attributeConfigurationDimensionSubject.subscribe((windowDimension: any) => {\r\n      if(windowDimension){\r\n        this.windowDimension = windowDimension;\r\n      }\r\n    }));\r\n\r\n    this.subscriptions.add(this.attributeService.getAttributeValueSet().subscribe((attributeValueSet: AttributeValueSet) => {\r\n      this.attributeValueSet = attributeValueSet;\r\n\r\n      if (this.attributeValueSet) {\r\n        this.attributeService.notifyAttributes();\r\n      }\r\n    }));\r\n  }\r\n\r\n  @Input() set boundData(value: any) {\r\n    this.attributeService.setBoundData(value);\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.subscriptions.unsubscribe();\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges) {\r\n    if (! this.editable) {\r\n      this.editInline = false;\r\n      this.editPopup = false;\r\n    }\r\n    \r\n    if (changes.idAttributeContainer) {\r\n      this.idAttributeContainer = changes.idAttributeContainer.currentValue;\r\n\r\n      this.attributeContainer = this.getAttributeContainerById(this.idAttributeContainer);\r\n    }\r\n\r\n    if (changes.indexOfContainer) {\r\n      this.indexOfContainer = changes.indexOfContainer.currentValue;\r\n      if (this.attributeConfiguration && this.attributeConfiguration.attributeContainers[this.indexOfContainer]) {\r\n        this.attributeContainer = this.attributeConfiguration.attributeContainers[this.indexOfContainer];\r\n      }\r\n    }\r\n  }\r\n\r\n  getAttributeService(): AttributeService {\r\n    return this.attributeService;\r\n  }\r\n\r\n  edit(modal: TemplateRef<any>, editContainer: AttributeContainer): void {\r\n    this.editContainer = editContainer;\r\n\r\n    this.modalService.open(modal, {windowClass: \"modal-lg\"}).result.then((result) => {\r\n      if (result === \"Save\") {\r\n        this.attributeService.updateAttributeValueSet();\r\n      } else if (result === \"Cancel\") {\r\n        this.attributeService.clearUpdatedAttributeValues();\r\n      }\r\n    }, (reason) => {});\r\n  }\r\n\r\n  post(): void {\r\n    this.attributeService.updateAttributeValueSet();\r\n  }\r\n\r\n  getAttributeContainerById(idAttributeContainer: number): AttributeContainer {\r\n    if (this.attributeConfiguration) {\r\n      return this.attributeConfiguration.attributeContainers.find(x => x.idAttributeContainer === idAttributeContainer);\r\n    }\r\n  }\r\n}\r\n"]}
+  `
+                }]
+        }], ctorParameters: () => [{ type: i1.AttributeService }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }, { type: i2.NgbModal }], propDecorators: { classList: [{
+                type: HostBinding,
+                args: ["class"]
+            }], idAttributeValueSet: [{
+                type: Input
+            }], idAttributeConfiguration: [{
+                type: Input
+            }], idAttributeContainer: [{
+                type: Input
+            }], indexOfContainer: [{
+                type: Input
+            }], idParentObject: [{
+                type: Input
+            }], attributeContainer: [{
+                type: Input
+            }], attributeConfiguration: [{
+                type: Input
+            }], attributeValueSet: [{
+                type: Input
+            }], editInline: [{
+                type: Input
+            }], editPopup: [{
+                type: Input
+            }], editable: [{
+                type: Input
+            }], boundData: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attribute-container.component.js","sourceRoot":"","sources":["../../../../projects/cod/src/components/attribute-container.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EAAE,SAAS,EAAmB,UAAU,EAAE,KAAK,EACrD,SAAS,EAA+B,WAAW,EAC/D,MAAM,eAAe,CAAC;AACvB,OAAO,EAAW,YAAY,EAAE,MAAM,MAAM,CAAC;AAC7C,OAAO,EAAC,QAAQ,EAAW,MAAM,4BAA4B,CAAC;AAE9D,OAAO,EAAC,gBAAgB,EAAC,MAAM,+BAA+B,CAAC;;;;;;;;;;AAK/D;;;;GAIG;AAyDH,MAAM,OAAO,2BAA2B;IAgCtC,YAAoB,gBAAkC,EAClC,UAAsB,EACtB,QAAmB,EACnB,iBAAoC,EACpC,YAAsB;QAJtB,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,eAAU,GAAV,UAAU,CAAY;QACtB,aAAQ,GAAR,QAAQ,CAAW;QACnB,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,iBAAY,GAAZ,YAAY,CAAU;QAnCpB,cAAS,GAAW,oEAAoE,CAAC;QAYtG,eAAU,GAAY,IAAI,CAAC;QAC3B,cAAS,GAAa,KAAK,CAAC;QAC5B,aAAQ,GAAY,IAAI,CAAC;QAIlC,oBAAe,GAAQ,EAAE,CAAC;QAE1B,kBAAa,GAAiB,IAAI,YAAY,EAAE,CAAC;QAEjD,oBAAe,GAAa,GAAG,EAAE;YAC/B,IAAI,QAAQ,GAAU,EAAE,CAAC;YAEzB,iFAAiF;YACjF,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,EAAE,CAAC,CAAC;YAEzD,OAAO,QAAQ,CAAC;QAClB,CAAC,CAAC;IAM2C,CAAC;IAE9C;;OAEG;IACH,QAAQ;QACN,IAAI,CAAE,IAAI,CAAC,QAAQ,EAAE,CAAC;YACpB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;YACxB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACzB,CAAC;QAED,IAAI,CAAC,gBAAgB,CAAC,6BAA6B,CAAC,IAAI,CAAC,wBAAwB,EAAE,IAAI,CAAC,mBAAmB,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QAElI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,gCAAgC,EAAE,CAAC,SAAS,CAAC,CAAC,sBAA8C,EAAE,EAAE;YAC3I,IAAG,sBAAsB,EAAE,CAAC;gBAC1B,IAAI,CAAC,sBAAsB,GAAG,sBAAsB,CAAC;gBAErD,IAAI,IAAI,CAAC,oBAAoB,KAAK,SAAS,EAAE,CAAC;oBAC5C,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;gBACtF,CAAC;gBAED,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;oBACxC,IAAI,IAAI,CAAC,sBAAsB,CAAC,mBAAmB,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC;wBAC3E,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,sBAAsB,CAAC,mBAAmB,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;oBACnG,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC,CAAC;QAEJ,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,sCAAsC,CAAC,SAAS,CAAC,CAAC,eAAoB,EAAE,EAAE;YACrH,IAAG,eAAe,EAAC,CAAC;gBAClB,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;YACzC,CAAC;QACH,CAAC,CAAC,CAAC,CAAC;QAEJ,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,oBAAoB,EAAE,CAAC,SAAS,CAAC,CAAC,iBAAoC,EAAE,EAAE;YACrH,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;YAE3C,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAC3B,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,EAAE,CAAC;YAC3C,CAAC;QACH,CAAC,CAAC,CAAC,CAAC;IACN,CAAC;IAED,IAAa,SAAS,CAAC,KAAU;QAC/B,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED,WAAW;QACT,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;IACnC,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,CAAE,IAAI,CAAC,QAAQ,EAAE,CAAC;YACpB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;YACxB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACzB,CAAC;QAED,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC;YACjC,IAAI,CAAC,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC,YAAY,CAAC;YAEtE,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QACtF,CAAC;QAED,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;YAC7B,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,YAAY,CAAC;YAC9D,IAAI,IAAI,CAAC,sBAAsB,IAAI,IAAI,CAAC,sBAAsB,CAAC,mBAAmB,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC;gBAC1G,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,sBAAsB,CAAC,mBAAmB,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;YACnG,CAAC;QACH,CAAC;IACH,CAAC;IAED,mBAAmB;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAED,IAAI,CAAC,KAAuB,EAAE,aAAiC;QAC7D,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QAEnC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,EAAE,EAAC,WAAW,EAAE,UAAU,EAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YAC9E,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;gBACtB,IAAI,CAAC,gBAAgB,CAAC,uBAAuB,EAAE,CAAC;YAClD,CAAC;iBAAM,IAAI,MAAM,KAAK,QAAQ,EAAE,CAAC;gBAC/B,IAAI,CAAC,gBAAgB,CAAC,2BAA2B,EAAE,CAAC;YACtD,CAAC;QACH,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,GAAE,CAAC,CAAC,CAAC;IACrB,CAAC;IAED,IAAI;QACF,IAAI,CAAC,gBAAgB,CAAC,uBAAuB,EAAE,CAAC;IAClD,CAAC;IAED,yBAAyB,CAAC,oBAA4B;QACpD,IAAI,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAChC,OAAO,IAAI,CAAC,sBAAsB,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,oBAAoB,KAAK,oBAAoB,CAAC,CAAC;QACpH,CAAC;IACH,CAAC;8GApIU,2BAA2B;kGAA3B,2BAA2B,ilBAtD5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDT;;2FAEU,2BAA2B;kBAxDvC,SAAS;mBAAC;oBACT,QAAQ,EAAE,yBAAyB;oBACnC,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDT;iBACF;6LAEuB,SAAS;sBAA9B,WAAW;uBAAC,OAAO;gBAEX,mBAAmB;sBAA3B,KAAK;gBACG,wBAAwB;sBAAhC,KAAK;gBACG,oBAAoB;sBAA5B,KAAK;gBACG,gBAAgB;sBAAxB,KAAK;gBACG,cAAc;sBAAtB,KAAK;gBAEG,kBAAkB;sBAA1B,KAAK;gBACG,sBAAsB;sBAA9B,KAAK;gBACG,iBAAiB;sBAAzB,KAAK;gBAEG,UAAU;sBAAlB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBAiEO,SAAS;sBAArB,KAAK","sourcesContent":["import {\r\n  ChangeDetectorRef, Component, ContentChildren, ElementRef, Input, isDevMode,\r\n  QueryList, Renderer2, ViewChildren, SimpleChanges, HostBinding, TemplateRef\r\n} from \"@angular/core\";\r\nimport { Subject, Subscription } from \"rxjs\";\r\nimport {NgbModal, NgbPanel} from \"@ng-bootstrap/ng-bootstrap\";\r\nimport {AccordionNavComponent} from \"@huntsman-cancer-institute/misc\";\r\nimport {AttributeService} from \"../services/attribute.service\";\r\nimport {AttributeConfiguration} from \"../model/attribute-configuration.entity\";\r\nimport {AttributeValueSet} from \"../model/attribute-value-set.entity\";\r\nimport {AttributeContainer} from \"../model/attribute-container.entity\";\r\n\r\n/**\r\n * This component should be added on to any screen that displays a container with COD content.  This container\r\n * represents the one of the containers, which in turn contain attributes which display those values in the\r\n * attributeValueSet.\r\n */\r\n@Component({\r\n  selector: \"hci-attribute-container\",\r\n  template: `\r\n    <hci-busy [getBusySubjects]=\"getBusySubjects\"></hci-busy>\r\n  \r\n    <ng-container *ngIf=\"attributeContainer\">\r\n      <div *ngIf=\"editPopup\" [id]=\"'id-attribute-container-' + attributeContainer.idAttributeContainer + '-header'\"\r\n           class=\"d-flex attribute-container-header {{'sort-order-' + attributeContainer.sortOrder}}\">\r\n        <div class=\"ml-auto mr-0\" (click)=\"edit(editModal, attributeContainer)\">\r\n          <i class=\"fas fa-pencil\"></i>\r\n        </div>\r\n      </div>\r\n      <div class=\"d-flex flex-grow-1 y-auto\" style=\"flex: 1 1 1px;\">\r\n        <div class=\"attribute-container\"\r\n             [class.col-md-12]=\"attributeContainer.isAutoLayout && attributeContainer.isAutoLayout === 'Y'\"\r\n             [class.flex]=\"attributeContainer.isAutoLayout && attributeContainer.isAutoLayout === 'Y'\"\r\n             [class.flex-wrap]=\"attributeContainer.isAutoLayout && attributeContainer.isAutoLayout === 'Y'\"\r\n             [class.absolute]=\"!attributeContainer.isAutoLayout || attributeContainer.isAutoLayout === 'N'\">\r\n          <ng-container *ngFor=\"let attribute of attributeContainer.graphicalAttributes | isGroupAttribute: false\">\r\n            <ng-container *ngIf=\"attributeContainer.isAutoLayout && attributeContainer.isAutoLayout === 'Y' && attribute.codeAttributeDataType !== 'LINE'\">\r\n              <hci-attribute-flex [id]=\"'id-attribute-' + attribute.idAttribute\"\r\n                                  [attribute]=\"attribute\"\r\n                                  [editInline]=\"editInline\"\r\n                                  [class.attribute]=\"true\"\r\n                                  [class.col-4]=\"attribute.codeAttributeDataType !== 'GA' && attribute.codeAttributeDataType !== 'LINE'\"\r\n                                  [class.col-12]=\"attribute.codeAttributeDataType === 'GA' || attribute.codeAttributeDataType === 'LINE'\"></hci-attribute-flex>\r\n            </ng-container>\r\n            <ng-container *ngIf=\"!attributeContainer.isAutoLayout || attributeContainer.isAutoLayout === 'N'\">\r\n              <hci-attribute-absolute [id]=\"'id-attribute-' + attribute.idAttribute\"\r\n                                      [attribute]=\"attribute\"\r\n                                      [editInline]=\"editInline\"\r\n                                      [class.attribute]=\"true\"></hci-attribute-absolute>\r\n            </ng-container>\r\n          </ng-container>\r\n        </div>\r\n      </div>\r\n    </ng-container>\r\n\r\n    <ng-template #editModal let-close=\"close\">\r\n      <div class=\"modal-header\">\r\n        {{editContainer.containerName}}\r\n      </div>\r\n      <div class=\"modal-body d-flex flex-column hci-cod-edit\">\r\n        <ng-container *ngFor=\"let attribute of editContainer.graphicalAttributes | isGroupAttribute: false\">\r\n          <hci-attribute-edit [id]=\"'edit-id-attribute-' + attribute.idAttribute\"\r\n                              [attribute]=\"attribute\"\r\n                              class=\"attribute\"></hci-attribute-edit>\r\n        </ng-container>\r\n      </div>\r\n      <div class=\"modal-footer\">\r\n        <button class=\"btn btn-primary\" (click)=\"close('Save')\">Save</button>\r\n        <button class=\"btn btn-primary\" (click)=\"close('Cancel')\">Cancel</button>\r\n      </div>\r\n    </ng-template>\r\n  `\r\n})\r\nexport class AttributeContainerComponent {\r\n  @HostBinding(\"class\") classList: string = \"hci-attribute-configuration hci-cod d-flex flex-column flex-grow-1\";\r\n\r\n  @Input() idAttributeValueSet: number;\r\n  @Input() idAttributeConfiguration: number;\r\n  @Input() idAttributeContainer: number;\r\n  @Input() indexOfContainer: number;\r\n  @Input() idParentObject: number;\r\n\r\n  @Input() attributeContainer: AttributeContainer;\r\n  @Input() attributeConfiguration: AttributeConfiguration;\r\n  @Input() attributeValueSet: AttributeValueSet;\r\n  \r\n  @Input() editInline: boolean = true;\r\n  @Input() editPopup: boolean =  false;\r\n  @Input() editable: boolean = true;\r\n\r\n  editContainer: AttributeContainer;\r\n\r\n  windowDimension: any = {};\r\n\r\n  subscriptions: Subscription = new Subscription();\r\n  \r\n  getBusySubjects: Function = () => {\r\n    let subjects: any[] = [];\r\n  \r\n    //subjects.push(this.attributeService.getAttributeConfigurationLoadingSubject());\r\n    subjects.push(this.attributeService.getLoadingSubject());\r\n    \r\n    return subjects;\r\n  };\r\n\r\n  constructor(private attributeService: AttributeService,\r\n              private elementRef: ElementRef,\r\n              private renderer: Renderer2,\r\n              private changeDetectorRef: ChangeDetectorRef,\r\n              private modalService: NgbModal) {}\r\n\r\n  /**\r\n   * Upon init, subscribe to the configuration and value set.\r\n   */\r\n  ngOnInit() {\r\n    if (! this.editable) {\r\n      this.editInline = false;\r\n      this.editPopup = false;\r\n    }\r\n    \r\n    this.attributeService.setAttributeConfigurationById(this.idAttributeConfiguration, this.idAttributeValueSet, this.idParentObject);\r\n\r\n    this.subscriptions.add(this.attributeService.getAttributeConfigurationSubject().subscribe((attributeConfiguration: AttributeConfiguration) => {\r\n      if(attributeConfiguration) {\r\n        this.attributeConfiguration = attributeConfiguration;\r\n\r\n        if (this.idAttributeContainer !== undefined) {\r\n          this.attributeContainer = this.getAttributeContainerById(this.idAttributeContainer);\r\n        }\r\n\r\n        if (this.indexOfContainer !== undefined) {\r\n          if (this.attributeConfiguration.attributeContainers[this.indexOfContainer]) {\r\n            this.attributeContainer = this.attributeConfiguration.attributeContainers[this.indexOfContainer];\r\n          }\r\n        }\r\n      }\r\n    }));\r\n\r\n    this.subscriptions.add(this.attributeService.attributeConfigurationDimensionSubject.subscribe((windowDimension: any) => {\r\n      if(windowDimension){\r\n        this.windowDimension = windowDimension;\r\n      }\r\n    }));\r\n\r\n    this.subscriptions.add(this.attributeService.getAttributeValueSet().subscribe((attributeValueSet: AttributeValueSet) => {\r\n      this.attributeValueSet = attributeValueSet;\r\n\r\n      if (this.attributeValueSet) {\r\n        this.attributeService.notifyAttributes();\r\n      }\r\n    }));\r\n  }\r\n\r\n  @Input() set boundData(value: any) {\r\n    this.attributeService.setBoundData(value);\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.subscriptions.unsubscribe();\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges) {\r\n    if (! this.editable) {\r\n      this.editInline = false;\r\n      this.editPopup = false;\r\n    }\r\n    \r\n    if (changes.idAttributeContainer) {\r\n      this.idAttributeContainer = changes.idAttributeContainer.currentValue;\r\n\r\n      this.attributeContainer = this.getAttributeContainerById(this.idAttributeContainer);\r\n    }\r\n\r\n    if (changes.indexOfContainer) {\r\n      this.indexOfContainer = changes.indexOfContainer.currentValue;\r\n      if (this.attributeConfiguration && this.attributeConfiguration.attributeContainers[this.indexOfContainer]) {\r\n        this.attributeContainer = this.attributeConfiguration.attributeContainers[this.indexOfContainer];\r\n      }\r\n    }\r\n  }\r\n\r\n  getAttributeService(): AttributeService {\r\n    return this.attributeService;\r\n  }\r\n\r\n  edit(modal: TemplateRef<any>, editContainer: AttributeContainer): void {\r\n    this.editContainer = editContainer;\r\n\r\n    this.modalService.open(modal, {windowClass: \"modal-lg\"}).result.then((result) => {\r\n      if (result === \"Save\") {\r\n        this.attributeService.updateAttributeValueSet();\r\n      } else if (result === \"Cancel\") {\r\n        this.attributeService.clearUpdatedAttributeValues();\r\n      }\r\n    }, (reason) => {});\r\n  }\r\n\r\n  post(): void {\r\n    this.attributeService.updateAttributeValueSet();\r\n  }\r\n\r\n  getAttributeContainerById(idAttributeContainer: number): AttributeContainer {\r\n    if (this.attributeConfiguration) {\r\n      return this.attributeConfiguration.attributeContainers.find(x => x.idAttributeContainer === idAttributeContainer);\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/components/attribute-default.component.mjs

@@ -1,43 +1,43 @@
-import { Component, forwardRef, Input } from "@angular/core";
-import { NG_VALUE_ACCESSOR } from "@angular/forms";
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/common";
-import * as i2 from "@angular/forms";
-import * as i3 from "@huntsman-cancer-institute/input";
-export class AttributeDefaultComponent {
-    get value() {
-        return this._value;
-    }
-    ;
-    set value(v) {
-        this.onTouched();
-        if (v !== this.value) {
-            this._value = v;
-            this.onChange(v);
-        }
-    }
-    constructor() {
-        this._value = "";
-        this.onChange = (_) => { };
-        this.onTouched = () => { };
-    }
-    ngOnInit() { }
-    writeValue(v) {
-        this._value = v;
-    }
-    registerOnChange(fn) {
-        this.onChange = fn;
-    }
-    registerOnTouched(fn) {
-        this.onTouched = fn;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AttributeDefaultComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: AttributeDefaultComponent, selector: "hci-attribute-default", inputs: { id: "id", name: "name", attribute: "attribute" }, providers: [
-            {
-                provide: NG_VALUE_ACCESSOR,
-                useExisting: forwardRef(() => AttributeDefaultComponent),
-                multi: true
-            }
+import { Component, forwardRef, Input } from "@angular/core";
+import { NG_VALUE_ACCESSOR } from "@angular/forms";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+import * as i3 from "@huntsman-cancer-institute/input";
+export class AttributeDefaultComponent {
+    get value() {
+        return this._value;
+    }
+    ;
+    set value(v) {
+        this.onTouched();
+        if (v !== this.value) {
+            this._value = v;
+            this.onChange(v);
+        }
+    }
+    constructor() {
+        this._value = "";
+        this.onChange = (_) => { };
+        this.onTouched = () => { };
+    }
+    ngOnInit() { }
+    writeValue(v) {
+        this._value = v;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AttributeDefaultComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.2", type: AttributeDefaultComponent, selector: "hci-attribute-default", inputs: { id: "id", name: "name", attribute: "attribute" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => AttributeDefaultComponent),
+                multi: true
+            }
         ], ngImport: i0, template: `
     <!-- String -->
     <ng-container *ngIf="attribute.codeAttributeDataType.toUpperCase() === 'S'">
@@ -169,12 +169,12 @@ export class AttributeDefaultComponent {
              [name]="name"
              disabled>
     </ng-container>
-  `, isInline: true, 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: "directive", type: i2.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i2.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i2.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: i2.NumberValueAccessor, selector: "input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]" }, { kind: "directive", type: i2.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { kind: "directive", type: i2.SelectControlValueAccessor, selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", inputs: ["compareWith"] }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i3.NativeSelectComponent, selector: "hci-native-select", inputs: ["class", "name", "label", "url", "entries", "required", "idKey", "displayKey", "disabled", "sortKey", "sortNumeric", "filterKey", "filter"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AttributeDefaultComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: "hci-attribute-default",
+  `, isInline: true, 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: "directive", type: i2.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i2.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i2.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: i2.NumberValueAccessor, selector: "input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]" }, { kind: "directive", type: i2.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { kind: "directive", type: i2.SelectControlValueAccessor, selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", inputs: ["compareWith"] }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i3.NativeSelectComponent, selector: "hci-native-select", inputs: ["class", "name", "label", "url", "entries", "required", "idKey", "displayKey", "disabled", "sortKey", "sortNumeric", "filterKey", "filter"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AttributeDefaultComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "hci-attribute-default",
                     template: `
     <!-- String -->
     <ng-container *ngIf="attribute.codeAttributeDataType.toUpperCase() === 'S'">
@@ -306,20 +306,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
              [name]="name"
              disabled>
     </ng-container>
-  `,
-                    providers: [
-                        {
-                            provide: NG_VALUE_ACCESSOR,
-                            useExisting: forwardRef(() => AttributeDefaultComponent),
-                            multi: true
-                        }
-                    ]
-                }]
-        }], ctorParameters: function () { return []; }, propDecorators: { id: [{
-                type: Input
-            }], name: [{
-                type: Input
-            }], attribute: [{
-                type: Input
-            }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attribute-default.component.js","sourceRoot":"","sources":["../../../../projects/cod/src/components/attribute-default.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,UAAU,EAAE,KAAK,EAAC,MAAM,eAAe,CAAC;AAE3D,OAAO,EAAuB,iBAAiB,EAAC,MAAM,gBAAgB,CAAC;;;;;AAkJvE,MAAM,OAAO,yBAAyB;IAWpC,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAAA,CAAC;IAEF,IAAI,KAAK,CAAC,CAAS;QACjB,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,EAAE;YACpB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;YAChB,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;SAClB;IACH,CAAC;IAED;QArBA,WAAM,GAAW,EAAE,CAAC;QAMpB,aAAQ,GAAQ,CAAC,CAAM,EAAE,EAAE,GAAE,CAAC,CAAC;QAC/B,cAAS,GAAQ,GAAG,EAAE,GAAE,CAAC,CAAC;IAcX,CAAC;IAEhB,QAAQ,KAAU,CAAC;IAEnB,UAAU,CAAC,CAAS;QAClB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;IAClB,CAAC;IAED,gBAAgB,CAAC,EAAO;QACtB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACrB,CAAC;IAED,iBAAiB,CAAC,EAAO;QACvB,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACtB,CAAC;+GArCU,yBAAyB;mGAAzB,yBAAyB,4GARzB;YACT;gBACE,OAAO,EAAE,iBAAiB;gBAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,yBAAyB,CAAC;gBACxD,KAAK,EAAE,IAAI;aACZ;SACF,0BA1IS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmIT;;4FASU,yBAAyB;kBA9IrC,SAAS;mBAAC;oBACT,QAAQ,EAAE,uBAAuB;oBACjC,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmIT;oBACD,SAAS,EAAE;wBACT;4BACE,OAAO,EAAE,iBAAiB;4BAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,0BAA0B,CAAC;4BACxD,KAAK,EAAE,IAAI;yBACZ;qBACF;iBACF;0EAKU,EAAE;sBAAV,KAAK;gBACG,IAAI;sBAAZ,KAAK;gBACG,SAAS;sBAAjB,KAAK","sourcesContent":["import {Component, forwardRef, Input} from \"@angular/core\";\r\n\r\nimport {ControlValueAccessor, NG_VALUE_ACCESSOR} from \"@angular/forms\";\r\n\r\nimport {GraphicalAttribute} from \"../model/graphical-attribute.entity\";\r\n\r\n@Component({\r\n  selector: \"hci-attribute-default\",\r\n  template: `\r\n    <!-- String -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'S'\">\r\n      <input type=\"text\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             [(ngModel)]=\"value\">\r\n    </ng-container>\r\n\r\n    <!-- Text -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'TXT'\">\r\n      <textarea type=\"text\"\r\n                class=\"form-control\"\r\n                [id]=\"id\"\r\n                [name]=\"name\"\r\n                spellcheck=\"spellcheck\"\r\n                lang=\"en\"\r\n                [(ngModel)]=\"value\">\r\n      </textarea>\r\n    </ng-container>\r\n\r\n    <!-- Checkbox -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'CB'\">\r\n      <input type=\"checkbox\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             [(ngModel)]=\"value\"\r\n             [checked]=\"value && value.toUpperCase() === 'Y'\">\r\n    </ng-container>\r\n\r\n    <!-- Numeric -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'N'\">\r\n      <input type=\"number\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             [(ngModel)]=\"value\">\r\n    </ng-container>\r\n\r\n    <!-- Integer -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'I'\">\r\n      <input type=\"number\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             [(ngModel)]=\"value\">\r\n    </ng-container>\r\n\r\n    <!-- Date -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'D'\">\r\n      <input type=\"date\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             [(ngModel)]=\"value\">\r\n    </ng-container>\r\n\r\n    <!-- Date Time -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'DT'\">\r\n      <input type=\"date\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             [(ngModel)]=\"value\">\r\n    </ng-container>\r\n\r\n    <!-- Boolean -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'B'\">\r\n      <select [(ngModel)]=\"value\"\r\n             class=\"form-control edit-renderer\"\r\n             [id]=\"id\"\r\n             [name]=\"name\">\r\n        <option [ngValue]=\"'Y'\" [selected]=\"value && value.toUpperCase() === 'Y'\">Y</option>\r\n        <option [ngValue]=\"'N'\" [selected]=\"value && value.toUpperCase() === 'N'\">N</option>\r\n      </select>\r\n    </ng-container>\r\n\r\n    <!-- Extended Boolean -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'EB'\">\r\n      <select [(ngModel)]=\"value\"\r\n              class=\"form-control edit-renderer\"\r\n              [id]=\"id\"\r\n              [name]=\"name\">\r\n        <option [ngValue]=\"'Y'\" [selected]=\"value && value.toUpperCase() === 'Y'\">Y</option>\r\n        <option [ngValue]=\"'N'\" [selected]=\"value && value.toUpperCase() === 'N'\">N</option>\r\n        <option [ngValue]=\"'U'\" [selected]=\"value && value.toUpperCase() === 'U'\">U</option>\r\n      </select>\r\n    </ng-container>\r\n\r\n    <!-- Choice: Single -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'AC' && attribute.isMultiValue.toUpperCase() === 'N'\">\r\n      <select [(ngModel)]=\"value\"\r\n              class=\"form-control edit-renderer\"\r\n              [id]=\"id\"\r\n              [name]=\"name\">\r\n        <option *ngFor=\"let attributeChoice of attribute.attributeChoices\"\r\n                [ngValue]=\"attributeChoice\"\r\n                [selected]=\"value && value.toUpperCase() === attributeChoice.idAttributeChoice.toString().toUpperCase()\">\r\n          {{ attributeChoice.choice }}\r\n        </option>\r\n      </select>\r\n    </ng-container>\r\n\r\n    <!-- Choice: Multi -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'AC' && attribute.isMultiValue.toUpperCase() === 'Y'\">\r\n      <input type=\"text\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             disabled>\r\n    </ng-container>\r\n\r\n    <!-- Dictionary -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'DICT'\">\r\n      <hci-native-select [(ngModel)]=\"value\"\r\n                         [className]=\"attribute.attributeDictionary.className\"\r\n                         [id]=\"id\"\r\n                         [name]=\"name\">\r\n      </hci-native-select>\r\n    </ng-container>\r\n\r\n    <!-- Grid -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'GA'\">\r\n      <input type=\"text\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             disabled>\r\n    </ng-container>\r\n  `,\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => AttributeDefaultComponent),\r\n      multi: true\r\n    }\r\n  ]\r\n})\r\nexport class AttributeDefaultComponent implements ControlValueAccessor {\r\n\r\n  _value: string = \"\";\r\n\r\n  @Input() id: string;\r\n  @Input() name: string;\r\n  @Input() attribute: GraphicalAttribute;\r\n\r\n  onChange: any = (_: any) => {};\r\n  onTouched: any = () => {};\r\n\r\n  get value(): string {\r\n    return this._value;\r\n  };\r\n\r\n  set value(v: string) {\r\n    this.onTouched();\r\n    if (v !== this.value) {\r\n      this._value = v;\r\n      this.onChange(v);\r\n    }\r\n  }\r\n\r\n  constructor() {}\r\n\r\n  ngOnInit(): void {}\r\n\r\n  writeValue(v: string) {\r\n    this._value = v;\r\n  }\r\n\r\n  registerOnChange(fn: any) {\r\n    this.onChange = fn;\r\n  }\r\n\r\n  registerOnTouched(fn: any) {\r\n    this.onTouched = fn;\r\n  }\r\n}\r\n"]}
+  `,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => AttributeDefaultComponent),
+                            multi: true
+                        }
+                    ]
+                }]
+        }], ctorParameters: () => [], propDecorators: { id: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], attribute: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attribute-default.component.js","sourceRoot":"","sources":["../../../../projects/cod/src/components/attribute-default.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,UAAU,EAAE,KAAK,EAAC,MAAM,eAAe,CAAC;AAE3D,OAAO,EAAuB,iBAAiB,EAAC,MAAM,gBAAgB,CAAC;;;;;AAkJvE,MAAM,OAAO,yBAAyB;IAWpC,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAAA,CAAC;IAEF,IAAI,KAAK,CAAC,CAAS;QACjB,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;YACrB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;YAChB,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QACnB,CAAC;IACH,CAAC;IAED;QArBA,WAAM,GAAW,EAAE,CAAC;QAMpB,aAAQ,GAAQ,CAAC,CAAM,EAAE,EAAE,GAAE,CAAC,CAAC;QAC/B,cAAS,GAAQ,GAAG,EAAE,GAAE,CAAC,CAAC;IAcX,CAAC;IAEhB,QAAQ,KAAU,CAAC;IAEnB,UAAU,CAAC,CAAS;QAClB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;IAClB,CAAC;IAED,gBAAgB,CAAC,EAAO;QACtB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACrB,CAAC;IAED,iBAAiB,CAAC,EAAO;QACvB,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACtB,CAAC;8GArCU,yBAAyB;kGAAzB,yBAAyB,4GARzB;YACT;gBACE,OAAO,EAAE,iBAAiB;gBAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,yBAAyB,CAAC;gBACxD,KAAK,EAAE,IAAI;aACZ;SACF,0BA1IS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmIT;;2FASU,yBAAyB;kBA9IrC,SAAS;mBAAC;oBACT,QAAQ,EAAE,uBAAuB;oBACjC,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmIT;oBACD,SAAS,EAAE;wBACT;4BACE,OAAO,EAAE,iBAAiB;4BAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,0BAA0B,CAAC;4BACxD,KAAK,EAAE,IAAI;yBACZ;qBACF;iBACF;wDAKU,EAAE;sBAAV,KAAK;gBACG,IAAI;sBAAZ,KAAK;gBACG,SAAS;sBAAjB,KAAK","sourcesContent":["import {Component, forwardRef, Input} from \"@angular/core\";\r\n\r\nimport {ControlValueAccessor, NG_VALUE_ACCESSOR} from \"@angular/forms\";\r\n\r\nimport {GraphicalAttribute} from \"../model/graphical-attribute.entity\";\r\n\r\n@Component({\r\n  selector: \"hci-attribute-default\",\r\n  template: `\r\n    <!-- String -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'S'\">\r\n      <input type=\"text\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             [(ngModel)]=\"value\">\r\n    </ng-container>\r\n\r\n    <!-- Text -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'TXT'\">\r\n      <textarea type=\"text\"\r\n                class=\"form-control\"\r\n                [id]=\"id\"\r\n                [name]=\"name\"\r\n                spellcheck=\"spellcheck\"\r\n                lang=\"en\"\r\n                [(ngModel)]=\"value\">\r\n      </textarea>\r\n    </ng-container>\r\n\r\n    <!-- Checkbox -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'CB'\">\r\n      <input type=\"checkbox\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             [(ngModel)]=\"value\"\r\n             [checked]=\"value && value.toUpperCase() === 'Y'\">\r\n    </ng-container>\r\n\r\n    <!-- Numeric -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'N'\">\r\n      <input type=\"number\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             [(ngModel)]=\"value\">\r\n    </ng-container>\r\n\r\n    <!-- Integer -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'I'\">\r\n      <input type=\"number\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             [(ngModel)]=\"value\">\r\n    </ng-container>\r\n\r\n    <!-- Date -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'D'\">\r\n      <input type=\"date\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             [(ngModel)]=\"value\">\r\n    </ng-container>\r\n\r\n    <!-- Date Time -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'DT'\">\r\n      <input type=\"date\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             [(ngModel)]=\"value\">\r\n    </ng-container>\r\n\r\n    <!-- Boolean -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'B'\">\r\n      <select [(ngModel)]=\"value\"\r\n             class=\"form-control edit-renderer\"\r\n             [id]=\"id\"\r\n             [name]=\"name\">\r\n        <option [ngValue]=\"'Y'\" [selected]=\"value && value.toUpperCase() === 'Y'\">Y</option>\r\n        <option [ngValue]=\"'N'\" [selected]=\"value && value.toUpperCase() === 'N'\">N</option>\r\n      </select>\r\n    </ng-container>\r\n\r\n    <!-- Extended Boolean -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'EB'\">\r\n      <select [(ngModel)]=\"value\"\r\n              class=\"form-control edit-renderer\"\r\n              [id]=\"id\"\r\n              [name]=\"name\">\r\n        <option [ngValue]=\"'Y'\" [selected]=\"value && value.toUpperCase() === 'Y'\">Y</option>\r\n        <option [ngValue]=\"'N'\" [selected]=\"value && value.toUpperCase() === 'N'\">N</option>\r\n        <option [ngValue]=\"'U'\" [selected]=\"value && value.toUpperCase() === 'U'\">U</option>\r\n      </select>\r\n    </ng-container>\r\n\r\n    <!-- Choice: Single -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'AC' && attribute.isMultiValue.toUpperCase() === 'N'\">\r\n      <select [(ngModel)]=\"value\"\r\n              class=\"form-control edit-renderer\"\r\n              [id]=\"id\"\r\n              [name]=\"name\">\r\n        <option *ngFor=\"let attributeChoice of attribute.attributeChoices\"\r\n                [ngValue]=\"attributeChoice\"\r\n                [selected]=\"value && value.toUpperCase() === attributeChoice.idAttributeChoice.toString().toUpperCase()\">\r\n          {{ attributeChoice.choice }}\r\n        </option>\r\n      </select>\r\n    </ng-container>\r\n\r\n    <!-- Choice: Multi -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'AC' && attribute.isMultiValue.toUpperCase() === 'Y'\">\r\n      <input type=\"text\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             disabled>\r\n    </ng-container>\r\n\r\n    <!-- Dictionary -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'DICT'\">\r\n      <hci-native-select [(ngModel)]=\"value\"\r\n                         [className]=\"attribute.attributeDictionary.className\"\r\n                         [id]=\"id\"\r\n                         [name]=\"name\">\r\n      </hci-native-select>\r\n    </ng-container>\r\n\r\n    <!-- Grid -->\r\n    <ng-container *ngIf=\"attribute.codeAttributeDataType.toUpperCase() === 'GA'\">\r\n      <input type=\"text\"\r\n             class=\"form-control\"\r\n             [id]=\"id\"\r\n             [name]=\"name\"\r\n             disabled>\r\n    </ng-container>\r\n  `,\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => AttributeDefaultComponent),\r\n      multi: true\r\n    }\r\n  ]\r\n})\r\nexport class AttributeDefaultComponent implements ControlValueAccessor {\r\n\r\n  _value: string = \"\";\r\n\r\n  @Input() id: string;\r\n  @Input() name: string;\r\n  @Input() attribute: GraphicalAttribute;\r\n\r\n  onChange: any = (_: any) => {};\r\n  onTouched: any = () => {};\r\n\r\n  get value(): string {\r\n    return this._value;\r\n  };\r\n\r\n  set value(v: string) {\r\n    this.onTouched();\r\n    if (v !== this.value) {\r\n      this._value = v;\r\n      this.onChange(v);\r\n    }\r\n  }\r\n\r\n  constructor() {}\r\n\r\n  ngOnInit(): void {}\r\n\r\n  writeValue(v: string) {\r\n    this._value = v;\r\n  }\r\n\r\n  registerOnChange(fn: any) {\r\n    this.onChange = fn;\r\n  }\r\n\r\n  registerOnTouched(fn: any) {\r\n    this.onTouched = fn;\r\n  }\r\n}\r\n"]}