WebSVN - OpenConcerto - Diff - Rev 156 and 174 - /trunk/OpenConcerto/src/org/openconcerto/erp/core/finance/accounting/element/EcritureSQLElement.java


/*
 * 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.finance.accounting.element;
 
import org.openconcerto.erp.config.ComptaPropsConfiguration;
import org.openconcerto.erp.core.common.element.ComptaSQLConfElement;
import org.openconcerto.erp.core.common.ui.DeviseField;
import org.openconcerto.erp.core.common.ui.PanelFrame;
import org.openconcerto.erp.core.edm.AttachmentAction;
import org.openconcerto.erp.core.finance.accounting.ui.AssociationAnalytiquePanel;
import org.openconcerto.erp.core.finance.accounting.ui.ConsultationCompteFrame;
import org.openconcerto.erp.core.finance.accounting.ui.LettrageRenderer;
import org.openconcerto.erp.core.finance.accounting.ui.ListEcritureRenderer;
import org.openconcerto.erp.core.finance.accounting.ui.ListeDesEcrituresPanel;
import org.openconcerto.erp.core.finance.accounting.ui.PointageRenderer;
import org.openconcerto.erp.core.finance.accounting.ui.SuppressionEcrituresPanel;
import org.openconcerto.sql.Configuration;
import org.openconcerto.sql.element.BaseSQLComponent;
import org.openconcerto.sql.element.SQLComponent;
import org.openconcerto.sql.element.SQLElement;
import org.openconcerto.sql.element.TreesOfSQLRows;
import org.openconcerto.sql.model.FieldPath;
import org.openconcerto.sql.model.SQLBase;
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.SQLTable;
import org.openconcerto.sql.model.Where;
import org.openconcerto.sql.model.graph.Path;
import org.openconcerto.sql.request.ListSQLRequest;
import org.openconcerto.sql.request.UpdateBuilder;
import org.openconcerto.sql.sqlobject.ElementComboBox;
import org.openconcerto.sql.users.UserManager;
import org.openconcerto.sql.utils.SQLUtils;
import org.openconcerto.sql.utils.SQLUtils.SQLFactory;
import org.openconcerto.sql.view.EditFrame;
import org.openconcerto.sql.view.list.BaseSQLTableModelColumn;
import org.openconcerto.sql.view.list.IListe;
import org.openconcerto.sql.view.list.IListeAction.IListeEvent;
import org.openconcerto.sql.view.list.RowAction.PredicateRowAction;
import org.openconcerto.sql.view.list.SQLTableModelColumn;
import org.openconcerto.sql.view.list.SQLTableModelSource;
import org.openconcerto.sql.view.list.SQLTableModelSourceOnline;
import org.openconcerto.ui.DefaultGridBagConstraints;
import org.openconcerto.ui.JDate;
import org.openconcerto.ui.component.InteractionMode;
import org.openconcerto.utils.CollectionUtils;
import org.openconcerto.utils.ExceptionHandler;
import org.openconcerto.utils.convertor.ValueConvertor;
 
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
 
 
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Set;
 
import javax.swing.AbstractAction;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
 
import javax.swing.JTextField;
import javax.swing.SwingUtilities;
 
import org.apache.commons.dbutils.handlers.ArrayListHandler;
 
public class EcritureSQLElement extends ComptaSQLConfElement {
 
    public EcritureSQLElement() {
        super("ECRITURE", "une écriture", "écritures");
        PredicateRowAction actionAttachment = new PredicateRowAction(new AttachmentAction("ID_MOUVEMENT").getAction(), true);
        actionAttachment.setPredicate(IListeEvent.getSingleSelectionPredicate());
        getRowActions().add(actionAttachment);
 
        PredicateRowAction consult = new PredicateRowAction(new AbstractAction("Consultation du compte") {
            public void actionPerformed(ActionEvent event) {
                SQLRowAccessor row = IListe.get(event).getSelectedRow();
                consultationCompte(ComptePCESQLElement.getRow(row.getString("COMPTE_NUMERO"), row.getString("COMPTE_NOM")));
            }
        }, false);
        consult.setPredicate(IListeEvent.getSingleSelectionPredicate());
        getRowActions().add(consult);
 
        PredicateRowAction contre = new PredicateRowAction(new AbstractAction("Contrepassation") {
            public void actionPerformed(ActionEvent event) {
                EcritureSQLElement.contrePassationPiece(IListe.get(event).getSelectedId());
            }
        }, false);
        contre.setPredicate(IListeEvent.getSingleSelectionPredicate());
        getRowActions().add(contre);
        // menuDroit.add(new AbstractAction("Valider le mouvement") {
        // public void actionPerformed(ActionEvent event) {
        // if (JOptionPane.showConfirmDialog(null, "Etes vous sûr de vouloir valider le
        // mouvement?") == JOptionPane.YES_OPTION) {
        // EcritureSQLElement.validationEcritures(frame.getPanel().getListe().getSelectedRow().getInt("ID_MOUVEMENT"));
        // }
        // }
        // });
 
        PredicateRowAction clone = new PredicateRowAction(new AbstractAction("Dupliquer") {
            public void actionPerformed(ActionEvent event) {
                EcritureSQLElement.dupliquer(IListe.get(event).fetchSelectedRow());
            }
        }, false);
        clone.setPredicate(IListeEvent.getSingleSelectionPredicate());
        getRowActions().add(clone);
 
        PredicateRowAction an = new PredicateRowAction(new AbstractAction("Gérer l'analytique") {
            public void actionPerformed(ActionEvent event) {
                PanelFrame frameAssoc = new PanelFrame(new AssociationAnalytiquePanel(IListe.get(event).getSelectedRow().asRow()), "Association analytique");
                frameAssoc.setVisible(true);
            }
        }, false);
        an.setPredicate(IListeEvent.getSingleSelectionPredicate());
        getRowActions().add(an);
 
        PredicateRowAction show = new PredicateRowAction(new AbstractAction("Voir la source") {
            public void actionPerformed(ActionEvent event) {
 
                SQLRow row = IListe.get(event).fetchSelectedRow();
 
                MouvementSQLElement.showSource(row.getInt("ID_MOUVEMENT"));
            }
        }, false);
        show.setPredicate(IListeEvent.getSingleSelectionPredicate());
        getRowActions().add(show);
    }
 
    @Override
    protected String getParentFFName() {
        return "ID_MOUVEMENT";
    }
 
    @Override
    public boolean isPrivate() {
        return false;
    }
 
    // Impossible de modifier si validée
    // FIXME impossible de saisir une écriture avant la date de debut d'exercice --> de saisir de
    // document de gest comm
 
    public List<String> getListFields() {
        final List<String> l = new ArrayList<String>();
        l.add("VALIDE");
        l.add("ID_MOUVEMENT");
        if (getTable().contains("NOM_PIECE")) {
            l.add("NOM_PIECE");
        }
        // l.add("ID_COMPTE_PCE");
        l.add("COMPTE_NUMERO");
        l.add("COMPTE_NOM");
        // l.add("ID_JOURNAL");
        l.add("JOURNAL_NOM");
        l.add("NOM");
        l.add("DATE");
 
        l.add("DEBIT");
        l.add("CREDIT");
 
        return l;
    }
 
    protected List<String> getComboFields() {
        final List<String> l = new ArrayList<String>();
        l.add("NOM");
        l.add("DATE");
        l.add("DEBIT");
        l.add("CREDIT");
        l.add("ID_JOURNAL");
        l.add("ID_MOUVEMENT");
        return l;
    }
 
    @Override
    protected void _initListRequest(ListSQLRequest req) {
        super._initListRequest(req);
        req.addToGraphToFetch("VALIDE");
    }
 
    public void consultationCompte(SQLRowAccessor rowCpt) {
 
 
 
 
 
 
 
 
 
        final ListeDesEcrituresPanel panel = new ListeDesEcrituresPanel();
 
 
 
 
 
 
 
 
 
 
 
 
        final ConsultationCompteFrame f = new ConsultationCompteFrame(panel, rowCpt);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        f.getPanel().getListe().setModificationAllowed(false);
        f.pack();
        f.setVisible(true);
    }
 
    @Override
    protected void _initTableSource(SQLTableModelSource res) {
        super._initTableSource(res);
        BaseSQLTableModelColumn analytique = new BaseSQLTableModelColumn("Poste analytique", String.class) {
 
            @Override
            protected Object show_(SQLRowAccessor r) {
                Collection<? extends SQLRowAccessor> assocs = r.getReferentRows(getTable().getTable("ASSOCIATION_ANALYTIQUE"));
                StringBuffer res = new StringBuffer();
 
                for (SQLRowAccessor sqlRowAccessor : assocs) {
                    res.append(sqlRowAccessor.getForeign("ID_POSTE_ANALYTIQUE").getString("NOM"));
                    res.append(", ");
                }
 
                return res.toString();
            }
 
            @Override
            public Set<FieldPath> getPaths() {
                Path p = new Path(getTable());
                p = p.add(getTable().getTable("ASSOCIATION_ANALYTIQUE"));
                p = p.add(p.getLast().getForeignTable("ID_POSTE_ANALYTIQUE"));
                return CollectionUtils.createSet(new FieldPath(p, "NOM"));
            }
        };
        res.getColumns().add(analytique);
        for (SQLTableModelColumn col : res.getColumns()) {
            col.setRenderer(ListEcritureRenderer.UTILS.getRenderer(col.getRenderer()));
        }
    }
 
    public final SQLTableModelSourceOnline createPointageTableSource() {
        final List<String> listEcriture = new ArrayList<String>();
        listEcriture.add("POINTEE");
        listEcriture.add("DATE_POINTEE");
        listEcriture.add("ID_MOUVEMENT");
        listEcriture.add("NOM");
        listEcriture.add("DATE");
        listEcriture.add("DEBIT");
        listEcriture.add("CREDIT");
        final SQLTableModelSourceOnline res = this.instantiateTableSourceOnline(this.createListRequest(listEcriture));
        for (SQLTableModelColumn col : res.getColumns()) {
            if (col.getValueClass() == Long.class || col.getValueClass() == BigInteger.class) {
                col.setConverter(new ValueConvertor<Number, BigDecimal>() {
                    @Override
                    public BigDecimal convert(Number o) {
                        if (o == null) {
                            return BigDecimal.ZERO;
                        }
                        return new BigDecimal(o.longValue()).movePointLeft(2);
                    }
 
                    @Override
                    public Number unconvert(BigDecimal o) {
 
                        if (o == null) {
                            return 0;
                        }
                        return o.movePointRight(2);
                    }
                }, BigDecimal.class);
                col.setRenderer(CURRENCY_RENDERER);
            }
 
            col.setRenderer(PointageRenderer.UTILS.getRenderer(col.getRenderer()));
        }
        return this.initTableSource(res, true);
    }
 
    public final SQLTableModelSourceOnline createLettrageTableSource() {
        final List<String> listEcriture = new ArrayList<String>();
        listEcriture.add("LETTRAGE");
        listEcriture.add("ID_COMPTE_PCE");
        listEcriture.add("ID_MOUVEMENT");
        if (getTable().contains("NOM_PIECE")) {
            listEcriture.add("NOM_PIECE");
        }
        listEcriture.add("NOM");
        listEcriture.add("DATE_LETTRAGE");
        listEcriture.add("DATE");
        listEcriture.add("DEBIT");
        listEcriture.add("CREDIT");
        final SQLTableModelSourceOnline res = this.instantiateTableSourceOnline(this.createListRequest(listEcriture));
        for (SQLTableModelColumn col : res.getColumns()) {
            if (col.getValueClass() == Long.class || col.getValueClass() == BigInteger.class) {
                col.setConverter(new ValueConvertor<Number, BigDecimal>() {
                    @Override
                    public BigDecimal convert(Number o) {
                        if (o == null) {
                            return BigDecimal.ZERO;
                        }
                        return new BigDecimal(o.longValue()).movePointLeft(2);
                    }
 
                    @Override
                    public Number unconvert(BigDecimal o) {
 
                        if (o == null) {
                            return 0;
                        }
                        return o.movePointRight(2);
                    }
                }, BigDecimal.class);
                col.setRenderer(CURRENCY_RENDERER);
            }
            col.setRenderer(LettrageRenderer.UTILS.getRenderer(col.getRenderer()));
        }
        return this.initTableSource(res, true);
    }
 
    /*
     * (non-Javadoc)
     * 
     * @see org.openconcerto.devis.SQLElement#getComponent()
     */
    public SQLComponent createComponent() {
        return new BaseSQLComponent(this) {
 
            private JTextField nom;
            private DeviseField debit;
            private DeviseField credit;
            private JDate date;
            private ElementComboBox journal;
 
            public void addViews() {
                this.setLayout(new GridBagLayout());
                final GridBagConstraints c = new DefaultGridBagConstraints();
 
                this.nom = new JTextField();
                this.debit = new DeviseField();
                this.credit = new DeviseField();
                this.date = new JDate();
                this.journal = new ElementComboBox();
                // Mouvement
                /*
                 * JLabel labelMouvement = new JLabel("Mouvement"); this.add(labelMouvement, c);
                 * 
                 * c.gridx ++; c.weightx = 1; this.add(idMouvement, c);
                 */
 
                // Journal
                JLabel labelJournal = new JLabel("Journal");
                c.gridx = 0;
                this.add(labelJournal, c);
 
                c.gridx++;
                c.weightx = 1;
                this.add(this.journal, c);
 
                // Date
                JLabel labelDate = new JLabel("Date");
                c.gridx++;
                this.add(labelDate, c);
 
                c.gridx++;
                c.weightx = 1;
                this.add(this.date, c);
 
                // libellé
                JLabel labelNom = new JLabel("Libellé");
                c.gridy++;
                c.gridx = 0;
                this.add(labelNom, c);
 
                c.gridx++;
                c.weightx = 1;
                c.gridwidth = GridBagConstraints.REMAINDER;
                this.add(this.nom, c);
 
                // debit
                c.gridwidth = 1;
                JLabel labelDebit = new JLabel("Debit");
                c.gridy++;
                c.gridx = 0;
                this.add(labelDebit, c);
 
                c.gridx++;
                c.weightx = 1;
                this.add(this.debit, c);
                this.debit.addKeyListener(new KeyAdapter() {
                    public void keyReleased(KeyEvent e) {
                        if ((credit.getText().trim().length() != 0) && (debit.getText().trim().length() != 0)) {
                            credit.setText("");
                        }
                    }
                });
 
                // Credit
                JLabel labelCredit = new JLabel("Credit");
                c.gridx++;
                this.add(labelCredit, c);
 
                c.gridx++;
                c.weightx = 1;
                this.add(this.credit, c);
 
                this.credit.addKeyListener(new KeyAdapter() {
                    public void keyReleased(KeyEvent e) {
                        if ((debit.getText().trim().length() != 0) && (credit.getText().trim().length() != 0)) {
                            debit.setText("");
                        }
                    }
                });
 
                this.addSQLObject(this.nom, "NOM");
                this.addSQLObject(this.debit, "DEBIT");
                this.addSQLObject(this.credit, "CREDIT");
                this.addRequiredSQLObject(this.date, "DATE");
                this.addRequiredSQLObject(this.journal, "ID_JOURNAL");
            }
 
            @Override
            public void select(SQLRowAccessor r) {
                super.select(r);
 
                if (r != null && r.getBoolean("VALIDE")) {
                    this.nom.setEnabled(false);
                    this.debit.setEnabled(false);
                    this.credit.setEnabled(false);
                    this.date.setInteractionMode(InteractionMode.DISABLED);
                    this.journal.setEnabled(false);
                }
 
            }
 
            public void update() {
                SQLRow row = EcritureSQLElement.this.getTable().getRow(getSelectedID());
                if (row.getBoolean("VALIDE")) {
                    System.out.println("Impossible de modifier une ecriture validée");
                } else {
                    super.update();
                }
            }
 
        };
    }
 
    /**
     * Validation d'un mouvement, implique la validation de l'ensemble de la piece
     * 
     * @param idMvt
     */
    private static void validerMouvement(int idMvt) {
 
        if (idMvt == 1) {
            return;
        }
 
        SQLTable tableMvt = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("MOUVEMENT");
        SQLRow rowMvt = tableMvt.getRow(idMvt);
 
        // On parcourt en profondeur
        if (rowMvt.getInt("ID_MOUVEMENT_PERE") > 1) {
            validerMouvement(rowMvt.getInt("ID_MOUVEMENT_PERE"));
        } else {
            validerMouvementProfondeur(idMvt);
        }
    }
 
    /**
     * Valider l'ensemble des mouvements formés par le sous arbre de du mouvement d'id idMvtPere
     * 
     * @param idMvtPere
     */
    private static void validerMouvementProfondeur(int idMvtPere) {
        SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
        SQLTable tableMvt = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("MOUVEMENT");
 
        SQLSelect selectFils = new SQLSelect();
        selectFils.addSelect(tableMvt.getField("ID"));
        selectFils.setWhere(tableMvt.getField("ID_MOUVEMENT_PERE"), "=", idMvtPere);
 
        List l = (List) base.getDataSource().execute(selectFils.asString(), new ArrayListHandler());
 
        // valide mouvements fils
        for (int i = 0; i < l.size(); i++) {
            Object[] tmp = (Object[]) l.get(i);
            validerMouvementProfondeur(Integer.parseInt(tmp[0].toString()));
        }
 
        // valide mouvement
        validationEcritures(idMvtPere);
    }
 
    /**
     * Valide l'ensemble des ecritures du mouvement
     * 
     * @param idMvt Id du mouvement à valider
     */
    public static final void validationEcritures(int idMvt) {
        SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
        SQLTable tableEcriture = base.getTable("ECRITURE");
 
        SQLSelect selEcriture = new SQLSelect(base);
        selEcriture.addSelect(tableEcriture.getField("ID"));
 
        Where w = new Where(tableEcriture.getField("ID_MOUVEMENT"), "=", idMvt);
 
        selEcriture.setWhere(w);
 
        String reqEcriture = selEcriture.asString();
 
        Object obEcriture = base.getDataSource().execute(reqEcriture, new ArrayListHandler());
 
        List myListEcriture = (List) obEcriture;
 
        if (myListEcriture.size() != 0) {
 
            for (int i = 0; i < myListEcriture.size(); i++) {
                Object[] objTmp = (Object[]) myListEcriture.get(i);
                valideEcriture(Integer.parseInt(objTmp[0].toString()));
            }
        }
    }
 
    /**
     * Validation des ecritures avant la date d
     * 
     * @param d date
     * @param cloture
     */
    public static final void validationEcrituresBefore(Date d, boolean cloture) {
 
        SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
        SQLTable tableEcriture = base.getTable("ECRITURE");
 
        // on recupere l'ensemble des mouvements à valider
        SQLSelect selEcriture = new SQLSelect(base);
        selEcriture.addSelect(tableEcriture.getField("ID_MOUVEMENT"));
        selEcriture.setDistinct(true);
        Where w1 = new Where(tableEcriture.getField("DATE"), "<=", d);
        Where w2 = new Where(tableEcriture.getField("VALIDE"), "=", Boolean.FALSE);
        selEcriture.setWhere(w1.and(w2));
        List l = (List) base.getDataSource().execute(selEcriture.asString(), new ArrayListHandler());
 
        // validation de tous les mouvements
        for (int i = 0; i < l.size(); i++) {
            Object[] tmp = (Object[]) l.get(i);
            System.err.println("Validation du mouvement " + tmp[0]);
            validationEcritures(Integer.parseInt(tmp[0].toString()));
        }
 
        if (cloture) {
 
            SQLTable tableExercice = Configuration.getInstance().getBase().getTable("EXERCICE_COMMON");
 
            SQLRow rowSociete = ((ComptaPropsConfiguration) Configuration.getInstance()).getRowSociete();
            SQLRow rowExercice = tableExercice.getRow(rowSociete.getInt("ID_EXERCICE_COMMON"));
            Date dateCloture = (Date) rowExercice.getObject("DATE_CLOTURE");
 
            if (dateCloture == null || dateCloture.before(d)) {
 
                SQLRowValues rowVals = new SQLRowValues(tableExercice);
                rowVals.put("DATE_CLOTURE", new java.sql.Date(d.getTime()));
                try {
                    rowVals.update(rowExercice.getID());
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
 
    private static final void valideEcriture(int id) {
        SQLTable tableEcriture = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("ECRITURE");
        SQLRowValues rowVals = new SQLRowValues(tableEcriture);
        rowVals.put("VALIDE", Boolean.TRUE);
        rowVals.put("DATE_VALIDE", new java.sql.Date(new Date().getTime()));
        rowVals.put("IDUSER_VALIDE", UserManager.getInstance().getCurrentUser().getId());
 
        try {
            rowVals.update(id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
 
    public void archiveMouvement(int idMvt) {
        SQLTable tableMouvement = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("MOUVEMENT");
        SQLRow rowMvt = tableMouvement.getRow(idMvt);
 
        if (rowMvt.getInt("ID_MOUVEMENT_PERE") > 1) {
            archiveMouvement(rowMvt.getInt("ID_MOUVEMENT_PERE"));
        } else {
            archiveMouvementProfondeur(idMvt, true);
        }
    }
 
    /**
     * Archivage de l'ensemble des opérations liés au mouvement passé en parametre
     * 
     * @param idMvtPere mouvement racine
     * @param dropPere suppression du mouvement pere
     */
    public void archiveMouvementProfondeur(int idMvtPere, boolean dropPere) {
        if (idMvtPere > 1) {
            SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
            SQLTable tableMvt = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("MOUVEMENT");
 
            SQLSelect selectFils = new SQLSelect();
            selectFils.addSelect(tableMvt.getField("ID"));
            selectFils.setWhere(tableMvt.getField("ID_MOUVEMENT_PERE"), "=", idMvtPere);
 
            List l = (List) base.getDataSource().execute(selectFils.asString(), new ArrayListHandler());
 
            // archive mouvements fils
            for (int i = 0; i < l.size(); i++) {
                Object[] tmp = (Object[]) l.get(i);
                archiveMouvementProfondeur(Integer.parseInt(tmp[0].toString()), true);
            }
 
            // archive mouvement
            archiveEcritures(idMvtPere, dropPere);
 
        } else {
 
            System.err.println("Suppression du mouvement d'id 1 impossible.");
            JOptionPane.showMessageDialog(null, "Impossible d'archiver, le mouvement est indéfini.");
        }
    }
 
    // Suppression des ecritures associées à un mouvement
    public synchronized void archiveEcritures(final int idMvt, final boolean dropMvt) {
        final SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
        final SQLTable tableMvt = base.getTable("MOUVEMENT");
        final SQLTable tableEcriture = base.getTable("ECRITURE");
        final SQLRow rowMvt = tableMvt.getRow(idMvt);
 
        // on verifie que le mouvement n'est pas validé
        if (MouvementSQLElement.isEditable(idMvt)) {
 
            // on archive le mouvement
            if (dropMvt) {
 
                SQLElement elt = getDirectory().getElement(tableMvt);
 
                try {
                    elt.archive(idMvt);
                } catch (SQLException e) {
                    ExceptionHandler.handle("Erreur lors de la suppression du mouvement d'id [" + idMvt + "]", e);
                    e.printStackTrace();
                }
            } else {
 
                SQLFactory<Object> sqlFactory = new SQLFactory<Object>() {
                    @Override
                    public Object create() throws SQLException {
                        // on recupere l'ensemble des ecritures associées au mouvement
                        SQLSelect selEcritures = new SQLSelect();
                        selEcritures.addSelect(tableEcriture.getField("ID"));
                        selEcritures.setWhere(tableEcriture.getField("ID_MOUVEMENT"), "=", idMvt);
 
                        List l = (List) base.getDataSource().execute(selEcritures.asString(), new ArrayListHandler());
                        for (int i = 0; i < l.size(); i++) {
                            Object[] tmp = (Object[]) l.get(i);
                            archiveEcriture(tableEcriture.getRow(Integer.parseInt(tmp[0].toString())));
                        }
 
                        return null;
                    }
                };
 
                try {
                    SQLUtils.executeAtomic(base.getDataSource(), sqlFactory);
                } catch (SQLException e) {
 
                    ExceptionHandler.handle("Une erreur est survenue lors de la suppression des écritures.", e);
                }
            }
 
        } else {
            JOptionPane.showMessageDialog(null, "Impossible de supprimer le mouvement n°" + rowMvt.getInt("NUMERO") + " car il est validé.");
        }
    }
 
    @Override
    protected void archive(TreesOfSQLRows trees, boolean cutLinks) throws SQLException {
        for (SQLRow row : trees.getRows()) {
            // Si on supprime une ecriture on doit supprimer toutes les ecritures du mouvement
            // associé
            System.err.println("Archivage des écritures");
            // archiveMouvement(row.getInt("ID_MOUVEMENT"));
            JFrame frame = new PanelFrame(new SuppressionEcrituresPanel(row.getInt("ID_MOUVEMENT")), "Suppression d'ecritures");
            frame.pack();
            frame.setResizable(false);
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
        }
    }
 
    /**
     * Permet d'archiver une ecriture seule attention méthode à utiliser en vérifiant que la balance
     * est respectée
     * 
     * @param row
     * @throws SQLException
     */
    public void archiveEcriture(SQLRow row) throws SQLException {
 
        if (!row.getBoolean("VALIDE")) {
 
            SQLRowValues rowVals = new SQLRowValues(this.getTable());
            rowVals.put("IDUSER_DELETE", UserManager.getInstance().getCurrentUser().getId());
            rowVals.put("ARCHIVE", 1);
            rowVals.update(row.getID());
 
            // Annulation du lettrage si l'ecriture est lettrée pour ne pas avoir de lettrage
            // déséquilibré
            final String codeLettrage = row.getString("LETTRAGE");
            if (codeLettrage != null && codeLettrage.trim().length() > 0) {
                UpdateBuilder builder = new UpdateBuilder(getTable());
                builder.setObject("LETTRAGE", "");
                builder.setObject("DATE_LETTRAGE", null);
                builder.setWhere(new Where(getTable().getField("LETTRAGE"), "=", codeLettrage));
                getTable().getDBSystemRoot().getDataSource().execute(builder.asString());
            }
 
            // super.archive(row, true);
        } else {
            System.err.println("Impossible de supprimer une ecriture validée");
            JOptionPane.showMessageDialog(null, "Impossible de supprimer une ecriture validée. \n" + row);
        }
    }
 
    private static EditFrame frameSaisieKm = null;
 
    /**
     * Contrepassation d'un piece comptable à partir de l'id d'une écriture. Chargement d'un panel
     * Saisie au Km avec les ecritures inversées
     * 
     * @param id
     */
    public static void contrePassationPiece(int id) {
 
        SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
 
        SQLTable tableEcriture = base.getTable("ECRITURE");
        SQLRow rowEcr = tableEcriture.getRow(id);
        final int idMvt = rowEcr.getInt("ID_MOUVEMENT");
        System.err.println("ID MOUVEMENT --> " + idMvt);
        if (frameSaisieKm == null) {
            frameSaisieKm = new EditFrame(Configuration.getInstance().getDirectory().getElement("SAISIE_KM"));
        }
 
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                SaisieKmSQLElement.loadContrePassation(frameSaisieKm.getSQLComponent(), idMvt);
            }
        });
        frameSaisieKm.setVisible(true);
    }
 
    @Override
    protected String createCode() {
        return createCodeOfPackage() + ".entry.item";
    }
 
    public static void dupliquer(SQLRow selectedRow) {
 
        final SQLRow foreignMvt = selectedRow.getForeign("ID_MOUVEMENT");
        if (foreignMvt.getString("SOURCE").equalsIgnoreCase("SAISIE_KM")) {
            final SQLElement elementSaisieKm = Configuration.getInstance().getDirectory().getElement("SAISIE_KM");
            final SQLElement elementSaisieKmItem = Configuration.getInstance().getDirectory().getElement("SAISIE_KM_ELEMENT");
            final EditFrame frameCloneSaisieKm = new EditFrame(elementSaisieKm);
            int idSource = foreignMvt.getInt("IDSOURCE");
            SQLRow rowKm = elementSaisieKm.getTable().getRow(idSource);
            final SQLRowValues rowVals = elementSaisieKm.createCopy(idSource);
            rowVals.put("ID_MOUVEMENT", null);
            Collection<SQLRow> items = rowKm.getReferentRows(elementSaisieKm.getTable().getTable("SAISIE_KM_ELEMENT"));
            for (SQLRow sqlRow : items) {
                SQLRowValues sqlRowValues = elementSaisieKmItem.createCopy(sqlRow.getID());
                sqlRowValues.put("ID_ECRITURE", null);
                sqlRowValues.put("ID_SAISIE_KM", rowVals);
                System.err.println("ADD ELEMENT KM :: " + sqlRowValues.getID());
            }
 
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    frameCloneSaisieKm.getSQLComponent().select(rowVals);
                }
            });
            frameCloneSaisieKm.setVisible(true);
        } else {
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    JOptionPane.showMessageDialog(null, "La duplication n'est possible que sur les saisies au kilomètre");
                }
            });
        }
    }
}

Rev 156	Rev 174
1	`/*`	1	`/*`
2	`* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.`	2	`* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.`
3	`*`	3	`*`
4	`* Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.`	4	`* Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.`
5	`*`	5	`*`
6	`* The contents of this file are subject to the terms of the GNU General Public License Version 3`	6	`* The contents of this file are subject to the terms of the GNU General Public License Version 3`
7	`* only ("GPL"). You may not use this file except in compliance with the License. You can obtain a`	7	`* only ("GPL"). You may not use this file except in compliance with the License. You can obtain a`
8	`* copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific`	8	`* copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific`
9	`* language governing permissions and limitations under the License.`	9	`* language governing permissions and limitations under the License.`
10	`*`	10	`*`
11	`* When distributing the software, include this License Header Notice in each file.`	11	`* When distributing the software, include this License Header Notice in each file.`
12	`*/`	12	`*/`
13		13
14	`package org.openconcerto.erp.core.finance.accounting.element;`	14	`package org.openconcerto.erp.core.finance.accounting.element;`
15		15
16	`import org.openconcerto.erp.config.ComptaPropsConfiguration;`	16	`import org.openconcerto.erp.config.ComptaPropsConfiguration;`
17	`import org.openconcerto.erp.core.common.element.ComptaSQLConfElement;`	17	`import org.openconcerto.erp.core.common.element.ComptaSQLConfElement;`
18	`import org.openconcerto.erp.core.common.ui.DeviseField;`	18	`import org.openconcerto.erp.core.common.ui.DeviseField;`
19	`import org.openconcerto.erp.core.common.ui.PanelFrame;`	19	`import org.openconcerto.erp.core.common.ui.PanelFrame;`
20	`import org.openconcerto.erp.core.edm.AttachmentAction;`	20	`import org.openconcerto.erp.core.edm.AttachmentAction;`
21	`import org.openconcerto.erp.core.finance.accounting.ui.AssociationAnalytiquePanel;`	21	`import org.openconcerto.erp.core.finance.accounting.ui.AssociationAnalytiquePanel;`
22	`import org.openconcerto.erp.core.finance.accounting.ui.ConsultationCompteFrame;`	22	`import org.openconcerto.erp.core.finance.accounting.ui.ConsultationCompteFrame;`
23	`import org.openconcerto.erp.core.finance.accounting.ui.LettrageRenderer;`	23	`import org.openconcerto.erp.core.finance.accounting.ui.LettrageRenderer;`
24	`import org.openconcerto.erp.core.finance.accounting.ui.ListEcritureRenderer;`	24	`import org.openconcerto.erp.core.finance.accounting.ui.ListEcritureRenderer;`
25	`import org.openconcerto.erp.core.finance.accounting.ui.ListeDesEcrituresPanel;`	25	`import org.openconcerto.erp.core.finance.accounting.ui.ListeDesEcrituresPanel;`
26	`import org.openconcerto.erp.core.finance.accounting.ui.PointageRenderer;`	26	`import org.openconcerto.erp.core.finance.accounting.ui.PointageRenderer;`
27	`import org.openconcerto.erp.core.finance.accounting.ui.SuppressionEcrituresPanel;`	27	`import org.openconcerto.erp.core.finance.accounting.ui.SuppressionEcrituresPanel;`
28	`import org.openconcerto.sql.Configuration;`	28	`import org.openconcerto.sql.Configuration;`
29	`import org.openconcerto.sql.element.BaseSQLComponent;`	29	`import org.openconcerto.sql.element.BaseSQLComponent;`
30	`import org.openconcerto.sql.element.SQLComponent;`	30	`import org.openconcerto.sql.element.SQLComponent;`
31	`import org.openconcerto.sql.element.SQLElement;`	31	`import org.openconcerto.sql.element.SQLElement;`
32	`import org.openconcerto.sql.element.TreesOfSQLRows;`	32	`import org.openconcerto.sql.element.TreesOfSQLRows;`
33	`import org.openconcerto.sql.model.FieldPath;`	33	`import org.openconcerto.sql.model.FieldPath;`
34	`import org.openconcerto.sql.model.SQLBase;`	34	`import org.openconcerto.sql.model.SQLBase;`
35	`import org.openconcerto.sql.model.SQLRow;`	35	`import org.openconcerto.sql.model.SQLRow;`
36	`import org.openconcerto.sql.model.SQLRowAccessor;`	36	`import org.openconcerto.sql.model.SQLRowAccessor;`
37	`import org.openconcerto.sql.model.SQLRowValues;`	37	`import org.openconcerto.sql.model.SQLRowValues;`
38	`import org.openconcerto.sql.model.SQLSelect;`	38	`import org.openconcerto.sql.model.SQLSelect;`
39	`import org.openconcerto.sql.model.SQLTable;`	39	`import org.openconcerto.sql.model.SQLTable;`
40	`import org.openconcerto.sql.model.Where;`	40	`import org.openconcerto.sql.model.Where;`
41	`import org.openconcerto.sql.model.graph.Path;`	41	`import org.openconcerto.sql.model.graph.Path;`
42	`import org.openconcerto.sql.request.ListSQLRequest;`	42	`import org.openconcerto.sql.request.ListSQLRequest;`
43	`import org.openconcerto.sql.request.UpdateBuilder;`	43	`import org.openconcerto.sql.request.UpdateBuilder;`
44	`import org.openconcerto.sql.sqlobject.ElementComboBox;`	44	`import org.openconcerto.sql.sqlobject.ElementComboBox;`
45	`import org.openconcerto.sql.users.UserManager;`	45	`import org.openconcerto.sql.users.UserManager;`
46	`import org.openconcerto.sql.utils.SQLUtils;`	46	`import org.openconcerto.sql.utils.SQLUtils;`
47	`import org.openconcerto.sql.utils.SQLUtils.SQLFactory;`	47	`import org.openconcerto.sql.utils.SQLUtils.SQLFactory;`
48	`import org.openconcerto.sql.view.EditFrame;`	48	`import org.openconcerto.sql.view.EditFrame;`
49	`import org.openconcerto.sql.view.list.BaseSQLTableModelColumn;`	49	`import org.openconcerto.sql.view.list.BaseSQLTableModelColumn;`
50	`import org.openconcerto.sql.view.list.IListe;`	50	`import org.openconcerto.sql.view.list.IListe;`
51	`import org.openconcerto.sql.view.list.IListeAction.IListeEvent;`	51	`import org.openconcerto.sql.view.list.IListeAction.IListeEvent;`
52	`import org.openconcerto.sql.view.list.RowAction.PredicateRowAction;`	52	`import org.openconcerto.sql.view.list.RowAction.PredicateRowAction;`
53	`import org.openconcerto.sql.view.list.SQLTableModelColumn;`	53	`import org.openconcerto.sql.view.list.SQLTableModelColumn;`
54	`import org.openconcerto.sql.view.list.SQLTableModelSource;`	54	`import org.openconcerto.sql.view.list.SQLTableModelSource;`
55	`import org.openconcerto.sql.view.list.SQLTableModelSourceOnline;`	55	`import org.openconcerto.sql.view.list.SQLTableModelSourceOnline;`
56	`import org.openconcerto.ui.DefaultGridBagConstraints;`	56	`import org.openconcerto.ui.DefaultGridBagConstraints;`
57	`import org.openconcerto.ui.JDate;`	57	`import org.openconcerto.ui.JDate;`
58	`import org.openconcerto.ui.component.InteractionMode;`	58	`import org.openconcerto.ui.component.InteractionMode;`
59	`import org.openconcerto.utils.CollectionUtils;`	59	`import org.openconcerto.utils.CollectionUtils;`
60	`import org.openconcerto.utils.ExceptionHandler;`	60	`import org.openconcerto.utils.ExceptionHandler;`
61	`import org.openconcerto.utils.convertor.ValueConvertor;`	61	`import org.openconcerto.utils.convertor.ValueConvertor;`
62		62
63	`import java.awt.GridBagConstraints;`	63	`import java.awt.GridBagConstraints;`
64	`import java.awt.GridBagLayout;`	64	`import java.awt.GridBagLayout;`
65	`import java.awt.event.ActionEvent;`	65	`import java.awt.event.ActionEvent;`
66	`import java.awt.event.KeyAdapter;`	66	`import java.awt.event.KeyAdapter;`
67	`import java.awt.event.KeyEvent;`	67	`import java.awt.event.KeyEvent;`
68	`import java.awt.event.MouseAdapter;`	-
69	`import java.awt.event.MouseEvent;`	-
70	`import java.math.BigDecimal;`	68	`import java.math.BigDecimal;`
71	`import java.math.BigInteger;`	69	`import java.math.BigInteger;`
72	`import java.sql.SQLException;`	70	`import java.sql.SQLException;`
73	`import java.util.ArrayList;`	71	`import java.util.ArrayList;`
74	`import java.util.Collection;`	72	`import java.util.Collection;`
75	`import java.util.Date;`	73	`import java.util.Date;`
76	`import java.util.List;`	74	`import java.util.List;`
77	`import java.util.Set;`	75	`import java.util.Set;`
78		76
79	`import javax.swing.AbstractAction;`	77	`import javax.swing.AbstractAction;`
80	`import javax.swing.JFrame;`	78	`import javax.swing.JFrame;`
81	`import javax.swing.JLabel;`	79	`import javax.swing.JLabel;`
82	`import javax.swing.JOptionPane;`	80	`import javax.swing.JOptionPane;`
83	`import javax.swing.JPopupMenu;`	-
84	`import javax.swing.JTextField;`	81	`import javax.swing.JTextField;`
85	`import javax.swing.SwingUtilities;`	82	`import javax.swing.SwingUtilities;`
86		83
87	`import org.apache.commons.dbutils.handlers.ArrayListHandler;`	84	`import org.apache.commons.dbutils.handlers.ArrayListHandler;`
88		85
89	`public class EcritureSQLElement extends ComptaSQLConfElement {`	86	`public class EcritureSQLElement extends ComptaSQLConfElement {`
90		87
91	`public EcritureSQLElement() {`	88	`public EcritureSQLElement() {`
92	`super("ECRITURE", "une écriture", "écritures");`	89	`super("ECRITURE", "une écriture", "écritures");`
93	`PredicateRowAction actionAttachment = new PredicateRowAction(new AttachmentAction("ID_MOUVEMENT").getAction(), true);`	90	`PredicateRowAction actionAttachment = new PredicateRowAction(new AttachmentAction("ID_MOUVEMENT").getAction(), true);`
94	`actionAttachment.setPredicate(IListeEvent.getSingleSelectionPredicate());`	91	`actionAttachment.setPredicate(IListeEvent.getSingleSelectionPredicate());`
95	`getRowActions().add(actionAttachment);`	92	`getRowActions().add(actionAttachment);`
96		93
97	`PredicateRowAction consult = new PredicateRowAction(new AbstractAction("Consultation du compte") {`	94	`PredicateRowAction consult = new PredicateRowAction(new AbstractAction("Consultation du compte") {`
98	`public void actionPerformed(ActionEvent event) {`	95	`public void actionPerformed(ActionEvent event) {`
99	`SQLRowAccessor row = IListe.get(event).getSelectedRow();`	96	`SQLRowAccessor row = IListe.get(event).getSelectedRow();`
100	`consultationCompte(ComptePCESQLElement.getRow(row.getString("COMPTE_NUMERO"), row.getString("COMPTE_NOM")));`	97	`consultationCompte(ComptePCESQLElement.getRow(row.getString("COMPTE_NUMERO"), row.getString("COMPTE_NOM")));`
101	`}`	98	`}`
102	`}, false);`	99	`}, false);`
103	`consult.setPredicate(IListeEvent.getSingleSelectionPredicate());`	100	`consult.setPredicate(IListeEvent.getSingleSelectionPredicate());`
104	`getRowActions().add(consult);`	101	`getRowActions().add(consult);`
105		102
106	`PredicateRowAction contre = new PredicateRowAction(new AbstractAction("Contrepassation") {`	103	`PredicateRowAction contre = new PredicateRowAction(new AbstractAction("Contrepassation") {`
107	`public void actionPerformed(ActionEvent event) {`	104	`public void actionPerformed(ActionEvent event) {`
108	`EcritureSQLElement.contrePassationPiece(IListe.get(event).getSelectedId());`	105	`EcritureSQLElement.contrePassationPiece(IListe.get(event).getSelectedId());`
109	`}`	106	`}`
110	`}, false);`	107	`}, false);`
111	`contre.setPredicate(IListeEvent.getSingleSelectionPredicate());`	108	`contre.setPredicate(IListeEvent.getSingleSelectionPredicate());`
112	`getRowActions().add(contre);`	109	`getRowActions().add(contre);`
113	`// menuDroit.add(new AbstractAction("Valider le mouvement") {`	110	`// menuDroit.add(new AbstractAction("Valider le mouvement") {`
114	`// public void actionPerformed(ActionEvent event) {`	111	`// public void actionPerformed(ActionEvent event) {`
115	`// if (JOptionPane.showConfirmDialog(null, "Etes vous sûr de vouloir valider le`	112	`// if (JOptionPane.showConfirmDialog(null, "Etes vous sûr de vouloir valider le`
116	`// mouvement?") == JOptionPane.YES_OPTION) {`	113	`// mouvement?") == JOptionPane.YES_OPTION) {`
117	`// EcritureSQLElement.validationEcritures(frame.getPanel().getListe().getSelectedRow().getInt("ID_MOUVEMENT"));`	114	`// EcritureSQLElement.validationEcritures(frame.getPanel().getListe().getSelectedRow().getInt("ID_MOUVEMENT"));`
118	`// }`	115	`// }`
119	`// }`	116	`// }`
120	`// });`	117	`// });`
121		118
122	`PredicateRowAction clone = new PredicateRowAction(new AbstractAction("Dupliquer") {`	119	`PredicateRowAction clone = new PredicateRowAction(new AbstractAction("Dupliquer") {`
123	`public void actionPerformed(ActionEvent event) {`	120	`public void actionPerformed(ActionEvent event) {`
124	`EcritureSQLElement.dupliquer(IListe.get(event).fetchSelectedRow());`	121	`EcritureSQLElement.dupliquer(IListe.get(event).fetchSelectedRow());`
125	`}`	122	`}`
126	`}, false);`	123	`}, false);`
127	`clone.setPredicate(IListeEvent.getSingleSelectionPredicate());`	124	`clone.setPredicate(IListeEvent.getSingleSelectionPredicate());`
128	`getRowActions().add(clone);`	125	`getRowActions().add(clone);`
129		126
130	`PredicateRowAction an = new PredicateRowAction(new AbstractAction("Gérer l'analytique") {`	127	`PredicateRowAction an = new PredicateRowAction(new AbstractAction("Gérer l'analytique") {`
131	`public void actionPerformed(ActionEvent event) {`	128	`public void actionPerformed(ActionEvent event) {`
132	`PanelFrame frameAssoc = new PanelFrame(new AssociationAnalytiquePanel(IListe.get(event).getSelectedRow().asRow()), "Association analytique");`	129	`PanelFrame frameAssoc = new PanelFrame(new AssociationAnalytiquePanel(IListe.get(event).getSelectedRow().asRow()), "Association analytique");`
133	`frameAssoc.setVisible(true);`	130	`frameAssoc.setVisible(true);`
134	`}`	131	`}`
135	`}, false);`	132	`}, false);`
136	`an.setPredicate(IListeEvent.getSingleSelectionPredicate());`	133	`an.setPredicate(IListeEvent.getSingleSelectionPredicate());`
137	`getRowActions().add(an);`	134	`getRowActions().add(an);`
138		135
139	`PredicateRowAction show = new PredicateRowAction(new AbstractAction("Voir la source") {`	136	`PredicateRowAction show = new PredicateRowAction(new AbstractAction("Voir la source") {`
140	`public void actionPerformed(ActionEvent event) {`	137	`public void actionPerformed(ActionEvent event) {`
141		138
142	`SQLRow row = IListe.get(event).fetchSelectedRow();`	139	`SQLRow row = IListe.get(event).fetchSelectedRow();`
143		140
144	`MouvementSQLElement.showSource(row.getInt("ID_MOUVEMENT"));`	141	`MouvementSQLElement.showSource(row.getInt("ID_MOUVEMENT"));`
145	`}`	142	`}`
146	`}, false);`	143	`}, false);`
147	`show.setPredicate(IListeEvent.getSingleSelectionPredicate());`	144	`show.setPredicate(IListeEvent.getSingleSelectionPredicate());`
148	`getRowActions().add(show);`	145	`getRowActions().add(show);`
149	`}`	146	`}`
150		147
151	`@Override`	148	`@Override`
152	`protected String getParentFFName() {`	149	`protected String getParentFFName() {`
153	`return "ID_MOUVEMENT";`	150	`return "ID_MOUVEMENT";`
154	`}`	151	`}`
155		152
-		153	`@Override`
-		154	`public boolean isPrivate() {`
-		155	`return false;`
-		156	`}`
-		157
156	`// Impossible de modifier si validée`	158	`// Impossible de modifier si validée`
157	`// FIXME impossible de saisir une écriture avant la date de debut d'exercice --> de saisir de`	159	`// FIXME impossible de saisir une écriture avant la date de debut d'exercice --> de saisir de`
158	`// document de gest comm`	160	`// document de gest comm`
159		161
160	`public List<String> getListFields() {`	162	`public List<String> getListFields() {`
161	`final List<String> l = new ArrayList<String>();`	163	`final List<String> l = new ArrayList<String>();`
162	`l.add("VALIDE");`	164	`l.add("VALIDE");`
163	`l.add("ID_MOUVEMENT");`	165	`l.add("ID_MOUVEMENT");`
164	`if (getTable().contains("NOM_PIECE")) {`	166	`if (getTable().contains("NOM_PIECE")) {`
165	`l.add("NOM_PIECE");`	167	`l.add("NOM_PIECE");`
166	`}`	168	`}`
167	`// l.add("ID_COMPTE_PCE");`	169	`// l.add("ID_COMPTE_PCE");`
168	`l.add("COMPTE_NUMERO");`	170	`l.add("COMPTE_NUMERO");`
169	`l.add("COMPTE_NOM");`	171	`l.add("COMPTE_NOM");`
170	`// l.add("ID_JOURNAL");`	172	`// l.add("ID_JOURNAL");`
171	`l.add("JOURNAL_NOM");`	173	`l.add("JOURNAL_NOM");`
172	`l.add("NOM");`	174	`l.add("NOM");`
173	`l.add("DATE");`	175	`l.add("DATE");`
174		176
175	`l.add("DEBIT");`	177	`l.add("DEBIT");`
176	`l.add("CREDIT");`	178	`l.add("CREDIT");`
177		179
178	`return l;`	180	`return l;`
179	`}`	181	`}`
180		182
181	`protected List<String> getComboFields() {`	183	`protected List<String> getComboFields() {`
182	`final List<String> l = new ArrayList<String>();`	184	`final List<String> l = new ArrayList<String>();`
183	`l.add("NOM");`	185	`l.add("NOM");`
184	`l.add("DATE");`	186	`l.add("DATE");`
185	`l.add("DEBIT");`	187	`l.add("DEBIT");`
186	`l.add("CREDIT");`	188	`l.add("CREDIT");`
187	`l.add("ID_JOURNAL");`	189	`l.add("ID_JOURNAL");`
188	`l.add("ID_MOUVEMENT");`	190	`l.add("ID_MOUVEMENT");`
189	`return l;`	191	`return l;`
190	`}`	192	`}`
191		193
192	`@Override`	194	`@Override`
193	`protected void _initListRequest(ListSQLRequest req) {`	195	`protected void _initListRequest(ListSQLRequest req) {`
194	`super._initListRequest(req);`	196	`super._initListRequest(req);`
195	`req.addToGraphToFetch("VALIDE");`	197	`req.addToGraphToFetch("VALIDE");`
196	`}`	198	`}`
197		199
198	`public void consultationCompte(SQLRowAccessor rowCpt) {`	200	`public void consultationCompte(SQLRowAccessor rowCpt) {`
199	`final ConsultationCompteFrame f = new ConsultationCompteFrame(new ListeDesEcrituresPanel(), "Consultation compte n°" + rowCpt.getString("NUMERO") + " " + rowCpt.getString("NOM"));`	-
200		-
201	`f.getPanel().getListe().getJTable().addMouseListener(new MouseAdapter() {`	-
202		-
203	`public void mousePressed(final MouseEvent mE) {`	-
204		-
205	`if (mE.getButton() == MouseEvent.BUTTON3) {`	-
206	`JPopupMenu menuDroit = new JPopupMenu();`	-
207		-
208	`menuDroit.add(new AbstractAction("Voir les ecritures du journal") {`	201	`final ListeDesEcrituresPanel panel = new ListeDesEcrituresPanel();`
209		-
210	`public void actionPerformed(ActionEvent e) {`	-
211	`int id = f.getPanel().getListe().idFromIndex(f.getPanel().getListe().getJTable().rowAtPoint(mE.getPoint()));`	-
212	`// int id = f.getPanel().getListe().getSelectedId();`	-
213		-
214	`SQLTable ecrTable = getTable().getTable("ECRITURE");`	-
215		-
216	`System.err.println("Ecritures ID ::: " + id);`	-
217	`SQLRow rowEcr = ecrTable.getRow(id);`	-
218		-
219	`System.err.println("Ecritures ID ::: " + id + " --> ID_JOURNAL = " + rowEcr.getInt("ID_JOURNAL"));`	-
220		-
221	`ConsultationCompteFrame f2 = new ConsultationCompteFrame(new ListeDesEcrituresPanel(),`	202	`final ConsultationCompteFrame f = new ConsultationCompteFrame(panel, rowCpt);`
222	`"Consultation du journal " + getTable().getTable("JOURNAL").getRow(rowEcr.getInt("ID_JOURNAL")).getString("NOM"));`	-
223		-
224	`Where w = new Where(ecrTable.getField("ID_JOURNAL"), "=", rowEcr.getInt("ID_JOURNAL"));`	-
225		-
226	`f2.getPanel().getListe().getRequest().setWhere(w);`	-
227	`f2.getPanel().getListe().setModificationAllowed(false);`	-
228	`f2.pack();`	-
229	`f2.setVisible(true);`	-
230	`}`	-
231	`});`	-
232		-
233	`menuDroit.add(new AbstractAction("Voir la source") {`	-
234		-
235	`public void actionPerformed(ActionEvent e) {`	-
236		-
237	`// int id = f.getPanel().getListe().getSelectedId();`	-
238	`int id = f.getPanel().getListe().idFromIndex(f.getPanel().getListe().getJTable().rowAtPoint(mE.getPoint()));`	-
239	`System.err.println("ID COMPTE SELECTED " + id);`	-
240	`SQLRow rowEcr = getTable().getTable("ECRITURE").getRow(id);`	-
241		-
242	`System.out.println("MOUVEMENT VALIDE ------------->>>>>>>>>>>>>> " + MouvementSQLElement.isEditable(rowEcr.getInt("ID_MOUVEMENT")));`	-
243		-
244	`MouvementSQLElement.showSource(rowEcr.getInt("ID_MOUVEMENT"));`	-
245		-
246	`System.out.println("Mouvement Numero : " + rowEcr.getInt("ID_MOUVEMENT"));`	-
247	`}`	-
248	`});`	-
249		-
250	`menuDroit.show(mE.getComponent(), mE.getX(), mE.getY());`	-
251	`}`	-
252	`}`	-
253	`});`	-
254		-
255	`SQLTable ecrTable = getTable().getTable("ECRITURE");`	-
256		-
257	`Where w = new Where(ecrTable.getField("ID_COMPTE_PCE"), "=", rowCpt.getID());`	-
258	`f.getPanel().getListe().getRequest().setWhere(w);`	-
259		203
260	`f.getPanel().getListe().setModificationAllowed(false);`	204	`f.getPanel().getListe().setModificationAllowed(false);`
261	`f.pack();`	205	`f.pack();`
262	`f.setVisible(true);`	206	`f.setVisible(true);`
263	`}`	207	`}`
264		208
265	`@Override`	209	`@Override`
266	`protected void _initTableSource(SQLTableModelSource res) {`	210	`protected void _initTableSource(SQLTableModelSource res) {`
267	`super._initTableSource(res);`	211	`super._initTableSource(res);`
268	`BaseSQLTableModelColumn analytique = new BaseSQLTableModelColumn("Poste analytique", String.class) {`	212	`BaseSQLTableModelColumn analytique = new BaseSQLTableModelColumn("Poste analytique", String.class) {`
269		213
270	`@Override`	214	`@Override`
271	`protected Object show_(SQLRowAccessor r) {`	215	`protected Object show_(SQLRowAccessor r) {`
272	`Collection<? extends SQLRowAccessor> assocs = r.getReferentRows(getTable().getTable("ASSOCIATION_ANALYTIQUE"));`	216	`Collection<? extends SQLRowAccessor> assocs = r.getReferentRows(getTable().getTable("ASSOCIATION_ANALYTIQUE"));`
273	`StringBuffer res = new StringBuffer();`	217	`StringBuffer res = new StringBuffer();`
274		218
275	`for (SQLRowAccessor sqlRowAccessor : assocs) {`	219	`for (SQLRowAccessor sqlRowAccessor : assocs) {`
276	`res.append(sqlRowAccessor.getForeign("ID_POSTE_ANALYTIQUE").getString("NOM"));`	220	`res.append(sqlRowAccessor.getForeign("ID_POSTE_ANALYTIQUE").getString("NOM"));`
277	`res.append(", ");`	221	`res.append(", ");`
278	`}`	222	`}`
279		223
280	`return res.toString();`	224	`return res.toString();`
281	`}`	225	`}`
282		226
283	`@Override`	227	`@Override`
284	`public Set<FieldPath> getPaths() {`	228	`public Set<FieldPath> getPaths() {`
285	`Path p = new Path(getTable());`	229	`Path p = new Path(getTable());`
286	`p = p.add(getTable().getTable("ASSOCIATION_ANALYTIQUE"));`	230	`p = p.add(getTable().getTable("ASSOCIATION_ANALYTIQUE"));`
287	`p = p.add(p.getLast().getForeignTable("ID_POSTE_ANALYTIQUE"));`	231	`p = p.add(p.getLast().getForeignTable("ID_POSTE_ANALYTIQUE"));`
288	`return CollectionUtils.createSet(new FieldPath(p, "NOM"));`	232	`return CollectionUtils.createSet(new FieldPath(p, "NOM"));`
289	`}`	233	`}`
290	`};`	234	`};`
291	`res.getColumns().add(analytique);`	235	`res.getColumns().add(analytique);`
292	`for (SQLTableModelColumn col : res.getColumns()) {`	236	`for (SQLTableModelColumn col : res.getColumns()) {`
293	`col.setRenderer(ListEcritureRenderer.UTILS.getRenderer(col.getRenderer()));`	237	`col.setRenderer(ListEcritureRenderer.UTILS.getRenderer(col.getRenderer()));`
294	`}`	238	`}`
295	`}`	239	`}`
296		240
297	`public final SQLTableModelSourceOnline createPointageTableSource() {`	241	`public final SQLTableModelSourceOnline createPointageTableSource() {`
298	`final List<String> listEcriture = new ArrayList<String>();`	242	`final List<String> listEcriture = new ArrayList<String>();`
299	`listEcriture.add("POINTEE");`	243	`listEcriture.add("POINTEE");`
300	`listEcriture.add("DATE_POINTEE");`	244	`listEcriture.add("DATE_POINTEE");`
301	`listEcriture.add("ID_MOUVEMENT");`	245	`listEcriture.add("ID_MOUVEMENT");`
302	`listEcriture.add("NOM");`	246	`listEcriture.add("NOM");`
303	`listEcriture.add("DATE");`	247	`listEcriture.add("DATE");`
304	`listEcriture.add("DEBIT");`	248	`listEcriture.add("DEBIT");`
305	`listEcriture.add("CREDIT");`	249	`listEcriture.add("CREDIT");`
306	`final SQLTableModelSourceOnline res = this.instantiateTableSourceOnline(this.createListRequest(listEcriture));`	250	`final SQLTableModelSourceOnline res = this.instantiateTableSourceOnline(this.createListRequest(listEcriture));`
307	`for (SQLTableModelColumn col : res.getColumns()) {`	251	`for (SQLTableModelColumn col : res.getColumns()) {`
308	`if (col.getValueClass() == Long.class \|\| col.getValueClass() == BigInteger.class) {`	252	`if (col.getValueClass() == Long.class \|\| col.getValueClass() == BigInteger.class) {`
309	`col.setConverter(new ValueConvertor<Number, BigDecimal>() {`	253	`col.setConverter(new ValueConvertor<Number, BigDecimal>() {`
310	`@Override`	254	`@Override`
311	`public BigDecimal convert(Number o) {`	255	`public BigDecimal convert(Number o) {`
312	`if (o == null) {`	256	`if (o == null) {`
313	`return BigDecimal.ZERO;`	257	`return BigDecimal.ZERO;`
314	`}`	258	`}`
315	`return new BigDecimal(o.longValue()).movePointLeft(2);`	259	`return new BigDecimal(o.longValue()).movePointLeft(2);`
316	`}`	260	`}`
317		261
318	`@Override`	262	`@Override`
319	`public Number unconvert(BigDecimal o) {`	263	`public Number unconvert(BigDecimal o) {`
320		264
321	`if (o == null) {`	265	`if (o == null) {`
322	`return 0;`	266	`return 0;`
323	`}`	267	`}`
324	`return o.movePointRight(2);`	268	`return o.movePointRight(2);`
325	`}`	269	`}`
326	`}, BigDecimal.class);`	270	`}, BigDecimal.class);`
327	`col.setRenderer(CURRENCY_RENDERER);`	271	`col.setRenderer(CURRENCY_RENDERER);`
328	`}`	272	`}`
329		273
330	`col.setRenderer(PointageRenderer.UTILS.getRenderer(col.getRenderer()));`	274	`col.setRenderer(PointageRenderer.UTILS.getRenderer(col.getRenderer()));`
331	`}`	275	`}`
332	`return this.initTableSource(res, true);`	276	`return this.initTableSource(res, true);`
333	`}`	277	`}`
334		278
335	`public final SQLTableModelSourceOnline createLettrageTableSource() {`	279	`public final SQLTableModelSourceOnline createLettrageTableSource() {`
336	`final List<String> listEcriture = new ArrayList<String>();`	280	`final List<String> listEcriture = new ArrayList<String>();`
337	`listEcriture.add("LETTRAGE");`	281	`listEcriture.add("LETTRAGE");`
338	`listEcriture.add("ID_COMPTE_PCE");`	282	`listEcriture.add("ID_COMPTE_PCE");`
339	`listEcriture.add("ID_MOUVEMENT");`	283	`listEcriture.add("ID_MOUVEMENT");`
340	`if (getTable().contains("NOM_PIECE")) {`	284	`if (getTable().contains("NOM_PIECE")) {`
341	`listEcriture.add("NOM_PIECE");`	285	`listEcriture.add("NOM_PIECE");`
342	`}`	286	`}`
343	`listEcriture.add("NOM");`	287	`listEcriture.add("NOM");`
344	`listEcriture.add("DATE_LETTRAGE");`	288	`listEcriture.add("DATE_LETTRAGE");`
345	`listEcriture.add("DATE");`	289	`listEcriture.add("DATE");`
346	`listEcriture.add("DEBIT");`	290	`listEcriture.add("DEBIT");`
347	`listEcriture.add("CREDIT");`	291	`listEcriture.add("CREDIT");`
348	`final SQLTableModelSourceOnline res = this.instantiateTableSourceOnline(this.createListRequest(listEcriture));`	292	`final SQLTableModelSourceOnline res = this.instantiateTableSourceOnline(this.createListRequest(listEcriture));`
349	`for (SQLTableModelColumn col : res.getColumns()) {`	293	`for (SQLTableModelColumn col : res.getColumns()) {`
350	`if (col.getValueClass() == Long.class \|\| col.getValueClass() == BigInteger.class) {`	294	`if (col.getValueClass() == Long.class \|\| col.getValueClass() == BigInteger.class) {`
351	`col.setConverter(new ValueConvertor<Number, BigDecimal>() {`	295	`col.setConverter(new ValueConvertor<Number, BigDecimal>() {`
352	`@Override`	296	`@Override`
353	`public BigDecimal convert(Number o) {`	297	`public BigDecimal convert(Number o) {`
354	`if (o == null) {`	298	`if (o == null) {`
355	`return BigDecimal.ZERO;`	299	`return BigDecimal.ZERO;`
356	`}`	300	`}`
357	`return new BigDecimal(o.longValue()).movePointLeft(2);`	301	`return new BigDecimal(o.longValue()).movePointLeft(2);`
358	`}`	302	`}`
359		303
360	`@Override`	304	`@Override`
361	`public Number unconvert(BigDecimal o) {`	305	`public Number unconvert(BigDecimal o) {`
362		306
363	`if (o == null) {`	307	`if (o == null) {`
364	`return 0;`	308	`return 0;`
365	`}`	309	`}`
366	`return o.movePointRight(2);`	310	`return o.movePointRight(2);`
367	`}`	311	`}`
368	`}, BigDecimal.class);`	312	`}, BigDecimal.class);`
369	`col.setRenderer(CURRENCY_RENDERER);`	313	`col.setRenderer(CURRENCY_RENDERER);`
370	`}`	314	`}`
371	`col.setRenderer(LettrageRenderer.UTILS.getRenderer(col.getRenderer()));`	315	`col.setRenderer(LettrageRenderer.UTILS.getRenderer(col.getRenderer()));`
372	`}`	316	`}`
373	`return this.initTableSource(res, true);`	317	`return this.initTableSource(res, true);`
374	`}`	318	`}`
375		319
376	`/*`	320	`/*`
377	`* (non-Javadoc)`	321	`* (non-Javadoc)`
378	`*`	322	`*`
379	`* @see org.openconcerto.devis.SQLElement#getComponent()`	323	`* @see org.openconcerto.devis.SQLElement#getComponent()`
380	`*/`	324	`*/`
381	`public SQLComponent createComponent() {`	325	`public SQLComponent createComponent() {`
382	`return new BaseSQLComponent(this) {`	326	`return new BaseSQLComponent(this) {`
383		327
384	`private JTextField nom;`	328	`private JTextField nom;`
385	`private DeviseField debit;`	329	`private DeviseField debit;`
386	`private DeviseField credit;`	330	`private DeviseField credit;`
387	`private JDate date;`	331	`private JDate date;`
388	`private ElementComboBox journal;`	332	`private ElementComboBox journal;`
389		333
390	`public void addViews() {`	334	`public void addViews() {`
391	`this.setLayout(new GridBagLayout());`	335	`this.setLayout(new GridBagLayout());`
392	`final GridBagConstraints c = new DefaultGridBagConstraints();`	336	`final GridBagConstraints c = new DefaultGridBagConstraints();`
393		337
394	`this.nom = new JTextField();`	338	`this.nom = new JTextField();`
395	`this.debit = new DeviseField();`	339	`this.debit = new DeviseField();`
396	`this.credit = new DeviseField();`	340	`this.credit = new DeviseField();`
397	`this.date = new JDate();`	341	`this.date = new JDate();`
398	`this.journal = new ElementComboBox();`	342	`this.journal = new ElementComboBox();`
399	`// Mouvement`	343	`// Mouvement`
400	`/*`	344	`/*`
401	`* JLabel labelMouvement = new JLabel("Mouvement"); this.add(labelMouvement, c);`	345	`* JLabel labelMouvement = new JLabel("Mouvement"); this.add(labelMouvement, c);`
402	`*`	346	`*`
403	`* c.gridx ++; c.weightx = 1; this.add(idMouvement, c);`	347	`* c.gridx ++; c.weightx = 1; this.add(idMouvement, c);`
404	`*/`	348	`*/`
405		349
406	`// Journal`	350	`// Journal`
407	`JLabel labelJournal = new JLabel("Journal");`	351	`JLabel labelJournal = new JLabel("Journal");`
408	`c.gridx = 0;`	352	`c.gridx = 0;`
409	`this.add(labelJournal, c);`	353	`this.add(labelJournal, c);`
410		354
411	`c.gridx++;`	355	`c.gridx++;`
412	`c.weightx = 1;`	356	`c.weightx = 1;`
413	`this.add(this.journal, c);`	357	`this.add(this.journal, c);`
414		358
415	`// Date`	359	`// Date`
416	`JLabel labelDate = new JLabel("Date");`	360	`JLabel labelDate = new JLabel("Date");`
417	`c.gridx++;`	361	`c.gridx++;`
418	`this.add(labelDate, c);`	362	`this.add(labelDate, c);`
419		363
420	`c.gridx++;`	364	`c.gridx++;`
421	`c.weightx = 1;`	365	`c.weightx = 1;`
422	`this.add(this.date, c);`	366	`this.add(this.date, c);`
423		367
424	`// libellé`	368	`// libellé`
425	`JLabel labelNom = new JLabel("Libellé");`	369	`JLabel labelNom = new JLabel("Libellé");`
426	`c.gridy++;`	370	`c.gridy++;`
427	`c.gridx = 0;`	371	`c.gridx = 0;`
428	`this.add(labelNom, c);`	372	`this.add(labelNom, c);`
429		373
430	`c.gridx++;`	374	`c.gridx++;`
431	`c.weightx = 1;`	375	`c.weightx = 1;`
432	`c.gridwidth = GridBagConstraints.REMAINDER;`	376	`c.gridwidth = GridBagConstraints.REMAINDER;`
433	`this.add(this.nom, c);`	377	`this.add(this.nom, c);`
434		378
435	`// debit`	379	`// debit`
436	`c.gridwidth = 1;`	380	`c.gridwidth = 1;`
437	`JLabel labelDebit = new JLabel("Debit");`	381	`JLabel labelDebit = new JLabel("Debit");`
438	`c.gridy++;`	382	`c.gridy++;`
439	`c.gridx = 0;`	383	`c.gridx = 0;`
440	`this.add(labelDebit, c);`	384	`this.add(labelDebit, c);`
441		385
442	`c.gridx++;`	386	`c.gridx++;`
443	`c.weightx = 1;`	387	`c.weightx = 1;`
444	`this.add(this.debit, c);`	388	`this.add(this.debit, c);`
445	`this.debit.addKeyListener(new KeyAdapter() {`	389	`this.debit.addKeyListener(new KeyAdapter() {`
446	`public void keyReleased(KeyEvent e) {`	390	`public void keyReleased(KeyEvent e) {`
447	`if ((credit.getText().trim().length() != 0) && (debit.getText().trim().length() != 0)) {`	391	`if ((credit.getText().trim().length() != 0) && (debit.getText().trim().length() != 0)) {`
448	`credit.setText("");`	392	`credit.setText("");`
449	`}`	393	`}`
450	`}`	394	`}`
451	`});`	395	`});`
452		396
453	`// Credit`	397	`// Credit`
454	`JLabel labelCredit = new JLabel("Credit");`	398	`JLabel labelCredit = new JLabel("Credit");`
455	`c.gridx++;`	399	`c.gridx++;`
456	`this.add(labelCredit, c);`	400	`this.add(labelCredit, c);`
457		401
458	`c.gridx++;`	402	`c.gridx++;`
459	`c.weightx = 1;`	403	`c.weightx = 1;`
460	`this.add(this.credit, c);`	404	`this.add(this.credit, c);`
461		405
462	`this.credit.addKeyListener(new KeyAdapter() {`	406	`this.credit.addKeyListener(new KeyAdapter() {`
463	`public void keyReleased(KeyEvent e) {`	407	`public void keyReleased(KeyEvent e) {`
464	`if ((debit.getText().trim().length() != 0) && (credit.getText().trim().length() != 0)) {`	408	`if ((debit.getText().trim().length() != 0) && (credit.getText().trim().length() != 0)) {`
465	`debit.setText("");`	409	`debit.setText("");`
466	`}`	410	`}`
467	`}`	411	`}`
468	`});`	412	`});`
469		413
470	`this.addSQLObject(this.nom, "NOM");`	414	`this.addSQLObject(this.nom, "NOM");`
471	`this.addSQLObject(this.debit, "DEBIT");`	415	`this.addSQLObject(this.debit, "DEBIT");`
472	`this.addSQLObject(this.credit, "CREDIT");`	416	`this.addSQLObject(this.credit, "CREDIT");`
473	`this.addRequiredSQLObject(this.date, "DATE");`	417	`this.addRequiredSQLObject(this.date, "DATE");`
474	`this.addRequiredSQLObject(this.journal, "ID_JOURNAL");`	418	`this.addRequiredSQLObject(this.journal, "ID_JOURNAL");`
475	`}`	419	`}`
476		420
477	`@Override`	421	`@Override`
478	`public void select(SQLRowAccessor r) {`	422	`public void select(SQLRowAccessor r) {`
479	`super.select(r);`	423	`super.select(r);`
480		424
481	`if (r != null && r.getBoolean("VALIDE")) {`	425	`if (r != null && r.getBoolean("VALIDE")) {`
482	`this.nom.setEnabled(false);`	426	`this.nom.setEnabled(false);`
483	`this.debit.setEnabled(false);`	427	`this.debit.setEnabled(false);`
484	`this.credit.setEnabled(false);`	428	`this.credit.setEnabled(false);`
485	`this.date.setInteractionMode(InteractionMode.DISABLED);`	429	`this.date.setInteractionMode(InteractionMode.DISABLED);`
486	`this.journal.setEnabled(false);`	430	`this.journal.setEnabled(false);`
487	`}`	431	`}`
488		432
489	`}`	433	`}`
490		434
491	`public void update() {`	435	`public void update() {`
492	`SQLRow row = EcritureSQLElement.this.getTable().getRow(getSelectedID());`	436	`SQLRow row = EcritureSQLElement.this.getTable().getRow(getSelectedID());`
493	`if (row.getBoolean("VALIDE")) {`	437	`if (row.getBoolean("VALIDE")) {`
494	`System.out.println("Impossible de modifier une ecriture validée");`	438	`System.out.println("Impossible de modifier une ecriture validée");`
495	`} else {`	439	`} else {`

Dépôt officiel du code source de l'ERP OpenConcerto

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/erp/core/finance/accounting/element/EcritureSQLElement.java - Rev 156 → 174