asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/DataMigration.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.asdctool.impl;
  22
  23 import java.io.BufferedReader;
  24 import java.io.BufferedWriter;
  25 import java.io.File;
  26 import java.io.FileReader;
  27 import java.io.FileWriter;
  28 import java.io.IOException;
  29 import java.io.PrintWriter;
  30 import java.lang.reflect.Type;
  31 import java.net.MalformedURLException;
  32 import java.net.URISyntaxException;
  33 import java.net.URL;
  34 import java.nio.file.Files;
  35 import java.nio.file.Paths;
  36 import java.text.ParseException;
  37 import java.text.SimpleDateFormat;
  38 import java.util.Date;
  39 import java.util.EnumMap;
  40 import java.util.Map;
  41 import java.util.TimeZone;
  42
  43 import org.apache.commons.lang.SystemUtils;
  44 import org.elasticsearch.action.search.SearchResponse;
  45 import org.elasticsearch.cluster.metadata.IndexMetaData;
  46 import org.elasticsearch.common.collect.ImmutableOpenMap;
  47 import org.elasticsearch.common.settings.Settings;
  48 import org.elasticsearch.common.unit.TimeValue;
  49 import org.elasticsearch.index.query.QueryBuilder;
  50 import org.elasticsearch.index.query.QueryBuilders;
  51 import org.elasticsearch.search.SearchHit;
  52 import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
  53 import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
  54 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
  55 import org.openecomp.sdc.be.dao.cassandra.schema.Table;
  56 import org.openecomp.sdc.be.dao.es.ElasticSearchClient;
  57 import org.openecomp.sdc.be.resources.data.ESArtifactData;
  58 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  59 import org.openecomp.sdc.be.resources.data.auditing.AuditingGenericEvent;
  60 import org.openecomp.sdc.be.resources.data.auditing.AuditingGetUebClusterEvent;
  61 import org.openecomp.sdc.be.resources.data.auditing.AuditingTypesConstants;
  62 import org.openecomp.sdc.be.resources.data.auditing.AuthEvent;
  63 import org.openecomp.sdc.be.resources.data.auditing.CategoryEvent;
  64 import org.openecomp.sdc.be.resources.data.auditing.ConsumerEvent;
  65 import org.openecomp.sdc.be.resources.data.auditing.DistributionDeployEvent;
  66 import org.openecomp.sdc.be.resources.data.auditing.DistributionDownloadEvent;
  67 import org.openecomp.sdc.be.resources.data.auditing.DistributionEngineEvent;
  68 import org.openecomp.sdc.be.resources.data.auditing.DistributionNotificationEvent;
  69 import org.openecomp.sdc.be.resources.data.auditing.DistributionStatusEvent;
  70 import org.openecomp.sdc.be.resources.data.auditing.GetCategoryHierarchyEvent;
  71 import org.openecomp.sdc.be.resources.data.auditing.GetUsersListEvent;
  72 import org.openecomp.sdc.be.resources.data.auditing.ResourceAdminEvent;
  73 import org.openecomp.sdc.be.resources.data.auditing.UserAccessEvent;
  74 import org.openecomp.sdc.be.resources.data.auditing.UserAdminEvent;
  75 import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
  76 import org.slf4j.Logger;
  77 import org.slf4j.LoggerFactory;
  78 import org.springframework.beans.factory.annotation.Autowired;
  79
  80 import com.carrotsearch.hppc.cursors.ObjectCursor;
  81 import com.fasterxml.jackson.databind.ObjectMapper;
  82 import com.google.gson.Gson;
  83 import com.google.gson.reflect.TypeToken;
  84
  85 import fj.data.Either;
  86
  87 /**
  88  * Created by mlando on 5/16/2016.
  89  */
  90 public class DataMigration {
  91
  92         private Gson gson = new Gson();
  93
  94         private ObjectMapper jsonMapper = new ObjectMapper();
  95
  96         private static Logger log = LoggerFactory.getLogger(DataMigration.class.getName());
  97
  98         protected ElasticSearchClient elasticSearchClient;
  99         @Autowired
 100         protected AuditCassandraDao auditCassandraDao;
 101         @Autowired
 102         protected ArtifactCassandraDao artifactCassandraDao;
 103         private static final String dateFormatPattern = "yyyy-MM-dd HH:mm:ss.SSS z";
 104         private static SimpleDateFormat simpleDateFormat;
 105
 106         /**
 107          * the method exports and imports the records from ES to cassandra the flow
 108          * will check to see if the files are not empty if the files are not empty
 109          * the export will be skiped and the flow will use the existing files. the
 110          * flow will check if the tables in cassandra are empty, if the tables are
 111          * not empty the proces will stop and exit. if the tables are empty the
 112          * method will import the records from the files. in case of a fail the flow
 113          * will exit and clear all the Cassandra tables.
 114          *
 115          * @param appConfigDir
 116          *            the location of the dir in wich the output files will be
 117          *            stored
 118          * @param exportFromEs
 119          *            should the es be exported again and overwrite the old export
 120          * @param importToCassandra
 121          *            should we import the data into cassandra
 122          * @return true in case the operation was successful.
 123          */
 124         public boolean migrateDataESToCassndra(String appConfigDir, boolean exportFromEs, boolean importToCassandra) {
 125                 initFormater();
 126                 if (!initEsClient())
 127                         return false;
 128                 Map<Table, File> files = createOutPutFiles(appConfigDir, exportFromEs);
 129                 if (files == null) {
 130                         return false;
 131                 }
 132                 if (exportFromEs && filesEmpty(files)) {
 133                         Map<Table, PrintWriter> printerWritersMap = createWriters(files);
 134                         if (printerWritersMap == null) {
 135                                 return false;
 136                         }
 137                         try {
 138                                 ImmutableOpenMap<String, IndexMetaData> indexData = getIndexData();
 139                                 for (ObjectCursor<String> key : indexData.keys()) {
 140                                         if ("resources".equalsIgnoreCase(key.value)) {
 141                                                 if (!exportArtifacts(key.value, printerWritersMap)) {
 142                                                         return false;
 143                                                 }
 144                                         } else if (key.value.startsWith("auditingevents")) {
 145                                                 if (!exportAudit(key.value, printerWritersMap)) {
 146                                                         return false;
 147                                                 }
 148                                         }
 149                                 }
 150                         } finally {
 151                                 if (elasticSearchClient != null) {
 152                                         elasticSearchClient.close();
 153                                 }
 154                                 for (PrintWriter writer : printerWritersMap.values()) {
 155                                         writer.close();
 156                                 }
 157                         }
 158                 }
 159                 if (importToCassandra && !importToCassndra(files)) {
 160                         return false;
 161                 }
 162
 163                 return true;
 164         }
 165
 166         private void initFormater() {
 167                 simpleDateFormat = new SimpleDateFormat(dateFormatPattern);
 168                 simpleDateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
 169         }
 170
 171         private boolean initEsClient() {
 172                 String configHome = System.getProperty("config.home");
 173                 URL url = null;
 174                 Settings settings = null;
 175                 try {
 176                         if (SystemUtils.IS_OS_WINDOWS) {
 177                                 url = new URL("file:///" + configHome + "/elasticsearch.yml");
 178                         } else {
 179                                 url = new URL("file:" + configHome + "/elasticsearch.yml");
 180                         }
 181                         log.debug("URL {}", url);
 182                         settings = Settings.settingsBuilder().loadFromPath(Paths.get(url.toURI())).build();
 183                 } catch (MalformedURLException | URISyntaxException e1) {
 184                         log.error("Failed to create URL in order to load elasticsearch yml", e1);
 185                         return true;
 186                 }
 187
 188                 this.elasticSearchClient = new ElasticSearchClient();
 189                 this.elasticSearchClient.setClusterName(settings.get("cluster.name"));
 190                 this.elasticSearchClient.setLocal(settings.get("elasticSearch.local"));
 191                 this.elasticSearchClient.setTransportClient(settings.get("elasticSearch.transportclient"));
 192                 try {
 193                         elasticSearchClient.initialize();
 194                 } catch (URISyntaxException e) {
 195                         e.printStackTrace();
 196                         return false;
 197                 }
 198                 return true;
 199         }
 200
 201         /**
 202          * the method clears all the cassandra tables
 203          */
 204         private void truncateCassandraTable() {
 205                 log.info("import failed. truncating Cassandra tables.");
 206                 artifactCassandraDao.deleteAllArtifacts();
 207                 auditCassandraDao.deleteAllAudit();
 208         }
 209
 210         /**
 211          * the method imports the records from the files into cassandra
 212          *
 213          * @param files
 214          *            a map of files holding
 215          * @return true if the operation was successful
 216          */
 217         private boolean importToCassndra(Map<Table, File> files) {
 218                 log.info("starting to import date into Cassandra.");
 219                 if (!validtaTablsNotEmpty(files))
 220                         return true;
 221                 for (Table table : files.keySet()) {
 222                         log.info("importing recordes into {}", table.getTableDescription().getTableName());
 223                         if (!handleImport(files, table)) {
 224                                 truncateCassandraTable();
 225                                 return false;
 226                         }
 227                 }
 228                 log.info("finished to import date into Cassandra.");
 229                 return true;
 230         }
 231
 232         private boolean validtaTablsNotEmpty(Map<Table, File> files) {
 233                 for (Table table : files.keySet()) {
 234                         Either<Boolean, CassandraOperationStatus> isTableEmptyRes = checkIfTableIsEmpty(table);
 235                         if (isTableEmptyRes.isRight() || !isTableEmptyRes.left().value()) {
 236                                 log.error("Cassandra table {} is not empty operation aborted.",
 237                                                 table.getTableDescription().getTableName());
 238                                 return false;
 239                         }
 240                 }
 241                 return true;
 242         }
 243
 244         /**
 245          * the method retrieves the fields from the given map and praprs them for
 246          * storage as an audit according to the table name
 247          *
 248          * @param map
 249          *            the map from which we will retrive the fields enum values
 250          * @param table
 251          *            the table we are going to store the record in.
 252          * @return a enummap representing the audit record that is going to be
 253          *         created.
 254          */
 255         private EnumMap<AuditingFieldsKeysEnum, Object> createAuditMap(Map<String, String> map, Table table) {
 256                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class);
 257                 switch (table) {
 258                 case USER_ADMIN_EVENT:
 259                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
 260                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
 261                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
 262                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
 263                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
 264                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
 265                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_AFTER, map.get("USER_AFTER"));
 266                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_BEFORE, map.get("USER_BEFORE"));
 267                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
 268                         break;
 269                 case USER_ACCESS_EVENT:
 270                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
 271                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
 272                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
 273                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
 274                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
 275                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
 276                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_UID, map.get("USER"));
 277                         break;
 278                 case RESOURCE_ADMIN_EVENT:
 279                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
 280                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
 281                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
 282                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_INVARIANT_UUID, map.get("INVARIANT_UUID"));
 283                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
 284                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
 285                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
 286                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, map.get("CURR_VERSION"));
 287                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, map.get("CURR_STATE"));
 288                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, map.get("DID"));
 289                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
 290                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_VERSION, map.get("PREV_VERSION"));
 291                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_STATE, map.get("PREV_STATE"));
 292                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, map.get("RESOURCE_NAME"));
 293                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, map.get("RESOURCE_TYPE"));
 294                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_DPREV_STATUS, map.get("DPREV_STATUS"));
 295                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_DCURR_STATUS, map.get("DCURR_STATUS"));
 296                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TOSCA_NODE_TYPE, map.get("TOSCA_NODE_TYPE"));
 297                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_COMMENT, map.get("COMMENT"));
 298                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ARTIFACT_DATA, map.get("ARTIFACT_DATA"));
 299                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_PREV_ARTIFACT_UUID, map.get("PREV_ARTIFACT_UUID"));
 300                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_CURR_ARTIFACT_UUID, map.get("CURR_ARTIFACT_UUID"));
 301                         break;
 302                 case DISTRIBUTION_DOWNLOAD_EVENT:
 303                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
 304                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
 305                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
 306                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
 307                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
 308                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
 309                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_RESOURCE_URL, map.get("RESOURCE_URL"));
 310                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, map.get("CONSUMER_ID"));
 311                         break;
 312                 case DISTRIBUTION_ENGINE_EVENT:
 313                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
 314                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
 315                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
 316                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
 317                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
 318                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
 319                         if (map.get("TOPIC_NAME") != null) {
 320                                 if (map.get("TOPIC_NAME").contains("-STATUS-")) {
 321                                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_STATUS_TOPIC_NAME,
 322                                                         map.get("TOPIC_NAME"));
 323                                 } else {
 324                                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_NOTIFICATION_TOPIC_NAME,
 325                                                         map.get("TOPIC_NAME"));
 326                                 }
 327                         } else {
 328                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_STATUS_TOPIC_NAME,
 329                                                 map.get("DSTATUS_TOPIC"));
 330                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_NOTIFICATION_TOPIC_NAME,
 331                                                 map.get("DNOTIF_TOPIC"));
 332                         }
 333                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TOPIC_NAME, map.get("TOPIC_NAME"));
 334                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ROLE, map.get("ROLE"));
 335                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_API_KEY, map.get("API_KEY"));
 336                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ENVRIONMENT_NAME, map.get("D_ENV"));
 337                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, map.get("CONSUMER_ID"));
 338                         break;
 339                 case DISTRIBUTION_NOTIFICATION_EVENT:
 340                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
 341                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
 342                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
 343                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
 344                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
 345                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
 346                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, map.get("CURR_STATE"));
 347                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, map.get("CURR_VERSION"));
 348                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, map.get("DID"));
 349                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
 350                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, map.get("RESOURCE_NAME"));
 351                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, map.get("RESOURCE_TYPE"));
 352                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TOPIC_NAME, map.get("TOPIC_NAME"));
 353                         break;
 354                 case DISTRIBUTION_STATUS_EVENT:
 355                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
 356                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
 357                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
 358                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
 359                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
 360                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
 361                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_RESOURCE_URL, map.get("RESOURCE_URL"));
 362                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, map.get("DID"));
 363                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TOPIC_NAME, map.get("TOPIC_NAME"));
 364                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, map.get("CONSUMER_ID"));
 365                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_STATUS_TIME, map.get("STATUS_TIME"));
 366                         break;
 367                 case DISTRIBUTION_DEPLOY_EVENT:
 368                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
 369                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
 370                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
 371                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
 372                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
 373                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
 374                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, map.get("DID"));
 375                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, map.get("RESOURCE_NAME"));
 376                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, map.get("RESOURCE_TYPE"));
 377                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
 378                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, map.get("CURR_VERSION"));
 379                         break;
 380                 case DISTRIBUTION_GET_UEB_CLUSTER_EVENT:
 381                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
 382                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
 383                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
 384                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
 385                         if (map.get("STATUS_DESC") != null) {
 386                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("STATUS_DESC"));
 387                         } else {
 388                                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
 389                         }
 390                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
 391                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, map.get("CONSUMER_ID"));
 392                         break;
 393                 case AUTH_EVENT:
 394                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
 395                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
 396                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
 397                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
 398                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
 399                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_USER, map.get("USER"));
 400                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_URL, map.get("URL"));
 401                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_STATUS, map.get("AUTH_STATUS"));
 402                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_REALM, map.get("REALM"));
 403                         break;
 404                 case CONSUMER_EVENT:
 405                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
 406                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
 407                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
 408                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
 409                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
 410                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
 411                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ECOMP_USER, map.get("ECOMP_USER"));
 412                         break;
 413                 case CATEGORY_EVENT:
 414                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
 415                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
 416                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
 417                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
 418                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
 419                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
 420                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
 421                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_CATEGORY_NAME, map.get("CATEGORY_NAME"));
 422                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SUB_CATEGORY_NAME, map.get("SUB_CATEGORY_NAME"));
 423                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_GROUPING_NAME, map.get("GROUPING_NAME"));
 424                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, map.get("RESOURCE_TYPE"));
 425                         break;
 426                 case GET_USERS_LIST_EVENT:
 427                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
 428                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
 429                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
 430                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
 431                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
 432                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
 433                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DETAILS, map.get("DETAILS"));
 434                         break;
 435                 case GET_CATEGORY_HIERARCHY_EVENT:
 436                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
 437                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
 438                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
 439                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
 440                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
 441                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
 442                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DETAILS, map.get("DETAILS"));
 443                         break;
 444                 default:
 445                         auditingFields = null;
 446                         break;
 447                 }
 448                 return auditingFields;
 449         }
 450
 451         /**
 452          * the method reads the content of the file intended for a given table, and
 453          * sores them in cassandra
 454          *
 455          * @param files
 456          *            a map of files from which the recordes will be retrieved.
 457          * @param table
 458          *            the name of the table we want to look up in the files and sore
 459          *            in Cassandra // * @param store the function to call when
 460          *            storing recordes in cassndra
 461          * @return true if the operation was successful
 462          */
 463         private boolean handleImport(Map<Table, File> files, Table table) {
 464                 BufferedReader br = null;
 465                 try {
 466                         br = new BufferedReader(new FileReader(files.get(table)));
 467                         String line = null;
 468                         while ((line = br.readLine()) != null) {
 469                                 CassandraOperationStatus res = null;
 470                                 if (Table.ARTIFACT.equals(table)) {
 471                                         res = artifactCassandraDao.saveArtifact(jsonMapper.readValue(line, ESArtifactData.class));
 472                                 } else {
 473                                         Type type = new TypeToken<Map<String, String>>() {
 474                                         }.getType();
 475                                         Map<String, String> map = gson.fromJson(line, type);
 476                                         EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = createAuditMap(map, table);
 477                                         AuditingGenericEvent recordForCassandra = null;
 478                                         try {
 479                                                 recordForCassandra = createAuditRecord(auditingFields);
 480                                         } catch (ParseException e) {
 481                                                 log.error("filed to parse time stemp in recored {}", auditingFields);
 482                                                 return false;
 483                                         }
 484
 485                                         res = auditCassandraDao.saveRecord(recordForCassandra);
 486                                 }
 487                                 if (!res.equals(CassandraOperationStatus.OK)) {
 488                                         log.error("save recored to cassndra {} failed with status {} aborting.",
 489                                                         table.getTableDescription().getTableName(), res);
 490                                         return false;
 491                                 }
 492                         }
 493                         return true;
 494                 } catch (IOException e) {
 495                         log.error("failed to read file", e);
 496                         return false;
 497                 } finally {
 498                         if (br != null) {
 499                                 try {
 500                                         br.close();
 501                                 } catch (IOException e) {
 502                                         log.error("failed to close file reader", e);
 503                                 }
 504                         }
 505                 }
 506         }
 507
 508         /**
 509          * the method checks if the given table is empty
 510          *
 511          * @param table
 512          *            the name of the table we want to check
 513          * @return true if the table is empty
 514          */
 515         private Either<Boolean, CassandraOperationStatus> checkIfTableIsEmpty(Table table) {
 516                 if (Table.ARTIFACT.equals(table)) {
 517                         return artifactCassandraDao.isTableEmpty(table.getTableDescription().getTableName());
 518                 } else {
 519                         return auditCassandraDao.isTableEmpty(table.getTableDescription().getTableName());
 520                 }
 521         }
 522
 523         private boolean filesEmpty(Map<Table, File> files) {
 524                 for (Table table : files.keySet()) {
 525                         File file = files.get(table);
 526                         if (file.length() != 0) {
 527                                 log.info("file:{} is not empty skipping export", table.getTableDescription().getTableName());
 528                                 return false;
 529                         }
 530                 }
 531                 return true;
 532         }
 533
 534         /**
 535          * the method reads the records from es index of audit's into a file as
 536          * json's.
 537          *
 538          * @param value
 539          *            the name of the index we want
 540          * @param printerWritersMap
 541          *            a map of the writers we use to write to a file.
 542          * @return true in case the export was successful.
 543          */
 544         private boolean exportAudit(String value, Map<Table, PrintWriter> printerWritersMap) {
 545                 log.info("stratng to export audit data from es index{} to file.", value);
 546                 QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
 547                 SearchResponse scrollResp = elasticSearchClient.getClient().prepareSearch(value).setScroll(new TimeValue(60000))
 548                                 .setQuery(queryBuilder).setSize(100).execute().actionGet();
 549                 while (true) {
 550                         for (SearchHit hit : scrollResp.getHits().getHits()) {
 551                                 PrintWriter out = printerWritersMap.get(TypeToTableMapping.getTableByType(hit.getType()));
 552                                 out.println(hit.getSourceAsString());
 553                         }
 554                         scrollResp = elasticSearchClient.getClient().prepareSearchScroll(scrollResp.getScrollId())
 555                                         .setScroll(new TimeValue(60000)).execute().actionGet();
 556                         if (scrollResp.getHits().getHits().length == 0) {
 557                                 break;
 558
 559                         }
 560                 }
 561
 562                 log.info("export audit data from es to file. finished succsesfully");
 563                 return true;
 564         }
 565
 566         /**
 567          * the method reads the records from es index of resources into a file as
 568          * json's.
 569          *
 570          * @param index
 571          *            the name of the index we want to read
 572          * @param printerWritersMap
 573          *            a map of the writers we use to write to a file.
 574          * @return true in case the export was successful.
 575          */
 576         private boolean exportArtifacts(String index, Map<Table, PrintWriter> printerWritersMap) {
 577                 log.info("stratng to export artifact data from es to file.");
 578                 PrintWriter out = printerWritersMap.get(Table.ARTIFACT);
 579                 QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
 580                 SearchResponse scrollResp = elasticSearchClient.getClient().prepareSearch(index).setScroll(new TimeValue(60000))
 581                                 .setQuery(queryBuilder).setSize(100).execute().actionGet();
 582                 while (true) {
 583                         for (SearchHit hit : scrollResp.getHits().getHits()) {
 584                                 ;
 585                                 out.println(hit.getSourceAsString());
 586                         }
 587                         scrollResp = elasticSearchClient.getClient().prepareSearchScroll(scrollResp.getScrollId())
 588                                         .setScroll(new TimeValue(60000)).execute().actionGet();
 589                         if (scrollResp.getHits().getHits().length == 0) {
 590                                 break;
 591
 592                         }
 593                 }
 594
 595                 log.info("export artifact data from es to file. finished succsesfully");
 596                 return true;
 597         }
 598
 599         /**
 600          * the method retrieves all the indexes from elasticsearch
 601          *
 602          * @return a map of indexes and there metadata
 603          */
 604         private ImmutableOpenMap<String, IndexMetaData> getIndexData() {
 605                 return elasticSearchClient.getClient().admin().cluster().prepareState().get().getState().getMetaData()
 606                                 .getIndices();
 607         }
 608
 609         /**
 610          * the method creates all the files and dir which holds them. in case the
 611          * files exist they will not be created again.
 612          *
 613          * @param appConfigDir
 614          *            the base path under which the output dir will be created and
 615          *            the export result files the created filesa are named according
 616          *            to the name of the table into which it will be imported.
 617          * @param exportToEs
 618          *            if true all the export files will be recreated
 619          * @returnthe returns a map of tables and the files representing them them
 620          */
 621         private Map<Table, File> createOutPutFiles(String appConfigDir, boolean exportToEs) {
 622                 Map<Table, File> result = new EnumMap<Table, File>(Table.class);
 623                 File outputDir = new File(appConfigDir + "/output/");
 624                 if (!createOutPutFolder(outputDir)) {
 625                         return null;
 626                 }
 627                 for (Table table : Table.values()) {
 628                         File file = new File(outputDir + "/" + table.getTableDescription().getTableName());
 629                         if (exportToEs) {
 630                                 try {
 631                                         if (file.exists()) {
 632                                                 Files.delete(file.toPath());
 633                                         }
 634                                 } catch (IOException e) {
 635                                         log.error("failed to delete output file {}", file.getAbsolutePath(), e);
 636                                         return null;
 637                                 }
 638                                 file = new File(outputDir + "/" + table.getTableDescription().getTableName());
 639                         }
 640                         if (!file.exists()) {
 641                                 try {
 642                                         file.createNewFile();
 643                                 } catch (IOException e) {
 644                                         log.error("failed to create output file {}", file.getAbsolutePath(), e);
 645                                         return null;
 646                                 }
 647                         }
 648                         result.put(table, file);
 649
 650                 }
 651                 return result;
 652         }
 653
 654         /**
 655          * the method create the writers to each file
 656          *
 657          * @param files
 658          *            a map of the files according to table
 659          * @return returns a map of writers according to table.
 660          */
 661         private Map<Table, PrintWriter> createWriters(Map<Table, File> files) {
 662                 Map<Table, PrintWriter> printerWritersMap = new EnumMap<>(Table.class);
 663                 try {
 664                         for (Table table : files.keySet()) {
 665                                 log.info("creating writer for {}", table);
 666                                 File file = files.get(table);
 667                                 FileWriter fw = new FileWriter(file, true);
 668                                 BufferedWriter bw = new BufferedWriter(fw);
 669                                 PrintWriter out = new PrintWriter(bw);
 670                                 printerWritersMap.put(table, out);
 671                                 log.info("creating writer for {} was successful", table);
 672                         }
 673                 } catch (IOException e) {
 674                         log.error("create writer to file failed", e);
 675                         return null;
 676                 }
 677                 return printerWritersMap;
 678         }
 679
 680         /**
 681          * the method creates the output dir in case it does not exist
 682          *
 683          * @param outputDir
 684          *            the path under wich the directory will be created.
 685          * @return true in case the create was succsesful or the dir already exists
 686          */
 687         private boolean createOutPutFolder(File outputDir) {
 688                 if (!outputDir.exists()) {
 689                         log.info("creating output dir {}", outputDir.getAbsolutePath());
 690                         try {
 691                                 Files.createDirectories(outputDir.toPath());
 692                         } catch (IOException e) {
 693                                 log.error("failed to create output dir {}", outputDir.getAbsolutePath(), e);
 694                                 return false;
 695                         }
 696                 }
 697                 return true;
 698         }
 699
 700         public enum TypeToTableMapping {
 701                 USER_ADMIN_EVENT_TYPE(AuditingTypesConstants.USER_ADMIN_EVENT_TYPE,
 702                                 Table.USER_ADMIN_EVENT), USER_ACCESS_EVENT_TYPE(AuditingTypesConstants.USER_ACCESS_EVENT_TYPE,
 703                                                 Table.USER_ACCESS_EVENT), RESOURCE_ADMIN_EVENT_TYPE(
 704                                                                 AuditingTypesConstants.RESOURCE_ADMIN_EVENT_TYPE,
 705                                                                 Table.RESOURCE_ADMIN_EVENT), DISTRIBUTION_DOWNLOAD_EVENT_TYPE(
 706                                                                                 AuditingTypesConstants.DISTRIBUTION_DOWNLOAD_EVENT_TYPE,
 707                                                                                 Table.DISTRIBUTION_DOWNLOAD_EVENT), DISTRIBUTION_ENGINE_EVENT_TYPE(
 708                                                                                                 AuditingTypesConstants.DISTRIBUTION_ENGINE_EVENT_TYPE,
 709                                                                                                 Table.DISTRIBUTION_ENGINE_EVENT), DISTRIBUTION_NOTIFICATION_EVENT_TYPE(
 710                                                                                                                 AuditingTypesConstants.DISTRIBUTION_NOTIFICATION_EVENT_TYPE,
 711                                                                                                                 Table.DISTRIBUTION_NOTIFICATION_EVENT), DISTRIBUTION_STATUS_EVENT_TYPE(
 712                                                                                                                                 AuditingTypesConstants.DISTRIBUTION_STATUS_EVENT_TYPE,
 713                                                                                                                                 Table.DISTRIBUTION_STATUS_EVENT), DISTRIBUTION_DEPLOY_EVENT_TYPE(
 714                                                                                                                                                 AuditingTypesConstants.DISTRIBUTION_DEPLOY_EVENT_TYPE,
 715                                                                                                                                                 Table.DISTRIBUTION_DEPLOY_EVENT), DISTRIBUTION_GET_UEB_CLUSTER_EVENT_TYPE(
 716                                                                                                                                                                 AuditingTypesConstants.DISTRIBUTION_GET_UEB_CLUSTER_EVENT_TYPE,
 717                                                                                                                                                                 Table.DISTRIBUTION_GET_UEB_CLUSTER_EVENT), AUTH_EVENT_TYPE(
 718                                                                                                                                                                                 AuditingTypesConstants.AUTH_EVENT_TYPE,
 719                                                                                                                                                                                 Table.AUTH_EVENT), CONSUMER_EVENT_TYPE(
 720                                                                                                                                                                                                 AuditingTypesConstants.CONSUMER_EVENT_TYPE,
 721                                                                                                                                                                                                 Table.CONSUMER_EVENT), CATEGORY_EVENT_TYPE(
 722                                                                                                                                                                                                                 AuditingTypesConstants.CATEGORY_EVENT_TYPE,
 723                                                                                                                                                                                                                 Table.CATEGORY_EVENT), GET_USERS_LIST_EVENT_TYPE(
 724                                                                                                                                                                                                                                 AuditingTypesConstants.GET_USERS_LIST_EVENT_TYPE,
 725                                                                                                                                                                                                                                 Table.GET_USERS_LIST_EVENT), GET_CATEGORY_HIERARCHY_EVENT_TYPE(
 726                                                                                                                                                                                                                                                 AuditingTypesConstants.GET_CATEGORY_HIERARCHY_EVENT_TYPE,
 727                                                                                                                                                                                                                                                 Table.GET_CATEGORY_HIERARCHY_EVENT);
 728
 729                 String typeName;
 730                 Table table;
 731
 732                 TypeToTableMapping(String typeName, Table table) {
 733                         this.typeName = typeName;
 734                         this.table = table;
 735                 }
 736
 737                 public String getTypeName() {
 738                         return typeName;
 739                 }
 740
 741                 public Table getTable() {
 742                         return table;
 743                 }
 744
 745                 public static Table getTableByType(String type) {
 746                         for (TypeToTableMapping mapping : TypeToTableMapping.values()) {
 747                                 if (mapping.getTypeName().equalsIgnoreCase(type)) {
 748                                         return mapping.getTable();
 749                                 }
 750                         }
 751                         return null;
 752                 }
 753         }
 754
 755         public static AuditingGenericEvent createAuditRecord(EnumMap<AuditingFieldsKeysEnum, Object> auditingFields)
 756                         throws ParseException {
 757                 AuditingActionEnum actionEnum = AuditingActionEnum
 758                                 .getActionByName((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_ACTION));
 759                 String tableName = actionEnum.getAuditingEsType();
 760                 AuditingGenericEvent event = null;
 761                 Date date = null;
 762                 switch (tableName) {
 763                 case AuditingTypesConstants.USER_ADMIN_EVENT_TYPE:
 764                         UserAdminEvent userAdminEvent = new UserAdminEvent(auditingFields);
 765                         date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
 766                         userAdminEvent.setTimestamp1(date);
 767                         event = userAdminEvent;
 768                         break;
 769                 case AuditingTypesConstants.AUTH_EVENT_TYPE:
 770                         AuthEvent authEvent = new AuthEvent(auditingFields);
 771                         date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
 772                         authEvent.setTimestamp1(date);
 773                         event = authEvent;
 774                         break;
 775                 case AuditingTypesConstants.CATEGORY_EVENT_TYPE:
 776                         CategoryEvent categoryEvent = new CategoryEvent(auditingFields);
 777                         date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
 778                         categoryEvent.setTimestamp1(date);
 779                         event = categoryEvent;
 780                         break;
 781                 case AuditingTypesConstants.RESOURCE_ADMIN_EVENT_TYPE:
 782                         ResourceAdminEvent resourceAdminEvent = new ResourceAdminEvent(auditingFields);
 783                         date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
 784                         resourceAdminEvent.setTimestamp1(date);
 785                         event = resourceAdminEvent;
 786                         break;
 787                 case AuditingTypesConstants.USER_ACCESS_EVENT_TYPE:
 788                         event = new UserAccessEvent(auditingFields);
 789                         UserAccessEvent userAccessEvent = new UserAccessEvent(auditingFields);
 790                         date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
 791                         userAccessEvent.setTimestamp1(date);
 792                         event = userAccessEvent;
 793                         break;
 794                 case AuditingTypesConstants.DISTRIBUTION_STATUS_EVENT_TYPE:
 795                         DistributionStatusEvent distributionStatusEvent = new DistributionStatusEvent(auditingFields);
 796                         date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
 797                         distributionStatusEvent.setTimestamp1(date);
 798                         event = distributionStatusEvent;
 799                         break;
 800                 case AuditingTypesConstants.DISTRIBUTION_DOWNLOAD_EVENT_TYPE:
 801                         DistributionDownloadEvent distributionDownloadEvent = new DistributionDownloadEvent(auditingFields);
 802                         date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
 803                         distributionDownloadEvent.setTimestamp1(date);
 804                         event = distributionDownloadEvent;
 805                         break;
 806                 case AuditingTypesConstants.DISTRIBUTION_ENGINE_EVENT_TYPE:
 807                         DistributionEngineEvent distributionEngineEvent = new DistributionEngineEvent(auditingFields);
 808                         date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
 809                         distributionEngineEvent.setTimestamp1(date);
 810                         event = distributionEngineEvent;
 811                         break;
 812                 case AuditingTypesConstants.DISTRIBUTION_NOTIFICATION_EVENT_TYPE:
 813                         DistributionNotificationEvent distributionNotificationEvent = new DistributionNotificationEvent(
 814                                         auditingFields);
 815                         date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
 816                         distributionNotificationEvent.setTimestamp1(date);
 817                         event = distributionNotificationEvent;
 818                         break;
 819                 case AuditingTypesConstants.DISTRIBUTION_DEPLOY_EVENT_TYPE:
 820                         DistributionDeployEvent distributionDeployEvent = new DistributionDeployEvent(auditingFields);
 821                         date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
 822                         distributionDeployEvent.setTimestamp1(date);
 823                         event = distributionDeployEvent;
 824                         break;
 825                 case AuditingTypesConstants.DISTRIBUTION_GET_UEB_CLUSTER_EVENT_TYPE:
 826                         AuditingGetUebClusterEvent auditingGetUebClusterEvent = new AuditingGetUebClusterEvent(auditingFields);
 827                         date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
 828                         auditingGetUebClusterEvent.setTimestamp1(date);
 829                         event = auditingGetUebClusterEvent;
 830                         break;
 831                 case AuditingTypesConstants.CONSUMER_EVENT_TYPE:
 832                         ConsumerEvent consumerEvent = new ConsumerEvent(auditingFields);
 833                         date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
 834                         consumerEvent.setTimestamp1(date);
 835                         event = consumerEvent;
 836                         break;
 837                 case AuditingTypesConstants.GET_USERS_LIST_EVENT_TYPE:
 838                         GetUsersListEvent getUsersListEvent = new GetUsersListEvent(auditingFields);
 839                         date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
 840                         getUsersListEvent.setTimestamp1(date);
 841                         event = getUsersListEvent;
 842                         break;
 843                 case AuditingTypesConstants.GET_CATEGORY_HIERARCHY_EVENT_TYPE:
 844                         GetCategoryHierarchyEvent getCategoryHierarchyEvent = new GetCategoryHierarchyEvent(auditingFields);
 845                         date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
 846                         getCategoryHierarchyEvent.setTimestamp1(date);
 847                         event = getCategoryHierarchyEvent;
 848                         break;
 849
 850                 }
 851                 return event;
 852         }
 853
 854 }