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

   1 import { Injectable, ViewChild } from '@angular/core';
   2 import { MetaDataTabModel } from './mapping-models/metadata/MetaDataTab.model';
   3 import { VlbDefinition } from './mapping-models/definitions/VlbDefinition';
   4 import { DslDefinition } from './mapping-models/CBAPacakge.model';
   5 import { PackageCreationStore } from './package-creation.store';
   6 import * as JSZip from 'jszip';
   7 import { PackageCreationUtils } from './package-creation.utils';
   8 import { MetadataTabComponent } from './metadata-tab/metadata-tab.component';
   9 import { DesignerStore } from '../designer/designer.store';
  10
  11 @Injectable({
  12     providedIn: 'root'
  13 })
  14 export class PackageCreationExtractionService {
  15
  16     private zipFile: JSZip = new JSZip();
  17     private entryDefinitionKeys: string[] = ['template_tags', 'user-groups',
  18         'author-email', 'template_version', 'template_name', 'template_author', 'template_description'];
  19
  20     private toscaMetaDataKeys: string[] = ['TOSCA-Meta-File-Version', 'CSAR-Version',
  21         'Created-By', 'Entry-Definitions', 'Template-Name', 'Template-Version', 'Template-Type', 'Template-Tags'];
  22     @ViewChild(MetadataTabComponent, { static: false })
  23     private metadataTabComponent: MetadataTabComponent;
  24
  25     constructor(
  26         private packageCreationStore: PackageCreationStore,
  27         private packageCreationUtils: PackageCreationUtils,
  28         private designerStore: DesignerStore
  29     ) {
  30
  31     }
  32
  33     public extractBlobToStore(blob) {
  34
  35         let packageName = null;
  36         this.zipFile.loadAsync(blob).then((zip) => {
  37             Object.keys(zip.files).filter(fileName => fileName.includes('TOSCA-Metadata/'))
  38                 .forEach((filename) => {
  39                     zip.files[filename].async('string').then((fileData) => {
  40                         if (fileData) {
  41                             if (filename.includes('TOSCA-Metadata/')) {
  42
  43                                 const metaDataTabInfo: MetaDataTabModel = this.getMetaDataTabInfo(fileData);
  44                                 packageName = metaDataTabInfo.name;
  45                                 this.setMetaData(metaDataTabInfo);
  46                                 console.log('found file ' + packageName);
  47                             }
  48                         }
  49                     });
  50                 });
  51         });
  52
  53         this.zipFile.loadAsync(blob).then((zip) => {
  54             Object.keys(zip.files).forEach((filename) => {
  55                 zip.files[filename].async('string').then((fileData) => {
  56                     console.log(filename);
  57                     if (fileData) {
  58                         if (filename.includes('Scripts/')) {
  59                             this.setScripts(filename, fileData);
  60                         } else if (filename.includes('Templates/')) {
  61                             if (filename.includes('-mapping.')) {
  62                                 this.setMapping(filename, fileData);
  63                             } else if (filename.includes('-template.')) {
  64                                 this.setTemplates(filename, fileData);
  65                             }
  66
  67                         } else if (filename.includes('Definitions/')) {
  68                             this.setImports(filename, fileData, packageName);
  69                         }
  70                     }
  71                 });
  72             });
  73         });
  74     }
  75
  76     private setScripts(filename: string, fileData: any) {
  77         this.packageCreationStore.addScripts(filename, fileData);
  78     }
  79
  80     private setImports(filename: string, fileData: any, packageName: string) {
  81         console.log(filename);
  82         if (filename.includes(packageName)) {
  83             let definition = new VlbDefinition();
  84             definition = fileData as VlbDefinition;
  85             definition = JSON.parse(fileData);
  86             const dslDefinition = new DslDefinition();
  87             dslDefinition.content = this.packageCreationUtils.transformToJson(definition.dsl_definitions);
  88             const mapOfCustomKeys = new Map<string, string>();
  89             for (const metadataKey in definition.metadata) {
  90                 if (!this.entryDefinitionKeys.includes(metadataKey + '')) {
  91                     mapOfCustomKeys.set(metadataKey + '', definition.metadata[metadataKey + '']);
  92                 }
  93             }
  94             this.packageCreationStore.changeDslDefinition(dslDefinition);
  95             this.packageCreationStore.setCustomKeys(mapOfCustomKeys);
  96             this.setPackageDescription(definition.metadata.template_description);
  97             console.log(definition);
  98             console.log(definition.topology_template);
  99             const content = {};
 100             const workflow = 'workflows';
 101             content[workflow] = definition.topology_template ? definition.topology_template.workflows : {};
 102             const nodeTemplates = 'node_templates';
 103             content[nodeTemplates] = definition.topology_template ? definition.topology_template.node_templates : {};
 104             this.designerStore.saveSourceContent(JSON.stringify(content));
 105
 106         }
 107         this.packageCreationStore.addDefinition(filename, fileData);
 108
 109     }
 110
 111     private setTemplates(filename: string, fileData: any) {
 112         this.packageCreationStore.addTemplate(filename, fileData);
 113     }
 114
 115     private setMapping(fileName: string, fileData: string) {
 116         this.packageCreationStore.addMapping(fileName, fileData);
 117     }
 118
 119     private setMetaData(metaDataObject: MetaDataTabModel) {
 120         this.packageCreationStore.changeMetaData(metaDataObject);
 121     }
 122
 123     private getMetaDataTabInfo(fileData: string) {
 124         const metaDataTabModel = new MetaDataTabModel();
 125
 126         const arrayOfLines = fileData.split('\n');
 127         const map = new Map<string, string>();
 128         for (const currentLine of arrayOfLines) {
 129             const currentKey = currentLine.split(':')[0];
 130             const currentValue = currentLine.split(':')[1];
 131             map.set(currentKey, currentValue);
 132         }
 133         metaDataTabModel.entryFileName = map.get(this.toscaMetaDataKeys[3]);
 134         metaDataTabModel.name = map.get(this.toscaMetaDataKeys[4]);
 135         metaDataTabModel.version = map.get(this.toscaMetaDataKeys[5]).trim();
 136         metaDataTabModel.mode = map.get(this.toscaMetaDataKeys[6]);
 137         if (map.get(this.toscaMetaDataKeys[7])) {
 138             metaDataTabModel.templateTags = new Set<string>(map.get(this.toscaMetaDataKeys[7]).split(','));
 139         }
 140         return metaDataTabModel;
 141     }
 142
 143     private setPackageDescription(templateDescription: string) {
 144         const metaData = this.packageCreationStore.getMetaData();
 145         metaData.description = templateDescription;
 146         this.setMetaData(metaData);
 147
 148     }
 149 }