cds-ui/designer-client/src/app/modules/feature-modules/packages/package-creation/package-creation-extraction.service.ts

   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(private packageCreationStore: PackageCreationStore,
  26                 private packageCreationUtils: PackageCreationUtils,
  27                 private designerStore: DesignerStore) {
  28
  29     }
  30
  31     public extractBlobToStore(blob) {
  32
  33         let packageName = null;
  34         this.zipFile.loadAsync(blob).then((zip) => {
  35             Object.keys(zip.files).filter(fileName => fileName.includes('TOSCA-Metadata/'))
  36                 .forEach((filename) => {
  37                     zip.files[filename].async('string').then((fileData) => {
  38                         if (fileData) {
  39                             if (filename.includes('TOSCA-Metadata/')) {
  40
  41                                 const metaDataTabInfo: MetaDataTabModel = this.getMetaDataTabInfo(fileData);
  42                                 packageName = metaDataTabInfo.name;
  43                                 this.setMetaData(metaDataTabInfo);
  44                                 console.log('found file ' + packageName);
  45                             }
  46                         }
  47                     });
  48                 });
  49         });
  50
  51         this.zipFile.loadAsync(blob).then((zip) => {
  52             Object.keys(zip.files).forEach((filename) => {
  53                 zip.files[filename].async('string').then((fileData) => {
  54                     console.log(filename);
  55                     if (fileData) {
  56                         if (filename.includes('Scripts/')) {
  57                             this.setScripts(filename, fileData);
  58                         } else if (filename.includes('Templates/')) {
  59                             if (filename.includes('-mapping.')) {
  60                                 this.setMapping(filename, fileData);
  61                             } else if (filename.includes('-template.')) {
  62                                 this.setTemplates(filename, fileData);
  63                             }
  64
  65                         } else if (filename.includes('Definitions/')) {
  66                             this.setImports(filename, fileData, packageName);
  67                         }
  68                     }
  69                 });
  70             });
  71         });
  72     }
  73
  74     private setScripts(filename: string, fileData: any) {
  75         this.packageCreationStore.addScripts(filename, fileData);
  76     }
  77
  78     private setImports(filename: string, fileData: any, packageName: string) {
  79         console.log(filename);
  80         if (filename.includes(packageName)) {
  81             let definition = new VlbDefinition();
  82             definition = fileData as VlbDefinition;
  83             definition = JSON.parse(fileData);
  84             const dslDefinition = new DslDefinition();
  85             dslDefinition.content = this.packageCreationUtils.transformToJson(definition.dsl_definitions);
  86             const mapOfCustomKeys = new Map<string, string>();
  87             for (const metadataKey in definition.metadata) {
  88                 if (!this.entryDefinitionKeys.includes(metadataKey + '')) {
  89                     mapOfCustomKeys.set(metadataKey + '', definition.metadata[metadataKey + '']);
  90                 }
  91             }
  92             this.packageCreationStore.changeDslDefinition(dslDefinition);
  93             this.packageCreationStore.setCustomKeys(mapOfCustomKeys);
  94             this.setPackageDescription(definition.metadata.template_description);
  95             console.log(definition);
  96             console.log(definition.topology_template);
  97             const content = {};
  98             const workflow = 'workflows';
  99             content[workflow] = definition.topology_template.workflows;
 100             const nodeTemplates = 'node_templates';
 101             content[nodeTemplates] = definition.topology_template.node_templates;
 102             this.designerStore.saveSourceContent(JSON.stringify(content));
 103
 104         }
 105         this.packageCreationStore.addDefinition(filename, fileData);
 106
 107     }
 108
 109     private setTemplates(filename: string, fileData: any) {
 110         this.packageCreationStore.addTemplate(filename, fileData);
 111     }
 112
 113     private setMapping(fileName: string, fileData: string) {
 114         this.packageCreationStore.addMapping(fileName, fileData);
 115     }
 116
 117     private setMetaData(metaDataObject: MetaDataTabModel) {
 118         this.packageCreationStore.changeMetaData(metaDataObject);
 119     }
 120
 121     private getMetaDataTabInfo(fileData: string) {
 122         const metaDataTabModel = new MetaDataTabModel();
 123
 124         const arrayOfLines = fileData.split('\n');
 125         const map = new Map<string, string>();
 126         for (const currentLine of arrayOfLines) {
 127             const currentKey = currentLine.split(':')[0];
 128             const currentValue = currentLine.split(':')[1];
 129             map.set(currentKey, currentValue);
 130         }
 131         metaDataTabModel.entryFileName = map.get(this.toscaMetaDataKeys[3]);
 132         metaDataTabModel.name = map.get(this.toscaMetaDataKeys[4]);
 133         metaDataTabModel.version = map.get(this.toscaMetaDataKeys[5]).trim();
 134         metaDataTabModel.mode = map.get(this.toscaMetaDataKeys[6]);
 135         if (map.get(this.toscaMetaDataKeys[7])) {
 136             metaDataTabModel.templateTags = new Set<string>(map.get(this.toscaMetaDataKeys[7]).split(','));
 137         }
 138         return metaDataTabModel;
 139     }
 140
 141     private setPackageDescription(templateDescription: string) {
 142         const metaData = this.packageCreationStore.getMetaData();
 143         metaData.description = templateDescription;
 144         this.setMetaData(metaData);
 145
 146     }
 147 }