catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogic.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.components.impl;
  22
  23 import java.util.ArrayList;
  24 import java.util.HashMap;
  25 import java.util.Iterator;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.Map.Entry;
  29 import java.util.Objects;
  30 import java.util.Optional;
  31 import java.util.UUID;
  32 import java.util.stream.Collectors;
  33
  34 import org.apache.commons.collections.CollectionUtils;
  35 import org.apache.commons.collections.MapUtils;
  36 import org.apache.commons.lang.StringUtils;
  37 import org.apache.commons.lang3.tuple.ImmutablePair;
  38 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  39 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
  40 import org.openecomp.sdc.be.dao.api.ActionStatus;
  41 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  42 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  43 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  44 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
  45 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  46 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
  47 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  48 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  49 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
  50 import org.openecomp.sdc.be.info.CreateAndAssotiateInfo;
  51 import org.openecomp.sdc.be.model.ArtifactDefinition;
  52 import org.openecomp.sdc.be.model.Component;
  53 import org.openecomp.sdc.be.model.ComponentInstance;
  54 import org.openecomp.sdc.be.model.ComponentInstanceInput;
  55 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  56 import org.openecomp.sdc.be.model.ComponentParametersView;
  57 import org.openecomp.sdc.be.model.DataTypeDefinition;
  58 import org.openecomp.sdc.be.model.GroupDefinition;
  59 import org.openecomp.sdc.be.model.GroupInstance;
  60 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  61 import org.openecomp.sdc.be.model.PropertyDefinition.PropertyNames;
  62 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  63 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  64 import org.openecomp.sdc.be.model.User;
  65 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  66 import org.openecomp.sdc.be.model.operations.api.IComponentInstanceOperation;
  67 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  68 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
  69 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  70 import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils;
  71 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
  72 import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
  73 import org.openecomp.sdc.be.resources.data.PropertyValueData;
  74 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  75 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  76 import org.openecomp.sdc.common.api.Constants;
  77 import org.openecomp.sdc.common.datastructure.Wrapper;
  78 import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
  79 import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum;
  80 import org.openecomp.sdc.common.util.ValidationUtils;
  81 import org.openecomp.sdc.exception.ResponseFormat;
  82 import org.slf4j.Logger;
  83 import org.slf4j.LoggerFactory;
  84 import org.springframework.beans.factory.annotation.Autowired;
  85
  86 import fj.data.Either;
  87
  88 public abstract class ComponentInstanceBusinessLogic extends BaseBusinessLogic {
  89
  90         private static Logger log = LoggerFactory.getLogger(ComponentInstanceBusinessLogic.class.getName());
  91
  92         @Autowired
  93         private IComponentInstanceOperation componentInstanceOperation;
  94
  95         @Autowired
  96         private ArtifactsBusinessLogic artifactBusinessLogic;
  97         @Autowired
  98         private ApplicationDataTypeCache dataTypeCache;
  99
 100         public static final String VF_MODULE = "org.openecomp.groups.VfModule";
 101
 102         public ComponentInstanceBusinessLogic() {
 103         }
 104
 105         public Either<ComponentInstance, ResponseFormat> createComponentInstance(String containerComponentParam, String containerComponentId, String userId, ComponentInstance resourceInstance) {
 106                 return createComponentInstance(containerComponentParam, containerComponentId, userId, resourceInstance, false, true);
 107         }
 108
 109         public Either<ComponentInstance, ResponseFormat> createComponentInstance(String containerComponentParam, String containerComponentId, String userId, ComponentInstance resourceInstance, boolean inTransaction, boolean needLock) {
 110
 111                 Component origComponent = null;
 112                 Either<ComponentInstance, ResponseFormat> resultOp = null;
 113                 User user = null;
 114                 org.openecomp.sdc.be.model.Component containerComponent = null;
 115                 ComponentTypeEnum containerComponentType;
 116
 117                 try{
 118                         Either<User, ResponseFormat> resp = validateUserExists(userId, "create Component Instance", inTransaction);
 119                         if (resp.isRight()) {
 120                                 return Either.right(resp.right().value());
 121                         } else {
 122                                 user = resp.left().value();
 123                         }
 124
 125                         Either<Boolean, ResponseFormat> validateValidJson = validateJsonBody(resourceInstance, ComponentInstance.class);
 126                         if (validateValidJson.isRight()) {
 127                                 return Either.right(validateValidJson.right().value());
 128                         }
 129
 130                         Either<ComponentTypeEnum, ResponseFormat> validateComponentType = validateComponentType(containerComponentParam);
 131                         if (validateComponentType.isRight()) {
 132                                 return Either.right(validateComponentType.right().value());
 133                         } else {
 134                                 containerComponentType = validateComponentType.left().value();
 135                         }
 136
 137                         Either<org.openecomp.sdc.be.model.Component, ResponseFormat> validateComponentExists = validateComponentExists(containerComponentId, containerComponentType, null);
 138                         if (validateComponentExists.isRight()) {
 139                                 return Either.right(validateComponentExists.right().value());
 140                         } else {
 141                                 containerComponent = validateComponentExists.left().value();
 142                         }
 143
 144                         Either<Boolean, ResponseFormat> validateAllowedToContainCompInstances = validateAllowedToContainCompInstances(containerComponent);
 145                         if (validateAllowedToContainCompInstances.isRight()) {
 146                                 return Either.right(validateAllowedToContainCompInstances.right().value());
 147                         }
 148
 149                         Either<Boolean, ResponseFormat> validateCanWorkOnComponent = validateCanWorkOnComponent(containerComponent, userId);
 150                         if (validateCanWorkOnComponent.isRight()) {
 151                                 return Either.right(validateCanWorkOnComponent.right().value());
 152                         }
 153
 154                         if (resourceInstance != null && containerComponentType != null) {
 155                                 Either<Component, ResponseFormat> getOriginComponentRes = getAndValidateOriginComponentOfComponentInstance(containerComponentType, resourceInstance);
 156                                 if (getOriginComponentRes.isRight()) {
 157                                         return Either.right(getOriginComponentRes.right().value());
 158                                 } else {
 159                                         origComponent = getOriginComponentRes.left().value();
 160                                 }
 161                         }
 162                         if (needLock) {
 163                                 Either<Boolean, ResponseFormat> lockComponent = lockComponent(containerComponent, "createComponentInstance");
 164                                 if (lockComponent.isRight()) {
 165                                         return Either.right(lockComponent.right().value());
 166                                 }
 167                         }
 168                         log.debug("Try to create entry on graph");
 169                         resultOp = createComponentInstanceOnGraph(containerComponent, origComponent, resourceInstance, user);
 170                         return resultOp;
 171
 172                 } finally {
 173                         if (needLock)
 174                                 unlockComponent(resultOp, containerComponent);
 175                 }
 176         }
 177
 178         public Either<CreateAndAssotiateInfo, ResponseFormat> createAndAssociateRIToRI(String containerComponentParam, String containerComponentId, String userId, CreateAndAssotiateInfo createAndAssotiateInfo) {
 179
 180                 Either<CreateAndAssotiateInfo, ResponseFormat> resultOp = null;
 181                 ComponentInstance resourceInstance = createAndAssotiateInfo.getNode();
 182                 RequirementCapabilityRelDef associationInfo = createAndAssotiateInfo.getAssociate();
 183
 184                 Either<User, ResponseFormat> resp = validateUserExists(userId, "create And Associate RI To RI", false);
 185                 if (resp.isRight()) {
 186                         return Either.right(resp.right().value());
 187                 }
 188
 189                 User user = resp.left().value();
 190                 Either<ComponentTypeEnum, ResponseFormat> validateComponentType = validateComponentType(containerComponentParam);
 191                 if (validateComponentType.isRight()) {
 192                         return Either.right(validateComponentType.right().value());
 193                 }
 194
 195                 final ComponentTypeEnum containerComponentType = validateComponentType.left().value();
 196
 197                 Either<org.openecomp.sdc.be.model.Component, ResponseFormat> validateComponentExists = validateComponentExists(containerComponentId, containerComponentType, null);
 198                 if (validateComponentExists.isRight()) {
 199                         return Either.right(validateComponentExists.right().value());
 200                 }
 201                 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists.left().value();
 202
 203                 Either<Boolean, ResponseFormat> validateAllowedToContainCompInstances = validateAllowedToContainCompInstances(containerComponent);
 204                 if (validateAllowedToContainCompInstances.isRight()) {
 205                         return Either.right(validateAllowedToContainCompInstances.right().value());
 206                 }
 207
 208                 Either<Boolean, ResponseFormat> validateCanWorkOnComponent = validateCanWorkOnComponent(containerComponent, userId);
 209                 if (validateCanWorkOnComponent.isRight()) {
 210                         return Either.right(validateCanWorkOnComponent.right().value());
 211                 }
 212
 213                 Either<Boolean, ResponseFormat> lockComponent = lockComponent(containerComponent, "createAndAssociateRIToRI");
 214                 if (lockComponent.isRight()) {
 215                         return Either.right(lockComponent.right().value());
 216                 }
 217
 218                 try {
 219                         log.debug("Try to create entry on graph");
 220                         Either<Component, ResponseFormat> eitherResourceName = getOriginComponentNameFromComponentInstance(resourceInstance, true);
 221
 222                         if (eitherResourceName.isRight()) {
 223                                 resultOp = Either.right(eitherResourceName.right().value());
 224                                 return resultOp;
 225                         }
 226                         Component origComponent = eitherResourceName.left().value();
 227
 228                         Either<ComponentInstance, ResponseFormat> result = createComponentInstanceOnGraph(containerComponent, origComponent, resourceInstance, user);
 229                         if (result.isRight()) {
 230                                 log.debug("Failed to create resource instance {}", containerComponentId);
 231                                 resultOp = Either.right(result.right().value());
 232                                 return resultOp;
 233
 234                         }
 235
 236                         log.debug("Entity on graph is created.");
 237                         ComponentInstance resResourceInfo = result.left().value();
 238                         if (associationInfo.getFromNode() == null || associationInfo.getFromNode().isEmpty()) {
 239                                 associationInfo.setFromNode(resResourceInfo.getUniqueId());
 240                         } else {
 241                                 associationInfo.setToNode(resResourceInfo.getUniqueId());
 242                         }
 243
 244                         RequirementCapabilityRelDef requirementCapabilityRelDef = associationInfo;// createRequirementCapabilityrelDef(associationInfo);
 245                         Either<RequirementCapabilityRelDef, StorageOperationStatus> resultReqCapDef = toscaOperationFacade.associateResourceInstances(containerComponentId, requirementCapabilityRelDef);
 246                         if (resultReqCapDef.isLeft()) {
 247                                 log.debug("Enty on graph is created.");
 248                                 RequirementCapabilityRelDef resReqCapabilityRelDef = resultReqCapDef.left().value();
 249                                 CreateAndAssotiateInfo resInfo = new CreateAndAssotiateInfo(resResourceInfo, resReqCapabilityRelDef);
 250                                 resultOp = Either.left(resInfo);
 251                                 return resultOp;
 252
 253                         } else {
 254                                 log.info("Failed to associate node {} with node {}", associationInfo.getFromNode(), associationInfo.getToNode());
 255                                 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstance(componentsUtils.convertFromStorageResponseForResourceInstance(resultReqCapDef.right().value(), true), "", null));
 256                                 return resultOp;
 257                         }
 258
 259                 } finally {
 260                         unlockComponent(resultOp, containerComponent);
 261                 }
 262         }
 263
 264         private Either<Component, ResponseFormat> getOriginComponentNameFromComponentInstance(ComponentInstance componentInstance, boolean inTransaction) {
 265                 Either<Component, ResponseFormat> eitherResponse;
 266                 Either<Component, StorageOperationStatus> eitherComponent = toscaOperationFacade.getToscaFullElement(componentInstance.getComponentUid());
 267                 if (eitherComponent.isRight()) {
 268                         log.debug("Failed to get origin component with id {} for component instance {} ", componentInstance.getComponentUid(), componentInstance.getName());
 269                         eitherResponse = Either.right(componentsUtils.getResponseFormatForResourceInstance(componentsUtils.convertFromStorageResponse(eitherComponent.right().value(), ComponentTypeEnum.RESOURCE), "", null));
 270                 } else {
 271                         eitherResponse = Either.left(eitherComponent.left().value());
 272                 }
 273                 return eitherResponse;
 274         }
 275
 276         private Either<ComponentInstance, ResponseFormat> createComponentInstanceOnGraph(org.openecomp.sdc.be.model.Component containerComponent, Component originComponent, ComponentInstance componentInstance, User user) {
 277                 Either<ComponentInstance, ResponseFormat> resultOp;
 278
 279                 Either<ImmutablePair<Component, String>, StorageOperationStatus> result = toscaOperationFacade.addComponentInstanceToTopologyTemplate(containerComponent, originComponent, componentInstance, false, user);
 280
 281                 if (result.isRight()) {
 282                         log.debug("Failed to create entry on graph for component instance {}", componentInstance.getName());
 283                         resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstance(componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true), "", null));
 284                         return resultOp;
 285                 }
 286
 287                 log.debug("Entity on graph is created.");
 288                 Component updatedComponent = result.left().value().getLeft();
 289                 Map<String, String> existingEnvVersions = new HashMap<>();
 290                 //TODO existingEnvVersions ??
 291                 Either<ActionStatus, ResponseFormat> addComponentInstanceArtifacts = addComponentInstanceArtifacts(updatedComponent, componentInstance, originComponent, user, existingEnvVersions);
 292                 if (addComponentInstanceArtifacts.isRight()) {
 293                         log.debug("Failed to create component instance {}", componentInstance.getName());
 294                         resultOp = Either.right(addComponentInstanceArtifacts.right().value());
 295                         return resultOp;
 296                 }
 297
 298                 Optional<ComponentInstance> updatedInstanceOptional = updatedComponent.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(result.left().value().getRight())).findFirst();
 299                 if (!updatedInstanceOptional.isPresent()) {
 300                         log.debug("Failed to fetch new added component instance {} from component {}", componentInstance.getName(), containerComponent.getName());
 301                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName()));
 302                         return resultOp;
 303                 }
 304                 resultOp = Either.left(updatedInstanceOptional.get());
 305                 return resultOp;
 306         }
 307
 308         /**
 309          * addResourceInstanceArtifacts - add artifacts (HEAT_ENV) to resource instance The instance artifacts are generated from the resource's artifacts
 310          *
 311          * @param componentInstance
 312          * @param userId
 313          * @param existingEnvVersions
 314          *            TODO
 315          * @param containerComponentId
 316          *
 317          * @return
 318          */
 319         protected Either<ActionStatus, ResponseFormat> addComponentInstanceArtifacts(org.openecomp.sdc.be.model.Component containerComponent, ComponentInstance componentInstance, org.openecomp.sdc.be.model.Component originComponent, User user,
 320                         Map<String, String> existingEnvVersions) {
 321                 log.debug("add artifacts to resource instance");
 322                 List<GroupDefinition> filteredGroups = null;
 323                 ActionStatus status = setResourceArtifactsOnResourceInstance(componentInstance);
 324                 if (!ActionStatus.OK.equals(status)) {
 325                         ResponseFormat resultOp = componentsUtils.getResponseFormatForResourceInstance(status, "", null);
 326                         return Either.right(resultOp);
 327                 }
 328
 329                 // generate heat_env if necessary
 330                 Map<String, ArtifactDefinition> componentDeploymentArtifacts = componentInstance.getDeploymentArtifacts();
 331                 if (componentDeploymentArtifacts == null) {
 332                         return Either.left(ActionStatus.OK);
 333                 }
 334                 Map<String, ArtifactDefinition> finalDeploymentArtifacts = new HashMap<String, ArtifactDefinition>();
 335
 336                 Map<String, List<ArtifactDefinition>> groupInstancesArtifacts = new HashMap<>();
 337
 338                 for (ArtifactDefinition artifact : componentDeploymentArtifacts.values()) {
 339                         String type = artifact.getArtifactType();
 340
 341                         if ( !type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_ENV.getType()) ){
 342                                 finalDeploymentArtifacts.put(artifact.getArtifactLabel(), artifact);
 343                         }
 344
 345                         if (!(type.equalsIgnoreCase(ArtifactTypeEnum.HEAT.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_NET.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_VOL.getType()))) {
 346                                 continue;
 347                         }
 348
 349                         if (artifact.checkEsIdExist()) {
 350                                 Either<ArtifactDefinition, ResponseFormat> createHeatEnvPlaceHolder = artifactBusinessLogic.createHeatEnvPlaceHolder(artifact, ArtifactsBusinessLogic.HEAT_ENV_NAME, componentInstance.getUniqueId(), NodeTypeEnum.ResourceInstance,
 351                                                 componentInstance.getName(), user, containerComponent, existingEnvVersions);
 352                                 if (createHeatEnvPlaceHolder.isRight()) {
 353                                         return Either.right(createHeatEnvPlaceHolder.right().value());
 354                                 }
 355                                 ArtifactDefinition artifactDefinition = createHeatEnvPlaceHolder.left().value();
 356
 357                                 //put env
 358                                 finalDeploymentArtifacts.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
 359
 360                                 if(CollectionUtils.isNotEmpty(originComponent.getGroups())){
 361                                         filteredGroups = originComponent.getGroups().stream().filter(g -> g.getType().equals(VF_MODULE)).collect(Collectors.toList());
 362                                 }
 363                                 if (CollectionUtils.isNotEmpty(filteredGroups)) {
 364                                         for (GroupDefinition groupInstance : filteredGroups) {
 365                                                 Optional<String> op = groupInstance.getArtifacts().stream().filter(p -> p.equals(artifactDefinition.getGeneratedFromId())).findAny();
 366                                                 if (op.isPresent()) {
 367                                                         List<ArtifactDefinition> artifactsUid;
 368                                                         if (groupInstancesArtifacts.containsKey(groupInstance.getUniqueId())) {
 369                                                                 artifactsUid = groupInstancesArtifacts.get(groupInstance.getUniqueId());
 370                                                         } else {
 371                                                                 artifactsUid = new ArrayList<>();
 372                                                         }
 373                                                         artifactsUid.add(artifactDefinition);
 374                                                         groupInstancesArtifacts.put(groupInstance.getUniqueId(), artifactsUid);
 375                                                         break;
 376                                                 }
 377                                         }
 378
 379                                 }
 380                         }
 381                 }
 382                 StorageOperationStatus artStatus = toscaOperationFacade.addDeploymentArtifactsToInstance(containerComponent.getUniqueId(), componentInstance, finalDeploymentArtifacts);
 383                 if ( artStatus != StorageOperationStatus.OK){
 384                         log.debug("Failed to add instance deployment artifacts for instance {} in conatiner {} error {}", componentInstance.getUniqueId(), containerComponent.getUniqueId(), artStatus);
 385                         return Either.left(componentsUtils.convertFromStorageResponseForResourceInstance(artStatus, false));
 386
 387                 }
 388                 StorageOperationStatus result = toscaOperationFacade
 389                                 .addGroupInstancesToComponentInstance(containerComponent, componentInstance, filteredGroups, groupInstancesArtifacts);
 390                 if (result != StorageOperationStatus.OK) {
 391                         log.debug("failed to update group instance for component instance {}", componentInstance.getUniqueId());
 392                         return Either.left(componentsUtils.convertFromStorageResponse(result));
 393                 }
 394                 componentInstance.setDeploymentArtifacts(finalDeploymentArtifacts);
 395                 return Either.left(ActionStatus.OK);
 396         }
 397
 398         private ActionStatus setResourceArtifactsOnResourceInstance(ComponentInstance resourceInstance) {
 399                 Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getResourceDeploymentArtifacts = artifactBusinessLogic.getArtifacts(resourceInstance.getComponentUid(), NodeTypeEnum.Resource, true, ArtifactGroupTypeEnum.DEPLOYMENT, null);
 400
 401                 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<String, ArtifactDefinition>();
 402                 if (getResourceDeploymentArtifacts.isRight()) {
 403                         StorageOperationStatus status = getResourceDeploymentArtifacts.right().value();
 404                         if (!status.equals(StorageOperationStatus.NOT_FOUND)) {
 405                                 log.debug("Failed to fetch resource: {} artifacts. status is {}", resourceInstance.getComponentUid(), status);
 406                                 return componentsUtils.convertFromStorageResponseForResourceInstance(status, true);
 407                         }
 408                 } else {
 409                         deploymentArtifacts = getResourceDeploymentArtifacts.left().value();
 410                 }
 411
 412                 if (!deploymentArtifacts.isEmpty()) {
 413                         Map<String, ArtifactDefinition> tempDeploymentArtifacts = new HashMap<String, ArtifactDefinition>(deploymentArtifacts);
 414                         for (Entry<String, ArtifactDefinition> artifact : deploymentArtifacts.entrySet()) {
 415                                 if (!artifact.getValue().checkEsIdExist()) {
 416                                         tempDeploymentArtifacts.remove(artifact.getKey());
 417                                 }
 418                         }
 419
 420                         resourceInstance.setDeploymentArtifacts(tempDeploymentArtifacts);
 421                 }
 422
 423                 return ActionStatus.OK;
 424         }
 425
 426         public Either<ComponentInstance, ResponseFormat> updateComponentInstanceMetadata(String containerComponentParam, String containerComponentId, String componentInstanceId, String userId, ComponentInstance componentInstance) {
 427                 return updateComponentInstanceMetadata(containerComponentParam, containerComponentId, componentInstanceId, userId, componentInstance, false, true, true);
 428         }
 429
 430         public Either<ComponentInstance, ResponseFormat> updateComponentInstanceMetadata(String containerComponentParam, String containerComponentId, String componentInstanceId, String userId, ComponentInstance componentInstance, boolean inTransaction,
 431                         boolean needLock, boolean createNewTransaction) {
 432
 433                 Either<User, ResponseFormat> resp = validateUserExists(userId, "update Component Instance", inTransaction);
 434                 if (resp.isRight()) {
 435                         return Either.right(resp.right().value());
 436                 }
 437
 438                 Either<ComponentInstance, ResponseFormat> resultOp = null;
 439
 440                 Either<ComponentTypeEnum, ResponseFormat> validateComponentType = validateComponentType(containerComponentParam);
 441                 if (validateComponentType.isRight()) {
 442                         return Either.right(validateComponentType.right().value());
 443                 }
 444
 445                 final ComponentTypeEnum containerComponentType = validateComponentType.left().value();
 446
 447                 Either<org.openecomp.sdc.be.model.Component, ResponseFormat> validateComponentExists = validateComponentExists(containerComponentId, containerComponentType, null);
 448                 if (validateComponentExists.isRight()) {
 449                         return Either.right(validateComponentExists.right().value());
 450                 }
 451                 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists.left().value();
 452
 453                 Either<Boolean, ResponseFormat> validateCanWorkOnComponent = validateCanWorkOnComponent(containerComponent, userId);
 454                 if (validateCanWorkOnComponent.isRight()) {
 455                         return Either.right(validateCanWorkOnComponent.right().value());
 456                 }
 457                 ComponentTypeEnum instanceType = getComponentType(containerComponentType);
 458                 Either<Boolean, StorageOperationStatus> validateParentStatus = toscaOperationFacade.validateComponentExists(componentInstance.getComponentUid());
 459                 if (validateParentStatus.isRight()) {
 460                         log.debug("Failed to get component instance {} on service {}", componentInstanceId, containerComponentId);
 461                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND, componentInstance.getName(), instanceType.getValue().toLowerCase()));
 462                         return resultOp;
 463                 }
 464                 if (!validateParentStatus.left().value()) {
 465                         resultOp = Either.right(
 466                                         componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName(), instanceType.getValue().toLowerCase(), containerComponentType.getValue().toLowerCase(), containerComponentId));
 467                         return resultOp;
 468                 }
 469
 470                 if (needLock) {
 471                         Either<Boolean, ResponseFormat> lockComponent = lockComponent(containerComponent, "updateComponentInstance");
 472                         if (lockComponent.isRight()) {
 473                                 return Either.right(lockComponent.right().value());
 474                         }
 475                 }
 476                 try {
 477
 478                         Either<Component, ResponseFormat> eitherResourceName = getOriginComponentNameFromComponentInstance(componentInstance, inTransaction);
 479
 480                         if (eitherResourceName.isRight()) {
 481                                 resultOp = Either.right(eitherResourceName.right().value());
 482                                 return resultOp;
 483                         }
 484                         Component origComponent = eitherResourceName.left().value();
 485
 486                         resultOp = updateComponentInstanceMetadata(containerComponent, containerComponentType, origComponent, componentInstanceId, componentInstance, inTransaction);
 487                         return resultOp;
 488
 489                 } finally {
 490                         if (needLock)
 491                                 unlockComponent(resultOp, containerComponent);
 492                 }
 493         }
 494
 495         // New Multiple Instance Update API
 496         public Either<List<ComponentInstance>, ResponseFormat> updateComponentInstance(String containerComponentParam, String containerComponentId, String userId, List<ComponentInstance> componentInstanceList, boolean needLock,
 497                         boolean createNewTransaction) {
 498
 499                 Either<List<ComponentInstance>, ResponseFormat> resultOp = null;
 500                 org.openecomp.sdc.be.model.Component containerComponent = null;
 501                 try {
 502                         Either<User, ResponseFormat> resp = validateUserExists(userId, "update Component Instance", true);
 503                         if (resp.isRight()) {
 504                                 return Either.right(resp.right().value());
 505                         }
 506
 507                         Either<ComponentTypeEnum, ResponseFormat> validateComponentType = validateComponentType(containerComponentParam);
 508                         if (validateComponentType.isRight()) {
 509                                 return Either.right(validateComponentType.right().value());
 510                         }
 511
 512                         final ComponentTypeEnum containerComponentType = validateComponentType.left().value();
 513
 514                         ComponentParametersView componentFilter = new ComponentParametersView();
 515                         componentFilter.disableAll();
 516                         componentFilter.setIgnoreUsers(false);
 517                         componentFilter.setIgnoreComponentInstances(false);
 518                         Either<org.openecomp.sdc.be.model.Component, ResponseFormat> validateComponentExists = validateComponentExistsByFilter(containerComponentId, containerComponentType, componentFilter, true);
 519                         if (validateComponentExists.isRight()) {
 520                                 return Either.right(validateComponentExists.right().value());
 521                         }
 522
 523                         containerComponent = validateComponentExists.left().value();
 524
 525                         Either<Boolean, ResponseFormat> validateCanWorkOnComponent = validateCanWorkOnComponent(containerComponent, userId);
 526                         if (validateCanWorkOnComponent.isRight()) {
 527                                 return Either.right(validateCanWorkOnComponent.right().value());
 528                         }
 529
 530                         ComponentTypeEnum instanceType = getComponentType(containerComponentType);
 531
 532                         for (ComponentInstance componentInstance : componentInstanceList) {
 533                                 boolean validateParent = validateParent(containerComponent, componentInstance.getUniqueId());
 534                                 if (!validateParent) {
 535                                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName(), instanceType.getValue().toLowerCase(), containerComponentType.getValue().toLowerCase(),
 536                                                         containerComponentId));
 537                                         return resultOp;
 538                                 }
 539                         }
 540
 541                         if (needLock) {
 542
 543                                 Either<Boolean, ResponseFormat> lockComponent = lockComponent(containerComponent, "updateComponentInstance");
 544                                 if (lockComponent.isRight()) {
 545                                         return Either.right(lockComponent.right().value());
 546                                 }
 547                         }
 548
 549                         List<ComponentInstance> updatedList = new ArrayList<>();
 550                         List<ComponentInstance> instancesFromContainerComponent = containerComponent.getComponentInstances();
 551                         List<ComponentInstance> listForUpdate = new ArrayList<>();
 552                         if(instancesFromContainerComponent == null || instancesFromContainerComponent.isEmpty())
 553                                 containerComponent.setComponentInstances(componentInstanceList);
 554                         else{
 555                                 Iterator<ComponentInstance> iterator = instancesFromContainerComponent.iterator();
 556                                 while(iterator.hasNext()){
 557                                         ComponentInstance origInst = iterator.next();
 558                                         Optional<ComponentInstance> op = componentInstanceList.stream().filter(ci -> ci.getUniqueId().equals(origInst.getUniqueId())).findAny();
 559                                         if(op.isPresent()){
 560                                                 ComponentInstance updatedCi = op.get();
 561                                                 Boolean isUniqueName = validateInstanceNameUniquenessUponUpdate(containerComponent, origInst, updatedCi.getName());
 562                                                 if(!isUniqueName){
 563                                                         CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update the name of the component instance {} to {}. A component instance with the same name already exists. ",
 564                                                                         origInst.getName(), updatedCi.getName());
 565                                                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, containerComponentType.getValue(), origInst.getName()));
 566                                                         return resultOp;
 567                                                 }
 568
 569                                                 listForUpdate.add(updatedCi);
 570                                         }
 571                                         else
 572                                                 listForUpdate.add(origInst);
 573                                 }
 574                                 containerComponent.setComponentInstances(listForUpdate);
 575
 576                                 if(resultOp == null){
 577                                         Either<Component, StorageOperationStatus> updateStatus = toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
 578                                         if(updateStatus.isRight()){
 579                                                 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update metadata belonging to container component {}. Status is {}. ", containerComponent.getName(), updateStatus.right().value());
 580                                                 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstance(componentsUtils.convertFromStorageResponseForResourceInstance(updateStatus.right().value(), true), "", null));
 581                                                 return resultOp;
 582                                         }
 583                                         for(ComponentInstance updatedInstance : updateStatus.left().value().getComponentInstances()){
 584                                                 Optional<ComponentInstance> op = componentInstanceList.stream().filter(ci -> ci.getName().equals(updatedInstance.getName())).findAny();
 585                                                 if(op.isPresent()){
 586                                                         updatedList.add(updatedInstance);
 587                                                 }
 588                                         }
 589                                 }
 590                         }
 591
 592                         resultOp = Either.left(updatedList);
 593                         return resultOp;
 594
 595                 } finally {
 596                         if (needLock) {
 597                                 unlockComponent(resultOp, containerComponent);
 598                         }
 599                 }
 600         }
 601
 602         private boolean validateParent(org.openecomp.sdc.be.model.Component containerComponent, String nodeTemplateId) {
 603                 return containerComponent.getComponentInstances().stream().anyMatch(p -> p.getUniqueId().equals(nodeTemplateId));
 604         }
 605
 606         private ComponentTypeEnum getComponentType(ComponentTypeEnum containerComponentType) {
 607                 if (ComponentTypeEnum.PRODUCT.equals(containerComponentType)) {
 608                         return ComponentTypeEnum.SERVICE_INSTANCE;
 609                 } else {
 610                         return ComponentTypeEnum.RESOURCE_INSTANCE;
 611                 }
 612         }
 613
 614         private Either<ComponentInstance, ResponseFormat> updateComponentInstanceMetadata(Component containerComponent, ComponentTypeEnum containerComponentType, org.openecomp.sdc.be.model.Component origComponent, String componentInstanceId,
 615                         ComponentInstance componentInstance, boolean inTransaction) {
 616
 617                 Either<ComponentInstance, ResponseFormat> resultOp = null;
 618                 Optional<ComponentInstance> componentInstanceOptional = null;
 619                 Either<ImmutablePair<Component, String>, StorageOperationStatus> updateRes = null;
 620
 621                 if (resultOp == null) {
 622                         componentInstanceOptional = containerComponent.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(componentInstance.getUniqueId())).findFirst();
 623                         if (!componentInstanceOptional.isPresent()) {
 624                                 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find the component instance {} in container component {}. ", componentInstance.getName(), containerComponent.getName());
 625                                 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName()));
 626                         }
 627                 }
 628                 if (resultOp == null) {
 629                         ComponentInstance oldComponentInstance = componentInstanceOptional.get();
 630                         String newInstanceName = componentInstance.getName();
 631                         Boolean isUniqueName = validateInstanceNameUniquenessUponUpdate(containerComponent, oldComponentInstance, newInstanceName);
 632                         if (!isUniqueName) {
 633                                 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update the name of the component instance {} to {}. A component instance with the same name already exists. ", oldComponentInstance.getName(), newInstanceName);
 634                                 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, containerComponentType.getValue(), componentInstance.getName()));
 635                         }
 636                 }
 637                 if (resultOp == null) {
 638                         updateRes = toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(containerComponent, origComponent, componentInstance);
 639                         if (updateRes.isRight()) {
 640                                 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update metadata of component instance {} belonging to container component {}. Status is {}. ", componentInstance.getName(), containerComponent.getName(),
 641                                                 updateRes.right().value());
 642                                 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstance(componentsUtils.convertFromStorageResponseForResourceInstance(updateRes.right().value(), true), "", null));
 643                         }
 644                 }
 645                 if (resultOp == null) {
 646                         String newInstanceId = updateRes.left().value().getRight();
 647                         Optional<ComponentInstance> updatedInstanceOptional = updateRes.left().value().getLeft().getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(newInstanceId)).findFirst();
 648
 649                         if (!updatedInstanceOptional.isPresent()) {
 650                                 log.debug("Failed to update metadata of component instance {} of container component {}", componentInstance.getName(), containerComponent.getName());
 651                                 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName()));
 652                         }else{
 653                                 resultOp = Either.left(updatedInstanceOptional.get());
 654                         }
 655
 656                 }
 657                 if (resultOp == null) {
 658                         resultOp = Either.left(componentInstanceOptional.get());
 659                 }
 660                 return resultOp;
 661         }
 662
 663         public Either<ComponentInstance, ResponseFormat> deleteComponentInstance(String containerComponentParam, String containerComponentId, String componentInstanceId, String userId) {
 664
 665                 Either<User, ResponseFormat> resp = validateUserExists(userId, "delete Component Instance", false);
 666                 if (resp.isRight()) {
 667                         return Either.right(resp.right().value());
 668                 }
 669
 670                 Either<ComponentTypeEnum, ResponseFormat> validateComponentType = validateComponentType(containerComponentParam);
 671                 if (validateComponentType.isRight()) {
 672                         return Either.right(validateComponentType.right().value());
 673                 }
 674
 675                 final ComponentTypeEnum containerComponentType = validateComponentType.left().value();
 676                 Either<org.openecomp.sdc.be.model.Component, ResponseFormat> validateComponentExists = validateComponentExists(containerComponentId, containerComponentType, null);
 677                 if (validateComponentExists.isRight()) {
 678                         return Either.right(validateComponentExists.right().value());
 679                 }
 680                 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists.left().value();
 681                 Either<Boolean, ResponseFormat> validateCanWorkOnComponent = validateCanWorkOnComponent(containerComponent, userId);
 682                 if (validateCanWorkOnComponent.isRight()) {
 683                         return Either.right(validateCanWorkOnComponent.right().value());
 684                 }
 685
 686                 Either<Boolean, ResponseFormat> lockComponent = lockComponent(containerComponent, "deleteComponentInstance");
 687                 if (lockComponent.isRight()) {
 688                         return Either.right(lockComponent.right().value());
 689                 }
 690                 // validate resource
 691                 /*
 692                  * if (!ComponentValidationUtils.canWorkOnComponent(containerComponentId, serviceOperation, userId)) { log.info( "Restricted operation for user " + userId + " on service " + containerComponentId); return Either.right(componentsUtils
 693                  * .getResponseFormat(ActionStatus.RESTRICTED_OPERATION)); } // lock resource StorageOperationStatus lockStatus = graphLockOperation.lockComponent( containerComponentId, NodeTypeEnum.Service); if (lockStatus != StorageOperationStatus.OK) {
 694                  * log.debug("Failed to lock service  {}", containerComponentId); resultOp = Either.right(componentsUtils .getResponseFormat(componentsUtils .convertFromStorageResponse(lockStatus))); return resultOp; }
 695                  */
 696                 Either<ComponentInstance, ResponseFormat> resultOp = null;
 697                 try {
 698                         resultOp = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentType);
 699                         return resultOp;
 700
 701                 } finally {
 702                         /*
 703                          * if (resultOp == null || resultOp.isRight()) { titanGenericDao.rollback(); } else { titanGenericDao.commit(); } graphLockOperation.unlockComponent(containerComponentId, NodeTypeEnum.Service);
 704                          */
 705                         unlockComponent(resultOp, containerComponent);
 706                 }
 707         }
 708
 709         private Either<ComponentInstance, ResponseFormat> deleteComponentInstance(Component containerComponent, String componentInstanceId, ComponentTypeEnum containerComponentType) {
 710
 711                 Either<ComponentInstance, ResponseFormat> resultOp = null;
 712                 ComponentInstance deletedInstance = null;
 713                 Either<ImmutablePair<Component, String>, StorageOperationStatus> deleteRes = toscaOperationFacade.deleteComponentInstanceFromTopologyTemplate(containerComponent, componentInstanceId);
 714
 715                 if (deleteRes.isRight()) {
 716                         log.debug("Failed to delete entry on graph for resourceInstance {}", componentInstanceId);
 717                         ActionStatus status = componentsUtils.convertFromStorageResponse(deleteRes.right().value(), containerComponentType);
 718                         resultOp = Either.right(componentsUtils.getResponseFormat(status, componentInstanceId));
 719                 }
 720                 if (resultOp == null) {
 721                         log.debug("The component instance {} has been removed from container component {}. ", componentInstanceId, containerComponent);
 722                         deletedInstance = findAndRemoveComponentInstanceFromContainerComponent(componentInstanceId, containerComponent);
 723                         resultOp = Either.left(deletedInstance);
 724                 }
 725                 if (resultOp.isLeft() && CollectionUtils.isNotEmpty(containerComponent.getGroups())) {
 726                         List<GroupDataDefinition> groupsToUpdate = new ArrayList<>();
 727                         for(GroupDataDefinition currGroup : containerComponent.getGroups()){
 728                                 if(currGroup.getMembers().containsKey(deletedInstance.getName())){
 729                                         currGroup.getMembers().remove(deletedInstance.getName());
 730                                         groupsToUpdate.add(currGroup);
 731                                 }
 732                         }
 733                         Either<List<GroupDefinition>, StorageOperationStatus> updateGroupsRes =
 734                                         toscaOperationFacade.updateGroupsOnComponent(containerComponent, containerComponent.getComponentType(), groupsToUpdate);
 735                         if (updateGroupsRes.isRight()) {
 736                                 log.debug("Failed to delete component instance {} from group members. ", componentInstanceId);
 737                                 ActionStatus status = componentsUtils.convertFromStorageResponse(updateGroupsRes.right().value(), containerComponentType);
 738                                 resultOp = Either.right(componentsUtils.getResponseFormat(status, componentInstanceId));
 739                         }
 740                 }
 741                 return resultOp;
 742         }
 743
 744         private ComponentInstance findAndRemoveComponentInstanceFromContainerComponent(String componentInstanceId, Component containerComponent) {
 745                 ComponentInstance foundInstance = null;
 746                 for(ComponentInstance instance : containerComponent.getComponentInstances()){
 747                         if(instance.getUniqueId().equals(componentInstanceId)){
 748                                 foundInstance = instance;
 749                                 containerComponent.getComponentInstances().remove(instance);
 750                                 break;
 751                         }
 752                 }
 753                 return foundInstance;
 754         }
 755
 756         public Either<RequirementCapabilityRelDef, ResponseFormat> associateRIToRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef, ComponentTypeEnum componentTypeEnum) {
 757                 return associateRIToRI(componentId, userId, requirementDef, componentTypeEnum, false, true, true);
 758         }
 759
 760         public Either<RequirementCapabilityRelDef, ResponseFormat> associateRIToRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef, ComponentTypeEnum componentTypeEnum, boolean inTransaction, boolean needLock,
 761                         boolean createNewTransaction) {
 762
 763                 Either<User, ResponseFormat> resp = validateUserExists(userId, "associate Ri To RI", inTransaction);
 764                 if (resp.isRight()) {
 765                         return Either.right(resp.right().value());
 766                 }
 767
 768                 Either<RequirementCapabilityRelDef, ResponseFormat> resultOp = null;
 769
 770                 Either<org.openecomp.sdc.be.model.Component, ResponseFormat> validateComponentExists = validateComponentExists(componentId, componentTypeEnum, null);
 771                 if (validateComponentExists.isRight()) {
 772                         return Either.right(validateComponentExists.right().value());
 773                 }
 774                 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists.left().value();
 775
 776                 Either<Boolean, ResponseFormat> validateCanWorkOnComponent = validateCanWorkOnComponent(containerComponent, userId);
 777                 if (validateCanWorkOnComponent.isRight()) {
 778                         return Either.right(validateCanWorkOnComponent.right().value());
 779                 }
 780                 if (needLock) {
 781                         Either<Boolean, ResponseFormat> lockComponent = lockComponent(containerComponent, "associateRIToRI");
 782
 783                         if (lockComponent.isRight()) {
 784                                 return Either.right(lockComponent.right().value());
 785                         }
 786                 }
 787
 788                 try {
 789
 790                         resultOp = associateRIToRIOnGraph(validateComponentExists.left().value(), requirementDef, componentTypeEnum, inTransaction);
 791
 792                         return resultOp;
 793
 794                 } finally {
 795                         if (needLock)
 796                                 unlockComponent(resultOp, containerComponent);
 797                 }
 798         }
 799
 800         public Either<RequirementCapabilityRelDef, ResponseFormat> associateRIToRIOnGraph(Component containerComponent, RequirementCapabilityRelDef requirementDef, ComponentTypeEnum componentTypeEnum, boolean inTransaction) {
 801
 802                 log.debug("Try to create entry on graph");
 803                 Either<RequirementCapabilityRelDef, ResponseFormat> resultOp = null;
 804
 805                 Either<RequirementCapabilityRelDef, StorageOperationStatus> result = toscaOperationFacade.associateResourceInstances(containerComponent.getUniqueId(), requirementDef);
 806
 807                 if (result.isLeft()) {
 808                         log.debug("Enty on graph is created.");
 809                         RequirementCapabilityRelDef requirementCapabilityRelDef = result.left().value();
 810                         resultOp = Either.left(requirementCapabilityRelDef);
 811                         return resultOp;
 812
 813                 } else {
 814                         log.debug("Failed to associate node: {} with node {}", requirementDef.getFromNode(), requirementDef.getToNode());
 815                         String fromNameOrId = "";
 816                         String toNameOrId = "";
 817                         Either<ComponentInstance, StorageOperationStatus> fromResult = getResourceInstanceById(containerComponent, requirementDef.getFromNode());
 818                         Either<ComponentInstance, StorageOperationStatus> toResult = getResourceInstanceById(containerComponent, requirementDef.getToNode());
 819
 820                         toNameOrId = requirementDef.getFromNode();
 821                         fromNameOrId = requirementDef.getFromNode();
 822                         if (fromResult.isLeft()) {
 823                                 fromNameOrId = fromResult.left().value().getName();
 824                         }
 825                         if (toResult.isLeft()) {
 826                                 toNameOrId = toResult.left().value().getName();
 827                         }
 828
 829                         resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true), fromNameOrId, toNameOrId, requirementDef.getRelationships().get(0).getRequirement()));
 830
 831                         return resultOp;
 832                 }
 833
 834         }
 835
 836         public Either<RequirementCapabilityRelDef, ResponseFormat> dissociateRIFromRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef, ComponentTypeEnum componentTypeEnum) {
 837                 Either<User, ResponseFormat> resp = validateUserExists(userId, "dissociate RI From RI", false);
 838                 if (resp.isRight()) {
 839                         return Either.right(resp.right().value());
 840                 }
 841
 842                 Either<RequirementCapabilityRelDef, ResponseFormat> resultOp = null;
 843                 Either<org.openecomp.sdc.be.model.Component, ResponseFormat> validateComponentExists = validateComponentExists(componentId, componentTypeEnum, null);
 844                 if (validateComponentExists.isRight()) {
 845                         return Either.right(validateComponentExists.right().value());
 846                 }
 847                 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists.left().value();
 848
 849                 Either<Boolean, ResponseFormat> validateCanWorkOnComponent = validateCanWorkOnComponent(containerComponent, userId);
 850                 if (validateCanWorkOnComponent.isRight()) {
 851                         return Either.right(validateCanWorkOnComponent.right().value());
 852                 }
 853                 Either<Boolean, ResponseFormat> lockComponent = lockComponent(containerComponent, "associateRIToRI");
 854
 855                 if (lockComponent.isRight()) {
 856                         return Either.right(lockComponent.right().value());
 857                 }
 858                 try {
 859                         log.debug("Try to create entry on graph");
 860                         Either<RequirementCapabilityRelDef, StorageOperationStatus> result = toscaOperationFacade.dissociateResourceInstances(componentId, requirementDef);
 861                         if (result.isLeft()) {
 862                                 log.debug("Enty on graph is created.");
 863                                 RequirementCapabilityRelDef requirementCapabilityRelDef = result.left().value();
 864                                 resultOp = Either.left(requirementCapabilityRelDef);
 865                                 return resultOp;
 866
 867                         } else {
 868
 869                                 log.debug("Failed to dissocaite node  {} from node {}", requirementDef.getFromNode(), requirementDef.getToNode());
 870                                 String fromNameOrId = "";
 871                                 String toNameOrId = "";
 872                                 Either<ComponentInstance, StorageOperationStatus> fromResult = getResourceInstanceById(containerComponent, requirementDef.getFromNode());
 873                                 Either<ComponentInstance, StorageOperationStatus> toResult = getResourceInstanceById(containerComponent, requirementDef.getToNode());
 874
 875                                 toNameOrId = requirementDef.getFromNode();
 876                                 fromNameOrId = requirementDef.getFromNode();
 877                                 if (fromResult.isLeft()) {
 878                                         fromNameOrId = fromResult.left().value().getName();
 879                                 }
 880                                 if (toResult.isLeft()) {
 881                                         toNameOrId = toResult.left().value().getName();
 882                                 }
 883
 884                                 resultOp = Either
 885                                                 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true), fromNameOrId, toNameOrId, requirementDef.getRelationships().get(0).getRequirement()));
 886                                 return resultOp;
 887                         }
 888                 } finally {
 889                         unlockComponent(resultOp, containerComponent);
 890                 }
 891         }
 892
 893         private Either<ComponentInstanceProperty, ResponseFormat> updateAttributeValue(ComponentInstanceProperty attribute, String resourceInstanceId) {
 894                 Either<ComponentInstanceProperty, StorageOperationStatus> eitherAttribute = componentInstanceOperation.updateAttributeValueInResourceInstance(attribute, resourceInstanceId, true);
 895                 Either<ComponentInstanceProperty, ResponseFormat> result;
 896                 if (eitherAttribute.isLeft()) {
 897                         log.debug("Attribute value {} was updated on graph.", attribute.getValueUniqueUid());
 898                         ComponentInstanceProperty instanceAttribute = eitherAttribute.left().value();
 899
 900                         result = Either.left(instanceAttribute);
 901
 902                 } else {
 903                         log.debug("Failed to update attribute value {} in resource instance {}", attribute, resourceInstanceId);
 904
 905                         ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(eitherAttribute.right().value());
 906
 907                         result = Either.right(componentsUtils.getResponseFormat(actionStatus, ""));
 908
 909                 }
 910                 return result;
 911         }
 912
 913         private Either<ComponentInstanceProperty, ResponseFormat> createAttributeValue(ComponentInstanceProperty attribute, String resourceInstanceId) {
 914
 915                 Either<ComponentInstanceProperty, ResponseFormat> result;
 916
 917                 Wrapper<Integer> indexCounterWrapper = new Wrapper<>();
 918                 Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 919                 validateIncrementCounter(resourceInstanceId, GraphPropertiesDictionary.ATTRIBUTE_COUNTER, indexCounterWrapper, errorWrapper);
 920
 921                 if (!errorWrapper.isEmpty()) {
 922                         result = Either.right(errorWrapper.getInnerElement());
 923                 } else {
 924                         Either<ComponentInstanceProperty, StorageOperationStatus> eitherAttribute = componentInstanceOperation.addAttributeValueToResourceInstance(attribute, resourceInstanceId, indexCounterWrapper.getInnerElement(), true);
 925                         if (eitherAttribute.isLeft()) {
 926                                 log.debug("Attribute value was added to resource instance {}", resourceInstanceId);
 927                                 ComponentInstanceProperty instanceAttribute = eitherAttribute.left().value();
 928                                 result = Either.left(instanceAttribute);
 929
 930                         } else {
 931                                 log.debug("Failed to add attribute value {}  to resource instance {}", attribute, resourceInstanceId);
 932
 933                                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(eitherAttribute.right().value());
 934                                 result = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
 935
 936                         }
 937                 }
 938                 return result;
 939         }
 940
 941         /**
 942          * Create Or Updates Attribute Instance
 943          *
 944          * @param componentTypeEnum
 945          * @param componentId
 946          * @param resourceInstanceId
 947          * @param attribute
 948          * @param userId
 949          * @return
 950          */
 951         public Either<ComponentInstanceProperty, ResponseFormat> createOrUpdateAttributeValue(ComponentTypeEnum componentTypeEnum, String componentId, String resourceInstanceId, ComponentInstanceProperty attribute, String userId) {
 952                 Either<ComponentInstanceProperty, ResponseFormat> result = null;
 953                 Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 954
 955                 validateUserExist(userId, "create Or Update Attribute Value", errorWrapper);
 956                 if (errorWrapper.isEmpty()) {
 957                         validateComponentTypeEnum(componentTypeEnum, "CreateOrUpdateAttributeValue", errorWrapper);
 958                 }
 959                 if (errorWrapper.isEmpty()) {
 960                         validateCanWorkOnComponent(componentId, componentTypeEnum, userId, errorWrapper);
 961                 }
 962                 if (errorWrapper.isEmpty()) {
 963                         validateComponentLock(componentId, componentTypeEnum, errorWrapper);
 964                 }
 965
 966                 try {
 967                         if (errorWrapper.isEmpty()) {
 968                                 final boolean isCreate = Objects.isNull(attribute.getValueUniqueUid());
 969                                 if (isCreate) {
 970                                         result = createAttributeValue(attribute, resourceInstanceId);
 971                                 } else {
 972                                         result = updateAttributeValue(attribute, resourceInstanceId);
 973                                 }
 974                         } else {
 975                                 result = Either.right(errorWrapper.getInnerElement());
 976                         }
 977                         return result;
 978                 }
 979
 980                 finally {
 981                         if (result == null || result.isRight()) {
 982                                 titanDao.rollback();
 983                         } else {
 984                                 titanDao.commit();
 985                         }
 986                         // unlock resource
 987                         graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
 988                 }
 989         }
 990
 991         // US833308 VLI in service - specific network_role property value logic
 992         private StorageOperationStatus concatServiceNameToVLINetworkRolePropertyValue(ToscaOperationFacade toscaOperationFacade, ComponentTypeEnum componentTypeEnum, String componentId, String resourceInstanceId, ComponentInstanceProperty property) {
 993                 if (StringUtils.isNotEmpty(property.getValue()) && PropertyNames.NETWORK_ROLE.getPropertyName().equalsIgnoreCase(property.getName()) && ComponentTypeEnum.SERVICE == componentTypeEnum) {
 994                         ComponentParametersView componentParametersView = new ComponentParametersView();
 995                         componentParametersView.disableAll();
 996                         componentParametersView.setIgnoreComponentInstances(false);
 997                         Either<Component, StorageOperationStatus> getServiceResult = toscaOperationFacade.getToscaElement(componentId, componentParametersView);
 998                         if (getServiceResult.isRight()) {
 999                                 return getServiceResult.right().value();
1000                         }
1001                         Component service = getServiceResult.left().value();
1002                         Optional<ComponentInstance> getInstance = service.getComponentInstances().stream().filter(p -> p.getUniqueId().equals(resourceInstanceId)).findAny();
1003                         if (!getInstance.isPresent()) {
1004                                 return StorageOperationStatus.NOT_FOUND;
1005                         }
1006                         String prefix = service.getSystemName() + ".";
1007                         String value = property.getValue();
1008                         if (OriginTypeEnum.VL == getInstance.get().getOriginType() && (!value.startsWith(prefix) || value.equalsIgnoreCase(prefix))) {
1009                                 property.setValue(prefix + value);
1010                         }
1011                 }
1012                 return StorageOperationStatus.OK;
1013         }
1014
1015         public Either<ComponentInstanceProperty, ResponseFormat> createOrUpdatePropertyValue(ComponentTypeEnum componentTypeEnum, String componentId, String resourceInstanceId, ComponentInstanceProperty property, String userId) {
1016
1017                 Either<ComponentInstanceProperty, ResponseFormat> resultOp = null;
1018
1019                 Either<User, ResponseFormat> resp = validateUserExists(userId, "create Or Update Property Value", false);
1020                 if (resp.isRight()) {
1021                         return Either.right(resp.right().value());
1022                 }
1023
1024                 if (componentTypeEnum == null) {
1025                         BeEcompErrorManager.getInstance().logInvalidInputError("CreateOrUpdatePropertyValue", "invalid component type", ErrorSeverity.INFO);
1026                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
1027                         return resultOp;
1028                 }
1029                 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
1030
1031                 if (getResourceResult.isRight()) {
1032                         log.debug("Failed to retrieve component, component id {}", componentId);
1033                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
1034                         return resultOp;
1035                 }
1036                 Component containerComponent = getResourceResult.left().value();
1037
1038                 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
1039                         log.info("Restricted operation for user: {} on service {}", userId, componentId);
1040                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
1041                         return resultOp;
1042                 }
1043                 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, resourceInstanceId);
1044                 if (resourceInstanceStatus.isRight()) {
1045                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, resourceInstanceId, componentId));
1046                         return resultOp;
1047                 }
1048                 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
1049                 // specific property value logic US833308
1050                 StorageOperationStatus fetchByIdsStatus = concatServiceNameToVLINetworkRolePropertyValue(toscaOperationFacade, componentTypeEnum, componentId, resourceInstanceId, property);
1051                 if (StorageOperationStatus.OK != fetchByIdsStatus) {
1052                         resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(fetchByIdsStatus)));
1053                         return resultOp;
1054                 }
1055                 // lock resource
1056                 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
1057                 if (lockStatus != StorageOperationStatus.OK) {
1058                         log.debug("Failed to lock service {}", componentId);
1059                         resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
1060                         return resultOp;
1061                 }
1062                 String innerType = null;
1063                 String propertyType = property.getType();
1064                 ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
1065                 log.debug("The type of the property {} is {}", property.getUniqueId(), propertyType);
1066
1067                 if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
1068                         SchemaDefinition def = property.getSchema();
1069                         if (def == null) {
1070                                 log.debug("Schema doesn't exists for property of type {}", type);
1071                                 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
1072                         }
1073                         PropertyDataDefinition propDef = def.getProperty();
1074                         if (propDef == null) {
1075                                 log.debug("Property in Schema Definition inside property of type {} doesn't exist", type);
1076                                 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
1077                         }
1078                         innerType = propDef.getType();
1079                 }
1080                 // Specific Update Logic
1081                 Either<Map<String, DataTypeDefinition>, TitanOperationStatus> allDataTypes = dataTypeCache.getAll();
1082                 if (allDataTypes.isRight()) {
1083                         TitanOperationStatus status = allDataTypes.right().value();
1084                         BeEcompErrorManager.getInstance().logInternalFlowError("UpdatePropertyValueOnComponentInstance", "Failed to update property value on instance. Status is " + status, ErrorSeverity.ERROR);
1085                         return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(DaoStatusConverter.convertTitanStatusToStorageStatus(status))));
1086                 }
1087                 Either<Object, Boolean> isValid = propertyOperation.validateAndUpdatePropertyValue(propertyType, property.getValue(), true, innerType, allDataTypes.left().value());
1088
1089                 String newValue = property.getValue();
1090                 if (isValid.isRight()) {
1091                         Boolean res = isValid.right().value();
1092                         if (res == false) {
1093                                 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(DaoStatusConverter.convertTitanStatusToStorageStatus(TitanOperationStatus.ILLEGAL_ARGUMENT))));
1094                         }
1095                 } else {
1096                         Object object = isValid.left().value();
1097                         if (object != null) {
1098                                 newValue = object.toString();
1099                         }
1100                 }
1101
1102                 ImmutablePair<String, Boolean> pair = propertyOperation.validateAndUpdateRules(propertyType, property.getRules(), innerType, allDataTypes.left().value(), true);
1103                 if (pair.getRight() != null && pair.getRight() == false) {
1104                         BeEcompErrorManager.getInstance().logBeInvalidValueError("Add property value", pair.getLeft(), property.getName(), propertyType);
1105                         return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(DaoStatusConverter.convertTitanStatusToStorageStatus(TitanOperationStatus.ILLEGAL_ARGUMENT))));
1106                 }
1107
1108                 try {
1109                         List<ComponentInstanceProperty> instanceProperties = containerComponent.getComponentInstancesProperties().get(resourceInstanceId);
1110                         Optional<ComponentInstanceProperty> instanceProperty = instanceProperties.stream().filter(p -> p.getUniqueId().equals(property.getUniqueId())).findAny();
1111                         StorageOperationStatus status;
1112                         instanceProperty.get().setValue(newValue);
1113                         if(instanceProperty.isPresent()){
1114                                 status = toscaOperationFacade.updateComponentInstanceProperty(containerComponent, foundResourceInstance.getUniqueId(), property);
1115                         } else {
1116                                 status = toscaOperationFacade.addComponentInstanceProperty(containerComponent, foundResourceInstance.getUniqueId(), property);
1117                         }
1118                         if(status != StorageOperationStatus.OK){
1119                                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
1120                                 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1121                                 return resultOp;
1122                         }
1123                         List<String> path = new ArrayList<>();
1124                         path.add(foundResourceInstance.getUniqueId());
1125                         property.setPath(path);
1126
1127                         foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
1128                         Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
1129
1130                         if (updateContainerRes.isRight()) {
1131                                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
1132                                 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1133                                 return resultOp;
1134                         }
1135                 resultOp = Either.left(property);
1136                 return resultOp;
1137
1138                 } finally {
1139                         if (resultOp == null || resultOp.isRight()) {
1140                                 titanDao.rollback();
1141                         } else {
1142                                 titanDao.commit();
1143                         }
1144                         // unlock resource
1145                         graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
1146                 }
1147
1148         }
1149
1150         public Either<ComponentInstanceInput, ResponseFormat> createOrUpdateInstanceInputValue(ComponentTypeEnum componentTypeEnum, String componentId, String resourceInstanceId, ComponentInstanceInput property, String userId) {
1151
1152                 Either<ComponentInstanceInput, ResponseFormat> resultOp = null;
1153
1154                 Either<User, ResponseFormat> resp = validateUserExists(userId, "create Or Update Property Value", false);
1155                 if (resp.isRight()) {
1156                         return Either.right(resp.right().value());
1157                 }
1158
1159                 if (componentTypeEnum == null) {
1160                         BeEcompErrorManager.getInstance().logInvalidInputError("CreateOrUpdatePropertyValue", "invalid component type", ErrorSeverity.INFO);
1161                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
1162                         return resultOp;
1163                 }
1164                 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
1165
1166                 if (getResourceResult.isRight()) {
1167                         log.debug("Failed to retrieve component, component id {}", componentId);
1168                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
1169                         return resultOp;
1170                 }
1171                 Component containerComponent = getResourceResult.left().value();
1172
1173                 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
1174                         log.info("Restricted operation for user: {} on service {}", userId, componentId);
1175                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
1176                         return resultOp;
1177                 }
1178                 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, resourceInstanceId);
1179                 if (resourceInstanceStatus.isRight()) {
1180                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, resourceInstanceId, componentId));
1181                         return resultOp;
1182                 }
1183
1184                 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
1185
1186                 // lock resource
1187                 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
1188                 if (lockStatus != StorageOperationStatus.OK) {
1189                         log.debug("Failed to lock service {}", componentId);
1190                         resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
1191                         return resultOp;
1192                 }
1193                 String innerType = null;
1194                 String propertyType = property.getType();
1195                 ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
1196                 log.debug("The type of the property {} is {}", property.getUniqueId(), propertyType);
1197
1198                 if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
1199                         SchemaDefinition def = property.getSchema();
1200                         if (def == null) {
1201                                 log.debug("Schema doesn't exists for property of type {}", type);
1202                                 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
1203                         }
1204                         PropertyDataDefinition propDef = def.getProperty();
1205                         if (propDef == null) {
1206                                 log.debug("Property in Schema Definition inside property of type {} doesn't exist", type);
1207                                 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
1208                         }
1209                         innerType = propDef.getType();
1210                 }
1211                 // Specific Update Logic
1212                 Either<Map<String, DataTypeDefinition>, TitanOperationStatus> allDataTypes = dataTypeCache.getAll();
1213                 if (allDataTypes.isRight()) {
1214                         TitanOperationStatus status = allDataTypes.right().value();
1215                         BeEcompErrorManager.getInstance().logInternalFlowError("UpdatePropertyValueOnComponentInstance", "Failed to update property value on instance. Status is " + status, ErrorSeverity.ERROR);
1216                         return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(DaoStatusConverter.convertTitanStatusToStorageStatus(status))));
1217                 }
1218                 Either<Object, Boolean> isValid = propertyOperation.validateAndUpdatePropertyValue(propertyType, property.getValue(), true, innerType, allDataTypes.left().value());
1219
1220                 String newValue = property.getValue();
1221                 if (isValid.isRight()) {
1222                         Boolean res = isValid.right().value();
1223                         if (res == false) {
1224                                 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(DaoStatusConverter.convertTitanStatusToStorageStatus(TitanOperationStatus.ILLEGAL_ARGUMENT))));
1225                         }
1226                 } else {
1227                         Object object = isValid.left().value();
1228                         if (object != null) {
1229                                 newValue = object.toString();
1230                         }
1231                 }
1232
1233                 try {
1234                         List<ComponentInstanceInput> instanceProperties = containerComponent.getComponentInstancesInputs().get(resourceInstanceId);
1235                         Optional<ComponentInstanceInput> instanceProperty = instanceProperties.stream().filter(p -> p.getUniqueId().equals(property.getUniqueId())).findAny();
1236                         StorageOperationStatus status;
1237                         if(instanceProperty.isPresent()){
1238                                 instanceProperty.get().setValue(property.getValue());
1239                                 status = toscaOperationFacade.updateComponentInstanceInput(containerComponent, foundResourceInstance.getUniqueId(), property);
1240                         } else {
1241                                 status = toscaOperationFacade.addComponentInstanceInput(containerComponent, foundResourceInstance.getUniqueId(), property);
1242                         }
1243                         if(status != StorageOperationStatus.OK){
1244                                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
1245                                 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1246                                 return resultOp;
1247                         }
1248                         foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
1249                         Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
1250
1251                         if (updateContainerRes.isRight()) {
1252                                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
1253                                 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1254                                 return resultOp;
1255                         }
1256                 resultOp = Either.left(property);
1257                 return resultOp;
1258
1259                 } finally {
1260                         if (resultOp == null || resultOp.isRight()) {
1261                                 titanDao.rollback();
1262                         } else {
1263                                 titanDao.commit();
1264                         }
1265                         // unlock resource
1266                         graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
1267                 }
1268
1269         }
1270
1271         public Either<ComponentInstanceProperty, ResponseFormat> createOrUpdateGroupInstancePropertyValue(ComponentTypeEnum componentTypeEnum, String componentId, String resourceInstanceId, String groupInstanceId, ComponentInstanceProperty property,
1272                         String userId) {
1273
1274                 Either<ComponentInstanceProperty, ResponseFormat> resultOp = null;
1275
1276                 Either<User, ResponseFormat> resp = validateUserExists(userId, "create Or Update Property Value", false);
1277                 if (resp.isRight()) {
1278                         return Either.right(resp.right().value());
1279                 }
1280
1281                 if (componentTypeEnum == null) {
1282                         BeEcompErrorManager.getInstance().logInvalidInputError("CreateOrUpdatePropertyValue", "invalid component type", ErrorSeverity.INFO);
1283                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
1284                         return resultOp;
1285                 }
1286
1287                 if (!ComponentValidationUtils.canWorkOnComponent(componentId, toscaOperationFacade, userId)) {
1288                         log.info("Restricted operation for user: {} on service: {}", userId, componentId);
1289                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
1290                         return resultOp;
1291                 }
1292                 // lock resource
1293                 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
1294                 if (lockStatus != StorageOperationStatus.OK) {
1295                         log.debug("Failed to lock service {}", componentId);
1296                         resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
1297                         return resultOp;
1298                 }
1299                 try {
1300                         String propertyValueUid = property.getValueUniqueUid();
1301
1302                         if (propertyValueUid == null) {
1303
1304                                 Either<Integer, StorageOperationStatus> counterRes = groupInstanceOperation.increaseAndGetGroupInstancePropertyCounter(groupInstanceId);
1305
1306                                 if (counterRes.isRight()) {
1307                                         log.debug("increaseAndGetResourcePropertyCounter failed resource instance: {} property: {}", resourceInstanceId, property);
1308                                         StorageOperationStatus status = counterRes.right().value();
1309                                         ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
1310                                         resultOp = Either.right(componentsUtils.getResponseFormat(actionStatus));
1311                                 }
1312                                 Integer index = counterRes.left().value();
1313                                 Either<ComponentInstanceProperty, StorageOperationStatus> result = groupInstanceOperation.addPropertyValueToGroupInstance(property, resourceInstanceId, index, true);
1314
1315                                 if (result.isLeft()) {
1316                                         log.trace("Property value was added to resource instance {}", resourceInstanceId);
1317                                         ComponentInstanceProperty instanceProperty = result.left().value();
1318
1319                                         resultOp = Either.left(instanceProperty);
1320
1321                                 } else {
1322                                         log.debug("Failed to add property value: {} to resource instance {}", property, resourceInstanceId);
1323
1324                                         ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
1325
1326                                         resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1327                                 }
1328
1329                         } else {
1330                                 Either<ComponentInstanceProperty, StorageOperationStatus> result = groupInstanceOperation.updatePropertyValueInGroupInstance(property, resourceInstanceId, true);
1331
1332                                 if (result.isLeft()) {
1333                                         log.debug("Property value {} was updated on graph.", property.getValueUniqueUid());
1334                                         ComponentInstanceProperty instanceProperty = result.left().value();
1335
1336                                         resultOp = Either.left(instanceProperty);
1337
1338                                 } else {
1339                                         log.debug("Failed to update property value: {}, in resource instance {}", property, resourceInstanceId);
1340
1341                                         ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
1342
1343                                         resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1344                                 }
1345                         }
1346                         if (resultOp.isLeft()) {
1347                                 StorageOperationStatus updateCustomizationUUID = componentInstanceOperation.updateCustomizationUUID(resourceInstanceId);
1348                                 if (updateCustomizationUUID != StorageOperationStatus.OK) {
1349                                         ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateCustomizationUUID);
1350
1351                                         resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1352
1353                                 }
1354                         }
1355                         return resultOp;
1356
1357                 } finally {
1358                         if (resultOp == null || resultOp.isRight()) {
1359                                 titanDao.rollback();
1360                         } else {
1361                                 titanDao.commit();
1362                         }
1363                         // unlock resource
1364                         graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
1365                 }
1366
1367         }
1368
1369         public Either<ComponentInstanceInput, ResponseFormat> createOrUpdateInputValue(ComponentTypeEnum componentTypeEnum, String componentId, String resourceInstanceId, ComponentInstanceInput inputProperty, String userId) {
1370
1371                 Either<ComponentInstanceInput, ResponseFormat> resultOp = null;
1372
1373                 Either<User, ResponseFormat> resp = validateUserExists(userId, "create Or Update Input Value", false);
1374                 if (resp.isRight()) {
1375                         return Either.right(resp.right().value());
1376                 }
1377
1378                 if (componentTypeEnum == null) {
1379                         BeEcompErrorManager.getInstance().logInvalidInputError("createOrUpdateInputValue", "invalid component type", ErrorSeverity.INFO);
1380                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
1381                         return resultOp;
1382                 }
1383
1384                 if (!ComponentValidationUtils.canWorkOnComponent(componentId, toscaOperationFacade, userId)) {
1385                         log.info("Restricted operation for user: {} on service: {}", userId, componentId);
1386                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
1387                         return resultOp;
1388                 }
1389                 // lock resource
1390                 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
1391                 if (lockStatus != StorageOperationStatus.OK) {
1392                         log.debug("Failed to lock service {}", componentId);
1393                         resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
1394                         return resultOp;
1395                 }
1396                 try {
1397                         String propertyValueUid = inputProperty.getValueUniqueUid();
1398                         if (propertyValueUid == null) {
1399
1400                                 Either<Integer, StorageOperationStatus> counterRes = componentInstanceOperation.increaseAndGetResourceInstanceSpecificCounter(resourceInstanceId, GraphPropertiesDictionary.INPUT_COUNTER, true);
1401
1402                                 if (counterRes.isRight()) {
1403                                         log.debug("increaseAndGetResourceInputCounter failed resource instance {} inputProperty {}", resourceInstanceId, inputProperty);
1404                                         StorageOperationStatus status = counterRes.right().value();
1405                                         ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
1406                                         resultOp = Either.right(componentsUtils.getResponseFormat(actionStatus));
1407                                 }
1408                                 Integer index = counterRes.left().value();
1409                                 Either<ComponentInstanceInput, StorageOperationStatus> result = componentInstanceOperation.addInputValueToResourceInstance(inputProperty, resourceInstanceId, index, true);
1410
1411                                 if (result.isLeft()) {
1412                                         log.debug("Property value was added to resource instance {}", resourceInstanceId);
1413                                         ComponentInstanceInput instanceProperty = result.left().value();
1414
1415                                         resultOp = Either.left(instanceProperty);
1416                                         return resultOp;
1417
1418                                 } else {
1419                                         log.debug("Failed to add input value {} to resource instance {}", inputProperty, resourceInstanceId);
1420
1421                                         ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
1422
1423                                         resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1424
1425                                         return resultOp;
1426                                 }
1427
1428                         } else {
1429                                 Either<ComponentInstanceInput, StorageOperationStatus> result = componentInstanceOperation.updateInputValueInResourceInstance(inputProperty, resourceInstanceId, true);
1430
1431                                 if (result.isLeft()) {
1432                                         log.debug("Input value {} was updated on graph.", inputProperty.getValueUniqueUid());
1433                                         ComponentInstanceInput instanceProperty = result.left().value();
1434
1435                                         resultOp = Either.left(instanceProperty);
1436                                         return resultOp;
1437
1438                                 } else {
1439                                         log.debug("Failed to update property value {} in resource instance {}", inputProperty, resourceInstanceId);
1440
1441                                         ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
1442
1443                                         resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1444
1445                                         return resultOp;
1446                                 }
1447                         }
1448
1449                 } finally {
1450                         if (resultOp == null || resultOp.isRight()) {
1451                                 titanDao.rollback();
1452                         } else {
1453                                 titanDao.commit();
1454                         }
1455                         // unlock resource
1456                         graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
1457                 }
1458
1459         }
1460
1461         public Either<ComponentInstanceProperty, ResponseFormat> deletePropertyValue(ComponentTypeEnum componentTypeEnum, String serviceId, String resourceInstanceId, String propertyValueId, String userId) {
1462
1463                 Either<User, ResponseFormat> resp = validateUserExists(userId, "delete Property Value", false);
1464                 if (resp.isRight()) {
1465                         return Either.right(resp.right().value());
1466                 }
1467
1468                 Either<ComponentInstanceProperty, ResponseFormat> resultOp = null;
1469
1470                 if (componentTypeEnum == null) {
1471                         BeEcompErrorManager.getInstance().logInvalidInputError("CreateOrUpdatePropertyValue", "invalid component type", ErrorSeverity.INFO);
1472                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
1473                         return resultOp;
1474                 }
1475
1476                 if (!ComponentValidationUtils.canWorkOnComponent(serviceId, toscaOperationFacade, userId)) {
1477                         log.info("Restricted operation for user {} on service {}", userId, serviceId);
1478                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
1479                         return resultOp;
1480                 }
1481                 // lock resource
1482                 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(serviceId, componentTypeEnum.getNodeType());
1483                 if (lockStatus != StorageOperationStatus.OK) {
1484                         log.debug("Failed to lock service {}", serviceId);
1485                         resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
1486                         return resultOp;
1487                 }
1488                 try {
1489                         Either<ComponentInstanceProperty, StorageOperationStatus> result = propertyOperation.removePropertyValueFromResourceInstance(propertyValueId, resourceInstanceId, true);
1490
1491                         if (result.isLeft()) {
1492                                 log.debug("Property value {} was removed from graph.", propertyValueId);
1493                                 ComponentInstanceProperty instanceProperty = result.left().value();
1494
1495                                 resultOp = Either.left(instanceProperty);
1496                                 return resultOp;
1497
1498                         } else {
1499                                 log.debug("Failed to remove property value {} in resource instance {}", propertyValueId, resourceInstanceId);
1500
1501                                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
1502
1503                                 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1504
1505                                 return resultOp;
1506                         }
1507
1508                 } finally {
1509                         if (resultOp == null || resultOp.isRight()) {
1510                                 titanDao.rollback();
1511                         } else {
1512                                 titanDao.commit();
1513                         }
1514                         // unlock resource
1515                         graphLockOperation.unlockComponent(serviceId, componentTypeEnum.getNodeType());
1516                 }
1517
1518         }
1519
1520         private Either<Component, ResponseFormat> getAndValidateOriginComponentOfComponentInstance(ComponentTypeEnum containerComponentType, ComponentInstance componentInstance) {
1521
1522                 Either<Component, ResponseFormat> eitherResponse = null;
1523                 ComponentTypeEnum componentType = getComponentTypeByParentComponentType(containerComponentType);
1524                 Component component;
1525                 ResponseFormat errorResponse;
1526                 Either<Component, StorageOperationStatus> getComponentRes = toscaOperationFacade.getToscaFullElement(componentInstance.getComponentUid());
1527                 if (getComponentRes.isRight()) {
1528                         log.debug("Failed to get the component with id {} for component instance {} creation. ", componentInstance.getComponentUid(), componentInstance.getName());
1529                         ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getComponentRes.right().value(), componentType);
1530                         errorResponse = componentsUtils.getResponseFormat(actionStatus, Constants.EMPTY_STRING);
1531                         eitherResponse = Either.right(errorResponse);
1532                 }
1533                 if(eitherResponse == null) {
1534                         component = getComponentRes.left().value();
1535                         LifecycleStateEnum resourceCurrState = component.getLifecycleState();
1536                         if (resourceCurrState == LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT) {
1537                                 ActionStatus actionStatus = ActionStatus.ILLEGAL_COMPONENT_STATE;
1538                                 errorResponse = componentsUtils.getResponseFormat(actionStatus, component.getComponentType().toString(), component.getName(), resourceCurrState.toString());
1539                                 eitherResponse =  Either.right(errorResponse);
1540                         }
1541                 }
1542                 if(eitherResponse == null) {
1543                         eitherResponse = Either.left(getComponentRes.left().value());
1544                 }
1545                 return eitherResponse;
1546         }
1547
1548         public Either<ComponentInstance, ResponseFormat> changeComponentInstanceVersion(String containerComponentParam, String containerComponentId, String componentInstanceId, String userId, ComponentInstance newComponentInstance) {
1549
1550                 Either<User, ResponseFormat> resp = validateUserExists(userId, "change Component Instance Version", false);
1551                 if (resp.isRight()) {
1552                         return Either.right(resp.right().value());
1553                 }
1554
1555                 User user = resp.left().value();
1556                 Either<ComponentInstance, ResponseFormat> resultOp = null;
1557
1558                 Either<ComponentTypeEnum, ResponseFormat> validateComponentType = validateComponentType(containerComponentParam);
1559                 if (validateComponentType.isRight()) {
1560                         return Either.right(validateComponentType.right().value());
1561                 }
1562
1563                 final ComponentTypeEnum containerComponentType = validateComponentType.left().value();
1564
1565                 Either<org.openecomp.sdc.be.model.Component, ResponseFormat> validateComponentExists = validateComponentExists(containerComponentId, containerComponentType, null);
1566                 if (validateComponentExists.isRight()) {
1567                         return Either.right(validateComponentExists.right().value());
1568                 }
1569                 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists.left().value();
1570
1571                 Either<Boolean, ResponseFormat> validateCanWorkOnComponent = validateCanWorkOnComponent(containerComponent, userId);
1572                 if (validateCanWorkOnComponent.isRight()) {
1573                         return Either.right(validateCanWorkOnComponent.right().value());
1574                 }
1575
1576                 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,componentInstanceId);
1577                 if (resourceInstanceStatus.isRight()) {
1578                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceId, containerComponentId));
1579                         return resultOp;
1580                 }
1581
1582                 ComponentInstance currentResourceInstance = resourceInstanceStatus.left().value();
1583
1584                 Either<Boolean, ResponseFormat> lockComponent = lockComponent(containerComponent, "changeComponentInstanceVersion");
1585                 if (lockComponent.isRight()) {
1586                         return Either.right(lockComponent.right().value());
1587                 }
1588
1589                 try {
1590                         if (currentResourceInstance.getComponentUid().equals(newComponentInstance.getComponentUid())) {
1591                                 resultOp = Either.left(currentResourceInstance);
1592                                 return resultOp;
1593
1594                         }
1595                         String resourceId = newComponentInstance.getComponentUid();
1596                         Either<Boolean, StorageOperationStatus> componentExistsRes = toscaOperationFacade.validateComponentExists(resourceId);
1597                         if(componentExistsRes.isRight()){
1598                                 log.debug("Failed to validate existing of the component {}. Status is {} ", resourceId);
1599                                 resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(componentExistsRes.right().value()), resourceId));
1600                                 return resultOp;
1601                         }
1602                         else if (!componentExistsRes.left().value()) {
1603                                 log.debug("The resource {} not found ", resourceId);
1604                                 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, resourceId));
1605                                 return resultOp;
1606                         }
1607
1608                 //      List<GroupInstance> groupInstances = currentResourceInstance.getGroupInstances();
1609                         Map<String, ArtifactDefinition> deploymentArtifacts =  currentResourceInstance.getDeploymentArtifacts();
1610                         resultOp = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentType);
1611                         if (resultOp.isRight()) {
1612                                 log.debug("failed to delete resource instance {}", resourceId);
1613                                 return resultOp;
1614                         }
1615
1616                         Either<Component, ResponseFormat> eitherResourceName = getOriginComponentNameFromComponentInstance(newComponentInstance, true);
1617
1618                         if (eitherResourceName.isRight()) {
1619                                 resultOp = Either.right(eitherResourceName.right().value());
1620                                 return resultOp;
1621                         }
1622
1623                         Component origComponent = eitherResourceName.left().value();
1624
1625                         ComponentInstance resResourceInfo = resultOp.left().value();
1626                         newComponentInstance.setName(resResourceInfo.getName());
1627                         newComponentInstance.setPosX(resResourceInfo.getPosX());
1628                         newComponentInstance.setPosY(resResourceInfo.getPosY());
1629                         newComponentInstance.setDescription(resResourceInfo.getDescription());
1630
1631                         resultOp = createComponentInstanceOnGraph(containerComponent, origComponent, newComponentInstance, user);
1632
1633                         if (resultOp.isRight()) {
1634                                 log.debug("failed to create resource instance {}", resourceId);
1635                                 return resultOp;
1636                         }
1637
1638                         ComponentInstance updatedComponentInstance = resultOp.left().value();
1639                         if (resultOp.isRight()) {
1640                                 log.debug("failed to create resource instance {}", resourceId);
1641                                 return resultOp;
1642                         }
1643
1644         /*              if (CollectionUtils.isNotEmpty(groupInstances)) {
1645                                 StorageOperationStatus addGroupsToComponentInstance = toscaOperationFacade.addGroupInstancesToComponentInstance(containerComponent, updatedComponentInstance, groupInstances);
1646                                 if (addGroupsToComponentInstance != StorageOperationStatus.OK) {
1647                                         BeEcompErrorManager.getInstance().logInternalFlowError("ChangeComponentInstanceVersion", "Failed to associate groups to new component instance", ErrorSeverity.ERROR);
1648                                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1649                                         return resultOp;
1650                                 }
1651
1652
1653                         }
1654                         if (MapUtils.isNotEmpty(deploymentArtifacts)) {
1655                                 StorageOperationStatus addDeploymentArtifactsToComponentInstance = toscaOperationFacade.addDeploymentArtifactsToComponentInstance(containerComponent, updatedComponentInstance, deploymentArtifacts);
1656                                 if (addDeploymentArtifactsToComponentInstance != StorageOperationStatus.OK) {
1657                                         BeEcompErrorManager.getInstance().logInternalFlowError("ChangeComponentInstanceVersion", "Failed to associate groups to new component instance", ErrorSeverity.ERROR);
1658                                         resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1659                                         return resultOp;
1660                                 }
1661                         }*/
1662
1663
1664                         ComponentParametersView filter = new ComponentParametersView(true);
1665                         filter.setIgnoreComponentInstances(false);
1666                         Either<Component, StorageOperationStatus> updatedComponentRes  = toscaOperationFacade.getToscaElement(containerComponentId, filter);
1667                         if (updatedComponentRes.isRight()) {
1668                                 StorageOperationStatus storageOperationStatus = updatedComponentRes.right().value();
1669                                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(storageOperationStatus, containerComponent.getComponentType());
1670                                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(actionStatus, Constants.EMPTY_STRING);
1671                                 log.debug("Component with id {} was not found", containerComponentId);
1672                                 return Either.right(responseFormat);
1673                         }
1674                         resourceInstanceStatus = getResourceInstanceById(updatedComponentRes.left().value(),updatedComponentInstance.getUniqueId());
1675                         if (resourceInstanceStatus.isRight()) {
1676                                 resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(resourceInstanceStatus.right().value()), updatedComponentInstance.getUniqueId()));
1677                                 return resultOp;
1678                         }
1679                         resultOp = Either.left(resourceInstanceStatus.left().value());
1680                         return resultOp;
1681
1682                 } finally {
1683                         unlockComponent(resultOp, containerComponent);
1684                 }
1685         }
1686
1687         protected abstract Either<Boolean, ResponseFormat> validateAllowedToContainCompInstances(org.openecomp.sdc.be.model.Component containerComponent);
1688
1689         protected abstract NodeTypeEnum getNodeTypeOfComponentInstanceOrigin();
1690
1691         protected abstract ComponentTypeEnum getComponentTypeOfComponentInstance();
1692
1693         // US831698
1694         public Either<List<ComponentInstanceProperty>, ResponseFormat> getComponentInstancePropertiesById(String containerComponentTypeParam, String containerComponentId, String componentInstanceUniqueId, String userId) {
1695                 final String ECOMP_ERROR_CONTEXT = "Get Component Instance Properties By Id";
1696                 Component containerComponent = null;
1697
1698                 Either<List<ComponentInstanceProperty>, ResponseFormat> resultOp = null;
1699                 try {
1700                         Either<User, ResponseFormat> validateUserExists = validateUserExists(userId, ECOMP_ERROR_CONTEXT, false);
1701                         if (validateUserExists.isRight()) {
1702                                 resultOp = Either.right(validateUserExists.right().value());
1703                                 return resultOp;
1704                         }
1705
1706                         Either<ComponentTypeEnum, ResponseFormat> validateComponentType = validateComponentType(containerComponentTypeParam);
1707                         if (validateComponentType.isRight()) {
1708                                 resultOp = Either.right(validateComponentType.right().value());
1709                                 return resultOp;
1710                         }
1711
1712                         Either<Component, StorageOperationStatus> validateContainerComponentExists = toscaOperationFacade.getToscaElement(containerComponentId);
1713                         if (validateContainerComponentExists.isRight()) {
1714                                 resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(validateContainerComponentExists.right().value())));
1715                                 return resultOp;
1716                         }
1717                         containerComponent = validateContainerComponentExists.left().value();
1718
1719                         Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, componentInstanceUniqueId);
1720                         if (resourceInstanceStatus.isRight()) {
1721                                 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId));
1722                                 return resultOp;
1723                         }
1724
1725                         List<ComponentInstanceProperty> instanceProperties = containerComponent.getComponentInstancesProperties().get(componentInstanceUniqueId);
1726                         if(CollectionUtils.isEmpty(instanceProperties)){
1727                                 instanceProperties = new ArrayList<>();
1728                         }
1729                         resultOp = Either.left(instanceProperties);
1730                         return resultOp;
1731                 } finally {
1732                         unlockComponent(resultOp, containerComponent);
1733                 }
1734         }
1735
1736         protected void validateIncrementCounter(String resourceInstanceId, GraphPropertiesDictionary counterType, Wrapper<Integer> instaceCounterWrapper, Wrapper<ResponseFormat> errorWrapper) {
1737                 Either<Integer, StorageOperationStatus> counterRes = componentInstanceOperation.increaseAndGetResourceInstanceSpecificCounter(resourceInstanceId, counterType, true);
1738
1739                 if (counterRes.isRight()) {
1740                         log.debug("increase And Get {} failed resource instance {}", counterType.name(), resourceInstanceId);
1741                         StorageOperationStatus status = counterRes.right().value();
1742                         ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
1743                         errorWrapper.setInnerElement(componentsUtils.getResponseFormat(actionStatus));
1744                 } else {
1745                         instaceCounterWrapper.setInnerElement(counterRes.left().value());
1746                 }
1747
1748         }
1749
1750         /**
1751          * updates componentInstance modificationTime
1752          *
1753          * @param componentInstance
1754          * @param componentInstanceType
1755          * @param modificationTime
1756          * @param inTransaction
1757          * @return
1758          */
1759         public Either<ComponentInstanceData, ResponseFormat> updateComponentInstanceModificationTimeAndCustomizationUuid(ComponentInstance componentInstance, NodeTypeEnum componentInstanceType, Long modificationTime, boolean inTransaction) {
1760                 Either<ComponentInstanceData, ResponseFormat> result;
1761                 Either<ComponentInstanceData, StorageOperationStatus> updateComponentInstanceRes = componentInstanceOperation.updateComponentInstanceModificationTimeAndCustomizationUuidOnGraph(componentInstance, componentInstanceType, modificationTime,
1762                                 inTransaction);
1763                 if (updateComponentInstanceRes.isRight()) {
1764                         log.debug("Failed to update component instance {} with new last update date and mofifier. Status is {}. ", componentInstance.getName(), updateComponentInstanceRes.right().value());
1765                         result = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(updateComponentInstanceRes.right().value())));
1766                 } else {
1767                         result = Either.left(updateComponentInstanceRes.left().value());
1768                 }
1769                 return result;
1770         }
1771
1772         private Boolean validateInstanceNameUniqueness(Component containerComponent, ComponentInstance oldComponentInstance, String newInstanceName) {
1773                 Boolean isUnique = true;
1774                 String newInstanceNormalizedName = ValidationUtils.normalizeComponentInstanceName(newInstanceName);
1775                 if (!oldComponentInstance.getNormalizedName().equals(newInstanceNormalizedName)) {
1776                         Optional<ComponentInstance> foundComponentInstance = containerComponent.getComponentInstances().stream().filter(ci -> ci.getNormalizedName().equals(newInstanceNormalizedName)).findFirst();
1777                         if (foundComponentInstance.isPresent()) {
1778                                 isUnique = false;
1779                         }
1780                         if (isUnique) {
1781                                 foundComponentInstance = containerComponent.getComponentInstances().stream().filter(ci -> ci.getUniqueId().endsWith(newInstanceNormalizedName)).findFirst();
1782                                 if (foundComponentInstance.isPresent()) {
1783                                         isUnique = false;
1784                                 }
1785                         }
1786                 }
1787                 return isUnique;
1788         }
1789
1790         private Boolean validateInstanceNameUniquenessUponUpdate(Component containerComponent, ComponentInstance oldComponentInstance, String newInstanceName) {
1791                 Boolean isUnique = true;
1792                 String newInstanceNormalizedName = ValidationUtils.normalizeComponentInstanceName(newInstanceName);
1793                 if (!oldComponentInstance.getNormalizedName().equals(newInstanceNormalizedName)) {
1794                         Optional<ComponentInstance> foundComponentInstance = containerComponent.getComponentInstances().stream().filter(ci -> ci.getNormalizedName().equals(newInstanceNormalizedName)).findFirst();
1795                         if (foundComponentInstance.isPresent()) {
1796                                 isUnique = false;
1797                         }
1798                 }
1799                 return isUnique;
1800         }
1801
1802         private Either<ComponentInstance, StorageOperationStatus> getResourceInstanceById(Component containerComponent, String instanceId) {
1803
1804                 Either<ComponentInstance, StorageOperationStatus> result = null;
1805                 List<ComponentInstance> instances = containerComponent.getComponentInstances();
1806                 Optional<ComponentInstance> foundInstance = null;
1807                 if(CollectionUtils.isEmpty(instances)){
1808                         result = Either.right(StorageOperationStatus.NOT_FOUND);
1809                 }
1810                 if(result == null){
1811                         foundInstance = instances.stream().filter(i -> i.getUniqueId().equals(instanceId)).findFirst();
1812                         if(!foundInstance.isPresent()){
1813                                 result = Either.right(StorageOperationStatus.NOT_FOUND);
1814                         }
1815                 }
1816                 if(result == null){
1817                         result = Either.left(foundInstance.get());
1818                 }
1819                 return result;
1820         }
1821 }