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 { VlbDefinition } from '../package-creation/mapping-models/definitions/VlbDefinition';
  10 import { 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 { DesignerService } from '../designer/designer.service';
  17 import { ToastrService } from 'ngx-toastr';
  18 import { NgxFileDropEntry } from 'ngx-file-drop';
  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     dslDefinition: DslDefinition = new DslDefinition();
  43
  44     constructor(
  45         private route: ActivatedRoute,
  46         private configurationDashboardService: ConfigurationDashboardService,
  47         private packageCreationStore: PackageCreationStore,
  48         private packageCreationUtils: PackageCreationUtils,
  49         private router: Router,
  50         private designerStore: DesignerStore,
  51         private toastService: ToastrService
  52     ) {
  53     }
  54
  55     ngOnInit() {
  56         this.elementRef.nativeElement.focus();
  57         this.id = this.route.snapshot.paramMap.get('id');
  58         this.configurationDashboardService.getPagedPackages(this.id).subscribe(
  59             (bluePrintDetailModels) => {
  60                 if (bluePrintDetailModels) {
  61                     this.viewedPackage = bluePrintDetailModels[0];
  62                     this.downloadCBAPackage(bluePrintDetailModels);
  63                     this.packageCreationStore.clear();
  64                 }
  65             });
  66
  67         if (this.route.snapshot.paramMap.has('id')) {
  68             console.log('The id is equal to ' + this.route.snapshot.paramMap.get('id'));
  69         }
  70     }
  71
  72     private downloadCBAPackage(bluePrintDetailModels: BluePrintDetailModel) {
  73         this.configurationDashboardService.downloadResource(
  74             bluePrintDetailModels[0].artifactName + '/' + bluePrintDetailModels[0].artifactVersion).subscribe(response => {
  75                 const blob = new Blob([response], { type: 'application/octet-stream' });
  76                 this.currentBlob = blob;
  77                 this.zipFile.loadAsync(blob).then((zip) => {
  78                     Object.keys(zip.files).forEach((filename) => {
  79                         zip.files[filename].async('string').then((fileData) => {
  80                             if (fileData) {
  81                                 if (filename.includes('Scripts/')) {
  82                                     this.setScripts(filename, fileData);
  83                                 } else if (filename.includes('Templates/')) {
  84                                     if (filename.includes('-mapping.')) {
  85                                         this.setMapping(filename, fileData);
  86                                     } else if (filename.includes('-template.')) {
  87                                         this.setTemplates(filename, fileData);
  88                                     }
  89
  90                                 } else if (filename.includes('Definitions/')) {
  91                                     this.setImports(filename, fileData, bluePrintDetailModels);
  92                                 } else if (filename.includes('TOSCA-Metadata/')) {
  93                                     const metaDataTabInfo: MetaDataTabModel = this.getMetaDataTabInfo(fileData);
  94                                     this.setMetaData(metaDataTabInfo, bluePrintDetailModels[0]);
  95                                 }
  96                             }
  97                         });
  98                     });
  99                 });
 100             });
 101     }
 102
 103     setScripts(filename: string, fileData: any) {
 104         this.packageCreationStore.addScripts(filename, fileData);
 105     }
 106
 107     setImports(filename: string, fileData: any, bluePrintDetailModels: BluePrintDetailModel) {
 108         if (filename.includes(bluePrintDetailModels[0].artifactName)) {
 109             let definition = new VlbDefinition();
 110             definition = fileData as VlbDefinition;
 111             definition = JSON.parse(fileData);
 112             const dslDefinition = new DslDefinition();
 113             dslDefinition.content = this.packageCreationUtils.transformToJson(definition.dsl_definitions);
 114             const mapOfCustomKeys = new Map<string, string>();
 115             for (const metadataKey in definition.metadata) {
 116                 if (!this.entryDefinitionKeys.includes(metadataKey + '')) {
 117                     mapOfCustomKeys.set(metadataKey + '', definition.metadata[metadataKey + '']);
 118                 }
 119             }
 120             this.packageCreationStore.changeDslDefinition(dslDefinition);
 121             this.packageCreationStore.setCustomKeys(mapOfCustomKeys);
 122             if (definition.topology_template && definition.topology_template.content) {
 123                 this.designerStore.saveSourceContent(definition.topology_template.content);
 124             }
 125         } else {
 126             this.packageCreationStore.addDefinition(filename, fileData);
 127
 128         }
 129     }
 130
 131     setTemplates(filename: string, fileData: any) {
 132         this.packageCreationStore.addTemplate(filename, fileData);
 133     }
 134
 135     setMapping(fileName: string, fileData: string) {
 136         this.packageCreationStore.addMapping(fileName, fileData);
 137     }
 138
 139     editBluePrint() {
 140         this.packageCreationStore.state$.subscribe(
 141             cbaPackage => {
 142                 FilesContent.clear();
 143                 let packageCreationModes: PackageCreationModes;
 144                 cbaPackage = PackageCreationModes.mapModeType(cbaPackage);
 145                 cbaPackage.metaData = PackageCreationModes.setEntryPoint(cbaPackage.metaData);
 146                 packageCreationModes = PackageCreationBuilder.getCreationMode(cbaPackage);
 147                 packageCreationModes.execute(cbaPackage, this.packageCreationUtils);
 148                 this.filesData.push(this.folder.TREE_DATA);
 149                 this.saveBluePrintToDataBase();
 150             });
 151     }
 152
 153     setMetaData(metaDataObject: MetaDataTabModel, bluePrintDetailModel: BluePrintDetailModel) {
 154         metaDataObject.description = bluePrintDetailModel.artifactDescription;
 155         this.packageCreationStore.changeMetaData(metaDataObject);
 156
 157     }
 158
 159     saveMetaData() {
 160         this.metadataTabComponent.saveMetaDataToStore();
 161     }
 162
 163     getMetaDataTabInfo(fileData: string) {
 164         const metaDataTabModel = new MetaDataTabModel();
 165         const arrayOfLines = fileData.split('\n');
 166         metaDataTabModel.entryFileName = arrayOfLines[3].split(':')[1];
 167         metaDataTabModel.name = arrayOfLines[4].split(':')[1];
 168         metaDataTabModel.version = arrayOfLines[5].split(':')[1];
 169         metaDataTabModel.mode = arrayOfLines[6].split(':')[1];
 170         metaDataTabModel.templateTags = new Set<string>(arrayOfLines[7].split(':')[1].split(','));
 171         return metaDataTabModel;
 172     }
 173
 174     saveBluePrintToDataBase() {
 175         this.create();
 176         this.zipFile.generateAsync({ type: 'blob' })
 177             .then(blob => {
 178                 this.packageCreationStore.saveBluePrint(blob).subscribe(
 179                     bluePrintDetailModels => {
 180                         if (bluePrintDetailModels) {
 181                             const id = bluePrintDetailModels.toString().split('id')[1].split(':')[1].split('"')[1];
 182                             this.toastService.info('package updated successfully ');
 183                             this.router.navigate(['/packages/package/' + id]);
 184                         }
 185                     }, error => {
 186                         this.toastService.error('error happened when editing ' + error.message);
 187                         console.log('Error -' + error.message);
 188                     });
 189             });
 190     }
 191
 192     deletePackage() {
 193         this.configurationDashboardService.deletePackage(this.id).subscribe(res => {
 194             console.log('Deleted');
 195             console.log(res);
 196             this.router.navigate(['/packages']);
 197         }, err => {
 198             console.log(err);
 199         });
 200     }
 201     create() {
 202         this.zipFile = new JSZip();
 203         FilesContent.getMapOfFilesNamesAndContent().forEach((value, key) => {
 204             this.zipFile.folder(key.split('/')[0]);
 205             this.zipFile.file(key, value);
 206         });
 207
 208     }
 209
 210     goBacktoDashboard() {
 211         this.router.navigate(['/packages']);
 212     }
 213
 214     downloadPackage(artifactName: string, artifactVersion: string) {
 215         this.configurationDashboardService.downloadResource(artifactName + '/' + artifactVersion).subscribe(response => {
 216             const blob = new Blob([response], { type: 'application/octet-stream' });
 217             saveAs(blob, artifactName + '-' + artifactVersion + '-CBA.zip');
 218         });
 219     }
 220
 221     deployCurrentPackage() {
 222         console.log('happened');
 223         /*   this.zipFile.generateAsync({type: 'blob'})
 224                .then(blob => {
 225                    const formData = new FormData();
 226                    formData.append('file', this.currentBlob);
 227                    this.configurationDashboardService.deployPost(formData)
 228                        .subscribe(data => {
 229                        }, error => {
 230                        });
 231                    this.router.navigate(['/packages']);
 232                });
 233    */
 234         this.router.navigate(['/packages']);
 235     }
 236
 237     goToDesignerMode(id) {
 238         //  this.designerService.setActionName(this.customActionName);
 239         this.router.navigate(['/packages/designer', id, { actionName: this.customActionName }]);
 240     }
 241
 242     public dropped(files: NgxFileDropEntry[]) {
 243
 244     }
 245     public fileOver(event) {
 246         console.log(event);
 247     }
 248
 249     public fileLeave(event) {
 250         console.log(event);
 251     }
 252
 253     textChanged($event: {}) {
 254
 255     }
 256 }