RegisterGenerator.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.model.register;
 
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import org.turro.string.Strings;
import org.turro.financials.entity.*;
import org.turro.financials.model.AccountFormat;
import org.turro.financials.model.business.CompanyWrapper;
import org.turro.math.Round;
import org.turro.math.Zero;
 
public class RegisterGenerator {
 
  private Register register;
  private int fractionDigits;
 
  public RegisterGenerator() {
    fractionDigits = CompanyWrapper.getCompanyCurrency().getDefaultFractionDigits();
  }
 
  public int getFractionDigits() {
    return fractionDigits;
  }
 
  public Register getRegister() {
    if(register == null) {
      register = new Register();
    }
    return register;
  }
 
  public void setRegister(Register register) {
    this.register = register;
  }
 
  public void addAccount(Account account, String concept, double balance) {
    if(!Zero.near(balance, fractionDigits)) {
      if(balance < 0) {
        addAccount(account, concept, 0.0, -balance);
      } else {
        addAccount(account, concept, balance, 0.0);
      }
    }
  }
 
  public void addAccount(Contract store, String concept, double debit, double credit) {
    String accStr = "%ctd.%ct",
           asCash = store.getContractDefinition().getDefaultContractPreference().getAsCash();
    accStr = accStr.replaceAll("\\%ctd", asCash)
                   .replaceAll("\\%ct", "" + store.getId());
    Account account = new Account();
    account.setId(AccountFormat.expand(accStr));
    account.setDescription(store.getFullDescription());
    addAccount(account, concept, debit, credit);
  }
 
  public void addAccount(Account account, String concept, double debit, double credit) {
    if(register == null) {
      register = new Register();
    }
    if(Strings.isBlank(account.getDescription())) {
      MajorAccount ma = account.getParent();
      if(ma != null) {
        account.setDescription(ma.getDescription());
      }
    }
    if(!(Zero.near(debit, fractionDigits))) {
      RegisterEntry re = new RegisterEntry();
      re.setAccount(account);
      re.setConcept(concept);
      re.setCredit(0.0);
      re.setDebit(new Round(debit).decimals(fractionDigits).value());
      re.setRegister(register);
      register.getRegisterEntries().add(re);
      re.roundIt(fractionDigits);
    }
    if(!(Zero.near(credit, fractionDigits))) {
      RegisterEntry re = new RegisterEntry();
      re.setAccount(account);
      re.setConcept(concept);
      re.setCredit(new Round(credit).decimals(fractionDigits).value());
      re.setDebit(0.0);
      re.setRegister(register);
      register.getRegisterEntries().add(re);
      re.roundIt(fractionDigits);
    }
  }
 
  public Set<RegisterEntry> addAmount(RegisterView view, Contract contract, Contract store, LineType lineType, String concept, double amount) {
    Set<RegisterEntry> set = addEntries(view, contract, store, lineType, concept, amount);
    if(register == null) {
      register = new Register();
    }
    for(RegisterEntry re : set) {
      re.setRegister(register);
      register.getRegisterEntries().add(re);
    }
    return set;
  }
 
  private Set<RegisterEntry> addEntries(RegisterView view, Contract contract, Contract store, LineType lineType, String concept, double amount) {
    if(store == null || lineType == null || amount == 0) return Collections.EMPTY_SET;
    HashSet<RegisterEntry> set = new HashSet<RegisterEntry>();
    for(LineTypeAccount lta : lineType.getLineTypeAccounts()) {
      if(view == null || lta.getView() == null || lta.getView().getId() == view.getId()) {
        Account account = new Account();
        String acc = lta.getPattern();
        if(acc.indexOf("%s") > -1) {
          if(Strings.isBlank(account.getDescription())) {
            account.setDescription(store.getFullDescription());
          }
          acc = convertPattern(acc, "\\%sctc", store.getContractDefinition().getAsContact());
          acc = convertPattern(acc, "\\%scte", store.getContractDefinition().getDefaultContractPreference().getAsOperating(store));
          acc = convertPattern(acc, "\\%sctd", store.getContractDefinition().getAsCash());
          acc = convertPattern(acc, "\\%sctt", store.getContractDefinition().getDefaultContractPreference().getAsTax(store));
          acc = convertPattern(acc, "\\%sctr", store.getContractDefinition().getDefaultContractPreference().getAsRetention(store));
          acc = convertPattern(acc, "\\%sct", store.getId() + "");
          acc = convertPattern(acc, "\\%s", store.getId() + "");
        }
        if(acc.indexOf("%ct") > -1) {
          if(Strings.isBlank(account.getDescription())) {
            account.setDescription(contract.getFullDescription());
          }
          acc = convertPattern(acc, "\\%ctc", contract.getContractDefinition().getAsContact());
          acc = convertPattern(acc, "\\%cte", lineType.getContractPreference().getAsOperating(contract));
          acc = convertPattern(acc, "\\%ctd", contract.getContractDefinition().getAsCash());
          acc = convertPattern(acc, "\\%ctt", lineType.getContractPreference().getAsTax(contract));
          acc = convertPattern(acc, "\\%ctr", lineType.getContractPreference().getAsRetention(contract));
          acc = convertPattern(acc, "\\%ct", contract.getId() + "");
        }
        acc = convertPattern(acc, "\\%ltv", convertToString(lta.getTypeValue()));
        account.setId(AccountFormat.expand(acc));
        if(Strings.isBlank(account.getDescription())) {
          MajorAccount ma = account.getParent();
          if(ma != null) {
            String extra = "";
            if(lta.getType().equals(LineTypeAccountType.LTAT_TAX)) {
              if(lta.getTypeValue() != 0) {
                extra = " (" + lta.getTypeValue() + ")";
              }
            }
            account.setDescription(ma.getDescription() + extra);
          }
        }
        RegisterEntry re = new RegisterEntry();
        re.setAccount(account);
        re.setConcept(lineType.getName() + " - " + concept);
        double _amount = 0;
        if(lta.getType().equals(LineTypeAccountType.LTAT_TOTAL)) {
          _amount = amount * lta.getCoefficient();
        }
        if(lta.getPosition().equals(AccountPosition.ACC_DEBIT)) {
          re.setDebit(_amount);
        } else {
          re.setCredit(_amount);
        }
        if(re.getDebit() != 0 || re.getCredit() != 0) {
          re.roundIt(fractionDigits);
          set.add(re);
        }
      }
    }
    return set;
  }
 
  private String convertToString(double value) {
    return Double.valueOf(value).intValue() + "";
  }
 
  private String convertPattern(String text, String pattern, String value) {
    int l = value == null ? 0 : value.length();
    if(text.contains(pattern.replaceAll("\\\\", "") + "%1") && l > 1) {
      return text.replaceAll(pattern + "\\%1", value.substring(0, 1));
    } else if(text.contains(pattern.replaceAll("\\\\", "") + "%2") && l > 2) {
      return text.replaceAll(pattern + "\\%2", value.substring(0, 2));
    }
    return text.replaceAll(pattern, value);
  }
 
}