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

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 2011 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.common.component;

import org.openconcerto.erp.config.Gestion;
import org.openconcerto.erp.core.common.ui.AbstractArticleItemTable;
import org.openconcerto.sql.Configuration;
import org.openconcerto.sql.element.BaseSQLComponent;
import org.openconcerto.sql.element.SQLComponent;
import org.openconcerto.sql.element.SQLElement;
import org.openconcerto.sql.model.SQLField;
import org.openconcerto.sql.model.SQLInjector;
import org.openconcerto.sql.model.SQLRow;
import org.openconcerto.sql.model.SQLRowAccessor;
import org.openconcerto.sql.model.SQLRowValues;
import org.openconcerto.sql.model.SQLRowValues.ForeignCopyMode;
import org.openconcerto.sql.model.SQLRowValuesListFetcher;
import org.openconcerto.sql.model.SQLSelect;
import org.openconcerto.sql.model.SQLTable;
import org.openconcerto.sql.model.Where;
import org.openconcerto.sql.view.EditFrame;
import org.openconcerto.sql.view.EditPanel.EditMode;
import org.openconcerto.sql.view.list.RowValuesTable;
import org.openconcerto.ui.FrameUtil;
import org.openconcerto.utils.ExceptionHandler;
import org.openconcerto.utils.cc.ITransformer;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import javax.swing.ImageIcon;

public abstract class TransfertBaseSQLComponent extends BaseSQLComponent {
    protected SQLRowAccessor selectedRow;
    private List<SQLRowValues> sourceRows;

    public TransfertBaseSQLComponent(SQLElement element) {
        super(element);
    }

    /**
     * Chargement d'élément à partir d'une autre table ex : les éléments d'un BL dans une facture
     * 
     * @param table ItemTable du component de destination (ex : tableFacture)
     * @param elt element source (ex : BL)
     * @param id id de la row source
     * @param itemsElt elements des items de la source (ex : BL_ELEMENT)
     */
    public void loadItem(AbstractArticleItemTable table, SQLElement elt, int id, SQLElement itemsElt) {
        loadItem(table, elt, id, itemsElt, true);
    }

    public void loadItem(AbstractArticleItemTable table, SQLElement elt, int id, SQLElement itemsElt, boolean clear) {
        List<SQLRow> myListItem = elt.getTable().getRow(id).getReferentRows(itemsElt.getTable());

        if (myListItem.size() != 0) {
            SQLInjector injector = SQLInjector.getInjector(itemsElt.getTable(), table.getSQLElement().getTable());
            if (clear) {
                table.getModel().clearRows();
            }
            for (SQLRow rowElt : myListItem) {

                SQLRowValues createRowValuesFrom = injector.createRowValuesFrom(rowElt);
                if (createRowValuesFrom.getTable().getFieldsName().contains("POURCENT_ACOMPTE")) {
                    if (createRowValuesFrom.getObject("POURCENT_ACOMPTE") == null) {
                        createRowValuesFrom.put("POURCENT_ACOMPTE", new BigDecimal(100.0));
                    }
                }
                table.getModel().addRow(createRowValuesFrom);
                int rowIndex = table.getModel().getRowCount() - 1;
                table.getModel().fireTableModelModified(rowIndex);
            }
        } else {
            if (clear) {
                table.getModel().clearRows();
                table.getModel().addNewRowAt(0);
            }
        }
        table.getModel().fireTableDataChanged();
        table.repaint();
    }

    public void importFrom(List<SQLRowValues> rows) {
        this.sourceRows = rows;
        if (rows.size() > 0) {
            final SQLInjector injector = SQLInjector.getInjector(rows.get(0).getTable(), this.getTable());
            final SQLRowValues rValues = injector.createRowValuesFrom(rows);
            select(rValues);
        } else {
            select(null);
        }
    }

    @Override
    public int insert(SQLRow order) {
        // TODO: Pour l'instant appelé dans Swing, mais cela va changer...
        final int insertedId = super.insert(order);
        if (insertedId != SQLRow.NONEXISTANT_ID && sourceRows != null && !sourceRows.isEmpty()) {
            final SQLInjector injector = SQLInjector.getInjector(sourceRows.get(0).getTable(), this.getTable());
            try {
                injector.commitTransfert(sourceRows, insertedId);
            } catch (Exception e) {
                ExceptionHandler.handle("Unable to insert transfert", e);
            }
        }
        return insertedId;
    }

    @Override
    public void select(SQLRowAccessor r) {
        if (r == null) {
            super.select(null);
            return;
        }
        // remove foreign and replace rowvalues by id
        super.select(r);
        final RowValuesTable table = this.getRowValuesTable();
        if (table != null) {
            table.clear();
            table.insertFrom(r);
        }
        refreshAfterSelect(r);
    }

    protected abstract void refreshAfterSelect(SQLRowAccessor rSource);

    protected RowValuesTable getRowValuesTable() {
        return null;
    }

    public static EditFrame openTransfertFrame(List<SQLRowValues> sourceRows, String destTableName) {
        return openTransfertFrame(sourceRows, destTableName, null);
    }

    public static EditFrame openTransfertFrame(List<SQLRowValues> sourceRows, String destTableName, String compID) {
        final SQLElement elt = Configuration.getInstance().getDirectory().getElement(destTableName);
        final EditFrame editFrame;
        if (compID == null || compID.trim().length() == 0) {
            editFrame = new EditFrame(elt);
        } else {
            editFrame = new EditFrame(elt.createComponent(compID), EditMode.CREATION);
        }
        editFrame.setIconImage(new ImageIcon(Gestion.class.getResource("frameicon.png")).getImage());
        final SQLComponent sqlComponent = editFrame.getSQLComponent();
        if (sqlComponent instanceof TransfertBaseSQLComponent) {
            final TransfertBaseSQLComponent comp = (TransfertBaseSQLComponent) sqlComponent;

            if (!sourceRows.isEmpty()) {
                // fetch all fields of all table to avoid 1 request by referent row
                final List<Number> ids = new ArrayList<Number>(sourceRows.size());
                for (SQLRowValues sqlRowValues : sourceRows) {
                    ids.add(sqlRowValues.getIDNumber());
                }

                final SQLRowValues row = new SQLRowValues(sourceRows.get(0).getTable());
                // FIXME don't work in the general case
                for (final SQLField rk : row.getTable().getDBSystemRoot().getGraph().getReferentKeys(row.getTable())) {
                    final Set<SQLRowValues> referentRows = row.getReferentRows(rk);
                    if (referentRows.size() > 1) {
                        final Iterator<SQLRowValues> iter = new ArrayList<SQLRowValues>(referentRows).iterator();
                        // keep the first
                        iter.next();
                        while (iter.hasNext()) {
                            final SQLRowValues ref = iter.next();
                            ref.remove(rk.getName());
                        }
                    }
                }
                for (SQLRowValues r : row.getGraph().getItems()) {
                    final Set<String> fields = new HashSet<String>(r.getTable().getFieldsName());
                    fields.removeAll(r.getFields());
                    r.putNulls(fields, false);
                }
                final SQLRowValuesListFetcher fetcher = SQLRowValuesListFetcher.create(row);
                fetcher.setSelTransf(new ITransformer<SQLSelect, SQLSelect>() {

                    @Override
                    public SQLSelect transformChecked(SQLSelect input) {
                        input.setWhere(new Where(row.getTable().getKey(), ids));
                        return input;
                    }
                });

                final List<SQLRowValues> result = fetcher.fetch();
                comp.importFrom(result);
                FrameUtil.show(editFrame);
            }
            return editFrame;
        } else {
            throw new IllegalArgumentException("Table " + destTableName + " SQLComponent is not a TransfertBaseSQLComponent");
        }
    }

    public static boolean isAlreadyAllTransfert(final List<SQLRowValues> selectedRows, final SQLTable from, final SQLTable to, final String fieldTotalFrom, final String fieldTotalTo) {
        final SQLTable tableTransfert = from.getTable("TR_" + from.getName());
        SQLRowValues rowVals = new SQLRowValues(tableTransfert);
        rowVals.put("ID_" + from.getName(), new SQLRowValues(from).put("NUMERO", null).put(fieldTotalFrom, null));
        rowVals.putRowValues("ID_" + to.getName()).put("NUMERO", null).put(fieldTotalTo, null);
        rowVals.put("ID", null);

        final List<Number> lID = new ArrayList<>();
        for (SQLRowValues sqlRowValues : selectedRows) {
            lID.add(sqlRowValues.getID());
        }

        SQLRowValuesListFetcher fetch = SQLRowValuesListFetcher.create(rowVals);
        fetch.setSelTransf(new ITransformer<SQLSelect, SQLSelect>() {

            @Override
            public SQLSelect transformChecked(SQLSelect input) {
                Where w = new Where(tableTransfert.getField("ID_" + from.getName()), lID);
                w = w.and(new Where(tableTransfert.getField("ID_" + to.getName()), "IS NOT", (Object) null));
                input.setWhere(w);
                return input;
            }
        });

        List<SQLRowValues> rows = fetch.fetch();
        if (rows != null && rows.size() > 0) {
            String numero = "";

            long totalBR = 0;
            long totalFact = 0;
            Set<String> idsAdded = new HashSet<>();
            for (SQLRowValues sqlRow : rows) {
                final SQLRowAccessor foreignBR = sqlRow.getForeign("ID_" + from.getName());
                final SQLRowAccessor foreignFact = sqlRow.getForeign("ID_" + to.getName());
                numero += foreignBR.getString("NUMERO") + " ,";
                String fromKey = from.getName() + "-" + foreignBR.getID();
                if (!idsAdded.contains(fromKey)) {
                    totalBR += foreignBR.getLong(fieldTotalFrom);
                    idsAdded.add(fromKey);
                }
                String toKey = to.getName() + "-" + foreignFact.getID();
                if (!idsAdded.contains(toKey)) {
                    totalFact += foreignFact.getLong(fieldTotalTo);
                    idsAdded.add(toKey);
                }
            }

            numero = numero.substring(0, numero.length() - 2);
            return totalBR <= totalFact;
        }
        return Boolean.FALSE;
    }
}