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
  19 @Component({
  20     selector: 'app-configuration-dashboard',
  21     templateUrl: './configuration-dashboard.component.html',
  22     styleUrls: ['./configuration-dashboard.component.css'],
  23 })
  24 export class ConfigurationDashboardComponent implements OnInit {
  25     viewedPackage: BluePrintDetailModel = new BluePrintDetailModel();
  26     @ViewChild(MetadataTabComponent, {static: false})
  27     private metadataTabComponent: MetadataTabComponent;
  28     public customActionName = '';
  29
  30     entryDefinitionKeys: string[] = ['template_tags', 'user-groups',
  31         'author-email', 'template_version', 'template_name', 'template_author', 'template_description'];
  32     @ViewChild('nameit', {static: true})
  33     private elementRef: ElementRef;
  34
  35     private zipFile: JSZip = new JSZip();
  36     private filesData: any = [];
  37     private folder: FolderNodeElement = new FolderNodeElement();
  38
  39     private currentBlob = new Blob();
  40
  41     constructor(private route: ActivatedRoute, private configurationDashboardService: ConfigurationDashboardService,
  42                 private packageCreationStore: PackageCreationStore,
  43                 private packageCreationUtils: PackageCreationUtils,
  44                 private router: Router,
  45                 private designerStore: DesignerStore,
  46                 private designerService: DesignerService,
  47                 private toastService: ToastrService
  48     ) {
  49     }
  50
  51     ngOnInit() {
  52         this.elementRef.nativeElement.focus();
  53         const id = this.route.snapshot.paramMap.get('id');
  54         this.configurationDashboardService.getPagedPackages(id).subscribe(
  55             (bluePrintDetailModels) => {
  56                 if (bluePrintDetailModels) {
  57                     this.viewedPackage = bluePrintDetailModels[0];
  58                     this.downloadCBAPackage(bluePrintDetailModels);
  59                     this.packageCreationStore.clear();
  60                 }
  61             });
  62     }
  63
  64
  65     private downloadCBAPackage(bluePrintDetailModels: BluePrintDetailModel) {
  66         this.configurationDashboardService.downloadResource(
  67             bluePrintDetailModels[0].artifactName + '/' + bluePrintDetailModels[0].artifactVersion).subscribe(response => {
  68             const blob = new Blob([response], {type: 'application/octet-stream'});
  69             this.currentBlob = blob;
  70             this.zipFile.loadAsync(blob).then((zip) => {
  71                 Object.keys(zip.files).forEach((filename) => {
  72                     zip.files[filename].async('string').then((fileData) => {
  73                         if (fileData) {
  74                             if (filename.includes('Scripts/')) {
  75                                 this.setScripts(filename, fileData);
  76                             } else if (filename.includes('Templates/')) {
  77                                 if (filename.includes('-mapping.')) {
  78                                     this.setMapping(filename, fileData);
  79                                 } else if (filename.includes('-template.')) {
  80                                     this.setTemplates(filename, fileData);
  81                                 }
  82
  83                             } else if (filename.includes('Definitions/')) {
  84                                 this.setImports(filename, fileData, bluePrintDetailModels);
  85                             } else if (filename.includes('TOSCA-Metadata/')) {
  86                                 const metaDataTabInfo: MetaDataTabModel = this.getMetaDataTabInfo(fileData);
  87                                 this.setMetaData(metaDataTabInfo, bluePrintDetailModels[0]);
  88                             }
  89                         }
  90                     });
  91                 });
  92             });
  93         });
  94     }
  95
  96     private setScripts(filename: string, fileData: any) {
  97         this.packageCreationStore.addScripts(filename, fileData);
  98     }
  99
 100     private setImports(filename: string, fileData: any, bluePrintDetailModels: BluePrintDetailModel) {
 101         if (filename.includes(bluePrintDetailModels[0].artifactName)) {
 102             let definition = new VlbDefinition();
 103             definition = fileData as VlbDefinition;
 104             definition = JSON.parse(fileData);
 105             const dslDefinition = new DslDefinition();
 106             dslDefinition.content = this.packageCreationUtils.transformToJson(definition.dsl_definitions);
 107             const mapOfCustomKeys = new Map<string, string>();
 108             for (const metadataKey in definition.metadata) {
 109                 if (!this.entryDefinitionKeys.includes(metadataKey + '')) {
 110                     mapOfCustomKeys.set(metadataKey + '', definition.metadata[metadataKey + '']);
 111                 }
 112             }
 113             this.packageCreationStore.changeDslDefinition(dslDefinition);
 114             this.packageCreationStore.setCustomKeys(mapOfCustomKeys);
 115             if (definition.topology_template && definition.topology_template.content) {
 116                 this.designerStore.saveSourceContent(definition.topology_template.content);
 117             }
 118         } else {
 119             this.packageCreationStore.addDefinition(filename, fileData);
 120
 121         }
 122     }
 123
 124     private setTemplates(filename: string, fileData: any) {
 125         this.packageCreationStore.addTemplate(filename, fileData);
 126     }
 127
 128     private setMapping(fileName: string, fileData: string) {
 129         this.packageCreationStore.addMapping(fileName, fileData);
 130     }
 131
 132     editBluePrint() {
 133         this.packageCreationStore.state$.subscribe(
 134             cbaPackage => {
 135                 FilesContent.clear();
 136                 let packageCreationModes: PackageCreationModes;
 137                 cbaPackage = PackageCreationModes.mapModeType(cbaPackage);
 138                 cbaPackage.metaData = PackageCreationModes.setEntryPoint(cbaPackage.metaData);
 139                 packageCreationModes = PackageCreationBuilder.getCreationMode(cbaPackage);
 140                 packageCreationModes.execute(cbaPackage, this.packageCreationUtils);
 141                 this.filesData.push(this.folder.TREE_DATA);
 142                 this.saveBluePrintToDataBase();
 143             });
 144     }
 145
 146     private setMetaData(metaDataObject: MetaDataTabModel, bluePrintDetailModel: BluePrintDetailModel) {
 147         metaDataObject.description = bluePrintDetailModel.artifactDescription;
 148         this.packageCreationStore.changeMetaData(metaDataObject);
 149
 150     }
 151
 152     saveMetaData() {
 153         this.metadataTabComponent.saveMetaDataToStore();
 154     }
 155
 156     getMetaDataTabInfo(fileData: string) {
 157         const metaDataTabModel = new MetaDataTabModel();
 158         const arrayOfLines = fileData.split('\n');
 159         metaDataTabModel.entryFileName = arrayOfLines[3].split(':')[1];
 160         metaDataTabModel.name = arrayOfLines[4].split(':')[1];
 161         metaDataTabModel.version = arrayOfLines[5].split(':')[1];
 162         metaDataTabModel.mode = arrayOfLines[6].split(':')[1];
 163         metaDataTabModel.templateTags = new Set<string>(arrayOfLines[7].split(':')[1].split(','));
 164         return metaDataTabModel;
 165     }
 166
 167     saveBluePrintToDataBase() {
 168         this.create();
 169         this.zipFile.generateAsync({type: 'blob'})
 170             .then(blob => {
 171                 this.packageCreationStore.saveBluePrint(blob).subscribe(
 172                     bluePrintDetailModels => {
 173                         if (bluePrintDetailModels) {
 174                             const id = bluePrintDetailModels.toString().split('id')[1].split(':')[1].split('"')[1];
 175                             this.toastService.info('package updated successfully ');
 176                             this.router.navigate(['/packages/package/' + id]);
 177                         }
 178                     }, error => {
 179                         this.toastService.error('error happened when editing ' + error.message);
 180                         console.log('Error -' + error.message);
 181                     });
 182             });
 183     }
 184
 185
 186     create() {
 187         this.zipFile = new JSZip();
 188         FilesContent.getMapOfFilesNamesAndContent().forEach((value, key) => {
 189             this.zipFile.folder(key.split('/')[0]);
 190             this.zipFile.file(key, value);
 191         });
 192
 193     }
 194
 195     goBacktoDashboard() {
 196         this.router.navigate(['/packages']);
 197     }
 198
 199     downloadPackage(artifactName: string, artifactVersion: string) {
 200         this.configurationDashboardService.downloadResource(artifactName + '/' + artifactVersion).subscribe(response => {
 201             const blob = new Blob([response], {type: 'application/octet-stream'});
 202             saveAs(blob, artifactName + '-' + artifactVersion + '-CBA.zip');
 203         });
 204     }
 205
 206     deployCurrentPackage() {
 207         console.log('happened');
 208         /*   this.zipFile.generateAsync({type: 'blob'})
 209                .then(blob => {
 210                    const formData = new FormData();
 211                    formData.append('file', this.currentBlob);
 212                    this.configurationDashboardService.deployPost(formData)
 213                        .subscribe(data => {
 214                        }, error => {
 215                        });
 216                    this.router.navigate(['/packages']);
 217                });
 218    */
 219         this.router.navigate(['/packages']);
 220     }
 221
 222     goToDesignerMode(id) {
 223         //  this.designerService.setActionName(this.customActionName);
 224         this.router.navigate(['/packages/designer', id, {actionName: this.customActionName}]);
 225     }
 226 }