OrderReference.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.erp.entity;
 
import java.util.*;
import javax.persistence.*;
import org.turro.string.Strings;
import org.hibernate.annotations.SortType;
import org.turro.elephant.impl.util.StringParser;
import org.turro.erp.db.ErpPU;
import org.turro.erp.workorder.ReferenceStatusWrapper;
import org.turro.financials.db.FinancialsPU;
import org.turro.financials.entity.Contract;
import org.turro.financials.entity.Product;
import org.turro.jpa.Dao;
import org.turro.jpa.entity.CachedEntity;
 
@Entity
public class OrderReference implements java.io.Serializable {
 
  @Id
  @GeneratedValue(strategy=GenerationType.IDENTITY)
  @Column(name="IDENTIFIER")
  private long id;
 
  @ManyToOne
  private org.turro.erp.entity.WorkOrder workOrder;
  
  @OneToOne(cascade = CascadeType.ALL, orphanRemoval = true)
  private CustomerOrder customerOrder;
  
  @Lob
  @Column(length=4096)
  private String description;
 
  private long productId;
  
  private int orderRef;
 
  private boolean validated, noFraction, delivered;
  
  private double quantity, price, tax, retention;
  
  private long serviceId;
  
  @ManyToOne
  private org.turro.erp.entity.Project project;
 
  @OneToMany(fetch = FetchType.EAGER, cascade= CascadeType.ALL, orphanRemoval=true)
  private Set<Budget> budgets = new HashSet<Budget>();
 
  @OneToMany(fetch = FetchType.EAGER, cascade= CascadeType.ALL, orphanRemoval=true)
  @OrderBy("orderRef")
  private Set<Breakdown> breakdowns = new HashSet<Breakdown>();
 
  @OneToMany(mappedBy = "orderReference", fetch = FetchType.EAGER, cascade = CascadeType.REMOVE, orphanRemoval=true)
  @org.hibernate.annotations.Sort(type=SortType.COMPARATOR, comparator=org.turro.erp.entity.TaskComparator.class)
  private SortedSet<Task> tasks = new TreeSet<Task>(new org.turro.erp.entity.TaskComparator());
 
  public Set<Breakdown> getBreakdowns() {
    return breakdowns;
  }
 
  public void setBreakdowns(Set<Breakdown> breakdowns) {
    this.breakdowns = breakdowns;
  }
 
  public Set<Budget> getBudgets() {
    return budgets;
  }
 
  public void setBudgets(Set<Budget> budgets) {
    this.budgets = budgets;
  }
 
  public CustomerOrder getCustomerOrder() {
    return customerOrder;
  }
 
  public void setCustomerOrder(CustomerOrder customerOrder) {
    this.customerOrder = customerOrder;
    if(customerOrder != null) {
      customerOrder.setServiceId(serviceId);
      customerOrder.setCustomerId(workOrder.getContractId());
    }
  }
 
  public boolean isDelivered() {
    return delivered;
  }
 
  public void setDelivered(boolean delivered) {
    this.delivered = delivered;
  }
 
  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 boolean isNoFraction() {
    return noFraction;
  }
 
  public void setNoFraction(boolean noFraction) {
    this.noFraction = noFraction;
  }
 
  public int getOrderRef() {
    return orderRef;
  }
 
  public void setOrderRef(int orderRef) {
    this.orderRef = orderRef;
  }
 
  public double getPrice() {
    return price;
  }
 
  public void setPrice(double price) {
    this.price = price;
  }
 
  public long getProductId() {
    return productId;
  }
 
  public void setProductId(long productId) {
    this.productId = productId;
  }
 
  public double getQuantity() {
    return quantity;
  }
 
  public void setQuantity(double quantity) {
    this.quantity = quantity;
  }
 
  public double getRetention() {
    return retention;
  }
 
  public void setRetention(double retention) {
    this.retention = retention;
  }
 
  public long getServiceId() {
    return serviceId;
  }
 
  public void setServiceId(long serviceId) {
    this.serviceId = serviceId;
  }
 
  public SortedSet<Task> getTasks() {
    return tasks;
  }
 
  public void setTasks(SortedSet<Task> tasks) {
    this.tasks = tasks;
  }
 
  public double getTax() {
    return tax;
  }
 
  public void setTax(double tax) {
    this.tax = tax;
  }
 
  public boolean isValidated() {
    return validated;
  }
 
  public void setValidated(boolean validated) {
    this.validated = validated;
  }
 
  public WorkOrder getWorkOrder() {
    return workOrder;
  }
 
  public void setWorkOrder(WorkOrder workOrder) {
    this.workOrder = workOrder;
  }
 
  /* Financials Helpers */
 
  private transient CachedEntity<Product, Long> product = 
          new CachedEntity<Product, Long>() {
    @Override
    protected Dao createDao() {
      return new FinancialsPU();
    }
  };
  
  public Product getProduct() {
    return product.getEntity(productId);
  }
 
  public void setProduct(Product product) {
    productId = this.product.setEntity(product);
  }
 
  private transient CachedEntity<Contract, Long> service = 
          new CachedEntity<Contract, Long>() {
    @Override
    protected Dao createDao() {
      return new FinancialsPU();
    }
  };
  
  public Contract getService() {
    return service.getEntity(serviceId);
  }
 
  public void setService(Contract service) {
    serviceId = this.service.setEntity(service);
  }
 
  /* Description Helper */
  
  public String getOrderDescription() {
    return orderRef + " - " + getSomeDescription();
  }
  
  public String getSomeDescription() {
    return (productId > 0 ? getProduct().getProductString() : "") + 
            description;
  }
 
  public String getFullDescription() {
    return getSomeDescription() + " (" + workOrder.getFullDescription() + ") ";
  }
 
  public String getHtmlDescription() {
    return StringParser.toHTML(description);
  }
 
  /* Helpers */
 
  public boolean isEmpty() {
    boolean empty = (Strings.isBlank(description) && productId == 0) ||
            serviceId == 0;
    return empty;
  }
 
  public void clearEmptyLines() {
    Iterator<Task> it = tasks.iterator();
    while(it.hasNext()) {
      Task t = it.next();
      if(t.isEmpty()) {
        t.setOrderReference(null);
        it.remove();
      }
    }
    Iterator<Breakdown> itb = breakdowns.iterator();
    while(itb.hasNext()) {
      Breakdown b = itb.next();
      if(b.isEmpty()) {
        itb.remove();
      }
    }
  }
 
  public void prepareForSaving() {
    if(workOrder.getProductId() > 0) {
      productId = workOrder.getProductId();
    }
    clearEmptyLines();
    for(Task t : tasks) {
      t.prepareForSaving();
    }
  }
 
  public Set<Task> getUpdatedTasks() {
    if(id > 0) {
      Dao dao = new ErpPU();
      tasks = dao.lazyLoader(OrderReference.class, this, "tasks").tasks;
    }
    return tasks;
  }
 
  public void initFrom(CustomerOrder cu) {
    this.customerOrder = cu;
    description = cu.getDescription();
    noFraction = cu.isNoFraction();
    quantity = cu.getQuantity();
    price = cu.getPrice();
    serviceId = cu.getServiceId();
  }
  
  public ReferenceStatusWrapper getStatusWrapper() {
    return getStatusWrapper(null);
  }
  
  public ReferenceStatusWrapper getStatusWrapper(Date now) {
    return new ReferenceStatusWrapper(this, now);
  }
 
  private boolean hasDeliveredBudget() {
    if(budgets.isEmpty()) return false;
    for(Budget b : budgets) {
      if(b.isDelivered()) {
        return true;
      }
    }
    return false;
  }
 
  public boolean hasAcceptedBudget() {
    if(budgets.isEmpty()) return false;
    for(Budget b : budgets) {
      if(b.isAccepted()) {
        return true;
      }
    }
    return false;
  }
 
  public boolean requiresBudget() {
    return customerOrder != null && customerOrder.isWantBudget();
  }
  
  public boolean hasPendingBudget() {
    if(!hasAcceptedBudget() && (
            !budgets.isEmpty() || requiresBudget())) {
      return true;
    }
    return false;
  }
 
  public boolean hasBugdetStopper() {
    return hasAcceptedBudget() || hasDeliveredBudget();
  }
 
  public double getCost() {
    double cost = 0;
    for(Task t : getTasks()) {
      cost += t.getCost();
    }
    return cost;
  }
  
}