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

   1 /*
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2020 Nordix Foundation
   4  *  ================================================================================
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  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  *  SPDX-License-Identifier: Apache-2.0
  17  *  ============LICENSE_END=========================================================
  18  */
  19 package org.openecomp.sdc.be.components.impl;
  20
  21 import static org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR;
  22
  23 import fj.data.Either;
  24 import java.util.Arrays;
  25 import java.util.Collections;
  26 import java.util.Optional;
  27 import org.apache.commons.lang3.StringUtils;
  28 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
  29 import org.openecomp.sdc.be.components.impl.utils.NodeFilterConstraintAction;
  30 import org.openecomp.sdc.be.components.validation.NodeFilterValidator;
  31 import org.openecomp.sdc.be.dao.api.ActionStatus;
  32 import org.openecomp.sdc.be.datamodel.utils.ConstraintConvertor;
  33 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
  34 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  35 import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterCapabilityDataDefinition;
  36 import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterPropertyDataDefinition;
  37 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  38 import org.openecomp.sdc.be.datatypes.enums.NodeFilterConstraintType;
  39 import org.openecomp.sdc.be.model.Component;
  40 import org.openecomp.sdc.be.model.ComponentInstance;
  41 import org.openecomp.sdc.be.model.User;
  42 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
  43 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
  44 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
  45 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  46 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
  47 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
  48 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
  49 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  50 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
  51 import org.openecomp.sdc.be.ui.model.UIConstraint;
  52 import org.openecomp.sdc.be.user.Role;
  53 import org.openecomp.sdc.common.log.wrappers.Logger;
  54 import org.openecomp.sdc.exception.ResponseFormat;
  55 import org.springframework.beans.factory.annotation.Autowired;
  56
  57 @org.springframework.stereotype.Component("componentNodeFilterBusinessLogic")
  58 public class ComponentNodeFilterBusinessLogic extends BaseBusinessLogic {
  59
  60     private static final Logger LOGGER = Logger.getLogger(ComponentNodeFilterBusinessLogic.class.getName());
  61     private final NodeFilterOperation nodeFilterOperation;
  62     private final NodeFilterValidator nodeFilterValidator;
  63
  64     @Autowired
  65     public ComponentNodeFilterBusinessLogic(final IElementOperation elementDao, final IGroupOperation groupOperation,
  66                                             final IGroupInstanceOperation groupInstanceOperation, final IGroupTypeOperation groupTypeOperation,
  67                                             final InterfaceOperation interfaceOperation,
  68                                             final InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
  69                                             final ArtifactsOperations artifactToscaOperation, final NodeFilterOperation nodeFilterOperation,
  70                                             final NodeFilterValidator nodeFilterValidator) {
  71         super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation,
  72             artifactToscaOperation);
  73         this.nodeFilterOperation = nodeFilterOperation;
  74         this.nodeFilterValidator = nodeFilterValidator;
  75     }
  76
  77     public Optional<CINodeFilterDataDefinition> createNodeFilterIfNotExist(final String componentId, final String componentInstanceId,
  78                                                                            final boolean shouldLock, final ComponentTypeEnum componentTypeEnum)
  79         throws BusinessLogicException {
  80         final Component component = getComponent(componentId);
  81         final Optional<ComponentInstance> componentInstance = getComponentInstance(componentInstanceId, component);
  82         Optional<CINodeFilterDataDefinition> filterDataDefinition = getCiNodeFilterDataDefinition(componentInstance);
  83         if (filterDataDefinition.isPresent()) {
  84             return filterDataDefinition;
  85         }
  86         final Either<CINodeFilterDataDefinition, StorageOperationStatus> result;
  87         boolean wasLocked = false;
  88         try {
  89             if (shouldLock) {
  90                 lockComponent(component.getUniqueId(), component, "Create Node Filter on component");
  91                 wasLocked = true;
  92             }
  93             result = nodeFilterOperation.createNodeFilter(componentId, componentInstanceId);
  94             if (result.isRight()) {
  95                 janusGraphDao.rollback();
  96                 LOGGER.error(BUSINESS_PROCESS_ERROR, "Failed to Create Node filter on component with id {}", componentId);
  97                 throw new BusinessLogicException(componentsUtils
  98                     .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(result.right().value()), component.getSystemName()));
  99             } else {
 100                 filterDataDefinition = Optional.ofNullable(result.left().value());
 101             }
 102             janusGraphDao.commit();
 103             LOGGER.debug("Node filter successfully created in component {} . ", component.getSystemName());
 104         } catch (final Exception e) {
 105             janusGraphDao.rollback();
 106             LOGGER.error(BUSINESS_PROCESS_ERROR, "Exception occurred during add Component node filter property values: {}", e.getMessage(), e);
 107             throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
 108         } finally {
 109             if (wasLocked) {
 110                 unlockComponent(component.getUniqueId(), componentTypeEnum);
 111             }
 112         }
 113         return filterDataDefinition;
 114     }
 115
 116     public Optional<String> deleteNodeFilterIfExists(final String componentId, final String componentInstanceId, final boolean shouldLock,
 117                                                      final ComponentTypeEnum componentTypeEnum) throws BusinessLogicException {
 118         final Component component = getComponent(componentId);
 119         final Optional<CINodeFilterDataDefinition> nodeFilterDataDefinition = getCiNodeFilterDataDefinition(componentInstanceId, component);
 120         if (!nodeFilterDataDefinition.isPresent()) {
 121             return Optional.ofNullable(componentInstanceId);
 122         }
 123         final Either<String, StorageOperationStatus> result;
 124         boolean wasLocked = false;
 125         try {
 126             if (shouldLock) {
 127                 lockComponent(component.getUniqueId(), component, "Delete Node Filter from component");
 128                 wasLocked = true;
 129             }
 130             result = nodeFilterOperation.deleteNodeFilter(component, componentInstanceId);
 131             if (result.isRight()) {
 132                 LOGGER.error(BUSINESS_PROCESS_ERROR, "Failed to delete node filter in component {}. Response is {}. ", component.getName(),
 133                     result.right().value());
 134                 janusGraphDao.rollback();
 135                 throw new BusinessLogicException(componentsUtils
 136                     .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(result.right().value()), component.getSystemName()));
 137             }
 138             janusGraphDao.commit();
 139             LOGGER.debug("Node filter successfully deleted in component {} . ", component.getSystemName());
 140         } catch (final Exception e) {
 141             LOGGER.error(BUSINESS_PROCESS_ERROR, "Exception occurred during delete deleting node filter: {}", e.getMessage(), e);
 142             janusGraphDao.rollback();
 143             throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
 144         } finally {
 145             if (wasLocked) {
 146                 unlockComponent(component.getUniqueId(), componentTypeEnum);
 147             }
 148         }
 149         return Optional.ofNullable(result.left().value());
 150     }
 151
 152     public Optional<CINodeFilterDataDefinition> addNodeFilter(final String componentId, final String componentInstanceId,
 153                                                               final NodeFilterConstraintAction action, final String propertyName,
 154                                                               final String constraint, final boolean shouldLock,
 155                                                               final ComponentTypeEnum componentTypeEnum,
 156                                                               final NodeFilterConstraintType nodeFilterConstraintType, final String capabilityName)
 157         throws BusinessLogicException {
 158         final Component component = getComponent(componentId);
 159         CINodeFilterDataDefinition nodeFilterDataDefinition = validateAndReturnNodeFilterDefinition(componentInstanceId, action, constraint,
 160             component, nodeFilterConstraintType);
 161         boolean wasLocked = false;
 162         try {
 163             if (shouldLock) {
 164                 lockComponent(component.getUniqueId(), component, "Add Node Filter on Component");
 165                 wasLocked = true;
 166             }
 167             final RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition = new RequirementNodeFilterPropertyDataDefinition();
 168             requirementNodeFilterPropertyDataDefinition.setName(propertyName);
 169             requirementNodeFilterPropertyDataDefinition.setConstraints(Collections.singletonList(constraint));
 170             final Either<CINodeFilterDataDefinition, StorageOperationStatus> result = addNewNodeFilter(componentId, componentInstanceId,
 171                 nodeFilterConstraintType, nodeFilterDataDefinition, requirementNodeFilterPropertyDataDefinition, capabilityName);
 172             if (result.isRight()) {
 173                 janusGraphDao.rollback();
 174                 throw new BusinessLogicException(componentsUtils
 175                     .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(result.right().value()), component.getSystemName()));
 176             } else {
 177                 nodeFilterDataDefinition = result.left().value();
 178             }
 179             janusGraphDao.commit();
 180             LOGGER.debug("Node filter successfully created in component {} . ", component.getSystemName());
 181         } catch (final Exception e) {
 182             janusGraphDao.rollback();
 183             LOGGER.error(BUSINESS_PROCESS_ERROR, "Exception occurred during add component node filter property values: {}", e.getMessage(), e);
 184             throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
 185         } finally {
 186             if (wasLocked) {
 187                 unlockComponent(component.getUniqueId(), componentTypeEnum);
 188             }
 189         }
 190         return Optional.ofNullable(nodeFilterDataDefinition);
 191     }
 192
 193     public Optional<CINodeFilterDataDefinition> deleteNodeFilter(final String componentId, final String componentInstanceId,
 194                                                                  final NodeFilterConstraintAction action, final String constraint, final int position,
 195                                                                  final boolean shouldLock, final ComponentTypeEnum componentTypeEnum,
 196                                                                  final NodeFilterConstraintType nodeFilterConstraintType)
 197         throws BusinessLogicException {
 198         final Component component = getComponent(componentId);
 199         CINodeFilterDataDefinition nodeFilterDataDefinition = validateAndReturnNodeFilterDefinition(componentInstanceId, action, constraint,
 200             component, nodeFilterConstraintType);
 201         boolean wasLocked = false;
 202         try {
 203             if (shouldLock) {
 204                 lockComponent(component.getUniqueId(), component, "Add Node Filter on Component");
 205                 wasLocked = true;
 206             }
 207             final Either<CINodeFilterDataDefinition, StorageOperationStatus> result = nodeFilterOperation
 208                 .deleteConstraint(componentId, componentInstanceId, nodeFilterDataDefinition, position, nodeFilterConstraintType);
 209             if (result.isRight()) {
 210                 janusGraphDao.rollback();
 211                 throw new BusinessLogicException(componentsUtils
 212                     .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(result.right().value()), component.getSystemName()));
 213             } else {
 214                 nodeFilterDataDefinition = result.left().value();
 215             }
 216             janusGraphDao.commit();
 217             LOGGER.debug("Node filter successfully deleted in component {} . ", component.getSystemName());
 218         } catch (final Exception e) {
 219             janusGraphDao.rollback();
 220             LOGGER.error(BUSINESS_PROCESS_ERROR, "Exception occurred during delete component node filter property values: {}", e.getMessage(), e);
 221             throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
 222         } finally {
 223             if (wasLocked) {
 224                 unlockComponent(component.getUniqueId(), componentTypeEnum);
 225             }
 226         }
 227         return Optional.ofNullable(nodeFilterDataDefinition);
 228     }
 229
 230     private Either<CINodeFilterDataDefinition, StorageOperationStatus> addNewNodeFilter(final String componentId, final String componentInstanceId,
 231                                                                                         final NodeFilterConstraintType nodeFilterConstraintType,
 232                                                                                         final CINodeFilterDataDefinition nodeFilterDataDefinition,
 233                                                                                         final RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition,
 234                                                                                         final String capabilityName) {
 235         if (NodeFilterConstraintType.PROPERTIES.equals(nodeFilterConstraintType)) {
 236             return nodeFilterOperation
 237                 .addNewProperty(componentId, componentInstanceId, nodeFilterDataDefinition, requirementNodeFilterPropertyDataDefinition);
 238         }
 239         final RequirementNodeFilterCapabilityDataDefinition requirementNodeFilterCapabilityDataDefinition = new RequirementNodeFilterCapabilityDataDefinition();
 240         requirementNodeFilterCapabilityDataDefinition.setName(capabilityName);
 241         final ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> propertyDataDefinitionListDataDefinition = new ListDataDefinition<>();
 242         propertyDataDefinitionListDataDefinition.getListToscaDataDefinition()
 243             .addAll(Collections.singleton(requirementNodeFilterPropertyDataDefinition));
 244         requirementNodeFilterCapabilityDataDefinition.setProperties(propertyDataDefinitionListDataDefinition);
 245         return nodeFilterOperation
 246             .addNewCapabilities(componentId, componentInstanceId, nodeFilterDataDefinition, requirementNodeFilterCapabilityDataDefinition);
 247     }
 248
 249     private void unlockComponent(final String componentUniqueId, final ComponentTypeEnum componentType) {
 250         graphLockOperation.unlockComponent(componentUniqueId, componentType.getNodeType());
 251     }
 252
 253     public User validateUser(final String userId) {
 254         final User user = userValidations.validateUserExists(userId);
 255         userValidations.validateUserRole(user, Arrays.asList(Role.DESIGNER, Role.ADMIN));
 256         return user;
 257     }
 258
 259     private Optional<ComponentInstance> getComponentInstance(final String componentInstanceId, final Component component) {
 260         return component.getComponentInstanceById(componentInstanceId);
 261     }
 262
 263     private Optional<CINodeFilterDataDefinition> getCiNodeFilterDataDefinition(final Optional<ComponentInstance> componentInstance) {
 264         if (componentInstance.isPresent()) {
 265             return Optional.ofNullable(componentInstance.get().getNodeFilter());
 266         }
 267         return Optional.empty();
 268     }
 269
 270     private Optional<CINodeFilterDataDefinition> getCiNodeFilterDataDefinition(final String componentInstanceId, final Component component)
 271         throws BusinessLogicException {
 272         final Either<Boolean, ResponseFormat> response = nodeFilterValidator.validateComponentInstanceExist(component, componentInstanceId);
 273         if (response.isRight()) {
 274             throw new BusinessLogicException(
 275                 componentsUtils.getResponseFormat(ActionStatus.NODE_FILTER_NOT_FOUND, response.right().value().getFormattedMessage()));
 276         }
 277         final Optional<ComponentInstance> componentInstance = getComponentInstance(componentInstanceId, component);
 278         if (componentInstance.isPresent()) {
 279             return Optional.ofNullable(componentInstance.get().getNodeFilter());
 280         }
 281         return Optional.empty();
 282     }
 283
 284     private CINodeFilterDataDefinition validateAndReturnNodeFilterDefinition(final String componentInstanceId,
 285                                                                              final NodeFilterConstraintAction action, final String constraint,
 286                                                                              final Component component,
 287                                                                              final NodeFilterConstraintType nodeFilterConstraintType)
 288         throws BusinessLogicException {
 289         validateNodeFilter(component, componentInstanceId, action, constraint, nodeFilterConstraintType);
 290         final Optional<CINodeFilterDataDefinition> cINodeFilterDataDefinition = getCiNodeFilterDataDefinition(componentInstanceId, component);
 291         if (!cINodeFilterDataDefinition.isPresent()) {
 292             throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.NODE_FILTER_NOT_FOUND));
 293         }
 294         return cINodeFilterDataDefinition.get();
 295     }
 296
 297     private void validateNodeFilter(final Component component, final String componentInstanceId, final NodeFilterConstraintAction action,
 298                                     final String constraint, final NodeFilterConstraintType nodeFilterConstraintType) throws BusinessLogicException {
 299         final Either<Boolean, ResponseFormat> response = nodeFilterValidator
 300             .validateFilter(component, componentInstanceId, Collections.singletonList(constraint), action, nodeFilterConstraintType);
 301         if (response.isRight()) {
 302             throw new BusinessLogicException(
 303                 componentsUtils.getResponseFormat(ActionStatus.NODE_FILTER_NOT_FOUND, response.right().value().getFormattedMessage()));
 304         }
 305     }
 306
 307     public Optional<CINodeFilterDataDefinition> updateNodeFilter(final String componentId, final String componentInstanceId,
 308                                                                  final UIConstraint uiConstraint, final ComponentTypeEnum componentTypeEnum,
 309                                                                  final NodeFilterConstraintType nodeFilterConstraintType, final int index)
 310         throws BusinessLogicException {
 311         final Optional<CINodeFilterDataDefinition> deleteActionResponse = deleteNodeFilter(componentId, componentInstanceId,
 312             NodeFilterConstraintAction.DELETE, null, index, true, componentTypeEnum, nodeFilterConstraintType);
 313         if (!deleteActionResponse.isPresent()) {
 314             throw new BusinessLogicException(
 315                 componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR, "Failed to delete node filter capabilities"));
 316         }
 317         return addNodeFilter(componentId.toLowerCase(), componentInstanceId, NodeFilterConstraintAction.ADD, uiConstraint.getServicePropertyName(),
 318             new ConstraintConvertor().convert(uiConstraint), true, componentTypeEnum, nodeFilterConstraintType,
 319             StringUtils.isEmpty(uiConstraint.getCapabilityName()) ? "" : uiConstraint.getCapabilityName());
 320     }
 321 }