WebSVN - OpenConcerto - Diff - Rev 177 and 182 - /trunk/OpenConcerto/src/org/openconcerto/erp/config/InstallationPanel.java

 /*
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
- * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.
+ * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.
+ *
  * The contents of this file are subject to the terms of the GNU General Public License Version 3
  * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
  * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
  * language governing permissions and limitations under the License.
 import org.openconcerto.erp.core.humanresources.payroll.report.LignePayeSimplifiee;
 import org.openconcerto.erp.core.sales.order.ui.EtatCommandeClient;
 import org.openconcerto.erp.core.sales.quote.element.EtatDevisSQLElement;
 import org.openconcerto.erp.modules.ModuleManager;
 import org.openconcerto.erp.modules.ModuleReference;
-import org.openconcerto.sql.Configuration;
+import org.openconcerto.erp.rights.DepotStockViewRightEditor;
 import org.openconcerto.sql.changer.convert.AddFK;
+import org.openconcerto.sql.changer.convert.AddMDFields;
 import org.openconcerto.sql.changer.convert.ChangeIDToInt;
+import org.openconcerto.sql.changer.convert.MergeTable;
 import org.openconcerto.sql.changer.correct.CorrectOrder;
 import org.openconcerto.sql.changer.correct.FixSerial;
 import org.openconcerto.sql.element.GroupSQLComponent;
 import org.openconcerto.sql.model.AliasedTable;
 import org.openconcerto.sql.model.DBRoot;
                     @Override
                     public void run() {
                         System.setProperty(SQLSchema.NOAUTO_CREATE_METADATA, "false");
                         final ComptaPropsConfiguration conf = ComptaPropsConfiguration.create(true);
-                        final DBSystemRoot systemRoot = conf.getSystemRoot();
-                        if (systemRoot.getChild(conf.getRootNameValue().getValue()) == null) {
-                            conf.destroy();
-                            SwingUtilities.invokeLater(new Runnable() {
-                                @Override
-                                public void run() {
-                                    up.setEnabled(true);
-                                    bar.setValue(bar.getMaximum());
-                                    JOptionPane.showMessageDialog(InstallationPanel.this, "Votre base de données n'est pas initialisée");
-                                }
-                            });
-                            return;
-                        }
                         updateDatabase(conf);
                         conf.destroy();
                         SwingUtilities.invokeLater(new Runnable() {
+            }
+        }
         patchFieldElt1Dot3(table, root);
+    }
-    private void updateSocieteSchema(final Configuration conf, final DBRoot root) throws IOException, Exception {
+    private void updateSocieteSchema(final DBRoot root) throws IOException, Exception {
         final DBSystemRoot sysRoot = root.getDBSystemRoot();
         final SQLDataSource ds = sysRoot.getDataSource();
         System.out.println("InstallationPanel.InstallationPanel() UPDATE COMMERCIAL " + root);
         // Fix commercial Ordre
             // Suppression des champs 1.0
             System.out.println("InstallationPanel.InstallationPanel() UPDATE FROM 1.0 " + root);
             final List<ChangeTable<?>> changes = new ArrayList<ChangeTable<?>>();
             final ModuleManager instance = new ModuleManager();
-            instance.setup(root, conf);
+            instance.setRoot(root);
             final Collection<ModuleReference> refs = instance.getModulesInstalledRemotely();
             final Set<String> allUsedTable = new HashSet<String>();
             for (ModuleReference ref : refs) {
                 Set<String> tableNames = instance.getCreatedItems(ref.getID()).get0();
                 allUsedTable.addAll(tableNames);
+            }
             System.out.println("Tables created by modules:" + allUsedTable);
-            final Set<String> notMigrated = instance.migrateOldTransientDirs();
-            if (!notMigrated.isEmpty())
-                System.out.println("Couldn't migrate old backed up/failed modules: " + notMigrated);
             final List<String> alterRequests = ChangeTable.cat(changes, root.getName());
             try {
                 for (final String req : alterRequests) {
                     ds.execute(req);
+                }
             rowValsUserRight.put("ID_RIGHT", row.getID());
             rowValsUserRight.put("HAVE_RIGHT", Boolean.TRUE);
             rowValsUserRight.commit();
+        }
+        if (!codes.contains(DepotStockViewRightEditor.ID_RIGHT)) {
+            SQLRowValues rowVals = new SQLRowValues(table);
+            rowVals.put("CODE", DepotStockViewRightEditor.ID_RIGHT);
+            rowVals.put("NOM", "Voir le stock d'un dépôt");
+            String desc = "Autorise un utilisateur à visualiser le stock d'un dépôt.";
+            rowVals.put("DESCRIPTION", desc);
+            SQLRow row = rowVals.commit();
+            SQLRowValues rowValsUserRight = new SQLRowValues(table.getTable("USER_RIGHT"));
+            rowValsUserRight.put("ID_RIGHT", row.getID());
+            rowValsUserRight.put("HAVE_RIGHT", Boolean.TRUE);
+            rowValsUserRight.commit();
+        }
         if (!codes.contains("MENU_ACCESS")) {
             SQLRowValues rowVals = new SQLRowValues(table);
             rowVals.put("CODE", "MENU_ACCESS");
             rowVals.put("NOM", "Autoriser l'accés à un menu");
             String desc = "Autorise un utilisateur à visualiser le menu spécifié en objet.";
             SQLRowValues rowValsUserRight = new SQLRowValues(table.getTable("USER_RIGHT"));
             rowValsUserRight.put("ID_RIGHT", row.getID());
             rowValsUserRight.put("HAVE_RIGHT", Boolean.TRUE);
             rowValsUserRight.commit();
+        }
         // if (!codes.contains("MODIF_PRODUCT_KIT")) {
         // SQLRowValues rowVals = new SQLRowValues(table);
         // rowVals.put("CODE", "MODIF_PRODUCT_KIT");
         // rowVals.put("NOM", "Autoriser à modifier les kits créer par autres utilisateurs.");
         // String desc =
+    }
     public void updateDatabase(final ComptaPropsConfiguration conf) {
         try {
-            final DBSystemRoot systemRoot = conf.getSystemRoot();
+            final SQLDataSource ds = conf.getSystemRoot().getDataSource();
-            System.err.println("SystemRoot:" + systemRoot);
+            System.err.println("SystemRoot:" + conf.getSystemRoot());
-            final DBRoot rootCommon = conf.getRoot();
-            System.err.println("Root:" + rootCommon);
+            System.err.println("Root:" + conf.getRoot());
-            final SQLDataSource ds = systemRoot.getDataSource();
             // FixUnbounded varchar
-            fixUnboundedVarchar(rootCommon);
+            fixUnboundedVarchar(conf.getRoot());
             // FIXME DROP CONSTRAINT UNIQUE ORDRE ON
             // CONTACT_FOURNISSEUR
-            checkCompteDefault(rootCommon);
+            checkCompteDefault(conf.getRoot());
-            updateSocieteTable(rootCommon);
+            updateSocieteTable(conf.getRoot());
-            updateVille(rootCommon.getTable("ADRESSE"));
+            updateVille(conf.getRoot().getTable("ADRESSE"));
             // Champ user 1.4.1
-            final SQLTable tableUser = rootCommon.getTable("USER_COMMON");
+            final SQLTable tableUser = conf.getRoot().getTable("USER_COMMON");
             if (tableUser != null) {
                 final AlterTable alter = new AlterTable(tableUser);
                 boolean alterUser = false;
                 if (!tableUser.contains("DISABLED")) {
                     alter.addBooleanColumn("DISABLED", Boolean.FALSE, false);
                     alterUser = true;
+                }
                 if (alterUser) {
                     final String req = alter.asString();
-                    rootCommon.getDBSystemRoot().getDataSource().execute(req);
+                    conf.getRoot().getDBSystemRoot().getDataSource().execute(req);
-                    rootCommon.refetchTable(tableUser.getName());
+                    conf.getRoot().refetchTable(tableUser.getName());
-                    rootCommon.getSchema().updateVersion();
+                    conf.getRoot().getSchema().updateVersion();
+                }
+            }
             // Champ Paye
-            final SQLTable tableCaisse = rootCommon.getTable("CAISSE_COTISATION");
+            final SQLTable tableCaisse = conf.getRoot().getTable("CAISSE_COTISATION");
             if (!tableCaisse.contains("NUMERO_COMPTE_PCE")) {
                 final AlterTable alter = new AlterTable(tableCaisse);
                 alter.addVarCharColumn("NUMERO_COMPTE_PCE", 128);
                 alter.addVarCharColumn("NUMERO_COMPTE_PCE_CHARGES", 128);
                 final String req = alter.asString();
-                rootCommon.getDBSystemRoot().getDataSource().execute(req);
+                conf.getRoot().getDBSystemRoot().getDataSource().execute(req);
-                rootCommon.refetchTable(tableCaisse.getName());
+                conf.getRoot().refetchTable(tableCaisse.getName());
-                rootCommon.getSchema().updateVersion();
+                conf.getRoot().getSchema().updateVersion();
+            }
-            final SQLTable tableRC = rootCommon.getTable("RUBRIQUE_COTISATION");
+            final SQLTable tableRC = conf.getRoot().getTable("RUBRIQUE_COTISATION");
             if (!tableRC.contains("PART_CSG_SANS_ABATTEMENT")) {
                 final AlterTable alter = new AlterTable(tableRC);
                 alter.addBooleanColumn("PART_CSG_SANS_ABATTEMENT", Boolean.FALSE, false);
                 final String req = alter.asString();
-                rootCommon.getDBSystemRoot().getDataSource().execute(req);
+                conf.getRoot().getDBSystemRoot().getDataSource().execute(req);
-                rootCommon.refetchTable(tableRC.getName());
+                conf.getRoot().refetchTable(tableRC.getName());
-                rootCommon.getSchema().updateVersion();
+                conf.getRoot().getSchema().updateVersion();
+            }
+            // if (!tableRC.contains("DATE_DEBUT_REGUL")) {
+            // final AlterTable alter = new AlterTable(tableRC);
+            // alter.addColumn("DATE_DEBUT_REGUL", "date");
+            // alter.addColumn("DATE_FIN_REGUL", "date");
+            // final String req = alter.asString();
+            // conf.getRoot().getDBSystemRoot().getDataSource().execute(req);
+            // conf.getRoot().refetchTable(tableRC.getName());
+            // conf.getRoot().getSchema().updateVersion();
+            // }
             // Paye simplifiee
             List<SQLRow> rowRubriqueReduGvt = new ArrayList<>();
+            {
-                final SQLTable tableRCom = rootCommon.getTable("RUBRIQUE_COMM");
+                final SQLTable tableRCom = conf.getRoot().getTable("RUBRIQUE_COMM");
                 if (!tableRCom.contains("REDUCTION_GVT_COM")) {
                     final AlterTable alter = new AlterTable(tableRCom);
                     alter.addBooleanColumn("REDUCTION_GVT_COM", Boolean.FALSE, false);
                     final String req = alter.asString();
-                    rootCommon.getDBSystemRoot().getDataSource().execute(req);
+                    conf.getRoot().getDBSystemRoot().getDataSource().execute(req);
-                    rootCommon.refetchTable(tableRCom.getName());
+                    conf.getRoot().refetchTable(tableRCom.getName());
-                    rootCommon.getSchema().updateVersion();
+                    conf.getRoot().getSchema().updateVersion();
                     SQLRowValues rowValsCommChom = new SQLRowValues(tableRCom);
                     rowValsCommChom.put("TAUX_SAL", "1.45;");
                     rowValsCommChom.put("NB_BASE", "SAL_BRUT;");
                     rowValsCommChom.put("NOM", "Assurance chômage reduction 2018");
                     rowValsCommCSG.put("REDUCTION_GVT_COM", Boolean.TRUE);
                     rowValsCommCSG.putRowValues("ID_PERIODE_VALIDITE").put("JANVIER", Boolean.TRUE);
                     rowRubriqueReduGvt.add(rowValsCommCSG.commit());
                     SQLSelect sel = new SQLSelect();
-                    sel.addSelect(rootCommon.getTable("PROFIL_PAYE").getKey());
+                    sel.addSelect(conf.getRoot().getTable("PROFIL_PAYE").getKey());
                     List<SQLRow> rowsProfil = SQLRowListRSH.execute(sel);
                     int pos = 70;
                     for (SQLRow rowRub : rowRubriqueReduGvt) {
                         for (SQLRow rowProfil : rowsProfil) {
-                            SQLRowValues rowValsRubGvt = new SQLRowValues(rootCommon.getTable("PROFIL_PAYE_ELEMENT"));
+                            SQLRowValues rowValsRubGvt = new SQLRowValues(conf.getRoot().getTable("PROFIL_PAYE_ELEMENT"));
                             rowValsRubGvt.put("ID_PROFIL_PAYE", rowProfil.getID());
                             rowValsRubGvt.put("POSITION", pos);
                             rowValsRubGvt.put("IDSOURCE", rowRub.getID());
                             rowValsRubGvt.put("SOURCE", rowRub.getTable().getName());
                             rowValsRubGvt.put("NOM", rowRub.getString("NOM"));
+                        }
                         pos++;
+                    }
+                }
-                final SQLTable tableRB = rootCommon.getTable("RUBRIQUE_BRUT");
+                final SQLTable tableRB = conf.getRoot().getTable("RUBRIQUE_BRUT");
                 if (!tableRB.contains("AVANTAGE_NATURE")) {
                     final AlterTable alter = new AlterTable(tableRB);
                     alter.addBooleanColumn("AVANTAGE_NATURE", Boolean.FALSE, false);
                     final String req = alter.asString();
-                    rootCommon.getDBSystemRoot().getDataSource().execute(req);
+                    conf.getRoot().getDBSystemRoot().getDataSource().execute(req);
-                    rootCommon.refetchTable(tableRB.getName());
+                    conf.getRoot().refetchTable(tableRB.getName());
-                    rootCommon.getSchema().updateVersion();
+                    conf.getRoot().getSchema().updateVersion();
+                }
                 if (!tableRC.contains("LIGNE_PAYE_SIMPLIFIEE")) {
                     final AlterTable alter = new AlterTable(tableRC);
                     alter.addBooleanColumn("ALLEGEMENT_COTISATION", Boolean.FALSE, false);
                     alter.addVarCharColumn("LIGNE_PAYE_SIMPLIFIEE", 256);
                     final String req = alter.asString();
-                    rootCommon.getDBSystemRoot().getDataSource().execute(req);
+                    conf.getRoot().getDBSystemRoot().getDataSource().execute(req);
-                    rootCommon.refetchTable(tableRC.getName());
+                    conf.getRoot().refetchTable(tableRC.getName());
-                    rootCommon.getSchema().updateVersion();
+                    conf.getRoot().getSchema().updateVersion();
                     Map<String, String> liaison = new HashMap<String, String>();
                     liaison.put("COTCSA", LignePayeSimplifiee.SANTE_SECURITE.getId());
                     liaison.put("COTMALADIE", LignePayeSimplifiee.SANTE_SECURITE.getId());
                     liaison.put("COTAF", LignePayeSimplifiee.FAMILLE_ALLOCATIONS.getId());
                     liaison.put("COTVEUV", LignePayeSimplifiee.SANTE_SECURITE.getId());
                     liaison.put("COTPREV", LignePayeSimplifiee.RETRAITE_SUPPLEMENTAIRE.getId());
                     liaison.put("COT_MUTUELLE", LignePayeSimplifiee.SANTE_COMPLEMENAIRE_SANTE.getId());
                     liaison.put("COT_PENIBLE", LignePayeSimplifiee.AUTRES_CONTRIBUTIONS.getId());
                     SQLSelect sel = new SQLSelect();
-                    sel.addSelect(rootCommon.findTable("RUBRIQUE_COTISATION").getField("CODE"));
+                    sel.addSelect(conf.getRoot().findTable("RUBRIQUE_COTISATION").getField("CODE"));
-                    sel.addSelect(rootCommon.findTable("RUBRIQUE_COTISATION").getField("NOM"));
+                    sel.addSelect(conf.getRoot().findTable("RUBRIQUE_COTISATION").getField("NOM"));
-                    sel.addSelect(rootCommon.findTable("RUBRIQUE_COTISATION").getKey());
+                    sel.addSelect(conf.getRoot().findTable("RUBRIQUE_COTISATION").getKey());
                     List<SQLRow> rubCotis = SQLRowListRSH.execute(sel);
                     for (SQLRow sqlRow : rubCotis) {
                         final String code = sqlRow.getString("CODE");
                         if (liaison.containsKey(code)) {
+                        }
+                    }
+                }
+            }
-            final SQLTable tableRnet = rootCommon.getTable("RUBRIQUE_NET");
+            final SQLTable tableRnet = conf.getRoot().getTable("RUBRIQUE_NET");
             if (!tableRnet.contains("NUMERO_COMPTE_PCE_CHARGES")) {
                 final AlterTable alter = new AlterTable(tableRnet);
                 alter.addVarCharColumn("NUMERO_COMPTE_PCE_CHARGES", 128);
                 final String req = alter.asString();
-                rootCommon.getDBSystemRoot().getDataSource().execute(req);
+                conf.getRoot().getDBSystemRoot().getDataSource().execute(req);
-                rootCommon.refetchTable(tableRnet.getName());
+                conf.getRoot().refetchTable(tableRnet.getName());
-                rootCommon.getSchema().updateVersion();
+                conf.getRoot().getSchema().updateVersion();
+            }
             if (!tableRC.contains("PART_PAT_IMPOSABLE")) {
                 final AlterTable alter = new AlterTable(tableRC);
                 alter.addBooleanColumn("PART_PAT_IMPOSABLE", Boolean.FALSE, false);
                 final String req = alter.asString();
-                rootCommon.getDBSystemRoot().getDataSource().execute(req);
+                conf.getRoot().getDBSystemRoot().getDataSource().execute(req);
-                rootCommon.refetchTable(tableRC.getName());
+                conf.getRoot().refetchTable(tableRC.getName());
-                rootCommon.getSchema().updateVersion();
+                conf.getRoot().getSchema().updateVersion();
+            }
             if (!tableRC.contains("REDUCTION_FILLON")) {
                 final AlterTable alter = new AlterTable(tableRC);
                 alter.addBooleanColumn("REDUCTION_FILLON", Boolean.FALSE, false);
                 final String req = alter.asString();
-                rootCommon.getDBSystemRoot().getDataSource().execute(req);
+                conf.getRoot().getDBSystemRoot().getDataSource().execute(req);
-                rootCommon.refetchTable(tableRC.getName());
+                conf.getRoot().refetchTable(tableRC.getName());
-                rootCommon.getSchema().updateVersion();
+                conf.getRoot().getSchema().updateVersion();
+            }
             // Vérification des droits existants
-            checkRights(rootCommon);
+            checkRights(conf.getRoot());
-            if (!rootCommon.contains("DEVISE")) {
+            if (!conf.getRoot().contains("DEVISE")) {
                 System.out.println("InstallationPanel.InstallationPanel() ADD DEVISE");
                 try {
                     SQLUtils.executeAtomic(ds, new SQLUtils.SQLFactory<Object>() {
                         @Override
                         public Object create() throws SQLException {
-                            final SQLCreateTable createDevise = new SQLCreateTable(rootCommon, "DEVISE");
+                            final SQLCreateTable createDevise = new SQLCreateTable(conf.getRoot(), "DEVISE");
                             createDevise.addVarCharColumn("CODE", 128);
                             createDevise.addVarCharColumn("NOM", 128);
                             createDevise.addVarCharColumn("LIBELLE", 128);
                             createDevise.addVarCharColumn("LIBELLE_CENT", 128);
                             createDevise.addDecimalColumn("TAUX", 16, 8, BigDecimal.ONE, false);
                             createDevise.addDecimalColumn("TAUX_COMMERCIAL", 16, 8, BigDecimal.ONE, false);
                             ds.execute(createDevise.asString());
                             insertUndef(createDevise);
-                            rootCommon.getSchema().updateVersion();
+                            conf.getRoot().getSchema().updateVersion();
                             return null;
+                        }
                     });
                 } catch (Exception ex) {
                     throw new IllegalStateException("Erreur lors de la création de la table DEVISE", ex);
+                }
-            } else if (!rootCommon.getTable("DEVISE").contains("TAUX_COMMERCIAL")) {
+            } else if (!conf.getRoot().getTable("DEVISE").contains("TAUX_COMMERCIAL")) {
-                final SQLTable tDevise = rootCommon.getTable("DEVISE");
+                final SQLTable tDevise = conf.getRoot().getTable("DEVISE");
                 final AlterTable alterDevise = new AlterTable(tDevise);
                 alterDevise.addDecimalColumn("TAUX_COMMERCIAL", 16, 8, BigDecimal.ONE, false);
                 ds.execute(alterDevise.asString());
                 tDevise.getSchema().updateVersion();
+            }
-            if (!rootCommon.contains("TYPE_MODELE")) {
+            if (!conf.getRoot().contains("TYPE_MODELE")) {
                 System.out.println("InstallationPanel.InstallationPanel() ADD TYPE_MODELE");
                 try {
                     SQLUtils.executeAtomic(ds, new SQLUtils.SQLFactory<Object>() {
                         @Override
                         public Object create() throws SQLException {
-                            final SQLCreateTable createTypeModele = new SQLCreateTable(rootCommon, "TYPE_MODELE");
+                            final SQLCreateTable createTypeModele = new SQLCreateTable(conf.getRoot(), "TYPE_MODELE");
                             createTypeModele.addVarCharColumn("NOM", 128);
                             createTypeModele.addVarCharColumn("TABLE", 128);
                             createTypeModele.addVarCharColumn("DEFAULT_MODELE", 128);
                             ds.execute(createTypeModele.asString());
                             insertUndef(createTypeModele);
-                            rootCommon.getSchema().updateVersion();
+                            conf.getRoot().getSchema().updateVersion();
-                            rootCommon.refetch();
+                            conf.getRoot().refetch();
                             return null;
+                        }
                     });
                     final String[] type = new String[] { "Avoir client", "AVOIR_CLIENT", "Avoir", "Bon de livraison", "BON_DE_LIVRAISON", "BonLivraison", "Commande Client", "COMMANDE_CLIENT",
                             "CommandeClient", "Devis", "DEVIS", "Devis", "Facture", "SAISIE_VENTE_FACTURE", "VenteFacture" };
                     // ('FR', 'Français', 1.000), ('EN',
                     // 'Anglais', 2.000)
                     final List<String> values = new ArrayList<String>();
-                    final SQLBase base = rootCommon.getBase();
+                    final SQLBase base = conf.getRoot().getBase();
                     for (int i = 0; i < type.length; i += 3) {
                         final int order = values.size() + 1;
                         values.add("(" + base.quoteString(type[i]) + ", " + base.quoteString(type[i + 1]) + ", " + base.quoteString(type[i + 2]) + ", " + order + ")");
+                    }
                     final String valuesStr = CollectionUtils.join(values, ", ");
-                    final String insertVals = "INSERT INTO " + rootCommon.getTable("TYPE_MODELE").getSQLName().quote() + "(" + SQLBase.quoteIdentifier("NOM") + ", " + SQLBase.quoteIdentifier("TABLE")
+                    final String insertVals = "INSERT INTO " + conf.getRoot().getTable("TYPE_MODELE").getSQLName().quote() + "(" + SQLBase.quoteIdentifier("NOM") + ", "
-                            + ", " + SQLBase.quoteIdentifier("DEFAULT_MODELE") + ", " + SQLBase.quoteIdentifier(SQLSyntax.ORDER_NAME) + ") VALUES" + valuesStr;
+                            + SQLBase.quoteIdentifier("TABLE") + ", " + SQLBase.quoteIdentifier("DEFAULT_MODELE") + ", " + SQLBase.quoteIdentifier(SQLSyntax.ORDER_NAME) + ") VALUES" + valuesStr;
                     ds.execute(insertVals);
                 } catch (Exception ex) {
                     throw new IllegalStateException("Erreur lors de la création de la table TYPE_MODELE", ex);
+                }
+            }
-            SQLTable.setUndefID(rootCommon.getSchema(), "DEVISE", 1);
+            SQLTable.setUndefID(conf.getRoot().getSchema(), "DEVISE", 1);
-            SQLTable.setUndefID(rootCommon.getSchema(), "TYPE_MODELE", 1);
+            SQLTable.setUndefID(conf.getRoot().getSchema(), "TYPE_MODELE", 1);
             // DSN
             final DSNInstallationUtils dsnUtils = new DSNInstallationUtils();
-            dsnUtils.updateDSNCommonTable(rootCommon);
+            dsnUtils.updateDSNCommonTable(conf.getRoot());
-            SQLRow rowRubNetPAS = createPasCommon(rootCommon);
+            SQLRow rowRubNetPAS = createPasCommon(conf.getRoot());
             // ECo contribution
             final EcoContributionInstallationUtils ecoUtils = new EcoContributionInstallationUtils();
-            ecoUtils.updateEcoCommonTable(rootCommon);
+            ecoUtils.updateEcoCommonTable(conf.getRoot());
             // we need to upgrade all roots
             // ///////////////////////////
-            systemRoot.mapAllRoots();
+            conf.getSystemRoot().mapAllRoots();
-            systemRoot.refetch();
+            conf.getSystemRoot().refetch();
+            // Merge IDCC
+            final SQLTable societeCommon = conf.getRoot().getTable("SOCIETE_COMMON");
+            if (!societeCommon.contains("ID_IDCC")) {
+                SQLCreateTable createIDCCCommon = new SQLCreateTable(conf.getRoot(), "IDCC");
+                createIDCCCommon.addVarCharColumn("CODE", 45, false, "''", true);
+                createIDCCCommon.addVarCharColumn("NOM", 2048, false, "''", true);
+                AddMDFields.addFields(createIDCCCommon, conf.getRoot().getTable("USER_COMMON"));
+                societeCommon.getDBRoot().createTable(createIDCCCommon);
+                societeCommon.getDBRoot().refetchTable("IDCC");
+                AlterTable alter = new AlterTable(societeCommon);
+                alter.addForeignColumn("ID_IDCC", conf.getRoot().getTable("IDCC"));
+                societeCommon.getDBRoot().getDBSystemRoot().getDataSource().execute(alter.asString());
+                societeCommon.getDBRoot().refetchTable("SOCIETE_COMMON");
+            }
+            final Set<String> childrenNames = conf.getSystemRoot().getChildrenNames();
+            MergeTable mergeIDCC = new MergeTable(conf.getRoot().getDBSystemRoot());
+            mergeIDCC.setDestTable(conf.getRoot().getTable("IDCC"));
+            final List<String> mdFields = Arrays.asList("ID_USER_COMMON_CREATE", "ID_USER_COMMON_MODIFY", "CREATION_DATE", "MODIFICATION_DATE");
+            for (final String childName : childrenNames) {
+                final DBRoot root = conf.getSystemRoot().getRoot(childName);
+                if (!root.getName().contains("Common") && root.contains("IDCC")) {
+                    final SQLTable table = root.getTable("IDCC");
+                    AlterTable alter = new AlterTable(table);
+                    alter.alterColumnNullable("ARCHIVE", false);
+                    // Drop MD Fields to be sure having same column properties
+                    for (String field : mdFields) {
+                        alter.dropColumn(field);
+                    }
+                    root.getDBSystemRoot().getDataSource().execute(alter.asString());
+                    root.refetchTable("IDCC");
+                    new AddMDFields(root.getDBSystemRoot()).change(table);
+                    mergeIDCC.change(table);
+                }
+            }
-            final Set<String> childrenNames = systemRoot.getChildrenNames();
+            // final Set<String> childrenNames = conf.getSystemRoot().getChildrenNames();
             SwingUtilities.invokeLater(new Runnable() {
                 @Override
                 public void run() {
                     public void run() {
                         bar.setValue(barValue);
+                    }
                 });
                 i++;
-                final DBRoot root = systemRoot.getRoot(childName);
+                final DBRoot root = conf.getSystemRoot().getRoot(childName);
                 try {
-                    systemRoot.getDataSource().execute("CREATE LANGUAGE plpgsql;");
+                    conf.getSystemRoot().getDataSource().execute("CREATE LANGUAGE plpgsql;");
                 } catch (Exception e) {
                     System.err.println("Warning: cannot add language plpgsql" + e.getMessage());
+                }
                 final SQLTable tableUndef = root.getTable(SQLTable.undefTable);
                 if (tableUndef != null && tableUndef.getField("UNDEFINED_ID").isNullable() == Boolean.FALSE) {
                         @Override
                         public Object create() throws SQLException {
                             fixUnboundedNumeric(root);
                             fixCompletion(root);
                             try {
-                                updateSocieteSchema(conf, root);
+                                updateSocieteSchema(root);
                             } catch (Exception e) {
                                 throw new SQLException(e);
+                            }
                             updateToV1Dot2(root);
                             updateToV1Dot3(root);

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

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/erp/config/InstallationPanel.java @ 177 - Rev 177 → 182