Dépôt officiel du code source de l'ERP OpenConcerto

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 package org.openconcerto.erp.core.finance.accounting.model;

import org.openconcerto.erp.config.ComptaPropsConfiguration;

import org.openconcerto.sql.model.DBRoot;

import org.openconcerto.sql.model.Order;

import org.openconcerto.sql.model.SQLRow;

import org.openconcerto.sql.model.SQLRowListRSH;

import org.openconcerto.sql.model.SQLSelect;

import org.openconcerto.sql.model.SQLTable;

import org.openconcerto.sql.model.Where;

import org.openconcerto.utils.DecimalUtils;

import org.openconcerto.utils.Tuple2;

import org.openconcerto.utils.Tuple3;

import java.math.BigDecimal;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Calendar;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.TimeZone;

public class CurrencyConverter {

    private String companyCurrencyCode;

    private final DBRoot root;

    private boolean useCache = false;

    private String baseCurrencyCode;

    public CurrencyConverter(DBRoot rootSociete, String companyCurrencyCode, String baseCurrencyCode) {

        if (companyCurrencyCode == null || companyCurrencyCode.isEmpty()) {

            this.companyCurrencyCode = "EUR";

        } else {

            this.companyCurrencyCode = companyCurrencyCode.trim().toUpperCase();

        }

        this.baseCurrencyCode = baseCurrencyCode;

        this.root = rootSociete;

    }

    public CurrencyConverter() {

        this(ComptaPropsConfiguration.getInstanceCompta().getRootSociete(), ComptaPropsConfiguration.getInstanceCompta().getCurrency().getCode(), "EUR");

    }

    public String getCompanyCurrencyCode() {

        return companyCurrencyCode;

    }

    public String getBaseCurrencyCode() {

        return baseCurrencyCode;

    }

    public void setUseCache(boolean useCache) {

        this.useCache = useCache;

    }

    /**

     * Converter an amount to an other currency

     */

    public BigDecimal convert(BigDecimal amount, String from, String to) {

        return convert(amount, from, to, Calendar.getInstance().getTime());

    }

    /**

     * Converter an amount to an other currency at a precise date

     */

    public BigDecimal convert(BigDecimal amount, String from, String to, Date date) {

        return convert(amount, from, to, date, false);

    }

    Map<Tuple3<String, String, Date>, Tuple2<BigDecimal, BigDecimal>> cacheBiased = new HashMap<Tuple3<String, String, Date>, Tuple2<BigDecimal, BigDecimal>>();

    Map<Tuple3<String, String, Date>, Tuple2<BigDecimal, BigDecimal>> cacheNotBiased = new HashMap<Tuple3<String, String, Date>, Tuple2<BigDecimal, BigDecimal>>();

    public void clearCache() {

        cacheBiased.clear();

        cacheNotBiased.clear();

    }

    /**

     * Converter an amount to an other currency at a precise date

     */

    public BigDecimal convert(BigDecimal amount, String from, String to, Date date, boolean useBiased) {

        if (from.equalsIgnoreCase(to)) {

            return amount;

        }

        if (amount.signum() == 0) {

            return BigDecimal.ZERO;

        }

        BigDecimal r1 = null;

        BigDecimal r2 = null;

        if (useCache) {

            Tuple3<String, String, Date> key = Tuple3.create(from, to, date);

            if (useBiased && cacheBiased.containsKey(key)) {

                Tuple2<BigDecimal, BigDecimal> value = cacheBiased.get(key);

                r1 = value.get0();

                r2 = value.get1();

            } else if (!useBiased && cacheNotBiased.containsKey(key)) {

                Tuple2<BigDecimal, BigDecimal> value = cacheNotBiased.get(key);

                r1 = value.get0();

                r2 = value.get1();

            }

        }

        if (r1 == null || r2 == null) {

            // Clean date

            final Calendar c = Calendar.getInstance(TimeZone.getTimeZone("UTC"));

            c.setTimeInMillis(date.getTime());

            c.set(Calendar.HOUR_OF_DAY, 23);

            c.set(Calendar.MINUTE, 59);

            c.set(Calendar.SECOND, 59);

            c.set(Calendar.MILLISECOND, 59);

            // Limit pour récupérer le taux de la veille pour le taux réel

            if (!useBiased) {

                c.add(Calendar.DAY_OF_MONTH, -1);

            }

            final Date d = c.getTime();

            // Get conversion info

            final List<SQLRow> rowsFrom = getRates(from, d);

            final List<SQLRow> rowsTo = getRates(to, d);

            List<SQLRow> rows = new ArrayList<SQLRow>();

            rows.addAll(rowsTo);

            rows.addAll(rowsFrom);

            // Pour le taux réel, on récupére celui de la veille

            for (SQLRow sqlRow : rows) {

                if (sqlRow.getString("DST").equals(from)) {

                    if (useBiased) {

                        if (r1 == null) {

                            r1 = sqlRow.getBigDecimal("TAUX_COMMERCIAL");

                        }

                    } else {

                        r1 = sqlRow.getBigDecimal("TAUX");

                    }

                }

                if (sqlRow.getString("DST").equals(to)) {

                    if (useBiased) {

                        if (r2 == null) {

                            r2 = sqlRow.getBigDecimal("TAUX_COMMERCIAL");

                        }

                    } else {

                        r2 = sqlRow.getBigDecimal("TAUX");

                    }

                }

            }

            if (from.equals(this.baseCurrencyCode)) {

                r1 = BigDecimal.ONE;

            }

            if (to.equals(this.baseCurrencyCode)) {

                r2 = BigDecimal.ONE;

            }

            if (r1 == null || r2 == null) {

                // Récupération des taux par défaut dans DEVISE si aucun taux dans l'historique

                List<SQLRow> rowsDevise = new ArrayList<SQLRow>();

                if (rowsTo.isEmpty() || rowsFrom.isEmpty()) {

                    SQLSelect sel = new SQLSelect();

                    sel.addSelectStar(root.findTable("DEVISE"));

                    rowsDevise.addAll(SQLRowListRSH.execute(sel));

                }

                if (r2 == null) {

                    for (SQLRow sqlRow : rowsDevise) {

                        if (sqlRow.getString("CODE").equalsIgnoreCase(to)) {

                            r2 = (useBiased ? sqlRow.getBigDecimal("TAUX_COMMERCIAL") : sqlRow.getBigDecimal("TAUX"));

                        }

                    }

                }

                if (r1 == null) {

                    for (SQLRow sqlRow : rowsDevise) {

                        if (sqlRow.getString("CODE").equalsIgnoreCase(from)) {

                            r1 = (useBiased ? sqlRow.getBigDecimal("TAUX_COMMERCIAL") : sqlRow.getBigDecimal("TAUX"));

                        }

                    }

                }

            }

        }

        if (r1 == null) {

            throw new IllegalStateException("No conversion rate for " + from);

        }

        if (r2 == null) {

            throw new IllegalStateException("No conversion rate for " + to);

        }

        if (useCache) {

            Tuple3<String, String, Date> key = Tuple3.create(from, to, date);

            if (useBiased) {

                cacheBiased.put(key, Tuple2.create(r1, r2));

            } else {

                cacheNotBiased.put(key, Tuple2.create(r1, r2));

            }

        }

        if (r1.equals(BigDecimal.ZERO)) {

            r1 = BigDecimal.ONE;

        }

        final BigDecimal result = amount.multiply(r2, DecimalUtils.HIGH_PRECISION).divide(r1, DecimalUtils.HIGH_PRECISION);

        return result;

    }

    public List<SQLRow> getRates(String currencyCode, final Date d) {

        final SQLSelect select = new SQLSelect();

        final SQLTable t = this.root.getTable("DEVISE_HISTORIQUE");

        select.addAllSelect(t, Arrays.asList("ID", "DATE", "SRC", "DST", "TAUX", "TAUX_COMMERCIAL"));

        Where w = new Where(t.getField("SRC"), "=", baseCurrencyCode);

        w = w.and(new Where(t.getField("DST"), "=", currencyCode));

        w = w.and(new Where(t.getField("DATE"), "<=", d));

        select.setWhere(w);

        select.addFieldOrder(t.getField("DATE"), Order.desc());

        // On ne veut que le plus récent

        select.setLimit(1);

        final List<SQLRow> rows = SQLRowListRSH.execute(select);

        return rows;

    }

}