catalog-be/src/main/java/org/openecomp/sdc/be/impl/ComponentsUtils.java

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