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.element.SQLElement;

import org.openconcerto.sql.model.FieldPath;

import org.openconcerto.sql.model.IFieldPath;

import org.openconcerto.sql.model.SQLField;

import org.openconcerto.sql.model.SQLFieldsSet;

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.SQLTable;

import org.openconcerto.sql.model.graph.Path;

import org.openconcerto.sql.request.BaseFillSQLRequest;

import org.openconcerto.sql.request.ComboSQLRequest.KeepMode;

import org.openconcerto.sql.request.ListSQLRequest;

import org.openconcerto.utils.cc.IClosure;

import org.openconcerto.utils.change.ListChangeIndex;

import org.openconcerto.utils.change.ListChangeRecorder;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.lang.ref.WeakReference;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.concurrent.atomic.AtomicBoolean;

import javax.swing.SwingUtilities;

import net.jcip.annotations.GuardedBy;

/**

 * Define the columns and lines for ITableModel.

 *

 * @author Sylvain

 */

public abstract class SQLTableModelSource {

    protected static final class DebugRow extends BaseSQLTableModelColumn {

        private final SQLTable t;

        protected DebugRow(final SQLTable t) {

            // don't put SQLRowAccessor: it's an interface and thus JTable.getDefaultRenderer()

            // returns null

            super("Fields", Object.class);

            this.t = t;

        }

        @Override

        protected Object show_(SQLRowAccessor r) {

            if (r instanceof SQLRow)

                return r;

            else

                return new SQLRowValues((SQLRowValues) r, ForeignCopyMode.COPY_ID_OR_RM);

        }

        @Override

        public Set<SQLField> getFields() {

            return this.t.getFields();

        }

        @Override

        public Set<FieldPath> getPaths() {

            return FieldPath.create(Path.get(this.t), this.t.getFieldsName());

        }

    }

    private final ListSQLRequest req;

    private final SQLElement elem;

    // only from EDT

    private SQLRowValues inited;

    // this.cols + debugCols, unmodifiable

    @GuardedBy("this")

    private SQLTableModelColumns allCols;

    // only from EDT

    private final ListChangeRecorder<SQLTableModelColumn> cols;

    // only from EDT

    private final List<SQLTableModelColumn> debugCols;

    // to notify of columns change, better than having one listener per line

    private final List<WeakReference<SQLTableModelLinesSource>> lines;

    private final PropertyChangeSupport supp;

    {

        this.supp = new PropertyChangeSupport(this);

        this.lines = new ArrayList<WeakReference<SQLTableModelLinesSource>>();

    }

    public SQLTableModelSource(final ListSQLRequest req, final SQLElement elem) {

        if (elem == null)

            throw new IllegalArgumentException("Missing element");

        this.req = req;

        this.elem = elem;

        if (!this.getPrimaryTable().equals(this.elem.getTable()))

            throw new IllegalArgumentException("not the same table: " + this.getPrimaryTable() + " != " + this.elem);

        this.setAllCols(SQLTableModelColumns.empty());

        this.cols = new ListChangeRecorder<SQLTableModelColumn>(new ArrayList<SQLTableModelColumn>());

        this.debugCols = new ArrayList<SQLTableModelColumn>();

        this.inited = req.getGraph();

    }

    public SQLElement getElem() {

        return this.elem;

    }

    protected abstract KeepMode getKeepMode();

    // lazy initialization since this method calls colsChanged() which subclasses overload and

    // they need their own attribute that aren't set yet since super() must be the first statement.

    public void init() {

        assert SwingUtilities.isEventDispatchThread();

        if (this.inited == null)

            return;

        final SQLRowValues graph = this.inited;

        final boolean moreDebugCols = this.getKeepMode() == KeepMode.GRAPH;

        graph.walkFields(new IClosure<FieldPath>() {

            @Override

            public void executeChecked(final FieldPath input) {

                final SQLField f = input.getField();

                if (f.getTable().getLocalContentFields().contains(f)) {

                    final SQLTableModelColumnPath col = new SQLTableModelColumnPath(input, null, getElem().getDirectory());

                    SQLTableModelSource.this.cols.add(col);

                } else if (moreDebugCols) {

                    SQLTableModelSource.this.debugCols.add(new SQLTableModelColumnPath(input.getPath(), f.getName(), f.toString()) {

                        // don't show the rowValues since it's very verbose (and all content fields

                        // are already displayed as normal columns) and unsortable

                        @Override

                        protected Object show_(SQLRowAccessor r) {

                            final Object res = super.show_(r);

                            return res instanceof SQLRowValues ? ((SQLRowValues) res).getID() : res;

                        }

                    });

                }

            }

        }, true);

        if (moreDebugCols)

            this.debugCols.add(new DebugRow(getPrimaryTable()));

        final SQLField orderField = getPrimaryTable().getOrderField();

        if (orderField != null)

            this.debugCols.add(new SQLTableModelColumnPath(Path.get(getPrimaryTable()), orderField.getName(), "Order"));

        this.debugCols.add(new SQLTableModelColumnPath(Path.get(getPrimaryTable()), getPrimaryTable().getKey().getName(), "PrimaryKey"));

        // at the end so that fireColsChanged() can use it

        this.inited = null;

        listenToCols();

        updateCols(null);

    }

    public SQLTableModelSource(SQLTableModelSource src) {

        this.req = src.req;

        this.elem = src.elem;

        this.setAllCols(src.getAllColumns());

        this.cols = new ListChangeRecorder<SQLTableModelColumn>(new ArrayList<SQLTableModelColumn>(src.cols));

        this.debugCols = new ArrayList<SQLTableModelColumn>(src.debugCols);

        this.inited = null;

        listenToCols();

    }

    private void listenToCols() {

        assert SwingUtilities.isEventDispatchThread();

        // keep allCols in sync with cols, and listen to any change

        this.cols.getRecipe().addListener(new IClosure<ListChangeIndex<SQLTableModelColumn>>() {

            @Override

            public void executeChecked(ListChangeIndex<SQLTableModelColumn> change) {

                updateCols(change);

            }

        });

    }

    protected final void updateCols(ListChangeIndex<SQLTableModelColumn> change) {

        assert SwingUtilities.isEventDispatchThread();

        // do not fire while initializing

        assert this.inited == null;

        if (change != null && change.getItemsAdded().isEmpty() && change.getItemsRemoved().isEmpty())

            return;

        final SQLTableModelSourceState beforeState = this.createState();

        this.setAllCols(new SQLTableModelColumns(this.cols, this.debugCols));

        colsChanged(change == null ? new ListChangeIndex.Add<SQLTableModelColumn>(0, this.getAllColumns().getAllColumns()) : change);

        final SQLTableModelSourceState afterState = this.createState();

        fireColsChanged(beforeState, afterState);

    }

    protected final SQLTableModelSourceState createState() {

        return new SQLTableModelSourceState(this.getAllColumns(), this.getReq());

    }

    private final void colsChanged(final ListChangeIndex<SQLTableModelColumn> change) {

        final AtomicBoolean biggerGraph = new AtomicBoolean(false);

        // add needed fields for each new column

        this.getReq().changeGraphToFetch(new IClosure<SQLRowValues>() {

            @Override

            public void executeChecked(SQLRowValues g) {

                for (final SQLTableModelColumn col : change.getItemsAdded()) {

                    // DebugRow should uses all *fetched* fields, but since it cannot know them

                    // getPaths() return all fields in the table. So don't fetch all fields just for

                    // this debug column

                    if (!(col instanceof DebugRow)) {

                        for (final IFieldPath p : col.getPaths()) {

                            if (BaseFillSQLRequest.addToFetch(g, p.getPath(), Collections.singleton(p.getFieldName())))

                                biggerGraph.set(true);

                        }

                    }

                }

            }

        });

        if (biggerGraph.get() && !allowBiggerGraph())

            throw new IllegalStateException("Bigger graph not allowed");

    }

    protected abstract boolean allowBiggerGraph();

    private void fireColsChanged(final SQLTableModelSourceState beforeState, final SQLTableModelSourceState afterState) {

        // let know each of our LinesSource that the columns have changed

        for (final SQLTableModelLinesSource line : getLines()) {

            line.colsChanged(beforeState, afterState);

        }

        // before notifying our regular listeners

        this.supp.firePropertyChange("cols", null, this.cols);

    }

    private final List<SQLTableModelLinesSource> getLines() {

        final List<SQLTableModelLinesSource> res = new ArrayList<SQLTableModelLinesSource>();

        int i = 0;

        while (i < this.lines.size()) {

            final WeakReference<SQLTableModelLinesSource> l = this.lines.get(i);

            final SQLTableModelLinesSource line = l.get();

            if (line == null)

                this.lines.remove(i);

            else {

                res.add(line);

                i++;

            }

        }

        return res;

    }

    protected final int getLinesCount() {

        return this.getLines().size();

    }

    public final SQLTableModelLinesSource createLinesSource(ITableModel model) {

        this.init();

        final SQLTableModelLinesSource res = this._createLinesSource(model);

        this.lines.add(new WeakReference<SQLTableModelLinesSource>(res));

        return res;

    }

    protected abstract SQLTableModelLinesSource _createLinesSource(ITableModel model);

    /**

     * The maximum graph of the lines returned by {@link #createLinesSource(ITableModel)}.

     *

     * @return the maximum graph of our lines.

     */

    public final SQLRowValues getMaxGraph() {

        return this.getReq().getGraphToFetch();

    }

    // * columns

    /**

     * The normal columns.

     *

     * @return the normal columns.

     */

    public final List<SQLTableModelColumn> getColumns() {

        this.init();

        return this.cols;

    }

    private synchronized void setAllCols(SQLTableModelColumns allCols) {

        this.allCols = allCols;

    }

    /**

     * The normal columns plus some debug columns. Usually primary and foreign keys.

     *

     * @return the debub columns.

     */

    public synchronized final SQLTableModelColumns getAllColumns() {

        return this.allCols;

    }

    public final void addDebugColumn(final SQLTableModelColumn col) {

        this.init();

        this.debugCols.add(col);

        updateCols(new ListChangeIndex.Add<SQLTableModelColumn>(this.getAllColumns().size(), Collections.singleton(col)));

    }

    public final SQLTableModelColumn getColumn(int index) {

        return this.getAllColumns().getAllColumns().get(index);

    }

    /**

     * All the columns that depends on the passed field.

     *

     * @param f the field.

     * @return all columns needing <code>f</code>.

     */

    public final List<SQLTableModelColumn> getColumns(SQLField f) {

        return this.getAllColumns().getColumns(f);

    }

    /**

     * The column depending solely on the passed field.

     *

     * @param f the field.

     * @return the column needing only <code>f</code>.

     * @throws IllegalArgumentException if more than one column matches.

     */

    public final SQLTableModelColumn getColumn(SQLField f) {

        return this.getAllColumns().getColumn(f);

    }

    /**

     * The column depending solely on the passed path.

     *

     * @param fp the field path.

     * @return the column needing only <code>fp</code>.

     * @throws IllegalArgumentException if more than one column matches.

     */

    public final SQLTableModelColumn getColumn(FieldPath fp) {

        return this.getAllColumns().getColumn(fp);

    }

    public final void addColumnListener(PropertyChangeListener l) {

        this.supp.addPropertyChangeListener("cols", l);

    }

    public final void rmColumnListener(PropertyChangeListener l) {

        this.supp.removePropertyChangeListener("cols", l);

    }

    // * SQLIdentifier

    public final ListSQLRequest getReq() {

        return this.req;

    }

    public final SQLTable getPrimaryTable() {

        return this.getReq().getPrimaryTable();

    }

    /**

     * All the displayed tables, i.e. tables of {@link #getLineFields()}.

     *

     * @return the displayed tables.

     */

    public final Set<SQLTable> getTables() {

        return new SQLFieldsSet(this.getLineFields()).getTables();

    }

    /**

     * All fields that affects a line of this source. I.e. not just the displayed fields, but also

     * the foreign keys, including intermediate ones (e.g. if this displays [BATIMENT.DES, CPI.DES]

     * LOCAL.ID_BATIMENT matters).

     *

     * @return the fields affecting this.

     */

    public final Set<SQLField> getLineFields() {

        final Set<SQLField> res = new HashSet<SQLField>();

        for (final SQLRowValues v : getMaxGraph().getGraph().getItems()) {

            for (final String f : v.getFields())

                res.add(v.getTable().getField(f));

            if (v.getTable().isArchivable())

                res.add(v.getTable().getArchiveField());

        }

        return res;

    }

}