org.eclipse.mdm.nucleus/org.eclipse.mdm.application/src/main/webapp/src/app/administration/extsystem-editor.component.ts - mdmbl/org.eclipse.mdm - Git at Google

 /********************************************************************************
  * Copyright (c) 2015-2018 Contributors to the Eclipse Foundation
  *
  * See the NOTICE file(s) distributed with this work for additional
  * information regarding copyright ownership.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0.
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  ********************************************************************************/


 import { Component, OnInit, ViewChild, Input, OnDestroy, Output, EventEmitter } from '@angular/core';
 import { FormGroup, FormControl, FormBuilder, FormArray, Validators } from '@angular/forms';
 import { ActivatedRoute } from '@angular/router';
 import { TranslateService } from '@ngx-translate/core';
 import { DropdownModule } from 'primeng/dropdown';
 import { TreeTableModule } from 'primeng/treetable';
 import { TreeNode, MenuItem, SelectItem } from 'primeng/api';
 import { ContextMenuModule } from 'primeng/contextmenu';
 import { TreeTable, TreeTableToggler, DataTable } from 'primeng/primeng';
 import { Observable, BehaviorSubject, of, forkJoin } from 'rxjs';
 import 'rxjs/add/operator/toPromise';

 import { MDMNotificationService } from '../core/mdm-notification.service';
 import { ExtSystemService } from './extsystem.service';
 import { Node, Attribute, Relation } from '../navigator/node';
 import { plainToClass } from 'class-transformer';
 import { CatalogService } from './catalog.service';
 import { mergeMap, flatMap, map } from 'rxjs/operators';

 @Component( {
     selector: 'mdm-extsystem-editor',
   templateUrl: './extsystem-editor.component.html',
   styleUrls: ['./extsystem.component.css']
 })
 export class ExtSystemEditorComponent implements OnInit, OnDestroy {

   // passed down from parent
   @Input() extSystems: Node[];
   @Input() selectedEnvironment: Node;
   @Input() selectedES: string;

   @Output() editMode = new EventEmitter<boolean>();

   // table selection
   selectedExtSystem: Node;
   selectedExtSystemAttr: Node;
   tableExtSystems: Node[] = new Array();

   // dropdown for table edit
   mdmCompTypes: SelectItem[];
   mdmCompNames: Node[];
   mdmAttrNames: Node[];

   // external system attributes
   extSystemAttrs: Node[];
   bsExtSystemAttrs: BehaviorSubject<Node[]> = new BehaviorSubject<Node[]>(undefined);

   // loading states
   loadingExtSystemAttr = false;

   // for immediate creation only
   tmpExtSystemAttr: Node;
   tmpExtSystemMDMAttr: Node;

   // dropdown boxes
   availableSlctCtlgComps: any[][] = [];
   availableSlctAttrComps: any[][] = [];

   loadedTemplateRoots: any[][] = [];
   loadedCatalogComps: any[][] = [];
   loadedAttributeComps: any[][] = [];

   constructor(private extSystemService: ExtSystemService,
               private notificationService: MDMNotificationService,
               private translateService: TranslateService,
               private catalogService: CatalogService) {

     this.bsExtSystemAttrs.subscribe(value => {
       this.extSystemAttrs = value;
     });

     this.mdmCompTypes = [
       { label: this.translateService.instant('administration.extsystem.dropdown-please-select'), value: '' },
       { label: this.translateService.instant('administration.extsystem.unit-under-test'), value: 'UnitUnderTest' },
       { label: this.translateService.instant('administration.extsystem.test-equipment'), value: 'TestEquipment' },
       { label: this.translateService.instant('administration.extsystem.test-sequence'), value: 'TestSequence' },
       { label: this.translateService.instant('administration.extsystem.sensor'), value: 'Sensor' }
     ];
   }

   ngOnInit() {
     for (let extSystem of this.extSystems) {
       if (extSystem.type === 'ExtSystem' && extSystem.id === this.selectedES) {
         this.selectedExtSystem = extSystem;
         this.tableExtSystems.push(this.selectedExtSystem);
         break;
       }
     }

     this.loadingExtSystemAttr = true;
     this.extSystemService.getExtSystemAttributesForScope(this.selectedEnvironment.sourceName, this.selectedExtSystem.id)
       .subscribe(attrs => {
         this.bsExtSystemAttrs.next(attrs);
         this.loadingExtSystemAttr = false;
       });
   }

   ngOnDestroy() {
   }

   getExternalSystemAttributes() {
     if (!this.extSystemAttrs) {
       return new Array();
     }
     return this.extSystemAttrs.filter(attr => attr.type === 'ExtSystemAttribute');
   }
   getMDMAttributes() {
     let ids = new Array();
       if (this.selectedExtSystemAttr.relations) {
       for (let relation of this.selectedExtSystemAttr.relations) {
         if (relation.entityType === 'MDMAttribute') {
           for (let relationid of relation.ids) {
             ids.push(relationid);
           }
         }
       }
     }
     let data = new Array();
     for (let attr of this.extSystemAttrs) {
       if (attr.type === 'MDMAttribute' && ids.find(el => el === attr.id)) {
         data.push(attr);
       }
     }
     return data;
   }

   getAttributeValueFromNode(node: Node, attribute: string) {
     if (node && node.attributes !== undefined) {
       for (let attr of node.attributes) {
         if (attr.name === attribute) {
           return attr.value;
         }
       }
     }
     return '';
   }

   getAttributeFromNode(node: Node, attribute: string) {
     if (node && node.attributes !== undefined) {
       for (let attr of node.attributes) {
         if (attr.name === attribute) {
           return attr;
         }
       }
     }
     return undefined;
   }

   getNextTemporaryId() {
     let id = -1;
     for (let extSystem of this.extSystems) {
       if (parseInt(extSystem.id, 10) < id) {
         id = parseInt(extSystem.id, 10);
       }
     }
     return --id;
   }

   createAttribute(name: string, value?: string) {
     let attr = new Attribute();
     attr.dataType = 'STRING';
     attr.unit = '';
     attr.value = value !== undefined ? value : '';
     attr.name = name;
     return attr;
   }

   getIndicesForIds(ids: string[]) {
     let indices = new Array();
     for (let id of ids) {
       for (let extSystem of this.extSystems) {
         if (extSystem.id === ids[id]) {
           indices.push(this.extSystems.indexOf(extSystem));
         }
       }
     }
     return indices;
   }

   /**
    * Save the external system
    */
   saveExtSystem() {
     this.getAttributeFromNode(this.selectedExtSystem, 'Name').value = this.selectedExtSystem.name;
     this.extSystemService.saveExtSystem(this.selectedEnvironment.sourceName, this.selectedExtSystem)
       .subscribe(
         response => { /* discard */ },
         error => this.notificationService.notifyError(
           this.translateService.instant('administration.extsystem.err-cannot-update-ext-system'), error)
       );
   }

   addExtSystemAttr() {
     // initialze the node
     this.tmpExtSystemAttr = new Node();
     this.tmpExtSystemAttr.type = 'ExtSystemAttribute';
     this.tmpExtSystemAttr.sourceType = 'ExtSystemAttr';
     this.tmpExtSystemAttr.sourceName = this.selectedEnvironment.sourceName;
     this.tmpExtSystemAttr.attributes = new Array();
     this.tmpExtSystemAttr.attributes.push(this.createAttribute('Description'));
     this.tmpExtSystemAttr.attributes.push(this.createAttribute('Name'));
     this.tmpExtSystemAttr.attributes.push(this.createAttribute('ConverterClassname'));
     this.tmpExtSystemAttr.attributes.push(this.createAttribute('ConverterParameter'));
     this.tmpExtSystemAttr.attributes.push(this.createAttribute('MimeType', 'application/x-asam.aoany.extsystemattr'));

     // Initialize relations on the external system if it is not defined yet
     if (this.selectedExtSystem.relations === undefined || this.selectedExtSystem.relations.length === 0) {
       this.selectedExtSystem.relations = new Array();
       let relation = new Relation();
       relation.entityType = 'ExtSystemAttribute';
       relation.type = 'CHILDREN';
       relation.ids = new Array();
       this.selectedExtSystem.relations.push(relation);
     }
     if (this.selectedExtSystem.relations[0].ids === undefined) {
       this.selectedExtSystem.relations[0].ids = new Array();
     }

     // Set initial name to persist the attribute
     this.tmpExtSystemAttr.name = 'Attribut';
     this.getAttributeFromNode(this.tmpExtSystemAttr, 'Name').value = this.tmpExtSystemAttr.name;
     this.saveExtSystemAttr(this.tmpExtSystemAttr);
   }

   /**
    * Remove the external system attribute
    */
   removeExtSystemAttr(extSystemAttr?: Node) {
     if (extSystemAttr != undefined) {

       if (extSystemAttr.id !== undefined && parseInt(extSystemAttr.id, 10) > 0 && this.extSystemAttrs.indexOf(extSystemAttr) !== -1) {
         this.extSystemService.deleteExtSystemAttr(this.selectedEnvironment.sourceName, extSystemAttr.id).subscribe();
         let idxES: number = this.extSystemAttrs.indexOf(extSystemAttr);
         if (idxES !== -1) {
           this.extSystemAttrs.splice(idxES, 1);
           if (extSystemAttr.relations !== undefined && extSystemAttr.relations.length > 0) {
             // remove all children
             let indices = new Array<number>();
             for (let h of extSystemAttr.relations) {
               // the mdm attributes
               indices = indices.concat(this.getIndicesForIds(h.ids));
             }
             indices.sort((a, b) => b - a);
             for (let i of indices) {
               this.extSystemAttrs.splice(indices[i], 1);
             }
           }
         }
       }
     }
     this.selectedExtSystemAttr = undefined;
   }

   /**
    * Change listener on the name and description of the table element
    */
   updateSystemAttrModel(rowData: Node) {
     // update the name attribute
     this.getAttributeFromNode(rowData, 'Name').value = rowData.name;
     // persist the change
     this.saveExtSystemAttr(rowData);
   }

   /**
    * Method invoked only if the save of the external system attribute succeeded
    * This method is additional only successful if the node is a new node
    */
   saveExtSystemAttrSuccess(nodes: Node[]) {
     if (this.tmpExtSystemAttr) {
       for (let node of nodes) {
         if (node.name === this.tmpExtSystemAttr.name && this.tmpExtSystemAttr.id === undefined) {
           this.tmpExtSystemAttr.id = node.id;
         }
       }
       this.extSystemAttrs.push(this.tmpExtSystemAttr);
       this.tmpExtSystemAttr = undefined;
     }
   }

   /**
    * Save the external system attribute
    */
   saveExtSystemAttr(tmpAttr: Node) {
     this.extSystemService.saveExtSystemAttr(this.selectedEnvironment.sourceName, tmpAttr, this.selectedExtSystem)
       .subscribe(
         response => this.saveExtSystemAttrSuccess(plainToClass(Node, response.json().data)),
         error => {
           this.tmpExtSystemAttr = undefined;
           this.notificationService.notifyError(
             this.translateService.instant('administration.extsystem.err-cannot-save-ext-system-attr'), error);
         }
       );
   }

   onExtSystemAttrSelect(event) {
     let mdmAttrs = this.getMDMAttributes();
     for (let attr of mdmAttrs) {
       this.getCatalogComponentStr(attr);
       this.getAttributeComponentStr(attr);
     }
   }

   addExtSystemMDMAttr() {
     this.tmpExtSystemMDMAttr = new Node();
     this.tmpExtSystemMDMAttr.type = 'MDMAttribute';
     this.tmpExtSystemMDMAttr.sourceType = 'MDMAttr';
     this.tmpExtSystemMDMAttr.sourceName = this.selectedEnvironment.sourceName;
     this.tmpExtSystemMDMAttr.attributes = new Array();
     this.tmpExtSystemMDMAttr.attributes.push(this.createAttribute('AttrName'));
     this.tmpExtSystemMDMAttr.attributes.push(this.createAttribute('CompName'));
     this.tmpExtSystemMDMAttr.attributes.push(this.createAttribute('CompType'));
     this.tmpExtSystemMDMAttr.attributes.push(this.createAttribute('MimeType', 'application/x-asam.aoany.mdmattr'));
     // the name is the hierarchy from the parent elements appended with the name, set in save method
     this.tmpExtSystemMDMAttr.attributes.push(this.createAttribute('Name'));

     // add relation
     if (this.selectedExtSystemAttr.relations === undefined || this.selectedExtSystemAttr.relations.length === 0) {
       this.selectedExtSystemAttr.relations = new Array();
       let relation = new Relation();
       relation.entityType = 'MDMAttribute';
       relation.type = 'CHILDREN';
       relation.ids = new Array();
       this.selectedExtSystemAttr.relations.push(relation);
     }
     if (this.selectedExtSystemAttr.relations[0].ids === undefined) {
       this.selectedExtSystemAttr.relations[0].ids = new Array();
     }

     // Set initial name to persist the attribute
     this.getAttributeFromNode(this.tmpExtSystemMDMAttr, 'CompType').value = 'UnitUnderTest';
     this.getAttributeFromNode(this.tmpExtSystemMDMAttr, 'CompName').value = 'Komponente';
     this.getAttributeFromNode(this.tmpExtSystemMDMAttr, 'AttrName').value = 'Attribut';

     this.saveExtSystemMDMAttr(this.tmpExtSystemMDMAttr);
   }

   removeExtSystemMDMAttr(extSystemMDMAttr?: Node) {
     if (extSystemMDMAttr != undefined) {
       if (this.extSystemAttrs.indexOf(extSystemMDMAttr) !== -1) {
         if (extSystemMDMAttr.id !== undefined && parseInt(extSystemMDMAttr.id, 10) > 0) {
           this.extSystemService.deleteExtSystemMDMAttr(this.selectedEnvironment.sourceName, extSystemMDMAttr.id).subscribe();
         }
         this.extSystemAttrs.splice(this.extSystemAttrs.indexOf(extSystemMDMAttr), 1);
       }
     }
   }

   saveExtSystemMDMAttrSuccess(nodes: Node[]) {
     if (this.tmpExtSystemMDMAttr) {
       for (let node of nodes) {
         if (node.name === this.tmpExtSystemMDMAttr.name && this.tmpExtSystemMDMAttr.id === undefined) {
           this.tmpExtSystemMDMAttr.id = node.id;
           for (let relation of this.selectedExtSystemAttr.relations) {
             if (relation.entityType === 'MDMAttribute') {
               if (relation.ids === undefined) {
                 relation.ids = new Array();
               }
               relation.ids.push(node.id);
             }
           }
         }
       }
       this.extSystemAttrs.push(this.tmpExtSystemMDMAttr);
       this.tmpExtSystemMDMAttr = undefined;
     }
   }

   saveExtSystemMDMAttr(tmpAttr: Node) {
       // update the name attribute with the hierarchy
       tmpAttr.name = this.getAttributeValueFromNode(tmpAttr, 'CompType')
         + '.' + this.getAttributeValueFromNode(tmpAttr, 'CompName')
         + '.' + this.getAttributeValueFromNode(tmpAttr, 'AttrName');
       this.getAttributeFromNode(tmpAttr, 'Name').value = tmpAttr.name;

     this.extSystemService.saveExtSystemMDMAttr(this.selectedEnvironment.sourceName, tmpAttr, this.selectedExtSystemAttr)
       .subscribe(
         response => this.saveExtSystemMDMAttrSuccess(plainToClass(Node, response.json().data)),
         error => {
           this.tmpExtSystemMDMAttr = undefined;
           this.notificationService.notifyError(
             this.translateService.instant('administration.extsystem.err-cannot-save-ext-mdm-attr'), error);
         }
       );
   }

   async loadCatalogComps(type: string) {
     if (type !== undefined && type != null && type.length > 0) {

       // load the template roots if not available
       if (this.loadedTemplateRoots[type] === undefined) {
         this.loadedTemplateRoots[type] = [];
         try {
           const response = await this.catalogService.getTplRootsForType(this.selectedEnvironment.sourceName, type).toPromise();
           this.loadedTemplateRoots[type] = response;
         } catch (error) {
           this.notificationService.notifyError(
             this.translateService.instant('administration.extsystem.err-cannot-load-comp-types'), error);
         }
       }

       // load the catalog components if not already triggered
       if (this.loadedTemplateRoots[type] !== undefined && this.loadedTemplateRoots[type].length > 0
         && this.loadedCatalogComps[type] === undefined) {
         this.loadedCatalogComps[type] = [];
         let tmpIds = this.loadedTemplateRoots[type].map(tr => tr.id);

         of(tmpIds).pipe(
           flatMap(q => forkJoin(...q.map(id => this.catalogService.getTplCompForRoot(this.selectedEnvironment.sourceName, type, id)))),
           map(nested => [].concat(...nested))
         ).subscribe(
             templateComponentWithDuplicateVersions => {
               const groupedByName = templateComponentWithDuplicateVersions.reduce((group: any[], templateComponent: any) => {
                 group[templateComponent.name] = group[templateComponent.name] || [];
                 group[templateComponent.name].push(templateComponent);
                 return group;
               }, {});
               let templateComponents = [];
               for (const name of Object.keys(groupedByName)) {
                 templateComponents.push(groupedByName[name].reduce((g: any, templateComponent: any) =>
                   g.id <= templateComponent.id ? templateComponent : g,
                   { id: -1 }
                 ));
               }
               this.loadedCatalogComps[type] = templateComponents;
             },
             error => this.notificationService.notifyError(
               this.translateService.instant('administration.extsystem.err-cannot-load-comp-types'), error)
             );

         return true;
       }
     }
     return false;
   }

   async loadAttributeComps(type: string, comp: string) {
     if (type !== undefined && type != null && type.length > 0 && comp !== undefined && comp != null && comp.length > 0
       && this.loadedAttributeComps[type + comp] === undefined) {
       let compId = '';
       let rootId = '0';
       if (this.loadedCatalogComps && this.loadedCatalogComps[type]) {
         for (let catalogComp of this.loadedCatalogComps[type]) {
           if (catalogComp.name === comp) {
             compId = catalogComp.id;
             break;
           }
         }
       }
       if (this.loadedTemplateRoots && this.loadedTemplateRoots[type]) {
         for (let templateRoot of this.loadedTemplateRoots[type]) {
           if (templateRoot.relations !== undefined) {
             for (let relation of templateRoot.relations) {
               if (relation.entityType === 'TemplateComponent'
                 && relation.ids !== undefined) {
                 for (let id of relation.ids) {
                   if (id === compId) {
                     rootId = templateRoot.id;
                     break;
                   }
                 }
                 if (rootId !== '0') {
                   break;
                 }
               }
             }
             if (rootId !== '0') {
               break;
             }
           }
         }
       }
       if (rootId !== '0' && compId !== '') {
         this.loadedAttributeComps[type + comp] = [];
         try {
           const response = await this.catalogService.
             getTplAttrsForComp(this.selectedEnvironment.sourceName, type, rootId, compId).toPromise();
           for (let t of response) {
             this.loadedAttributeComps[type + comp].push(t);
           }
         } catch (error) {
           this.notificationService.notifyError(
             this.translateService.instant('administration.extsystem.err-cannot-load-comp-types'), error);
         }
         return true;
       }
     } else {
       return false;
     }
   }

   getCatalogComponentStr(rowData: Node) {
     let type: string = <string> this.getAttributeValueFromNode(rowData, 'CompType');
     let data: string[] = new Array();
     // sensor does not have catalog elements
     if (type !== undefined && type !== 'Sensor') {
       let components = this.getCatalogComponents(type);
       if (components) {
         for (let component of components) {
           data.push(component.name);
         }
       }
     }
     return data;
   }

   getAttributeComponentStr(rowData: Node) {
     let type: string = <string> this.getAttributeValueFromNode(rowData, 'CompType');
     let comp: string = <string> this.getAttributeValueFromNode(rowData, 'CompName');
     let data: string[] = new Array();
     if (type !== undefined && comp !== undefined) {
       let components = this.getAttributeComponents(type, comp);
       if (components) {
         for (let component of components) {
           data.push(component.name);
         }
       }
     }
     return data;
   }

   getCatalogComponents(type: string) {
     let data: Node[] = this.loadedCatalogComps[type];
     if (data === undefined || data == null || data.length === 0) {
       if (this.loadCatalogComps(type)) {
         data = this.loadedCatalogComps[type];
       }
     }
     return data;
   }

   getAttributeComponents(type: string, comp: string) {
     let data: Node[] = this.loadedAttributeComps[type + comp];
     if (data === undefined || data == null || data.length === 0) {
       if (this.loadAttributeComps(type, comp)) {
         data = this.loadedAttributeComps[type + comp];
       }
     }
     return data;
   }

   /**
    *
    */
   availableCatalogComps(rowData: Node) {
     let result = this.availableSlctCtlgComps[rowData.id];
     if (result === undefined) {
       result = [];
       result.push({ label: this.translateService.instant('administration.extsystem.dropdown-please-select'), value: '' });
       let items = this.getCatalogComponentStr(rowData);
       for (let item of items) {
         if (item !== undefined) {
           result.push({ label: item, value: item});
         }
       }
       if (result.length > 1) {
         this.availableSlctCtlgComps[rowData.id] = result;
       }
     }
     return result;
   }

   availableAttributeComps(rowData: Node) {
     let result = this.availableSlctAttrComps[rowData.id];
     if (result === undefined) {
       result = [];
       result.push({ label: this.translateService.instant('administration.extsystem.dropdown-please-select'), value: '' });
       let items = this.getAttributeComponentStr(rowData);
       for (let item of items) {
         if (item !== undefined) {
           result.push({ label: item, value: item});
         }
       }
       if (result.length > 1) {
         this.availableSlctAttrComps[rowData.id] = result;
       }
     }
     return result;
   }

   handleCompTypeSelect(event, rowData: Node) {
     this.availableSlctCtlgComps[rowData.id] = undefined;
     this.availableSlctAttrComps[rowData.id] = undefined;
     this.getAttributeFromNode(rowData, 'CompName').value = 'Komponente';
     this.getAttributeFromNode(rowData, 'AttrName').value = 'Attribut';
     this.getCatalogComponentStr(rowData);
     this.saveExtSystemMDMAttr(rowData);
   }

   handleCompSelect(event, rowData: Node) {
     this.availableSlctAttrComps[rowData.id] = undefined;
     this.getAttributeFromNode(rowData, 'AttrName').value = 'Attribut';
     this.getAttributeComponentStr(rowData);
     this.saveExtSystemMDMAttr(rowData);
   }

   handleAttrCompSelect(event, rowData: Node) {
     this.saveExtSystemMDMAttr(rowData);
   }

 }
	/********************************************************************************
	* Copyright (c) 2015-2018 Contributors to the Eclipse Foundation
	*
	* See the NOTICE file(s) distributed with this work for additional
	* information regarding copyright ownership.
	*
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v. 2.0 which is available at
	* http://www.eclipse.org/legal/epl-2.0.
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	********************************************************************************/


	import { Component, OnInit, ViewChild, Input, OnDestroy, Output, EventEmitter } from '@angular/core';
	import { FormGroup, FormControl, FormBuilder, FormArray, Validators } from '@angular/forms';
	import { ActivatedRoute } from '@angular/router';
	import { TranslateService } from '@ngx-translate/core';
	import { DropdownModule } from 'primeng/dropdown';
	import { TreeTableModule } from 'primeng/treetable';
	import { TreeNode, MenuItem, SelectItem } from 'primeng/api';
	import { ContextMenuModule } from 'primeng/contextmenu';
	import { TreeTable, TreeTableToggler, DataTable } from 'primeng/primeng';
	import { Observable, BehaviorSubject, of, forkJoin } from 'rxjs';
	import 'rxjs/add/operator/toPromise';

	import { MDMNotificationService } from '../core/mdm-notification.service';
	import { ExtSystemService } from './extsystem.service';
	import { Node, Attribute, Relation } from '../navigator/node';
	import { plainToClass } from 'class-transformer';
	import { CatalogService } from './catalog.service';
	import { mergeMap, flatMap, map } from 'rxjs/operators';

	@Component( {
	selector: 'mdm-extsystem-editor',
	templateUrl: './extsystem-editor.component.html',
	styleUrls: ['./extsystem.component.css']
	})
	export class ExtSystemEditorComponent implements OnInit, OnDestroy {

	// passed down from parent
	@Input() extSystems: Node[];
	@Input() selectedEnvironment: Node;
	@Input() selectedES: string;

	@Output() editMode = new EventEmitter<boolean>();

	// table selection
	selectedExtSystem: Node;
	selectedExtSystemAttr: Node;
	tableExtSystems: Node[] = new Array();

	// dropdown for table edit
	mdmCompTypes: SelectItem[];
	mdmCompNames: Node[];
	mdmAttrNames: Node[];

	// external system attributes
	extSystemAttrs: Node[];
	bsExtSystemAttrs: BehaviorSubject<Node[]> = new BehaviorSubject<Node[]>(undefined);

	// loading states
	loadingExtSystemAttr = false;

	// for immediate creation only
	tmpExtSystemAttr: Node;
	tmpExtSystemMDMAttr: Node;

	// dropdown boxes
	availableSlctCtlgComps: any[][] = [];
	availableSlctAttrComps: any[][] = [];

	loadedTemplateRoots: any[][] = [];
	loadedCatalogComps: any[][] = [];
	loadedAttributeComps: any[][] = [];

	constructor(private extSystemService: ExtSystemService,
	private notificationService: MDMNotificationService,
	private translateService: TranslateService,
	private catalogService: CatalogService) {

	this.bsExtSystemAttrs.subscribe(value => {
	this.extSystemAttrs = value;
	});

	this.mdmCompTypes = [
	{ label: this.translateService.instant('administration.extsystem.dropdown-please-select'), value: '' },
	{ label: this.translateService.instant('administration.extsystem.unit-under-test'), value: 'UnitUnderTest' },
	{ label: this.translateService.instant('administration.extsystem.test-equipment'), value: 'TestEquipment' },
	{ label: this.translateService.instant('administration.extsystem.test-sequence'), value: 'TestSequence' },
	{ label: this.translateService.instant('administration.extsystem.sensor'), value: 'Sensor' }
	];
	}

	ngOnInit() {
	for (let extSystem of this.extSystems) {
	if (extSystem.type === 'ExtSystem' && extSystem.id === this.selectedES) {
	this.selectedExtSystem = extSystem;
	this.tableExtSystems.push(this.selectedExtSystem);
	break;
	}
	}

	this.loadingExtSystemAttr = true;
	this.extSystemService.getExtSystemAttributesForScope(this.selectedEnvironment.sourceName, this.selectedExtSystem.id)
	.subscribe(attrs => {
	this.bsExtSystemAttrs.next(attrs);
	this.loadingExtSystemAttr = false;
	});
	}

	ngOnDestroy() {
	}

	getExternalSystemAttributes() {
	if (!this.extSystemAttrs) {
	return new Array();
	}
	return this.extSystemAttrs.filter(attr => attr.type === 'ExtSystemAttribute');
	}
	getMDMAttributes() {
	let ids = new Array();
	if (this.selectedExtSystemAttr.relations) {
	for (let relation of this.selectedExtSystemAttr.relations) {
	if (relation.entityType === 'MDMAttribute') {
	for (let relationid of relation.ids) {
	ids.push(relationid);
	}
	}
	}
	}
	let data = new Array();
	for (let attr of this.extSystemAttrs) {
	if (attr.type === 'MDMAttribute' && ids.find(el => el === attr.id)) {
	data.push(attr);
	}
	}
	return data;
	}

	getAttributeValueFromNode(node: Node, attribute: string) {
	if (node && node.attributes !== undefined) {
	for (let attr of node.attributes) {
	if (attr.name === attribute) {
	return attr.value;
	}
	}
	}
	return '';
	}

	getAttributeFromNode(node: Node, attribute: string) {
	if (node && node.attributes !== undefined) {
	for (let attr of node.attributes) {
	if (attr.name === attribute) {
	return attr;
	}
	}
	}
	return undefined;
	}

	getNextTemporaryId() {
	let id = -1;
	for (let extSystem of this.extSystems) {
	if (parseInt(extSystem.id, 10) < id) {
	id = parseInt(extSystem.id, 10);
	}
	}
	return --id;
	}

	createAttribute(name: string, value?: string) {
	let attr = new Attribute();
	attr.dataType = 'STRING';
	attr.unit = '';
	attr.value = value !== undefined ? value : '';
	attr.name = name;
	return attr;
	}

	getIndicesForIds(ids: string[]) {
	let indices = new Array();
	for (let id of ids) {
	for (let extSystem of this.extSystems) {
	if (extSystem.id === ids[id]) {
	indices.push(this.extSystems.indexOf(extSystem));
	}
	}
	}
	return indices;
	}

	/**
	* Save the external system
	*/
	saveExtSystem() {
	this.getAttributeFromNode(this.selectedExtSystem, 'Name').value = this.selectedExtSystem.name;
	this.extSystemService.saveExtSystem(this.selectedEnvironment.sourceName, this.selectedExtSystem)
	.subscribe(
	response => { /* discard */ },
	error => this.notificationService.notifyError(
	this.translateService.instant('administration.extsystem.err-cannot-update-ext-system'), error)
	);
	}

	addExtSystemAttr() {
	// initialze the node
	this.tmpExtSystemAttr = new Node();
	this.tmpExtSystemAttr.type = 'ExtSystemAttribute';
	this.tmpExtSystemAttr.sourceType = 'ExtSystemAttr';
	this.tmpExtSystemAttr.sourceName = this.selectedEnvironment.sourceName;
	this.tmpExtSystemAttr.attributes = new Array();
	this.tmpExtSystemAttr.attributes.push(this.createAttribute('Description'));
	this.tmpExtSystemAttr.attributes.push(this.createAttribute('Name'));
	this.tmpExtSystemAttr.attributes.push(this.createAttribute('ConverterClassname'));
	this.tmpExtSystemAttr.attributes.push(this.createAttribute('ConverterParameter'));
	this.tmpExtSystemAttr.attributes.push(this.createAttribute('MimeType', 'application/x-asam.aoany.extsystemattr'));

	// Initialize relations on the external system if it is not defined yet
	if (this.selectedExtSystem.relations === undefined \|\| this.selectedExtSystem.relations.length === 0) {
	this.selectedExtSystem.relations = new Array();
	let relation = new Relation();
	relation.entityType = 'ExtSystemAttribute';
	relation.type = 'CHILDREN';
	relation.ids = new Array();
	this.selectedExtSystem.relations.push(relation);
	}
	if (this.selectedExtSystem.relations[0].ids === undefined) {
	this.selectedExtSystem.relations[0].ids = new Array();
	}

	// Set initial name to persist the attribute
	this.tmpExtSystemAttr.name = 'Attribut';
	this.getAttributeFromNode(this.tmpExtSystemAttr, 'Name').value = this.tmpExtSystemAttr.name;
	this.saveExtSystemAttr(this.tmpExtSystemAttr);
	}

	/**
	* Remove the external system attribute
	*/
	removeExtSystemAttr(extSystemAttr?: Node) {
	if (extSystemAttr != undefined) {

	if (extSystemAttr.id !== undefined && parseInt(extSystemAttr.id, 10) > 0 && this.extSystemAttrs.indexOf(extSystemAttr) !== -1) {
	this.extSystemService.deleteExtSystemAttr(this.selectedEnvironment.sourceName, extSystemAttr.id).subscribe();
	let idxES: number = this.extSystemAttrs.indexOf(extSystemAttr);
	if (idxES !== -1) {
	this.extSystemAttrs.splice(idxES, 1);
	if (extSystemAttr.relations !== undefined && extSystemAttr.relations.length > 0) {
	// remove all children
	let indices = new Array<number>();
	for (let h of extSystemAttr.relations) {
	// the mdm attributes
	indices = indices.concat(this.getIndicesForIds(h.ids));
	}
	indices.sort((a, b) => b - a);
	for (let i of indices) {
	this.extSystemAttrs.splice(indices[i], 1);
	}
	}
	}
	}
	}
	this.selectedExtSystemAttr = undefined;
	}

	/**
	* Change listener on the name and description of the table element
	*/
	updateSystemAttrModel(rowData: Node) {
	// update the name attribute
	this.getAttributeFromNode(rowData, 'Name').value = rowData.name;
	// persist the change
	this.saveExtSystemAttr(rowData);
	}

	/**
	* Method invoked only if the save of the external system attribute succeeded
	* This method is additional only successful if the node is a new node
	*/
	saveExtSystemAttrSuccess(nodes: Node[]) {
	if (this.tmpExtSystemAttr) {
	for (let node of nodes) {
	if (node.name === this.tmpExtSystemAttr.name && this.tmpExtSystemAttr.id === undefined) {
	this.tmpExtSystemAttr.id = node.id;
	}
	}
	this.extSystemAttrs.push(this.tmpExtSystemAttr);
	this.tmpExtSystemAttr = undefined;
	}
	}

	/**
	* Save the external system attribute
	*/
	saveExtSystemAttr(tmpAttr: Node) {
	this.extSystemService.saveExtSystemAttr(this.selectedEnvironment.sourceName, tmpAttr, this.selectedExtSystem)
	.subscribe(
	response => this.saveExtSystemAttrSuccess(plainToClass(Node, response.json().data)),
	error => {
	this.tmpExtSystemAttr = undefined;
	this.notificationService.notifyError(
	this.translateService.instant('administration.extsystem.err-cannot-save-ext-system-attr'), error);
	}
	);
	}

	onExtSystemAttrSelect(event) {
	let mdmAttrs = this.getMDMAttributes();
	for (let attr of mdmAttrs) {
	this.getCatalogComponentStr(attr);
	this.getAttributeComponentStr(attr);
	}
	}

	addExtSystemMDMAttr() {
	this.tmpExtSystemMDMAttr = new Node();
	this.tmpExtSystemMDMAttr.type = 'MDMAttribute';
	this.tmpExtSystemMDMAttr.sourceType = 'MDMAttr';
	this.tmpExtSystemMDMAttr.sourceName = this.selectedEnvironment.sourceName;
	this.tmpExtSystemMDMAttr.attributes = new Array();
	this.tmpExtSystemMDMAttr.attributes.push(this.createAttribute('AttrName'));
	this.tmpExtSystemMDMAttr.attributes.push(this.createAttribute('CompName'));
	this.tmpExtSystemMDMAttr.attributes.push(this.createAttribute('CompType'));
	this.tmpExtSystemMDMAttr.attributes.push(this.createAttribute('MimeType', 'application/x-asam.aoany.mdmattr'));
	// the name is the hierarchy from the parent elements appended with the name, set in save method
	this.tmpExtSystemMDMAttr.attributes.push(this.createAttribute('Name'));

	// add relation
	if (this.selectedExtSystemAttr.relations === undefined \|\| this.selectedExtSystemAttr.relations.length === 0) {
	this.selectedExtSystemAttr.relations = new Array();
	let relation = new Relation();
	relation.entityType = 'MDMAttribute';
	relation.type = 'CHILDREN';
	relation.ids = new Array();
	this.selectedExtSystemAttr.relations.push(relation);
	}
	if (this.selectedExtSystemAttr.relations[0].ids === undefined) {
	this.selectedExtSystemAttr.relations[0].ids = new Array();
	}

	// Set initial name to persist the attribute
	this.getAttributeFromNode(this.tmpExtSystemMDMAttr, 'CompType').value = 'UnitUnderTest';
	this.getAttributeFromNode(this.tmpExtSystemMDMAttr, 'CompName').value = 'Komponente';
	this.getAttributeFromNode(this.tmpExtSystemMDMAttr, 'AttrName').value = 'Attribut';

	this.saveExtSystemMDMAttr(this.tmpExtSystemMDMAttr);
	}

	removeExtSystemMDMAttr(extSystemMDMAttr?: Node) {
	if (extSystemMDMAttr != undefined) {
	if (this.extSystemAttrs.indexOf(extSystemMDMAttr) !== -1) {
	if (extSystemMDMAttr.id !== undefined && parseInt(extSystemMDMAttr.id, 10) > 0) {
	this.extSystemService.deleteExtSystemMDMAttr(this.selectedEnvironment.sourceName, extSystemMDMAttr.id).subscribe();
	}
	this.extSystemAttrs.splice(this.extSystemAttrs.indexOf(extSystemMDMAttr), 1);
	}
	}
	}

	saveExtSystemMDMAttrSuccess(nodes: Node[]) {
	if (this.tmpExtSystemMDMAttr) {
	for (let node of nodes) {
	if (node.name === this.tmpExtSystemMDMAttr.name && this.tmpExtSystemMDMAttr.id === undefined) {
	this.tmpExtSystemMDMAttr.id = node.id;
	for (let relation of this.selectedExtSystemAttr.relations) {
	if (relation.entityType === 'MDMAttribute') {
	if (relation.ids === undefined) {
	relation.ids = new Array();
	}
	relation.ids.push(node.id);
	}
	}
	}
	}
	this.extSystemAttrs.push(this.tmpExtSystemMDMAttr);
	this.tmpExtSystemMDMAttr = undefined;
	}
	}

	saveExtSystemMDMAttr(tmpAttr: Node) {
	// update the name attribute with the hierarchy
	tmpAttr.name = this.getAttributeValueFromNode(tmpAttr, 'CompType')
	+ '.' + this.getAttributeValueFromNode(tmpAttr, 'CompName')
	+ '.' + this.getAttributeValueFromNode(tmpAttr, 'AttrName');
	this.getAttributeFromNode(tmpAttr, 'Name').value = tmpAttr.name;

	this.extSystemService.saveExtSystemMDMAttr(this.selectedEnvironment.sourceName, tmpAttr, this.selectedExtSystemAttr)
	.subscribe(
	response => this.saveExtSystemMDMAttrSuccess(plainToClass(Node, response.json().data)),
	error => {
	this.tmpExtSystemMDMAttr = undefined;
	this.notificationService.notifyError(
	this.translateService.instant('administration.extsystem.err-cannot-save-ext-mdm-attr'), error);
	}
	);
	}

	async loadCatalogComps(type: string) {
	if (type !== undefined && type != null && type.length > 0) {

	// load the template roots if not available
	if (this.loadedTemplateRoots[type] === undefined) {
	this.loadedTemplateRoots[type] = [];
	try {
	const response = await this.catalogService.getTplRootsForType(this.selectedEnvironment.sourceName, type).toPromise();
	this.loadedTemplateRoots[type] = response;
	} catch (error) {
	this.notificationService.notifyError(
	this.translateService.instant('administration.extsystem.err-cannot-load-comp-types'), error);
	}
	}

	// load the catalog components if not already triggered
	if (this.loadedTemplateRoots[type] !== undefined && this.loadedTemplateRoots[type].length > 0
	&& this.loadedCatalogComps[type] === undefined) {
	this.loadedCatalogComps[type] = [];
	let tmpIds = this.loadedTemplateRoots[type].map(tr => tr.id);

	of(tmpIds).pipe(
	flatMap(q => forkJoin(...q.map(id => this.catalogService.getTplCompForRoot(this.selectedEnvironment.sourceName, type, id)))),
	map(nested => [].concat(...nested))
	).subscribe(
	templateComponentWithDuplicateVersions => {
	const groupedByName = templateComponentWithDuplicateVersions.reduce((group: any[], templateComponent: any) => {
	group[templateComponent.name] = group[templateComponent.name] \|\| [];
	group[templateComponent.name].push(templateComponent);
	return group;
	}, {});
	let templateComponents = [];
	for (const name of Object.keys(groupedByName)) {
	templateComponents.push(groupedByName[name].reduce((g: any, templateComponent: any) =>
	g.id <= templateComponent.id ? templateComponent : g,
	{ id: -1 }
	));
	}
	this.loadedCatalogComps[type] = templateComponents;
	},
	error => this.notificationService.notifyError(
	this.translateService.instant('administration.extsystem.err-cannot-load-comp-types'), error)
	);

	return true;
	}
	}
	return false;
	}

	async loadAttributeComps(type: string, comp: string) {
	if (type !== undefined && type != null && type.length > 0 && comp !== undefined && comp != null && comp.length > 0
	&& this.loadedAttributeComps[type + comp] === undefined) {
	let compId = '';
	let rootId = '0';
	if (this.loadedCatalogComps && this.loadedCatalogComps[type]) {
	for (let catalogComp of this.loadedCatalogComps[type]) {
	if (catalogComp.name === comp) {
	compId = catalogComp.id;
	break;
	}
	}
	}
	if (this.loadedTemplateRoots && this.loadedTemplateRoots[type]) {
	for (let templateRoot of this.loadedTemplateRoots[type]) {
	if (templateRoot.relations !== undefined) {
	for (let relation of templateRoot.relations) {
	if (relation.entityType === 'TemplateComponent'
	&& relation.ids !== undefined) {
	for (let id of relation.ids) {
	if (id === compId) {
	rootId = templateRoot.id;
	break;
	}
	}
	if (rootId !== '0') {
	break;
	}
	}
	}
	if (rootId !== '0') {
	break;
	}
	}
	}
	}
	if (rootId !== '0' && compId !== '') {
	this.loadedAttributeComps[type + comp] = [];
	try {
	const response = await this.catalogService.
	getTplAttrsForComp(this.selectedEnvironment.sourceName, type, rootId, compId).toPromise();
	for (let t of response) {
	this.loadedAttributeComps[type + comp].push(t);
	}
	} catch (error) {
	this.notificationService.notifyError(
	this.translateService.instant('administration.extsystem.err-cannot-load-comp-types'), error);
	}
	return true;
	}
	} else {
	return false;
	}
	}

	getCatalogComponentStr(rowData: Node) {
	let type: string = <string> this.getAttributeValueFromNode(rowData, 'CompType');
	let data: string[] = new Array();
	// sensor does not have catalog elements
	if (type !== undefined && type !== 'Sensor') {
	let components = this.getCatalogComponents(type);
	if (components) {
	for (let component of components) {
	data.push(component.name);
	}
	}
	}
	return data;
	}

	getAttributeComponentStr(rowData: Node) {
	let type: string = <string> this.getAttributeValueFromNode(rowData, 'CompType');
	let comp: string = <string> this.getAttributeValueFromNode(rowData, 'CompName');
	let data: string[] = new Array();
	if (type !== undefined && comp !== undefined) {
	let components = this.getAttributeComponents(type, comp);
	if (components) {
	for (let component of components) {
	data.push(component.name);
	}
	}
	}
	return data;
	}

	getCatalogComponents(type: string) {
	let data: Node[] = this.loadedCatalogComps[type];
	if (data === undefined \|\| data == null \|\| data.length === 0) {
	if (this.loadCatalogComps(type)) {
	data = this.loadedCatalogComps[type];
	}
	}
	return data;
	}

	getAttributeComponents(type: string, comp: string) {
	let data: Node[] = this.loadedAttributeComps[type + comp];
	if (data === undefined \|\| data == null \|\| data.length === 0) {
	if (this.loadAttributeComps(type, comp)) {
	data = this.loadedAttributeComps[type + comp];
	}
	}
	return data;
	}

	/**
	*
	*/
	availableCatalogComps(rowData: Node) {
	let result = this.availableSlctCtlgComps[rowData.id];
	if (result === undefined) {
	result = [];
	result.push({ label: this.translateService.instant('administration.extsystem.dropdown-please-select'), value: '' });
	let items = this.getCatalogComponentStr(rowData);
	for (let item of items) {
	if (item !== undefined) {
	result.push({ label: item, value: item});
	}
	}
	if (result.length > 1) {
	this.availableSlctCtlgComps[rowData.id] = result;
	}
	}
	return result;
	}

	availableAttributeComps(rowData: Node) {
	let result = this.availableSlctAttrComps[rowData.id];
	if (result === undefined) {
	result = [];
	result.push({ label: this.translateService.instant('administration.extsystem.dropdown-please-select'), value: '' });
	let items = this.getAttributeComponentStr(rowData);
	for (let item of items) {
	if (item !== undefined) {
	result.push({ label: item, value: item});
	}
	}
	if (result.length > 1) {
	this.availableSlctAttrComps[rowData.id] = result;
	}
	}
	return result;
	}

	handleCompTypeSelect(event, rowData: Node) {
	this.availableSlctCtlgComps[rowData.id] = undefined;
	this.availableSlctAttrComps[rowData.id] = undefined;
	this.getAttributeFromNode(rowData, 'CompName').value = 'Komponente';
	this.getAttributeFromNode(rowData, 'AttrName').value = 'Attribut';
	this.getCatalogComponentStr(rowData);
	this.saveExtSystemMDMAttr(rowData);
	}

	handleCompSelect(event, rowData: Node) {
	this.availableSlctAttrComps[rowData.id] = undefined;
	this.getAttributeFromNode(rowData, 'AttrName').value = 'Attribut';
	this.getAttributeComponentStr(rowData);
	this.saveExtSystemMDMAttr(rowData);
	}

	handleAttrCompSelect(event, rowData: Node) {
	this.saveExtSystemMDMAttr(rowData);
	}

	}