openecomp-be/tools/zusammen-tools/src/main/java/org/openecomp/core/tools/exportinfo/ExportSerializer.java

   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;
  56                     data = convertByType(vlms, row, i, name, checkForVLM);
  57                     rowData.add(data.toString());
  58                 }
  59                 tableData.rows.add(rowData);
  60             });
  61             ObjectMapper objectMapper = new ObjectMapper();
  62             String fileName = ImportProperties.ROOT_DIRECTORY + File.separator + table + "_" + System.currentTimeMillis() + ".json";
  63             objectMapper.writeValue(Paths.get(fileName).toFile(), tableData);
  64             Utils.printMessage(logger, "File exported is :" + fileName);
  65
  66         } catch (IOException e) {
  67             Utils.logError(logger, e);
  68             System.exit(1);
  69         }
  70     }
  71
  72     private Object convertByType(Set<String> vlms, Row row, int i, Name name, boolean checkForVLM) {
  73         Object data;
  74         switch (name) {
  75             case VARCHAR:
  76             case TEXT:
  77             case ASCII:
  78                 String string = row.getString(i);
  79                 if (string == null) {
  80                     string = "";
  81                 }
  82                 if (checkForVLM && vlms != null){
  83                     String vlm = extractVlm(string);
  84                     if (vlm!= null) {
  85                         vlms.add(vlm);
  86                     }
  87                 }
  88                 data = Base64.getEncoder().encodeToString(string.getBytes());
  89                 break;
  90             case BLOB:
  91                 ByteBuffer bytes = row.getBytes(i);
  92                 if (bytes == null) {
  93                     bytes = ByteBuffer.wrap("".getBytes());
  94                 }
  95                 data = Base64.getEncoder().encodeToString(bytes.array());
  96                 break;
  97             case TIMESTAMP:
  98                 data = row.getDate(i).getTime();
  99                 break;
 100             case BOOLEAN:
 101                 data = row.getBool(i);
 102                 break;
 103             case COUNTER:
 104                 data = row.getLong(i);
 105                 break;
 106             case INT:
 107                 data = row.getInt(i);
 108                 break;
 109             case FLOAT:
 110                 data = row.getFloat(i);
 111                 break;
 112             case SET:
 113                 Set set = row.getSet(i, Object.class);
 114                 Object joined = set.stream().map(o -> o.toString()).collect(Collectors.joining(ExportDataCommand.JOIN_DELIMITER));
 115                 data = Base64.getEncoder().encodeToString(joined.toString().getBytes());
 116                 break;
 117             case MAP:
 118                 Map<Object,Object> map = row.getMap(i, Object.class, Object.class);
 119                 Set<Map.Entry<Object,Object>> entrySet = map.entrySet();
 120                 Object mapAsString = entrySet.parallelStream().map(entry -> entry.getKey().toString() + ExportDataCommand.MAP_DELIMITER +entry.getValue().toString())
 121                         .collect(Collectors.joining(ExportDataCommand.MAP_DELIMITER));
 122                 data = Base64.getEncoder().encodeToString(mapAsString.toString().getBytes());
 123                 break;
 124             default:
 125                 throw new UnsupportedOperationException("Name is not supported :" + name);
 126         }
 127         return data;
 128     }
 129
 130     protected String extractVlm(String injson) {
 131         try {
 132             if (injson == null){
 133                 return null;
 134             }
 135             JsonElement root = new JsonParser().parse(injson);
 136             if (root == null){
 137                 return null;
 138             }
 139             JsonElement properties = root.getAsJsonObject().get("properties");
 140             if (properties == null){
 141                 return null;
 142             }
 143             JsonElement vendorId = properties.getAsJsonObject().get("vendorId");
 144             if (vendorId == null){
 145                 return null;
 146             }
 147             return vendorId.getAsString();
 148         } catch (Exception ex){
 149             return null;
 150         }
 151     }
 152 }