ProcessMatching.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.matching;
 
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Stream;
import org.turro.action.IProcess;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.db.WhereClause;
import org.turro.indicator.Formulas;
import org.turro.indicator.IElephantIndicator;
import org.turro.indicator.IPreprocessor;
import org.turro.indicator.IndicatorVariable;
import org.turro.indicator.Indicators;
import org.turro.indicator.VariableType;
import org.turro.jpa.Dao;
import org.turro.math.Zero;
 
public abstract class ProcessMatching<T> implements IProcess, IPreprocessor {
  
  @Override
  public void startProcess() {
    Logger.getLogger(ProcessMatching.class.getName())
            .log(Level.INFO, ElephantContext.logMsg("Start " + instanceClass().getSimpleName() + "..."));
    start();
    truncate();
    Logger.getLogger(ProcessMatching.class.getName())
            .log(Level.INFO, ElephantContext.logMsg("Truncated"));
    List<IndicatorVariable> vars = Indicators.getMatchingVariables(indicatorsRoot());
    prepareProcess(vars);
    Logger.getLogger(ProcessMatching.class.getName())
            .log(Level.INFO, ElephantContext.logMsg("Preprocessed"));
    if(Indicators.hasDirectProcess(vars)) {
      try(Stream<T> entities = getEntityStream()) {
        process(entities, vars);
      }
    }
    Logger.getLogger(ProcessMatching.class.getName())
            .log(Level.INFO, ElephantContext.logMsg("Processed"));
    postProcess(vars);
    Logger.getLogger(ProcessMatching.class.getName())
            .log(Level.INFO, ElephantContext.logMsg("Postprocessed"));
    calculateMatching();
    end();
    Logger.getLogger(ProcessMatching.class.getName())
            .log(Level.INFO, ElephantContext.logMsg("End " + instanceClass().getSimpleName()));
  }
 
  @Override
  public void startProcessFor(Object entity) {
    String entityPath = getDao().getPath(entity);
    WhereClause wc = new WhereClause();
    wc.addClause("delete from " + instanceClass().getSimpleName());
    wc.addClause("where entityPath = :entityPath");
    wc.addNamedValue("entityPath", entityPath);
    getDao().executeUpdate(wc);
    processFor((T) entity, Indicators.getMatchingVariables(indicatorsRoot()));
  }
 
  public void process(Stream<T> stream, List<IndicatorVariable> variables) {
    stream.forEach(t -> {
      processFor(t, variables);
    });
  }
  
  public void processFor(T entity, List<IndicatorVariable> variables) {
    prepareEntity(entity);
    try(Stream<String> related = Indicators.getIndicator("generic").getEntityPaths(relatedRoot())) {
      related.forEach(r -> {
        variables.forEach(v -> {
          if(!v.isPreprocess()) {
            process(entity, r, v);
          }
        });
      });
    }
  }
  
  protected void start() {}
  protected void end() {}
  
  protected void truncate() {
    if(getSelectedPaths() == null) {
      getDao().executeNativeUpdate("truncate table " + instanceClass().getSimpleName());
    } else {
      WhereClause wc = new WhereClause();
      wc.addClause("delete from " + instanceClass().getSimpleName());
      wc.addIn("where", "entityPath", getSelectedPaths());
      getDao().executeUpdate(wc);
    }
  }
  
  protected List<String> getSelectedPaths() {
    return null;
  }
  
  protected IMatching process(T entity, String relatedPath, IndicatorVariable variable) {
    IMatching matching = createMatchingInstance(getDao().getPath(entity), relatedPath, variable);
    matching.setMatching(Indicators.getValue(entity, relatedPath, variable));
    if(!Zero.near(matching.getMatching(), 2)) {
      matching = getDao().saveObject(matching);
    }
    return matching;
  }
 
  protected void prepareProcess(List<IndicatorVariable> variables) {
    variables.forEach(v -> {
      if(v.isPreprocess()) {
        IElephantIndicator ei = Indicators.getIndicator(v);
        ei.preprocess(v, this, entitiesRoot(), relatedRoot());
      }
    });
  }
  
  protected void postProcess(List<IndicatorVariable> variables) {
    variables.forEach(v -> {
      IElephantIndicator ei = Indicators.getIndicator(v);
      ei.postprocess(v, this, entitiesRoot(), relatedRoot());
    });
  }
  
  protected void prepareEntity(T entity) { }
  
  protected double calculate(MatchingSet set) {
    return set.applyFrom(Formulas.load().getFormula(instanceClass()));
  }
  
  protected IMatching createMatchingInstance(String entityPath, String relatedPath, IndicatorVariable variable) {
    IMatching matching = createMatchingInstance();
    matching.setEntityPath(entityPath);
    matching.setRelatedPath(relatedPath);
    matching.setConcept(variable.getName());
    matching.setMatching(0);
    return matching;
  }
 
  protected abstract Stream<T> getEntityStream();
  protected abstract IMatching createMatchingInstance();
  protected abstract Class instanceClass();
  protected abstract String indicatorsRoot();
  protected abstract String entitiesRoot();
  protected abstract String relatedRoot();
  protected abstract Dao createDao();
  
  /* Results */
  
  private IMatching previous;
  private MatchingSet set;
  private List<IndicatorVariable> variables;
 
  private void calculateMatching() {
    previous = null;
    set = new MatchingSet();
    variables = Indicators.getMatchingVariables(indicatorsRoot());
    try(Stream<IMatching> tuples = getIndicatorTuples()) {
      tuples.forEach(t -> {
        doCalculate(t);
      });
    }
    if(!set.isEmpty()) {
      doCalculate(null);
    }
    getDao().finishPool();
  }
  
  private Stream<IMatching> getIndicatorTuples() {
    WhereClause wc = new WhereClause();
    wc.addClause("select m from " + instanceClass().getSimpleName() + " m");
    if(getSelectedPaths() != null) {
      wc.addIn("where", "entityPath", getSelectedPaths());
    }
    wc.addClause("order by entityPath, relatedPath, concept");
    return createDao().stream(IMatching.class, wc, 1000);  
  }
  
  private void doCalculate(IMatching matching) {
    if(matching == null || (previous != null && !sameTuple(previous, matching))) {
      set.addMissing(variables);
      IMatching result = createMatchingInstance(previous.getEntityPath(), previous.getRelatedPath(), 
              IndicatorVariable.result(indicatorsRoot(), VariableType.MATCHING_VARIABLE));
      result.setMatching(calculate(set));
      if(!Zero.near(result.getMatching(), 2)) {
        getDao().poolObject(result, 1000);
      }
      set = new MatchingSet();
    }
    if(matching != null) {
      set.add(matching);
      previous = matching;
    }
  }
 
  private boolean sameTuple(IMatching matching1, IMatching matching2) {
    if(matching1 == null || matching2 == null) {
      return false;
    }
    return matching1.getEntityPath().equals(matching2.getEntityPath()) &&
           matching1.getRelatedPath().equals(matching2.getRelatedPath());
  }
  
  /* Preprocessor */
 
  @Override
  public Object createInstance() {
    return createMatchingInstance();
  }
 
  @Override
  public void poolInstance(Object value) {
    getDao().poolObject(value, 1000);
  }
 
  @Override
  public void finishPreprocessor() {
    getDao().finishPool();
  }
  
  @Override
  public String tableName() {
    return instanceClass().getSimpleName();
  }  
  
  /* Dao */
  
  private Dao _dao;
  
  protected Dao getDao() {
    if(_dao == null) {
      _dao = createDao();
    }
    return _dao;
  }
 
}