Document.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.text.SimpleDateFormat;
import java.util.*;
import javax.persistence.*;
import org.amic.util.date.CheckDate;
import org.turro.string.Strings;
import org.turro.contacts.Contact;
import org.turro.contacts.util.ContactList;
import org.turro.elephant.db.IdUtils;
import org.turro.entities.Entities;
import org.turro.entities.IElephantEntity;
import org.turro.financials.db.FinancialsPU;
import org.turro.financials.model.RelatedToLineTypeAdapter;
import org.turro.financials.model.contract.ContractWrapper;
import org.turro.financials.model.document.AmountTaxable;
import org.turro.financials.model.document.DocumentAmounts;
import org.turro.financials.model.document.DocumentAmountsByBook;
import org.turro.financials.model.document.DocumentDefinitionWrapper;
import org.turro.financials.model.document.DocumentLineComparator;
import org.turro.financials.model.document.LineTypeSet;
import org.turro.html.HtmlContent;
import org.turro.jpa.Dao;
import org.turro.jpa.entity.IDaoEntity;
import org.turro.mail.message.MailUtils;
import org.turro.plugin.scheduler.ScheduledAction;
import org.turro.reflection.MappingSet;
import org.turro.util.Chars;
import org.turro.util.PhraseBuilder;
 
@Entity
@Table(indexes={
  @Index(name="IndexDocument", columnList="documentNumber,documentDate")
})
public class Document implements java.io.Serializable, IDaoEntity, ScheduledAction {
 
  @Id
  @GeneratedValue(strategy=GenerationType.IDENTITY)
  @Column(name="IDENTIFIER")
  private long id;
 
  @ManyToOne(fetch=FetchType.LAZY)
  private DocumentDefinition documentDefinition;
 
  @ManyToOne
  private Contract contract;
 
  @Lob
  @Column(length=4096)
  private String notes;
 
  @Temporal(value = TemporalType.DATE)
  private Date receiptDate;
 
  @Column(nullable=false)
  @Temporal(value = TemporalType.DATE)
  private Date documentDate;
 
  @Column(nullable=false)
  private String documentNumber;
 
  private Currency currency;
 
  private double quote;
 
  private boolean draft, noAncestors = false, noDescendants = false;
  
  private String relatedPath;
 
  @ManyToOne
  private RegisterView forcedView;
 
  @OneToMany(mappedBy = "descendant", fetch = FetchType.EAGER)
  private Set<DocumentRelation> ancestors = new HashSet<>();
 
  @OneToMany(mappedBy = "ancestor", fetch = FetchType.EAGER)
  private Set<DocumentRelation> descendants = new HashSet<>();
 
  @OneToMany(mappedBy = "document", fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval=true)
  private Set<Register> registers = new HashSet<>();
 
  @OneToMany(mappedBy = "document", fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval=true)
  @OrderBy(value="lineOrder")
  private Set<DocumentLine> documentLines = new TreeSet<>(new DocumentLineComparator());
 
  public Set<DocumentRelation> getAncestors() {
    Dao dao = new FinancialsPU();
    if(id > 0 && dao.isNotLoaded(ancestors)) {
      ancestors = dao.lazyLoader(Document.class, this, "ancestors").ancestors;
    }
    return ancestors;
  }
 
  public void setAncestors(Set<DocumentRelation> ancestors) {
    this.ancestors = ancestors;
  }
 
  public Contract getContract() {
    return contract;
  }
 
  public void setContract(Contract contract) {
    this.contract = contract;
    _stores = null;
  }
 
  public Currency getCurrency() {
    if(currency == null && contract != null) {
      currency = contract.getCurrency();
    }
    return currency;
  }
 
  public void setCurrency(Currency currency) {
    this.currency = currency;
  }
 
  public Set<DocumentRelation> getDescendants() {
    Dao dao = new FinancialsPU();
    if(id > 0 && dao.isNotLoaded(descendants)) {
      descendants = dao.lazyLoader(Document.class, this, "descendants").descendants;
    }
   return descendants;
  }
 
  public Set<DocumentRelation> getUpdatedDescendants() {
    Dao dao = new FinancialsPU();
    if(id > 0) {
      descendants = dao.lazyLoader(Document.class, this, "descendants").descendants;
    }
    return descendants;
  }
 
  public void setDescendants(Set<DocumentRelation> descendants) {
    this.descendants = descendants;
  }
 
  public Date getDocumentDate() {
    return documentDate;
  }
 
  public void setDocumentDate(Date documentDate) {
    this.documentDate = documentDate;
  }
 
  public DocumentDefinition getDocumentDefinition() {
    Dao dao = new FinancialsPU();
    if(id > 0 && dao.isNotLoaded(documentDefinition)) {
      setDocumentDefinition(dao.lazyLoader(Document.class, this, "documentDefinition").documentDefinition);
    }
    return documentDefinition;
  }
 
  public void setDocumentDefinition(DocumentDefinition documentDefinition) {
    this.documentDefinition = documentDefinition;
    _stores = null;
  }
 
  public Set<DocumentLine> getDocumentLines() {
    return documentLines;
  }
 
  public void setDocumentLines(Set<DocumentLine> documentLines) {
    this.documentLines = documentLines;
  }
 
  public String getDocumentNumber() {
    return documentNumber;
  }
 
  public void setDocumentNumber(String documentNumber) {
    this.documentNumber = documentNumber;
  }
 
  public boolean isDraft() {
    return draft;
  }
 
  public void setDraft(boolean draft) {
    this.draft = draft;
  }
 
  public RegisterView getForcedView() {
    return forcedView;
  }
 
  public void setForcedView(RegisterView forcedView) {
    this.forcedView = forcedView;
  }
 
  public long getId() {
    return id;
  }
 
  public void setId(long id) {
    this.id = id;
  }
 
  public boolean isNoAncestors() {
    return noAncestors;
  }
 
  public void setNoAncestors(boolean noAncestors) {
    this.noAncestors = noAncestors;
  }
 
  public boolean isNoDescendants() {
    return noDescendants;
  }
 
  public void setNoDescendants(boolean noDescendants) {
    this.noDescendants = noDescendants;
  }
 
  public String getNotes() {
    return notes;
  }
 
  public void setNotes(String notes) {
    this.notes = notes;
  }
 
  public double getQuote() {
    return quote;
  }
 
  public void setQuote(double quote) {
    this.quote = quote;
  }
 
  public Date getReceiptDate() {
    return receiptDate;
  }
 
  public void setReceiptDate(Date receiptDate) {
    this.receiptDate = receiptDate;
  }
 
  public Set<Register> getRegisters() {
    return registers;
  }
 
  public void setRegisters(Set<Register> registers) {
    this.registers = registers;
  }
 
  public String getRelatedPath() {
    return relatedPath;
  }
 
  public void setRelatedPath(String relatedPath) {
    this.relatedPath = relatedPath;
  }
 
  /* IDaoEntity */
  
  @Override
  public Object entityId() {
    return id;
  }
 
  @Override
  public boolean isEmpty() {
    return documentLines.isEmpty() ||
            isBlank() ||
            !isValid() ||
            documentDate == null ||
            receiptDate == null;
  }
 
  @Override
  public void prepareSave() {
    IDaoEntity.super.prepareSave();
    if(Strings.isBlank(documentNumber)) {
      // Ensure not null value
      if(draft) {
        documentNumber = "";
      } else {
        if(forcedView == null) {
          documentNumber = IdUtils.getMaxLongIdFromString(
                  new FinancialsPU(), "Document", "documentNumber",
                  new String[] {
                    "year(receiptDate) = " + new CheckDate(receiptDate).getYear(),
                    "documentDefinition_identifier = " + getDocumentDefinition().getId(),
                    "forcedView_identifier is null"
                  }) + "";
        } else {
          documentNumber = IdUtils.getMaxLongIdFromString(
                  new FinancialsPU(), "Document", "documentNumber",
                  new String[] {
                    "year(receiptDate) = " + new CheckDate(receiptDate).getYear(),
                    "documentDefinition_identifier = " + getDocumentDefinition().getId(),
                    "forcedView_identifier = " + forcedView.getId()
                  }) + "";
        }
      }
    }
  }
 
  @Override
  public Collection<Collection> collections() {
    return List.of(getRegisters());
  }
  
  /* Helpers */
  
  public IElephantEntity getRelated() {
    return Entities.getController(relatedPath);
  }
 
  public boolean isValid() {
    return !(contract == null || getDocumentDefinition() == null);
  }
 
  public boolean isBlank() {
    Iterator<DocumentLine> itl = getDocumentLines().iterator();
    while(itl.hasNext()) {
      if(!itl.next().isEmpty()) {
        return false;
      }
    }
    return true;
  }
 
  public String getConcept() {
    PhraseBuilder pb = new PhraseBuilder();
    for(DocumentLine dl : documentLines) {
      pb.addWord(dl.getConcept());
    }
    return pb.toString();
  }
 
  public String getCleanFullNotes() {
    return HtmlContent.noTags(MailUtils.cleanLinks(getFullNotes()));
  }
  
  public String getFullNotes() {
    PhraseBuilder pb = new PhraseBuilder();
    pb.addWord(notes);
//    pb.addPendingSeparator(Chars.nl().repeat(2).toString());
//    pb.addWord(getContract().getNotes());
    pb.addPendingSeparator(Chars.nl().repeat(2).toString());
    ContractDefinitionNotes cdNotes = getContract().getContractDefinition().getNotes();
    if(cdNotes != null) {
      pb.addWord(cdNotes.getNotes());
    }
    return pb.toString();
  }
  
  public void clearEmpties() {
    Iterator<DocumentLine> itl = getDocumentLines().iterator();
    while(itl.hasNext()) {
      if(itl.next().isEmpty()) {
        itl.remove();
      }
    }
  }
 
  public void assignTableOrder(Collection<DocumentLine> lines) {
    Iterator<DocumentLine> it = lines.iterator();
    int c = 0;
    while(it.hasNext()) {
      it.next().setLineOrder(c++);
    }
  }
 
  public DocumentAmounts getAmounts() {
    return new DocumentAmounts(this);
  }
  
  public DocumentAmountsByBook getAmountsByBook(BookDefinition bookDefinition) {
    return new DocumentAmountsByBook(this, bookDefinition);
  }
  
//  public AmountSet getAmountSet() {
//    AmountSet as = new AmountSet();
//    if(getCurrency() != null) {
//      int fractionDigits = getCurrency().getDefaultFractionDigits();
//      if(contract != null) {
//        int count = 0;
//        for(DocumentLine dl : documentLines) {
//          dl.setLineOrder(count++);
//          double tax = dl.getTax();
//          if(!getContract().getOperatingModifier().isSumTax(dl)) {
//            tax = 0.0;
//          }
//          Amount a = as.getAmount(tax);
//          if(a == null) {
//            as.add(new Amount(tax, dl.getSubtotal(), dl.getDiscount(), dl.getRetained(), fractionDigits));
//          } else {
//            a.addTax(tax, dl.getSubtotal(), dl.getDiscount(), dl.getRetained());
//          }
//        }
//        as.clearEmpty();
//      }
//    }
//    return as;
//  }
 
  public double getSubTotal() {
    return getAmounts().getAmount();
  }
 
  public double getTotalAmount() {
    return getAmounts().getTotal();
  }
 
  public ContractPreference getDefaultContractPreference() {
    if(getContract() != null) {
      if(getContract().getContractPreferences().isEmpty()) {
        return getContract().getContractDefinition().getDefaultContractPreference();
      } else {
        return getContract().getContractPreferences().iterator().next();
      }
    }
    return null;
  }
 
  public void appendLines(Document relDoc, String header, DocumentWorkflow workflow) {
    int count = getMaxLineOrder() + 1;
    if(header != null) {
      Contract defaultStore = getDefaultStore();
      DocumentLine dl = new DocumentLine();
      dl.setDocument(this);
      dl.setConcept(header);
      dl.setStore(defaultStore);
      dl.setLineOrder(count++);
      documentLines.add(dl);
    }
    for(DocumentLine l : relDoc.getDocumentLines()) {
      DocumentLine dl = new DocumentLine();
      dl.setDocument(this);
      dl.setProduct(l.getProduct());
      dl.setProductByContractor(l.getProductByContractor());
      dl.setConcept(l.getConcept());
      dl.setQuantity(l.getQuantity());
      dl.setPrice(l.getPrice());
      dl.setDiscountPerCent(l.getDiscountPerCent());
      dl.setDiscountMoney(l.getDiscountMoney());
      dl.setTax(l.getTax());
      dl.setEquivalenceSurcharge(l.getEquivalenceSurcharge());
      dl.setRetention(l.getRetention());
      dl.setStore(l.getStore());
      dl.setLineOrder(count++);
      if(l.getLineType() != null) {
        double sc = l.getLineType().getStockCoefficient();
        dl.setLineType(workflow == null ? null : workflow.getLineType());
        if(dl.getLineType() == null) {
          for(RelatedLineType rlt : getDocumentDefinition().getRelatedLineTypes()) {
            if((sc == 0 && rlt.getLineType().getStockCoefficient() != 0) ||
                    (sc != 0 && rlt.getLineType().getStockCoefficient() == 0)) {
              dl.setLineType(rlt.getLineType());
              break;
            }
          }
        }
        if(dl.getLineType() == null) {
          dl.setLineType(getDefaultLineType());
        }
      } else {
        dl.setLineType(null);
      }
      if(workflow == null) {
        dl.setContractPreference(getDefaultContractPreference());
      } else {
        dl.setContractPreference(l.getContractPreference());
      }
      documentLines.add(dl);
    }
  }
 
  public void appendAmounts(Document relDoc, String header, DocumentWorkflow workflow) {
    int count = getMaxLineOrder() + 1;
    LineType lt = workflow == null ? null : workflow.getLineType();
    if(lt == null) {
      for(RelatedLineType rlt : getDocumentDefinition().getRelatedLineTypes()) {
        if(rlt.getLineType().getStockCoefficient() == 0) {
          lt = rlt.getLineType();
          break;
        }
      }
    }
    if(lt == null) {
      lt = getDefaultLineType();
    }
    Contract defaultStore = getDefaultStore();
    if(getDocumentDefinition().hasColumn(DocumentColumn.DCOL_TAX)) {
      for(AmountTaxable l : relDoc.getAmounts().getTaxables()) {
        DocumentLine dl = new DocumentLine();
        dl.setDocument(this);
        if(header != null) {
          dl.setConcept(header + " [" + l.getTax() + "]");
        }
        dl.setPrice(l.getAmount());
        dl.setTax(l.getTax());
        dl.setEquivalenceSurcharge(l.getReq());
        dl.setLineType(lt);
        dl.setContractPreference(getDefaultContractPreference());
        dl.setStore(defaultStore);
        dl.setLineOrder(count++);
        documentLines.add(dl);
      }
    } else {
      DocumentLine dl = new DocumentLine();
      dl.setDocument(this);
      if(header != null) {
        dl.setConcept(header);
      }
      dl.setPrice(relDoc.getTotalAmount());
      dl.setLineType(lt);
      dl.setContractPreference(getDefaultContractPreference());
      dl.setStore(defaultStore);
      dl.setLineOrder(count++);
      documentLines.add(dl);
    }
  }
 
  public void flowFrom(Document doc, String header, DocumentWorkflow workflow) {
    Date now = new Date();
    setContract(doc.getContract());
    setCurrency(doc.getCurrency());
    setDocumentDate(now);
    setDocumentNumber(null);
    setReceiptDate(now);
    setDocumentDefinition(workflow.getDescendant());
    setDraft(doc.isDraft());
    setNotes(doc.getNotes());
    if(workflow.getAncestor().hasDetail() && workflow.getDescendant().hasDetail()) {
      appendLines(doc, header, workflow);
    } else {
      appendAmounts(doc, header, workflow);
    }
    DocumentRelation dr = new DocumentRelation();
    dr.setAncestor(doc);
    dr.setDescendant(this);
    getAncestors().add(dr);
  }
 
  public void backFrom(Document doc, String header, DocumentWorkflow workflow) {
    Date now = new Date();
    setContract(doc.getContract());
    setCurrency(doc.getCurrency());
    setDocumentDate(now);
    setDocumentNumber(null);
    setReceiptDate(now);
    setDocumentDefinition(workflow.getAncestor());
    setDraft(doc.isDraft());
    setNotes(doc.getNotes());
    if(workflow.getAncestor().hasDetail() && workflow.getDescendant().hasDetail()) {
      appendLines(doc, header, null);
    } else {
      appendAmounts(doc, header, null);
    }
    DocumentRelation dr = new DocumentRelation();
    dr.setAncestor(this);
    dr.setDescendant(doc);
    getDescendants().add(dr);
  }
 
  public void copyFrom(Document doc, boolean shallowCopy) {
    if(!shallowCopy) {
      setContract(doc.getContract());
    }
    setCurrency(doc.getCurrency());
    setDocumentDate(doc.getDocumentDate());
    setDocumentNumber(doc.getDocumentNumber() + "*");
    setReceiptDate(doc.getReceiptDate());
    setDocumentDefinition(doc.getDocumentDefinition());
    setDraft(true);
    setNotes(doc.getNotes());
    setForcedView(doc.getForcedView());
    Contract defaultStore = (!shallowCopy) ? null : getDefaultStore();
    for(DocumentLine dl : doc.getDocumentLines()) {
      DocumentLine nl = new DocumentLine();
      nl.setConcept(dl.getConcept());
      nl.setDiscountMoney(dl.getDiscountMoney());
      nl.setDiscountPerCent(dl.getDiscountPerCent());
      nl.setDocument(this);
      nl.setLineOrder(dl.getLineOrder());
      nl.setLineType(dl.getLineType());
      nl.setContractPreference(dl.getContractPreference());
      nl.setPrice(dl.getPrice());
      nl.setProduct(dl.getProduct());
      nl.setProductByContractor(dl.getProductByContractor());
      nl.setQuantity(dl.getQuantity());
      nl.setStore(shallowCopy ? defaultStore : dl.getStore());
      nl.setTax(dl.getTax());
      nl.setEquivalenceSurcharge(dl.getEquivalenceSurcharge());
      nl.setRetention(dl.getRetention());
      documentLines.add(nl);
    }
  }
 
  public Collection<ContractFlow> getContractFlows() {
    return contract == null ? null : contract.getFlowFor(this);
  }
 
  public Collection<DocumentWorkflow> getWorkflows() {
    return getWorkflows(true, true);
  }
 
  public Collection<DocumentWorkflow> getWorkflows(boolean forward, boolean missing) {
    if(forward && (!missing || getDescendants().isEmpty())) {
      return new FinancialsPU().getResultList(
              "select dw from DocumentWorkflow as dw " +
              "where dw.ancestor = ? " +
              "and dw.contractDefinition = ?",
              new Object[] {
                getDocumentDefinition(),
                contract.getContractDefinition()
              });
    } else if(!forward && (!missing || getAncestors().isEmpty())) {
      return new FinancialsPU().getResultList(
              "select dw from DocumentWorkflow as dw " +
              "where dw.descendant = ? " +
              "and dw.contractDefinition = ?",
              new Object[] {
                getDocumentDefinition(),
                contract.getContractDefinition()
              });
    }
    return Collections.EMPTY_LIST;
  }
 
  public Collection<Contact> getActualHqContacts() {
    ContactList l = new ContactList();
    for(DocumentLine line : getDocumentLines()) {
      if(!line.isEmpty()) {
        Contract ctc = line.getStore();
        if(ctc != null && ctc.getDepartment() != null && ctc.getDepartment().getHeadquarters() != null) {
          l.add((Contact) ctc.getDepartment().getHeadquarters().getIContact().getContact());
        }
      }
    }
    return l;
  }
 
  public String getDocDescription() {
    return getDocumentDefinition().getName() + ": " +
              (getForcedView() == null ? "" : "(" + getForcedView().getName() + ") ") +
              getDocumentNumber() + " " +
              SimpleDateFormat.getDateInstance().format(documentDate);
  }
 
  public String getDocumentString() {
    return getDocumentDefinition().getName() + " " + documentNumber + " " +
            SimpleDateFormat.getDateInstance().format(documentDate);
  }
 
  /* Stores */
  
  @Transient
  private transient Collection<Contract> _stores;
  
  public Collection<Contract> getStores() {
    if(_stores == null) {
      _stores = new DocumentDefinitionWrapper(getDocumentDefinition())
              .getRelatedStores(getContract());
      if(_stores.isEmpty()) {
        _stores = new DocumentDefinitionWrapper(getDocumentDefinition())
              .getRelatedStores();
      }
      ContractWrapper.clearInactives(_stores);
    }
    return _stores;
  }
 
  public Contract getDefaultStore() {
    Collection<Contract> stores = getStores();
    if(!stores.isEmpty()) {
      return stores.iterator().next();
    }
    return null;
  }
 
  public int getMaxLineOrder() {
    int result = 0;
    for(DocumentLine dl : getDocumentLines()) {
      if(dl.getLineOrder() > result) {
        result = dl.getLineOrder();
      }
    }
    return result;
  }
 
  /* Usual */
  public String getUsualPath() {
    if(contract != null && getDocumentDefinition() != null) {
      return contract.getUsualPath(getDocumentDefinition());
    }
    return "";
  }
 
  /* Line types */
 
  public LineType getDefaultLineType() {
    LineType lt = null;
    if(getDocumentDefinition() != null) {
      for(RelatedLineType rlt : getDocumentDefinition().getRelatedLineTypes()) {
        if(rlt.isDefaultLineType()) {
          for(LineType l : getLineTypes()) {
            if(rlt.getLineType().getId() == l.getId()) {
              return l;
            }
            if(lt == null) lt = l;
          }
        }
      }
    }
    return lt;
  }
 
  public Collection<LineType> getLineTypes() {
    LineTypeSet result = new LineTypeSet();
    if(getDocumentDefinition() != null && contract != null) {
      LineTypeSet lts = new RelatedToLineTypeAdapter(getDocumentDefinition().getRelatedLineTypes());
      for(LineType lt : lts) {
        if(lt.getName().contains("%n")) {
          if(contract.getContractPreferences().isEmpty()) {
            LineType ltt = lt.clone();
            ltt.setContractPreference(getDefaultContractPreference());
            result.add(ltt);
          } else {
            for(ContractPreference cp : contract.getContractPreferences()) {
              LineType ltt = lt.clone();
              ltt.setContractPreference(cp);
              result.add(ltt);
            }
          }
        } else {
          LineType ltt = lt.clone();
          ltt.setContractPreference(getDefaultContractPreference());
          result.add(ltt);
        }
      }
    }
    return result;
  }
 
  /* ScheduledAction */
 
  @Override
  public Object doAction(Date now, String data) {
    if(data.contains("action:clone")) {
      Document nd = new Document();
      nd.copyFrom(this, false);
      nd.setDocumentDate(now);
      nd.setReceiptDate(now);
      if(nd.getDocumentDefinition().isAutoNumbered()) {
        nd.setDocumentNumber(null);
      }
      nd.setDraft(data.contains("clone:draft"));
      nd.prepareSave();
      return new FinancialsPU().saveObject(nd);
    }
    return null;
  }
 
  /* Books */
  
  public long getBookNumber() {
    if(!getRegisters().isEmpty()) {
      Register register = getRegisters().iterator().next();
      if(!register.getBookRegisters().isEmpty()) {
        return register.getBookRegisters().iterator().next().getBookOrder();
      }
    }
    return 0L;
  }
  
  /* Transient data */
  
  @Transient
  public transient boolean conciliateRegister;
 
  public boolean isConciliateRegister() {
    return conciliateRegister;
  }
 
  public void setConciliateRegister(boolean conciliateRegister) {
    this.conciliateRegister = conciliateRegister;
  }
  
  @Transient
  public transient boolean regularizeVAT;
 
  public boolean isRegularizeVAT() {
    return regularizeVAT;
  }
 
  public void setRegularizeVAT(boolean regularizeVAT) {
    this.regularizeVAT = regularizeVAT;
  }
  
  @Transient
  public transient boolean regularizeIRPF;
 
  public boolean isRegularizeIRPF() {
    return regularizeIRPF;
  }
 
  public void setRegularizeIRPF(boolean regularizeIRPF) {
    this.regularizeIRPF = regularizeIRPF;
  }
  
  /* XML Serializer */
  
  public MappingSet getSerializerMappings() {
    MappingSet set = new MappingSet();
    set.addMapping(Document.class, 1, 
            new String[] { "id", "documentNumber", "documentDate" }, 
            new String[] { "documentDefinition", "notes", "receiptDate", "draft", "documentLines", 
              "currency", "contract", "forcedView", "relatedPath", "ancestors", "descendants", "registers",
              "conciliateRegister", "regularizeVAT", "regularizeIRPF", "noAncestors", "noDescendants" });
    set.addMapping(DocumentDefinition.class, 2,
            new String[] { "id", "name" }, 
            null);
    set.addMapping(Contract.class, 2,
            new String[] { "id", "name" }, 
            null);
    set.addMapping(RegisterView.class, 2,
            new String[] { "id", "name" }, 
            null);
    set.addMapping(DocumentRelation.class, 2,
            null, 
            new String[] { "ancestor", "descendant" });
    set.addMapping(Document.class, 3, 
            new String[] { "id" }, 
            null);
    set.addMapping(DocumentLine.class, 2,
            new String[] { "quantity", "price", "tax", "retention", "discountPerCent", "discountMoney" }, 
            new String[] { "concept", "product", "productByContractor", "store", 
              "lineType", "contractPreference"});
    set.addMapping(Product.class, 3,
            new String[] { "id", "productCode" }, 
            new String[] { "description" });
    set.addMapping(ProductByContractor.class, 3,
            new String[] { "contractorCode" }, 
            new String[] { "contract" });
    set.addMapping(Contract.class, 4,
            new String[] { "id", "name" }, 
            null);
    set.addMapping(Contract.class, 3,
            new String[] { "id", "name" }, 
            null);
    set.addMapping(LineType.class, 3,
            new String[] { "name" }, 
            null);
    set.addMapping(ContractPreference.class, 3,
            new String[] { "name" }, 
            null);
//    set.addMapping(Register.class, 2,
//            new String[] { "idRegister", "registerDate" }, 
//            new String[] { "view", "registerEntries" });
//    set.addMapping(RegisterView.class, 3,
//            new String[] { "id", "name" }, 
//            null);
//    set.addMapping(RegisterEntry.class, 3,
//            new String[] { "debit", "credit", "approved", "conciliated" }, 
//            new String[] { "account" } );
//    set.addMapping(Account.class, 4,
//            new String[] { "id", "description" }, 
//            null);
    return set;
  }
 
}