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