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