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 boolean validateStringNotEmpty(String value) {
1170         return value != null && !value.trim().isEmpty();
1171     }
1172
1173     public ActionStatus convertFromStorageResponseForAdditionalInformation(StorageOperationStatus storageResponse) {
1174         ActionStatus responseEnum;
1175         switch (storageResponse) {
1176             case OK:
1177                 responseEnum = ActionStatus.OK;
1178                 break;
1179             case ENTITY_ALREADY_EXISTS:
1180                 responseEnum = ActionStatus.COMPONENT_NAME_ALREADY_EXIST;
1181                 break;
1182             case INVALID_ID:
1183                 responseEnum = ActionStatus.ADDITIONAL_INFORMATION_NOT_FOUND;
1184                 break;
1185             default:
1186                 responseEnum = ActionStatus.GENERAL_ERROR;
1187                 break;
1188         }
1189         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
1190         return responseEnum;
1191     }
1192
1193     public ActionStatus convertFromResultStatusEnum(ResultStatusEnum resultStatus, JsonPresentationFields elementType) {
1194         ActionStatus responseEnum = ActionStatus.GENERAL_ERROR;
1195         switch (resultStatus) {
1196             case OK:
1197                 responseEnum = ActionStatus.OK;
1198                 break;
1199             case ELEMENT_NOT_FOUND:
1200                 if (elementType == JsonPresentationFields.PROPERTY) {
1201                     responseEnum = ActionStatus.PROPERTY_NOT_FOUND;
1202                 }
1203                 break;
1204             case INVALID_PROPERTY_DEFAULT_VALUE:
1205             case INVALID_PROPERTY_TYPE:
1206             case INVALID_PROPERTY_VALUE:
1207             case INVALID_PROPERTY_NAME:
1208             case MISSING_ENTRY_SCHEMA_TYPE:
1209                 responseEnum = ActionStatus.INVALID_PROPERTY;
1210                 break;
1211             case INVALID_ATTRIBUTE_NAME:
1212                 responseEnum = ActionStatus.INVALID_ATTRIBUTE;
1213                 break;
1214             default:
1215                 break;
1216         }
1217         return responseEnum;
1218     }
1219
1220     public ResponseFormat getResponseFormatAdditionalProperty(ActionStatus actionStatus, AdditionalInfoParameterInfo additionalInfoParameterInfo,
1221                                                               NodeTypeEnum nodeType, AdditionalInformationEnum labelOrValue) {
1222         if (additionalInfoParameterInfo == null) {
1223             additionalInfoParameterInfo = new AdditionalInfoParameterInfo();
1224         }
1225         if (labelOrValue == null) {
1226             labelOrValue = AdditionalInformationEnum.None;
1227         }
1228         switch (actionStatus) {
1229             case COMPONENT_NAME_ALREADY_EXIST:
1230                 return getResponseFormat(actionStatus, "Additional parameter", additionalInfoParameterInfo.getKey());
1231             case ADDITIONAL_INFORMATION_EXCEEDS_LIMIT:
1232                 return getResponseFormat(actionStatus, labelOrValue.name().toLowerCase(),
1233                     ValidationUtils.ADDITIONAL_INFORMATION_KEY_MAX_LENGTH.toString());
1234             case ADDITIONAL_INFORMATION_MAX_NUMBER_REACHED:
1235                 return getResponseFormat(actionStatus, nodeType.name().toLowerCase());
1236             case ADDITIONAL_INFORMATION_EMPTY_STRING_NOT_ALLOWED:
1237                 return getResponseFormat(actionStatus);
1238             case ADDITIONAL_INFORMATION_KEY_NOT_ALLOWED_CHARACTERS:
1239                 return getResponseFormat(actionStatus);
1240             case ADDITIONAL_INFORMATION_VALUE_NOT_ALLOWED_CHARACTERS:
1241                 return getResponseFormat(actionStatus);
1242             case ADDITIONAL_INFORMATION_NOT_FOUND:
1243                 return getResponseFormat(actionStatus);
1244             default:
1245                 return getResponseFormat(actionStatus);
1246         }
1247     }
1248
1249     public ResponseFormat getResponseFormatAdditionalProperty(ActionStatus actionStatus) {
1250         return getResponseFormatAdditionalProperty(actionStatus, null, null, null);
1251     }
1252
1253     public ActionStatus convertFromStorageResponseForConsumer(StorageOperationStatus storageResponse) {
1254         ActionStatus responseEnum;
1255         switch (storageResponse) {
1256             case OK:
1257                 responseEnum = ActionStatus.OK;
1258                 break;
1259             case CONNECTION_FAILURE:
1260             case GRAPH_IS_LOCK:
1261                 responseEnum = ActionStatus.GENERAL_ERROR;
1262                 break;
1263             case BAD_REQUEST:
1264                 responseEnum = ActionStatus.INVALID_CONTENT;
1265                 break;
1266             case ENTITY_ALREADY_EXISTS:
1267                 responseEnum = ActionStatus.CONSUMER_ALREADY_EXISTS;
1268                 break;
1269             case SCHEMA_VIOLATION:
1270                 responseEnum = ActionStatus.CONSUMER_ALREADY_EXISTS;
1271                 break;
1272             case NOT_FOUND:
1273                 responseEnum = ActionStatus.ECOMP_USER_NOT_FOUND;
1274                 break;
1275             default:
1276                 responseEnum = ActionStatus.GENERAL_ERROR;
1277                 break;
1278         }
1279         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
1280         return responseEnum;
1281     }
1282
1283     public ActionStatus convertFromStorageResponseForGroupType(StorageOperationStatus storageResponse) {
1284         ActionStatus responseEnum;
1285         switch (storageResponse) {
1286             case OK:
1287                 responseEnum = ActionStatus.OK;
1288                 break;
1289             case CONNECTION_FAILURE:
1290             case GRAPH_IS_LOCK:
1291                 responseEnum = ActionStatus.GENERAL_ERROR;
1292                 break;
1293             case BAD_REQUEST:
1294                 responseEnum = ActionStatus.INVALID_CONTENT;
1295                 break;
1296             case ENTITY_ALREADY_EXISTS:
1297                 responseEnum = ActionStatus.GROUP_TYPE_ALREADY_EXIST;
1298                 break;
1299             case SCHEMA_VIOLATION:
1300                 responseEnum = ActionStatus.GROUP_TYPE_ALREADY_EXIST;
1301                 break;
1302             default:
1303                 responseEnum = ActionStatus.GENERAL_ERROR;
1304                 break;
1305         }
1306         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
1307         return responseEnum;
1308     }
1309
1310     public ActionStatus convertFromStorageResponseForPolicyType(StorageOperationStatus storageResponse) {
1311         ActionStatus responseEnum;
1312         switch (storageResponse) {
1313             case OK:
1314                 responseEnum = ActionStatus.OK;
1315                 break;
1316             case CONNECTION_FAILURE:
1317             case GRAPH_IS_LOCK:
1318                 responseEnum = ActionStatus.GENERAL_ERROR;
1319                 break;
1320             case BAD_REQUEST:
1321                 responseEnum = ActionStatus.INVALID_CONTENT;
1322                 break;
1323             case ENTITY_ALREADY_EXISTS:
1324                 responseEnum = ActionStatus.POLICY_TYPE_ALREADY_EXIST;
1325                 break;
1326             case SCHEMA_VIOLATION:
1327                 responseEnum = ActionStatus.POLICY_TYPE_ALREADY_EXIST;
1328                 break;
1329             default:
1330                 responseEnum = ActionStatus.GENERAL_ERROR;
1331                 break;
1332         }
1333         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
1334         return responseEnum;
1335     }
1336
1337     public ActionStatus convertFromStorageResponseForDataType(StorageOperationStatus storageResponse) {
1338         ActionStatus responseEnum;
1339         switch (storageResponse) {
1340             case OK:
1341                 responseEnum = ActionStatus.OK;
1342                 break;
1343             case CONNECTION_FAILURE:
1344             case GRAPH_IS_LOCK:
1345                 responseEnum = ActionStatus.GENERAL_ERROR;
1346                 break;
1347             case BAD_REQUEST:
1348                 responseEnum = ActionStatus.INVALID_CONTENT;
1349                 break;
1350             case ENTITY_ALREADY_EXISTS:
1351                 responseEnum = ActionStatus.DATA_TYPE_ALREADY_EXIST;
1352                 break;
1353             case SCHEMA_VIOLATION:
1354                 responseEnum = ActionStatus.DATA_TYPE_ALREADY_EXIST;
1355                 break;
1356             case CANNOT_UPDATE_EXISTING_ENTITY:
1357                 responseEnum = ActionStatus.DATA_TYPE_CANNOT_BE_UPDATED_BAD_REQUEST;
1358                 break;
1359             default:
1360                 responseEnum = ActionStatus.GENERAL_ERROR;
1361                 break;
1362         }
1363         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
1364         return responseEnum;
1365     }
1366
1367     public ResponseFormat getResponseFormatByGroupType(ActionStatus actionStatus, GroupTypeDefinition groupType) {
1368         if (groupType == null) {
1369             return getResponseFormat(actionStatus);
1370         }
1371         ResponseFormat responseFormat;
1372         switch (actionStatus) {
1373             case GROUP_MEMBER_EMPTY:
1374             case GROUP_TYPE_ALREADY_EXIST:
1375                 responseFormat = getResponseFormat(actionStatus, groupType.getType());
1376                 break;
1377             default:
1378                 responseFormat = getResponseFormat(actionStatus);
1379                 break;
1380         }
1381         return responseFormat;
1382     }
1383
1384     public ResponseFormat getResponseFormatByPolicyType(ActionStatus actionStatus, PolicyTypeDefinition policyType) {
1385         if (policyType == null) {
1386             return getResponseFormat(actionStatus);
1387         }
1388         ResponseFormat responseFormat;
1389         if (actionStatus == ActionStatus.POLICY_TYPE_ALREADY_EXIST) {
1390             responseFormat = getResponseFormat(actionStatus, policyType.getType());
1391         } else {
1392             responseFormat = getResponseFormat(actionStatus);
1393         }
1394         return responseFormat;
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         switch (actionStatus) {
1403             case DATA_TYPE_ALREADY_EXIST:
1404                 responseFormat = getResponseFormat(actionStatus, dataType.getName());
1405                 break;
1406             case DATA_TYPE_NOR_PROPERTIES_NEITHER_DERIVED_FROM:
1407                 responseFormat = getResponseFormat(actionStatus, dataType.getName());
1408                 break;
1409             case DATA_TYPE_PROPERTIES_CANNOT_BE_EMPTY:
1410                 responseFormat = getResponseFormat(actionStatus, dataType.getName());
1411                 break;
1412             case DATA_TYPE_PROPERTY_ALREADY_DEFINED_IN_ANCESTOR:
1413                 responseFormat = getResponseFormat(actionStatus, dataType.getName(), properties == null ? "" : String.valueOf(properties));
1414                 break;
1415             case DATA_TYPE_DERIVED_IS_MISSING:
1416                 responseFormat = getResponseFormat(actionStatus, dataType.getDerivedFromName());
1417                 break;
1418             case DATA_TYPE_DUPLICATE_PROPERTY:
1419                 responseFormat = getResponseFormat(actionStatus, dataType.getName());
1420                 break;
1421             case DATA_TYPE_PROEPRTY_CANNOT_HAVE_SAME_TYPE_OF_DATA_TYPE:
1422                 responseFormat = getResponseFormat(actionStatus, dataType.getName(), properties == null ? "" : String.valueOf(properties));
1423                 break;
1424             case DATA_TYPE_CANNOT_HAVE_PROPERTIES:
1425                 responseFormat = getResponseFormat(actionStatus, dataType.getName());
1426                 break;
1427             case DATA_TYPE_CANNOT_BE_UPDATED_BAD_REQUEST:
1428                 responseFormat = getResponseFormat(actionStatus, dataType.getName());
1429                 break;
1430             default:
1431                 responseFormat = getResponseFormat(actionStatus);
1432                 break;
1433         }
1434         return responseFormat;
1435     }
1436
1437     public StorageOperationStatus convertToStorageOperationStatus(CassandraOperationStatus cassandraStatus) {
1438         StorageOperationStatus result;
1439         switch (cassandraStatus) {
1440             case OK:
1441                 result = StorageOperationStatus.OK;
1442                 break;
1443             case NOT_FOUND:
1444                 result = StorageOperationStatus.NOT_FOUND;
1445                 break;
1446             case CLUSTER_NOT_CONNECTED:
1447             case KEYSPACE_NOT_CONNECTED:
1448                 result = StorageOperationStatus.CONNECTION_FAILURE;
1449                 break;
1450             default:
1451                 result = StorageOperationStatus.GENERAL_ERROR;
1452                 break;
1453         }
1454         return result;
1455     }
1456
1457     public ResponseFormat getResponseFormat(ComponentException exception) {
1458         return exception instanceof ByResponseFormatComponentException ? getResponseFormat((ByResponseFormatComponentException) exception)
1459             : getResponseFormat((ByActionStatusComponentException) exception);
1460     }
1461
1462     public ResponseFormat getResponseFormat(ByResponseFormatComponentException exception) {
1463         return exception.getResponseFormat();
1464     }
1465
1466     public ResponseFormat getResponseFormat(ByActionStatusComponentException exception) {
1467         return getResponseFormat(exception.getActionStatus(), exception.getParams());
1468     }
1469
1470     public ActionStatus convertFromStorageResponseForRelationshipType(StorageOperationStatus storageResponse) {
1471         ActionStatus responseEnum;
1472         switch (storageResponse) {
1473             case OK:
1474                 responseEnum = ActionStatus.OK;
1475                 break;
1476             case CONNECTION_FAILURE:
1477             case GRAPH_IS_LOCK:
1478                 responseEnum = ActionStatus.GENERAL_ERROR;
1479                 break;
1480             case BAD_REQUEST:
1481                 responseEnum = ActionStatus.INVALID_CONTENT;
1482                 break;
1483             case ENTITY_ALREADY_EXISTS:
1484                 responseEnum = ActionStatus.RELATIONSHIP_TYPE_ALREADY_EXIST;
1485                 break;
1486             case SCHEMA_VIOLATION:
1487                 responseEnum = ActionStatus.RELATIONSHIP_TYPE_ALREADY_EXIST;
1488                 break;
1489             default:
1490                 responseEnum = ActionStatus.GENERAL_ERROR;
1491                 break;
1492         }
1493         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
1494         return responseEnum;
1495     }
1496
1497     public ResponseFormat getResponseFormat(StorageException exception) {
1498         ActionStatus status = convertFromStorageResponse(exception.getStorageOperationStatus());
1499         return getResponseFormat(status, exception.getParams());
1500     }
1501
1502     public List<UiLeftPaletteComponent> convertComponentToUiLeftPaletteComponentObject(List<Component> components) {
1503         List<UiLeftPaletteComponent> uiLeftPaletteComponents = new ArrayList<>();
1504         components.forEach(c -> uiLeftPaletteComponents.add(new UiLeftPaletteComponent(c)));
1505         return uiLeftPaletteComponents;
1506     }
1507
1508     public F<StorageOperationStatus, ResponseFormat> toResponseFormat() {
1509         return sos -> getResponseFormat(convertFromStorageResponse(sos));
1510     }
1511
1512     public Optional<UIConstraint> parseToConstraint(final String componentJson, final User user, final ComponentTypeEnum componentTypeEnum) {
1513         final Either<UIConstraint, ResponseFormat> uiConstraintResponseFormatEither = convertJsonToObjectUsingObjectMapper(componentJson, user,
1514             UIConstraint.class, AuditingActionEnum.CREATE_RESOURCE, componentTypeEnum);
1515         if (uiConstraintResponseFormatEither.isRight()) {
1516             return Optional.empty();
1517         }
1518         return Optional.of(uiConstraintResponseFormatEither.left().value());
1519     }
1520
1521     private Either<List, ResponseFormat> parseToConstraints(final String componentJson, final User user, final ComponentTypeEnum componentTypeEnum) {
1522         return convertJsonToObjectUsingObjectMapper(componentJson, user, List.class, AuditingActionEnum.CREATE_RESOURCE, componentTypeEnum);
1523     }
1524
1525     public List<UIConstraint> validateAndParseConstraint(final ComponentTypeEnum componentTypeEnum, final String constraintData,
1526                                                          final User userModifier) {
1527         final String FAILED_TO_PARSE_CONSTRAINT_DATA = "Failed to Parse Constraint Data {}";
1528         final Either<List, ResponseFormat> convertResponse = parseToConstraints(constraintData, userModifier, componentTypeEnum);
1529         if (convertResponse.isRight()) {
1530             log.error(EcompLoggerErrorCode.DATA_ERROR, FAILED_TO_PARSE_CONSTRAINT_DATA, constraintData, convertResponse.right().value());
1531             return Collections.emptyList();
1532         }
1533         final List<Map<String, String>> uiConstraintsMaps = (List<Map<String, String>>) convertResponse.left().value();
1534         if (uiConstraintsMaps == null) {
1535             log.error(EcompLoggerErrorCode.DATA_ERROR, FAILED_TO_PARSE_CONSTRAINT_DATA, constraintData);
1536             return Collections.emptyList();
1537         }
1538         return uiConstraintsMaps.stream().map(dataMap -> new ObjectMapper().convertValue(dataMap, UIConstraint.class))
1539             .collect(Collectors.toList());
1540     }
1541
1542     public Map<String, DataTypeDefinition> getAllDataTypes(final ApplicationDataTypeCache applicationDataTypeCache, final String model) {
1543         final Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = applicationDataTypeCache.getAll(model);
1544         if (allDataTypes.isRight()) {
1545             final var operationStatus = allDataTypes.right().value();
1546             if (operationStatus == JanusGraphOperationStatus.NOT_FOUND) {
1547                 BeEcompErrorManager.getInstance().logInternalDataError("FetchDataTypes", "Data types are not loaded", ErrorSeverity.ERROR);
1548                 throw new ByActionStatusComponentException(ActionStatus.DATA_TYPES_NOT_LOADED, model);
1549             } else {
1550                 BeEcompErrorManager.getInstance().logInternalFlowError("FetchDataTypes", "Failed to fetch data types", ErrorSeverity.ERROR);
1551                 throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
1552             }
1553         }
1554         return allDataTypes.left().value();
1555     }
1556
1557     public ActionStatus convertFromStorageResponseForArtifactType(final StorageOperationStatus storageResponse) {
1558         ActionStatus responseEnum;
1559         switch (storageResponse) {
1560             case OK:
1561                 responseEnum = ActionStatus.OK;
1562                 break;
1563             case CONNECTION_FAILURE:
1564             case GRAPH_IS_LOCK:
1565                 responseEnum = ActionStatus.GENERAL_ERROR;
1566                 break;
1567             case BAD_REQUEST:
1568                 responseEnum = ActionStatus.INVALID_CONTENT;
1569                 break;
1570             case ENTITY_ALREADY_EXISTS:
1571                 responseEnum = ActionStatus.ARTIFACT_TYPE_ALREADY_EXIST;
1572                 break;
1573             case SCHEMA_VIOLATION:
1574                 responseEnum = ActionStatus.ARTIFACT_TYPE_ALREADY_EXIST;
1575                 break;
1576             default:
1577                 responseEnum = ActionStatus.GENERAL_ERROR;
1578                 break;
1579         }
1580         log.debug(CONVERT_STORAGE_RESPONSE_TO_ACTION_RESPONSE, storageResponse, responseEnum);
1581         return responseEnum;
1582     }
1583
1584 }