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

import org.openconcerto.sql.Configuration;

import org.openconcerto.sql.element.SQLElement;

import org.openconcerto.sql.model.FieldPath;

import org.openconcerto.sql.model.SQLField;

import org.openconcerto.sql.model.SQLRowAccessor;

import org.openconcerto.sql.model.SQLRowValues;

import org.openconcerto.sql.model.SQLTable;

import org.openconcerto.sql.model.SQLTable.VirtualFields;

import org.openconcerto.sql.model.Where;

import org.openconcerto.sql.request.ComboSQLRequest;

import org.openconcerto.sql.request.ListSQLRequest;

import org.openconcerto.sql.request.SQLFieldTranslator;

import org.openconcerto.sql.view.list.RowAction;

import org.openconcerto.sql.view.list.SQLTableModelColumn;

import org.openconcerto.sql.view.list.SQLTableModelSource;

import org.openconcerto.sql.view.list.SQLTableModelSourceOnline;

import org.openconcerto.sql.view.list.TableAction;

import org.openconcerto.ui.AutoHideListener;

import org.openconcerto.ui.light.InformationLine;

import org.openconcerto.ui.light.LightUIElement;

import org.openconcerto.ui.light.LightUILine;

import org.openconcerto.ui.light.LightUIPanel;

import org.openconcerto.ui.light.RowSelectionSpec;

import org.openconcerto.ui.light.SimpleTextLine;

import org.openconcerto.ui.table.TableCellRendererUtils;

import org.openconcerto.utils.GestionDevise;

import org.openconcerto.utils.convertor.ValueConvertor;

import java.awt.Color;

import java.awt.Component;

import java.awt.event.ActionEvent;

import java.lang.reflect.Modifier;

import java.math.BigDecimal;

import java.math.BigInteger;

import java.util.ArrayList;

import java.util.List;

import javax.swing.AbstractAction;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JTable;

import javax.swing.SwingConstants;

import javax.swing.table.DefaultTableCellRenderer;

import javax.swing.table.TableCellRenderer;

import org.jdom2.Document;

import org.jdom2.input.DOMBuilder;

/**

 * SQLElement de la base société

 *

 * @author Administrateur

 *

 */

public abstract class SocieteSQLConfElement extends SQLElement {

    public static final String ACTION_ID_ADD = "add";

    public static final String ACTION_ID_MODIFY = "modify";

    public static final String ACTION_ID_REMOVE = "remove";

    public SocieteSQLConfElement(SQLTable table, String singular, String plural) {

        super(singular, plural, table);

    }

    public SocieteSQLConfElement(SQLTable table) {

        this(table, null);

    }

    public SocieteSQLConfElement(SQLTable table, String code) {

        super(table, null, code);

    }

    public static final TableCellRenderer CURRENCY_RENDERER = new DefaultTableCellRenderer() {

        @Override

        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {

            final Component res = super.getTableCellRendererComponent(table, GestionDevise.currencyToString((BigDecimal) value), isSelected, hasFocus, row, column);

            // this renderer can be decorated by e.g. ListeFactureRenderer which does a

            // setBackground(), thus always reset the colors

            // MAYBE always use ProxyComp as in AlternateTableCellRenderer to leave the decorated

            // renderer as found

            TableCellRendererUtils.setColors(res, table, isSelected);

            ((JLabel) res).setHorizontalAlignment(SwingConstants.RIGHT);

            return res;

        }

    };

    static public final JPanel createAdditionalPanel() {

        return AutoHideListener.listen(new JPanel());

    }

    @Override

    protected String createCode() {

        final String suffix = this.createCodeSuffix();

        if (suffix.indexOf(' ') >= 0)

            throw new IllegalStateException("Suffix contains space : '" + suffix + "'");

        if (suffix.length() < 2)

            throw new IllegalStateException("Suffix too short : '" + suffix + "'");

        return createCodeOfPackage() + suffix;

    }

    protected String createCodeSuffix() {

        return this.createCodeSuffixFromTable();

    }

    protected final String createCodeSuffixFromTable() {

        return '.' + this.getTable().getName();

    }

    /**

     * Return a code that doesn't change when subclassing to allow to easily change a SQLElement

     * while keeping the same code. To achieve that, the code isn't

     * {@link #createCodeOfPackage(Class) computed} with <code>this.getClass()</code>. We iterate up

     * through our superclass chain, and as soon as we find an abstract class, we stop and use the

     * previous class (i.e. non abstract). E.g. any direct subclass of {@link ComptaSQLConfElement}

     * will still use <code>this.getClass()</code>, but so is one of its subclass.

     *

     * @return a code computed from the superclass just under the first abstract superclass.

     * @see #createCodeOfPackage(Class)

     */

    protected final String createCodeOfPackage() {

        return createCodeOfPackage(getLastNonAbstractClass());

    }

    private final Class<? extends SocieteSQLConfElement> getLastNonAbstractClass() {

        return getLastNonAbstractClass(this.getClass(), SocieteSQLConfElement.class);

    }

    static protected final <T extends SQLElement> Class<? extends T> getLastNonAbstractClass(final Class<? extends T> clazz, final Class<T> superClass) {

        Class<?> prev = null;

        Class<?> cl = clazz;

        // test loop

        assert superClass.isAssignableFrom(cl);

        if (Modifier.isAbstract(cl.getModifiers()))

            throw new IllegalArgumentException("Class is abstract : " + cl);

        if (!Modifier.isAbstract(superClass.getModifiers()))

            throw new IllegalArgumentException("Superclass isn't abstract : " + superClass);

        while (!Modifier.isAbstract(cl.getModifiers())) {

            prev = cl;

            cl = cl.getSuperclass();

        }

        return prev.asSubclass(superClass);

    }

    static private final String ERP_CORE = ".erp.core.";

    static private final String ERP_ELEMENT = ".erp.element.";

    static protected String createCodeOfPackage(final Class<? extends SQLElement> cl) {

        String canonicalName = cl.getPackage().getName();

        if (canonicalName.contains(ERP_CORE) && canonicalName.contains(".element")) {

            int i = canonicalName.indexOf(ERP_CORE) + ERP_CORE.length();

            int j = canonicalName.indexOf(".element");

            canonicalName = canonicalName.substring(i, j);

        } else if (canonicalName.contains(ERP_ELEMENT)) {

            canonicalName = canonicalName.substring(canonicalName.indexOf(ERP_ELEMENT) + ERP_ELEMENT.length());

        }

        return canonicalName;

    }

    @Override

    protected void _initTableSource(SQLTableModelSource res) {

        super._initTableSource(res);

        for (final SQLTableModelColumn col : res.getColumns()) {

            // TODO getDeviseFields()

            if (col.getValueClass() == Long.class || col.getValueClass() == BigInteger.class) {

                col.setConverter(new ValueConvertor<Number, BigDecimal>() {

                    @Override

                    public BigDecimal convert(Number o) {

                        if (o == null) {

                            System.err.println("ComptaSQLConfElement._initTableSource: Warning null Number conversion (" + this + ")");

                            return BigDecimal.ZERO;

                        }

                        return new BigDecimal(o.longValue()).movePointLeft(2);

                    }

                    @Override

                    public Number unconvert(BigDecimal o) {

                        if (o == null) {

                            System.err.println("ComptaSQLConfElement._initTableSource: Warning null BigDecimal conversion (" + this + ")");

                            return 0;

                        }

                        return o.movePointRight(2);

                    }

                }, BigDecimal.class);

                col.setRenderer(CURRENCY_RENDERER);

            }

        }

    }

    /**

     * Get columns user preferences for a specific table

     *

     * @param userId - Id of the user who want view the table

     * @param tableId - Id of table to show

     * @param sqlColumns - List of columns to be displayed

     * @return the XML which contains user preferences

     */

    protected Document getColumnsUserPerfs(final Configuration configuration, final int userId, final String tableId, final List<SQLTableModelColumn> sqlColumns) {

        Document columnsPrefs = null;

        try {

            final DOMBuilder in = new DOMBuilder();

            final org.w3c.dom.Document w3cDoc = configuration.getXMLConf(userId, tableId);

            if (w3cDoc != null) {

                columnsPrefs = in.build(w3cDoc);

            }

        } catch (Exception ex) {

            throw new IllegalArgumentException("Failed to get ColumnPrefs for table " + tableId + " and for user " + userId + "\n" + ex.getMessage());

        }

        return columnsPrefs;

    }

    /**

     * Create buttons from SQLElement secondary row actions

     */

    public LightUILine createSecondaryRowActionLine(final RowSelectionSpec selection) {

        return null;

    }

    /**

     * Create information ui panel for selected lines. By default, all fields in SQLRowValues are

     * displayed

     *

     * @param sessionToken - String use to find session on server

     * @param selection - List of SQLRowAccessor attach to selected lines

     *

     * @return null if selection is empty or a LightUIPanel

     */

    public final LightUIPanel createDataPanel(final String sessionToken, final List<SQLRowAccessor> selection) {

        if (selection == null || selection.isEmpty()) {

            return null;

        }

        final LightUIPanel dataPanel = new LightUIPanel(this.getCode() + ".data.panel");

        dataPanel.setVerticallyScrollable(true);

        dataPanel.setWeightX(1);

        dataPanel.setMarginLeft(4);

        this.fillDataPanel(sessionToken, selection, dataPanel);

        return dataPanel;

    }

    protected void fillDataPanel(final String sessionToken, final List<SQLRowAccessor> selection, final LightUIPanel dataPanel) {

        final SQLFieldTranslator translator = this.getDirectory().getTranslator();

        for (final SQLRowAccessor listRow : selection) {

            final int rowId = listRow.getID();

            final LightUILine mainLine = new LightUILine();

            final LightUIPanel mainLinePanel = new LightUIPanel(dataPanel.getId() + ".main.line." + rowId);

            mainLinePanel.setWeightX(1);

            mainLinePanel.addChild(new SimpleTextLine("Information sur l'élément n°" + rowId, true, LightUIElement.HALIGN_CENTER));

            final LightUILine lineData = new LightUILine();

            final LightUIPanel panel = new LightUIPanel(this.getCode() + ".data.panel." + rowId);

            panel.setWeightX(1);

            final List<String> dataPanelFields = this.getDataPanelFields();

            for (final String fieldName : dataPanelFields) {

                this.addFieldToPanel(fieldName, panel, listRow, translator);

            }

            lineData.addChild(panel);

            mainLinePanel.addChild(lineData);

            mainLine.addChild(mainLinePanel);

            dataPanel.addChild(mainLine);

        }

    }

    protected List<String> getDataPanelFields() {

        return this.getListFields();

    }

    public void addFieldToPanel(final String fieldName, final LightUIPanel dataPanel, final SQLRowAccessor sqlRow, final SQLFieldTranslator translator) {

        addFieldToPanel(fieldName, dataPanel, sqlRow, translator, false, "");

    }

    static private final VirtualFields FIELDS_TO_IGNORE = VirtualFields.PRIMARY_KEY.union(VirtualFields.ARCHIVE).union(VirtualFields.ORDER);

    /**

     * Add the field name translation and it's value to the information panel

     *

     * @param fieldName - Field to be translate

     * @param dataPanel - Information panel

     * @param sqlRow - Row which contains data

     * @param translator - Field translator

     */

    public void addFieldToPanel(final String fieldName, final LightUIPanel dataPanel, final SQLRowAccessor sqlRow, final SQLFieldTranslator translator, boolean addEmpty, String defaultValue) {

        final SQLTable sqlTable = sqlRow.getTable();

        final SQLField field = sqlTable.getField(fieldName);

        if (!sqlTable.getFields(FIELDS_TO_IGNORE).contains(field)) {

            String key = translator.getLabelFor(field);

            boolean error = false;

            if (key == null) {

                error = true;

                key = field.getFieldName();

            }

            String value = "";

            if (field.isKey()) {

                final List<FieldPath> fieldsPath = getListExpander().expand(field);

                for (FieldPath fieldPath : fieldsPath) {

                    final SQLRowValues foreignRow = sqlRow.asRowValues().followPath(fieldPath.getPath());

                    if (foreignRow != null) {

                        value += foreignRow.getString(fieldPath.getField().getName()) + " ";

                    }

                }

            } else {

                value = sqlRow.getString(fieldName);

            }

            boolean isDefault = false;

            if (value == null || value.isEmpty()) {

                isDefault = true;

                value = defaultValue;

            }

            if (!value.isEmpty() || addEmpty) {

                final InformationLine line = new InformationLine(key, value);

                if (error) {

                    line.setLabelColor(Color.RED);

                }

                line.setItalicOnValue(isDefault);

                dataPanel.addChild(line);

            }

        }

    }

    public List<SQLRowValues> getRowValues(final String fieldName, final long id) {

        final SQLTableModelSourceOnline tableSource = this.getTableSource(true);

        final ListSQLRequest req = tableSource.getReq();

        req.setWhere(new Where(this.getTable().getField(fieldName), "=", id));

        return req.getValues();

    }

    @Override

    protected void _initComboRequest(ComboSQLRequest req) {

        super._initComboRequest(req);

        req.setSearchable(true);

    }

    /**

     * Primary actions on the element (add/modify/remove)

     */

    public List<TableAction> getPrimaryRowActions() {

        final List<TableAction> actions = new ArrayList<>(3);

        actions.add(new TableAction(getAddAction()));

        actions.add(new TableAction(getModifyAction()));

        actions.add(new TableAction(getRemoveAction()));

        return actions;

    }

    /**

     * Secondary actions on the element (send by email, ..)

     */

    public List<TableAction> getSecondaryRowActions() {

        return new ArrayList<>(0);

    }

    public RowAction getAddAction() {

        return new RowAction(new AbstractAction() {

            public void actionPerformed(ActionEvent e) {

                // nothing here because use on an ActionButtonWithSelection

            }

        }, true, ACTION_ID_ADD) {

            @Override

            public boolean enabledFor(final List<SQLRowValues> selection) {

                return true;

            };

        };

    }

    public RowAction getModifyAction() {

        final RowAction rowAction = new RowAction(new AbstractAction() {

            public void actionPerformed(ActionEvent e) {// nothing here because use on an

                                                        // ActionButtonWithSelection

            }

        }, true, ACTION_ID_MODIFY) {

            @Override

            public boolean enabledFor(final List<SQLRowValues> selection) {

                return (selection != null && selection.size() == 1);

            };

        };

        return rowAction;

    }

    public RowAction getRemoveAction() {

        return new RowAction(new AbstractAction() {

            public void actionPerformed(ActionEvent e) {// nothing here because use on an

                                                        // ActionButtonWithSelection

            }

        }, true, ACTION_ID_REMOVE) {

            @Override

            public boolean enabledFor(final List<SQLRowValues> selection) {

                return (selection != null && !selection.isEmpty());

            };

        };

    }

}