catalog-be/src/main/java/org/openecomp/sdc/be/impl/ComponentsUtils.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.impl;
  22
  23 import java.lang.reflect.Type;
  24 import java.util.ArrayList;
  25 import java.util.Collection;
  26 import java.util.EnumMap;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.regex.Pattern;
  30
  31 import javax.annotation.PostConstruct;
  32 import javax.servlet.http.HttpServletRequest;
  33
  34 import org.codehaus.jackson.Version;
  35 import org.codehaus.jackson.map.DeserializationConfig;
  36 import org.codehaus.jackson.map.JsonDeserializer;
  37 import org.codehaus.jackson.map.ObjectMapper;
  38 import org.codehaus.jackson.map.module.SimpleModule;
  39 import org.openecomp.sdc.be.auditing.api.IAuditingManager;
  40 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
  41 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
  42 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  43 import org.openecomp.sdc.be.dao.api.ActionStatus;
  44 import org.openecomp.sdc.be.dao.graph.datatype.AdditionalInformationEnum;
  45 import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterInfo;
  46 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  47 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  48 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  49 import org.openecomp.sdc.be.model.ArtifactDefinition;
  50 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
  51 import org.openecomp.sdc.be.model.Component;
  52 import org.openecomp.sdc.be.model.ConsumerDefinition;
  53 import org.openecomp.sdc.be.model.DataTypeDefinition;
  54 import org.openecomp.sdc.be.model.GroupTypeDefinition;
  55 import org.openecomp.sdc.be.model.PolicyTypeDefinition;
  56 import org.openecomp.sdc.be.model.PropertyConstraint;
  57 import org.openecomp.sdc.be.model.Resource;
  58 import org.openecomp.sdc.be.model.Service;
  59 import org.openecomp.sdc.be.model.User;
  60 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  61 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation.PropertyConstraintDeserialiser;
  62 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation.PropertyConstraintJacksonDeserialiser;
  63 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  64 import org.openecomp.sdc.be.tosca.ToscaError;
  65 import org.openecomp.sdc.common.api.Constants;
  66 import org.openecomp.sdc.common.config.EcompErrorName;
  67 import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
  68 import org.openecomp.sdc.common.util.ThreadLocalsHolder;
  69 import org.openecomp.sdc.common.util.ValidationUtils;
  70 import org.openecomp.sdc.exception.ResponseFormat;
  71 import org.slf4j.Logger;
  72 import org.slf4j.LoggerFactory;
  73
  74 import com.google.gson.Gson;
  75 import com.google.gson.GsonBuilder;
  76 import com.google.gson.reflect.TypeToken;
  77
  78 import fj.data.Either;
  79
  80 @org.springframework.stereotype.Component("componentUtils")
  81 public class ComponentsUtils {
  82
  83         @javax.annotation.Resource
  84         private IAuditingManager auditingManager;
  85
  86         private ResponseFormatManager responseFormatManager;
  87
  88         private static Logger log = LoggerFactory.getLogger(ComponentsUtils.class.getName());
  89
  90         @PostConstruct
  91         public void Init() {
  92                 this.responseFormatManager = ResponseFormatManager.getInstance();
  93         }
  94
  95         public IAuditingManager getAuditingManager() {
  96                 return auditingManager;
  97         }
  98
  99         public void setAuditingManager(IAuditingManager auditingManager) {
 100                 this.auditingManager = auditingManager;
 101         }
 102
 103         public <T> Either<T, ResponseFormat> convertJsonToObject(String data, User user, Class<T> clazz, AuditingActionEnum actionEnum) {
 104                 if (data == null) {
 105                         BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeInvalidJsonInput, "convertJsonToObject");
 106                         BeEcompErrorManager.getInstance().logBeInvalidJsonInput("convertJsonToObject");
 107                         log.debug("object is null after converting from json");
 108                         ResponseFormat responseFormat = getInvalidContentErrorAndAudit(user, actionEnum);
 109                         return Either.right(responseFormat);
 110                 }
 111                 try {
 112                         T obj = parseJsonToObject(data, clazz);
 113                         return Either.left(obj);
 114                 } catch (Exception e) {
 115                         // INVALID JSON
 116                         BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeInvalidJsonInput, "convertJsonToObject");
 117                         BeEcompErrorManager.getInstance().logBeInvalidJsonInput("convertJsonToObject");
 118                         log.debug("failed to convert from json {}", data, e);
 119                         ResponseFormat responseFormat = getInvalidContentErrorAndAudit(user, actionEnum);
 120                         return Either.right(responseFormat);
 121                 }
 122         }
 123
 124         public static <T> T parseJsonToObject(String data, Class<T> clazz) {
 125                 Type constraintType = new TypeToken<PropertyConstraint>() {
 126                 }.getType();
 127                 Gson gson = new GsonBuilder().registerTypeAdapter(constraintType, new PropertyConstraintDeserialiser()).create();
 128                 log.trace("convert json to object. json=\n{}", data);
 129                 T resource = gson.fromJson(data, clazz);
 130                 return resource;
 131         }
 132
 133         public <T> Either<T, ResponseFormat> convertJsonToObjectUsingObjectMapper(String data, User user, Class<T> clazz, AuditingActionEnum actionEnum, ComponentTypeEnum typeEnum) {
 134                 T component = null;
 135                 ObjectMapper mapper = new ObjectMapper().configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 136
 137                 try {
 138                         log.trace("convert json to object. json=\n{}", data);
 139
 140                         final SimpleModule module = new SimpleModule("customerSerializationModule", new Version(1, 0, 0, "static version"));
 141                         JsonDeserializer<PropertyConstraint> desrializer = new PropertyConstraintJacksonDeserialiser();
 142                         addDeserializer(module, PropertyConstraint.class, desrializer);
 143                         //
 144                         mapper.registerModule(module);
 145
 146                         component = mapper.readValue(data, clazz);
 147                         if (component == null) {
 148                                 BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeInvalidJsonInput, "convertJsonToObject");
 149                                 BeEcompErrorManager.getInstance().logBeInvalidJsonInput("convertJsonToObject");
 150                                 log.debug("object is null after converting from json");
 151                                 ResponseFormat responseFormat = getInvalidContentErrorAndAuditComponent(user, actionEnum, typeEnum);
 152                                 return Either.right(responseFormat);
 153                         }
 154                 } catch (Exception e) {
 155                         BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeInvalidJsonInput, "convertJsonToObject");
 156                         BeEcompErrorManager.getInstance().logBeInvalidJsonInput("convertJsonToObject");
 157                         log.debug("failed to convert from json {}", data, e);
 158                         ResponseFormat responseFormat = getInvalidContentErrorAndAuditComponent(user, actionEnum, typeEnum);
 159                         return Either.right(responseFormat);
 160                 }
 161                 return Either.left(component);
 162         }
 163
 164         public <T> void addDeserializer(SimpleModule module, Class<T> clazz, final JsonDeserializer<T> deserializer) {
 165                 module.addDeserializer(clazz, deserializer);
 166         }
 167
 168         // Error response
 169
 170         public ResponseFormat getResponseFormat(ActionStatus actionStatus, String... params) {
 171                 return responseFormatManager.getResponseFormat(actionStatus, params);
 172         }
 173
 174         /**
 175          * Returns the response format of resource error with respective variables according to actionStatus. This is needed for cases where actionStatus is anonymously converted from storage operation, and the caller doesn't know what actionStatus he
 176          * received. It's caller's Responsibility to fill the resource object passed to this function with needed fields.
 177          *
 178          * Note that RESOURCE_IN_USE case passes hardcoded "resource" string to the error parameter. This means that if Resource object will also be used for Service, this code needs to be refactored and we should tell Resource from Service.
 179          *
 180          * @param actionStatus
 181          * @param resource
 182          * @return
 183          */
 184         public ResponseFormat getResponseFormatByResource(ActionStatus actionStatus, Resource resource) {
 185                 if (resource == null) {
 186                         return getResponseFormat(actionStatus);
 187                 }
 188                 ResponseFormat responseFormat;
 189
 190                 switch (actionStatus) {
 191                 case COMPONENT_VERSION_ALREADY_EXIST:
 192                         responseFormat = getResponseFormat(ActionStatus.COMPONENT_VERSION_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resource.getVersion());
 193                         break;
 194                 case RESOURCE_NOT_FOUND:
 195                         responseFormat = getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, resource.getName());
 196                         break;
 197                 case COMPONENT_NAME_ALREADY_EXIST:
 198                         responseFormat = getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
 199                         break;
 200                 case COMPONENT_IN_USE:
 201                         responseFormat = getResponseFormat(ActionStatus.COMPONENT_IN_USE, ComponentTypeEnum.RESOURCE.name().toLowerCase(), resource.getUniqueId());
 202                         break;
 203                 default:
 204                         responseFormat = getResponseFormat(actionStatus);
 205                         break;
 206                 }
 207                 return responseFormat;
 208         }
 209
 210         public ResponseFormat getResponseFormatByResource(ActionStatus actionStatus, String resourceName) {
 211                 if (resourceName == null) {
 212                         return getResponseFormat(actionStatus);
 213                 }
 214                 ResponseFormat responseFormat;
 215
 216                 switch (actionStatus) {
 217                 case RESOURCE_NOT_FOUND:
 218                         responseFormat = getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, resourceName);
 219                         break;
 220                 default:
 221                         responseFormat = getResponseFormat(actionStatus);
 222                         break;
 223                 }
 224                 return responseFormat;
 225         }
 226
 227         public ResponseFormat getResponseFormatByCapabilityType(ActionStatus actionStatus, CapabilityTypeDefinition capabilityType) {
 228                 if (capabilityType == null) {
 229                         return getResponseFormat(actionStatus);
 230                 }
 231                 ResponseFormat responseFormat;
 232
 233                 switch (actionStatus) {
 234                 case CAPABILITY_TYPE_ALREADY_EXIST:
 235                         responseFormat = getResponseFormat(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, capabilityType.getType());
 236                         break;
 237                 default:
 238                         responseFormat = getResponseFormat(actionStatus);
 239                         break;
 240                 }
 241                 return responseFormat;
 242         }
 243
 244         /**
 245          * Returns the response format of resource error with respective variables according to actionStatus. This is needed for cases where actionStatus is anynomously converted from storage operation, and the caller doesn't know what actionStatus he
 246          * received. It's caller's responisibility to fill the passed resource object with needed fields.
 247          *
 248          * @param actionStatus
 249          * @param user
 250          * @return
 251          */
 252         public ResponseFormat getResponseFormatByUser(ActionStatus actionStatus, User user) {
 253                 if (user == null) {
 254                         return getResponseFormat(actionStatus);
 255                 }
 256                 ResponseFormat requestErrorWrapper;
 257                 switch (actionStatus) {
 258                 case INVALID_USER_ID:
 259                         requestErrorWrapper = getResponseFormat(actionStatus, user.getUserId());
 260                         break;
 261                 case INVALID_EMAIL_ADDRESS:
 262                         requestErrorWrapper = getResponseFormat(actionStatus, user.getEmail());
 263                         break;
 264                 case INVALID_ROLE:
 265                         requestErrorWrapper = getResponseFormat(actionStatus, user.getRole());
 266                         break;
 267                 case USER_NOT_FOUND:
 268                 case USER_ALREADY_EXIST:
 269                 case USER_INACTIVE:
 270                 case USER_HAS_ACTIVE_ELEMENTS:
 271                         requestErrorWrapper = getResponseFormat(actionStatus, user.getUserId());
 272                         break;
 273                 default:
 274                         requestErrorWrapper = getResponseFormat(actionStatus);
 275                         break;
 276                 }
 277                 return requestErrorWrapper;
 278         }
 279
 280         public ResponseFormat getResponseFormatByUserId(ActionStatus actionStatus, String userId) {
 281                 User user = new User();
 282                 user.setUserId(userId);
 283                 return getResponseFormatByUser(actionStatus, user);
 284         }
 285
 286         public ResponseFormat getResponseFormatByDE(ActionStatus actionStatus, String serviceId, String envName) {
 287                 ResponseFormat responseFormat;
 288
 289                 switch (actionStatus) {
 290                 case DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE:
 291                         responseFormat = getResponseFormat(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE, envName);
 292                         break;
 293                 case DISTRIBUTION_ENVIRONMENT_NOT_FOUND:
 294                         responseFormat = getResponseFormat(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_FOUND, envName);
 295                         break;
 296                 case DISTRIBUTION_ARTIFACT_NOT_FOUND:
 297                         responseFormat = getResponseFormat(ActionStatus.DISTRIBUTION_ARTIFACT_NOT_FOUND, serviceId);
 298                         break;
 299                 default:
 300                         responseFormat = getResponseFormat(actionStatus);
 301                         break;
 302                 }
 303                 return responseFormat;
 304         }
 305
 306         public ResponseFormat getResponseFormatByArtifactId(ActionStatus actionStatus, String artifactId) {
 307                 ResponseFormat responseFormat;
 308
 309                 switch (actionStatus) {
 310                 case RESOURCE_NOT_FOUND:
 311                 case ARTIFACT_NOT_FOUND:
 312                         responseFormat = getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, artifactId);
 313                         break;
 314                 default:
 315                         responseFormat = getResponseFormat(actionStatus);
 316                         break;
 317                 }
 318                 return responseFormat;
 319         }
 320
 321         public ResponseFormat getInvalidContentErrorAndAudit(User user, AuditingActionEnum actionEnum) {
 322                 ResponseFormat responseFormat = responseFormatManager.getResponseFormat(ActionStatus.INVALID_CONTENT);
 323                 log.debug("audit before sending response");
 324                 auditResource(responseFormat, user, null, "", "", actionEnum, null);
 325                 return responseFormat;
 326         }
 327
 328         public ResponseFormat getInvalidContentErrorAndAuditComponent(User user, AuditingActionEnum actionEnum, ComponentTypeEnum typeEnum) {
 329                 ResponseFormat responseFormat = responseFormatManager.getResponseFormat(ActionStatus.INVALID_CONTENT);
 330                 log.debug("audit before sending response");
 331                 auditComponentAdmin(responseFormat, user, null, "", "", actionEnum, typeEnum);
 332                 return responseFormat;
 333         }
 334
 335         public void auditResource(ResponseFormat responseFormat, User modifier, Resource resource, String prevState, String prevVersion, AuditingActionEnum actionEnum, EnumMap<AuditingFieldsKeysEnum, Object> additionalParams) {
 336                 if (actionEnum != null) {
 337                         log.trace("Inside auditing for audit action {}", actionEnum.name());
 338                         EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 339                         int status = responseFormat.getStatus();
 340                         String message = "";
 341
 342                         if (responseFormat.getMessageId() != null) {
 343                                 message = responseFormat.getMessageId() + ": ";
 344                         }
 345                         message += responseFormat.getFormattedMessage();
 346
 347                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
 348
 349                         updateUserFields(modifier, auditingFields);
 350
 351                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, ComponentTypeEnum.RESOURCE.getValue());
 352                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_VERSION, prevVersion);
 353                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_STATE, prevState);
 354                         if (resource != null) {
 355                                 // fields that are filled during creation and might still be
 356                                 // empty
 357                                 String resourceCurrVersion = (resource.getVersion() != null) ? resource.getVersion() : "";
 358                                 String resourceCurrState = (resource.getLifecycleState() != null) ? resource.getLifecycleState().name() : "";
 359                                 String uuid = (resource.getUUID() != null) ? resource.getUUID() : "";
 360                                 String invariantUUID = (resource.getInvariantUUID() != null) ? resource.getInvariantUUID() : "";
 361
 362                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resource.getName());
 363                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, resourceCurrVersion);
 364                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, resourceCurrState);
 365                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, uuid);
 366                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_INVARIANT_UUID, invariantUUID);
 367
 368                         } else {
 369                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_INVARIANT_UUID, "");
 370                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, "");
 371                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, "");
 372                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, "");
 373                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, "");
 374                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_INVARIANT_UUID, "");
 375                         }
 376                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
 377                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, message);
 378
 379                         // In those specific cases we want some specific fields from
 380                         // resource object
 381                         switch (actionEnum) {
 382                         case IMPORT_RESOURCE:
 383                                 if (resource != null) {
 384                                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TOSCA_NODE_TYPE, resource.getToscaResourceName());
 385                                 } else {
 386                                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TOSCA_NODE_TYPE, "");
 387                                 }
 388                                 break;
 389                         default:
 390                                 break;
 391                         }
 392
 393                         // This is to add/overwrite anything set in this function if some
 394                         // params were passed from above,
 395                         // for example resourceName of resource import
 396                         if (additionalParams != null) {
 397                                 auditingFields.putAll(additionalParams);
 398                         }
 399
 400                         getAuditingManager().auditEvent(auditingFields);
 401                 }
 402         }
 403
 404         private void updateUserFields(User modifier, EnumMap<AuditingFieldsKeysEnum, Object> auditingFields) {
 405                 if (modifier != null) {
 406                         String firstName = modifier.getFirstName();
 407                         String lastName = modifier.getLastName();
 408                         if (firstName != null || lastName != null) {// to prevent "null
 409                                                                                                                 // null" names
 410                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, firstName + " " + lastName);
 411                         }
 412                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifier.getUserId());
 413                 }
 414         }
 415
 416         public void auditDistributionDownload(ResponseFormat responseFormat, AuditingActionEnum actionEnum, EnumMap<AuditingFieldsKeysEnum, Object> additionalParams) {
 417                 log.trace("Inside auditing for audit action {}", actionEnum.name());
 418                 int status = responseFormat.getStatus();
 419                 String message = "";
 420                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 421                 if (responseFormat.getMessageId() != null) {
 422                         message = responseFormat.getMessageId() + ": ";
 423                 }
 424                 message += responseFormat.getFormattedMessage();
 425                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
 426                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
 427                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, message);
 428
 429                 // This is to add/overwrite anything set in this function if some params
 430                 // were passed from above,
 431                 // for example resourceName of resource import
 432                 if (additionalParams != null) {
 433                         auditingFields.putAll(additionalParams);
 434                 }
 435
 436                 getAuditingManager().auditEvent(auditingFields);
 437         }
 438
 439         public void auditExternalGetAsset(ResponseFormat responseFormat, AuditingActionEnum actionEnum, EnumMap<AuditingFieldsKeysEnum, Object> additionalParams) {
 440                 log.trace("Inside auditing for audit action {}", actionEnum.name());
 441                 int status = responseFormat.getStatus();
 442                 String message = "";
 443                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 444                 if (responseFormat.getMessageId() != null) {
 445                         message = responseFormat.getMessageId() + ": ";
 446                 }
 447                 message += responseFormat.getFormattedMessage();
 448                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
 449                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
 450                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, message);
 451
 452                 if (additionalParams != null) {
 453                         auditingFields.putAll(additionalParams);
 454                 }
 455
 456                 getAuditingManager().auditEvent(auditingFields);
 457         }
 458
 459         public void auditExternalCrudApi(ResponseFormat responseFormat, String componentType, String actionEnum, HttpServletRequest request, EnumMap<AuditingFieldsKeysEnum, Object> additionalParams) {
 460                 log.trace("Inside auditing for audit action {}", actionEnum);
 461                 String instanceIdHeader = request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER);
 462                 String requestURI = request.getRequestURI();
 463                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 464                 int status = 0;
 465                 String message = "";
 466                 if(responseFormat != null){
 467                         status = responseFormat.getStatus();
 468                         if (responseFormat.getMessageId() != null) {
 469                                 message = responseFormat.getMessageId() + ": ";
 470                         }
 471                         message += responseFormat.getFormattedMessage();
 472                 }
 473                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum);
 474                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, instanceIdHeader);
 475                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_RESOURCE_URL, requestURI);
 476                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, componentType);
 477                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
 478                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, message);
 479
 480                 if (additionalParams != null) {
 481                         auditingFields.putAll(additionalParams);
 482                         if(!additionalParams.containsKey(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME)){
 483                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, "");
 484                         }
 485                 }
 486
 487                 getAuditingManager().auditEvent(auditingFields);
 488         }
 489
 490         public void auditExternalDownloadArtifact(ResponseFormat responseFormat, String componentType, HttpServletRequest request, EnumMap<AuditingFieldsKeysEnum, Object> additionalParams) {
 491                 auditExternalCrudApi(responseFormat, componentType, AuditingActionEnum.DOWNLOAD_ARTIFACT.getName(), request, additionalParams);
 492         }
 493
 494         public void auditExternalUploadArtifact(ResponseFormat responseFormat, String componentType, HttpServletRequest request, EnumMap<AuditingFieldsKeysEnum, Object> additionalParams) {
 495                 additionalParams.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, request.getHeader(Constants.USER_ID_HEADER));
 496                 additionalParams.put(AuditingFieldsKeysEnum.AUDIT_PREV_ARTIFACT_UUID, "");
 497                 auditExternalCrudApi(responseFormat, componentType, AuditingActionEnum.ARTIFACT_UPLOAD_BY_API.getName(), request, additionalParams);
 498         }
 499
 500         public void auditExternalUpdateArtifact(ResponseFormat responseFormat, String componentType, HttpServletRequest request, EnumMap<AuditingFieldsKeysEnum, Object> additionalParams) {
 501                 additionalParams.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, request.getHeader(Constants.USER_ID_HEADER));
 502                 additionalParams.put(AuditingFieldsKeysEnum.AUDIT_PREV_ARTIFACT_UUID, "");
 503                 auditExternalCrudApi(responseFormat, componentType, AuditingActionEnum.ARTIFACT_UPDATE_BY_API.getName(), request, additionalParams);
 504         }
 505
 506         public void auditExternalDeleteArtifact(ResponseFormat responseFormat, String componentType, HttpServletRequest request, EnumMap<AuditingFieldsKeysEnum, Object> additionalParams) {
 507                 additionalParams.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, request.getHeader(Constants.USER_ID_HEADER));
 508                 additionalParams.put(AuditingFieldsKeysEnum.AUDIT_PREV_ARTIFACT_UUID, "");
 509                 auditExternalCrudApi(responseFormat, componentType, AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName(), request, additionalParams);
 510         }
 511
 512         public void auditCategory(ResponseFormat responseFormat, User modifier, String categoryName, String subCategoryName, String groupingName, AuditingActionEnum actionEnum, String componentType) {
 513                 log.trace("Inside auditing for audit action {}", actionEnum.name());
 514                 int status = responseFormat.getStatus();
 515                 String message = "";
 516
 517                 if (responseFormat.getMessageId() != null) {
 518                         message = responseFormat.getMessageId() + ": ";
 519                 }
 520                 message += responseFormat.getFormattedMessage();
 521
 522                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 523                 updateUserFields(modifier, auditingFields);
 524                 // String componentTypeStr = (componentTypeEnum != null ?
 525                 // componentTypeEnum.getValue() : null);
 526                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, componentType);
 527
 528                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
 529                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
 530                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, message);
 531
 532                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_CATEGORY_NAME, categoryName);
 533                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SUB_CATEGORY_NAME, subCategoryName);
 534                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_GROUPING_NAME, groupingName);
 535                 getAuditingManager().auditEvent(auditingFields);
 536         }
 537
 538         public ActionStatus convertFromStorageResponse(StorageOperationStatus storageResponse) {
 539
 540                 return convertFromStorageResponse(storageResponse, ComponentTypeEnum.RESOURCE);
 541         }
 542
 543         public ActionStatus convertFromStorageResponse(StorageOperationStatus storageResponse, ComponentTypeEnum type) {
 544
 545                 ActionStatus responseEnum = ActionStatus.GENERAL_ERROR;
 546                 if (storageResponse == null) {
 547                         return responseEnum;
 548                 }
 549                 switch (storageResponse) {
 550                 case OK:
 551                         responseEnum = ActionStatus.OK;
 552                         break;
 553                 case CONNECTION_FAILURE:
 554                 case GRAPH_IS_LOCK:
 555                         responseEnum = ActionStatus.GENERAL_ERROR;
 556                         break;
 557                 case BAD_REQUEST:
 558                         responseEnum = ActionStatus.INVALID_CONTENT;
 559                         break;
 560                 case ENTITY_ALREADY_EXISTS:
 561                         responseEnum = ActionStatus.COMPONENT_NAME_ALREADY_EXIST;
 562                         break;
 563                 case PARENT_RESOURCE_NOT_FOUND:
 564                         responseEnum = ActionStatus.PARENT_RESOURCE_NOT_FOUND;
 565                         break;
 566                 case MULTIPLE_PARENT_RESOURCE_FOUND:
 567                         responseEnum = ActionStatus.MULTIPLE_PARENT_RESOURCE_FOUND;
 568                         break;
 569                 case NOT_FOUND:
 570                         if (ComponentTypeEnum.RESOURCE == type) {
 571                                 responseEnum = ActionStatus.RESOURCE_NOT_FOUND;
 572                         } else if (ComponentTypeEnum.PRODUCT == type) {
 573                                 responseEnum = ActionStatus.PRODUCT_NOT_FOUND;
 574                         } else {
 575                                 responseEnum = ActionStatus.SERVICE_NOT_FOUND;
 576                         }
 577                         break;
 578                 case FAILED_TO_LOCK_ELEMENT:
 579                         responseEnum = ActionStatus.COMPONENT_IN_USE;
 580                         break;
 581                 case ARTIFACT_NOT_FOUND:
 582                         responseEnum = ActionStatus.ARTIFACT_NOT_FOUND;
 583                         break;
 584                 case DISTR_ENVIRONMENT_NOT_AVAILABLE:
 585                         responseEnum = ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE;
 586                         break;
 587                 case DISTR_ENVIRONMENT_NOT_FOUND:
 588                         responseEnum = ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_FOUND;
 589                         break;
 590                 case DISTR_ENVIRONMENT_SENT_IS_INVALID:
 591                         responseEnum = ActionStatus.DISTRIBUTION_ENVIRONMENT_INVALID;
 592                         break;
 593                 case DISTR_ARTIFACT_NOT_FOUND:
 594                         responseEnum = ActionStatus.DISTRIBUTION_ARTIFACT_NOT_FOUND;
 595                         break;
 596                 case INVALID_TYPE:
 597                         responseEnum = ActionStatus.INVALID_CONTENT;
 598                         break;
 599                 case INVALID_VALUE:
 600                         responseEnum = ActionStatus.INVALID_CONTENT;
 601                         break;
 602                 case CSAR_NOT_FOUND:
 603                         responseEnum = ActionStatus.CSAR_NOT_FOUND;
 604                         break;
 605                 case PROPERTY_NAME_ALREADY_EXISTS:
 606                         responseEnum = ActionStatus.PROPERTY_NAME_ALREADY_EXISTS;
 607                         break;
 608                 case MATCH_NOT_FOUND:
 609                         responseEnum = ActionStatus.COMPONENT_SUB_CATEGORY_NOT_FOUND_FOR_CATEGORY;
 610                         break;
 611                 case CATEGORY_NOT_FOUND:
 612                         responseEnum = ActionStatus.COMPONENT_CATEGORY_NOT_FOUND;
 613                         break;
 614                 case INVALID_PROPERTY:
 615                         responseEnum = ActionStatus.INVALID_PROPERTY;
 616                         break;
 617                 default:
 618                         responseEnum = ActionStatus.GENERAL_ERROR;
 619                         break;
 620                 }
 621                 log.debug("convert storage response {} to action response {}", storageResponse.name(), responseEnum.name());
 622                 return responseEnum;
 623         }
 624
 625         public ActionStatus convertFromToscaError(ToscaError toscaError) {
 626                 ActionStatus responseEnum = ActionStatus.GENERAL_ERROR;
 627                 if (toscaError == null) {
 628                         return responseEnum;
 629                 }
 630                 switch (toscaError) {// TODO match errors
 631                 case NODE_TYPE_CAPABILITY_ERROR:
 632                 case NOT_SUPPORTED_TOSCA_TYPE:
 633                 case NODE_TYPE_REQUIREMENT_ERROR:
 634                         responseEnum = ActionStatus.INVALID_CONTENT;
 635                         break;
 636                 default:
 637                         responseEnum = ActionStatus.GENERAL_ERROR;
 638                         break;
 639                 }
 640                 return responseEnum;
 641         }
 642
 643         public ActionStatus convertFromStorageResponseForCapabilityType(StorageOperationStatus storageResponse) {
 644                 ActionStatus responseEnum = ActionStatus.GENERAL_ERROR;
 645
 646                 switch (storageResponse) {
 647                 case OK:
 648                         responseEnum = ActionStatus.OK;
 649                         break;
 650                 case CONNECTION_FAILURE:
 651                 case GRAPH_IS_LOCK:
 652                         responseEnum = ActionStatus.GENERAL_ERROR;
 653                         break;
 654                 case BAD_REQUEST:
 655                         responseEnum = ActionStatus.INVALID_CONTENT;
 656                         break;
 657                 case ENTITY_ALREADY_EXISTS:
 658                         responseEnum = ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST;
 659                         break;
 660                 case SCHEMA_VIOLATION:
 661                         responseEnum = ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST;
 662                         break;
 663                 default:
 664                         responseEnum = ActionStatus.GENERAL_ERROR;
 665                         break;
 666                 }
 667                 log.debug("convert storage response {} to action response {}", storageResponse.name(), responseEnum.name());
 668                 return responseEnum;
 669         }
 670
 671         public ActionStatus convertFromStorageResponseForLifecycleType(StorageOperationStatus storageResponse) {
 672                 ActionStatus responseEnum = ActionStatus.GENERAL_ERROR;
 673
 674                 switch (storageResponse) {
 675                 case OK:
 676                         responseEnum = ActionStatus.OK;
 677                         break;
 678                 case CONNECTION_FAILURE:
 679                 case GRAPH_IS_LOCK:
 680                         responseEnum = ActionStatus.GENERAL_ERROR;
 681                         break;
 682                 case BAD_REQUEST:
 683                         responseEnum = ActionStatus.INVALID_CONTENT;
 684                         break;
 685                 case ENTITY_ALREADY_EXISTS:
 686                         responseEnum = ActionStatus.LIFECYCLE_TYPE_ALREADY_EXIST;
 687                         break;
 688                 case SCHEMA_VIOLATION:
 689                         responseEnum = ActionStatus.LIFECYCLE_TYPE_ALREADY_EXIST;
 690                         break;
 691                 default:
 692                         responseEnum = ActionStatus.GENERAL_ERROR;
 693                         break;
 694                 }
 695                 log.debug("convert storage response {} to action response {}", storageResponse.name(), responseEnum.name());
 696                 return responseEnum;
 697         }
 698
 699         public ActionStatus convertFromStorageResponseForResourceInstance(StorageOperationStatus storageResponse, boolean isRelation) {
 700                 ActionStatus responseEnum = ActionStatus.GENERAL_ERROR;
 701
 702                 switch (storageResponse) {
 703                 case OK:
 704                         responseEnum = ActionStatus.OK;
 705                         break;
 706                 case INVALID_ID:
 707                         responseEnum = ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST;
 708                         break;
 709                 case INVALID_PROPERTY:
 710                         responseEnum = ActionStatus.INVALID_PROPERTY;
 711                         break;
 712                 case GRAPH_IS_LOCK:
 713                         responseEnum = ActionStatus.GENERAL_ERROR;
 714                         break;
 715                 case BAD_REQUEST:
 716                         responseEnum = ActionStatus.INVALID_CONTENT;
 717                         break;
 718                 case MATCH_NOT_FOUND:
 719                         responseEnum = ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND;
 720                         break;
 721                 case SCHEMA_VIOLATION:
 722                         responseEnum = ActionStatus.RESOURCE_INSTANCE_ALREADY_EXIST;
 723                         break;
 724                 case NOT_FOUND:
 725                         if (isRelation) {
 726                                 responseEnum = ActionStatus.RESOURCE_INSTANCE_RELATION_NOT_FOUND;
 727                         } else {
 728                                 responseEnum = ActionStatus.RESOURCE_INSTANCE_NOT_FOUND;
 729                         }
 730                         break;
 731                 default:
 732                         responseEnum = ActionStatus.GENERAL_ERROR;
 733                         break;
 734                 }
 735                 log.debug("convert storage response {} to action response {}", storageResponse.name(), responseEnum.name());
 736                 return responseEnum;
 737         }
 738
 739         public ResponseFormat getResponseFormatForResourceInstance(ActionStatus actionStatus, String serviceName, String resourceInstanceName) {
 740                 ResponseFormat responseFormat;
 741
 742                 switch (actionStatus) {
 743                 case RESOURCE_INSTANCE_NOT_FOUND:
 744                         responseFormat = getResponseFormat(actionStatus, resourceInstanceName);
 745                         break;
 746                 default:
 747                         responseFormat = getResponseFormat(actionStatus, serviceName);
 748                         break;
 749                 }
 750                 return responseFormat;
 751         }
 752
 753         public ResponseFormat getResponseFormatForResourceInstanceProperty(ActionStatus actionStatus, String resourceInstanceName) {
 754                 ResponseFormat responseFormat;
 755
 756                 switch (actionStatus) {
 757                 case RESOURCE_INSTANCE_NOT_FOUND:
 758                         responseFormat = getResponseFormat(actionStatus, resourceInstanceName);
 759                         break;
 760                 default:
 761                         responseFormat = getResponseFormat(actionStatus);
 762                         break;
 763                 }
 764                 return responseFormat;
 765         }
 766
 767         public ActionStatus convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus storageResponse) {
 768                 ActionStatus responseEnum = ActionStatus.GENERAL_ERROR;
 769
 770                 switch (storageResponse) {
 771                 case OK:
 772                         responseEnum = ActionStatus.OK;
 773                         break;
 774                 case INVALID_ID:
 775                         responseEnum = ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST;
 776                         break;
 777                 case GRAPH_IS_LOCK:
 778                         responseEnum = ActionStatus.GENERAL_ERROR;
 779                         break;
 780                 case BAD_REQUEST:
 781                         responseEnum = ActionStatus.INVALID_CONTENT;
 782                         break;
 783                 case MATCH_NOT_FOUND:
 784                         responseEnum = ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND;
 785                         break;
 786                 case SCHEMA_VIOLATION:
 787                         responseEnum = ActionStatus.RESOURCE_INSTANCE_ALREADY_EXIST;
 788                         break;
 789                 case NOT_FOUND:
 790                         responseEnum = ActionStatus.RESOURCE_INSTANCE_NOT_FOUND;
 791                         break;
 792                 default:
 793                         responseEnum = ActionStatus.GENERAL_ERROR;
 794                         break;
 795                 }
 796                 log.debug("convert storage response {} to action response {}", storageResponse.name(), responseEnum.name());
 797                 return responseEnum;
 798         }
 799
 800         public void auditComponentAdmin(ResponseFormat responseFormat, User modifier, Component component, String prevState, String prevVersion, AuditingActionEnum actionEnum, ComponentTypeEnum type) {
 801                 auditComponent(responseFormat, modifier, component, prevState, prevVersion, actionEnum, type, null);
 802         }
 803
 804         public void auditComponent(ResponseFormat responseFormat, User modifier, Component component, String prevState, String prevVersion, AuditingActionEnum actionEnum, ComponentTypeEnum type, EnumMap<AuditingFieldsKeysEnum, Object> additionalParams) {
 805                 if (actionEnum != null) {
 806                         log.trace("Inside auditing for audit action {}", actionEnum.name());
 807                         EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 808
 809                         int status = responseFormat.getStatus();
 810                         String message = "";
 811
 812                         if (responseFormat.getMessageId() != null) {
 813                                 message = responseFormat.getMessageId() + ": ";
 814                         }
 815                         message += responseFormat.getFormattedMessage();
 816
 817                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
 818
 819                         updateUserFields(modifier, auditingFields);
 820                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, type.getValue().replace(" ", ""));
 821
 822                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_VERSION, prevVersion);
 823                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_STATE, prevState);
 824                         if (component != null) {
 825                                 // fields that are filled during creation and might still be
 826                                 // empty
 827                                 String resourceCurrVersion = component.getVersion();
 828                                 String resourceCurrState = (component.getLifecycleState() != null) ? component.getLifecycleState().name() : "";
 829                                 String resourceUuid = (component.getUUID() != null) ? component.getUUID() : "";
 830                                 String invariantUUID = (component.getInvariantUUID() != null) ? component.getInvariantUUID() : "";
 831
 832                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, component.getComponentMetadataDefinition().getMetadataDataDefinition().getName());
 833                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, resourceCurrVersion);
 834                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, resourceCurrState);
 835                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, resourceUuid);
 836                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_INVARIANT_UUID, invariantUUID);
 837                         } else {
 838                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, "");
 839                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, "");
 840                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, "");
 841                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, "");
 842                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_INVARIANT_UUID, "");
 843                         }
 844                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
 845                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, message);
 846
 847                         // This is meant to overwrite anything set in this function if some
 848                         // params were passed from above,
 849                         // for example resourceName of resource import
 850                         if (additionalParams != null) {
 851                                 auditingFields.putAll(additionalParams);
 852                         }
 853
 854                         getAuditingManager().auditEvent(auditingFields);
 855                 }
 856         }
 857
 858         public void auditDistributionEngine(AuditingActionEnum actionEnum, String environmentName, String topicName, String role, String apiKey, String status) {
 859
 860                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 861                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
 862
 863                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ENVRIONMENT_NAME, environmentName);
 864                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TOPIC_NAME, topicName);
 865                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ROLE, role);
 866                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_API_KEY, apiKey);
 867                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
 868
 869                 getAuditingManager().auditEvent(auditingFields);
 870         }
 871
 872         public void auditDistributionNotification(AuditingActionEnum actionEnum, String serviceUUID, String resourceName, String resourceType, String currVersion, String modifierUid, String modifierName, String environmentName, String currState,
 873                         String topicName, String distributionId, String description, String status) {
 874
 875                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 876                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
 877                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, serviceUUID);
 878
 879                 // auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ENVRIONMENT_NAME,
 880                 // environmentName);
 881                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TOPIC_NAME, topicName);
 882                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, distributionId);
 883                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
 884                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, currVersion);
 885                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, currState);
 886                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, resourceType);
 887                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, description);
 888                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifierUid);
 889                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifierName);
 890                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceName);
 891
 892                 getAuditingManager().auditEvent(auditingFields);
 893         }
 894
 895         public void auditAuthEvent(AuditingActionEnum actionEnum, String url, String user, String authStatus, String realm) {
 896
 897                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 898                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
 899                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_URL, url);
 900                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_USER, user);
 901                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_STATUS, authStatus);
 902                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_REALM, realm);
 903                 getAuditingManager().auditEvent(auditingFields);
 904         }
 905
 906         public void auditDistributionStatusNotification(AuditingActionEnum actionEnum, String distributionId, String consumerId, String topicName, String resourceUrl, String statusTime, String status, String errorReason) {
 907
 908                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 909                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
 910                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, distributionId);
 911                 ThreadLocalsHolder.setUuid(distributionId);
 912
 913                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, distributionId);
 914                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, consumerId);
 915                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TOPIC_NAME, topicName);
 916                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_RESOURCE_URL, resourceUrl);
 917                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_STATUS_TIME, statusTime);
 918                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
 919                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, errorReason);
 920
 921                 getAuditingManager().auditEvent(auditingFields);
 922         }
 923
 924         public void auditGetUebCluster(AuditingActionEnum actionEnum, String consumerId, String statusTime, String status, String description) {
 925
 926                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 927                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
 928                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, consumerId);
 929                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_STATUS_TIME, statusTime);
 930                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
 931                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_STATUS_DESC, description);
 932
 933                 getAuditingManager().auditEvent(auditingFields);
 934         }
 935
 936         public void auditMissingInstanceId(AuditingActionEnum actionEnum, String status, String description) {
 937
 938                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 939                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
 940                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, null);
 941                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, null);
 942                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
 943                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, description);
 944
 945                 getAuditingManager().auditEvent(auditingFields);
 946         }
 947
 948         public void auditTopicACLKeys(AuditingActionEnum actionEnum, String envName, String topicName, String role, String apiPublicKey, String status) {
 949
 950                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 951                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
 952                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ENVRIONMENT_NAME, envName);
 953                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TOPIC_NAME, topicName);
 954                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ROLE, role);
 955                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_API_KEY, apiPublicKey);
 956                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
 957
 958                 getAuditingManager().auditEvent(auditingFields);
 959         }
 960
 961         public void auditRegisterOrUnRegisterEvent(AuditingActionEnum actionEnum, String consumerId, String apiPublicKey, String envName, String status, String statusDesc, String notifTopicName, String statusTopicName) {
 962                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 963                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
 964                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, consumerId);
 965                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_API_KEY, apiPublicKey);
 966                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ENVRIONMENT_NAME, envName);
 967                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
 968                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_STATUS_DESC, statusDesc);
 969                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_NOTIFICATION_TOPIC_NAME, notifTopicName);
 970                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_STATUS_TOPIC_NAME, statusTopicName);
 971                 getAuditingManager().auditEvent(auditingFields);
 972         }
 973
 974         public void auditServiceDistributionDeployed(AuditingActionEnum actionEnum, String serviceName, String serviceVersion, String serviceUUID, String distributionId, String status, String desc, User modifier) {
 975
 976                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 977                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
 978                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, serviceUUID);
 979
 980                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifier.getFirstName() + " " + modifier.getLastName());
 981                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifier.getUserId());
 982                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, "Service");
 983                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, serviceName);
 984                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, serviceVersion);
 985
 986                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, distributionId);
 987                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
 988                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, desc);
 989
 990                 getAuditingManager().auditEvent(auditingFields);
 991         }
 992
 993         public void auditConsumerCredentialsEvent(AuditingActionEnum actionEnum, ConsumerDefinition consumer, ResponseFormat responseFormat, User modifier) {
 994
 995                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 996                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
 997                 if (modifier != null) {
 998                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifier.getFirstName() + " " + modifier.getLastName());
 999                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifier.getUserId());
1000                 }
1001                 StringBuilder ecompUser = new StringBuilder();
1002                 if (consumer != null) {
1003                         if (consumer.getConsumerName() != null && !consumer.getConsumerName().trim().isEmpty()) {
1004                                 ecompUser.append(consumer.getConsumerName());
1005                         }
1006                         if (consumer.getConsumerSalt() != null && !consumer.getConsumerSalt().trim().isEmpty()) {
1007                                 if (ecompUser.length() > 0) {
1008                                         ecompUser.append(",");
1009                                 }
1010                                 ecompUser.append(consumer.getConsumerSalt());
1011                         }
1012                         if (consumer.getConsumerPassword() != null && !consumer.getConsumerPassword().trim().isEmpty()) {
1013                                 if (ecompUser.length() > 0) {
1014                                         ecompUser.append(",");
1015                                 }
1016                                 ecompUser.append(consumer.getConsumerPassword());
1017                         }
1018                 }
1019                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ECOMP_USER, ecompUser.toString());
1020                 int status = responseFormat.getStatus();
1021                 String message = "";
1022
1023                 if (responseFormat.getMessageId() != null) {
1024                         message = responseFormat.getMessageId() + ": ";
1025                 }
1026                 message += responseFormat.getFormattedMessage();
1027                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
1028                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, message);
1029
1030                 getAuditingManager().auditEvent(auditingFields);
1031         }
1032
1033         public void auditGetUsersList(AuditingActionEnum actionEnum, User modifier, String details, ResponseFormat responseFormat) {
1034
1035                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
1036                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
1037                 if (modifier != null) {
1038                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifier.getFirstName() + " " + modifier.getLastName());
1039                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifier.getUserId());
1040                 }
1041
1042                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_DETAILS, details);
1043                 int status = responseFormat.getStatus();
1044                 String message = "";
1045
1046                 if (responseFormat.getMessageId() != null) {
1047                         message = responseFormat.getMessageId() + ": ";
1048                 }
1049                 message += responseFormat.getFormattedMessage();
1050                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
1051                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, message);
1052                 getAuditingManager().auditEvent(auditingFields);
1053         }
1054
1055         public void auditAdminUserAction(AuditingActionEnum actionEnum, User modifier, User userBefore, User userAfter, ResponseFormat responseFormat) {
1056
1057                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
1058                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
1059                 if (modifier != null) {
1060                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifier.getFirstName() + " " + modifier.getLastName());
1061                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifier.getUserId());
1062                 } else {
1063                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, "");
1064                 }
1065                 if (userBefore != null) {
1066                         String userBeforeUserId = (userBefore.getUserId() != null) ? userBefore.getUserId() : "";
1067                         String userBeforFirstName = (userBefore.getFirstName() != null) ? ", " + userBefore.getFirstName() + " " : "";
1068                         String userBeforLastName = (userBefore.getLastName() != null) ? userBefore.getLastName() : "";
1069                         String userBeforEmail = (userBefore.getEmail() != null) ? ", " + userBefore.getEmail() : "";
1070                         String userBeforRloe = (userBefore.getRole() != null) ? ", " + userBefore.getRole() : "";
1071
1072                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_BEFORE, userBeforeUserId + userBeforFirstName + userBeforLastName + userBeforEmail + userBeforRloe);
1073                 } else {
1074                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_BEFORE, "");
1075                 }
1076                 if (userAfter != null) {
1077                         String userAfterUserId = (userAfter.getUserId() != null) ? userAfter.getUserId() : "";
1078                         String userAfterFirstName = (userAfter.getFirstName() != null) ? ", " + userAfter.getFirstName() + " " : "";
1079                         String userAfterLastName = (userAfter.getLastName() != null) ? userAfter.getLastName() : "";
1080                         String userAfterEmail = (userAfter.getEmail() != null) ? ", " + userAfter.getEmail() : "";
1081                         String userAfterRloe = (userAfter.getRole() != null) ? ", " + userAfter.getRole() : "";
1082
1083                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_AFTER, userAfterUserId + userAfterFirstName + userAfterLastName + userAfterEmail + userAfterRloe);
1084                 } else {
1085                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_AFTER, "");
1086                 }
1087
1088                 int status = responseFormat.getStatus();
1089                 String message = "";
1090
1091                 if (responseFormat.getMessageId() != null) {
1092                         message = responseFormat.getMessageId() + ": ";
1093                 }
1094                 message += responseFormat.getFormattedMessage();
1095                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
1096                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, message);
1097                 getAuditingManager().auditEvent(auditingFields);
1098         }
1099
1100         public void auditUserAccess(AuditingActionEnum actionEnum, User user, ResponseFormat responseFormat) {
1101
1102                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
1103                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
1104                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_UID, user.getFirstName() + " " + user.getLastName() + '(' + user.getUserId() + ')');
1105                 int status = responseFormat.getStatus();
1106                 String message = "";
1107
1108                 if (responseFormat.getMessageId() != null) {
1109                         message = responseFormat.getMessageId() + ": ";
1110                 }
1111                 message += responseFormat.getFormattedMessage();
1112                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
1113                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, message);
1114                 getAuditingManager().auditEvent(auditingFields);
1115         }
1116
1117         public void auditGetCategoryHierarchy(AuditingActionEnum actionEnum, User modifier, String details, ResponseFormat responseFormat) {
1118
1119                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
1120                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, actionEnum.getName());
1121                 if (modifier != null) {
1122                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifier.getFirstName() + " " + modifier.getLastName());
1123                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifier.getUserId());
1124                 }
1125                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DETAILS, details);
1126                 int status = responseFormat.getStatus();
1127                 String message = "";
1128
1129                 if (responseFormat.getMessageId() != null) {
1130                         message = responseFormat.getMessageId() + ": ";
1131                 }
1132                 message += responseFormat.getFormattedMessage();
1133                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status);
1134                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, message);
1135                 getAuditingManager().auditEvent(auditingFields);
1136         }
1137
1138         public ResponseFormat getResponseFormatByComponent(ActionStatus actionStatus, Component component, ComponentTypeEnum type) {
1139                 if (component == null) {
1140                         return getResponseFormat(actionStatus);
1141                 }
1142                 ResponseFormat responseFormat;
1143
1144                 switch (actionStatus) {
1145                 case COMPONENT_VERSION_ALREADY_EXIST:
1146                         responseFormat = getResponseFormat(ActionStatus.COMPONENT_VERSION_ALREADY_EXIST, type.getValue(), component.getVersion());
1147                         break;
1148                 case RESOURCE_NOT_FOUND:
1149                         responseFormat = getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, component.getComponentMetadataDefinition().getMetadataDataDefinition().getName());
1150                         break;
1151                 case COMPONENT_NAME_ALREADY_EXIST:
1152                         responseFormat = getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, type.getValue(), component.getComponentMetadataDefinition().getMetadataDataDefinition().getName());
1153                         break;
1154                 case COMPONENT_IN_USE:
1155                         responseFormat = getResponseFormat(ActionStatus.COMPONENT_IN_USE, type.name().toLowerCase(), component.getUniqueId());
1156                         break;
1157                 case SERVICE_DEPLOYMENT_ARTIFACT_NOT_FOUND:
1158                         responseFormat = getResponseFormat(ActionStatus.SERVICE_DEPLOYMENT_ARTIFACT_NOT_FOUND, component.getComponentMetadataDefinition().getMetadataDataDefinition().getName());
1159                         break;
1160                 default:
1161                         responseFormat = getResponseFormat(actionStatus);
1162                         break;
1163                 }
1164                 return responseFormat;
1165         }
1166
1167         public Either<Boolean, ResponseFormat> validateStringNotEmpty(User user, Component component, String value, ActionStatus badResult, AuditingActionEnum actionEnum) {
1168                 if ((value == null) || (value.trim().isEmpty())) {
1169                         log.info(badResult.name());
1170                         ResponseFormat errorResponse = getResponseFormat(badResult);
1171                         if (actionEnum != null) {
1172                                 log.debug("audit before sending response");
1173                                 auditComponentAdmin(errorResponse, user, component, "", "", actionEnum, getComponentType(component));
1174                         }
1175                         return Either.right(errorResponse);
1176                 }
1177                 return Either.left(true);
1178         }
1179
1180         public Boolean validateStringNotEmpty(String value) {
1181                 if ((value == null) || (value.trim().isEmpty())) {
1182                         return false;
1183                 }
1184                 return true;
1185         }
1186
1187         private ComponentTypeEnum getComponentType(Component component) {
1188                 if (component instanceof Service) {
1189                         return ComponentTypeEnum.SERVICE;
1190                 } // else if(component instanceof Resource){
1191                 return null;
1192         }
1193
1194         public Either<Boolean, ResponseFormat> validateStringMatchesPattern(User user, Component component, String value, Pattern pattern, ActionStatus badResult, AuditingActionEnum actionEnum) {
1195                 if (!pattern.matcher(value).matches()) {
1196                         log.error(badResult.name());
1197                         ResponseFormat errorResponse = getResponseFormat(badResult);
1198                         if (actionEnum != null) {
1199                                 log.debug("audit before sending response");
1200                                 auditComponentAdmin(errorResponse, user, component, "", "", actionEnum, getComponentType(component));
1201                         }
1202                         return Either.right(errorResponse);
1203                 }
1204                 return Either.left(true);
1205         }
1206
1207         /**
1208          *
1209          * " Error: Missing Mandatory Informational %s1 %s2 : %s3 " where %s1 - "resource"/"service" %s2 - "artifact"/ "artifacts" %s3 - Comma separated list of missing informational artifact types
1210          *
1211          * @param resource
1212          * @param componentMissingMandatoryArtifacts
1213          * @param value
1214          * @return
1215          */
1216         public ResponseFormat getResponseFormatByMissingArtifacts(ComponentTypeEnum componentType, Map<String, ArtifactDefinition> artifacts) {
1217
1218                 String artifactTitle = "artifact";
1219                 if (artifacts.size() > 1) {
1220                         artifactTitle = "artifacts";
1221                 }
1222                 Collection<ArtifactDefinition> artifactsLabels = artifacts.values();
1223                 StringBuilder artifactsLabelBuilder = new StringBuilder();
1224
1225                 List<ArtifactDefinition> artifactsLabelsList = new ArrayList<ArtifactDefinition>();
1226                 artifactsLabelsList.addAll(artifactsLabels);
1227                 for (int i = 0; i < artifactsLabelsList.size(); i++) {
1228                         ArtifactDefinition artifactDef = artifactsLabelsList.get(i);
1229                         artifactsLabelBuilder.append(artifactDef.getArtifactDisplayName());
1230                         if (i < artifactsLabelsList.size() - 1) {
1231                                 artifactsLabelBuilder.append(";");
1232                         }
1233                 }
1234                 ResponseFormat responseFormat = getResponseFormat(ActionStatus.COMPONENT_MISSING_MANDATORY_ARTIFACTS, componentType.name().toLowerCase(), artifactTitle, artifactsLabelBuilder.toString());
1235
1236                 return responseFormat;
1237         }
1238
1239         public ActionStatus convertFromStorageResponseForAdditionalInformation(StorageOperationStatus storageResponse) {
1240                 ActionStatus responseEnum = ActionStatus.GENERAL_ERROR;
1241
1242                 switch (storageResponse) {
1243                 case OK:
1244                         responseEnum = ActionStatus.OK;
1245                         break;
1246                 case ENTITY_ALREADY_EXISTS:
1247                         responseEnum = ActionStatus.COMPONENT_NAME_ALREADY_EXIST;
1248                         break;
1249                 case INVALID_ID:
1250                         responseEnum = ActionStatus.ADDITIONAL_INFORMATION_NOT_FOUND;
1251                         break;
1252                 default:
1253                         responseEnum = ActionStatus.GENERAL_ERROR;
1254                         break;
1255                 }
1256                 log.debug("convert storage response {} to action response {}", storageResponse.name(), responseEnum.name());
1257                 return responseEnum;
1258         }
1259
1260         public ActionStatus convertFromResultStatusEnum(ResultStatusEnum resultStatus, JsonPresentationFields elementType) {
1261                 ActionStatus responseEnum = ActionStatus.GENERAL_ERROR;
1262                 switch (resultStatus) {
1263                 case OK:
1264                         responseEnum = ActionStatus.OK;
1265                         break;
1266                 case ELEMENT_NOT_FOUND:
1267                         if(elementType!= null && elementType == JsonPresentationFields.PROPERTY){
1268                                 responseEnum = ActionStatus.PROPERTY_NOT_FOUND;
1269                         }
1270                 break;
1271                 case INVALID_PROPERTY_DEFAULT_VALUE:
1272                 case INVALID_PROPERTY_TYPE:
1273                 case INVALID_PROPERTY_VALUE:
1274                 case INVALID_PROPERTY_NAME:
1275                 case MISSING_ENTRY_SCHEMA_TYPE:
1276                         responseEnum = ActionStatus.INVALID_PROPERTY;
1277                         break;
1278                 default:
1279                         responseEnum = ActionStatus.GENERAL_ERROR;
1280                         break;
1281                 }
1282                 return responseEnum;
1283         }
1284
1285         public ResponseFormat getResponseFormatAdditionalProperty(ActionStatus actionStatus, AdditionalInfoParameterInfo additionalInfoParameterInfo, NodeTypeEnum nodeType, AdditionalInformationEnum labelOrValue) {
1286
1287                 if (additionalInfoParameterInfo == null) {
1288                         additionalInfoParameterInfo = new AdditionalInfoParameterInfo();
1289                 }
1290                 if (labelOrValue == null) {
1291                         labelOrValue = AdditionalInformationEnum.None;
1292                 }
1293
1294                 ResponseFormat responseFormat = null;
1295                 switch (actionStatus) {
1296                 case COMPONENT_NAME_ALREADY_EXIST:
1297                         responseFormat = getResponseFormat(actionStatus, "Additional parameter", additionalInfoParameterInfo.getKey());
1298                         break;
1299                 case ADDITIONAL_INFORMATION_EXCEEDS_LIMIT:
1300                         responseFormat = getResponseFormat(actionStatus, labelOrValue.name().toLowerCase(), ValidationUtils.ADDITIONAL_INFORMATION_KEY_MAX_LENGTH.toString());
1301                         break;
1302                 case ADDITIONAL_INFORMATION_MAX_NUMBER_REACHED:
1303                         responseFormat = getResponseFormat(actionStatus, nodeType.name().toLowerCase());
1304                         break;
1305                 case ADDITIONAL_INFORMATION_EMPTY_STRING_NOT_ALLOWED:
1306                         responseFormat = getResponseFormat(actionStatus);
1307                         break;
1308                 case ADDITIONAL_INFORMATION_KEY_NOT_ALLOWED_CHARACTERS:
1309                         responseFormat = getResponseFormat(actionStatus);
1310                         break;
1311                 case ADDITIONAL_INFORMATION_VALUE_NOT_ALLOWED_CHARACTERS:
1312                         responseFormat = getResponseFormat(actionStatus);
1313                         break;
1314                 case ADDITIONAL_INFORMATION_NOT_FOUND:
1315                         responseFormat = getResponseFormat(actionStatus);
1316                         break;
1317                 default:
1318                         responseFormat = getResponseFormat(actionStatus);
1319                         break;
1320                 }
1321
1322                 return responseFormat;
1323         }
1324
1325         public ResponseFormat getResponseFormatAdditionalProperty(ActionStatus actionStatus) {
1326                 return getResponseFormatAdditionalProperty(actionStatus, null, null, null);
1327         }
1328
1329         public ActionStatus convertFromStorageResponseForConsumer(StorageOperationStatus storageResponse) {
1330                 ActionStatus responseEnum = ActionStatus.GENERAL_ERROR;
1331
1332                 switch (storageResponse) {
1333                 case OK:
1334                         responseEnum = ActionStatus.OK;
1335                         break;
1336                 case CONNECTION_FAILURE:
1337                 case GRAPH_IS_LOCK:
1338                         responseEnum = ActionStatus.GENERAL_ERROR;
1339                         break;
1340                 case BAD_REQUEST:
1341                         responseEnum = ActionStatus.INVALID_CONTENT;
1342                         break;
1343                 case ENTITY_ALREADY_EXISTS:
1344                         responseEnum = ActionStatus.CONSUMER_ALREADY_EXISTS;
1345                         break;
1346                 case SCHEMA_VIOLATION:
1347                         responseEnum = ActionStatus.CONSUMER_ALREADY_EXISTS;
1348                         break;
1349                 case NOT_FOUND:
1350                         responseEnum = ActionStatus.ECOMP_USER_NOT_FOUND;
1351                         break;
1352                 default:
1353                         responseEnum = ActionStatus.GENERAL_ERROR;
1354                         break;
1355                 }
1356                 log.debug("convert storage response {} to action response {}", storageResponse.name(), responseEnum.name());
1357                 return responseEnum;
1358         }
1359
1360         public ActionStatus convertFromStorageResponseForGroupType(StorageOperationStatus storageResponse) {
1361                 ActionStatus responseEnum = ActionStatus.GENERAL_ERROR;
1362
1363                 switch (storageResponse) {
1364                 case OK:
1365                         responseEnum = ActionStatus.OK;
1366                         break;
1367                 case CONNECTION_FAILURE:
1368                 case GRAPH_IS_LOCK:
1369                         responseEnum = ActionStatus.GENERAL_ERROR;
1370                         break;
1371                 case BAD_REQUEST:
1372                         responseEnum = ActionStatus.INVALID_CONTENT;
1373                         break;
1374                 case ENTITY_ALREADY_EXISTS:
1375                         responseEnum = ActionStatus.GROUP_TYPE_ALREADY_EXIST;
1376                         break;
1377                 case SCHEMA_VIOLATION:
1378                         responseEnum = ActionStatus.GROUP_TYPE_ALREADY_EXIST;
1379                         break;
1380                 default:
1381                         responseEnum = ActionStatus.GENERAL_ERROR;
1382                         break;
1383                 }
1384                 log.debug("convert storage response {} to action response {}", storageResponse.name(), responseEnum.name());
1385                 return responseEnum;
1386         }
1387
1388         public ActionStatus convertFromStorageResponseForDataType(StorageOperationStatus storageResponse) {
1389                 ActionStatus responseEnum = ActionStatus.GENERAL_ERROR;
1390
1391                 switch (storageResponse) {
1392                 case OK:
1393                         responseEnum = ActionStatus.OK;
1394                         break;
1395                 case CONNECTION_FAILURE:
1396                 case GRAPH_IS_LOCK:
1397                         responseEnum = ActionStatus.GENERAL_ERROR;
1398                         break;
1399                 case BAD_REQUEST:
1400                         responseEnum = ActionStatus.INVALID_CONTENT;
1401                         break;
1402                 case ENTITY_ALREADY_EXISTS:
1403                         responseEnum = ActionStatus.DATA_TYPE_ALREADY_EXIST;
1404                         break;
1405                 case SCHEMA_VIOLATION:
1406                         responseEnum = ActionStatus.DATA_TYPE_ALREADY_EXIST;
1407                         break;
1408                 case CANNOT_UPDATE_EXISTING_ENTITY:
1409                         responseEnum = ActionStatus.DATA_TYPE_CANNOT_BE_UPDATED_BAD_REQUEST;
1410                         break;
1411                 default:
1412                         responseEnum = ActionStatus.GENERAL_ERROR;
1413                         break;
1414                 }
1415                 log.debug("convert storage response {} to action response {}", storageResponse.name(), responseEnum.name());
1416                 return responseEnum;
1417         }
1418
1419         public ResponseFormat getResponseFormatByGroupType(ActionStatus actionStatus, GroupTypeDefinition groupType) {
1420                 if (groupType == null) {
1421                         return getResponseFormat(actionStatus);
1422                 }
1423                 ResponseFormat responseFormat;
1424
1425                 switch (actionStatus) {
1426                 case GROUP_MEMBER_EMPTY:
1427                 case GROUP_TYPE_ALREADY_EXIST:
1428                         responseFormat = getResponseFormat(actionStatus, groupType.getType());
1429                         break;
1430                 default:
1431                         responseFormat = getResponseFormat(actionStatus);
1432                         break;
1433                 }
1434                 return responseFormat;
1435
1436         }
1437
1438         public ResponseFormat getResponseFormatByPolicyType(ActionStatus actionStatus, PolicyTypeDefinition policyType) {
1439                 if (policyType == null) {
1440                         return getResponseFormat(actionStatus);
1441                 }
1442                 ResponseFormat responseFormat;
1443
1444                 switch (actionStatus) {
1445                 case POLICY_TYPE_ALREADY_EXIST:
1446                         responseFormat = getResponseFormat(actionStatus, policyType.getType());
1447                         break;
1448                 default:
1449                         responseFormat = getResponseFormat(actionStatus);
1450                         break;
1451                 }
1452                 return responseFormat;
1453
1454         }
1455
1456         public ResponseFormat getResponseFormatByDataType(ActionStatus actionStatus, DataTypeDefinition dataType, List<String> properties) {
1457                 if (dataType == null) {
1458                         return getResponseFormat(actionStatus);
1459                 }
1460                 ResponseFormat responseFormat;
1461
1462                 switch (actionStatus) {
1463                 case DATA_TYPE_ALREADY_EXIST:
1464                         responseFormat = getResponseFormat(actionStatus, dataType.getName());
1465                         break;
1466                 case DATA_TYPE_NOR_PROPERTIES_NEITHER_DERIVED_FROM:
1467                         responseFormat = getResponseFormat(actionStatus, dataType.getName());
1468                         break;
1469                 case DATA_TYPE_PROPERTIES_CANNOT_BE_EMPTY:
1470                         responseFormat = getResponseFormat(actionStatus, dataType.getName());
1471                         break;
1472                 case DATA_TYPE_PROPERTY_ALREADY_DEFINED_IN_ANCESTOR:
1473                         responseFormat = getResponseFormat(actionStatus, dataType.getName(), properties == null ? "" : String.valueOf(properties));
1474                         break;
1475                 case DATA_TYPE_DERIVED_IS_MISSING:
1476                         responseFormat = getResponseFormat(actionStatus, dataType.getDerivedFromName());
1477                         break;
1478                 case DATA_TYPE_DUPLICATE_PROPERTY:
1479                         responseFormat = getResponseFormat(actionStatus, dataType.getName());
1480                         break;
1481                 case DATA_TYPE_PROEPRTY_CANNOT_HAVE_SAME_TYPE_OF_DATA_TYPE:
1482                         responseFormat = getResponseFormat(actionStatus, dataType.getName(), properties == null ? "" : String.valueOf(properties));
1483                         break;
1484                 case DATA_TYPE_CANNOT_HAVE_PROPERTIES:
1485                         responseFormat = getResponseFormat(actionStatus, dataType.getName());
1486                         break;
1487                 case DATA_TYPE_CANNOT_BE_UPDATED_BAD_REQUEST:
1488                         responseFormat = getResponseFormat(actionStatus, dataType.getName());
1489                         break;
1490
1491                 default:
1492                         responseFormat = getResponseFormat(actionStatus);
1493                         break;
1494                 }
1495                 return responseFormat;
1496         }
1497 }