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