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.sql.view.list;

import org.openconcerto.sql.model.ConnectionHandlerNoSetup;
import org.openconcerto.sql.model.SQLDataSource;
import org.openconcerto.sql.model.SQLRow;
import org.openconcerto.sql.model.SQLRowAccessor;
import org.openconcerto.sql.model.SQLRowValues;
import org.openconcerto.sql.model.SQLSelect;
import org.openconcerto.sql.model.SQLSelect.LockStrength;
import org.openconcerto.sql.model.SQLSyntax;
import org.openconcerto.sql.model.SQLTable;
import org.openconcerto.sql.model.Where;
import org.openconcerto.sql.request.UpdateBuilder;
import org.openconcerto.sql.utils.ReOrder;
import org.openconcerto.sql.utils.SQLUtils;
import org.openconcerto.utils.ExceptionUtils;
import org.openconcerto.utils.NumberUtils;
import org.openconcerto.utils.SleepingQueue;

import java.math.BigDecimal;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

import javax.swing.SwingUtilities;

public final class MoveQueue extends SleepingQueue {

    private final ITableModel tableModel;

    MoveQueue(ITableModel model) {
        super(MoveQueue.class.getSimpleName() + " on " + model);
        this.tableModel = model;
    }

    public Future<?> move(final List<? extends SQLRowAccessor> rows, final int inc) {
        if (inc == 0 || rows.size() == 0)
            return null;

        final boolean after = inc > 0;
        SQLRowAccessor outerR = null;
        for (final SQLRowAccessor r : rows) {
            if (outerR == null) {
                outerR = r;
            } else {
                final int compare = r.getOrder().compareTo(outerR.getOrder());
                if (after && compare > 0 || !after && compare < 0) {
                    outerR = r;
                }
            }
        }
        final int id = outerR.getID();
        return this.put(new Runnable() {
            public void run() {
                final FutureTask<ListSQLLine> destID = new FutureTask<ListSQLLine>(new Callable<ListSQLLine>() {
                    @Override
                    public ListSQLLine call() {
                        return MoveQueue.this.tableModel.getDestLine(id, inc);
                    }
                });
                MoveQueue.this.tableModel.invokeLater(destID);
                try {
                    if (destID.get() != null) {
                        SQLUtils.executeAtomic(getTable().getDBSystemRoot().getDataSource(), new ConnectionHandlerNoSetup<Object, Exception>() {
                            @Override
                            public Object handle(SQLDataSource ds) throws Exception {
                                moveQuick(rows, after, destID.get().getRowAccessor().asRow());
                                return null;
                            }
                        });
                    }
                } catch (Exception e) {
                    throw ExceptionUtils.createExn(IllegalStateException.class, "move failed", e);
                }
            }
        });
    }

    // row index as returned by JTable.DropLocation.getRow()
    public Future<?> moveTo(final List<? extends Number> rows, final int rowIndex) {
        if (rows.size() == 0)
            return null;

        // the user just dropped rows to move on rowIndex, find out right away which row that is.
        // (we used to go through the UpdateQueue which could result in the destination row the user
        // saw being replaced by a different row)
        assert rowIndex >= 0;
        assert SwingUtilities.isEventDispatchThread();
        final int rowCount = this.tableModel.getRowCount();
        final boolean after = rowIndex >= rowCount;
        final int index = after ? rowCount - 1 : rowIndex;
        final SQLRowAccessor line = this.tableModel.getRow(index).getRowAccessor();
        assert line.isFrozen() : "row could change by the time move() is called";

        return this.put(new Runnable() {
            @Override
            public void run() {
                try {
                    SQLUtils.executeAtomic(getTable().getDBSystemRoot().getDataSource(), new ConnectionHandlerNoSetup<Object, Exception>() {
                        @Override
                        public Object handle(SQLDataSource ds) throws Exception {
                            moveQuick(rows, after, line.asRow());
                            return null;
                        }
                    });
                } catch (Exception e) {
                    throw ExceptionUtils.createExn(IllegalStateException.class, "move failed", e);
                }
            }
        });
    }

    final void moveQuick(final List<?> srcRows, final boolean after, final SQLRow destRow) throws SQLException {
        final int rowCount = srcRows.size();
        // if only some rows are moved, update one by one (avoids refreshing the whole list)
        // (getRowCount() is not thread-safe, so use getTotalRowCount())
        if (rowCount < 5 && rowCount < (this.tableModel.getTotalRowCount() / 3)) {
            final SQLTable t = getTable();
            final String orderName = t.getOrderField().getName();
            final SQLRowValues vals = new SQLRowValues(t);
            final List<BigDecimal> orders = ReOrder.getFreeOrderValuesFor(rowCount, after, destRow).get0();
            for (int i = 0; i < rowCount; i++) {
                final Object src = srcRows.get(i);
                vals.put(orderName, orders.get(i)).update(getID(src, t).intValue());
            }
        } else {
            // update all rows at once and refresh the whole list
            moveAtOnce(srcRows, rowCount, after, destRow);
        }
    }

    private static Number getID(final Object o, final SQLTable t) {
        final Number res;
        if (o instanceof SQLRowAccessor) {
            final SQLRowAccessor row = (SQLRowAccessor) o;
            if (row.getTable() != t)
                throw new IllegalArgumentException("Not from the same table : " + row + " != " + t);
            res = row.getIDNumber();
        } else {
            res = (Number) o;
        }
        return res;
    }

    private SQLTable getTable() {
        return this.tableModel.getTable();
    }

    /**
     * Move the passed rows just before or just after the destination row. The current database
     * order of the rows is not used, i.e. after this method returns the order will be that of the
     * passed list, with <code>destRow</code> coming either before or after them all.
     * 
     * @param srcRows rows to reorder.
     * @param after <code>true</code> if the rows should be placed after <code>destRow</code>,
     *        <code>false</code> otherwise.
     * @param destRow <code>srcRows</code> will be placed relative to the order of this row.
     * @throws SQLException if an error occurs.
     */
    static public void moveAtOnce(final List<? extends SQLRowAccessor> srcRows, final boolean after, final SQLRow destRow) throws SQLException {
        moveAtOnce(srcRows, srcRows.size(), after, destRow);
    }

    /**
     * Move the passed rows just before or just after the destination row if needed.
     * 
     * @param ids rows to order.
     * @param after <code>true</code> if the rows should be placed after <code>destRow</code>,
     *        <code>false</code> otherwise.
     * @param destRow <code>srcRows</code> will be placed relative to the order of this row.
     * @param checkBefore if <code>true</code> the current DB order will be checked and if it
     *        matched the passed rows, no change will be made to the DB, <code>false</code> to
     *        always change the orders in the DB.
     * @return if the DB was changed.
     * @throws SQLException if an error occurs.
     */
    static public boolean moveIDsAtOnce(final List<? extends Number> ids, final boolean after, final SQLRow destRow, final boolean checkBefore) throws SQLException {
        final int size = ids.size();
        if (checkBefore) {
            final SQLTable table = destRow.getTable();
            final SQLSelect sel = new SQLSelect(true);
            sel.addSelect(table.getKey());
            sel.addOrder(table);
            sel.setWhere(new Where(table.getKey(), ids));
            // needed since we might update them just after in moveAtOnce(), and it's safer to lock
            // with the most restrictive mode first.
            sel.setLockStrength(LockStrength.UPDATE);
            final List<?> dbOrderedIDs = table.getDBSystemRoot().getDataSource().executeCol(sel.asString());
            if (dbOrderedIDs.size() != size)
                throw new IllegalStateException("Missing rows");
            boolean orderOK = true;
            for (int i = 0; i < size && orderOK; i++) {
                final Number passedID = ids.get(i);
                final Number dbID = (Number) dbOrderedIDs.get(i);
                orderOK = NumberUtils.areNumericallyEqual(passedID, dbID);
            }
            if (orderOK)
                return false;
        }
        moveAtOnce(ids, size, after, destRow);
        return true;
    }

    static private void moveAtOnce(final List<?> srcRows, final int rowCount, final boolean after, final SQLRow destRow) throws SQLException {
        if (rowCount == 0)
            return;
        final SQLTable t = destRow.getTable();

        final List<BigDecimal> freeOrderValues = ReOrder.getFreeOrderValuesFor(rowCount, after, destRow).get0();

        final List<List<String>> newOrdersAndIDs = new ArrayList<List<String>>(rowCount);
        int i = 0;
        final List<Number> ids = rowCount < 10 ? new ArrayList<Number>(rowCount) : null;
        // we go from newOrder and up, so that the passed rows are in ascending order
        for (final Object src : srcRows) {
            final Number srcID = getID(src, t);
            if (ids != null)
                ids.add(srcID);
            final BigDecimal newOrder = freeOrderValues.get(i++);
            newOrdersAndIDs.add(Arrays.asList(srcID.toString(), newOrder.toPlainString()));
        }

        final SQLSyntax syntax = SQLSyntax.get(t);
        final UpdateBuilder update = new UpdateBuilder(t);
        final String constantTableAlias = "newOrdersAndIDs";
        update.addVirtualJoin(syntax.getConstantTable(newOrdersAndIDs, constantTableAlias, Arrays.asList("ID", "newOrder")), constantTableAlias, true, "ID", t.getKey().getName());
        update.setFromVirtualJoinField(t.getOrderField().getName(), constantTableAlias, "newOrder");
        t.getDBSystemRoot().getDataSource().execute(update.asString());

        final List<String> fieldsChanged = Collections.singletonList(t.getOrderField().getName());
        if (ids == null) {
            t.fireTableModified(SQLRow.NONEXISTANT_ID, fieldsChanged);
        } else {
            for (final Number id : ids)
                t.fireTableModified(id.intValue(), fieldsChanged);
        }
    }
}