ReportBody.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2020 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package org.turro.financials.report;
 
import java.io.File;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.TreeSet;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Stream;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.db.WhereClause;
import org.turro.elephant.impl.util.FileUtil;
import org.turro.financials.db.FinancialsPU;
import org.turro.financials.entity.RegisterEntry;
import org.turro.reflection.JSONSerializer;
 
public class ReportBody {
  
  private String name;
  private TreeSet<ReportRow> rows;
  private TreeSet<ReportColumn> columns;
  private transient HashMap<String, Double> values;
  private transient HashMap<String, HashMap<String, Double>> sum;
  private transient File file;
 
  public ReportBody(String name) {
    this.name = name;
  }
 
  public String getName() {
    return name;
  }
 
  public TreeSet<ReportRow> getRows() {
    if(rows == null) rows = new TreeSet<>();
    return rows;
  }
 
  public TreeSet<ReportColumn> getColumns() {
    if(columns == null) columns = new TreeSet<>();
    return columns;
  }
  
  public Double getValue(ReportRow row, ReportColumn column) {
    if(values != null) {
      Double accumulate = values.get(generateKey(row, column));
      if(accumulate != null) {
        return formatAndAddSum(row, column, accumulate);
      }
    }
    return 0.0;
  }
 
  public Double getSum(ReportRow row, ReportColumn column, String group) {
    if(sum != null) {
      Double total = sum.get(group).get(generateKey(null, column));
      sum.get(group).put(generateKey(null, column), 0.0);
      if(total != null) {
        return row.isNegate() ? -total : total;
      }
    }
    return 0.0;
  }
 
  public File getFile() {
    return file;
  }
  
  public void fill(Date start, Date end) {
    if(values != null) values.clear();
    if(sum != null) sum.clear();
    WhereClause wc = new WhereClause();
    wc.addClause("select e from RegisterEntry e");
    wc.addClause("where e.register.registerDate >= :start");
    wc.addClause("and e.register.registerDate <= :end");
    wc.addNamedValue("start", start);
    wc.addNamedValue("end", end);
    try(Stream<RegisterEntry> entries = new FinancialsPU().stream(RegisterEntry.class, wc)) {
      entries.forEach((e) -> {
        addEntry(e);
      });
    }
    // Generate sum groups
    if(sum == null) sum = new HashMap<>();
    for(ReportRow row : getRows()) {
      if(row.isSum()) {
        sum.put(row.getGroup(), new HashMap<>());
      }
    }
  }
  
  public boolean hasValues() {
    return values != null && !values.isEmpty();
  }
  
  private void setFile(File file) {
    this.file = file;
  }
 
  private void addEntry(RegisterEntry e) {
    rows.forEach((row) -> {
      if(!row.isSum() && row.check(e)) {
        columns.forEach((column) -> {
          if(column.check(e)) {
            addValue(e, row, column);
          }
        });
      }
    });
  }
  
  private String generateKey(ReportRow row, ReportColumn column) {
    return row == null ? "" + column.hashCode() : row.hashCode() + "|" + column.hashCode();
  }
    
  private void addValue(RegisterEntry e, ReportRow row, ReportColumn column) {
    if(values == null) values = new HashMap<>();
    double value = 0.0;
    switch(row.getSumType()) {
      case BALANCE:
        value = e.getDebit() - e.getCredit();
        break;
      case DEBIT:
        value = e.getDebit();
        break;
      case CREDIT:
        value = e.getCredit();
        break;
    }
    Double accumulate = values.get(generateKey(row, column));
    if(accumulate == null) {
      accumulate = value;
    } else {
      accumulate += value;
    }
    values.put(generateKey(row, column), accumulate);
  }
 
  private Double formatAndAddSum(ReportRow row, ReportColumn column, Double value) {
    value = row.isNegate() ? -value : value;
    for(HashMap<String, Double> sm : sum.values()) {
      Double total = sm.get(generateKey(null, column));
      if(total == null) {
        total = value;
      } else {
        total += value;
      }
      sm.put(generateKey(null, column), total);
    }
    return value;
  }
 
  /* Report Elements */
  
  private static final String dveRoot = "/WEB-INF/elephant/reports/financials";
 
  public static List<ReportBody> reports() {
    File root = new File(ElephantContext.getRealPath(dveRoot));
    root.mkdirs();
    List<ReportBody> reports = new ArrayList<>();
    for(File file : root.listFiles()) {
      if(file.isFile() && !file.isHidden()) {
        reports.add(ReportBody.load(file));
      }
    }
    return reports;
  }
  
  public static ReportBody load(File file) {
    ReportBody body = null;
    if(file != null) {
      try {
          JSONSerializer ser = new JSONSerializer(true);
          body = ser.fromJson(FileUtil.getContent(file), ReportBody.class);
          body.setFile(file);
      } catch (IOException ex) {
        Logger.getLogger(ReportBody.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    }
    if(body == null) {
      body = new ReportBody("Test report");
      setTest(body);
      ReportBody.save(body, "test");
    }
    return body;
  }
  
  private static void save(ReportBody body, String name) {
    try (Writer writer = FileUtil.getFileWriter(fileName(name))) {
      JSONSerializer ser = new JSONSerializer(body, true);
      writer.write(ser.toJson());
    } catch (IOException ex) {
      Logger.getLogger(ReportBody.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
  }
  
  private static String fileName(String name) {
    return ElephantContext.getRealPath(dveRoot) + "/" + name + ".json";
  }
  
  /* Defaults */
  
  private static void setTest(ReportBody body) {
    ReportRow row = new ReportRow(0, "Test row", new String[] {"[67].*"}, ReportSumType.BALANCE, false);
    body.getRows().add(row);
    ReportColumn column = new ReportColumn(0, "Test column", new String[] {".*"});
    body.getColumns().add(column);
  }
 
}