Statistics.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.indicator;
 
import java.util.List;
import java.util.function.Consumer;
import org.turro.string.Strings;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.db.WhereClause;
import org.turro.jpa.Dao;
import org.turro.jpa.search.DaoHtmlSearch;
import org.turro.jpa.search.DaoSearchKey;
import org.turro.matching.Matchings;
import org.turro.plugin.contacts.IContact;
import org.turro.ranking.Rankings;
 
public class Statistics {
 
  private final IConstructor constructor;
  private final String rankingInstance, matchingInstance;
  private final WhereClause wc;
  private String entityRoot, entityId, defaultSorting;
  private IContact contact;
  private Consumer<WhereClause> onCriteria;
  private boolean allowMatching, allowRanking;
  private boolean doMatching = false;
  private String sortOrder = "*";
  private boolean useDaoSearch = true;
  
  public Statistics setEntityFields(String root, String id) {
    entityRoot = root;
    entityId = id;
    return this;
  }
  
  public Statistics setDefaultSorting(String sortOrder) {
    defaultSorting = sortOrder;
    return this;
  }
  
  public Statistics setContact(IContact contact) {
    this.contact = contact;
    return this;
  }
  
  public Statistics onCriteria(Consumer<WhereClause> onCriteria) {
    this.onCriteria = onCriteria;
    return this;
  }
 
  public Statistics allowMatching(boolean allowMatching) {
    this.allowMatching = allowMatching && !Strings.isBlank(matchingInstance);
    return this;
  }
 
  public Statistics allowRanking(boolean allowRanking) {
    this.allowRanking = allowRanking && !Strings.isBlank(rankingInstance);
    return this;
  }
  
  public Statistics doMatching(boolean doIt) {
    doMatching = doIt;
    return this;    
  }
  
  public Statistics setSortOrder(String sortOrder) {
    this.sortOrder = sortOrder;
    return this;
  }
 
  public Statistics useDaoSearch(boolean doIt) {
    useDaoSearch = doIt;
    return this;    
  }
  
  public WhereClause getClause() {
    if(missingValues()) throw new NullPointerException("Missing values!");
    readDaoSearchValues();
    String orderBy = "";
    if(allowMatching && contact != null && contact.isValid() && doMatching) {
      Matchings.addJoin(wc, matchingInstance, entityRoot, entityId, contact, sortOrder);
      orderBy += Matchings.getOrdering() + ", ";
      sortOrder = "*";
    }
    if(allowRanking) {
      Rankings.addJoin(wc, rankingInstance, entityRoot, entityId, sortOrder);
      orderBy += Rankings.getOrdering() + ", ";
    }
    if(onCriteria != null) onCriteria.accept(wc);
    wc.addClause("order by " + orderBy + defaultSorting);
    return wc;
  }
  
  public static Statistics load(IConstructor constructor, String rankingInstance, String matchingInstance, WhereClause wc) {
    return new Statistics(constructor, rankingInstance, matchingInstance, wc);
  }
 
  public static Aggregates aggregates(Dao dao, String table, String aggregateField, Consumer<WhereClause> onFilter) {
    WhereClause wc = new WhereClause();
    wc.addClause("select new org.turro.indicator.Aggregates(");
    wc.addClause("count(t),");
    wc.addClause("min(t." + aggregateField + "),");
    wc.addClause("max(t." + aggregateField + "),");
    wc.addClause("avg(t." + aggregateField + ")");
    wc.addClause(")");
    wc.addClause("from " + table + " t");
    if(onFilter != null) onFilter.accept(wc);
    Aggregates aggregates = (Aggregates) dao.getSingleResultOrNull(wc);
    if(aggregates != null && aggregates.getCount() > 0) {
      wc = new WhereClause();
      wc.addClause("select t." + aggregateField + " from " + table + " t");
      if(onFilter != null) onFilter.accept(wc);
      wc.addClause("order by t." + aggregateField + " asc");
      List<Double> values;
      if(aggregates.getCount() % 2 == 0) {
        values = dao.getResultList(wc, (int) Math.floor(aggregates.getCount() / 2), 2);
      } else {
        values = dao.getResultList(wc, (int) Math.floor(aggregates.getCount() / 2) + 1, 1);
      }
      if(values != null && !values.isEmpty()) {
        if(values.size() == 1) {
          aggregates.setMedian(values.get(0));
        } else if(values.size() == 2) {
          aggregates.setMedian((values.get(0) + values.get(1)) / 2.0);
        }
      } 
    }
    return aggregates;
  }
  
  private Statistics(IConstructor constructor, String rankingInstance, String matchingInstance, WhereClause wc) {
    this.constructor = constructor;
    this.rankingInstance = rankingInstance;
    this.matchingInstance = matchingInstance;
    this.wc = wc;
  }
 
  private boolean missingValues() {
    return constructor == null || (allowRanking && Strings.isBlank(rankingInstance)) ||
            (allowMatching && Strings.isBlank(matchingInstance) && contact != null) || 
            wc == null || Strings.isBlank(entityRoot) || Strings.isBlank(entityId) ||
            Strings.isBlank(defaultSorting);
  }
 
  private void readDaoSearchValues() {
    if(useDaoSearch) {
      DaoHtmlSearch dhs = DaoHtmlSearch.getInstance(constructor, ElephantContext.getContextVariable(constructor));
      if(dhs != null) {
        DaoSearchKey dsk = dhs.get("point-of-view");
        if(dsk != null) {
          doMatching = "1".equals(dsk.getValue());
        }
        dsk = dhs.get("sort-order");
        if(dsk != null) {
          sortOrder = dsk.getValue();
        }
      }
    }
  }
  
}