IssueWrapper.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 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.issue;
 
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.turro.action.Contacts;
import org.turro.string.ObjectString;
import org.turro.string.Strings;
import org.turro.auth.Authentication;
import org.turro.dossier.db.DossierPU;
import org.turro.dossier.dossier.DossierData;
import org.turro.dossier.dossier.DossierValues;
import org.turro.dossier.dossier.DossierWrapper;
import org.turro.dossier.dw.DossierDWReport;
import org.turro.dossier.entity.*;
import org.turro.dossier.util.WorksheetUtil;
import org.turro.elephant.context.Application;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.db.WhereClause;
import org.turro.i18n.I_;
import org.turro.jpa.Dao;
import org.turro.jpa.entity.DaoEntity;
import org.turro.plugin.contacts.IContact;
import org.turro.related.Relateds;
 
public class IssueWrapper extends DaoEntity<Issue, Long> {
 
  private IContact contact;
  private List<IssueParticipantRole> role;
  private boolean hasIssueQA;
  private DossierValues reality;
 
  public IssueWrapper(Issue issue) {
    super(issue);
    this.contact = Authentication.getIContact();
  }
 
  public IssueWrapper(Issue issue, IContact contact) {
    super(issue);
    this.contact = contact;
  }
 
  public String getTabLabel() {
    return getSelfLabel() + " #" + (entity.getId() == null ? "" : entity.getId());
  }
  
  public String getSelfLabel() {
    return I_.get("Issue");
  }
  
  public String getTooltiptext() {
    try {
      return entity.getFullDescription();
    } catch(Exception ex) {
      return null;
    }
  }
 
  public void setContact(IContact contact) {
    this.contact = contact;
  }
 
  public boolean isFullParticipant() {
    if(!Contacts.isValid(contact)) return false;
    if(isParticipant()) return true;
    for(IDossierParticipant dp : getIssue().getDossier().getFullParticipants()) {
      if(dp.getIdContact().equals(contact.getId()) && dp.isShowAllIssues()) {
        return true;
      }
    }
    return false;
  }
 
  public boolean isParticipant() {
    return !getRole().isEmpty();
  }
  
  public boolean isReporter() {
    return getRole().contains(IssueParticipantRole.ISSUE_REPORTER);
  }
  
  public boolean isResponsible() {
    return getRole().contains(IssueParticipantRole.ISSUE_RESPONSIBLE);
  }
  
  public boolean isQA() {
    return getRole().contains(IssueParticipantRole.ISSUE_QA);
  }
  
  public boolean isAssistant() {
    return getRole().contains(IssueParticipantRole.ISSUE_ASSISTANT);
  }
  
  public boolean hasQA() {
    getRole();
    return hasIssueQA;
  }
  
  public boolean getCanShowDossier() {
    return Application.getApplication().isInRole("dossier:show") &&
            entity.getDossier() != null &&
            new DossierWrapper(entity.getDossier()).isParticipant();
  }
  
  public Issue getIssue() {
    return entity;
  }
 
  public void setIssue(Issue issue) {
    this.entity = issue;
  }
 
  public String getTimmingImage() {
    return "/_zul/images/timming" + getRelevanceOrderByContact() + ".png";
  }
  
  public String getAlarmImage() {
    if(hasPassedNow()) {
      return "/_zul/images/date_surpassed.png";
    }
    if(hasPassedValues()) {
      return "/_zul/images/value_surpassed.png";
    }
    return "";
  }
  
  public String getPriorityImage() {
    int p = entity.getPriority().getPriority();
    if(p < 3) {
      return "/_zul/images/priority" + p + ".png";
    }
    return "";
  }
 
  public int getRelevanceOrderByContact() {
    return Math.min(getRelevanceByReporter(), Math.min(getRelevanceByResponsible(), getRelevanceByQA()));
  }
 
  public String getOrderingValue() {
    StringBuilder result = new StringBuilder();
    try {
      if(isUnrelated()) {
        result.append("0");
      }
      else {
        result.append("1");
      }
      if(hasPassedNow()) {
        result.append("0");
      }
      else {
        result.append("1");
      }
      if(hasPassedStartDate() && canStartBySources()) {
        result.append("0");
      } else {
        result.append("1");
      }
      result.append(getRelevanceOrderByContact());
      result.append(entity.getPriority().getPriority());
      result.append(entity.getType().getPriority());
      result.append(reverse(ObjectString.formatObject(entity.getModification(), ObjectString.COMPRESSED_DATE_PATTERN, false)));
      result.append(entity.getId());
    
    // TODO: shouldn't happen... but...
    } catch(Exception ex) {
      Logger.getLogger(IssueWrapper.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
    
    return result.toString();
  }
 
  public DossierValues getReality() {
    if(reality == null) {
      reality = new DossierValues();
      // TODO: optimize using SQL aggregates
      for(IssueComment icomment : entity.getComments()) {
        reality.expenses += icomment.getExpenses();
        reality.hours += icomment.getHours();
        reality.price += icomment.getPrice();
      }
    }
    return reality;
  }
 
  public DossierData getData() {
    DossierValues prevision = new DossierValues();
    prevision.expenses = entity.getExpenses();
    prevision.hours = entity.getHours();
    prevision.price = entity.getPrice();
    return new DossierData(prevision, getReality());
  }
 
  public DossierData getDossierData() {
    DossierDWReport dr = new DossierDWReport();
    dr.setReportValues(entity.getDossier());
    return dr.getData();
  }
 
  public boolean isUnrelated() {
    return getIssue().getDossier() == null ||
            !hasReporter() ||
            !hasResponsible();
  }
 
  public boolean hasReporter() {
    for(IssueParticipant ip : entity.getParticipants()) {
      if(ip.getRole().equals(IssueParticipantRole.ISSUE_REPORTER) &&
              !Strings.isBlank(ip.getIdContact())) {
        return true;
      }
    }
    return false;
  }
 
  public boolean hasResponsible() {
    for(IssueParticipant ip : entity.getParticipants()) {
      if(ip.getRole().equals(IssueParticipantRole.ISSUE_RESPONSIBLE) &&
              !Strings.isBlank(ip.getIdContact())) {
        return true;
      }
    }
    return false;
  }
 
  public boolean hasAssistant() {
    for(IssueParticipant ip : entity.getParticipants()) {
      if(ip.getRole().equals(IssueParticipantRole.ISSUE_ASSISTANT) &&
              !Strings.isBlank(ip.getIdContact())) {
        return true;
      }
    }
    return false;
  }
 
  public boolean hasPassedStartDate() {
    Date now = new Date();
    return entity.getStartDate() == null || now.after(entity.getStartDate());
  }
 
  public boolean hasPassedNow() {
    Date now = new Date();
    return (entity.getControlDate() != null && now.after(entity.getControlDate())) || 
            (entity.getDelivery() != null && now.after(entity.getDelivery()));
  }
  
  public boolean hasPassedValues() {
    return getReality().expenses > entity.getExpenses() ||
            getReality().hours > entity.getHours() ||
            getReality().price > entity.getPrice();
  }
  
  public boolean hasAlarm() {
    return hasPassedNow() || hasPassedValues();
  }
 
  @Deprecated
  public Set<IssuePredecessor> getSources() {
    return entity.getSources();
  }
 
  @Deprecated
  public Set<IssuePredecessor> getTargets() {
    return entity.getTargets();
  }
 
  public String getResponsibleString() {
    String result = "";
    for(IssueParticipant ip : entity.getParticipants()) {
      if(ip.getRole().equals(IssueParticipantRole.ISSUE_RESPONSIBLE)) {
        result += (Strings.isEmpty(result) ? "" : ", ") + ip.getName();
      }
    }
    return result;
  }
 
  public String getReporterString() {
    String result = "";
    for(IssueParticipant ip : entity.getParticipants()) {
      if(ip.getRole().equals(IssueParticipantRole.ISSUE_REPORTER)) {
        result += (Strings.isEmpty(result) ? "" : ", ") + ip.getName();
      }
    }
    return result;
  }
 
  public String getQAString() {
    String result = "";
    for(IssueParticipant ip : entity.getParticipants()) {
      if(ip.getRole().equals(IssueParticipantRole.ISSUE_QA)) {
        result += (Strings.isEmpty(result) ? "" : ", ") + ip.getName();
      }
    }
    return result;
  }
 
  public String getAssistantString() {
    String result = "";
    for(IssueParticipant ip : entity.getParticipants()) {
      if(ip.getRole().equals(IssueParticipantRole.ISSUE_ASSISTANT)) {
        result += (Strings.isEmpty(result) ? "" : ", ") + ip.getName();
      }
    }
    return result;
  }
 
  public boolean canStartBySources() {
    for(IssuePredecessor ip : entity.getSources()) {
      if(ip.getType() == IssuePredecessorType.START_WHEN_STARTS && !ip.getSource().getStatus().isSeen()) {
        return false;
      } else if(ip.getType() == IssuePredecessorType.START_WHEN_ENDS && !ip.getSource().getStatus().isFinished()) {
        return false;
      }
    }
    return true;
  }
 
  public List<String> getWaitingReason() {
    List<String> l = new ArrayList<String>();
    Date now = new Date();
    if(entity.getStartDate() != null) {
      if(now.before(entity.getStartDate())) {
        l.add(I_.format("Waiting for date %tF", entity.getStartDate()));
      }
    }
    StringBuffer sb = new StringBuffer();
    for(IssuePredecessor ip : entity.getSources()) {
      Issue source = ip.getSource();
      if(ip.getType() == IssuePredecessorType.START_WHEN_STARTS && !source.getStatus().isSeen()) {
        l.add(I_.byKey(ip.getType().toString()) + " #" + source.getId() + " " + source.getDescription() + "\n");
      } else if(ip.getType() == IssuePredecessorType.START_WHEN_ENDS && !source.getStatus().isFinished()) {
        l.add(I_.byKey(ip.getType().toString()) + " #" + source.getId() + " " + source.getDescription() + "\n");
      }
    }
    return l;
  }
 
  public int getKanbanColumn() {
    IssueStatus status = entity.getStatus();
    if(!status.isSeen()) {
      return 1;
    } else if(status.isWorking() || status.isStandBy()) {
      return 2;
    } else if(status.isFinished()) {
      return 3;
    } else {
      return 0;
    }
  }
          
  private String reverse(String string) {
    StringBuffer sb = new StringBuffer(string);
    for(int i = 0; i < sb.length(); i++) {
      sb.setCharAt(i, (char)('9' - sb.charAt(i) + '0'));
    }
    return sb.toString();
  }
 
  private List<IssueParticipantRole> getRole() {
    if(!contact.isValid()) return Collections.EMPTY_LIST;
    if(role == null) {
      role = new ArrayList<>();
      for(IssueParticipant ip : getIssue().getParticipants()) {
        if(!Strings.isBlank(ip.getIdContact())) {
          if(ip.getIdContact().equals(contact.getId())) {
            role.add(ip.getRole());
          }
          if(ip.getRole() == IssueParticipantRole.ISSUE_QA) {
            hasIssueQA = true;
          }
        }
      }
    }
    return role;
  }
 
  private int getRelevanceByReporter() {
    IssueStatus status = entity.getStatus();
    if(isReporter()) {
      if(status == IssueStatus.STATUS_INCOMPLETE || 
              (status == IssueStatus.STATUS_VERIFIED && hasIssueQA) || 
              (status == IssueStatus.STATUS_RESOLVED && !hasIssueQA)) {
        return 1;
      }
      else if(status == IssueStatus.STATUS_REUNION) {
        return 2;
      }
      else if(status == IssueStatus.STATUS_FROZEN) {
        return 5;
      }
      else {
        return 3;
      }
    }
    return 4;
  }
  
  private int getRelevanceByResponsible() {
    IssueStatus status = entity.getStatus();
    if(isResponsible()) {
      if(status == IssueStatus.STATUS_NEW || 
              status == IssueStatus.STATUS_STARTED || 
              status == IssueStatus.STATUS_REOPENED) {
        return 1;
      }
      else if(status == IssueStatus.STATUS_REUNION) {
        return 2;
      }
      else if(status == IssueStatus.STATUS_FROZEN) {
        return 5;
      }
      else {
        return 3;
      }
    }
    return 4;
  }
          
  private int getRelevanceByQA() {
    IssueStatus status = entity.getStatus();
    if(isQA()) {
      if(status == IssueStatus.STATUS_RESOLVED) {
        return 1;
      }
      else if(status == IssueStatus.STATUS_REUNION) {
        return 2;
      }
      else if(status == IssueStatus.STATUS_FROZEN) {
        return 5;
      }
      else {
        return 3;
      }
    }
    return 4;
  }
  
  public void clearEmpties() {
    Iterator<IssueParticipant> iip = entity.getParticipants().iterator();
    while(iip.hasNext()) {
      if(Strings.isBlank(iip.next().getIdContact())) {
        iip.remove();
      }
    }
  }
 
  public Date getBeginDate() {
    return entity.getStartDate();
  }
  
  public Date getEndDate() {
    return entity.getDelivery();
  }
  
  public Date getControlDate() {
    return entity.getControlDate();
  }
  
  public IssueDetailSet getDetail() {
    return new IssueDetailSet(entity);
  }
 
  @Override
  protected Dao createDao() {
    return new DossierPU();
  }
  
  @Override
  public boolean delete() {
    Relateds.empty().removeAny(DossierPU.getObjectPath(entity));
    WorksheetUtil.removeWorksheet(entity.getId());
    return super.delete();
  }
  
  @Override
  protected boolean shouldLog() {
    return false;
  }
  
  public String getLeaveAsLabel() {
    return I_.get("Leave issue as") + ": " + I_.byKey(entity.getStatus().toString()) +
            (entity.getStatus().isFinished() ? " " + I_.byKey(entity.getResolution().toString()) : "");
  }
 
  public boolean getCanStart() {
    return EnumSet.of(IssueStatus.STATUS_NEW, IssueStatus.STATUS_INCOMPLETE)
            .contains(entity.getStatus()) && isResponsible();
  }
  
  public boolean getCanMarkAsIncomplete() {
    return EnumSet.of(IssueStatus.STATUS_NEW, IssueStatus.STATUS_STARTED, 
            IssueStatus.STATUS_REOPENED)
            .contains(entity.getStatus()) && isResponsible();
  }
  
  public boolean getCanFreeze() {
    return EnumSet.of(IssueStatus.STATUS_NEW, IssueStatus.STATUS_STARTED, 
            IssueStatus.STATUS_REOPENED, IssueStatus.STATUS_INCOMPLETE,
            IssueStatus.STATUS_REUNION)
            .contains(entity.getStatus()) && (isResponsible() || isReporter());
  }
  
  public boolean getCanResolve() {
    return EnumSet.of(IssueStatus.STATUS_NEW, IssueStatus.STATUS_INCOMPLETE, 
            IssueStatus.STATUS_STARTED, IssueStatus.STATUS_REOPENED,
            IssueStatus.STATUS_REUNION)
            .contains(entity.getStatus()) && (isFullParticipant());
  }
  
  public boolean getCanReopen() {
    return EnumSet.of(IssueStatus.STATUS_CLOSED, IssueStatus.STATUS_FROZEN, 
            IssueStatus.STATUS_REUNION, IssueStatus.STATUS_RESOLVED, 
            IssueStatus.STATUS_VERIFIED, IssueStatus.STATUS_INCOMPLETE)
            .contains(entity.getStatus()) && isFullParticipant();
  }
  
  public boolean getCanVerify() {
    return EnumSet.of(IssueStatus.STATUS_RESOLVED)
            .contains(entity.getStatus()) && hasQA() && isQA();
  }
  
  public boolean getCanClose() {
    return (EnumSet.of(IssueStatus.STATUS_RESOLVED)
            .contains(entity.getStatus()) && !hasQA() && (isFullParticipant())) ||
            (EnumSet.of(IssueStatus.STATUS_VERIFIED)
            .contains(entity.getStatus()) && hasQA() && (isFullParticipant()));
  }
  
  public boolean getCanCheckClose() {
    return (EnumSet.of(IssueStatus.STATUS_NEW, IssueStatus.STATUS_INCOMPLETE,
            IssueStatus.STATUS_STARTED, IssueStatus.STATUS_REOPENED, IssueStatus.STATUS_REUNION)
            .contains(entity.getStatus()) && !hasQA() && 
            (entity.getId() == null || isReporter() || isResponsible()));
  }
  
  public static void checkPendingRevision(Issue issue) {
    IssueWrapper iw = new IssueWrapper(issue);
    if(issue.getStatus().equals(IssueStatus.STATUS_CLOSED)) {
      IssueComment last = null;
      for(IssueComment ic : issue.getComments()) {
        last = ic;
      }
      if(last != null) {
        for(IssueParticipant ip : issue.getParticipants()) {
          if(ip.getRole().equals(IssueParticipantRole.ISSUE_REPORTER)) {
            if(Strings.isEmpty(last.getIdContact()) || !last.getIdContact().equals(ip.getIdContact())) {
              WhereClause wc = new WhereClause();
              wc.addClause("update IssueParticipant ip");
              wc.addClause("set pendingRevision = true");
              wc.addClause("where ip = :ip");
              wc.addNamedValue("ip", ip);
              iw.getDao().executeUpdate(wc);
            }
          }
        }
      }
    } else {
      WhereClause wc = new WhereClause();
      wc.addClause("update IssueParticipant ip");
      wc.addClause("set pendingRevision = false");
      wc.addClause("where ip.issue = :issue");
      wc.addNamedValue("issue", issue);
      iw.getDao().executeUpdate(wc);
    }
  }
 
}