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