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