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

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  *  Copyright (C) 2021 Nordix Foundation. All rights reserved.
   6  *  ================================================================================
   7  *  Licensed under the Apache License, Version 2.0 (the "License");
   8  *  you may not use this file except in compliance with the License.
   9  *  You may obtain a copy of the License at
  10  *
  11  *        http://www.apache.org/licenses/LICENSE-2.0
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.zone-instance.component.ts
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License.
  17  *
  18  *  SPDX-License-Identifier: Apache-2.0
  19  *  ============LICENSE_END=========================================================
  20  */
  21
  22 package org.openecomp.sdc.be.components.impl;
  23
  24 import static org.openecomp.sdc.be.components.impl.ImportUtils.Constants.QUOTE;
  25
  26 import com.google.common.reflect.TypeToken;
  27 import com.google.gson.Gson;
  28 import com.google.gson.GsonBuilder;
  29 import fj.data.Either;
  30 import java.lang.reflect.Type;
  31 import java.util.ArrayList;
  32 import java.util.Arrays;
  33 import java.util.HashMap;
  34 import java.util.List;
  35 import java.util.Map;
  36 import java.util.Optional;
  37 import java.util.UUID;
  38 import java.util.stream.Collectors;
  39 import org.apache.commons.collections.CollectionUtils;
  40 import org.apache.commons.collections.MapUtils;
  41 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
  42 import org.openecomp.sdc.be.components.validation.ComponentValidations;
  43 import org.openecomp.sdc.be.dao.api.ActionStatus;
  44 import org.openecomp.sdc.be.datamodel.utils.PropertyValueConstraintValidationUtil;
  45 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  46 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  47 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  48 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
  49 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  50 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  51 import org.openecomp.sdc.be.model.ArtifactTypeDefinition;
  52 import org.openecomp.sdc.be.model.Component;
  53 import org.openecomp.sdc.be.model.ComponentInstance;
  54 import org.openecomp.sdc.be.model.ComponentInstanceInterface;
  55 import org.openecomp.sdc.be.model.ComponentParametersView;
  56 import org.openecomp.sdc.be.model.InterfaceDefinition;
  57 import org.openecomp.sdc.be.model.PropertyConstraint;
  58 import org.openecomp.sdc.be.model.PropertyDefinition;
  59 import org.openecomp.sdc.be.model.User;
  60 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
  61 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
  62 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  63 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
  64 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
  65 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
  66 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  67 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
  68 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  69 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  70 import org.openecomp.sdc.be.tosca.utils.OperationArtifactUtil;
  71 import org.openecomp.sdc.be.user.Role;
  72 import org.openecomp.sdc.common.datastructure.Wrapper;
  73 import org.openecomp.sdc.exception.ResponseFormat;
  74 import org.slf4j.Logger;
  75 import org.slf4j.LoggerFactory;
  76 import org.springframework.beans.factory.annotation.Autowired;
  77
  78 @org.springframework.stereotype.Component("componentInterfaceOperationBusinessLogic")
  79 public class ComponentInterfaceOperationBusinessLogic extends BaseBusinessLogic {
  80
  81     private static final Logger LOGGER = LoggerFactory.getLogger(ComponentInterfaceOperationBusinessLogic.class);
  82     private static final String UPDATE_INTERFACE_OPERATION_ON_COMPONENT_INSTANCE =
  83         "Update Interface Operation on Component instance";
  84     private static final String EXCEPTION_OCCURRED_WHEN_UPDATING_COMPONENT_INSTANCE_INTERFACES =
  85         "Exception occurred when updating Component Instance Interfaces {}";
  86     private final ComponentValidations componentValidations;
  87     private final PropertyBusinessLogic propertyBusinessLogic;
  88     private final ArtifactTypeBusinessLogic artifactTypeBusinessLogic;
  89
  90     @Autowired
  91     public ComponentInterfaceOperationBusinessLogic(final IElementOperation elementDao, final IGroupOperation groupOperation,
  92                                                     final IGroupInstanceOperation groupInstanceOperation,
  93                                                     final IGroupTypeOperation groupTypeOperation, final InterfaceOperation interfaceOperation,
  94                                                     final InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
  95                                                     final ArtifactsOperations artifactToscaOperation,
  96                                                     final ComponentValidations componentValidations,
  97                                                     final PropertyBusinessLogic propertyBusinessLogic,
  98                                                     final ArtifactTypeBusinessLogic artifactTypeBusinessLogic) {
  99         super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation,
 100             artifactToscaOperation);
 101         this.componentValidations = componentValidations;
 102         this.propertyBusinessLogic = propertyBusinessLogic;
 103         this.artifactTypeBusinessLogic = artifactTypeBusinessLogic;
 104     }
 105
 106     public Optional<ComponentInstance> updateComponentInstanceInterfaceOperation(final String componentId, final String componentInstanceId,
 107                                                                                  final InterfaceDefinition interfaceDefinition,
 108                                                                                  final ComponentTypeEnum componentTypeEnum,
 109                                                                                  final Wrapper<ResponseFormat> errorWrapper, final boolean shouldLock)
 110         throws BusinessLogicException {
 111         final Component component = getComponent(componentId);
 112         final Optional<ComponentInstance> componentInstanceOptional = componentValidations.getComponentInstance(component, componentInstanceId);
 113         ResponseFormat responseFormat;
 114         if (componentInstanceOptional.isEmpty()) {
 115             responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND);
 116             LOGGER.debug("Failed to found component instance with id {}, error: {}", componentInstanceId, responseFormat);
 117             errorWrapper.setInnerElement(responseFormat);
 118             return Optional.empty();
 119         }
 120         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfaceMap = component.getComponentInstancesInterfaces();
 121         if (MapUtils.isEmpty(componentInstancesInterfaceMap)) {
 122             componentInstancesInterfaceMap = new HashMap<>();
 123             component.setComponentInstancesInterfaces(componentInstancesInterfaceMap);
 124         }
 125         final List<ComponentInstanceInterface> componentInstanceInterfaceList = componentInstancesInterfaceMap.get(componentInstanceId);
 126         if (CollectionUtils.isEmpty(componentInstanceInterfaceList)) {
 127             responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND);
 128             LOGGER.debug("Failed to found component instance with id {}, error: {}", componentInstanceId, responseFormat);
 129             errorWrapper.setInnerElement(responseFormat);
 130             return Optional.empty();
 131         }
 132         final Optional<OperationDataDefinition> optionalOperationDataDefinition = interfaceDefinition.getOperations().values().stream().findFirst();
 133         if (optionalOperationDataDefinition.isEmpty()) {
 134             responseFormat = componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND);
 135             LOGGER.debug("Failed to found interface operation on component instance with id {}, error: {}", componentInstanceId, responseFormat);
 136             errorWrapper.setInnerElement(responseFormat);
 137             return Optional.empty();
 138         }
 139         final OperationDataDefinition updatedOperationDataDefinition = optionalOperationDataDefinition.get();
 140         final Optional<ComponentInstanceInterface> optionalComponentInstanceInterface = componentInstanceInterfaceList.stream().filter(
 141                 ci -> ci.getOperations().values().stream().anyMatch(
 142                     operationDataDefinition -> operationDataDefinition.getUniqueId().equalsIgnoreCase(updatedOperationDataDefinition.getUniqueId())))
 143             .findFirst();
 144         if (optionalComponentInstanceInterface.isEmpty()) {
 145             responseFormat = componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT);
 146             LOGGER
 147                 .debug("Failed to found ComponentInstanceInterface on component instance with id {}, error: {}", componentInstanceId, responseFormat);
 148             errorWrapper.setInnerElement(responseFormat);
 149             return Optional.empty();
 150         }
 151
 152         final String model = propertyBusinessLogic.getComponentModelByComponentId(componentId);
 153         PropertyValueConstraintValidationUtil constraintValidatorUtil = new PropertyValueConstraintValidationUtil();
 154         Either<Boolean, ResponseFormat> constraintValidatorResponse =
 155             validateOperationInputConstraints(updatedOperationDataDefinition, constraintValidatorUtil, model);
 156         if (!isConstraintsValidationSucceed(constraintValidatorResponse, errorWrapper, updatedOperationDataDefinition)) {
 157             return Optional.empty();
 158         }
 159         constraintValidatorResponse = validateOperationArtifactPropertyConstraints(
 160             updatedOperationDataDefinition, constraintValidatorUtil, model);
 161         if (!isConstraintsValidationSucceed(constraintValidatorResponse, errorWrapper, updatedOperationDataDefinition)) {
 162             return Optional.empty();
 163         }
 164
 165         updateOperationDefinitionImplementation(updatedOperationDataDefinition);
 166         optionalComponentInstanceInterface.get().getOperations().replace(updatedOperationDataDefinition.getName(), updatedOperationDataDefinition);
 167         boolean wasLocked = false;
 168         try {
 169             if (shouldLock) {
 170                 lockComponent(componentId, component, UPDATE_INTERFACE_OPERATION_ON_COMPONENT_INSTANCE);
 171                 wasLocked = true;
 172             }
 173             final StorageOperationStatus status = toscaOperationFacade.updateComponentInstanceInterfaces(component, componentInstanceId);
 174             if (status != StorageOperationStatus.OK) {
 175                 janusGraphDao.rollback();
 176                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 177                 LOGGER.error(EXCEPTION_OCCURRED_WHEN_UPDATING_COMPONENT_INSTANCE_INTERFACES, responseFormat);
 178                 errorWrapper.setInnerElement(responseFormat);
 179                 return Optional.empty();
 180             }
 181             final ComponentParametersView componentFilter = new ComponentParametersView();
 182             componentFilter.disableAll();
 183             componentFilter.setIgnoreUsers(false);
 184             componentFilter.setIgnoreComponentInstances(false);
 185             componentFilter.setIgnoreInterfaces(false);
 186             componentFilter.setIgnoreComponentInstancesInterfaces(false);
 187             final Either<Component, StorageOperationStatus> operationStatusEither = toscaOperationFacade
 188                 .updateComponentInstanceMetadataOfTopologyTemplate(component, componentFilter);
 189             if (operationStatusEither.isRight()) {
 190                 janusGraphDao.rollback();
 191                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 192                 LOGGER.error("Exception occurred when updating Component Instance Topology template {}", responseFormat);
 193                 errorWrapper.setInnerElement(responseFormat);
 194                 return Optional.empty();
 195             }
 196             janusGraphDao.commit();
 197         } catch (final Exception e) {
 198             janusGraphDao.rollback();
 199             LOGGER.error("Exception occurred when updating Interface Operation on Component Instance: {}", e.getMessage(), e);
 200             responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 201             errorWrapper.setInnerElement(responseFormat);
 202             throw new BusinessLogicException(responseFormat);
 203         } finally {
 204             if (wasLocked) {
 205                 unlockComponent(component.getUniqueId(), componentTypeEnum);
 206             }
 207         }
 208         return componentInstanceOptional;
 209     }
 210
 211     private Either<Boolean, ResponseFormat> validateOperationInputConstraints(
 212         OperationDataDefinition operationDataDefinition, PropertyValueConstraintValidationUtil constraintValidatorUtil, String model) {
 213         return constraintValidatorUtil
 214             .validatePropertyConstraints(convertOperationInputsToPropertyDefinitions(operationDataDefinition), applicationDataTypeCache,
 215                 model);
 216     }
 217
 218     private Either<Boolean, ResponseFormat> validateOperationArtifactPropertyConstraints(
 219         OperationDataDefinition operationDataDefinition, PropertyValueConstraintValidationUtil constraintValidatorUtil, String model) {
 220         return constraintValidatorUtil
 221             .validatePropertyConstraints(convertOperationArtifactPropsToPropertyDefinitions(operationDataDefinition, model), applicationDataTypeCache,
 222                 model);
 223     }
 224
 225     private boolean isConstraintsValidationSucceed(Either<Boolean, ResponseFormat> constraintValidatorResponse,
 226                                                    Wrapper<ResponseFormat> errorWrapper,
 227                                                    OperationDataDefinition updatedOperationDataDefinition) {
 228         if (constraintValidatorResponse.isRight()) {
 229             ResponseFormat responseFormat = constraintValidatorResponse.right().value();
 230             LOGGER.error("Failed constraints validation on inputs for interface operation: {} - {}",
 231                 updatedOperationDataDefinition.getName(),
 232                 constraintValidatorResponse.right().value());
 233             errorWrapper.setInnerElement(responseFormat);
 234             return false;
 235         }
 236         return true;
 237     }
 238
 239     public Optional<Component> updateResourceInterfaceOperation(final String componentId,
 240                                                                 final String user,
 241                                                                 final InterfaceDefinition interfaceDefinition,
 242                                                                 final ComponentTypeEnum componentTypeEnum,
 243                                                                 final Wrapper<ResponseFormat> errorWrapper,
 244                                                                 final boolean shouldLock) throws BusinessLogicException {
 245         final var component = getComponent(componentId);
 246         validateCanWorkOnComponent(component, user);
 247         ResponseFormat responseFormat;
 248
 249         Map<String, InterfaceDefinition> componentInterfaceMap = component.getInterfaces();
 250         final String interfaceDefinitionType = interfaceDefinition.getType();
 251         if (MapUtils.isEmpty(componentInterfaceMap)) {
 252             componentInterfaceMap = new HashMap<>();
 253             componentInterfaceMap.put(interfaceDefinitionType, interfaceDefinition);
 254             component.setInterfaces(componentInterfaceMap);
 255         } else {
 256             InterfaceDefinition componentInterfaceDefinition = componentInterfaceMap.get(interfaceDefinitionType);
 257             if (componentInterfaceDefinition == null) {
 258                 componentInterfaceDefinition = interfaceDefinition;
 259                 componentInterfaceMap.put(interfaceDefinitionType, interfaceDefinition);
 260             }
 261
 262             final Map<String, OperationDataDefinition> interfaceDefinitionOperations = interfaceDefinition.getOperations();
 263             final Optional<OperationDataDefinition> optionalOperationDataDefinition = interfaceDefinitionOperations.values().stream().findFirst();
 264             if (optionalOperationDataDefinition.isEmpty()) {
 265                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND);
 266                 LOGGER.debug("Failed to found interface operation on provided InterfaceDefinition {}, error: {}",
 267                     interfaceDefinitionType, responseFormat);
 268                 errorWrapper.setInnerElement(responseFormat);
 269                 return Optional.empty();
 270             }
 271             final var updatedOperationDataDefinition = optionalOperationDataDefinition.get();
 272             updateOperationDefinitionImplementation(updatedOperationDataDefinition);
 273             Map<String, OperationDataDefinition> componentOperationDataDefinitionMap = componentInterfaceDefinition.getOperations();
 274             if (MapUtils.isEmpty(componentOperationDataDefinitionMap)) {
 275                 componentOperationDataDefinitionMap = new HashMap<>();
 276                 componentInterfaceDefinition.setOperations(componentOperationDataDefinitionMap);
 277             }
 278             componentOperationDataDefinitionMap.replace(updatedOperationDataDefinition.getName(), updatedOperationDataDefinition);
 279         }
 280         boolean wasLocked = false;
 281         try {
 282             if (shouldLock) {
 283                 lockComponent(componentId, component, UPDATE_INTERFACE_OPERATION_ON_COMPONENT_INSTANCE);
 284                 wasLocked = true;
 285             }
 286             final StorageOperationStatus status = toscaOperationFacade.updateComponentInterfaces(component, interfaceDefinitionType);
 287             if (status != StorageOperationStatus.OK) {
 288                 janusGraphDao.rollback();
 289                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 290                 LOGGER.error(EXCEPTION_OCCURRED_WHEN_UPDATING_COMPONENT_INSTANCE_INTERFACES, responseFormat);
 291                 errorWrapper.setInnerElement(responseFormat);
 292                 return Optional.empty();
 293             }
 294             janusGraphDao.commit();
 295         } catch (final Exception e) {
 296             janusGraphDao.rollback();
 297             LOGGER.error("Exception occurred when updating Interface Operation on Component Instance: ", e);
 298             responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 299             errorWrapper.setInnerElement(responseFormat);
 300             throw new BusinessLogicException(responseFormat);
 301         } finally {
 302             if (wasLocked) {
 303                 unlockComponent(component.getUniqueId(), componentTypeEnum);
 304             }
 305         }
 306         return Optional.of(component);
 307     }
 308
 309     public Optional<Component> createInterfaceOperationInResource(final String componentId, final InterfaceDefinition interfaceDefinition,
 310                                                                   final ComponentTypeEnum componentTypeEnum,
 311                                                                   final Wrapper<ResponseFormat> errorWrapper, final boolean shouldLock)
 312         throws BusinessLogicException {
 313         final Component component = getComponent(componentId);
 314         ResponseFormat responseFormat;
 315         final String componentInterfaceUpdatedKey = interfaceDefinition.getType();
 316
 317         Map<String, InterfaceDefinition> componentInterfaceMap = component.getInterfaces();
 318         if (MapUtils.isEmpty(componentInterfaceMap)) {
 319             componentInterfaceMap = new HashMap<>();
 320             component.setInterfaces(componentInterfaceMap);
 321         }
 322
 323         interfaceDefinition.setUniqueId(componentInterfaceUpdatedKey);
 324         interfaceDefinition.setToscaResourceName(componentInterfaceUpdatedKey);
 325         interfaceDefinition.setUserCreated(true);
 326
 327         final Optional<OperationDataDefinition> optionalOperationDataDefinition = interfaceDefinition.getOperations().values().stream().findFirst();
 328         if (optionalOperationDataDefinition.isEmpty()) {
 329             responseFormat = componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND);
 330             LOGGER.debug("Failed to found interface operation on component instance with id {}, error: {}", componentId, responseFormat);
 331             errorWrapper.setInnerElement(responseFormat);
 332             return Optional.empty();
 333         }
 334
 335         final OperationDataDefinition updatedOperationDataDefinition = optionalOperationDataDefinition.get();
 336         updatedOperationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 337         updatedOperationDataDefinition.getImplementation()
 338             .setArtifactName(generateArtifactName(updatedOperationDataDefinition.getImplementation().getArtifactName()));
 339
 340         final InterfaceDefinition interfaceDefinitionFound = componentInterfaceMap.get(componentInterfaceUpdatedKey);
 341         if (interfaceDefinitionFound != null) {
 342             final Map<String, OperationDataDefinition> operationsFromComponent = interfaceDefinitionFound.getOperations();
 343             final String updatedOperationDataDefinitionName = updatedOperationDataDefinition.getName();
 344             final boolean find = operationsFromComponent.containsKey(updatedOperationDataDefinitionName);
 345             if (find) {
 346                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NAME_ALREADY_IN_USE,
 347                     updatedOperationDataDefinitionName);
 348                 LOGGER.error("Operation '{}' for Interface '{}' already exist, error: '{}'", updatedOperationDataDefinitionName,
 349                     componentInterfaceUpdatedKey, responseFormat);
 350                 errorWrapper.setInnerElement(responseFormat);
 351                 return Optional.empty();
 352             } else {
 353                 operationsFromComponent.put(updatedOperationDataDefinitionName, updatedOperationDataDefinition);
 354                 interfaceDefinition.setOperations(operationsFromComponent);
 355             }
 356         }
 357
 358         componentInterfaceMap.put(componentInterfaceUpdatedKey, interfaceDefinition);
 359
 360         boolean wasLocked = false;
 361         try {
 362             if (shouldLock) {
 363                 lockComponent(componentId, component, UPDATE_INTERFACE_OPERATION_ON_COMPONENT_INSTANCE);
 364                 wasLocked = true;
 365             }
 366             final Either<InterfaceDefinition, StorageOperationStatus> operationStatusEither =
 367                 toscaOperationFacade.addInterfaceToComponent(componentInterfaceUpdatedKey, interfaceDefinition, component);
 368             if (operationStatusEither.isRight()) {
 369                 janusGraphDao.rollback();
 370                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 371                 LOGGER.error(EXCEPTION_OCCURRED_WHEN_UPDATING_COMPONENT_INSTANCE_INTERFACES, responseFormat);
 372                 errorWrapper.setInnerElement(responseFormat);
 373                 return Optional.empty();
 374             }
 375             janusGraphDao.commit();
 376         } catch (final Exception e) {
 377             janusGraphDao.rollback();
 378             LOGGER.error("Exception occurred when updating Interface Operation on Component Instance: ", e);
 379             responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 380             errorWrapper.setInnerElement(responseFormat);
 381             throw new BusinessLogicException(responseFormat);
 382         } finally {
 383             if (wasLocked) {
 384                 unlockComponent(component.getUniqueId(), componentTypeEnum);
 385             }
 386         }
 387         return Optional.of(component);
 388     }
 389
 390     private String generateArtifactName(final String name) {
 391         if (OperationArtifactUtil.artifactNameIsALiteralValue(name)) {
 392             return name;
 393         } else {
 394             return QUOTE + name + QUOTE;
 395         }
 396     }
 397
 398     public User validateUser(final String userId) {
 399         final User user = userValidations.validateUserExists(userId);
 400         userValidations.validateUserRole(user, Arrays.asList(Role.DESIGNER, Role.ADMIN));
 401         return user;
 402     }
 403
 404     private void unlockComponent(final String componentUniqueId, final ComponentTypeEnum componentType) {
 405         graphLockOperation.unlockComponent(componentUniqueId, componentType.getNodeType());
 406     }
 407
 408     private void updateOperationDefinitionImplementation(final OperationDataDefinition updatedOperationDataDefinition) {
 409         final ArtifactDataDefinition artifactInfo = new ArtifactDataDefinition(updatedOperationDataDefinition.getImplementation());
 410         artifactInfo.setArtifactName(String.format("'%s'", updatedOperationDataDefinition.getImplementation().getArtifactName()));
 411         updatedOperationDataDefinition.setImplementation(artifactInfo);
 412     }
 413
 414     private List<PropertyDefinition> convertOperationInputsToPropertyDefinitions(final OperationDataDefinition operationDataDefinition) {
 415         List<PropertyDefinition> propertyDefinitions = new ArrayList<>();
 416         ListDataDefinition<OperationInputDefinition> inputsDefinitionListData = operationDataDefinition.getInputs();
 417         if (null != inputsDefinitionListData && !inputsDefinitionListData.isEmpty()) {
 418             List<OperationInputDefinition> inputDefinitionList =
 419                 inputsDefinitionListData.getListToscaDataDefinition();
 420             for (OperationInputDefinition operationInputDefinition : inputDefinitionList) {
 421                 PropertyDefinition propertyDefinition = new PropertyDefinition();
 422                 propertyDefinition.setValue(operationInputDefinition.getValue());
 423                 propertyDefinition.setUniqueId(operationInputDefinition.getUniqueId());
 424                 propertyDefinition.setType(operationInputDefinition.getType());
 425                 propertyDefinition.setName(operationInputDefinition.getName());
 426                 propertyDefinition.setDefaultValue(operationInputDefinition.getDefaultValue());
 427                 propertyDefinition.setInputPath(operationInputDefinition.getInputPath());
 428                 propertyDefinitions.add(propertyDefinition);
 429             }
 430         }
 431         return propertyDefinitions;
 432     }
 433
 434     private List<PropertyDefinition> convertOperationArtifactPropsToPropertyDefinitions(final OperationDataDefinition operationDataDefinition,
 435                                                                                         final String model) {
 436         List<PropertyDefinition> artifactPropertiesToValidateCollection = new ArrayList<>();
 437         final ArtifactDataDefinition artifactDataDefinition = operationDataDefinition.getImplementation();
 438         if (null != artifactDataDefinition) {
 439             final String artifactType = artifactDataDefinition.getArtifactType();
 440             final String uniqueId = UniqueIdBuilder.buildArtifactTypeUid(model, artifactType);
 441             ArtifactTypeDefinition retrievedArtifact = artifactTypeBusinessLogic.getArtifactTypeByUid(uniqueId);
 442             if (retrievedArtifact != null) {
 443                 List<PropertyDataDefinition> artifactPropertiesList = artifactDataDefinition.getProperties();
 444                 if (null != artifactPropertiesList && !artifactPropertiesList.isEmpty()) {
 445                     for (PropertyDataDefinition propertyDataDefinition : artifactPropertiesList) {
 446                         PropertyDefinition propertyDefinition = new PropertyDefinition();
 447                         propertyDefinition.setConstraints(deserializePropertyConstraints(propertyDataDefinition.getPropertyConstraints()));
 448                         propertyDefinition.setValue(propertyDataDefinition.getValue());
 449                         propertyDefinition.setType(propertyDataDefinition.getType());
 450                         propertyDefinition.setName(propertyDataDefinition.getName());
 451                         propertyDefinition.setDefaultValue(propertyDataDefinition.getDefaultValue());
 452                         propertyDefinition.setInputPath(propertyDataDefinition.getInputPath());
 453                         artifactPropertiesToValidateCollection.add(propertyDefinition);
 454                     }
 455                 }
 456             }
 457         }
 458         return artifactPropertiesToValidateCollection;
 459     }
 460
 461     private List<PropertyConstraint> deserializePropertyConstraints(List<String> constraints) {
 462         if (CollectionUtils.isNotEmpty(constraints)) {
 463             Type constraintType = new TypeToken<PropertyConstraint>() {
 464             }.getType();
 465             Gson gson = new GsonBuilder().registerTypeAdapter(constraintType, new PropertyOperation.PropertyConstraintDeserialiser()).create();
 466             return constraints.stream().map(c -> (PropertyConstraint) gson.fromJson(c, constraintType)).collect(
 467                 Collectors.toList());
 468         }
 469         return null;
 470     }
 471 }