catalog-ui/src/app/ng2/services/component-services/topology-template.service.ts

   1 /**
   2  * Created by ob0695 on 6/26/2018.
   3  */
   4 /*-
   5  * ============LICENSE_START=======================================================
   6  * SDC
   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
  13  *
  14  *      http://www.apache.org/licenses/LICENSE-2.0
  15  *
  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=========================================================
  22  */
  23
  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';
  29 import {
  30     Component,
  31     InputBEModel,
  32     InstancePropertiesAPIMap,
  33     FilterPropertiesAssignmentData,
  34     ArtifactModel,
  35     PropertyModel,
  36     IFileDownload,
  37     AttributeModel,
  38     Capability, Requirement, BEOperationModel, InterfaceModel
  39 } from "app/models";
  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";
  55 import {
  56     Component as TopologyTemplate,
  57     FullComponentInstance,
  58     Service,
  59     OperationModel,
  60 } from 'app/models';
  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";
  68 import {
  69     BEInterfaceOperationModel,
  70     ComponentInstanceInterfaceModel,
  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";
  75
  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*/
  78
  79 @Injectable()
  80 export class TopologyTemplateService {
  81
  82     protected baseUrl;
  83
  84     constructor(protected http: HttpClient, @Inject(SdcConfigToken) sdcConfig: ISdcConfig) {
  85         this.baseUrl = sdcConfig.api.root + sdcConfig.api.component_api_root;
  86     }
  87
  88     getFullComponent(componentType: string, uniqueId: string): Observable<Component> {
  89         return this.http.get<Component>(this.baseUrl + this.getServerTypeUrl(componentType) + uniqueId);
  90     }
  91
  92     getComponentMetadata(uniqueId: string, type: string): Observable<ComponentGenericResponse> {
  93         return this.getComponentDataByFieldsName(type, uniqueId, [COMPONENT_FIELDS.COMPONENT_METADATA]);
  94     }
  95
  96     getComponentInstanceAttributesAndProperties(uniqueId: string, type: string): Observable<ComponentGenericResponse> {
  97         return this.getComponentDataByFieldsName(type, uniqueId, [COMPONENT_FIELDS.COMPONENT_INSTANCES_PROPERTIES, COMPONENT_FIELDS.COMPONENT_INSTANCES_ATTRIBUTES]);
  98     }
  99
 100     async getComponentAttributes(componentType: string, componentId: string): Promise<ComponentGenericResponse> {
 101         return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_ATTRIBUTES]).toPromise();
 102     }
 103
 104     getComponentCompositionData(componentUniqueId: string, componentType: string): Observable<ComponentGenericResponse> {
 105         const params: string[] = [COMPONENT_FIELDS.COMPONENT_INSTANCES_RELATION, COMPONENT_FIELDS.COMPONENT_INSTANCES,
 106             COMPONENT_FIELDS.COMPONENT_NON_EXCLUDED_POLICIES, COMPONENT_FIELDS.COMPONENT_NON_EXCLUDED_GROUPS];
 107         if (componentType === ComponentType.SERVICE) {
 108             params.push(COMPONENT_FIELDS.FORWARDING_PATHS);
 109         }
 110         return this.getComponentDataByFieldsName(componentType, componentUniqueId, params);
 111     }
 112
 113     getComponentResourcePropertiesData(component: Component): Observable<ComponentGenericResponse> {
 114         return this.getComponentDataByFieldsName(component.componentType, component.uniqueId,
 115             [COMPONENT_FIELDS.COMPONENT_INSTANCES, COMPONENT_FIELDS.COMPONENT_POLICIES, COMPONENT_FIELDS.COMPONENT_NON_EXCLUDED_GROUPS]);
 116     }
 117
 118     getComponentInstances(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
 119         return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_INSTANCES]);
 120     }
 121
 122     getComponentInputs(component: Component): Observable<ComponentGenericResponse> {
 123         return this.getComponentDataByFieldsName(component.componentType, component.uniqueId, [COMPONENT_FIELDS.COMPONENT_INPUTS]);
 124     }
 125
 126     getComponentInputsValues(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
 127         return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_INPUTS]);
 128     }
 129
 130     getComponentInputsWithProperties(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
 131         return this.getComponentDataByFieldsName(componentType, componentId,
 132             [COMPONENT_FIELDS.COMPONENT_INPUTS, COMPONENT_FIELDS.COMPONENT_INSTANCES, COMPONENT_FIELDS.COMPONENT_INSTANCES_PROPERTIES, COMPONENT_FIELDS.COMPONENT_PROPERTIES]);
 133     }
 134
 135     getComponentOutputsWithAttributes(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
 136         return this.getComponentDataByFieldsName(componentType, componentId,
 137             [COMPONENT_FIELDS.COMPONENT_OUTPUTS, COMPONENT_FIELDS.COMPONENT_INSTANCES, COMPONENT_FIELDS.COMPONENT_INSTANCES_ATTRIBUTES, COMPONENT_FIELDS.COMPONENT_ATTRIBUTES,COMPONENT_FIELDS.COMPONENT_INSTANCES_OUTPUTS]);
 138     }
 139
 140     getComponentDeploymentArtifacts(component: Component): Observable<ComponentGenericResponse> {
 141         return this.getComponentDataByFieldsName(component.componentType, component.uniqueId, [COMPONENT_FIELDS.COMPONENT_DEPLOYMENT_ARTIFACTS]);
 142     }
 143
 144     getComponentInformationalArtifacts(component: Component): Observable<ComponentGenericResponse> {
 145         return this.getComponentDataByFieldsName(component.componentType, component.uniqueId, [COMPONENT_FIELDS.COMPONENT_INFORMATIONAL_ARTIFACTS]);
 146     }
 147
 148     getComponentInformationalArtifactsAndInstances(component: Component): Observable<ComponentGenericResponse> {
 149         return this.getComponentDataByFieldsName(component.componentType, component.uniqueId, [COMPONENT_FIELDS.COMPONENT_INFORMATIONAL_ARTIFACTS, COMPONENT_FIELDS.COMPONENT_INSTANCES]);
 150     }
 151
 152     getComponentToscaArtifacts(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
 153         return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_TOSCA_ARTIFACTS]);
 154     }
 155
 156     getComponentProperties(component: Component): Observable<ComponentGenericResponse> {
 157         return this.getComponentDataByFieldsName(component.componentType, component.uniqueId, [COMPONENT_FIELDS.COMPONENT_PROPERTIES]);
 158     }
 159
 160     getCapabilitiesAndRequirements(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
 161         return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_REQUIREMENTS, COMPONENT_FIELDS.COMPONENT_CAPABILITIES]);
 162     }
 163
 164     getRequirementsAndCapabilitiesWithProperties(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
 165         return this.getComponentDataByFieldsName(componentType, componentId,
 166             [COMPONENT_FIELDS.COMPONENT_REQUIREMENTS, COMPONENT_FIELDS.COMPONENT_CAPABILITIES, COMPONENT_FIELDS.COMPONENT_CAPABILITIES_PROPERTIES]);
 167     }
 168
 169     getDeploymentGraphData(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
 170         return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_INSTANCES_RELATION, COMPONENT_FIELDS.COMPONENT_INSTANCES, COMPONENT_FIELDS.COMPONENT_GROUPS]);
 171     }
 172
 173     createInput(component: Component, inputsToCreate: InstancePropertiesAPIMap, isSelf: boolean): Observable<any> {
 174         const inputs = isSelf ? { serviceProperties: inputsToCreate.componentInstanceProperties } : inputsToCreate;
 175         return this.http.post(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/create/inputs', inputs);
 176     }
 177
 178     createOutput(component: Component, outputsToCreate: InstanceAttributesAPIMap, isSelf: boolean): Observable<any> {
 179         const outputs = isSelf ? { serviceProperties: outputsToCreate.componentInstanceAttributes } : outputsToCreate;
 180         return this.http.post(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/create/outputs', outputs);
 181     }
 182
 183     restoreComponent(componentType: string, componentId: string) {
 184         return this.http.post(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/restore', {});
 185     }
 186
 187     archiveComponent(componentType: string, componentId: string) {
 188         return this.http.post(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/archive', {});
 189     }
 190
 191     deleteInput(component: Component, input: InputBEModel): Observable<InputBEModel> {
 192         return this.http.delete<InputBEModel>(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/delete/' + input.uniqueId + '/input')
 193             .map((res) => {
 194                 return new InputBEModel(res);
 195             });
 196     }
 197
 198     updateComponentInputs(component: Component, inputs: InputBEModel[]): Observable<InputBEModel[]> {
 199         return this.http.post<InputBEModel[]>(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/update/inputs', inputs)
 200             .map((res) => {
 201                 return res.map((input) => new InputBEModel(input));
 202             });
 203     }
 204
 205     filterComponentInstanceProperties(component: Component, filterData: FilterPropertiesAssignmentData): Observable<InstanceBePropertiesMap> {// instance-property-be-map
 206         let params: HttpParams = new HttpParams();
 207         _.forEach(filterData.selectedTypes, (type: string) => {
 208             params = params.append('resourceType', type);
 209         });
 210
 211         // tslint:disable-next-line:object-literal-shorthand
 212         return this.http.get<InstanceBePropertiesMap>(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/filteredproperties/' + filterData.propertyName, {params: params});
 213     }
 214
 215      createServiceProperty(componentId: string, propertyModel: PropertyBEModel): Observable<PropertyBEModel> {
 216         const serverObject = {};
 217         serverObject[propertyModel.name] = propertyModel;
 218         return this.http.post<PropertyBEModel>(this.baseUrl + 'services/' + componentId + '/properties', serverObject)
 219             .map((res) => {
 220                 const property: PropertyBEModel = new PropertyBEModel(res);
 221                 return property;
 222             });
 223     }
 224
 225     createServiceAttribute(componentId: string, attributeModel: AttributeBEModel): Observable<AttributeBEModel> {
 226         const serverObject = {};
 227         serverObject[attributeModel.name] = attributeModel;
 228         return this.http.post<AttributeBEModel>(this.baseUrl + 'services/' + componentId + '/attributes', serverObject)
 229             .map((res) => {
 230                 const attribute: AttributeBEModel = new AttributeBEModel(res);
 231                 return attribute;
 232             });
 233     }
 234
 235     getServiceProperties(componentId: string): Observable<PropertyBEModel[]> {
 236         return this.http.get<any>(this.baseUrl + 'services/' + componentId + '/properties')
 237             .map((res) => {
 238                 if (!res) {
 239                     return new Array<PropertyBEModel>();
 240                 }
 241                 return CommonUtils.initBeProperties(res);
 242             });
 243     }
 244
 245     getServiceAttributes(componentId: string): Observable<AttributeBEModel[]> {
 246         return this.http.get<any>(this.baseUrl + 'services/' + componentId + '/attributes')
 247             .map((res) => {
 248                 if (!res) {
 249                     return new Array<AttributeBEModel>();
 250                 }
 251                 return CommonUtils.initAttributes(res);
 252             });
 253     }
 254
 255     updateServiceProperties(componentId: string, properties: PropertyBEModel[]) {
 256         return this.http.put<any>( this.baseUrl + 'services/' + componentId + '/properties', properties)
 257             .map((res) => {
 258                 const resJson = res;
 259                 return _.map(resJson,
 260                     (resValue: PropertyBEModel) => new PropertyBEModel(resValue));
 261             });
 262     }
 263
 264     updateServiceAttributes(componentId: string, attributes: AttributeBEModel[]) {
 265         return this.http.put<any>( this.baseUrl + 'services/' + componentId + '/attributes', attributes)
 266             .map((res) => {
 267                 const resJson = res;
 268                 return _.map(resJson,
 269                     (resValue: AttributeBEModel) => new AttributeBEModel(resValue));
 270             });
 271     }
 272
 273     deleteServiceProperty(componentId: string, property: PropertyBEModel): Observable<string> {
 274         return this.http.delete(this.baseUrl + 'services/' + componentId + '/properties/' + property.uniqueId )
 275             .map((res: Response) => {
 276                 return property.uniqueId;
 277             });
 278     }
 279
 280     createServiceInput(componentId: string, inputModel: InputBEModel): Observable<InputBEModel> {
 281         const serverObject = {};
 282         serverObject[inputModel.name] = inputModel;
 283         return this.http.post<InputBEModel>(this.baseUrl + 'services/' + componentId + '/create/input', serverObject)
 284             .map((res) => {
 285                 const input: InputBEModel = new InputBEModel(res);
 286                 return input;
 287             });
 288     }
 289
 290     deleteServiceAttribute(componentId: string, attribute: AttributeBEModel): Observable<string> {
 291         return this.http.delete(this.baseUrl + 'services/' + componentId + '/attributes/' + attribute.uniqueId )
 292             .map((res: Response) => {
 293                 return attribute.uniqueId;
 294             });
 295     }
 296
 297     getDependencies(componentType: string, componentId: string): Observable<IDependenciesServerResponse[]> {
 298         return this.http.get<IDependenciesServerResponse[]>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/dependencies');
 299     }
 300
 301     automatedUpgrade(componentType: string, componentId: string, componentsIdsToUpgrade: IAutomatedUpgradeRequestObj[]): Observable<AutomatedUpgradeGenericResponse> {
 302         return this.http.post<AutomatedUpgradeGenericResponse>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/automatedupgrade', componentsIdsToUpgrade);
 303     }
 304
 305     updateComponentInstance(componentMetaDataId: string, componentType: string, componentInstance:ComponentInstance): Observable<ComponentInstance> {
 306         return this.http.post<ComponentInstance>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/resourceInstance/' + componentInstance.uniqueId, componentInstance);
 307     }
 308
 309     updateMultipleComponentInstances(componentId: string, componentType: string, instances: ComponentInstance[]): Observable<ComponentInstance[]> {
 310         return this.http.post<ComponentInstance[]>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/resourceInstance/multipleComponentInstance', instances)
 311             .map((res) => {
 312                 return CommonUtils.initComponentInstances(res);
 313             });
 314     }
 315
 316     createRelation(componentId: string, componentType: string, link: RelationshipModel): Observable<RelationshipModel> {
 317         return this.http.post<RelationshipModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/resourceInstance/associate', link)
 318             .map((res) => {
 319                 return new RelationshipModel(res);
 320             });
 321     }
 322
 323     deleteRelation(componentId: string, componentType: string, link: RelationshipModel): Observable<RelationshipModel> {
 324         return this.http.put<RelationshipModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/resourceInstance/dissociate', link)
 325             .map((res) => {
 326                 return new RelationshipModel(res);
 327             });
 328     }
 329
 330     createComponentInstance(componentType: string, componentId: string, componentInstance: ComponentInstance): Observable<ComponentInstance> {
 331         return this.http.post<ComponentInstance>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/resourceInstance', componentInstance)
 332             .map((res) => {
 333                 return new ComponentInstance(res);
 334             });
 335     }
 336
 337     deleteComponentInstance(componentType: string, componentId: string, componentInstanceId: string): Observable<ComponentInstance> {
 338         return this.http.delete<ComponentInstance>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/resourceInstance/' + componentInstanceId)
 339             .map((res) => {
 340                 return new ComponentInstance(res);
 341             });
 342     }
 343
 344     fetchRelation(componentType: string, componentId: string, linkId: string): Observable<RelationshipModel> {
 345         return this.http.get<RelationshipModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/relationId/' + linkId)
 346             .map((res) => {
 347                 return new RelationshipModel(res);
 348             });
 349     }
 350
 351     addOrUpdateArtifact = (componentType: string, componentId: string, artifact: ArtifactModel): Observable<ArtifactModel> => {
 352         let headerObj: HttpHeaders = new HttpHeaders();
 353         if (artifact.payloadData) {
 354             headerObj = headerObj.append('Content-MD5', HttpHelperService.getHeaderMd5(artifact));
 355         }
 356
 357         let artifactID: string = '';
 358         if (artifact.uniqueId) {
 359             artifactID = '/' + artifact.uniqueId;
 360         }
 361         return this.http.post<ArtifactModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/artifacts' + artifactID, JSON.stringify(artifact), {headers: headerObj}).map(
 362             (res) => new ArtifactModel(res)
 363         );
 364     }
 365
 366     deleteArtifact = (componentId: string, componentType: string, artifactId: string, artifactLabel: string): Observable<ArtifactModel> => {
 367         return this.http.delete<ArtifactModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/artifacts/' + artifactId + '?operation=' + artifactLabel)
 368             .map((res) => new ArtifactModel(res));
 369     }
 370
 371     downloadArtifact = (componentType: string, componentId: string, artifactId: string): Observable<IFileDownload> => {
 372         return this.http.get<IFileDownload>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/artifacts/' + artifactId);
 373     }
 374
 375     // ------------------------------------------------ Properties API --------------------------------------------------//
 376     addProperty = (componentType: string, componentId: string, property: PropertyModel):Observable<PropertyModel> => {
 377         return this.http.post<PropertyModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/properties', property.convertToServerObject())
 378         .map((response) => {
 379             return new PropertyModel(response);
 380         });
 381     }
 382
 383     updateProperty = (componentType: string, componentId: string, property: PropertyModel): Observable<PropertyModel> => {
 384         var propertiesList:PropertyBEModel[]  = [property];
 385         return this.http.put<PropertyModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/properties', propertiesList)
 386         .map((response) => {
 387             return new PropertyModel(response[Object.keys(response)[0]]);
 388         });
 389     }
 390
 391     deleteProperty = (componentType: string, componentId: string, propertyId: string): Observable<PropertyModel> => {
 392         return this.http.delete<PropertyModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/properties/' + propertyId);
 393     }
 394
 395     // ------------------------------------------------ Attributes API --------------------------------------------------//
 396     addAttribute = (componentType: string, componentId: string, attribute: AttributeModel): Observable<AttributeModel> => {
 397         return this.http.post<AttributeModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/attributes', attribute.convertToServerObject())
 398             .map((response) => {
 399                 return new AttributeModel(response);
 400             });
 401     }
 402
 403     updateAttribute = (componentType: string, componentId: string, attribute: AttributeModel): Observable<AttributeModel> => {
 404         const payload = attribute.convertToServerObject();
 405
 406         return this.http.put<AttributeModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/attributes/' + attribute.uniqueId, payload)
 407             .map((response) => {
 408                 return new AttributeModel(response);
 409             });
 410     }
 411
 412     // Async Methods
 413     addAttributeAsync = async (componentType: string, componentId: string, attribute: AttributeModel): Promise<AttributeModel> => {
 414         return this.addAttribute(componentType, componentId, attribute).toPromise();
 415     }
 416
 417     updateAttributeAsync = async (componentType: string, componentId: string, attribute: AttributeModel): Promise<AttributeModel> => {
 418         return this.updateAttribute(componentType, componentId, attribute).toPromise();
 419     }
 420
 421     deleteAttributeAsync = async (componentType: string, componentId: string, attribute: AttributeModel): Promise<any> => {
 422         return this.http.delete<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/attributes/' + attribute.uniqueId, {}).toPromise();
 423     }
 424
 425     getArtifactsByType(componentType: string, componentId: string, artifactsType: ArtifactGroupType) {
 426         return this.getComponentDataByFieldsName(componentType, componentId, [this.convertArtifactTypeToUrl(artifactsType)]);
 427     }
 428
 429     getServiceConsumptionData(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
 430         return this.getComponentDataByFieldsName(componentType, componentId, [
 431             // COMPONENT_FIELDS.COMPONENT_INSTANCES_INTERFACES,
 432             COMPONENT_FIELDS.COMPONENT_INSTANCES_PROPERTIES,
 433             // COMPONENT_FIELDS.COMPONENT_INSTANCES_INPUTS,
 434             COMPONENT_FIELDS.COMPONENT_INPUTS,
 435             COMPONENT_FIELDS.COMPONENT_INSTANCES,
 436             COMPONENT_FIELDS.COMPONENT_CAPABILITIES
 437         ]);
 438     }
 439
 440     getServiceConsumptionInputs(componentMetaDataId: string, serviceInstanceId: string, interfaceId: string, operation: OperationModel): Observable<ConsumptionInput[]> {
 441         return this.http.get<ConsumptionInput[]>
 442         (this.baseUrl + 'services/' + componentMetaDataId + '/consumption/' + serviceInstanceId + '/interfaces/' + interfaceId + '/operations/' + operation.uniqueId + '/inputs');
 443     }
 444
 445     createOrUpdateServiceConsumptionInputs(componentMetaDataId: string, serviceInstanceId: string, consumptionInputsList: Array<{[id: string]: ConsumptionInput[]}>): Observable<any> {
 446         return this.http.post(this.baseUrl + 'services/' + componentMetaDataId + '/consumption/' + serviceInstanceId, consumptionInputsList);
 447     }
 448
 449     getServiceFilterConstraints(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
 450         return this.getComponentDataByFieldsName(componentType, componentId, [SERVICE_FIELDS.NODE_FILTER]);
 451     }
 452
 453     getSubstitutionFilterConstraints(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
 454         return this.getComponentDataByFieldsName(componentType, componentId, [SERVICE_FIELDS.SUBSTITUTION_FILTER]);
 455     }
 456
 457     getComponentInstanceProperties(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
 458         return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_INSTANCES_PROPERTIES]);
 459     }
 460
 461     getComponentInstanceCapabilityProperties(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
 462         return this.getComponentDataByFieldsName(componentType, componentId,
 463             [COMPONENT_FIELDS.COMPONENT_CAPABILITIES, COMPONENT_FIELDS.COMPONENT_CAPABILITIES_PROPERTIES]);
 464     }
 465
 466     createServiceFilterConstraints(componentMetaDataId: string, componentInstanceId: string, constraint: ConstraintObject, componentType: string, constraintType: string): Observable<any> {
 467         return this.http.post<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/componentInstance/' + componentInstanceId + '/' + constraintType + '/nodeFilter', constraint);
 468     }
 469
 470     createServiceFilterCapabilitiesConstraints(componentMetaDataId: string, componentInstanceId: string, constraint: CapabilitiesConstraintObject, componentType: string, constraintType: string): Observable<any> {
 471         return this.http.post<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/componentInstance/' + componentInstanceId + '/' + constraintType + '/nodeFilter', constraint);
 472     }
 473
 474     updateServiceFilterConstraints(componentMetaDataId: string, componentInstanceId: string, constraints: ConstraintObject, componentType: string, constraintType: string, constraintIndex: number):Observable<any>{
 475         return this.http.put<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/componentInstance/' + componentInstanceId + '/' + constraintType + '/' + constraintIndex + '/nodeFilter', constraints)
 476     }
 477
 478     updateServiceFilterCapabilitiesConstraint(componentMetaDataId: string, componentInstanceId: string, constraints: CapabilitiesConstraintObject, componentType: string, constraintType: string, constraintIndex: number):Observable<any>{
 479         return this.http.put<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/componentInstance/' + componentInstanceId + '/' + constraintType + '/' + constraintIndex + '/nodeFilter', constraints)
 480     }
 481
 482     deleteServiceFilterConstraints(componentMetaDataId: string, componentInstanceId: string, constraintIndex: number, componentType: string, constraintType: string): Observable<any>{
 483         return this.http.delete<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/componentInstance/' + componentInstanceId + '/' + constraintType + '/' + constraintIndex + '/nodeFilter')
 484     }
 485
 486     getComponentPropertiesAndInputsForSubstitutionFilter(componentType: string, componentId: string): Observable<ComponentGenericResponse> {
 487         return this.getComponentDataByFieldsName(componentType, componentId, [COMPONENT_FIELDS.COMPONENT_PROPERTIES, COMPONENT_FIELDS.COMPONENT_INPUTS]);
 488     }
 489
 490     createSubstitutionFilterConstraints(componentMetaDataId: string, constraint: ConstraintObject, componentType: string, constraintType: string): Observable<any> {
 491         return this.http.post<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/substitutionFilter/' + constraintType, constraint);
 492     }
 493
 494     updateSubstitutionFilterConstraints(componentMetaDataId: string, constraint: ConstraintObject[], componentType: string, constraintType: string): Observable<any>{
 495         return this.http.put<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/substitutionFilter/' + constraintType, constraint);
 496     }
 497
 498     deleteSubstitutionFilterConstraints(componentMetaDataId: string, constraintIndex: number, componentType: string, constraintType: string): Observable<any>{
 499         return this.http.delete<any>(this.baseUrl + this.getServerTypeUrl(componentType) + componentMetaDataId + '/substitutionFilter/' + constraintType + "/" + constraintIndex)
 500     }
 501
 502     deletePolicy(component: Component, policy: PolicyInstance): Observable<PolicyInstance> {
 503         return this.http.put<PolicyInstance>(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/policies/' + policy.uniqueId + '/undeclare', policy)
 504     }
 505
 506     createListInput(component: Component, input: any, isSelf: boolean): Observable<any> {
 507         let inputs: any;
 508         if (isSelf) {
 509             // change componentInstanceProperties -> serviceProperties
 510             inputs = {
 511                 componentInstInputsMap: {
 512                     serviceProperties: input.componentInstInputsMap.componentInstanceProperties
 513                 },
 514                 listInput: input.listInput
 515             };
 516         } else {
 517             inputs = input;
 518         }
 519         return this.http.post<any>(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/create/listInput', inputs);
 520     }
 521
 522     createPolicy(component: Component, policiesToCreate: InstancePropertiesAPIMap, isSelf: boolean): Observable<any> {
 523         const policiesList =
 524             isSelf ?
 525                 // tslint:disable-next-line:object-literal-key-quotes
 526                 {'componentPropertiesToPolicies': {
 527                         ...policiesToCreate.componentInstanceProperties
 528                     }
 529                 } :
 530                 // tslint:disable-next-line:object-literal-key-quotes
 531                 {'componentInstancePropertiesToPolicies': {
 532                         ...policiesToCreate.componentInstanceProperties
 533                     }
 534                 };
 535         return this.http.post(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/create/policies', policiesList);
 536     }
 537
 538     protected getComponentDataByFieldsName(componentType: string, componentId: string, fields: string[]): Observable<ComponentGenericResponse> {
 539         let params: HttpParams = new HttpParams();
 540         _.forEach(fields, (field: string): void => {
 541             params = params.append(API_QUERY_PARAMS.INCLUDE, field);
 542         });
 543         // tslint:disable-next-line:object-literal-shorthand
 544         return this.http.get<ComponentGenericResponse>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/filteredDataByParams', {params: params})
 545             .map((res) => {
 546                 return componentType === ComponentType.SERVICE ? new ServiceGenericResponse().deserialize(res) :
 547                         new ComponentGenericResponse().deserialize(res);
 548             });
 549     }
 550
 551     private getServerTypeUrl = (componentType: string): string => {
 552         switch (componentType) {
 553             case ComponentType.SERVICE:
 554             case ComponentType.SERVICE_PROXY:
 555             case ComponentType.SERVICE_SUBSTITUTION:
 556                 return ServerTypeUrl.SERVICES;
 557             default:
 558                 return ServerTypeUrl.RESOURCES;
 559         }
 560     }
 561
 562     private convertArtifactTypeToUrl = (artifactType: ArtifactGroupType): string => {
 563         switch (artifactType) {
 564             case ArtifactGroupType.TOSCA:
 565                 return COMPONENT_FIELDS.COMPONENT_TOSCA_ARTIFACTS;
 566             case ArtifactGroupType.INFORMATION:
 567                 return COMPONENT_FIELDS.COMPONENT_INFORMATIONAL_ARTIFACTS;
 568             case ArtifactGroupType.DEPLOYMENT:
 569                 return COMPONENT_FIELDS.COMPONENT_DEPLOYMENT_ARTIFACTS;
 570             case ArtifactGroupType.SERVICE_API:
 571                 return COMPONENT_FIELDS.SERVICE_API_ARTIFACT;
 572         }
 573     }
 574
 575     // createCapability(component: Component, capabilityData: Capability): Observable<Capability[]> {
 576     createCapability(type: string, uniqueId: string, capabilityData: Capability): Observable<Capability[]> {
 577         let capBEObj = {
 578             'capabilities': {
 579                 [capabilityData.type]: [capabilityData]
 580             }
 581         };
 582         return this.http.post<any>(this.baseUrl + type + uniqueId + '/capabilities', capBEObj);
 583     }
 584
 585     updateCapability(type: string, uniqueId: string, capabilityData: Capability): Observable<Capability[]> {
 586         let capBEObj = {
 587             'capabilities': {
 588                 [capabilityData.type]: [capabilityData]
 589             }
 590         };
 591         return this.http.put<any>(this.baseUrl + type + uniqueId + '/capabilities', capBEObj);
 592     }
 593
 594     deleteCapability(component: Component, capId: string): Observable<Capability> {
 595         return this.http.delete<Capability>(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/capabilities/' + capId);
 596     }
 597
 598     createRequirement(type: string, uniqueId: string, requirementData: Requirement): Observable<any> {
 599         let reqBEObj = {
 600             'requirements': {
 601                 [requirementData.capability]: [requirementData]
 602             }
 603         };
 604         return this.http.post(this.baseUrl + type + uniqueId + '/requirements', reqBEObj);
 605     }
 606
 607     updateRequirement(type: string, uniqueId: string, requirementData: Requirement): Observable<any> {
 608         let reqBEObj = {
 609             'requirements': {
 610                 [requirementData.capability]: [requirementData]
 611             }
 612         };
 613         return this.http.put(this.baseUrl + type + uniqueId + '/requirements', reqBEObj);
 614     }
 615
 616     deleteRequirement(component: Component, reqId: string): Observable<Requirement> {
 617         return this.http.delete<Requirement>(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/requirements/' + reqId);
 618     }
 619
 620     getDirectiveList(): Observable<string[]> {
 621         return this.http.get<ListDirectiveResponse>(this.baseUrl + "directives")
 622         .pipe(map(response => response.directives));
 623     }
 624
 625     updateComponentInstanceInterfaceOperation(componentMetaDataId: string,
 626                                               componentMetaDataType: string,
 627                                               componentInstanceId: string,
 628                                               operation: InterfaceOperationModel): Observable<ComponentInstance> {
 629         const operationList = {
 630             interfaces: {
 631                 [operation.interfaceType]: {
 632                     type: operation.interfaceType,
 633                     operations: {
 634                         [operation.name]: new BEInterfaceOperationModel(operation)
 635                     }
 636                 }
 637             }
 638         };
 639         return this.http.put<ComponentInstance>(this.baseUrl + this
 640         .getServerTypeUrl(componentMetaDataType) + componentMetaDataId + '/componentInstance/' + componentInstanceId + '/interfaceOperation', operationList);
 641     }
 642
 643 }