catalog-ui/src/app/ng2/pages/composition/palette/services/palette.service.ts

   1 import { HttpClient, HttpParams } from '@angular/common/http';
   2 import { Inject, Injectable } from '@angular/core';
   3 import { LeftPaletteComponent, LeftPaletteMetadataTypes } from 'app/models/components/displayComponent';
   4 import { GroupMetadata } from 'app/models/group-metadata';
   5 import { PolicyMetadata } from 'app/models/policy-metadata';
   6 import { IComponentMetadata } from 'app/models/component-metadata';
   7 import { SdcConfigToken } from 'app/ng2/config/sdc-config.config';
   8 import { ISdcConfig } from 'app/ng2/config/sdc-config.config.factory';
   9 import { WorkspaceService } from 'app/ng2/pages/workspace/workspace.service';
  10 import 'rxjs/add/observable/forkJoin';
  11 import { Observable } from 'rxjs/Rx';
  12 import Dictionary = _.Dictionary;
  13
  14
  15
  16 @Injectable()
  17 export class CompositionPaletteService {
  18
  19     protected baseUrl = '';
  20
  21     private leftPaletteComponents: Dictionary<Dictionary<LeftPaletteComponent[]>>;
  22     private facadeUrl: string;
  23     constructor(protected http: HttpClient, @Inject(SdcConfigToken) sdcConfig: ISdcConfig, private workspaceService: WorkspaceService) {
  24         this.baseUrl = sdcConfig.api.root + sdcConfig.api.component_api_root;
  25         this.facadeUrl = sdcConfig.api.uicache_root + sdcConfig.api.GET_uicache_left_palette;
  26
  27     }
  28
  29     public subscribeToLeftPaletteElements(next, error) {
  30         let params = new HttpParams();
  31         params = params.append('internalComponentType', this.workspaceService.getMetadataType());
  32         let model = this.workspaceService.metadata.model
  33         if (model) {
  34           params = params.append('componentModel', model);
  35           if (this.workspaceService.getMetadataType() === 'SERVICE'){
  36             params = params.append('includeNormativeExtensionModels', 'true');
  37           }
  38         }
  39         const loadInstances = this.http.get(this.facadeUrl, {params});
  40         const loadGroups = this.http.get(this.baseUrl + 'groupTypes', {params});
  41         const loadPolicies = this.http.get(this.baseUrl + 'policyTypes', {params});
  42         Observable.forkJoin(loadInstances, loadGroups, loadPolicies).subscribe( ([resInstances, resGrouops, resPolicies]) => {
  43             const combinedDictionary = this.combineResoponses(resInstances, resGrouops, resPolicies);
  44             this.leftPaletteComponents = combinedDictionary;
  45             next(this.leftPaletteComponents);
  46         });
  47     }
  48
  49     public getLeftPaletteElements = (): Dictionary<Dictionary<LeftPaletteComponent[]>> => {
  50         return this.leftPaletteComponents;
  51     }
  52
  53
  54     public convertPoliciesOrGroups = (paletteListResult, type: string ) => {
  55         const components: LeftPaletteComponent[] = [];
  56
  57         if (type === 'Policies') {
  58             _.forEach(paletteListResult, (policyMetadata: PolicyMetadata) => {
  59                 components.push(new LeftPaletteComponent(LeftPaletteMetadataTypes.Policy, policyMetadata));
  60             });
  61             return {
  62                 Policies: components
  63             };
  64         }
  65
  66         if (type === 'Groups') {
  67             _.forEach(paletteListResult, (groupMetadata: GroupMetadata) => {
  68                 const item = new LeftPaletteComponent(LeftPaletteMetadataTypes.Group, groupMetadata);
  69                 components.push(item);
  70             });
  71             return {
  72                 Groups: components
  73             };
  74         }
  75
  76         return {};
  77     }
  78
  79     private combineResoponses(resInstances: object, resGrouops: object, resPolicies: object) {
  80         const retValObject = {};
  81
  82         if (resInstances['Generic']) {
  83                 if (this.isSubstitutionForNestedServices()) {
  84                     const serviceGroup = this.createServiceGroup(resInstances);
  85                     if (serviceGroup) {
  86                         retValObject['Service'] = serviceGroup;
  87                     }
  88                 }
  89                         retValObject['Generic'] = resInstances['Generic'];
  90             }
  91
  92         // Add all other categories
  93         for (const category in resInstances) {
  94             if (category === 'Generic') {
  95                 continue;
  96             }
  97             retValObject[category] = resInstances[category];
  98         }
  99
 100         // Add Groups
 101         retValObject["Groups"] = this.convertPoliciesOrGroups(resGrouops, 'Groups');
 102
 103         // Add policies
 104         retValObject["Policies"] = this.convertPoliciesOrGroups(resPolicies, 'Policies');
 105
 106         return retValObject;
 107     }
 108
 109     private isSubstitutionForNestedServices(): boolean {
 110             return this.workspaceService.metadata.categories[0].useServiceSubstitutionForNestedServices;
 111         }
 112
 113     private createServiceGroup(resInstances: object): object {
 114             const servicesList = resInstances['Generic']['Generic'];
 115             if (Array.isArray(servicesList) && servicesList.length > 0) {
 116                 delete resInstances['Generic']['Generic'];
 117                 return servicesList.reduce(function (map, component) {
 118                     if (map[component.categories[0].name]) {
 119                         map[component.categories[0].name].push(component);
 120                     } else {
 121                         map[component.categories[0].name] = [component];
 122                     }
 123                     return map;
 124                 }, {});
 125             }
 126             return null;
 127         }
 128
 129 }