2 * Created by ob0695 on 6/26/2018.
5 * ============LICENSE_START=======================================================
7 * ================================================================================
8 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
9 * ================================================================================
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
14 * http://www.apache.org/licenses/LICENSE-2.0
16 * Unless required by applicable law or agreed to in writing, software
17 * distributed under the License is distributed on an "AS IS" BASIS,
18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 * See the License for the specific language governing permissions and
20 * limitations under the License.
21 * ============LICENSE_END=========================================================
24 import * as _ from "lodash";
25 import {Injectable, Inject} from '@angular/core';
26 import {Observable} from 'rxjs/Observable';
27 import 'rxjs/add/operator/map';
28 import 'rxjs/add/operator/toPromise';
32 InstancePropertiesAPIMap,
33 FilterPropertiesAssignmentData,
38 Capability, Requirement, BEOperationModel, InterfaceModel
40 import {ArtifactGroupType, COMPONENT_FIELDS} from "app/utils";
41 import {ComponentGenericResponse} from "../responses/component-generic-response";
42 import {InstanceBePropertiesMap} from "../../../models/properties-inputs/property-fe-map";
43 import {API_QUERY_PARAMS} from "app/utils";
44 import {ComponentType, ServerTypeUrl, SERVICE_FIELDS} from "../../../utils/constants";
45 import {SdcConfigToken, ISdcConfig} from "../../config/sdc-config.config";
46 import {IDependenciesServerResponse} from "../responses/dependencies-server-response";
47 import {AutomatedUpgradeGenericResponse} from "../responses/automated-upgrade-response";
48 import {IAutomatedUpgradeRequestObj} from "../../pages/automated-upgrade/automated-upgrade.service";
49 import {ComponentInstance} from "../../../models/componentsInstances/componentInstance";
50 import {CommonUtils} from "../../../utils/common-utils";
51 import {RelationshipModel} from "../../../models/graph/relationship";
52 import {ServiceGenericResponse} from "../responses/service-generic-response";
53 import { HttpClient, HttpParams, HttpHeaders } from "@angular/common/http";
54 import { HttpHelperService } from "../http-hepler.service";
56 Component as TopologyTemplate,
57 FullComponentInstance,
61 import { ConsumptionInput } from "../../components/logic/service-consumption/service-consumption.component";
62 import { ConstraintObject } from "../../components/logic/service-dependencies/service-dependencies.component";
63 import { ComponentMetadata } from "../../../models/component-metadata";
64 import { PolicyInstance } from "../../../models/graph/zones/policy-instance";
65 import { PropertyBEModel } from "../../../models/properties-inputs/property-be-model";
66 import {map} from "rxjs/operators";
67 import {CapabilitiesConstraintObject} from "../../components/logic/capabilities-constraint/capabilities-constraint.component";
69 BEInterfaceOperationModel,
70 ComponentInterfaceDefinitionModel,
71 InterfaceOperationModel
72 } from "../../../models/interfaceOperation";
73 import {AttributeBEModel} from "../../../models/attributes-outputs/attribute-be-model";
74 import {InstanceAttributesAPIMap} from "../../../models/attributes-outputs/attribute-fe-map";
76 /* we need to use this service from now, we will remove component.service when we finish remove the angular1.
77 The service is duplicated since we can not use downgrades service with NGXS*/
80 export class TopologyTemplateService {
84 constructor(protected http: HttpClient, @Inject(SdcConfigToken) sdcConfig: ISdcConfig) {
85 this.baseUrl = sdcConfig.api.root + sdcConfig.api.component_api_root;
88 getFullComponent(componentType: string, uniqueId: string): Observable<Component> {
89 return this.http.get<Component>(this.baseUrl + this.getServerTypeUrl(componentType) + uniqueId);
92 getComponentMetadata(uniqueId: string, type: string): Observable<ComponentGenericResponse> {
93 return this.getComponentDataByFieldsName(type, uniqueId, [COMPONENT_FIELDS.COMPONENT_METADATA]);
96 getComponentInstanceAttributesAndProperties(uniqueId: string, type: string): Observable<ComponentGenericResponse> {
97 return this.getComponentDataByFieldsName(type, uniqueId, [COMPONENT_FIELDS.COMPONENT_INSTANCES_PROPERTIES, COMPONENT_FIELDS.COMPONENT_INSTANCES_ATTRIBUTES]);
100 getComponentInstanceAttributesAndPropertiesAndInputs(uniqueId: string, type: string): Observable<ComponentGenericResponse> {
101 return this.getComponentDataByFieldsName(type, uniqueId, [COMPONENT_FIELDS.COMPONENT_INSTANCES_PROPERTIES, COMPONENT_FIELDS.COMPONENT_INSTANCES_ATTRIBUTES, COMPONENT_FIELDS.COMPONENT_INPUTS]);
104 async getComponentAttributes(componentType: string, componentId: string): Promise<ComponentGenericResponse> {
105 return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_ATTRIBUTES]).toPromise();
108 getComponentCompositionData(componentUniqueId: string, componentType: string): Observable<ComponentGenericResponse> {
109 const params: string[] = [COMPONENT_FIELDS.COMPONENT_INSTANCES_RELATION, COMPONENT_FIELDS.COMPONENT_INSTANCES,
110 COMPONENT_FIELDS.COMPONENT_NON_EXCLUDED_POLICIES, COMPONENT_FIELDS.COMPONENT_NON_EXCLUDED_GROUPS];
111 if (componentType === ComponentType.SERVICE) {
112 params.push(COMPONENT_FIELDS.FORWARDING_PATHS);
114 return this.getComponentDataByFieldsName(componentType, componentUniqueId, params);
117 getComponentResourcePropertiesData(component: Component): Observable<ComponentGenericResponse> {
118 return this.getComponentDataByFieldsName(component.componentType, component.uniqueId,
119 [COMPONENT_FIELDS.COMPONENT_INSTANCES, COMPONENT_FIELDS.COMPONENT_POLICIES, COMPONENT_FIELDS.COMPONENT_NON_EXCLUDED_GROUPS]);
122 getComponentInstances(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
123 return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_INSTANCES]);
126 getComponentInputs(component: Component): Observable<ComponentGenericResponse> {
127 return this.getComponentDataByFieldsName(component.componentType, component.uniqueId, [COMPONENT_FIELDS.COMPONENT_INPUTS]);
130 getComponentInputsValues(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
131 return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_INPUTS]);
134 getComponentInputsWithProperties(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
135 return this.getComponentDataByFieldsName(componentType, componentId,
136 [COMPONENT_FIELDS.COMPONENT_INPUTS, COMPONENT_FIELDS.COMPONENT_INSTANCES, COMPONENT_FIELDS.COMPONENT_INSTANCES_PROPERTIES, COMPONENT_FIELDS.COMPONENT_PROPERTIES]);
139 getComponentOutputsWithAttributes(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
140 return this.getComponentDataByFieldsName(componentType, componentId,
141 [COMPONENT_FIELDS.COMPONENT_OUTPUTS, COMPONENT_FIELDS.COMPONENT_INSTANCES, COMPONENT_FIELDS.COMPONENT_INSTANCES_ATTRIBUTES, COMPONENT_FIELDS.COMPONENT_ATTRIBUTES,COMPONENT_FIELDS.COMPONENT_INSTANCES_OUTPUTS]);
144 getComponentDeploymentArtifacts(component: Component): Observable<ComponentGenericResponse> {
145 return this.getComponentDataByFieldsName(component.componentType, component.uniqueId, [COMPONENT_FIELDS.COMPONENT_DEPLOYMENT_ARTIFACTS]);
148 getComponentInformationalArtifacts(component: Component): Observable<ComponentGenericResponse> {
149 return this.getComponentDataByFieldsName(component.componentType, component.uniqueId, [COMPONENT_FIELDS.COMPONENT_INFORMATIONAL_ARTIFACTS]);
152 getComponentInterfaceOperations(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
153 return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_INTERFACE_OPERATIONS]);
156 getComponentInformationalArtifactsAndInstances(component: Component): Observable<ComponentGenericResponse> {
157 return this.getComponentDataByFieldsName(component.componentType, component.uniqueId, [COMPONENT_FIELDS.COMPONENT_INFORMATIONAL_ARTIFACTS, COMPONENT_FIELDS.COMPONENT_INSTANCES]);
160 getComponentToscaArtifacts(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
161 return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_TOSCA_ARTIFACTS]);
164 getComponentProperties(component: Component): Observable<ComponentGenericResponse> {
165 return this.findAllComponentProperties(component.componentType, component.uniqueId);
168 findAllComponentProperties(componentType: string, componentUniqueId: string): Observable<ComponentGenericResponse> {
169 return this.getComponentDataByFieldsName(componentType, componentUniqueId, [COMPONENT_FIELDS.COMPONENT_PROPERTIES]);
172 getCapabilitiesAndRequirements(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
173 return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_REQUIREMENTS, COMPONENT_FIELDS.COMPONENT_CAPABILITIES]);
176 getRequirementsAndCapabilitiesWithProperties(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
177 return this.getComponentDataByFieldsName(componentType, componentId,
178 [COMPONENT_FIELDS.COMPONENT_REQUIREMENTS, COMPONENT_FIELDS.COMPONENT_CAPABILITIES, COMPONENT_FIELDS.COMPONENT_CAPABILITIES_PROPERTIES]);
181 getDeploymentGraphData(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
182 return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_INSTANCES_RELATION, COMPONENT_FIELDS.COMPONENT_INSTANCES, COMPONENT_FIELDS.COMPONENT_GROUPS]);
185 createInput(component: Component, inputsToCreate: InstancePropertiesAPIMap, isSelf: boolean): Observable<any> {
186 const inputs = isSelf ? { serviceProperties: inputsToCreate.componentInstanceProperties } : inputsToCreate;
187 return this.http.post(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/create/inputs', inputs);
190 createOutput(component: Component, outputsToCreate: InstanceAttributesAPIMap, isSelf: boolean): Observable<any> {
191 const outputs = isSelf ? { serviceProperties: outputsToCreate.componentInstanceAttributes } : outputsToCreate;
192 return this.http.post(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/create/outputs', outputs);
195 restoreComponent(componentType: string, componentId: string) {
196 return this.http.post(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/restore', {});
199 archiveComponent(componentType: string, componentId: string) {
200 return this.http.post(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/archive', {});
203 deleteInput(component: Component, input: InputBEModel): Observable<InputBEModel> {
204 return this.http.delete<InputBEModel>(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/delete/' + input.uniqueId + '/input')
206 return new InputBEModel(res);
210 updateComponentInputs(component: Component, inputs: InputBEModel[]): Observable<InputBEModel[]> {
211 return this.http.post<InputBEModel[]>(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/update/inputs', inputs)
213 return res.map((input) => new InputBEModel(input));
217 filterComponentInstanceProperties(component: Component, filterData: FilterPropertiesAssignmentData): Observable<InstanceBePropertiesMap> {// instance-property-be-map
218 let params: HttpParams = new HttpParams();
219 _.forEach(filterData.selectedTypes, (type: string) => {
220 params = params.append('resourceType', type);
223 // tslint:disable-next-line:object-literal-shorthand
224 return this.http.get<InstanceBePropertiesMap>(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/filteredproperties/' + filterData.propertyName, {params: params});
227 createServiceProperty(componentId: string, propertyModel: PropertyBEModel): Observable<PropertyBEModel> {
228 const serverObject = {};
229 serverObject[propertyModel.name] = propertyModel;
230 return this.http.post<PropertyBEModel>(this.baseUrl + 'services/' + componentId + '/properties', serverObject)
232 const property: PropertyBEModel = new PropertyBEModel(res);
237 createServiceAttribute(componentId: string, attributeModel: AttributeBEModel): Observable<AttributeBEModel> {
238 const serverObject = {};
239 serverObject[attributeModel.name] = attributeModel;
240 return this.http.post<AttributeBEModel>(this.baseUrl + 'services/' + componentId + '/attributes', serverObject)
242 const attribute: AttributeBEModel = new AttributeBEModel(res);
247 getServiceProperties(componentId: string): Observable<PropertyBEModel[]> {
248 return this.http.get<any>(this.baseUrl + 'services/' + componentId + '/properties')
251 return new Array<PropertyBEModel>();
253 return CommonUtils.initBeProperties(res);
257 getServiceAttributes(componentId: string): Observable<AttributeBEModel[]> {
258 return this.http.get<any>(this.baseUrl + 'services/' + componentId + '/attributes')
261 return new Array<AttributeBEModel>();
263 return CommonUtils.initAttributes(res);
267 updateServiceProperties(componentId: string, properties: PropertyBEModel[]) {
268 return this.http.put<any>( this.baseUrl + 'services/' + componentId + '/properties', properties)
271 return _.map(resJson,
272 (resValue: PropertyBEModel) => new PropertyBEModel(resValue));
276 updateServiceAttributes(componentId: string, attributes: AttributeBEModel[]) {
277 return this.http.put<any>( this.baseUrl + 'services/' + componentId + '/attributes', attributes)
280 return _.map(resJson,
281 (resValue: AttributeBEModel) => new AttributeBEModel(resValue));
285 deleteServiceProperty(componentId: string, property: PropertyBEModel): Observable<string> {
286 return this.http.delete(this.baseUrl + 'services/' + componentId + '/properties/' + property.uniqueId )
287 .map((res: Response) => {
288 return property.uniqueId;
292 createServiceInput(componentId: string, inputModel: InputBEModel): Observable<InputBEModel> {
293 const serverObject = {};
294 serverObject[inputModel.name] = inputModel;
295 return this.http.post<InputBEModel>(this.baseUrl + 'services/' + componentId + '/create/input', serverObject)
297 const input: InputBEModel = new InputBEModel(res);
302 deleteServiceAttribute(componentId: string, attribute: AttributeBEModel): Observable<string> {
303 return this.http.delete(this.baseUrl + 'services/' + componentId + '/attributes/' + attribute.uniqueId )
304 .map((res: Response) => {
305 return attribute.uniqueId;
309 getDependencies(componentType: string, componentId: string): Observable<IDependenciesServerResponse[]> {
310 return this.http.get<IDependenciesServerResponse[]>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/dependencies');
313 automatedUpgrade(componentType: string, componentId: string, componentsIdsToUpgrade: IAutomatedUpgradeRequestObj[]): Observable<AutomatedUpgradeGenericResponse> {
314 return this.http.post<AutomatedUpgradeGenericResponse>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/automatedupgrade', componentsIdsToUpgrade);
317 updateComponentInstance(componentMetaDataId: string, componentType: string, componentInstance:ComponentInstance): Observable<ComponentInstance> {
318 return this.http.post<ComponentInstance>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/resourceInstance/' + componentInstance.uniqueId, componentInstance);
321 updateMultipleComponentInstances(componentId: string, componentType: string, instances: ComponentInstance[]): Observable<ComponentInstance[]> {
322 return this.http.post<ComponentInstance[]>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/resourceInstance/multipleComponentInstance', instances)
324 return CommonUtils.initComponentInstances(res);
328 createRelation(componentId: string, componentType: string, link: RelationshipModel): Observable<RelationshipModel> {
329 return this.http.post<RelationshipModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/resourceInstance/associate', link)
331 return new RelationshipModel(res);
335 deleteRelation(componentId: string, componentType: string, link: RelationshipModel): Observable<RelationshipModel> {
336 return this.http.put<RelationshipModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/resourceInstance/dissociate', link)
338 return new RelationshipModel(res);
342 createComponentInstance(componentType: string, componentId: string, componentInstance: ComponentInstance): Observable<ComponentInstance> {
343 return this.http.post<ComponentInstance>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/resourceInstance', componentInstance)
345 return new ComponentInstance(res);
349 deleteComponentInstance(componentType: string, componentId: string, componentInstanceId: string): Observable<ComponentInstance> {
350 return this.http.delete<ComponentInstance>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/resourceInstance/' + componentInstanceId)
352 return new ComponentInstance(res);
356 fetchRelation(componentType: string, componentId: string, linkId: string): Observable<RelationshipModel> {
357 return this.http.get<RelationshipModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/relationId/' + linkId)
359 return new RelationshipModel(res);
363 addOrUpdateArtifact = (componentType: string, componentId: string, artifact: ArtifactModel): Observable<ArtifactModel> => {
364 let headerObj: HttpHeaders = new HttpHeaders();
365 if (artifact.payloadData) {
366 headerObj = headerObj.append('Content-MD5', HttpHelperService.getHeaderMd5(artifact));
369 let artifactID: string = '';
370 if (artifact.uniqueId) {
371 artifactID = '/' + artifact.uniqueId;
373 return this.http.post<ArtifactModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/artifacts' + artifactID, JSON.stringify(artifact), {headers: headerObj}).map(
374 (res) => new ArtifactModel(res)
378 deleteArtifact = (componentId: string, componentType: string, artifactId: string, artifactLabel: string): Observable<ArtifactModel> => {
379 return this.http.delete<ArtifactModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/artifacts/' + artifactId + '?operation=' + artifactLabel)
380 .map((res) => new ArtifactModel(res));
383 downloadArtifact = (componentType: string, componentId: string, artifactId: string): Observable<IFileDownload> => {
384 return this.http.get<IFileDownload>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/artifacts/' + artifactId);
387 // ------------------------------------------------ Properties API --------------------------------------------------//
388 addProperty = (componentType: string, componentId: string, property: PropertyModel):Observable<PropertyModel> => {
389 return this.http.post<PropertyModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/properties', property.convertToServerObject())
391 return new PropertyModel(response);
395 updateProperty = (componentType: string, componentId: string, property: PropertyModel): Observable<PropertyModel> => {
396 var propertiesList:PropertyBEModel[] = [property];
397 return this.http.put<PropertyModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/properties', propertiesList)
399 return new PropertyModel(response[Object.keys(response)[0]]);
403 deleteProperty = (componentType: string, componentId: string, propertyId: string): Observable<PropertyModel> => {
404 return this.http.delete<PropertyModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/properties/' + propertyId);
407 // ------------------------------------------------ Attributes API --------------------------------------------------//
408 addAttribute = (componentType: string, componentId: string, attribute: AttributeModel): Observable<AttributeModel> => {
409 return this.http.post<AttributeModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/attributes', attribute.convertToServerObject())
411 return new AttributeModel(response);
415 updateAttribute = (componentType: string, componentId: string, attribute: AttributeModel): Observable<AttributeModel> => {
416 const payload = attribute.convertToServerObject();
418 return this.http.put<AttributeModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/attributes/' + attribute.uniqueId, payload)
420 return new AttributeModel(response);
425 addAttributeAsync = async (componentType: string, componentId: string, attribute: AttributeModel): Promise<AttributeModel> => {
426 return this.addAttribute(componentType, componentId, attribute).toPromise();
429 updateAttributeAsync = async (componentType: string, componentId: string, attribute: AttributeModel): Promise<AttributeModel> => {
430 return this.updateAttribute(componentType, componentId, attribute).toPromise();
433 deleteAttributeAsync = async (componentType: string, componentId: string, attribute: AttributeModel): Promise<any> => {
434 return this.http.delete<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/attributes/' + attribute.uniqueId, {}).toPromise();
437 getArtifactsByType(componentType: string, componentId: string, artifactsType: ArtifactGroupType) {
438 return this.getComponentDataByFieldsName(componentType, componentId, [this.convertArtifactTypeToUrl(artifactsType)]);
441 getServiceConsumptionData(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
442 return this.getComponentDataByFieldsName(componentType, componentId, [
443 // COMPONENT_FIELDS.COMPONENT_INSTANCES_INTERFACES,
444 COMPONENT_FIELDS.COMPONENT_INSTANCES_PROPERTIES,
445 // COMPONENT_FIELDS.COMPONENT_INSTANCES_INPUTS,
446 COMPONENT_FIELDS.COMPONENT_INPUTS,
447 COMPONENT_FIELDS.COMPONENT_INSTANCES,
448 COMPONENT_FIELDS.COMPONENT_CAPABILITIES
452 getServiceConsumptionInputs(componentMetaDataId: string, serviceInstanceId: string, interfaceId: string, operation: OperationModel): Observable<ConsumptionInput[]> {
453 return this.http.get<ConsumptionInput[]>
454 (this.baseUrl + 'services/' + componentMetaDataId + '/consumption/' + serviceInstanceId + '/interfaces/' + interfaceId + '/operations/' + operation.uniqueId + '/inputs');
457 createOrUpdateServiceConsumptionInputs(componentMetaDataId: string, serviceInstanceId: string, consumptionInputsList: Array<{[id: string]: ConsumptionInput[]}>): Observable<any> {
458 return this.http.post(this.baseUrl + 'services/' + componentMetaDataId + '/consumption/' + serviceInstanceId, consumptionInputsList);
461 getServiceFilterConstraints(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
462 return this.getComponentDataByFieldsName(componentType, componentId, [SERVICE_FIELDS.NODE_FILTER]);
465 getSubstitutionFilterConstraints(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
466 return this.getComponentDataByFieldsName(componentType, componentId, [SERVICE_FIELDS.SUBSTITUTION_FILTER]);
469 getComponentInstanceProperties(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
470 return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_INSTANCES_PROPERTIES]);
473 getComponentInstanceCapabilityProperties(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
474 return this.getComponentDataByFieldsName(componentType, componentId,
475 [COMPONENT_FIELDS.COMPONENT_CAPABILITIES, COMPONENT_FIELDS.COMPONENT_CAPABILITIES_PROPERTIES]);
478 createServiceFilterConstraints(componentMetaDataId: string, componentInstanceId: string, constraint: ConstraintObject, componentType: string, constraintType: string): Observable<any> {
479 return this.http.post<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/componentInstance/' + componentInstanceId + '/' + constraintType + '/nodeFilter', constraint);
482 createServiceFilterCapabilitiesConstraints(componentMetaDataId: string, componentInstanceId: string, constraint: CapabilitiesConstraintObject, componentType: string, constraintType: string): Observable<any> {
483 return this.http.post<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/componentInstance/' + componentInstanceId + '/' + constraintType + '/nodeFilter', constraint);
486 updateServiceFilterConstraints(componentMetaDataId: string, componentInstanceId: string, constraints: ConstraintObject, componentType: string, constraintType: string, constraintIndex: number):Observable<any>{
487 return this.http.put<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/componentInstance/' + componentInstanceId + '/' + constraintType + '/' + constraintIndex + '/nodeFilter', constraints)
490 updateServiceFilterCapabilitiesConstraint(componentMetaDataId: string, componentInstanceId: string, constraints: CapabilitiesConstraintObject, componentType: string, constraintType: string, constraintIndex: number):Observable<any>{
491 return this.http.put<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/componentInstance/' + componentInstanceId + '/' + constraintType + '/' + constraintIndex + '/nodeFilter', constraints)
494 deleteServiceFilterConstraints(componentMetaDataId: string, componentInstanceId: string, constraintIndex: number, componentType: string, constraintType: string): Observable<any>{
495 return this.http.delete<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/componentInstance/' + componentInstanceId + '/' + constraintType + '/' + constraintIndex + '/nodeFilter')
498 getComponentPropertiesAndInputsForSubstitutionFilter(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
499 return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_PROPERTIES, COMPONENT_FIELDS.COMPONENT_INPUTS]);
502 createSubstitutionFilterConstraints(componentMetaDataId: string, constraint: ConstraintObject, componentType: string, constraintType: string): Observable<any> {
503 return this.http.post<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/substitutionFilter/' + constraintType, constraint);
506 updateSubstitutionFilterConstraints(componentMetaDataId: string, constraint: ConstraintObject[], componentType: string, constraintType: string): Observable<any>{
507 return this.http.put<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/substitutionFilter/' + constraintType, constraint);
510 deleteSubstitutionFilterConstraints(componentMetaDataId: string, constraintIndex: number, componentType: string, constraintType: string): Observable<any>{
511 return this.http.delete<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/substitutionFilter/' + constraintType + "/" + constraintIndex)
514 deletePolicy(component: Component, policy: PolicyInstance): Observable<PolicyInstance> {
515 return this.http.put<PolicyInstance>(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/policies/' + policy.uniqueId + '/undeclare', policy)
518 createListInput(component: Component, input: any, isSelf: boolean): Observable<any> {
521 // change componentInstanceProperties -> serviceProperties
523 componentInstInputsMap: {
524 serviceProperties: input.componentInstInputsMap.componentInstanceProperties
526 listInput: input.listInput
531 return this.http.post<any>(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/create/listInput', inputs);
534 createPolicy(component: Component, policiesToCreate: InstancePropertiesAPIMap, isSelf: boolean): Observable<any> {
537 // tslint:disable-next-line:object-literal-key-quotes
538 {'componentPropertiesToPolicies': {
539 ...policiesToCreate.componentInstanceProperties
542 // tslint:disable-next-line:object-literal-key-quotes
543 {'componentInstancePropertiesToPolicies': {
544 ...policiesToCreate.componentInstanceProperties
547 return this.http.post(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/create/policies', policiesList);
550 protected getComponentDataByFieldsName(componentType: string, componentId: string, fields: string[]): Observable<ComponentGenericResponse> {
551 let params: HttpParams = new HttpParams();
552 _.forEach(fields, (field: string): void => {
553 params = params.append(API_QUERY_PARAMS.INCLUDE, field);
555 // tslint:disable-next-line:object-literal-shorthand
556 return this.http.get<ComponentGenericResponse>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/filteredDataByParams', {params: params})
558 return componentType === ComponentType.SERVICE ? new ServiceGenericResponse().deserialize(res) :
559 new ComponentGenericResponse().deserialize(res);
563 private getServerTypeUrl = (componentType: string): string => {
564 switch (componentType) {
565 case ComponentType.SERVICE:
566 case ComponentType.SERVICE_PROXY:
567 case ComponentType.SERVICE_SUBSTITUTION:
568 return ServerTypeUrl.SERVICES;
570 return ServerTypeUrl.RESOURCES;
574 private convertArtifactTypeToUrl = (artifactType: ArtifactGroupType): string => {
575 switch (artifactType) {
576 case ArtifactGroupType.TOSCA:
577 return COMPONENT_FIELDS.COMPONENT_TOSCA_ARTIFACTS;
578 case ArtifactGroupType.INFORMATION:
579 return COMPONENT_FIELDS.COMPONENT_INFORMATIONAL_ARTIFACTS;
580 case ArtifactGroupType.DEPLOYMENT:
581 return COMPONENT_FIELDS.COMPONENT_DEPLOYMENT_ARTIFACTS;
582 case ArtifactGroupType.SERVICE_API:
583 return COMPONENT_FIELDS.SERVICE_API_ARTIFACT;
587 // createCapability(component: Component, capabilityData: Capability): Observable<Capability[]> {
588 createCapability(type: string, uniqueId: string, capabilityData: Capability): Observable<Capability[]> {
591 [capabilityData.type]: [capabilityData]
594 return this.http.post<any>(this.baseUrl + type + uniqueId + '/capabilities', capBEObj);
597 updateCapability(type: string, uniqueId: string, capabilityData: Capability): Observable<Capability[]> {
600 [capabilityData.type]: [capabilityData]
603 return this.http.put<any>(this.baseUrl + type + uniqueId + '/capabilities', capBEObj);
606 deleteCapability(component: Component, capId: string): Observable<Capability> {
607 return this.http.delete<Capability>(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/capabilities/' + capId);
610 createRequirement(type: string, uniqueId: string, requirementData: Requirement): Observable<any> {
613 [requirementData.capability]: [requirementData]
616 return this.http.post(this.baseUrl + type + uniqueId + '/requirements', reqBEObj);
619 updateRequirement(type: string, uniqueId: string, requirementData: Requirement): Observable<any> {
622 [requirementData.capability]: [requirementData]
625 return this.http.put(this.baseUrl + type + uniqueId + '/requirements', reqBEObj);
628 deleteRequirement(component: Component, reqId: string): Observable<Requirement> {
629 return this.http.delete<Requirement>(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/requirements/' + reqId);
632 getDirectiveList(): Observable<string[]> {
633 return this.http.get<ListDirectiveResponse>(this.baseUrl + "directives")
634 .pipe(map(response => response.directives));
637 updateComponentInstanceInterfaceOperation(componentMetaDataId: string,
638 componentMetaDataType: string,
639 componentInstanceId: string,
640 operation: InterfaceOperationModel): Observable<ComponentInstance> {
641 const operationList = {
643 [operation.interfaceType]: {
644 type: operation.interfaceType,
646 [operation.name]: new BEInterfaceOperationModel(operation)
651 return this.http.put<ComponentInstance>(this.baseUrl + this
652 .getServerTypeUrl(componentMetaDataType) + componentMetaDataId + '/componentInstance/' + componentInstanceId + '/interfaceOperation', operationList);