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  * Modifications copyright (c) 2019 Nokia
  20  * ================================================================================
  21  */
  22 package org.openecomp.sdc.be.impl;
  23
  24 import com.fasterxml.jackson.annotation.JsonInclude.Include;
  25 import com.fasterxml.jackson.databind.DeserializationFeature;
  26 import com.fasterxml.jackson.databind.ObjectMapper;
  27 import com.fasterxml.jackson.databind.module.SimpleModule;
  28 import com.google.gson.Gson;
  29 import com.google.gson.GsonBuilder;
  30 import com.google.gson.reflect.TypeToken;
  31 import fj.F;
  32 import fj.data.Either;
  33 import java.lang.reflect.Type;
  34 import java.util.ArrayList;
  35 import java.util.Collections;
  36 import java.util.List;
  37 import java.util.Map;
  38 import java.util.Optional;
  39 import java.util.Set;
  40 import java.util.stream.Collectors;
  41 import javax.servlet.http.HttpServletRequest;
  42 import org.apache.commons.collections.CollectionUtils;
  43 import org.apache.commons.lang3.StringUtils;
  44 import org.onap.logging.ref.slf4j.ONAPLogConstants;
  45 import org.openecomp.sdc.be.auditing.api.AuditEventFactory;
  46 import org.openecomp.sdc.be.auditing.impl.AuditAuthRequestEventFactory;
  47 import org.openecomp.sdc.be.auditing.impl.AuditConsumerEventFactory;
  48 import org.openecomp.sdc.be.auditing.impl.AuditEcompOpEnvEventFactory;
  49 import org.openecomp.sdc.be.auditing.impl.AuditGetUebClusterEventFactory;
  50 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  51 import org.openecomp.sdc.be.auditing.impl.category.AuditCategoryEventFactory;
  52 import org.openecomp.sdc.be.auditing.impl.category.AuditGetCategoryHierarchyEventFactory;
  53 import org.openecomp.sdc.be.auditing.impl.distribution.AuditDistributionDeployEventFactory;
  54 import org.openecomp.sdc.be.auditing.impl.distribution.AuditDistributionDownloadEventFactory;
  55 import org.openecomp.sdc.be.auditing.impl.distribution.AuditDistributionEngineEventFactoryManager;
  56 import org.openecomp.sdc.be.auditing.impl.distribution.AuditDistributionNotificationEventFactory;
  57 import org.openecomp.sdc.be.auditing.impl.distribution.AuditDistributionStatusEventFactory;
  58 import org.openecomp.sdc.be.auditing.impl.distribution.AuditRegUnregDistributionEngineEventFactory;
  59 import org.openecomp.sdc.be.auditing.impl.externalapi.AuditActivateServiceExternalApiEventFactory;
  60 import org.openecomp.sdc.be.auditing.impl.externalapi.AuditAssetExternalApiEventFactory;
  61 import org.openecomp.sdc.be.auditing.impl.externalapi.AuditAssetListExternalApiEventFactory;
  62 import org.openecomp.sdc.be.auditing.impl.externalapi.AuditChangeLifecycleExternalApiEventFactory;
  63 import org.openecomp.sdc.be.auditing.impl.externalapi.AuditCreateResourceExternalApiEventFactory;
  64 import org.openecomp.sdc.be.auditing.impl.externalapi.AuditCreateServiceExternalApiEventFactory;
  65 import org.openecomp.sdc.be.auditing.impl.externalapi.AuditCrudExternalApiArtifactEventFactory;
  66 import org.openecomp.sdc.be.auditing.impl.externalapi.AuditDownloadArtifactExternalApiEventFactory;
  67 import org.openecomp.sdc.be.auditing.impl.resourceadmin.AuditResourceEventFactoryManager;
  68 import org.openecomp.sdc.be.auditing.impl.usersadmin.AuditGetUsersListEventFactory;
  69 import org.openecomp.sdc.be.auditing.impl.usersadmin.AuditUserAccessEventFactory;
  70 import org.openecomp.sdc.be.auditing.impl.usersadmin.AuditUserAdminEventFactory;
  71 import org.openecomp.sdc.be.components.distribution.engine.DmaapConsumer;
  72 import org.openecomp.sdc.be.components.impl.ImportUtils;
  73 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
  74 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
  75 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
  76 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
  77 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  78 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  79 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
  80 import org.openecomp.sdc.be.dao.api.ActionStatus;
  81 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
  82 import org.openecomp.sdc.be.dao.graph.datatype.AdditionalInformationEnum;
  83 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  84 import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterInfo;
  85 import org.openecomp.sdc.be.datatypes.elements.ToscaFunction;
  86 import org.openecomp.sdc.be.datatypes.elements.ToscaFunctionJsonDeserializer;
  87 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  88 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  89 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  90 import org.openecomp.sdc.be.model.ArtifactDefinition;
  91 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
  92 import org.openecomp.sdc.be.model.Component;
  93 import org.openecomp.sdc.be.model.ComponentInstance;
  94 import org.openecomp.sdc.be.model.ConsumerDefinition;
  95 import org.openecomp.sdc.be.model.DataTypeDefinition;
  96 import org.openecomp.sdc.be.model.GroupTypeDefinition;
  97 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  98 import org.openecomp.sdc.be.model.PolicyTypeDefinition;
  99 import org.openecomp.sdc.be.model.PropertyConstraint;
 100 import org.openecomp.sdc.be.model.RequirementDefinition;
 101 import org.openecomp.sdc.be.model.Resource;
 102 import org.openecomp.sdc.be.model.User;
 103 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
 104 import org.openecomp.sdc.be.model.operations.StorageException;
 105 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 106 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation.PropertyConstraintDeserialiser;
 107 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation.PropertyConstraintJacksonDeserializer;
 108 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
 109 import org.openecomp.sdc.be.resources.data.auditing.AuditingTypesConstants;
 110 import org.openecomp.sdc.be.resources.data.auditing.model.CommonAuditData;
 111 import org.openecomp.sdc.be.resources.data.auditing.model.DistributionData;
 112 import org.openecomp.sdc.be.resources.data.auditing.model.DistributionTopicData;
 113 import org.openecomp.sdc.be.resources.data.auditing.model.OperationalEnvAuditData;
 114 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceCommonInfo;
 115 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
 116 import org.openecomp.sdc.be.tosca.ToscaError;
 117 import org.openecomp.sdc.be.ui.model.UIConstraint;
 118 import org.openecomp.sdc.be.ui.model.UiLeftPaletteComponent;
 119 import org.openecomp.sdc.common.api.Constants;
 120 import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
 121 import org.openecomp.sdc.common.log.enums.LogLevel;
 122 import org.openecomp.sdc.common.log.enums.Severity;
 123 import org.openecomp.sdc.common.log.wrappers.Logger;
 124 import org.openecomp.sdc.common.log.wrappers.LoggerSdcAudit;
 125 import org.openecomp.sdc.common.util.ThreadLocalsHolder;
 126 import org.openecomp.sdc.common.util.ValidationUtils;
 127 import org.openecomp.sdc.exception.ResponseFormat;
 128 import org.slf4j.MarkerFactory;
 129 import org.springframework.beans.factory.annotation.Autowired;
 130
 131 @org.springframework.stereotype.Component("componentUtils")
 132 public class ComponentsUtils {
 133
 134     private static final String CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE = "convert storage response {} to action response {}";
 135     private static final String INSIDE_AUDITING_FOR_AUDIT_ACTION = "Inside auditing for audit action {}";
 136     private static final String AUDIT_BEFORE_SENDING_RESPONSE = "audit before sending response";
 137     private static final String CONVERT_JSON_TO_OBJECT = "convertJsonToObject";
 138     private static final Logger log = Logger.getLogger(ComponentsUtils.class);
 139     private static final String PARTNER_NAME = "UNKNOWN";
 140     private static final LoggerSdcAudit audit = new LoggerSdcAudit(DmaapConsumer.class);
 141     private final AuditingManager auditingManager;
 142     private final ResponseFormatManager responseFormatManager;
 143
 144     @Autowired
 145     public ComponentsUtils(AuditingManager auditingManager) {
 146         this.auditingManager = auditingManager;
 147         this.responseFormatManager = ResponseFormatManager.getInstance();
 148     }
 149
 150     public static <T> T parseJsonToObject(String data, Class<T> clazz) {
 151         Type constraintType = new TypeToken<PropertyConstraint>() {
 152         }.getType();
 153         Gson gson = new GsonBuilder().registerTypeAdapter(constraintType, new PropertyConstraintDeserialiser()).create();
 154         log.trace("convert json to object. json=\n{}", data);
 155         return gson.fromJson(data, clazz);
 156     }
 157
 158     private static Set<String> getNodesFiltersToBeDeleted(final Component component, final String componentInstanceName) {
 159         return component.getComponentInstances().stream().filter(ci -> isNodeFilterUsingChangedCi(ci, componentInstanceName))
 160             .map(ComponentInstance::getName).collect(Collectors.toSet());
 161     }
 162
 163     public static Set<String> getNodesFiltersToBeDeleted(final Component component, final ComponentInstance componentInstance) {
 164         return getNodesFiltersToBeDeleted(component, componentInstance.getName());
 165     }
 166
 167     private static boolean isNodeFilterUsingChangedCi(final ComponentInstance componentInstance, final String componentInstanceName) {
 168         if (CollectionUtils.isEmpty(componentInstance.getDirectives())) {
 169             return false;
 170         }
 171         if (componentInstance.getNodeFilter() == null || componentInstance.getNodeFilter().getProperties() == null
 172             || componentInstance.getNodeFilter().getProperties().getListToscaDataDefinition() == null) {
 173             return false;
 174         }
 175         return componentInstance.getNodeFilter().getProperties().getListToscaDataDefinition().stream()
 176             .anyMatch(property -> ServiceFilterUtils.isPropertyConstraintChangedByCi(property, componentInstanceName));
 177     }
 178
 179     public AuditingManager getAuditingManager() {
 180         return auditingManager;
 181     }
 182
 183     public <T> Either<T, ResponseFormat> convertJsonToObject(String data, User user, Class<T> clazz, AuditingActionEnum actionEnum) {
 184         if (data == null) {
 185             BeEcompErrorManager.getInstance().logBeInvalidJsonInput(CONVERT_JSON_TO_OBJECT);
 186             log.debug("object is null after converting from json");
 187             ResponseFormat responseFormat = getInvalidContentErrorAndAudit(user, actionEnum);
 188             return Either.right(responseFormat);
 189         }
 190         try {
 191             T obj = parseJsonToObject(data, clazz);
 192             return Either.left(obj);
 193         } catch (Exception e) {
 194             // INVALID JSON
 195             BeEcompErrorManager.getInstance().logBeInvalidJsonInput(CONVERT_JSON_TO_OBJECT);
 196             log.debug("failed to convert from json {}", data, e);
 197             ResponseFormat responseFormat = getInvalidContentErrorAndAudit(user, actionEnum);
 198             return Either.right(responseFormat);
 199         }
 200     }
 201
 202     public <T> Either<T, ResponseFormat> convertJsonToObjectUsingObjectMapper(String data, User user, Class<T> clazz, AuditingActionEnum actionEnum,
 203                                                                               ComponentTypeEnum typeEnum) {
 204         T component;
 205         ObjectMapper mapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 206         mapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
 207         mapper.configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL, true);
 208         try {
 209             log.trace("convert json to object. json=\n{}", data);
 210             SimpleModule module = new SimpleModule("customDeserializationModule");
 211             module.addDeserializer(PropertyConstraint.class, new PropertyConstraintJacksonDeserializer());
 212             module.addDeserializer(ToscaFunction.class, new ToscaFunctionJsonDeserializer());
 213             mapper.registerModule(module);
 214             mapper.setSerializationInclusion(Include.NON_NULL);
 215             component = mapper.readValue(data, clazz);
 216             if (component == null) {
 217                 BeEcompErrorManager.getInstance().logBeInvalidJsonInput(CONVERT_JSON_TO_OBJECT);
 218                 log.debug("object is null after converting from json");
 219                 ResponseFormat responseFormat = getInvalidContentErrorAndAuditComponent(user, actionEnum, typeEnum);
 220                 return Either.right(responseFormat);
 221             }
 222         } catch (Exception e) {
 223             BeEcompErrorManager.getInstance().logBeInvalidJsonInput(CONVERT_JSON_TO_OBJECT);
 224             log.debug("failed to convert from json {}", data, e);
 225             ResponseFormat responseFormat = getInvalidContentErrorAndAuditComponent(user, actionEnum, typeEnum);
 226             return Either.right(responseFormat);
 227         }
 228         return Either.left(component);
 229     }
 230
 231     public ResponseFormat getResponseFormat(ActionStatus actionStatus, String... params) {
 232         return responseFormatManager.getResponseFormat(actionStatus, params);
 233     }
 234
 235     public ResponseFormat getResponseFormat(StorageOperationStatus storageStatus, String... params) {
 236         return responseFormatManager.getResponseFormat(this.convertFromStorageResponse(storageStatus), params);
 237     }
 238
 239     public <T> Either<List<T>, ResponseFormat> convertToResponseFormatOrNotFoundErrorToEmptyList(StorageOperationStatus storageOperationStatus) {
 240         return storageOperationStatus.equals(StorageOperationStatus.NOT_FOUND) ? Either.left(Collections.emptyList())
 241             : Either.right(getResponseFormat(storageOperationStatus));
 242     }
 243
 244     /**
 245      * Returns the response format of resource error with respective variables according to actionStatus. This is needed for cases where actionStatus
 246      * is anonymously converted from storage operation, and the caller doesn't know what actionStatus he received. It's caller's Responsibility to
 247      * fill the resource object passed to this function with needed fields.
 248      * <p>
 249      * Note that RESOURCE_IN_USE case passes hardcoded "resource" string to the error parameter. This means that if Resource object will also be used
 250      * for Service, this code needs to be refactored and we should tell Resource from Service.
 251      *
 252      * @param actionStatus
 253      * @param resource
 254      * @return
 255      */
 256     public ResponseFormat getResponseFormatByResource(ActionStatus actionStatus, Component resource) {
 257         if (resource == null) {
 258             return getResponseFormat(actionStatus);
 259         }
 260         ResponseFormat responseFormat;
 261         switch (actionStatus) {
 262             case COMPONENT_VERSION_ALREADY_EXIST:
 263                 responseFormat = getResponseFormat(ActionStatus.COMPONENT_VERSION_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(),
 264                     resource.getVersion());
 265                 break;
 266             case RESOURCE_NOT_FOUND:
 267                 responseFormat = getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, resource.getName());
 268                 break;
 269             case COMPONENT_NAME_ALREADY_EXIST:
 270                 responseFormat = getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(),
 271                     resource.getName());
 272                 break;
 273             case COMPONENT_IN_USE:
 274                 responseFormat = getResponseFormat(ActionStatus.COMPONENT_IN_USE, ComponentTypeEnum.RESOURCE.name().toLowerCase(),
 275                     resource.getUniqueId());
 276                 break;
 277             default:
 278                 responseFormat = getResponseFormat(actionStatus);
 279                 break;
 280         }
 281         return responseFormat;
 282     }
 283
 284     public ResponseFormat getResponseFormatByResource(ActionStatus actionStatus, String resourceName) {
 285         if (resourceName == null) {
 286             return getResponseFormat(actionStatus);
 287         }
 288         ResponseFormat responseFormat;
 289         if (actionStatus == ActionStatus.RESOURCE_NOT_FOUND) {
 290             responseFormat = getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, resourceName);
 291         } else {
 292             responseFormat = getResponseFormat(actionStatus);
 293         }
 294         return responseFormat;
 295     }
 296
 297     public ResponseFormat getResponseFormatByCapabilityType(ActionStatus actionStatus, CapabilityTypeDefinition capabilityType) {
 298         if (capabilityType == null) {
 299             return getResponseFormat(actionStatus);
 300         }
 301         ResponseFormat responseFormat;
 302         if (actionStatus == ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST) {
 303             responseFormat = getResponseFormat(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, capabilityType.getType());
 304         } else {
 305             responseFormat = getResponseFormat(actionStatus);
 306         }
 307         return responseFormat;
 308     }
 309
 310     public <T> ResponseFormat getResponseFormatByElement(ActionStatus actionStatus, T obj) {
 311         if (obj == null) {
 312             return getResponseFormat(actionStatus);
 313         }
 314         ResponseFormat responseFormat = null;
 315         if (actionStatus == ActionStatus.MISSING_CAPABILITY_TYPE) {
 316             if (obj instanceof List && org.apache.commons.collections.CollectionUtils.isNotEmpty((List) obj)) {
 317                 List list = (List) obj;
 318                 if (list.get(0) instanceof RequirementDefinition) {
 319                     responseFormat = getResponseFormat(ActionStatus.MISSING_CAPABILITY_TYPE, ((RequirementDefinition) list
 320                         .get(0)).getName());    //Arbitray index, all we need is single object
 321                     return responseFormat;
 322                 }
 323             }
 324             log.debug("UNKNOWN TYPE : expecting obj as a non empty List<RequirmentsDefinitions>");
 325         } else {
 326             responseFormat = getResponseFormat(actionStatus);
 327         }
 328         return responseFormat;
 329     }
 330
 331     /**
 332      * Returns the response format of resource error with respective variables according to actionStatus. This is needed for cases where actionStatus
 333      * is anynomously converted from storage operation, and the caller doesn't know what actionStatus he received. It's caller's responisibility to
 334      * fill the passed resource object with needed fields.
 335      *
 336      * @param actionStatus
 337      * @param user
 338      * @return
 339      */
 340     ResponseFormat getResponseFormatByUser(ActionStatus actionStatus, User user) {
 341         if (user == null) {
 342             return getResponseFormat(actionStatus);
 343         }
 344         ResponseFormat requestErrorWrapper;
 345         switch (actionStatus) {
 346             case INVALID_USER_ID:
 347                 requestErrorWrapper = getResponseFormat(actionStatus, user.getUserId());
 348                 break;
 349             case INVALID_EMAIL_ADDRESS:
 350                 requestErrorWrapper = getResponseFormat(actionStatus, user.getEmail());
 351                 break;
 352             case INVALID_ROLE:
 353                 requestErrorWrapper = getResponseFormat(actionStatus, user.getRole());
 354                 break;
 355             case USER_NOT_FOUND:
 356             case USER_ALREADY_EXIST:
 357             case USER_INACTIVE:
 358             case USER_HAS_ACTIVE_ELEMENTS:
 359                 requestErrorWrapper = getResponseFormat(actionStatus, user.getUserId());
 360                 break;
 361             default:
 362                 requestErrorWrapper = getResponseFormat(actionStatus);
 363                 break;
 364         }
 365         return requestErrorWrapper;
 366     }
 367
 368     public ResponseFormat getResponseFormatByUserId(ActionStatus actionStatus, String userId) {
 369         User user = new User();
 370         user.setUserId(userId);
 371         return getResponseFormatByUser(actionStatus, user);
 372     }
 373
 374     public ResponseFormat getResponseFormatByDE(ActionStatus actionStatus, String envName) {
 375         ResponseFormat responseFormat;
 376         switch (actionStatus) {
 377             case DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE:
 378                 responseFormat = getResponseFormat(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE, envName);
 379                 break;
 380             case DISTRIBUTION_ENVIRONMENT_NOT_FOUND:
 381                 responseFormat = getResponseFormat(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_FOUND, envName);
 382                 break;
 383             default:
 384                 responseFormat = getResponseFormat(actionStatus);
 385                 break;
 386         }
 387         return responseFormat;
 388     }
 389
 390     public ResponseFormat getResponseFormatByArtifactId(ActionStatus actionStatus, String... params) {
 391         ResponseFormat responseFormat;
 392         switch (actionStatus) {
 393             case RESOURCE_NOT_FOUND:
 394             case ARTIFACT_NOT_FOUND:
 395                 responseFormat = getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, params);
 396                 break;
 397             case ARTIFACT_NAME_INVALID:
 398                 responseFormat = getResponseFormat(ActionStatus.ARTIFACT_NAME_INVALID, params);
 399                 break;
 400             default:
 401                 responseFormat = getResponseFormat(actionStatus);
 402                 break;
 403         }
 404         return responseFormat;
 405     }
 406
 407     public ResponseFormat getInvalidContentErrorAndAudit(User user, AuditingActionEnum actionEnum) {
 408         ResponseFormat responseFormat = responseFormatManager.getResponseFormat(ActionStatus.INVALID_CONTENT);
 409         log.debug(AUDIT_BEFORE_SENDING_RESPONSE);
 410         auditAdminUserAction(actionEnum, user, null, null, responseFormat);
 411         return responseFormat;
 412     }
 413
 414     public ResponseFormat getInvalidContentErrorAndAudit(User user, String resourceName, AuditingActionEnum actionEnum) {
 415         ResponseFormat responseFormat = responseFormatManager.getResponseFormat(ActionStatus.INVALID_CONTENT);
 416         log.debug(AUDIT_BEFORE_SENDING_RESPONSE);
 417         auditResource(responseFormat, user, resourceName, actionEnum);
 418         return responseFormat;
 419     }
 420
 421     public ResponseFormat getInvalidContentErrorForConsumerAndAudit(User user, ConsumerDefinition consumer, AuditingActionEnum actionEnum) {
 422         ResponseFormat responseFormat = responseFormatManager.getResponseFormat(ActionStatus.INVALID_CONTENT);
 423         log.debug(AUDIT_BEFORE_SENDING_RESPONSE);
 424         auditConsumerCredentialsEvent(actionEnum, consumer, responseFormat, user);
 425         return responseFormat;
 426     }
 427
 428     private ResponseFormat getInvalidContentErrorAndAuditComponent(User user, AuditingActionEnum actionEnum, ComponentTypeEnum typeEnum) {
 429         ResponseFormat responseFormat = responseFormatManager.getResponseFormat(ActionStatus.INVALID_CONTENT);
 430         log.debug(AUDIT_BEFORE_SENDING_RESPONSE);
 431         auditComponentAdmin(responseFormat, user, null, actionEnum, typeEnum);
 432         return responseFormat;
 433     }
 434
 435     public void auditResource(ResponseFormat responseFormat, User modifier, Resource resource, AuditingActionEnum actionEnum,
 436                               ResourceVersionInfo prevResFields) {
 437         auditResource(responseFormat, modifier, resource, resource.getName(), actionEnum, prevResFields, null, null);
 438     }
 439
 440     public void auditResource(ResponseFormat responseFormat, User modifier, String resourceName, AuditingActionEnum actionEnum) {
 441         auditResource(responseFormat, modifier, null, resourceName, actionEnum);
 442     }
 443
 444     public void auditResource(ResponseFormat responseFormat, User modifier, Resource resource, AuditingActionEnum actionEnum) {
 445         auditResource(responseFormat, modifier, resource, resource.getName(), actionEnum);
 446     }
 447
 448     public void auditResource(ResponseFormat responseFormat, User modifier, Resource resource, String resourceName, AuditingActionEnum actionEnum) {
 449         auditResource(responseFormat, modifier, resource, resourceName, actionEnum, ResourceVersionInfo.newBuilder().build(), null, null);
 450     }
 451
 452     public void auditResource(ResponseFormat responseFormat, User modifier, Resource resource, String resourceName, AuditingActionEnum actionEnum,
 453                               ResourceVersionInfo prevResFields, String currentArtifactUuid, ArtifactDefinition artifactDefinition) {
 454         if (actionEnum != null) {
 455             int status = responseFormat.getStatus();
 456             String uuid = null;
 457             String resourceCurrVersion = null;
 458             String resourceCurrState = null;
 459             String invariantUUID = null;
 460             String resourceType = ComponentTypeEnum.RESOURCE.getValue();
 461             String toscaNodeType = null;
 462             log.trace(INSIDE_AUDITING_FOR_AUDIT_ACTION, actionEnum);
 463             String message = getMessageString(responseFormat);
 464             String artifactData = buildAuditingArtifactData(artifactDefinition);
 465             if (resource != null) {
 466                 resourceName = resource.getName();
 467                 resourceCurrVersion = resource.getVersion();
 468                 if (resource.getLifecycleState() != null) {
 469                     resourceCurrState = resource.getLifecycleState().name();
 470                 }
 471                 if (resource.getResourceType() != null) {
 472                     resourceType = resource.getResourceType().name();
 473                 }
 474                 invariantUUID = resource.getInvariantUUID();
 475                 uuid = resource.getUUID();
 476                 toscaNodeType = resource.getToscaResourceName();
 477             }
 478             AuditEventFactory factory = AuditResourceEventFactoryManager.createResourceEventFactory(actionEnum,
 479                 CommonAuditData.newBuilder().status(status).description(message).requestId(ThreadLocalsHolder.getUuid()).serviceInstanceId(uuid)
 480                     .build(), new ResourceCommonInfo(resourceName, resourceType), prevResFields,
 481                 ResourceVersionInfo.newBuilder().artifactUuid(currentArtifactUuid).state(resourceCurrState).version(resourceCurrVersion).build(),
 482                 invariantUUID, modifier, artifactData, null, null, toscaNodeType);
 483             getAuditingManager().auditEvent(factory);
 484         }
 485     }
 486
 487     private String getMessageString(ResponseFormat responseFormat) {
 488         String message = "";
 489         if (responseFormat.getMessageId() != null) {
 490             message = responseFormat.getMessageId() + ": ";
 491         }
 492         message += responseFormat.getFormattedMessage();
 493         return message;
 494     }
 495
 496     public void auditDistributionDownload(ResponseFormat responseFormat, DistributionData distributionData) {
 497         log.trace("Inside auditing");
 498         int status = responseFormat.getStatus();
 499         String message = getMessageString(responseFormat);
 500         AuditDistributionDownloadEventFactory factory = new AuditDistributionDownloadEventFactory(
 501             CommonAuditData.newBuilder().status(status).description(message).requestId(ThreadLocalsHolder.getUuid()).build(), distributionData);
 502         getAuditingManager().auditEvent(factory);
 503     }
 504
 505     public void auditExternalGetAsset(ResponseFormat responseFormat, AuditingActionEnum actionEnum, DistributionData distributionData,
 506                                       ResourceCommonInfo resourceCommonInfo, String requestId, String serviceInstanceId) {
 507         log.trace(INSIDE_AUDITING_FOR_AUDIT_ACTION, actionEnum);
 508         AuditEventFactory factory = new AuditAssetExternalApiEventFactory(actionEnum,
 509             CommonAuditData.newBuilder().status(responseFormat.getStatus()).description(getMessageString(responseFormat)).requestId(requestId)
 510                 .serviceInstanceId(serviceInstanceId).build(), resourceCommonInfo, distributionData);
 511         getAuditingManager().auditEvent(factory);
 512     }
 513
 514     public void auditExternalGetAssetList(ResponseFormat responseFormat, AuditingActionEnum actionEnum, DistributionData distributionData,
 515                                           String requestId) {
 516         log.trace(INSIDE_AUDITING_FOR_AUDIT_ACTION, actionEnum);
 517         AuditEventFactory factory = new AuditAssetListExternalApiEventFactory(actionEnum,
 518             CommonAuditData.newBuilder().status(responseFormat.getStatus()).description(getMessageString(responseFormat)).requestId(requestId)
 519                 .build(), distributionData);
 520         getAuditingManager().auditEvent(factory);
 521     }
 522
 523     public void auditChangeLifecycleAction(ResponseFormat responseFormat, ComponentTypeEnum componentType, String requestId, Component component,
 524                                            Component responseObject, DistributionData distributionData, User modifier) {
 525         String invariantUuid = "";
 526         String serviceInstanceId = "";
 527         ResourceVersionInfo currResourceVersionInfo = null;
 528         ResourceVersionInfo prevResourceVersionInfo = null;
 529         ResourceCommonInfo resourceCommonInfo = new ResourceCommonInfo(componentType.getValue());
 530         if (component != null) {
 531             prevResourceVersionInfo = buildResourceVersionInfoFromComponent(component);
 532             resourceCommonInfo.setResourceName(component.getName());
 533         }
 534         if (responseObject != null) {
 535             currResourceVersionInfo = buildResourceVersionInfoFromComponent(responseObject);
 536             invariantUuid = responseObject.getInvariantUUID();
 537             serviceInstanceId = responseObject.getUUID();
 538         } else if (component != null) {
 539             currResourceVersionInfo = buildResourceVersionInfoFromComponent(component);
 540             invariantUuid = component.getInvariantUUID();
 541             serviceInstanceId = component.getUUID();
 542         }
 543         if (prevResourceVersionInfo == null) {
 544             prevResourceVersionInfo = ResourceVersionInfo.newBuilder().build();
 545         }
 546         if (currResourceVersionInfo == null) {
 547             currResourceVersionInfo = ResourceVersionInfo.newBuilder().build();
 548         }
 549         AuditEventFactory factory = new AuditChangeLifecycleExternalApiEventFactory(
 550             CommonAuditData.newBuilder().serviceInstanceId(serviceInstanceId).requestId(requestId).description(getMessageString(responseFormat))
 551                 .status(responseFormat.getStatus()).build(), resourceCommonInfo, distributionData, prevResourceVersionInfo, currResourceVersionInfo,
 552             invariantUuid, modifier);
 553         getAuditingManager().auditEvent(factory);
 554     }
 555
 556     private ResourceVersionInfo buildResourceVersionInfoFromComponent(Component component) {
 557         return ResourceVersionInfo.newBuilder().version(component.getVersion()).state(component.getLifecycleState().name()).build();
 558     }
 559
 560     public void auditExternalCrudApi(ResponseFormat responseFormat, AuditingActionEnum actionEnum, ResourceCommonInfo resourceCommonInfo,
 561                                      HttpServletRequest request, ArtifactDefinition artifactDefinition, String artifactUuid) {
 562         log.trace(INSIDE_AUDITING_FOR_AUDIT_ACTION, actionEnum);
 563         ResourceVersionInfo currResourceVersionInfo;
 564         User modifier = new User();
 565         modifier.setUserId(request.getHeader(Constants.USER_ID_HEADER));
 566         String artifactData = "";
 567         DistributionData distributionData = new DistributionData(request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER), request.getRequestURI());
 568         String requestId = request.getHeader(Constants.X_ECOMP_REQUEST_ID_HEADER);
 569         if (artifactDefinition == null) {
 570             currResourceVersionInfo = ResourceVersionInfo.newBuilder().artifactUuid(artifactUuid).build();
 571         } else {
 572             currResourceVersionInfo = ResourceVersionInfo.newBuilder().artifactUuid(artifactDefinition.getArtifactUUID())
 573                 .version(artifactDefinition.getArtifactVersion()).build();
 574             artifactData = buildAuditingArtifactData(artifactDefinition);
 575             modifier.setUserId(artifactDefinition.getUserIdLastUpdater());
 576         }
 577         AuditEventFactory factory = new AuditCrudExternalApiArtifactEventFactory(actionEnum,
 578             CommonAuditData.newBuilder().status(responseFormat.getStatus()).description(getMessageString(responseFormat)).requestId(requestId)
 579                 .build(), resourceCommonInfo, distributionData, ResourceVersionInfo.newBuilder().build(), currResourceVersionInfo, null, modifier,
 580             artifactData);
 581         getAuditingManager().auditEvent(factory);
 582     }
 583
 584     public boolean isExternalApiEvent(AuditingActionEnum auditingActionEnum) {
 585         return auditingActionEnum != null && auditingActionEnum.getAuditingEsType().equals(AuditingTypesConstants.EXTERNAL_API_EVENT_TYPE);
 586     }
 587
 588     public void auditCreateResourceExternalApi(ResponseFormat responseFormat, ResourceCommonInfo resourceCommonInfo, HttpServletRequest request,
 589                                                Resource resource) {
 590         String invariantUuid = null;
 591         String serviceInstanceId = null;
 592         User modifier = new User();
 593         modifier.setUserId(request.getHeader(Constants.USER_ID_HEADER));
 594         DistributionData distributionData = new DistributionData(request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER), request.getRequestURI());
 595         String requestId = request.getHeader(Constants.X_ECOMP_REQUEST_ID_HEADER);
 596         ResourceVersionInfo currResourceVersionInfo;
 597         if (resource != null) {
 598             currResourceVersionInfo = ResourceVersionInfo.newBuilder().state(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())
 599                 .version(ImportUtils.Constants.FIRST_NON_CERTIFIED_VERSION).build();
 600             resourceCommonInfo.setResourceName(resource.getName());
 601             invariantUuid = resource.getInvariantUUID();
 602             serviceInstanceId = resource.getUUID();
 603         } else {
 604             currResourceVersionInfo = ResourceVersionInfo.newBuilder().build();
 605         }
 606         AuditEventFactory factory = new AuditCreateResourceExternalApiEventFactory(
 607             CommonAuditData.newBuilder().status(responseFormat.getStatus()).description(getMessageString(responseFormat)).requestId(requestId)
 608                 .serviceInstanceId(serviceInstanceId).build(), resourceCommonInfo, distributionData, currResourceVersionInfo, invariantUuid,
 609             modifier);
 610         getAuditingManager().auditEvent(factory);
 611     }
 612
 613     public void auditCreateServiceExternalApi(ResponseFormat responseFormat, HttpServletRequest request, Component service) {
 614         String invariantUuid = null;
 615         String serviceInstanceId = null;
 616         User modifier = new User();
 617         modifier.setUserId(request.getHeader(Constants.USER_ID_HEADER));
 618         DistributionData distributionData = new DistributionData(request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER), request.getRequestURI());
 619         String requestId = request.getHeader(Constants.X_ECOMP_REQUEST_ID_HEADER);
 620         if (null != service) {
 621             invariantUuid = service.getInvariantUUID();
 622             serviceInstanceId = service.getUUID();
 623         }
 624         AuditEventFactory factory = new AuditCreateServiceExternalApiEventFactory(
 625             CommonAuditData.newBuilder().status(responseFormat.getStatus()).description(getMessageString(responseFormat)).requestId(requestId)
 626                 .serviceInstanceId(serviceInstanceId).build(), new ResourceCommonInfo(ComponentTypeEnum.SERVICE.name()), distributionData,
 627             invariantUuid, modifier);
 628         getAuditingManager().auditEvent(factory);
 629     }
 630
 631     public void auditExternalActivateService(ResponseFormat responseFormat, DistributionData distributionData, String requestId,
 632                                              String serviceInstanceUuid, User modifier) {
 633         AuditEventFactory factory = new AuditActivateServiceExternalApiEventFactory(
 634             CommonAuditData.newBuilder().serviceInstanceId(serviceInstanceUuid).description(getMessageString(responseFormat))
 635                 .status(responseFormat.getStatus()).requestId(requestId).build(), new ResourceCommonInfo(ComponentTypeEnum.SERVICE.name()),
 636             distributionData, "", modifier);
 637         getAuditingManager().auditEvent(factory);
 638     }
 639
 640     public void auditExternalDownloadArtifact(ResponseFormat responseFormat, ResourceCommonInfo resourceCommonInfo, DistributionData distributionData,
 641                                               String requestId, String currArtifactUuid, String userId) {
 642         User modifier = new User();
 643         modifier.setUserId(userId);
 644         AuditEventFactory factory = new AuditDownloadArtifactExternalApiEventFactory(
 645             CommonAuditData.newBuilder().description(getMessageString(responseFormat)).status(responseFormat.getStatus()).requestId(requestId)
 646                 .build(), resourceCommonInfo, distributionData, ResourceVersionInfo.newBuilder().artifactUuid(currArtifactUuid).build(), modifier);
 647         getAuditingManager().auditEvent(factory);
 648     }
 649
 650     private String buildAuditingArtifactData(ArtifactDefinition artifactDefinition) {
 651         StringBuilder sb = new StringBuilder();
 652         if (artifactDefinition != null) {
 653             sb.append(artifactDefinition.getArtifactGroupType().getType()).append(",").append("'").append(artifactDefinition.getArtifactLabel())
 654                 .append("'").append(",").append(artifactDefinition.getArtifactType()).append(",").append(artifactDefinition.getArtifactName())
 655                 .append(",").append(artifactDefinition.getTimeout()).append(",").append(artifactDefinition.getEsId());
 656             sb.append(",");
 657             sb.append(artifactDefinition.getArtifactVersion() != null ? artifactDefinition.getArtifactVersion() : " ");
 658             sb.append(",");
 659             sb.append(artifactDefinition.getArtifactUUID() != null ? artifactDefinition.getArtifactUUID() : " ");
 660         }
 661         return sb.toString();
 662     }
 663
 664     public void auditCategory(ResponseFormat responseFormat, User modifier, String categoryName, String subCategoryName, String groupingName,
 665                               AuditingActionEnum actionEnum, String componentType) {
 666         log.trace(INSIDE_AUDITING_FOR_AUDIT_ACTION, actionEnum);
 667         AuditEventFactory factory = new AuditCategoryEventFactory(actionEnum,
 668             CommonAuditData.newBuilder().description(getMessageString(responseFormat)).status(responseFormat.getStatus())
 669                 .requestId(ThreadLocalsHolder.getUuid()).build(), modifier, categoryName, subCategoryName, groupingName, componentType);
 670         getAuditingManager().auditEvent(factory);
 671     }
 672
 673     public ActionStatus convertFromStorageResponse(StorageOperationStatus storageResponse) {
 674         return convertFromStorageResponse(storageResponse, ComponentTypeEnum.RESOURCE);
 675     }
 676
 677     public ActionStatus convertFromStorageResponse(StorageOperationStatus storageResponse, ComponentTypeEnum type) {
 678         ActionStatus responseEnum = ActionStatus.GENERAL_ERROR;
 679         if (storageResponse == null) {
 680             return responseEnum;
 681         }
 682         switch (storageResponse) {
 683             case OK:
 684                 responseEnum = ActionStatus.OK;
 685                 break;
 686             case CONNECTION_FAILURE:
 687             case GRAPH_IS_LOCK:
 688                 responseEnum = ActionStatus.GENERAL_ERROR;
 689                 break;
 690             case BAD_REQUEST:
 691                 responseEnum = ActionStatus.INVALID_CONTENT;
 692                 break;
 693             case ENTITY_ALREADY_EXISTS:
 694                 responseEnum = ActionStatus.COMPONENT_NAME_ALREADY_EXIST;
 695                 break;
 696             case PARENT_RESOURCE_NOT_FOUND:
 697                 responseEnum = ActionStatus.PARENT_RESOURCE_NOT_FOUND;
 698                 break;
 699             case MULTIPLE_PARENT_RESOURCE_FOUND:
 700                 responseEnum = ActionStatus.MULTIPLE_PARENT_RESOURCE_FOUND;
 701                 break;
 702             case NOT_FOUND:
 703                 if (ComponentTypeEnum.RESOURCE == type) {
 704                     responseEnum = ActionStatus.RESOURCE_NOT_FOUND;
 705                 } else if (ComponentTypeEnum.PRODUCT == type) {
 706                     responseEnum = ActionStatus.PRODUCT_NOT_FOUND;
 707                 } else {
 708                     responseEnum = ActionStatus.SERVICE_NOT_FOUND;
 709                 }
 710                 break;
 711             case FAILED_TO_LOCK_ELEMENT:
 712                 responseEnum = ActionStatus.COMPONENT_IN_USE;
 713                 break;
 714             case ARTIFACT_NOT_FOUND:
 715                 responseEnum = ActionStatus.ARTIFACT_NOT_FOUND;
 716                 break;
 717             case DISTR_ENVIRONMENT_NOT_AVAILABLE:
 718                 responseEnum = ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE;
 719                 break;
 720             case DISTR_ENVIRONMENT_NOT_FOUND:
 721                 responseEnum = ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_FOUND;
 722                 break;
 723             case DISTR_ENVIRONMENT_SENT_IS_INVALID:
 724                 responseEnum = ActionStatus.DISTRIBUTION_ENVIRONMENT_INVALID;
 725                 break;
 726             case INVALID_TYPE:
 727                 responseEnum = ActionStatus.INVALID_CONTENT;
 728                 break;
 729             case INVALID_VALUE:
 730                 responseEnum = ActionStatus.INVALID_CONTENT;
 731                 break;
 732             case CSAR_NOT_FOUND:
 733                 responseEnum = ActionStatus.CSAR_NOT_FOUND;
 734                 break;
 735             case PROPERTY_NAME_ALREADY_EXISTS:
 736                 responseEnum = ActionStatus.PROPERTY_NAME_ALREADY_EXISTS;
 737                 break;
 738             case MATCH_NOT_FOUND:
 739                 responseEnum = ActionStatus.COMPONENT_SUB_CATEGORY_NOT_FOUND_FOR_CATEGORY;
 740                 break;
 741             case CATEGORY_NOT_FOUND:
 742                 responseEnum = ActionStatus.COMPONENT_CATEGORY_NOT_FOUND;
 743                 break;
 744             case INVALID_PROPERTY:
 745                 responseEnum = ActionStatus.INVALID_PROPERTY;
 746                 break;
 747             case COMPONENT_IS_ARCHIVED:
 748                 responseEnum = ActionStatus.COMPONENT_IS_ARCHIVED;
 749                 break;
 750             case COMPONENT_NOT_ARCHIVED:
 751                 responseEnum = ActionStatus.COMPONENT_NOT_ARCHIVED;
 752                 break;
 753             case COMPONENT_IS_IN_USE:
 754                 responseEnum = ActionStatus.COMPONENT_IN_USE_BY_ANOTHER_COMPONENT;
 755                 break;
 756             case DECLARED_INPUT_USED_BY_OPERATION:
 757                 responseEnum = ActionStatus.DECLARED_INPUT_USED_BY_OPERATION;
 758                 break;
 759             default:
 760                 responseEnum = ActionStatus.GENERAL_ERROR;
 761                 break;
 762         }
 763         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
 764         return responseEnum;
 765     }
 766
 767     public ActionStatus convertFromToscaError(ToscaError toscaError) {
 768         ActionStatus responseEnum = ActionStatus.GENERAL_ERROR;
 769         if (toscaError == null) {
 770             return responseEnum;
 771         }
 772         switch (toscaError) {// TODO match errors
 773             case NODE_TYPE_CAPABILITY_ERROR:
 774             case NOT_SUPPORTED_TOSCA_TYPE:
 775             case NODE_TYPE_REQUIREMENT_ERROR:
 776                 responseEnum = ActionStatus.INVALID_CONTENT;
 777                 break;
 778             default:
 779                 break;
 780         }
 781         return responseEnum;
 782     }
 783
 784     public ActionStatus convertFromStorageResponseForCapabilityType(StorageOperationStatus storageResponse) {
 785         ActionStatus responseEnum;
 786         switch (storageResponse) {
 787             case OK:
 788                 responseEnum = ActionStatus.OK;
 789                 break;
 790             case CONNECTION_FAILURE:
 791             case GRAPH_IS_LOCK:
 792                 responseEnum = ActionStatus.GENERAL_ERROR;
 793                 break;
 794             case BAD_REQUEST:
 795                 responseEnum = ActionStatus.INVALID_CONTENT;
 796                 break;
 797             case ENTITY_ALREADY_EXISTS:
 798                 responseEnum = ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST;
 799                 break;
 800             case SCHEMA_VIOLATION:
 801                 responseEnum = ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST;
 802                 break;
 803             case NOT_FOUND:
 804                 responseEnum = ActionStatus.CAPABILITY_NOT_FOUND;
 805                 break;
 806             default:
 807                 responseEnum = ActionStatus.GENERAL_ERROR;
 808                 break;
 809         }
 810         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
 811         return responseEnum;
 812     }
 813
 814     public ActionStatus convertFromStorageResponseForLifecycleType(StorageOperationStatus storageResponse) {
 815         ActionStatus responseEnum;
 816         switch (storageResponse) {
 817             case OK:
 818                 responseEnum = ActionStatus.OK;
 819                 break;
 820             case CONNECTION_FAILURE:
 821             case GRAPH_IS_LOCK:
 822                 responseEnum = ActionStatus.GENERAL_ERROR;
 823                 break;
 824             case BAD_REQUEST:
 825                 responseEnum = ActionStatus.INVALID_CONTENT;
 826                 break;
 827             case ENTITY_ALREADY_EXISTS:
 828                 responseEnum = ActionStatus.LIFECYCLE_TYPE_ALREADY_EXIST;
 829                 break;
 830             case SCHEMA_VIOLATION:
 831                 responseEnum = ActionStatus.LIFECYCLE_TYPE_ALREADY_EXIST;
 832                 break;
 833             default:
 834                 responseEnum = ActionStatus.GENERAL_ERROR;
 835                 break;
 836         }
 837         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
 838         return responseEnum;
 839     }
 840
 841     public ActionStatus convertFromStorageResponseForResourceInstance(StorageOperationStatus storageResponse, boolean isRelation) {
 842         ActionStatus responseEnum;
 843         switch (storageResponse) {
 844             case OK:
 845                 responseEnum = ActionStatus.OK;
 846                 break;
 847             case INVALID_ID:
 848                 responseEnum = ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST;
 849                 break;
 850             case INVALID_PROPERTY:
 851                 responseEnum = ActionStatus.INVALID_PROPERTY;
 852                 break;
 853             case GRAPH_IS_LOCK:
 854                 responseEnum = ActionStatus.GENERAL_ERROR;
 855                 break;
 856             case BAD_REQUEST:
 857                 responseEnum = ActionStatus.INVALID_CONTENT;
 858                 break;
 859             case MATCH_NOT_FOUND:
 860                 responseEnum = ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND;
 861                 break;
 862             case SCHEMA_VIOLATION:
 863                 responseEnum = ActionStatus.RESOURCE_INSTANCE_ALREADY_EXIST;
 864                 break;
 865             case NOT_FOUND:
 866                 if (isRelation) {
 867                     responseEnum = ActionStatus.RESOURCE_INSTANCE_RELATION_NOT_FOUND;
 868                 } else {
 869                     responseEnum = ActionStatus.RESOURCE_INSTANCE_NOT_FOUND;
 870                 }
 871                 break;
 872             default:
 873                 responseEnum = ActionStatus.GENERAL_ERROR;
 874                 break;
 875         }
 876         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
 877         return responseEnum;
 878     }
 879
 880     public ResponseFormat getResponseFormatForResourceInstance(ActionStatus actionStatus, String serviceName, String resourceInstanceName) {
 881         ResponseFormat responseFormat;
 882         if (actionStatus == ActionStatus.RESOURCE_INSTANCE_NOT_FOUND) {
 883             responseFormat = getResponseFormat(actionStatus, resourceInstanceName);
 884         } else {
 885             responseFormat = getResponseFormat(actionStatus, serviceName);
 886         }
 887         return responseFormat;
 888     }
 889
 890     public ResponseFormat getResponseFormatForResourceInstanceProperty(ActionStatus actionStatus, String resourceInstanceName) {
 891         ResponseFormat responseFormat;
 892         if (actionStatus == ActionStatus.RESOURCE_INSTANCE_NOT_FOUND) {
 893             responseFormat = getResponseFormat(actionStatus, resourceInstanceName);
 894         } else {
 895             responseFormat = getResponseFormat(actionStatus);
 896         }
 897         return responseFormat;
 898     }
 899
 900     public ActionStatus convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus storageResponse) {
 901         ActionStatus responseEnum;
 902         switch (storageResponse) {
 903             case OK:
 904                 responseEnum = ActionStatus.OK;
 905                 break;
 906             case INVALID_ID:
 907                 responseEnum = ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST;
 908                 break;
 909             case GRAPH_IS_LOCK:
 910                 responseEnum = ActionStatus.GENERAL_ERROR;
 911                 break;
 912             case BAD_REQUEST:
 913                 responseEnum = ActionStatus.INVALID_CONTENT;
 914                 break;
 915             case MATCH_NOT_FOUND:
 916                 responseEnum = ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND;
 917                 break;
 918             case SCHEMA_VIOLATION:
 919                 responseEnum = ActionStatus.RESOURCE_INSTANCE_ALREADY_EXIST;
 920                 break;
 921             case NOT_FOUND:
 922                 responseEnum = ActionStatus.RESOURCE_INSTANCE_NOT_FOUND;
 923                 break;
 924             default:
 925                 responseEnum = ActionStatus.GENERAL_ERROR;
 926                 break;
 927         }
 928         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
 929         return responseEnum;
 930     }
 931
 932     public void auditComponent(ResponseFormat responseFormat, User modifier, Component component, AuditingActionEnum actionEnum,
 933                                ResourceCommonInfo resourceCommonInfo, ResourceVersionInfo prevComponent, String comment) {
 934         auditComponent(responseFormat, modifier, component, actionEnum, resourceCommonInfo, prevComponent, null, comment, null, null);
 935     }
 936
 937     public void auditComponentAdmin(ResponseFormat responseFormat, User modifier, Component component, AuditingActionEnum actionEnum,
 938                                     ComponentTypeEnum typeEnum) {
 939         auditComponent(responseFormat, modifier, component, actionEnum, new ResourceCommonInfo(typeEnum.getValue()),
 940             ResourceVersionInfo.newBuilder().build());
 941     }
 942
 943     public void auditComponentAdmin(ResponseFormat responseFormat, User modifier, Component component, AuditingActionEnum actionEnum,
 944                                     ComponentTypeEnum typeEnum, String comment) {
 945         auditComponent(responseFormat, modifier, component, actionEnum, new ResourceCommonInfo(typeEnum.getValue()),
 946             ResourceVersionInfo.newBuilder().build(), null, comment, null, null);
 947     }
 948
 949     public void auditComponentAdmin(ResponseFormat responseFormat, User modifier, Component component, AuditingActionEnum actionEnum,
 950                                     ComponentTypeEnum typeEnum, ResourceVersionInfo prevComponent) {
 951         auditComponent(responseFormat, modifier, component, actionEnum, new ResourceCommonInfo(typeEnum.getValue()), prevComponent);
 952     }
 953
 954     public void auditComponent(ResponseFormat responseFormat, User modifier, Component component, AuditingActionEnum actionEnum,
 955                                ResourceCommonInfo resourceCommonInfo, ResourceVersionInfo prevComponent) {
 956         auditComponent(responseFormat, modifier, component, actionEnum, resourceCommonInfo, prevComponent, null, null, null, null);
 957     }
 958
 959     public void auditComponent(ResponseFormat responseFormat, User modifier, AuditingActionEnum actionEnum, ResourceCommonInfo resourceCommonInfo,
 960                                String comment) {
 961         auditComponent(responseFormat, modifier, null, actionEnum, resourceCommonInfo, ResourceVersionInfo.newBuilder().build(), null, comment, null,
 962             null);
 963     }
 964
 965     public void auditComponent(ResponseFormat responseFormat, User modifier, Component component, AuditingActionEnum actionEnum,
 966                                ResourceCommonInfo resourceCommonInfo, ResourceVersionInfo prevComponent, ResourceVersionInfo currComponent) {
 967         auditComponent(responseFormat, modifier, component, actionEnum, resourceCommonInfo, prevComponent, currComponent, null, null, null);
 968     }
 969
 970     public void auditComponent(ResponseFormat responseFormat, User modifier, Component component, AuditingActionEnum actionEnum,
 971                                ResourceCommonInfo resourceCommonInfo, ResourceVersionInfo prevComponent, ResourceVersionInfo currComponent,
 972                                String comment, ArtifactDefinition artifactDefinition, String did) {
 973         if (actionEnum != null) {
 974             String uuid = null;
 975             String currState = null;
 976             String invariantUUID = null;
 977             String currArtifactUid = null;
 978             String currVersion = null;
 979             String dcurrStatus = null;
 980             log.trace(INSIDE_AUDITING_FOR_AUDIT_ACTION, actionEnum);
 981             String message = getMessageString(responseFormat);
 982             int status = responseFormat.getStatus();
 983             String artifactData = buildAuditingArtifactData(artifactDefinition);
 984             if (component != null) {
 985                 // fields that are filled during creation and might still be empty
 986                 if (component.getLifecycleState() != null) {
 987                     currState = component.getLifecycleState().name();
 988                 }
 989                 uuid = component.getUUID();
 990                 invariantUUID = component.getInvariantUUID();
 991                 currVersion = component.getVersion();
 992                 if (StringUtils.isEmpty(resourceCommonInfo.getResourceName())) {
 993                     resourceCommonInfo.setResourceName(component.getComponentMetadataDefinition().getMetadataDataDefinition().getName());
 994                 }
 995             }
 996             if (currComponent != null) {
 997                 currArtifactUid = currComponent.getArtifactUuid();
 998                 dcurrStatus = currComponent.getDistributionStatus();
 999                 if (currState == null) { //probably it was not set
1000                     currState = currComponent.getState();
1001                 }
1002                 if (currVersion == null) { //probably it was not set
1003                     currVersion = currComponent.getVersion();
1004                 }
1005             }
1006             AuditEventFactory factory = AuditResourceEventFactoryManager.createResourceEventFactory(actionEnum,
1007                 CommonAuditData.newBuilder().status(status).description(message).requestId(ThreadLocalsHolder.getUuid()).serviceInstanceId(uuid)
1008                     .build(), resourceCommonInfo, prevComponent,
1009                 ResourceVersionInfo.newBuilder().artifactUuid(currArtifactUid).state(currState).version(currVersion).distributionStatus(dcurrStatus)
1010                     .build(), invariantUUID, modifier, artifactData, comment, did, null);
1011             getAuditingManager().auditEvent(factory);
1012         }
1013     }
1014
1015     public void auditDistributionEngine(AuditingActionEnum action, String environmentName, DistributionTopicData distributionTopicData,
1016                                         String status) {
1017         auditDistributionEngine(action, environmentName, distributionTopicData, null, null, status);
1018     }
1019
1020     public void auditDistributionEngine(AuditingActionEnum action, String environmentName, DistributionTopicData distributionTopicData, String role,
1021                                         String apiKey, String status) {
1022         AuditEventFactory factory = AuditDistributionEngineEventFactoryManager
1023             .createDistributionEngineEventFactory(action, environmentName, distributionTopicData, role, apiKey, status);
1024         getAuditingManager().auditEvent(factory);
1025     }
1026
1027     public void auditEnvironmentEngine(AuditingActionEnum actionEnum, String environmentID, String environmentType, String action,
1028                                        String environmentName, String tenantContext) {
1029         AuditEventFactory factory = new AuditEcompOpEnvEventFactory(actionEnum, environmentID, environmentName, environmentType, action,
1030             tenantContext);
1031         audit.startAuditFetchLog(PARTNER_NAME, DmaapConsumer.class.getName());
1032         audit.logEntry(LogLevel.INFO, Severity.OK, null, MarkerFactory.getMarker(ONAPLogConstants.Markers.ENTRY.getName()), environmentID);
1033         getAuditingManager().auditEvent(factory, audit);
1034     }
1035
1036     public void auditDistributionNotification(String serviceUUID, String resourceName, String resourceType, String currVersion, User modifier,
1037                                               String environmentName, String currState, String topicName, String distributionId, String description,
1038                                               String status, String workloadContext, String tenant) {
1039         AuditEventFactory factory = new AuditDistributionNotificationEventFactory(
1040             CommonAuditData.newBuilder().serviceInstanceId(serviceUUID).status(status).description(description)
1041                 .requestId(ThreadLocalsHolder.getUuid()).build(), new ResourceCommonInfo(resourceName, resourceType),
1042             ResourceVersionInfo.newBuilder().state(currState).version(currVersion).build(), distributionId, modifier, topicName,
1043             new OperationalEnvAuditData(environmentName, workloadContext, tenant));
1044         getAuditingManager().auditEvent(factory);
1045     }
1046
1047     public void auditAuthEvent(String url, String user, String authStatus, String realm) {
1048         AuditEventFactory factory = new AuditAuthRequestEventFactory(CommonAuditData.newBuilder().requestId(ThreadLocalsHolder.getUuid()).build(),
1049             user, url, realm, authStatus);
1050         getAuditingManager().auditEvent(factory);
1051     }
1052
1053     public void auditDistributionStatusNotification(String distributionId, String consumerId, String topicName, String resourceUrl, String statusTime,
1054                                                     String status, String errorReason, LoggerSdcAudit audit) {
1055         AuditEventFactory factory = new AuditDistributionStatusEventFactory(
1056             CommonAuditData.newBuilder().description(errorReason).status(status).requestId(distributionId).build(),
1057             new DistributionData(consumerId, resourceUrl), distributionId, topicName, statusTime);
1058         getAuditingManager().auditEvent(factory, audit);
1059     }
1060
1061     public void auditGetUebCluster(String consumerId, String status, String description) {
1062         AuditEventFactory factory = new AuditGetUebClusterEventFactory(
1063             CommonAuditData.newBuilder().description(description).status(status).requestId(ThreadLocalsHolder.getUuid()).build(), consumerId);
1064         getAuditingManager().auditEvent(factory);
1065     }
1066
1067     public void auditMissingInstanceIdAsDistributionEngineEvent(AuditingActionEnum actionEnum, String status) {
1068         AuditEventFactory factory = AuditDistributionEngineEventFactoryManager
1069             .createDistributionEngineEventFactory(actionEnum, "", DistributionTopicData.newBuilder().build(), null, null, status);
1070         getAuditingManager().auditEvent(factory);
1071     }
1072
1073     public void auditRegisterOrUnRegisterEvent(AuditingActionEnum action, String consumerId, String apiPublicKey, String envName, String status,
1074                                                String distributionStatus, String notifTopicName, String statusTopicName) {
1075         String appliedStatus = !StringUtils.isEmpty(status) ? status : distributionStatus;
1076         AuditEventFactory factory = new AuditRegUnregDistributionEngineEventFactory(action,
1077             CommonAuditData.newBuilder().requestId(ThreadLocalsHolder.getUuid()).status(appliedStatus).build(),
1078             DistributionTopicData.newBuilder().statusTopic(statusTopicName).notificationTopic(notifTopicName).build(), consumerId, apiPublicKey,
1079             envName);
1080         getAuditingManager().auditEvent(factory);
1081     }
1082
1083     public void auditServiceDistributionDeployed(String serviceName, String serviceVersion, String serviceUUID, String distributionId, String status,
1084                                                  String desc, User modifier) {
1085         AuditEventFactory factory = new AuditDistributionDeployEventFactory(
1086             CommonAuditData.newBuilder().requestId(ThreadLocalsHolder.getUuid()).serviceInstanceId(serviceUUID).status(status).description(desc)
1087                 .build(), new ResourceCommonInfo(serviceName, "Service"), distributionId, modifier, serviceVersion);
1088         getAuditingManager().auditEvent(factory);
1089     }
1090
1091     public void auditConsumerCredentialsEvent(AuditingActionEnum actionEnum, ConsumerDefinition consumer, ResponseFormat responseFormat,
1092                                               User modifier) {
1093         AuditEventFactory factory = new AuditConsumerEventFactory(actionEnum,
1094             CommonAuditData.newBuilder().description(getMessageString(responseFormat)).status(responseFormat.getStatus())
1095                 .requestId(ThreadLocalsHolder.getUuid()).build(), modifier, consumer);
1096         getAuditingManager().auditEvent(factory);
1097     }
1098
1099     public void auditGetUsersList(User user, String details, ResponseFormat responseFormat) {
1100         AuditEventFactory factory = new AuditGetUsersListEventFactory(
1101             CommonAuditData.newBuilder().description(getMessageString(responseFormat)).status(responseFormat.getStatus())
1102                 .requestId(ThreadLocalsHolder.getUuid()).build(), user, details);
1103         getAuditingManager().auditEvent(factory);
1104     }
1105
1106     public void auditAdminUserActionAndThrowException(AuditingActionEnum actionEnum, User modifier, User userBefore, User userAfter,
1107                                                       ActionStatus status, String... params) {
1108         ResponseFormat responseFormat = getResponseFormat(status, params);
1109         auditAdminUserAction(actionEnum, modifier, userBefore, userAfter, responseFormat);
1110         throw new ByResponseFormatComponentException(responseFormat);
1111     }
1112
1113     public void auditAdminUserAction(AuditingActionEnum actionEnum, User modifier, User userBefore, User userAfter, ResponseFormat responseFormat) {
1114         AuditEventFactory factory = new AuditUserAdminEventFactory(actionEnum,
1115             CommonAuditData.newBuilder().description(getMessageString(responseFormat)).status(responseFormat.getStatus())
1116                 .requestId(ThreadLocalsHolder.getUuid()).build(), modifier, userBefore, userAfter);
1117         getAuditingManager().auditEvent(factory);
1118     }
1119
1120     public void auditUserAccess(User user, ActionStatus status, String... params) {
1121         auditUserAccess(user, getResponseFormat(status, params));
1122     }
1123
1124     public void auditUserAccess(User user, ResponseFormat responseFormat) {
1125         AuditEventFactory factory = new AuditUserAccessEventFactory(
1126             CommonAuditData.newBuilder().description(getMessageString(responseFormat)).status(responseFormat.getStatus())
1127                 .requestId(ThreadLocalsHolder.getUuid()).build(), user);
1128         getAuditingManager().auditEvent(factory);
1129     }
1130
1131     public void auditGetCategoryHierarchy(User user, String details, ResponseFormat responseFormat) {
1132         AuditEventFactory factory = new AuditGetCategoryHierarchyEventFactory(
1133             CommonAuditData.newBuilder().description(getMessageString(responseFormat)).status(responseFormat.getStatus())
1134                 .requestId(ThreadLocalsHolder.getUuid()).build(), user, details);
1135         getAuditingManager().auditEvent(factory);
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         switch (actionStatus) {
1144             case COMPONENT_VERSION_ALREADY_EXIST:
1145                 responseFormat = getResponseFormat(ActionStatus.COMPONENT_VERSION_ALREADY_EXIST, type.getValue(), component.getVersion());
1146                 break;
1147             case RESOURCE_NOT_FOUND:
1148                 responseFormat = getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND,
1149                     component.getComponentMetadataDefinition().getMetadataDataDefinition().getName());
1150                 break;
1151             case COMPONENT_NAME_ALREADY_EXIST:
1152                 responseFormat = getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, type.getValue(),
1153                     component.getComponentMetadataDefinition().getMetadataDataDefinition().getName());
1154                 break;
1155             case COMPONENT_IN_USE:
1156                 responseFormat = getResponseFormat(ActionStatus.COMPONENT_IN_USE, type.name().toLowerCase(), component.getUniqueId());
1157                 break;
1158             case SERVICE_DEPLOYMENT_ARTIFACT_NOT_FOUND:
1159                 responseFormat = getResponseFormat(ActionStatus.SERVICE_DEPLOYMENT_ARTIFACT_NOT_FOUND,
1160                     component.getComponentMetadataDefinition().getMetadataDataDefinition().getName());
1161                 break;
1162             default:
1163                 responseFormat = getResponseFormat(actionStatus);
1164                 break;
1165         }
1166         return responseFormat;
1167     }
1168
1169     public ActionStatus convertFromStorageResponseForAdditionalInformation(StorageOperationStatus storageResponse) {
1170         ActionStatus responseEnum;
1171         switch (storageResponse) {
1172             case OK:
1173                 responseEnum = ActionStatus.OK;
1174                 break;
1175             case ENTITY_ALREADY_EXISTS:
1176                 responseEnum = ActionStatus.COMPONENT_NAME_ALREADY_EXIST;
1177                 break;
1178             case INVALID_ID:
1179                 responseEnum = ActionStatus.ADDITIONAL_INFORMATION_NOT_FOUND;
1180                 break;
1181             default:
1182                 responseEnum = ActionStatus.GENERAL_ERROR;
1183                 break;
1184         }
1185         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
1186         return responseEnum;
1187     }
1188
1189     public ActionStatus convertFromResultStatusEnum(ResultStatusEnum resultStatus, JsonPresentationFields elementType) {
1190         ActionStatus responseEnum = ActionStatus.GENERAL_ERROR;
1191         switch (resultStatus) {
1192             case OK:
1193                 responseEnum = ActionStatus.OK;
1194                 break;
1195             case ELEMENT_NOT_FOUND:
1196                 if (elementType == JsonPresentationFields.PROPERTY) {
1197                     responseEnum = ActionStatus.PROPERTY_NOT_FOUND;
1198                 }
1199                 break;
1200             case INVALID_PROPERTY_DEFAULT_VALUE:
1201             case INVALID_PROPERTY_TYPE:
1202             case INVALID_PROPERTY_VALUE:
1203             case INVALID_PROPERTY_NAME:
1204             case MISSING_ENTRY_SCHEMA_TYPE:
1205                 responseEnum = ActionStatus.INVALID_PROPERTY;
1206                 break;
1207             case INVALID_ATTRIBUTE_NAME:
1208                 responseEnum = ActionStatus.INVALID_ATTRIBUTE;
1209                 break;
1210             default:
1211                 break;
1212         }
1213         return responseEnum;
1214     }
1215
1216     public ResponseFormat getResponseFormatAdditionalProperty(ActionStatus actionStatus, AdditionalInfoParameterInfo additionalInfoParameterInfo,
1217                                                               NodeTypeEnum nodeType, AdditionalInformationEnum labelOrValue) {
1218         if (additionalInfoParameterInfo == null) {
1219             additionalInfoParameterInfo = new AdditionalInfoParameterInfo();
1220         }
1221         if (labelOrValue == null) {
1222             labelOrValue = AdditionalInformationEnum.None;
1223         }
1224         switch (actionStatus) {
1225             case COMPONENT_NAME_ALREADY_EXIST:
1226                 return getResponseFormat(actionStatus, "Additional parameter", additionalInfoParameterInfo.getKey());
1227             case ADDITIONAL_INFORMATION_EXCEEDS_LIMIT:
1228                 return getResponseFormat(actionStatus, labelOrValue.name().toLowerCase(),
1229                     ValidationUtils.ADDITIONAL_INFORMATION_KEY_MAX_LENGTH.toString());
1230             case ADDITIONAL_INFORMATION_MAX_NUMBER_REACHED:
1231                 return getResponseFormat(actionStatus, nodeType.name().toLowerCase());
1232             case ADDITIONAL_INFORMATION_EMPTY_STRING_NOT_ALLOWED:
1233                 return getResponseFormat(actionStatus);
1234             case ADDITIONAL_INFORMATION_KEY_NOT_ALLOWED_CHARACTERS:
1235                 return getResponseFormat(actionStatus);
1236             case ADDITIONAL_INFORMATION_VALUE_NOT_ALLOWED_CHARACTERS:
1237                 return getResponseFormat(actionStatus);
1238             case ADDITIONAL_INFORMATION_NOT_FOUND:
1239                 return getResponseFormat(actionStatus);
1240             default:
1241                 return getResponseFormat(actionStatus);
1242         }
1243     }
1244
1245     public ResponseFormat getResponseFormatAdditionalProperty(ActionStatus actionStatus) {
1246         return getResponseFormatAdditionalProperty(actionStatus, null, null, null);
1247     }
1248
1249     public ActionStatus convertFromStorageResponseForConsumer(StorageOperationStatus storageResponse) {
1250         ActionStatus responseEnum;
1251         switch (storageResponse) {
1252             case OK:
1253                 responseEnum = ActionStatus.OK;
1254                 break;
1255             case CONNECTION_FAILURE:
1256             case GRAPH_IS_LOCK:
1257                 responseEnum = ActionStatus.GENERAL_ERROR;
1258                 break;
1259             case BAD_REQUEST:
1260                 responseEnum = ActionStatus.INVALID_CONTENT;
1261                 break;
1262             case ENTITY_ALREADY_EXISTS:
1263                 responseEnum = ActionStatus.CONSUMER_ALREADY_EXISTS;
1264                 break;
1265             case SCHEMA_VIOLATION:
1266                 responseEnum = ActionStatus.CONSUMER_ALREADY_EXISTS;
1267                 break;
1268             case NOT_FOUND:
1269                 responseEnum = ActionStatus.ECOMP_USER_NOT_FOUND;
1270                 break;
1271             default:
1272                 responseEnum = ActionStatus.GENERAL_ERROR;
1273                 break;
1274         }
1275         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
1276         return responseEnum;
1277     }
1278
1279     public ActionStatus convertFromStorageResponseForGroupType(StorageOperationStatus storageResponse) {
1280         ActionStatus responseEnum;
1281         switch (storageResponse) {
1282             case OK:
1283                 responseEnum = ActionStatus.OK;
1284                 break;
1285             case CONNECTION_FAILURE:
1286             case GRAPH_IS_LOCK:
1287                 responseEnum = ActionStatus.GENERAL_ERROR;
1288                 break;
1289             case BAD_REQUEST:
1290                 responseEnum = ActionStatus.INVALID_CONTENT;
1291                 break;
1292             case ENTITY_ALREADY_EXISTS:
1293                 responseEnum = ActionStatus.GROUP_TYPE_ALREADY_EXIST;
1294                 break;
1295             case SCHEMA_VIOLATION:
1296                 responseEnum = ActionStatus.GROUP_TYPE_ALREADY_EXIST;
1297                 break;
1298             default:
1299                 responseEnum = ActionStatus.GENERAL_ERROR;
1300                 break;
1301         }
1302         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
1303         return responseEnum;
1304     }
1305
1306     public ActionStatus convertFromStorageResponseForPolicyType(StorageOperationStatus storageResponse) {
1307         ActionStatus responseEnum;
1308         switch (storageResponse) {
1309             case OK:
1310                 responseEnum = ActionStatus.OK;
1311                 break;
1312             case CONNECTION_FAILURE:
1313             case GRAPH_IS_LOCK:
1314                 responseEnum = ActionStatus.GENERAL_ERROR;
1315                 break;
1316             case BAD_REQUEST:
1317                 responseEnum = ActionStatus.INVALID_CONTENT;
1318                 break;
1319             case ENTITY_ALREADY_EXISTS:
1320                 responseEnum = ActionStatus.POLICY_TYPE_ALREADY_EXIST;
1321                 break;
1322             case SCHEMA_VIOLATION:
1323                 responseEnum = ActionStatus.POLICY_TYPE_ALREADY_EXIST;
1324                 break;
1325             default:
1326                 responseEnum = ActionStatus.GENERAL_ERROR;
1327                 break;
1328         }
1329         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
1330         return responseEnum;
1331     }
1332
1333     public ActionStatus convertFromStorageResponseForDataType(StorageOperationStatus storageResponse) {
1334         ActionStatus responseEnum;
1335         switch (storageResponse) {
1336             case OK:
1337                 responseEnum = ActionStatus.OK;
1338                 break;
1339             case CONNECTION_FAILURE:
1340             case GRAPH_IS_LOCK:
1341                 responseEnum = ActionStatus.GENERAL_ERROR;
1342                 break;
1343             case BAD_REQUEST:
1344                 responseEnum = ActionStatus.INVALID_CONTENT;
1345                 break;
1346             case ENTITY_ALREADY_EXISTS:
1347                 responseEnum = ActionStatus.DATA_TYPE_ALREADY_EXIST;
1348                 break;
1349             case SCHEMA_VIOLATION:
1350                 responseEnum = ActionStatus.DATA_TYPE_ALREADY_EXIST;
1351                 break;
1352             case CANNOT_UPDATE_EXISTING_ENTITY:
1353                 responseEnum = ActionStatus.DATA_TYPE_CANNOT_BE_UPDATED_BAD_REQUEST;
1354                 break;
1355             default:
1356                 responseEnum = ActionStatus.GENERAL_ERROR;
1357                 break;
1358         }
1359         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
1360         return responseEnum;
1361     }
1362
1363     public ResponseFormat getResponseFormatByGroupType(ActionStatus actionStatus, GroupTypeDefinition groupType) {
1364         if (groupType == null) {
1365             return getResponseFormat(actionStatus);
1366         }
1367         ResponseFormat responseFormat;
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     public ResponseFormat getResponseFormatByPolicyType(ActionStatus actionStatus, PolicyTypeDefinition policyType) {
1381         if (policyType == null) {
1382             return getResponseFormat(actionStatus);
1383         }
1384         ResponseFormat responseFormat;
1385         if (actionStatus == ActionStatus.POLICY_TYPE_ALREADY_EXIST) {
1386             responseFormat = getResponseFormat(actionStatus, policyType.getType());
1387         } else {
1388             responseFormat = getResponseFormat(actionStatus);
1389         }
1390         return responseFormat;
1391     }
1392
1393     public ResponseFormat getResponseFormatByDataType(ActionStatus actionStatus, DataTypeDefinition dataType, List<String> properties) {
1394         if (dataType == null) {
1395             return getResponseFormat(actionStatus);
1396         }
1397         ResponseFormat responseFormat;
1398         switch (actionStatus) {
1399             case DATA_TYPE_ALREADY_EXIST:
1400                 responseFormat = getResponseFormat(actionStatus, dataType.getName());
1401                 break;
1402             case DATA_TYPE_NOR_PROPERTIES_NEITHER_DERIVED_FROM:
1403                 responseFormat = getResponseFormat(actionStatus, dataType.getName());
1404                 break;
1405             case DATA_TYPE_PROPERTIES_CANNOT_BE_EMPTY:
1406                 responseFormat = getResponseFormat(actionStatus, dataType.getName());
1407                 break;
1408             case DATA_TYPE_PROPERTY_ALREADY_DEFINED_IN_ANCESTOR:
1409                 responseFormat = getResponseFormat(actionStatus, dataType.getName(), properties == null ? "" : String.valueOf(properties));
1410                 break;
1411             case DATA_TYPE_DERIVED_IS_MISSING:
1412                 responseFormat = getResponseFormat(actionStatus, dataType.getDerivedFromName());
1413                 break;
1414             case DATA_TYPE_DUPLICATE_PROPERTY:
1415                 responseFormat = getResponseFormat(actionStatus, dataType.getName());
1416                 break;
1417             case DATA_TYPE_PROEPRTY_CANNOT_HAVE_SAME_TYPE_OF_DATA_TYPE:
1418                 responseFormat = getResponseFormat(actionStatus, dataType.getName(), properties == null ? "" : String.valueOf(properties));
1419                 break;
1420             case DATA_TYPE_CANNOT_HAVE_PROPERTIES:
1421                 responseFormat = getResponseFormat(actionStatus, dataType.getName());
1422                 break;
1423             case DATA_TYPE_CANNOT_BE_UPDATED_BAD_REQUEST:
1424                 responseFormat = getResponseFormat(actionStatus, dataType.getName());
1425                 break;
1426             default:
1427                 responseFormat = getResponseFormat(actionStatus);
1428                 break;
1429         }
1430         return responseFormat;
1431     }
1432
1433     public StorageOperationStatus convertToStorageOperationStatus(CassandraOperationStatus cassandraStatus) {
1434         StorageOperationStatus result;
1435         switch (cassandraStatus) {
1436             case OK:
1437                 result = StorageOperationStatus.OK;
1438                 break;
1439             case NOT_FOUND:
1440                 result = StorageOperationStatus.NOT_FOUND;
1441                 break;
1442             case CLUSTER_NOT_CONNECTED:
1443             case KEYSPACE_NOT_CONNECTED:
1444                 result = StorageOperationStatus.CONNECTION_FAILURE;
1445                 break;
1446             default:
1447                 result = StorageOperationStatus.GENERAL_ERROR;
1448                 break;
1449         }
1450         return result;
1451     }
1452
1453     public ResponseFormat getResponseFormat(ComponentException exception) {
1454         return exception instanceof ByResponseFormatComponentException ? getResponseFormat((ByResponseFormatComponentException) exception)
1455             : getResponseFormat((ByActionStatusComponentException) exception);
1456     }
1457
1458     public ResponseFormat getResponseFormat(ByResponseFormatComponentException exception) {
1459         return exception.getResponseFormat();
1460     }
1461
1462     public ResponseFormat getResponseFormat(ByActionStatusComponentException exception) {
1463         return getResponseFormat(exception.getActionStatus(), exception.getParams());
1464     }
1465
1466     public ActionStatus convertFromStorageResponseForRelationshipType(StorageOperationStatus storageResponse) {
1467         ActionStatus responseEnum;
1468         switch (storageResponse) {
1469             case OK:
1470                 responseEnum = ActionStatus.OK;
1471                 break;
1472             case CONNECTION_FAILURE:
1473             case GRAPH_IS_LOCK:
1474                 responseEnum = ActionStatus.GENERAL_ERROR;
1475                 break;
1476             case BAD_REQUEST:
1477                 responseEnum = ActionStatus.INVALID_CONTENT;
1478                 break;
1479             case ENTITY_ALREADY_EXISTS:
1480                 responseEnum = ActionStatus.RELATIONSHIP_TYPE_ALREADY_EXIST;
1481                 break;
1482             case SCHEMA_VIOLATION:
1483                 responseEnum = ActionStatus.RELATIONSHIP_TYPE_ALREADY_EXIST;
1484                 break;
1485             default:
1486                 responseEnum = ActionStatus.GENERAL_ERROR;
1487                 break;
1488         }
1489         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
1490         return responseEnum;
1491     }
1492
1493     public ResponseFormat getResponseFormat(StorageException exception) {
1494         ActionStatus status = convertFromStorageResponse(exception.getStorageOperationStatus());
1495         return getResponseFormat(status, exception.getParams());
1496     }
1497
1498     public List<UiLeftPaletteComponent> convertComponentToUiLeftPaletteComponentObject(List<Component> components) {
1499         List<UiLeftPaletteComponent> uiLeftPaletteComponents = new ArrayList<>();
1500         components.forEach(c -> uiLeftPaletteComponents.add(new UiLeftPaletteComponent(c)));
1501         return uiLeftPaletteComponents;
1502     }
1503
1504     public F<StorageOperationStatus, ResponseFormat> toResponseFormat() {
1505         return sos -> getResponseFormat(convertFromStorageResponse(sos));
1506     }
1507
1508     public Optional<UIConstraint> parseToConstraint(final String componentJson, final User user, final ComponentTypeEnum componentTypeEnum) {
1509         final Either<UIConstraint, ResponseFormat> uiConstraintResponseFormatEither = convertJsonToObjectUsingObjectMapper(componentJson, user,
1510             UIConstraint.class, AuditingActionEnum.CREATE_RESOURCE, componentTypeEnum);
1511         if (uiConstraintResponseFormatEither.isRight()) {
1512             return Optional.empty();
1513         }
1514         return Optional.of(uiConstraintResponseFormatEither.left().value());
1515     }
1516
1517     private Either<List, ResponseFormat> parseToConstraints(final String componentJson, final User user, final ComponentTypeEnum componentTypeEnum) {
1518         return convertJsonToObjectUsingObjectMapper(componentJson, user, List.class, AuditingActionEnum.CREATE_RESOURCE, componentTypeEnum);
1519     }
1520
1521     public List<UIConstraint> validateAndParseConstraint(final ComponentTypeEnum componentTypeEnum, final String constraintData,
1522                                                          final User userModifier) {
1523         final String FAILED_TO_PARSE_CONSTRAINT_DATA = "Failed to Parse Constraint Data {}";
1524         final Either<List, ResponseFormat> convertResponse = parseToConstraints(constraintData, userModifier, componentTypeEnum);
1525         if (convertResponse.isRight()) {
1526             log.error(EcompLoggerErrorCode.DATA_ERROR, FAILED_TO_PARSE_CONSTRAINT_DATA, constraintData, convertResponse.right().value());
1527             return Collections.emptyList();
1528         }
1529         final List<Map<String, String>> uiConstraintsMaps = (List<Map<String, String>>) convertResponse.left().value();
1530         if (uiConstraintsMaps == null) {
1531             log.error(EcompLoggerErrorCode.DATA_ERROR, FAILED_TO_PARSE_CONSTRAINT_DATA, constraintData);
1532             return Collections.emptyList();
1533         }
1534         return uiConstraintsMaps.stream().map(dataMap -> new ObjectMapper().convertValue(dataMap, UIConstraint.class))
1535             .collect(Collectors.toList());
1536     }
1537
1538     public Map<String, DataTypeDefinition> getAllDataTypes(final ApplicationDataTypeCache applicationDataTypeCache, final String model) {
1539         final Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = applicationDataTypeCache.getAll(model);
1540         if (allDataTypes.isRight()) {
1541             final var operationStatus = allDataTypes.right().value();
1542             if (operationStatus == JanusGraphOperationStatus.NOT_FOUND) {
1543                 BeEcompErrorManager.getInstance().logInternalDataError("FetchDataTypes", "Data types are not loaded", ErrorSeverity.ERROR);
1544                 throw new ByActionStatusComponentException(ActionStatus.DATA_TYPES_NOT_LOADED, model);
1545             } else {
1546                 BeEcompErrorManager.getInstance().logInternalFlowError("FetchDataTypes", "Failed to fetch data types", ErrorSeverity.ERROR);
1547                 throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
1548             }
1549         }
1550         return allDataTypes.left().value();
1551     }
1552
1553     public ActionStatus convertFromStorageResponseForArtifactType(final StorageOperationStatus storageResponse) {
1554         ActionStatus responseEnum;
1555         switch (storageResponse) {
1556             case OK:
1557                 responseEnum = ActionStatus.OK;
1558                 break;
1559             case CONNECTION_FAILURE:
1560             case GRAPH_IS_LOCK:
1561                 responseEnum = ActionStatus.GENERAL_ERROR;
1562                 break;
1563             case BAD_REQUEST:
1564                 responseEnum = ActionStatus.INVALID_CONTENT;
1565                 break;
1566             case ENTITY_ALREADY_EXISTS:
1567                 responseEnum = ActionStatus.ARTIFACT_TYPE_ALREADY_EXIST;
1568                 break;
1569             case SCHEMA_VIOLATION:
1570                 responseEnum = ActionStatus.ARTIFACT_TYPE_ALREADY_EXIST;
1571                 break;
1572             default:
1573                 responseEnum = ActionStatus.GENERAL_ERROR;
1574                 break;
1575         }
1576         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
1577         return responseEnum;
1578     }
1579
1580 }