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.supplychain.stock.element;

import org.openconcerto.sql.model.DBRoot;

import org.openconcerto.sql.model.SQLRow;

import org.openconcerto.sql.model.SQLRowAccessor;

import org.openconcerto.sql.model.SQLRowValues;

import org.openconcerto.sql.model.SQLRowValuesListFetcher;

import org.openconcerto.sql.model.SQLSelect;

import org.openconcerto.sql.model.SQLSelectJoin;

import org.openconcerto.sql.model.SQLTable;

import org.openconcerto.sql.model.SQLTableEvent;

import org.openconcerto.sql.model.SQLTableEvent.Mode;

import org.openconcerto.sql.model.Where;

import org.openconcerto.sql.request.UpdateBuilder;

import org.openconcerto.sql.utils.SQLUtils;

import org.openconcerto.utils.ExceptionHandler;

import org.openconcerto.utils.Tuple2;

import org.openconcerto.utils.cc.ITransformer;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.apache.commons.dbutils.ResultSetHandler;

public class ComposedItemStockUpdater {

    private final List<StockItem> itemsUpdated;

    private final DBRoot root;

    /// FIXME mettre à jour les stocks des kits à partir des feuilles

    /**

     * Met à jour les stocks des nomenclature composé par un des articles de itemsUpdated

     *

     * @param root

     * @param itemsUpdated liste des StockItem non composés qui ont été mis à jour

     */

    public ComposedItemStockUpdater(DBRoot root, List<StockItem> itemsUpdated) {

        this.itemsUpdated = itemsUpdated;

        this.root = root;

    }

    /**

     * Mise à jour des stocks en fonction des composants de l'article

     *

     * @throws SQLException

     */

    public void update() throws SQLException {

        // Liste des nomenclatures dépendantes des itemsUpdated

        List<StockItem> items = getAllComposedItemToUpdate();

        updateNomenclature(items);

    }

    public void updateNomenclature(List<StockItem> items) throws SQLException {

        // Fecth des articles liés

        getAllChildren(items);

        List<StockItem> removedBadItem = new ArrayList<>();

        // Mise à jour des stocks

        for (StockItem stockItem : items) {

            if (!stockItem.updateQtyFromChildren()) {

                removedBadItem.add(stockItem);

            }

        }

        items.removeAll(removedBadItem);

        SQLTable stockTable = root.getTable("STOCK");

        List<String> requests = new ArrayList<String>();

        for (StockItem stockItem : items) {

            if (stockItem.isStockInit()) {

                UpdateBuilder update = new UpdateBuilder(stockTable);

                update.setWhere(new Where(stockTable.getKey(), "=", stockItem.stock.getID()));

                update.setObject("QTE_REEL", stockItem.getRealQty());

                update.setObject("QTE_TH", stockItem.getVirtualQty());

                update.setObject("QTE_LIV_ATTENTE", stockItem.getDeliverQty());

                update.setObject("QTE_RECEPT_ATTENTE", stockItem.getReceiptQty());

                requests.add(update.asString());

            } else {

                SQLRowValues rowVals = new SQLRowValues(stockTable);

                rowVals.put("QTE_REEL", stockItem.getRealQty());

                rowVals.put("QTE_TH", stockItem.getVirtualQty());

                rowVals.put("QTE_LIV_ATTENTE", stockItem.getDeliverQty());

                rowVals.put("QTE_RECEPT_ATTENTE", stockItem.getReceiptQty());

                rowVals.put("ID_ARTICLE", stockItem.getArticle().getID());

                rowVals.put("ID_DEPOT_STOCK", stockItem.stock.getForeignID("ID_DEPOT_STOCK"));

                rowVals.commit();

                if (stockItem.getArticle().getForeignID("ID_DEPOT_STOCK") == stockItem.stock.getForeignID("ID_DEPOT_STOCK")) {

                    SQLRowValues rowValsArt = stockItem.getArticle().createEmptyUpdateRow();

                    rowValsArt.put("ID_STOCK", rowVals);

                    rowValsArt.commit();

                }

            }

        }

        List<? extends ResultSetHandler> handlers = new ArrayList<ResultSetHandler>(requests.size());

        for (String s : requests) {

            handlers.add(null);

        }

        SQLUtils.executeMultiple(stockTable.getDBSystemRoot(), requests, handlers);

        stockTable.fire(new SQLTableEvent(stockTable, SQLRow.NONEXISTANT_ID, Mode.ROW_UPDATED));

    }

    /**

     * Associe les StockItems liés aux items passés en parametres

     *

     * @param items liste des stockitems d'article composé

     */

    private void getAllChildren(List<StockItem> items) {

        final SQLTable tableArticle = this.root.getTable("ARTICLE");

        final int undefDepot = tableArticle.getTable("DEPOT_STOCK").getUndefinedID();

        final SQLRowValues rowValsArt = new SQLRowValues(tableArticle);

        rowValsArt.put(tableArticle.getKey().getName(), null);

        SQLRowValues rowValsStock = new SQLRowValues(this.root.getTable("STOCK"));

        rowValsStock.put("QTE_REEL", null);

        rowValsStock.put("QTE_TH", null);

        rowValsStock.put("QTE_RECEPT_ATTENTE", null);

        rowValsStock.put("QTE_LIV_ATTENTE", null);

        rowValsStock.put("ID_DEPOT_STOCK", null);

        rowValsStock.put("ID_ARTICLE", rowValsArt);

        final SQLTable tableArticleElt = this.root.getTable("ARTICLE_ELEMENT");

        SQLRowValues rowValsArtItem = new SQLRowValues(tableArticleElt);

        rowValsArtItem.put("ID_ARTICLE", rowValsArt);

        rowValsArtItem.put("QTE", null);

        rowValsArtItem.put("QTE_UNITAIRE", null);

        rowValsArtItem.put("ID_ARTICLE_PARENT", null);

        final List<Integer> ids = new ArrayList<Integer>();

        Map<Tuple2<Integer, Integer>, StockItem> mapItem = new HashMap<Tuple2<Integer, Integer>, StockItem>();

        for (StockItem stockItem : items) {

            final int id = stockItem.getArticle().getID();

            ids.add(id);

            if (stockItem.stock.getForeignID("ID_DEPOT_STOCK") != undefDepot) {

                mapItem.put(Tuple2.create(id, stockItem.stock.getForeignID("ID_DEPOT_STOCK")), stockItem);

            }

        }

        SQLRowValuesListFetcher fetcher = SQLRowValuesListFetcher.create(rowValsArtItem);

        fetcher.setSelTransf(new ITransformer<SQLSelect, SQLSelect>() {

            @Override

            public SQLSelect transformChecked(SQLSelect input) {

                Where w = new Where(tableArticleElt.getField("ID_ARTICLE_PARENT"), ids);

                input.setWhere(w);

                return input;

            }

        });

        List<SQLRowValues> values = fetcher.fetch();

        for (SQLRowValues sqlRowValues : values) {

            final SQLRowAccessor article = sqlRowValues.getForeign("ID_ARTICLE");

            final SQLRowAccessor articleParent = sqlRowValues.getForeign("ID_ARTICLE_PARENT");

            if (article != null && !article.isUndefined()) {

                final Collection<? extends SQLRowAccessor> referentStockRows = article.getReferentRows(this.root.getTable("STOCK"));

                {

                    // Init Stock if no depot

                    if (referentStockRows.size() == 0) {

                        // init default stock depot

                        SQLRowValues rowVals = new SQLRowValues(article.getTable().getTable("STOCK"));

                        rowVals.put("ID_ARTICLE", article.getID());

                        rowVals.put("ID_DEPOT_STOCK", DepotStockSQLElement.DEFAULT_ID);

                        try {

                            SQLRow rowStock = rowVals.commit();

                            article.createEmptyUpdateRow().put("ID_STOCK", rowStock.getID()).commit();

                            System.err.println("NO DEPOT STOCK FOR ITEM " + articleParent.getID() + " -- PARENT " + articleParent.getID());

                            StockItem stockItem = mapItem.get(Tuple2.create(articleParent.getID(), DepotStockSQLElement.DEFAULT_ID));

                            if (stockItem != null) {

                                stockItem.addItemComponent(new StockItemComponent(new StockItem(article, rowStock), sqlRowValues.getBigDecimal("QTE_UNITAIRE"), sqlRowValues.getInt("QTE")));

                            } else {

                                System.err.println("Unable to find stock of item ARTICLE " + articleParent.getID() + " DEPOT " + DepotStockSQLElement.DEFAULT_ID);

                            }

                        } catch (SQLException e) {

                            ExceptionHandler.handle("Erreur lors de l'initialisation du stock de l'article", e);

                        }

                    }

                }

                for (SQLRowAccessor sqlRowAccessor : referentStockRows) {

                    StockItem stockItem = mapItem.get(Tuple2.create(articleParent.getID(), sqlRowAccessor.getForeignID("ID_DEPOT_STOCK")));

                    if (stockItem != null) {

                        stockItem.addItemComponent(new StockItemComponent(new StockItem(article, sqlRowAccessor), sqlRowValues.getBigDecimal("QTE_UNITAIRE"), sqlRowValues.getInt("QTE")));

                    } else if (sqlRowAccessor.getForeignID("ID_DEPOT_STOCK") == sqlRowAccessor.getTable().getForeignTable("ID_DEPOT_STOCK").getUndefinedID()) {

                        stockItem = mapItem.get(Tuple2.create(articleParent.getID(), DepotStockSQLElement.DEFAULT_ID));

                        stockItem.addItemComponent(new StockItemComponent(new StockItem(article, sqlRowAccessor), sqlRowValues.getBigDecimal("QTE_UNITAIRE"), sqlRowValues.getInt("QTE")));

                    } else {

                        System.err.println("Unable to find stock of item ARTICLE " + articleParent.getID() + " DEPOT " + sqlRowAccessor.getForeignID("ID_DEPOT_STOCK"));

                    }

                }

            }

        }

    }

    /**

     * @return l'ensemble des stockItems composés à mettre à jour

     */

    private List<StockItem> getAllComposedItemToUpdate() {

        // Liste des ids des artciles non composé mis à jour

        Set<Integer> ids = new HashSet<Integer>(itemsUpdated.size());

        for (StockItem stockItem : itemsUpdated) {

            ids.add(stockItem.getArticle().getID());

        }

        // Liste des nomenclatures dépendantes des itemsUpdated

        List<SQLRowValues> list = getComposedItemToUpdate(ids);

        int size = list.size();

        Map<Integer, SQLRowValues> result = new HashMap<Integer, SQLRowValues>(ids.size());

        for (SQLRowValues sqlRowValues : list) {

            result.put(sqlRowValues.getID(), sqlRowValues);

        }

        // Liste des nomenclatures dépendantes des nomenclatures (kit dans kits)

        while (size > 0) {

            List<SQLRowValues> l = getComposedItemToUpdate(ids);

            for (SQLRowValues sqlRowValues : l) {

                result.put(sqlRowValues.getID(), sqlRowValues);

            }

            size = l.size();

            if (size > 0) {

                ids.clear();

                for (SQLRowValues r : l) {

                    ids.add(r.getForeignID("ID_ARTICLE"));

                }

            }

        }

        List<StockItem> items = new ArrayList<StockItem>(result.size());

        for (SQLRowValues rowVals : result.values()) {

            StockItem item = new StockItem(rowVals.getForeign("ID_ARTICLE"), rowVals);

            items.add(item);

        }

        return items;

    }

    /**

     *

     * @param ids

     * @return l'ensemble des Articles composés avec un des articles en parametres

     */

    private List<SQLRowValues> getComposedItemToUpdate(final Set<Integer> ids) {

        final SQLTable tableArticle = this.root.getTable("ARTICLE");

        final SQLRowValues rowValsArt = new SQLRowValues(tableArticle);

        rowValsArt.put(tableArticle.getKey().getName(), null);

        SQLRowValues rowValsStock = new SQLRowValues(this.root.getTable("STOCK"));

        rowValsStock.put("QTE_REEL", null);

        rowValsStock.put("QTE_TH", null);

        rowValsStock.put("QTE_RECEPT_ATTENTE", null);

        rowValsStock.put("QTE_LIV_ATTENTE", null);

        rowValsStock.put("ID_ARTICLE", rowValsArt);

        rowValsStock.put("ID_DEPOT_STOCK", null);

        final SQLTable tableArticleElt = this.root.getTable("ARTICLE_ELEMENT");

        // SQLRowValues rowValsArtItem = new SQLRowValues(tableArticleElt);

        // rowValsArtItem.put("ID_ARTICLE_PARENT", rowValsArt);

        // rowValsArtItem.put("QTE", null);

        // rowValsArtItem.put("QTE_UNITAIRE", null);

        SQLRowValuesListFetcher fetcher = SQLRowValuesListFetcher.create(rowValsStock);

        fetcher.setSelTransf(new ITransformer<SQLSelect, SQLSelect>() {

            @Override

            public SQLSelect transformChecked(SQLSelect input) {

                SQLSelectJoin joinFromField = input.addJoin("RIGHT", tableArticleElt, new Where(tableArticleElt.getField("ID_ARTICLE_PARENT"), "=", input.getTable("STOCK").getField("ID_ARTICLE")));

                Where w = new Where(joinFromField.getJoinedTable().getField("ID_ARTICLE"), ids);

                joinFromField.setWhere(w);

                input.clearOrder();

                input.setDistinct(true);

                return input;

            }

        });

        return fetcher.fetch();

    }

}