Issue.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.entity;
 
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import javax.persistence.*;
import org.turro.string.Strings;
import org.turro.action.Contacts;
import org.turro.action.Interceptors;
import org.turro.dossier.db.DossierPU;
import org.turro.dossier.dossier.ParticipantSet;
import org.turro.jpa.Dao;
import org.turro.jpa.entity.IDaoEntity;
import org.turro.math.Round;
import org.turro.plugin.contacts.IContact;
import org.turro.reflection.MappingSet;
import org.turro.related.RelatedItem;
import org.turro.util.Chars;
 
@Entity
public class Issue implements java.io.Serializable, IDaoEntity {
 
  @Id
  @GeneratedValue(strategy=GenerationType.IDENTITY)
  @Column(name="IDENTIFIER")
  private Long id;
 
  @Temporal(value = TemporalType.TIMESTAMP)
  private java.util.Date startDate;
 
  @Temporal(value = TemporalType.TIMESTAMP)
  private java.util.Date controlDate;
 
  @Temporal(value = TemporalType.TIMESTAMP)
  private java.util.Date delivery;
 
  @Temporal(value = TemporalType.TIMESTAMP)
  private java.util.Date issueDate;
  
  @Temporal(value = TemporalType.TIMESTAMP)
  private java.util.Date modification;
 
  @Temporal(value = TemporalType.TIMESTAMP)
  private java.util.Date solvedDate;
 
  @Lob
  @Column(length=4096)
  private String description, grouping;
 
  @Column(name="ISSUE_TYPE")
  private IssueType type;
 
  private IssuePriority priority;
  
  private IssueResolution resolution;
  
  private IssueStatus status;
 
  private double expenses, hours, price;
 
  private boolean publishable, milestone;
 
  @OneToOne
  private Issue duplicated;
 
  @ManyToOne
  @JoinColumn(name="DOSSIER_FK")
  private Dossier dossier;
  
  @ManyToOne
  private DossierVersion version;
 
  @OneToMany(mappedBy = "issue", fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval=true)
  @OrderBy(value="name")
  private Set<IssueParticipant> participants = new HashSet<IssueParticipant>();
 
  @OneToMany(mappedBy = "issue", fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval=true)
  @OrderBy(value = "modification ASC")
  private Set<IssueComment> comments = new HashSet<IssueComment>();
 
  @OneToMany(mappedBy = "target", fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval=true)
  @OrderBy(value="type")
  private Set<IssuePredecessor> sources = new HashSet<IssuePredecessor>();
 
  @OneToMany(mappedBy = "source", fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval=true)
  @OrderBy(value="type")
  private Set<IssuePredecessor> targets = new HashSet<IssuePredecessor>();
 
  private transient RelatedItem related = new RelatedItem();
 
  public Set<IssueParticipant> getParticipants() {
    return participants;
  }
 
  public void setParticipants(Set<IssueParticipant> participants) {
    this.participants = participants;
  }
 
  public Set<IssueComment> getComments() {
    Dao dao = new DossierPU();
    if(id != null && id > 0 && dao.isNotLoaded(comments)) {
      comments = dao.lazyLoader(Issue.class, this, "comments").comments;
    }
    return comments;
  }
 
  public void setComments(Set<IssueComment> comments) {
    this.comments = comments;
  }
 
  public Date getControlDate() {
    return controlDate;
  }
 
  public void setControlDate(Date controlDate) {
    this.controlDate = controlDate;
  }
 
  public Date getDelivery() {
    return delivery;
  }
 
  public void setDelivery(Date delivery) {
    this.delivery = delivery;
  }
 
  public String getDescription() {
    return description;
  }
 
  public void setDescription(String description) {
    this.description = description;
  }
 
  public Dossier getDossier() {
    return dossier;
  }
 
  public void setDossier(Dossier dossier) {
    this.dossier = dossier;
  }
 
  public Issue getDuplicated() {
    return duplicated;
  }
 
  public void setDuplicated(Issue duplicated) {
    this.duplicated = duplicated;
  }
 
  public Long getId() {
    return id;
  }
 
  public void setId(Long id) {
    this.id = id;
  }
 
  public Date getIssueDate() {
    return issueDate;
  }
 
  public void setIssueDate(Date issueDate) {
    this.issueDate = issueDate;
  }
 
  public boolean isMilestone() {
    return milestone;
  }
 
  public void setMilestone(boolean milestone) {
    this.milestone = milestone;
  }
 
  public Date getModification() {
    return modification;
  }
 
  public void setModification(Date modification) {
    this.modification = modification;
  }
 
  public IssuePriority getPriority() {
    return priority;
  }
 
  public void setPriority(IssuePriority priority) {
    this.priority = priority;
  }
 
  public boolean isPublishable() {
    return publishable;
  }
 
  public void setPublishable(boolean publishable) {
    this.publishable = publishable;
  }
 
  public RelatedItem getRelated() {
    return related;
  }
 
  public IssueResolution getResolution() {
    return resolution;
  }
 
  public void setResolution(IssueResolution resolution) {
    this.resolution = resolution;
  }
 
  public IssueStatus getStatus() {
    return status;
  }
 
  public Date getSolvedDate() {
    return solvedDate;
  }
 
  public void setSolvedDate(Date solvedDate) {
    this.solvedDate = solvedDate;
  }
 
  public void setStatus(IssueStatus status) {
    setStatus(status, null);
  }
 
  public void setStatus(IssueStatus status, Date endDate) {
    if(this.status != null && !this.status.isFinished() && status.isFinished()) {
      solvedDate = endDate != null ? endDate : new Date();
    } else if(!status.isFinished()) {
      solvedDate = null;
    }
    this.status = status;
  }
 
  public String getGrouping() {
    return grouping;
  }
 
  public void setGrouping(String grouping) {
    this.grouping = grouping;
  }
 
  public Set<IssuePredecessor> getSources() {
    Dao dao = new DossierPU();
    if(id != null && id > 0 && dao.isNotLoaded(sources)) {
      sources = dao.lazyLoader(Issue.class, this, "sources").sources;
    }
    return sources;
  }
 
  public void setSources(Set<IssuePredecessor> sources) {
    this.sources = sources;
  }
 
  public Set<IssuePredecessor> getTargets() {
    Dao dao = new DossierPU();
    if(id != null && id > 0 && dao.isNotLoaded(targets)) {
      targets = dao.lazyLoader(Issue.class, this, "targets").targets;
    }
    return targets;
  }
 
  public void setTargets(Set<IssuePredecessor> targets) {
    this.targets = targets;
  }
 
  public IssueType getType() {
    return type;
  }
 
  public void setType(IssueType type) {
    this.type = type;
  }
 
  public double getExpenses() {
    return expenses;
  }
 
  public void setExpenses(double expenses) {
    this.expenses = expenses;
  }
 
  public double getHours() {
    return hours;
  }
 
  public void setHours(double hours) {
    this.hours = hours;
  }
 
  public double getPrice() {
    return price;
  }
 
  public void setPrice(double price) {
    this.price = price;
  }
 
  public Date getStartDate() {
      return startDate;
  }
 
  public void setStartDate(Date startDate) {
      this.startDate = startDate;
  }
 
  public DossierVersion getVersion() {
    return version;
  }
 
  public void setVersion(DossierVersion version) {
    this.version = version;
  }
 
  /* IDaoEntity */
 
  @Override
  public Object entityId() {
    return id;
  }
 
  @Override
  public boolean isEmpty() {
    return Strings.isBlank(description) || dossier == null;
  }
  
  
  /* Helpers */
  
  public String getFullDescription() {
    return getFullDescription(true);
  }
  
  public String getFullDescription(boolean withSubject) {
    return description + 
            (dossier != null ? Chars.forward().spaced() + dossier.getFullDescription(withSubject) : "");
  }
  
  public boolean isKnowledgeBase() {
    if(dossier != null) {
      return dossier.isKnowledgeBase();
    }
    return false;
  }
  
  public IssueComment getLastComment() {
    IssueComment last = null;
    for(IssueComment comment : getComments()) {
      if(last == null || last.getModification().before(comment.getModification())) {
        last = comment;
      }
    }
    return last;
  }
  
  /* Duplicates */
  
  private transient Collection<Issue> _duplicates;
  
  public Collection<Issue> getDuplicates() {
    if(_duplicates == null) {
      Dao dao = new DossierPU();
      _duplicates = dao.getResultList(
              "select distinct i from Issue i " +
              "where i.duplicated = ?",
              new Object[] { this });
    }
    return _duplicates;
  }
  
  /* Reporter helper */
  
  public IssueParticipant addReporter(Object contact) {
    IContact c = Contacts.getEmpty();
    c.setContact(contact);
    return addParticipant(c, IssueParticipantRole.ISSUE_REPORTER);
  }
 
  public IssueParticipant addResponsible(Object contact) {
    IContact c = Contacts.getEmpty();
    c.setContact(contact);
    return addParticipant(c, IssueParticipantRole.ISSUE_RESPONSIBLE);
  }
 
  public IssueParticipant addQA(Object contact) {
    IContact c = Contacts.getEmpty();
    c.setContact(contact);
    return addParticipant(c, IssueParticipantRole.ISSUE_QA);
  }
 
  public IssueParticipant addReporter(IContact contact) {
    return addParticipant(contact, IssueParticipantRole.ISSUE_REPORTER);
  }
 
  public IssueParticipant addResponsible(IContact contact) {
    return addParticipant(contact, IssueParticipantRole.ISSUE_RESPONSIBLE);
  }
 
  public IssueParticipant addQA(IContact contact) {
    return addParticipant(contact, IssueParticipantRole.ISSUE_QA);
  }
 
  public IssueParticipant addParticipant(String id, IssueParticipantRole role) {
    if(id == null) return null;
    return addParticipant(Contacts.getContactById(id), role);
  }
 
  public IssueParticipant addParticipant(IContact contact, IssueParticipantRole role) {
    if(contact == null) return null;
    IssueParticipant ip = new IssueParticipant();
    ip.setIssue(this);
    ip.setIdContact(contact.getId());
    ip.setName(contact.getName());
    ip.setRole(role);
    getParticipants().add(ip);
    return ip;
  }
 
  public IssueParticipant removeParticipant(IContact contact, IssueParticipantRole role) {
    if(contact == null) return null;
    Iterator<IssueParticipant> it = getParticipants().iterator();
    while(it.hasNext()) {
      IssueParticipant ip = it.next();
      if(ip.getIdContact().equals(contact.getId()) &&
         ip.getRole().equals(role)) {
        it.remove();
        return ip;
      }
    }
    return null;
  }
 
  /* Participants helper */
 
  private transient ParticipantSet _participants;
  
  public ParticipantSet getFullParticipants() {
    if(_participants == null) {
      _participants = new ParticipantSet(getParticipants());
      if(dossier != null) _participants.addAll(dossier.getFullParticipants());
    }
    return _participants;
  }
 
  public ParticipantSet<IssueParticipant> getIssueParticipants() {
    return new ParticipantSet<>(getParticipants());
  }
 
  /* Data helper */
 
  public boolean hasData() {
    return expenses != 0 || hours != 0 || price != 0;
  }
 
  public double getSumExpenses() {
    double r = 0;
    for(IssueComment c : getComments()) {
      r += c.getExpenses();
    }
    return r;
  }
 
  public double getSumHours() {
    double r = 0;
    for(IssueComment c : getComments()) {
      r += c.getHours();
    }
    return r;
  }
 
  public double getSumPrice() {
    double r = 0;
    for(IssueComment c : getComments()) {
      r += c.getPrice();
    }
    return r;
  }
  
  public static Issue getDefaultIssue() {
    Issue i = new Issue();
    i.setType(IssueType.TYPE_TASK);
    i.setStatus(IssueStatus.STATUS_NEW);
    i.setPriority(IssuePriority.PRIORITY_HAS_WORKAROUND);
    i.setResolution(IssueResolution.RESOLUTION_FIXED);
    i.setIssueDate(new java.util.Date());
    i.setPublishable(true);
    return i;
  }
 
  public String getIssueURL() {
    String issueUrl;
    if(getStatus().isFinished()) {
      issueUrl = (String) getDossier().getFieldMap()
              .getOrDefault("issueClosedUrl", "/app/frame?" + Interceptors.parameters("issue", getId().toString()).encoded());
    } else {
      issueUrl = (String) getDossier().getFieldMap()
              .getOrDefault("issueOpenUrl", "/app/frame?" + Interceptors.parameters("issue", getId().toString()).encoded());
    }
    issueUrl = issueUrl.replaceAll("\\#DID", getDossier().getId() + "")
                       .replaceAll("\\#IID", getId() + "");
    return issueUrl;
  }
  
  /* Predecessors */
 
  private transient Collection<Issue> _body, _next;
  
  public Collection<Issue> getBodyIssues() {
    if(_body == null) {
      Dao dao = new DossierPU();
      _body = dao.getResultList(
              "select distinct ip.target from IssuePredecessor ip " +
              "where ip.source = ? " +        
              "and ip.type = ? ",
              new Object[] { this, IssuePredecessorType.START_WHEN_STARTS });
    }
    return _body;
  }
  
  public double getBodyPercentDone() {
    getBodyIssues();
    if(!_body.isEmpty()) {
      double d = 0.0;
      for(Issue i : _body) {
        if(i.getStatus().isFinished()) {
          d += 1.0;
        }
      }
      return new Round(d / ((double) _body.size()) * 100.0).decimals(2).value();
    }
    return 0.0;
  }
  
  public Collection<Issue> getNextIssues() {
    if(_next == null) {
      Dao dao = new DossierPU();
      _next = dao.getResultList(
              "select distinct ip.target from IssuePredecessor ip " +
              "where ip.source = ? " +        
              "and ip.target.grouping = ip.source.grouping " +        
              "and ip.type = ? ",
              new Object[] { this, IssuePredecessorType.START_WHEN_ENDS });
    }
    return _next;
  }
  
  /* XML Serializer */
  
  public MappingSet getSerializerMappings() {
    MappingSet set = new MappingSet();
    set.addMapping(Dossier.class, 1, 
            new String[] { "id" }, 
            null);
    return set;
  }
  
}