gerrit.onap Code Review - sdc.git/blob

   1 /**
   2  * Copyright © 2016-2017 European Support Limited.
   3  */
   4 package org.openecomp.core.tools.exportinfo;
   5
   6 import static org.openecomp.core.tools.exportinfo.ExportDataCommand.NULL_REPRESENTATION;
   7 import static org.openecomp.core.tools.importinfo.ImportSingleTable.dataTypesMap;
   8
   9 import com.datastax.driver.core.DataType.Name;
  10 import com.datastax.driver.core.ResultSet;
  11 import com.datastax.driver.core.Row;
  12 import com.google.gson.JsonElement;
  13 import com.google.gson.JsonParser;
  14 import com.google.gson.JsonSyntaxException;
  15 import java.io.File;
  16 import java.io.IOException;
  17 import java.nio.ByteBuffer;
  18 import java.nio.file.Paths;
  19 import java.util.*;
  20 import java.util.stream.Collectors;
  21 import org.apache.commons.lang3.StringUtils;
  22 import org.codehaus.jackson.map.ObjectMapper;
  23 import org.openecomp.core.tools.importinfo.ImportProperties;
  24 import org.openecomp.core.tools.model.ColumnDefinition;
  25 import org.openecomp.core.tools.model.TableData;
  26 import org.openecomp.core.tools.util.Utils;
  27 import org.openecomp.sdc.logging.api.Logger;
  28 import org.openecomp.sdc.logging.api.LoggerFactory;
  29
  30 public class ExportSerializer {
  31
  32     private static final Logger logger = LoggerFactory.getLogger(ExportSerializer.class);
  33     private static final String ELEMENT_TABLE_NAME = "element";
  34     private static final String ELEMENT_INFO_COLUMN_NAME = "info";
  35
  36
  37     public void serializeResult(final ResultSet resultSet, final Set<String> filteredItems, final String filteredColumn, Set<String> vlms) {
  38         try {
  39             TableData tableData = new TableData();
  40             tableData.definitions = resultSet.getColumnDefinitions().asList().stream().map(ColumnDefinition::new).collect(Collectors.toList());
  41             String table = tableData.definitions.iterator().next().getTable();
  42             boolean isElementTable = table.equals(ELEMENT_TABLE_NAME);
  43             Iterator<Row> iterator = resultSet.iterator();
  44             iterator.forEachRemaining(row -> {
  45                 if (!filteredItems.contains(row.getString(filteredColumn))) {
  46                     return;
  47                 }
  48                 List<String> rowData = new ArrayList<>();
  49                 for (int i = 0; i < tableData.definitions.size(); i++) {
  50                     ColumnDefinition columnDefinition = tableData.definitions.get(i);
  51                     Name name = dataTypesMap.get(columnDefinition.getType());
  52                     boolean checkForVLM = isElementTable && columnDefinition.getName().equals(ELEMENT_INFO_COLUMN_NAME);
  53                     Object data = convertByType(vlms, row, i, name, checkForVLM);
  54                     rowData.add(data.toString());
  55                 }
  56                 tableData.rows.add(rowData);
  57             });
  58             ObjectMapper objectMapper = new ObjectMapper();
  59             String fileName = ImportProperties.ROOT_DIRECTORY + File.separator + table + "_" + System.currentTimeMillis() + ".json";
  60             objectMapper.writeValue(Paths.get(fileName).toFile(), tableData);
  61             Utils.printMessage(logger, "File exported is :" + fileName);
  62
  63         } catch (IOException e) {
  64             Utils.logError(logger, e);
  65             System.exit(1);
  66         }
  67     }
  68
  69     private Object convertByType(Set<String> vlms, Row row, int i, Name name, boolean checkForVLM) {
  70         Object data;
  71         switch (name) {
  72             case VARCHAR:
  73             case TEXT:
  74             case ASCII:
  75                 String string = row.getString(i);
  76                 if (string == null) {
  77                     string = NULL_REPRESENTATION;
  78                 }
  79                 if (checkForVLM && vlms != null) {
  80                     String vlm = extractVlm(string);
  81                     if (vlm != null) {
  82                         vlms.add(vlm);
  83                     }
  84                 }
  85                 data = Base64.getEncoder().encodeToString(string.getBytes());
  86                 break;
  87             case BLOB:
  88                 ByteBuffer bytes = row.getBytes(i);
  89                 if (bytes == null) {
  90                     bytes = ByteBuffer.wrap("".getBytes());
  91                 }
  92                 data = Base64.getEncoder().encodeToString(bytes.array());
  93                 break;
  94             case TIMESTAMP:
  95                 Date rowDate = row.getTimestamp(i);
  96                 if (rowDate != null) {
  97                     data = rowDate.getTime();
  98                 } else {
  99                     data = "";
 100                 }
 101                 break;
 102             case BOOLEAN:
 103                 data = row.getBool(i);
 104                 break;
 105             case COUNTER:
 106                 data = row.getLong(i);
 107                 break;
 108             case INT:
 109                 data = row.getInt(i);
 110                 break;
 111             case FLOAT:
 112                 data = row.getFloat(i);
 113                 break;
 114             case SET:
 115                 Set<Object> set = (Set<Object>) row.getObject(i);
 116                 Object joined = set.stream().map(Object::toString).collect(Collectors.joining(ExportDataCommand.JOIN_DELIMITER));
 117                 data = Base64.getEncoder().encodeToString(joined.toString().getBytes());
 118                 break;
 119             case MAP:
 120                 Map<Object, Object> map = (Map<Object, Object>) row.getObject(i);
 121                 Set<Map.Entry<Object, Object>> entrySet = map.entrySet();
 122                 Object mapAsString = entrySet.parallelStream().map(entry -> entry.getKey().toString() + ExportDataCommand.MAP_DELIMITER + entry.getValue().toString())
 123                         .collect(Collectors.joining(ExportDataCommand.JOIN_DELIMITER));
 124                 data = Base64.getEncoder().encodeToString(mapAsString.toString().getBytes());
 125                 break;
 126             default:
 127                 throw new UnsupportedOperationException("Name is not supported :" + name);
 128         }
 129         return data;
 130     }
 131
 132     protected String extractVlm(String inJson) {
 133         if (StringUtils.isEmpty(inJson.trim())) {
 134             return null;
 135         }
 136         JsonElement root;
 137         try {
 138             root = new JsonParser().parse(inJson);
 139         } catch (JsonSyntaxException e) {
 140             Utils.logError(logger, "Failed to parse json " + inJson, e);
 141             return null;
 142         }
 143         if (root == null) {
 144             return null;
 145         }
 146         JsonElement properties = root.getAsJsonObject().get("properties");
 147         if (properties == null) {
 148             return null;
 149         }
 150         JsonElement vendorId = properties.getAsJsonObject().get("vendorId");
 151         if (vendorId == null) {
 152             return null;
 153         }
 154         return vendorId.getAsString();
 155     }
 156 }