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