GitLab

at 2018-05-13T18:59:37Z

use last toolkit and new topia api

       <groupId>fr.ird.observe.toolkit</groupId>

       <artifactId>common-service</artifactId>

     </dependency>

+    <dependency>

+      <groupId>fr.ird.observe.toolkit</groupId>

+      <artifactId>topia-extension</artifactId>

+    </dependency>

     <dependency>

       <groupId>io.ultreia.java4all</groupId>

  * it under the terms of the GNU General Public License as

  * published by the Free Software Foundation, either version 3 of the

  * License, or (at your option) any later version.

- * 

+ *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

- * 

+ *

  * You should have received a copy of the GNU General Public

  * License along with this program.  If not, see

  * <http://www.gnu.org/licenses/gpl-3.0.html>.

  * #L%

  */

-import fr.ird.observe.persistence.migration.ObserveMigrationConfigurationProvider;

 import fr.ird.observe.services.configuration.topia.ObserveDataSourceConfigurationTopiaH2;

 import fr.ird.observe.test.TestHelper;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

+import org.nuiton.topia.service.migration.resources.MigrationVersionResourceProvider;

 import org.nuiton.version.Version;

 import java.io.File;

         configurationTopiaH2.setDirectory(localDbFile);

         configurationTopiaH2.setDbName("obstuna");

         configurationTopiaH2.setAutoMigrate(true);

-        configurationTopiaH2.setModelVersion(ObserveMigrationConfigurationProvider.get().getLastVersion());

+        configurationTopiaH2.setModelVersion(MigrationVersionResourceProvider.get().getLastVersion());

         return configurationTopiaH2;

     }

     private void deleteDirectory(Path directory) {

         try {

             log.debug(String.format("Delete directory: %s", directory));

-            Files.walk(directory).filter(f->!f.equals(directory)).forEach(f -> {

+            Files.walk(directory).filter(f -> !f.equals(directory)).forEach(f -> {

                 try {

                     if (Files.isDirectory(f)) {

                         deleteDirectory(f);

     <dependency>

       <groupId>fr.ird.observe.toolkit</groupId>

       <artifactId>topia-extension</artifactId>

-      <version>${observeToolkitVersion}</version>

     </dependency>

     <dependency>

 import org.nuiton.topia.persistence.metadata.TopiaMetadataModel;

 import org.nuiton.topia.persistence.support.TopiaMetadataModelSupport;

 import org.nuiton.topia.service.migration.TopiaMigrationService;

-import org.nuiton.topia.service.sql.batch.TopiaSqlBatchService;

-import org.nuiton.topia.service.sql.batch.tables.TopiaSqlTable;

-import org.nuiton.topia.service.sql.batch.tables.TopiaSqlTables;

-import org.nuiton.topia.service.sql.batch.tables.TopiaSqlTablesFactory;

+import org.nuiton.topia.service.script.TopiaSqlScriptGeneratorService;

+import org.nuiton.topia.service.script.table.TopiaSqlTable;

+import org.nuiton.topia.service.script.table.TopiaSqlTables;

+import org.nuiton.topia.service.script.table.TopiaSqlTablesFactory;

 import org.nuiton.util.StringUtil;

 import java.io.BufferedInputStream;

 public class ObserveTopiaApplicationContext extends AbstractObserveTopiaApplicationContext implements TopiaMetadataModelSupport {

     static final String MIGRATION_SERVICE_NAME = "migration";

-    static final String SQL_BATCH_SERVICE_NAME = "sqlBatch";

+    static final String SQL_SCRIPT_GENERATOR_BATCH_SERVICE_NAME = "sqlScriptGenerator";

     /**

      * Logger.

      */

         return getServices(TopiaMigrationService.class).get(MIGRATION_SERVICE_NAME);

     }

-    public TopiaSqlBatchService getSqlBatchService() {

-        return getServices(TopiaSqlBatchService.class).get(SQL_BATCH_SERVICE_NAME);

+    public TopiaSqlScriptGeneratorService getSqlScriptGeneratorService() {

+        return getServices(TopiaSqlScriptGeneratorService.class).get(SQL_SCRIPT_GENERATOR_BATCH_SERVICE_NAME);

     }

     @Override

 import org.nuiton.topia.persistence.jdbc.JdbcConfiguration;

 import org.nuiton.topia.persistence.jdbc.JdbcConfigurationBuilder;

 import org.nuiton.topia.service.migration.TopiaMigrationService;

-import org.nuiton.topia.service.sql.batch.TopiaSqlBatchServiceImpl;

+import org.nuiton.topia.service.script.TopiaSqlScriptGeneratorServiceImpl;

 import java.io.File;

         log.debug("jdbcUrl: " + topiaConfiguration.getJdbcConnectionUrl());

         topiaConfiguration.addDeclaredService(ObserveTopiaApplicationContext.MIGRATION_SERVICE_NAME, TopiaMigrationService.class);

-        topiaConfiguration.addDeclaredService(ObserveTopiaApplicationContext.SQL_BATCH_SERVICE_NAME, TopiaSqlBatchServiceImpl.class);

+        topiaConfiguration.addDeclaredService(ObserveTopiaApplicationContext.SQL_SCRIPT_GENERATOR_BATCH_SERVICE_NAME, TopiaSqlScriptGeneratorServiceImpl.class);

         return topiaConfiguration;

-package fr.ird.observe.persistence.migration;

-

-/*-

- * #%L

- * ObServe :: Persistence

- * %%

- * Copyright (C) 2008 - 2018 IRD, Code Lutin, Ultreia.io

- * %%

- * This program is free software: you can redistribute it and/or modify

- * it under the terms of the GNU General Public License as

- * published by the Free Software Foundation, either version 3 of the

- * License, or (at your option) any later version.

- *

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

- *

- * You should have received a copy of the GNU General Public

- * License along with this program.  If not, see

- * <http://www.gnu.org/licenses/gpl-3.0.html>.

- * #L%

- */

-

-import com.google.common.collect.ImmutableList;

-import org.nuiton.topia.service.migration.resources.MigrationVersionResourceProvider;

-import org.nuiton.version.Version;

-import org.nuiton.version.VersionBuilder;

-

-import java.util.List;

-

-/**

- * Created on 01/08/16.

- *

- * @author Tony Chemit - dev@tchemit.fr

- * @since 5.0

- */

-public final class ObserveMigrationConfigurationProvider {

-

-    private static ObserveMigrationConfigurationProvider INSTANCE;

-

-    private final MigrationVersionResourceProvider resourceProvider;

-

-    private ObserveMigrationConfigurationProvider() {

-        resourceProvider = new MigrationVersionResourceProvider();

-    }

-

-    public static ObserveMigrationConfigurationProvider get() {

-        if (INSTANCE == null) {

-            INSTANCE = new ObserveMigrationConfigurationProvider();

-        }

-        return INSTANCE;

-    }

-

-    public List<Version> getAvailableVersions() {

-        return resourceProvider.getAvailableVersions();

-    }

-

-    public Version getLastVersion() {

-        return resourceProvider.getLastVersion();

-    }

-

-    public ImmutableList<Version> getVersionsAfter(Version current) {

-        return resourceProvider.getVersionsAfter(current);

-    }

-

-    public Version getMinimumVersion() {

-        return VersionBuilder.create("3.0").build();

-    }

-

-}
  * @author Tony Chemit - dev@tchemit.fr

  */

 @AutoService(TopiaMigrationServiceAskUserToMigrate.class)

+@SuppressWarnings("WeakerAccess")

 public class ObserveTopiaMigrationServiceAskUserToMigrate implements TopiaMigrationServiceAskUserToMigrate {

-    private final Version minimumVersion = VersionBuilder.create("3.0").build();

+    private static final Version MINIMUM_VERSION = VersionBuilder.create("3.0").build();

-    public Version getMinimumVersion() {

-        return minimumVersion;

+    public static Version getMinimumVersion() {

+        return MINIMUM_VERSION;

     }

     @Override

     <maven.build.timestamp.format>dd/MM/yyyy HH:mm z</maven.build.timestamp.format>

     <buildDate>${maven.build.timestamp}</buildDate>

-    <observeToolkitVersion>3.4-SNAPSHOT</observeToolkitVersion>

+    <observeToolkitVersion>3.5-SNAPSHOT</observeToolkitVersion>

     <!--<lib.version.java4all.jaxx>3.0-alpha-31</lib.version.java4all.jaxx>-->

     <!--<lib.version.nuiton.topia>3.4.2-SNAPSHOT</lib.version.nuiton.topia>-->

-package fr.ird.observe.services.local;

-

-/*-

- * #%L

- * ObServe :: Services local implementation

- * %%

- * Copyright (C) 2008 - 2018 IRD, Code Lutin, Ultreia.io

- * %%

- * This program is free software: you can redistribute it and/or modify

- * it under the terms of the GNU General Public License as

- * published by the Free Software Foundation, either version 3 of the

- * License, or (at your option) any later version.

- * 

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

- * 

- * You should have received a copy of the GNU General Public

- * License along with this program.  If not, see

- * <http://www.gnu.org/licenses/gpl-3.0.html>.

- * #L%

- */

-

-import com.google.common.collect.Lists;

-import com.google.common.collect.Sets;

-import fr.ird.observe.dto.ObserveDbRole;

-import fr.ird.observe.dto.db.ObserveDbUserDto;

-import org.apache.commons.lang3.tuple.Pair;

-import org.apache.commons.logging.Log;

-import org.apache.commons.logging.LogFactory;

-import org.nuiton.topia.persistence.jdbc.JdbcConfiguration;

-import org.nuiton.topia.persistence.jdbc.JdbcHelper;

-import org.nuiton.version.Version;

-import org.nuiton.version.Versions;

-

-import java.sql.Connection;

-import java.sql.DatabaseMetaData;

-import java.sql.PreparedStatement;

-import java.sql.ResultSet;

-import java.sql.SQLException;

-import java.util.ArrayList;

-import java.util.Collections;

-import java.util.LinkedHashSet;

-import java.util.List;

-import java.util.Set;

-

-/**

- * @author Tony Chemit - dev@tchemit.fr

- */

-public class ObserveJdbcHelper extends JdbcHelper {

-

-    private static final Set<String> POSTGIS_TABLES = Sets.newHashSet("geometry_columns", "spatial_ref_sys");

-    private static final Log log = LogFactory.getLog(ObserveJdbcHelper.class);

-

-

-    public ObserveJdbcHelper(JdbcConfiguration jdbcConfiguration) {

-        super(jdbcConfiguration);

-    }

-

-    public Set<String> getTablePrivileges(String schema, String tableName) {

-        Connection connection = null;

-        try {

-            connection = openConnection();

-            DatabaseMetaData metaData = connection.getMetaData();

-            ResultSet observerDataPrivilege = metaData.getTablePrivileges(null, schema, tableName);

-

-            Set<String> tablePrivileges = Sets.newHashSet();

-

-            while (observerDataPrivilege.next()) {

-                String security = observerDataPrivilege.getString("PRIVILEGE");

-                String grantor = observerDataPrivilege.getString("GRANTOR");

-                String grantee = observerDataPrivilege.getString("GRANTEE");

-                // Il se peut que le login soit echappe sous la forme \"login\"

-                grantor= grantor.replaceAll("\\\\\"", "");

-                grantee = grantee.replaceAll("\\\\\"", "");

-                if (log.isDebugEnabled()) {

-                    log.debug(String.format("(security %s) - grantee (%s)", security, grantee));

-                }

-                if (grantor.equals(jdbcConfiguration.getJdbcConnectionUser())) {

-                    if (log.isDebugEnabled()) {

-                        log.debug("for " + tableName + " table " + grantor + '/' + security);

-                    }

-                    tablePrivileges.add(security);

-                } else if (grantee.equals(jdbcConfiguration.getJdbcConnectionUser())) {

-                    if (log.isDebugEnabled()) {

-                        log.debug("for " + tableName + " table " + grantee + '/' + security);

-                    }

-                    tablePrivileges.add(security);

-                }

-            }

-

-            return tablePrivileges;

-

-        } catch (SQLException e) {

-            throw new RuntimeException(e);

-        } finally {

-            closeQuietly(connection);

-        }

-

-    }

-

-    public Version getVersion() {

-        Version version = Version.VZERO;

-

-        Connection connection = null;

-        PreparedStatement preparedStatement = null;

-        try {

-            connection = openConnection();

-            // la connexion est reussie, on recherche les droits de

-            // récupération de la version de la base

-            preparedStatement = connection.prepareStatement("SELECT version FROM tms_version;");

-            ResultSet resultSet = preparedStatement.executeQuery();

-

-            if (resultSet.next()) {

-                String versionStr = resultSet.getString(1);

-                version = Versions.valueOf(versionStr);

-            }

-

-        } catch (SQLException e) {

-            if (log.isErrorEnabled()) {

-                log.error(e);

-            }

-        } finally {

-            closeQuietly(preparedStatement);

-            closeQuietly(connection);

-        }

-

-        return version;

-

-    }

-

-    public List<ObserveDbUserDto> getUsers() {

-        Connection connection = null;

-        PreparedStatement preparedStatement = null;

-        List<ObserveDbUserDto> users = Lists.newLinkedList();

-

-        try {

-            connection = openConnection();

-            // la connexion est reussie, on recherche les droits de

-            // récupération de la version de la base

-            preparedStatement = connection.prepareStatement("SELECT rolname FROM pg_catalog.pg_roles;");

-            ResultSet resultSet = preparedStatement.executeQuery();

-

-            while (resultSet.next()) {

-                String name = resultSet.getString(1);

-                ObserveDbUserDto user = new ObserveDbUserDto();

-                user.setName(name);

-                if (jdbcConfiguration.getJdbcConnectionUser().equals(name)) {

-                    user.setRole(ObserveDbRole.ADMINISTRATOR);

-                } else {

-                    user.setRole(ObserveDbRole.UNUSED);

-                }

-

-                users.add(user);

-            }

-

-            return users;

-

-        } catch (SQLException e) {

-            throw new RuntimeException(e);

-        } finally {

-            closeQuietly(preparedStatement);

-            closeQuietly(connection);

-        }

-    }

-

-    public List<Pair<String, String>> getTables(Set<String> schemas, Set<String> extraTables) {

-        List<Pair<String, String>> result = new ArrayList<>();

-

-        Connection connection = null;

-        ResultSet tables = null;

-

-        try {

-            // recuperation des tables sur la base

-            connection = openConnection();

-            DatabaseMetaData data = connection.getMetaData();

-            tables = data.getTables(null,

-                                    null,

-                                    null,

-                                    new String[]{"TABLE"}

-            );

-

-            int columnCount = tables.getMetaData().getColumnCount();

-

-            if (log.isDebugEnabled()) {

-                StringBuilder builder = new StringBuilder();

-                builder.append("\nheader");

-                for (int i = 1; i <= columnCount; i++) {

-                    String columnName = tables.getMetaData().getColumnName(i);

-                    builder.append("\n [").append(i).append("] :").append(columnName);

-                }

-                log.debug(builder.toString());

-                log.debug("fetchSize : " + tables.getFetchSize());

-            }

-            while (tables.next()) {

-                String schemaName = tables.getString(2);

-                String tableName = tables.getString(3);

-                if (log.isDebugEnabled()) {

-                    log.debug(String.format("Discover table named %s", tables));

-                }

-                if (!extraTables.contains(tableName)) {

-

-                    if (POSTGIS_TABLES.contains(tableName)) {

-                        continue;

-                    }

-

-                    if (schemaName == null || !schemas.contains(schemaName.toLowerCase())) {

-                        continue;

-                    }

-

-                }

-

-                if (log.isDebugEnabled()) {

-                    log.debug(String.format("Keep table: %s", tables));

-                }

-                result.add(Pair.of(schemaName, tableName));

-            }

-

-            Collections.sort(result);

-            return result;

-        } catch (SQLException e) {

-            throw new RuntimeException(e);

-        } finally {

-            closeQuietly(connection);

-            closeQuietly(tables);

-        }

-    }

-

-    public Set<String> getPostgisFunctions(String functionPattern) {

-

-        final Set<String> result = new LinkedHashSet<>();

-        Connection connection = null;

-        PreparedStatement preparedStatement = null;

-

-        String sql = String.format("SELECT ns.nspname::text || '.' ||  p.proname::text || '(' || oidvectortypes(p.proargtypes)::text || ')'" +

-                                           " FROM pg_proc p INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid)" +

-                                           " WHERE ns.nspname = 'public' AND p.proname ILIKE '%s%%';", functionPattern);

-        try {

-            connection = openConnection();

-            preparedStatement = connection.prepareStatement(sql);

-            ResultSet set = preparedStatement.executeQuery();

-

-            while (set.next()) {

-                String functionPrototype = set.getString(1);

-                result.add(functionPrototype);

-            }

-

-        } catch (SQLException e) {

-            throw new RuntimeException(e);

-        } finally {

-            closeQuietly(connection);

-            closeQuietly(preparedStatement);

-        }

-        return result;

-

-    }

-

-    public void loadScript(String scriptContent) {

-        Connection connection = null;

-        PreparedStatement preparedStatement = null;

-

-        try {

-            connection = openConnection();

-

-            preparedStatement = connection.prepareStatement(scriptContent);

-

-            preparedStatement.executeUpdate();

-

-        } catch (SQLException e) {

-            throw new RuntimeException(e);

-        } finally {

-            closeQuietly(connection);

-            closeQuietly(preparedStatement);

-        }

-    }

-

-

-}
  * it under the terms of the GNU General Public License as

  * published by the Free Software Foundation, either version 3 of the

  * License, or (at your option) any later version.

- * 

+ *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

- * 

+ *

  * You should have received a copy of the GNU General Public

  * License along with this program.  If not, see

  * <http://www.gnu.org/licenses/gpl-3.0.html>.

 import org.apache.commons.logging.LogFactory;

 import org.nuiton.topia.migration.mappings.TMSVersionHibernateDao;

 import org.nuiton.topia.persistence.TopiaEntityEnum;

+import org.nuiton.topia.persistence.TopiaException;

 import org.nuiton.topia.persistence.jdbc.JdbcConfiguration;

+import org.nuiton.topia.persistence.sql.PostgresJdbcHelper;

+import org.nuiton.topia.persistence.util.SqlScriptConsumer;

+import org.nuiton.topia.persistence.util.SqlScriptWriter;

 import org.nuiton.util.StringUtil;

+import java.io.IOException;

+import java.nio.file.Files;

+import java.nio.file.Path;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collection;

     public static final String OBSERVE_COMMON_SCHEMA_NAME = "observe_common";

     public static final String OBSERVE_SEINE_SCHEMA_NAME = "observe_seine";

-    public static final String OBSERVE_LONGLINE_SCHEMA_NAME = "observe_longline";

-    public static final Function<String, String> ESCAPE_STRING = input -> "\"" + input + "\"";

-    protected static final String DROP_TABLE_PATTERN = "DROP TABLE IF EXISTS %s.%s CASCADE;\n";

-    protected static final String DROP_SCHEMA_PATTERN = "DROP SCHEMA IF EXISTS %s CASCADE;\n";

-    protected static final String REVOKE_ON_TABLE_ALL_PATTERN = "REVOKE ALL ON %s.%s FROM %s CASCADE;\n";

-    protected static final String SET_ON_TABLE_OWNER_PATTERN = "ALTER TABLE %s.%s OWNER TO %s;\n";

-    protected static final String GRANT_ON_TABLE_READ_PATTERN = "GRANT SELECT ON %s.%s TO %s;\n";

-    protected static final String GRANT_ON_TABLE_ALL_PATTERN = "GRANT ALL ON %s.%s TO %s;\n";

-    protected static final String GRANT_ON_FUNCTION_PATTERN = "GRANT EXECUTE ON FUNCTION %s TO %s;\n";

-    protected static final String REVOKE_ON_SCHEMA_ALL_PATTERN = "REVOKE ALL ON SCHEMA %s FROM %s CASCADE;\n";

-    protected static final String REVOKE_ON_FUNCTIONS_PATTERN = "REVOKE EXECUTE ON FUNCTION %s FROM %s CASCADE;\n";

-    protected static final String GRANT_ON_SCHEMA_ALL_PATTERN = "GRANT USAGE ON SCHEMA %s TO %s;\n";

-    protected static final Set<String> EXTRA_TABLES = Sets.newHashSet(

+    private static final String OBSERVE_LONGLINE_SCHEMA_NAME = "observe_longline";

+    private static final Function<String, String> ESCAPE_STRING = input -> "\"" + input + "\"";

+    private static final String REVOKE_ON_TABLE_ALL_PATTERN = "REVOKE ALL ON %s.%s FROM %s CASCADE;";

+    private static final String SET_ON_TABLE_OWNER_PATTERN = "ALTER TABLE %s.%s OWNER TO %s;";

+    private static final String GRANT_ON_TABLE_READ_PATTERN = "GRANT SELECT ON %s.%s TO %s;";

+    private static final String GRANT_ON_TABLE_ALL_PATTERN = "GRANT ALL ON %s.%s TO %s;";

+    private static final String GRANT_ON_FUNCTION_PATTERN = "GRANT EXECUTE ON FUNCTION %s TO %s;";

+    private static final String REVOKE_ON_SCHEMA_ALL_PATTERN = "REVOKE ALL ON SCHEMA %s FROM %s CASCADE;";

+    private static final String REVOKE_ON_FUNCTIONS_PATTERN = "REVOKE EXECUTE ON FUNCTION %s FROM %s CASCADE;";

+    private static final String GRANT_ON_SCHEMA_ALL_PATTERN = "GRANT USAGE ON SCHEMA %s TO %s;";

+    private static final Set<String> EXTRA_TABLES = Sets.newHashSet(

             TMSVersionHibernateDao.TABLE_NAME,

             TMSVersionHibernateDao.LEGACY_TABLE_NAME);

-    protected static final Set<String> FUNCTION_NAMES_PREFIXS = Sets.newHashSet("ST_MakePoint",

-                                                                                "ST_SetSRID",

-                                                                                "sync_",

-                                                                                "tr_sync",

-                                                                                "ot_enhanced_school_type",

-                                                                                "observe_");

-    protected static final String SCHEMA_PUBLIC = "public";

-    protected static final Set<String> SCHEMAS = Sets.newHashSet(SCHEMA_PUBLIC,

-                                                                 OBSERVE_COMMON_SCHEMA_NAME,

-                                                                 OBSERVE_SEINE_SCHEMA_NAME,

-                                                                 OBSERVE_LONGLINE_SCHEMA_NAME);

+    private static final Set<String> FUNCTION_NAMES_PREFIXS = Sets.newHashSet("ST_MakePoint",

+            "ST_SetSRID",

+            "sync_",

+            "tr_sync",

+            "ot_enhanced_school_type",

+            "observe_");

+    private static final String SCHEMA_PUBLIC = "public";

+    private static final Set<String> SCHEMAS = Sets.newHashSet(SCHEMA_PUBLIC,

+            OBSERVE_COMMON_SCHEMA_NAME,

+            OBSERVE_SEINE_SCHEMA_NAME,

+            OBSERVE_LONGLINE_SCHEMA_NAME);

     private static final Log log = LogFactory.getLog(ObserveSecurityHelper.class);

-    protected final ObserveJdbcHelper jdbcHelper;

-    protected final JdbcConfiguration jdbcConfiguration;

+    private final PostgresJdbcHelper jdbcHelper;

     public ObserveSecurityHelper(JdbcConfiguration jdbcConfiguration) {

-        this.jdbcConfiguration = jdbcConfiguration;

-        this.jdbcHelper = new ObserveJdbcHelper(jdbcConfiguration);

+        this.jdbcHelper = new PostgresJdbcHelper(jdbcConfiguration);

     }

-    public void applySecurity(Set<ObserveDbUserDto> users, boolean showSql) {

+    public void applySecurity(Set<ObserveDbUserDto> users) {

         if (users == null) {

             throw new NullPointerException("users can not be null");

         }

-        String script = createSecurityScript(users);

-

-        if (showSql && log.isInfoEnabled()) {

-            log.info("SQL to execute :\n" + script);

+        Path scriptPath;

+        try {

+            scriptPath = Files.createTempFile("topia-sql-script-", ".sql");

+        } catch (IOException e) {

+            throw new IllegalStateException("Can't create temporary path", e);

         }

-        jdbcHelper.loadScript(script);

-

+        try {

+            try (SqlScriptWriter sqlScriptWriter = SqlScriptWriter.of(scriptPath)) {

+                createSecurityScript(users, sqlScriptWriter);

+                log.info(String.format("Generate security script %d statements(s) at %s", sqlScriptWriter.getStatementCount(), scriptPath));

+            }

+            jdbcHelper.consume(SqlScriptConsumer.of(scriptPath));

+        } catch (IOException e) {

+            throw new TopiaException(String.format("Can't generate security script at %s", scriptPath), e);

+        }

     }

-    protected String createSecurityScript(Set<ObserveDbUserDto> users) {

+    private void createSecurityScript(Set<ObserveDbUserDto> users, SqlScriptWriter sqlScriptWriter) {

         List<Pair<String, String>> tables = jdbcHelper.getTables(SCHEMAS, EXTRA_TABLES);

         if (tables.isEmpty()) {

             // no tables

-            return "";

+            return;

         }

         String administratorName = Iterables.get(getUserNamesByRole(users, ObserveDbRole.ADMINISTRATOR), 0);

         List<Pair<String, String>> referentielTables = getReferentielTables(tables);

-        getDataTables(tables, referentielTables);

-

         Set<String> allPostgisFunctions = new LinkedHashSet<>();

         for (String postgisFunction : FUNCTION_NAMES_PREFIXS) {

             Set<String> postgisFunctions = jdbcHelper.getPostgisFunctions(postgisFunction);

             allPostgisFunctions.addAll(postgisFunctions);

         }

-        StringBuilder builder = new StringBuilder();

-

         String administratorEscapedName = ESCAPE_STRING.apply(administratorName);

         Set<String> technicalEscapedNames = escapedNames(technicalNames);

         Set<String> usersEscapedNames = escapedNames(usersNames);

             String roles = StringUtil.join(privateRoles, ",", true);

-            addOnTablesForRole(REVOKE_ON_TABLE_ALL_PATTERN, builder, tables, roles);

-            addOnSchemaForRole(REVOKE_ON_SCHEMA_ALL_PATTERN, builder, SCHEMAS, roles);

-            addOnFunctionForRole(REVOKE_ON_FUNCTIONS_PATTERN, builder, allPostgisFunctions, roles);

+            addOnTablesForRole(REVOKE_ON_TABLE_ALL_PATTERN, sqlScriptWriter, tables, roles);

+            addOnSchemaForRole(REVOKE_ON_SCHEMA_ALL_PATTERN, sqlScriptWriter, SCHEMAS, roles);

+            addOnFunctionForRole(REVOKE_ON_FUNCTIONS_PATTERN, sqlScriptWriter, allPostgisFunctions, roles);

         }

         // ajout propriétaire

-        addOnTablesForRole(SET_ON_TABLE_OWNER_PATTERN, builder, tables, administratorEscapedName);

-        addOnSchemaForRole(GRANT_ON_SCHEMA_ALL_PATTERN, builder, SCHEMAS, administratorEscapedName);

-        addOnSchemaForRole(GRANT_ON_FUNCTION_PATTERN, builder, allPostgisFunctions, administratorEscapedName);

+        addOnTablesForRole(SET_ON_TABLE_OWNER_PATTERN, sqlScriptWriter, tables, administratorEscapedName);

+        addOnSchemaForRole(GRANT_ON_SCHEMA_ALL_PATTERN, sqlScriptWriter, SCHEMAS, administratorEscapedName);

+        addOnSchemaForRole(GRANT_ON_FUNCTION_PATTERN, sqlScriptWriter, allPostgisFunctions, administratorEscapedName);

         // ajout administrateurs

         if (!technicalEscapedNames.isEmpty()) {

             String roles = StringUtil.join(technicalEscapedNames, ",", true);

-            addOnTablesForRole(GRANT_ON_TABLE_ALL_PATTERN, builder, tables, roles);

-            addOnSchemaForRole(GRANT_ON_SCHEMA_ALL_PATTERN, builder, SCHEMAS, roles);

-            addOnSchemaForRole(GRANT_ON_FUNCTION_PATTERN, builder, allPostgisFunctions, roles);

+            addOnTablesForRole(GRANT_ON_TABLE_ALL_PATTERN, sqlScriptWriter, tables, roles);

+            addOnSchemaForRole(GRANT_ON_SCHEMA_ALL_PATTERN, sqlScriptWriter, SCHEMAS, roles);

+            addOnSchemaForRole(GRANT_ON_FUNCTION_PATTERN, sqlScriptWriter, allPostgisFunctions, roles);

         }

         // ajout utilisateur

         if (!usersEscapedNames.isEmpty()) {

             String roles = StringUtil.join(usersEscapedNames, ",", true);

-            addOnTablesForRole(GRANT_ON_TABLE_READ_PATTERN, builder, tables, roles);

-            addOnSchemaForRole(GRANT_ON_SCHEMA_ALL_PATTERN, builder, SCHEMAS, roles);

-            addOnSchemaForRole(GRANT_ON_FUNCTION_PATTERN, builder, allPostgisFunctions, roles);

+            addOnTablesForRole(GRANT_ON_TABLE_READ_PATTERN, sqlScriptWriter, tables, roles);

+            addOnSchemaForRole(GRANT_ON_SCHEMA_ALL_PATTERN, sqlScriptWriter, SCHEMAS, roles);

+            addOnSchemaForRole(GRANT_ON_FUNCTION_PATTERN, sqlScriptWriter, allPostgisFunctions, roles);

         }

         // ajout referentiel

         if (!referentialEscapedNames.isEmpty()) {

             String roles = StringUtil.join(referentialEscapedNames, ",", true);

-            addOnTablesForRole(GRANT_ON_TABLE_READ_PATTERN, builder, referentielTables, roles);

-            addOnSchemaForRole(GRANT_ON_SCHEMA_ALL_PATTERN, builder, SCHEMAS, roles);

-            addOnSchemaForRole(GRANT_ON_FUNCTION_PATTERN, builder, allPostgisFunctions, roles);

+            addOnTablesForRole(GRANT_ON_TABLE_READ_PATTERN, sqlScriptWriter, referentielTables, roles);

+            addOnSchemaForRole(GRANT_ON_SCHEMA_ALL_PATTERN, sqlScriptWriter, SCHEMAS, roles);

+            addOnSchemaForRole(GRANT_ON_FUNCTION_PATTERN, sqlScriptWriter, allPostgisFunctions, roles);

         }

-        String result = builder.toString();

-

-        if (log.isInfoEnabled()) {

-            log.info("Security script :\n" + result);

-        }

-        return result;

-

-

     }

-    protected List<String> getUserNamesByRole(Set<ObserveDbUserDto> users, ObserveDbRole role) {

+    private List<String> getUserNamesByRole(Set<ObserveDbUserDto> users, ObserveDbRole role) {

         return users.stream().filter(u -> u.getRole() == role).map(ObserveDbUserDto::getName).collect(Collectors.toList());

     }

-    protected Set<String> escapedNames(List<String> names) {

+    private Set<String> escapedNames(List<String> names) {

         return names.stream().map(ESCAPE_STRING).collect(Collectors.toSet());

     }

-    protected List<Pair<String, String>> getReferentielTables(Iterable<Pair<String, String>> tables) {

-        Set<TopiaEntityEnum> types = new HashSet<>();

-        types.addAll(Arrays.asList(Entities.REFERENCE_ENTITIES));

+    private List<Pair<String, String>> getReferentielTables(Collection<Pair<String, String>> tables) {

+        Set<TopiaEntityEnum> types = new HashSet<>(Arrays.asList(Entities.REFERENCE_ENTITIES));

-        List<Pair<String, String>> result = getTables(tables, types, EXTRA_TABLES);

+        List<Pair<String, String>> result = getTables(tables, types);

         if (log.isInfoEnabled()) {

             StringBuilder sb = new StringBuilder();

             sb.append("Detected ").append(result.size()).append(" referentiel tables :");

             for (Pair<String, String> s : result) {

                 sb.append("\n - ").append(s);

             }

-            log.info(sb.toString());

-        }

-        return result;

-    }

-

-    protected List<Pair<String, String>> getDataTables(Collection<Pair<String, String>> tables,

-                                                       Collection<Pair<String, String>> referentielTables) {

-        List<Pair<String, String>> result = new ArrayList<>(tables);

-        result.removeAll(referentielTables);

+            List<Pair<String, String>> dataTables = new ArrayList<>(tables);

+            dataTables.removeAll(result);

-        if (log.isInfoEnabled()) {

-            StringBuilder sb = new StringBuilder();

-            sb.append("Detected ").append(result.size()).append(" data tables :");

-            for (Pair<String, String> s : result) {

+            sb.append("Detected ").append(dataTables.size()).append(" data tables :");

+            for (Pair<String, String> s : dataTables) {

                 sb.append("\n - ").append(s);

             }

             log.info(sb.toString());

         return result;

     }

-    protected List<Pair<String, String>> getTables(Iterable<Pair<String, String>> tables,

-                                                   Set<TopiaEntityEnum> types,

-                                                   Set<String> extraTypes) {

+    private List<Pair<String, String>> getTables(Iterable<Pair<String, String>> tables, Set<TopiaEntityEnum> types) {

         List<Pair<String, String>> result = new ArrayList<>();

         for (Pair<String, String> t : tables) {

             String table = t.getRight();

                 }

             }

             if (detectedType == null) {

-                for (String extraType : extraTypes) {

+                for (String extraType : EXTRA_TABLES) {

                     if (table.equalsIgnoreCase(extraType)) {

                         detectedType = extraType;

                         break;

         return result;

     }

-    protected void addOnTablesForRole(String pattern,

-                                      StringBuilder builder,

-                                      Iterable<Pair<String, String>> tables,

-                                      String role) {

-

+    private void addOnTablesForRole(String pattern, SqlScriptWriter builder, Iterable<Pair<String, String>> tables, String role) {

         for (Pair<String, String> t : tables) {

-            builder.append(String.format(pattern, t.getLeft(), t.getRight(), role));

+            builder.writeSql(String.format(pattern, t.getLeft(), t.getRight(), role));

         }

     }

-    protected void addOnSchemaForRole(String pattern,

-                                      StringBuilder builder,

-                                      Set<String> schemas,

-                                      String role) {

-

+    private void addOnSchemaForRole(String pattern, SqlScriptWriter builder, Set<String> schemas, String role) {

         for (String t : schemas) {

-            builder.append(String.format(pattern, t, role));

+            builder.writeSql(String.format(pattern, t, role));

         }

     }

-    protected void addOnFunctionForRole(String pattern,

-                                        StringBuilder builder,

-                                        Set<String> functions,

-                                        String role) {

-

+    private void addOnFunctionForRole(String pattern, SqlScriptWriter builder, Set<String> functions, String role) {

         for (String t : functions) {

-            builder.append(String.format(pattern, t, role));

+            builder.writeSql(String.format(pattern, t, role));

         }

     }

-

 }
  * it under the terms of the GNU General Public License as

  * published by the Free Software Foundation, either version 3 of the

  * License, or (at your option) any later version.

- * 

+ *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

- * 

+ *

  * You should have received a copy of the GNU General Public

  * License along with this program.  If not, see

  * <http://www.gnu.org/licenses/gpl-3.0.html>.

  * #L%

  */

-import com.google.common.base.Joiner;

 import com.google.common.base.Preconditions;

 import com.google.common.collect.ImmutableSet;

-import com.google.common.collect.Sets;

+import fr.ird.observe.dto.ObserveDbRole;

 import fr.ird.observe.dto.db.ObserveDbUserDto;

 import fr.ird.observe.dto.reference.ReferentialDtoReference;

 import fr.ird.observe.entities.referentiel.ObserveReferentialEntity;

 import fr.ird.observe.persistence.ObserveTopiaApplicationContext;

 import fr.ird.observe.persistence.ObserveTopiaConfiguration;

 import fr.ird.observe.persistence.ObserveTopiaConfigurationFactory;

-import fr.ird.observe.persistence.migration.ObserveMigrationConfigurationProvider;

+import fr.ird.observe.persistence.migration.ObserveTopiaMigrationServiceAskUserToMigrate;

 import fr.ird.observe.services.configuration.DataSourceCreateConfigurationDto;

 import fr.ird.observe.services.configuration.DataSourceCreateWithNoReferentialImportException;

 import fr.ird.observe.services.configuration.IncompatibleDataSourceCreateConfigurationException;

 import fr.ird.observe.services.configuration.topia.ObserveDataSourceConfigurationTopiaPG;

 import fr.ird.observe.services.configuration.topia.ObserveDataSourceConfigurationTopiaSupport;

 import fr.ird.observe.services.configuration.topia.ObserveDataSourceConnectionTopia;

-import fr.ird.observe.services.local.ObserveJdbcHelper;

 import fr.ird.observe.services.local.ObserveSecurityHelper;

 import fr.ird.observe.services.local.ObserveTopiaApplicationContextFactory;

 import fr.ird.observe.services.service.BabModelVersionException;

 import org.nuiton.topia.persistence.metadata.TopiaMetadataEntity;

 import org.nuiton.topia.persistence.metadata.TopiaMetadataModel;

 import org.nuiton.topia.persistence.metadata.TopiaMetadataModelVisitor;

+import org.nuiton.topia.persistence.sql.PostgresJdbcHelper;

+import org.nuiton.topia.service.migration.resources.MigrationVersionResourceProvider;

+import org.nuiton.topia.service.migration.version.TMSVersion;

+import org.nuiton.topia.service.migration.version.TMSVersionHibernateDao;

 import org.nuiton.version.Version;

 import org.nuiton.version.Versions;

 import java.io.File;

 import java.io.IOException;

 import java.nio.file.Files;

+import java.util.LinkedHashSet;

+import java.util.List;

 import java.util.Optional;

 import java.util.Set;

 import java.util.UUID;

-import java.util.stream.Collectors;

 import static org.nuiton.i18n.I18n.l;

     @Override

     public ObserveDataSourceInformation checkCanConnect(ObserveDataSourceConfiguration dataSourceConfiguration) throws DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException {

-        if (log.isTraceEnabled()) {

-            log.trace("checkCanConnect(" + dataSourceConfiguration + ")");

-        }

         Preconditions.checkState(dataSourceConfiguration instanceof ObserveDataSourceConfigurationTopiaSupport);

         ObserveDataSourceConfigurationTopiaSupport dataSourceConfigurationTopiaSupport = (ObserveDataSourceConfigurationTopiaSupport) dataSourceConfiguration;

             // On tente une connection à la base

             ObserveTopiaConfiguration topiaConfiguration = ObserveTopiaConfigurationFactory.forH2Database(h2DataSourceConfiguration.getDirectory(),

-                                                                                                          h2DataSourceConfiguration.getDbName(),

-                                                                                                          h2DataSourceConfiguration.getUsername(),

-                                                                                                          new String(h2DataSourceConfiguration.getPassword()),

-                                                                                                          false,

-                                                                                                          false);

+                    h2DataSourceConfiguration.getDbName(),

+                    h2DataSourceConfiguration.getUsername(),

+                    new String(h2DataSourceConfiguration.getPassword()),

+                    false,

+                    false);

             try {

             ObserveDataSourceConfigurationTopiaPG pgDataSourceConfiguration = (ObserveDataSourceConfigurationTopiaPG) dataSourceConfigurationTopiaSupport;

             // On tente une connexion au serveur

             ObserveTopiaConfiguration topiaConfiguration = ObserveTopiaConfigurationFactory.forPostgresqlDatabase(pgDataSourceConfiguration.getJdbcUrl(),

-                                                                                                                  pgDataSourceConfiguration.getUsername(),

-                                                                                                                  new String(pgDataSourceConfiguration.getPassword()),

-                                                                                                                  false,

+                    pgDataSourceConfiguration.getUsername(),

+                    new String(pgDataSourceConfiguration.getPassword()),

+                    false,

                     false);

             try {

     public ObserveDataSourceConnectionTopia create(ObserveDataSourceConfiguration dataSourceConfiguration, DataSourceCreateConfigurationDto dataSourceCreateConfiguration)

             throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException,

             BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {

-        if (log.isTraceEnabled()) {

-            log.trace("create(" + dataSourceConfiguration + ", " + dataSourceCreateConfiguration + ")");

-        }

         dataSourceCreateConfiguration.validateConfiguration();

             if (importStandaloneReferantial) {

-                if (log.isInfoEnabled()) {

-                    log.info("Import referential.");

-                }

+                log.info("Import referential.");

                 ObserveDataSourceConfiguration importDataSourceConfiguration = dataSourceCreateConfiguration.getImportReferentialDataSourceConfiguration();

                 // Récupération du dump qui contient les données

                 ImmutableSet<String> importDataIds = dataSourceCreateConfiguration.getImportDataIds();

-                if (log.isInfoEnabled()) {

-                    log.info("Get data: " + importDataIds);

-                }

+                log.info("Get data: " + importDataIds);

                 request.dataIdsToAdd(importDataIds);

     @Override

     public ObserveDataSourceConnectionTopia open(ObserveDataSourceConfiguration dataSourceConfiguration) throws DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {

-        if (log.isTraceEnabled()) {

-            log.trace("open(" + dataSourceConfiguration + ")");

-        }

         ObserveDataSourceInformation dataSourceInformation = checkCanConnect(dataSourceConfiguration);

     @Override

     public void close() {

-        if (log.isTraceEnabled()) {

-            log.trace("close()");

-        }

         ObserveDataSourceConfigurationTopiaSupport dataSourceConfiguration = serviceContext.getDataSourceConfiguration().orElseThrow(IllegalStateException::new);

         Optional<ObserveTopiaApplicationContext> optionalTopiaApplicationContext = ObserveTopiaApplicationContextFactory.getTopiaApplicationContextIfPresent(dataSourceConfiguration);

     @Override

     public void destroy() throws DatabaseDestroyNotAuthorizedException {

-        if (log.isTraceEnabled()) {

-            log.trace("destroy()");

-        }

         ObserveDataSourceConfigurationTopiaSupport dataSourceConfiguration = serviceContext.getDataSourceConfiguration().orElseThrow(IllegalStateException::new);

     public void backup(File backupFile) {

         if (!serviceContext.getTopiaApplicationContext().getConfiguration().isH2Configuration()) {

-

             throw new IllegalStateException("Cant backup a none H2 database.");

         }

     @Override

     public Set<ObserveDbUserDto> getUsers(ObserveDataSourceConfiguration dataSourceConfiguration) {

-        if (log.isTraceEnabled()) {

-            log.trace("getUsers(" + dataSourceConfiguration + ")");

-        }

-        Set<ObserveDbUserDto> users = Sets.newHashSet();

+        Set<ObserveDbUserDto> users = new LinkedHashSet<>();

         // pas d'user pour les bases autres que postgresql

         if (dataSourceConfiguration instanceof ObserveDataSourceConfigurationTopiaPG) {

             ObserveDataSourceConfigurationTopiaPG sourceConfiguration = (ObserveDataSourceConfigurationTopiaPG) dataSourceConfiguration;

-            ObserveTopiaApplicationContext topiaApplicationContext = ObserveTopiaApplicationContextFactory.getOrCreateTopiaApplicationContext(sourceConfiguration);

-

-            ObserveTopiaConfiguration topiaConfiguration = topiaApplicationContext.getConfiguration();

+            try (ObserveTopiaApplicationContext topiaApplicationContext = ObserveTopiaApplicationContextFactory.getOrCreateTopiaApplicationContext(sourceConfiguration)) {

-            ObserveJdbcHelper observeJdbcHelper = new ObserveJdbcHelper(topiaConfiguration);

+                ObserveTopiaConfiguration topiaConfiguration = topiaApplicationContext.getConfiguration();

-            users.addAll(observeJdbcHelper.getUsers());

+                PostgresJdbcHelper observeJdbcHelper = new PostgresJdbcHelper(topiaConfiguration);

-            topiaApplicationContext.close();

+                Set<String> userNames = observeJdbcHelper.getRoles();

+                for (String userName : userNames) {

+                    ObserveDbUserDto user = new ObserveDbUserDto();

+                    user.setName(userName);

+                    if (topiaConfiguration.getJdbcConnectionUser().equals(userName)) {

+                        user.setRole(ObserveDbRole.ADMINISTRATOR);

+                    } else {

+                        user.setRole(ObserveDbRole.UNUSED);

+                    }

+                    users.add(user);

+                }

+            }

         }

     @Override

     public void applySecurity(ObserveDataSourceConfiguration dataSourceConfiguration, ImmutableSet<ObserveDbUserDto> users) {

-        if (log.isTraceEnabled()) {

-            log.trace("applySecurity(" + dataSourceConfiguration + ", [" + Joiner.on(", ").join(users.stream().map(ObserveDbUserDto::getName).collect(Collectors.toList())) + "])");

-        }

         // pas de securité  pour les bases autres que postgresql

         if (dataSourceConfiguration instanceof ObserveDataSourceConfigurationTopiaPG) {

             ObserveDataSourceConfigurationTopiaPG sourceConfiguration = (ObserveDataSourceConfigurationTopiaPG) dataSourceConfiguration;

-            ObserveTopiaApplicationContext optionalTopiaApplicationContext = ObserveTopiaApplicationContextFactory.getOrCreateTopiaApplicationContext(sourceConfiguration);

-

-            ObserveTopiaConfiguration topiaConfiguration = optionalTopiaApplicationContext.getConfiguration();

-

-            ObserveSecurityHelper securityHelper = new ObserveSecurityHelper(topiaConfiguration);

+            ObserveTopiaConfiguration topiaConfiguration;

+            try (ObserveTopiaApplicationContext optionalTopiaApplicationContext = ObserveTopiaApplicationContextFactory.getOrCreateTopiaApplicationContext(sourceConfiguration)) {

-            securityHelper.applySecurity(users, sourceConfiguration.isShowMigrationSql());

+                topiaConfiguration = optionalTopiaApplicationContext.getConfiguration();

+                new ObserveSecurityHelper(topiaConfiguration).applySecurity(users);

+            }

         }

     @Override

     public void migrateData(ObserveDataSourceConfiguration dataSourceConfiguration) {

-        if (log.isTraceEnabled()) {

-            log.trace("migrateData(" + dataSourceConfiguration + ")");

-        }

-

         ObserveTopiaApplicationContext topiaApplicationContext = ObserveTopiaApplicationContextFactory.getOrCreateTopiaApplicationContext((ObserveDataSourceConfigurationTopiaSupport) dataSourceConfiguration);

-

         topiaApplicationContext.getMigrationService().runSchemaMigration();

-

     }

     @Override

         Version version;

-        ObserveJdbcHelper observeJdbcHelper = new ObserveJdbcHelper(topiaConfiguration);

+        PostgresJdbcHelper jdbcHelper = new PostgresJdbcHelper(topiaConfiguration);

-        version = observeJdbcHelper.getVersion();

+        version = TMSVersionHibernateDao.getVersion(jdbcHelper, "tms_version").map(TMSVersion::toVersion).orElse(Version.VZERO);

         if (dataSourceConfiguration.isH2Database()) {

             // stockées dans pg canWriteData, canWrite pour etre sur du resultat

             // recherche des droits sur les données observers

-            Set<String> dataPrivileges = observeJdbcHelper.getTablePrivileges(ObserveSecurityHelper.OBSERVE_SEINE_SCHEMA_NAME, "trip");

+            Set<String> dataPrivileges = jdbcHelper.getTablePrivileges(ObserveSecurityHelper.OBSERVE_SEINE_SCHEMA_NAME, "trip");

             readData = canRead(dataPrivileges);

             writeData = canWrite(dataPrivileges);

             // recherche des droits sur le referentiel

-            Set<String> referentielPrivileges = observeJdbcHelper.getTablePrivileges(ObserveSecurityHelper.OBSERVE_COMMON_SCHEMA_NAME, "vessel");

+            Set<String> referentielPrivileges = jdbcHelper.getTablePrivileges(ObserveSecurityHelper.OBSERVE_COMMON_SCHEMA_NAME, "vessel");

             // Sur une base PG, on regarde en base ce que l'utilisateur peut lire/écrire

             writeReferential = canWrite(referentielPrivileges);

-

         }

-        if (log.isDebugEnabled()) {

-            log.debug("User can write referential : " + writeReferential + ", " +

-                    "read data : " + readData + ", " +

-                    "write data : " + writeData + ".");

-        }

+        log.debug(String.format("User can write referential : %s, read data : %s, write data : %s.", writeReferential, readData, writeData));

-        ObserveMigrationConfigurationProvider observeMigrationConfigurationProvider = ObserveMigrationConfigurationProvider.get();

+        MigrationVersionResourceProvider observeMigrationConfigurationProvider = MigrationVersionResourceProvider.get();

         return new ObserveDataSourceInformation(

                 true,

                 writeReferential,

                 readData,

                 writeData,

-                observeMigrationConfigurationProvider.getMinimumVersion(),

+                ObserveTopiaMigrationServiceAskUserToMigrate.getMinimumVersion(),

                 version,

                 observeMigrationConfigurationProvider.getVersionsAfter(version));

     }

     private void close(ObserveDataSourceConfigurationTopiaSupport dataSourceConfiguration, ObserveTopiaApplicationContext topiaApplicationContext) {

         if (topiaApplicationContext != null) {

-

-            if (log.isInfoEnabled()) {

-                log.info("Closing topia application context: " + dataSourceConfiguration);

-            }

+            log.info("Closing topia application context: " + dataSourceConfiguration);

             topiaApplicationContext.close();

-

         }

     }

  * it under the terms of the GNU General Public License as

  * published by the Free Software Foundation, either version 3 of the

  * License, or (at your option) any later version.

- * 

+ *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

- * 

+ *

  * You should have received a copy of the GNU General Public

  * License along with this program.  If not, see

  * <http://www.gnu.org/licenses/gpl-3.0.html>.

 import com.google.common.collect.ImmutableSet;

 import com.google.common.collect.ListMultimap;

-import org.nuiton.topia.persistence.util.TopiaBlobsContainer;

 import fr.ird.observe.dto.reference.ReferentialDtoReference;

 import fr.ird.observe.persistence.Entities;

 import fr.ird.observe.persistence.ObserveEntityEnum;

 import fr.ird.observe.services.service.sql.SqlScriptProducerService;

 import fr.ird.observe.spi.DbModelHelper;

 import org.apache.commons.collections4.CollectionUtils;

-import org.apache.commons.logging.Log;

-import org.apache.commons.logging.LogFactory;

 import org.nuiton.topia.persistence.metadata.TopiaMetadataModel;

-import org.nuiton.topia.service.sql.batch.SqlRequests;

-import org.nuiton.topia.service.sql.batch.SqlResult;

-import org.nuiton.topia.service.sql.batch.TopiaSqlBatchService;

-import org.nuiton.topia.service.sql.batch.actions.BlobsContainer;

-import org.nuiton.topia.service.sql.batch.actions.TopiaSqlTableSelectArgument;

-

-import java.io.ByteArrayOutputStream;

-import java.io.IOException;

-import java.io.OutputStreamWriter;

-import java.io.Writer;

-import java.nio.charset.StandardCharsets;

+import org.nuiton.topia.persistence.util.TopiaBlobsContainer;

+import org.nuiton.topia.service.script.TopiaSqlScriptGeneratorRequest;

+import org.nuiton.topia.service.script.TopiaSqlScriptGeneratorResult;

+import org.nuiton.topia.service.script.TopiaSqlScriptGeneratorService;

+import org.nuiton.topia.service.script.request.TopiaSqlTableSelectArgument;

+

+import java.nio.file.Files;

+import java.nio.file.Path;

 import java.util.List;

 import java.util.Set;

 import java.util.stream.Collectors;

-import java.util.zip.GZIPOutputStream;

 import static fr.ird.observe.persistence.Entities.IS_LONGLINE_ID;

 import static fr.ird.observe.persistence.Entities.IS_SEINE_ID;

  */

 public class SqlScriptProducerServiceLocal extends ObserveServiceLocal implements SqlScriptProducerService {

-    private static final Log log = LogFactory.getLog(SqlScriptProducerServiceLocal.class);

-

     @Override

     public AddSqlScriptProducerResult produceAddSqlScript(AddSqlScriptProducerRequest request) {

-        if (log.isTraceEnabled()) {

-            log.trace("produceAddSqlScript(" + request + ")");

-        }

-        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

+

+        Path targetPath = serviceContext.getTemporaryDirectoryRoot().toPath().resolve("addSqlScript-" + System.nanoTime() + ".sql");

+

+        try {

             ImmutableSet.Builder<TopiaBlobsContainer> observeBlobContainers = ImmutableSet.builder();

-            try (Writer writer = new OutputStreamWriter(new GZIPOutputStream(out), StandardCharsets.UTF_8)) {

-

-                TopiaSqlBatchService sqlBatchService = serviceContext.getTopiaApplicationContext().getSqlBatchService();

-                SqlRequests.Builder builder = sqlBatchService.requestBuilder().to(writer);

-

-                SqlRequests sqlRequests = sqlRequests(request, builder);

-                SqlResult sqlResult = sqlBatchService.execute(sqlRequests);

-                ImmutableSet<BlobsContainer> blobsContainers = sqlResult.getBlobsContainers();

-                for (BlobsContainer blobsContainer : blobsContainers) {

-                    observeBlobContainers.add(new TopiaBlobsContainer(blobsContainer.getTableName(),

-                                                                        blobsContainer.getColumnName(),

-                                                                        blobsContainer.getBlobsById()));

-                }

-            }

+            TopiaSqlScriptGeneratorService sqlBatchService = serviceContext.getTopiaApplicationContext().getSqlScriptGeneratorService();

+            TopiaSqlScriptGeneratorRequest builder = sqlBatchService.newRequest(targetPath);

-            return new AddSqlScriptProducerResult(out.toByteArray(), observeBlobContainers.build());

+            sqlRequests(request, builder);

+            TopiaSqlScriptGeneratorResult sqlResult = sqlBatchService.generate(builder);

+            ImmutableSet<TopiaBlobsContainer> blobsContainers = sqlResult.getBlobsContainers();

+            for (TopiaBlobsContainer blobsContainer : blobsContainers) {

+                observeBlobContainers.add(new TopiaBlobsContainer(blobsContainer.getTableName(),

+                        blobsContainer.getColumnName(),

+                        blobsContainer.getBlobsById()));

+            }

+            return new AddSqlScriptProducerResult(Files.readAllBytes(targetPath), observeBlobContainers.build());

-        } catch (IOException e) {

+        } catch (Exception e) {

             throw new RuntimeException("Could not produce sql script", e);

         }

     @Override

     public byte[] produceDeleteSqlScript(DeleteSqlScriptProducerRequest request) {

-        if (log.isTraceEnabled()) {

-            log.trace("produceDeleteSqlScript(" + request + ")");

-        }

-        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

-            try (Writer writer = new OutputStreamWriter(new GZIPOutputStream(out), StandardCharsets.UTF_8)) {

+        Path targetPath = serviceContext.getTemporaryDirectoryRoot().toPath().resolve("deleteSqlScript-" + System.nanoTime() + ".sql");

-                TopiaSqlBatchService sqlBatchService = serviceContext.getTopiaApplicationContext().getSqlBatchService();

-                SqlRequests.Builder builder = sqlBatchService.requestBuilder().to(writer);

+        try {

-                SqlRequests sqlRequests = sqlRequests(request, builder);

-                sqlBatchService.execute(sqlRequests);

-

-            }

-

-            return out.toByteArray();

-

-        } catch (IOException e) {

-            throw new RuntimeException("Could not produce delete sql script", e);

+            TopiaSqlScriptGeneratorService sqlBatchService = serviceContext.getTopiaApplicationContext().getSqlScriptGeneratorService();

+            TopiaSqlScriptGeneratorRequest builder = sqlBatchService.newRequest(targetPath);

+            sqlRequests(request, builder);

+            sqlBatchService.generate(builder);

+            return Files.readAllBytes(targetPath);

+        } catch (Exception e) {

+            throw new RuntimeException("Could not produce sql script", e);

         }

+

     }

     @SuppressWarnings("unchecked")

-    private SqlRequests sqlRequests(AddSqlScriptProducerRequest request, SqlRequests.Builder builder) {

+    private void sqlRequests(AddSqlScriptProducerRequest request, TopiaSqlScriptGeneratorRequest builder) {

-        if (serviceContext.getTopiaApplicationContext().getConfiguration().isShowSql()) {

-            builder.showSql();

+        if (request.isH2()) {

+            builder.forH2();

+        } else {

+            builder.forPostgresql();

         }

         if (request.isAddSchema()) {

-

-            SqlRequests.CreateSchemaRequestBuilder createSchemaRequestBuilder = builder

-                    .createSchemaBuilder()

-                    .setTemporaryPath(serviceContext.getTemporaryDirectoryRoot().toPath());

-            if (request.isH2()) {

-                createSchemaRequestBuilder.forH2();

-            } else {

-                createSchemaRequestBuilder.forPostgres();

-            }

-            createSchemaRequestBuilder.flush();

-

+            builder.addCreateSchemaRequest(true, true);

         }

         ObserveTopiaApplicationContext topiaApplicationContext = serviceContext.getTopiaApplicationContext();

         TopiaMetadataModel metadataModel = topiaApplicationContext.getMetadataModel();

         if (request.isAddReferential()) {

-            builder.replicateTablesBuilder(metadataModel)

-                    .setTables(topiaApplicationContext.getReferentialTables())

-                    .flush();

-

+            builder.addReplicateTablesRequest(topiaApplicationContext.getReferentialTables(), null, metadataModel);

         }

         if (request.isAddSomeReferential()) {

                 Class referenceType = DbModelHelper.fromReferentialEntity(entityType).toReferenceType();

                 List<String> ids = referentialIds.get(referenceType);

                 if (CollectionUtils.isNotEmpty(ids)) {

-

-                    builder.replicateTablesBuilder(metadataModel)

-                            .setTables(topiaApplicationContext.getReferentialTable(entityType))

-                            .setSelectArgument(TopiaSqlTableSelectArgument.of(ids))

-                            .flush();

-

+                    builder.addReplicateTablesRequest(topiaApplicationContext.getReferentialTable(entityType), TopiaSqlTableSelectArgument.of(ids), metadataModel);

                 }

             }

             ImmutableSet<String> tripIds = request.getDataIds();

             if (tripIds == null) {

-                builder.replicateTablesBuilder(metadataModel)

-                        .setTables(topiaApplicationContext.getTripSeineTables())

-                        .replicateTablesBuilder(metadataModel)

-                        .setTables(topiaApplicationContext.getTripLonglineTables())

-                        .flush();

+                builder.addReplicateTablesRequest(topiaApplicationContext.getTripSeineTables(), null, metadataModel);

+                builder.addReplicateTablesRequest(topiaApplicationContext.getTripLonglineTables(), null, metadataModel);

             } else {

                 {

-

                     Set<String> tripIds1 = tripIds.stream().filter(IS_SEINE_ID).collect(Collectors.toSet());

-

                     if (!tripIds1.isEmpty()) {

-

-                        builder.replicateTablesBuilder(metadataModel)

-                                .setTables(topiaApplicationContext.getTripSeineTables())

-                                .setSelectArgument(TopiaSqlTableSelectArgument.of(tripIds1))

-                                .flush();

-

+                        builder.addReplicateTablesRequest(topiaApplicationContext.getTripSeineTables(), TopiaSqlTableSelectArgument.of(tripIds1), metadataModel);

                     }

-

                 }

                 {

                     Set<String> tripIds1 = tripIds.stream().filter(IS_LONGLINE_ID).collect(Collectors.toSet());

                     if (!tripIds1.isEmpty()) {

-

-                        builder.replicateTablesBuilder(metadataModel)

-                                .setTables(topiaApplicationContext.getTripLonglineTables())

-                                .setSelectArgument(TopiaSqlTableSelectArgument.of(tripIds1))

-                                .flush();

-

+                        builder.addReplicateTablesRequest(topiaApplicationContext.getTripLonglineTables(), TopiaSqlTableSelectArgument.of(tripIds1), metadataModel);

                     }

-

                 }

-

             }

-

         }

-

-        return builder.build();

     }

-    private SqlRequests sqlRequests(DeleteSqlScriptProducerRequest request, SqlRequests.Builder builder) {

-

-        if (serviceContext.getTopiaApplicationContext().getConfiguration().isShowSql()) {

-            builder.showSql();

-        }

+    private void sqlRequests(DeleteSqlScriptProducerRequest request, TopiaSqlScriptGeneratorRequest builder) {

         ObserveTopiaApplicationContext topiaApplicationContext = serviceContext.getTopiaApplicationContext();

             ImmutableSet<String> tripIds = request.getDataIds();

             if (tripIds == null) {

-                builder.deleteTablesBuilder()

-                        .setTables(topiaApplicationContext.getTripSeineTables())

-                        .replicateTablesBuilder(topiaApplicationContext.getMetadataModel())

-                        .setTables(topiaApplicationContext.getTripLonglineTables())

-                        .flush();

+                builder.addDeleteTablesRequest(topiaApplicationContext.getTripSeineTables(), null);

+                builder.addDeleteTablesRequest(topiaApplicationContext.getTripLonglineTables(), null);

             } else {

                 {

-

                     Set<String> tripIds1 = tripIds.stream().filter(Entities.IS_SEINE_ID).collect(Collectors.toSet());

-

                     if (!tripIds1.isEmpty()) {

-

-                        builder.deleteTablesBuilder()

-                                .setTables(topiaApplicationContext.getTripSeineTables())

-                                .setSelectArgument(TopiaSqlTableSelectArgument.of(tripIds1))

-                                .flush();

-

+                        builder.addDeleteTablesRequest(topiaApplicationContext.getTripSeineTables(), TopiaSqlTableSelectArgument.of(tripIds1));

                     }

-

                 }

                 {

-

                     Set<String> tripIds1 = tripIds.stream().filter(Entities.IS_LONGLINE_ID).collect(Collectors.toSet());

-

                     if (!tripIds1.isEmpty()) {

-

-                        builder.deleteTablesBuilder()

-                                .setTables(topiaApplicationContext.getTripLonglineTables())

-                                .setSelectArgument(TopiaSqlTableSelectArgument.of(tripIds1))

-                                .flush();

-

+                        builder.addDeleteTablesRequest(topiaApplicationContext.getTripLonglineTables(), TopiaSqlTableSelectArgument.of(tripIds1));

                     }

-

                 }

-

             }

-

         }

-

-        return builder.build();

     }

 }
  * it under the terms of the GNU General Public License as

  * published by the Free Software Foundation, either version 3 of the

  * License, or (at your option) any later version.

- * 

+ *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

- * 

+ *

  * You should have received a copy of the GNU General Public

  * License along with this program.  If not, see

  * <http://www.gnu.org/licenses/gpl-3.0.html>.

  * #L%

  */

-import fr.ird.observe.persistence.migration.ObserveMigrationConfigurationProvider;

 import fr.ird.observe.services.configuration.topia.ObserveDataSourceConfigurationTopiaH2;

 import fr.ird.observe.test.TestHelper;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

+import org.nuiton.topia.service.migration.resources.MigrationVersionResourceProvider;

 import org.nuiton.version.Version;

 import java.io.File;

         configurationTopiaH2.setDirectory(localDbFile);

         configurationTopiaH2.setDbName("obstuna");

         configurationTopiaH2.setAutoMigrate(true);

-        configurationTopiaH2.setModelVersion(ObserveMigrationConfigurationProvider.get().getLastVersion());

+        configurationTopiaH2.setModelVersion(MigrationVersionResourceProvider.get().getLastVersion());

         return configurationTopiaH2;

     }

  * it under the terms of the GNU General Public License as

  * published by the Free Software Foundation, either version 3 of the

  * License, or (at your option) any later version.

- * 

+ *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

- * 

+ *

  * You should have received a copy of the GNU General Public

  * License along with this program.  If not, see

  * <http://www.gnu.org/licenses/gpl-3.0.html>.

 import fr.ird.observe.test.ObserveFixtures;

 import fr.ird.observe.test.spi.DatabaseNameConfiguration;

 import org.junit.Test;

-import org.nuiton.topia.service.sql.batch.actions.ReplicateTablesRequest;

-import org.nuiton.topia.service.sql.batch.tables.TopiaSqlTables;

+import org.nuiton.topia.service.script.request.ReplicateTablesRequest;

+import org.nuiton.topia.service.script.table.TopiaSqlTables;

 /**

  * Created on 29/12/15.

         TopiaSqlTables tables = localTestMethodResource.getTopiaApplicationContext().getReferentialTables();

-        ReplicateTablesRequest request

-                = createReplicateTablesRequest(DatabaseName.empty_h2)

-                .setTables(tables)

-                .build();

-

+        ReplicateTablesRequest request = createReplicateTablesRequest(DatabaseName.empty_h2, tables, null);

         testReplicate0(request, ObserveFixtures.REFERENTIAL_TABLES_COUNT);

     }

  * it under the terms of the GNU General Public License as

  * published by the Free Software Foundation, either version 3 of the

  * License, or (at your option) any later version.

- * 

+ *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

- * 

+ *

  * You should have received a copy of the GNU General Public

  * License along with this program.  If not, see

  * <http://www.gnu.org/licenses/gpl-3.0.html>.

  */

 import com.google.common.collect.ImmutableMap;

-import com.google.common.io.Files;

 import fr.ird.observe.persistence.ObserveTopiaApplicationContext;

 import fr.ird.observe.persistence.ObserveTopiaPersistenceContext;

 import fr.ird.observe.services.configuration.DataSourceCreateWithNoReferentialImportException;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import org.junit.Assert;

-import org.nuiton.topia.service.sql.batch.actions.ReplicateTablesRequest;

-import org.nuiton.topia.service.sql.batch.tables.TopiaSqlTable;

-import org.nuiton.topia.service.sql.batch.tables.TopiaSqlTables;

+import org.nuiton.topia.persistence.util.SqlScriptConsumer;

+import org.nuiton.topia.service.script.TopiaSqlScriptGeneratorRequest;

+import org.nuiton.topia.service.script.request.ReplicateTablesRequest;

+import org.nuiton.topia.service.script.request.TopiaSqlTableSelectArgument;

+import org.nuiton.topia.service.script.table.TopiaSqlTable;

+import org.nuiton.topia.service.script.table.TopiaSqlTables;

 import org.nuiton.util.StringUtil;

 import java.io.File;

 import java.io.IOException;

-import java.io.Writer;

-import java.nio.charset.StandardCharsets;

 import java.util.Map;

 /**

     private static final Log log = LogFactory.getLog(ReplicateTestSupport.class);

     private File scriptFile;

+    private ObserveTopiaApplicationContext targetTopiaApplicationContext;

-    ReplicateTablesRequest.Builder createReplicateTablesRequest(DatabaseName databaseName) throws DataSourceCreateWithNoReferentialImportException, IOException, IncompatibleDataSourceCreateConfigurationException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {

-

-        File targetDatabaseDirectory = new File(localTestMethodResource.getTestDirectory(), "targetReplication");

-        ObserveDataSourceConfigurationTopiaH2 targetTopiaConfiguration = TOPIA_TEST_CLASS_RESOURCE.createDataSourceConfiguration(localTestMethodResource.getDbVersion(), databaseName.name(), targetDatabaseDirectory, localTestMethodResource.getLogin(), localTestMethodResource.getPassword());

-        ObserveTopiaApplicationContext targetTopiaApplicationContext = ObserveTopiaApplicationContextFactory.getOrCreateTopiaApplicationContext(targetTopiaConfiguration);

-

-        scriptFile = new File(localTestMethodResource.getTestDirectory(), "script.sql");

-

-        Writer writer = Files.newWriter(scriptFile, StandardCharsets.UTF_8);

-

-        return localTestMethodResource.getTopiaApplicationContext()

-                .getSqlBatchService()

-                .replicateTablesRequestBuilder()

-                .to(targetTopiaApplicationContext)

-                .to(writer);

-    }

-

-    private static void assertReplicateTripResults(ReplicateTablesRequest replicationRequest, ImmutableMap<String, Long> expectedResults) {

+    private static void assertReplicateTripResults(ObserveTopiaApplicationContext targetTopiaApplicationContext, File scriptFile, ReplicateTablesRequest replicationRequest, ImmutableMap<String, Long> expectedResults) {

         TopiaSqlTables tables = replicationRequest.getTables();

-        try (ObserveTopiaPersistenceContext persistenceContext = (ObserveTopiaPersistenceContext) replicationRequest.getTargetTopiaApplicationContext().newPersistenceContext()) {

+        try (ObserveTopiaPersistenceContext persistenceContext = targetTopiaApplicationContext.newPersistenceContext()) {

+

+            persistenceContext.getSqlSupport().doSqlWork(SqlScriptConsumer.of(scriptFile.toPath()));

             for (TopiaSqlTable table : tables) {

                 String fullyTableName = table.getFullyTableName();

     }

+    ReplicateTablesRequest createReplicateTablesRequest(DatabaseName databaseName, TopiaSqlTables tables, TopiaSqlTableSelectArgument selectedArgument) throws DataSourceCreateWithNoReferentialImportException, IOException, IncompatibleDataSourceCreateConfigurationException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {

+

+        File targetDatabaseDirectory = new File(localTestMethodResource.getTestDirectory(), "targetReplication");

+        ObserveDataSourceConfigurationTopiaH2 targetTopiaConfiguration = TOPIA_TEST_CLASS_RESOURCE.createDataSourceConfiguration(localTestMethodResource.getDbVersion(), databaseName.name(), targetDatabaseDirectory, localTestMethodResource.getLogin(), localTestMethodResource.getPassword());

+        targetTopiaApplicationContext = ObserveTopiaApplicationContextFactory.getOrCreateTopiaApplicationContext(targetTopiaConfiguration);

+

+        scriptFile = new File(localTestMethodResource.getTestDirectory(), "script.sql");

+

+        return new ReplicateTablesRequest(tables, selectedArgument, targetTopiaApplicationContext.getMetadataModel());

+    }

+

     void testReplicate0(ReplicateTablesRequest request, ImmutableMap<String, Long> expectedTablesCount) {

         TopiaSqlTables tables = request.getTables();

         log.info(String.format("Will replicate using %d tables.", tables.size()));

+        TopiaSqlScriptGeneratorRequest generatorRequest = localTestMethodResource.getTopiaApplicationContext()

+                .getSqlScriptGeneratorService()

+                .newRequest(scriptFile.toPath())

+                .gzip(false)

+                .addRequest(request);

         localTestMethodResource.getTopiaApplicationContext()

-                .getSqlBatchService()

-                .execute(request);

+                .getSqlScriptGeneratorService()

+                .generate(generatorRequest);

-        assertReplicateTripResults(request, expectedTablesCount);

+        assertReplicateTripResults(targetTopiaApplicationContext, scriptFile, request, expectedTablesCount);

         log.debug(String.format("Replicate to script (length: %s) :\n%s", StringUtil.convertMemory(scriptFile.length()), scriptFile));

  * it under the terms of the GNU General Public License as

  * published by the Free Software Foundation, either version 3 of the

  * License, or (at your option) any later version.

- * 

+ *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

- * 

+ *

  * You should have received a copy of the GNU General Public

  * License along with this program.  If not, see

  * <http://www.gnu.org/licenses/gpl-3.0.html>.

 import fr.ird.observe.test.spi.DatabaseNameConfiguration;

 import org.junit.Ignore;

 import org.junit.Test;

-import org.nuiton.topia.service.sql.batch.actions.ReplicateTablesRequest;

-import org.nuiton.topia.service.sql.batch.actions.TopiaSqlTableSelectArgument;

-import org.nuiton.topia.service.sql.batch.tables.TopiaSqlTables;

+import org.nuiton.topia.service.script.request.ReplicateTablesRequest;

+import org.nuiton.topia.service.script.request.TopiaSqlTableSelectArgument;

+import org.nuiton.topia.service.script.table.TopiaSqlTables;

 import java.io.IOException;

     @Test

     public void testReplicateAllTripLongline2() throws Exception {

         testReplicate(ObserveFixtures.ALL_TRIP_LONGLINE_COUNT,

-                      ObserveFixtures.TRIP_LONGLINE_ID_1,

-                      ObserveFixtures.TRIP_LONGLINE_ID_2,

-                      ObserveFixtures.TRIP_LONGLINE_ID_3);

+                ObserveFixtures.TRIP_LONGLINE_ID_1,

+                ObserveFixtures.TRIP_LONGLINE_ID_2,

+                ObserveFixtures.TRIP_LONGLINE_ID_3);

     }

     @Test

     protected void testReplicate(ImmutableMap<String, Long> expectedTablesCount, String... tripIds) throws DataSourceCreateWithNoReferentialImportException, IOException, IncompatibleDataSourceCreateConfigurationException, DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {

         TopiaSqlTables tables = localTestMethodResource.getTopiaApplicationContext().getTripLonglineTables();

-        ReplicateTablesRequest request

-                = createReplicateTablesRequest(DatabaseName.referentiel)

-                .setSelectArgument(TopiaSqlTableSelectArgument.of(tripIds))

-                .setTables(tables)

-                .build();

-

+        ReplicateTablesRequest request = createReplicateTablesRequest(DatabaseName.referentiel, tables, TopiaSqlTableSelectArgument.of(tripIds));

         testReplicate0(request, expectedTablesCount);

     }

  * it under the terms of the GNU General Public License as

  * published by the Free Software Foundation, either version 3 of the

  * License, or (at your option) any later version.

- * 

+ *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

- * 

+ *

  * You should have received a copy of the GNU General Public

  * License along with this program.  If not, see

  * <http://www.gnu.org/licenses/gpl-3.0.html>.

 import fr.ird.observe.test.ObserveFixtures;

 import fr.ird.observe.test.spi.DatabaseNameConfiguration;

 import org.junit.Test;

-import org.nuiton.topia.service.sql.batch.actions.ReplicateTablesRequest;

-import org.nuiton.topia.service.sql.batch.actions.TopiaSqlTableSelectArgument;

-import org.nuiton.topia.service.sql.batch.tables.TopiaSqlTables;

+import org.nuiton.topia.service.script.request.ReplicateTablesRequest;

+import org.nuiton.topia.service.script.request.TopiaSqlTableSelectArgument;

+import org.nuiton.topia.service.script.table.TopiaSqlTables;

 /**

  * Created on 29/12/15.

     @Test

     public void testReplicateAllTripSeine2() throws Exception {

         testReplicate(ObserveFixtures.ALL_TRIP_SEINE_COUNT,

-                      ObserveFixtures.TRIP_SEINE_ID_1,

-                      ObserveFixtures.TRIP_SEINE_ID_2,

-                      ObserveFixtures.TRIP_SEINE_ID_3);

+                ObserveFixtures.TRIP_SEINE_ID_1,

+                ObserveFixtures.TRIP_SEINE_ID_2,

+                ObserveFixtures.TRIP_SEINE_ID_3);

     }

     @Test

     }

     protected void testReplicate(ImmutableMap<String, Long> expectedTablesCount, String... tripIds) throws Exception {

-

         TopiaSqlTables tables = localTestMethodResource.getTopiaApplicationContext().getTripSeineTables();

-

-        ReplicateTablesRequest request

-                = createReplicateTablesRequest(DatabaseName.referentiel)

-                .setSelectArgument(TopiaSqlTableSelectArgument.of(tripIds))

-                .setTables(tables)

-                .build();

-

+        ReplicateTablesRequest request = createReplicateTablesRequest(DatabaseName.referentiel, tables, TopiaSqlTableSelectArgument.of(tripIds));

         testReplicate0(request, expectedTablesCount);

     }

  * it under the terms of the GNU General Public License as

  * published by the Free Software Foundation, either version 3 of the

  * License, or (at your option) any later version.

- * 

+ *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

- * 

+ *

  * You should have received a copy of the GNU General Public

  * License along with this program.  If not, see

  * <http://www.gnu.org/licenses/gpl-3.0.html>.

 import fr.ird.observe.dto.data.seine.TripSeineDto;

 import fr.ird.observe.dto.form.Form;

 import fr.ird.observe.dto.referential.ProgramDto;

-import fr.ird.observe.persistence.migration.ObserveMigrationConfigurationProvider;

 import fr.ird.observe.services.configuration.ObserveDataSourceConnection;

 import fr.ird.observe.services.configuration.topia.ObserveDataSourceConfigurationTopiaPG;

 import fr.ird.observe.services.security.UnauthorizedException;

 import org.junit.Assert;

 import org.junit.Ignore;

 import org.junit.Test;

+import org.nuiton.topia.service.migration.resources.MigrationVersionResourceProvider;

 /**

  * FIXME Ca sert à quoi ? et je comprends pas le mot rigth ?

         configurationTopiaPG.setUsername(login);

         configurationTopiaPG.setPassword('a');

         configurationTopiaPG.setAutoMigrate(true);

-        configurationTopiaPG.setModelVersion(ObserveMigrationConfigurationProvider.get().getLastVersion());

+        configurationTopiaPG.setModelVersion(MigrationVersionResourceProvider.get().getLastVersion());

         return configurationTopiaPG;

     }

-

     public void testReadData(String login) throws DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException, BabModelVersionException {

         TripSeineService service = localTestMethodResource.newService(TripSeineService.class);

Tony CHEMIT pushed to branch develop at ultreiaio / ird-observe

Commits:

18 changed files:

Changes: