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

Commits:

24 changed files:

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
    28 28 
     import fr.ird.observe.dto.db.BabModelVersionException;
    29 29 
     import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
    30 30 
     import fr.ird.observe.dto.db.DatabaseNotFoundException;
    31 
    -import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
    32 31 
     import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
    33 32 
     import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
    34 33 
     import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
    ... ... @@ -41,6 +40,7 @@ import fr.ird.observe.spi.decoration.DecoratorService;
    41 40 
     import io.ultreia.java4all.i18n.I18n;
    42 41 
     import org.apache.logging.log4j.LogManager;
    43 42 
     import org.apache.logging.log4j.Logger;
    43 
    +import org.nuiton.topia.persistence.script.TopiaSqlScript;
    44 44
    45 45 
     import java.io.Closeable;
    46 46 
     import java.io.File;
    ... ... @@ -170,6 +170,17 @@ public class ObserveDataSourcesManager implements Closeable {
    170 170 
             return dataSource;
    171 171 
         }
    172 172
    173 
    +    public ObserveSwingDataSource newDataSource(ObserveDataSourceConfigurationTopiaH2 configuration, TopiaSqlScript dump) {
    174 
    +        ObserveSwingDataSource dataSource = new ObserveSwingDataSource(config, serviceFactory, decoratorService, configuration) {
    175 
    +            @Override
    176 
    +            public void open() throws DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException, BabModelVersionException, IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException {
    177 
    +                createFromDump(dump);
    178 
    +            }
    179 
    +        };
    180 
    +        addInternalListener(dataSource);
    181 
    +        return dataSource;
    182 
    +    }
    183 
    +
    173 184 
         void addInternalListener(ObserveSwingDataSource dataSource) {
    174 185 
             dataSource.addObserveSwingDataSourceListener(new ObserveSwingDataSourceListenerAdapter() {
    175 186
    ... ... @@ -195,18 +206,6 @@ public class ObserveDataSourcesManager implements Closeable {
    195 206 
             });
    196 207 
         }
    197 208
    198 
    -    public ObserveSwingDataSource newDataSource(ObserveDataSourceConfigurationTopiaH2 configuration, DataSourceCreateConfigurationDto createDto) {
    199 
    -        ObserveSwingDataSource dataSource = new ObserveSwingDataSource(config, serviceFactory, decoratorService, configuration) {
    200 
    -            @Override
    201 
    -            public void open() throws DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException, BabModelVersionException, IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException {
    202 
    -                create(createDto);
    203 
    -
    204 
    -            }
    205 
    -        };
    206 
    -        addInternalListener(dataSource);
    207 
    -        return dataSource;
    208 
    -    }
    209 
    -
    210 209 
         @Override
    211 210 
         public void close() {
    212 211

  • client/core/src/main/java/fr/ird/observe/client/datasource/api/ObserveSwingDataSource.java
    ... ... @@ -22,6 +22,8 @@ package fr.ird.observe.client.datasource.api;
    22 22 
      * #L%
    23 23 
      */
    24 24
    25 
    +import com.google.common.collect.ArrayListMultimap;
    26 
    +import com.google.common.collect.Multimap;
    25 27 
     import fr.ird.observe.client.WithClientUIContextApi;
    26 28 
     import fr.ird.observe.client.configuration.ClientConfig;
    27 29 
     import fr.ird.observe.client.datasource.api.event.ObserveSwingDataSourceEvent;
    ... ... @@ -38,7 +40,6 @@ import fr.ird.observe.dto.db.BabModelVersionException;
    38 40 
     import fr.ird.observe.dto.db.DataSourceUserDto;
    39 41 
     import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
    40 42 
     import fr.ird.observe.dto.db.DatabaseNotFoundException;
    41 
    -import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
    42 43 
     import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
    43 44 
     import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
    44 45 
     import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
    ... ... @@ -86,6 +87,7 @@ import javax.swing.event.EventListenerList;
    86 87 
     import java.io.File;
    87 88 
     import java.nio.file.Files;
    88 89 
     import java.nio.file.Path;
    90 
    +import java.util.Collection;
    89 91 
     import java.util.Collections;
    90 92 
     import java.util.Date;
    91 93 
     import java.util.Iterator;
    ... ... @@ -241,27 +243,66 @@ public class ObserveSwingDataSource extends AbstractJavaBean implements ObserveS
    241 243 
             fireOpened();
    242 244 
         }
    243 245
    244 
    -    public void createFrom(ObserveSwingDataSource localSource)
    246 
    +    public void createEmpty()
    245 247 
                 throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException,
    246 248 
                 DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {
    247 
    -        DataSourceCreateConfigurationDto createDto = new DataSourceCreateConfigurationDto();
    248 
    -        createDto.setLeaveOpenSource(true);
    249 
    -        createDto.setImportReferentialDataSourceConfiguration(localSource.getConfiguration());
    250 
    -        create(createDto);
    249 
    +        checkIsNotOpen();
    250 
    +        fireNewMessage(t("observe.ui.datasource.storage.message.creating", getLabel()));
    251 
    +        fireOpening();
    252 
    +        AnonymousService dataSourceService = getAnonymousService();
    253 
    +        setConnection(dataSourceService.createEmpty(getConfiguration()));
    254 
    +        fireNewMessage(t("observe.ui.datasource.storage.message.created", getLabel()));
    255 
    +        fireOpened();
    251 256 
         }
    252 257
    253 
    -    public void create(DataSourceCreateConfigurationDto createDto)
    258 
    +    public void createFromDump(TopiaSqlScript dump)
    254 259 
                 throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException,
    255 260 
                 DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {
    256 261 
             checkIsNotOpen();
    257 262 
             fireNewMessage(t("observe.ui.datasource.storage.message.creating", getLabel()));
    258 263 
             fireOpening();
    259 264 
             AnonymousService dataSourceService = getAnonymousService();
    260 
    -        setConnection(dataSourceService.create(getConfiguration(), createDto));
    265 
    +        setConnection(dataSourceService.createFromDump(getConfiguration(), dump));
    261 266 
             fireNewMessage(t("observe.ui.datasource.storage.message.created", getLabel()));
    262 267 
             fireOpened();
    263 268 
         }
    264 269
    270 
    +    public void createFromImport(TopiaSqlScript referential, TopiaSqlScript data)
    271 
    +            throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException,
    272 
    +            DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {
    273 
    +        checkIsNotOpen();
    274 
    +        fireNewMessage(t("observe.ui.datasource.storage.message.creating", getLabel()));
    275 
    +        fireOpening();
    276 
    +        AnonymousService dataSourceService = getAnonymousService();
    277 
    +        setConnection(dataSourceService.createFromImport(getConfiguration(), referential, data));
    278 
    +        fireNewMessage(t("observe.ui.datasource.storage.message.created", getLabel()));
    279 
    +        fireOpened();
    280 
    +    }
    281 
    +
    282 
    +    public TopiaSqlScript extract(boolean loadSchema, Set<String> importDataIds) {
    283 
    +        checkIsOpen();
    284 
    +        DataSourceService dataSourceService = getDataSourceService();
    285 
    +        CreateDatabaseRequest.Builder request = CreateDatabaseRequest.builder(true, getVersion());
    286 
    +        if (loadSchema) {
    287 
    +            request.addSchema().addStandaloneTables();
    288 
    +        }
    289 
    +        if (importDataIds != null) {
    290 
    +            Multimap<String, String> idsByType = ArrayListMultimap.create();
    291 
    +            for (String importDataId : importDataIds) {
    292 
    +                //FIXME
    293 
    +                String className = importDataId.contains(".ll.") ? "fr.ird.observe.entities.data.ll.common.Trip" : "fr.ird.observe.entities.data.ps.common.Trip";
    294 
    +                idsByType.put(className, importDataId);
    295 
    +            }
    296 
    +            for (Map.Entry<String, Collection<String>> entry : idsByType.asMap().entrySet()) {
    297 
    +                String type = entry.getKey();
    298 
    +                Set<String> dataIds = Set.copyOf(entry.getValue());
    299 
    +                log.info(String.format("Add %d data of type: %s", dataIds.size(), type));
    300 
    +                request.dataIdsToAdd(type, dataIds);
    301 
    +            }
    302 
    +        }
    303 
    +        return dataSourceService.produceCreateSqlScript(request.build());
    304 
    +    }
    305 
    +
    265 306 
         @Override
    266 307 
         public void close() {
    267 308 
             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;
    30 30 
     import fr.ird.observe.client.datasource.api.event.ObserveSwingDataSourceEvent;
    31 31 
     import fr.ird.observe.client.datasource.api.event.ObserveSwingDataSourceListenerAdapter;
    32 32 
     import fr.ird.observe.client.util.ObserveSwingTechnicalException;
    33 
    -import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
    34 33 
     import io.ultreia.java4all.lang.Strings;
    35 34 
     import org.apache.logging.log4j.LogManager;
    36 35 
     import org.apache.logging.log4j.Logger;
    ... ... @@ -98,9 +97,6 @@ public class BackupsManager implements Closeable {
    98 97 
                 log.info("Will check backup " + backupStorage.getFile());
    99 98
    100 99 
                 try {
    101 
    -//                byte[] dump = Files.readAllBytes(backupStorage.getFile().toPath());
    102 
    -                DataSourceCreateConfigurationDto createDto = new DataSourceCreateConfigurationDto();
    103 
    -                createDto.setImportDatabase(TopiaSqlScript.of(backupStorage.getFile().toURI()));
    104 100
    105 101 
                     try (ObserveSwingDataSource dataSource = dataSourcesManager.newTemporaryH2DataSource("check-" + backupStorage.getName())) {
    106 102 
                         dataSource.addObserveSwingDataSourceListener(new ObserveSwingDataSourceListenerAdapter() {
    ... ... @@ -109,7 +105,7 @@ public class BackupsManager implements Closeable {
    109 105 
                                 dataSource.destroy();
    110 106 
                             }
    111 107 
                         });
    112 
    -                    dataSource.create(createDto);
    108 
    +                    dataSource.createFromDump(TopiaSqlScript.of(backupStorage.getFile().toURI()));
    113 109 
                     }
    114 110 
                     backupStorage.setVerified(true);
    115 111 
                     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;
    34 34 
     import fr.ird.observe.client.util.ObserveSwingTechnicalException;
    35 35 
     import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
    36 36 
     import fr.ird.observe.dto.db.configuration.DataSourceConnectMode;
    37 
    -import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
    38 37 
     import fr.ird.observe.dto.db.configuration.DataSourceInitMode;
    39 38 
     import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
    40 39 
     import fr.ird.observe.dto.db.configuration.ObserveDataSourceInformation;
    ... ... @@ -212,13 +211,8 @@ public class DataSourceEditorHelper implements WithClientUIContextApi {
    212 211
    213 212 
             log.info("Will load last backup: " + backupStorage.getFile());
    214 213 
             try {
    215 
    -            DataSourceCreateConfigurationDto createDto = new DataSourceCreateConfigurationDto();
    216 
    -            createDto.setImportDatabase(TopiaSqlScript.of(backupStorage.getFile().toPath().toUri()));
    217 
    -
    218 214 
                 ObserveDataSourceConfigurationTopiaH2 dataSourceConfigurationH2 = dataSourcesManager.newH2DataSourceConfiguration(I18n.n("observe.runner.initStorage.label.local"));
    219 
    -
    220 
    -            ObserveSwingDataSource dataSource = dataSourcesManager.newDataSource(dataSourceConfigurationH2, createDto);
    221 
    -
    215 
    +            ObserveSwingDataSource dataSource = dataSourcesManager.newDataSource(dataSourceConfigurationH2, TopiaSqlScript.of(backupStorage.getFile().toPath().toUri()));
    222 216 
                 //FIXME:BodyContent Review progress model, not linked to ui any more...
    223 217 
                 mainUI.getMainUIBodyContentManager().getBodyTyped(DataSourceEditor.class, DataSourceEditorBodyContent.class).loadStorage(mainUI, dataSource);
    224 218 
             } 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;
    31 31 
     import fr.ird.observe.client.datasource.editor.api.loading.LoadingDataSourceContext;
    32 32 
     import fr.ird.observe.client.datasource.editor.api.wizard.DataSourceHelper;
    33 33 
     import fr.ird.observe.client.datasource.editor.api.wizard.StorageUIModel;
    34 
    -import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
    35 34 
     import fr.ird.observe.dto.db.configuration.DataSourceInitModel;
    36 35 
     import fr.ird.observe.dto.db.configuration.ObserveDataSourceInformation;
    37 36 
     import org.apache.logging.log4j.LogManager;
    38 37 
     import org.apache.logging.log4j.Logger;
    38 
    +import org.nuiton.topia.persistence.script.TopiaSqlScript;
    39 39
    40 40 
     import static io.ultreia.java4all.i18n.I18n.t;
    41 41
    ... ... @@ -115,8 +115,8 @@ public class OpenDataSourceActionStep extends OpenDataSourceActionStepSupport {
    115 115 
             try {
    116 116 
                 if (initModel.isOnCreateMode()) {
    117 117 
                     // do create local data source
    118 
    -                DataSourceCreateConfigurationDto creationConfigurationDto = DataSourceHelper.getCreationConfigurationDto(model);
    119 
    -                newDataSource.create(creationConfigurationDto);
    118 
    +                TopiaSqlScript dump = DataSourceHelper.getCreationConfigurationDto(model);
    119 
    +                newDataSource.createFromDump(dump);
    120 120 
                 } else {
    121 121 
                     // open data source
    122 122 
                     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;
    32 32 
     import fr.ird.observe.dto.db.BabModelVersionException;
    33 33 
     import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
    34 34 
     import fr.ird.observe.dto.db.DatabaseNotFoundException;
    35 
    -import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
    36 35 
     import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
    37 36 
     import fr.ird.observe.dto.db.configuration.DataSourceInitModel;
    38 37 
     import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
    ... ... @@ -49,6 +48,7 @@ import org.nuiton.topia.service.sql.request.CreateDatabaseRequest;
    49 48
    50 49 
     import java.io.File;
    51 50 
     import java.nio.file.Path;
    51 
    +import java.util.Set;
    52 52
    53 53 
     /**
    54 54 
      * Created on 01/03/2021.
    ... ... @@ -57,6 +57,7 @@ import java.nio.file.Path;
    57 57 
      * @since 8.0.7
    58 58 
      */
    59 59 
     public class DataSourceHelper {
    60 
    +    public static final String referentialDbLabel = I18n.n("observe.ui.datasource.storage.label.reference.import.db");
    60 61 
         private static final Logger log = LogManager.getLogger(DataSourceHelper.class);
    61 62
    62 63 
         public static void importModel(StorageUIModel source, StorageUIModel dst) {
    ... ... @@ -79,7 +80,6 @@ public class DataSourceHelper {
    79 80 
             dst.getChooseDb().updateEditConfig();
    80 81 
         }
    81 82
    82 
    -
    83 83 
         public static void exportModel(StorageUIModel source, StorageUIModel dst) {
    84 84 
             source.getChooseDb().copyTo(dst.getChooseDb());
    85 85
    ... ... @@ -99,51 +99,74 @@ public class DataSourceHelper {
    99 99 
             dst.setDataSourceInformation(source.getDataSourceInformation());
    100 100 
         }
    101 101
    102 
    -    public static DataSourceCreateConfigurationDto getCreationConfigurationDto(StorageUIModel model) throws DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException, BabModelVersionException, IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException {
    103 
    -        DataSourceCreateConfigurationDto result = null;
    102 
    +    public static TopiaSqlScript getCreationConfigurationDto(StorageUIModel model) throws DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException, BabModelVersionException, IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException {
    104 103 
             ChooseDbModel chooseDb = model.getChooseDb();
    105 104 
             DataSourceInitModel initModel = chooseDb.getInitModel();
    106 
    -        if (initModel.isOnCreateMode()) {
    107 
    -            result = new DataSourceCreateConfigurationDto();
    108 
    -            TopiaSqlScript importDatabase = null;
    109 
    -            ObserveDataSourceConfiguration configSrc = null;
    110 
    -            switch (initModel.getCreateMode()) {
    105 
    +        TopiaSqlScript importDatabase = null;
    106 
    +        ObserveDataSourceConfiguration configSrc = null;
    107 
    +        switch (initModel.getCreateMode()) {
    111 108
    112 
    -                case EMPTY:
    113 
    -                    break;
    114 
    -                case IMPORT_INTERNAL_DUMP: {
    115 
    -                    File dumpFile = model.getClientConfig().getInitialDbDump();
    116 
    -                    importDatabase = TopiaSqlScript.of(dumpFile.toURI());
    117 
    -                }
    109 
    +            case EMPTY:
    118 110 
                     break;
    119 
    -                case IMPORT_EXTERNAL_DUMP: {
    120 
    -                    File dumpFile = model.getDumpFile();
    121 
    -                    importDatabase = TopiaSqlScript.of(dumpFile.toURI());
    122 
    -                }
    111 
    +            case IMPORT_INTERNAL_DUMP: {
    112 
    +                File dumpFile = model.getClientConfig().getInitialDbDump();
    113 
    +                importDatabase = TopiaSqlScript.of(dumpFile.toURI());
    114 
    +            }
    115 
    +            break;
    116 
    +            case IMPORT_EXTERNAL_DUMP: {
    117 
    +                File dumpFile = model.getDumpFile();
    118 
    +                importDatabase = TopiaSqlScript.of(dumpFile.toURI());
    119 
    +            }
    120 
    +            break;
    121 
    +            case IMPORT_LOCAL_STORAGE:
    122 
    +                configSrc = model.getLocalConfig().getConfiguration();
    123 
    +                break;
    124 
    +            case IMPORT_REMOTE_STORAGE:
    125 
    +                configSrc = model.getRemoteConfig().getConfiguration();
    123 126 
                     break;
    124 
    -                case IMPORT_LOCAL_STORAGE:
    125 
    -                    configSrc = model.getLocalConfig().getConfiguration();
    126 
    -                    break;
    127 
    -                case IMPORT_REMOTE_STORAGE:
    128 
    -                    configSrc = model.getRemoteConfig().getConfiguration();
    129 
    -                    break;
    130 
    -                case IMPORT_SERVER_STORAGE:
    131 
    -                    configSrc = model.getServerConfig().getConfiguration();
    132 
    -                    break;
    127 
    +            case IMPORT_SERVER_STORAGE:
    128 
    +                configSrc = model.getServerConfig().getConfiguration();
    129 
    +                break;
    130 
    +        }
    131 
    +        if (configSrc != null) {
    132 
    +            try (ObserveSwingDataSource source = model.getDataSourcesManager().newDataSource(configSrc)) {
    133 
    +                source.open();
    134 
    +                DataSourceService dumpService = source.getDataSourceService();
    135 
    +                CreateDatabaseRequest request = CreateDatabaseRequest.builder(false, source.getVersion()).addSchema().addStandaloneTables().build();
    136 
    +                importDatabase = dumpService.produceCreateSqlScript(request);
    133 137 
                 }
    134 
    -            if (configSrc != null) {
    135 
    -                try (ObserveSwingDataSource source = model.getDataSourcesManager().newDataSource(configSrc)) {
    136 
    -                    source.open();
    137 
    -                    DataSourceService dumpService = source.getDataSourceService();
    138 
    -                    CreateDatabaseRequest request = CreateDatabaseRequest.builder(false, source.getVersion()).addSchema().addStandaloneTables().build();
    139 
    -                    importDatabase = dumpService.produceCreateSqlScript(request);
    140 
    -                }
    138 
    +        }
    139 
    +        return importDatabase;
    140 
    +    }
    141 
    +
    142 
    +    public static TopiaSqlScript extract(ObserveDataSourcesManager dataSourcesManager, File dumpFile, boolean loadSchema, Set<String> importDataIds) {
    143 
    +        try (ObserveSwingDataSource importDataSource = dataSourcesManager.newTemporaryH2DataSource(referentialDbLabel)) {
    144 
    +            try {
    145 
    +                importDataSource.createFromDump(TopiaSqlScript.of(dumpFile.toURI()));
    146 
    +                return importDataSource.extract(loadSchema, importDataIds);
    147 
    +            } catch (IncompatibleDataSourceCreateConfigurationException
    148 
    +                    | DataSourceCreateWithNoReferentialImportException
    149 
    +                    | DatabaseNotFoundException
    150 
    +                    | DatabaseConnexionNotAuthorizedException
    151 
    +                    | BabModelVersionException e) {
    152 
    +                throw new ObserveSwingTechnicalException("Could not create import data source", e);
    141 153 
                 }
    142 
    -            if (importDatabase != null) {
    143 
    -                result.setImportDatabase(importDatabase);
    154 
    +        }
    155 
    +    }
    156 
    +
    157 
    +    public static TopiaSqlScript extract(ObserveDataSourcesManager dataSourcesManager, ObserveDataSourceConfiguration sourceConfiguration, boolean loadSchema, Set<String> importDataIds) {
    158 
    +        try (ObserveSwingDataSource importDataSource = dataSourcesManager.newDataSource(sourceConfiguration)) {
    159 
    +            try {
    160 
    +                importDataSource.open();
    161 
    +                return importDataSource.extract(loadSchema,importDataIds);
    162 
    +            } catch (IncompatibleDataSourceCreateConfigurationException
    163 
    +                    | DataSourceCreateWithNoReferentialImportException
    164 
    +                    | DatabaseNotFoundException
    165 
    +                    | DatabaseConnexionNotAuthorizedException
    166 
    +                    | BabModelVersionException e) {
    167 
    +                throw new ObserveSwingTechnicalException("Could not create import data source", e);
    144 168 
                 }
    145 169 
             }
    146 
    -        return result;
    147 170 
         }
    148 171
    149 172 
         public static ObserveSwingDataSource initDataSourceFromModel(StorageUIModel model) {
    ... ... @@ -214,103 +237,6 @@ public class DataSourceHelper {
    214 237 
             return dataSource;
    215 238 
         }
    216 239
    217 
    -    public static DataSourceCreateConfigurationDto toImportReferentielSourceConfig(StorageUIModel model) {
    218 
    -        DataSourceCreateConfigurationDto importReferenceConfig = new DataSourceCreateConfigurationDto();
    219 
    -        // can create empty data base
    220 
    -        importReferenceConfig.setCanCreateEmptyDatabase(true);
    221 
    -        if (model.getChooseDb().doImportReferential()) {
    222 
    -            String dbLabel = I18n.n("observe.ui.datasource.storage.label.reference.import.db");
    223 
    -            switch (model.getChooseDb().getReferentielImportMode()) {
    224 
    -                case IMPORT_EXTERNAL_DUMP:
    225 
    -                    if (ObstunaAdminAction.CREATE.equals(model.getAdminAction())) {
    226 
    -                        // import referential to temporary data source
    227 
    -                        DataSourceCreateConfigurationDto createConfigurationDto = new DataSourceCreateConfigurationDto();
    228 
    -                        File dumpFile = model.getCentralSourceModel().getDumpFile();
    229 
    -                        createConfigurationDto.setImportDatabase(TopiaSqlScript.of(dumpFile.toURI()));
    230 
    -                        try (ObserveSwingDataSource importDataSource = model.getDataSourcesManager().newTemporaryH2DataSource(dbLabel)) {
    231 
    -                            try {
    232 
    -                                importDataSource.create(createConfigurationDto);
    233 
    -                            } catch (IncompatibleDataSourceCreateConfigurationException
    234 
    -                                    | DataSourceCreateWithNoReferentialImportException
    235 
    -                                    | DatabaseNotFoundException
    236 
    -                                    | DatabaseConnexionNotAuthorizedException
    237 
    -                                    | BabModelVersionException e) {
    238 
    -                                throw new ObserveSwingTechnicalException("Could not create import data source", e);
    239 
    -                            }
    240 
    -                            importReferenceConfig.setImportReferentialDataSourceConfiguration(importDataSource.getConfiguration());
    241 
    -                        }
    242 
    -                    } else {
    243 
    -                        File dumpFile = model.getDumpFile();
    244 
    -                        importReferenceConfig.setImportDatabase(TopiaSqlScript.of(dumpFile.toURI()));
    245 
    -                    }
    246 
    -                    break;
    247 
    -                case IMPORT_REMOTE_STORAGE:
    248 
    -                    // import referentiel from a remote db
    249 
    -                    ObserveDataSourceConfigurationTopiaPG pgConfig = toPGStorageConfig(model.getCentralSourceModel(), dbLabel);
    250 
    -                    pgConfig.setCanMigrate(false);
    251 
    -                    importReferenceConfig.setImportReferentialDataSourceConfiguration(pgConfig);
    252 
    -                    break;
    253 
    -                case IMPORT_SERVER_STORAGE:
    254 
    -                    // import referentiel from a server db
    255 
    -                    ObserveDataSourceConfigurationRest restConfig = toRestStorageConfig(model.getCentralSourceModel(), dbLabel);
    256 
    -                    importReferenceConfig.setImportReferentialDataSourceConfiguration(restConfig);
    257 
    -                    break;
    258 
    -                default:
    259 
    -                    throw new IllegalStateException("Can't come here");
    260 
    -            }
    261 
    -        }
    262 
    -        return importReferenceConfig;
    263 
    -    }
    264 
    -
    265 
    -    public static ObserveSwingDataSource toImportDataSourceConfig(StorageUIModel model) {
    266 
    -
    267 
    -        ObserveSwingDataSource importDataSource;
    268 
    -
    269 
    -        if (model.getChooseDb().doImportData()) {
    270 
    -
    271 
    -            String dbLabel = I18n.n("observe.ui.datasource.storage.label.data.import.db");
    272 
    -
    273 
    -            ObserveDataSourcesManager dataSourcesManager = model.getDataSourcesManager();
    274 
    -            switch (model.getChooseDb().getDataImportMode()) {
    275 
    -                case IMPORT_EXTERNAL_DUMP:
    276 
    -                    DataSourceCreateConfigurationDto createConfigurationDto = new DataSourceCreateConfigurationDto();
    277 
    -                    File dumpFile = ObstunaAdminAction.CREATE.equals(model.getAdminAction()) ? model.getDataSourceModel().getDumpFile() : model.getDumpFile();
    278 
    -                    createConfigurationDto.setImportDatabase(TopiaSqlScript.of(dumpFile.toURI()));
    279 
    -                    try (ObserveSwingDataSource importDataSource2 = dataSourcesManager.newTemporaryH2DataSource(dbLabel)) {
    280 
    -                        importDataSource = importDataSource2;
    281 
    -                        try {
    282 
    -                            importDataSource2.create(createConfigurationDto);
    283 
    -                        } catch (IncompatibleDataSourceCreateConfigurationException
    284 
    -                                | DataSourceCreateWithNoReferentialImportException
    285 
    -                                | DatabaseNotFoundException
    286 
    -                                | DatabaseConnexionNotAuthorizedException
    287 
    -                                | BabModelVersionException e) {
    288 
    -                            throw new ObserveSwingTechnicalException("Could not create import data source", e);
    289 
    -                        }
    290 
    -                    }
    291 
    -                    break;
    292 
    -                case IMPORT_REMOTE_STORAGE: {
    293 
    -                    // import referentiel from a remote db
    294 
    -                    ObserveDataSourceConfigurationTopiaPG dataSourceConfig = toPGStorageConfig(model.getDataSourceModel(), dbLabel);
    295 
    -                    dataSourceConfig.setCanMigrate(false);
    296 
    -                    importDataSource = dataSourcesManager.newDataSource(dataSourceConfig);
    297 
    -                }
    298 
    -                break;
    299 
    -                case IMPORT_SERVER_STORAGE: {
    300 
    -                    // import referentiel from a server db
    301 
    -                    ObserveDataSourceConfigurationRest dataSourceConfig = toRestStorageConfig(model.getDataSourceModel(), dbLabel);
    302 
    -                    importDataSource = dataSourcesManager.newDataSource(dataSourceConfig);
    303 
    -                }
    304 
    -                break;
    305 
    -                default:
    306 
    -                    throw new IllegalStateException("Can't come here");
    307 
    -            }
    308 
    -        } else {
    309 
    -            importDataSource = null;
    310 
    -        }
    311 
    -        return importDataSource;
    312 
    -    }
    313 
    -
    314 240 
         static ObserveDataSourceConfigurationTopiaH2 toH2StorageConfig(StorageUIModel model, String label) {
    315 241 
             ObserveDataSourceConfigurationTopiaH2 h2Config = model.getLocalConfig().getConfiguration();
    316 242 
             return ObserveDataSourceConfigurationTopiaH2.create(
    ... ... @@ -326,7 +252,7 @@ public class DataSourceHelper {
    326 252 
             );
    327 253 
         }
    328 254
    329 
    -    static ObserveDataSourceConfigurationTopiaPG toPGStorageConfig(StorageUIModel model, String label) {
    255 
    +    public static ObserveDataSourceConfigurationTopiaPG toPGStorageConfig(StorageUIModel model, String label) {
    330 256 
             ObserveDataSourceConfigurationTopiaPG pgConfig = model.getRemoteConfig().getConfiguration();
    331 257 
             return ObserveDataSourceConfigurationTopiaPG.create(
    332 258 
                     label,
    ... ... @@ -341,7 +267,7 @@ public class DataSourceHelper {
    341 267 
             );
    342 268 
         }
    343 269
    344 
    -    static ObserveDataSourceConfigurationRest toRestStorageConfig(StorageUIModel model, String label) {
    270 
    +    public static ObserveDataSourceConfigurationRest toRestStorageConfig(StorageUIModel model, String label) {
    345 271 
             ObserveDataSourceConfigurationRest restConfig = model.getServerConfig().getConfiguration();
    346 272 
             return ObserveDataSourceConfigurationRest.create(
    347 273 
                     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;
    42 42 
     import org.apache.logging.log4j.LogManager;
    43 43 
     import org.apache.logging.log4j.Logger;
    44 44 
     import org.nuiton.jaxx.runtime.JAXXContext;
    45 
    +import org.nuiton.topia.persistence.script.TopiaSqlScript;
    45 46
    46 47 
     import java.awt.Window;
    47 48 
     import java.io.File;
    ... ... @@ -137,7 +138,8 @@ public class StorageBackupUILauncher extends StorageUILauncher {
    137 138 
             try (ObserveSwingDataSource targetSource = dataSourcesManager.newTemporaryH2DataSource("Backup-" + backupFile.getName())) {
    138 139
    139 140 
                 // create temporary source
    140 
    -            targetSource.createFrom(incomingSource);
    141 
    +            TopiaSqlScript referentialDump = incomingSource.extract(true, null);
    142 
    +            targetSource.createFromDump(referentialDump);
    141 143 
                 progressModel.increments();
    142 144
    143 145 
                 // 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
    671 671 
                         }
    672 672 
                         break;
    673 673 
                     case CONFIG_REFERENTIAL:
    674 
    -
    674 
    +                    if (chooseDb.getReferentielImportMode() == null) {
    675 
    +                        return false;
    676 
    +                    }
    675 677 
                         switch (chooseDb.getReferentielImportMode()) {
    676 678
    677 679 
                             case EMPTY:
    ... ... @@ -703,7 +705,9 @@ public class StorageUIModel extends WizardModel<StorageStep> implements WithClie
    703 705 
                         break;
    704 706
    705 707 
                     case CONFIG_DATA:
    706 
    -
    708 
    +                    if (chooseDb.getDataImportMode() == null) {
    709 
    +                        return false;
    710 
    +                    }
    707 711 
                         switch (chooseDb.getDataImportMode()) {
    708 712
    709 713 
                             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;
    22 22 
      * #L%
    23 23 
      */
    24 24
    25 
    +import fr.ird.observe.client.datasource.api.ObserveDataSourcesManager;
    25 26 
     import fr.ird.observe.client.datasource.api.ObserveSwingDataSource;
    26 27 
     import fr.ird.observe.client.datasource.editor.api.wizard.DataSourceHelper;
    27 28 
     import fr.ird.observe.client.datasource.editor.api.wizard.ObstunaAdminAction;
    28 29 
     import fr.ird.observe.client.datasource.editor.api.wizard.StorageUI;
    29 30 
     import fr.ird.observe.client.datasource.editor.api.wizard.StorageUIModel;
    31 
    +import fr.ird.observe.client.util.ObserveSwingTechnicalException;
    30 32 
     import fr.ird.observe.dto.db.BabModelVersionException;
    31 33 
     import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
    32 34 
     import fr.ird.observe.dto.db.DatabaseNotFoundException;
    33 35 
     import fr.ird.observe.dto.db.configuration.DataSourceConnectMode;
    34 
    -import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
    36 
    +import fr.ird.observe.dto.db.configuration.DataSourceCreateMode;
    35 37 
     import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
    36 38 
     import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
    37 39 
     import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
    38 40 
     import fr.ird.observe.dto.db.configuration.ObserveDataSourceInformation;
    39 
    -import fr.ird.observe.navigation.tree.selection.SelectionTreeModel;
    41 
    +import fr.ird.observe.dto.db.configuration.rest.ObserveDataSourceConfigurationRest;
    42 
    +import fr.ird.observe.dto.db.configuration.topia.ObserveDataSourceConfigurationTopiaPG;
    43 
    +import io.ultreia.java4all.i18n.I18n;
    40 44 
     import org.apache.logging.log4j.LogManager;
    41 45 
     import org.apache.logging.log4j.Logger;
    42 46 
     import org.nuiton.jaxx.runtime.JAXXContext;
    47 
    +import org.nuiton.topia.persistence.script.TopiaSqlScript;
    43 48
    44 49 
     import java.awt.Window;
    50 
    +import java.io.File;
    45 51 
     import java.util.Objects;
    46 52 
     import java.util.Set;
    47 53
    54 
    +import static fr.ird.observe.client.datasource.editor.api.wizard.DataSourceHelper.toPGStorageConfig;
    55 
    +
    48 56 
     /**
    49 57 
      * Created on 14/09/2021.
    50 58 
      *
    ... ... @@ -53,7 +61,53 @@ import java.util.Set;
    53 61 
      */
    54 62 
     public class CreateLauncher extends RemoteUILauncher {
    55 63 
         private static final Logger log = LogManager.getLogger(CreateLauncher.class);
    56 
    -    DataSourceCreateConfigurationDto createConfigurationDto;
    64 
    +    private TopiaSqlScript referential;
    65 
    +    private TopiaSqlScript data;
    66 
    +
    67 
    +    public static ObserveSwingDataSource toImportDataSourceConfig(StorageUIModel model) {
    68 
    +
    69 
    +        if (!model.getChooseDb().doImportData()) {
    70 
    +            throw new IllegalStateException(String.format("Must be in select data mode to come here: %s", model));
    71 
    +        }
    72 
    +
    73 
    +        String dbLabel = I18n.n("observe.ui.datasource.storage.label.data.import.db");
    74 
    +        ObserveSwingDataSource importDataSource;
    75 
    +
    76 
    +        ObserveDataSourcesManager dataSourcesManager = model.getDataSourcesManager();
    77 
    +        switch (model.getChooseDb().getDataImportMode()) {
    78 
    +            case IMPORT_EXTERNAL_DUMP:
    79 
    +                File dumpFile = model.getDataSourceModel().getDumpFile();
    80 
    +                try (ObserveSwingDataSource importDataSource2 = dataSourcesManager.newTemporaryH2DataSource(dbLabel)) {
    81 
    +                    importDataSource = importDataSource2;
    82 
    +                    try {
    83 
    +                        importDataSource2.createFromDump(TopiaSqlScript.of(dumpFile.toURI()));
    84 
    +                    } catch (IncompatibleDataSourceCreateConfigurationException
    85 
    +                            | DataSourceCreateWithNoReferentialImportException
    86 
    +                            | DatabaseNotFoundException
    87 
    +                            | DatabaseConnexionNotAuthorizedException
    88 
    +                            | BabModelVersionException e) {
    89 
    +                        throw new ObserveSwingTechnicalException("Could not create import data source", e);
    90 
    +                    }
    91 
    +                }
    92 
    +                break;
    93 
    +            case IMPORT_REMOTE_STORAGE: {
    94 
    +                // import referentiel from a remote db
    95 
    +                ObserveDataSourceConfigurationTopiaPG dataSourceConfig = DataSourceHelper.toPGStorageConfig(model.getDataSourceModel(), dbLabel);
    96 
    +                dataSourceConfig.setCanMigrate(false);
    97 
    +                importDataSource = dataSourcesManager.newDataSource(dataSourceConfig);
    98 
    +            }
    99 
    +            break;
    100 
    +            case IMPORT_SERVER_STORAGE: {
    101 
    +                // import referentiel from a server db
    102 
    +                ObserveDataSourceConfigurationRest dataSourceConfig = DataSourceHelper.toRestStorageConfig(model.getDataSourceModel(), dbLabel);
    103 
    +                importDataSource = dataSourcesManager.newDataSource(dataSourceConfig);
    104 
    +            }
    105 
    +            break;
    106 
    +            default:
    107 
    +                throw new IllegalStateException("Can't come here");
    108 
    +        }
    109 
    +        return importDataSource;
    110 
    +    }
    57 111
    58 112 
         public CreateLauncher(JAXXContext context, Window frame, DataSourceConnectMode connectMode) {
    59 113 
             super(ObstunaAdminAction.CREATE, context, frame, connectMode);
    ... ... @@ -67,27 +121,112 @@ public class CreateLauncher extends RemoteUILauncher {
    67 121 
             //FIXME This logic should be done in StorageModel not here, like this!
    68 122 
             model.getChooseDb().setCanMigrate(true);
    69 123 
             model.getRemoteConfig().setCanCreateDatabase(true);
    124 
    +        model.getServerConfig().setCanCreateDatabase(true);
    70 125 
             super.init(ui);
    71 126 
         }
    72 127
    73 128 
         @Override
    74 
    -    protected ObserveSwingDataSource initTask(StorageUIModel model) throws Exception {
    129 
    +    protected ObserveSwingDataSource initTask(StorageUIModel model) {
    75 130 
             ObserveSwingDataSource dataSource = getDataSource(model);
    76 
    -        createConfigurationDto = DataSourceHelper.toImportReferentielSourceConfig(model);
    77 
    -        ObserveDataSourceConfiguration importReferentialConfig = createConfigurationDto.getImportReferentialDataSourceConfiguration();
    78 
    -        if (importReferentialConfig != null) {
    79 
    -            log.info(String.format("Use referentiel import data source %s", importReferentialConfig.getLabel()));
    80 
    -            checkImportDbVersion(model, importReferentialConfig);
    131 
    +        // can create empty data base
    132 
    +        boolean importReferential = model.getChooseDb().doImportReferential();
    133 
    +        boolean importData = model.getChooseDb().doImportData();
    134 
    +        if (!importReferential && !importData) {
    135 
    +            // no import at all
    136 
    +            log.info("Create empty database.");
    137 
    +            return dataSource;
    81 138 
             }
    82 
    -        // data import
    83 
    -        ObserveSwingDataSource importDataConfig = DataSourceHelper.toImportDataSourceConfig(model);
    84 
    -        if (importDataConfig != null) {
    85 
    -            log.info(String.format("Use data import data source %s", importDataConfig.getLabel()));
    86 
    -            checkImportDbVersion(model, importDataConfig.getConfiguration());
    87 
    -            SelectionTreeModel dataModel = model.getSelectDataModel();
    88 
    -            Set<String> importDataIds = dataModel.getSelectedDataIds();
    89 
    -            createConfigurationDto.setImportDataConfiguration(importDataConfig.getConfiguration(), importDataIds);
    139 
    +
    140 
    +        DataSourceCreateMode referentialImportMode = model.getChooseDb().getReferentielImportMode();
    141 
    +        DataSourceCreateMode dataImportMode = model.getChooseDb().getDataImportMode();
    142 
    +
    143 
    +        File referentialDump = null;
    144 
    +        ObserveDataSourceConfiguration referentialConfig = null;
    145 
    +        File dataDump = null;
    146 
    +        ObserveDataSourceConfiguration dataConfig = null;
    147 
    +        Set<String> selectedDataIds = null;
    148 
    +        if (importReferential && referentialImportMode != null) {
    149 
    +            switch (referentialImportMode) {
    150 
    +                case IMPORT_EXTERNAL_DUMP:
    151 
    +                    referentialDump = model.getCentralSourceModel().getDumpFile();
    152 
    +
    153 
    +                    break;
    154 
    +                case IMPORT_REMOTE_STORAGE:
    155 
    +                    ObserveDataSourceConfigurationTopiaPG pgConfig = toPGStorageConfig(model.getCentralSourceModel(), DataSourceHelper.referentialDbLabel);
    156 
    +                    pgConfig.setCanMigrate(false);
    157 
    +                    referentialConfig = pgConfig;
    158 
    +                    break;
    159 
    +                case IMPORT_SERVER_STORAGE:
    160 
    +                    referentialConfig = DataSourceHelper.toRestStorageConfig(model.getCentralSourceModel(), DataSourceHelper.referentialDbLabel);
    161 
    +                    break;
    162 
    +                default:
    163 
    +                    throw new IllegalStateException("Can't come here");
    164 
    +            }
    90 165 
             }
    166 
    +        if (importData && dataImportMode != null) {
    167 
    +            String dbLabel = I18n.n("observe.ui.datasource.storage.label.data.import.db");
    168 
    +            selectedDataIds = model.getSelectDataModel().getSelectedDataIds();
    169 
    +            switch (dataImportMode) {
    170 
    +                case IMPORT_EXTERNAL_DUMP:
    171 
    +                    dataDump = model.getDataSourceModel().getDumpFile();
    172 
    +                    break;
    173 
    +                case IMPORT_REMOTE_STORAGE: {
    174 
    +                    ObserveDataSourceConfigurationTopiaPG dataSourceConfig = toPGStorageConfig(model.getDataSourceModel(), dbLabel);
    175 
    +                    dataSourceConfig.setCanMigrate(false);
    176 
    +                    dataConfig = dataSourceConfig;
    177 
    +                }
    178 
    +                break;
    179 
    +                case IMPORT_SERVER_STORAGE: {
    180 
    +                    dataConfig = DataSourceHelper.toRestStorageConfig(model.getDataSourceModel(), dbLabel);
    181 
    +                    break;
    182 
    +                }
    183 
    +                default:
    184 
    +                    throw new IllegalStateException("Can't come here");
    185 
    +            }
    186 
    +        }
    187 
    +
    188 
    +        if (referentialDump != null) {
    189 
    +            if (dataDump != null) {
    190 
    +                if (referentialDump.equals(dataDump)) {
    191 
    +
    192 
    +                    log.info(String.format("Extract referential + data from dump %s", referentialDump));
    193 
    +                    referential = DataSourceHelper.extract(model.getDataSourcesManager(), referentialDump, true, selectedDataIds);
    194 
    +                } else {
    195 
    +                    log.info(String.format("Extract referential from dump %s", referentialDump));
    196 
    +                    referential = DataSourceHelper.extract(model.getDataSourcesManager(), referentialDump, true, null);
    197 
    +                    log.info(String.format("Extract data from dump %s %s", dataDump, selectedDataIds));
    198 
    +                    data = DataSourceHelper.extract(model.getDataSourcesManager(), dataDump, false, selectedDataIds);
    199 
    +                }
    200 
    +            } else {
    201 
    +                log.info(String.format("Extract referential from dump %s", referentialDump));
    202 
    +                referential = DataSourceHelper.extract(model.getDataSourcesManager(), referentialDump, true, null);
    203 
    +                if (dataConfig != null) {
    204 
    +                    log.info(String.format("Extract data from config %s %s", dataConfig.getLabel(), selectedDataIds));
    205 
    +                    data = DataSourceHelper.extract(model.getDataSourcesManager(), dataConfig, false, selectedDataIds);
    206 
    +                }
    207 
    +            }
    208 
    +        } else {
    209 
    +            Objects.requireNonNull(referentialConfig);
    210 
    +            if (dataConfig != null) {
    211 
    +                if (referentialConfig.equals(dataConfig)) {
    212 
    +                    log.info(String.format("Extract referential + data from config %s %s", referentialConfig.getLabel(), selectedDataIds));
    213 
    +                    referential = DataSourceHelper.extract(model.getDataSourcesManager(), referentialConfig, true, selectedDataIds);
    214 
    +                } else {
    215 
    +                    log.info(String.format("Extract referential from config %s", referentialConfig.getLabel()));
    216 
    +                    referential = DataSourceHelper.extract(model.getDataSourcesManager(), referentialConfig, true, null);
    217 
    +                    log.info(String.format("Extract data from config %s %s", dataConfig.getLabel(), selectedDataIds));
    218 
    +                    data = DataSourceHelper.extract(model.getDataSourcesManager(), dataConfig, false, selectedDataIds);
    219 
    +                }
    220 
    +            } else {
    221 
    +                log.info(String.format("Extract referential from config %s", referentialConfig.getLabel()));
    222 
    +                referential = DataSourceHelper.extract(model.getDataSourcesManager(), referentialConfig, true, null);
    223 
    +                if (dataDump != null) {
    224 
    +                    log.info(String.format("Extract data from dump %s %s", dataDump, selectedDataIds));
    225 
    +                    data = DataSourceHelper.extract(model.getDataSourcesManager(), dataDump, false, selectedDataIds);
    226 
    +                }
    227 
    +            }
    228 
    +        }
    229 
    +        Objects.requireNonNull(referential);
    91 230 
             return dataSource;
    92 231 
         }
    93 232
    ... ... @@ -95,21 +234,15 @@ public class CreateLauncher extends RemoteUILauncher {
    95 234 
         protected void execute(ObserveSwingDataSource dataSource, ObserveDataSourceInformation dataSourceInformation) throws Exception {
    96 235 
             log.info("Create db...");
    97 236 
             try {
    98 
    -            dataSource.create(createConfigurationDto);
    237 
    +            if (referential != null) {
    238 
    +                dataSource.createFromImport(referential, data);
    239 
    +            } else {
    240 
    +                dataSource.createEmpty();
    241 
    +            }
    99 242 
                 log.info(String.format("Open [%s] and create it.", dataSource.getLabel()));
    100 243 
             } finally {
    101 
    -            if (dataSource.isOpen()) {
    102 
    -                dataSource.close();
    103 
    -            }
    104 
    -        }
    105 
    -    }
    106 
    -
    107 
    -    void checkImportDbVersion(StorageUIModel model, ObserveDataSourceConfiguration dataSourceConfig) throws DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException, BabModelVersionException, IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException {
    108 
    -        try (ObserveSwingDataSource importDataSource = Objects.requireNonNull(model.getDataSourcesManager().newDataSource(dataSourceConfig))) {
    109 
    -            importDataSource.open();
    110 
    -            model.checkImportDbVersion(importDataSource);
    244 
    +            ObserveSwingDataSource.doCloseSource(dataSource);
    111 245 
             }
    112 246 
         }
    113 
    -
    114 247 
     }
    115 248

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

  • 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;
    29 29 
     import fr.ird.observe.client.datasource.editor.api.selection.SelectionTreePane;
    30 30 
     import fr.ird.observe.client.datasource.editor.api.selection.SelectionTreePaneHandler;
    31 31 
     import fr.ird.observe.client.datasource.editor.api.selection.actions.SelectUnselect;
    32 
    -import fr.ird.observe.client.datasource.editor.api.wizard.DataSourceHelper;
    33 32 
     import fr.ird.observe.client.datasource.editor.api.wizard.ObstunaAdminAction;
    34 33 
     import fr.ird.observe.client.datasource.editor.api.wizard.StorageUIModel;
    34 
    +import fr.ird.observe.client.datasource.editor.api.wizard.launchers.CreateLauncher;
    35 35 
     import fr.ird.observe.client.util.ObserveKeyStrokesSupport;
    36 36 
     import fr.ird.observe.client.util.ObserveSwingTechnicalException;
    37 37 
     import fr.ird.observe.navigation.id.Project;
    ... ... @@ -75,7 +75,7 @@ public class SelectDataUIHandler extends StorageTabUIHandler<SelectDataUI> imple
    75 75 
                 }
    76 76 
                 if (createDataSource) {
    77 77 
                     // create temporary data source
    78 
    -                try (ObserveSwingDataSource dataSource = DataSourceHelper.toImportDataSourceConfig(model)) {
    78 
    +                try (ObserveSwingDataSource dataSource = CreateLauncher.toImportDataSourceConfig(model)) {
    79 79 
                         SelectionTreePaneHandler.initDataSource(treePane, dataSource);
    80 80 
                         dataSource.open();
    81 81 
                         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;
    28 28 
     import fr.ird.observe.dto.db.BabModelVersionException;
    29 29 
     import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
    30 30 
     import fr.ird.observe.dto.db.DatabaseNotFoundException;
    31 
    -import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
    32 31 
     import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
    33 32 
     import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
    34 33 
     import fr.ird.observe.dto.db.configuration.topia.ObserveDataSourceConfigurationTopiaH2;
    ... ... @@ -90,11 +89,9 @@ public class ClientTestClassResource extends TestClassResourceSupport {
    90 89 
             boolean sharedDatabaseExist = sharedDatabaseFile.exists();
    91 90 
             if (!sharedDatabaseExist) {
    92 91 
                 log.info(String.format("Create shared database: %s/%s to %s", dbVersion.toString(), dbName, sharedDatabaseFile));
    93 
    -            DataSourceCreateConfigurationDto createConfiguration = new DataSourceCreateConfigurationDto();
    94 92 
                 TopiaSqlScript script = dataSourcesForTestManager.getCache(dbVersion, dbName);
    95 
    -            createConfiguration.setImportDatabase(script);
    96 93 
                 observeSwingDataSource = ClientUIContextApplicationComponent.value().getDataSourcesManager().newDataSource(sharedDatabaseConfiguration);
    97 
    -            observeSwingDataSource.create(createConfiguration);
    94 
    +            observeSwingDataSource.createFromDump(script);
    98 95 
             }
    99 96 
             if (targetPath == null) {
    100 97 
                 dataSourceConfiguration = sharedDatabaseConfiguration;

  • core/persistence/java/src/main/java/fr/ird/observe/entities/DataSourceCreateHelper.java
    1 
    +package fr.ird.observe.entities;
    2 
    +
    3 
    +/*-
    4 
    + * #%L
    5 
    + * ObServe Core :: Persistence :: Java
    6 
    + * %%
    7 
    + * Copyright (C) 2008 - 2022 IRD, Code Lutin, Ultreia.io
    8 
    + * %%
    9 
    + * This program is free software: you can redistribute it and/or modify
    10 
    + * it under the terms of the GNU General Public License as
    11 
    + * published by the Free Software Foundation, either version 3 of the
    12 
    + * License, or (at your option) any later version.
    13 
    + *
    14 
    + * This program is distributed in the hope that it will be useful,
    15 
    + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    16 
    + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    17 
    + * GNU General Public License for more details.
    18 
    + *
    19 
    + * You should have received a copy of the GNU General Public
    20 
    + * License along with this program.  If not, see
    21 
    + * <http://www.gnu.org/licenses/gpl-3.0.html>.
    22 
    + * #L%
    23 
    + */
    24 
    +
    25 
    +import fr.ird.observe.dto.db.BabModelVersionException;
    26 
    +import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
    27 
    +import fr.ird.observe.dto.db.DatabaseNotFoundException;
    28 
    +import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
    29 
    +import fr.ird.observe.dto.db.configuration.topia.ObserveDataSourceConfigurationTopiaH2;
    30 
    +import io.ultreia.java4all.util.Version;
    31 
    +import org.apache.logging.log4j.LogManager;
    32 
    +import org.apache.logging.log4j.Logger;
    33 
    +import org.nuiton.topia.persistence.script.TopiaSqlScript;
    34 
    +import org.nuiton.topia.service.migration.TopiaMigrationService;
    35 
    +import org.nuiton.topia.service.sql.request.CreateDatabaseRequest;
    36 
    +
    37 
    +import java.io.File;
    38 
    +import java.io.IOException;
    39 
    +import java.nio.file.Files;
    40 
    +import java.nio.file.Path;
    41 
    +
    42 
    +/**
    43 
    + * Created on 16/03/2022.
    44 
    + *
    45 
    + * @author Tony Chemit - dev@tchemit.fr
    46 
    + * @since 6.0.7
    47 
    + */
    48 
    +public class DataSourceCreateHelper {
    49 
    +
    50 
    +    private static final Logger log = LogManager.getLogger(DataSourceCreateHelper.class);
    51 
    +
    52 
    +    public static void create(ToolkitTopiaApplicationContextSupport<?> applicationContext) throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    53 
    +        log.debug(String.format("Create topia application context: %s", applicationContext));
    54 
    +        // si le referentiel n'est pas importé on aliment la table lastUpdateDate
    55 
    +        //FIXME Make sure this is ok, but not sure
    56 
    +        applicationContext.insertLastUpdateDate();
    57 
    +    }
    58 
    +
    59 
    +    public static void create(ToolkitTopiaApplicationContextSupport<?> applicationContext, ObserveDataSourceConfiguration dataSourceConfiguration, TopiaSqlScript importDatabase) throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    60 
    +        log.debug(String.format("Create topia application context: %s", applicationContext));
    61 
    +        Path temporaryDirectory = dataSourceConfiguration.getTemporaryDirectory();
    62 
    +        log.info("Create new database from a script.");
    63 
    +        TopiaMigrationService migrationService = (TopiaMigrationService) applicationContext.getMigrationService();
    64 
    +        if (dataSourceConfiguration.isLocal()) {
    65 
    +            applicationContext.executeSqlStatements(importDatabase);
    66 
    +            migrationService.createSchemaIfNotExist();
    67 
    +            migrationService.runSchemaMigration();
    68 
    +        } else {
    69 
    +            // base postgres
    70 
    +            // do import in temporary h2 database
    71 
    +            File tmpDir;
    72 
    +            try {
    73 
    +                tmpDir = Files.createTempDirectory(temporaryDirectory, "obstuna").toFile();
    74 
    +            } catch (IOException e) {
    75 
    +                throw new IllegalStateException("could not create temporary directory ", e);
    76 
    +            }
    77 
    +            Version modelVersion = dataSourceConfiguration.getModelVersion();
    78 
    +            ObserveDataSourceConfigurationTopiaH2 temporaryConfiguration = applicationContext.createTemporaryConfiguration(tmpDir, modelVersion);
    79 
    +            ObserveTopiaApplicationContext temporaryTopiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(temporaryConfiguration, false);
    80 
    +            temporaryTopiaApplicationContext.executeSqlStatements(importDatabase);
    81 
    +            temporaryTopiaApplicationContext.getMigrationService().createSchemaIfNotExist();
    82 
    +            temporaryTopiaApplicationContext.getMigrationService().runSchemaMigration();
    83 
    +            CreateDatabaseRequest request = CreateDatabaseRequest.builder(true, modelVersion).addSchema().addStandaloneTables().addAllData().build();
    84 
    +            TopiaSqlScript dump = applicationContext.getSqlService().consume(request);
    85 
    +            applicationContext.executeSqlStatements(dump);
    86 
    +            migrationService.createSchemaIfNotExist();
    87 
    +            migrationService.runSchemaMigration();
    88 
    +            temporaryTopiaApplicationContext.close();
    89 
    +            File databaseFile = temporaryConfiguration.getDatabaseFile();
    90 
    +            if (!databaseFile.delete()) {
    91 
    +                throw new IllegalStateException("could not delete " + databaseFile);
    92 
    +            }
    93 
    +        }
    94 
    +    }
    95 
    +
    96 
    +    public static void create(ToolkitTopiaApplicationContextSupport<?> applicationContext, TopiaSqlScript dump, TopiaSqlScript optionalDump) throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    97 
    +        log.debug(String.format("Create topia application context: %s", applicationContext));
    98 
    +        applicationContext.executeSqlStatements(dump);
    99 
    +        if (optionalDump != null) {
    100 
    +            applicationContext.executeSqlStatements(optionalDump);
    101 
    +        }
    102 
    +    }
    103 
    +}

  • core/persistence/java/src/main/java/fr/ird/observe/entities/ObserveTopiaApplicationContext.java
    ... ... @@ -22,14 +22,10 @@ package fr.ird.observe.entities;
    22 22 
      * #L%
    23 23 
      */
    24 24
    25 
    -import com.google.common.collect.ArrayListMultimap;
    26 
    -import com.google.common.collect.Multimap;
    27 25 
     import fr.ird.observe.dto.db.BabModelVersionException;
    28 26 
     import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
    29 27 
     import fr.ird.observe.dto.db.DatabaseNotFoundException;
    30 
    -import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
    31 28 
     import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
    32 
    -import fr.ird.observe.dto.db.configuration.topia.ObserveDataSourceConfigurationTopiaH2;
    33 29 
     import fr.ird.observe.dto.referential.ReferentialDto;
    34 30 
     import fr.ird.observe.entities.data.DataGroupByEntity;
    35 31 
     import fr.ird.observe.spi.module.BusinessProject;
    ... ... @@ -37,16 +33,11 @@ import fr.ird.observe.spi.referential.differential.DifferentialMetaModel;
    37 33 
     import fr.ird.observe.spi.referential.synchro.OneSideSqlResultBuilder;
    38 34 
     import fr.ird.observe.spi.script.ToolkitEntitySqlScriptModel;
    39 35 
     import fr.ird.observe.spi.service.ServiceContext;
    40 
    -import io.ultreia.java4all.util.Version;
    41 
    -import org.apache.logging.log4j.LogManager;
    42 
    -import org.apache.logging.log4j.Logger;
    43 36 
     import org.nuiton.topia.persistence.TagValues;
    44 37 
     import org.nuiton.topia.persistence.TopiaConfigurationExtension;
    45 38 
     import org.nuiton.topia.persistence.TopiaEntity;
    46 
    -import org.nuiton.topia.persistence.TopiaIdFactory;
    47 39 
     import org.nuiton.topia.persistence.TopiaPersistenceContextConstructorParameterSupport;
    48 40 
     import org.nuiton.topia.persistence.script.TopiaSqlScript;
    49 
    -import org.nuiton.topia.service.migration.TopiaMigrationService;
    50 41 
     import org.nuiton.topia.service.sql.blob.TopiaEntitySqlBlobModel;
    51 42 
     import org.nuiton.topia.service.sql.metadata.TopiaMetadataModel;
    52 43 
     import org.nuiton.topia.service.sql.metadata.TopiaMetadataModelPaths;
    ... ... @@ -54,25 +45,15 @@ import org.nuiton.topia.service.sql.model.TopiaEntitySqlModel;
    54 45 
     import org.nuiton.topia.service.sql.plan.copy.TopiaEntitySqlCopyPlanModel;
    55 46 
     import org.nuiton.topia.service.sql.plan.delete.TopiaEntitySqlDeletePlanModel;
    56 47 
     import org.nuiton.topia.service.sql.plan.replicate.TopiaEntitySqlReplicatePlanModel;
    57 
    -import org.nuiton.topia.service.sql.request.CreateDatabaseRequest;
    58 48 
     import org.nuiton.topia.service.sql.usage.TopiaEntitySqlUsageModel;
    59 49
    60 
    -import java.io.File;
    61 
    -import java.io.IOException;
    62 
    -import java.nio.file.Files;
    63 
    -import java.nio.file.Path;
    64 50 
     import java.time.Duration;
    65 
    -import java.util.Collection;
    66 51 
     import java.util.Date;
    67 
    -import java.util.Map;
    68 52 
     import java.util.Set;
    69 
    -import java.util.UUID;
    70 53 
     import java.util.function.Consumer;
    71 54
    72 55 
     public class ObserveTopiaApplicationContext extends AbstractObserveTopiaApplicationContext {
    73 56
    74 
    -    private static final Logger log = LogManager.getLogger(ObserveTopiaApplicationContext.class);
    75 
    -
    76 57 
         public ObserveTopiaApplicationContext(TopiaConfigurationExtension topiaConfiguration) {
    77 58 
             super(topiaConfiguration);
    78 59 
         }
    ... ... @@ -187,131 +168,15 @@ public class ObserveTopiaApplicationContext extends AbstractObserveTopiaApplicat
    187 168 
             return ObserveTopiaEntitySqlModelResource.get().getScriptModel();
    188 169 
         }
    189 170
    190 
    -    public void create(ObserveDataSourceConfiguration dataSourceConfiguration, DataSourceCreateConfigurationDto dataSourceCreateConfiguration) throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    191 
    -        log.debug(String.format("Create topia application context: %s", this));
    192 
    -        if (dataSourceCreateConfiguration.isImportDatabase()) {
    193 
    -            log.info("Create new database from a script.");
    194 
    -            TopiaSqlScript importDatabase = dataSourceCreateConfiguration.getImportDatabase();
    195 
    -            boolean migrate = dataSourceCreateConfiguration.isMigrate();
    196 
    -            TopiaMigrationService migrationService = getMigrationService();
    197 
    -            if (dataSourceConfiguration.isLocal()) {
    198 
    -                executeSqlStatements(importDatabase);
    199 
    -                if (migrate) {
    200 
    -                    migrationService.createSchemaIfNotExist();
    201 
    -                    migrationService.runSchemaMigration();
    202 
    -                }
    203 
    -            } else { // base postgres
    204 
    -                // do import in temporary h2 database
    205 
    -                File tmpDir;
    206 
    -                try {
    207 
    -                    Path temporaryDirectory = dataSourceConfiguration.getTemporaryDirectory();
    208 
    -                    tmpDir = Files.createTempDirectory(temporaryDirectory, "obstuna").toFile();
    209 
    -                } catch (IOException e) {
    210 
    -                    throw new IllegalStateException("could not create temporary directory ", e);
    211 
    -                }
    212 
    -                ObserveDataSourceConfigurationTopiaH2 temporaryConfiguration = createTemporaryConfiguration(tmpDir, dataSourceConfiguration.getModelVersion());
    213 
    -                ObserveTopiaApplicationContext temporaryTopiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(temporaryConfiguration, false);
    214 
    -                temporaryTopiaApplicationContext.executeSqlStatements(importDatabase);
    215 
    -                if (migrate) {
    216 
    -                    temporaryTopiaApplicationContext.getMigrationService().createSchemaIfNotExist();
    217 
    -                    temporaryTopiaApplicationContext.getMigrationService().runSchemaMigration();
    218 
    -                }
    219 
    -                CreateDatabaseRequest request = CreateDatabaseRequest.builder(true, dataSourceConfiguration.getModelVersion()).addSchema().addStandaloneTables().addAllData().build();
    220 
    -                TopiaSqlScript dump = getSqlService().consume(request);
    221 
    -                executeSqlStatements(dump);
    222 
    -                migrationService.createSchemaIfNotExist();
    223 
    -                migrationService.runSchemaMigration();
    224 
    -                temporaryTopiaApplicationContext.close();
    225 
    -                File databaseFile = temporaryConfiguration.getDatabaseFile();
    226 
    -                if (!databaseFile.delete()) {
    227 
    -                    throw new IllegalStateException("could not delete " + databaseFile);
    228 
    -                }
    229 
    -            }
    230 
    -        } else {
    231 
    -            boolean importReferential = dataSourceCreateConfiguration.isImportReferential();
    232 
    -            boolean importData = dataSourceCreateConfiguration.isImportData();
    233 
    -            // si le referentiel n'est pas importé on aliment la table lastUpdateDate
    234 
    -            if (!importReferential) {
    235 
    -                insertLastUpdateDate();
    236 
    -            }
    237 
    -            boolean importStandaloneReferential = importReferential;
    238 
    -            if (importReferential && importData) {
    239 
    -                // Si on est sur la même source de données pour les deux imports, on fait tout sur la même base temporaire
    240 
    -                ObserveDataSourceConfiguration importReferentialDataSourceConfiguration = dataSourceCreateConfiguration.getImportReferentialDataSourceConfiguration();
    241 
    -                ObserveDataSourceConfiguration importDataSourceConfiguration = dataSourceCreateConfiguration.getImportDataDataSourceConfiguration();
    242 
    -                importStandaloneReferential = !importReferentialDataSourceConfiguration.equals(importDataSourceConfiguration);
    243 
    -            }
    244 
    -            boolean referentialImported = false;
    245 
    -            if (importStandaloneReferential) {
    246 
    -                log.info("Import referential.");
    247 
    -                ObserveDataSourceConfiguration importDataSourceConfiguration = dataSourceCreateConfiguration.getImportReferentialDataSourceConfiguration();
    248 
    -                Version dbVersion = Version.valueOf(getModelVersion());
    249 
    -                CreateDatabaseRequest request = CreateDatabaseRequest.builder(!dataSourceConfiguration.isLocal(), dbVersion)
    250 
    -                        .addStandaloneTables().build();
    251 
    -                TopiaSqlScript referentialDump;
    252 
    -                ObserveTopiaApplicationContext temporaryTopiaApplicationContext = null;
    253 
    -                try {
    254 
    -                    temporaryTopiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(importDataSourceConfiguration, false);
    255 
    -//                    ObserveDataSourceConnection importDataSourceConnection = serviceContext().newService(importDataSourceConfiguration, AnonymousService.class).open(importDataSourceConfiguration);
    256 
    -//                    DataSourceService dumpProducerService = serviceContext().newService(importDataSourceConnection, DataSourceService.class);
    257 
    -                    referentialDump = temporaryTopiaApplicationContext.getSqlService().consume(request);
    258 
    -                    executeSqlStatements(referentialDump);
    259 
    -                } finally {
    260 
    -                    if (!dataSourceCreateConfiguration.isLeaveOpenSource() && temporaryTopiaApplicationContext != null) {
    261 
    -                        temporaryTopiaApplicationContext.close();
    262 
    -                    }
    263 
    -                }
    264 
    -                referentialImported = true;
    265 
    -            }
    266 
    -
    267 
    -            if (importData) {
    268 
    -                ObserveDataSourceConfiguration importDataSourceConfiguration = dataSourceCreateConfiguration.getImportDataDataSourceConfiguration();
    269 
    -                Version dbVersion = Version.valueOf(getModelVersion());
    270 
    -                CreateDatabaseRequest.Builder requestBuilder = CreateDatabaseRequest.builder(!dataSourceConfiguration.isLocal(), dbVersion);
    271 
    -                if (!referentialImported) {
    272 
    -                    log.info("Get referential.");
    273 
    -                    requestBuilder.addStandaloneTables();
    274 
    -                }
    275 
    -
    276 
    -                // Récupération du dump qui contient les données
    277 
    -                Set<String> importDataIds = dataSourceCreateConfiguration.getImportDataIds();
    278 
    -                TopiaIdFactory idFactory = getTopiaIdFactory();
    279 
    -                Multimap<String, String> idsByType = ArrayListMultimap.create();
    280 
    -                for (String importDataId : importDataIds) {
    281 
    -                    Class<TopiaEntity> className = idFactory.getClassName(importDataId);
    282 
    -                    idsByType.put(className.getName(), importDataId);
    283 
    -                }
    284 
    -                log.info(String.format("Get data: %s", importDataIds));
    285 
    -                for (Map.Entry<String, Collection<String>> entry : idsByType.asMap().entrySet()) {
    286 
    -                    requestBuilder.dataIdsToAdd(entry.getKey(), Set.copyOf(entry.getValue()));
    287 
    -                }
    288 
    -                TopiaSqlScript dataDump;
    289 
    -                ObserveTopiaApplicationContext temporaryTopiaApplicationContext = null;
    290 
    -                CreateDatabaseRequest request = requestBuilder.build();
    291 
    -                try {
    292 
    -                    temporaryTopiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(importDataSourceConfiguration, false);
    293 
    -//                    ObserveDataSourceConnection importDataSourceConnection = serviceContext().newService(importDataSourceConfiguration, AnonymousService.class).open(importDataSourceConfiguration);
    294 
    -//                    DataSourceService dumpProducerService = serviceContext().newService(importDataSourceConnection, DataSourceService.class);
    295 
    -//                    dataDump = dumpProducerService.produceCreateSqlScript(request);
    296 
    -                    dataDump = temporaryTopiaApplicationContext.getSqlService().consume(request);
    297 
    -                } finally {
    298 
    -                    if (!dataSourceCreateConfiguration.isLeaveOpenSource() && temporaryTopiaApplicationContext != null) {
    299 
    -                        temporaryTopiaApplicationContext.close();
    300 
    -//                        serviceContext().newService(importDataSourceConfiguration, DataSourceService.class).close();
    301 
    -                    }
    302 
    -                }
    303 
    -                log.info(String.format("Import data%s", request.isAddStandaloneTables() ? " and referential." : "."));
    304 
    -                executeSqlStatements(dataDump);
    305 
    -            }
    306 
    -        }
    171 
    +    public void createEmpty() throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    172 
    +        DataSourceCreateHelper.create(this);
    307 173 
         }
    308 174
    309 
    -    private ObserveDataSourceConfigurationTopiaH2 createTemporaryConfiguration(File tmpDirectory, Version version) {
    310 
    -        File dbDirectory = new File(tmpDirectory, "obstuna" + UUID.randomUUID());
    311 
    -        ObserveDataSourceConfigurationTopiaH2 result = ObserveDataSourceConfigurationTopiaH2.create(
    312 
    -                "obtunaTmp", dbDirectory, "obstuna", "sa", "sa".toCharArray(), true, true, version);
    313 
    -        result.setTemporaryDirectory(tmpDirectory.toPath());
    314 
    -        return result;
    175 
    +    public void createFromDump(ObserveDataSourceConfiguration dataSourceConfiguration, TopiaSqlScript dump) throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    176 
    +        DataSourceCreateHelper.create(this, dataSourceConfiguration, dump);
    315 177 
         }
    316 178
    179 
    +    public void createAndImport(TopiaSqlScript dump, TopiaSqlScript optionalDump) throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    180 
    +        DataSourceCreateHelper.create(this, dump, optionalDump);
    181 
    +    }
    317 182 
     }

  • core/services/client/src/main/java/fr/ird/observe/services/client/AnonymousServiceClient.java
    ... ... @@ -25,30 +25,50 @@ package fr.ird.observe.services.client;
    25 25 
     import fr.ird.observe.dto.db.BabModelVersionException;
    26 26 
     import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
    27 27 
     import fr.ird.observe.dto.db.DatabaseNotFoundException;
    28 
    -import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
    29 28 
     import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
    30 29 
     import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
    31 30 
     import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
    32 31 
     import fr.ird.observe.dto.db.configuration.ObserveDataSourceConnection;
    33 32 
     import fr.ird.observe.services.ObserveServiceInitializer;
    33 
    +import org.nuiton.topia.persistence.script.TopiaSqlScript;
    34 34
    35 35 
     public class AnonymousServiceClient extends GeneratedAnonymousServiceClient {
    36 36
    37 37 
         @Override
    38 
    -    public ObserveDataSourceConnection create(ObserveDataSourceConfiguration config, DataSourceCreateConfigurationDto createConfiguration) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    39 
    -        ObserveServiceInitializer initializer = getServiceContext().getInitializer();
    40 
    -        initializer.setConfiguration(config);
    41 
    -        ObserveDataSourceConnection dataSourceConnection = super.create(config, createConfiguration);
    42 
    -        initializer.setConnection(dataSourceConnection);
    43 
    -        initializer.setConfiguration(null);
    44 
    -        return dataSourceConnection;
    38 
    +    public ObserveDataSourceConnection createEmpty(ObserveDataSourceConfiguration config) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    39 
    +        ObserveServiceInitializer initializer = start(config);
    40 
    +        ObserveDataSourceConnection dataSourceConnection = super.createEmpty(config);
    41 
    +        return end(initializer, dataSourceConnection);
    42 
    +    }
    43 
    +
    44 
    +    @Override
    45 
    +    public ObserveDataSourceConnection createFromDump(ObserveDataSourceConfiguration config, TopiaSqlScript dump) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    46 
    +        ObserveServiceInitializer initializer = start(config);
    47 
    +        ObserveDataSourceConnection dataSourceConnection = super.createFromDump(config, dump);
    48 
    +        return end(initializer, dataSourceConnection);
    49 
    +    }
    50 
    +
    51 
    +    @Override
    52 
    +    public ObserveDataSourceConnection createFromImport(ObserveDataSourceConfiguration config, TopiaSqlScript dump, TopiaSqlScript optionalDump) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    53 
    +        ObserveServiceInitializer initializer = start(config);
    54 
    +        ObserveDataSourceConnection dataSourceConnection = super.createFromImport(config, dump, optionalDump);
    55 
    +        return end(initializer, dataSourceConnection);
    45 56 
         }
    46 57
    47 58 
         @Override
    48 59 
         public ObserveDataSourceConnection open(ObserveDataSourceConfiguration config) throws DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {
    60 
    +        ObserveServiceInitializer initializer = start(config);
    61 
    +        ObserveDataSourceConnection dataSourceConnection = super.open(config);
    62 
    +        return end(initializer, dataSourceConnection);
    63 
    +    }
    64 
    +
    65 
    +    private ObserveServiceInitializer start(ObserveDataSourceConfiguration config) {
    49 66 
             ObserveServiceInitializer initializer = getServiceContext().getInitializer();
    50 67 
             initializer.setConfiguration(config);
    51 
    -        ObserveDataSourceConnection dataSourceConnection = super.open(config);
    68 
    +        return initializer;
    69 
    +    }
    70 
    +
    71 
    +    private ObserveDataSourceConnection end(ObserveServiceInitializer initializer, ObserveDataSourceConnection dataSourceConnection) {
    52 72 
             initializer.setConnection(dataSourceConnection);
    53 73 
             initializer.setConfiguration(null);
    54 74 
             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;
    25 25 
     import fr.ird.observe.dto.db.BabModelVersionException;
    26 26 
     import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
    27 27 
     import fr.ird.observe.dto.db.DatabaseNotFoundException;
    28 
    -import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
    29 28 
     import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
    30 29 
     import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
    31 30 
     import fr.ird.observe.dto.db.configuration.ObserveDataSourceConnection;
    ... ... @@ -80,11 +79,8 @@ public class AnonymousServiceClientReadTest extends GeneratedAnonymousServiceCli
    80 79
    81 80 
             //FIXME Should get an not implemented exception for this service
    82 81 
             ObserveDataSourceConfigurationRest dataSourceConfiguration = serviceClientTestMethodResource.getDataSourceConfiguration();
    83 
    -        DataSourceCreateConfigurationDto dataSourceCreateConfiguration = new DataSourceCreateConfigurationDto();
    84 
    -        dataSourceCreateConfiguration.setCanCreateEmptyDatabase(true);
    85 
    -
    86 82 
             AnonymousService service = serviceClientTestMethodResource.newService(dataSourceConfiguration, AnonymousService.class);
    87 
    -        service.create(dataSourceConfiguration, dataSourceCreateConfiguration);
    83 
    +        service.createEmpty(dataSourceConfiguration);
    88 84
    89 85 
         }
    90 86

  • 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;
    28 28 
     import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
    29 29 
     import fr.ird.observe.dto.db.DatabaseNotFoundException;
    30 30 
     import fr.ird.observe.dto.db.DatabaseVersionIsTooHighException;
    31 
    -import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
    32 31 
     import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
    33 32 
     import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
    34 33 
     import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
    ... ... @@ -45,6 +44,7 @@ import io.ultreia.java4all.util.Version;
    45 44 
     import org.apache.logging.log4j.LogManager;
    46 45 
     import org.apache.logging.log4j.Logger;
    47 46 
     import org.nuiton.topia.persistence.TopiaConfigurationExtension;
    47 
    +import org.nuiton.topia.persistence.script.TopiaSqlScript;
    48 48
    49 49 
     import java.nio.file.Path;
    50 50 
     import java.util.Set;
    ... ... @@ -107,15 +107,39 @@ public class AnonymousServiceLocalSupport extends ObserveServiceLocal implements
    107 107 
         }
    108 108
    109 109 
         @Override
    110 
    -    public ObserveDataSourceConnection create(ObserveDataSourceConfiguration config, DataSourceCreateConfigurationDto createConfiguration)
    111 
    -            throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException,
    112 
    -            BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    113 
    -        createConfiguration.validateConfiguration(getApplicationLocale());
    110 
    +    public ObserveDataSourceConnection createEmpty(ObserveDataSourceConfiguration config) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    114 111 
             setTemporaryDirectory(config);
    115 
    -        boolean initSchema = !createConfiguration.isImportDatabase();
    116 
    -        ObserveTopiaApplicationContext topiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(config, initSchema);
    112 
    +        ObserveTopiaApplicationContext topiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(config, true);
    117 113 
             try {
    118 
    -            topiaApplicationContext.create(config, createConfiguration);
    114 
    +            topiaApplicationContext.createEmpty();
    115 
    +        } catch (Exception e) {
    116 
    +            close(config, topiaApplicationContext);
    117 
    +            throw e;
    118 
    +        }
    119 
    +        ObserveDataSourceInformation dataSourceInformation = getDataSourceInformation(config, topiaApplicationContext.getConfiguration(), false);
    120 
    +        return config.toConnection(topiaApplicationContext.getAuthenticationToken(), dataSourceInformation);
    121 
    +    }
    122 
    +
    123 
    +    @Override
    124 
    +    public ObserveDataSourceConnection createFromDump(ObserveDataSourceConfiguration config, TopiaSqlScript dump) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    125 
    +        setTemporaryDirectory(config);
    126 
    +        ObserveTopiaApplicationContext topiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(config, false);
    127 
    +        try {
    128 
    +            topiaApplicationContext.createFromDump(config, dump);
    129 
    +        } catch (Exception e) {
    130 
    +            close(config, topiaApplicationContext);
    131 
    +            throw e;
    132 
    +        }
    133 
    +        ObserveDataSourceInformation dataSourceInformation = getDataSourceInformation(config, topiaApplicationContext.getConfiguration(), false);
    134 
    +        return config.toConnection(topiaApplicationContext.getAuthenticationToken(), dataSourceInformation);
    135 
    +    }
    136 
    +
    137 
    +    @Override
    138 
    +    public ObserveDataSourceConnection createFromImport(ObserveDataSourceConfiguration config, TopiaSqlScript dump, TopiaSqlScript optionalDump) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    139 
    +        setTemporaryDirectory(config);
    140 
    +        ObserveTopiaApplicationContext topiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(config, false);
    141 
    +        try {
    142 
    +            topiaApplicationContext.createAndImport(dump, optionalDump);
    119 143 
             } catch (Exception e) {
    120 144 
                 close(config, topiaApplicationContext);
    121 145 
                 throw e;
    ... ... @@ -192,127 +216,6 @@ public class AnonymousServiceLocalSupport extends ObserveServiceLocal implements
    192 216 
             return dataSourceInformation;
    193 217 
         }
    194 218
    195 
    -//    private void create0(ObserveTopiaApplicationContext topiaApplicationContext, ObserveDataSourceConfiguration dataSourceConfiguration, DataSourceCreateConfigurationDto dataSourceCreateConfiguration) throws BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    196 
    -//        log.debug(String.format("Create topia application context: %s", topiaApplicationContext));
    197 
    -//        if (dataSourceCreateConfiguration.isImportDatabase()) {
    198 
    -//            log.info("Create new database from a script.");
    199 
    -//            TopiaSqlScript importDatabase = dataSourceCreateConfiguration.getImportDatabase();
    200 
    -//            boolean migrate = dataSourceCreateConfiguration.isMigrate();
    201 
    -//            TopiaMigrationService migrationService = topiaApplicationContext.getMigrationService();
    202 
    -//            if (dataSourceConfiguration.isLocal()) {
    203 
    -//                topiaApplicationContext.executeSqlStatements(importDatabase);
    204 
    -//                if (migrate) {
    205 
    -//                    migrationService.createSchemaIfNotExist();
    206 
    -//                    migrationService.runSchemaMigration();
    207 
    -//                }
    208 
    -//            } else { // base postgres
    209 
    -//                // on realise les import dans un base H2 temporaire
    210 
    -//                File tmpDir;
    211 
    -//                try {
    212 
    -//                    Path temporaryDirectory = dataSourceConfiguration.getTemporaryDirectory();
    213 
    -//                    tmpDir = Files.createTempDirectory(temporaryDirectory, "obstuna").toFile();
    214 
    -//                } catch (IOException e) {
    215 
    -//                    throw new IllegalStateException("could not create temporary directory ", e);
    216 
    -//                }
    217 
    -//                ObserveDataSourceConfigurationTopiaH2 temporaryConfiguration = createTemporaryConfiguration(tmpDir, dataSourceConfiguration.getModelVersion());
    218 
    -//                ObserveTopiaApplicationContext temporaryTopiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext(temporaryConfiguration, false);
    219 
    -//                temporaryTopiaApplicationContext.executeSqlStatements(importDatabase);
    220 
    -//                if (migrate) {
    221 
    -//                    temporaryTopiaApplicationContext.getMigrationService().createSchemaIfNotExist();
    222 
    -//                    temporaryTopiaApplicationContext.getMigrationService().runSchemaMigration();
    223 
    -//                }
    224 
    -//                DataSourceService dumpProducerService = serviceContext().newService(temporaryConfiguration, DataSourceService.class);
    225 
    -//                CreateDatabaseRequest request = CreateDatabaseRequest.of(true, dataSourceConfiguration.getModelVersion()).addSchema().addStandaloneTables().addAllData();
    226 
    -//                TopiaSqlScript dump = dumpProducerService.produceCreateSqlScript(request);
    227 
    -//                topiaApplicationContext.executeSqlStatements(dump);
    228 
    -//                migrationService.createSchemaIfNotExist();
    229 
    -//                migrationService.runSchemaMigration();
    230 
    -//                temporaryTopiaApplicationContext.close();
    231 
    -//                File databaseFile = temporaryConfiguration.getDatabaseFile();
    232 
    -//                if (!databaseFile.delete()) {
    233 
    -//                    throw new IllegalStateException("could not delete " + databaseFile);
    234 
    -//                }
    235 
    -//            }
    236 
    -//        } else {
    237 
    -//            boolean importReferential = dataSourceCreateConfiguration.isImportReferential();
    238 
    -//            boolean importData = dataSourceCreateConfiguration.isImportData();
    239 
    -//            // si le referentiel n'est pas importé on aliment la table lastUpdateDate
    240 
    -//            if (!importReferential) {
    241 
    -//                topiaApplicationContext.insertLastUpdateDate();
    242 
    -//            }
    243 
    -//            boolean importStandaloneReferential = importReferential;
    244 
    -//            if (importReferential && importData) {
    245 
    -//                // Si on est sur la même source de données pour les deux imports, on fait tout sur la même base temporaire
    246 
    -//                ObserveDataSourceConfiguration importReferentialDataSourceConfiguration = dataSourceCreateConfiguration.getImportReferentialDataSourceConfiguration();
    247 
    -//                ObserveDataSourceConfiguration importDataSourceConfiguration = dataSourceCreateConfiguration.getImportDataDataSourceConfiguration();
    248 
    -//                importStandaloneReferential = !importReferentialDataSourceConfiguration.equals(importDataSourceConfiguration);
    249 
    -//            }
    250 
    -//            boolean referentialImported = false;
    251 
    -//            if (importStandaloneReferential) {
    252 
    -//                log.info("Import referential.");
    253 
    -//                ObserveDataSourceConfiguration importDataSourceConfiguration = dataSourceCreateConfiguration.getImportReferentialDataSourceConfiguration();
    254 
    -//                Version dbVersion = Version.valueOf(topiaApplicationContext.getModelVersion());
    255 
    -//                CreateDatabaseRequest request = CreateDatabaseRequest.of(!dataSourceConfiguration.isLocal(), dbVersion)
    256 
    -//                        .addStandaloneTables();
    257 
    -//                TopiaSqlScript referentialDump;
    258 
    -//                try {
    259 
    -//                    ObserveDataSourceConnection importDataSourceConnection = serviceContext().newService(importDataSourceConfiguration, AnonymousService.class).open(importDataSourceConfiguration);
    260 
    -//                    DataSourceService dumpProducerService = serviceContext().newService(importDataSourceConnection, DataSourceService.class);
    261 
    -//                    referentialDump = dumpProducerService.produceCreateSqlScript(request);
    262 
    -//                    topiaApplicationContext.executeSqlStatements(referentialDump);
    263 
    -//                } finally {
    264 
    -//                    if (!dataSourceCreateConfiguration.isLeaveOpenSource()) {
    265 
    -//                        serviceContext().newService(importDataSourceConfiguration, DataSourceService.class).close();
    266 
    -//                    }
    267 
    -//                }
    268 
    -//                referentialImported = true;
    269 
    -//            }
    270 
    -//
    271 
    -//            if (importData) {
    272 
    -//                ObserveDataSourceConfiguration importDataSourceConfiguration = dataSourceCreateConfiguration.getImportDataDataSourceConfiguration();
    273 
    -//                Version dbVersion = Version.valueOf(topiaApplicationContext.getModelVersion());
    274 
    -//                CreateDatabaseRequest request = CreateDatabaseRequest.of(!dataSourceConfiguration.isLocal(), dbVersion);
    275 
    -//                if (!referentialImported) {
    276 
    -//                    log.info("Get referential.");
    277 
    -//                    request.addStandaloneTables();
    278 
    -//                }
    279 
    -//
    280 
    -//                // Récupération du dump qui contient les données
    281 
    -//                Set<String> importDataIds = dataSourceCreateConfiguration.getImportDataIds();
    282 
    -//                TopiaIdFactory idFactory = getTopiaPersistenceContext().getIdFactory();
    283 
    -//                Multimap<String, String> idsByType = ArrayListMultimap.create();
    284 
    -//                for (String importDataId : importDataIds) {
    285 
    -//                    Class<TopiaEntity> className = idFactory.getClassName(importDataId);
    286 
    -//                    idsByType.put(className.getName(), importDataId);
    287 
    -//                }
    288 
    -//                log.info(String.format("Get data: %s", importDataIds));
    289 
    -//                for (Map.Entry<String, Collection<String>> entry : idsByType.asMap().entrySet()) {
    290 
    -//                    request.dataIdsToAdd(entry.getKey(), Set.copyOf(entry.getValue()));
    291 
    -//                }
    292 
    -//                TopiaSqlScript dataDump;
    293 
    -//                try {
    294 
    -//                    ObserveDataSourceConnection importDataSourceConnection = serviceContext().newService(importDataSourceConfiguration, AnonymousService.class).open(importDataSourceConfiguration);
    295 
    -//                    DataSourceService dumpProducerService = serviceContext().newService(importDataSourceConnection, DataSourceService.class);
    296 
    -//                    dataDump = dumpProducerService.produceCreateSqlScript(request);
    297 
    -//                } finally {
    298 
    -//                    if (!dataSourceCreateConfiguration.isLeaveOpenSource()) {
    299 
    -//                        serviceContext().newService(importDataSourceConfiguration, DataSourceService.class).close();
    300 
    -//                    }
    301 
    -//                }
    302 
    -//                log.info(String.format("Import data%s", request.isAddStandaloneTables() ? " and referential." : "."));
    303 
    -//                topiaApplicationContext.executeSqlStatements(dataDump);
    304 
    -//            }
    305 
    -//        }
    306 
    -//    }
    307 
    -//
    308 
    -//    private ObserveDataSourceConfigurationTopiaH2 createTemporaryConfiguration(File tmpDirectory, Version version) {
    309 
    -//        File dbDirectory = new File(tmpDirectory, "obstuna" + UUID.randomUUID());
    310 
    -//        ObserveDataSourceConfigurationTopiaH2 result = ObserveDataSourceConfigurationTopiaH2.create(
    311 
    -//                "obtunaTmp", dbDirectory, "obstuna", "sa", "sa".toCharArray(), true, true, version);
    312 
    -//        result.setTemporaryDirectory(tmpDirectory.toPath());
    313 
    -//        return result;
    314 
    -//    }
    315 
    -
    316 219 
         private ObserveDataSourceInformation getDataSourceInformation(ObserveDataSourceConfiguration dataSourceConfiguration, TopiaConfigurationExtension topiaConfiguration, boolean canBeEmpty) throws DatabaseConnexionNotAuthorizedException {
    317 220 
             try {
    318 221 
                 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;
    26 26 
     import fr.ird.observe.dto.db.DataSourceValidationMode;
    27 27 
     import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
    28 28 
     import fr.ird.observe.dto.db.DatabaseNotFoundException;
    29 
    -import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
    30 29 
     import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
    31 30 
     import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
    32 31 
     import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
    ... ... @@ -66,6 +65,7 @@ public class LocalTestClassResource extends TestClassResourceSupport {
    66 65 
         private final ObserveServiceFactoryLocal serviceFactory;
    67 66
    68 67 
         ObserveServiceInitializerConfig serviceInitializerConfig;
    68 
    +    private boolean generateNow;
    69 69
    70 70 
         public LocalTestClassResource() {
    71 71 
             this(DatabaseClassifier.DEFAULT);
    ... ... @@ -105,11 +105,8 @@ public class LocalTestClassResource extends TestClassResourceSupport {
    105 105 
                 AnonymousService service = newService(sharedDatabaseConfiguration, AnonymousService.class);
    106 106
    107 107 
                 try {
    108 
    -                DataSourceCreateConfigurationDto createConfiguration = new DataSourceCreateConfigurationDto();
    109 108 
                     TopiaSqlScript script = getDataSourcesForTestManager().getCache(dbVersion, dbName);
    110 
    -                createConfiguration.setImportDatabase(script);
    111 
    -                createConfiguration.setMigrate(false);
    112 
    -                service.create(sharedDatabaseConfiguration, createConfiguration);
    109 
    +                service.createFromDump(sharedDatabaseConfiguration, script);
    113 110 
                 } finally {
    114 111 
                     newService(sharedDatabaseConfiguration, DataSourceService.class).close();
    115 112 
                 }
    ... ... @@ -134,15 +131,13 @@ public class LocalTestClassResource extends TestClassResourceSupport {
    134 131 
             ObserveServiceInitializer serviceInitializer = new ObserveServiceInitializer(getServiceInitializerConfig(), dataSourceConfiguration, null) {
    135 132 
                 @Override
    136 133 
                 public Date now() {
    137 
    -                return generateNow?new Date():ObserveFixtures.DATE;
    134 
    +                return generateNow ? new Date() : ObserveFixtures.DATE;
    138 135 
                 }
    139 136 
             };
    140 137 
             serviceInitializer.setConfiguration(dataSourceConfiguration);
    141 138 
             return serviceFactory.newService(serviceInitializer, serviceType);
    142 139 
         }
    143 140
    144 
    -    private boolean generateNow;
    145 
    -
    146 141 
         public boolean isGenerateNow() {
    147 142 
             return generateNow;
    148 143 
         }
    ... ... @@ -152,10 +147,10 @@ public class LocalTestClassResource extends TestClassResourceSupport {
    152 147 
         }
    153 148
    154 149 
         public <S extends ObserveService> S newService(ObserveDataSourceConnection dataSourceConnection, Class<S> serviceType) {
    155 
    -        ObserveServiceInitializer serviceInitializer = new ObserveServiceInitializer(getServiceInitializerConfig(), null, dataSourceConnection){
    150 
    +        ObserveServiceInitializer serviceInitializer = new ObserveServiceInitializer(getServiceInitializerConfig(), null, dataSourceConnection) {
    156 151 
                 @Override
    157 152 
                 public Date now() {
    158 
    -                return generateNow?new Date():ObserveFixtures.DATE;
    153 
    +                return generateNow ? new Date() : ObserveFixtures.DATE;
    159 154 
                 }
    160 155 
             };
    161 156 
             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
    72 72 
         }
    73 73
    74 74 
         @Override
    75 
    -    public void create(fr.ird.observe.services.ObserveServicesProvider servicesProvider, AnonymousService service) {
    75 
    +    public void createEmpty(fr.ird.observe.services.ObserveServicesProvider servicesProvider, AnonymousService service) {
    76 76 
             // FIXME:Test Remove super method invocation and implements fixture
    77 77 
             // actual = service.create(getProperty("create.id"));
    78 78 
             // Assert.assertNotNull(actual);
    79 
    -        super.create(servicesProvider, service);
    79 
    +        super.createEmpty(servicesProvider, service);
    80 
    +    }
    81 
    +
    82 
    +    @Override
    83 
    +    public void createFromDump(ObserveServicesProvider servicesProvider, AnonymousService service) {
    84 
    +        //FIXME
    85 
    +        super.createFromDump(servicesProvider, service);
    86 
    +    }
    87 
    +
    88 
    +    @Override
    89 
    +    public void createFromImport(ObserveServicesProvider servicesProvider, AnonymousService service) {
    90 
    +        //FIXME
    91 
    +        super.createFromImport(servicesProvider, service);
    80 92 
         }
    81 93
    82 94 
         @Override

  • pom.xml
    ... ... @@ -23,7 +23,7 @@
    23 23 
       <parent>
    24 24 
         <groupId>io.ultreia.maven</groupId>
    25 25 
         <artifactId>pom</artifactId>
    26 
    -    <version>2022.36</version>
    26 
    +    <version>2022.37</version>
    27 27 
       </parent>
    28 28 
       <groupId>fr.ird.observe</groupId>
    29 29 
       <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
    25 25 
     GET    /AnonymousService/applySecurity                                      AnonymousServiceRestApi.applySecurity
    26 26 
     GET    /AnonymousService/checkCanConnect                                    AnonymousServiceRestApi.checkCanConnect
    27 27 
     GET    /AnonymousService/checkCanConnectOrBeEmpty                           AnonymousServiceRestApi.checkCanConnectOrBeEmpty
    28 
    -GET    /AnonymousService/create                                             AnonymousServiceRestApi.create
    28 
    +POST   /AnonymousService/createEmpty                                        AnonymousServiceRestApi.createEmpty
    29 
    +POST   /AnonymousService/createFromDump                                     AnonymousServiceRestApi.createFromDump
    30 
    +POST   /AnonymousService/createFromImport                                   AnonymousServiceRestApi.createFromImport
    29 31 
     GET    /AnonymousService/generateHomeId                                     AnonymousServiceRestApi.generateHomeId
    30 32 
     GET    /AnonymousService/getModelVersion                                    AnonymousServiceRestApi.getModelVersion
    31 33 
     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;
    28 28 
     import fr.ird.observe.server.configuration.ServerConfig;
    29 29 
     import fr.ird.observe.server.configuration.ServerConfigApplicationComponent;
    30 30 
     import fr.ird.observe.server.configuration.ServerConfigFinder;
    31 
    +import fr.ird.observe.server.converter.JsonAwareDtoConverter;
    31 32 
     import fr.ird.observe.server.security.ObserveWebSecurityApplicationContext;
    32 33 
     import fr.ird.observe.services.ObserveServiceFactory;
    33 34 
     import fr.ird.observe.services.ObserveServiceInitializer;
    ... ... @@ -37,9 +38,11 @@ import fr.ird.observe.services.service.ObserveService;
    37 38 
     import fr.ird.observe.spi.json.DtoGsonSupplier;
    38 39 
     import io.ultreia.java4all.application.context.ApplicationContext;
    39 40 
     import io.ultreia.java4all.util.Version;
    41 
    +import org.apache.commons.beanutils.ConvertUtils;
    40 42 
     import org.apache.logging.log4j.LogManager;
    41 43 
     import org.apache.logging.log4j.Logger;
    42 44 
     import org.debux.webmotion.server.call.HttpContext;
    45 
    +import org.nuiton.topia.persistence.script.TopiaSqlScript;
    43 46
    44 47 
     import javax.servlet.ServletContext;
    45 48 
     import java.io.Closeable;
    ... ... @@ -125,6 +128,9 @@ public class ObserveWebApplicationContext extends ApplicationContext {
    125 128 
                 closeDeleteTemporaryFilesTimer();
    126 129 
             }
    127 130 
             deleteTemporaryFilesTimer = CleanTemporaryFilesTask.create(getApplicationConfiguration());
    131 
    +
    132 
    +        JsonAwareDtoConverter<TopiaSqlScript> converter = new JsonAwareDtoConverter<>(getGsonSupplier().get(), TopiaSqlScript.class);
    133 
    +        ConvertUtils.register(converter, TopiaSqlScript.class);
    128 134 
         }
    129 135
    130 136 
         @Override

  • server/core/src/main/java/fr/ird/observe/server/controller/AnonymousServiceRestApi.java
    ... ... @@ -26,7 +26,6 @@ import fr.ird.observe.dto.db.BabModelVersionException;
    26 26 
     import fr.ird.observe.dto.db.DataSourceUserDto;
    27 27 
     import fr.ird.observe.dto.db.DatabaseConnexionNotAuthorizedException;
    28 28 
     import fr.ird.observe.dto.db.DatabaseNotFoundException;
    29 
    -import fr.ird.observe.dto.db.configuration.DataSourceCreateConfigurationDto;
    30 29 
     import fr.ird.observe.dto.db.configuration.DataSourceCreateWithNoReferentialImportException;
    31 30 
     import fr.ird.observe.dto.db.configuration.IncompatibleDataSourceCreateConfigurationException;
    32 31 
     import fr.ird.observe.dto.db.configuration.ObserveDataSourceConfiguration;
    ... ... @@ -38,6 +37,7 @@ import fr.ird.observe.services.service.AnonymousService;
    38 37 
     import io.ultreia.java4all.util.Version;
    39 38 
     import org.apache.logging.log4j.LogManager;
    40 39 
     import org.apache.logging.log4j.Logger;
    40 
    +import org.nuiton.topia.persistence.script.TopiaSqlScript;
    41 41
    42 42 
     import java.lang.reflect.Method;
    43 43 
     import java.util.LinkedHashMap;
    ... ... @@ -49,6 +49,12 @@ public class AnonymousServiceRestApi extends GeneratedAnonymousServiceRestApi {
    49 49
    50 50 
         private static final Logger log = LogManager.getLogger(AnonymousServiceRestApi.class);
    51 51
    52 
    +    @Override
    53 
    +    public ObserveDataSourceInformation checkCanConnectOrBeEmpty(ObserveDataSourceConfiguration config) throws DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {
    54 
    +        ObserveWebUserSession session = getRequestContext().getConfigurationSession(config);
    55 
    +        return getService().checkCanConnectOrBeEmpty(session.getConfiguration());
    56 
    +    }
    57 
    +
    52 58 
         @Override
    53 59 
         public ObserveDataSourceInformation checkCanConnect(ObserveDataSourceConfiguration config) throws DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException, BabModelVersionException {
    54 60 
             ObserveWebUserSession session = getRequestContext().getConfigurationSession(config);
    ... ... @@ -56,11 +62,25 @@ public class AnonymousServiceRestApi extends GeneratedAnonymousServiceRestApi {
    56 62 
         }
    57 63
    58 64 
         @Override
    59 
    -    public ObserveDataSourceConnection create(ObserveDataSourceConfiguration config, DataSourceCreateConfigurationDto createConfiguration)
    60 
    -            throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException,
    61 
    -            DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {
    65 
    +    public ObserveDataSourceConnection createEmpty(ObserveDataSourceConfiguration config) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    66 
    +        ObserveWebUserSession configurationSession = getRequestContext().getConfigurationSession(config);
    67 
    +        ObserveDataSourceConnection connection = getService().createEmpty(configurationSession.getConfiguration());
    68 
    +        ObserveWebUserSession authenticatedSession = getSecurityApplicationContext().registerAuthenticatedSession(configurationSession, connection);
    69 
    +        return authenticatedSession.toRestConnection(config);
    70 
    +    }
    71 
    +
    72 
    +    @Override
    73 
    +    public ObserveDataSourceConnection createFromDump(ObserveDataSourceConfiguration config, TopiaSqlScript dump) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    74 
    +        ObserveWebUserSession configurationSession = getRequestContext().getConfigurationSession(config);
    75 
    +        ObserveDataSourceConnection connection = getService().createFromDump(configurationSession.getConfiguration(), dump);
    76 
    +        ObserveWebUserSession authenticatedSession = getSecurityApplicationContext().registerAuthenticatedSession(configurationSession, connection);
    77 
    +        return authenticatedSession.toRestConnection(config);
    78 
    +    }
    79 
    +
    80 
    +    @Override
    81 
    +    public ObserveDataSourceConnection createFromImport(ObserveDataSourceConfiguration config, TopiaSqlScript dump, TopiaSqlScript optionalDump) throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException, BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {
    62 82 
             ObserveWebUserSession configurationSession = getRequestContext().getConfigurationSession(config);
    63 
    -        ObserveDataSourceConnection connection = getService().create(configurationSession.getConfiguration(), createConfiguration);
    83 
    +        ObserveDataSourceConnection connection = getService().createFromImport(configurationSession.getConfiguration(), dump,optionalDump );
    64 84 
             ObserveWebUserSession authenticatedSession = getSecurityApplicationContext().registerAuthenticatedSession(configurationSession, connection);
    65 85 
             return authenticatedSession.toRestConnection(config);
    66 86 
         }

  • server/core/src/main/java/fr/ird/observe/server/converter/JsonAwareDtoConverter.java
    ... ... @@ -23,31 +23,32 @@ package fr.ird.observe.server.converter;
    23 23 
      */
    24 24
    25 25 
     import com.google.gson.Gson;
    26 
    -import fr.ird.observe.dto.ObserveDto;
    26 
    +import io.ultreia.java4all.http.json.JsonAware;
    27 27 
     import org.apache.commons.beanutils.converters.AbstractConverter;
    28 28 
     import org.apache.logging.log4j.LogManager;
    29 29 
     import org.apache.logging.log4j.Logger;
    30 
    -import io.ultreia.java4all.http.json.JsonAware;
    31 30
    32 31 
     /**
    33 32 
      * Created on 07/09/15.
    34 33 
      *
    35 34 
      * @author Tony Chemit - dev@tchemit.fr
    36 35 
      */
    37 
    -public class JsonAwareDtoConverter extends AbstractConverter {
    36 
    +public class JsonAwareDtoConverter<TT extends JsonAware> extends AbstractConverter {
    38 37
    39 38 
         private static final Logger log = LogManager.getLogger(JsonAwareDtoConverter.class);
    40 39
    41 40 
         protected final Gson gson;
    41 
    +    private final Class<TT> type;
    42 42
    43 
    -    public JsonAwareDtoConverter(Gson gson) {
    43 
    +    public JsonAwareDtoConverter(Gson gson, Class<TT> type) {
    44 44 
             this.gson = gson;
    45 
    +        this.type = type;
    45 46 
         }
    46 47
    47 48 
         @Override
    48 49 
         protected <T> T convertToType(Class<T> type, Object value) {
    49 50 
             T observeDto;
    50 
    -        if (JsonAware.class.isAssignableFrom(type)) {
    51 
    +        if (type.isAssignableFrom(type)) {
    51 52 
                 String gsonContent = value.toString();
    52 53 
                 observeDto = gson.fromJson(gsonContent, type);
    53 54 
                 log.info("convert observeDto: " + observeDto);
    ... ... @@ -59,7 +60,7 @@ public class JsonAwareDtoConverter extends AbstractConverter {
    59 60 
         }
    60 61
    61 62 
         @Override
    62 
    -    protected Class<?> getDefaultType() {
    63 
    -        return ObserveDto.class;
    63 
    +    protected Class<TT> getDefaultType() {
    64 
    +        return type;
    64 65 
         }
    65 66 
     }

    • —
    View it on GitLab.
    You're receiving this email because of your account on gitlab.com. If you'd like to receive fewer emails, you can adjust your notification settings.