AbstractIndicator.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.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.turro.elephant.db.SQLHelper;
import org.turro.elephant.db.WhereClause;
import org.turro.entities.Entities;
import org.turro.jpa.Dao;
import org.turro.matching.GenericSiblings;
import org.turro.matching.ProcessMatching;
import org.turro.ranking.ProcessRanking;
 
public abstract class AbstractIndicator implements IElephantIndicator {
 
  protected List<IndicatorVariable> variables = new ArrayList<>();
  protected String root, relatedRoot;
 
  @Override
  public void initIndicator() {
    initVariables();
  }
 
  @Override
  public void prepareIndicator() {
    initExternalVariables();
  }
 
  @Override
  public void generateSiblings() {
    // Do nothing
  }
 
  @Override
  public String getRoot() {
    return root;
  }
  
  protected void addVariable(String name, VariableType type) {
    variables.add(new IndicatorVariable(root, name, false, type));
  }
  
  protected void addVariable(String name, VariableType type, boolean reversed) {
    variables.add(new IndicatorVariable(root, name, false, type, reversed));
  }
  
  protected void addVariable(String name, VariableType type, String avoid) {
    variables.add(new IndicatorVariable(root, name, false, type, avoid));
  }
  
  protected void addVariable(String name, boolean preprocess, VariableType type) {
    variables.add(new IndicatorVariable(root, name, preprocess, type));
  }
  
  protected void addVariable(String name, boolean preprocess, VariableType type, boolean reversed) {
    variables.add(new IndicatorVariable(root, name, preprocess, type, reversed));
  }
  
  protected void addVariable(String name, boolean preprocess, VariableType type, String avoid) {
    variables.add(new IndicatorVariable(root, name, preprocess, type, avoid));
  }
  
  protected void addExternalVariable(String root, String name) {
    IndicatorVariable variable = Indicators.getVariable(root, name);
    if(variable != null) variables.add(variable);
  }
  
  @Override
  public List<IndicatorVariable> getVariables() {
    return variables.stream().filter(v -> root.equals(v.getRoot())).collect(Collectors.toList());
  }
 
  @Override
  public List<IndicatorVariable> getAllVariables() {
    return variables;
  }
  
  @Override
  public IndicatorVariable getVariable(String name) {
    return getVariables().stream().filter(v -> name.equals(v.getName())).findAny().get();
  }
  
  @Override
  public List<IndicatorVariable> getAllRankingVariables(String root) {
    return variables.stream().filter(v -> v.permits(root) && v.getType().isRanking()).collect(Collectors.toList());
  }
 
  @Override
  public List<IndicatorVariable> getAllMatchingVariables(String root) {
    return variables.stream().filter(v -> v.permits(root) && v.getType().isMatching()).collect(Collectors.toList());
  }
 
  @Override
  public double getValue(IndicatorVariable variable, Object entity) {
    return 0.0;
  }
 
  @Override
  public double getValue(IndicatorVariable variable, Object entity, String relatedPath) {
    return 0.0;
  }
 
  @Override
  public IndicatorResult readIndicator(String storeClass, String indicator) {
    String v[] = indicator.split("\\s*\\.\\s*");
    int index = 0;
    WhereClause wc = new WhereClause();
    if(v.length == 2) {
      wc.addClause("select new org.turro.indicator.IndicatorResult(sum(ranking), count(ranking))");
    } else {
      wc.addClause("select new org.turro.indicator.IndicatorResult(sum(matching), count(matching))");
    }
    wc.addClause("from " + storeClass);
    wc.addClause("where entityPath like :entityPath");
    wc.addNamedValue("entityPath", convertPathToLike(v[index++], root));
    if(v.length == 3) {
      wc.addClause("and relatedPath like :relatedPath");
      wc.addNamedValue("relatedPath", convertPathToLike(v[index++], relatedRoot));
    }
    wc.addClause("and concept like :indicator");
    wc.addNamedValue("indicator", convertIndicatorToLike(v[index]));
    
    return (IndicatorResult) getDao().getSingleResultOrNull(wc);
  }
 
  @Override
  public void preprocess(IndicatorVariable variable, IPreprocessor preprocessor, String entityRoot, String relatedRoot) {
    if(variable.isPreprocess()) {
      if(root.equals(variable.getRoot())) {
        if(preprocessor instanceof ProcessRanking) {
          processRankingVariable(createDao(), preprocessor, variable, entityRoot);
        } else if(preprocessor instanceof ProcessMatching) {
          processMatchingVariable(createDao(), preprocessor, variable, entityRoot, relatedRoot);
        }
      } else {
        Indicators.getIndicator(variable).preprocess(variable, preprocessor, entityRoot, relatedRoot);
      }
    }
  }
  
  @Override
  public void postprocess(IndicatorVariable variable, IPreprocessor postprocessor, String entityRoot, String relatedRoot) {
    if(postprocessor instanceof ProcessRanking) {
      postprocessRankingVariable(createDao(), postprocessor, variable, entityRoot);
    } else if(postprocessor instanceof ProcessMatching) {
      postprocessMatchingVariable(createDao(), postprocessor, variable, entityRoot, relatedRoot);
    }
  }
  
  protected String getPath(Object entity) {
    return (entity instanceof String) ? (String) entity : Entities.getController(entity).getPath();
  }
  
  private String convertPathToLike(String value, String root) {
    if(value.matches("\\/[a-z\\-\\*\\?]+\\/[0-9a-zA-Z\\*\\?]+")) {
      return SQLHelper.convertToLike(value);
    } else {
      return "/" + root + "/" + SQLHelper.convertToLike(value);
    }
  }
  
  private String convertIndicatorToLike(String value) {
    if("final".equals(value)) {
      return "*";
    } else {
      return SQLHelper.convertToLike(value);
    }
  }
  
  /* Variables */
  
  protected abstract void initVariables();
  protected abstract void initExternalVariables();
  
  /* Preprocessor */
  
  protected abstract void processRankingVariable(Dao dao, IPreprocessor preprocessor, 
          IndicatorVariable variable, String entityRoot);
  protected abstract void processMatchingVariable(Dao dao, IPreprocessor preprocessor, 
          IndicatorVariable variable, String entityRoot, String relatedRoot);
  
  /* Postprocessor */
  
  protected void postprocessRankingVariable(Dao dao, IPreprocessor postprocessor, 
          IndicatorVariable variable, String entityRoot) {}
  protected void postprocessMatchingVariable(Dao dao, IPreprocessor postprocessor, 
          IndicatorVariable variable, String entityRoot, String relatedRoot) {}
  
  /* Streams */
 
  @Override
  public Stream<String> getEntityPaths(String root) {
    throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
  }
 
  @Override
  public Stream<GenericSiblings> getSiblingPaths(String entityPath) {
    throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
  }
  
  /* Dao */
  
  private Dao _dao;
  
  public Dao getDao() {
    if(_dao == null) {
      _dao = createDao();
    }
    return _dao;
  }
  
  protected abstract Dao createDao();
 
  /* Type checking */
 
  @Override
  public boolean itsMine(String root) {
    return this.root.equals(root);
  }
  
  @Override
  public boolean itsMine(IndicatorVariable variable) {
    return getVariables().contains(variable);
  }
 
}