[Observe-commits] [Git][ultreiaio/ird-observe][develop] 2 commits: Impossible de créer une base centrale vierge, quelque soit la méthode...

18 Mar 2022


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


Commits:
9995f02b by Tony Chemit at 2022-03-18T09:19:10+01:00
Impossible de créer une base centrale vierge, quelque soit la méthode appliquée - See ultreiaio/ird-observe#2214

- - - - -
6883c98a by Tony Chemit at 2022-03-18T09:40:35+01:00
update pom

- - - - -


24 changed files:

- client/core/src/main/java/fr/ird/observe/client/datasource/api/ObserveDataSourcesManager.java
- client/core/src/main/java/fr/ird/observe/client/datasource/api/ObserveSwingDataSource.java
- client/core/src/main/java/fr/ird/observe/client/datasource/h2/backup/BackupsManager.java
- client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/DataSourceEditorHelper.java
- client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/loading/open/OpenDataSourceActionStep.java
- client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/wizard/DataSourceHelper.java
- client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/wizard/StorageBackupUILauncher.java
- client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/wizard/StorageUIModel.java
- client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/wizard/launchers/CreateLauncher.java
- client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/wizard/tabs/ConfigDataUI.jaxx
- client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/wizard/tabs/SelectDataUIHandler.java
- client/runner/src/test/java/fr/ird/observe/client/ClientTestClassResource.java
- + core/persistence/java/src/main/java/fr/ird/observe/entities/DataSourceCreateHelper.java
- core/persistence/java/src/main/java/fr/ird/observe/entities/ObserveTopiaApplicationContext.java
- core/services/client/src/main/java/fr/ird/observe/services/client/AnonymousServiceClient.java
- core/services/client/src/test/java/fr/ird/observe/services/client/service/AnonymousServiceClientReadTest.java
- core/services/local/src/main/java/fr/ird/observe/services/local/service/AnonymousServiceLocalSupport.java
- core/services/local/src/test/java/fr/ird/observe/services/local/LocalTestClassResource.java
- core/services/test/src/main/java/fr/ird/observe/services/service/AnonymousServiceFixtures.java
- pom.xml
- server/core/src/main/filtered-resources/META-INF/mapping-api-client.wm
- server/core/src/main/java/fr/ird/observe/server/ObserveWebApplicationContext.java
- server/core/src/main/java/fr/ird/observe/server/controller/AnonymousServiceRestApi.java
- server/core/src/main/java/fr/ird/observe/server/converter/JsonAwareDtoConverter.java


Changes:

=====================================
client/core/src/main/java/fr/ird/observe/client/datasource/api/ObserveDataSourcesManager.java
=====================================
@@ -28,7 +28,6 @@ import fr.ird.observe.client.datasource.api.event.ObserveSwingDataSourceListener
 import fr.ird.observe.dto.db.BabModelVersionException;
 import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
 import fr.ird.observe.dto.db.DatabaseNotFoundException;
-import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
 import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
 import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
 import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
@@ -41,6 +40,7 @@ import fr.ird.observe.spi.decoration.DecoratorService;
 import io.ultreia.java4all.i18n.I18n;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.nuiton.topia.persistence.script.TopiaSqlScript;
 
 import java.io.Closeable;
 import java.io.File;
@@ -170,6 +170,17 @@ public class ObserveDataSourcesManager implements Closeable {
         return dataSource;
     }
 
+    public ObserveSwingDataSource newDataSource(ObserveDataSourceConfigurationTopiaH2 configuration, TopiaSqlScript dump) {
+        ObserveSwingDataSource dataSource = new ObserveSwingDataSource(config, serviceFactory, decoratorService, configuration) {
+            @Override
+            public void open() throws DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException, BabModelVersionException, IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException {
+                createFromDump(dump);
+            }
+        };
+        addInternalListener(dataSource);
+        return dataSource;
+    }
+
     void addInternalListener(ObserveSwingDataSource dataSource) {
         dataSource.addObserveSwingDataSourceListener(new ObserveSwingDataSourceListenerAdapter() {
 
@@ -195,18 +206,6 @@ public class ObserveDataSourcesManager implements Closeable {
         });
     }
 
-    public ObserveSwingDataSource newDataSource(ObserveDataSourceConfigurationTopiaH2 configuration, DataSourceCreateConfigurationDto createDto) {
-        ObserveSwingDataSource dataSource = new ObserveSwingDataSource(config, serviceFactory, decoratorService, configuration) {
-            @Override
-            public void open() throws DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException, BabModelVersionException, IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException {
-                create(createDto);
-
-            }
-        };
-        addInternalListener(dataSource);
-        return dataSource;
-    }
-
     @Override
     public void close() {
 


=====================================
client/core/src/main/java/fr/ird/observe/client/datasource/api/ObserveSwingDataSource.java
=====================================
@@ -22,6 +22,8 @@ package fr.ird.observe.client.datasource.api;
  * #L%
  */
 
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Multimap;
 import fr.ird.observe.client.WithClientUIContextApi;
 import fr.ird.observe.client.configuration.ClientConfig;
 import fr.ird.observe.client.datasource.api.event.ObserveSwingDataSourceEvent;
@@ -38,7 +40,6 @@ import fr.ird.observe.dto.db.BabModelVersionException;
 import fr.ird.observe.dto.db.DataSourceUserDto;
 import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
 import fr.ird.observe.dto.db.DatabaseNotFoundException;
-import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
 import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
 import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
 import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
@@ -86,6 +87,7 @@ import javax.swing.event.EventListenerList;
 import java.io.File;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
 import java.util.Iterator;
@@ -241,27 +243,66 @@ public class ObserveSwingDataSource extends AbstractJavaBean implements ObserveS
         fireOpened();
     }
 
-    public void createFrom(ObserveSwingDataSource localSource)
+    public void createEmpty()
             throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException,
             DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {
-        DataSourceCreateConfigurationDto createDto = new DataSourceCreateConfigurationDto();
-        createDto.setLeaveOpenSource(true);
-        createDto.setImportReferentialDataSourceConfiguration(localSource.getConfiguration());
-        create(createDto);
+        checkIsNotOpen();
+        fireNewMessage(t("observe.ui.datasource.storage.message.creating", getLabel()));
+        fireOpening();
+        AnonymousService dataSourceService = getAnonymousService();
+        setConnection(dataSourceService.createEmpty(getConfiguration()));
+        fireNewMessage(t("observe.ui.datasource.storage.message.created", getLabel()));
+        fireOpened();
     }
 
-    public void create(DataSourceCreateConfigurationDto createDto)
+    public void createFromDump(TopiaSqlScript dump)
             throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException,
             DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {
         checkIsNotOpen();
         fireNewMessage(t("observe.ui.datasource.storage.message.creating", getLabel()));
         fireOpening();
         AnonymousService dataSourceService = getAnonymousService();
-        setConnection(dataSourceService.create(getConfiguration(), createDto));
+        setConnection(dataSourceService.createFromDump(getConfiguration(), dump));
         fireNewMessage(t("observe.ui.datasource.storage.message.created", getLabel()));
         fireOpened();
     }
 
+    public void createFromImport(TopiaSqlScript referential, TopiaSqlScript data)
+            throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException,
+            DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {
+        checkIsNotOpen();
+        fireNewMessage(t("observe.ui.datasource.storage.message.creating", getLabel()));
+        fireOpening();
+        AnonymousService dataSourceService = getAnonymousService();
+        setConnection(dataSourceService.createFromImport(getConfiguration(), referential, data));
+        fireNewMessage(t("observe.ui.datasource.storage.message.created", getLabel()));
+        fireOpened();
+    }
+
+    public TopiaSqlScript extract(boolean loadSchema, Set<String> importDataIds) {
+        checkIsOpen();
+        DataSourceService dataSourceService = getDataSourceService();
+        CreateDatabaseRequest.Builder request = CreateDatabaseRequest.builder(true, getVersion());
+        if (loadSchema) {
+            request.addSchema().addStandaloneTables();
+        }
+        if (importDataIds != null) {
+            Multimap<String, String> idsByType = ArrayListMultimap.create();
+            for (String importDataId : importDataIds) {
+                //FIXME
+                String className = importDataId.contains(".ll.") ? "fr.ird.observe.entities.data.ll.common.Trip" : "fr.ird.observe.entities.data.ps.common.Trip";
+                idsByType.put(className, importDataId);
+            }
+            for (Map.Entry<String, Collection<String>> entry : idsByType.asMap().entrySet()) {
+                String type = entry.getKey();
+                Set<String> dataIds = Set.copyOf(entry.getValue());
+                log.info(String.format("Add %d data of type: %s", dataIds.size(), type));
+                request.dataIdsToAdd(type, dataIds);
+            }
+        }
+        return dataSourceService.produceCreateSqlScript(request.build());
+    }
+
     @Override
     public void close() {
         if (!configurationAndConnection.withConnection()) {


=====================================
client/core/src/main/java/fr/ird/observe/client/datasource/h2/backup/BackupsManager.java
=====================================
@@ -30,7 +30,6 @@ import fr.ird.observe.client.datasource.api.ObserveSwingDataSource;
 import fr.ird.observe.client.datasource.api.event.ObserveSwingDataSourceEvent;
 import fr.ird.observe.client.datasource.api.event.ObserveSwingDataSourceListenerAdapter;
 import fr.ird.observe.client.util.ObserveSwingTechnicalException;
-import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
 import io.ultreia.java4all.lang.Strings;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -98,9 +97,6 @@ public class BackupsManager implements Closeable {
             log.info("Will check backup " + backupStorage.getFile());
 
             try {
-//                byte[] dump = Files.readAllBytes(backupStorage.getFile().toPath());
-                DataSourceCreateConfigurationDto createDto = new DataSourceCreateConfigurationDto();
-                createDto.setImportDatabase(TopiaSqlScript.of(backupStorage.getFile().toURI()));
 
                 try (ObserveSwingDataSource dataSource = dataSourcesManager.newTemporaryH2DataSource("check-" + backupStorage.getName())) {
                     dataSource.addObserveSwingDataSourceListener(new ObserveSwingDataSourceListenerAdapter() {
@@ -109,7 +105,7 @@ public class BackupsManager implements Closeable {
                             dataSource.destroy();
                         }
                     });
-                    dataSource.create(createDto);
+                    dataSource.createFromDump(TopiaSqlScript.of(backupStorage.getFile().toURI()));
                 }
                 backupStorage.setVerified(true);
                 log.info("Add sane backup from " + backupStorage.getFile());


=====================================
client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/DataSourceEditorHelper.java
=====================================
@@ -34,7 +34,6 @@ import fr.ird.observe.client.main.ObserveMainUI;
 import fr.ird.observe.client.util.ObserveSwingTechnicalException;
 import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
 import fr.ird.observe.dto.db.configuration.DataSourceConnectMode;
-import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
 import fr.ird.observe.dto.db.configuration.DataSourceInitMode;
 import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
 import fr.ird.observe.dto.db.configuration.ObserveDataSourceInformation;
@@ -212,13 +211,8 @@ public class DataSourceEditorHelper implements WithClientUIContextApi {
 
         log.info("Will load last backup: " + backupStorage.getFile());
         try {
-            DataSourceCreateConfigurationDto createDto = new DataSourceCreateConfigurationDto();
-            createDto.setImportDatabase(TopiaSqlScript.of(backupStorage.getFile().toPath().toUri()));
-
             ObserveDataSourceConfigurationTopiaH2 dataSourceConfigurationH2 = dataSourcesManager.newH2DataSourceConfiguration(I18n.n("observe.runner.initStorage.label.local"));
-
-            ObserveSwingDataSource dataSource = dataSourcesManager.newDataSource(dataSourceConfigurationH2, createDto);
-
+            ObserveSwingDataSource dataSource = dataSourcesManager.newDataSource(dataSourceConfigurationH2, TopiaSqlScript.of(backupStorage.getFile().toPath().toUri()));
             //FIXME:BodyContent Review progress model, not linked to ui any more...
             mainUI.getMainUIBodyContentManager().getBodyTyped(DataSourceEditor.class, DataSourceEditorBodyContent.class).loadStorage(mainUI, dataSource);
         } catch (Exception e) {


=====================================
client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/loading/open/OpenDataSourceActionStep.java
=====================================
@@ -31,11 +31,11 @@ import fr.ird.observe.client.datasource.editor.api.DataSourceEditorBodyContent;
 import fr.ird.observe.client.datasource.editor.api.loading.LoadingDataSourceContext;
 import fr.ird.observe.client.datasource.editor.api.wizard.DataSourceHelper;
 import fr.ird.observe.client.datasource.editor.api.wizard.StorageUIModel;
-import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
 import fr.ird.observe.dto.db.configuration.DataSourceInitModel;
 import fr.ird.observe.dto.db.configuration.ObserveDataSourceInformation;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.nuiton.topia.persistence.script.TopiaSqlScript;
 
 import static io.ultreia.java4all.i18n.I18n.t;
 
@@ -115,8 +115,8 @@ public class OpenDataSourceActionStep extends OpenDataSourceActionStepSupport {
         try {
             if (initModel.isOnCreateMode()) {
                 // do create local data source
-                DataSourceCreateConfigurationDto creationConfigurationDto = DataSourceHelper.getCreationConfigurationDto(model);
-                newDataSource.create(creationConfigurationDto);
+                TopiaSqlScript dump = DataSourceHelper.getCreationConfigurationDto(model);
+                newDataSource.createFromDump(dump);
             } else {
                 // open data source
                 newDataSource.open();


=====================================
client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/wizard/DataSourceHelper.java
=====================================
@@ -32,7 +32,6 @@ import fr.ird.observe.client.util.ObserveSwingTechnicalException;
 import fr.ird.observe.dto.db.BabModelVersionException;
 import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
 import fr.ird.observe.dto.db.DatabaseNotFoundException;
-import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
 import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
 import fr.ird.observe.dto.db.configuration.DataSourceInitModel;
 import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
@@ -49,6 +48,7 @@ import org.nuiton.topia.service.sql.request.CreateDatabaseRequest;
 
 import java.io.File;
 import java.nio.file.Path;
+import java.util.Set;
 
 /**
  * Created on 01/03/2021.
@@ -57,6 +57,7 @@ import java.nio.file.Path;
  * @since 8.0.7
  */
 public class DataSourceHelper {
+    public static final String referentialDbLabel = I18n.n("observe.ui.datasource.storage.label.reference.import.db");
     private static final Logger log = LogManager.getLogger(DataSourceHelper.class);
 
     public static void importModel(StorageUIModel source, StorageUIModel dst) {
@@ -79,7 +80,6 @@ public class DataSourceHelper {
         dst.getChooseDb().updateEditConfig();
     }
 
-
     public static void exportModel(StorageUIModel source, StorageUIModel dst) {
         source.getChooseDb().copyTo(dst.getChooseDb());
 
@@ -99,51 +99,74 @@ public class DataSourceHelper {
         dst.setDataSourceInformation(source.getDataSourceInformation());
     }
 
-    public static DataSourceCreateConfigurationDto getCreationConfigurationDto(StorageUIModel model) throws DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException, BabModelVersionException, IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException {
-        DataSourceCreateConfigurationDto result = null;
+    public static TopiaSqlScript getCreationConfigurationDto(StorageUIModel model) throws DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException, BabModelVersionException, IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException {
         ChooseDbModel chooseDb = model.getChooseDb();
         DataSourceInitModel initModel = chooseDb.getInitModel();
-        if (initModel.isOnCreateMode()) {
-            result = new DataSourceCreateConfigurationDto();
-            TopiaSqlScript importDatabase = null;
-            ObserveDataSourceConfiguration configSrc = null;
-            switch (initModel.getCreateMode()) {
+        TopiaSqlScript importDatabase = null;
+        ObserveDataSourceConfiguration configSrc = null;
+        switch (initModel.getCreateMode()) {
 
-                case EMPTY:
-                    break;
-                case IMPORT_INTERNAL_DUMP: {
-                    File dumpFile = model.getClientConfig().getInitialDbDump();
-                    importDatabase = TopiaSqlScript.of(dumpFile.toURI());
-                }
+            case EMPTY:
                 break;
-                case IMPORT_EXTERNAL_DUMP: {
-                    File dumpFile = model.getDumpFile();
-                    importDatabase = TopiaSqlScript.of(dumpFile.toURI());
-                }
+            case IMPORT_INTERNAL_DUMP: {
+                File dumpFile = model.getClientConfig().getInitialDbDump();
+                importDatabase = TopiaSqlScript.of(dumpFile.toURI());
+            }
+            break;
+            case IMPORT_EXTERNAL_DUMP: {
+                File dumpFile = model.getDumpFile();
+                importDatabase = TopiaSqlScript.of(dumpFile.toURI());
+            }
+            break;
+            case IMPORT_LOCAL_STORAGE:
+                configSrc = model.getLocalConfig().getConfiguration();
+                break;
+            case IMPORT_REMOTE_STORAGE:
+                configSrc = model.getRemoteConfig().getConfiguration();
                 break;
-                case IMPORT_LOCAL_STORAGE:
-                    configSrc = model.getLocalConfig().getConfiguration();
-                    break;
-                case IMPORT_REMOTE_STORAGE:
-                    configSrc = model.getRemoteConfig().getConfiguration();
-                    break;
-                case IMPORT_SERVER_STORAGE:
-                    configSrc = model.getServerConfig().getConfiguration();
-                    break;
+            case IMPORT_SERVER_STORAGE:
+                configSrc = model.getServerConfig().getConfiguration();
+                break;
+        }
+        if (configSrc != null) {
+            try (ObserveSwingDataSource source = model.getDataSourcesManager().newDataSource(configSrc)) {
+                source.open();
+                DataSourceService dumpService = source.getDataSourceService();
+                CreateDatabaseRequest request = CreateDatabaseRequest.builder(false, source.getVersion()).addSchema().addStandaloneTables().build();
+                importDatabase = dumpService.produceCreateSqlScript(request);
             }
-            if (configSrc != null) {
-                try (ObserveSwingDataSource source = model.getDataSourcesManager().newDataSource(configSrc)) {
-                    source.open();
-                    DataSourceService dumpService = source.getDataSourceService();
-                    CreateDatabaseRequest request = CreateDatabaseRequest.builder(false, source.getVersion()).addSchema().addStandaloneTables().build();
-                    importDatabase = dumpService.produceCreateSqlScript(request);
-                }
+        }
+        return importDatabase;
+    }
+
+    public static TopiaSqlScript extract(ObserveDataSourcesManager dataSourcesManager, File dumpFile, boolean loadSchema, Set<String> importDataIds) {
+        try (ObserveSwingDataSource importDataSource = dataSourcesManager.newTemporaryH2DataSource(referentialDbLabel)) {
+            try {
+                importDataSource.createFromDump(TopiaSqlScript.of(dumpFile.toURI()));
+                return importDataSource.extract(loadSchema, importDataIds);
+            } catch (IncompatibleDataSourceCreateConfigurationException
+                    | DataSourceCreateWithNoReferentialImportException
+                    | DatabaseNotFoundException
+                    | DatabaseConnexionNotAuthorizedException
+                    | BabModelVersionException e) {
+                throw new ObserveSwingTechnicalException("Could not create import data source", e);
             }
-            if (importDatabase != null) {
-                result.setImportDatabase(importDatabase);
+        }
+    }
+
+    public static TopiaSqlScript extract(ObserveDataSourcesManager dataSourcesManager, ObserveDataSourceConfiguration sourceConfiguration, boolean loadSchema, Set<String> importDataIds) {
+        try (ObserveSwingDataSource importDataSource = dataSourcesManager.newDataSource(sourceConfiguration)) {
+            try {
+                importDataSource.open();
+                return importDataSource.extract(loadSchema,importDataIds);
+            } catch (IncompatibleDataSourceCreateConfigurationException
+                    | DataSourceCreateWithNoReferentialImportException
+                    | DatabaseNotFoundException
+                    | DatabaseConnexionNotAuthorizedException
+                    | BabModelVersionException e) {
+                throw new ObserveSwingTechnicalException("Could not create import data source", e);
             }
         }
-        return result;
     }
 
     public static ObserveSwingDataSource initDataSourceFromModel(StorageUIModel model) {
@@ -214,103 +237,6 @@ public class DataSourceHelper {
         return dataSource;
     }
 
-    public static DataSourceCreateConfigurationDto toImportReferentielSourceConfig(StorageUIModel model) {
-        DataSourceCreateConfigurationDto importReferenceConfig = new DataSourceCreateConfigurationDto();
-        // can create empty data base
-        importReferenceConfig.setCanCreateEmptyDatabase(true);
-        if (model.getChooseDb().doImportReferential()) {
-            String dbLabel = I18n.n("observe.ui.datasource.storage.label.reference.import.db");
-            switch (model.getChooseDb().getReferentielImportMode()) {
-                case IMPORT_EXTERNAL_DUMP:
-                    if (ObstunaAdminAction.CREATE.equals(model.getAdminAction())) {
-                        // import referential to temporary data source
-                        DataSourceCreateConfigurationDto createConfigurationDto = new DataSourceCreateConfigurationDto();
-                        File dumpFile = model.getCentralSourceModel().getDumpFile();
-                        createConfigurationDto.setImportDatabase(TopiaSqlScript.of(dumpFile.toURI()));
-                        try (ObserveSwingDataSource importDataSource = model.getDataSourcesManager().newTemporaryH2DataSource(dbLabel)) {
-                            try {
-                                importDataSource.create(createConfigurationDto);
-                            } catch (IncompatibleDataSourceCreateConfigurationException
-                                    | DataSourceCreateWithNoReferentialImportException
-                                    | DatabaseNotFoundException
-                                    | DatabaseConnexionNotAuthorizedException
-                                    | BabModelVersionException e) {
-                                throw new ObserveSwingTechnicalException("Could not create import data source", e);
-                            }
-                            importReferenceConfig.setImportReferentialDataSourceConfiguration(importDataSource.getConfiguration());
-                        }
-                    } else {
-                        File dumpFile = model.getDumpFile();
-                        importReferenceConfig.setImportDatabase(TopiaSqlScript.of(dumpFile.toURI()));
-                    }
-                    break;
-                case IMPORT_REMOTE_STORAGE:
-                    // import referentiel from a remote db
-                    ObserveDataSourceConfigurationTopiaPG pgConfig = toPGStorageConfig(model.getCentralSourceModel(), dbLabel);
-                    pgConfig.setCanMigrate(false);
-                    importReferenceConfig.setImportReferentialDataSourceConfiguration(pgConfig);
-                    break;
-                case IMPORT_SERVER_STORAGE:
-                    // import referentiel from a server db
-                    ObserveDataSourceConfigurationRest restConfig = toRestStorageConfig(model.getCentralSourceModel(), dbLabel);
-                    importReferenceConfig.setImportReferentialDataSourceConfiguration(restConfig);
-                    break;
-                default:
-                    throw new IllegalStateException("Can't come here");
-            }
-        }
-        return importReferenceConfig;
-    }
-
-    public static ObserveSwingDataSource toImportDataSourceConfig(StorageUIModel model) {
-
-        ObserveSwingDataSource importDataSource;
-
-        if (model.getChooseDb().doImportData()) {
-
-            String dbLabel = I18n.n("observe.ui.datasource.storage.label.data.import.db");
-
-            ObserveDataSourcesManager dataSourcesManager = model.getDataSourcesManager();
-            switch (model.getChooseDb().getDataImportMode()) {
-                case IMPORT_EXTERNAL_DUMP:
-                    DataSourceCreateConfigurationDto createConfigurationDto = new DataSourceCreateConfigurationDto();
-                    File dumpFile = ObstunaAdminAction.CREATE.equals(model.getAdminAction()) ? model.getDataSourceModel().getDumpFile() : model.getDumpFile();
-                    createConfigurationDto.setImportDatabase(TopiaSqlScript.of(dumpFile.toURI()));
-                    try (ObserveSwingDataSource importDataSource2 = dataSourcesManager.newTemporaryH2DataSource(dbLabel)) {
-                        importDataSource = importDataSource2;
-                        try {
-                            importDataSource2.create(createConfigurationDto);
-                        } catch (IncompatibleDataSourceCreateConfigurationException
-                                | DataSourceCreateWithNoReferentialImportException
-                                | DatabaseNotFoundException
-                                | DatabaseConnexionNotAuthorizedException
-                                | BabModelVersionException e) {
-                            throw new ObserveSwingTechnicalException("Could not create import data source", e);
-                        }
-                    }
-                    break;
-                case IMPORT_REMOTE_STORAGE: {
-                    // import referentiel from a remote db
-                    ObserveDataSourceConfigurationTopiaPG dataSourceConfig = toPGStorageConfig(model.getDataSourceModel(), dbLabel);
-                    dataSourceConfig.setCanMigrate(false);
-                    importDataSource = dataSourcesManager.newDataSource(dataSourceConfig);
-                }
-                break;
-                case IMPORT_SERVER_STORAGE: {
-                    // import referentiel from a server db
-                    ObserveDataSourceConfigurationRest dataSourceConfig = toRestStorageConfig(model.getDataSourceModel(), dbLabel);
-                    importDataSource = dataSourcesManager.newDataSource(dataSourceConfig);
-                }
-                break;
-                default:
-                    throw new IllegalStateException("Can't come here");
-            }
-        } else {
-            importDataSource = null;
-        }
-        return importDataSource;
-    }
-
     static ObserveDataSourceConfigurationTopiaH2 toH2StorageConfig(StorageUIModel model, String label) {
         ObserveDataSourceConfigurationTopiaH2 h2Config = model.getLocalConfig().getConfiguration();
         return ObserveDataSourceConfigurationTopiaH2.create(
@@ -326,7 +252,7 @@ public class DataSourceHelper {
         );
     }
 
-    static ObserveDataSourceConfigurationTopiaPG toPGStorageConfig(StorageUIModel model, String label) {
+    public static ObserveDataSourceConfigurationTopiaPG toPGStorageConfig(StorageUIModel model, String label) {
         ObserveDataSourceConfigurationTopiaPG pgConfig = model.getRemoteConfig().getConfiguration();
         return ObserveDataSourceConfigurationTopiaPG.create(
                 label,
@@ -341,7 +267,7 @@ public class DataSourceHelper {
         );
     }
 
-    static ObserveDataSourceConfigurationRest toRestStorageConfig(StorageUIModel model, String label) {
+    public static ObserveDataSourceConfigurationRest toRestStorageConfig(StorageUIModel model, String label) {
         ObserveDataSourceConfigurationRest restConfig = model.getServerConfig().getConfiguration();
         return ObserveDataSourceConfigurationRest.create(
                 label,


=====================================
client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/wizard/StorageBackupUILauncher.java
=====================================
@@ -42,6 +42,7 @@ import fr.ird.observe.navigation.tree.selection.SelectionTreeModel;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.nuiton.jaxx.runtime.JAXXContext;
+import org.nuiton.topia.persistence.script.TopiaSqlScript;
 
 import java.awt.Window;
 import java.io.File;
@@ -137,7 +138,8 @@ public class StorageBackupUILauncher extends StorageUILauncher {
         try (ObserveSwingDataSource targetSource = dataSourcesManager.newTemporaryH2DataSource("Backup-" + backupFile.getName())) {
 
             // create temporary source
-            targetSource.createFrom(incomingSource);
+            TopiaSqlScript referentialDump = incomingSource.extract(true, null);
+            targetSource.createFromDump(referentialDump);
             progressModel.increments();
 
             // insert selected data


=====================================
client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/wizard/StorageUIModel.java
=====================================
@@ -671,7 +671,9 @@ public class StorageUIModel extends WizardModel<StorageStep> implements WithClie
                     }
                     break;
                 case CONFIG_REFERENTIAL:
-
+                    if (chooseDb.getReferentielImportMode() == null) {
+                        return false;
+                    }
                     switch (chooseDb.getReferentielImportMode()) {
 
                         case EMPTY:
@@ -703,7 +705,9 @@ public class StorageUIModel extends WizardModel<StorageStep> implements WithClie
                     break;
 
                 case CONFIG_DATA:
-
+                    if (chooseDb.getDataImportMode() == null) {
+                        return false;
+                    }
                     switch (chooseDb.getDataImportMode()) {
 
                         case EMPTY:


=====================================
client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/wizard/launchers/CreateLauncher.java
=====================================
@@ -22,29 +22,37 @@ package fr.ird.observe.client.datasource.editor.api.wizard.launchers;
  * #L%
  */
 
+import fr.ird.observe.client.datasource.api.ObserveDataSourcesManager;
 import fr.ird.observe.client.datasource.api.ObserveSwingDataSource;
 import fr.ird.observe.client.datasource.editor.api.wizard.DataSourceHelper;
 import fr.ird.observe.client.datasource.editor.api.wizard.ObstunaAdminAction;
 import fr.ird.observe.client.datasource.editor.api.wizard.StorageUI;
 import fr.ird.observe.client.datasource.editor.api.wizard.StorageUIModel;
+import fr.ird.observe.client.util.ObserveSwingTechnicalException;
 import fr.ird.observe.dto.db.BabModelVersionException;
 import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
 import fr.ird.observe.dto.db.DatabaseNotFoundException;
 import fr.ird.observe.dto.db.configuration.DataSourceConnectMode;
-import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
+import fr.ird.observe.dto.db.configuration.DataSourceCreateMode;
 import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
 import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
 import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
 import fr.ird.observe.dto.db.configuration.ObserveDataSourceInformation;
-import fr.ird.observe.navigation.tree.selection.SelectionTreeModel;
+import fr.ird.observe.dto.db.configuration.rest.ObserveDataSourceConfigurationRest;
+import fr.ird.observe.dto.db.configuration.topia.ObserveDataSourceConfigurationTopiaPG;
+import io.ultreia.java4all.i18n.I18n;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.nuiton.jaxx.runtime.JAXXContext;
+import org.nuiton.topia.persistence.script.TopiaSqlScript;
 
 import java.awt.Window;
+import java.io.File;
 import java.util.Objects;
 import java.util.Set;
 
+import static fr.ird.observe.client.datasource.editor.api.wizard.DataSourceHelper.toPGStorageConfig;
+
 /**
  * Created on 14/09/2021.
  *
@@ -53,7 +61,53 @@ import java.util.Set;
  */
 public class CreateLauncher extends RemoteUILauncher {
     private static final Logger log = LogManager.getLogger(CreateLauncher.class);
-    DataSourceCreateConfigurationDto createConfigurationDto;
+    private TopiaSqlScript referential;
+    private TopiaSqlScript data;
+
+    public static ObserveSwingDataSource toImportDataSourceConfig(StorageUIModel model) {
+
+        if (!model.getChooseDb().doImportData()) {
+            throw new IllegalStateException(String.format("Must be in select data mode to come here: %s", model));
+        }
+
+        String dbLabel = I18n.n("observe.ui.datasource.storage.label.data.import.db");
+        ObserveSwingDataSource importDataSource;
+
+        ObserveDataSourcesManager dataSourcesManager = model.getDataSourcesManager();
+        switch (model.getChooseDb().getDataImportMode()) {
+            case IMPORT_EXTERNAL_DUMP:
+                File dumpFile = model.getDataSourceModel().getDumpFile();
+                try (ObserveSwingDataSource importDataSource2 = dataSourcesManager.newTemporaryH2DataSource(dbLabel)) {
+                    importDataSource = importDataSource2;
+                    try {
+                        importDataSource2.createFromDump(TopiaSqlScript.of(dumpFile.toURI()));
+                    } catch (IncompatibleDataSourceCreateConfigurationException
+                            | DataSourceCreateWithNoReferentialImportException
+                            | DatabaseNotFoundException
+                            | DatabaseConnexionNotAuthorizedException
+                            | BabModelVersionException e) {
+                        throw new ObserveSwingTechnicalException("Could not create import data source", e);
+                    }
+                }
+                break;
+            case IMPORT_REMOTE_STORAGE: {
+                // import referentiel from a remote db
+                ObserveDataSourceConfigurationTopiaPG dataSourceConfig = DataSourceHelper.toPGStorageConfig(model.getDataSourceModel(), dbLabel);
+                dataSourceConfig.setCanMigrate(false);
+                importDataSource = dataSourcesManager.newDataSource(dataSourceConfig);
+            }
+            break;
+            case IMPORT_SERVER_STORAGE: {
+                // import referentiel from a server db
+                ObserveDataSourceConfigurationRest dataSourceConfig = DataSourceHelper.toRestStorageConfig(model.getDataSourceModel(), dbLabel);
+                importDataSource = dataSourcesManager.newDataSource(dataSourceConfig);
+            }
+            break;
+            default:
+                throw new IllegalStateException("Can't come here");
+        }
+        return importDataSource;
+    }
 
     public CreateLauncher(JAXXContext context, Window frame, DataSourceConnectMode connectMode) {
         super(ObstunaAdminAction.CREATE, context, frame, connectMode);
@@ -67,27 +121,112 @@ public class CreateLauncher extends RemoteUILauncher {
         //FIXME This logic should be done in StorageModel not here, like this!
         model.getChooseDb().setCanMigrate(true);
         model.getRemoteConfig().setCanCreateDatabase(true);
+        model.getServerConfig().setCanCreateDatabase(true);
         super.init(ui);
     }
 
     @Override
-    protected ObserveSwingDataSource initTask(StorageUIModel model) throws Exception {
+    protected ObserveSwingDataSource initTask(StorageUIModel model) {
         ObserveSwingDataSource dataSource = getDataSource(model);
-        createConfigurationDto = DataSourceHelper.toImportReferentielSourceConfig(model);
-        ObserveDataSourceConfiguration importReferentialConfig = createConfigurationDto.getImportReferentialDataSourceConfiguration();
-        if (importReferentialConfig != null) {
-            log.info(String.format("Use referentiel import data source %s", importReferentialConfig.getLabel()));
-            checkImportDbVersion(model, importReferentialConfig);
+        // can create empty data base
+        boolean importReferential = model.getChooseDb().doImportReferential();
+        boolean importData = model.getChooseDb().doImportData();
+        if (!importReferential && !importData) {
+            // no import at all
+            log.info("Create empty database.");
+            return dataSource;
         }
-        // data import
-        ObserveSwingDataSource importDataConfig = DataSourceHelper.toImportDataSourceConfig(model);
-        if (importDataConfig != null) {
-            log.info(String.format("Use data import data source %s", importDataConfig.getLabel()));
-            checkImportDbVersion(model, importDataConfig.getConfiguration());
-            SelectionTreeModel dataModel = model.getSelectDataModel();
-            Set<String> importDataIds = dataModel.getSelectedDataIds();
-            createConfigurationDto.setImportDataConfiguration(importDataConfig.getConfiguration(), importDataIds);
+
+        DataSourceCreateMode referentialImportMode = model.getChooseDb().getReferentielImportMode();
+        DataSourceCreateMode dataImportMode = model.getChooseDb().getDataImportMode();
+
+        File referentialDump = null;
+        ObserveDataSourceConfiguration referentialConfig = null;
+        File dataDump = null;
+        ObserveDataSourceConfiguration dataConfig = null;
+        Set<String> selectedDataIds = null;
+        if (importReferential && referentialImportMode != null) {
+            switch (referentialImportMode) {
+                case IMPORT_EXTERNAL_DUMP:
+                    referentialDump = model.getCentralSourceModel().getDumpFile();
+
+                    break;
+                case IMPORT_REMOTE_STORAGE:
+                    ObserveDataSourceConfigurationTopiaPG pgConfig = toPGStorageConfig(model.getCentralSourceModel(), DataSourceHelper.referentialDbLabel);
+                    pgConfig.setCanMigrate(false);
+                    referentialConfig = pgConfig;
+                    break;
+                case IMPORT_SERVER_STORAGE:
+                    referentialConfig = DataSourceHelper.toRestStorageConfig(model.getCentralSourceModel(), DataSourceHelper.referentialDbLabel);
+                    break;
+                default:
+                    throw new IllegalStateException("Can't come here");
+            }
         }
+        if (importData && dataImportMode != null) {
+            String dbLabel = I18n.n("observe.ui.datasource.storage.label.data.import.db");
+            selectedDataIds = model.getSelectDataModel().getSelectedDataIds();
+            switch (dataImportMode) {
+                case IMPORT_EXTERNAL_DUMP:
+                    dataDump = model.getDataSourceModel().getDumpFile();
+                    break;
+                case IMPORT_REMOTE_STORAGE: {
+                    ObserveDataSourceConfigurationTopiaPG dataSourceConfig = toPGStorageConfig(model.getDataSourceModel(), dbLabel);
+                    dataSourceConfig.setCanMigrate(false);
+                    dataConfig = dataSourceConfig;
+                }
+                break;
+                case IMPORT_SERVER_STORAGE: {
+                    dataConfig = DataSourceHelper.toRestStorageConfig(model.getDataSourceModel(), dbLabel);
+                    break;
+                }
+                default:
+                    throw new IllegalStateException("Can't come here");
+            }
+        }
+
+        if (referentialDump != null) {
+            if (dataDump != null) {
+                if (referentialDump.equals(dataDump)) {
+
+                    log.info(String.format("Extract referential + data from dump %s", referentialDump));
+                    referential = DataSourceHelper.extract(model.getDataSourcesManager(), referentialDump, true, selectedDataIds);
+                } else {
+                    log.info(String.format("Extract referential from dump %s", referentialDump));
+                    referential = DataSourceHelper.extract(model.getDataSourcesManager(), referentialDump, true, null);
+                    log.info(String.format("Extract data from dump %s %s", dataDump, selectedDataIds));
+                    data = DataSourceHelper.extract(model.getDataSourcesManager(), dataDump, false, selectedDataIds);
+                }
+            } else {
+                log.info(String.format("Extract referential from dump %s", referentialDump));
+                referential = DataSourceHelper.extract(model.getDataSourcesManager(), referentialDump, true, null);
+                if (dataConfig != null) {
+                    log.info(String.format("Extract data from config %s %s", dataConfig.getLabel(), selectedDataIds));
+                    data = DataSourceHelper.extract(model.getDataSourcesManager(), dataConfig, false, selectedDataIds);
+                }
+            }
+        } else {
+            Objects.requireNonNull(referentialConfig);
+            if (dataConfig != null) {
+                if (referentialConfig.equals(dataConfig)) {
+                    log.info(String.format("Extract referential + data from config %s %s", referentialConfig.getLabel(), selectedDataIds));
+                    referential = DataSourceHelper.extract(model.getDataSourcesManager(), referentialConfig, true, selectedDataIds);
+                } else {
+                    log.info(String.format("Extract referential from config %s", referentialConfig.getLabel()));
+                    referential = DataSourceHelper.extract(model.getDataSourcesManager(), referentialConfig, true, null);
+                    log.info(String.format("Extract data from config %s %s", dataConfig.getLabel(), selectedDataIds));
+                    data = DataSourceHelper.extract(model.getDataSourcesManager(), dataConfig, false, selectedDataIds);
+                }
+            } else {
+                log.info(String.format("Extract referential from config %s", referentialConfig.getLabel()));
+                referential = DataSourceHelper.extract(model.getDataSourcesManager(), referentialConfig, true, null);
+                if (dataDump != null) {
+                    log.info(String.format("Extract data from dump %s %s", dataDump, selectedDataIds));
+                    data = DataSourceHelper.extract(model.getDataSourcesManager(), dataDump, false, selectedDataIds);
+                }
+            }
+        }
+        Objects.requireNonNull(referential);
         return dataSource;
     }
 
@@ -95,21 +234,15 @@ public class CreateLauncher extends RemoteUILauncher {
     protected void execute(ObserveSwingDataSource dataSource, ObserveDataSourceInformation dataSourceInformation) throws Exception {
         log.info("Create db...");
         try {
-            dataSource.create(createConfigurationDto);
+            if (referential != null) {
+                dataSource.createFromImport(referential, data);
+            } else {
+                dataSource.createEmpty();
+            }
             log.info(String.format("Open [%s] and create it.", dataSource.getLabel()));
         } finally {
-            if (dataSource.isOpen()) {
-                dataSource.close();
-            }
-        }
-    }
-
-    void checkImportDbVersion(StorageUIModel model, ObserveDataSourceConfiguration dataSourceConfig) throws DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException, BabModelVersionException, IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException {
-        try (ObserveSwingDataSource importDataSource = Objects.requireNonNull(model.getDataSourcesManager().newDataSource(dataSourceConfig))) {
-            importDataSource.open();
-            model.checkImportDbVersion(importDataSource);
+            ObserveSwingDataSource.doCloseSource(dataSource);
         }
     }
-
 }
 


=====================================
client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/wizard/tabs/ConfigDataUI.jaxx
=====================================
@@ -35,8 +35,8 @@
   <StorageStep id='step' initializer='StorageStep.CONFIG_DATA'/>
 
   <StorageUIModel id='model'/>
-  <StorageUIModel id='centralSourceModel' initializer='model.getDataSourceModel()'/>
   <ChooseDbModel id='chooseDbModel' initializer='model.getChooseDb()'/>
+  <StorageUIModel id='centralSourceModel' initializer='model.getDataSourceModel()'/>
 
   <ButtonGroup id='dataSourceCreateMode' onStateChanged='chooseDbModel.setDataImportMode((DataSourceCreateMode) dataSourceCreateMode.getSelectedValue())'/>
 


=====================================
client/datasource/editor/api/src/main/java/fr/ird/observe/client/datasource/editor/api/wizard/tabs/SelectDataUIHandler.java
=====================================
@@ -29,9 +29,9 @@ import fr.ird.observe.client.datasource.editor.api.config.TreeConfigUIHandler;
 import fr.ird.observe.client.datasource.editor.api.selection.SelectionTreePane;
 import fr.ird.observe.client.datasource.editor.api.selection.SelectionTreePaneHandler;
 import fr.ird.observe.client.datasource.editor.api.selection.actions.SelectUnselect;
-import fr.ird.observe.client.datasource.editor.api.wizard.DataSourceHelper;
 import fr.ird.observe.client.datasource.editor.api.wizard.ObstunaAdminAction;
 import fr.ird.observe.client.datasource.editor.api.wizard.StorageUIModel;
+import fr.ird.observe.client.datasource.editor.api.wizard.launchers.CreateLauncher;
 import fr.ird.observe.client.util.ObserveKeyStrokesSupport;
 import fr.ird.observe.client.util.ObserveSwingTechnicalException;
 import fr.ird.observe.navigation.id.Project;
@@ -75,7 +75,7 @@ public class SelectDataUIHandler extends StorageTabUIHandler<SelectDataUI> imple
             }
             if (createDataSource) {
                 // create temporary data source
-                try (ObserveSwingDataSource dataSource = DataSourceHelper.toImportDataSourceConfig(model)) {
+                try (ObserveSwingDataSource dataSource = CreateLauncher.toImportDataSourceConfig(model)) {
                     SelectionTreePaneHandler.initDataSource(treePane, dataSource);
                     dataSource.open();
                     if (init) {


=====================================
client/runner/src/test/java/fr/ird/observe/client/ClientTestClassResource.java
=====================================
@@ -28,7 +28,6 @@ import fr.ird.observe.client.datasource.api.ObserveSwingDataSource;
 import fr.ird.observe.dto.db.BabModelVersionException;
 import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
 import fr.ird.observe.dto.db.DatabaseNotFoundException;
-import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
 import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
 import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
 import fr.ird.observe.dto.db.configuration.topia.ObserveDataSourceConfigurationTopiaH2;
@@ -90,11 +89,9 @@ public class ClientTestClassResource extends TestClassResourceSupport {
         boolean sharedDatabaseExist = sharedDatabaseFile.exists();
         if (!sharedDatabaseExist) {
             log.info(String.format("Create shared database: %s/%s to %s", dbVersion.toString(), dbName, sharedDatabaseFile));
-            DataSourceCreateConfigurationDto createConfiguration = new DataSourceCreateConfigurationDto();
             TopiaSqlScript script = dataSourcesForTestManager.getCache(dbVersion, dbName);
-            createConfiguration.setImportDatabase(script);
             observeSwingDataSource = ClientUIContextApplicationComponent.value().getDataSourcesManager().newDataSource(sharedDatabaseConfiguration);
-            observeSwingDataSource.create(createConfiguration);
+            observeSwingDataSource.createFromDump(script);
         }
         if (targetPath == null) {
             dataSourceConfiguration = sharedDatabaseConfiguration;


=====================================
core/persistence/java/src/main/java/fr/ird/observe/entities/DataSourceCreateHelper.java
=====================================
@@ -0,0 +1,103 @@
+package fr.ird.observe.entities;
+
+/*-
+ * #%L
+ * ObServe Core :: Persistence :: Java
+ * %%
+ * Copyright (C) 2008 - 2022 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 fr.ird.observe.dto.db.BabModelVersionException;
+import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
+import fr.ird.observe.dto.db.DatabaseNotFoundException;
+import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
+import fr.ird.observe.dto.db.configuration.topia.ObserveDataSourceConfigurationTopiaH2;
+import io.ultreia.java4all.util.Version;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.nuiton.topia.persistence.script.TopiaSqlScript;
+import org.nuiton.topia.service.migration.TopiaMigrationService;
+import org.nuiton.topia.service.sql.request.CreateDatabaseRequest;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+/**
+ * Created on 16/03/2022.
+ *
+ * @author Tony Chemit - dev@tchemit.fr
+ * @since 6.0.7
+ */
+public class DataSourceCreateHelper {
+
+    private static final Logger log = LogManager.getLogger(DataSourceCreateHelper.class);
+
+    public static void create(ToolkitTopiaApplicationContextSupport<?> applicationContext) throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
+        log.debug(String.format("Create topia application context: %s", applicationContext));
+        // si le referentiel n'est pas importé on aliment la table lastUpdateDate
+        //FIXME Make sure this is ok, but not sure
+        applicationContext.insertLastUpdateDate();
+    }
+
+    public static void create(ToolkitTopiaApplicationContextSupport<?> applicationContext, ObserveDataSourceConfiguration dataSourceConfiguration, TopiaSqlScript importDatabase) throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
+        log.debug(String.format("Create topia application context: %s", applicationContext));
+        Path temporaryDirectory = dataSourceConfiguration.getTemporaryDirectory();
+        log.info("Create new database from a script.");
+        TopiaMigrationService migrationService = (TopiaMigrationService) applicationContext.getMigrationService();
+        if (dataSourceConfiguration.isLocal()) {
+            applicationContext.executeSqlStatements(importDatabase);
+            migrationService.createSchemaIfNotExist();
+            migrationService.runSchemaMigration();
+        } else {
+            // base postgres
+            // do import in temporary h2 database
+            File tmpDir;
+            try {
+                tmpDir = Files.createTempDirectory(temporaryDirectory, "obstuna").toFile();
+            } catch (IOException e) {
+                throw new IllegalStateException("could not create temporary directory ", e);
+            }
+            Version modelVersion = dataSourceConfiguration.getModelVersion();
+            ObserveDataSourceConfigurationTopiaH2 temporaryConfiguration = applicationContext.createTemporaryConfiguration(tmpDir, modelVersion);
+            ObserveTopiaApplicationContext temporaryTopiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(temporaryConfiguration, false);
+            temporaryTopiaApplicationContext.executeSqlStatements(importDatabase);
+            temporaryTopiaApplicationContext.getMigrationService().createSchemaIfNotExist();
+            temporaryTopiaApplicationContext.getMigrationService().runSchemaMigration();
+            CreateDatabaseRequest request = CreateDatabaseRequest.builder(true, modelVersion).addSchema().addStandaloneTables().addAllData().build();
+            TopiaSqlScript dump = applicationContext.getSqlService().consume(request);
+            applicationContext.executeSqlStatements(dump);
+            migrationService.createSchemaIfNotExist();
+            migrationService.runSchemaMigration();
+            temporaryTopiaApplicationContext.close();
+            File databaseFile = temporaryConfiguration.getDatabaseFile();
+            if (!databaseFile.delete()) {
+                throw new IllegalStateException("could not delete " + databaseFile);
+            }
+        }
+    }
+
+    public static void create(ToolkitTopiaApplicationContextSupport<?> applicationContext, TopiaSqlScript dump, TopiaSqlScript optionalDump) throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
+        log.debug(String.format("Create topia application context: %s", applicationContext));
+        applicationContext.executeSqlStatements(dump);
+        if (optionalDump != null) {
+            applicationContext.executeSqlStatements(optionalDump);
+        }
+    }
+}


=====================================
core/persistence/java/src/main/java/fr/ird/observe/entities/ObserveTopiaApplicationContext.java
=====================================
@@ -22,14 +22,10 @@ package fr.ird.observe.entities;
  * #L%
  */
 
-import com.google.common.collect.ArrayListMultimap;
-import com.google.common.collect.Multimap;
 import fr.ird.observe.dto.db.BabModelVersionException;
 import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
 import fr.ird.observe.dto.db.DatabaseNotFoundException;
-import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
 import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
-import fr.ird.observe.dto.db.configuration.topia.ObserveDataSourceConfigurationTopiaH2;
 import fr.ird.observe.dto.referential.ReferentialDto;
 import fr.ird.observe.entities.data.DataGroupByEntity;
 import fr.ird.observe.spi.module.BusinessProject;
@@ -37,16 +33,11 @@ import fr.ird.observe.spi.referential.differential.DifferentialMetaModel;
 import fr.ird.observe.spi.referential.synchro.OneSideSqlResultBuilder;
 import fr.ird.observe.spi.script.ToolkitEntitySqlScriptModel;
 import fr.ird.observe.spi.service.ServiceContext;
-import io.ultreia.java4all.util.Version;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.nuiton.topia.persistence.TagValues;
 import org.nuiton.topia.persistence.TopiaConfigurationExtension;
 import org.nuiton.topia.persistence.TopiaEntity;
-import org.nuiton.topia.persistence.TopiaIdFactory;
 import org.nuiton.topia.persistence.TopiaPersistenceContextConstructorParameterSupport;
 import org.nuiton.topia.persistence.script.TopiaSqlScript;
-import org.nuiton.topia.service.migration.TopiaMigrationService;
 import org.nuiton.topia.service.sql.blob.TopiaEntitySqlBlobModel;
 import org.nuiton.topia.service.sql.metadata.TopiaMetadataModel;
 import org.nuiton.topia.service.sql.metadata.TopiaMetadataModelPaths;
@@ -54,25 +45,15 @@ import org.nuiton.topia.service.sql.model.TopiaEntitySqlModel;
 import org.nuiton.topia.service.sql.plan.copy.TopiaEntitySqlCopyPlanModel;
 import org.nuiton.topia.service.sql.plan.delete.TopiaEntitySqlDeletePlanModel;
 import org.nuiton.topia.service.sql.plan.replicate.TopiaEntitySqlReplicatePlanModel;
-import org.nuiton.topia.service.sql.request.CreateDatabaseRequest;
 import org.nuiton.topia.service.sql.usage.TopiaEntitySqlUsageModel;
 
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
 import java.time.Duration;
-import java.util.Collection;
 import java.util.Date;
-import java.util.Map;
 import java.util.Set;
-import java.util.UUID;
 import java.util.function.Consumer;
 
 public class ObserveTopiaApplicationContext extends AbstractObserveTopiaApplicationContext {
 
-    private static final Logger log = LogManager.getLogger(ObserveTopiaApplicationContext.class);
-
     public ObserveTopiaApplicationContext(TopiaConfigurationExtension topiaConfiguration) {
         super(topiaConfiguration);
     }
@@ -187,131 +168,15 @@ public class ObserveTopiaApplicationContext extends AbstractObserveTopiaApplicat
         return ObserveTopiaEntitySqlModelResource.get().getScriptModel();
     }
 
-    public void create(ObserveDataSourceConfiguration dataSourceConfiguration, DataSourceCreateConfigurationDto dataSourceCreateConfiguration) throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
-        log.debug(String.format("Create topia application context: %s", this));
-        if (dataSourceCreateConfiguration.isImportDatabase()) {
-            log.info("Create new database from a script.");
-            TopiaSqlScript importDatabase = dataSourceCreateConfiguration.getImportDatabase();
-            boolean migrate = dataSourceCreateConfiguration.isMigrate();
-            TopiaMigrationService migrationService = getMigrationService();
-            if (dataSourceConfiguration.isLocal()) {
-                executeSqlStatements(importDatabase);
-                if (migrate) {
-                    migrationService.createSchemaIfNotExist();
-                    migrationService.runSchemaMigration();
-                }
-            } else { // base postgres
-                // do import in temporary h2 database
-                File tmpDir;
-                try {
-                    Path temporaryDirectory = dataSourceConfiguration.getTemporaryDirectory();
-                    tmpDir = Files.createTempDirectory(temporaryDirectory, "obstuna").toFile();
-                } catch (IOException e) {
-                    throw new IllegalStateException("could not create temporary directory ", e);
-                }
-                ObserveDataSourceConfigurationTopiaH2 temporaryConfiguration = createTemporaryConfiguration(tmpDir, dataSourceConfiguration.getModelVersion());
-                ObserveTopiaApplicationContext temporaryTopiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(temporaryConfiguration, false);
-                temporaryTopiaApplicationContext.executeSqlStatements(importDatabase);
-                if (migrate) {
-                    temporaryTopiaApplicationContext.getMigrationService().createSchemaIfNotExist();
-                    temporaryTopiaApplicationContext.getMigrationService().runSchemaMigration();
-                }
-                CreateDatabaseRequest request = CreateDatabaseRequest.builder(true, dataSourceConfiguration.getModelVersion()).addSchema().addStandaloneTables().addAllData().build();
-                TopiaSqlScript dump = getSqlService().consume(request);
-                executeSqlStatements(dump);
-                migrationService.createSchemaIfNotExist();
-                migrationService.runSchemaMigration();
-                temporaryTopiaApplicationContext.close();
-                File databaseFile = temporaryConfiguration.getDatabaseFile();
-                if (!databaseFile.delete()) {
-                    throw new IllegalStateException("could not delete " + databaseFile);
-                }
-            }
-        } else {
-            boolean importReferential = dataSourceCreateConfiguration.isImportReferential();
-            boolean importData = dataSourceCreateConfiguration.isImportData();
-            // si le referentiel n'est pas importé on aliment la table lastUpdateDate
-            if (!importReferential) {
-                insertLastUpdateDate();
-            }
-            boolean importStandaloneReferential = importReferential;
-            if (importReferential && importData) {
-                // Si on est sur la même source de données pour les deux imports, on fait tout sur la même base temporaire
-                ObserveDataSourceConfiguration importReferentialDataSourceConfiguration = dataSourceCreateConfiguration.getImportReferentialDataSourceConfiguration();
-                ObserveDataSourceConfiguration importDataSourceConfiguration = dataSourceCreateConfiguration.getImportDataDataSourceConfiguration();
-                importStandaloneReferential = !importReferentialDataSourceConfiguration.equals(importDataSourceConfiguration);
-            }
-            boolean referentialImported = false;
-            if (importStandaloneReferential) {
-                log.info("Import referential.");
-                ObserveDataSourceConfiguration importDataSourceConfiguration = dataSourceCreateConfiguration.getImportReferentialDataSourceConfiguration();
-                Version dbVersion = Version.valueOf(getModelVersion());
-                CreateDatabaseRequest request = CreateDatabaseRequest.builder(!dataSourceConfiguration.isLocal(), dbVersion)
-                        .addStandaloneTables().build();
-                TopiaSqlScript referentialDump;
-                ObserveTopiaApplicationContext temporaryTopiaApplicationContext = null;
-                try {
-                    temporaryTopiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(importDataSourceConfiguration, false);
-//                    ObserveDataSourceConnection importDataSourceConnection = serviceContext().newService(importDataSourceConfiguration, AnonymousService.class).open(importDataSourceConfiguration);
-//                    DataSourceService dumpProducerService = serviceContext().newService(importDataSourceConnection, DataSourceService.class);
-                    referentialDump = temporaryTopiaApplicationContext.getSqlService().consume(request);
-                    executeSqlStatements(referentialDump);
-                } finally {
-                    if (!dataSourceCreateConfiguration.isLeaveOpenSource() && temporaryTopiaApplicationContext != null) {
-                        temporaryTopiaApplicationContext.close();
-                    }
-                }
-                referentialImported = true;
-            }
-
-            if (importData) {
-                ObserveDataSourceConfiguration importDataSourceConfiguration = dataSourceCreateConfiguration.getImportDataDataSourceConfiguration();
-                Version dbVersion = Version.valueOf(getModelVersion());
-                CreateDatabaseRequest.Builder requestBuilder = CreateDatabaseRequest.builder(!dataSourceConfiguration.isLocal(), dbVersion);
-                if (!referentialImported) {
-                    log.info("Get referential.");
-                    requestBuilder.addStandaloneTables();
-                }
-
-                // Récupération du dump qui contient les données
-                Set<String> importDataIds = dataSourceCreateConfiguration.getImportDataIds();
-                TopiaIdFactory idFactory = getTopiaIdFactory();
-                Multimap<String, String> idsByType = ArrayListMultimap.create();
-                for (String importDataId : importDataIds) {
-                    Class<TopiaEntity> className = idFactory.getClassName(importDataId);
-                    idsByType.put(className.getName(), importDataId);
-                }
-                log.info(String.format("Get data: %s", importDataIds));
-                for (Map.Entry<String, Collection<String>> entry : idsByType.asMap().entrySet()) {
-                    requestBuilder.dataIdsToAdd(entry.getKey(), Set.copyOf(entry.getValue()));
-                }
-                TopiaSqlScript dataDump;
-                ObserveTopiaApplicationContext temporaryTopiaApplicationContext = null;
-                CreateDatabaseRequest request = requestBuilder.build();
-                try {
-                    temporaryTopiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(importDataSourceConfiguration, false);
-//                    ObserveDataSourceConnection importDataSourceConnection = serviceContext().newService(importDataSourceConfiguration, AnonymousService.class).open(importDataSourceConfiguration);
-//                    DataSourceService dumpProducerService = serviceContext().newService(importDataSourceConnection, DataSourceService.class);
-//                    dataDump = dumpProducerService.produceCreateSqlScript(request);
-                    dataDump = temporaryTopiaApplicationContext.getSqlService().consume(request);
-                } finally {
-                    if (!dataSourceCreateConfiguration.isLeaveOpenSource() && temporaryTopiaApplicationContext != null) {
-                        temporaryTopiaApplicationContext.close();
-//                        serviceContext().newService(importDataSourceConfiguration, DataSourceService.class).close();
-                    }
-                }
-                log.info(String.format("Import data%s", request.isAddStandaloneTables() ? " and referential." : "."));
-                executeSqlStatements(dataDump);
-            }
-        }
+    public void createEmpty() throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
+        DataSourceCreateHelper.create(this);
     }
 
-    private ObserveDataSourceConfigurationTopiaH2 createTemporaryConfiguration(File tmpDirectory, Version version) {
-        File dbDirectory = new File(tmpDirectory, "obstuna" + UUID.randomUUID());
-        ObserveDataSourceConfigurationTopiaH2 result = ObserveDataSourceConfigurationTopiaH2.create(
-                "obtunaTmp", dbDirectory, "obstuna", "sa", "sa".toCharArray(), true, true, version);
-        result.setTemporaryDirectory(tmpDirectory.toPath());
-        return result;
+    public void createFromDump(ObserveDataSourceConfiguration dataSourceConfiguration, TopiaSqlScript dump) throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
+        DataSourceCreateHelper.create(this, dataSourceConfiguration, dump);
     }
 
+    public void createAndImport(TopiaSqlScript dump, TopiaSqlScript optionalDump) throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
+        DataSourceCreateHelper.create(this, dump, optionalDump);
+    }
 }


=====================================
core/services/client/src/main/java/fr/ird/observe/services/client/AnonymousServiceClient.java
=====================================
@@ -25,30 +25,50 @@ package fr.ird.observe.services.client;
 import fr.ird.observe.dto.db.BabModelVersionException;
 import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
 import fr.ird.observe.dto.db.DatabaseNotFoundException;
-import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
 import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
 import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
 import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
 import fr.ird.observe.dto.db.configuration.ObserveDataSourceConnection;
 import fr.ird.observe.services.ObserveServiceInitializer;
+import org.nuiton.topia.persistence.script.TopiaSqlScript;
 
 public class AnonymousServiceClient extends GeneratedAnonymousServiceClient {
 
     @Override
-    public ObserveDataSourceConnection create(ObserveDataSourceConfiguration config, DataSourceCreateConfigurationDto createConfiguration) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
-        ObserveServiceInitializer initializer = getServiceContext().getInitializer();
-        initializer.setConfiguration(config);
-        ObserveDataSourceConnection dataSourceConnection = super.create(config, createConfiguration);
-        initializer.setConnection(dataSourceConnection);
-        initializer.setConfiguration(null);
-        return dataSourceConnection;
+    public ObserveDataSourceConnection createEmpty(ObserveDataSourceConfiguration config) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
+        ObserveServiceInitializer initializer = start(config);
+        ObserveDataSourceConnection dataSourceConnection = super.createEmpty(config);
+        return end(initializer, dataSourceConnection);
+    }
+
+    @Override
+    public ObserveDataSourceConnection createFromDump(ObserveDataSourceConfiguration config, TopiaSqlScript dump) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
+        ObserveServiceInitializer initializer = start(config);
+        ObserveDataSourceConnection dataSourceConnection = super.createFromDump(config, dump);
+        return end(initializer, dataSourceConnection);
+    }
+
+    @Override
+    public ObserveDataSourceConnection createFromImport(ObserveDataSourceConfiguration config, TopiaSqlScript dump, TopiaSqlScript optionalDump) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
+        ObserveServiceInitializer initializer = start(config);
+        ObserveDataSourceConnection dataSourceConnection = super.createFromImport(config, dump, optionalDump);
+        return end(initializer, dataSourceConnection);
     }
 
     @Override
     public ObserveDataSourceConnection open(ObserveDataSourceConfiguration config) throws DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {
+        ObserveServiceInitializer initializer = start(config);
+        ObserveDataSourceConnection dataSourceConnection = super.open(config);
+        return end(initializer, dataSourceConnection);
+    }
+
+    private ObserveServiceInitializer start(ObserveDataSourceConfiguration config) {
         ObserveServiceInitializer initializer = getServiceContext().getInitializer();
         initializer.setConfiguration(config);
-        ObserveDataSourceConnection dataSourceConnection = super.open(config);
+        return initializer;
+    }
+
+    private ObserveDataSourceConnection end(ObserveServiceInitializer initializer, ObserveDataSourceConnection dataSourceConnection) {
         initializer.setConnection(dataSourceConnection);
         initializer.setConfiguration(null);
         return dataSourceConnection;


=====================================
core/services/client/src/test/java/fr/ird/observe/services/client/service/AnonymousServiceClientReadTest.java
=====================================
@@ -25,7 +25,6 @@ package fr.ird.observe.services.client.service;
 import fr.ird.observe.dto.db.BabModelVersionException;
 import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
 import fr.ird.observe.dto.db.DatabaseNotFoundException;
-import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
 import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
 import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
 import fr.ird.observe.dto.db.configuration.ObserveDataSourceConnection;
@@ -80,11 +79,8 @@ public class AnonymousServiceClientReadTest extends GeneratedAnonymousServiceCli
 
         //FIXME Should get an not implemented exception for this service
         ObserveDataSourceConfigurationRest dataSourceConfiguration = serviceClientTestMethodResource.getDataSourceConfiguration();
-        DataSourceCreateConfigurationDto dataSourceCreateConfiguration = new DataSourceCreateConfigurationDto();
-        dataSourceCreateConfiguration.setCanCreateEmptyDatabase(true);
-
         AnonymousService service = serviceClientTestMethodResource.newService(dataSourceConfiguration, AnonymousService.class);
-        service.create(dataSourceConfiguration, dataSourceCreateConfiguration);
+        service.createEmpty(dataSourceConfiguration);
 
     }
 


=====================================
core/services/local/src/main/java/fr/ird/observe/services/local/service/AnonymousServiceLocalSupport.java
=====================================
@@ -28,7 +28,6 @@ import fr.ird.observe.dto.db.DataSourceUserDto;
 import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
 import fr.ird.observe.dto.db.DatabaseNotFoundException;
 import fr.ird.observe.dto.db.DatabaseVersionIsTooHighException;
-import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
 import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
 import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
 import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
@@ -45,6 +44,7 @@ import io.ultreia.java4all.util.Version;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.nuiton.topia.persistence.TopiaConfigurationExtension;
+import org.nuiton.topia.persistence.script.TopiaSqlScript;
 
 import java.nio.file.Path;
 import java.util.Set;
@@ -107,15 +107,39 @@ public class AnonymousServiceLocalSupport extends ObserveServiceLocal implements
     }
 
     @Override
-    public ObserveDataSourceConnection create(ObserveDataSourceConfiguration config, DataSourceCreateConfigurationDto createConfiguration)
-            throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException,
-            BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
-        createConfiguration.validateConfiguration(getApplicationLocale());
+    public ObserveDataSourceConnection createEmpty(ObserveDataSourceConfiguration config) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
         setTemporaryDirectory(config);
-        boolean initSchema = !createConfiguration.isImportDatabase();
-        ObserveTopiaApplicationContext topiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(config, initSchema);
+        ObserveTopiaApplicationContext topiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(config, true);
         try {
-            topiaApplicationContext.create(config, createConfiguration);
+            topiaApplicationContext.createEmpty();
+        } catch (Exception e) {
+            close(config, topiaApplicationContext);
+            throw e;
+        }
+        ObserveDataSourceInformation dataSourceInformation = getDataSourceInformation(config, topiaApplicationContext.getConfiguration(), false);
+        return config.toConnection(topiaApplicationContext.getAuthenticationToken(), dataSourceInformation);
+    }
+
+    @Override
+    public ObserveDataSourceConnection createFromDump(ObserveDataSourceConfiguration config, TopiaSqlScript dump) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
+        setTemporaryDirectory(config);
+        ObserveTopiaApplicationContext topiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(config, false);
+        try {
+            topiaApplicationContext.createFromDump(config, dump);
+        } catch (Exception e) {
+            close(config, topiaApplicationContext);
+            throw e;
+        }
+        ObserveDataSourceInformation dataSourceInformation = getDataSourceInformation(config, topiaApplicationContext.getConfiguration(), false);
+        return config.toConnection(topiaApplicationContext.getAuthenticationToken(), dataSourceInformation);
+    }
+
+    @Override
+    public ObserveDataSourceConnection createFromImport(ObserveDataSourceConfiguration config, TopiaSqlScript dump, TopiaSqlScript optionalDump) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
+        setTemporaryDirectory(config);
+        ObserveTopiaApplicationContext topiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(config, false);
+        try {
+            topiaApplicationContext.createAndImport(dump, optionalDump);
         } catch (Exception e) {
             close(config, topiaApplicationContext);
             throw e;
@@ -192,127 +216,6 @@ public class AnonymousServiceLocalSupport extends ObserveServiceLocal implements
         return dataSourceInformation;
     }
 
-//    private void create0(ObserveTopiaApplicationContext topiaApplicationContext, ObserveDataSourceConfiguration dataSourceConfiguration, DataSourceCreateConfigurationDto dataSourceCreateConfiguration) throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
-//        log.debug(String.format("Create topia application context: %s", topiaApplicationContext));
-//        if (dataSourceCreateConfiguration.isImportDatabase()) {
-//            log.info("Create new database from a script.");
-//            TopiaSqlScript importDatabase = dataSourceCreateConfiguration.getImportDatabase();
-//            boolean migrate = dataSourceCreateConfiguration.isMigrate();
-//            TopiaMigrationService migrationService = topiaApplicationContext.getMigrationService();
-//            if (dataSourceConfiguration.isLocal()) {
-//                topiaApplicationContext.executeSqlStatements(importDatabase);
-//                if (migrate) {
-//                    migrationService.createSchemaIfNotExist();
-//                    migrationService.runSchemaMigration();
-//                }
-//            } else { // base postgres
-//                // on realise les import dans un base H2 temporaire
-//                File tmpDir;
-//                try {
-//                    Path temporaryDirectory = dataSourceConfiguration.getTemporaryDirectory();
-//                    tmpDir = Files.createTempDirectory(temporaryDirectory, "obstuna").toFile();
-//                } catch (IOException e) {
-//                    throw new IllegalStateException("could not create temporary directory ", e);
-//                }
-//                ObserveDataSourceConfigurationTopiaH2 temporaryConfiguration = createTemporaryConfiguration(tmpDir, dataSourceConfiguration.getModelVersion());
-//                ObserveTopiaApplicationContext temporaryTopiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(temporaryConfiguration, false);
-//                temporaryTopiaApplicationContext.executeSqlStatements(importDatabase);
-//                if (migrate) {
-//                    temporaryTopiaApplicationContext.getMigrationService().createSchemaIfNotExist();
-//                    temporaryTopiaApplicationContext.getMigrationService().runSchemaMigration();
-//                }
-//                DataSourceService dumpProducerService = serviceContext().newService(temporaryConfiguration, DataSourceService.class);
-//                CreateDatabaseRequest request = CreateDatabaseRequest.of(true, dataSourceConfiguration.getModelVersion()).addSchema().addStandaloneTables().addAllData();
-//                TopiaSqlScript dump = dumpProducerService.produceCreateSqlScript(request);
-//                topiaApplicationContext.executeSqlStatements(dump);
-//                migrationService.createSchemaIfNotExist();
-//                migrationService.runSchemaMigration();
-//                temporaryTopiaApplicationContext.close();
-//                File databaseFile = temporaryConfiguration.getDatabaseFile();
-//                if (!databaseFile.delete()) {
-//                    throw new IllegalStateException("could not delete " + databaseFile);
-//                }
-//            }
-//        } else {
-//            boolean importReferential = dataSourceCreateConfiguration.isImportReferential();
-//            boolean importData = dataSourceCreateConfiguration.isImportData();
-//            // si le referentiel n'est pas importé on aliment la table lastUpdateDate
-//            if (!importReferential) {
-//                topiaApplicationContext.insertLastUpdateDate();
-//            }
-//            boolean importStandaloneReferential = importReferential;
-//            if (importReferential && importData) {
-//                // Si on est sur la même source de données pour les deux imports, on fait tout sur la même base temporaire
-//                ObserveDataSourceConfiguration importReferentialDataSourceConfiguration = dataSourceCreateConfiguration.getImportReferentialDataSourceConfiguration();
-//                ObserveDataSourceConfiguration importDataSourceConfiguration = dataSourceCreateConfiguration.getImportDataDataSourceConfiguration();
-//                importStandaloneReferential = !importReferentialDataSourceConfiguration.equals(importDataSourceConfiguration);
-//            }
-//            boolean referentialImported = false;
-//            if (importStandaloneReferential) {
-//                log.info("Import referential.");
-//                ObserveDataSourceConfiguration importDataSourceConfiguration = dataSourceCreateConfiguration.getImportReferentialDataSourceConfiguration();
-//                Version dbVersion = Version.valueOf(topiaApplicationContext.getModelVersion());
-//                CreateDatabaseRequest request = CreateDatabaseRequest.of(!dataSourceConfiguration.isLocal(), dbVersion)
-//                        .addStandaloneTables();
-//                TopiaSqlScript referentialDump;
-//                try {
-//                    ObserveDataSourceConnection importDataSourceConnection = serviceContext().newService(importDataSourceConfiguration, AnonymousService.class).open(importDataSourceConfiguration);
-//                    DataSourceService dumpProducerService = serviceContext().newService(importDataSourceConnection, DataSourceService.class);
-//                    referentialDump = dumpProducerService.produceCreateSqlScript(request);
-//                    topiaApplicationContext.executeSqlStatements(referentialDump);
-//                } finally {
-//                    if (!dataSourceCreateConfiguration.isLeaveOpenSource()) {
-//                        serviceContext().newService(importDataSourceConfiguration, DataSourceService.class).close();
-//                    }
-//                }
-//                referentialImported = true;
-//            }
-//
-//            if (importData) {
-//                ObserveDataSourceConfiguration importDataSourceConfiguration = dataSourceCreateConfiguration.getImportDataDataSourceConfiguration();
-//                Version dbVersion = Version.valueOf(topiaApplicationContext.getModelVersion());
-//                CreateDatabaseRequest request = CreateDatabaseRequest.of(!dataSourceConfiguration.isLocal(), dbVersion);
-//                if (!referentialImported) {
-//                    log.info("Get referential.");
-//                    request.addStandaloneTables();
-//                }
-//
-//                // Récupération du dump qui contient les données
-//                Set<String> importDataIds = dataSourceCreateConfiguration.getImportDataIds();
-//                TopiaIdFactory idFactory = getTopiaPersistenceContext().getIdFactory();
-//                Multimap<String, String> idsByType = ArrayListMultimap.create();
-//                for (String importDataId : importDataIds) {
-//                    Class<TopiaEntity> className = idFactory.getClassName(importDataId);
-//                    idsByType.put(className.getName(), importDataId);
-//                }
-//                log.info(String.format("Get data: %s", importDataIds));
-//                for (Map.Entry<String, Collection<String>> entry : idsByType.asMap().entrySet()) {
-//                    request.dataIdsToAdd(entry.getKey(), Set.copyOf(entry.getValue()));
-//                }
-//                TopiaSqlScript dataDump;
-//                try {
-//                    ObserveDataSourceConnection importDataSourceConnection = serviceContext().newService(importDataSourceConfiguration, AnonymousService.class).open(importDataSourceConfiguration);
-//                    DataSourceService dumpProducerService = serviceContext().newService(importDataSourceConnection, DataSourceService.class);
-//                    dataDump = dumpProducerService.produceCreateSqlScript(request);
-//                } finally {
-//                    if (!dataSourceCreateConfiguration.isLeaveOpenSource()) {
-//                        serviceContext().newService(importDataSourceConfiguration, DataSourceService.class).close();
-//                    }
-//                }
-//                log.info(String.format("Import data%s", request.isAddStandaloneTables() ? " and referential." : "."));
-//                topiaApplicationContext.executeSqlStatements(dataDump);
-//            }
-//        }
-//    }
-//
-//    private ObserveDataSourceConfigurationTopiaH2 createTemporaryConfiguration(File tmpDirectory, Version version) {
-//        File dbDirectory = new File(tmpDirectory, "obstuna" + UUID.randomUUID());
-//        ObserveDataSourceConfigurationTopiaH2 result = ObserveDataSourceConfigurationTopiaH2.create(
-//                "obtunaTmp", dbDirectory, "obstuna", "sa", "sa".toCharArray(), true, true, version);
-//        result.setTemporaryDirectory(tmpDirectory.toPath());
-//        return result;
-//    }
-
     private ObserveDataSourceInformation getDataSourceInformation(ObserveDataSourceConfiguration dataSourceConfiguration, TopiaConfigurationExtension topiaConfiguration, boolean canBeEmpty) throws DatabaseConnexionNotAuthorizedException {
         try {
             return SecurityHelper.getDataSourceInformation(SECURITY_HELPER_MODEL, dataSourceConfiguration, topiaConfiguration, canBeEmpty);


=====================================
core/services/local/src/test/java/fr/ird/observe/services/local/LocalTestClassResource.java
=====================================
@@ -26,7 +26,6 @@ import fr.ird.observe.dto.db.BabModelVersionException;
 import fr.ird.observe.dto.db.DataSourceValidationMode;
 import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
 import fr.ird.observe.dto.db.DatabaseNotFoundException;
-import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
 import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
 import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
 import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
@@ -66,6 +65,7 @@ public class LocalTestClassResource extends TestClassResourceSupport {
     private final ObserveServiceFactoryLocal serviceFactory;
 
     ObserveServiceInitializerConfig serviceInitializerConfig;
+    private boolean generateNow;
 
     public LocalTestClassResource() {
         this(DatabaseClassifier.DEFAULT);
@@ -105,11 +105,8 @@ public class LocalTestClassResource extends TestClassResourceSupport {
             AnonymousService service = newService(sharedDatabaseConfiguration, AnonymousService.class);
 
             try {
-                DataSourceCreateConfigurationDto createConfiguration = new DataSourceCreateConfigurationDto();
                 TopiaSqlScript script = getDataSourcesForTestManager().getCache(dbVersion, dbName);
-                createConfiguration.setImportDatabase(script);
-                createConfiguration.setMigrate(false);
-                service.create(sharedDatabaseConfiguration, createConfiguration);
+                service.createFromDump(sharedDatabaseConfiguration, script);
             } finally {
                 newService(sharedDatabaseConfiguration, DataSourceService.class).close();
             }
@@ -134,15 +131,13 @@ public class LocalTestClassResource extends TestClassResourceSupport {
         ObserveServiceInitializer serviceInitializer = new ObserveServiceInitializer(getServiceInitializerConfig(), dataSourceConfiguration, null) {
             @Override
             public Date now() {
-                return generateNow?new Date():ObserveFixtures.DATE;
+                return generateNow ? new Date() : ObserveFixtures.DATE;
             }
         };
         serviceInitializer.setConfiguration(dataSourceConfiguration);
         return serviceFactory.newService(serviceInitializer, serviceType);
     }
 
-    private boolean generateNow;
-
     public boolean isGenerateNow() {
         return generateNow;
     }
@@ -152,10 +147,10 @@ public class LocalTestClassResource extends TestClassResourceSupport {
     }
 
     public <S extends ObserveService> S newService(ObserveDataSourceConnection dataSourceConnection, Class<S> serviceType) {
-        ObserveServiceInitializer serviceInitializer = new ObserveServiceInitializer(getServiceInitializerConfig(), null, dataSourceConnection){
+        ObserveServiceInitializer serviceInitializer = new ObserveServiceInitializer(getServiceInitializerConfig(), null, dataSourceConnection) {
             @Override
             public Date now() {
-                return generateNow?new Date():ObserveFixtures.DATE;
+                return generateNow ? new Date() : ObserveFixtures.DATE;
             }
         };
         return serviceFactory.newService(serviceInitializer, serviceType);


=====================================
core/services/test/src/main/java/fr/ird/observe/services/service/AnonymousServiceFixtures.java
=====================================
@@ -72,11 +72,23 @@ public class AnonymousServiceFixtures extends GeneratedAnonymousServiceFixtures
     }
 
     @Override
-    public void create(fr.ird.observe.services.ObserveServicesProvider servicesProvider, AnonymousService service) {
+    public void createEmpty(fr.ird.observe.services.ObserveServicesProvider servicesProvider, AnonymousService service) {
         // FIXME:Test Remove super method invocation and implements fixture
         // actual = service.create(getProperty("create.id"));
         // Assert.assertNotNull(actual);
-        super.create(servicesProvider, service);
+        super.createEmpty(servicesProvider, service);
+    }
+
+    @Override
+    public void createFromDump(ObserveServicesProvider servicesProvider, AnonymousService service) {
+        //FIXME
+        super.createFromDump(servicesProvider, service);
+    }
+
+    @Override
+    public void createFromImport(ObserveServicesProvider servicesProvider, AnonymousService service) {
+        //FIXME
+        super.createFromImport(servicesProvider, service);
     }
 
     @Override


=====================================
pom.xml
=====================================
@@ -23,7 +23,7 @@
   <parent>
     <groupId>io.ultreia.maven</groupId>
     <artifactId>pom</artifactId>
-    <version>2022.36</version>
+    <version>2022.37</version>
   </parent>
   <groupId>fr.ird.observe</groupId>
   <artifactId>ird-observe</artifactId>


=====================================
server/core/src/main/filtered-resources/META-INF/mapping-api-client.wm
=====================================
@@ -25,7 +25,9 @@ server.main.handler.class=fr.ird.observe.server.ObserveWebMainHandler
 GET    /AnonymousService/applySecurity                                      AnonymousServiceRestApi.applySecurity
 GET    /AnonymousService/checkCanConnect                                    AnonymousServiceRestApi.checkCanConnect
 GET    /AnonymousService/checkCanConnectOrBeEmpty                           AnonymousServiceRestApi.checkCanConnectOrBeEmpty
-GET    /AnonymousService/create                                             AnonymousServiceRestApi.create
+POST   /AnonymousService/createEmpty                                        AnonymousServiceRestApi.createEmpty
+POST   /AnonymousService/createFromDump                                     AnonymousServiceRestApi.createFromDump
+POST   /AnonymousService/createFromImport                                   AnonymousServiceRestApi.createFromImport
 GET    /AnonymousService/generateHomeId                                     AnonymousServiceRestApi.generateHomeId
 GET    /AnonymousService/getModelVersion                                    AnonymousServiceRestApi.getModelVersion
 GET    /AnonymousService/getServerVersion                                   AnonymousServiceRestApi.getServerVersion


=====================================
server/core/src/main/java/fr/ird/observe/server/ObserveWebApplicationContext.java
=====================================
@@ -28,6 +28,7 @@ import fr.ird.observe.dto.server.ServerModelHelper;
 import fr.ird.observe.server.configuration.ServerConfig;
 import fr.ird.observe.server.configuration.ServerConfigApplicationComponent;
 import fr.ird.observe.server.configuration.ServerConfigFinder;
+import fr.ird.observe.server.converter.JsonAwareDtoConverter;
 import fr.ird.observe.server.security.ObserveWebSecurityApplicationContext;
 import fr.ird.observe.services.ObserveServiceFactory;
 import fr.ird.observe.services.ObserveServiceInitializer;
@@ -37,9 +38,11 @@ import fr.ird.observe.services.service.ObserveService;
 import fr.ird.observe.spi.json.DtoGsonSupplier;
 import io.ultreia.java4all.application.context.ApplicationContext;
 import io.ultreia.java4all.util.Version;
+import org.apache.commons.beanutils.ConvertUtils;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.debux.webmotion.server.call.HttpContext;
+import org.nuiton.topia.persistence.script.TopiaSqlScript;
 
 import javax.servlet.ServletContext;
 import java.io.Closeable;
@@ -125,6 +128,9 @@ public class ObserveWebApplicationContext extends ApplicationContext {
             closeDeleteTemporaryFilesTimer();
         }
         deleteTemporaryFilesTimer = CleanTemporaryFilesTask.create(getApplicationConfiguration());
+
+        JsonAwareDtoConverter<TopiaSqlScript> converter = new JsonAwareDtoConverter<>(getGsonSupplier().get(), TopiaSqlScript.class);
+        ConvertUtils.register(converter, TopiaSqlScript.class);
     }
 
     @Override


=====================================
server/core/src/main/java/fr/ird/observe/server/controller/AnonymousServiceRestApi.java
=====================================
@@ -26,7 +26,6 @@ import fr.ird.observe.dto.db.BabModelVersionException;
 import fr.ird.observe.dto.db.DataSourceUserDto;
 import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
 import fr.ird.observe.dto.db.DatabaseNotFoundException;
-import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
 import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
 import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
 import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
@@ -38,6 +37,7 @@ import fr.ird.observe.services.service.AnonymousService;
 import io.ultreia.java4all.util.Version;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.nuiton.topia.persistence.script.TopiaSqlScript;
 
 import java.lang.reflect.Method;
 import java.util.LinkedHashMap;
@@ -49,6 +49,12 @@ public class AnonymousServiceRestApi extends GeneratedAnonymousServiceRestApi {
 
     private static final Logger log = LogManager.getLogger(AnonymousServiceRestApi.class);
 
+    @Override
+    public ObserveDataSourceInformation checkCanConnectOrBeEmpty(ObserveDataSourceConfiguration config) throws DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {
+        ObserveWebUserSession session = getRequestContext().getConfigurationSession(config);
+        return getService().checkCanConnectOrBeEmpty(session.getConfiguration());
+    }
+
     @Override
     public ObserveDataSourceInformation checkCanConnect(ObserveDataSourceConfiguration config) throws DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException, BabModelVersionException {
         ObserveWebUserSession session = getRequestContext().getConfigurationSession(config);
@@ -56,11 +62,25 @@ public class AnonymousServiceRestApi extends GeneratedAnonymousServiceRestApi {
     }
 
     @Override
-    public ObserveDataSourceConnection create(ObserveDataSourceConfiguration config, DataSourceCreateConfigurationDto createConfiguration)
-            throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException,
-            DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {
+    public ObserveDataSourceConnection createEmpty(ObserveDataSourceConfiguration config) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
+        ObserveWebUserSession configurationSession = getRequestContext().getConfigurationSession(config);
+        ObserveDataSourceConnection connection = getService().createEmpty(configurationSession.getConfiguration());
+        ObserveWebUserSession authenticatedSession = getSecurityApplicationContext().registerAuthenticatedSession(configurationSession, connection);
+        return authenticatedSession.toRestConnection(config);
+    }
+
+    @Override
+    public ObserveDataSourceConnection createFromDump(ObserveDataSourceConfiguration config, TopiaSqlScript dump) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
+        ObserveWebUserSession configurationSession = getRequestContext().getConfigurationSession(config);
+        ObserveDataSourceConnection connection = getService().createFromDump(configurationSession.getConfiguration(), dump);
+        ObserveWebUserSession authenticatedSession = getSecurityApplicationContext().registerAuthenticatedSession(configurationSession, connection);
+        return authenticatedSession.toRestConnection(config);
+    }
+
+    @Override
+    public ObserveDataSourceConnection createFromImport(ObserveDataSourceConfiguration config, TopiaSqlScript dump, TopiaSqlScript optionalDump) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
         ObserveWebUserSession configurationSession = getRequestContext().getConfigurationSession(config);
-        ObserveDataSourceConnection connection = getService().create(configurationSession.getConfiguration(), createConfiguration);
+        ObserveDataSourceConnection connection = getService().createFromImport(configurationSession.getConfiguration(), dump,optionalDump );
         ObserveWebUserSession authenticatedSession = getSecurityApplicationContext().registerAuthenticatedSession(configurationSession, connection);
         return authenticatedSession.toRestConnection(config);
     }


=====================================
server/core/src/main/java/fr/ird/observe/server/converter/JsonAwareDtoConverter.java
=====================================
@@ -23,31 +23,32 @@ package fr.ird.observe.server.converter;
  */
 
 import com.google.gson.Gson;
-import fr.ird.observe.dto.ObserveDto;
+import io.ultreia.java4all.http.json.JsonAware;
 import org.apache.commons.beanutils.converters.AbstractConverter;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import io.ultreia.java4all.http.json.JsonAware;
 
 /**
  * Created on 07/09/15.
  *
  * @author Tony Chemit - dev@tchemit.fr
  */
-public class JsonAwareDtoConverter extends AbstractConverter {
+public class JsonAwareDtoConverter<TT extends JsonAware> extends AbstractConverter {
 
     private static final Logger log = LogManager.getLogger(JsonAwareDtoConverter.class);
 
     protected final Gson gson;
+    private final Class<TT> type;
 
-    public JsonAwareDtoConverter(Gson gson) {
+    public JsonAwareDtoConverter(Gson gson, Class<TT> type) {
         this.gson = gson;
+        this.type = type;
     }
 
     @Override
     protected <T> T convertToType(Class<T> type, Object value) {
         T observeDto;
-        if (JsonAware.class.isAssignableFrom(type)) {
+        if (type.isAssignableFrom(type)) {
             String gsonContent = value.toString();
             observeDto = gson.fromJson(gsonContent, type);
             log.info("convert observeDto: " + observeDto);
@@ -59,7 +60,7 @@ public class JsonAwareDtoConverter extends AbstractConverter {
     }
 
     @Override
-    protected Class<?> getDefaultType() {
-        return ObserveDto.class;
+    protected Class<TT> getDefaultType() {
+        return type;
     }
 }



View it on GitLab: https://gitlab.com/ultreiaio/ird-observe/-/compare/a864fb664be6b4f57a7edf8a1...

-- 
View it on GitLab: https://gitlab.com/ultreiaio/ird-observe/-/compare/a864fb664be6b4f57a7edf8a1...
You're receiving this email because of your account on gitlab.com.

    

[Observe-commits] [Git][ultreiaio/ird-observe][develop] 2 commits: Impossible de créer une base centrale vierge, quelque soit la méthode...

Tony CHEMIT (＠tchemit)