cds-ui/designer-client/src/app/modules/feature-modules/packages/configuration-dashboard/configuration-dashboard.component.ts

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