gerrit.onap Code Review - sdc.git/blob

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