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