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

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.openecomp.sdc.be.components.impl;
  17
  18 import fj.data.Either;
  19 import java.util.ArrayList;
  20 import java.util.Collection;
  21 import java.util.Collections;
  22 import java.util.List;
  23 import java.util.Map;
  24 import java.util.Objects;
  25 import java.util.Optional;
  26 import java.util.UUID;
  27 import java.util.stream.Collectors;
  28 import org.apache.commons.collections.CollectionUtils;
  29 import org.apache.commons.lang3.StringUtils;
  30 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  31 import org.openecomp.sdc.be.components.validation.RequirementValidation;
  32 import org.openecomp.sdc.be.dao.api.ActionStatus;
  33 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  34 import org.openecomp.sdc.be.model.ComponentParametersView;
  35 import org.openecomp.sdc.be.model.RequirementDefinition;
  36 import org.openecomp.sdc.be.model.User;
  37 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
  38 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
  39 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.RequirementOperation;
  40 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  41 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
  42 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
  43 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
  44 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  45 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
  46 import org.openecomp.sdc.exception.ResponseFormat;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49 import org.springframework.beans.factory.annotation.Autowired;
  50 import org.springframework.stereotype.Component;
  51
  52 @Component("requirementBusinessLogic")
  53 public class RequirementBusinessLogic extends BaseBusinessLogic {
  54
  55     private static final Logger LOGGER = LoggerFactory.getLogger(RequirementBusinessLogic.class);
  56     private static final String FAILED_TO_LOCK_COMPONENT_RESPONSE_IS = "Failed to lock component {}. Response is {}";
  57     private static final String DELETE_REQUIREMENTS = "deleteRequirement";
  58     private static final String GET_REQUIREMENTS = "getRequirements";
  59     private static final String EXCEPTION_OCCURRED_DURING_REQUIREMENTS = "Exception occurred during {}. Response is {}";
  60     private RequirementOperation requirementOperation;
  61     private RequirementValidation requirementValidation;
  62
  63     @Autowired
  64     public RequirementBusinessLogic(IElementOperation elementDao, IGroupOperation groupOperation, IGroupInstanceOperation groupInstanceOperation,
  65                                     IGroupTypeOperation groupTypeOperation, InterfaceOperation interfaceOperation,
  66                                     InterfaceLifecycleOperation interfaceLifecycleTypeOperation, ArtifactsOperations artifactToscaOperation) {
  67         super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation,
  68             artifactToscaOperation);
  69     }
  70
  71     @Autowired
  72     public void setRequirementOperation(RequirementOperation requirementOperation) {
  73         this.requirementOperation = requirementOperation;
  74     }
  75
  76     @Autowired
  77     public void setRequirementValidation(RequirementValidation requirementValidation) {
  78         this.requirementValidation = requirementValidation;
  79     }
  80
  81     public Either<List<RequirementDefinition>, ResponseFormat> createRequirements(String componentId,
  82                                                                                   List<RequirementDefinition> requirementDefinitions, User user,
  83                                                                                   String errorContext, boolean lock) {
  84         validateUserExists(user.getUserId());
  85         Either<org.openecomp.sdc.be.model.Component, ResponseFormat> componentEither = getComponentDetails(componentId);
  86         if (componentEither.isRight()) {
  87             return Either.right(componentEither.right().value());
  88         }
  89         org.openecomp.sdc.be.model.Component storedComponent = componentEither.left().value();
  90         Either<Boolean, ResponseFormat> requirementsValidationEither = requirementValidation
  91             .validateRequirements(requirementDefinitions, storedComponent, false);
  92         if (requirementsValidationEither.isRight()) {
  93             return Either.right(requirementsValidationEither.right().value());
  94         }
  95         Either<Boolean, ResponseFormat> lockResult = lockComponentResult(lock, storedComponent, errorContext);
  96         if (lockResult.isRight()) {
  97             return Either.right(lockResult.right().value());
  98         }
  99         try {
 100             Either<List<RequirementDefinition>, StorageOperationStatus> result;
 101             List<RequirementDefinition> requirementsListStoredInComponent = null;
 102             Map<String, List<RequirementDefinition>> storedComponentRequirements = storedComponent.getRequirements();
 103             if (org.apache.commons.collections.MapUtils.isNotEmpty(storedComponentRequirements)) {
 104                 RequirementDefinition requirementDefinitionToGetType = requirementDefinitions.get(0);
 105                 if (Objects.isNull(requirementDefinitionToGetType)) {
 106                     return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
 107                 }
 108                 requirementsListStoredInComponent = getRequirementStoredInComponentByType(requirementDefinitionToGetType.getCapability(),
 109                     storedComponentRequirements);
 110             }
 111             List<RequirementDefinition> requirementsToReturn;
 112             if (org.apache.commons.collections.CollectionUtils.isNotEmpty(requirementsListStoredInComponent)) {
 113                 List<RequirementDefinition> requirementDefToCreate = requirementDefinitions.stream()
 114                     .map(requirementDefinition -> initiateNewRequirement(storedComponent, requirementDefinition)).collect(Collectors.toList());
 115                 requirementsToReturn = requirementDefToCreate;
 116                 requirementDefToCreate.addAll(requirementsListStoredInComponent);
 117                 result = requirementOperation.updateRequirement(componentId, requirementDefToCreate);
 118             } else {
 119                 requirementsToReturn = requirementDefinitions.stream()
 120                     .map(requirementDefinition -> initiateNewRequirement(storedComponent, requirementDefinition)).collect(Collectors.toList());
 121                 result = requirementOperation.addRequirement(componentId, requirementsToReturn);
 122             }
 123             if (result.isRight()) {
 124                 janusGraphDao.rollback();
 125                 return Either.right(componentsUtils
 126                     .getResponseFormat(componentsUtils.convertFromStorageResponse(result.right().value(), storedComponent.getComponentType()), ""));
 127             }
 128             janusGraphDao.commit();
 129             return Either.left(requirementsToReturn);
 130         } catch (Exception e) {
 131             janusGraphDao.rollback();
 132             LOGGER.error(EXCEPTION_OCCURRED_DURING_REQUIREMENTS, "addOrUpdate", e);
 133             return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
 134         } finally {
 135             if (lockResult.isLeft() && lockResult.left().value()) {
 136                 graphLockOperation
 137                     .unlockComponent(storedComponent.getUniqueId(), NodeTypeEnum.getByNameIgnoreCase(storedComponent.getComponentType().getValue()));
 138             }
 139         }
 140     }
 141
 142     public Either<List<RequirementDefinition>, ResponseFormat> updateRequirements(String componentId,
 143                                                                                   List<RequirementDefinition> requirementDefinitions, User user,
 144                                                                                   String errorContext, boolean lock) {
 145         validateUserExists(user.getUserId());
 146         Either<org.openecomp.sdc.be.model.Component, ResponseFormat> componentEither = getComponentDetails(componentId);
 147         if (componentEither.isRight()) {
 148             return Either.right(componentEither.right().value());
 149         }
 150         org.openecomp.sdc.be.model.Component storedComponent = componentEither.left().value();
 151         Either<Boolean, ResponseFormat> requirementsValidationEither = requirementValidation
 152             .validateRequirements(requirementDefinitions, storedComponent, true);
 153         if (requirementsValidationEither.isRight()) {
 154             return Either.right(requirementsValidationEither.right().value());
 155         }
 156         Either<Boolean, ResponseFormat> lockResult = lockComponentResult(lock, storedComponent, errorContext);
 157         if (lockResult.isRight()) {
 158             return Either.right(lockResult.right().value());
 159         }
 160         try {
 161             Either<List<RequirementDefinition>, StorageOperationStatus> result;
 162             List<RequirementDefinition> requirementsListStoredInComponent = null;
 163             Map<String, List<RequirementDefinition>> storedComponentRequirements = storedComponent.getRequirements();
 164             if (org.apache.commons.collections.MapUtils.isNotEmpty(storedComponentRequirements)) {
 165                 RequirementDefinition requirementDefinitionToGetType = requirementDefinitions.get(0);
 166                 if (Objects.isNull(requirementDefinitionToGetType)) {
 167                     return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
 168                 }
 169                 requirementsListStoredInComponent = getRequirementStoredInComponentByType(requirementDefinitionToGetType.getCapability(),
 170                     storedComponentRequirements);
 171             }
 172             List<RequirementDefinition> requirementsToReturn = null;
 173             if (org.apache.commons.collections.CollectionUtils.isNotEmpty(requirementsListStoredInComponent)) {
 174                 List<RequirementDefinition> requirementDefToUpdate = new ArrayList<>();
 175                 if (requirementDefinitions.stream()
 176                     .anyMatch(requirementDefinition -> isRequirementUsedInServiceComposition(requirementDefinition, storedComponent))) {
 177                     LOGGER.error("Requirement can't be edited, since it is used in service composition");
 178                     return Either.right(componentsUtils.getResponseFormat(ActionStatus.REQUIREMENT_UPDATE_NOT_ALLOWED_USED_IN_COMPOSITION));
 179                 }
 180                 for (RequirementDefinition requirementDefinitionToUpdate : requirementDefinitions) {
 181                     requirementsToReturn = requirementsListStoredInComponent.stream()
 182                         .filter(reqToUpdate -> reqToUpdate.getUniqueId().equals(requirementDefinitionToUpdate.getUniqueId()))
 183                         .map(requirementDefinition -> updateRequirement(requirementDefinition, requirementDefinitionToUpdate))
 184                         .collect(Collectors.toList());
 185                     requirementsListStoredInComponent
 186                         .removeIf(reqToUpdate -> reqToUpdate.getUniqueId().equals(requirementDefinitionToUpdate.getUniqueId()));
 187                     if (CollectionUtils.isNotEmpty(requirementsToReturn)) {
 188                         requirementsListStoredInComponent.addAll(requirementsToReturn);
 189                         requirementDefToUpdate.addAll(requirementsListStoredInComponent);
 190                     } else {
 191                         Either<List<RequirementDefinition>, ResponseFormat> updateCapTypeEither = handleUpdateRequirementCapabilityWhenNewCapabilityExist(
 192                             storedComponent, storedComponentRequirements, requirementsToReturn, requirementDefinitionToUpdate);
 193                         if (updateCapTypeEither.isRight()) {
 194                             return Either.right(updateCapTypeEither.right().value());
 195                         }
 196                         requirementDefToUpdate = updateCapTypeEither.left().value();
 197                     }
 198                 }
 199                 result = requirementOperation.updateRequirement(componentId, requirementDefToUpdate);
 200             } else {
 201                 Either<List<RequirementDefinition>, ResponseFormat> requirementDefinitionToDelete = handleRequirementCapabilityUpdateWhenNewCapabilityNotExist(
 202                     requirementDefinitions, storedComponent, storedComponentRequirements);
 203                 if (requirementDefinitionToDelete != null) {
 204                     return requirementDefinitionToDelete;
 205                 }
 206                 requirementsToReturn = requirementDefinitions.stream()
 207                     .map(requirementDefinition -> initiateNewRequirement(storedComponent, requirementDefinition)).collect(Collectors.toList());
 208                 result = requirementOperation.addRequirement(componentId, requirementsToReturn);
 209             }
 210             if (result.isRight()) {
 211                 janusGraphDao.rollback();
 212                 return Either.right(componentsUtils
 213                     .getResponseFormat(componentsUtils.convertFromStorageResponse(result.right().value(), storedComponent.getComponentType()), ""));
 214             }
 215             janusGraphDao.commit();
 216             return Either.left(requirementsToReturn);
 217         } catch (Exception e) {
 218             janusGraphDao.rollback();
 219             LOGGER.error(EXCEPTION_OCCURRED_DURING_REQUIREMENTS, "addOrUpdate", e);
 220             return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
 221         } finally {
 222             if (lockResult.isLeft() && lockResult.left().value()) {
 223                 graphLockOperation
 224                     .unlockComponent(storedComponent.getUniqueId(), NodeTypeEnum.getByNameIgnoreCase(storedComponent.getComponentType().getValue()));
 225             }
 226         }
 227     }
 228
 229     private Either<List<RequirementDefinition>, ResponseFormat> handleUpdateRequirementCapabilityWhenNewCapabilityExist(
 230         org.openecomp.sdc.be.model.Component storedComponent, Map<String, List<RequirementDefinition>> storedComponentRequirements,
 231         List<RequirementDefinition> requirementsToReturn, RequirementDefinition requirementDefinitionToUpdate) {
 232         List<RequirementDefinition> requirementsListStoredInComponent;
 233         List<RequirementDefinition> requirementDefsToCreateOrUpdate = new ArrayList<>();
 234         Optional<RequirementDefinition> definitionOptional = storedComponentRequirements.values().stream().flatMap(Collection::stream)
 235             .filter(requirementDefinition -> requirementDefinition.getUniqueId().equals(requirementDefinitionToUpdate.getUniqueId())).findAny();
 236         if (!definitionOptional.isPresent()) {
 237             return Either.right(componentsUtils.getResponseFormat(ActionStatus.REQUIREMENT_NOT_FOUND, storedComponent.getUniqueId()));
 238         }
 239         RequirementDefinition requirementDefinitionToDelete = definitionOptional.get();
 240         requirementsListStoredInComponent = getRequirementStoredInComponentByType(requirementDefinitionToUpdate.getCapability(),
 241             storedComponentRequirements);
 242         Either<List<RequirementDefinition>, StorageOperationStatus> deleteRequirementEither = deleteRequirement(storedComponent,
 243             storedComponentRequirements, requirementDefinitionToDelete);
 244         if (deleteRequirementEither.isRight()) {
 245             janusGraphDao.rollback();
 246             return Either.right(componentsUtils.getResponseFormat(deleteRequirementEither.right().value()));
 247         }
 248         requirementsToReturn.add(initiateNewRequirement(storedComponent, requirementDefinitionToUpdate));
 249         requirementDefsToCreateOrUpdate.addAll(requirementsToReturn);
 250         requirementDefsToCreateOrUpdate.addAll(requirementsListStoredInComponent);
 251         return Either.left(requirementDefsToCreateOrUpdate);
 252     }
 253
 254     private Either<List<RequirementDefinition>, ResponseFormat> handleRequirementCapabilityUpdateWhenNewCapabilityNotExist(
 255         List<RequirementDefinition> requirementDefinitions, org.openecomp.sdc.be.model.Component storedComponent,
 256         Map<String, List<RequirementDefinition>> storedComponentRequirements) {
 257         for (RequirementDefinition requirementDefinitionToUpdate : requirementDefinitions) {
 258             Optional<RequirementDefinition> definitionOptional = storedComponentRequirements.values().stream().flatMap(Collection::stream)
 259                 .filter(requirementDefinition -> requirementDefinition.getUniqueId().equals(requirementDefinitionToUpdate.getUniqueId())).findAny();
 260             if (!definitionOptional.isPresent()) {
 261                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.REQUIREMENT_NOT_FOUND, storedComponent.getUniqueId()));
 262             }
 263             RequirementDefinition requirementDefinitionToDelete = definitionOptional.get();
 264             Boolean isRequirementUsedInServiceComposition = isRequirementUsedInServiceComposition(requirementDefinitionToDelete, storedComponent);
 265             if (isRequirementUsedInServiceComposition) {
 266                 LOGGER.error("Requirement {} can't be edited, since it is used in service composition", requirementDefinitionToDelete.getUniqueId());
 267                 return Either.right(componentsUtils
 268                     .getResponseFormat(ActionStatus.REQUIREMENT_UPDATE_NOT_ALLOWED_USED_IN_COMPOSITION, requirementDefinitionToDelete.getName()));
 269             }
 270             Either<List<RequirementDefinition>, StorageOperationStatus> deleteRequirementEither = deleteRequirement(storedComponent,
 271                 storedComponentRequirements, requirementDefinitionToDelete);
 272             if (deleteRequirementEither.isRight()) {
 273                 janusGraphDao.rollback();
 274                 return Either.right(componentsUtils.getResponseFormat(deleteRequirementEither.right().value()));
 275             }
 276         }
 277         return null;
 278     }
 279
 280     public Either<RequirementDefinition, ResponseFormat> getRequirement(String componentId, String requirementIdToGet, User user, boolean lock) {
 281         validateUserExists(user.getUserId());
 282         Either<org.openecomp.sdc.be.model.Component, ResponseFormat> componentEither = getComponentDetails(componentId);
 283         if (componentEither.isRight()) {
 284             return Either.right(componentEither.right().value());
 285         }
 286         org.openecomp.sdc.be.model.Component storedComponent = componentEither.left().value();
 287         Either<Boolean, ResponseFormat> lockResult = lockComponentResult(lock, storedComponent, GET_REQUIREMENTS);
 288         if (lockResult.isRight()) {
 289             return Either.right(lockResult.right().value());
 290         }
 291         try {
 292             List<RequirementDefinition> requirementDefinitions = storedComponent.getRequirements().values().stream().flatMap(Collection::stream)
 293                 .collect(Collectors.toList());
 294             if (requirementDefinitions.isEmpty()) {
 295                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.REQUIREMENT_NOT_FOUND, componentId));
 296             }
 297             RequirementDefinition requirementDefinitionToReturn;
 298             Optional<RequirementDefinition> requirementDefinitionOptional = requirementDefinitions.stream()
 299                 .filter(requirementDefinition -> requirementDefinition.getUniqueId().equals(requirementIdToGet)).findAny();
 300             if (requirementDefinitionOptional.isPresent()) {
 301                 requirementDefinitionToReturn = requirementDefinitionOptional.get();
 302             } else {
 303                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.REQUIREMENT_NOT_FOUND, componentId));
 304             }
 305             return Either.left(requirementDefinitionToReturn);
 306         } catch (Exception e) {
 307             LOGGER.error(EXCEPTION_OCCURRED_DURING_REQUIREMENTS, "get", e);
 308             return Either.right(componentsUtils.getResponseFormat(ActionStatus.REQUIREMENT_NOT_FOUND, componentId));
 309         } finally {
 310             if (lockResult.isLeft() && lockResult.left().value()) {
 311                 graphLockOperation
 312                     .unlockComponent(storedComponent.getUniqueId(), NodeTypeEnum.getByNameIgnoreCase(storedComponent.getComponentType().getValue()));
 313             }
 314         }
 315     }
 316
 317     public Either<RequirementDefinition, ResponseFormat> deleteRequirement(String componentId, String requirementIdToDelete, User user,
 318                                                                            boolean lock) {
 319         validateUserExists(user.getUserId());
 320         Either<org.openecomp.sdc.be.model.Component, ResponseFormat> componentEither = getComponentDetails(componentId);
 321         if (componentEither.isRight()) {
 322             return Either.right(componentEither.right().value());
 323         }
 324         org.openecomp.sdc.be.model.Component storedComponent = componentEither.left().value();
 325         Either<Boolean, ResponseFormat> lockResult = lockComponentResult(lock, storedComponent, DELETE_REQUIREMENTS);
 326         if (lockResult.isRight()) {
 327             return Either.right(lockResult.right().value());
 328         }
 329         try {
 330             Map<String, List<RequirementDefinition>> storedComponentRequirements = storedComponent.getRequirements();
 331             if (storedComponentRequirements.isEmpty()) {
 332                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.REQUIREMENT_NOT_FOUND, componentId));
 333             }
 334             Optional<RequirementDefinition> definitionOptional = storedComponentRequirements.values().stream().flatMap(Collection::stream)
 335                 .filter(requirementDefinition -> requirementDefinition.getUniqueId().equals(requirementIdToDelete)).findAny();
 336             if (!definitionOptional.isPresent()) {
 337                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.REQUIREMENT_NOT_FOUND, componentId));
 338             }
 339             RequirementDefinition requirementDefinitionToDelete = definitionOptional.get();
 340             Boolean isRequirementUsedInServiceComposition = isRequirementUsedInServiceComposition(requirementDefinitionToDelete, storedComponent);
 341             if (isRequirementUsedInServiceComposition) {
 342                 LOGGER.error("Requirement {} can't be deleted, since it is used in service composition", requirementDefinitionToDelete.getUniqueId());
 343                 return Either.right(componentsUtils
 344                     .getResponseFormat(ActionStatus.CAPABILITY_DELETION_NOT_ALLOWED_USED_IN_COMPOSITION, requirementDefinitionToDelete.getName()));
 345             }
 346             Either<List<RequirementDefinition>, StorageOperationStatus> result = deleteRequirement(storedComponent, storedComponentRequirements,
 347                 requirementDefinitionToDelete);
 348             if (result.isRight()) {
 349                 janusGraphDao.rollback();
 350                 LOGGER.error("Failed to delete requirement  from component {}. Response is {}", storedComponent.getName(), result.right().value());
 351                 return Either.right(componentsUtils
 352                     .getResponseFormat(componentsUtils.convertFromStorageResponse(result.right().value(), storedComponent.getComponentType())));
 353             }
 354             janusGraphDao.commit();
 355             return Either.left(requirementDefinitionToDelete);
 356         } catch (Exception e) {
 357             LOGGER.error(EXCEPTION_OCCURRED_DURING_REQUIREMENTS, "delete", e);
 358             janusGraphDao.rollback();
 359             return Either.right(componentsUtils.getResponseFormat(ActionStatus.REQUIREMENT_NOT_FOUND));
 360         } finally {
 361             if (lockResult.isLeft() && lockResult.left().value()) {
 362                 graphLockOperation
 363                     .unlockComponent(storedComponent.getUniqueId(), NodeTypeEnum.getByNameIgnoreCase(storedComponent.getComponentType().getValue()));
 364             }
 365         }
 366     }
 367
 368     private Either<List<RequirementDefinition>, StorageOperationStatus> deleteRequirement(org.openecomp.sdc.be.model.Component storedComponent,
 369                                                                                           Map<String, List<RequirementDefinition>> storedComponentRequirements,
 370                                                                                           RequirementDefinition requirementDefinitionToDelete) {
 371         List<RequirementDefinition> requirementStoredInComponentByType = getRequirementStoredInComponentByType(
 372             requirementDefinitionToDelete.getCapability(), storedComponentRequirements);
 373         if (requirementStoredInComponentByType == null) {
 374             return Either.right(StorageOperationStatus.BAD_REQUEST);
 375         }
 376         requirementStoredInComponentByType
 377             .removeIf(requirementDefinition -> requirementDefinition.getUniqueId().equals(requirementDefinitionToDelete.getUniqueId()));
 378         Either<List<RequirementDefinition>, StorageOperationStatus> result;
 379         if (requirementStoredInComponentByType.isEmpty()) {
 380             StorageOperationStatus operationStatus = requirementOperation
 381                 .deleteRequirements(storedComponent, requirementDefinitionToDelete.getCapability());
 382             if (operationStatus.equals(StorageOperationStatus.OK)) {
 383                 result = Either.left(Collections.singletonList(requirementDefinitionToDelete));
 384             } else {
 385                 result = Either.right(operationStatus);
 386             }
 387         } else {
 388             result = requirementOperation.updateRequirement(storedComponent.getUniqueId(), requirementStoredInComponentByType);
 389         }
 390         return result;
 391     }
 392
 393     private Either<org.openecomp.sdc.be.model.Component, ResponseFormat> getComponentDetails(String componentId) {
 394         ComponentParametersView filter = new ComponentParametersView(true);
 395         filter.setIgnoreRequirements(false);
 396         Either<org.openecomp.sdc.be.model.Component, StorageOperationStatus> componentStorageOperationStatusEither = toscaOperationFacade
 397             .getToscaElement(componentId, filter);
 398         if (componentStorageOperationStatusEither.isRight()) {
 399             StorageOperationStatus errorStatus = componentStorageOperationStatusEither.right().value();
 400             LOGGER.error("Failed to fetch component information by component id {}, Response is {}", componentId, errorStatus);
 401             return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(errorStatus)));
 402         }
 403         return Either.left(componentStorageOperationStatusEither.left().value());
 404     }
 405
 406     private Either<Boolean, ResponseFormat> lockComponentResult(boolean lock, org.openecomp.sdc.be.model.Component component, String action) {
 407         if (lock) {
 408             try {
 409                 lockComponent(component.getUniqueId(), component, action);
 410             } catch (ComponentException e) {
 411                 LOGGER.debug(FAILED_TO_LOCK_COMPONENT_RESPONSE_IS, component.getName(), e.getMessage());
 412                 janusGraphDao.rollback();
 413                 throw e;
 414             }
 415         }
 416         return Either.left(true);
 417     }
 418
 419     private List<RequirementDefinition> getRequirementStoredInComponentByType(String capabilityType,
 420                                                                               Map<String, List<RequirementDefinition>> requirements) {
 421         Optional<Map.Entry<String, List<RequirementDefinition>>> entryOptional = requirements.entrySet().stream()
 422             .filter(map -> map.getKey().equals(capabilityType)).findFirst();
 423         return entryOptional.map(Map.Entry::getValue).orElse(null);
 424     }
 425
 426     private RequirementDefinition initiateNewRequirement(org.openecomp.sdc.be.model.Component component,
 427                                                          RequirementDefinition requirementDefinition) {
 428         if (StringUtils.isEmpty(requirementDefinition.getUniqueId())) {
 429             requirementDefinition.setUniqueId(UUID.randomUUID().toString());
 430         }
 431         if (StringUtils.isEmpty(requirementDefinition.getOwnerId())) {
 432             requirementDefinition.setOwnerId(component.getUniqueId());
 433         }
 434         if (StringUtils.isEmpty(requirementDefinition.getOwnerName())) {
 435             requirementDefinition.setOwnerName(component.getName());
 436         }
 437         requirementDefinition.setLeftOccurrences(requirementDefinition.getMaxOccurrences());
 438         return requirementDefinition;
 439     }
 440
 441     private RequirementDefinition updateRequirement(RequirementDefinition storedRequirement, RequirementDefinition requirementToUpdate) {
 442         storedRequirement.setName(requirementToUpdate.getName());
 443         storedRequirement.setCapability(requirementToUpdate.getCapability());
 444         storedRequirement.setNode(requirementToUpdate.getNode());
 445         storedRequirement.setRelationship(requirementToUpdate.getRelationship());
 446         storedRequirement.setMinOccurrences(requirementToUpdate.getMinOccurrences());
 447         storedRequirement.setMaxOccurrences(requirementToUpdate.getMaxOccurrences());
 448         return storedRequirement;
 449     }
 450
 451     private Boolean isRequirementUsedInServiceComposition(RequirementDefinition requirementDefinition,
 452                                                           org.openecomp.sdc.be.model.Component component) {
 453         Either<List<org.openecomp.sdc.be.model.Component>, StorageOperationStatus> componentList = toscaOperationFacade
 454             .getParentComponents(component.getUniqueId());
 455         if (componentList.isRight()) {
 456             return Boolean.FALSE;
 457         }
 458         return componentList.left().value().stream().flatMap(parentComponent -> parentComponent.getComponentInstancesRelations().stream())
 459             .flatMap(requirementCapabilityRelDef -> requirementCapabilityRelDef.getRelationships().stream()).anyMatch(
 460                 capabilityRequirementRelationship -> capabilityRequirementRelationship.getRelation().getRequirementUid()
 461                     .equals(requirementDefinition.getUniqueId()));
 462     }
 463 }