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