Register.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.financials.entity;
 
import java.util.*;
import javax.persistence.*;
import org.amic.util.date.CheckDate;
import org.turro.elephant.db.IdUtils;
import org.turro.financials.db.FinancialsPU;
import org.turro.financials.model.Amount;
import org.turro.financials.model.AmountSet;
import org.turro.financials.model.document.DocumentAmounts;
import org.turro.jpa.entity.IDaoEntity;
import org.turro.reflection.MappingSet;
 
@Entity
@Table(indexes={
  @Index(name="IndexRegister", columnList="idRegister"),
  @Index(name="IndexDate", columnList="registerDate")
})
public class Register implements java.io.Serializable, IDaoEntity {
 
  @Id
  @GeneratedValue(strategy=GenerationType.IDENTITY)
  @Column(name="IDENTIFIER")
  private long id;
 
  @Column(nullable=false)
  @Temporal(value = TemporalType.DATE)
  private Date registerDate;
 
  @Column(nullable=false)
  private long idRegister;
 
  @ManyToOne
  private RegisterView view;
 
  private boolean exclude;
 
  private boolean closing;
  
  private boolean regularizeVAT;
  
  private boolean regularizeIRPF;
 
  @ManyToOne
  private Document document;
 
  @OneToMany(mappedBy = "register", fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval=true)
  private Set<BookRegister> bookRegisters = new HashSet<BookRegister>();
 
  @OneToMany(mappedBy = "register", fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval=true)
  //@OrderBy(value="entryOrder")
  private Set<RegisterEntry> registerEntries = new HashSet<RegisterEntry>();
 
  public Set<BookRegister> getBookRegisters() {
    return bookRegisters;
  }
 
  public void setBookRegisters(Set<BookRegister> bookRegisters) {
    this.bookRegisters = bookRegisters;
  }
 
  public boolean isClosing() {
    return closing;
  }
 
  public void setClosing(boolean closing) {
    this.closing = closing;
  }
 
  public Document getDocument() {
    return document;
  }
 
  public void setDocument(Document document) {
    this.document = document;
  }
 
  public boolean isExclude() {
    return exclude;
  }
 
  public void setExclude(boolean exclude) {
    this.exclude = exclude;
  }
 
  public long getId() {
    return id;
  }
 
  public void setId(long id) {
    this.id = id;
  }
 
  public long getIdRegister() {
    return idRegister;
  }
 
  public void setIdRegister(long idRegister) {
    this.idRegister = idRegister;
  }
 
  public Date getRegisterDate() {
    return registerDate;
  }
 
  public void setRegisterDate(Date registerDate) {
    if(this.registerDate != null && !new CheckDate(this.registerDate).sameYear(registerDate)) {
      bookRegisters.clear();
      idRegister = 0;
    }
    this.registerDate = registerDate;
  }
 
  public Set<RegisterEntry> getRegisterEntries() {
    return registerEntries;
  }
 
  public void setRegisterEntries(Set<RegisterEntry> registerEntries) {
    this.registerEntries = registerEntries;
  }
 
  public boolean isRegularizeIRPF() {
    return regularizeIRPF;
  }
 
  public void setRegularizeIRPF(boolean regularizeIRPF) {
    this.regularizeIRPF = regularizeIRPF;
  }
 
  public boolean isRegularizeVAT() {
    return regularizeVAT;
  }
 
  public void setRegularizeVAT(boolean regularizeVAT) {
    this.regularizeVAT = regularizeVAT;
  }
 
  public RegisterView getView() {
    return view;
  }
 
  public void setView(RegisterView view) {
    this.view = view;
  }
 
  /* IDaoEntity */
  
  @Override
  public Object entityId() {
    return id;
  }
 
  @Override
  public boolean isEmpty() {
    removeEmpties();
    return registerEntries.isEmpty() ||
            view == null ||
            registerDate == null;
  }
 
  @Override
  public void prepareSave() {
    IDaoEntity.super.prepareSave();
    if(idRegister == 0) {
      idRegister = IdUtils.getMaxLongIdFromLong(
              new FinancialsPU(), "Register", "idRegister",
              new String[] {
                "year(registerDate) = " + new CheckDate(registerDate).getYear(),
                "view.id = " + view.getId()
              });
    }
  }
 
  @Override
  public Collection<Collection> collections() {
    return List.of(getBookRegisters(), getRegisterEntries());
  }
 
  /* Helpers */
 
  public double getDebit() {
    double r = 0;
    for(RegisterEntry re : registerEntries) {
      r += re.getDebit();
    }
    return r;
  }
  
  public double getCredit() {
    double r = 0;
    for(RegisterEntry re : registerEntries) {
      r += re.getCredit();
    }
    return r;
  }
 
  public void reuseLines(Collection<RegisterEntry> entries) {
    Iterator<RegisterEntry> it1 = getRegisterEntries().iterator();
    Iterator<RegisterEntry> it2 = entries.iterator();
    RegisterEntry re1, re2 = null;
    while(it1.hasNext()) {
      re1 = it1.next();
      if(it2.hasNext()) {
        re2 = it2.next();
      } else {
        re2 = null;
      }
      // new lines is finished
      if(re2 == null) {
        re1.clearLine();
      } else {
        re1.assignValuesFrom(re2);
        re1.setRegister(this);
      }
      re2 = null;
    }
    // there are still new lines
    if(re2 != null) {
      re1 = new RegisterEntry();
      re1.assignValuesFrom(re2);
      re1.setRegister(this);
      registerEntries.add(re1);
    }
    while(it2.hasNext()) {
      re2 = it2.next();
      re1 = new RegisterEntry();
      re1.assignValuesFrom(re2);
      re1.setRegister(this);
      registerEntries.add(re1);
    }
  }
 
  /* Books */
  
  public void killUnusedBooks(Set<Long> bookDefs) {
    Iterator<BookRegister> it = getBookRegisters().iterator();
    while(it.hasNext()) {
      boolean used = false;
      BookRegister br = it.next();
      for(long bd : bookDefs) {
        if(br.getBookDefinition().getId() == bd) {
          used = true;
          break;
        }
      }
      if(!used) {
        it.remove();
      }
    }
  }
 
  public String getBookString() {
    StringBuilder sb = new StringBuilder();
    for(BookRegister br : getBookRegisters()) {
      if(sb.length() > 0) {
        sb.append(" | ");
      }
      sb.append(br.getBookDefinition().getDescription());
      sb.append(" [" + (br.getBookOrder() == 0 ? "<auto>" : br.getBookOrder()) +"]");
    }
    return sb.toString();
  }
 
  private transient AmountSet as;
  
  public AmountSet getAmounts(Collection<String> majors) {
    if(as == null) {
      as = new AmountSet();
      if(document != null) {
        for(RegisterEntry re : registerEntries) {
          Account acc = re.getAccount();
          for(String major : majors) {
            if(acc.getId().startsWith(major)) {
              double tax = Integer.valueOf(acc.getId().substring(5)) / 10.0;
              if(tax > 0) {
                double amount = re.getDebit() + re.getCredit();
                as.addAmount(new Amount(tax, amount / (tax / 100.0), 0.0, 0.0, 2));
              }
              break;
            }
          }
        }
      }
    }
    return as;
  }
  
  private transient DocumentAmounts da;
  
  public DocumentAmounts getDocumentAmounts() {
    if(da == null) {
      if(document != null) {
        da = document.getAmounts();
      }
    }
    return da;
  }
  
  /* XML Serializer */
  
  public MappingSet getSerializerMappings() {
    MappingSet set = new MappingSet();
    set.addMapping(Register.class, 1,
            new String[] { "idRegister", "registerDate" }, 
            new String[] { "view", "registerEntries" });
    set.addMapping(RegisterView.class, 2,
            new String[] { "id", "name" }, 
            null);
    set.addMapping(RegisterEntry.class, 2,
            new String[] { "debit", "credit", "approved", "conciliated" }, 
            new String[] { "account" } );
    set.addMapping(Account.class, 3,
            new String[] { "id", "description" }, 
            null);
    return set;
  }
 
}