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.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.GroupSQLComponent;
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.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.ui.group.Group;
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 TransfertGroupSQLComponent extends GroupSQLComponent {
    protected SQLRowAccessor selectedRow;
    private List<SQLRowValues> sourceRows;

    public TransfertGroupSQLComponent(SQLElement element, Group group) {
        super(element, group);
    }

    /**
     * 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, false);
                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
        final SQLRowValues singleRowValues = new SQLRowValues(r.asRowValues(), ForeignCopyMode.COPY_ID_OR_RM);
        super.select(singleRowValues);
        final RowValuesTable table = this.getRowValuesTable();
        if (table != null) {
            table.clear();
            table.insertFrom(r);
        }
    }

    protected RowValuesTable getRowValuesTable() {
        return null;
    }

    public static EditFrame openTransfertFrame(List<SQLRowValues> sourceRows, String destTableName, String groupID) {
        final SQLElement elt = Configuration.getInstance().getDirectory().getElement(destTableName);
        final EditFrame editFrame = new EditFrame(elt.createComponent(groupID), EditMode.CREATION);
        editFrame.setIconImage(new ImageIcon(Gestion.class.getResource("frameicon.png")).getImage());
        final SQLComponent sqlComponent = editFrame.getSQLComponent();
        if (sqlComponent instanceof TransfertGroupSQLComponent) {
            final TransfertGroupSQLComponent comp = (TransfertGroupSQLComponent) 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 = sourceRows.get(0).deepCopy();
                // 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");
        }
    }
}