Category.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.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.Index;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OrderBy;
import javax.persistence.Table;
import org.turro.string.Strings;
import org.turro.action.Contacts;
import org.turro.collections.Hierarchy;
import org.turro.dossier.db.DossierPU;
import org.turro.dossier.dossier.ParticipantSet;
import org.turro.elephant.db.IdUtils;
import org.turro.elephant.db.WhereClause;
import org.turro.jpa.Dao;
import org.turro.jpa.entity.IDaoEntity;
import org.turro.plugin.contacts.IContact;
import org.turro.util.Chars;
 
@Entity
@Table(indexes={
  @Index(name="PathIndex", columnList="uniquePath")
})
public class Category implements java.io.Serializable, IDaoEntity {
 
  @Id
  @Column(name="IDENTIFIER")
  private Long id;
 
  private String description;
 
  private String fullDescription, uniquePath;
  
  private boolean knowledgeBase, ownsProjects;
 
  @ManyToOne
  private Category parent;
 
  @OneToMany(mappedBy = "parent", fetch = FetchType.EAGER)
  @OrderBy(value="description")
  private Set<Category> children = new HashSet<Category>();
 
  @OneToMany(mappedBy = "category", fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval=true)
  @OrderBy(value="name")
  private Set<CategoryParticipant> participants = new HashSet<CategoryParticipant>();
 
  @OneToMany(mappedBy = "category", fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval=true)
  @OrderBy(value="orderNumber")
  private Set<DescriptorDefinition> descriptors = new HashSet<DescriptorDefinition>();
 
  @OneToMany(mappedBy = "category", fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval=true)
  private Set<WorthDefinition> worths = new HashSet<WorthDefinition>();
 
  public Set<Category> getChildren() {
    return children;
  }
 
  public void setChildren(Set<Category> children) {
    this.children = children;
  }
 
  public String getDescription() {
    return description;
  }
 
  public void setDescription(String description) {
    this.description = description;
  }
 
  public Long getId() {
    return id;
  }
 
  public void setId(Long id) {
    this.id = id;
  }
 
  public Category getParent() {
    return parent;
  }
 
  public void setParent(Category parent) {
    this.parent = parent;
  }
 
  public Set<CategoryParticipant> getParticipants() {
    Dao dao = new DossierPU();
    if(id != null && id > 0 && dao.isNotLoaded(participants)) {
      participants = dao.lazyLoader(Category.class, this, "participants").participants;
    }
    return participants;
  }
 
  public void setParticipants(Set<CategoryParticipant> participants) {
    this.participants = participants;
  }
 
  public String getFullDescription() {
    return fullDescription;
  }
 
  public void setFullDescription(String fullDescription) {
    this.fullDescription = fullDescription;
  }
 
  public String getUniquePath() {
    return uniquePath;
  }
 
  public void setUniquePath(String uniquePath) {
    this.uniquePath = uniquePath;
  }
 
  public boolean isKnowledgeBase() {
    return knowledgeBase;
  }
 
  public void setKnowledgeBase(boolean knowledgeBase) {
    this.knowledgeBase = knowledgeBase;
  }
 
  public boolean isOwnsProjects() {
    return ownsProjects;
  }
 
  public void setOwnsProjects(boolean ownsProjects) {
    this.ownsProjects = ownsProjects;
  }
 
  public Set<DescriptorDefinition> getDescriptors() {
    return descriptors;
  }
 
  public void setDescriptors(Set<DescriptorDefinition> descriptors) {
    this.descriptors = descriptors;
  }
 
  public Set<WorthDefinition> getWorths() {
    return worths;
  }
 
  public void setWorths(Set<WorthDefinition> worths) {
    this.worths = worths;
  }
 
  /* IDaoEntity */
  
  @Override
  public Object entityId() {
    return id;
  }
 
  @Override
  public boolean isEmpty() {
    return Strings.isBlank(description);
  }
 
  @Override
  public void prepareSave() {
    IDaoEntity.super.prepareSave();
    if(id == null || id == 0) {
      id = IdUtils.getNewLongIdFromLong(new DossierPU(), "Category", "id");
    } else {
      if(Hierarchy.checkLoop(this, (c) -> c.id, (c) -> c.parent)) {
        parent = null;
      }
    }
  }
 
  /* Helpers */
  
  public CategoryParticipant addOwner(IContact contact) {
    if(contact == null) return null;
    CategoryParticipant p = new CategoryParticipant();
    p.setCategory(this);
    p.setIdContact(contact.getId());
    p.setName(contact.getName());
    p.setRole(ParticipantRole.PARTICIPANT_OWNER);
    getParticipants().add(p);
    return p;
  }
 
  public CategoryParticipant addAssistant(IContact contact) {
    if(contact == null) return null;
    CategoryParticipant p = new CategoryParticipant();
    p.setCategory(this);
    p.setIdContact(contact.getId());
    p.setName(contact.getName());
    p.setRole(ParticipantRole.PARTICIPANT_ASSISTANT);
    getParticipants().add(p);
    return p;
  }
 
  public boolean isDirectOwner(IContact contact) {
    for(CategoryParticipant p : getParticipants()) {
      if(p.getRole().equals(ParticipantRole.PARTICIPANT_OWNER)) {
        if(contact.getId().equals(p.getIdContact())) {
          return true;
        }
      }
    }
    return false;
  }
  
  public boolean isBranchAdmin(IContact contact) {
    for(CategoryParticipant p : getParticipants()) {
      if(p.getRole().equals(ParticipantRole.PARTICIPANT_OWNER) && 
              contact.getId().equals(p.getIdContact()) &&
              p.isAdmin()) {
        return true;
      }
    }
    return false;
  }
  
  public List<IDossierParticipant> getDirectOwners() {
    List<IDossierParticipant> list = new ArrayList<>();
    for(CategoryParticipant p : getParticipants()) {
      if(p.getRole().equals(ParticipantRole.PARTICIPANT_OWNER)) {
        list.add(p);
      }
    }
    return list;
  }
  
  public String getPath() {
    if(!Strings.isBlank(fullDescription)) {
      return "/" + fullDescription.replaceAll("\\s*\\" + Chars.backward() + "\\s*", "\\/");  
    }
    return null;
  }
  
  public static String getPathToFullDescription(String path) {
    if(!Strings.isBlank(path)) {
      return path.substring(1).replaceAll("\\/", " \\" + Chars.backward() + " ");  
    }
    return null;
  }
  
  public ParticipantSet<IDossierParticipant> getFullParticipants() {
    ParticipantSet<IDossierParticipant> set = new ParticipantSet<>(getParticipants());
    Category c = getParent();
    while(c != null) {
      set.addAll(c.getParticipants());
      c = c.getParent();
    }
    return set;
  }
  
  public IContact getDefaultResponsible(ParticipantRole role) {
    for(CategoryParticipant p : getParticipants()) {
      if(p.getRole().equals(role)) {
        return Contacts.getContactById(p.getIdContact());
      }
    }
    if(getParent() != null) {
      return getParent().getDefaultResponsible(role);
    }
    return null;
  }
  
  public List<Dossier> getDossiers() {
    WhereClause wc = new WhereClause();
    wc.addClause("select d from Dossier d");
    wc.addClause("where d.category = :category");
    wc.addNamedValue("category", this);
    Dao dao = new DossierPU();
    return dao.getResultList(Dossier.class, wc);
  }
 
}