DossierDWReport.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2018 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.dossier.dw;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.EnumMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import org.turro.dossier.db.DossierPU;
import org.turro.dossier.dossier.DossierData;
import org.turro.dossier.dossier.DossierReportItem;
import org.turro.dossier.dossier.DossierValues;
import org.turro.dossier.entity.Dossier;
import org.turro.dossier.entity.IssueParticipantRole;
import org.turro.dossier.entity.IssueResolution;
import org.turro.dossier.entity.IssueStatus;
import org.turro.dossier.entity.IssueType;
import org.turro.dossier.search.DossierIds;
import org.turro.elephant.db.WhereClause;
import org.turro.i18n.I_;
import org.turro.jpa.Dao;
import org.turro.math.Round;
import org.turro.util.PhraseBuilder;
 
public class DossierDWReport {
 
  private DossierValues prevision, reality;
  private HashSet<DossierReportItem> items;
  private String participantId;
  private IssueParticipantRole role;
  private Collection<DossierIds> dossierIds;
  
  public void setReportValues(Dossier dossier) {
    setReportValues(null, null, dossier.getId());
  }
  
  public void setReportValues(String participantId, IssueParticipantRole role, Long dossierId) {
    ArrayList al = new ArrayList();
    al.add(new DossierIds(dossierId, 0L, null));
    setReportValues(participantId, role, al);
  }
 
  public void setReportValues(String participantId, IssueParticipantRole role, Collection<DossierIds> dossierIds) {
    this.participantId = participantId;
    this.role = role;
    this.dossierIds = dossierIds;
    prevision = null;
    reality = null;
    items = null;
  }
 
  public double getIssueCount() {
    return (double) getItems().size();
  }
 
  public DossierValues getPrevision() {
    if(prevision == null) {
      prevision = new DossierValues();
      for(DossierReportItem dri : getItems()) {
        prevision.expenses += dri.prevision.expenses;
        prevision.hours += dri.prevision.hours;
        prevision.price += dri.prevision.price;
      }
    }
    return prevision;
  }
 
  public DossierValues getReality() {
    if(reality == null) {
      reality = new DossierValues();
      for(DossierReportItem dri : getItems()) {
        reality.expenses += dri.reality.expenses;
        reality.hours += dri.reality.hours;
        reality.price += dri.reality.price;
      }
    }
    return reality;
  }
 
  public DossierData getData() {
    return new DossierData(getPrevision(), getReality());
  }
 
  public double getIssueCountByType(IssueType type) {
    double count = 0;
    for(DossierReportItem dri : getItems()) {
      if(dri.type.equals(type)) {
        count++;
      }
    }
    return count;
  }
 
  public double getIssueCountByStatus(IssueStatus status) {
    double count = 0;
    for(DossierReportItem dri : getItems()) {
      if(dri.status.equals(status)) {
        count++;
      }
    }
    return count;
  }
 
  public double getIssueCountByResolution(IssueResolution resolution) {
    double count = 0;
    for(DossierReportItem dri : getItems()) {
      if(dri.status.isFinished() && dri.resolution.equals(resolution)) {
        count++;
      }
    }
    return count;
  }
 
  public double getPositivelySolved() {
    double count = 0;
    for(DossierReportItem dri : getItems()) {
      if(dri.status.isFinished() && dri.resolution.isSolved()) {
        count++;
      }
    }
    return count;
  }
 
  public double getNegativelySolved() {
    double count = 0;
    for(DossierReportItem dri : getItems()) {
      if(dri.status.isFinished() && !(dri.resolution.isSolved()) && !(dri.resolution.isRejected())) {
        count++;
      }
    }
    return count;
  }
 
  public double getSolved() {
    double count = 0;
    for(DossierReportItem dri : getItems()) {
      if(dri.status.isFinished()) {
        count++;
      }
    }
    return count;
  }
 
  public double getOnWork() {
    double count = 0;
    for(DossierReportItem dri : getItems()) {
      if(dri.status.isWorking()) {
        count++;
      }
    }
    return count;
  }
 
  public double getStandBy() {
    double count = 0;
    for(DossierReportItem dri : getItems()) {
      if(dri.status.isStandBy()) {
        count++;
      }
    }
    return count;
  }
 
  public Collection<String> getIssuesPathByType(String type) {
    ArrayList<String> list = new ArrayList<>();
    for(DossierReportItem dri : getItems()) {
      if(I_.byKey(dri.type.toString()).equals(type)) {
        list.add("/issue/" + dri.issueId);
      }
    }
    return list;
  }
 
  public Collection<String> getIssuesPathByStatus(String status) {
    ArrayList<String> list = new ArrayList<>();
    for(DossierReportItem dri : getItems()) {
      if(I_.byKey(dri.status.toString()).equals(status)) {
        list.add("/issue/" + dri.issueId);
      }
    }
    return list;
  }
 
  public Collection<String> getIssuesPathByResolution(String resolution) {
    ArrayList<String> list = new ArrayList<>();
    for(DossierReportItem dri : getItems()) {
      if(I_.byKey(dri.resolution.toString()).equals(resolution)) {
        list.add("/issue/" + dri.issueId);
      }
    }
    return list;
  }
 
 
  public Map<IssueType, Double> getIssuesByType() {
    Map type = new EnumMap<>(IssueType.class);
    for(IssueType is : IssueType.values()) {
      double d = getIssueCountByType(is);
      if(d > 0.0) type.put(is, d);
    }
    return type;
  }
 
  public Map<IssueStatus, Double> getIssuesByStatus() {
    Map status = new EnumMap<>(IssueStatus.class);
    for(IssueStatus is : IssueStatus.values()) {
      double d = getIssueCountByStatus(is);
      if(d > 0.0) status.put(is, d);
    }
    return status;
  }
 
  public Map<IssueResolution, Double> getIssuesByResolution() {
    Map resolution = new EnumMap<>(IssueResolution.class);
    for(IssueResolution is : IssueResolution.values()) {
      double d = getIssueCountByResolution(is);
      if(d > 0.0) resolution.put(is, d);
    }
    return resolution;
  }
 
  public Double getEfectivity() {
    double solved = getSolved();
    return new Round(solved > 0 ? getPositivelySolved() / solved : 0).perCent(2);
  }
 
  public Double getDaySpanAverage() {
    double issues = 0, days = 0;
    for(DossierReportItem dri : getItems()) {
      if(dri.status.isFinished() && dri.startDate != null &&
              dri.solvedDate != null && dri.startDate.before(dri.solvedDate)) {
        issues++;
        days = (dri.solvedDate.getTime() - dri.startDate.getTime()) / (24 * 60 * 60 * 1000);
      }
    }
    return new Round(issues > 0 ? days / issues : 0).decimals(2).value();
  }
 
  private String getInValue(Collection<DossierIds> dossierIds) {
    PhraseBuilder pb = new PhraseBuilder();
    pb.addWord("(");
    for(DossierIds id : dossierIds) {
      pb.addWord(id.dossierId + "");
      pb.addPendingSeparator(",");
    }
    pb.cancelSeparator();
    pb.addWord(")");
    return pb.toString();
  }
  
  private HashSet<DossierReportItem> getItems() {
    if(items == null) {
      items = new HashSet<>();
      init(participantId, role, dossierIds);
    }
    return items;
  }
 
  private void init(String participantId, IssueParticipantRole role, Collection<DossierIds> dossierIds) {
    Dao dao = new DossierPU();
    WhereClause wc = new WhereClause();
    wc.addClause("select distinct issueId, type, status, resolution,");
    wc.addClause("pexpenses, phours, pprice,");
    wc.addClause("startDate, solvedDate,");
    wc.addClause("commentCount, rexpenses,");
    wc.addClause("rhours, rprice");
    wc.addClause("from DWIssue as issue where 1=1");
    if(participantId != null) {
      wc.addClause("and participantId = :idContact");
      wc.addClause("and participantRole = :role");
      wc.addNamedValue("idContact", participantId);
      wc.addNamedValue("role", role);
    }
    if(dossierIds != null && !dossierIds.isEmpty()) {
      wc.addClause("and issue.dossierId in " + getInValue(dossierIds));
    }
    wc.addClause("and (issue.startDate <= :startDate or issue.startDate is null)");
    wc.addNamedValue("startDate", new Date());
    List<Object[]> l = dao.getResultList(wc);
    for(Object[] result : l) {
      DossierReportItem dri = new DossierReportItem();
      dri.issueId = (Long) result[0];
      dri.type = (IssueType) result[1];
      dri.status = (IssueStatus) result[2];
      dri.resolution = (IssueResolution) result[3];
      dri.prevision.expenses = (Double) result[4];
      dri.prevision.hours = (Double) result[5];
      dri.prevision.price = (Double) result[6];
      dri.setStartDate((Date) result[7], (Date) result[7]);
      dri.solvedDate = (Date) result[8];
      dri.commentCount = result[9] == null ? 0 : (Long) result[9];
      dri.reality.expenses = result[10] == null ? 0 : (Double) result[10];
      dri.reality.hours = result[11] == null ? 0 : (Double) result[11];
      dri.reality.price = result[12] == null ? 0 : (Double) result[12];
      items.add(dri);
    }
  }
 
}