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