ViewportResultsJsonCsvWriter.java example

Explorer
OG-Platform-master
- projects
- sesame
/**
 * Copyright (C) 2012 - present by OpenGamma Inc. and the OpenGamma group of companies
 *
 * Please see distribution for license.
 */
package com.opengamma.web.analytics;

import static com.opengamma.web.analytics.formatting.DataType.UNKNOWN;

import java.io.StringWriter;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.List;
import java.util.Map;

import org.json.JSONObject;

import au.com.bytecode.opencsv.CSVWriter;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.opengamma.engine.ComputationTargetSpecification;
import com.opengamma.engine.calcnode.MissingValue;
import com.opengamma.engine.value.ValueSpecification;
import com.opengamma.engine.view.AggregatedExecutionLog;
import com.opengamma.engine.view.ExecutionLog;
import com.opengamma.engine.view.ExecutionLogWithContext;
import com.opengamma.util.log.LogEvent;
import com.opengamma.util.log.LogLevel;
import com.opengamma.web.analytics.formatting.DataType;
import com.opengamma.web.analytics.formatting.ResultsFormatter;
import com.opengamma.web.analytics.formatting.TypeFormatter;
import com.opengamma.web.server.conversion.DoubleValueOptionalDecimalPlaceFormatter;

/**
 * Creates a JSON/CSV object from an instance of {@link ViewportResults}.
 */
public class ViewportResultsJsonCsvWriter {

  private static final String VERSION = "version";
  private static final String VALUE = "v";
  private static final String HISTORY = "h";
  private static final String TYPE = "t";
  private static final String DATA = "data";
  private static final String ERROR = "error";
  private static final String CALCULATION_DURATION = "calculationDuration";
  private static final String LOG_LEVEL = "logLevel";
  private static final String LOG_OUTPUT = "logOutput";
  private static final String EXCEPTION_CLASS = "exceptionClass";
  private static final String EXCEPTION_MESSAGE = "exceptionMessage";
  private static final String EXCEPTION_STACK_TRACE = "exceptionStackTrace";
  private static final String EVENTS = "events";
  private static final String LEVEL = "level";
  private static final String MESSAGE = "message";
  private static final String FUNCTION_NAME = "functionName";
  private static final String TARGET = "target";

  private final ResultsFormatter _formatter;
  private final DoubleValueOptionalDecimalPlaceFormatter _durationFormatter = new DoubleValueOptionalDecimalPlaceFormatter();

  public ViewportResultsJsonCsvWriter(ResultsFormatter formatter) {
    _formatter = formatter;
  }
  
  public String getCsv(ViewportResults viewportResults) {
    GridColumnGroups columnGroups = viewportResults.getColumns();
    String[] header1 = new String[columnGroups.getGroups().size()];
    String[] header2 = new String[columnGroups.getColumnCount()];
    
    int index = 0;
    for (GridColumnGroup gridColumnGroup : columnGroups.getGroups()) {
      header1[index++] = gridColumnGroup.getName();
    }
    
    List<GridColumn> columns = columnGroups.getColumns();
    index = 0;
    for (GridColumn gridColumn : columns) {
      header2[index++] = gridColumn.getHeader();
    }
    
    StringWriter stringWriter = new StringWriter();
    @SuppressWarnings("resource")
    CSVWriter csvWriter = new CSVWriter(stringWriter);
    
    csvWriter.writeNext(header1);
    csvWriter.writeNext(header2);
    
    List<ResultsCell> viewportCells = viewportResults.getResults();
    Iterable<List<ResultsCell>> results = Iterables.partition(viewportCells, columnGroups.getColumnCount());
    for (List<ResultsCell> row : results) {
      String[] rowArray = new String[row.size()];
      int col = 0;
      for (ResultsCell cell : row) {
        Object cellValue = cell.getValue();
        if (cellValue instanceof RowTarget) {
          rowArray[col++] = ((RowTarget) cellValue).getName();
          continue;
        }
        
        ValueSpecification cellValueSpec = cell.getValueSpecification();
        Object formattedValue = _formatter.format(cellValue, cellValueSpec, cell.getFormat(), cell.getInlineKey());
        if (formattedValue instanceof String) {
          rowArray[col++] = (String) formattedValue;
        } else {
          rowArray[col++] = formattedValue.toString();
        }
      }
      csvWriter.writeNext(rowArray);
    }
    return stringWriter.toString();
  }

  // TODO use a Freemarker template - will that perform well enough?
  public String getJson(ViewportResults viewportResults) {
    List<ResultsCell> viewportCells = viewportResults.getResults();
    List<Object> results = Lists.newArrayListWithCapacity(viewportCells.size());
    for (ResultsCell cell : viewportCells) {
      Object cellValue = cell.getValue();
      ValueSpecification cellValueSpec = cell.getValueSpecification();
      Object formattedValue = _formatter.format(cellValue, cellValueSpec, cell.getFormat(), cell.getInlineKey());
      Collection<Object> history = cell.getHistory();
      Class<?> columnType = cell.getType();
      DataType columnFormat = _formatter.getDataType(columnType);
      Map<String, Object> valueMap = Maps.newHashMap();
      AggregatedExecutionLog executionLog = cell.getExecutionLog();
      LogLevel logLevel = maxLogLevel(executionLog);

      valueMap.put(VALUE, formattedValue);
      if (columnFormat == UNKNOWN) {
        // if the the column type isn't known then send the type with the value
        valueMap.put(TYPE, _formatter.getDataTypeForValue(cellValue, cellValueSpec).name());
      }
      if (history != null) {
        List<Object> formattedHistoy = formatHistory(cellValueSpec, cell.getInlineKey(), history);
        if (formattedHistoy != null) {
          valueMap.put(HISTORY, formattedHistoy);
        }
      }
      if (cell.isError() || isError(formattedValue)) {
        valueMap.put(ERROR, true);
      }
      if (logLevel != null) {
        valueMap.put(LOG_LEVEL, logLevel);
      }
      if (hasLogOutput(executionLog)) {
        valueMap.put(LOG_OUTPUT, formatLogOutput(executionLog));
      }
      results.add(valueMap);
    }
    String duration = _durationFormatter.format(new BigDecimal(viewportResults.getCalculationDuration().toMillis()));
    ImmutableMap<String, Object> resultsMap = ImmutableMap.of(VERSION, viewportResults.getVersion(),
                                                              CALCULATION_DURATION, duration,
                                                              DATA, results);
    return new JSONObject(resultsMap).toString();
  }

  private static boolean isError(Object value) {
    return value instanceof MissingValue;
  }

  private static LogLevel maxLogLevel(AggregatedExecutionLog log) {
    if (log == null) {
      return null;
    }
    EnumSet<LogLevel> logLevels = log.getLogLevels();
    if (logLevels.isEmpty()) {
      return null;
    }
    List<LogLevel> logLevelList = Lists.newArrayList(logLevels);
    Collections.sort(logLevelList);
    return logLevelList.get(logLevelList.size() - 1);
  }

  private static boolean hasLogOutput(AggregatedExecutionLog aggregatedLog) {
    return aggregatedLog != null && aggregatedLog.getLogs() != null && !aggregatedLog.getLogs().isEmpty();
  }

  private static List<Map<String, Object>> formatLogOutput(AggregatedExecutionLog aggregatedLog) {
    List<Map<String, Object>> output = Lists.newArrayList();
    for (ExecutionLogWithContext logWithContext : aggregatedLog.getLogs()) {
      Map<String, Object> logMap = Maps.newHashMap();
      ComputationTargetSpecification target = logWithContext.getTargetSpecification();
      logMap.put(FUNCTION_NAME, logWithContext.getFunctionName());
      logMap.put(TARGET, target.getType() + " " + target.getUniqueId());
      ExecutionLog log = logWithContext.getExecutionLog();
      if (log.hasException()) {
        logMap.put(EXCEPTION_CLASS, log.getExceptionClass());
        logMap.put(EXCEPTION_MESSAGE, log.getExceptionMessage());
        logMap.put(EXCEPTION_STACK_TRACE, log.getExceptionStackTrace());
      }
      List<Map<String, Object>> events = Lists.newArrayList();
      logMap.put(EVENTS, events);
      if (log.getEvents() != null) {
        for (LogEvent logEvent : log.getEvents()) {
          events.add(ImmutableMap.<String, Object>of(LEVEL, logEvent.getLevel(), MESSAGE, logEvent.getMessage()));
        }
      }
      output.add(logMap);
    }
    return output;
  }

  /**
   * Formats history data as a JSON list.
   *
   * @param cellValueSpec The cell's value specification, can be null
   * @param inlineKey If the cell contains a single value derived from an inlined value, this object is the key
   * to obtain the cell's value from the underlying value.
   *@param history The history values, not null  @return The formatted history
   */
  private List<Object> formatHistory(ValueSpecification cellValueSpec, Object inlineKey, Collection<Object> history) {
    List<Object> formattedHistory = Lists.newArrayListWithCapacity(history.size());
    for (Object historyValue : history) {
      Object formattedValue = _formatter.format(historyValue, cellValueSpec, TypeFormatter.Format.HISTORY, inlineKey);
      if (formattedValue != ResultsFormatter.VALUE_UNAVAILABLE) {
        formattedHistory.add(formattedValue);
      }
    }
    // it's possible for an object to have history but not to have any formatted history if it's inlined. some inline
    // keys won't have a value for some inlined results. in that case the cell will have empty history although
    // there is history for the underlying value
    if (formattedHistory.isEmpty()) {
      return null;
    } else {
      return formattedHistory;
    }
  }
}