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