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.Log;
import org.openconcerto.sql.model.SQLRow;
import org.openconcerto.sql.model.SQLRowValues;
import org.openconcerto.sql.model.SQLRowValues.CreateMode;
import org.openconcerto.sql.model.SQLRowValuesListFetcher;
import org.openconcerto.sql.model.SQLSelect;
import org.openconcerto.sql.model.graph.Path;
import org.openconcerto.sql.request.BaseFillSQLRequest;
import org.openconcerto.sql.request.ListSQLRequest;
import org.openconcerto.sql.view.list.search.SearchQueue;
import org.openconcerto.utils.CollectionUtils;
import org.openconcerto.utils.ListMap;
import org.openconcerto.utils.Value;
import org.openconcerto.utils.cc.ITransformer;

import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;

abstract class AbstractUpdateOneRunnable extends UpdateRunnable {

    public AbstractUpdateOneRunnable(ITableModel model, final SQLRow r) {
        super(model, r);
        if (this.getID() < SQLRow.MIN_VALID_ID)
            throw new IllegalArgumentException("id is not valid : " + this.getID());
    }

    protected final ListMap<Path, ListSQLLine> getAffectedPaths() {
        return this.getUpdateQ().getAffectedPaths(this.getRow());
    }

    protected final void updateLines(ListMap<Path, ListSQLLine> paths) {
        this.updateLines(paths, Value.<ListSQLLine> getNone());
    }

    protected final void updateLines(ListMap<Path, ListSQLLine> paths, final Value<ListSQLLine> line) {
        final List<ListSQLLine> fullList = this.getUpdateQ().getFullList();
        synchronized (fullList) {
            this._updateLines(paths, line);
        }
    }

    private final void _updateLines(ListMap<Path, ListSQLLine> paths, final Value<ListSQLLine> newLine) {
        final boolean isPrimaryTable = getRow().getTable() == getReq().getParent().getPrimaryTable();
        // if we're refreshing the primary table, the new line must be provided
        assert newLine.hasValue() == isPrimaryTable;
        // even if paths is empty we might have to add a line, so this must be done outside the for
        if (isPrimaryTable) {
            final List<ListSQLLine> lines = paths.getNonNull(new Path(getRow().getTable()));
            if (lines.size() > 1)
                throw new IllegalStateException("More than one line for " + this.getRow() + " : " + lines);
            if (!newLine.hasValue())
                throw new IllegalArgumentException("Missing line");
            // update fullList
            final ListSQLLine oldLine = this.getUpdateQ().replaceLine(getRow().getID(), newLine.getValue());
            assert oldLine == CollectionUtils.getSole(lines);
        }
        for (final Entry<Path, ? extends Collection<ListSQLLine>> e : paths.entrySet()) {
            // eg SITE.ID_CONTACT_CHEF
            final Path p = e.getKey();
            // eg [SQLRowValues(SITE), SQLRowValues(SITE)]
            final List<ListSQLLine> lines = (List<ListSQLLine>) e.getValue();
            // primary table already handled above
            if (p.length() > 0 && !lines.isEmpty()) {
                final ListSQLRequest updateQueueReq = getModel().getLinesSource().getUpdateQueueReq();
                // deepCopy() instead of new SQLRowValues() otherwise the used line's graph will be
                // modified (eg the new instance would be linked to it)
                final SQLRowValues proto = updateQueueReq.getGraphToFetch().followPathToOne(p, CreateMode.CREATE_NONE, false).deepCopy();
                final String lastReferentField = SearchQueue.getLastReferentField(p);
                // there's only one path from the graph start to proto, and we will graft the newly
                // fetched values at the end of p, so remove other values
                if (lastReferentField != null) {
                    proto.put(lastReferentField, null);
                } else {
                    proto.clearReferents();
                    // keep only what has changed, eg CONTACT.NOM
                    proto.retainAll(getModifedFields());
                }
                // the modified fields aren't used at the path (e.g. if we display a row and its
                // same-table origin, the event was added by UpdateQueue.rowModified() since the
                // the modified fields are displayed for the primary row, but might not for the
                // origin)
                if (!proto.getFields().isEmpty()) {
                    // fetch the changed rowValues
                    // ATTN this doesn't use the original fetcher that was used in the updateAll
                    // MAYBE add a slower but accurate mode using the updateAll fetcher (and thus
                    // reloading rows from the primary table and not just the changed rows)
                    final SQLRowValuesListFetcher fetcher = SQLRowValuesListFetcher.create(proto);
                    BaseFillSQLRequest.setupForeign(fetcher);
                    if (updateQueueReq.isLockSelect()) {
                        fetcher.appendSelTransf(new ITransformer<SQLSelect, SQLSelect>() {
                            @Override
                            public SQLSelect transformChecked(SQLSelect input) {
                                input.addLockedTable(getTable().getName());
                                return input;
                            }
                        });
                    }
                    final SQLRowValues soleFetched = fetcher.fetchOne(getRow().getIDNumber());

                    // OK if lastReferentField != null : a referent row has been deleted
                    if (soleFetched == null && lastReferentField == null) {
                        Log.get().fine("no row fetched for " + this + ", lines have been changed without the TableModel knowing : " + lines + " req :\n" + fetcher.getReq());
                        getModel().updateAll();
                    } else {
                        // copy it to each affected lines
                        for (final ListSQLLine line : lines) {
                            // don't update a part of the line, if the whole has been be passed to
                            // UpdateQueue.replaceLine()
                            // (if the primary table is in the graph more than once, and a row is
                            // deleted, the line might get (rightly) removed from the full list and
                            // then searched and added to the table model by the following)
                            if (!isPrimaryTable || getRow().getID() != line.getID())
                                this.getUpdateQ().updateLine(line, p, getRow().getID(), soleFetched);
                        }
                    }
                }
            }
        }
    }

    protected final void updateLines(final Set<Integer> affectedLines, final Integer primaryID) {
        final Set<Integer> idsToFetch;
        if (primaryID != null && !affectedLines.contains(primaryID)) {
            idsToFetch = new HashSet<>(affectedLines);
            idsToFetch.add(primaryID);
        } else {
            idsToFetch = affectedLines;
        }
        final List<ListSQLLine> newLines = getModel().getLinesSource().get(idsToFetch);

        final Set<Integer> notUpdated = new HashSet<>(affectedLines);
        synchronized (this.getUpdateQ().getFullList()) {
            for (final ListSQLLine newLine : newLines) {
                this.getUpdateQ().replaceLine(newLine.getID(), newLine);
                notUpdated.remove(newLine.getID());
            }
            for (final Integer toRemove : notUpdated) {
                this.getUpdateQ().replaceLine(toRemove, null);
            }
        }
    }

    protected abstract Collection<String> getModifedFields();
}