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 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;
  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(packageName)) {
  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             this.packageCreationStore.changeDslDefinition(dslDefinition);
  96             this.packageCreationStore.setCustomKeys(mapOfCustomKeys);
  97             this.setPackageDescription(definition.metadata.template_description);
  98             console.log(definition);
  99             console.log(definition.topology_template);
 100             const content = {};
 101             const workflow = 'workflows';
 102             content[workflow] = definition.topology_template ? definition.topology_template.workflows : {};
 103             const nodeTemplates = 'node_templates';
 104             content[nodeTemplates] = definition.topology_template ? definition.topology_template.node_templates : {};
 105             this.designerStore.saveSourceContent(JSON.stringify(content));
 106             this.packageCreationStore.addTopologyTemplate(definition.topology_template);
 107
 108
 109         }
 110         this.packageCreationStore.addDefinition(filename, fileData);
 111
 112     }
 113
 114     public setTemplates(filename: string, fileData: any) {
 115         this.packageCreationStore.addTemplate(filename, fileData);
 116     }
 117
 118     public setMapping(fileName: string, fileData: string) {
 119         this.packageCreationStore.addMapping(fileName, fileData);
 120     }
 121
 122     private setMetaData(metaDataObject: MetaDataTabModel) {
 123         this.packageCreationStore.changeMetaData(metaDataObject);
 124     }
 125
 126     public setMetaDataWithObject(metaDataObject: MetaDataTabModel, bluePrintDetailModel: BluePrintDetailModel) {
 127         metaDataObject.description = bluePrintDetailModel.artifactDescription;
 128         this.packageCreationStore.changeMetaData(metaDataObject);
 129
 130     }
 131
 132     public getMetaDataTabInfo(fileData: string) {
 133         const metaDataTabModel = new MetaDataTabModel();
 134
 135         const arrayOfLines = fileData.split('\n');
 136         const map = new Map<string, string>();
 137         for (const currentLine of arrayOfLines) {
 138             const currentKey = currentLine.split(':')[0];
 139             const currentValue = currentLine.split(':')[1];
 140             map.set(currentKey, currentValue);
 141         }
 142         metaDataTabModel.entryFileName = map.get(this.toscaMetaDataKeys[3]);
 143         metaDataTabModel.name = map.get(this.toscaMetaDataKeys[4]);
 144         metaDataTabModel.version = map.get(this.toscaMetaDataKeys[5]).trim();
 145         metaDataTabModel.mode = map.get(this.toscaMetaDataKeys[6]);
 146         if (map.get(this.toscaMetaDataKeys[7])) {
 147             metaDataTabModel.templateTags = new Set<string>(map.get(this.toscaMetaDataKeys[7]).split(','));
 148         }
 149         return metaDataTabModel;
 150     }
 151
 152     private setPackageDescription(templateDescription: string) {
 153         const metaData = this.packageCreationStore.getMetaData();
 154         metaData.description = templateDescription;
 155         this.setMetaData(metaData);
 156
 157     }
 158 }