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