sdc-workflow-designer-ui/src/app/components/parameter-tree/parameter-tree.component.ts

   1 /**
   2  * Copyright (c) 2017 ZTE Corporation.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * and the Apache License 2.0 which both accompany this distribution,
   6  * and are available at http://www.eclipse.org/legal/epl-v10.html
   7  * and http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Contributors:
  10  *     ZTE - initial API and implementation and/or initial documentation
  11  */
  12
  13 import { Component, Input, OnChanges, Output, SimpleChange, SimpleChanges, ViewEncapsulation } from '@angular/core';
  14 import { TreeNode } from 'primeng/primeng';
  15
  16 import { ValueSource } from '../../model/value-source.enum';
  17 import { ValueType } from '../../model/value-type.enum';
  18 import { Parameter } from '../../model/workflow/parameter';
  19 import { RestParameter } from '../../model/workflow/rest-parameter';
  20 import { RestTask } from '../../model/workflow/rest-task';
  21 import { SwaggerTreeConverterService } from '../../services/swagger-tree-converter.service';
  22 import { WorkflowUtil } from '../../util/workflow-util';
  23
  24 /**
  25  * parameter tree presents parameter of task node's input and output parameters.
  26  */
  27 @Component({
  28     selector: 'b4t-parameter-tree',
  29     styleUrls: ['./parameter-tree.component.css'],
  30     templateUrl: 'parameter-tree.component.html',
  31     encapsulation: ViewEncapsulation.None
  32 })
  33 export class ParameterTreeComponent implements OnChanges {
  34     @Input() public parameters: TreeNode[];
  35     @Input() public task: RestTask;
  36     @Input() public defaultValueSource: string;
  37     @Input() public valueSource: ValueSource[];
  38
  39     constructor(private swaggerTreeConverterService: SwaggerTreeConverterService) { }
  40
  41     public ngOnChanges(changes: SimpleChanges) {
  42         const changeParameters = changes["parameters"];
  43         if (changeParameters && 0 < changeParameters.currentValue.length) {
  44             this.formatParam(changeParameters.currentValue);
  45         }
  46     }
  47
  48     public getParam(node: any) {
  49         if (undefined === node.parameter.name) {
  50             node.parameter.name = node.label;
  51             node.parameter.valueSource = this.defaultValueSource;
  52         } else {
  53             if (node.parent.parameter.value[node.label]) {
  54                 node.parameter.value = node.parent.parameter.value[node.label].value;
  55                 node.parameter.valueSource = node.parent.parameter.value[node.label].valueSource;
  56             } else {
  57                 const tempParamValue: any = {};
  58                 tempParamValue.value = '';
  59                 tempParamValue.valueSource = this.defaultValueSource;
  60                 node.parent.parameter.value[node.label] = tempParamValue;
  61                 node.parameter.value = tempParamValue.value;
  62                 node.parameter.valueSource = tempParamValue.valueSource;
  63             }
  64         }
  65         return node.parameter;
  66     }
  67
  68     public paramChange(param: Parameter, node: any) {
  69         if (node.label !== param.name) {
  70             node.label = param.name;
  71             this.propertyKeyChanged(node, param.value);
  72         }
  73         if (node.parent) {
  74             if (node.parent.parameter.value[param.name]) {
  75                 node.parent.parameter.value[param.name].value = param.value;
  76                 node.parent.parameter.value[param.name].valueSource = param.valueSource;
  77             } else {
  78                 node.parent.parameter.value[param.name] = {
  79                     value: param.value,
  80                     valueSource: param.valueSource
  81                 };
  82             }
  83         }
  84     }
  85
  86     public getKeyParameter(node: any) {
  87         return new Parameter('key', node.label, ValueSource[ValueSource.String], ValueType[ValueType.String]);
  88     }
  89
  90     public keyParameterChange(node: any, parameter: Parameter) {
  91         node.label = parameter.value;
  92         this.propertyKeyChanged(node, parameter.value);
  93     }
  94
  95     public getValueParameter(node: any, key: string) {
  96         const nodeValue = node[key] ? node[key] : {
  97             value: '',
  98             valueSource: ValueSource[ValueSource.String],
  99         };
 100         node[key] = nodeValue;
 101         return nodeValue;
 102     }
 103
 104     public valueParameterChange(node: any, key: string, parameter: Parameter) {
 105         node[key].value = parameter.value;
 106         node[key].valueSource = parameter.valueSource;
 107     }
 108
 109     public addChildNode4DynamicObject(node: any) {
 110         const copyItem = WorkflowUtil.deepClone(node.parameter.additionalProperties);
 111         const key = Object.keys(node.parameter.value).length;
 112         const childrenNode = this.swaggerTreeConverterService
 113             .schema2TreeNode(key, this.task.serviceName, this.task.serviceVersion, copyItem);
 114
 115         childrenNode.keyEditable = true;
 116         node.parameter.value[key] = childrenNode.parameter.value;
 117
 118         node.children.push(childrenNode);
 119     }
 120
 121     public propertyKeyChanged(node: any, newKey: string) {
 122         const value = node.parent.parameter.value[node.label];
 123         node.parent.parameter.value[newKey] = value;
 124         delete node.parent.parameter.value[node.label];
 125
 126         node.label = newKey;
 127     }
 128
 129     public addChildNode4ObjectArray(node: any) {
 130         const copyItem = WorkflowUtil.deepClone(node.parameter.items);
 131
 132         const childrenNode = this.swaggerTreeConverterService
 133             .schema2TreeNode(
 134             node.children.length,
 135             this.task.serviceName,
 136             this.task.serviceVersion,
 137             copyItem);
 138
 139         node.parameter.value.push(childrenNode.parameter.value);
 140         node.children.push(childrenNode);
 141         this.initParam(node);
 142     }
 143
 144     public deleteTreeNode(node: any) {
 145         // delete data
 146         node.parent.parameter.value.splice(node.label, 1);
 147         node.parent.children.splice(node.label, 1);
 148
 149         // update node index
 150         node.parent.children.forEach((childNode, index) => childNode.label = index);
 151     }
 152
 153     public canEditValue(node: any): boolean {
 154         return node.children.length === 0;
 155     }
 156
 157     public canDelete(node: any) {
 158         const parent = node.parent;
 159         if (parent &&
 160             (this.isArrayObject(parent) || this.isDynamicObject(parent))) {
 161             return true;
 162         } else {
 163             return false;
 164         }
 165     }
 166
 167     public updateObjectValue(node: any, value: string) {
 168         const newValueObj = JSON.parse(value);
 169         for (const key in node.parameter.value) {
 170             delete node.parameter.value[key];
 171         }
 172
 173         for (const key in newValueObj) {
 174             node.parameter.value[key] = newValueObj[key];
 175         }
 176     }
 177
 178     public getObjectValue(node) {
 179         return JSON.stringify(node.parameter.value);
 180     }
 181
 182     public canAdd(node: any) {
 183         return this.isArrayObject(node) || this.isDynamicObject(node);
 184     }
 185
 186     private formatParam(params: any[]): void {
 187         console.log(params);
 188         params.forEach(param => this.initParam(param));
 189     }
 190
 191     private initParam(parameter: any, value?: any): void {
 192         if (!parameter || 0 === parameter.length) {
 193             return;
 194         }
 195         switch (parameter.type) {
 196             case 'default':
 197                 parameter.parameter.name = parameter.label;
 198                 if (value && value[parameter.label]) {
 199                     parameter.parameter.value = value[parameter.label].value;
 200                     parameter.parameter.valueSource = value[parameter.label].valueSource;
 201                 } else {
 202                     parameter.parameter.valueSource = this.defaultValueSource;
 203                 }
 204                 break;
 205             case 'object':
 206                 for (let index = 0; index < parameter.children.length; index++) {
 207                     let param = parameter.children[index];
 208                     this.initParam(param, parameter.parameter.value);
 209                 }
 210                 break;
 211             case 'array':
 212                 for (let index = 0; index < parameter.children.length; index++) {
 213                     let param = parameter.children[index];
 214                     this.initParam(param, parameter.parameter.value);
 215                 }
 216                 break;
 217             default:
 218                 console.log('init a unsupport parameter, type is:' + parameter.type);
 219                 break;
 220         }
 221     }
 222
 223     private isArrayObject(node: any): boolean {
 224         return node.type === 'array';
 225     }
 226
 227     private isDynamicObject(node: any): boolean {
 228         return node.type === 'map';
 229     }
 230 }