gerrit.onap Code Review - ccsdk/cds.git/blob

   1 import {Component, ElementRef, OnInit, ViewChild} from '@angular/core';
   2 import {ActivatedRoute, Router} from '@angular/router';
   3 import {BluePrintDetailModel} from '../model/BluePrint.detail.model';
   4 import {PackageCreationStore} from '../package-creation/package-creation.store';
   5 import {FilesContent, FolderNodeElement, MetaDataTabModel} from '../package-creation/mapping-models/metadata/MetaDataTab.model';
   6 import {MetadataTabComponent} from '../package-creation/metadata-tab/metadata-tab.component';
   7 import * as JSZip from 'jszip';
   8 import {ConfigurationDashboardService} from './configuration-dashboard.service';
   9 import {TemplateTopology, VlbDefinition} from '../package-creation/mapping-models/definitions/VlbDefinition';
  10 import {CBAPackage, DslDefinition} from '../package-creation/mapping-models/CBAPacakge.model';
  11 import {PackageCreationUtils} from '../package-creation/package-creation.utils';
  12 import {PackageCreationModes} from '../package-creation/creationModes/PackageCreationModes';
  13 import {PackageCreationBuilder} from '../package-creation/creationModes/PackageCreationBuilder';
  14 import {saveAs} from 'file-saver';
  15 import {DesignerStore} from '../designer/designer.store';
  16 import {ToastrService} from 'ngx-toastr';
  17 import {NgxFileDropEntry} from 'ngx-file-drop';
  18 import {PackageCreationService} from '../package-creation/package-creation.service';
  19
  20 @Component({
  21     selector: 'app-configuration-dashboard',
  22     templateUrl: './configuration-dashboard.component.html',
  23     styleUrls: ['./configuration-dashboard.component.css'],
  24 })
  25 export class ConfigurationDashboardComponent implements OnInit {
  26     viewedPackage: BluePrintDetailModel = new BluePrintDetailModel();
  27     @ViewChild(MetadataTabComponent, {static: false})
  28     metadataTabComponent: MetadataTabComponent;
  29     public customActionName = '';
  30
  31     entryDefinitionKeys: string[] = ['template_tags', 'user-groups',
  32         'author-email', 'template_version', 'template_name', 'template_author', 'template_description'];
  33     @ViewChild('nameit', {static: true})
  34     elementRef: ElementRef;
  35     uploadedFiles = [];
  36     zipFile: JSZip = new JSZip();
  37     filesData: any = [];
  38     folder: FolderNodeElement = new FolderNodeElement();
  39     id: any;
  40
  41     currentBlob = new Blob();
  42     vlbDefinition: VlbDefinition = new VlbDefinition();
  43     isSaveEnabled = false;
  44     versionPattern = '^(\\d+\\.)?(\\d+\\.)?(\\*|\\d+)$';
  45     metadataClasses = 'nav-item nav-link active';
  46     private cbaPackage: CBAPackage = new CBAPackage();
  47
  48     constructor(
  49         private route: ActivatedRoute,
  50         private configurationDashboardService: ConfigurationDashboardService,
  51         private packageCreationStore: PackageCreationStore,
  52         private packageCreationService: PackageCreationService,
  53         private packageCreationUtils: PackageCreationUtils,
  54         private router: Router,
  55         private designerStore: DesignerStore,
  56         private toastService: ToastrService
  57     ) {
  58         this.packageCreationStore.state$.subscribe(
  59             cbaPackage => {
  60                 this.cbaPackage = cbaPackage;
  61             });
  62     }
  63
  64     ngOnInit() {
  65         this.vlbDefinition.topology_template = new TemplateTopology();
  66
  67         this.elementRef.nativeElement.focus();
  68         this.refreshCurrentPackage();
  69         const regexp = RegExp(this.versionPattern);
  70         if (this.cbaPackage && this.cbaPackage.metaData && this.cbaPackage.metaData.description
  71             && this.cbaPackage.metaData.name && this.cbaPackage.metaData.version &&
  72             regexp.test(this.cbaPackage.metaData.version)) {
  73             if (!this.metadataClasses.includes('complete')) {
  74                 this.metadataClasses += ' complete';
  75             }
  76         } else {
  77             this.metadataClasses = this.metadataClasses.replace('complete', '');
  78             this.isSaveEnabled = false;
  79         }
  80
  81
  82     }
  83
  84     private refreshCurrentPackage() {
  85         this.id = this.route.snapshot.paramMap.get('id');
  86         this.configurationDashboardService.getPagedPackages(this.id).subscribe(
  87             (bluePrintDetailModels) => {
  88                 if (bluePrintDetailModels) {
  89                     this.viewedPackage = bluePrintDetailModels[0];
  90                     this.downloadCBAPackage(bluePrintDetailModels);
  91                     this.packageCreationStore.clear();
  92                 }
  93             });
  94     }
  95
  96     private downloadCBAPackage(bluePrintDetailModels: BluePrintDetailModel) {
  97         this.configurationDashboardService.downloadResource(
  98             bluePrintDetailModels[0].artifactName + '/' + bluePrintDetailModels[0].artifactVersion).subscribe(response => {
  99             const blob = new Blob([response], {type: 'application/octet-stream'});
 100             this.currentBlob = blob;
 101             this.extractBlobToStore(blob, bluePrintDetailModels);
 102         });
 103     }
 104
 105     private extractBlobToStore(blob: Blob, bluePrintDetailModels: BluePrintDetailModel) {
 106         this.zipFile.loadAsync(blob).then((zip) => {
 107             Object.keys(zip.files).forEach((filename) => {
 108                 zip.files[filename].async('string').then((fileData) => {
 109                     console.log(filename);
 110                     if (fileData) {
 111                         if (filename.includes('Scripts/')) {
 112                             this.setScripts(filename, fileData);
 113                         } else if (filename.includes('Templates/')) {
 114                             if (filename.includes('-mapping.')) {
 115                                 this.setMapping(filename, fileData);
 116                             } else if (filename.includes('-template.')) {
 117                                 this.setTemplates(filename, fileData);
 118                             }
 119
 120                         } else if (filename.includes('Definitions/')) {
 121                             this.setImports(filename, fileData, bluePrintDetailModels);
 122                         } else if (filename.includes('TOSCA-Metadata/')) {
 123                             const metaDataTabInfo: MetaDataTabModel = this.getMetaDataTabInfo(fileData);
 124                             this.setMetaData(metaDataTabInfo, bluePrintDetailModels[0]);
 125                         }
 126                     }
 127                 });
 128             });
 129         });
 130     }
 131
 132     setScripts(filename: string, fileData: any) {
 133         this.packageCreationStore.addScripts(filename, fileData);
 134     }
 135
 136     setImports(filename: string, fileData: any, bluePrintDetailModels: BluePrintDetailModel) {
 137         if (filename.includes(bluePrintDetailModels[0].artifactName)) {
 138             let definition = new VlbDefinition();
 139             definition = fileData as VlbDefinition;
 140             definition = JSON.parse(fileData);
 141             const dslDefinition = new DslDefinition();
 142             dslDefinition.content = this.packageCreationUtils.transformToJson(definition.dsl_definitions);
 143             const mapOfCustomKeys = new Map<string, string>();
 144             for (const metadataKey in definition.metadata) {
 145                 if (!this.entryDefinitionKeys.includes(metadataKey + '')) {
 146                     mapOfCustomKeys.set(metadataKey + '', definition.metadata[metadataKey + '']);
 147                 }
 148             }
 149             this.packageCreationStore.changeDslDefinition(dslDefinition);
 150             this.packageCreationStore.setCustomKeys(mapOfCustomKeys);
 151             if (definition.topology_template && definition.topology_template.content) {
 152                 this.designerStore.saveSourceContent(definition.topology_template.content);
 153             }
 154
 155         }
 156         this.packageCreationStore.addDefinition(filename, fileData);
 157
 158     }
 159
 160     setTemplates(filename: string, fileData: any) {
 161         this.packageCreationStore.addTemplate(filename, fileData);
 162     }
 163
 164     setMapping(fileName: string, fileData: string) {
 165         this.packageCreationStore.addMapping(fileName, fileData);
 166     }
 167
 168     editBluePrint() {
 169         if (this.cbaPackage) {
 170             this.formTreeData();
 171             this.saveBluePrintToDataBase();
 172         }
 173     }
 174
 175     private formTreeData() {
 176         FilesContent.clear();
 177         let packageCreationModes: PackageCreationModes;
 178         this.cbaPackage = PackageCreationModes.mapModeType(this.cbaPackage);
 179         this.cbaPackage.metaData = PackageCreationModes.setEntryPoint(this.cbaPackage.metaData);
 180         packageCreationModes = PackageCreationBuilder.getCreationMode(this.cbaPackage);
 181         packageCreationModes.execute(this.cbaPackage, this.packageCreationUtils);
 182         this.filesData.push(this.folder.TREE_DATA);
 183     }
 184
 185     setMetaData(metaDataObject: MetaDataTabModel, bluePrintDetailModel: BluePrintDetailModel) {
 186         metaDataObject.description = bluePrintDetailModel.artifactDescription;
 187         this.packageCreationStore.changeMetaData(metaDataObject);
 188
 189     }
 190
 191     saveMetaData() {
 192         this.metadataTabComponent.saveMetaDataToStore();
 193
 194     }
 195
 196     getMetaDataTabInfo(fileData: string) {
 197         const metaDataTabModel = new MetaDataTabModel();
 198         const arrayOfLines = fileData.split('\n');
 199         metaDataTabModel.entryFileName = arrayOfLines[3].split(':')[1];
 200         metaDataTabModel.name = arrayOfLines[4].split(':')[1];
 201         metaDataTabModel.version = arrayOfLines[5].split(':')[1];
 202         metaDataTabModel.mode = arrayOfLines[6].split(':')[1];
 203         metaDataTabModel.templateTags = new Set<string>(arrayOfLines[7].split(':')[1].split(','));
 204         return metaDataTabModel;
 205     }
 206
 207     saveBluePrintToDataBase() {
 208         this.create();
 209         this.zipFile.generateAsync({type: 'blob'})
 210             .then(blob => {
 211                 this.packageCreationService.savePackage(blob).subscribe(
 212                     bluePrintDetailModels => {
 213                         if (bluePrintDetailModels) {
 214                             const id = bluePrintDetailModels.toString().split('id')[1].split(':')[1].split('"')[1];
 215                             this.toastService.info('package updated successfully ');
 216                             this.router.navigate(['/packages/package/' + id]);
 217                         }
 218                     }, error => {
 219                         this.toastService.error('error happened when editing ' + error.message);
 220                         console.log('Error -' + error.message);
 221                     });
 222             });
 223     }
 224
 225     deletePackage() {
 226         this.configurationDashboardService.deletePackage(this.id).subscribe(res => {
 227             console.log('Deleted');
 228             console.log(res);
 229             this.router.navigate(['/packages']);
 230         }, err => {
 231             console.log(err);
 232         });
 233     }
 234
 235     create() {
 236         this.zipFile = new JSZip();
 237         FilesContent.getMapOfFilesNamesAndContent().forEach((value, key) => {
 238             this.zipFile.folder(key.split('/')[0]);
 239             this.zipFile.file(key, value);
 240         });
 241
 242     }
 243
 244     discardChanges() {
 245         this.refreshCurrentPackage();
 246     }
 247
 248     downloadPackage(artifactName: string, artifactVersion: string) {
 249         this.configurationDashboardService.downloadResource(artifactName + '/' + artifactVersion).subscribe(response => {
 250             const blob = new Blob([response], {type: 'application/octet-stream'});
 251             saveAs(blob, artifactName + '-' + artifactVersion + '-CBA.zip');
 252         });
 253     }
 254
 255     deployCurrentPackage() {
 256         this.formTreeData();
 257         this.deployPackage();
 258
 259     }
 260
 261     goToDesignerMode(id) {
 262         //  this.designerService.setActionName(this.customActionName);
 263         this.router.navigate(['/packages/designer', id, {actionName: this.customActionName}]);
 264     }
 265
 266     public dropped(files: NgxFileDropEntry[]) {
 267
 268     }
 269
 270     public fileOver(event) {
 271         console.log(event);
 272     }
 273
 274     public fileLeave(event) {
 275         console.log(event);
 276     }
 277
 278     textChanged($event: {}) {
 279         this.packageCreationStore.addTopologyTemplate(this.vlbDefinition.topology_template);
 280     }
 281
 282     enrichBluePrint() {
 283
 284         this.formTreeData();
 285         this.enrichPackage();
 286     }
 287
 288
 289     private enrichPackage() {
 290         this.create();
 291         this.zipFile.generateAsync({type: 'blob'})
 292             .then(blob => {
 293                 this.packageCreationService.enrichPackage(blob).subscribe(response => {
 294                     console.log('success');
 295                     const blobInfo = new Blob([response], {type: 'application/octet-stream'});
 296                     this.configurationDashboardService.getPagedPackages(this.id).subscribe(
 297                         (bluePrintDetailModels) => {
 298                             if (bluePrintDetailModels) {
 299                                 this.packageCreationStore.clear();
 300                                 this.extractBlobToStore(blob, bluePrintDetailModels);
 301                                 this.isSaveEnabled = true;
 302                                 this.toastService.info('enriched successfully ');
 303                             }
 304                         });
 305
 306                     // saveAs(blobInfo, 'test' + '-' + '1.0.0' + '-CBA.zip');
 307
 308                 });
 309             }, error => {
 310                 this.toastService.error('error happened when editing ' + error.message);
 311                 console.log('Error -' + error.message);
 312             });
 313     }
 314
 315     private deployPackage() {
 316         this.create();
 317         this.zipFile.generateAsync({type: 'blob'})
 318             .then(blob => {
 319                 this.packageCreationService.enrichPackage(blob).subscribe(response => {
 320                     console.log('success');
 321                     console.log(response);
 322                 });
 323             }, error => {
 324                 this.toastService.error('error happened when deploying ' + error.message);
 325                 console.log('Error -' + error.message);
 326             });
 327     }
 328
 329     clickEvent() {
 330         this.isSaveEnabled = true;
 331     }
 332 }