OpenConcerto

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

svn://code.openconcerto.org/openconcerto

Rev

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