ContractExpiry.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2013 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.financials.entity;
 
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import org.amic.util.date.CheckDate;
import org.turro.financials.model.contract.ContractUsualSet;
import org.turro.financials.model.contract.ContractWrapper;
import org.turro.financials.model.document.AmountTaxable;
import org.turro.financials.model.document.DocumentDefinitionWrapper;
import org.turro.jpa.entity.IDaoEntity;
import org.turro.scheduler.constraints.WeekDay;
 
@Entity
public class ContractExpiry implements java.io.Serializable, IDaoEntity {
  
  @Id
  @GeneratedValue(strategy=GenerationType.IDENTITY)
  @Column(name="IDENTIFIER")
  private long id;
 
  @ManyToOne
  private ContractFlow contractFlow;
  
  @ManyToOne
  private DocumentDefinition documentDefinition;
  
  @ManyToOne
  private LineType lineType;
 
  private String concept;
  
  private int daysToAdd, dayOfWeek;
  
  private double percentValue, amountValue;
 
  @ElementCollection(fetch=FetchType.EAGER)
  private Set<Integer> daysOfMonth = new HashSet<Integer>();
 
  @ElementCollection(fetch=FetchType.EAGER)
  private Set<Integer> excludedMonths = new HashSet<Integer>();
 
  public long getId() {
    return id;
  }
 
  public void setId(long id) {
    this.id = id;
  }
 
  public ContractFlow getContractFlow() {
    return contractFlow;
  }
 
  public void setContractFlow(ContractFlow contractFlow) {
    this.contractFlow = contractFlow;
  }
 
  public DocumentDefinition getDocumentDefinition() {
    return documentDefinition;
  }
 
  public void setDocumentDefinition(DocumentDefinition documentDefinition) {
    this.documentDefinition = documentDefinition;
  }
 
  public LineType getLineType() {
    return lineType;
  }
 
  public void setLineType(LineType lineType) {
    this.lineType = lineType;
  }
 
  public String getConcept() {
    return concept;
  }
 
  public void setConcept(String concept) {
    this.concept = concept;
  }
 
  public int getDaysToAdd() {
    return daysToAdd;
  }
 
  public void setDaysToAdd(int daysToAdd) {
    this.daysToAdd = daysToAdd;
  }
 
  public Set<Integer> getDaysOfMonth() {
    return daysOfMonth;
  }
 
  public void setDaysOfMonth(Set<Integer> daysOfMonth) {
    this.daysOfMonth = daysOfMonth;
  }
 
  public int getDayOfWeek() {
    return dayOfWeek;
  }
 
  public void setDayOfWeek(int dayOfWeek) {
    this.dayOfWeek = dayOfWeek;
  }
 
  public Set<Integer> getExcludedMonths() {
    return excludedMonths;
  }
 
  public void setExcludedMonths(Set<Integer> excludedMonths) {
    this.excludedMonths = excludedMonths;
  }
 
  public double getPercentValue() {
    return percentValue;
  }
 
  public void setPercentValue(double percentValue) {
    this.percentValue = percentValue;
  }
 
  public double getAmountValue() {
    return amountValue;
  }
 
  public void setAmountValue(double amountValue) {
    this.amountValue = amountValue;
  }
  
  /* IDaoEntity */
 
  @Override
  public Object entityId() {
    return id;
  }
 
  @Override
  public boolean isEmpty() {
    return documentDefinition == null ||
            (percentValue == 0.0d && amountValue == 0.0d);
  }
 
  /* Helpers */
  
  public double generateFlow(Document document, double pendingAmount, int count) {
    Document ndoc = new Document();
    ndoc.setDocumentDate(newDate(document.getDocumentDate()));
    ndoc.setContract(document.getContract());
    ndoc.setCurrency(document.getCurrency());
    ndoc.setDocumentNumber(document.getDocumentNumber() + "/" + count);
    ndoc.setReceiptDate(ndoc.getDocumentDate());
    ndoc.setDocumentDefinition(documentDefinition);
    ndoc.setDraft(document.isDraft());
    ndoc.setNotes(document.getNotes());
    pendingAmount = appendAmount(document, ndoc, getStore(ndoc), pendingAmount);
    DocumentRelation dr = new DocumentRelation();
    dr.setAncestor(document);
    dr.setDescendant(ndoc);
    document.getDescendants().add(dr);
    return pendingAmount;
  }
 
  private Date newDate(Date date) {
    CheckDate d = new CheckDate(date);
    d.addDays(daysToAdd);
    boolean correct = false;
    while(!correct) {
      while(isExcluded(d)) {
        d.addDays(1);
      }
      if(!daysOfMonth.isEmpty()) {
        boolean done = false;
        do {
          for(Integer i : daysOfMonth) {
            done = i == d.getDay();
            if(done) break;
          }
          if(!done) d.addDays(1);
        } while(!done);
      }
      if(dayOfWeek > -1) {
        while(d.getDayOfWeek() != WeekDay.map(dayOfWeek)) {
          d.addDays(1);
        }
      }
      correct = !isExcluded(d);
    }
    return d.getDate();
  }
  
  private boolean isExcluded(CheckDate d) {
    for(Integer i : excludedMonths) {
      if(d.getMonth() == i) return true;
    }
    return false;
  }
  
  public double appendAmount(Document source, Document destination, Contract store, double pendingAmount) {
    int count = 0;
    if(documentDefinition.hasColumn(DocumentColumn.DCOL_TAX)) {
      for(AmountTaxable at : source.getAmounts().getTaxables()) {
        DocumentLine dl = new DocumentLine();
        dl.setDocument(destination);
        if(concept != null) {
          dl.setConcept(concept + " [" + at.getTax() + "]");
        }
        pendingAmount = assignAmount(dl, getAmount(at.getAmount()), pendingAmount);
        dl.setTax(at.getTax());
        dl.setLineType(lineType);
        dl.setContractPreference(source.getDefaultContractPreference());
        dl.setStore(store);
        dl.setLineOrder(count++);
        destination.getDocumentLines().add(dl);
      }
    } else {
      DocumentLine dl = new DocumentLine();
      dl.setDocument(destination);
      if(concept != null) {
        dl.setConcept(concept);
      }
      pendingAmount = assignAmount(dl, getAmount(source.getTotalAmount()), pendingAmount);
      dl.setLineType(lineType);
      dl.setContractPreference(source.getDefaultContractPreference());
      dl.setStore(store);
      dl.setLineOrder(count++);
      destination.getDocumentLines().add(dl);
    }
    return pendingAmount;
  }
 
  private double getAmount(double amount) {
    if(amountValue != 0.0d) {
      return amountValue;
    }
    if(percentValue != 0.0d) {
      return amount * percentValue;
    }
    return 0;
  }
 
  private Contract getStore(Document document) {
    Collection<Contract> stores = new DocumentDefinitionWrapper(documentDefinition)
            .getRelatedStores(contractFlow.getContract());
    if(stores.isEmpty()) {
      stores = new DocumentDefinitionWrapper(documentDefinition)
            .getRelatedStores();
    }
    ContractWrapper.clearInactives(stores);
    return stores.isEmpty() ? null : new ContractUsualSet(stores, true, document.getUsualPath() + "st:").iterator().next();
  }
 
  private double assignAmount(DocumentLine dl, double amount, double pendingAmount) {
    if(amount > pendingAmount) {
      amount = pendingAmount;
    }
    dl.setPrice(amount);
    pendingAmount -= amount;
    return pendingAmount;
  }
 
}