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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. 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  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.openecomp.sdc.be.components.impl;
  21
  22 import fj.data.Either;
  23 import java.util.List;
  24 import org.apache.commons.lang3.StringUtils;
  25 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  26 import org.openecomp.sdc.be.config.ConfigurationManager;
  27 import org.openecomp.sdc.be.dao.api.ActionStatus;
  28 import org.openecomp.sdc.be.dao.graph.datatype.AdditionalInformationEnum;
  29 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  30 import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterInfo;
  31 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  32 import org.openecomp.sdc.be.model.AdditionalInformationDefinition;
  33 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
  34 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
  35 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  36 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
  37 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
  38 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
  39 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  40 import org.openecomp.sdc.be.model.operations.impl.AdditionalInformationOperation;
  41 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
  42 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
  43 import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils;
  44 import org.openecomp.sdc.be.model.tosca.converters.StringConvertor;
  45 import org.openecomp.sdc.be.model.tosca.validators.StringValidator;
  46 import org.openecomp.sdc.common.log.wrappers.Logger;
  47 import org.openecomp.sdc.common.util.ValidationUtils;
  48 import org.openecomp.sdc.exception.ResponseFormat;
  49 import org.springframework.beans.factory.annotation.Autowired;
  50 import org.springframework.stereotype.Component;
  51
  52 @Component("additionalInformationBusinessLogic")
  53 public class AdditionalInformationBusinessLogic extends BaseBusinessLogic {
  54
  55     private static final String CREATE_ADDITIONAL_INFORMATION = "CreateAdditionalInformation";
  56     private static final String UPDATE_ADDITIONAL_INFORMATION = "UpdateAdditionalInformation";
  57     private static final String DELETE_ADDITIONAL_INFORMATION = "DeleteAdditionalInformation";
  58     private static final String GET_ADDITIONAL_INFORMATION = "GetAdditionalInformation";
  59     private static final Logger log = Logger.getLogger(AdditionalInformationBusinessLogic.class.getName());
  60     private static final String FAILED_TO_LOCK_COMPONENT_ERROR = "Failed to lock component {} error - {}";
  61     private final AdditionalInformationOperation additionalInformationOperation;
  62
  63     @Autowired
  64     public AdditionalInformationBusinessLogic(IElementOperation elementDao, IGroupOperation groupOperation,
  65                                               IGroupInstanceOperation groupInstanceOperation, IGroupTypeOperation groupTypeOperation,
  66                                               InterfaceOperation interfaceOperation, InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
  67                                               AdditionalInformationOperation additionalInformationOperation,
  68                                               ArtifactsOperations artifactToscaOperation) {
  69         super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation,
  70             artifactToscaOperation);
  71         this.additionalInformationOperation = additionalInformationOperation;
  72     }
  73
  74     /**
  75      * Create new additional information on resource/service on graph
  76      *
  77      * @param nodeType
  78      * @param resourceId
  79      * @param additionalInfoParameterInfo
  80      * @param userId
  81      * @return Either<AdditionalInfoParameterInfo, ResponseFormat>
  82      */
  83     public Either<AdditionalInfoParameterInfo, ResponseFormat> createAdditionalInformation(NodeTypeEnum nodeType, String resourceId,
  84                                                                                            AdditionalInfoParameterInfo additionalInfoParameterInfo,
  85                                                                                            String userId) {
  86         validateUserExists(userId);
  87         Either<AdditionalInfoParameterInfo, ResponseFormat> result = null;
  88         ResponseFormat responseFormat = verifyCanWorkOnComponent(nodeType, resourceId, userId);
  89         if (responseFormat != null) {
  90             result = Either.right(responseFormat);
  91             return result;
  92         }
  93         // lock component
  94         StorageOperationStatus lockResult = graphLockOperation.lockComponent(resourceId, nodeType);
  95         if (lockResult != StorageOperationStatus.OK) {
  96             BeEcompErrorManager.getInstance().logBeFailedLockObjectError(CREATE_ADDITIONAL_INFORMATION, nodeType.getName(), resourceId);
  97             log.info(FAILED_TO_LOCK_COMPONENT_ERROR, resourceId, lockResult);
  98             result = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
  99             return result;
 100         }
 101         try {
 102             responseFormat = validateMaxSizeNotReached(nodeType, resourceId, additionalInfoParameterInfo);
 103             if (responseFormat != null) {
 104                 result = Either.right(responseFormat);
 105                 return result;
 106             }
 107             // validate label
 108             responseFormat = validateAndConvertKey(additionalInfoParameterInfo, CREATE_ADDITIONAL_INFORMATION);
 109             if (responseFormat != null) {
 110                 result = Either.right(responseFormat);
 111                 return result;
 112             }
 113             // validate value
 114             responseFormat = validateAndConvertValue(additionalInfoParameterInfo, CREATE_ADDITIONAL_INFORMATION);
 115             if (responseFormat != null) {
 116                 result = Either.right(responseFormat);
 117                 return result;
 118             }
 119             Either<AdditionalInformationDefinition, StorageOperationStatus> addResult = additionalInformationOperation
 120                 .createAdditionalInformationParameter(nodeType, resourceId, additionalInfoParameterInfo.getKey(),
 121                     additionalInfoParameterInfo.getValue(), true);
 122             if (addResult.isRight()) {
 123                 StorageOperationStatus status = addResult.right().value();
 124                 BeEcompErrorManager.getInstance().logBeSystemError(CREATE_ADDITIONAL_INFORMATION);
 125                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForAdditionalInformation(status);
 126                 result = Either.right(componentsUtils
 127                     .getResponseFormatAdditionalProperty(actionStatus, additionalInfoParameterInfo, nodeType, AdditionalInformationEnum.Label));
 128                 return result;
 129             } else {
 130                 AdditionalInformationDefinition informationDefinition = addResult.left().value();
 131                 AdditionalInfoParameterInfo createdAI = findAdditionInformationKey(informationDefinition.getParameters(),
 132                     additionalInfoParameterInfo.getKey());
 133                 result = Either.left(createdAI);
 134                 return result;
 135             }
 136         } finally {
 137             commitOrRollback(result);
 138             // unlock component
 139             graphLockOperation.unlockComponent(resourceId, nodeType);
 140         }
 141     }
 142
 143     /**
 144      * Validate the value format. Format the value.
 145      *
 146      * @param additionalInfoParameterInfo
 147      * @return null in case of success. Otherwise response format.
 148      */
 149     private ResponseFormat validateAndConvertValue(AdditionalInfoParameterInfo additionalInfoParameterInfo, String context) {
 150         ResponseFormat result = null;
 151         String value = additionalInfoParameterInfo.getValue();
 152         log.debug("Going to validate additional information value {}", value);
 153         Either<String, ResponseFormat> valueValidRes = validateValue(value);
 154         if (valueValidRes.isRight()) {
 155             BeEcompErrorManager.getInstance()
 156                 .logBeInvalidValueError(context, additionalInfoParameterInfo.getValue(), "additional information value", "string");
 157             result = valueValidRes.right().value();
 158         } else {
 159             String newValue = valueValidRes.left().value();
 160             if (log.isTraceEnabled() && (value != null && !value.equals(newValue))) {
 161                 log.trace("The additional information value was normalized from {} to {}", value, newValue);
 162             }
 163             additionalInfoParameterInfo.setValue(newValue);
 164         }
 165         return result;
 166     }
 167
 168     /**
 169      * @param additionalInfoParameterInfo
 170      * @return
 171      */
 172     private ResponseFormat validateAndConvertKey(AdditionalInfoParameterInfo additionalInfoParameterInfo, String context) {
 173         String key = additionalInfoParameterInfo.getKey();
 174         log.debug("Going to validate additional information key {}", key);
 175         ResponseFormat result = null;
 176         ResponseFormat responseFormat;
 177         Either<String, ResponseFormat> validateKeyRes = validateAndNormalizeKey(key);
 178         if (validateKeyRes.isRight()) {
 179             responseFormat = validateKeyRes.right().value();
 180             BeEcompErrorManager.getInstance()
 181                 .logBeInvalidValueError(context, additionalInfoParameterInfo.getKey(), "additional information label", "string");
 182             result = responseFormat;
 183         } else {
 184             String convertedKey = validateKeyRes.left().value();
 185             if (log.isTraceEnabled() && key != null && !key.equals(convertedKey)) {
 186                 log.trace("The additional information key {} was normalized to {}", key, convertedKey);
 187             }
 188             additionalInfoParameterInfo.setKey(convertedKey);
 189         }
 190         return result;
 191     }
 192
 193     /**
 194      * verify that the maximal number of additional information properties has not been reached.
 195      *
 196      * @param nodeType
 197      * @param componentId
 198      * @param additionalInfoParameterInfo
 199      * @return response format in case the maximal number has been reached.
 200      */
 201     private ResponseFormat validateMaxSizeNotReached(NodeTypeEnum nodeType, String componentId,
 202                                                      AdditionalInfoParameterInfo additionalInfoParameterInfo) {
 203         ResponseFormat result;
 204         Integer additionalInformationMaxNumberOfKeys = ConfigurationManager.getConfigurationManager().getConfiguration()
 205             .getAdditionalInformationMaxNumberOfKeys();
 206         Either<Integer, StorageOperationStatus> checkRes = additionalInformationOperation
 207             .getNumberOfAdditionalInformationParameters(nodeType, componentId, true);
 208         if (checkRes.isRight()) {
 209             StorageOperationStatus status = checkRes.right().value();
 210             ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForAdditionalInformation(status);
 211             result = componentsUtils
 212                 .getResponseFormatAdditionalProperty(actionStatus, additionalInfoParameterInfo, nodeType, AdditionalInformationEnum.None);
 213             return result;
 214         }
 215         Integer currentNumberOfProperties = checkRes.left().value();
 216         if (currentNumberOfProperties >= additionalInformationMaxNumberOfKeys) {
 217             log.info("The current number of additional information properties is {}. The maximum allowed additional information properties is {}",
 218                 currentNumberOfProperties, currentNumberOfProperties);
 219             result = componentsUtils
 220                 .getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_MAX_NUMBER_REACHED, additionalInfoParameterInfo, nodeType,
 221                     AdditionalInformationEnum.None);
 222             return result;
 223         }
 224         return null;
 225     }
 226
 227     /**
 228      * validate additional information value
 229      *
 230      * @param value
 231      * @return
 232      */
 233     private Either<String, ResponseFormat> validateValue(String value) {
 234         if (StringUtils.isEmpty(value)) {
 235             return Either.right(componentsUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_EMPTY_STRING_NOT_ALLOWED));
 236         }
 237         boolean valid = StringValidator.getInstance().isValid(value, null);
 238         if (!valid) {
 239             return Either.right(componentsUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_VALUE_NOT_ALLOWED_CHARACTERS,
 240                 new AdditionalInfoParameterInfo(null, value), null, AdditionalInformationEnum.Value));
 241         }
 242         String converted = StringConvertor.getInstance().convert(value, null, null);
 243         return Either.left(converted);
 244     }
 245
 246     private AdditionalInfoParameterInfo findAdditionInformationKey(List<AdditionalInfoParameterInfo> parameters, String key) {
 247         for (AdditionalInfoParameterInfo infoParameterInfo : parameters) {
 248             if (infoParameterInfo.getKey().equals(key)) {
 249                 return infoParameterInfo;
 250             }
 251         }
 252         return null;
 253     }
 254
 255     /**
 256      * validate and normalize the key
 257      *
 258      * @param key
 259      * @return Either<String, ResponseFormat>
 260      */
 261     private Either<String, ResponseFormat> validateAndNormalizeKey(String key) {
 262         AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo();
 263         additionalInfoParameterInfo.setKey(key);
 264         String normKey = ValidationUtils.normalizeAdditionalInformation(key);
 265         if (StringUtils.isEmpty(normKey)) {
 266             return Either.right(componentsUtils
 267                 .getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_EMPTY_STRING_NOT_ALLOWED, null, null,
 268                     AdditionalInformationEnum.Label));
 269         }
 270         boolean isValidString = ValidationUtils.validateAdditionalInformationKeyName(normKey);
 271         if (!isValidString) {
 272             if (!ValidationUtils.validateLength(normKey, ValidationUtils.ADDITIONAL_INFORMATION_KEY_MAX_LENGTH)) {
 273                 return Either.right(componentsUtils
 274                     .getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_EXCEEDS_LIMIT, additionalInfoParameterInfo, null,
 275                         AdditionalInformationEnum.Label));
 276             }
 277             return Either.right(componentsUtils
 278                 .getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_KEY_NOT_ALLOWED_CHARACTERS, additionalInfoParameterInfo,
 279                     null, AdditionalInformationEnum.Label));
 280         }
 281         return Either.left(normKey);
 282     }
 283
 284     /**
 285      * update key and value of a given additional information.
 286      *
 287      * @param nodeType
 288      * @param resourceId
 289      * @param additionalInfoParameterInfo
 290      * @param userId
 291      * @return
 292      */
 293     public Either<AdditionalInfoParameterInfo, ResponseFormat> updateAdditionalInformation(NodeTypeEnum nodeType, String resourceId,
 294                                                                                            AdditionalInfoParameterInfo additionalInfoParameterInfo,
 295                                                                                            String userId) {
 296         validateUserExists(userId);
 297         Either<AdditionalInfoParameterInfo, ResponseFormat> result = null;
 298         ResponseFormat responseFormat = verifyCanWorkOnComponent(nodeType, resourceId, userId);
 299         if (responseFormat != null) {
 300             result = Either.right(responseFormat);
 301             return result;
 302         }
 303         // lock component
 304         StorageOperationStatus lockResult = graphLockOperation.lockComponent(resourceId, nodeType);
 305         if (lockResult != StorageOperationStatus.OK) {
 306             BeEcompErrorManager.getInstance().logBeFailedLockObjectError(UPDATE_ADDITIONAL_INFORMATION, nodeType.getName(), resourceId);
 307             log.info(FAILED_TO_LOCK_COMPONENT_ERROR, resourceId, lockResult);
 308             result = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
 309             return result;
 310         }
 311         try {
 312             // validate input
 313             responseFormat = validateAndConvertKey(additionalInfoParameterInfo, UPDATE_ADDITIONAL_INFORMATION);
 314             if (responseFormat != null) {
 315                 result = Either.right(responseFormat);
 316                 return result;
 317             }
 318             responseFormat = validateAndConvertValue(additionalInfoParameterInfo, UPDATE_ADDITIONAL_INFORMATION);
 319             if (responseFormat != null) {
 320                 result = Either.right(responseFormat);
 321                 return result;
 322             }
 323             Either<AdditionalInformationDefinition, StorageOperationStatus> addResult = additionalInformationOperation
 324                 .updateAdditionalInformationParameter(nodeType, resourceId, additionalInfoParameterInfo.getUniqueId(),
 325                     additionalInfoParameterInfo.getKey(), additionalInfoParameterInfo.getValue(), true);
 326             if (addResult.isRight()) {
 327                 StorageOperationStatus status = addResult.right().value();
 328                 BeEcompErrorManager.getInstance().logBeSystemError(UPDATE_ADDITIONAL_INFORMATION);
 329                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForAdditionalInformation(status);
 330                 result = Either.right(componentsUtils
 331                     .getResponseFormatAdditionalProperty(actionStatus, additionalInfoParameterInfo, nodeType, AdditionalInformationEnum.None));
 332                 return result;
 333             } else {
 334                 AdditionalInformationDefinition informationDefinition = addResult.left().value();
 335                 AdditionalInfoParameterInfo parameterInfo = findAdditionInformationKey(informationDefinition.getParameters(),
 336                     additionalInfoParameterInfo.getKey());
 337                 result = Either.left(parameterInfo);
 338                 return result;
 339             }
 340         } finally {
 341             commitOrRollback(result);
 342             // unlock component
 343             graphLockOperation.unlockComponent(resourceId, nodeType);
 344         }
 345     }
 346
 347     /**
 348      * Delete an additional information label
 349      *
 350      * @param nodeType
 351      * @param resourceId
 352      * @param additionalInfoParameterInfo
 353      * @param userId
 354      * @return
 355      */
 356     public Either<AdditionalInfoParameterInfo, ResponseFormat> deleteAdditionalInformation(NodeTypeEnum nodeType, String resourceId,
 357                                                                                            AdditionalInfoParameterInfo additionalInfoParameterInfo,
 358                                                                                            String userId) {
 359         validateUserExists(userId);
 360         Either<AdditionalInfoParameterInfo, ResponseFormat> result = null;
 361         ResponseFormat responseFormat = verifyCanWorkOnComponent(nodeType, resourceId, userId);
 362         if (responseFormat != null) {
 363             return Either.right(responseFormat);
 364         }
 365         // lock component
 366         StorageOperationStatus lockResult = graphLockOperation.lockComponent(resourceId, nodeType);
 367         if (lockResult != StorageOperationStatus.OK) {
 368             BeEcompErrorManager.getInstance().logBeFailedLockObjectError(DELETE_ADDITIONAL_INFORMATION, nodeType.getName(), resourceId);
 369             log.info(FAILED_TO_LOCK_COMPONENT_ERROR, resourceId, lockResult);
 370             result = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
 371             return result;
 372         }
 373         try {
 374             Either<AdditionalInfoParameterInfo, StorageOperationStatus> findIdRes = additionalInformationOperation
 375                 .getAdditionalInformationParameter(nodeType, resourceId, additionalInfoParameterInfo.getUniqueId(), true);
 376             if (findIdRes.isRight()) {
 377                 StorageOperationStatus status = findIdRes.right().value();
 378                 if (status != StorageOperationStatus.NOT_FOUND) {
 379                     BeEcompErrorManager.getInstance().logBeSystemError(GET_ADDITIONAL_INFORMATION);
 380                 }
 381                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForAdditionalInformation(status);
 382                 result = Either.right(componentsUtils
 383                     .getResponseFormatAdditionalProperty(actionStatus, additionalInfoParameterInfo, nodeType, AdditionalInformationEnum.None));
 384                 return result;
 385             }
 386             AdditionalInfoParameterInfo foundAdditionalInfo = findIdRes.left().value();
 387             Either<AdditionalInformationDefinition, StorageOperationStatus> addResult = additionalInformationOperation
 388                 .deleteAdditionalInformationParameter(nodeType, resourceId, additionalInfoParameterInfo.getUniqueId(), true);
 389             if (addResult.isRight()) {
 390                 StorageOperationStatus status = addResult.right().value();
 391                 BeEcompErrorManager.getInstance().logBeDaoSystemError(DELETE_ADDITIONAL_INFORMATION);
 392                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForAdditionalInformation(status);
 393                 result = Either.right(componentsUtils
 394                     .getResponseFormatAdditionalProperty(actionStatus, additionalInfoParameterInfo, nodeType, AdditionalInformationEnum.None));
 395                 return result;
 396             } else {
 397                 result = Either.left(foundAdditionalInfo);
 398                 return result;
 399             }
 400         } finally {
 401             commitOrRollback(result);
 402             // unlock component
 403             graphLockOperation.unlockComponent(resourceId, nodeType);
 404         }
 405     }
 406
 407     /**
 408      * @param nodeType
 409      * @param resourceId
 410      * @param additionalInfoParameterInfo
 411      * @param userId
 412      * @return
 413      */
 414     public Either<AdditionalInfoParameterInfo, ResponseFormat> getAdditionalInformation(NodeTypeEnum nodeType, String resourceId,
 415                                                                                         AdditionalInfoParameterInfo additionalInfoParameterInfo,
 416                                                                                         String userId) {
 417         validateUserExists(userId);
 418         Either<AdditionalInfoParameterInfo, ResponseFormat> result = null;
 419         try {
 420             Either<AdditionalInfoParameterInfo, StorageOperationStatus> findIdRes = additionalInformationOperation
 421                 .getAdditionalInformationParameter(nodeType, resourceId, additionalInfoParameterInfo.getUniqueId(), true);
 422             if (findIdRes.isRight()) {
 423                 StorageOperationStatus status = findIdRes.right().value();
 424                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForAdditionalInformation(status);
 425                 result = Either.right(componentsUtils
 426                     .getResponseFormatAdditionalProperty(actionStatus, additionalInfoParameterInfo, nodeType, AdditionalInformationEnum.None));
 427             }
 428             AdditionalInfoParameterInfo foundAdditionalInfo = findIdRes.left().value();
 429             result = Either.left(foundAdditionalInfo);
 430             return result;
 431         } finally {
 432             commitOrRollback(result);
 433         }
 434     }
 435
 436     /**
 437      * Get all additional information properties of a given resource/service
 438      *
 439      * @param nodeType
 440      * @param resourceId
 441      * @param userId
 442      * @return
 443      */
 444     public Either<AdditionalInformationDefinition, ResponseFormat> getAllAdditionalInformation(NodeTypeEnum nodeType, String resourceId,
 445                                                                                                String userId) {
 446         validateUserExists(userId);
 447         Either<AdditionalInformationDefinition, ResponseFormat> result = null;
 448         try {
 449             Either<AdditionalInformationDefinition, JanusGraphOperationStatus> findIdRes = additionalInformationOperation
 450                 .getAllAdditionalInformationParameters(nodeType, resourceId, false);
 451             if (findIdRes.isRight()) {
 452                 StorageOperationStatus status = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(findIdRes.right().value());
 453                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForAdditionalInformation(status);
 454                 result = Either.right(componentsUtils.getResponseFormatAdditionalProperty(actionStatus));
 455             } else {
 456                 AdditionalInformationDefinition informationDefinition = findIdRes.left().value();
 457                 result = Either.left(informationDefinition);
 458             }
 459             return result;
 460         } finally {
 461             commitOrRollback(result);
 462         }
 463     }
 464
 465     private ResponseFormat verifyCanWorkOnComponent(NodeTypeEnum nodeType, String resourceId, String userId) {
 466         switch (nodeType) {
 467             case Resource:
 468                 // verify that resource is checked-out and the user is the last
 469
 470                 // updater
 471                 if (!ComponentValidationUtils.canWorkOnComponent(resourceId, toscaOperationFacade, userId)) {
 472                     return componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
 473                 }
 474                 break;
 475             case Service:
 476                 // verify that resource is checked-out and the user is the last
 477
 478                 // updater
 479                 if (!ComponentValidationUtils.canWorkOnComponent(resourceId, toscaOperationFacade, userId)) {
 480                     return componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
 481                 }
 482                 break;
 483             default:
 484                 return componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT, nodeType.getName());
 485         }
 486         return null;
 487     }
 488 }