OpenConcerto

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

svn://code.openconcerto.org/openconcerto

Rev

Rev 156 | Rev 177 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
18 ilm 1 
/*
2 
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3 
 *
4 
 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.
5 
 *
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
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.
10 
 *
11 
 * When distributing the software, include this License Header Notice in each file.
12 
 */
13 
 
14 
 package org.openconcerto.erp.config;
15 
 
142 ilm 16 
import org.openconcerto.erp.config.update.Updater_1_5;
144 ilm 17 
import org.openconcerto.erp.core.humanresources.payroll.report.LignePayeSimplifiee;
93 ilm 18 
import org.openconcerto.erp.core.sales.order.ui.EtatCommandeClient;
67 ilm 19 
import org.openconcerto.erp.core.sales.quote.element.EtatDevisSQLElement;
61 ilm 20 
import org.openconcerto.erp.modules.ModuleManager;
67 ilm 21 
import org.openconcerto.erp.modules.ModuleReference;
156 ilm 22 
import org.openconcerto.sql.Configuration;
19 ilm 23 
import org.openconcerto.sql.changer.convert.AddFK;
83 ilm 24 
import org.openconcerto.sql.changer.convert.ChangeIDToInt;
19 ilm 25 
import org.openconcerto.sql.changer.correct.CorrectOrder;
18 ilm 26 
import org.openconcerto.sql.changer.correct.FixSerial;
142 ilm 27 
import org.openconcerto.sql.element.GroupSQLComponent;
73 ilm 28 
import org.openconcerto.sql.model.AliasedTable;
19 ilm 29 
import org.openconcerto.sql.model.DBRoot;
30 
import org.openconcerto.sql.model.DBSystemRoot;
31 
import org.openconcerto.sql.model.SQLBase;
32 
import org.openconcerto.sql.model.SQLDataSource;
20 ilm 33 
import org.openconcerto.sql.model.SQLField;
83 ilm 34 
import org.openconcerto.sql.model.SQLField.Properties;
73 ilm 35 
import org.openconcerto.sql.model.SQLInjector;
19 ilm 36 
import org.openconcerto.sql.model.SQLName;
18 ilm 37 
import org.openconcerto.sql.model.SQLRow;
38 
import org.openconcerto.sql.model.SQLRowListRSH;
39 
import org.openconcerto.sql.model.SQLRowValues;
73 ilm 40 
import org.openconcerto.sql.model.SQLRowValuesListFetcher;
80 ilm 41 
import org.openconcerto.sql.model.SQLSchema;
18 ilm 42 
import org.openconcerto.sql.model.SQLSelect;
19 ilm 43 
import org.openconcerto.sql.model.SQLSyntax;
44 
import org.openconcerto.sql.model.SQLSystem;
18 ilm 45 
import org.openconcerto.sql.model.SQLTable;
46 
import org.openconcerto.sql.model.Where;
57 ilm 47 
import org.openconcerto.sql.model.graph.SQLKey;
80 ilm 48 
import org.openconcerto.sql.request.Inserter;
83 ilm 49 
import org.openconcerto.sql.request.Inserter.Insertion;
81 ilm 50 
import org.openconcerto.sql.request.UpdateBuilder;
80 ilm 51 
import org.openconcerto.sql.sqlobject.SQLTextCombo;
174 ilm 52 
import org.openconcerto.sql.users.rights.TableAllRights;
18 ilm 53 
import org.openconcerto.sql.utils.AlterTable;
19 ilm 54 
import org.openconcerto.sql.utils.ChangeTable;
142 ilm 55 
import org.openconcerto.sql.utils.ChangeTable.ClauseType;
56 
import org.openconcerto.sql.utils.ChangeTable.DeferredClause;
19 ilm 57 
import org.openconcerto.sql.utils.ReOrder;
80 ilm 58 
import org.openconcerto.sql.utils.SQLCreateMoveableTable;
19 ilm 59 
import org.openconcerto.sql.utils.SQLCreateTable;
60 
import org.openconcerto.sql.utils.SQLUtils;
80 ilm 61 
import org.openconcerto.sql.utils.SQLUtils.SQLFactory;
18 ilm 62 
import org.openconcerto.ui.DefaultGridBagConstraints;
63 
import org.openconcerto.ui.JLabelBold;
19 ilm 64 
import org.openconcerto.utils.CollectionUtils;
18 ilm 65 
import org.openconcerto.utils.ExceptionHandler;
73 ilm 66 
import org.openconcerto.utils.ProductInfo;
174 ilm 67 
import org.openconcerto.utils.StringUtils;
73 ilm 68 
import org.openconcerto.utils.cc.ITransformer;
18 ilm 69 
 
70 
import java.awt.GridBagConstraints;
71 
import java.awt.GridBagLayout;
72 
import java.awt.Insets;
73 
import java.awt.event.ActionEvent;
74 
import java.awt.event.ActionListener;
61 ilm 75 
import java.io.IOException;
67 ilm 76 
import java.math.BigDecimal;
18 ilm 77 
import java.sql.SQLException;
20 ilm 78 
import java.sql.Types;
19 ilm 79 
import java.util.ArrayList;
57 ilm 80 
import java.util.Arrays;
80 ilm 81 
import java.util.Collection;
82 
import java.util.Collections;
19 ilm 83 
import java.util.EnumSet;
57 ilm 84 
import java.util.HashMap;
85 
import java.util.HashSet;
18 ilm 86 
import java.util.List;
57 ilm 87 
import java.util.Map;
18 ilm 88 
import java.util.Set;
89 
 
90 
import javax.swing.JButton;
91 
import javax.swing.JLabel;
92 
import javax.swing.JOptionPane;
93 
import javax.swing.JPanel;
94 
import javax.swing.JProgressBar;
95 
import javax.swing.JTextField;
96 
import javax.swing.SwingUtilities;
97 
 
98 
public class InstallationPanel extends JPanel {
57 ilm 99 
    private static final boolean DEBUG_FK = false;
18 ilm 100 
 
149 ilm 101 
    public static void insertUndef(final SQLCreateTable ct) throws SQLException {
80 ilm 102 
        // check that we can use insertReturnFirstField()
103 
        if (ct.getPrimaryKey().size() != 1)
104 
            throw new IllegalStateException("Not one and only one field in the PK : " + ct.getPrimaryKey());
105 
        final Insertion<?> insertion = new Inserter(ct).insertReturnFirstField("(" + SQLBase.quoteIdentifier(SQLSyntax.ORDER_NAME) + ") VALUES(" + ReOrder.MIN_ORDER + ")", false);
106 
        assert insertion.getCount() == 1;
107 
        if (insertion.getRows().size() != 1)
108 
            throw new IllegalStateException("Missing ID " + insertion.getRows());
109 
        SQLTable.setUndefID(ct.getRoot().getSchema(), ct.getName(), ((Number) insertion.getRows().get(0)).intValue());
19 ilm 110 
    }
111 
 
149 ilm 112 
    private static SQLName getTableName(final SQLCreateTable ct) {
19 ilm 113 
        return new SQLName(ct.getRoot().getName(), ct.getName());
114 
    }
115 
 
18 ilm 116 
    JProgressBar bar = new JProgressBar();
19 ilm 117 
    boolean error;
18 ilm 118 
 
119 
    public InstallationPanel(final ServerFinderPanel finderPanel) {
120 
        super(new GridBagLayout());
121 
        setOpaque(false);
122 
        GridBagConstraints c = new DefaultGridBagConstraints();
123 
        JButton user = new JButton("Créer l'utilisateur");
57 ilm 124 
        user.setOpaque(false);
18 ilm 125 
        // JButton bd = new JButton("Créer la base de données");
126 
        final JButton up = new JButton("Mise à niveau de la base");
57 ilm 127 
        up.setOpaque(false);
18 ilm 128 
        up.addActionListener(new ActionListener() {
129 
 
130 
            @Override
131 
            public void actionPerformed(ActionEvent e) {
149 ilm 132 
                if (finderPanel != null) {
133 
                    finderPanel.saveConfigFile();
134 
                }
18 ilm 135 
                bar.setIndeterminate(true);
136 
                up.setEnabled(false);
137 
                new Thread(new Runnable() {
138 
 
139 
                    @Override
140 
                    public void run() {
80 ilm 141 
                        System.setProperty(SQLSchema.NOAUTO_CREATE_METADATA, "false");
19 ilm 142 
                        final ComptaPropsConfiguration conf = ComptaPropsConfiguration.create(true);
18 ilm 143 
 
156 ilm 144 
                        final DBSystemRoot systemRoot = conf.getSystemRoot();
145 
                        if (systemRoot.getChild(conf.getRootNameValue().getValue()) == null) {
146 
                            conf.destroy();
147 
                            SwingUtilities.invokeLater(new Runnable() {
148 
                                @Override
149 
                                public void run() {
150 
                                    up.setEnabled(true);
151 
                                    bar.setValue(bar.getMaximum());
152 
                                    JOptionPane.showMessageDialog(InstallationPanel.this, "Votre base de données n'est pas initialisée");
153 
                                }
154 
                            });
155 
                            return;
156 
                        }
157 
 
149 ilm 158 
                        updateDatabase(conf);
19 ilm 159 
 
18 ilm 160 
                        conf.destroy();
161 
                        SwingUtilities.invokeLater(new Runnable() {
162 
 
163 
                            @Override
164 
                            public void run() {
165 
                                up.setEnabled(true);
41 ilm 166 
                                bar.setValue(bar.getMaximum());
19 ilm 167 
                                if (!error) {
168 
                                    JOptionPane.showMessageDialog(InstallationPanel.this, "Mise à niveau réussie");
169 
                                }
18 ilm 170 
                            }
171 
                        });
80 ilm 172 
                        System.setProperty(SQLSchema.NOAUTO_CREATE_METADATA, "true");
18 ilm 173 
                    }
174 
                }, "Database structure updater").start();
175 
 
176 
            }
177 
 
178 
        });
149 ilm 179 
        if (finderPanel != null && finderPanel.getToken() == null) {
61 ilm 180 
            c.weightx = 1;
181 
            c.gridwidth = GridBagConstraints.REMAINDER;
182 
            this.add(new JLabelBold("Création de l'utilisateur openconcerto dans la base"), c);
183 
            c.gridy++;
184 
            c.weightx = 1;
185 
            this.add(new JLabel("Identifiant de connexion de votre base "), c);
186 
            c.gridy++;
187 
            c.gridwidth = 1;
188 
            c.weightx = 0;
189 
            this.add(new JLabel("Login"), c);
190 
            c.gridx++;
18 ilm 191 
 
61 ilm 192 
            final JTextField login = new JTextField();
193 
            c.weightx = 1;
194 
            this.add(login, c);
18 ilm 195 
 
61 ilm 196 
            c.gridx++;
197 
            c.weightx = 0;
198 
            this.add(new JLabel("Mot de passe"), c);
199 
            c.gridx++;
200 
            final JTextField mdp = new JTextField();
201 
            c.weightx = 1;
202 
            this.add(mdp, c);
18 ilm 203 
 
61 ilm 204 
            c.gridx = 0;
205 
            c.gridy++;
206 
            c.weightx = 0;
207 
            c.anchor = GridBagConstraints.EAST;
208 
            c.gridwidth = GridBagConstraints.REMAINDER;
209 
            c.fill = GridBagConstraints.NONE;
210 
            this.add(user, c);
211 
            c.anchor = GridBagConstraints.WEST;
212 
            c.fill = GridBagConstraints.HORIZONTAL;
213 
            c.gridwidth = 1;
214 
            user.addActionListener(new ActionListener() {
18 ilm 215 
 
61 ilm 216 
                @Override
217 
                public void actionPerformed(ActionEvent e) {
218 
                    try {
219 
                        if (finderPanel.getServerConfig().createUserIfNeeded(login.getText(), mdp.getText())) {
220 
                            JOptionPane.showMessageDialog(InstallationPanel.this, "L'utilisateur openconcerto a été correctement ajouté.");
221 
                        } else {
222 
                            JOptionPane.showMessageDialog(InstallationPanel.this, "L'utilisateur openconcerto existe déjà dans la base.");
223 
                        }
224 
                    } catch (Exception e1) {
225 
                        e1.printStackTrace();
226 
                        JOptionPane.showMessageDialog(InstallationPanel.this, "Une erreur est survenue pendant la connexion au serveur, vérifiez vos paramètres de connexion.");
18 ilm 227 
                    }
228 
                }
61 ilm 229 
            });
18 ilm 230 
 
61 ilm 231 
            c.gridy++;
232 
            c.weightx = 1;
233 
            c.gridwidth = GridBagConstraints.REMAINDER;
234 
            c.insets = new Insets(10, 3, 2, 2);
235 
            this.add(new JLabelBold("Paramètrages de la base de données"), c);
236 
            c.gridy++;
237 
            c.insets = DefaultGridBagConstraints.getDefaultInsets();
238 
            this.add(new JLabel("Création des fonctions SQL nécessaires (plpgsql)."), c);
239 
            c.gridy++;
240 
            c.weightx = 0;
241 
            c.anchor = GridBagConstraints.EAST;
242 
            c.gridwidth = GridBagConstraints.REMAINDER;
243 
            c.fill = GridBagConstraints.NONE;
57 ilm 244 
 
61 ilm 245 
            JButton buttonPL = new JButton("Lancer");
246 
            buttonPL.setOpaque(false);
247 
            buttonPL.addActionListener(new ActionListener() {
25 ilm 248 
 
61 ilm 249 
                @Override
250 
                public void actionPerformed(ActionEvent e) {
251 
                    if (!finderPanel.getServerConfig().getType().equals(ServerFinderConfig.POSTGRESQL)) {
25 ilm 252 
 
61 ilm 253 
                    } else {
254 
                        final ComptaPropsConfiguration conf = ComptaPropsConfiguration.create(true);
255 
                        try {
256 
                            final SQLDataSource ds = conf.getSystemRoot().getDataSource();
132 ilm 257 
                            // ds.execute("CREATE FUNCTION plpgsql_call_handler() RETURNS
258 
                            // language_handler AS '$libdir/plpgsql' LANGUAGE C;"
61 ilm 259 
                            // + "\n"
260 
                            // +
132 ilm 261 
                            // "CREATE FUNCTION plpgsql_validator(oid) RETURNS void AS
262 
                            // '$libdir/plpgsql' LANGUAGE C;"
61 ilm 263 
                            // + "\n"
264 
                            // +
132 ilm 265 
                            // "CREATE TRUSTED PROCEDURAL LANGUAGE plpgsql HANDLER
266 
                            // plpgsql_call_handler VALIDATOR plpgsql_validator;");
61 ilm 267 
                            ds.execute("CREATE LANGUAGE plpgsql;");
268 
 
269 
                        } catch (Exception ex) {
270 
                            System.err.println("Impossible d'ajouter le langage PLPGSQL. Peut etre est il déjà installé.");
271 
                        }
25 ilm 272 
                    }
61 ilm 273 
                    JOptionPane.showMessageDialog(null, "Paramètrage terminé.");
25 ilm 274 
                }
61 ilm 275 
            });
276 
            this.add(buttonPL, c);
277 
        }
25 ilm 278 
        c.gridy++;
279 
        c.gridx = 0;
280 
        c.weightx = 1;
281 
        c.fill = GridBagConstraints.HORIZONTAL;
282 
        c.anchor = GridBagConstraints.WEST;
283 
        c.gridwidth = GridBagConstraints.REMAINDER;
284 
        c.insets = new Insets(10, 3, 2, 2);
18 ilm 285 
        this.add(new JLabelBold("Mise à niveau de la base OpenConcerto"), c);
286 
        c.gridy++;
57 ilm 287 
        c.insets = DefaultGridBagConstraints.getDefaultInsets();
288 
        this.add(new JLabel("Cette opération est nécessaire à chaque mise à jour du logiciel."), c);
289 
        c.gridy++;
290 
        this.add(new JLabel("La mise à niveau peut prendre plusieurs minutes."), c);
291 
        c.gridy++;
18 ilm 292 
        this.add(this.bar, c);
293 
        c.gridy++;
294 
        c.weightx = 0;
295 
        c.anchor = GridBagConstraints.EAST;
296 
        c.gridwidth = GridBagConstraints.REMAINDER;
297 
        c.fill = GridBagConstraints.NONE;
57 ilm 298 
 
18 ilm 299 
        this.add(up, c);
300 
 
301 
        c.anchor = GridBagConstraints.WEST;
302 
        c.fill = GridBagConstraints.HORIZONTAL;
303 
 
304 
        c.weightx = 1;
305 
        c.gridwidth = GridBagConstraints.REMAINDER;
306 
        c.weighty = 1;
307 
        c.gridy++;
308 
        final JPanel comp = new JPanel();
309 
        comp.setOpaque(false);
310 
        this.add(comp, c);
311 
    }
312 
 
94 ilm 313 
 
83 ilm 314 
    private void addArticleFournisseur(DBRoot root) {
315 
        if (!root.contains("ARTICLE_FOURNISSEUR")) {
316 
 
317 
            SQLCreateTable createBaseFamille = new SQLCreateTable(root, "FAMILLE_ARTICLE_FOURNISSEUR");
318 
            createBaseFamille.addVarCharColumn("CODE", 45);
319 
            createBaseFamille.addVarCharColumn("NOM", 2048);
320 
            createBaseFamille.addForeignColumn("ID_FAMILLE_ARTICLE_FOURNISSEUR_PERE", createBaseFamille);
321 
            final SQLDataSource ds = root.getDBSystemRoot().getDataSource();
322 
 
323 
            try {
324 
                ds.execute(createBaseFamille.asString());
325 
 
326 
                insertUndef(createBaseFamille);
327 
                root.refetchTable("FAMILLE_ARTICLE_FOURNISSEUR");
328 
                root.getSchema().updateVersion();
329 
            } catch (SQLException ex) {
330 
                throw new IllegalStateException("Erreur lors de la création de la table FAMILLE_ARTICLE_FOURNISSEUR", ex);
331 
            }
332 
 
333 
            SQLCreateTable createBase = new SQLCreateTable(root, "ARTICLE_FOURNISSEUR");
334 
            createBase.addVarCharColumn("CODE", 45);
335 
            createBase.addVarCharColumn("CODE_BARRE", 45);
336 
            createBase.addVarCharColumn("CODE_DOUANIER", 45);
337 
            createBase.addVarCharColumn("NOM", 2048);
338 
            createBase.addVarCharColumn("DESCRIPTIF", 2048);
339 
            createBase.addVarCharColumn("INFOS", 2048);
340 
 
341 
            createBase.addColumn("PRIX_METRIQUE_HA_1", "numeric (16,6) DEFAULT 0");
342 
            createBase.addColumn("PRIX_METRIQUE_HA_2", "numeric (16,8) DEFAULT 0");
343 
            createBase.addColumn("PRIX_METRIQUE_HA_3", "numeric (16,8) DEFAULT 0");
344 
 
345 
            createBase.addColumn("PRIX_METRIQUE_VT_1", "numeric (16,8) DEFAULT 0");
346 
            createBase.addColumn("PRIX_METRIQUE_VT_2", "numeric (16,8) DEFAULT 0");
347 
            createBase.addColumn("PRIX_METRIQUE_VT_3", "numeric (16,8) DEFAULT 0");
348 
 
349 
            createBase.addForeignColumn("ID_METRIQUE_1", root.findTable("METRIQUE", true));
350 
            createBase.addForeignColumn("ID_METRIQUE_2", root.findTable("METRIQUE", true));
351 
            createBase.addForeignColumn("ID_METRIQUE_3", root.findTable("METRIQUE", true));
352 
 
353 
            createBase.addColumn("PA_DEVISE", "numeric (16,8) DEFAULT 0");
354 
            createBase.addColumn("PV_U_DEVISE", "numeric (16,8) DEFAULT 0");
355 
            createBase.addColumn("PA_HT", "numeric (16,8) DEFAULT 0");
356 
            createBase.addColumn("PV_HT", "numeric (16,8) DEFAULT 0");
357 
            createBase.addColumn("PV_TTC", "numeric (16,2) DEFAULT 0");
358 
 
359 
            createBase.addForeignColumn("ID_TAXE", root.findTable("TAXE", true));
360 
            createBase.addForeignColumn("ID_FAMILLE_ARTICLE_FOURNISSEUR", root.findTable("FAMILLE_ARTICLE_FOURNISSEUR", true));
361 
            createBase.addForeignColumn("ID_MODE_VENTE_ARTICLE", root.findTable("MODE_VENTE_ARTICLE", true));
362 
            createBase.addForeignColumn("ID_FOURNISSEUR", root.findTable("FOURNISSEUR", true));
363 
            createBase.addForeignColumn("ID_PAYS", root.findTable("PAYS", true));
364 
            createBase.addForeignColumn("ID_DEVISE", root.findTable("DEVISE", true));
365 
            createBase.addForeignColumn("ID_DEVISE_HA", root.findTable("DEVISE", true));
366 
            createBase.addForeignColumn("ID_UNITE_VENTE", root.findTable("UNITE_VENTE", true));
367 
            createBase.addForeignColumn("ID_COMPTE_PCE", root.findTable("COMPTE_PCE", true));
368 
            createBase.addForeignColumn("ID_COMPTE_PCE_ACHAT", root.findTable("COMPTE_PCE", true));
369 
            createBase.addForeignColumn("ID_ARTICLE", root.findTable("ARTICLE", true));
370 
 
371 
            createBase.addColumn("POIDS", "real DEFAULT 0");
372 
            createBase.addColumn("VALEUR_METRIQUE_1", "real DEFAULT 0");
373 
            createBase.addColumn("VALEUR_METRIQUE_2", "real DEFAULT 0");
374 
            createBase.addColumn("VALEUR_METRIQUE_3", "real DEFAULT 0");
375 
            createBase.addBooleanColumn("SERVICE", Boolean.FALSE, false);
376 
            createBase.addBooleanColumn("OBSOLETE", Boolean.FALSE, false);
377 
            createBase.addBooleanColumn("GESTION_STOCK", Boolean.FALSE, false);
378 
            createBase.addIntegerColumn("QTE_ACHAT", 1);
379 
            createBase.addIntegerColumn("QTE_MIN", 1);
380 
 
381 
            try {
382 
                ds.execute(createBase.asString());
383 
 
384 
                insertUndef(createBase);
385 
                root.refetchTable("ARTICLE_FOURNISSEUR");
386 
                root.getSchema().updateVersion();
387 
            } catch (SQLException ex) {
388 
                throw new IllegalStateException("Erreur lors de la création de la table ARTICLE_FOURNISSEUR", ex);
389 
            }
390 
        }
391 
    }
392 
 
393 
    private void addContact(DBRoot root) throws SQLException {
394 
 
395 
        List<String> tables = Arrays.asList("AVOIR_CLIENT", "DEVIS", "BON_DE_LIVRAISON", "COMMANDE_CLIENT", "SAISIE_VENTE_FACTURE");
93 ilm 396 
        final SQLTable tableContact = root.findTable("CONTACT");
397 
        final SQLTable tableDpt = root.findTable("CLIENT_DEPARTEMENT");
398 
        final SQLDataSource dataSource = root.getDBSystemRoot().getDataSource();
83 ilm 399 
        for (String tableName : tables) {
93 ilm 400 
            boolean update = false;
401 
            final SQLTable table = root.getTable(tableName);
402 
            final AlterTable alterEcheance = new AlterTable(table);
83 ilm 403 
 
404 
            if (!table.contains("ID_CONTACT")) {
93 ilm 405 
                alterEcheance.addForeignColumn("ID_CONTACT", tableContact);
406 
                update = true;
407 
            }
83 ilm 408 
 
93 ilm 409 
            if (!table.contains("ID_CLIENT_DEPARTEMENT")) {
410 
                alterEcheance.addForeignColumn("ID_CLIENT_DEPARTEMENT", tableDpt);
411 
                update = true;
412 
            }
413 
            if (update) {
83 ilm 414 
                dataSource.execute(alterEcheance.asString());
415 
                table.getSchema().updateVersion();
416 
            }
93 ilm 417 
 
83 ilm 418 
        }
419 
    }
420 
 
73 ilm 421 
    private void addForeignKeyFactureOnEcheance(DBRoot root) {
422 
 
423 
        final SQLTable tableEch = root.getTable("ECHEANCE_CLIENT");
424 
        if (!tableEch.contains("ID_SAISIE_VENTE_FACTURE")) {
425 
            final SQLTable tableFacture = root.getTable("SAISIE_VENTE_FACTURE");
426 
            final SQLTable tableMvt = root.getTable("MOUVEMENT");
427 
            String query = "no query";
428 
            try {
429 
                final SQLDataSource dataSource = root.getDBSystemRoot().getDataSource();
430 
                final AlterTable alterEcheance = new AlterTable(tableEch);
431 
                alterEcheance.addForeignColumn("ID_SAISIE_VENTE_FACTURE", tableFacture);
432 
                dataSource.execute(alterEcheance.asString());
433 
                tableEch.getSchema().updateVersion();
434 
                tableEch.fetchFields();
81 ilm 435 
 
436 
                // select MOUVEMENT whose parent has a source FACTURE
437 
                final SQLSelect selMvt = new SQLSelect();
438 
                final AliasedTable refChild = new AliasedTable(tableMvt, "m1");
439 
                final AliasedTable refParent = new AliasedTable(tableMvt, "m2");
440 
                selMvt.addSelect(refParent.getField("IDSOURCE"));
441 
                selMvt.addBackwardJoin("INNER", refChild.getField("ID_MOUVEMENT_PERE"), refParent.getAlias());
442 
                selMvt.addSelect(refChild.getKey());
443 
                selMvt.setWhere(new Where(refParent.getField("SOURCE"), "=", tableFacture.getName()));
444 
 
445 
                final UpdateBuilder build = new UpdateBuilder(tableEch);
446 
                build.addVirtualJoin("( " + selMvt.asString() + " )", "mvt", false, tableMvt.getKey().getName(), "ID_MOUVEMENT");
447 
                build.setFromVirtualJoinField("ID_SAISIE_VENTE_FACTURE", "mvt", "IDSOURCE");
448 
                query = build.asString();
449 
                dataSource.execute(query);
73 ilm 450 
            } catch (SQLException ex) {
451 
                Log.get().severe("Error on query :" + query);
452 
                throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table ECHEANCE_CLIENT", ex);
453 
            }
454 
        }
455 
    }
456 
 
80 ilm 457 
    private void addFieldForPartialInvoice(DBRoot root) throws SQLException {
458 
        final SQLTable tableVF = root.getTable("SAISIE_VENTE_FACTURE");
459 
        AlterTable alter = new AlterTable(tableVF);
460 
        boolean doAlter = false;
461 
        if (!tableVF.contains("POURCENT_FACTURABLE")) {
462 
            alter.addColumn("POURCENT_FACTURABLE", "numeric (16,8)");
463 
            doAlter = true;
464 
        }
465 
        if (!tableVF.contains("MONTANT_FACTURABLE")) {
466 
            alter.addColumn("MONTANT_FACTURABLE", "numeric (16,8)");
467 
            doAlter = true;
468 
        }
469 
 
470 
        if (!tableVF.contains("SOLDE")) {
471 
            alter.addColumn("SOLDE", "boolean DEFAULT false");
472 
            doAlter = true;
473 
        }
474 
 
475 
        if (!tableVF.contains("PARTIAL")) {
476 
            alter.addColumn("PARTIAL", "boolean DEFAULT false");
477 
            doAlter = true;
478 
        }
479 
 
480 
        if (doAlter) {
481 
            root.getDBSystemRoot().getDataSource().execute(alter.asString());
482 
            root.refetchTable(tableVF.getName());
483 
        }
484 
 
485 
        // ELT
486 
        final SQLTable tableVFElt = root.getTable("SAISIE_VENTE_FACTURE_ELEMENT");
487 
        AlterTable alterElt = new AlterTable(tableVFElt);
488 
        boolean doAlterElt = false;
489 
        if (!tableVFElt.contains("MONTANT_FACTURABLE")) {
490 
            alterElt.addColumn("MONTANT_FACTURABLE", "numeric (16,8)");
491 
            doAlterElt = true;
492 
        }
493 
 
494 
        if (!tableVFElt.contains("POURCENT_FACTURABLE")) {
495 
            alterElt.addColumn("POURCENT_FACTURABLE", "numeric (16,8)");
496 
            doAlterElt = true;
497 
        }
498 
 
499 
        if (doAlterElt) {
500 
            root.getDBSystemRoot().getDataSource().execute(alterElt.asString());
501 
            root.refetchTable(tableVFElt.getName());
502 
        }
503 
 
504 
    }
505 
 
93 ilm 506 
    private void createAssocAnalytique(DBRoot root, ComptaPropsConfiguration conf) {
83 ilm 507 
 
508 
        if (!root.contains("ASSOCIATION_ANALYTIQUE")) {
509 
 
510 
            SQLCreateTable createAssoc = new SQLCreateTable(root, "ASSOCIATION_ANALYTIQUE");
511 
            createAssoc.addForeignColumn("ID_ECRITURE", root.findTable("ECRITURE", true));
512 
            createAssoc.addForeignColumn("ID_SAISIE_KM_ELEMENT", root.findTable("SAISIE_KM_ELEMENT", true));
513 
            createAssoc.addForeignColumn("ID_POSTE_ANALYTIQUE", root.findTable("POSTE_ANALYTIQUE", true));
514 
            createAssoc.addColumn("POURCENT", "numeric (16,8) DEFAULT 100");
515 
            createAssoc.addColumn("MONTANT", "bigInt DEFAULT 0");
516 
            createAssoc.addBooleanColumn("GESTION_AUTO", false, false);
517 
 
518 
            final SQLDataSource ds = root.getDBSystemRoot().getDataSource();
519 
 
520 
            try {
521 
                ds.execute(createAssoc.asString());
522 
 
523 
                insertUndef(createAssoc);
524 
                root.refetchTable("ASSOCIATION_ANALYTIQUE");
525 
                root.getSchema().updateVersion();
526 
            } catch (SQLException ex) {
527 
                throw new IllegalStateException("Erreur lors de la création de la table ASSOCIATION_ANALYTIQUE", ex);
528 
            }
529 
 
530 
        }
93 ilm 531 
        SQLTable tablePoste = root.getTable("POSTE_ANALYTIQUE");
532 
        if (!tablePoste.contains("DEFAULT")) {
533 
            AlterTable a = new AlterTable(tablePoste);
534 
            a.addBooleanColumn("DEFAULT", Boolean.FALSE, false);
535 
            final SQLDataSource ds = root.getDBSystemRoot().getDataSource();
536 
            try {
537 
                ds.execute(a.asString());
538 
                root.refetchTable("POSTE_ANALYTIQUE");
539 
                root.getSchema().updateVersion();
540 
            } catch (SQLException ex) {
541 
                throw new IllegalStateException("Erreur lors de la création du DEFAULT sur la table POSTE_ANALYTIQUE", ex);
542 
            }
543 
        }
83 ilm 544 
    }
545 
 
546 
    private void updateStock(DBRoot root) throws SQLException {
547 
 
548 
        final SQLTable tableStock = root.getTable("STOCK");
549 
        final SQLDataSource ds = root.getDBSystemRoot().getDataSource();
550 
        if (!tableStock.contains("QTE_RECEPT_ATTENTE")) {
551 
 
552 
            try {
553 
 
554 
                AlterTable alterElt = new AlterTable(root.getTable("STOCK"));
555 
                alterElt.addColumn("QTE_RECEPT_ATTENTE", "real DEFAULT 0");
556 
                alterElt.addColumn("QTE_LIV_ATTENTE", "real DEFAULT 0");
557 
                ds.execute(alterElt.asString());
558 
 
559 
                AlterTable alterMvt = new AlterTable(root.getTable("MOUVEMENT_STOCK"));
560 
                alterMvt.addBooleanColumn("REEL", Boolean.TRUE, false);
561 
 
562 
                ds.execute(alterMvt.asString());
563 
 
564 
                root.getSchema().updateVersion();
565 
 
566 
            } catch (SQLException ex) {
567 
                throw new IllegalStateException("Erreur lors de la mise à jour des tables de stock", ex);
568 
            }
569 
 
570 
        }
571 
        // if (!root.contains("ARTICLE_ELEMENT")) {
572 
        // final SQLCreateTable createTable = new SQLCreateTable(root, "ARTICLE_ELEMENT");
573 
        // createTable.addForeignColumn("ARTICLE");
574 
        // createTable.addForeignColumn("ID_ARTICLE_PARENT", root.getTable("ARTICLE"));
575 
        // createTable.addIntegerColumn("QTE", 1);
576 
        // createTable.addDecimalColumn("QTE_UNITAIRE", 16, 6, BigDecimal.valueOf(1), false);
577 
        // createTable.addForeignColumn("UNITE_VENTE");
578 
        // insertUndef(createTable);
579 
        // ds.execute(createTable.asString());
580 
        //
581 
        // root.getSchema().updateVersion();
582 
        // root.refetchTable("ARTICLE_ELEMENT");
583 
        //
584 
        // }
585 
        //
586 
        // if (!root.getTable("ARTICLE").contains("COMPOSED")) {
587 
        // AlterTable alterMvt = new AlterTable(root.getTable("ARTICLE"));
588 
        // alterMvt.addBooleanColumn("COMPOSED", Boolean.FALSE, false);
589 
        //
590 
        // ds.execute(alterMvt.asString());
591 
        //
592 
        // root.getSchema().updateVersion();
593 
        // }
594 
 
595 
    }
596 
 
597 
    private void createBanque(DBRoot root) throws SQLException {
598 
 
93 ilm 599 
        // Création de la table
83 ilm 600 
        if (!root.contains("BANQUE") && !root.contains("BANQUE_POLE_PRODUIT")) {
601 
 
602 
            SQLCreateTable createBanque = new SQLCreateTable(root, "BANQUE");
603 
            createBanque.addForeignColumn("ID_JOURNAL", root.findTable("JOURNAL", true));
604 
            createBanque.addVarCharColumn("INFOS", 2048);
605 
            createBanque.addVarCharColumn("NUMERO_RUE", 45);
606 
            createBanque.addVarCharColumn("RUE", 256);
607 
            createBanque.addVarCharColumn("IBAN", 256);
608 
            createBanque.addVarCharColumn("BIC", 256);
609 
            createBanque.addVarCharColumn("VOIE", 256);
610 
            createBanque.addVarCharColumn("VILLE", 256);
611 
            createBanque.addVarCharColumn("NOM", 256);
612 
            createBanque.addVarCharColumn("DOMICILIATION", 256);
613 
            createBanque.addVarCharColumn("CODE", 256);
614 
            createBanque.addBooleanColumn("AFFACTURAGE", Boolean.FALSE, false);
615 
            createBanque.addForeignColumn("ID_COMPTE_PCE", root.findTable("COMPTE_PCE", true));
616 
 
617 
            final SQLDataSource ds = root.getDBSystemRoot().getDataSource();
618 
 
619 
            try {
620 
                ds.execute(createBanque.asString());
621 
 
622 
                insertUndef(createBanque);
623 
                root.refetchTable("BANQUE");
93 ilm 624 
                root.getSchema().updateVersion();
83 ilm 625 
 
93 ilm 626 
            } catch (SQLException ex) {
627 
                throw new IllegalStateException("Erreur lors de la création de la table BANQUE", ex);
628 
            }
629 
        }
83 ilm 630 
 
93 ilm 631 
        // Création des foreignkeys
632 
        {
633 
            final SQLDataSource ds = root.getDBSystemRoot().getDataSource();
634 
            List<String> tablesWithBanque = Arrays.asList("MODE_REGLEMENT", "CHEQUE_A_ENCAISSER", "CHEQUE_FOURNISSEUR");
83 ilm 635 
 
93 ilm 636 
            for (String string : tablesWithBanque) {
637 
 
638 
                final SQLTable table = root.getTable(string);
639 
                if (!table.contains("ID_BANQUE") && !table.contains("ID_BANQUE_POLE_PRODUIT")) {
640 
                    String tableName = (table.contains("ID_BANQUE_PRODUIT")) ? "BANQUE_POLE_PRODUIT" : "BANQUE";
641 
                    AlterTable alterElt = new AlterTable(table);
642 
                    alterElt.addForeignColumn("ID_" + tableName, root.getTable(tableName));
83 ilm 643 
                    ds.execute(alterElt.asString());
93 ilm 644 
                    root.refetchTable(string);
645 
                    root.getSchema().updateVersion();
83 ilm 646 
                }
647 
            }
93 ilm 648 
        }
83 ilm 649 
 
650 
    }
651 
 
80 ilm 652 
    private void createFactureFournisseur(DBRoot root) throws SQLException {
653 
        boolean refetchRoot = false;
654 
        if (!root.contains("FACTURE_FOURNISSEUR")) {
655 
 
656 
            SQLCreateTable createFactureF = new SQLCreateTable(root, "FACTURE_FOURNISSEUR");
657 
            createFactureF.addVarCharColumn("NOM", 256);
658 
            createFactureF.addVarCharColumn("NUMERO", 45);
659 
            createFactureF.addVarCharColumn("INFOS", 2048);
660 
            createFactureF.addColumn("DATE", "date");
661 
            createFactureF.addForeignColumn("FOURNISSEUR");
662 
            createFactureF.addForeignColumn("AVOIR_FOURNISSEUR");
663 
            createFactureF.addForeignColumn("COMPTE_PCE");
664 
            createFactureF.addForeignColumn("COMMERCIAL");
665 
            createFactureF.addForeignColumn("MODE_REGLEMENT");
666 
            createFactureF.addForeignColumn("MOUVEMENT");
667 
            createFactureF.addForeignColumn("ID_DEVISE", root.findTable("DEVISE", true));
668 
            createFactureF.addColumn("T_HT", "bigint DEFAULT 0");
669 
            createFactureF.addColumn("T_TVA", "bigint DEFAULT 0");
670 
            createFactureF.addColumn("T_TTC", "bigint DEFAULT 0");
671 
            createFactureF.addColumn("T_SERVICE", "bigint DEFAULT 0");
672 
            createFactureF.addColumn("T_DEVISE", "bigint DEFAULT 0");
673 
            createFactureF.addColumn("T_POIDS", "real DEFAULT 0");
674 
 
675 
            final SQLDataSource ds = root.getDBSystemRoot().getDataSource();
676 
 
677 
            try {
678 
                ds.execute(createFactureF.asString());
679 
                insertUndef(createFactureF);
680 
                root.getSchema().updateVersion();
681 
                root.refetchTable("FACTURE_FOURNISSEUR");
682 
                refetchRoot = true;
683 
            } catch (SQLException ex) {
684 
                throw new IllegalStateException("Erreur lors de la création de la table FACTURE_FOURNISSEUR", ex);
685 
            }
686 
 
687 
        }
688 
 
689 
        if (!root.contains("FACTURE_FOURNISSEUR_ELEMENT")) {
690 
 
691 
            SQLCreateTable createFactureF = new SQLCreateTable(root, "FACTURE_FOURNISSEUR_ELEMENT");
692 
 
693 
            createFactureF.addDecimalColumn("PRIX_METRIQUE_HA_1", 16, 6, BigDecimal.ZERO, false);
694 
            createFactureF.addDecimalColumn("PRIX_METRIQUE_HA_2", 16, 6, BigDecimal.ZERO, false);
695 
            createFactureF.addDecimalColumn("PRIX_METRIQUE_HA_3", 16, 6, BigDecimal.ZERO, false);
696 
            createFactureF.addDecimalColumn("PRIX_METRIQUE_VT_1", 16, 6, BigDecimal.ZERO, false);
697 
            createFactureF.addDecimalColumn("PRIX_METRIQUE_VT_2", 16, 6, BigDecimal.ZERO, false);
698 
            createFactureF.addDecimalColumn("PRIX_METRIQUE_VT_3", 16, 6, BigDecimal.ZERO, false);
699 
            createFactureF.addDecimalColumn("T_PV_HT", 16, 6, BigDecimal.ZERO, false);
700 
            createFactureF.addDecimalColumn("T_PA_HT", 16, 6, BigDecimal.ZERO, false);
701 
            createFactureF.addDecimalColumn("PV_HT", 16, 6, BigDecimal.ZERO, false);
702 
            createFactureF.addDecimalColumn("PA_HT", 16, 6, BigDecimal.ZERO, false);
703 
            createFactureF.addDecimalColumn("T_PV_TTC", 16, 6, BigDecimal.ZERO, false);
704 
            createFactureF.addDecimalColumn("T_PA_TTC", 16, 6, BigDecimal.ZERO, false);
705 
            createFactureF.addDecimalColumn("QTE_UNITAIRE", 16, 6, BigDecimal.ZERO, false);
706 
            createFactureF.addDecimalColumn("PA_DEVISE_T", 16, 6, BigDecimal.ZERO, false);
707 
            createFactureF.addDecimalColumn("PA_DEVISE", 16, 6, BigDecimal.ZERO, false);
708 
            createFactureF.addIntegerColumn("QTE", 1);
709 
            createFactureF.addIntegerColumn("QTE_ACHAT", 1);
710 
 
711 
            createFactureF.addColumn("VALEUR_METRIQUE_1", "real DEFAULT 0");
712 
            createFactureF.addColumn("VALEUR_METRIQUE_2", "real DEFAULT 0");
713 
            createFactureF.addColumn("VALEUR_METRIQUE_3", "real DEFAULT 0");
714 
            createFactureF.addColumn("T_POIDS", "real DEFAULT 0");
715 
            createFactureF.addColumn("POIDS", "real DEFAULT 0");
716 
            createFactureF.addBooleanColumn("SERVICE", Boolean.FALSE, true);
717 
            createFactureF.addVarCharColumn("CODE", 45);
718 
            createFactureF.addVarCharColumn("NOM", 256);
719 
            createFactureF.addColumn("DATE", "date");
720 
            createFactureF.addForeignColumn("STYLE");
721 
            createFactureF.addForeignColumn("METRIQUE", "3");
722 
            createFactureF.addForeignColumn("METRIQUE", "2");
723 
            createFactureF.addForeignColumn("METRIQUE", "1");
724 
            createFactureF.addForeignColumn("FACTURE_FOURNISSEUR");
725 
            createFactureF.addForeignColumn("TAXE");
726 
            createFactureF.addForeignColumn("ID_MODE_VENTE_ARTICLE", root.findTable("MODE_VENTE_ARTICLE").getSQLName(), "ID", "5");
727 
            createFactureF.addForeignColumn("UNITE_VENTE");
728 
            createFactureF.addForeignColumn("ARTICLE");
729 
            createFactureF.addForeignColumn("ID_DEVISE", root.findTable("DEVISE", true));
730 
            createFactureF.addForeignColumn("CODE_FOURNISSEUR");
731 
 
732 
            final SQLDataSource ds = root.getDBSystemRoot().getDataSource();
733 
 
734 
            try {
735 
                ds.execute(createFactureF.asString());
736 
                insertUndef(createFactureF);
737 
                root.getSchema().updateVersion();
738 
                refetchRoot = true;
739 
            } catch (SQLException ex) {
740 
                throw new IllegalStateException("Erreur lors de la création de la table FACTURE_FOURNISSEUR_ELEMENT", ex);
741 
            }
742 
 
743 
        }
744 
 
132 ilm 745 
        if (root.contains("FACTURE_FOURNISSEUR_ELEMENT")) {
746 
            addHAElementField(root.getTable("FACTURE_FOURNISSEUR_ELEMENT"), root);
747 
        }
748 
 
80 ilm 749 
        if (!root.contains("REGLER_MONTANT_ELEMENT")) {
750 
 
751 
            SQLCreateTable createReglerElt = new SQLCreateTable(root, "REGLER_MONTANT_ELEMENT");
752 
 
753 
            createReglerElt.addForeignColumn("ECHEANCE_FOURNISSEUR");
754 
            createReglerElt.addForeignColumn("REGLER_MONTANT");
755 
            createReglerElt.addForeignColumn("MOUVEMENT", "ECHEANCE");
756 
            createReglerElt.addColumn("DATE", "date");
757 
            createReglerElt.addColumn("MONTANT_REGLE", "bigint DEFAULT 0");
758 
            createReglerElt.addColumn("MONTANT_A_REGLER", "bigint DEFAULT 0");
759 
 
760 
            final SQLDataSource ds = root.getDBSystemRoot().getDataSource();
761 
 
762 
            try {
763 
                ds.execute(createReglerElt.asString());
764 
                insertUndef(createReglerElt);
765 
                root.getSchema().updateVersion();
766 
                root.refetchTable("REGLER_MONTANT_ELEMENT");
767 
                refetchRoot = true;
768 
            } catch (SQLException ex) {
769 
                throw new IllegalStateException("Erreur lors de la création de la table REGLER_MONTANT_ELEMENT", ex);
770 
            }
771 
 
772 
        }
773 
 
774 
        final SQLTable tableReglerMontant = root.getTable("REGLER_MONTANT");
775 
 
776 
        boolean updateRegler = false;
777 
 
778 
        AlterTable alterElt = new AlterTable(tableReglerMontant);
779 
        if (!tableReglerMontant.contains("ID_FOURNISSEUR")) {
780 
            alterElt.addForeignColumn("ID_FOURNISSEUR", root.getTable("FOURNISSEUR"));
781 
            updateRegler = true;
782 
        }
783 
 
784 
        if (!tableReglerMontant.contains("NOM")) {
785 
            alterElt.addVarCharColumn("NOM", 256);
786 
            updateRegler = true;
787 
        }
788 
 
789 
        if (updateRegler) {
790 
            root.getDBSystemRoot().getDataSource().execute(alterElt.asString());
791 
            root.refetchTable(tableReglerMontant.getName());
792 
        }
793 
 
794 
        if (refetchRoot) {
795 
            root.refetch();
796 
        }
797 
    }
798 
 
25 ilm 799 
    private void fixUnboundedNumeric(DBRoot root) throws SQLException {
800 
 
801 
        final List<AlterTable> alters = new ArrayList<AlterTable>();
73 ilm 802 
        final List<UpdateBuilder> builds = new ArrayList<UpdateBuilder>();
25 ilm 803 
        {
804 
            SQLTable tableAvoir = root.getTable("AVOIR_CLIENT_ELEMENT");
805 
            final AlterTable alter = new AlterTable(tableAvoir);
93 ilm 806 
            if (tableAvoir.contains("POURCENT_ACOMPTE")) {
807 
                SQLField fieldAcompteAvoir = tableAvoir.getField("POURCENT_ACOMPTE");
808 
                if (fieldAcompteAvoir.getType().getSize() > 500) {
809 
                    final String fName = fieldAcompteAvoir.getName();
810 
                    alter.alterColumn(fName, EnumSet.allOf(Properties.class), "numeric(6,2)", "100", false);
73 ilm 811 
 
93 ilm 812 
                    UpdateBuilder build = new UpdateBuilder(tableAvoir);
813 
                    build.set(fieldAcompteAvoir.getName(), "100");
814 
                    build.setWhere(new Where(fieldAcompteAvoir, "=", (Object) null));
815 
                    builds.add(build);
816 
                }
25 ilm 817 
            }
83 ilm 818 
            if (tableAvoir.contains("POURCENT_REMISE")) {
819 
                SQLField fieldRemiseAvoir = tableAvoir.getField("POURCENT_REMISE");
820 
                if (fieldRemiseAvoir.getType().getSize() > 500) {
821 
                    final String fName = fieldRemiseAvoir.getName();
822 
                    alter.alterColumn(fName, EnumSet.allOf(Properties.class), "numeric(6,2)", "0", false);
73 ilm 823 
 
83 ilm 824 
                    UpdateBuilder build = new UpdateBuilder(tableAvoir);
825 
                    build.set(fieldRemiseAvoir.getName(), "0");
826 
                    build.setWhere(new Where(fieldRemiseAvoir, "=", (Object) null));
827 
                    builds.add(build);
828 
                }
25 ilm 829 
            }
830 
            if (!alter.isEmpty())
831 
                alters.add(alter);
832 
        }
833 
 
834 
        {
835 
            SQLTable tableFacture = root.getTable("SAISIE_VENTE_FACTURE_ELEMENT");
836 
            final AlterTable alter = new AlterTable(tableFacture);
93 ilm 837 
            if (tableFacture.contains("POURCENT_ACOMPTE")) {
838 
                SQLField fieldAcompteFacture = tableFacture.getField("POURCENT_ACOMPTE");
839 
                if (fieldAcompteFacture.getType().getSize() > 500) {
840 
                    final String fName = fieldAcompteFacture.getName();
841 
                    alter.alterColumn(fName, EnumSet.allOf(Properties.class), "numeric(6,2)", "100", false);
73 ilm 842 
 
93 ilm 843 
                    UpdateBuilder build = new UpdateBuilder(tableFacture);
844 
                    build.set(fieldAcompteFacture.getName(), "100");
845 
                    build.setWhere(new Where(fieldAcompteFacture, "=", (Object) null));
846 
                    builds.add(build);
847 
                }
25 ilm 848 
            }
849 
 
93 ilm 850 
            if (tableFacture.contains("POURCENT_REMISE")) {
851 
                SQLField fieldRemiseFacture = tableFacture.getField("POURCENT_REMISE");
852 
                if (fieldRemiseFacture.getType().getSize() > 500) {
853 
                    final String fName = fieldRemiseFacture.getName();
854 
                    alter.alterColumn(fName, EnumSet.allOf(Properties.class), "numeric(6,2)", "0", false);
73 ilm 855 
 
93 ilm 856 
                    UpdateBuilder build = new UpdateBuilder(tableFacture);
857 
                    build.set(fieldRemiseFacture.getName(), "0");
858 
                    build.setWhere(new Where(fieldRemiseFacture, "=", (Object) null));
859 
                    builds.add(build);
860 
                }
25 ilm 861 
            }
862 
            if (tableFacture.getFieldsName().contains("REPARTITION_POURCENT")) {
863 
                SQLField fieldRepFacture = tableFacture.getField("REPARTITION_POURCENT");
864 
                if (fieldRepFacture.getType().getSize() > 500) {
865 
                    final String fName = fieldRepFacture.getName();
866 
                    alter.alterColumn(fName, EnumSet.allOf(Properties.class), "numeric(6,2)", "0", false);
73 ilm 867 
 
868 
                    UpdateBuilder build = new UpdateBuilder(tableFacture);
869 
                    build.set(fieldRepFacture.getName(), "0");
870 
                    build.setWhere(new Where(fieldRepFacture, "=", (Object) null));
871 
                    builds.add(build);
25 ilm 872 
                }
873 
            }
874 
 
875 
            if (!alter.isEmpty())
876 
                alters.add(alter);
877 
 
878 
        }
879 
        if (alters.size() > 0) {
880 
            final SQLDataSource ds = root.getDBSystemRoot().getDataSource();
73 ilm 881 
 
882 
            for (UpdateBuilder updateBuilder : builds) {
883 
                ds.execute(updateBuilder.asString());
884 
            }
885 
 
25 ilm 886 
            for (final String sql : ChangeTable.cat(alters, root.getName())) {
887 
                ds.execute(sql);
888 
            }
889 
            root.refetch();
890 
        }
891 
    }
892 
 
20 ilm 893 
    private void fixUnboundedVarchar(DBRoot root) throws SQLException {
894 
        final Set<String> namesSet = CollectionUtils.createSet("NOM", "PRENOM", "SURNOM", "LOGIN", "PASSWORD");
895 
        final List<AlterTable> alters = new ArrayList<AlterTable>();
73 ilm 896 
        final List<UpdateBuilder> builds = new ArrayList<UpdateBuilder>();
20 ilm 897 
        for (final SQLTable t : root.getTables()) {
898 
            final AlterTable alter = new AlterTable(t);
899 
            for (final SQLField f : t.getFields()) {
156 ilm 900 
                // on PG, CLOB are text and the JDBC driver returns Types.VARCHAR, not CLOB. So test
901 
                // if the type name contains "char", since we only want unbounded varchar, not
902 
                // text/clob.
903 
                if (f.getType().getType() == Types.VARCHAR && f.getType().getSize() == Integer.MAX_VALUE && f.getTypeDecl().contains("char")) {
73 ilm 904 
 
905 
                    UpdateBuilder build = new UpdateBuilder(t);
156 ilm 906 
                    build.setObject(f.getName(), "");
907 
                    build.setWhere(Where.isNull(f));
73 ilm 908 
                    builds.add(build);
909 
 
20 ilm 910 
                    final String fName = f.getName();
911 
                    final int size;
80 ilm 912 
                    if (t.getName().contains("USER") && namesSet.contains(fName))
21 ilm 913 
                        size = 128;
20 ilm 914 
                    else if (fName.equals("TEL") || fName.startsWith("TEL_"))
21 ilm 915 
                        size = 32;
916 
                    else if (fName.contains("INFO"))
80 ilm 917 
                        size = 4096;
21 ilm 918 
                    else if (fName.contains("FORMULE"))
919 
                        size = 1024;
920 
                    else if (fName.equals("CONTENU"))
921 
                        size = 2048;
20 ilm 922 
                    else
80 ilm 923 
                        // e.g. IDCC.NOM > 350
151 ilm 924 
                        size = 512;
20 ilm 925 
                    alter.alterColumn(fName, EnumSet.allOf(Properties.class), "varchar(" + size + ")", "''", false);
926 
                }
927 
            }
928 
            if (!alter.isEmpty())
929 
                alters.add(alter);
930 
        }
931 
        if (alters.size() > 0) {
932 
            final SQLDataSource ds = root.getDBSystemRoot().getDataSource();
73 ilm 933 
 
934 
            for (UpdateBuilder build : builds) {
935 
                ds.execute(build.asString());
936 
            }
937 
 
20 ilm 938 
            for (final String sql : ChangeTable.cat(alters, root.getName())) {
151 ilm 939 
                ds.execute(sql);
20 ilm 940 
            }
941 
            root.refetch();
942 
        }
67 ilm 943 
 
20 ilm 944 
    }
945 
 
67 ilm 946 
    private void updateToV1Dot3(final DBRoot root) throws SQLException {
947 
        final SQLDataSource ds = root.getDBSystemRoot().getDataSource();
73 ilm 948 
 
949 
        addForeignKeyFactureOnEcheance(root);
80 ilm 950 
        addFieldForPartialInvoice(root);
73 ilm 951 
 
952 
        // Numérotation client
953 
        {
954 
            SQLTable tableNum = root.getTable("NUMEROTATION_AUTO");
955 
            boolean alterNum = false;
956 
            AlterTable t = new AlterTable(tableNum);
957 
            if (!tableNum.getFieldsName().contains("CLIENT_START")) {
958 
                t.addColumn("CLIENT_START", "integer DEFAULT 0");
959 
                alterNum = true;
960 
            }
961 
            if (!tableNum.getFieldsName().contains("CLIENT_FORMAT")) {
962 
                t.addVarCharColumn("CLIENT_FORMAT", 48);
963 
                alterNum = true;
964 
            }
965 
 
966 
            if (alterNum) {
967 
                try {
968 
                    ds.execute(t.asString());
969 
                    tableNum.getSchema().updateVersion();
970 
                    tableNum.fetchFields();
971 
                } catch (SQLException ex) {
972 
                    throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table NUMEROTATION_AUTO", ex);
973 
                }
974 
            }
975 
        }
976 
 
80 ilm 977 
        // Eecheance founisseur
978 
        {
979 
            SQLTable tableEchF = root.getTable("ECHEANCE_FOURNISSEUR");
980 
            AlterTable t = new AlterTable(tableEchF);
981 
            if (!tableEchF.getFieldsName().contains("REG_COMPTA")) {
982 
                t.addColumn("REG_COMPTA", "boolean DEFAULT false");
983 
                try {
984 
                    ds.execute(t.asString());
985 
                    tableEchF.getSchema().updateVersion();
986 
                    tableEchF.fetchFields();
987 
                } catch (SQLException ex) {
988 
                    throw new IllegalStateException("Erreur lors de l'ajout du champ REG_COMPTA sur la table ECHEANCE_FOUNISSEUR", ex);
989 
                }
990 
            }
991 
        }
992 
 
993 
        SQLTable tableTaxe = root.getTable("TAXE");
994 
        boolean containsTaxeDefault = tableTaxe.contains("DEFAULT");
995 
        if (!containsTaxeDefault) {
996 
            AlterTable t = new AlterTable(tableTaxe);
997 
            t.addColumn("DEFAULT", "boolean DEFAULT false");
998 
 
999 
            try {
1000 
                ds.execute(t.asString());
1001 
                tableTaxe.getSchema().updateVersion();
1002 
                tableTaxe.fetchFields();
1003 
            } catch (SQLException ex) {
1004 
                throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table TAXE", ex);
1005 
            }
1006 
 
1007 
        }
1008 
 
1009 
        // Ajout de la TVA à 20
1010 
        SQLSelect selTVA = new SQLSelect();
1011 
        selTVA.addSelect(tableTaxe.getKey(), "COUNT");
1012 
        selTVA.setWhere(new Where(tableTaxe.getField("TAUX"), "=", 20));
1013 
        Object result = root.getBase().getDataSource().executeScalar(selTVA.asString());
1014 
        if (result == null || ((Number) result).longValue() == 0) {
1015 
            SQLRowValues rowVals = new SQLRowValues(tableTaxe);
1016 
            rowVals.put("NOM", "TVA 20%");
1017 
            rowVals.put("TAUX", Float.valueOf(20));
1018 
            rowVals.put("DEFAULT", Boolean.TRUE);
1019 
            rowVals.commit();
1020 
        } else if (!containsTaxeDefault) {
1021 
            SQLSelect selTVA20 = new SQLSelect();
1022 
            selTVA20.addSelectStar(tableTaxe);
1023 
            selTVA20.setWhere(new Where(tableTaxe.getField("TAUX"), "=", 20));
1024 
            List<SQLRow> lTVA = SQLRowListRSH.execute(selTVA20);
1025 
            if (lTVA != null && lTVA.size() > 0) {
1026 
                SQLRowValues rowVals = lTVA.get(0).asRowValues();
1027 
                rowVals.put("DEFAULT", Boolean.TRUE);
1028 
                rowVals.update();
1029 
            }
1030 
 
1031 
        }
1032 
 
67 ilm 1033 
        // Article
1034 
        {
1035 
            SQLTable tableProduct = root.getTable("ARTICLE");
1036 
            boolean alterTableProduct = false;
1037 
            AlterTable t = new AlterTable(tableProduct);
1038 
            if (!tableProduct.getFieldsName().contains("ID_COMPTE_PCE")) {
1039 
                t.addForeignColumn("ID_COMPTE_PCE", root.getTable("COMPTE_PCE"));
1040 
                alterTableProduct = true;
1041 
            }
1042 
            if (!tableProduct.getFieldsName().contains("ID_COMPTE_PCE_ACHAT")) {
1043 
                t.addForeignColumn("ID_COMPTE_PCE_ACHAT", root.getTable("COMPTE_PCE"));
1044 
                alterTableProduct = true;
1045 
            }
1046 
            if (alterTableProduct) {
1047 
                try {
1048 
                    ds.execute(t.asString());
1049 
                    tableProduct.getSchema().updateVersion();
1050 
                    tableProduct.fetchFields();
1051 
                } catch (SQLException ex) {
1052 
                    throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table ARTICLE", ex);
1053 
                }
1054 
            }
1055 
        }
1056 
 
1057 
        // Famille Article
1058 
        {
1059 
            SQLTable tableArticleFamily = root.getTable("FAMILLE_ARTICLE");
1060 
            boolean alterArticleFamily = false;
1061 
            AlterTable t = new AlterTable(tableArticleFamily);
1062 
            if (!tableArticleFamily.getFieldsName().contains("ID_COMPTE_PCE")) {
1063 
                t.addForeignColumn("ID_COMPTE_PCE", root.getTable("COMPTE_PCE"));
1064 
                alterArticleFamily = true;
1065 
            }
1066 
            if (!tableArticleFamily.getFieldsName().contains("ID_COMPTE_PCE_ACHAT")) {
1067 
                t.addForeignColumn("ID_COMPTE_PCE_ACHAT", root.getTable("COMPTE_PCE"));
1068 
                alterArticleFamily = true;
1069 
            }
1070 
            if (alterArticleFamily) {
1071 
                try {
1072 
                    ds.execute(t.asString());
1073 
                    tableArticleFamily.getSchema().updateVersion();
1074 
                    tableArticleFamily.fetchFields();
1075 
                } catch (SQLException ex) {
1076 
                    throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table FAMILLE_ARTICLE", ex);
1077 
                }
1078 
            }
1079 
        }
1080 
 
1081 
        // ECRITURE
1082 
        {
1083 
            SQLTable tableRecords = root.getTable("ECRITURE");
1084 
            boolean alterRecords = false;
1085 
            AlterTable t = new AlterTable(tableRecords);
1086 
            if (!tableRecords.getFieldsName().contains("DATE_EXPORT")) {
1087 
                t.addColumn("DATE_EXPORT", "date");
1088 
                alterRecords = true;
1089 
            }
1090 
 
1091 
            if (!tableRecords.getFieldsName().contains("CODE_CLIENT")) {
1092 
                t.addVarCharColumn("CODE_CLIENT", 256);
1093 
                alterRecords = true;
1094 
            }
1095 
            if (alterRecords) {
1096 
                try {
1097 
                    ds.execute(t.asString());
1098 
                    tableRecords.getSchema().updateVersion();
1099 
                    tableRecords.fetchFields();
1100 
                } catch (SQLException ex) {
1101 
                    throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table ECRITURE", ex);
1102 
                }
1103 
            }
1104 
        }
1105 
        addInfoField(root, ds, "AVOIR_FOURNISSEUR");
1106 
        addInfoField(root, ds, "AVOIR_CLIENT");
1107 
 
1108 
        boolean refetchRoot = false;
1109 
        if (!root.contains("CODE_FOURNISSEUR")) {
1110 
 
1111 
            SQLCreateTable createCode = new SQLCreateTable(root, "CODE_FOURNISSEUR");
1112 
            createCode.addVarCharColumn("CODE", 256);
1113 
            createCode.addForeignColumn("FOURNISSEUR");
1114 
            createCode.addForeignColumn("ARTICLE");
1115 
            try {
1116 
                ds.execute(createCode.asString());
1117 
                insertUndef(createCode);
1118 
                root.getSchema().updateVersion();
1119 
                refetchRoot = true;
1120 
            } catch (SQLException ex) {
1121 
                throw new IllegalStateException("Erreur lors de la création de la table CODE_FOURNISSEUR", ex);
1122 
            }
1123 
 
1124 
        }
1125 
 
1126 
        // Chargement des tables fraichement créées
1127 
        if (refetchRoot)
1128 
            root.refetch();
1129 
 
80 ilm 1130 
        createFactureFournisseur(root);
1131 
 
67 ilm 1132 
        addSupplierCode(root, ds, "BON_RECEPTION_ELEMENT");
1133 
        addSupplierCode(root, ds, "COMMANDE_ELEMENT");
1134 
 
1135 
        // Undefined
1136 
        SQLTable.setUndefID(root.getSchema(), "ARTICLE_DESIGNATION", 1);
1137 
        SQLTable.setUndefID(root.getSchema(), "ARTICLE_TARIF", 1);
1138 
        SQLTable.setUndefID(root.getSchema(), "CODE_STATUT_CAT_CONV", 1);
1139 
        SQLTable.setUndefID(root.getSchema(), "CONTACT_ADMINISTRATIF", 1);
1140 
        SQLTable.setUndefID(root.getSchema(), "CONTACT_FOURNISSEUR", 1);
1141 
 
1142 
        SQLTable.setUndefID(root.getSchema(), "LANGUE", 1);
1143 
        SQLTable.setUndefID(root.getSchema(), "MODELE", 1);
1144 
        SQLTable.setUndefID(root.getSchema(), "OBJECTIF_COMMERCIAL", 1);
1145 
        SQLTable.setUndefID(root.getSchema(), "TARIF", 1);
1146 
 
1147 
        SQLTable.setUndefID(root.getSchema(), "UNITE_VENTE", 1);
73 ilm 1148 
 
1149 
        // Create transfer tables
1150 
        ComptaPropsConfiguration.setSocieteSQLInjector(root);
1151 
        SQLInjector.createTransferTables(root);
1152 
        // Move transfer info to SAISIE_VENTE_FACTURE
1153 
        convertTransfer(root, Arrays.asList("COMMANDE_CLIENT", "DEVIS", "BON_DE_LIVRAISON"), "SAISIE_VENTE_FACTURE");
83 ilm 1154 
        // Fix keys
1155 
        if (root.getServer().getSQLSystem().equals(SQLSystem.H2)) {
1156 
            final ChangeIDToInt c = new ChangeIDToInt(root.getDBSystemRoot());
1157 
            c.changeAll(root);
1158 
            root.getDBSystemRoot().reload(Collections.singleton(root.getName()));
1159 
        }
67 ilm 1160 
    }
1161 
 
73 ilm 1162 
    private void convertTransfer(DBRoot root, List<String> tablesSrc, String tableDest) throws SQLException {
1163 
        final SQLTable tableDestination = root.getTable(tableDest);
1164 
        if (tableDestination.contains("SOURCE") && tableDestination.contains("IDSOURCE")) {
1165 
            for (String tableSrc : tablesSrc) {
1166 
                convertTransfer(root.getTable(tableSrc), tableDestination);
1167 
            }
1168 
            final AlterTable alter = new AlterTable(tableDestination);
1169 
            alter.dropColumn("SOURCE");
1170 
            alter.dropColumn("IDSOURCE");
1171 
            final String req = alter.asString();
1172 
            root.getDBSystemRoot().getDataSource().execute(req);
1173 
            root.refetchTable(tableDest);
1174 
        }
1175 
    }
1176 
 
1177 
    private void convertTransfer(final SQLTable tableSource, final SQLTable tableDest) throws SQLException {
1178 
        SQLInjector inj = SQLInjector.getInjector(tableSource, tableDest);
1179 
        final SQLRowValues vals = new SQLRowValues(tableDest);
1180 
        vals.putNulls("SOURCE", "IDSOURCE");
1181 
        final SQLRowValuesListFetcher fetcher = new SQLRowValuesListFetcher(vals);
1182 
        fetcher.setSelTransf(new ITransformer<SQLSelect, SQLSelect>() {
1183 
 
1184 
            @Override
1185 
            public SQLSelect transformChecked(SQLSelect input) {
1186 
                Where w = new Where(tableDest.getField("SOURCE"), "=", tableSource.getName());
1187 
                w = w.and(new Where(tableDest.getField("IDSOURCE"), "!=", tableSource.getUndefinedIDNumber()));
1188 
                // remove archive idsource
1189 
                w = w.and(new Where(tableDest.getField("IDSOURCE"), "=", tableSource.getKey()));
1190 
                input.setWhere(w);
1191 
                return input;
1192 
            }
1193 
        });
1194 
        List<SQLRowValues> rows = fetcher.fetch();
1195 
        for (SQLRowValues sqlRowValues : rows) {
1196 
            inj.addTransfert(sqlRowValues.getInt("IDSOURCE"), sqlRowValues.getID());
1197 
        }
1198 
    }
1199 
 
67 ilm 1200 
    private void addInfoField(final DBRoot root, final SQLDataSource ds, String tableName) {
1201 
        SQLTable tableBL = root.getTable(tableName);
1202 
        boolean alterBL = false;
1203 
        AlterTable t = new AlterTable(tableBL);
1204 
        if (!tableBL.getFieldsName().contains("INFOS")) {
1205 
            t.addVarCharColumn("INFOS", 1024);
1206 
            alterBL = true;
1207 
        }
1208 
        if (alterBL) {
1209 
            try {
1210 
                ds.execute(t.asString());
1211 
                tableBL.getSchema().updateVersion();
1212 
                tableBL.fetchFields();
1213 
            } catch (SQLException ex) {
1214 
                throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table AVOIR FOURNISSEUR", ex);
1215 
            }
1216 
        }
1217 
    }
1218 
 
1219 
    private void addSupplierCode(final DBRoot root, final SQLDataSource ds, String tableName) {
1220 
        SQLTable tableBL = root.getTable(tableName);
1221 
        boolean alterBL = false;
1222 
        AlterTable t = new AlterTable(tableBL);
1223 
        if (!tableBL.contains("ID_CODE_FOURNISSEUR")) {
1224 
            t.addForeignColumn("ID_CODE_FOURNISSEUR", root.getTable("CODE_FOURNISSEUR"));
1225 
            alterBL = true;
1226 
        }
1227 
        if (alterBL) {
1228 
            try {
1229 
                ds.execute(t.asString());
1230 
                tableBL.getSchema().updateVersion();
1231 
                tableBL.fetchFields();
1232 
            } catch (SQLException ex) {
1233 
                throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table " + tableName, ex);
1234 
            }
1235 
        }
1236 
    }
1237 
 
132 ilm 1238 
    private void checkDepartementExists(DBRoot root, String dpt, String chefLieu, String regionAdmin, String numero) throws SQLException {
1239 
        SQLSelect sel = new SQLSelect();
1240 
        final SQLTable tableDpt = root.getTable("DEPARTEMENT");
1241 
        sel.addSelect(tableDpt.getKey());
1242 
        sel.addSelect(tableDpt.getField("NOM"));
1243 
        Where w = new Where(tableDpt.getField("NOM"), "=", dpt);
1244 
        sel.setWhere(w);
1245 
        int result = SQLRowListRSH.execute(sel).size();
1246 
        if (result == 0) {
1247 
            SQLRowValues rowVals = new SQLRowValues(tableDpt);
1248 
            rowVals.put("NOM", dpt);
1249 
            rowVals.put("CHEF_LIEU", chefLieu);
1250 
            rowVals.put("REGION_ADMIN", regionAdmin);
1251 
            rowVals.put("NUMERO", numero);
1252 
            rowVals.commit();
1253 
        }
1254 
    }
1255 
 
83 ilm 1256 
    private void updateToV1Dot4(final DBRoot root) throws SQLException {
93 ilm 1257 
 
94 ilm 1258 
        checkPrefsComptable(root);
132 ilm 1259 
        checkDepartementExists(root, "Aisne", "Laon", "Picardie", "02");
94 ilm 1260 
 
132 ilm 1261 
        if (root.contains("TARIF_AGENCE")) {
156 ilm 1262 
            SQLTable tableCmdFA = root.getTable("COMMANDE");
1263 
            if (!tableCmdFA.contains("INCOTERM")) {
1264 
                AlterTable t = new AlterTable(tableCmdFA);
1265 
                t.addVarCharColumn("INCOTERM", 256);
1266 
                tableCmdFA.getBase().getDataSource().execute(t.asString());
1267 
                tableCmdFA.getSchema().updateVersion();
1268 
                tableCmdFA.fetchFields();
1269 
            }
132 ilm 1270 
 
156 ilm 1271 
            SQLTable tableArticleA = root.getTable("ARTICLE");
1272 
            if (!tableArticleA.contains("CLOSED_KIT")) {
1273 
                AlterTable t = new AlterTable(tableArticleA);
1274 
                t.addBooleanColumn("CLOSED_KIT", Boolean.FALSE, true);
1275 
                tableArticleA.getBase().getDataSource().execute(t.asString());
1276 
                tableArticleA.getSchema().updateVersion();
1277 
                tableArticleA.fetchFields();
1278 
            }
1279 
 
1280 
            if (!tableArticleA.contains("CLOSED_KIT_DESC")) {
1281 
                AlterTable t = new AlterTable(tableArticleA);
1282 
                t.addVarCharColumn("CLOSED_KIT_DESC", 4096);
1283 
                tableArticleA.getBase().getDataSource().execute(t.asString());
1284 
                tableArticleA.getSchema().updateVersion();
1285 
                tableArticleA.fetchFields();
1286 
            }
1287 
 
1288 
            SQLTable tableCmdFEltA = root.getTable("COMMANDE_ELEMENT");
1289 
            if (!tableCmdFEltA.contains("INCOTERM")) {
1290 
                AlterTable t = new AlterTable(tableCmdFEltA);
1291 
                t.addVarCharColumn("INCOTERM", 256);
1292 
                tableCmdFEltA.getBase().getDataSource().execute(t.asString());
1293 
                tableCmdFEltA.getSchema().updateVersion();
1294 
                tableCmdFEltA.fetchFields();
1295 
            }
1296 
 
1297 
            if (root.getTable("VILLE") == null) {
1298 
 
1299 
                // INSERT INTO "OpenConcerto49"."VILLE" ("CODE_POSTAL","NOM") SELECT
1300 
                // "CODE_POSTAL",
1301 
                // "VILLE" FROM "OpenConcerto49"."ADRESSE" a WHERE a."ARCHIVE"=0
1302 
                final SQLCreateTable createTableVille = new SQLCreateTable(root, "VILLE");
1303 
                createTableVille.addVarCharColumn("NOM", 2048);
1304 
                createTableVille.addVarCharColumn("CODE_POSTAL", 2048);
1305 
                createTableVille.addLongColumn("X_LAMBERT", 0L, true);
1306 
                createTableVille.addLongColumn("Y_LAMBERT", 0L, true);
1307 
                createTableVille.addLongColumn("POPULATION", 0L, true);
1308 
                try {
1309 
                    root.getBase().getDataSource().execute(createTableVille.asString());
1310 
                    insertUndef(createTableVille);
1311 
                    root.refetchTable("VILLE");
1312 
                    root.getSchema().updateVersion();
1313 
                } catch (SQLException ex2) {
1314 
                    throw new IllegalStateException("Erreur lors de la création de la table " + "VILLE", ex2);
1315 
                }
1316 
            }
1317 
 
1318 
            if (root.getTable("ARTICLE_PRIX_MIN_VENTE") == null) {
1319 
                final SQLCreateTable createTablePrixMin = new SQLCreateTable(root, "ARTICLE_PRIX_MIN_VENTE");
1320 
                createTablePrixMin.addForeignColumn("ARTICLE");
1321 
                createTablePrixMin.addIntegerColumn("QTE", 1);
1322 
                createTablePrixMin.addDecimalColumn("PRIX", 16, 8, BigDecimal.ZERO, true);
1323 
                createTablePrixMin.addDateAndTimeColumn("DATE");
1324 
                try {
1325 
                    root.getBase().getDataSource().execute(createTablePrixMin.asString());
1326 
                    insertUndef(createTablePrixMin);
1327 
                    root.refetchTable("ARTICLE_PRIX_MIN_VENTE");
1328 
                    root.getSchema().updateVersion();
1329 
                } catch (SQLException ex2) {
1330 
                    throw new IllegalStateException("Erreur lors de la création de la table " + "ARTICLE_PRIX_MIN_VENTE", ex2);
1331 
                }
1332 
            }
1333 
 
1334 
            {
1335 
                final SQLTable tableTarifAgence = root.getTable("TARIF_AGENCE");
1336 
                AlterTable tTarifAgence = new AlterTable(tableTarifAgence);
1337 
                boolean updateTarifAgence = false;
1338 
 
1339 
                if (!tableTarifAgence.contains("PRC_AGENCE")) {
1340 
                    updateTarifAgence = true;
1341 
                    tTarifAgence.addDecimalColumn("PRC_AGENCE", 16, 8, BigDecimal.ZERO, true);
1342 
                }
1343 
                if (!tableTarifAgence.contains("CLOSED_KIT")) {
1344 
                    updateTarifAgence = true;
1345 
                    tTarifAgence.addBooleanColumn("CLOSED_KIT", false, true);
1346 
                }
1347 
                if (!tableTarifAgence.contains("PRIX_MIN_VENTE")) {
1348 
                    updateTarifAgence = true;
1349 
                    tTarifAgence.addDecimalColumn("PRIX_MIN_VENTE", 16, 8, BigDecimal.ZERO, true);
1350 
                }
1351 
 
1352 
                if (updateTarifAgence) {
1353 
                    tableTarifAgence.getBase().getDataSource().execute(tTarifAgence.asString());
1354 
                    tableTarifAgence.getSchema().updateVersion();
1355 
                    tableTarifAgence.fetchFields();
1356 
                }
1357 
            }
1358 
            {
1359 
                final SQLTable tableClient = root.getTable("CLIENT");
1360 
                AlterTable tClient = new AlterTable(tableClient);
1361 
                boolean updateClient = false;
1362 
 
1363 
                if (!tableClient.contains("ALG_REGISTRE")) {
1364 
                    updateClient = true;
1365 
                    tClient.addVarCharColumn("ALG_REGISTRE", 512);
1366 
                }
1367 
                if (!tableClient.contains("ALG_MATRICULE")) {
1368 
                    updateClient = true;
1369 
                    tClient.addVarCharColumn("ALG_MATRICULE", 512);
1370 
                }
1371 
                if (!tableClient.contains("ALG_ARTICLE")) {
1372 
                    updateClient = true;
1373 
                    tClient.addVarCharColumn("ALG_ARTICLE", 512);
1374 
                }
1375 
 
1376 
                if (updateClient) {
1377 
                    tableClient.getBase().getDataSource().execute(tClient.asString());
1378 
                    tableClient.getSchema().updateVersion();
1379 
                    tableClient.fetchFields();
1380 
                }
1381 
            }
1382 
            final SQLTable tableMvtStock = root.getTable("MOUVEMENT_STOCK");
1383 
 
1384 
            if (!tableMvtStock.contains("PRICE")) {
1385 
                AlterTable tMvt = new AlterTable(tableMvtStock);
1386 
                tMvt.addDecimalColumn("PRICE", 16, 6, BigDecimal.ZERO, true);
1387 
                tableMvtStock.getBase().getDataSource().execute(tMvt.asString());
1388 
                tableMvtStock.getSchema().updateVersion();
1389 
                tableMvtStock.fetchFields();
1390 
            }
1391 
 
1392 
            final SQLTable tableArticle = root.getTable("ARTICLE");
1393 
 
1394 
            if (!tableArticle.contains("AUTO_PRIX_MIN_VENTE_NOMENCLATURE")) {
1395 
                AlterTable tArt = new AlterTable(tableArticle);
1396 
                tArt.addBooleanColumn("AUTO_PRIX_MIN_VENTE_NOMENCLATURE", false, true);
1397 
                tableMvtStock.getBase().getDataSource().execute(tArt.asString());
1398 
                tableMvtStock.getSchema().updateVersion();
1399 
                tableMvtStock.fetchFields();
1400 
            }
1401 
            SQLTable tableContact = root.getTable("CONTACT");
1402 
            if (!tableContact.contains("TYPE")) {
1403 
                AlterTable t = new AlterTable(tableContact);
1404 
                t.addVarCharColumn("TYPE", 256);
1405 
                t.addVarCharColumn("SERVICE", 256);
1406 
                t.addVarCharColumn("PAYS", 256);
1407 
                t.addForeignColumn("ID_ADRESSE", root.getTable("ADRESSE"));
1408 
                tableContact.getBase().getDataSource().execute(t.asString());
1409 
                tableContact.getSchema().updateVersion();
1410 
                tableContact.fetchFields();
1411 
            }
1412 
 
1413 
            if (!root.contains("PERSONNEL_AFHYMAT")) {
1414 
                final SQLCreateTable createTablePers = new SQLCreateTable(root, "PERSONNEL_AFHYMAT");
1415 
                createTablePers.addVarCharColumn("NOM", 256);
1416 
                createTablePers.addVarCharColumn("PRENOM", 256);
1417 
                createTablePers.addVarCharColumn("FONCTION", 256);
1418 
 
1419 
                try {
1420 
                    root.getBase().getDataSource().execute(createTablePers.asString());
1421 
                    insertUndef(createTablePers);
1422 
                    root.refetchTable("PERSONNEL_AFHYMAT");
1423 
                    root.getSchema().updateVersion();
1424 
                } catch (SQLException ex) {
1425 
                    throw new IllegalStateException("Erreur lors de la création de la table " + "PERSONNEL_AFHYMAT", ex);
1426 
                }
1427 
 
1428 
                final SQLCreateTable createTable = new SQLCreateTable(root, "PERSONNEL_AFHYMAT_COUT");
1429 
                for (int i = 1; i <= 12; i++) {
1430 
                    createTable.addDecimalColumn("SAL_MONTH_" + i, 16, 2, BigDecimal.ZERO, false);
1431 
                    createTable.addDecimalColumn("COM_MONTH_" + i, 16, 2, BigDecimal.ZERO, false);
1432 
                }
1433 
                createTable.addIntegerColumn("ANNEE", 0);
1434 
                createTable.addForeignColumn("ID_PERSONNEL_AFHYMAT", root.getTable("PERSONNEL_AFHYMAT"));
1435 
 
1436 
                try {
1437 
                    root.getBase().getDataSource().execute(createTable.asString());
1438 
                    insertUndef(createTable);
1439 
                    root.refetchTable("PERSONNEL_AFHYMAT_COUT");
1440 
                    root.getSchema().updateVersion();
1441 
                } catch (SQLException ex) {
1442 
                    throw new IllegalStateException("Erreur lors de la création de la table " + "PERSONNEL_AFHYMAT_COUT", ex);
1443 
                }
1444 
            }
1445 
 
132 ilm 1446 
            List<String> tablesUiLocked = Arrays.asList("BON_DE_LIVRAISON", "COMMANDE_CLIENT", "SAISIE_VENTE_FACTURE", "AVOIR_CLIENT", "COMMANDE", "BON_RECEPTION", "FACTURE_FOURNISSEUR");
1447 
            for (String tableName : tablesUiLocked) {
1448 
                final SQLTable table = root.getTable(tableName);
1449 
                AlterTable t = new AlterTable(table);
1450 
                if (!table.contains("UI_LOCK")) {
1451 
                    t.addVarCharColumn("UI_LOCK", 512);
1452 
                    t.addForeignColumn("ID_USER_UI_LOCK", root.findTable("USER_COMMON"));
1453 
                    table.getBase().getDataSource().execute(t.asString());
1454 
                    table.getSchema().updateVersion();
1455 
                    table.fetchFields();
1456 
                }
1457 
 
1458 
            }
1459 
 
1460 
            if (!root.contains("RELIQUAT_BL")) {
1461 
                final SQLCreateTable createTable = new SQLCreateTable(root, "RELIQUAT_BL");
1462 
                createTable.addForeignColumn("ARTICLE");
1463 
                createTable.addForeignColumn("ID_BON_DE_LIVRAISON_ORIGINE", root.getTable("BON_DE_LIVRAISON"));
1464 
                createTable.addForeignColumn("ID_BON_DE_LIVRAISON", root.getTable("BON_DE_LIVRAISON"));
1465 
                createTable.addForeignColumn("ID_BON_DE_LIVRAISON_ELEMENT", root.getTable("BON_DE_LIVRAISON_ELEMENT"));
1466 
                createTable.addIntegerColumn("QTE", 1);
1467 
                createTable.addDecimalColumn("QTE_UNITAIRE", 16, 6, BigDecimal.valueOf(1), false);
1468 
                createTable.addForeignColumn("UNITE_VENTE");
1469 
 
1470 
                try {
1471 
                    root.getBase().getDataSource().execute(createTable.asString());
1472 
                    insertUndef(createTable);
1473 
                    root.refetchTable("RELIQUAT_BL");
1474 
                    root.getSchema().updateVersion();
1475 
                } catch (SQLException ex) {
1476 
                    throw new IllegalStateException("Erreur lors de la création de la table " + "RELIQUAT_BL", ex);
1477 
                }
1478 
            }
1479 
 
1480 
            if (!root.getTable("ARTICLE").contains("TRANSPORT")) {
1481 
                AlterTable alterArticle = new AlterTable(tableArticle);
1482 
                alterArticle.addBooleanColumn("TRANSPORT", false, false);
1483 
                tableArticle.getBase().getDataSource().execute(alterArticle.asString());
1484 
                tableArticle.getSchema().updateVersion();
1485 
                tableArticle.fetchFields();
1486 
            }
1487 
 
1488 
            if (!root.contains("RELIQUAT_BR")) {
1489 
                final SQLCreateTable createTable = new SQLCreateTable(root, "RELIQUAT_BR");
1490 
                createTable.addForeignColumn("ARTICLE");
1491 
                createTable.addForeignColumn("ID_BON_RECEPTION_ORIGINE", root.getTable("BON_RECEPTION"));
1492 
                createTable.addForeignColumn("ID_BON_RECEPTION", root.getTable("BON_RECEPTION"));
1493 
                createTable.addForeignColumn("ID_BON_RECEPTION_ELEMENT", root.getTable("BON_RECEPTION_ELEMENT"));
1494 
                createTable.addIntegerColumn("QTE", 1);
1495 
                createTable.addDecimalColumn("QTE_UNITAIRE", 16, 6, BigDecimal.valueOf(1), false);
1496 
                createTable.addForeignColumn("UNITE_VENTE");
1497 
 
1498 
                try {
1499 
                    root.getBase().getDataSource().execute(createTable.asString());
1500 
                    insertUndef(createTable);
1501 
                    root.refetchTable("RELIQUAT_BL");
1502 
                    root.getSchema().updateVersion();
1503 
                } catch (SQLException ex) {
1504 
                    throw new IllegalStateException("Erreur lors de la création de la table " + "RELIQUAT_BR", ex);
1505 
                }
1506 
            }
1507 
 
1508 
            {
1509 
                if (root.getName().endsWith("54")) {
1510 
                    AlterTable tArt = new AlterTable(tableArticle);
1511 
                    if (!tableArticle.contains("LABEL_DOUANE")) {
1512 
                        tArt.addVarCharColumn("LABEL_DOUANE", 512);
1513 
                        tableArticle.getBase().getDataSource().execute(tArt.asString());
1514 
                        tableArticle.getSchema().updateVersion();
1515 
                        tableArticle.fetchFields();
1516 
                    }
1517 
                }
1518 
            }
1519 
 
1520 
            {
1521 
                final SQLTable tableFour = root.getTable("FOURNISSEUR");
1522 
                AlterTable tFour = new AlterTable(tableFour);
1523 
                boolean updateFour = false;
1524 
 
1525 
                if (!tableFour.contains("ALG_REGISTRE")) {
1526 
                    updateFour = true;
1527 
                    tFour.addVarCharColumn("ALG_REGISTRE", 512);
1528 
                }
1529 
                if (!tableFour.contains("ALG_MATRICULE")) {
1530 
                    updateFour = true;
1531 
                    tFour.addVarCharColumn("ALG_MATRICULE", 512);
1532 
                }
1533 
                if (!tableFour.contains("ALG_ARTICLE")) {
1534 
                    updateFour = true;
1535 
                    tFour.addVarCharColumn("ALG_ARTICLE", 512);
1536 
                }
1537 
 
1538 
                if (updateFour) {
1539 
                    tableFour.getBase().getDataSource().execute(tFour.asString());
1540 
                    tableFour.getSchema().updateVersion();
1541 
                    tableFour.fetchFields();
1542 
                }
1543 
            }
1544 
 
1545 
        }
1546 
 
1547 
        if (root.getTable("COEFF_PRIME") == null) {
1548 
            final SQLCreateTable createTable = new SQLCreateTable(root, "COEFF_PRIME");
1549 
            // TODO numeric to real
1550 
            createTable.addColumn("PRIME_PERSO", "real DEFAULT 0");
1551 
            createTable.addColumn("PRIME_RECONSTRUCTION", "real DEFAULT 0");
1552 
            createTable.addColumn("PRIME_ANCIENNETE", "real DEFAULT 0");
1553 
            createTable.addColumn("PRIME_DEROULEMENT", "real DEFAULT 0");
1554 
 
1555 
            try {
1556 
                root.getDBSystemRoot().getDataSource().execute(createTable.asString());
1557 
                insertUndef(createTable);
1558 
                root.refetchTable("COEFF_PRIME");
1559 
                root.getSchema().updateVersion();
1560 
            } catch (SQLException ex) {
1561 
                throw new IllegalStateException("Erreur lors de la création de la table " + "COEFF_PRIME", ex);
1562 
            }
1563 
 
1564 
            SQLTable tableInfosSal = root.getTable("INFOS_SALARIE_PAYE");
1565 
            if (!tableInfosSal.contains("ID_COEFF_PRIME")) {
1566 
                AlterTable t = new AlterTable(tableInfosSal);
1567 
                t.addForeignColumn("ID_COEFF_PRIME", root.getTable("COEFF_PRIME"));
1568 
 
1569 
                try {
1570 
 
1571 
                    tableInfosSal.getBase().getDataSource().execute(t.asString());
1572 
                    tableInfosSal.getSchema().updateVersion();
1573 
                    tableInfosSal.fetchFields();
1574 
                } catch (SQLException ex) {
1575 
                    throw new IllegalStateException("Erreur lors de l'ajout des champs à la table " + tableInfosSal.getName(), ex);
1576 
                }
1577 
            }
1578 
        }
1579 
 
142 ilm 1580 
        SQLTable tableInfosSal = root.getTable("INFOS_SALARIE_PAYE");
1581 
        if (!tableInfosSal.contains("ID_SALARIE")) {
1582 
            // Ajout INFOS_SALARIE_PAYE.ID_SALARIE
1583 
            AlterTable t = new AlterTable(tableInfosSal);
1584 
            t.addForeignColumn("ID_SALARIE", root.getTable("SALARIE"));
1585 
 
1586 
            try {
1587 
 
1588 
                tableInfosSal.getBase().getDataSource().execute(t.asString());
1589 
                tableInfosSal.getSchema().updateVersion();
1590 
                tableInfosSal.fetchFields();
1591 
            } catch (SQLException ex) {
1592 
                throw new IllegalStateException("Erreur lors de l'ajout des champs à la table " + tableInfosSal.getName(), ex);
1593 
            }
1594 
 
1595 
            // Ajout CONTRAT.DEBUT_CONTRAT
1596 
            SQLTable tableContrat = root.getTable("CONTRAT_SALARIE");
1597 
            AlterTable tContrat = new AlterTable(tableContrat);
1598 
            tContrat.addDateAndTimeColumn("DATE_DEBUT");
1599 
            tContrat.addDateAndTimeColumn("DATE_MODIFICATION");
1600 
            // tContrat.addForeignColumn("ID_INFOS_SALARIE_PAYE_MODIFIE", tableInfosSal);
1601 
            try {
1602 
                tableContrat.getBase().getDataSource().execute(tContrat.asString());
1603 
                tableContrat.getSchema().updateVersion();
1604 
                tableContrat.fetchFields();
1605 
            } catch (SQLException ex) {
1606 
                throw new IllegalStateException("Erreur lors de l'ajout des champs à la table " + tableContrat.getName(), ex);
1607 
            }
1608 
 
1609 
            // Ajout FICHE_PAYE.INFOS_SALARIE_PAYE
1610 
            SQLTable tableFichePaye = root.getTable("FICHE_PAYE");
1611 
            AlterTable tFicheSal = new AlterTable(tableFichePaye);
1612 
            tFicheSal.addForeignColumn("ID_INFOS_SALARIE_PAYE", root.getTable("INFOS_SALARIE_PAYE"));
1613 
            try {
1614 
 
1615 
                tableFichePaye.getBase().getDataSource().execute(tFicheSal.asString());
1616 
                tableFichePaye.getSchema().updateVersion();
1617 
                tableFichePaye.fetchFields();
1618 
            } catch (SQLException ex) {
1619 
                throw new IllegalStateException("Erreur lors de l'ajout des champs à la table " + tableFichePaye.getName(), ex);
1620 
            }
1621 
 
1622 
            {
1623 
                // Mise à jour des dates de début de contrat
1624 
                UpdateBuilder builderContrat = new UpdateBuilder(tableContrat);
1625 
                builderContrat.addBackwardVirtualJoin(tableInfosSal, "ID_CONTRAT_SALARIE");
1626 
                builderContrat.setFromVirtualJoinField("DATE_DEBUT", tableInfosSal.getAlias(), "DATE_ARRIVE");
1627 
                tableInfosSal.getDBSystemRoot().getDataSource().execute(builderContrat.asString());
1628 
            }
1629 
            {
1630 
                // Mise à jour des INFOS_SALARIE_PAYE dans les fiches
1631 
                SQLTable tableSalarie = root.getTable("SALARIE");
1632 
                UpdateBuilder builderFiche = new UpdateBuilder(tableFichePaye);
1633 
                builderFiche.addForwardVirtualJoin(tableSalarie, "ID_SALARIE");
1634 
                builderFiche.setFromVirtualJoinField("ID_INFOS_SALARIE_PAYE", tableSalarie.getAlias(), "ID_INFOS_SALARIE_PAYE");
1635 
                tableInfosSal.getDBSystemRoot().getDataSource().execute(builderFiche.asString());
1636 
            }
1637 
        }
1638 
 
132 ilm 1639 
        // Cumuls paye
1640 
        SQLTable tableCumulsPaye = root.getTable("CUMULS_PAYE");
1641 
 
1642 
        AlterTable tCumuls = new AlterTable(tableCumulsPaye);
1643 
        tCumuls.alterColumn("NET_IMP_C", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
1644 
        tCumuls.alterColumn("COT_PAT_C", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
1645 
        tCumuls.alterColumn("COT_SAL_C", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
1646 
        tCumuls.alterColumn("SAL_BRUT_C", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
1647 
        tCumuls.alterColumn("NET_A_PAYER_C", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
1648 
        tCumuls.alterColumn("CSG_C", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
142 ilm 1649 
        if (tableCumulsPaye.contains("HEURE_TRAV") && !tableCumulsPaye.contains("HEURE_TRAV_C")) {
1650 
 
1651 
            AlterTable tColumnNameCumuls = new AlterTable(tableCumulsPaye);
1652 
 
1653 
            tColumnNameCumuls.addClause(new DeferredClause() {
1654 
                @Override
1655 
                public String asString(ChangeTable<?> ct, SQLName tableName) {
1656 
                    return (root.getServer().getSQLSystem() == SQLSystem.POSTGRESQL ? "RENAME COLUMN \"HEURE_TRAV\" TO \"HEURE_TRAV_C\"" : "ALTER COLUMN \"HEURE_TRAV\" RENAME TO \"HEURE_TRAV_C\"");
1657 
                }
1658 
 
1659 
                @Override
1660 
                public ClauseType getType() {
1661 
                    return ClauseType.OTHER;
1662 
                }
1663 
            });
1664 
            try {
1665 
 
1666 
                tableCumulsPaye.getBase().getDataSource().execute(tColumnNameCumuls.asString());
1667 
                tableCumulsPaye.getSchema().updateVersion();
1668 
                tableCumulsPaye.fetchFields();
1669 
            } catch (SQLException ex) {
1670 
                throw new IllegalStateException("Erreur lors de la modification du champ de la table " + tableCumulsPaye.getName(), ex);
1671 
            }
1672 
        } else if (!tableCumulsPaye.contains("HEURE_TRAV_C")) {
1673 
            tCumuls.addDecimalColumn("HEURE_TRAV_C", 16, 2, BigDecimal.ZERO, false);
132 ilm 1674 
        }
142 ilm 1675 
 
132 ilm 1676 
        try {
1677 
 
1678 
            tableCumulsPaye.getBase().getDataSource().execute(tCumuls.asString());
1679 
            tableCumulsPaye.getSchema().updateVersion();
1680 
            tableCumulsPaye.fetchFields();
1681 
        } catch (SQLException ex) {
1682 
            throw new IllegalStateException("Erreur lors de la modification des champs de la table " + tableCumulsPaye.getName(), ex);
1683 
        }
1684 
 
1685 
        // element paye
1686 
        SQLTable tableElementPaye = root.getTable("FICHE_PAYE_ELEMENT");
1687 
 
1688 
        AlterTable tEltPaye = new AlterTable(tableElementPaye);
1689 
        tEltPaye.alterColumn("TAUX_PAT", EnumSet.allOf(Properties.class), "numeric(16,6)", "0", true);
1690 
        tEltPaye.alterColumn("MONTANT_SAL_AJ", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
1691 
        tEltPaye.alterColumn("TAUX_SAL", EnumSet.allOf(Properties.class), "numeric(16,6)", "0", true);
1692 
        tEltPaye.alterColumn("MONTANT_SAL_DED", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
1693 
        tEltPaye.alterColumn("MONTANT_PAT", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
1694 
        tEltPaye.alterColumn("NB_BASE", EnumSet.allOf(Properties.class), "numeric(16,6)", "0", true);
1695 
 
1696 
        try {
1697 
 
1698 
            tableElementPaye.getBase().getDataSource().execute(tEltPaye.asString());
1699 
            tableElementPaye.getSchema().updateVersion();
1700 
            tableElementPaye.fetchFields();
1701 
        } catch (SQLException ex) {
1702 
            throw new IllegalStateException("Erreur lors de la modification des champs de la table " + tableElementPaye.getName(), ex);
1703 
        }
1704 
 
1705 
        // paye
1706 
        SQLTable tablePaye = root.getTable("FICHE_PAYE");
1707 
 
1708 
        AlterTable tPaye = new AlterTable(tablePaye);
1709 
        tPaye.alterColumn("ACOMPTE", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
1710 
        tPaye.alterColumn("NET_IMP", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
1711 
        tPaye.alterColumn("COT_PAT", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
1712 
        tPaye.alterColumn("NET_A_PAYER", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
1713 
        tPaye.alterColumn("SAL_BRUT", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
1714 
        tPaye.alterColumn("CSG", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
1715 
        tPaye.alterColumn("COT_SAL", EnumSet.allOf(Properties.class), "numeric(16,2)", "0", true);
1716 
 
1717 
        try {
1718 
            tablePaye.getBase().getDataSource().execute(tPaye.asString());
1719 
            tablePaye.getSchema().updateVersion();
1720 
            tablePaye.fetchFields();
1721 
        } catch (SQLException ex) {
1722 
            throw new IllegalStateException("Erreur lors de la modification des champs de la table " + tablePaye.getName(), ex);
1723 
        }
1724 
 
1725 
        if (root.getTable("ARTICLE_ELEMENT") == null) {
1726 
            final SQLCreateTable createTable = new SQLCreateTable(root, "ARTICLE_ELEMENT");
1727 
            createTable.addForeignColumn("ARTICLE");
1728 
            createTable.addForeignColumn("ID_ARTICLE_PARENT", root.getTable("ARTICLE"));
1729 
            createTable.addIntegerColumn("QTE", 1);
1730 
            createTable.addDecimalColumn("QTE_UNITAIRE", 16, 6, BigDecimal.valueOf(1), false);
1731 
            createTable.addForeignColumn("UNITE_VENTE");
1732 
            try {
1733 
                root.getBase().getDataSource().execute(createTable.asString());
1734 
                insertUndef(createTable);
1735 
                root.refetchTable("ARTICLE_ELEMENT");
1736 
                root.getSchema().updateVersion();
1737 
            } catch (SQLException ex) {
1738 
                throw new IllegalStateException("Erreur lors de la création de la table " + "ARTICLE_ELEMENT", ex);
1739 
            }
1740 
        }
1741 
 
1742 
        if (root.getTable("VILLE") == null) {
1743 
            final SQLCreateTable createTable = new SQLCreateTable(root, "VILLE");
1744 
            createTable.addLongColumn("X_LAMBERT", 0L, true);
1745 
            createTable.addLongColumn("Y_LAMBERT", 0L, true);
1746 
            createTable.addLongColumn("POPULATION", 0L, true);
1747 
            createTable.addVarCharColumn("NOM", 512);
1748 
            createTable.addVarCharColumn("CODE_POSTAL", 256);
1749 
            try {
1750 
                root.getBase().getDataSource().execute(createTable.asString());
1751 
                insertUndef(createTable);
1752 
                root.refetchTable("VILLE");
1753 
                root.getSchema().updateVersion();
1754 
            } catch (SQLException ex) {
1755 
                throw new IllegalStateException("Erreur lors de la création de la table " + "VILLE", ex);
1756 
            }
1757 
        }
1758 
 
94 ilm 1759 
        // Gestion des différentes numérotation
1760 
        if (!root.getTable("NUMEROTATION_AUTO").contains("NOM")) {
132 ilm 1761 
            final SQLTable tableNum = root.getTable("NUMEROTATION_AUTO");
1762 
            AlterTable tNum = new AlterTable(tableNum);
94 ilm 1763 
            tNum.addColumn("NOM", "varchar (256)", "'Standard'", true);
1764 
 
1765 
            root.getBase().getDataSource().execute(tNum.asString());
132 ilm 1766 
            tableNum.fetchFields();
94 ilm 1767 
            root.getSchema().updateVersion();
132 ilm 1768 
 
94 ilm 1769 
        }
1770 
 
1771 
        // Gestion du timbre fiscal
1772 
        if (!root.getTable("CLIENT").contains("TIMBRE_FISCAL")) {
1773 
            AlterTable tClient = new AlterTable(root.getTable("CLIENT"));
1774 
            tClient.addBooleanColumn("TIMBRE_FISCAL", Boolean.FALSE, false);
1775 
            root.getBase().getDataSource().execute(tClient.asString());
1776 
            root.getSchema().updateVersion();
1777 
        }
132 ilm 1778 
        // Obsolete
1779 
        if (!root.getTable("CLIENT").contains("OBSOLETE")) {
1780 
            AlterTable tClient = new AlterTable(root.getTable("CLIENT"));
1781 
            tClient.addBooleanColumn("OBSOLETE", Boolean.FALSE, false);
1782 
            root.getBase().getDataSource().execute(tClient.asString());
1783 
            root.getSchema().updateVersion();
1784 
        }
94 ilm 1785 
 
132 ilm 1786 
        // Relance
1787 
        if (!root.getTable("RELANCE").contains("ID_ECHEANCE_CLIENT")) {
1788 
            AlterTable tRelance = new AlterTable(root.getTable("RELANCE"));
1789 
            tRelance.addForeignColumn("ID_ECHEANCE_CLIENT", root.getTable("ECHEANCE_CLIENT"));
1790 
            root.getBase().getDataSource().execute(tRelance.asString());
1791 
            root.getSchema().updateVersion();
1792 
        }
1793 
 
1794 
        if (!root.getTable("AVOIR_CLIENT_ELEMENT").contains("RETOUR_STOCK")) {
1795 
            final SQLTable tableAvoirElt = root.getTable("AVOIR_CLIENT_ELEMENT");
1796 
            AlterTable tAvoir = new AlterTable(tableAvoirElt);
1797 
            tAvoir.addBooleanColumn("RETOUR_STOCK", Boolean.FALSE, false);
1798 
            root.getBase().getDataSource().execute(tAvoir.asString());
1799 
            root.getSchema().updateVersion();
1800 
            tableAvoirElt.fetchFields();
1801 
        }
1802 
 
94 ilm 1803 
        final SQLTable tableVenteFacture = root.getTable("SAISIE_VENTE_FACTURE");
1804 
        AlterTable tFacture = new AlterTable(tableVenteFacture);
1805 
        boolean alterFacture = false;
1806 
        boolean upNET = false;
1807 
        if (!tableVenteFacture.contains("SOUMIS_TIMBRE_FISCAL")) {
1808 
            tFacture.addBooleanColumn("SOUMIS_TIMBRE_FISCAL", Boolean.FALSE, true);
1809 
            alterFacture = true;
1810 
        }
1811 
        if (!tableVenteFacture.contains("TAUX_TIMBRE_FISCAL")) {
1812 
            tFacture.addDecimalColumn("TAUX_TIMBRE_FISCAL", 16, 4, BigDecimal.ONE, true);
1813 
            alterFacture = true;
1814 
        }
1815 
        if (!tableVenteFacture.contains("TOTAL_TIMBRE_FISCAL")) {
1816 
            tFacture.addLongColumn("TOTAL_TIMBRE_FISCAL", 0L, true);
1817 
            alterFacture = true;
1818 
        }
1819 
        if (!tableVenteFacture.contains("NET_A_PAYER")) {
1820 
            tFacture.addLongColumn("NET_A_PAYER", 0L, true);
1821 
            alterFacture = true;
1822 
            upNET = true;
1823 
        }
1824 
        if (alterFacture) {
1825 
            root.getBase().getDataSource().execute(tFacture.asString());
1826 
            root.getSchema().updateVersion();
1827 
            tableVenteFacture.fetchFields();
1828 
            if (upNET) {
1829 
                String req = "UPDATE " + tableVenteFacture.getSQLName().quote() + " SET \"NET_A_PAYER\"=(\"T_TTC\"-\"T_AVOIR_TTC\")";
1830 
                root.getBase().getDataSource().execute(req);
1831 
            }
1832 
        }
1833 
 
1834 
        SQLTable tableTaxe = root.getTable("TAXE");
1835 
        boolean updateTaxe = false;
1836 
        AlterTable tTaxe = new AlterTable(tableTaxe);
1837 
        if (!tableTaxe.contains("ID_COMPTE_PCE_VENTE")) {
1838 
            tTaxe.addForeignColumn("ID_COMPTE_PCE_VENTE", root.getTable("COMPTE_PCE"));
1839 
            updateTaxe = true;
1840 
        }
1841 
        if (!tableTaxe.contains("ID_COMPTE_PCE_VENTE_SERVICE")) {
1842 
            tTaxe.addForeignColumn("ID_COMPTE_PCE_VENTE_SERVICE", root.getTable("COMPTE_PCE"));
1843 
            updateTaxe = true;
1844 
        }
1845 
 
1846 
        if (updateTaxe) {
1847 
            try {
1848 
                tableTaxe.getBase().getDataSource().execute(tTaxe.asString());
1849 
                tableTaxe.getSchema().updateVersion();
1850 
                tableTaxe.fetchFields();
1851 
            } catch (SQLException ex) {
1852 
                throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table TAXE", ex);
1853 
            }
1854 
 
1855 
        }
1856 
 
1857 
        // Tarification par quantite
1858 
        if (root.getTable("TARIF_QUANTITE") == null) {
1859 
            final SQLCreateTable createTableQtyTarif = new SQLCreateTable(root, "TARIF_QUANTITE");
1860 
            createTableQtyTarif.addForeignColumn("ID_ARTICLE", root.getTable("ARTICLE"));
1861 
            createTableQtyTarif.addDecimalColumn("QUANTITE", 16, 3, BigDecimal.ONE, false);
1862 
            createTableQtyTarif.addDecimalColumn("POURCENT_REMISE", 16, 3, null, true);
1863 
            createTableQtyTarif.addDecimalColumn("PRIX_METRIQUE_VT_1", 16, 6, null, true);
1864 
            try {
1865 
                root.getBase().getDataSource().execute(createTableQtyTarif.asString());
1866 
                insertUndef(createTableQtyTarif);
1867 
                root.refetchTable("TARIF_QUANTITE");
1868 
                root.getSchema().updateVersion();
1869 
            } catch (SQLException ex) {
1870 
                throw new IllegalStateException("Erreur lors de la création de la table " + "TARIF_QUANTITE", ex);
1871 
            }
1872 
        }
1873 
        // Articles fournisseurs
1874 
        addArticleFournisseur(root);
1875 
 
1876 
        SQLTable tableCmdF = root.getTable("COMMANDE");
1877 
        if (!tableCmdF.contains("ID_MODELE")) {
1878 
            AlterTable t = new AlterTable(tableCmdF);
1879 
            t.addForeignColumn("ID_MODELE", root.getTable("MODELE"));
1880 
            tableCmdF.getBase().getDataSource().execute(t.asString());
1881 
            tableCmdF.getSchema().updateVersion();
1882 
            tableCmdF.fetchFields();
1883 
        }
1884 
 
1885 
        SQLTable tableArtF = root.getTable("ARTICLE_FOURNISSEUR");
1886 
        if (!tableArtF.contains("ID_FAMILLE_ARTICLE")) {
1887 
            AlterTable t = new AlterTable(tableArtF);
1888 
            t.addForeignColumn("ID_FAMILLE_ARTICLE", root.getTable("FAMILLE_ARTICLE"));
1889 
            tableArtF.getBase().getDataSource().execute(t.asString());
1890 
            tableArtF.getSchema().updateVersion();
1891 
            tableArtF.fetchFields();
1892 
        }
1893 
 
1894 
        if (!tableCmdF.contains("DATE_RECEPTION_DEMANDEE")) {
1895 
            AlterTable t = new AlterTable(tableCmdF);
1896 
            t.addColumn("DATE_RECEPTION_DEMANDEE", "date");
1897 
            t.addColumn("DATE_RECEPTION_CONFIRMEE", "date");
1898 
            tableCmdF.getBase().getDataSource().execute(t.asString());
1899 
            tableCmdF.getSchema().updateVersion();
1900 
            tableCmdF.fetchFields();
1901 
        }
1902 
 
1903 
        SQLTable tableEcr = root.getTable("ECRITURE");
1904 
        if (!tableEcr.contains("NOM_PIECE")) {
1905 
            AlterTable t = new AlterTable(tableEcr);
1906 
            t.addVarCharColumn("NOM_PIECE", 1024);
1907 
            tableEcr.getBase().getDataSource().execute(t.asString());
1908 
            tableEcr.getSchema().updateVersion();
1909 
            tableEcr.fetchFields();
1910 
        }
1911 
 
1912 
        SQLTable tableKm = root.getTable("SAISIE_KM_ELEMENT");
1913 
        if (!tableKm.contains("NOM_PIECE")) {
1914 
            AlterTable t = new AlterTable(tableKm);
1915 
            t.addVarCharColumn("NOM_PIECE", 1024);
1916 
 
1917 
            tableKm.getBase().getDataSource().execute(t.asString());
1918 
            tableKm.getSchema().updateVersion();
1919 
            tableKm.fetchFields();
1920 
        }
1921 
 
1922 
        {
1923 
            SQLSelect sel = new SQLSelect();
1924 
            final SQLTable tableStyle = root.getTable("STYLE");
1925 
            sel.addSelect(tableStyle.getKey());
1926 
            sel.setWhere(new Where(tableStyle.getField("NOM"), "=", "Composant"));
1927 
            String req = sel.asString();
1928 
            List<Map<String, Object>> l = root.getDBSystemRoot().getDataSource().execute(req);
1929 
 
1930 
            if (l.size() == 0) {
1931 
                SQLRowValues rowValsStyle = new SQLRowValues(tableStyle);
1932 
                rowValsStyle.put("NOM", "Composant");
1933 
                rowValsStyle.put("CODE", "COMP");
1934 
                rowValsStyle.insert();
1935 
            }
1936 
        }
1937 
 
1938 
        {
1939 
            // Fix qté et style
1940 
            List<String> tableElt = Arrays.asList("AVOIR_CLIENT_ELEMENT", "BON_DE_LIVRAISON_ELEMENT", "BON_RECEPTION_ELEMENT", "COMMANDE_CLIENT_ELEMENT", "COMMANDE_ELEMENT", "DEVIS_ELEMENT",
1941 
                    "SAISIE_VENTE_FACTURE_ELEMENT");
1942 
            for (String string : tableElt) {
1943 
                final SQLTable table = root.getTable(string);
1944 
                Number undefined = table.getUndefinedIDNumber();
1945 
                if (undefined != null && undefined.intValue() > 0) {
1946 
                    UpdateBuilder build = new UpdateBuilder(table);
1947 
                    build.setObject("ID_STYLE", 2);
1948 
                    build.setObject("QTE", 1);
1949 
                    build.setWhere(new Where(table.getKey(), "=", undefined.intValue()));
1950 
                    table.getDBSystemRoot().getDataSource().execute(build.asString());
1951 
                }
1952 
            }
1953 
        }
1954 
 
93 ilm 1955 
        // ADresse de livraison et remise
1956 
        {
1957 
            SQLTable tableDevis = root.getTable("DEVIS");
1958 
            addAdresseField(tableDevis, root);
1959 
            addRemiseField(tableDevis, root);
1960 
 
1961 
            SQLTable tableVF = root.getTable("SAISIE_VENTE_FACTURE");
1962 
            addAdresseField(tableVF, root);
1963 
            addRemiseField(tableVF, root);
1964 
 
1965 
            SQLTable tableCmd = root.getTable("COMMANDE_CLIENT");
1966 
            addAdresseField(tableCmd, root);
1967 
            addRemiseField(tableCmd, root);
1968 
 
1969 
            SQLTable tableBon = root.getTable("BON_DE_LIVRAISON");
1970 
            addAdresseField(tableBon, root);
1971 
            addRemiseField(tableBon, root);
1972 
 
1973 
            SQLTable tableAvoir = root.getTable("AVOIR_CLIENT");
1974 
            addAdresseField(tableAvoir, root);
1975 
            addRemiseField(tableAvoir, root);
1976 
        }
1977 
        // Service client
1978 
        if (root.getTable("CLIENT_DEPARTEMENT") == null) {
1979 
            final SQLCreateTable createTableDpt = new SQLCreateTable(root, "CLIENT_DEPARTEMENT");
1980 
            createTableDpt.addForeignColumn("CLIENT");
1981 
            if (root.contains("ADRESSE")) {
1982 
                createTableDpt.addForeignColumn("ADRESSE");
1983 
            } else {
1984 
                createTableDpt.addForeignColumn("ID_ADRESSE", root.findTable("ADRESSE"));
1985 
            }
1986 
            createTableDpt.addVarCharColumn("INFOS", 2048);
1987 
            createTableDpt.addVarCharColumn("NOM", 256);
1988 
            try {
1989 
                root.getBase().getDataSource().execute(createTableDpt.asString());
1990 
                insertUndef(createTableDpt);
1991 
                root.refetchTable("CLIENT_DEPARTEMENT");
1992 
                root.getSchema().updateVersion();
1993 
            } catch (SQLException ex2) {
1994 
                throw new IllegalStateException("Erreur lors de la création de la table " + "CLIENT_DEPARTEMENT", ex2);
1995 
            }
1996 
        }
1997 
 
83 ilm 1998 
        SQLTable tableVFElt = root.getTable("SAISIE_VENTE_FACTURE_ELEMENT");
1999 
        patchFieldElt1Dot4(tableVFElt, root);
2000 
 
2001 
        SQLTable tableDevisElt = root.getTable("DEVIS_ELEMENT");
2002 
        patchFieldElt1Dot4(tableDevisElt, root);
2003 
 
2004 
        SQLTable tableCmdElt = root.getTable("COMMANDE_CLIENT_ELEMENT");
93 ilm 2005 
 
83 ilm 2006 
        patchFieldElt1Dot4(tableCmdElt, root);
2007 
 
2008 
        SQLTable tableBonElt = root.getTable("BON_DE_LIVRAISON_ELEMENT");
2009 
        patchFieldElt1Dot4(tableBonElt, root);
2010 
 
2011 
        SQLTable tableAvoirElt = root.getTable("AVOIR_CLIENT_ELEMENT");
2012 
        patchFieldElt1Dot4(tableAvoirElt, root);
2013 
 
93 ilm 2014 
        addNiveauElementField(root.getTable("COMMANDE_ELEMENT"));
2015 
        addNiveauElementField(root.getTable("BON_RECEPTION_ELEMENT"));
2016 
        addNiveauElementField(root.getTable("FACTURE_FOURNISSEUR_ELEMENT"));
2017 
 
83 ilm 2018 
        addContact(root);
2019 
 
93 ilm 2020 
        {
2021 
            // Gestion des préparations de commandes
2022 
            final SQLTable tableCommandeClient = root.getTable("COMMANDE_CLIENT");
2023 
            AlterTable tCommandeClient = new AlterTable(tableCommandeClient);
2024 
            boolean updateCmdCli = false;
2025 
 
2026 
            if (!tableCommandeClient.contains("ETAT_COMMANDE")) {
2027 
                updateCmdCli = true;
2028 
                tCommandeClient.addIntegerColumn("ETAT_COMMANDE", EtatCommandeClient.A_PREPARER.getId());
2029 
            }
2030 
            if (!tableCommandeClient.contains("EMBALLAGE")) {
2031 
                updateCmdCli = true;
2032 
                tCommandeClient.addVarCharColumn("EMBALLAGE", 256);
2033 
            }
2034 
            if (!tableCommandeClient.contains("NUMERO_EXPEDITION")) {
2035 
                updateCmdCli = true;
2036 
                tCommandeClient.addVarCharColumn("NUMERO_EXPEDITION", 256);
2037 
            }
2038 
 
2039 
            if (!tableCommandeClient.contains("ID_TAXE_PORT")) {
2040 
                updateCmdCli = true;
2041 
                tCommandeClient.addForeignColumn("ID_TAXE_PORT", root.getTable("TAXE"));
2042 
            }
2043 
 
2044 
            if (!tableCommandeClient.contains("PORT_HT")) {
2045 
                updateCmdCli = true;
2046 
                tCommandeClient.addLongColumn("PORT_HT", Long.valueOf(0), false);
2047 
            }
2048 
 
2049 
            if (!tableCommandeClient.contains("REMISE_HT")) {
2050 
                updateCmdCli = true;
2051 
                tCommandeClient.addLongColumn("REMISE_HT", Long.valueOf(0), false);
2052 
            }
2053 
 
2054 
            if (updateCmdCli) {
2055 
                tableCommandeClient.getBase().getDataSource().execute(tCommandeClient.asString());
2056 
                tableCommandeClient.getSchema().updateVersion();
2057 
                tableCommandeClient.fetchFields();
2058 
            }
2059 
        }
2060 
 
2061 
        {
2062 
            // Gestion des préparations de commandes
2063 
            final SQLTable tableBonL = root.getTable("BON_DE_LIVRAISON");
2064 
            AlterTable tBonL = new AlterTable(tableBonL);
2065 
            boolean updateBonL = false;
2066 
 
2067 
            if (!tableBonL.contains("TOTAL_DEVISE")) {
2068 
                updateBonL = true;
2069 
                tBonL.addLongColumn("TOTAL_DEVISE", Long.valueOf(0), false);
2070 
            }
2071 
 
2072 
            if (!tableBonL.contains("TOTAL_SERVICE")) {
2073 
                updateBonL = true;
2074 
                tBonL.addLongColumn("TOTAL_SERVICE", Long.valueOf(0), false);
2075 
            }
2076 
 
2077 
            if (!tableBonL.contains("ID_TAXE_PORT")) {
2078 
                updateBonL = true;
2079 
                tBonL.addForeignColumn("ID_TAXE_PORT", root.getTable("TAXE"));
2080 
            }
2081 
 
2082 
            if (!tableBonL.contains("PORT_HT")) {
2083 
                updateBonL = true;
2084 
                tBonL.addLongColumn("PORT_HT", Long.valueOf(0), false);
2085 
            }
2086 
 
2087 
            if (!tableBonL.contains("REMISE_HT")) {
2088 
                updateBonL = true;
2089 
                tBonL.addLongColumn("REMISE_HT", Long.valueOf(0), false);
2090 
            }
2091 
 
2092 
            if (updateBonL) {
2093 
                tableBonL.getBase().getDataSource().execute(tBonL.asString());
2094 
                tableBonL.getSchema().updateVersion();
2095 
                tableBonL.fetchFields();
2096 
            }
2097 
        }
2098 
 
2099 
        final List<String> asList = Arrays.asList("SAISIE_VENTE_FACTURE", "BON_RECEPTION", "BON_DE_LIVRAISON");
2100 
        for (String tableVirtualStockName : asList) {
2101 
            SQLTable tableVirtualStock = root.getTable(tableVirtualStockName);
2102 
            if (!tableVirtualStock.contains("CREATE_VIRTUAL_STOCK")) {
2103 
                AlterTable t = new AlterTable(tableVirtualStock);
2104 
                t.addBooleanColumn("CREATE_VIRTUAL_STOCK", Boolean.TRUE, false);
2105 
                tableVirtualStock.getBase().getDataSource().execute(t.asString());
2106 
                tableVirtualStock.getSchema().updateVersion();
2107 
                tableVirtualStock.fetchFields();
2108 
            }
2109 
        }
2110 
 
2111 
        // Remise dans les devis
83 ilm 2112 
        final SQLTable tableDevis = root.getTable("DEVIS");
90 ilm 2113 
        AlterTable tDevis = new AlterTable(tableDevis);
2114 
        boolean updateDevis = false;
93 ilm 2115 
 
90 ilm 2116 
        if (!tableDevis.contains("POURCENT_REMISE")) {
2117 
            updateDevis = true;
2118 
            tDevis.addColumn("POURCENT_REMISE", "numeric (12,8)");
2119 
        }
83 ilm 2120 
        if (!tableDevis.contains("MONTANT_REMISE")) {
90 ilm 2121 
            updateDevis = true;
2122 
            tDevis.addColumn("MONTANT_REMISE", "numeric (16,8)");
2123 
        }
2124 
        if (!tableDevis.contains("T_HA")) {
2125 
            updateDevis = true;
2126 
            tDevis.addColumn("T_HA", "bigint", "0", false);
2127 
        }
93 ilm 2128 
 
2129 
        if (!tableDevis.contains("DUNNING_DATE")) {
2130 
            updateDevis = true;
2131 
            tDevis.addColumn("DUNNING_DATE", "date");
2132 
        }
2133 
 
90 ilm 2134 
        if (updateDevis) {
2135 
            tableDevis.getBase().getDataSource().execute(tDevis.asString());
83 ilm 2136 
            tableDevis.getSchema().updateVersion();
2137 
            tableDevis.fetchFields();
2138 
        }
2139 
 
2140 
        final SQLTable tableKmElt = root.getTable("SAISIE_KM_ELEMENT");
2141 
        if (!tableKmElt.contains("ANALYTIQUE")) {
2142 
            AlterTable t = new AlterTable(tableKmElt);
2143 
            t.addVarCharColumn("ANALYTIQUE", 256);
2144 
            tableKmElt.getBase().getDataSource().execute(t.asString());
2145 
            tableKmElt.getSchema().updateVersion();
2146 
            tableKmElt.fetchFields();
2147 
 
2148 
        }
2149 
 
132 ilm 2150 
        final SQLTable tableClient = root.getTable("CLIENT");
2151 
        final SQLTable tableAdresse = tableClient.getForeignTable("ID_ADRESSE");
90 ilm 2152 
        if (tableAdresse != null) {
83 ilm 2153 
            AlterTable t = new AlterTable(tableAdresse);
90 ilm 2154 
            boolean updateADr = false;
2155 
            if (!tableAdresse.contains("PROVINCE")) {
2156 
                t.addVarCharColumn("PROVINCE", 256);
2157 
                updateADr = true;
2158 
            }
2159 
            if (!tableAdresse.contains("LIBELLE")) {
2160 
                t.addVarCharColumn("LIBELLE", 256);
2161 
                updateADr = true;
2162 
            }
2163 
            if (!tableAdresse.contains("TYPE")) {
2164 
                t.addVarCharColumn("TYPE", 256);
2165 
                updateADr = true;
2166 
            }
2167 
            if (!tableAdresse.contains("EMAIL_CONTACT")) {
2168 
                t.addVarCharColumn("EMAIL_CONTACT", 256);
2169 
                updateADr = true;
2170 
            }
2171 
            if (updateADr) {
2172 
                tableAdresse.getBase().getDataSource().execute(t.asString());
2173 
                tableAdresse.getSchema().updateVersion();
2174 
                tableAdresse.fetchFields();
2175 
            }
83 ilm 2176 
        }
132 ilm 2177 
 
93 ilm 2178 
        if (tableClient != null) {
83 ilm 2179 
            AlterTable t = new AlterTable(tableClient);
93 ilm 2180 
            boolean upClient = false;
142 ilm 2181 
            if (!tableClient.contains("REMIND_DATE")) {
2182 
                t.addDateAndTimeColumn("REMIND_DATE");
2183 
                upClient = true;
2184 
            }
93 ilm 2185 
            if (!tableClient.contains("BLOQUE_LIVRAISON")) {
2186 
                t.addBooleanColumn("BLOQUE_LIVRAISON", false, false);
2187 
                upClient = true;
2188 
            }
83 ilm 2189 
            if (!tableClient.contains("BLOQUE")) {
93 ilm 2190 
                upClient = true;
83 ilm 2191 
                t.addBooleanColumn("BLOQUE", false, false);
2192 
            }
93 ilm 2193 
            if (!tableClient.contains("ID_COMPTE_PCE_SERVICE")) {
2194 
                upClient = true;
2195 
                t.addForeignColumn("ID_COMPTE_PCE_SERVICE", tableClient.getTable("COMPTE_PCE"));
2196 
            }
2197 
 
2198 
            if (!tableClient.contains("ID_COMPTE_PCE_PRODUIT")) {
2199 
                upClient = true;
2200 
                t.addForeignColumn("ID_COMPTE_PCE_PRODUIT", tableClient.getTable("COMPTE_PCE"));
2201 
            }
2202 
 
2203 
            if (!tableClient.contains("ENCOURS_MAX")) {
2204 
                upClient = true;
2205 
                t.addDecimalColumn("ENCOURS_MAX", 16, 2, BigDecimal.valueOf(0), false);
2206 
            }
2207 
            if (!tableClient.contains("CATEGORIES")) {
2208 
                upClient = true;
2209 
                t.addVarCharColumn("CATEGORIES", 2048);
2210 
            }
2211 
            if (!tableClient.contains("NOTE_FINANCIERE")) {
2212 
                upClient = true;
2213 
                t.addVarCharColumn("NOTE_FINANCIERE", 1024);
2214 
            }
2215 
            if (!tableClient.contains("CENTRE_GESTION")) {
2216 
                upClient = true;
2217 
                t.addVarCharColumn("CENTRE_GESTION", 1024);
2218 
            }
2219 
            if (!tableClient.contains("METHODE_RELANCE")) {
2220 
                upClient = true;
2221 
                t.addVarCharColumn("METHODE_RELANCE", 1024);
2222 
            }
2223 
            if (!tableClient.contains("SITE_INTERNET")) {
2224 
                upClient = true;
2225 
                t.addVarCharColumn("SITE_INTERNET", 2048);
2226 
            }
2227 
            if (!tableClient.contains("GROUPE")) {
2228 
                upClient = true;
2229 
                t.addVarCharColumn("GROUPE", 1024);
2230 
            }
2231 
            if (!tableClient.contains("ID_COMMERCIAL")) {
2232 
                upClient = true;
2233 
                t.addForeignColumn("ID_COMMERCIAL", tableClient.getTable("COMMERCIAL"));
2234 
            }
2235 
 
2236 
            if (upClient) {
2237 
                tableClient.getBase().getDataSource().execute(t.asString());
2238 
                tableClient.getSchema().updateVersion();
2239 
                tableClient.fetchFields();
2240 
            }
83 ilm 2241 
        }
93 ilm 2242 
        if (!root.contains("CATEGORIE_CLIENT")) {
2243 
            final SQLCreateTable createCategorieClientTable = new SQLCreateTable(root, "CATEGORIE_CLIENT");
2244 
            createCategorieClientTable.addVarCharColumn("NOM", 1024);
2245 
 
2246 
            try {
2247 
                root.getDBSystemRoot().getDataSource().execute(createCategorieClientTable.asString());
2248 
                insertUndef(createCategorieClientTable);
2249 
                tableDevis.getSchema().updateVersion();
2250 
            } catch (SQLException ex) {
2251 
                throw new IllegalStateException("Erreur lors de la création de la table CATEGORIE_CLIENT", ex);
2252 
            }
2253 
 
2254 
        }
2255 
 
83 ilm 2256 
        final SQLTable tableAssoc = root.getTable("ASSOCIATION_ANALYTIQUE");
2257 
        if (tableAssoc != null && !tableAssoc.contains("GESTION_AUTO")) {
2258 
            AlterTable t = new AlterTable(tableAssoc);
2259 
            t.addBooleanColumn("GESTION_AUTO", false, false);
2260 
            tableAssoc.getBase().getDataSource().execute(t.asString());
2261 
            tableAssoc.getSchema().updateVersion();
2262 
            tableAssoc.fetchFields();
2263 
        }
90 ilm 2264 
        if (!root.contains("CALENDAR_ITEM")) {
2265 
            final SQLCreateTable createTaskGroupTable = new SQLCreateTable(root, "CALENDAR_ITEM_GROUP");
2266 
            createTaskGroupTable.addVarCharColumn("NAME", 1024);
2267 
            createTaskGroupTable.addVarCharColumn("DESCRIPTION", 1024 * 8);
83 ilm 2268 
 
90 ilm 2269 
            final SQLCreateTable createTaskTable = new SQLCreateTable(root, "CALENDAR_ITEM");
2270 
            createTaskTable.addDateAndTimeColumn("START");
2271 
            createTaskTable.addDateAndTimeColumn("END");
2272 
            createTaskTable.addLongColumn("DURATION_S", 0L, false);
2273 
            createTaskTable.addVarCharColumn("SUMMARY", 1024);
2274 
            createTaskTable.addVarCharColumn("DESCRIPTION", 1024 * 8);
2275 
            createTaskTable.addVarCharColumn("FLAGS", 1024);
2276 
            createTaskTable.addVarCharColumn("STATUS", 128);
2277 
            createTaskTable.addForeignColumn(createTaskGroupTable);
2278 
            createTaskTable.addLongColumn("SOURCE_ID", null, true);
2279 
            createTaskTable.addVarCharColumn("SOURCE_TABLE", 256);
142 ilm 2280 
            createTaskTable.addVarCharColumn("UID", 1024);
2281 
            createTaskTable.addVarCharColumn("LOCATION", 4096);
90 ilm 2282 
            try {
2283 
                root.getDBSystemRoot().getDataSource().execute(createTaskGroupTable.asString());
2284 
                insertUndef(createTaskGroupTable);
2285 
                root.getDBSystemRoot().getDataSource().execute(createTaskTable.asString());
2286 
                insertUndef(createTaskTable);
2287 
                tableDevis.getSchema().updateVersion();
142 ilm 2288 
                root.refetchTable("CALENDAR_ITEM_GROUP");
2289 
                root.refetchTable("CALENDAR_ITEM");
2290 
 
90 ilm 2291 
            } catch (SQLException ex) {
2292 
                throw new IllegalStateException("Erreur lors de la création de la table TASK", ex);
2293 
            }
2294 
 
2295 
        }
93 ilm 2296 
 
2297 
        // Remise sur tarif client
94 ilm 2298 
        if (root.contains("ARTICLE_TARIF")) {
2299 
 
93 ilm 2300 
            AlterTable t = new AlterTable(root.getTable("ARTICLE_TARIF"));
94 ilm 2301 
            boolean alterTarif = false;
2302 
            if (!root.getTable("ARTICLE_TARIF").contains("POURCENT_REMISE")) {
2303 
                t.addDecimalColumn("POURCENT_REMISE", 16, 6, BigDecimal.valueOf(0), false);
2304 
                alterTarif = true;
2305 
            }
2306 
 
2307 
            if (!root.getTable("ARTICLE_TARIF").contains("QTE")) {
2308 
                t.addIntegerColumn("QTE", 1);
2309 
                alterTarif = true;
2310 
            }
2311 
            if (alterTarif) {
2312 
                root.getTable("ARTICLE_TARIF").getBase().getDataSource().execute(t.asString());
2313 
                root.getTable("ARTICLE_TARIF").fetchFields();
2314 
                root.getTable("ARTICLE").getSchema().updateVersion();
2315 
            }
93 ilm 2316 
        }
2317 
        // SKU et Type d'expedition
2318 
        final SQLTable articleTable = root.getTable("ARTICLE");
2319 
        if (!articleTable.contains("SKU")) {
2320 
            AlterTable a = new AlterTable(articleTable);
2321 
            a.addVarCharColumn("SKU", 256);
2322 
            try {
2323 
                articleTable.getBase().getDataSource().execute(a.asString());
2324 
                articleTable.getSchema().updateVersion();
2325 
                articleTable.fetchFields();
2326 
            } catch (SQLException ex2) {
2327 
                throw new IllegalStateException("Erreur lors de l'ajout du champs SKU sur la table ARTICLE", ex2);
2328 
            }
2329 
        }
2330 
 
2331 
        try {
2332 
            final SQLTable cmdClientTable = root.getTable("COMMANDE_CLIENT");
2333 
            if (!cmdClientTable.contains("TYPE_EXPEDITION")) {
2334 
                final AlterTable a = new AlterTable(cmdClientTable);
2335 
                a.addVarCharColumn("TYPE_EXPEDITION", 256);
2336 
                cmdClientTable.getBase().getDataSource().execute(a.asString());
2337 
                cmdClientTable.getSchema().updateVersion();
2338 
                cmdClientTable.fetchFields();
2339 
            }
2340 
        } catch (SQLException ex2) {
2341 
            throw new IllegalStateException("Erreur lors de l'ajout du champs TYPE_EXPEDITION sur la table COMMANDE_CLIENT", ex2);
2342 
        }
2343 
        try {
2344 
            final SQLTable axeTable = root.getTable("AXE_ANALYTIQUE");
2345 
            if (!axeTable.contains("TYPE")) {
2346 
                final AlterTable a = new AlterTable(axeTable);
2347 
                a.addVarCharColumn("TYPE", 256);
2348 
                axeTable.getBase().getDataSource().execute(a.asString());
2349 
                axeTable.getSchema().updateVersion();
2350 
                axeTable.fetchFields();
2351 
            }
2352 
        } catch (SQLException ex2) {
2353 
            throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table AXE_ANALYTIQUE", ex2);
2354 
        }
2355 
        // Historique des taux
2356 
        if (!root.contains("DEVISE_HISTORIQUE")) {
2357 
            final SQLCreateTable createTable = new SQLCreateTable(root, "DEVISE_HISTORIQUE");
2358 
            createTable.addDateAndTimeColumn("DATE");
2359 
            createTable.addVarCharColumn("SRC", 8);
2360 
            createTable.addVarCharColumn("DST", 8);
2361 
            createTable.addDecimalColumn("TAUX", 12, 6, new BigDecimal(1), false);
2362 
            createTable.addDecimalColumn("TAUX_COMMERCIAL", 12, 6, new BigDecimal(1), false);
2363 
            try {
2364 
                root.getDBSystemRoot().getDataSource().execute(createTable.asString());
2365 
                insertUndef(createTable);
2366 
                tableDevis.getSchema().updateVersion();
156 ilm 2367 
                root.refetchTable("DEVISE_HISTORIQUE");
93 ilm 2368 
            } catch (SQLException ex) {
2369 
                throw new IllegalStateException("Erreur lors de la création de la table TASK", ex);
2370 
            }
2371 
        }
2372 
 
2373 
        final SQLTable tableContact = root.getTable("CONTACT");
2374 
        if (tableContact != null && !tableContact.contains("NO_MAILING")) {
2375 
            AlterTable t = new AlterTable(tableContact);
2376 
            t.addBooleanColumn("NO_MAILING", false, false);
2377 
            tableContact.getBase().getDataSource().execute(t.asString());
2378 
            tableContact.getSchema().updateVersion();
2379 
            tableContact.fetchFields();
2380 
        }
2381 
 
94 ilm 2382 
        SQLTable tableBonR = root.getTable("FACTURE_FOURNISSEUR");
2383 
        if (!tableBonR.contains("TAUX_APPLIQUE")) {
2384 
            AlterTable t = new AlterTable(tableBonR);
2385 
            t.addDecimalColumn("TAUX_APPLIQUE", 12, 6, BigDecimal.ONE, true);
2386 
            tableBonR.getBase().getDataSource().execute(t.asString());
2387 
            tableBonR.getSchema().updateVersion();
2388 
            tableBonR.fetchFields();
2389 
        }
2390 
        root.getTable("ARTICLE").getSchema().updateVersion();
132 ilm 2391 
        // Valeur par défaut des numérotations
174 ilm 2392 
        if (root.contains("NUMEROTATION_AUTO")) {
2393 
            SQLRow rowNumerotation = root.getTable("NUMEROTATION_AUTO").getRow(2);
2394 
            if (rowNumerotation != null) {
2395 
                SQLRowValues rNumerotation = rowNumerotation.asRowValues();
2396 
                boolean numerotationFixed = false;
2397 
                if (StringUtils.isEmpty(rNumerotation.getString("AVOIR_F_FORMAT"), true)) {
2398 
                    rNumerotation.put("AVOIR_F_FORMAT", "'AVOIR'yyMM-000");
2399 
                    numerotationFixed = true;
2400 
                }
2401 
                if (StringUtils.isEmpty(rNumerotation.getString("CLIENT_FORMAT"), true)) {
2402 
                    rNumerotation.put("CLIENT_FORMAT", "'CLI'00000");
2403 
                    numerotationFixed = true;
2404 
                }
2405 
                if (numerotationFixed) {
2406 
                    rNumerotation.commit();
2407 
                }
2408 
            }
132 ilm 2409 
        }
142 ilm 2410 
        //
2411 
 
2412 
        final SQLTable tableCalendarItem = root.getTable("CALENDAR_ITEM");
2413 
        if (tableCalendarItem != null) {
2414 
            final AlterTable tVF = new AlterTable(tableCalendarItem);
2415 
            boolean needUpdate = false;
2416 
            if (!tableCalendarItem.getFieldsName().contains("UID")) {
2417 
                tVF.addVarCharColumn("UID", 1024);
2418 
                needUpdate = true;
2419 
            }
2420 
            if (!tableCalendarItem.getFieldsName().contains("LOCATION")) {
2421 
                tVF.addVarCharColumn("LOCATION", 4096);
2422 
                needUpdate = true;
2423 
            }
2424 
            if (needUpdate) {
2425 
                try {
2426 
                    tableCalendarItem.getBase().getDataSource().execute(tVF.asString());
2427 
                    tableCalendarItem.getSchema().updateVersion();
2428 
                    tableCalendarItem.fetchFields();
2429 
                } catch (SQLException ex) {
2430 
                    throw new IllegalStateException("Erreur lors de l'ajout de UID sur la table CALENDAR_ITEM", ex);
2431 
                }
2432 
            }
2433 
        }
2434 
 
83 ilm 2435 
    }
2436 
 
2437 
    private void updateStyle(final DBRoot root) throws SQLException {
2438 
        SQLTable style = root.getTable("STYLE");
2439 
        SQLRowValues rowVals = new SQLRowValues(style);
2440 
        rowVals.put("NOM", null);
2441 
        SQLRowValuesListFetcher fetcher = SQLRowValuesListFetcher.create(rowVals);
2442 
        List<SQLRowValues> list = fetcher.fetch();
2443 
        boolean containsInvisible = false;
2444 
        for (SQLRowValues sqlRowValues : list) {
2445 
            if (sqlRowValues.getString("NOM").equals("Invisible")) {
2446 
                containsInvisible = true;
2447 
            }
2448 
        }
2449 
        if (!containsInvisible) {
2450 
            SQLRowValues rowValsStyle = new SQLRowValues(style);
2451 
            rowValsStyle.put("NOM", "Invisible");
2452 
            rowValsStyle.put("CODE", "INV");
2453 
            rowValsStyle.insert();
2454 
        }
2455 
 
2456 
    }
2457 
 
19 ilm 2458 
    private void updateToV1Dot2(final DBRoot root) throws SQLException {
57 ilm 2459 
        // bigint -> int ID_METRIQUE BON_DE_LIVRAISON_ELEMENT
2460 
        final SQLTable tableLivraisonElement = root.getTable("BON_DE_LIVRAISON_ELEMENT");
2461 
        AlterTable alter = new AlterTable(tableLivraisonElement);
2462 
        alter.alterColumn("ID_METRIQUE_2", EnumSet.of(Properties.TYPE), "integer", null, null);
2463 
        String req3 = alter.asString();
2464 
        root.getDBSystemRoot().getDataSource().execute(req3);
2465 
 
19 ilm 2466 
        final SQLTable tableDevis = root.getTable("DEVIS");
2467 
        final SQLDataSource ds = root.getDBSystemRoot().getDataSource();
2468 
        if (!tableDevis.getFieldsName().contains("DATE_VALIDITE")) {
2469 
            AlterTable t = new AlterTable(tableDevis);
2470 
            t.addColumn("DATE_VALIDITE", "date");
2471 
            try {
2472 
                ds.execute(t.asString());
2473 
                tableDevis.getSchema().updateVersion();
2474 
            } catch (SQLException ex) {
2475 
                throw new IllegalStateException("Erreur lors de l'ajout du champ DATE_VALIDITE à la table DEVIS", ex);
2476 
            }
2477 
        } else {
2478 
            AlterTable t = new AlterTable(tableDevis);
2479 
            t.alterColumn("DATE_VALIDITE", EnumSet.allOf(Properties.class), "date", null, true);
2480 
            try {
2481 
                ds.execute(t.asString());
2482 
                tableDevis.getSchema().updateVersion();
2483 
            } catch (SQLException ex) {
2484 
                throw new IllegalStateException("Erreur lors de l'ajout du champ DATE_VALIDITE à la table DEVIS", ex);
2485 
            }
2486 
        }
18 ilm 2487 
 
61 ilm 2488 
        final SQLTable tableEtatDevis = root.getTable("ETAT_DEVIS");
2489 
        if (tableEtatDevis.getRow(5) == null && tableEtatDevis.getRowCount() <= 4) {
2490 
            SQLRowValues rowVals = new SQLRowValues(tableEtatDevis);
2491 
            rowVals.put("NOM", "En cours de rédaction");
2492 
            rowVals.commit();
67 ilm 2493 
 
61 ilm 2494 
        }
2495 
 
67 ilm 2496 
        SQLRowValues rowValsOrdre = new SQLRowValues(tableEtatDevis);
93 ilm 2497 
        rowValsOrdre.put("ORDRE", new BigDecimal("1.505"));
67 ilm 2498 
        rowValsOrdre.update(EtatDevisSQLElement.EN_ATTENTE);
2499 
 
93 ilm 2500 
        rowValsOrdre.put("ORDRE", new BigDecimal("2.505"));
67 ilm 2501 
        rowValsOrdre.update(EtatDevisSQLElement.ACCEPTE);
2502 
 
93 ilm 2503 
        rowValsOrdre.put("ORDRE", new BigDecimal("3.505"));
67 ilm 2504 
        rowValsOrdre.update(EtatDevisSQLElement.REFUSE);
2505 
 
93 ilm 2506 
        rowValsOrdre.put("ORDRE", new BigDecimal("4.505"));
67 ilm 2507 
        rowValsOrdre.update(EtatDevisSQLElement.EN_COURS);
2508 
 
63 ilm 2509 
        // Ajout de la TVA à 0
67 ilm 2510 
        SQLSelect selTVA = new SQLSelect();
63 ilm 2511 
        SQLTable tableTaxe = root.getTable("TAXE");
2512 
        selTVA.addSelect(tableTaxe.getKey(), "COUNT");
2513 
        selTVA.setWhere(new Where(tableTaxe.getField("TAUX"), "=", 0));
2514 
        Object result = root.getBase().getDataSource().executeScalar(selTVA.asString());
2515 
        if (result == null || ((Number) result).longValue() == 0) {
2516 
            SQLRowValues rowVals = new SQLRowValues(tableTaxe);
2517 
            rowVals.put("NOM", "Non applicable");
2518 
            rowVals.put("TAUX", Float.valueOf(0));
2519 
            rowVals.commit();
2520 
        }
2521 
 
19 ilm 2522 
        // Bon de livraison
2523 
        {
2524 
            SQLTable tableBL = root.getTable("BON_DE_LIVRAISON");
2525 
            boolean alterBL = false;
2526 
            AlterTable t = new AlterTable(tableBL);
2527 
            if (!tableBL.getFieldsName().contains("SOURCE")) {
2528 
                t.addVarCharColumn("SOURCE", 512);
2529 
                alterBL = true;
2530 
            }
2531 
            if (!tableBL.getFieldsName().contains("IDSOURCE")) {
2532 
                t.addColumn("IDSOURCE", "integer DEFAULT 1");
2533 
                alterBL = true;
2534 
            }
41 ilm 2535 
 
2536 
            if (!tableBL.getFieldsName().contains("DATE_LIVRAISON")) {
2537 
                t.addColumn("DATE_LIVRAISON", "date");
2538 
                alterBL = true;
2539 
            }
19 ilm 2540 
            if (alterBL) {
2541 
                try {
2542 
                    ds.execute(t.asString());
2543 
                    tableBL.getSchema().updateVersion();
2544 
                    tableBL.fetchFields();
2545 
                } catch (SQLException ex) {
2546 
                    throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table BON_DE_LIVRAISON", ex);
2547 
                }
2548 
            }
2549 
        }
61 ilm 2550 
 
2551 
        // Fournisseur
2552 
        {
2553 
            SQLTable tableBL = root.getTable("FOURNISSEUR");
2554 
            boolean alterBL = false;
2555 
            AlterTable t = new AlterTable(tableBL);
2556 
            if (!tableBL.getFieldsName().contains("ID_COMPTE_PCE_CHARGE")) {
2557 
                t.addForeignColumn("ID_COMPTE_PCE_CHARGE", root.getTable("COMPTE_PCE"));
2558 
                alterBL = true;
2559 
            }
2560 
            if (alterBL) {
2561 
                try {
2562 
                    ds.execute(t.asString());
2563 
                    tableBL.getSchema().updateVersion();
2564 
                    tableBL.fetchFields();
2565 
                } catch (SQLException ex) {
2566 
                    throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table FOURNISSEUR", ex);
2567 
                }
2568 
            }
2569 
        }
2570 
 
2571 
        // Numérotation
2572 
        {
2573 
            SQLTable tableNum = root.getTable("NUMEROTATION_AUTO");
2574 
            boolean alterNum = false;
2575 
            AlterTable t = new AlterTable(tableNum);
2576 
            if (!tableNum.getFieldsName().contains("AVOIR_F_START")) {
2577 
                t.addColumn("AVOIR_F_START", "integer DEFAULT 0");
2578 
                alterNum = true;
2579 
            }
2580 
            if (!tableNum.getFieldsName().contains("AVOIR_F_FORMAT")) {
2581 
                t.addVarCharColumn("AVOIR_F_FORMAT", 48);
2582 
                alterNum = true;
2583 
            }
2584 
 
2585 
            if (alterNum) {
2586 
                try {
2587 
                    ds.execute(t.asString());
2588 
                    tableNum.getSchema().updateVersion();
2589 
                    tableNum.fetchFields();
2590 
                } catch (SQLException ex) {
2591 
                    throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table NUMEROTATION_AUTO", ex);
2592 
                }
2593 
            }
2594 
        }
2595 
 
19 ilm 2596 
        SQLTable tableArticle = root.getTable("ARTICLE");
2597 
 
2598 
        AlterTable t = new AlterTable(tableArticle);
2599 
        boolean alterArticle = false;
2600 
        if (!tableArticle.getFieldsName().contains("QTE_ACHAT")) {
2601 
            t.addColumn("QTE_ACHAT", "integer DEFAULT 1");
2602 
            alterArticle = true;
2603 
        }
2604 
        if (!tableArticle.getFieldsName().contains("DESCRIPTIF")) {
2605 
            t.addVarCharColumn("DESCRIPTIF", 2048);
2606 
            alterArticle = true;
2607 
        }
2608 
        if (!tableArticle.getFieldsName().contains("CODE_BARRE")) {
2609 
            t.addVarCharColumn("CODE_BARRE", 256);
2610 
            alterArticle = true;
2611 
        }
2612 
        if (!tableArticle.getFieldsName().contains("GESTION_STOCK")) {
2613 
            t.addColumn("GESTION_STOCK", "boolean DEFAULT true");
2614 
            alterArticle = true;
2615 
        }
2616 
        if (!tableArticle.getFieldsName().contains("CODE_DOUANIER")) {
2617 
            t.addVarCharColumn("CODE_DOUANIER", 256);
2618 
            alterArticle = true;
2619 
        }
2620 
        if (!tableArticle.getFieldsName().contains("QTE_MIN")) {
2621 
            t.addColumn("QTE_MIN", "integer DEFAULT 1");
2622 
            alterArticle = true;
2623 
        }
2624 
        if (!tableArticle.getFieldsName().contains("ID_DEVISE")) {
61 ilm 2625 
            t.addForeignColumn("ID_DEVISE", root.findTable("DEVISE", true));
19 ilm 2626 
            alterArticle = true;
2627 
        }
2628 
        if (!tableArticle.getFieldsName().contains("ID_FOURNISSEUR")) {
61 ilm 2629 
            t.addForeignColumn("ID_FOURNISSEUR", root.findTable("FOURNISSEUR", true));
19 ilm 2630 
            alterArticle = true;
2631 
        }
2632 
        if (!tableArticle.getFieldsName().contains("PV_U_DEVISE")) {
2633 
            t.addColumn("PV_U_DEVISE", "bigint default 0");
2634 
            alterArticle = true;
2635 
        }
2636 
        if (!tableArticle.getFieldsName().contains("ID_DEVISE_HA")) {
61 ilm 2637 
            t.addForeignColumn("ID_DEVISE_HA", root.findTable("DEVISE", true));
19 ilm 2638 
            alterArticle = true;
2639 
        }
2640 
        if (!tableArticle.getFieldsName().contains("PA_DEVISE")) {
2641 
            t.addColumn("PA_DEVISE", "bigint default 0");
2642 
            alterArticle = true;
2643 
        }
2644 
        if (!tableArticle.getFieldsName().contains("ID_PAYS")) {
61 ilm 2645 
            t.addForeignColumn("ID_PAYS", root.findTable("PAYS", true));
19 ilm 2646 
            alterArticle = true;
2647 
        }
2648 
        if (alterArticle) {
18 ilm 2649 
            try {
19 ilm 2650 
                ds.execute(t.asString());
2651 
                tableArticle.getSchema().updateVersion();
18 ilm 2652 
                tableArticle.fetchFields();
2653 
            } catch (SQLException ex) {
19 ilm 2654 
                throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table ARTICLE", ex);
18 ilm 2655 
            }
2656 
        }
2657 
 
19 ilm 2658 
        // Création de la table Langue
2659 
        boolean refetchRoot = false;
61 ilm 2660 
        if (!root.contains("OBJECTIF_COMMERCIAL")) {
2661 
 
2662 
            SQLCreateTable createObjectif = new SQLCreateTable(root, "OBJECTIF_COMMERCIAL");
2663 
            createObjectif.addVarCharColumn("MOIS", 32);
2664 
            createObjectif.addColumn("ANNEE", "integer");
2665 
            createObjectif.addColumn("MARGE_HT", "bigint DEFAULT 0");
2666 
            createObjectif.addColumn("POURCENT_MARGE", "numeric (16,8)");
2667 
            createObjectif.addColumn("CHIFFRE_AFFAIRE", "bigint DeFAULT 0");
2668 
            createObjectif.addForeignColumn("COMMERCIAL");
2669 
            try {
2670 
                ds.execute(createObjectif.asString());
2671 
                insertUndef(createObjectif);
2672 
                tableDevis.getSchema().updateVersion();
2673 
                refetchRoot = true;
2674 
            } catch (SQLException ex) {
2675 
                throw new IllegalStateException("Erreur lors de la création de la table OBJECTIF_COMMERCIAL", ex);
2676 
            }
2677 
 
2678 
        }
2679 
 
19 ilm 2680 
        if (!root.contains("LANGUE")) {
18 ilm 2681 
 
19 ilm 2682 
            SQLCreateTable createLangue = new SQLCreateTable(root, "LANGUE");
2683 
            createLangue.addVarCharColumn("CODE", 256);
2684 
            createLangue.addVarCharColumn("NOM", 256);
2685 
            createLangue.addVarCharColumn("CHEMIN", 256);
2686 
            try {
2687 
                ds.execute(createLangue.asString());
2688 
                insertUndef(createLangue);
2689 
                tableDevis.getSchema().updateVersion();
67 ilm 2690 
                root.refetchTable(createLangue.getName());
19 ilm 2691 
            } catch (SQLException ex) {
2692 
                throw new IllegalStateException("Erreur lors de la création de la table LANGUE", ex);
2693 
            }
2694 
 
2695 
            final String[] langs = new String[] { "FR", "Français", "EN", "Anglais", "SP", "Espagnol", "DE", "Allemand", "NL", "Néerlandais", "IT", "Italien" };
2696 
            // ('FR', 'Français', 1.000), ('EN', 'Anglais', 2.000)
2697 
            final List<String> values = new ArrayList<String>();
2698 
            final SQLBase base = root.getBase();
2699 
            for (int i = 0; i < langs.length; i += 2) {
2700 
                final int order = values.size() + 1;
2701 
                values.add("(" + base.quoteString(langs[i]) + ", " + base.quoteString(langs[i + 1]) + ", " + order + ")");
2702 
            }
2703 
            final String valuesStr = CollectionUtils.join(values, ", ");
2704 
            final String insertVals = "INSERT INTO " + getTableName(createLangue).quote() + "(" + SQLBase.quoteIdentifier("CODE") + ", " + SQLBase.quoteIdentifier("NOM") + ", "
2705 
                    + SQLBase.quoteIdentifier(SQLSyntax.ORDER_NAME) + ") VALUES" + valuesStr;
2706 
            ds.execute(insertVals);
18 ilm 2707 
        }
2708 
 
21 ilm 2709 
        // Création de la table Modéle
2710 
        if (!root.contains("MODELE")) {
2711 
 
2712 
            SQLCreateTable createModele = new SQLCreateTable(root, "MODELE");
2713 
            createModele.addVarCharColumn("NOM", 256);
61 ilm 2714 
            createModele.addForeignColumn("ID_TYPE_MODELE", root.findTable("TYPE_MODELE", true));
21 ilm 2715 
            try {
2716 
                ds.execute(createModele.asString());
2717 
                insertUndef(createModele);
2718 
                tableDevis.getSchema().updateVersion();
2719 
                refetchRoot = true;
2720 
            } catch (SQLException ex) {
2721 
                throw new IllegalStateException("Erreur lors de la création de la table MODELE", ex);
2722 
            }
2723 
        }
2724 
 
2725 
        // Création de la table Modéle
2726 
        if (!root.contains("CONTACT_FOURNISSEUR")) {
2727 
 
2728 
            SQLCreateTable createModele = new SQLCreateTable(root, "CONTACT_FOURNISSEUR");
2729 
            createModele.addVarCharColumn("NOM", 256);
2730 
            createModele.addVarCharColumn("PRENOM", 256);
2731 
            createModele.addVarCharColumn("TEL_DIRECT", 256);
2732 
            createModele.addVarCharColumn("TEL_MOBILE", 256);
2733 
            createModele.addVarCharColumn("EMAIL", 256);
2734 
            createModele.addVarCharColumn("FAX", 256);
2735 
            createModele.addVarCharColumn("FONCTION", 256);
2736 
            createModele.addVarCharColumn("TEL_PERSONEL", 256);
2737 
            createModele.addVarCharColumn("TEL_STANDARD", 256);
2738 
            createModele.addForeignColumn("ID_TITRE_PERSONNEL", root.findTable("TITRE_PERSONNEL"));
2739 
            createModele.addForeignColumn("ID_FOURNISSEUR", root.findTable("FOURNISSEUR"));
2740 
 
2741 
            try {
2742 
                ds.execute(createModele.asString());
2743 
                insertUndef(createModele);
2744 
                tableDevis.getSchema().updateVersion();
2745 
                refetchRoot = true;
2746 
            } catch (SQLException ex) {
2747 
                throw new IllegalStateException("Erreur lors de la création de la table MODELE", ex);
2748 
            }
2749 
        }
2750 
 
19 ilm 2751 
        // Création de la table Tarif
2752 
        if (!root.contains("TARIF")) {
2753 
 
2754 
            SQLCreateTable createTarif = new SQLCreateTable(root, "TARIF");
2755 
            createTarif.addVarCharColumn("NOM", 256);
61 ilm 2756 
            createTarif.addForeignColumn("ID_DEVISE", root.findTable("DEVISE", true));
2757 
            createTarif.addForeignColumn("ID_TAXE", root.findTable("TAXE", true));
19 ilm 2758 
            createTarif.asString();
18 ilm 2759 
            try {
19 ilm 2760 
                ds.execute(createTarif.asString());
2761 
                insertUndef(createTarif);
2762 
                tableDevis.getSchema().updateVersion();
67 ilm 2763 
                root.refetchTable(createTarif.getName());
18 ilm 2764 
            } catch (SQLException ex) {
19 ilm 2765 
                throw new IllegalStateException("Erreur lors de la création de la table TARIF", ex);
18 ilm 2766 
            }
2767 
        }
2768 
 
19 ilm 2769 
        // Création de la table article Tarif
2770 
        if (!root.contains("ARTICLE_TARIF")) {
2771 
 
2772 
            SQLCreateTable createTarif = new SQLCreateTable(root, "ARTICLE_TARIF");
61 ilm 2773 
            createTarif.addForeignColumn("ID_DEVISE", root.findTable("DEVISE", true));
2774 
            createTarif.addForeignColumn("ID_TAXE", root.findTable("TAXE", true));
2775 
            createTarif.addForeignColumn("ID_TARIF", root.findTable("TARIF", true));
2776 
            createTarif.addForeignColumn("ID_ARTICLE", root.findTable("ARTICLE", true));
19 ilm 2777 
            createTarif.addColumn("PV_HT", "bigint DEFAULT 0");
2778 
            createTarif.addColumn("PV_TTC", "bigint DEFAULT 0");
2779 
            createTarif.addColumn("PRIX_METRIQUE_VT_1", "bigint DEFAULT 0");
2780 
            createTarif.addColumn("PRIX_METRIQUE_VT_2", "bigint DEFAULT 0");
2781 
            createTarif.addColumn("PRIX_METRIQUE_VT_3", "bigint DEFAULT 0");
2782 
            createTarif.asString();
18 ilm 2783 
            try {
19 ilm 2784 
                ds.execute(createTarif.asString());
2785 
                insertUndef(createTarif);
2786 
                tableDevis.getSchema().updateVersion();
61 ilm 2787 
                refetchRoot = true;
19 ilm 2788 
            } catch (SQLException ex) {
2789 
                throw new IllegalStateException("Erreur lors de la création de la table ARTICLE_TARIF", ex);
18 ilm 2790 
            }
2791 
        }
2792 
 
19 ilm 2793 
        // Création de la table article Désignation
2794 
        if (!root.contains("ARTICLE_DESIGNATION")) {
2795 
 
2796 
            SQLCreateTable createTarif = new SQLCreateTable(root, "ARTICLE_DESIGNATION");
61 ilm 2797 
            createTarif.addForeignColumn("ID_ARTICLE", root.findTable("ARTICLE", true));
2798 
            createTarif.addForeignColumn("ID_LANGUE", root.findTable("LANGUE", true));
19 ilm 2799 
            createTarif.addVarCharColumn("NOM", 1024);
2800 
            createTarif.asString();
18 ilm 2801 
            try {
19 ilm 2802 
                ds.execute(createTarif.asString());
2803 
                insertUndef(createTarif);
2804 
                tableDevis.getSchema().updateVersion();
61 ilm 2805 
                refetchRoot = true;
19 ilm 2806 
            } catch (SQLException ex) {
2807 
                throw new IllegalStateException("Erreur lors de la création de la table ARTICLE_DESIGNATION", ex);
18 ilm 2808 
            }
2809 
        }
2810 
 
61 ilm 2811 
        if (!root.contains("UNITE_VENTE")) {
2812 
 
2813 
            SQLCreateTable createUnite = new SQLCreateTable(root, "UNITE_VENTE");
2814 
            createUnite.addVarCharColumn("CODE", 32);
2815 
            createUnite.addVarCharColumn("NOM", 256);
2816 
            createUnite.addColumn("A_LA_PIECE", "boolean DEFAULT false");
2817 
            createUnite.addVarCharColumn("INFOS", 256);
2818 
            try {
2819 
                ds.execute(createUnite.asString());
2820 
                insertUndef(createUnite);
132 ilm 2821 
                final String insert = "INSERT into " + getTableName(createUnite).quote()
61 ilm 2822 
                        + "(\"CODE\",\"NOM\",\"A_LA_PIECE\",\"ORDRE\") VALUES('pièce','à la pièce',true,1),('m','mètres',false,2),('m²','mètres carré',false,3),('m3','mètres cube',false,4),('l','litres',false,5),('kg','kilos',false,6),('h','heures',false,7),('j','jours',false,8),('mois','mois',false,9)";
2823 
                root.getDBSystemRoot().getDataSource().execute(insert);
2824 
                tableDevis.getSchema().updateVersion();
2825 
                refetchRoot = true;
2826 
            } catch (SQLException ex) {
2827 
                throw new IllegalStateException("Erreur lors de la création de la table UNITE_VENTE", ex);
2828 
            }
2829 
 
2830 
        }
2831 
 
2832 
        // Chargement des tables fraichement créées
2833 
        if (refetchRoot)
2834 
            root.refetch();
2835 
 
2836 
        if (!tableArticle.getFieldsName().contains("ID_UNITE_VENTE")) {
2837 
            AlterTable alterTableArticle = new AlterTable(tableArticle);
2838 
            alterTableArticle.addForeignColumn("ID_UNITE_VENTE", root.findTable("UNITE_VENTE", true).getSQLName(), "ID", "2");
2839 
            try {
2840 
                ds.execute(alterTableArticle.asString());
2841 
                tableArticle.getSchema().updateVersion();
2842 
                tableArticle.fetchFields();
2843 
            } catch (SQLException ex) {
2844 
                throw new IllegalStateException("Erreur lors de l'ajout du champ UNITE_VENTE sur la table ARTICLE", ex);
2845 
            }
2846 
        }
2847 
 
19 ilm 2848 
        SQLTable tableVFElt = root.getTable("SAISIE_VENTE_FACTURE_ELEMENT");
41 ilm 2849 
        addVenteEltField(tableVFElt, root);
18 ilm 2850 
 
19 ilm 2851 
        SQLTable tableDevisElt = root.getTable("DEVIS_ELEMENT");
41 ilm 2852 
        addVenteEltField(tableDevisElt, root);
19 ilm 2853 
 
2854 
        SQLTable tableCmdElt = root.getTable("COMMANDE_CLIENT_ELEMENT");
41 ilm 2855 
        addVenteEltField(tableCmdElt, root);
19 ilm 2856 
 
2857 
        SQLTable tableBonElt = root.getTable("BON_DE_LIVRAISON_ELEMENT");
41 ilm 2858 
        addVenteEltField(tableBonElt, root);
19 ilm 2859 
 
2860 
        SQLTable tableAvoirElt = root.getTable("AVOIR_CLIENT_ELEMENT");
41 ilm 2861 
        addVenteEltField(tableAvoirElt, root);
19 ilm 2862 
 
2863 
        SQLTable tableCmdFournElt = root.getTable("COMMANDE_ELEMENT");
41 ilm 2864 
        addHAElementField(tableCmdFournElt, root);
90 ilm 2865 
        if (root.contains("DEMANDE_PRIX_ELEMENT")) {
2866 
            SQLTable tableDmdFournElt = root.getTable("DEMANDE_PRIX_ELEMENT");
2867 
            addHAElementField(tableDmdFournElt, root);
2868 
        }
19 ilm 2869 
 
2870 
        SQLTable tableBonRecptElt = root.getTable("BON_RECEPTION_ELEMENT");
41 ilm 2871 
        addHAElementField(tableBonRecptElt, root);
19 ilm 2872 
 
2873 
        SQLTable tableBonRecpt = root.getTable("BON_RECEPTION");
2874 
        addDeviseHAField(tableBonRecpt, root);
2875 
 
2876 
        SQLTable tableCommande = root.getTable("COMMANDE");
2877 
        addDeviseHAField(tableCommande, root);
2878 
 
67 ilm 2879 
        patchFieldElt1Dot3(root.getTable("ARTICLE"), root);
2880 
        patchFieldElt1Dot3(root.getTable("ARTICLE_TARIF"), root);
2881 
 
41 ilm 2882 
        if (!tableCommande.getFieldsName().contains("ID_ADRESSE")) {
2883 
            AlterTable alterCmd = new AlterTable(tableCommande);
61 ilm 2884 
            alterCmd.addForeignColumn("ID_ADRESSE", root.findTable("ADRESSE", true));
41 ilm 2885 
            try {
2886 
                ds.execute(alterCmd.asString());
2887 
                tableCommande.getSchema().updateVersion();
2888 
            } catch (SQLException ex) {
2889 
                throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table COMMANDE", ex);
2890 
            }
2891 
 
2892 
        }
61 ilm 2893 
        if (!tableCommande.getFieldsName().contains("ID_CLIENT")) {
2894 
            AlterTable alterCmd = new AlterTable(tableCommande);
2895 
            alterCmd.addForeignColumn("ID_CLIENT", root.findTable("CLIENT"));
2896 
            try {
2897 
                ds.execute(alterCmd.asString());
2898 
                tableCommande.getSchema().updateVersion();
2899 
            } catch (SQLException ex) {
2900 
                throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table COMMANDE", ex);
2901 
            }
41 ilm 2902 
 
61 ilm 2903 
        }
2904 
 
19 ilm 2905 
        {
21 ilm 2906 
            addTotalDeviseField(tableDevis, root);
2907 
            addModeleField(tableDevis, root);
2908 
 
19 ilm 2909 
            SQLTable tableVF = root.getTable("SAISIE_VENTE_FACTURE");
2910 
            addTotalDeviseField(tableVF, root);
21 ilm 2911 
            addModeleField(tableVF, root);
19 ilm 2912 
 
2913 
            addTotalDeviseField(tableDevis, root);
21 ilm 2914 
            addModeleField(tableDevis, root);
19 ilm 2915 
 
2916 
            SQLTable tableCmd = root.getTable("COMMANDE_CLIENT");
2917 
            addTotalDeviseField(tableCmd, root);
21 ilm 2918 
            addModeleField(tableCmd, root);
19 ilm 2919 
 
2920 
            SQLTable tableBon = root.getTable("BON_DE_LIVRAISON");
2921 
            addTotalDeviseField(tableBon, root);
21 ilm 2922 
            addModeleField(tableBon, root);
19 ilm 2923 
 
2924 
            SQLTable tableAvoir = root.getTable("AVOIR_CLIENT");
2925 
            addTotalDeviseField(tableAvoir, root);
21 ilm 2926 
            addModeleField(tableAvoir, root);
18 ilm 2927 
        }
19 ilm 2928 
        // Change client
2929 
        {
2930 
            SQLTable tableClient = root.getTable("CLIENT");
18 ilm 2931 
 
19 ilm 2932 
            AlterTable tClient = new AlterTable(tableClient);
2933 
            boolean alterClient = false;
2934 
 
2935 
            if (!tableClient.getFieldsName().contains("ID_TARIF")) {
61 ilm 2936 
                tClient.addForeignColumn("ID_TARIF", root.findTable("TARIF", true));
19 ilm 2937 
                alterClient = true;
2938 
            }
2939 
            if (!tableClient.getFieldsName().contains("ID_PAYS")) {
61 ilm 2940 
                tClient.addForeignColumn("ID_PAYS", root.findTable("PAYS", true));
19 ilm 2941 
                alterClient = true;
2942 
            }
2943 
            if (!tableClient.getFieldsName().contains("ID_LANGUE")) {
61 ilm 2944 
                tClient.addForeignColumn("ID_LANGUE", root.findTable("LANGUE", true));
19 ilm 2945 
                alterClient = true;
2946 
            }
2947 
 
2948 
            if (!tableClient.getFieldsName().contains("ID_DEVISE")) {
61 ilm 2949 
                tClient.addForeignColumn("ID_DEVISE", root.findTable("DEVISE", true));
19 ilm 2950 
                alterClient = true;
2951 
            }
2952 
            if (alterClient) {
2953 
                try {
2954 
                    ds.execute(tClient.asString());
2955 
                    tableClient.getSchema().updateVersion();
2956 
                } catch (SQLException ex) {
2957 
                    throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table CLIENT", ex);
2958 
                }
2959 
            }
18 ilm 2960 
        }
2961 
 
19 ilm 2962 
        // Change Pays
2963 
        {
2964 
            SQLTable tablePays = root.getTable("PAYS");
2965 
 
2966 
            AlterTable tPays = new AlterTable(tablePays);
2967 
            boolean alterPays = false;
2968 
 
2969 
            if (!tablePays.getFieldsName().contains("ID_TARIF")) {
61 ilm 2970 
                tPays.addForeignColumn("ID_TARIF", root.findTable("TARIF", true));
19 ilm 2971 
                alterPays = true;
2972 
            }
2973 
            if (!tablePays.getFieldsName().contains("ID_LANGUE")) {
61 ilm 2974 
                tPays.addForeignColumn("ID_LANGUE", root.findTable("LANGUE", true));
19 ilm 2975 
                alterPays = true;
2976 
            }
2977 
            if (alterPays) {
2978 
                try {
2979 
                    ds.execute(tPays.asString());
2980 
                    tablePays.getSchema().updateVersion();
2981 
                } catch (SQLException ex) {
2982 
                    throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table PAYS", ex);
2983 
                }
2984 
            }
2985 
        }
2986 
        // Change Commande
2987 
        {
2988 
            SQLTable tableCmd = root.getTable("COMMANDE");
2989 
 
2990 
            AlterTable tCmd = new AlterTable(tableCmd);
2991 
            boolean alterCmd = false;
2992 
 
2993 
            if (!tableCmd.getFieldsName().contains("EN_COURS")) {
2994 
                tCmd.addColumn("EN_COURS", "boolean default true");
2995 
                alterCmd = true;
2996 
            }
2997 
            if (alterCmd) {
2998 
                try {
2999 
                    ds.execute(tCmd.asString());
3000 
                    tableCmd.getSchema().updateVersion();
3001 
                } catch (SQLException ex) {
3002 
                    throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table COMMANDE", ex);
3003 
                }
3004 
            }
3005 
        }
65 ilm 3006 
 
3007 
        // Change VF
3008 
        {
3009 
            SQLTable tableVenteFacture = root.getTable("SAISIE_VENTE_FACTURE");
3010 
 
3011 
            AlterTable tVF = new AlterTable(tableVenteFacture);
3012 
            boolean alterVF = false;
3013 
 
3014 
            if (!tableVenteFacture.getFieldsName().contains("ID_TAXE_PORT")) {
3015 
                tVF.addForeignColumn("ID_TAXE_PORT", root.findTable("TAXE"));
3016 
                alterVF = true;
3017 
            }
3018 
            if (alterVF) {
3019 
                try {
3020 
                    ds.execute(tVF.asString());
3021 
                    tableVenteFacture.getSchema().updateVersion();
3022 
                } catch (SQLException ex) {
3023 
                    throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table SAISIE_VENTE_FACTURE", ex);
3024 
                }
3025 
            }
3026 
        }
3027 
 
19 ilm 3028 
        // Change Fournisseur
3029 
        {
3030 
            SQLTable tableFournisseur = root.getTable("FOURNISSEUR");
3031 
 
3032 
            AlterTable tFourn = new AlterTable(tableFournisseur);
3033 
            boolean alterFourn = false;
3034 
 
3035 
            if (!tableFournisseur.getFieldsName().contains("ID_LANGUE")) {
61 ilm 3036 
                tFourn.addForeignColumn("ID_LANGUE", root.findTable("LANGUE", true));
19 ilm 3037 
                alterFourn = true;
3038 
            }
3039 
            if (!tableFournisseur.getFieldsName().contains("ID_DEVISE")) {
61 ilm 3040 
                tFourn.addForeignColumn("ID_DEVISE", root.findTable("DEVISE", true));
19 ilm 3041 
                alterFourn = true;
3042 
            }
3043 
            if (!tableFournisseur.getFieldsName().contains("RESPONSABLE")) {
3044 
                tFourn.addVarCharColumn("RESPONSABLE", 256);
3045 
                alterFourn = true;
3046 
            }
3047 
            if (!tableFournisseur.getFieldsName().contains("TEL_P")) {
3048 
                tFourn.addVarCharColumn("TEL_P", 256);
3049 
                alterFourn = true;
3050 
            }
3051 
            if (!tableFournisseur.getFieldsName().contains("MAIL")) {
3052 
                tFourn.addVarCharColumn("MAIL", 256);
3053 
                alterFourn = true;
3054 
            }
3055 
            if (!tableFournisseur.getFieldsName().contains("INFOS")) {
3056 
                tFourn.addVarCharColumn("INFOS", 2048);
3057 
                alterFourn = true;
3058 
            }
3059 
 
3060 
            if (alterFourn) {
3061 
                try {
3062 
                    ds.execute(tFourn.asString());
3063 
                    tableFournisseur.getSchema().updateVersion();
3064 
                } catch (SQLException ex) {
3065 
                    throw new IllegalStateException("Erreur lors de l'ajout des champs sur la table FOURNISSEUR", ex);
3066 
                }
3067 
            }
3068 
        }
3069 
 
41 ilm 3070 
        updateN4DS(root);
3071 
 
19 ilm 3072 
        root.refetch();
18 ilm 3073 
    }
3074 
 
41 ilm 3075 
    /**
3076 
     * Mise à jour du schéma pour N4DS
3077 
     *
3078 
     * @param root
3079 
     * @throws SQLException
3080 
     */
3081 
    private void updateN4DS(DBRoot root) throws SQLException {
3082 
 
3083 
        {
3084 
            SQLTable table = root.findTable("INFOS_SALARIE_PAYE");
3085 
            boolean alter = false;
3086 
            AlterTable t = new AlterTable(table);
3087 
            if (!table.getFieldsName().contains("CODE_AT")) {
3088 
                t.addVarCharColumn("CODE_AT", 18);
3089 
                alter = true;
3090 
            }
3091 
            if (!table.getFieldsName().contains("CODE_SECTION_AT")) {
3092 
                t.addVarCharColumn("CODE_SECTION_AT", 18);
3093 
                alter = true;
3094 
            }
3095 
 
3096 
            if (alter) {
3097 
                try {
3098 
                    table.getBase().getDataSource().execute(t.asString());
3099 
                    table.getSchema().updateVersion();
3100 
                    table.fetchFields();
3101 
                } catch (SQLException ex) {
3102 
                    throw new IllegalStateException("Erreur lors de l'ajout des champs à la table " + table.getName(), ex);
3103 
                }
3104 
            }
3105 
 
3106 
        }
3107 
 
3108 
        if (!root.contains("CODE_STATUT_CAT_CONV")) {
3109 
 
3110 
            SQLCreateTable createTarif = new SQLCreateTable(root, "CODE_STATUT_CAT_CONV");
3111 
 
3112 
            createTarif.addVarCharColumn("CODE", 6);
3113 
            createTarif.addVarCharColumn("NOM", 256);
3114 
            createTarif.asString();
3115 
            try {
3116 
                root.getBase().getDataSource().execute(createTarif.asString());
3117 
                insertUndef(createTarif);
3118 
 
3119 
                String insert = "INSERT into " + getTableName(createTarif).quote() + "(\"CODE\",\"NOM\") VALUES ";
3120 
                insert += " ('01','agriculteur salarié de son exploitation')";
3121 
                insert += ", ('02','artisan ou commerçant salarié de son entreprise')";
3122 
                insert += ", ('03','cadre dirigeant (votant au collège employeur des élections prud''''hommales)')";
3123 
                insert += ", ('04','autres cadres au sens de la convention collective (ou du statut pour les régimes spéciaux)')";
3124 
                insert += ", ('05','profession intermédiaire (technicien, contremaître, agent de maîtrise, clergé)')";
3125 
                insert += ", ('06','employé administratif d''''entreprise, de commerce, agent de service')";
3126 
                insert += ", ('07','ouvriers qualifiés et non qualifiés y compris ouvriers agricoles');";
3127 
                createTarif.getRoot().getDBSystemRoot().getDataSource().execute(insert);
3128 
 
3129 
                root.getSchema().updateVersion();
3130 
                root.refetch();
3131 
            } catch (SQLException ex) {
3132 
                throw new IllegalStateException("Erreur lors de la création de la table CODE_STATUT_CAT_CONV", ex);
3133 
            }
3134 
        }
3135 
 
3136 
        // Création de la table Modéle
3137 
        if (!root.contains("CONTACT_ADMINISTRATIF")) {
3138 
 
3139 
            SQLCreateTable createModele = new SQLCreateTable(root, "CONTACT_ADMINISTRATIF");
3140 
            createModele.addVarCharColumn("NOM", 256);
3141 
            createModele.addVarCharColumn("PRENOM", 256);
3142 
            createModele.addVarCharColumn("TEL_DIRECT", 256);
3143 
            createModele.addVarCharColumn("TEL_MOBILE", 256);
3144 
            createModele.addVarCharColumn("EMAIL", 256);
3145 
            createModele.addVarCharColumn("FAX", 256);
3146 
            createModele.addVarCharColumn("FONCTION", 256);
3147 
            createModele.addVarCharColumn("TEL_PERSONEL", 256);
3148 
            createModele.addVarCharColumn("TEL_STANDARD", 256);
3149 
            createModele.addForeignColumn("ID_TITRE_PERSONNEL", root.findTable("TITRE_PERSONNEL"));
3150 
            createModele.addColumn("N4DS", "boolean DEFAULT false");
3151 
 
3152 
            try {
3153 
                root.getBase().getDataSource().execute(createModele.asString());
3154 
                insertUndef(createModele);
3155 
                root.getSchema().updateVersion();
3156 
            } catch (SQLException ex) {
3157 
                throw new IllegalStateException("Erreur lors de la création de la table MODELE", ex);
3158 
            }
3159 
        }
3160 
 
3161 
        {
61 ilm 3162 
            SQLTable tableContrat = root.findTable("CONTRAT_SALARIE", true);
41 ilm 3163 
            boolean alter2 = false;
3164 
            AlterTable t2 = new AlterTable(tableContrat);
3165 
            // UGRR
3166 
            if (!tableContrat.getFieldsName().contains("CODE_IRC_UGRR")) {
3167 
                t2.addVarCharColumn("CODE_IRC_UGRR", 18);
3168 
                alter2 = true;
3169 
            }
3170 
            if (!tableContrat.getFieldsName().contains("NUMERO_RATTACHEMENT_UGRR")) {
3171 
                t2.addVarCharColumn("NUMERO_RATTACHEMENT_UGRR", 64);
3172 
                alter2 = true;
3173 
            }
3174 
            // UGRC
3175 
            if (!tableContrat.getFieldsName().contains("CODE_IRC_UGRC")) {
3176 
                t2.addVarCharColumn("CODE_IRC_UGRC", 18);
3177 
                alter2 = true;
3178 
            }
3179 
            if (!tableContrat.getFieldsName().contains("NUMERO_RATTACHEMENT_UGRC")) {
3180 
                t2.addVarCharColumn("NUMERO_RATTACHEMENT_UGRC", 64);
3181 
                alter2 = true;
3182 
            }
3183 
 
3184 
            // Retraite Compl
3185 
            if (!tableContrat.getFieldsName().contains("CODE_IRC_RETRAITE")) {
3186 
                t2.addVarCharColumn("CODE_IRC_RETRAITE", 18);
3187 
                alter2 = true;
3188 
            }
3189 
            if (!tableContrat.getFieldsName().contains("NUMERO_RATTACHEMENT_RETRAITE")) {
3190 
                t2.addVarCharColumn("NUMERO_RATTACHEMENT_RETRAITE", 64);
3191 
                alter2 = true;
3192 
            }
3193 
 
3194 
            if (!tableContrat.getFieldsName().contains("ID_CODE_STATUT_CAT_CONV")) {
61 ilm 3195 
                t2.addForeignColumn("ID_CODE_STATUT_CAT_CONV", root.findTable("CODE_STATUT_CAT_CONV", true));
41 ilm 3196 
                alter2 = true;
3197 
            }
3198 
 
3199 
            if (alter2) {
3200 
                try {
3201 
                    tableContrat.getBase().getDataSource().execute(t2.asString());
3202 
                    tableContrat.getSchema().updateVersion();
3203 
                    tableContrat.fetchFields();
3204 
                } catch (SQLException ex) {
3205 
                    throw new IllegalStateException("Erreur lors de l'ajout des champs à la table " + tableContrat.getName(), ex);
3206 
                }
3207 
            }
3208 
 
3209 
        }
3210 
    }
3211 
 
19 ilm 3212 
    private void addDeviseHAField(SQLTable table, DBRoot root) throws SQLException {
3213 
        boolean alter = false;
3214 
        AlterTable t = new AlterTable(table);
3215 
        if (!table.getFieldsName().contains("ID_DEVISE")) {
61 ilm 3216 
            t.addForeignColumn("ID_DEVISE", root.findTable("DEVISE", true));
19 ilm 3217 
            alter = true;
3218 
        }
3219 
 
3220 
        if (!table.getFieldsName().contains("T_DEVISE")) {
3221 
            t.addColumn("T_DEVISE", "bigint default 0");
3222 
            alter = true;
3223 
        }
3224 
 
3225 
        if (alter) {
3226 
            try {
3227 
                table.getBase().getDataSource().execute(t.asString());
3228 
                table.getSchema().updateVersion();
3229 
                table.fetchFields();
3230 
            } catch (SQLException ex) {
3231 
                throw new IllegalStateException("Erreur lors de l'ajout des champs à la table " + table.getName(), ex);
3232 
            }
3233 
        }
3234 
 
3235 
    }
3236 
 
67 ilm 3237 
    private void patchFieldElt1Dot3(SQLTable table, DBRoot root) {
3238 
 
3239 
        List<String> cols = Arrays.asList("PV_HT", "PA_DEVISE_T", "T_PV_HT", "T_PA_TTC", "T_PA_HT", "PA_HT", "T_PV_TTC", "PRIX_METRIQUE_HA_2", "PRIX_METRIQUE_HA_1", "PRIX_METRIQUE_HA_3",
73 ilm 3240 
                "PRIX_METRIQUE_VT_2", "PRIX_METRIQUE_VT_1", "MONTANT_HT", "MONTANT_INITIAL", "PRIX_METRIQUE_VT_3", "MARGE_HT", "PA_DEVISE", "PV_U_DEVISE", "PV_T_DEVISE", "PV_TTC", "TARIF_Q18_HT",
90 ilm 3241 
                "T_PRIX_FINAL_TTC", "PRIX_FINAL_TTC", "PV_UNIT_HT", "PREBILAN", "MARGE_PREBILAN_HT");
67 ilm 3242 
 
132 ilm 3243 
        if ((table.contains("PV_HT") && table.getField("PV_HT").getType().getDecimalDigits() == 0)
3244 
                || (table.contains("PV_UNIT_HT") && table.getField("PV_UNIT_HT").getType().getDecimalDigits() == 0)) {
67 ilm 3245 
            AlterTable t = new AlterTable(table);
3246 
            UpdateBuilder builder = new UpdateBuilder(table);
73 ilm 3247 
            List<UpdateBuilder> builds = new ArrayList<UpdateBuilder>();
67 ilm 3248 
            for (String field : cols) {
3249 
                if (table.contains(field)) {
73 ilm 3250 
                    UpdateBuilder builderNonNull = new UpdateBuilder(table);
3251 
                    builderNonNull.set(field, "0");
3252 
                    builderNonNull.setWhere(new Where(table.getField(field), "=", (Object) null));
3253 
                    builds.add(builderNonNull);
3254 
 
67 ilm 3255 
                    builder.set(field, table.getField(field).getSQLName().getRest().quote() + "/100");
3256 
                    if (field.contains("TTC")) {
3257 
                        t.alterColumn(field, EnumSet.allOf(Properties.class), "numeric(16,2)", "0", false);
3258 
                    } else {
3259 
                        t.alterColumn(field, EnumSet.allOf(Properties.class), "numeric(16,6)", "0", false);
3260 
                    }
3261 
                }
3262 
            }
3263 
 
3264 
            try {
73 ilm 3265 
 
3266 
                for (UpdateBuilder updateBuilder : builds) {
3267 
                    table.getBase().getDataSource().execute(updateBuilder.asString());
3268 
                }
3269 
 
67 ilm 3270 
                table.getBase().getDataSource().execute(t.asString());
3271 
                table.getSchema().updateVersion();
3272 
                table.fetchFields();
3273 
            } catch (SQLException ex) {
3274 
                throw new IllegalStateException("Erreur lors de l'ajout des champs à la table " + table.getName(), ex);
3275 
            }
3276 
 
3277 
            String req2 = builder.asString();
3278 
            root.getDBSystemRoot().getDataSource().execute(req2);
3279 
        }
3280 
 
3281 
    }
3282 
 
93 ilm 3283 
    private void patchFieldElt1Dot4(SQLTable table, DBRoot root) throws SQLException {
83 ilm 3284 
 
3285 
        if (!table.contains("MONTANT_REMISE")) {
3286 
            AlterTable t = new AlterTable(table);
3287 
            t.alterColumn("POURCENT_REMISE", EnumSet.allOf(Properties.class), "numeric(12,8)", "0", true);
3288 
            t.addColumn("MONTANT_REMISE", "numeric (16,8)");
3289 
 
3290 
            try {
3291 
 
3292 
                table.getBase().getDataSource().execute(t.asString());
3293 
                table.getSchema().updateVersion();
3294 
                table.fetchFields();
3295 
            } catch (SQLException ex) {
3296 
                throw new IllegalStateException("Erreur lors de l'ajout des champs à la table " + table.getName(), ex);
3297 
            }
3298 
        }
93 ilm 3299 
 
3300 
        if (!table.contains("ID_FAMILLE_ARTICLE")) {
3301 
            AlterTable t = new AlterTable(table);
3302 
            t.addForeignColumn("ID_FAMILLE_ARTICLE", root.getTable("FAMILLE_ARTICLE"));
3303 
 
3304 
            try {
3305 
 
3306 
                table.getBase().getDataSource().execute(t.asString());
3307 
                table.getSchema().updateVersion();
3308 
                table.fetchFields();
3309 
            } catch (SQLException ex) {
3310 
                throw new IllegalStateException("Erreur lors de l'ajout du champs ID_FAMILLE_ARTICLE à la table " + table.getName(), ex);
3311 
            }
3312 
        }
3313 
 
3314 
        addNiveauElementField(table);
3315 
    }
3316 
 
3317 
    private void addNiveauElementField(SQLTable table) throws SQLException {
3318 
 
83 ilm 3319 
        if (!table.contains("NIVEAU")) {
3320 
            AlterTable t = new AlterTable(table);
3321 
            t.addIntegerColumn("NIVEAU", 1);
3322 
            try {
3323 
                table.getBase().getDataSource().execute(t.asString());
3324 
                table.getSchema().updateVersion();
3325 
                table.fetchFields();
3326 
            } catch (SQLException ex) {
3327 
                throw new IllegalStateException("Erreur lors de l'ajout du niveau à la table " + table.getName(), ex);
3328 
            }
3329 
        }
3330 
 
3331 
    }
3332 
 
41 ilm 3333 
    private void addHAElementField(SQLTable table, DBRoot root) throws SQLException {
67 ilm 3334 
 
19 ilm 3335 
        boolean alter = false;
3336 
        AlterTable t = new AlterTable(table);
3337 
        if (!table.getFieldsName().contains("QTE_ACHAT")) {
3338 
            t.addColumn("QTE_ACHAT", "integer DEFAULT 1");
3339 
            alter = true;
3340 
        }
61 ilm 3341 
        if (!table.getFieldsName().contains("QTE_UNITAIRE")) {
3342 
            t.addColumn("QTE_UNITAIRE", "numeric(16,6) DEFAULT 1");
3343 
            alter = true;
3344 
        }
3345 
        if (!table.getFieldsName().contains("ID_UNITE_VENTE")) {
3346 
            t.addForeignColumn("ID_UNITE_VENTE", root.findTable("UNITE_VENTE", true).getSQLName(), "ID", "2");
3347 
            alter = true;
3348 
        }
3349 
        if (!table.getFieldsName().contains("ID_ARTICLE")) {
3350 
            t.addForeignColumn("ID_ARTICLE", root.findTable("ARTICLE", true));
3351 
            alter = true;
3352 
        }
19 ilm 3353 
        if (!table.getFieldsName().contains("PA_DEVISE")) {
3354 
            t.addColumn("PA_DEVISE", "bigint default 0");
3355 
            alter = true;
3356 
        }
3357 
        if (!table.getFieldsName().contains("ID_DEVISE")) {
61 ilm 3358 
            t.addForeignColumn("ID_DEVISE", root.findTable("DEVISE", true));
19 ilm 3359 
            alter = true;
3360 
        }
3361 
 
3362 
        if (!table.getFieldsName().contains("PA_DEVISE_T")) {
3363 
            t.addColumn("PA_DEVISE_T", "bigint default 0");
3364 
            alter = true;
3365 
        }
93 ilm 3366 
        if (!table.getFieldsName().contains("DESCRIPTIF")) {
3367 
            t.addVarCharColumn("DESCRIPTIF", 2048);
3368 
            alter = true;
3369 
        }
19 ilm 3370 
 
67 ilm 3371 
        // if (!table.getFieldsName().contains("POURCENT_REMISE")) {
3372 
        // t.addColumn("POURCENT_REMISE", "numeric(16,2) DEFAULT 0");
3373 
        // alter = true;
3374 
        // }
3375 
 
19 ilm 3376 
        if (alter) {
3377 
            try {
3378 
                table.getBase().getDataSource().execute(t.asString());
3379 
                table.getSchema().updateVersion();
3380 
                table.fetchFields();
3381 
            } catch (SQLException ex) {
3382 
                throw new IllegalStateException("Erreur lors de l'ajout des champs à la table " + table.getName(), ex);
3383 
            }
3384 
        }
67 ilm 3385 
        patchFieldElt1Dot3(table, root);
19 ilm 3386 
    }
3387 
 
93 ilm 3388 
    private void addRemiseField(SQLTable table, DBRoot root) throws SQLException {
3389 
 
3390 
        AlterTable t = new AlterTable(table);
3391 
        boolean alter = false;
3392 
        if (!table.contains("POURCENT_REMISE")) {
3393 
            t.addColumn("POURCENT_REMISE", "numeric (12,8)");
3394 
            alter = true;
3395 
        }
3396 
        if (!table.contains("MONTANT_REMISE")) {
3397 
            t.addColumn("MONTANT_REMISE", "numeric (16,8)");
3398 
            alter = true;
3399 
        }
3400 
        if (alter) {
3401 
            try {
3402 
 
3403 
                table.getBase().getDataSource().execute(t.asString());
3404 
                table.getSchema().updateVersion();
3405 
                table.fetchFields();
3406 
            } catch (SQLException ex) {
3407 
                throw new IllegalStateException("Erreur lors de l'ajout des champs remise à la table " + table.getName(), ex);
3408 
            }
3409 
        }
3410 
    }
3411 
 
3412 
    private void addAdresseField(SQLTable table, DBRoot root) throws SQLException {
3413 
        boolean alter = false;
3414 
        AlterTable t = new AlterTable(table);
3415 
        if (!table.getFieldsName().contains("ID_ADRESSE")) {
3416 
            t.addForeignColumn("ID_ADRESSE", root.findTable("ADRESSE"));
3417 
            alter = true;
3418 
        }
3419 
 
3420 
        if (!table.getFieldsName().contains("ID_ADRESSE_LIVRAISON")) {
3421 
            t.addForeignColumn("ID_ADRESSE_LIVRAISON", root.findTable("ADRESSE"));
3422 
            alter = true;
3423 
        }
3424 
 
3425 
        if (alter) {
3426 
            try {
3427 
                table.getBase().getDataSource().execute(t.asString());
3428 
                table.getSchema().updateVersion();
3429 
                table.fetchFields();
3430 
            } catch (SQLException ex) {
3431 
                throw new IllegalStateException("Erreur lors de l'ajout des champs à la table " + table.getName(), ex);
3432 
            }
3433 
        }
3434 
    }
3435 
 
21 ilm 3436 
    private void addModeleField(SQLTable table, DBRoot root) throws SQLException {
3437 
        boolean alter = false;
3438 
        AlterTable t = new AlterTable(table);
3439 
        if (!table.getFieldsName().contains("ID_MODELE")) {
3440 
            t.addForeignColumn("ID_MODELE", root.findTable("MODELE"));
3441 
            alter = true;
3442 
        }
3443 
 
3444 
        if (alter) {
3445 
            try {
3446 
                table.getBase().getDataSource().execute(t.asString());
3447 
                table.getSchema().updateVersion();
3448 
                table.fetchFields();
3449 
            } catch (SQLException ex) {
3450 
                throw new IllegalStateException("Erreur lors de l'ajout des champs à la table " + table.getName(), ex);
3451 
            }
3452 
        }
3453 
    }
3454 
 
19 ilm 3455 
    private void addTotalDeviseField(SQLTable table, DBRoot root) throws SQLException {
3456 
        boolean alter = false;
3457 
        AlterTable t = new AlterTable(table);
3458 
        if (!table.getFieldsName().contains("T_DEVISE")) {
3459 
            t.addColumn("T_DEVISE", "bigint default 0");
3460 
            alter = true;
3461 
        } else {
3462 
            table.getBase().getDataSource().execute("UPDATE " + table.getSQLName().quote() + " SET \"T_DEVISE\"=0 WHERE \"T_DEVISE\" IS NULL");
3463 
            t.alterColumn("T_DEVISE", EnumSet.allOf(Properties.class), "bigint", "0", false);
3464 
        }
3465 
        if (!table.getFieldsName().contains("T_POIDS")) {
3466 
            t.addColumn("T_POIDS", "real default 0");
3467 
            alter = true;
3468 
        }
3469 
        if (!table.getFieldsName().contains("ID_TARIF")) {
61 ilm 3470 
            t.addForeignColumn("ID_TARIF", root.findTable("TARIF", true));
19 ilm 3471 
            alter = true;
3472 
        }
3473 
 
3474 
        if (alter) {
3475 
            try {
3476 
                table.getBase().getDataSource().execute(t.asString());
3477 
                table.getSchema().updateVersion();
3478 
                table.fetchFields();
3479 
            } catch (SQLException ex) {
3480 
                throw new IllegalStateException("Erreur lors de l'ajout des champs à la table " + table.getName(), ex);
3481 
            }
3482 
        }
3483 
    }
3484 
 
41 ilm 3485 
    private void addVenteEltField(SQLTable table, DBRoot root) throws SQLException {
19 ilm 3486 
 
3487 
        boolean alter = false;
3488 
        AlterTable t = new AlterTable(table);
3489 
        if (!table.getFieldsName().contains("QTE_ACHAT")) {
3490 
            t.addColumn("QTE_ACHAT", "integer DEFAULT 1");
3491 
            alter = true;
3492 
        }
61 ilm 3493 
        if (!table.getFieldsName().contains("QTE_UNITAIRE")) {
3494 
            t.addColumn("QTE_UNITAIRE", "numeric(16,6) DEFAULT 1");
3495 
            alter = true;
3496 
        }
3497 
        if (!table.getFieldsName().contains("ID_UNITE_VENTE")) {
3498 
            t.addForeignColumn("ID_UNITE_VENTE", root.findTable("UNITE_VENTE", true).getSQLName(), "ID", "2");
3499 
            alter = true;
3500 
        }
3501 
        if (!table.getFieldsName().contains("ID_ARTICLE")) {
3502 
            t.addForeignColumn("ID_ARTICLE", root.findTable("ARTICLE", true));
3503 
            alter = true;
3504 
        }
19 ilm 3505 
        if (!table.getFieldsName().contains("CODE_DOUANIER")) {
3506 
            t.addVarCharColumn("CODE_DOUANIER", 256);
3507 
            alter = true;
3508 
        }
21 ilm 3509 
        if (!table.getFieldsName().contains("DESCRIPTIF")) {
3510 
            t.addVarCharColumn("DESCRIPTIF", 2048);
3511 
            alter = true;
3512 
        }
19 ilm 3513 
        if (!table.getFieldsName().contains("ID_PAYS")) {
61 ilm 3514 
            t.addForeignColumn("ID_PAYS", root.findTable("PAYS", true));
19 ilm 3515 
            alter = true;
3516 
        }
21 ilm 3517 
        if (!table.getFieldsName().contains("MARGE_HT")) {
3518 
            t.addColumn("MARGE_HT", "bigint default 0");
3519 
            alter = true;
3520 
        }
19 ilm 3521 
 
3522 
        if (!table.getFieldsName().contains("ID_DEVISE")) {
61 ilm 3523 
            t.addForeignColumn("ID_DEVISE", root.findTable("DEVISE", true));
19 ilm 3524 
            alter = true;
3525 
        }
3526 
        if (!table.getFieldsName().contains("PV_U_DEVISE")) {
3527 
            t.addColumn("PV_U_DEVISE", "bigint default 0");
3528 
            alter = true;
3529 
        }
3530 
        if (!table.getFieldsName().contains("POURCENT_REMISE")) {
3531 
            t.addColumn("POURCENT_REMISE", "numeric(6,2) default 0");
3532 
            alter = true;
3533 
        }
3534 
        if (!table.getFieldsName().contains("PV_T_DEVISE")) {
3535 
            t.addColumn("PV_T_DEVISE", "bigint default 0");
3536 
            alter = true;
3537 
        }
3538 
        if (!table.getFieldsName().contains("TAUX_DEVISE")) {
3539 
            t.addColumn("TAUX_DEVISE", "numeric (16,8) DEFAULT 1");
3540 
            alter = true;
3541 
        }
80 ilm 3542 
 
3543 
        if (!table.getFieldsName().contains("POIDS_COLIS_NET")) {
3544 
            t.addColumn("POIDS_COLIS_NET", "numeric (16,8) DEFAULT 1");
3545 
            alter = true;
3546 
        }
3547 
 
3548 
        if (!table.getFieldsName().contains("T_POIDS_COLIS_NET")) {
3549 
            t.addColumn("T_POIDS_COLIS_NET", "numeric (16,8) DEFAULT 1");
3550 
            alter = true;
3551 
        }
3552 
 
3553 
        if (!table.getFieldsName().contains("NB_COLIS")) {
3554 
            t.addColumn("NB_COLIS", "integer DEFAULT 0");
3555 
            alter = true;
3556 
        }
19 ilm 3557 
        if (alter) {
3558 
            try {
3559 
                root.getDBSystemRoot().getDataSource().execute(t.asString());
3560 
                table.getSchema().updateVersion();
3561 
                table.fetchFields();
3562 
            } catch (SQLException ex) {
3563 
                throw new IllegalStateException("Erreur lors de l'ajout des champs à la table " + table.getName(), ex);
3564 
            }
3565 
        }
67 ilm 3566 
        patchFieldElt1Dot3(table, root);
19 ilm 3567 
    }
3568 
 
156 ilm 3569 
    private void updateSocieteSchema(final Configuration conf, final DBRoot root) throws IOException, Exception {
19 ilm 3570 
        final DBSystemRoot sysRoot = root.getDBSystemRoot();
3571 
        final SQLDataSource ds = sysRoot.getDataSource();
3572 
        System.out.println("InstallationPanel.InstallationPanel() UPDATE COMMERCIAL " + root);
3573 
        // Fix commercial Ordre
57 ilm 3574 
 
19 ilm 3575 
        SQLTable tableCommercial = root.getTable("COMMERCIAL");
3576 
        CorrectOrder orderCorrect = new CorrectOrder(sysRoot);
3577 
        orderCorrect.change(tableCommercial);
3578 
 
80 ilm 3579 
        sysRoot.reload(Collections.singleton(root.getName()));
19 ilm 3580 
 
3581 
        try {
3582 
            // Add article
3583 
            final SQLTable tableArticle = root.getTable("ARTICLE");
3584 
            if (!tableArticle.getFieldsName().contains("INFOS")) {
3585 
                AlterTable t = new AlterTable(tableArticle);
3586 
                t.addVarCharColumn("INFOS", 2048);
3587 
                try {
3588 
                    ds.execute(t.asString());
3589 
                } catch (Exception ex) {
3590 
                    throw new IllegalStateException("Erreur lors de l'ajout du champ INFO à la table ARTICLE", ex);
3591 
                }
3592 
            }
3593 
 
3594 
            if (sysRoot.getServer().getSQLSystem().equals(SQLSystem.POSTGRESQL)) {
3595 
                // Fix Caisse serial
3596 
                SQLTable tableCaisse = root.getTable("CAISSE");
3597 
 
3598 
                FixSerial f = new FixSerial(sysRoot);
3599 
                try {
3600 
                    f.change(tableCaisse);
3601 
                } catch (SQLException e2) {
3602 
                    throw new IllegalStateException("Erreur lors la mise à jours des sequences de la table CAISSE", e2);
3603 
                }
3604 
            }
3605 
            System.out.println("InstallationPanel.InstallationPanel() UPDATE TICKET_CAISSE " + root);
3606 
            // add Mvt on Ticket
3607 
            SQLTable tableTicket = root.getTable("TICKET_CAISSE");
3608 
            if (!tableTicket.getFieldsName().contains("ID_MOUVEMENT")) {
3609 
                AlterTable t = new AlterTable(tableTicket);
3610 
                t.addForeignColumn("ID_MOUVEMENT", root.getTable("MOUVEMENT"));
3611 
                try {
3612 
                    ds.execute(t.asString());
3613 
                } catch (Exception ex) {
3614 
                    throw new IllegalStateException("Erreur lors de l'ajout du champ ID_MOUVEMENT à la table TICKET_CAISSE", ex);
3615 
                }
3616 
            }
3617 
 
3618 
            // Check type de reglement
3619 
 
3620 
            System.out.println("InstallationPanel.InstallationPanel() UPDATE TYPE_REGLEMENT " + root);
3621 
            SQLTable tableReglmt = root.getTable("TYPE_REGLEMENT");
3622 
            SQLSelect sel = new SQLSelect(tableReglmt.getBase());
3623 
            sel.addSelect(tableReglmt.getKey());
3624 
            sel.setWhere(new Where(tableReglmt.getField("NOM"), "=", "Virement"));
3625 
            List<Number> l = (List<Number>) ds.executeCol(sel.asString());
3626 
            if (l.size() == 0) {
3627 
                SQLRowValues rowVals = new SQLRowValues(tableReglmt);
3628 
                rowVals.put("NOM", "Virement");
3629 
                rowVals.put("COMPTANT", Boolean.FALSE);
3630 
                rowVals.put("ECHEANCE", Boolean.FALSE);
3631 
                try {
3632 
                    rowVals.commit();
3633 
                } catch (SQLException e) {
3634 
                    throw new IllegalStateException("Erreur lors de l'ajout du type de paiement par virement", e);
3635 
                }
3636 
            }
3637 
 
67 ilm 3638 
            SQLSelect sel2 = new SQLSelect();
19 ilm 3639 
            sel2.addSelect(tableReglmt.getKey());
3640 
            sel2.setWhere(new Where(tableReglmt.getField("NOM"), "=", "CESU"));
67 ilm 3641 
            @SuppressWarnings("unchecked")
19 ilm 3642 
            List<Number> l2 = (List<Number>) ds.executeCol(sel2.asString());
3643 
            if (l2.size() == 0) {
3644 
                SQLRowValues rowVals = new SQLRowValues(tableReglmt);
3645 
                rowVals.put("NOM", "CESU");
3646 
                rowVals.put("COMPTANT", Boolean.FALSE);
3647 
                rowVals.put("ECHEANCE", Boolean.FALSE);
3648 
                try {
3649 
                    rowVals.commit();
3650 
                } catch (SQLException e) {
3651 
                    throw new IllegalStateException("Erreur lors de l'ajout du type CESU", e);
3652 
                }
3653 
            }
3654 
            System.out.println("InstallationPanel.InstallationPanel() UPDATE FAMILLE_ARTICLE " + root);
3655 
            //
3656 
            final SQLTable tableFam = root.getTable("FAMILLE_ARTICLE");
3657 
            final int nomSize = 256;
3658 
            if (tableFam.getField("NOM").getType().getSize() < nomSize) {
3659 
                final AlterTable t = new AlterTable(tableFam);
3660 
                t.alterColumn("NOM", EnumSet.allOf(Properties.class), "varchar(" + nomSize + ")", "''", false);
3661 
                try {
3662 
                    ds.execute(t.asString());
3663 
                } catch (Exception ex) {
3664 
                    throw new IllegalStateException("Erreur lors de la modification du champs NOM sur la table FAMILLE_ARTICLE", ex);
3665 
                }
3666 
            }
3667 
 
3668 
            // Suppression des champs 1.0
3669 
            System.out.println("InstallationPanel.InstallationPanel() UPDATE FROM 1.0 " + root);
3670 
            final List<ChangeTable<?>> changes = new ArrayList<ChangeTable<?>>();
3671 
 
61 ilm 3672 
            final ModuleManager instance = new ModuleManager();
156 ilm 3673 
            instance.setup(root, conf);
80 ilm 3674 
            final Collection<ModuleReference> refs = instance.getModulesInstalledRemotely();
61 ilm 3675 
            final Set<String> allUsedTable = new HashSet<String>();
67 ilm 3676 
            for (ModuleReference ref : refs) {
80 ilm 3677 
                Set<String> tableNames = instance.getCreatedItems(ref.getID()).get0();
61 ilm 3678 
                allUsedTable.addAll(tableNames);
3679 
            }
80 ilm 3680 
            System.out.println("Tables created by modules:" + allUsedTable);
19 ilm 3681 
 
156 ilm 3682 
            final Set<String> notMigrated = instance.migrateOldTransientDirs();
3683 
            if (!notMigrated.isEmpty())
3684 
                System.out.println("Couldn't migrate old backed up/failed modules: " + notMigrated);
3685 
 
19 ilm 3686 
            final List<String> alterRequests = ChangeTable.cat(changes, root.getName());
3687 
            try {
3688 
                for (final String req : alterRequests) {
3689 
                    ds.execute(req);
3690 
                }
3691 
            } catch (Exception e1) {
3692 
                throw new IllegalStateException("Erreur lors de la mise à jour des tables v1.0", e1);
3693 
            }
3694 
            System.out.println("InstallationPanel.InstallationPanel() UPDATE CAISSE " + root);
3695 
            // Undefined
3696 
            try {
3697 
                SQLTable.setUndefID(tableTicket.getSchema(), tableTicket.getName(), 1);
3698 
                SQLTable.setUndefID(tableTicket.getSchema(), "CAISSE", 1);
3699 
            } catch (SQLException e1) {
3700 
                throw new IllegalStateException("Erreur lors de la mise à jour des indéfinis de la table CAISSE", e1);
3701 
            }
83 ilm 3702 
        } catch (Exception e) {
3703 
            ExceptionHandler.handle("updateSocieteSchema on root " + root + " failed", e);
19 ilm 3704 
        } finally {
3705 
            // Mise à jour du schéma
3706 
            root.getSchema().updateVersion();
3707 
            root.refetch();
3708 
        }
3709 
    }
3710 
 
73 ilm 3711 
    private void checkRights(DBRoot root) throws SQLException {
80 ilm 3712 
        SQLTable table = root.findTable("RIGHT");
73 ilm 3713 
        SQLSelect sel = new SQLSelect();
3714 
        sel.addSelect(table.getKey());
3715 
        sel.addSelect(table.getField("CODE"));
3716 
        List<SQLRow> rows = SQLRowListRSH.execute(sel);
3717 
        Set<String> codes = new HashSet<String>();
3718 
        for (SQLRow row : rows) {
3719 
            codes.add(row.getString("CODE"));
3720 
        }
3721 
 
3722 
        if (!codes.contains("UPDATE_ROW")) {
3723 
            SQLRowValues rowVals = new SQLRowValues(table);
3724 
            rowVals.put("CODE", "UPDATE_ROW");
3725 
            rowVals.put("NOM", "Modification d'une ligne");
3726 
            String desc = "Autorise un utilisateur à modifier les éléments de la table spécifiée en objet.";
3727 
            rowVals.put("DESCRIPTION", desc);
3728 
            rowVals.commit();
3729 
        }
3730 
        if (!codes.contains("DELETE_ROW")) {
3731 
            SQLRowValues rowVals = new SQLRowValues(table);
3732 
            rowVals.put("CODE", "DELETE_ROW");
3733 
            rowVals.put("NOM", "Suppression d'une ligne");
3734 
            String desc = "Autorise un utilisateur à supprimer les éléments de la table spécifiée en objet.";
3735 
            rowVals.put("DESCRIPTION", desc);
3736 
            rowVals.commit();
3737 
        }
3738 
        if (!codes.contains("INSERT_ROW")) {
3739 
            SQLRowValues rowVals = new SQLRowValues(table);
3740 
            rowVals.put("CODE", "INSERT_ROW");
3741 
            rowVals.put("NOM", "Ajout d'une ligne");
3742 
            String desc = "Autorise un utilisateur à ajouter un élément dans la table spécifiée en objet.";
3743 
            rowVals.put("DESCRIPTION", desc);
3744 
            rowVals.commit();
3745 
        }
93 ilm 3746 
        if (!codes.contains("SAVE_ROW")) {
3747 
            SQLRowValues rowVals = new SQLRowValues(table);
3748 
            rowVals.put("CODE", "SAVE_ROW");
3749 
            rowVals.put("NOM", "Export des listes");
3750 
            String desc = "Autorise un utilisateur à exporter le contenu des listes via le bouton représentant une disquette.";
3751 
            rowVals.put("DESCRIPTION", desc);
3752 
            SQLRow row = rowVals.commit();
3753 
            SQLRowValues rowValsUserRight = new SQLRowValues(table.getTable("USER_RIGHT"));
3754 
            rowValsUserRight.put("ID_RIGHT", row.getID());
3755 
            rowValsUserRight.put("HAVE_RIGHT", Boolean.TRUE);
3756 
            rowValsUserRight.commit();
3757 
        }
3758 
 
3759 
        if (!codes.contains("MENU_ACCESS")) {
3760 
            SQLRowValues rowVals = new SQLRowValues(table);
3761 
            rowVals.put("CODE", "MENU_ACCESS");
3762 
            rowVals.put("NOM", "Autoriser l'accés à un menu");
3763 
            String desc = "Autorise un utilisateur à visualiser le menu spécifié en objet.";
3764 
            rowVals.put("DESCRIPTION", desc);
3765 
            SQLRow row = rowVals.commit();
3766 
            SQLRowValues rowValsUserRight = new SQLRowValues(table.getTable("USER_RIGHT"));
3767 
            rowValsUserRight.put("ID_RIGHT", row.getID());
3768 
            rowValsUserRight.put("HAVE_RIGHT", Boolean.TRUE);
3769 
            rowValsUserRight.commit();
3770 
        }
142 ilm 3771 
        if (!codes.contains(GroupSQLComponent.ITEM_RIGHT_CODE)) {
93 ilm 3772 
            SQLRowValues rowVals = new SQLRowValues(table);
142 ilm 3773 
            rowVals.put("CODE", GroupSQLComponent.ITEM_RIGHT_CODE);
93 ilm 3774 
            rowVals.put("NOM", "Autoriser à visualiser un champ");
3775 
            String desc = "Autorise un utilisateur à visualiser le champ spécifié en objet dans une interface.";
3776 
            rowVals.put("DESCRIPTION", desc);
3777 
            SQLRow row = rowVals.commit();
3778 
            SQLRowValues rowValsUserRight = new SQLRowValues(table.getTable("USER_RIGHT"));
3779 
            rowValsUserRight.put("ID_RIGHT", row.getID());
3780 
            rowValsUserRight.put("HAVE_RIGHT", Boolean.TRUE);
3781 
            rowValsUserRight.commit();
3782 
        }
94 ilm 3783 
        if (!codes.contains("CORPS_EDITER_PRIX_VENTE")) {
3784 
            SQLRowValues rowVals = new SQLRowValues(table);
3785 
            rowVals.put("CODE", "CORPS_EDITER_PRIX_VENTE");
3786 
            rowVals.put("NOM", "Autoriser à éditer les prix de vente dans les pièces commerciales.");
3787 
            String desc = "Autorise un utilisateur à éditer les prix de vente dans les pièces commerciales.";
3788 
            rowVals.put("DESCRIPTION", desc);
3789 
            SQLRow row = rowVals.commit();
3790 
            SQLRowValues rowValsUserRight = new SQLRowValues(table.getTable("USER_RIGHT"));
3791 
            rowValsUserRight.put("ID_RIGHT", row.getID());
3792 
            rowValsUserRight.put("HAVE_RIGHT", Boolean.TRUE);
3793 
            rowValsUserRight.commit();
3794 
        }
3795 
        if (!codes.contains("CORPS_VOIR_PRIX_ACHAT")) {
3796 
            SQLRowValues rowVals = new SQLRowValues(table);
3797 
            rowVals.put("CODE", "CORPS_VOIR_PRIX_ACHAT");
3798 
            rowVals.put("NOM", "Autoriser à voir les prix d'achat dans les pièces commerciales.");
3799 
            String desc = "Autorise un utilisateur à voir les prix d'achat dans les pièces commerciales.";
3800 
            rowVals.put("DESCRIPTION", desc);
3801 
            SQLRow row = rowVals.commit();
3802 
            SQLRowValues rowValsUserRight = new SQLRowValues(table.getTable("USER_RIGHT"));
3803 
            rowValsUserRight.put("ID_RIGHT", row.getID());
3804 
            rowValsUserRight.put("HAVE_RIGHT", Boolean.TRUE);
3805 
            rowValsUserRight.commit();
3806 
        }
3807 
        if (!codes.contains("CORPS_VERROU_PRIX_MIN_VENTE")) {
3808 
            SQLRowValues rowVals = new SQLRowValues(table);
3809 
            rowVals.put("CODE", "CORPS_VERROU_PRIX_MIN_VENTE");
3810 
            rowVals.put("NOM", "Autoriser à mettre un prix de vente inférieur au prix minimum dans les pièces commerciales.");
3811 
            String desc = "Autorise un utilisateur à mettre un prix de vente inférieur au prix minimum dans les pièces commerciales.";
3812 
            rowVals.put("DESCRIPTION", desc);
3813 
            SQLRow row = rowVals.commit();
3814 
            SQLRowValues rowValsUserRight = new SQLRowValues(table.getTable("USER_RIGHT"));
3815 
            rowValsUserRight.put("ID_RIGHT", row.getID());
3816 
            rowValsUserRight.put("HAVE_RIGHT", Boolean.TRUE);
3817 
            rowValsUserRight.commit();
3818 
        }
3819 
        // if (!codes.contains("MODIF_PRODUCT_KIT")) {
3820 
        // SQLRowValues rowVals = new SQLRowValues(table);
3821 
        // rowVals.put("CODE", "MODIF_PRODUCT_KIT");
3822 
        // rowVals.put("NOM", "Autoriser à modifier les kits créer par autres utilisateurs.");
3823 
        // String desc =
3824 
        // "Autorise un utilisateur à modifier les kits créer par autres utilisateurs.";
3825 
        // rowVals.put("DESCRIPTION", desc);
3826 
        // SQLRow row = rowVals.commit();
3827 
        // SQLRowValues rowValsUserRight = new SQLRowValues(table.getTable("USER_RIGHT"));
3828 
        // rowValsUserRight.put("ID_RIGHT", row.getID());
3829 
        // rowValsUserRight.put("HAVE_RIGHT", Boolean.TRUE);
3830 
        // rowValsUserRight.commit();
3831 
        // }
3832 
 
132 ilm 3833 
        if (!codes.contains("SYNC_TEMPLATE")) {
3834 
            SQLRowValues rowVals = new SQLRowValues(table);
3835 
            rowVals.put("CODE", "SYNC_TEMPLATE");
3836 
            rowVals.put("NOM", "Synchroniser les modèles vers le serveur");
3837 
            String desc = "Autorise un utilisateur à synchroniser les modèles.";
3838 
            rowVals.put("DESCRIPTION", desc);
3839 
            SQLRow row = rowVals.commit();
3840 
            SQLRowValues rowValsUserRight = new SQLRowValues(table.getTable("USER_RIGHT"));
3841 
            rowValsUserRight.put("ID_RIGHT", row.getID());
3842 
            rowValsUserRight.put("HAVE_RIGHT", Boolean.TRUE);
3843 
            rowValsUserRight.commit();
3844 
        }
3845 
 
174 ilm 3846 
        if (!codes.contains(TableAllRights.USER_UI_LOCK_ROW)) {
3847 
            SQLRowValues rowVals = new SQLRowValues(table);
3848 
            rowVals.put("CODE", TableAllRights.USER_UI_LOCK_ROW);
3849 
            rowVals.put("NOM", "Autoriser à verrouiller une ligne dans une liste.");
3850 
            String desc = "Autorise un utilisateur à verrouiller une ou plusieurs dans les listes où cette fonctionnalité est active.";
3851 
            rowVals.put("DESCRIPTION", desc);
3852 
            SQLRow row = rowVals.commit();
3853 
            SQLRowValues rowValsUserRight = new SQLRowValues(table.getTable("USER_RIGHT"));
3854 
            rowValsUserRight.put("ID_RIGHT", row.getID());
3855 
            rowValsUserRight.put("HAVE_RIGHT", Boolean.TRUE);
3856 
            rowValsUserRight.commit();
3857 
        }
3858 
 
3859 
        if (!codes.contains(TableAllRights.USER_UI_UNLOCK_ROW)) {
3860 
            SQLRowValues rowVals = new SQLRowValues(table);
3861 
            rowVals.put("CODE", TableAllRights.USER_UI_UNLOCK_ROW);
3862 
            rowVals.put("NOM", "Autoriser à déverrouiller une ligne dans une liste.");
3863 
            String desc = "Autorise un utilisateur à déverrouiller une ou plusieurs dans les listes où cette fonctionnalité est active.";
3864 
            rowVals.put("DESCRIPTION", desc);
3865 
            SQLRow row = rowVals.commit();
3866 
            SQLRowValues rowValsUserRight = new SQLRowValues(table.getTable("USER_RIGHT"));
3867 
            rowValsUserRight.put("ID_RIGHT", row.getID());
3868 
            rowValsUserRight.put("HAVE_RIGHT", Boolean.TRUE);
3869 
            rowValsUserRight.commit();
3870 
        }
3871 
 
73 ilm 3872 
    }
3873 
 
57 ilm 3874 
    private void findBadForeignKey(DBRoot root) {
3875 
        Set<SQLTable> tables = root.getTables();
3876 
        for (SQLTable table : tables) {
3877 
            findBadForeignKey(root, table);
3878 
        }
3879 
 
3880 
    }
3881 
 
3882 
    private void findBadForeignKey(DBRoot root, SQLTable table) {
3883 
        System.out.println("====================================== " + table.getName());
3884 
        Set<SQLField> ffields = table.getForeignKeys();
3885 
 
3886 
        Set<String> keysString = SQLKey.foreignKeys(table);
3887 
        for (String string : keysString) {
3888 
            ffields.add(table.getField(string));
3889 
        }
3890 
 
3891 
        if (ffields.size() == 0) {
3892 
            System.out.println("No foreign fields");
3893 
        }
3894 
        System.out.println("Foreign field for table " + table.getName() + ":" + ffields);
3895 
        // Map Champs-> Table sur lequel il pointe
3896 
        Map<SQLField, SQLTable> map = new HashMap<SQLField, SQLTable>();
3897 
        Set<SQLTable> extTables = new HashSet<SQLTable>();
3898 
        for (SQLField sqlField : ffields) {
3899 
            SQLTable t = null;
3900 
            try {
3901 
                t = SQLKey.keyToTable(sqlField);
3902 
            } catch (Exception e) {
3903 
                System.out.println("Ignoring field:" + sqlField.getName());
3904 
            }
3905 
            if (t == null) {
3906 
                System.out.println("Unable to find table for ff " + sqlField.getName());
3907 
            } else {
3908 
                extTables.add(t);
3909 
                map.put(sqlField, t);
3910 
            }
3911 
        }
3912 
        // Verification des datas
3913 
        System.out.println("Foreign table for table " + table.getName() + ":" + extTables);
3914 
        // Recupere les ids de toutes les tables
3915 
        Map<SQLTable, Set<Number>> ids = getIdsForTables(extTables);
3916 
 
3917 
        //
67 ilm 3918 
        SQLSelect s = new SQLSelect(true);
57 ilm 3919 
        if (table.getPrimaryKeys().size() != 1) {
3920 
            return;
3921 
        }
3922 
        s.addSelect(table.getKey());
3923 
        for (SQLField sqlField : map.keySet()) {
3924 
            s.addSelect(sqlField);
3925 
        }
3926 
        List<Map> result = root.getDBSystemRoot().getDataSource().execute(s.asString());