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 {CBADefinition, TemplateTopology} from './mapping-models/definitions/CBADefinition';
   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                         } else if (filename.includes('Plans/')) {
  71                             this.setPlans(filename, fileData);
  72                         } else if (filename.includes('Requirements/')) {
  73                             this.setRequirements(filename, fileData);
  74                         }
  75                     }
  76                 });
  77             });
  78         });
  79     }
  80
  81     public setScripts(filename: string, fileData: any) {
  82         this.packageCreationStore.addScripts(filename, fileData);
  83     }
  84
  85     public setPlans(filename: string, fileData: any) {
  86         this.packageCreationStore.addPlans(filename, fileData);
  87     }
  88
  89     public setRequirements(filename: string, fileData: any) {
  90         this.packageCreationStore.addRequirements(filename, fileData);
  91     }
  92
  93     public setImports(filename: string, fileData: any, packageName: string) {
  94         console.log(filename);
  95         if (filename.includes('Definitions/' + packageName.trim() + '.json')) {
  96             let definition = new CBADefinition();
  97             definition = fileData as CBADefinition;
  98             definition = JSON.parse(fileData);
  99             const dslDefinition = new DslDefinition();
 100             dslDefinition.content = this.packageCreationUtils.transformToJson(definition.dsl_definitions);
 101             const mapOfCustomKeys = new Map<string, string>();
 102             for (const metadataKey in definition.metadata) {
 103                 if (!this.entryDefinitionKeys.includes(metadataKey + '')) {
 104                     mapOfCustomKeys.set(metadataKey + '', definition.metadata[metadataKey + '']);
 105                 }
 106             }
 107
 108             this.packageCreationStore.changeDslDefinition(dslDefinition);
 109             this.packageCreationStore.setCustomKeys(mapOfCustomKeys);
 110             this.setPackageDescription(definition.metadata.template_description);
 111             console.log(definition);
 112             console.log(definition.topology_template);
 113             const content = {};
 114             const workflow = 'workflows';
 115             content[workflow] = definition.topology_template ? definition.topology_template.workflows : {};
 116             const nodeTemplates = 'node_templates';
 117             content[nodeTemplates] = definition.topology_template ? definition.topology_template.node_templates : {};
 118             this.designerStore.saveSourceContent(JSON.stringify(content));
 119             if (definition.topology_template) {
 120                 this.packageCreationStore.addTopologyTemplate(definition.topology_template);
 121             } else {
 122                 this.packageCreationStore.addTopologyTemplate(new TemplateTopology());
 123             }
 124
 125
 126         }
 127         this.packageCreationStore.addDefinition(filename, fileData);
 128
 129     }
 130
 131     public setTemplates(filename: string, fileData: any) {
 132         this.packageCreationStore.addTemplate(filename, fileData);
 133     }
 134
 135     public setMapping(fileName: string, fileData: string) {
 136         this.packageCreationStore.addMapping(fileName, fileData);
 137     }
 138
 139     private setMetaData(metaDataObject: MetaDataTabModel) {
 140         this.packageCreationStore.changeMetaData(metaDataObject);
 141     }
 142
 143     public setMetaDataWithObject(metaDataObject: MetaDataTabModel, bluePrintDetailModel: BluePrintDetailModel) {
 144         metaDataObject.description = bluePrintDetailModel.artifactDescription;
 145         this.packageCreationStore.changeMetaData(metaDataObject);
 146
 147     }
 148
 149     public getMetaDataTabInfo(fileData: string) {
 150         const metaDataTabModel = new MetaDataTabModel();
 151
 152         const arrayOfLines = fileData.split('\n');
 153         const map = new Map<string, string>();
 154         for (const currentLine of arrayOfLines) {
 155             const currentKey = currentLine.split(':')[0];
 156             const currentValue = currentLine.split(':')[1];
 157             map.set(currentKey, currentValue);
 158         }
 159         metaDataTabModel.entryFileName = map.get(this.toscaMetaDataKeys[3]);
 160         metaDataTabModel.name = map.get(this.toscaMetaDataKeys[4]).trim();
 161         metaDataTabModel.version = map.get(this.toscaMetaDataKeys[5]).trim();
 162         metaDataTabModel.mode = map.get(this.toscaMetaDataKeys[6]);
 163         if (map.get(this.toscaMetaDataKeys[7])) {
 164             metaDataTabModel.templateTags = new Set<string>(map.get(this.toscaMetaDataKeys[7]).split(','));
 165         }
 166         return metaDataTabModel;
 167     }
 168
 169     private setPackageDescription(templateDescription: string) {
 170         const metaData = this.packageCreationStore.getMetaData();
 171         metaData.description = templateDescription;
 172         this.setMetaData(metaData);
 173
 174     }
 175 }