GitLab

at 2020-05-21T14:20:04+02:00

First flush of better local data source error handling at closing, or loading

 transient = true

 final = true

+[option feedBackDirectory]

+description = observe.config.feedBackDirectory.description

+key = feedBack.directory

+type = file

+defaultValue = ${data.directory}/feedback

+transient = true

+final = true

+

 [option resourcesDirectory]

 description = observe.config.defaultResourcesDirectory.description

 key = resources.directory

 observe.config.defaultReportDirectory.description

 observe.config.defaultResourcesDirectory.description

 observe.config.defaultValidationReportDirectory.description

+observe.config.feedBackDirectory.description

 observe.config.h2.can.editReferential.description

 observe.config.h2.can.migrate.description

 observe.config.h2.login.description

     private static final Logger log = LogManager.getLogger(ClientConfig.class);

     /** le pattern du fichier de sauvegarde d'une base locale */

     private static final String BACKUP_DB_PATTERN = "observe-v%1$s-%2$tF--%2$tk-%2$tM-%2$tS.sql.gz";

+    private static final String FEED_BACK_PATTERN = "observe-v%1$s-feedback-%2$tF--%2$tk-%2$tM-%2$tS.zip";

     private static final String APPLICATION_VERSION = "application.version";

     private static final String VERSION = "version";

     public File newBackupDataFile() {

         return new File(getBackupDirectory(), String.format(BACKUP_DB_PATTERN, getBuildVersion().toString().replaceAll("\\.","_"), new Date()));

     }

+    public File newFeedBackFile() {

+        return new File(getFeedBackDirectory(), String.format(FEED_BACK_PATTERN, getBuildVersion().toString().replaceAll("\\.","_"), new Date()));

+    }

     public void saveForUser() {

         log.info(t("observe.message.save.configuration", get().getUserConfigFile()));

 import com.google.common.collect.ImmutableList;

 import com.google.common.collect.ImmutableSet;

 import fr.ird.observe.client.configuration.ClientConfig;

+import fr.ird.observe.client.configuration.WithClientConfig;

 import fr.ird.observe.client.datasource.api.event.ObserveSwingDataSourceEvent;

 import fr.ird.observe.client.datasource.api.event.ObserveSwingDataSourceListener;

 import fr.ird.observe.client.datasource.dcp.FloatingObjectPresetsManager;

+import fr.ird.observe.client.util.UIHelper;

 import fr.ird.observe.dto.IdDto;

 import fr.ird.observe.dto.ObserveUtil;

 import fr.ird.observe.dto.data.ps.dcp.FloatingObjectPreset;

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

 import fr.ird.observe.services.service.referential.ObserveReferentialCache;

 import fr.ird.observe.services.service.referential.ReferentialService;

+import fr.ird.observe.services.service.sql.AddSqlScriptProducerRequest;

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

 import fr.ird.observe.spi.map.ImmutableSetDtoMap;

 import fr.ird.observe.spi.map.ImmutableSetStringMap;

 import fr.ird.observe.spi.map.ImmutableTypedMap;

 import org.apache.logging.log4j.LogManager;

 import org.apache.logging.log4j.Logger;

 import org.nuiton.jaxx.runtime.swing.SwingUtil;

+import org.nuiton.topia.persistence.script.TopiaSqlScript;

 import org.nuiton.version.Version;

 import javax.swing.BoundedRangeModel;

 import javax.swing.event.EventListenerList;

 import java.io.File;

 import java.io.IOException;

+import java.nio.file.Files;

 import java.nio.file.Path;

 import java.util.Iterator;

 import java.util.Locale;

 import java.util.Map;

+import java.util.Objects;

 import java.util.Set;

 import java.util.TreeMap;

 import java.util.TreeSet;

  */

 @GenerateJavaBeanDefinition

 @GenerateTemplate(template = "dataSourceInformation.ftl")

-public class ObserveSwingDataSource extends ObserveServicesProviderSupport {

+public class ObserveSwingDataSource extends ObserveServicesProviderSupport implements WithClientConfig {

     private static final Logger log = LogManager.getLogger(ObserveSwingDataSource.class);

     private final ObserveReferentialCache referentialCache;

     private final ObserveServicesProvider servicesProvider;

     private final Icon icon;

+    private final ObserveServiceMainFactory serviceFactory;

     private ObserveDataSourceConnection connection;

     private BoundedRangeModel progressModel;

     // indique si l'utilisateur connecté est le propriétaire de la base

     private boolean owner;

     private boolean superUser;

-    private final ObserveServiceMainFactory serviceFactory;

     public ObserveSwingDataSource(ClientConfig config, ObserveServiceMainFactory serviceFactory, ObserveDataSourceConfiguration configuration) {

         this.config = config;

                         JOptionPane.WARNING_MESSAGE);

                 if (answer == JOptionPane.YES_OPTION) {

-

                     DataSourceService dataSourceService = servicesProvider.getDataSourceService();

-

-

-                    if (log.isInfoEnabled()) {

-                        log.info("Migrate data source " + getLabel() + " in " + dbVersion + " to " + targetVersion);

-                    }

-

+                    log.info(String.format("Migrate data source %s in %s to %s", getLabel(), dbVersion, targetVersion));

                     dataSourceService.migrateData(getConfiguration());

                 }

             }

         this.superUser = superUser;

     }

-    public void addObserveSwingDataSourceListener(ObserveSwingDataSourceListener listener) {

-        listenerList.add(ObserveSwingDataSourceListener.class, listener);

+    /**

+     * Effectue une sauvegarde de la base locale vers le fichier choisi.

+     *

+     * @param dst le fichier de sauvegarde

+     */

+    public void backupLocalDatabase(Path dst) {

+        Objects.requireNonNull(dst, "file where to backup can not be null");

+        log.info(String.format("Do backup of %s into: %s", this, dst));

+        try {

+            Files.deleteIfExists(dst);

+            AddSqlScriptProducerRequest request = AddSqlScriptProducerRequest.forH2(getClientConfig().getModelVersion()).addSchema().addReferential().addAllData();

+            SqlScriptProducerService dumpProducerService = getSqlScriptProducerService();

+            TopiaSqlScript dataDump = dumpProducerService.produceAddSqlScript(request);

+            dataDump.copy(dst);

+        } catch (Exception e) {

+            UIHelper.handlingError(e);

+        }

     }

-    private ObserveSwingDataSourceListener[] getObserveSwingDataSourceListener() {

-        return listenerList.getListeners(ObserveSwingDataSourceListener.class);

+    public void addObserveSwingDataSourceListener(ObserveSwingDataSourceListener listener) {

+        listenerList.add(ObserveSwingDataSourceListener.class, listener);

     }

     public void removeObserveSwingDataSourceListener(ObserveSwingDataSourceListener listener) {

         listenerList.remove(ObserveSwingDataSourceListener.class, listener);

     }

+    private ObserveSwingDataSourceListener[] getObserveSwingDataSourceListener() {

+        return listenerList.getListeners(ObserveSwingDataSourceListener.class);

+    }

+

     private void fireNewMessage(String message) {

         fireNewMessage(message, ObserveSwingDataSourceEvent.MessageLevel.INFO);

     }

             missingIds.removeAll(resultIds);

             log.warn(String.format("Remove preset: %s (%s id(s) not found in database).", preset.getLabel(config.getReferentialLocale()), missingIds));

         }

-        progressModel.setExtent(1);

+        progressModel.setValue(progressModel.getValue() + 1);

     }

     public void setCanMigrate(ClientConfig appConfig) {

+package fr.ird.observe.client.util.action;

+

+/*-

+ * #%L

+ * ObServe :: Client Core

+ * %%

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

+ * %%

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

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

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

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

+ *

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

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

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

+ * GNU General Public License for more details.

+ *

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

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

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

+ * #L%

+ */

+

+/**

+ * Describe an atomic action state.

+ *

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

+ * @since 8.0

+ */

+public enum ActionState {

+    /**

+     * When action is skipped.

+     */

+    SKIP,

+    /**

+     * When action is pending.

+     */

+    PENDING,

+    /**

+     * When action is done.

+     */

+    DONE,

+    /**

+     * When action has failed.

+     */

+    FAILED;

+

+    public boolean notSkip() {

+        return this != SKIP;

+    }

+

+    public boolean skip() {

+        return this == SKIP;

+    }

+

+    public boolean success() {

+        return this == DONE;

+    }

+

+    public boolean fail() {

+        return this == FAILED;

+    }

+

+    public boolean pending() {

+        return this == PENDING;

+    }

+

+    public static ActionState failIfPreviousFail(ActionState initialState, ActionState... previousStates) {

+        if (initialState.skip()) {

+            // If we are on skip state, then nothing to do, so previous states are not used

+            return initialState;

+        }

+        for (ActionState previousState : previousStates) {

+            if (previousState.fail()) {

+                // One of previous state has failed, so this will automatic failed

+                return FAILED;

+            }

+        }

+        // Nothing was changed from previous state

+        return initialState;

+    }

+

+    public static ActionState pendingIfPreviousFail(ActionState initialState, ActionState... previousStates) {

+        if (initialState.pending()) {

+            // If we are on pending state, then already mark to do it, so previous states are not used

+            return initialState;

+        }

+        for (ActionState previousState : previousStates) {

+            if (previousState.fail()) {

+                // One of previous state has failed, so this will automatic failed

+                return PENDING;

+            }

+        }

+        // Nothing was changed from previous state

+        return initialState;

+    }

+

+

+}
       <artifactId>persistence</artifactId>

     </dependency>

+    <dependency>

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

+      <artifactId>config-api</artifactId>

+    </dependency>

+

     <dependency>

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

       <artifactId>application-context</artifactId>

 observe.choice.cancel

 observe.choice.continue

 observe.choice.doNotSave

+observe.choice.generateFeedBack

 observe.choice.quit

 observe.choice.replace

 observe.choice.save

 observe.entity.message.reading

 observe.entity.message.updating

 observe.error.storage.could.not.backup.unsane.local.db

+observe.error.storage.could.not.close.local.data.source.message

+observe.error.storage.could.not.close.local.data.source.title

 observe.error.storage.could.not.load.local.db

+observe.error.storage.could.not.open.local.data.source.title

 observe.menu.navigation.action.noAction

 observe.message.db.closed

 observe.message.db.loaded

 class MainDataSourceListener extends ObserveSwingDataSourceListenerAdapter implements WithObserveDataSourcesManager, WithClientConfig, WithClientUIContext {

     private final ObserveDataSourcesManager dataSourcesManager;

-    private final ClientConfig config;

     private final DataSourceEditorBodyContent bodyContent;

     public MainDataSourceListener(DataSourceEditorBodyContent bodyContent) {

         this.bodyContent = bodyContent;

         this.dataSourcesManager = getObserveDataSourcesManager();

-        this.config = getClientConfig();

     }

     @Override

     @Override

     public void onOpened(ObserveSwingDataSourceEvent event) {

         ObserveSwingDataSource source = event.getSource();

-        if (source.isLocal()) {

-            config.setLocalStorageExist(true);

-        }

         bodyContent.setDataSource(source);

     }

  */

 import fr.ird.observe.client.constants.DbMode;

-import fr.ird.observe.client.datasource.editor.menu.DataSourceEditorMenu;

+import fr.ird.observe.client.datasource.api.ObserveDataSourcesManagerApplicationComponent;

+import fr.ird.observe.client.datasource.api.ObserveSwingDataSource;

+import fr.ird.observe.client.datasource.editor.wizard.StorageStep;

+import fr.ird.observe.client.datasource.editor.wizard.StorageUI;

 import fr.ird.observe.client.datasource.editor.wizard.StorageUILauncher;

+import fr.ird.observe.client.datasource.editor.wizard.StorageUIModel;

 import fr.ird.observe.client.main.ObserveMainUI;

-import fr.ird.observe.client.main.body.NoBodyContentComponent;

+import org.apache.commons.collections4.CollectionUtils;

 import org.apache.logging.log4j.LogManager;

 import org.apache.logging.log4j.Logger;

-import java.awt.event.ActionEvent;

+import java.util.Arrays;

 import java.util.EnumSet;

 import java.util.Set;

 import java.util.stream.Collectors;

  * @author Tony Chemit - dev@tchemit.fr

  * @since 3.13

  */

-public class ChangeStorageAction extends DataSourceEditorMenuActionSupport implements Runnable {

+public class ChangeStorageAction extends LoadStorageActionSupport {

     private static final Logger log = LogManager.getLogger(ChangeStorageAction.class);

         this(null, null);

     }

-    public ChangeStorageAction(String actionName, char keyStroke) {

-        super(actionName, t("observe.action.change.storage"), t("observe.action.change.storage.tip"), "db-change", keyStroke);

-        this.dbModes = EnumSet.noneOf(DbMode.class);

-        this.title = null;

-    }

-

     public ChangeStorageAction(Set<DbMode> dbModes, String title) {

         super(t("observe.action.change.storage"), t("observe.action.change.storage.tip"), "db-change", 'C');

         this.dbModes = dbModes == null ? EnumSet.noneOf(DbMode.class) : dbModes;

     }

     @Override

-    protected void doActionPerformed(ActionEvent event, DataSourceEditorMenu ui) {

-        run();

+    protected String getTitle() {

+        return t(title);

     }

     @Override

-    public void run() {

+    protected void init(StorageUI ui) {

+        log.debug(String.format("Incoming db mode : %s", dbModes.stream().map(DbMode::name).collect(Collectors.joining(", "))));

+        StorageUIModel model = ui.getModel();

+        if (CollectionUtils.isNotEmpty(dbModes)) {

+            log.info(String.format("will use incoming mode %s", dbModes.stream().map(DbMode::name).collect(Collectors.joining(", "))));

+

+            model.setExcludeSteps(Arrays.asList(StorageStep.SELECT_DATA,

+                                                StorageStep.BACKUP,

+                                                StorageStep.CONFIG_REFERENTIAL,

+                                                StorageStep.CONFIG_DATA,

+                                                StorageStep.ROLES));

+            model.setCanCreateLocalService(dbModes.contains(DbMode.CREATE_LOCAL));

+            model.setCanUseLocalService(dbModes.contains(DbMode.USE_LOCAL));

+            model.setCanUseRemoteService(dbModes.contains(DbMode.USE_REMOTE));

+            model.setCanUseServerService(dbModes.contains(DbMode.USE_SERVER));

-        ObserveMainUI mainUI = getClientUIContext().getMainUI();

-        boolean canContinue = mainUI.changeBodyContent(NoBodyContentComponent.class);

-//        boolean canContinue = getContentUIManager().closeSelectedContentUI();

-        if (canContinue) {

-            log.info("Start change storage with dbMode: " + dbModes.stream().map(DbMode::name).collect(Collectors.joining(", ")));

-            StorageUILauncher.changeStorage(ui == null ? mainUI : ui, mainUI, dbModes, t(title));

+            model.updateUniverse();

+            model.setDbMode(dbModes.stream().findFirst().orElse(null));

+        } else {

+            boolean localOpened = ObserveDataSourcesManagerApplicationComponent.value().getOptionalMainDataSource().map(ObserveSwingDataSource::isLocal).orElse(false);

+            if (localOpened) {

+                log.debug("Can not use local db (already opened)");

+                model.setCanUseLocalService(false);

+            }

+            model.setCanCreateLocalService(true);

+            model.setCanUseRemoteService(true);

+            model.setCanUseServerService(true);

         }

+        model.updateUniverse();

+    }

+    @Override

+    protected StorageUILauncher startWizard(ObserveMainUI mainUI) {

+        log.info(String.format("Start change storage with dbMode: %s", dbModes.stream().map(DbMode::name).collect(Collectors.joining(", "))));

+        return super.startWizard(mainUI);

     }

+

 }
+package fr.ird.observe.client.datasource.editor.menu.actions;

+

+/*-

+ * #%L

+ * ObServe :: Client DataSource Editor API

+ * %%

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

+ * %%

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

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

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

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

+ *

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

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

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

+ * GNU General Public License for more details.

+ *

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

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

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

+ * #L%

+ */

+

+import fr.ird.observe.client.ClientUIContextApplicationComponent;

+import fr.ird.observe.client.configuration.ClientConfig;

+import fr.ird.observe.client.util.UIHelper;

+import fr.ird.observe.client.util.action.ActionState;

+import org.apache.commons.io.FileUtils;

+import org.apache.logging.log4j.LogManager;

+import org.apache.logging.log4j.Logger;

+

+import javax.swing.JOptionPane;

+import java.io.File;

+import java.io.FileOutputStream;

+import java.io.IOException;

+import java.nio.file.Files;

+import java.nio.file.Path;

+import java.util.Objects;

+import java.util.zip.ZipEntry;

+import java.util.zip.ZipOutputStream;

+

+import static io.ultreia.java4all.i18n.I18n.t;

+

+public class FeedBackBuilder {

+

+    private static final Logger log = LogManager.getLogger(FeedBackBuilder.class);

+

+    private final LoadingDataSourceContext loadingContext;

+    private final ClientConfig config;

+    private final File feedBackFile;

+

+    public static void onClosingLocalDataSource(LoadingDataSourceContext loadingContext) {

+        new FeedBackBuilder(loadingContext).onClosingLocalDataSource();

+    }

+

+    public static void onLoadingLocalDataSource(LoadingDataSourceContext loadingContext) {

+        new FeedBackBuilder(loadingContext).onLoadingLocalDataSource();

+    }

+

+    public FeedBackBuilder(LoadingDataSourceContext loadingContext) {

+        this.loadingContext = Objects.requireNonNull(loadingContext);

+        this.config = loadingContext.getConfig();

+        this.feedBackFile = config.newFeedBackFile();

+    }

+

+    private void onClosingLocalDataSource() {

+        ActionState actionState = onLocalDataSourceError(t("observe.error.storage.could.not.close.local.data.source.title", feedBackFile));

+        loadingContext.setFeedBackOnClosingLocalDatasourceState(actionState);

+

+    }

+

+    private void onLoadingLocalDataSource() {

+        ActionState actionState = onLocalDataSourceError(t("observe.error.storage.could.not.open.local.data.source.title", feedBackFile));

+        loadingContext.setFeedBackOnClosingLocalDatasourceState(actionState);

+

+    }

+

+

+    private ActionState onLocalDataSourceError(String title) {

+

+        int response = UIHelper.askUser(ClientUIContextApplicationComponent.value().getMainUI(), title, t("observe.error.storage.could.not.close.local.data.source.message"), JOptionPane.ERROR_MESSAGE,

+                                        new Object[]{t("observe.choice.generateFeedBack"), t("observe.choice.cancel")}, 1);

+

+

+        switch (response) {

+            case JOptionPane.CLOSED_OPTION:

+            case 1:

+                // cancel operation

+                return ActionState.FAILED;

+        }

+        log.info(String.format("Create feed back at: %s", feedBackFile));

+        try {

+            createFeedBack();

+            setLocalStorageDoesNotExist();

+            destroyLocalDataSource();

+            loadingContext.setFeedBackOnLoadingLocalDatasourceState(ActionState.DONE);

+        } catch (IOException e) {

+            log.error("Could not create feed back", e);

+            return ActionState.FAILED;

+        }

+        return ActionState.DONE;

+    }

+

+

+    private void createFeedBack() throws IOException {

+        if (Files.notExists(feedBackFile.toPath())) {

+            Files.createDirectories(feedBackFile.toPath());

+        }

+        try (ZipOutputStream outputStream = new ZipOutputStream(new FileOutputStream(feedBackFile))) {

+            copyDirectoryToZip(config.getDbDirectory().toPath(), outputStream);

+            copyDirectoryToZip(config.getResourcesDirectory().toPath(), outputStream);

+            Path userConfigFile = config.get().getUserConfigFile().toPath();

+            copyFileToZip(userConfigFile.getParent(), userConfigFile, outputStream);

+        }

+    }

+

+    private void destroyLocalDataSource() throws IOException {

+        File dataSourceDirectory = config.getDbDirectory();

+        FileUtils.cleanDirectory(dataSourceDirectory);

+    }

+

+    private void copyDirectoryToZip(Path rootFile, ZipOutputStream zipOutputStream) throws IOException {

+        Files.walk(rootFile).filter(Files::isRegularFile).forEach(p -> copyFileToZip(rootFile, p, zipOutputStream));

+    }

+

+    private void copyFileToZip(Path rootFile, Path file, ZipOutputStream zipOutputStream) {

+

+        String entryName = file.relativize(rootFile).toString();

+        try {

+            zipOutputStream.putNextEntry(new ZipEntry(entryName));

+            Files.copy(file, zipOutputStream);

+        } catch (IOException e) {

+            log.error(String.format("Could not copy file %s to zip entry %S", file, entryName));

+        }

+

+    }

+

+    private void setLocalStorageDoesNotExist() {

+        config.setLocalStorageExist(false);

+        config.saveForUser();

+    }

+

+}
 import fr.ird.observe.client.configuration.ClientConfig;

 import fr.ird.observe.client.constants.CreationMode;

 import fr.ird.observe.client.constants.DbMode;

-import fr.ird.observe.client.datasource.editor.menu.DataSourceEditorMenu;

 import fr.ird.observe.client.datasource.editor.wizard.StorageStep;

 import fr.ird.observe.client.datasource.editor.wizard.StorageUI;

-import fr.ird.observe.client.datasource.editor.wizard.StorageUIHandler;

 import fr.ird.observe.client.datasource.editor.wizard.StorageUILauncher;

 import fr.ird.observe.client.datasource.editor.wizard.StorageUIModel;

 import fr.ird.observe.client.main.ObserveMainUI;

 import org.apache.logging.log4j.LogManager;

 import org.apache.logging.log4j.Logger;

-import java.awt.event.ActionEvent;

 import java.io.File;

 import static io.ultreia.java4all.i18n.I18n.t;

  * @author Tony Chemit - dev@tchemit.fr

  * @since 3.13

  */

-public class ImportStorageFromFileAction extends DataSourceEditorMenuActionSupport {

+public class ImportStorageFromFileAction extends LoadStorageActionSupport {

     private static final Logger log = LogManager.getLogger(ImportStorageFromFileAction.class);

+

     public ImportStorageFromFileAction() {

         super(t("observe.action.load.from.file"), t("observe.action.load.from.file.tip"), "local-import", 'I');

     }

     @Override

-    protected void doActionPerformed(ActionEvent event, DataSourceEditorMenu ui) {

-

-        final ObserveMainUI mainUI = getClientUIContext().getMainUI();

-        boolean canContinue = mainUI.canChangeBodyContent();

-        if (canContinue) {

-

-

-            if (getObserveDataSourcesManager().getOptionalMainDataSource().isPresent()) {

-                log.info("Closing datasource...");

-                getDataSourceEditorBodyContent().doCloseStorage();

-            }

-

-            new StorageUILauncher(ui, mainUI, t("observe.title.import.localDB")) {

-                @Override

-                protected void init(StorageUI ui) {

-                    super.init(ui);

-                    StorageUIModel model = ui.getModel();

-

-                    model.setDumpFile(getClientConfig().getImportDirectory());

-

-                    model.setCanCreateLocalService(true);

-                    model.setCanUseLocalService(false);

-                    model.setCanUseRemoteService(false);

-                    model.setCanUseServerService(false);

-                    model.setDbMode(DbMode.CREATE_LOCAL);

-                    model.setCreationMode(CreationMode.IMPORT_EXTERNAL_DUMP);

-                    if (model.isLocalStorageExist()) {

-                        // sauvegarde base locale possible

-                        model.setSteps(StorageStep.CONFIG, StorageStep.BACKUP, StorageStep.CONFIRM);

-

-                        // et requise par défaut

-                        model.setDoBackup(true);

-                    } else {

-                        model.setSteps(StorageStep.CONFIG, StorageStep.CONFIRM);

-                    }

-                }

-

-                @Override

-                public void doAction(StorageUI ui) {

-

-                    log.info("Start importing new datasource from backup file...");

-

-                    super.doAction(ui);

-                    StorageUIHandler handler = ui.getHandler();

-                    handler.doChangeStorage(ui.getModel());

-

-                    File importDirectory = ui.getModel().getDumpFile().getParentFile();

-                    ClientConfig config = getClientConfig();

-                    config.setImportDirectory(importDirectory);

-                    config.saveForUser();

-                }

+    protected String getTitle() {

+        return t("observe.title.import.localDB");

+    }

-            }.start();

+    @Override

+    protected void init(StorageUI ui) {

+        StorageUIModel model = ui.getModel();

+

+        model.setDumpFile(getClientConfig().getImportDirectory());

+

+        model.setCanCreateLocalService(true);

+        model.setCanUseLocalService(false);

+        model.setCanUseRemoteService(false);

+        model.setCanUseServerService(false);

+        model.setDbMode(DbMode.CREATE_LOCAL);

+        model.setCreationMode(CreationMode.IMPORT_EXTERNAL_DUMP);

+        if (model.isLocalStorageExist()) {

+            // sauvegarde base locale possible

+            model.setSteps(StorageStep.CONFIG, StorageStep.BACKUP, StorageStep.CONFIRM);

+

+            // et requise par défaut

+            model.setDoBackup(true);

+        } else {

+            model.setSteps(StorageStep.CONFIG, StorageStep.CONFIRM);

         }

+    }

+    @Override

+    protected StorageUILauncher startWizard(ObserveMainUI mainUI) {

+        if (getObserveDataSourcesManager().getOptionalMainDataSource().isPresent()) {

+            log.info("Closing datasource...");

+            getDataSourceEditorBodyContent().doCloseStorage();

+        }

+        return super.startWizard(mainUI);

     }

+    @Override

+    protected void doChangeStorage(StorageUI ui) {

+        log.info("Start importing new datasource from backup file...");

+

+        super.doChangeStorage(ui);

+    }

 }
+package fr.ird.observe.client.datasource.editor.menu.actions;

+

+/*-

+ * #%L

+ * ObServe :: Client DataSource Editor API

+ * %%

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

+ * %%

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

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

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

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

+ *

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

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

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

+ * GNU General Public License for more details.

+ *

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

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

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

+ * #L%

+ */

+

+import fr.ird.observe.client.configuration.ClientConfig;

+import fr.ird.observe.client.constants.DbMode;

+import fr.ird.observe.client.datasource.api.ObserveDataSourcesManager;

+import fr.ird.observe.client.datasource.api.ObserveSwingDataSource;

+import fr.ird.observe.client.datasource.dcp.WithFloatingObjectPresetsManager;

+import fr.ird.observe.client.datasource.editor.DataSourceEditor;

+import fr.ird.observe.client.datasource.editor.DataSourceEditorBodyContent;

+import fr.ird.observe.client.datasource.editor.menu.DataSourceEditorMenu;

+import fr.ird.observe.client.datasource.editor.wizard.StorageUI;

+import fr.ird.observe.client.datasource.editor.wizard.StorageUILauncher;

+import fr.ird.observe.client.datasource.editor.wizard.StorageUIModel;

+import fr.ird.observe.client.main.ObserveMainUI;

+import fr.ird.observe.client.main.body.NoBodyContentComponent;

+import fr.ird.observe.client.util.ProgressModel;

+import fr.ird.observe.client.util.action.ActionState;

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

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

+import fr.ird.observe.services.configuration.ObserveDataSourceInformation;

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

+import org.apache.logging.log4j.LogManager;

+import org.apache.logging.log4j.Logger;

+import org.nuiton.jaxx.runtime.JAXXContext;

+

+import java.awt.event.ActionEvent;

+import java.nio.file.Path;

+import java.util.Objects;

+

+import static io.ultreia.java4all.i18n.I18n.t;

+

+/**

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

+ * @since 8.0

+ */

+public abstract class LoadStorageActionSupport extends DataSourceEditorMenuActionSupport implements Runnable, WithFloatingObjectPresetsManager {

+

+    private static final Logger log = LogManager.getLogger(LoadStorageActionSupport.class);

+

+    protected abstract String getTitle();

+

+    protected abstract void init(StorageUI ui);

+

+    public LoadStorageActionSupport(String label, String shortDescription, String actionIcon, char acceleratorKey) {

+        super(label, shortDescription, actionIcon, acceleratorKey);

+    }

+

+    @Override

+    protected void doActionPerformed(ActionEvent event, DataSourceEditorMenu ui) {

+        run();

+    }

+

+    @Override

+    public void run() {

+

+        ObserveMainUI mainUI = getClientUIContext().getMainUI();

+        boolean canContinue = mainUI.changeBodyContent(NoBodyContentComponent.class);

+        if (!canContinue) {

+            return;

+        }

+        startWizard(mainUI).start();

+

+    }

+

+    protected StorageUILauncher startWizard(ObserveMainUI mainUI) {

+        JAXXContext rootContext = ui == null ? mainUI : ui;

+        return new StorageUILauncher(rootContext, mainUI, getTitle()) {

+

+            @Override

+            protected void init(StorageUI ui) {

+                super.init(ui);

+                LoadStorageActionSupport.this.init(ui);

+            }

+

+            @Override

+            public void doAction(StorageUI ui) {

+                super.doAction(ui);

+                doChangeStorage(ui);

+            }

+

+        };

+    }

+

+    protected void doChangeStorage(StorageUI ui) {

+

+        StorageUIModel model = ui.getModel();

+

+        ProgressModel progressModel = model.getProgressModel();

+        progressModel.installUI(ui.getCONFIRM().getProgressBar());

+

+        LoadingDataSourceContext loadingContext = new LoadingDataSourceContext(model,

+                                                                               getClientConfig(),

+                                                                               getObserveDataSourcesManager().getMainDataSource(),

+                                                                               getFloatingObjectPresetsManager());

+

+        doOpenLocalDataSource(loadingContext);

+

+        doBackupLocalDataSource(loadingContext);

+

+        doDestroyLocalDataSource(loadingContext);

+

+        doCloseLocalDatasource(loadingContext);

+

+        doCloseCurrentDatasource(loadingContext);

+

+        doFeedBackOnLocalDataSourceClosingErrors(loadingContext);

+

+        try {

+            ObserveMainUI mainUI = getClientUIContext().getMainUI();

+            doOpenNewDataSource(mainUI, loadingContext);

+            mainUI.changeBodyContent(DataSourceEditor.class);

+        } catch (Exception e) {

+            doFeedBackOnLocalDataSourceOnLoadingErrors(loadingContext);

+        } finally {

+            ObserveUtil.cleanMemory();

+        }

+

+    }

+

+    protected void doOpenLocalDataSource(LoadingDataSourceContext loadingContext) {

+

+        ObserveSwingDataSource currentDataSource = loadingContext.getCurrentDataSource();

+        boolean doBackup = loadingContext.getBackupState().notSkip();

+        boolean destroyLocalBase = loadingContext.getDestroyLocalDatabaseState().notSkip();

+

+        ObserveSwingDataSource localDataSource = null == currentDataSource || !currentDataSource.isLocal() ? null : currentDataSource;

+        if (destroyLocalBase || doBackup) {

+            if (localDataSource == null) {

+

+                ObserveDataSourcesManager dataSourcesManager = getObserveDataSourcesManager();

+

+                ObserveDataSourceConfigurationTopiaH2 localConfiguration = dataSourcesManager.newH2DataSourceConfiguration(t("observe.runner.initStorage.label.local"));

+

+                // can't migrate datasource in this case

+                localConfiguration.setCanMigrate(false);

+

+                //do open local datasource

+                localDataSource = dataSourcesManager.newDataSource(localConfiguration);

+            }

+

+            Objects.requireNonNull(localDataSource);

+

+            // Let's check if the datasource is opened or not :

+            // we could have close the datasource through the ui

+            // If the datasource is closed, we try to open it

+            if (!localDataSource.isOpen()) {

+                try {

+

+                    localDataSource.open();

+

+                } catch (Exception e) {

+                    log.error(t("observe.error.storage.could.not.load.local.db", e.getMessage()), e);

+

+                    // set no local data source, will then trigger some closing feedback

+                    localDataSource = null;

+                }

+            }

+        }

+        loadingContext.incrementsProgress();

+        loadingContext.setLocalDataSource(localDataSource);

+    }

+

+    private void doBackupLocalDataSource(LoadingDataSourceContext loadingContext) {

+        ActionState result = loadingContext.getBackupPendingState();

+        if (result.pending()) {

+            ObserveSwingDataSource localDataSource = loadingContext.getLocalDataSource();

+            if (localDataSource == null) {

+                // local database is not sane, can't do backup

+                log.error(t("observe.error.storage.could.not.backup.unsane.local.db"));

+                result = ActionState.FAILED;

+            } else {

+                StorageUIModel model = loadingContext.getModel();

+                Path f = model.getBackupFile().toPath();

+                log.info(String.format("Do backup with %s in %s", localDataSource, f));

+                try {

+                    localDataSource.backupLocalDatabase(f);

+                    result = ActionState.DONE;

+                } catch (Exception e) {

+                    result = ActionState.FAILED;

+                    log.error("Could not backup local datasource", e);

+                }

+            }

+        }

+        loadingContext.incrementsProgress();

+        loadingContext.setBackupState(result);

+    }

+

+    private void doDestroyLocalDataSource(LoadingDataSourceContext loadingContext) {

+        ActionState result = loadingContext.getDestroyLocalDatabasePendingState();

+        if (result.pending()) {

+            ObserveSwingDataSource localDataSource = loadingContext.getLocalDataSource();

+            if (localDataSource == null) {

+                // could not load local data source, mark this step as failed

+                result = ActionState.FAILED;

+            } else {

+                log.info(String.format("Destroy local data source %s", localDataSource));

+                try {

+                    localDataSource.destroy();

+                    result = ActionState.DONE;

+                } catch (Exception e) {

+                    log.error("Could not destroy local data source", e);

+                    result = ActionState.FAILED;

+                }

+            }

+        }

+        loadingContext.incrementsProgress();

+        loadingContext.setDestroyLocalDatabaseState(result);

+    }

+

+    private void doCloseLocalDatasource(LoadingDataSourceContext loadingContext) {

+        loadingContext.setCloseLocalDatabaseState(doCloseDatasource(loadingContext, loadingContext.getCloseLocalDatabasePendingState(), loadingContext.getLocalDataSource()));

+    }

+

+    private void doCloseCurrentDatasource(LoadingDataSourceContext loadingContext) {

+        loadingContext.setCloseCurrentDatabaseState(doCloseDatasource(loadingContext, loadingContext.getCloseCurrentDatabasePendingState(), loadingContext.getCurrentDataSource()));

+    }

+

+    private void doOpenNewDataSource(ObserveMainUI mainUI, LoadingDataSourceContext loadingContext) {

+        if (loadingContext.getOpenDataSourcePendingState().skip()) {

+            loadingContext.setOpenDataSourceState(ActionState.FAILED);

+        }

+        StorageUIModel model = loadingContext.getModel();

+        ClientConfig config = loadingContext.getConfig();

+        ObserveDataSourcesManager dataSourcesManager = getObserveDataSourcesManager();

+

+        ObserveSwingDataSource newDataSource = model.initDataSourceFromModel(config, dataSourcesManager);

+        newDataSource.setProgressModel(loadingContext.getProgressModel());

+

+        boolean useLocalDataSource = model.getDbMode() == DbMode.USE_LOCAL;

+

+        if (useLocalDataSource) {

+            // try an explicit data source migration

+

+            ObserveDataSourceInformation dataSourceInformation;

+            try {

+                dataSourceInformation = newDataSource.checkCanConnect(false);

+                newDataSource.setOwner(dataSourceInformation.isOwner());

+                newDataSource.setSuperUser(dataSourceInformation.isSuperUser());

+            } catch (Exception e) {

+                log.error(String.format("could not get local data source information: %s", newDataSource), e);

+                loadingContext.setOpenDataSourceState(ActionState.FAILED);

+                return;

+            } finally {

+                loadingContext.incrementsProgress();

+            }

+

+            try {

+                newDataSource.migrateData(dataSourceInformation, config.getModelVersion());

+            } catch (Exception e) {

+                log.error(String.format("could not migrate local data source: %s", newDataSource), e);

+                loadingContext.setOpenDataSourceState(ActionState.FAILED);

+                return;

+            } finally {

+                loadingContext.incrementsProgress();

+            }

+        }

+        mainUI.getMainUIBodyContentManager().getBodyTyped(DataSourceEditor.class, DataSourceEditorBodyContent.class).prepareMainStorage(newDataSource, true);

+

+        boolean createLocalDataSource = model.getDbMode() == DbMode.CREATE_LOCAL;

+

+        try {

+            if (createLocalDataSource) {

+                // do create local data source

+                DataSourceCreateConfigurationDto creationConfigurationDto = model.getCreationConfigurationDto();

+                newDataSource.create(creationConfigurationDto);

+            } else {

+                // open data source

+                newDataSource.open();

+            }

+            log.info(String.format("Main storage opened %s", newDataSource.getLabel()));

+        } catch (Exception e) {

+            log.error(String.format("could not open data source: %s", newDataSource), e);

+            dataSourcesManager.setMainDataSource(null);

+            loadingContext.setOpenDataSourceState(ActionState.FAILED);

+        } finally {

+            loadingContext.incrementsProgress();

+        }

+

+        loadingContext.setOpenDataSourceState(ActionState.DONE);

+    }

+

+    private ActionState doCloseDatasource(LoadingDataSourceContext loadingContext, ActionState dataSourceState, ObserveSwingDataSource dataSource) {

+        if (dataSourceState.notSkip()) {

+            if (dataSource == null || !dataSource.isOpen()) {

+                dataSourceState = ActionState.DONE;

+            } else {

+                log.info(String.format("close data source: %s", dataSource));

+                try {

+                    dataSource.close();

+                    dataSourceState = ActionState.DONE;

+                } catch (Exception e) {

+                    log.error("Could not close local data source", e);

+                    dataSourceState = ActionState.FAILED;

+                }

+            }

+        }

+        loadingContext.incrementsProgress();

+        return dataSourceState;

+    }

+

+    private void doFeedBackOnLocalDataSourceClosingErrors(LoadingDataSourceContext loadingContext) {

+        ActionState result = loadingContext.getFeedBackOnClosingLocalDatasourcePendingState();

+

+        if (result.notSkip()) {

+

+            //TODO

+            log.info("Do feed back after errors on closing local data source.");

+

+            try {

+

+                FeedBackBuilder.onClosingLocalDataSource(loadingContext);

+                result = ActionState.DONE;

+            } catch (Exception e) {

+                log.error("Could not feed back", e);

+                result = ActionState.FAILED;

+            }

+            loadingContext.setFeedBackOnClosingLocalDatasourceState(result);

+        }

+

+        loadingContext.incrementsProgress();

+    }

+

+    protected void doFeedBackOnLocalDataSourceOnLoadingErrors(LoadingDataSourceContext loadingContext) {

+

+        ActionState result = loadingContext.getFeedBackOnLoadingLocalDatasourcePendingState();

+        if (result.notSkip()) {

+

+            //TODO

+            log.info("Do feed back after errors on opening local data source.");

+

+            loadingContext.getConfig().setLocalStorageExist(false);

+            loadingContext.getConfig().saveForUser();

+            try {

+

+                result = ActionState.DONE;

+            } catch (Exception e) {

+                log.error("Could not feed back", e);

+                result = ActionState.FAILED;

+            }

+            loadingContext.setFeedBackOnLoadingLocalDatasourceState(result);

+        }

+

+

+        loadingContext.incrementsProgress();

+    }

+

+}
+package fr.ird.observe.client.datasource.editor.menu.actions;

+

+/*-

+ * #%L

+ * ObServe :: Client DataSource Editor API

+ * %%

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

+ * %%

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

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

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

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

+ *

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

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

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

+ * GNU General Public License for more details.

+ *

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

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

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

+ * #L%

+ */

+

+import fr.ird.observe.client.configuration.ClientConfig;

+import fr.ird.observe.client.constants.DbMode;

+import fr.ird.observe.client.datasource.api.ObserveSwingDataSource;

+import fr.ird.observe.client.datasource.dcp.FloatingObjectPresetsManager;

+import fr.ird.observe.client.datasource.editor.wizard.StorageUIModel;

+import fr.ird.observe.client.util.ProgressModel;

+import fr.ird.observe.client.util.action.ActionState;

+import org.apache.logging.log4j.LogManager;

+import org.apache.logging.log4j.Logger;

+

+/**

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

+ * @since 8.0.0

+ */

+public class LoadingDataSourceContext {

+

+    private static final Logger log = LogManager.getLogger(LoadingDataSourceContext.class);

+

+    private final StorageUIModel model;

+    private final ClientConfig config;

+    private final ObserveSwingDataSource currentDataSource;

+    private final ProgressModel progressModel;

+    private ObserveSwingDataSource localDataSource;

+    private ActionState backupState;

+    private ActionState destroyLocalDatabaseState;

+    private ActionState closeLocalDatabaseState;

+    private ActionState closeCurrentDatabaseState;

+    private ActionState feedBackOnClosingLocalDatasourceState;

+    private ActionState openDataSourceState;

+    private ActionState feedBackOnLoadingLocalDatasourceState;

+

+    LoadingDataSourceContext(StorageUIModel model, ClientConfig config, ObserveSwingDataSource currentDataSource, FloatingObjectPresetsManager floatingObjectPresetsManager) {

+        this.model = model;

+        this.config = config;

+        this.currentDataSource = currentDataSource;

+        boolean localStorageExist = config.isLocalStorageExist();

+        boolean currentDataSourceIsLocal = currentDataSource != null && currentDataSource.isLocal();

+        this.backupState = model.isDoBackup() ? ActionState.PENDING : ActionState.SKIP;

+        this.destroyLocalDatabaseState = localStorageExist && DbMode.CREATE_LOCAL == model.getDbMode() ? ActionState.PENDING : ActionState.SKIP;

+

+        log.info(String.format(" Will backup local db ? %s", backupState.notSkip()));

+        log.info(String.format(" Will destroy local db ? %s", destroyLocalDatabaseState.notSkip()));

+

+        this.progressModel = model.getProgressModel();

+        int stepsCount = computeStepCount(floatingObjectPresetsManager);

+

+        log.info(String.format("Found %d steps to load new data source.", stepsCount));

+

+        this.progressModel.setValue(0);

+        this.progressModel.setMaximum(stepsCount);

+

+        this.closeLocalDatabaseState = backupState.notSkip() || destroyLocalDatabaseState.notSkip() || currentDataSourceIsLocal ? ActionState.PENDING : ActionState.SKIP;

+        this.closeCurrentDatabaseState = currentDataSourceIsLocal ? ActionState.SKIP : ActionState.PENDING;

+        this.feedBackOnClosingLocalDatasourceState = ActionState.SKIP;

+        this.feedBackOnLoadingLocalDatasourceState = ActionState.SKIP;

+        this.openDataSourceState = ActionState.PENDING;

+    }

+

+    public ActionState getBackupPendingState() {

+        return backupState;

+    }

+

+    public ActionState getDestroyLocalDatabasePendingState() {

+        return ActionState.failIfPreviousFail(getDestroyLocalDatabaseState(), getBackupState());

+    }

+

+    public ActionState getCloseLocalDatabasePendingState() {

+        return ActionState.failIfPreviousFail(getCloseLocalDatabaseState(), getBackupState(), getDestroyLocalDatabaseState());

+    }

+

+    public ActionState getCloseCurrentDatabasePendingState() {

+        return getCloseCurrentDatabaseState();

+    }

+

+    public ActionState getFeedBackOnClosingLocalDatasourcePendingState() {

+        return ActionState.pendingIfPreviousFail(getFeedBackOnClosingLocalDatasourceState(), getBackupState(), getDestroyLocalDatabaseState(), getCloseCurrentDatabaseState());

+    }

+

+    public ActionState getFeedBackOnLoadingLocalDatasourcePendingState() {

+        return ActionState.pendingIfPreviousFail(getOpenDataSourceState());

+    }

+

+    public void incrementsProgress() {

+        progressModel.setValue(progressModel.getValue() + 1);

+    }

+

+    public StorageUIModel getModel() {

+        return model;

+    }

+

+    public ClientConfig getConfig() {

+        return config;

+    }

+

+    public ObserveSwingDataSource getCurrentDataSource() {

+        return currentDataSource;

+    }

+

+    public ActionState getBackupState() {

+        return backupState;

+    }

+

+    public ActionState getDestroyLocalDatabaseState() {

+        return destroyLocalDatabaseState;

+    }

+

+    public ProgressModel getProgressModel() {

+        return progressModel;

+    }

+

+    public ActionState getCloseLocalDatabaseState() {

+        return closeLocalDatabaseState;

+    }

+

+    public ActionState getCloseCurrentDatabaseState() {

+        return closeCurrentDatabaseState;

+    }

+

+    public ActionState getOpenDataSourceState() {

+        return openDataSourceState;

+    }

+

+    public ActionState getOpenDataSourcePendingState() {

+        return openDataSourceState;

+    }

+

+    public void setOpenDataSourceState(ActionState openDataSourceState) {

+        this.openDataSourceState = openDataSourceState;

+    }

+

+    public ObserveSwingDataSource getLocalDataSource() {

+        return localDataSource;

+    }

+

+    public void setLocalDataSource(ObserveSwingDataSource localDataSource) {

+        this.localDataSource = localDataSource;

+    }

+

+    public ActionState getFeedBackOnClosingLocalDatasourceState() {

+        return feedBackOnClosingLocalDatasourceState;

+    }

+

+    public ActionState getFeedBackOnLoadingLocalDatasourceState() {

+        return feedBackOnLoadingLocalDatasourceState;

+    }

+

+    public void setBackupState(ActionState backupState) {

+        this.backupState = backupState;

+    }

+

+    public void setCloseLocalDatabaseState(ActionState closeLocalDatabaseState) {

+        this.closeLocalDatabaseState = closeLocalDatabaseState;

+    }

+

+    public void setCloseCurrentDatabaseState(ActionState closeCurrentDatabaseState) {

+        this.closeCurrentDatabaseState = closeCurrentDatabaseState;

+    }

+

+    public void setFeedBackOnClosingLocalDatasourceState(ActionState feedBackOnClosingLocalDatasourceState) {

+        this.feedBackOnClosingLocalDatasourceState = feedBackOnClosingLocalDatasourceState;

+    }

+

+    public void setFeedBackOnLoadingLocalDatasourceState(ActionState feedBackOnLoadingLocalDatasourceState) {

+        this.feedBackOnLoadingLocalDatasourceState = feedBackOnLoadingLocalDatasourceState;

+    }

+

+    public void setDestroyLocalDatabaseState(ActionState destroyLocalDatabaseState) {

+        this.destroyLocalDatabaseState = destroyLocalDatabaseState;

+    }

+

+    private int computeStepCount(FloatingObjectPresetsManager floatingObjectPresetsManager) {

+        DbMode dbMode = model.getDbMode();

+        int stepsCount = 0;

+

+        // open local

+        stepsCount++;

+

+        // backup local

+        stepsCount++;

+

+        // destroy local

+        stepsCount++;

+

+        // close local

+        stepsCount++;

+

+        // close current

+        stepsCount++;

+

+        // feed back on closing

+        stepsCount++;

+

+        // open new data source

+        stepsCount++;

+

+        if (DbMode.USE_LOCAL.equals(dbMode)) {

+            // use local data source (requires migrate)

+            stepsCount += 2;

+        }

+

+        // feed back on loading

+        stepsCount++;

+

+        int openIds = config.getNavigationEditModelCount();

+        if (openIds > 0) {

+            stepsCount += 1 + openIds;

+        }

+        int selectedIds = config.getNavigationSelectModelCount();

+        if (selectedIds > 0) {

+            stepsCount += 1 + selectedIds;

+        }

+        stepsCount += floatingObjectPresetsManager.size();

+        return stepsCount;

+    }

+

+}
         }

     }

-    /**

-     * Utiliser le storage defini dans le modèle donné.

-     *

-     * @param model le model du storage a creer ou utiliser

-     */

-    public void doChangeStorage(StorageUIModel model) {

-

-        ClientConfig config = getClientConfig();

-

-        // faut-il detruire la base locale ?

-        boolean destroyLocalBase = config.isLocalStorageExist() && model.getDbMode() == DbMode.CREATE_LOCAL;

-

-        log.debug(">>> should destroy local db ? " + destroyLocalBase);

-

-        ObserveDataSourcesManager dataSourcesManager = getObserveDataSourcesManager();

-        ObserveSwingDataSource currentDataSource = dataSourcesManager.getMainDataSource();

-

-        ObserveSwingDataSource localDataSource = null;

-

-        if (currentDataSource != null && currentDataSource.isLocal()) {

-            localDataSource = currentDataSource;

-        }

-

-        ProgressModel progressModel = model.getProgressModel();

-

-        int stepsCount = 8;

-

-        if (destroyLocalBase || model.isDoBackup()) {

-            stepsCount++;

-        }

-        if (destroyLocalBase) {

-            stepsCount++;

-        }

-        if (model.isDoBackup()) {

-            stepsCount++;

-        }

-        if (currentDataSource != null && currentDataSource.isOpen()) {

-            stepsCount++;

-        }

-        if (DbMode.USE_LOCAL.equals((model.getDbMode()))) {

-            stepsCount += 2;

-        }

-        int openIds = config.getNavigationEditModelCount();

-        if (openIds > 0) {

-            stepsCount += 1 + openIds;

-        }

-        int selectedIds = config.getNavigationSelectModelCount();

-        if (selectedIds > 0) {

-            stepsCount += 1 + selectedIds;

-        }

-        stepsCount += getFloatingObjectPresetsManager().size();

-

-        progressModel.installUI(ui.getCONFIRM().getProgressBar());

-        progressModel.setMaximum(stepsCount);

-        log.info(String.format("Found %d steps to load new data source.", stepsCount));

-

-        boolean localDbIsSane = true;

-        if (destroyLocalBase || model.isDoBackup()) {

-            if (localDataSource == null) {

-

-                ObserveDataSourceConfigurationTopiaH2 localConfiguration = dataSourcesManager.newH2DataSourceConfiguration(t("observe.runner.initStorage.label.local"));

-

-                // la base ne doit pas etre mise a jour dans ce cas

-                localConfiguration.setCanMigrate(false);

-

-                // on charge un storage sur la base locale

-                localDataSource = dataSourcesManager.newDataSource(localConfiguration);

-            }

-

-            Objects.requireNonNull(localDataSource);

-

-            // Let's check if the datasource is opened or not :

-            // we could have close the datasource through the ui

-            // If the datasource is closed, we try to open it

-            if (!localDataSource.isOpen()) {

-                try {

-

-                    localDataSource.open();

-

-                } catch (Exception e) {

-                    // on a pas reussi à ouvrir la base locale

-                    // cela ne doit pas empécher de continuer

-                    // il faut juste supprimer physiquement le repertoire

-                    // de la base

-                    log.error(t("observe.error.storage.could.not.load.local.db", e.getMessage()), e);

-

-                    // on conserve l'état

-                    localDbIsSane = false;

-

-                    // pour la suite on fait comme si il n'y a pas de local storage

-                    localDataSource = null;

-                }

-            }

-

-            progressModel.setExtent(1);

-        }

-

-        if (model.isDoBackup()) {

-            if (!localDbIsSane) {

-

-                // la base locale n'est pas saine, on doit arrêter l'operation

-                // de changement de base sous peine de perdre la base.

-                Exception e = new Exception(t("observe.error.storage.could.not.backup.unsane.local.db"));

-                UIHelper.handlingError(e);

-                return;

-            }

-

-            Objects.requireNonNull(localDataSource);

-

-            // effectue la backup de la base locale existante

-            File f = model.getBackupFile();

-            log.debug(">>> do backup with " + localDataSource + " in " + f);

-            try {

-                SqlScriptProducerService dumpProducerService = localDataSource.getSqlScriptProducerService();

-                backupLocalDatabase(dumpProducerService, f);

-            } catch (Exception e) {

-                UIHelper.handlingError(e);

-                return;

-            }

-

-            progressModel.setExtent(1);

-        }

-

-        if (destroyLocalBase) {

-            log.debug(">>> destroy local db " + localDataSource);

-            if (!localDbIsSane) {

-                // la base locale n'est pas saine, on va supprimer directement

-                // le dossier de la base

-                File localDBDirectory = config.getLocalDBDirectory();

-                log.info(">>> destroy local db directory " + localDBDirectory);

-                try {

-                    FileUtils.deleteDirectory(localDBDirectory);

-                } catch (IOException e) {

-                    UIHelper.handlingError(e);

-                }

-            } else {

-                try {

-                    localDataSource.destroy();

-                } catch (Exception e) {

-                    UIHelper.handlingError(e);

-                    return;

-                }

-            }

-

-            progressModel.setExtent(1);

-        }

-

-        // suppression du storage precedent

-        if (currentDataSource != null && currentDataSource.isOpen()) {

-            log.debug(">>> close main storage " + currentDataSource);

-            // on doit fermer le storage en cours d'utilisation

-            try {

-                currentDataSource.close();

-            } catch (Exception e) {

-                UIHelper.handlingError(e);

-            }

-        }

-        progressModel.setExtent(1);

-

-        // suppression du storage local

-        if (localDataSource != null

-                && localDataSource.isOpen() // Si la base a été détruite précédemment, elle n'est plus ouverte

-                && localDataSource != currentDataSource) {

-            // ce cas peut arriver lorsque l'on fait juste une backup

-            // sans vouloir supprimer la base locale

-            log.debug(">>> close local storage " + localDataSource);

-            // on doit fermer le storage local ouvert

-            try {

-                localDataSource.close();

-            } catch (Exception e) {

-                UIHelper.handlingError(e);

-            }

-        }

-

-        log.debug("Will create new storage...");

-

-        // preparation du nouveau storage

-

-        try {

-            currentDataSource = model.initFromDataSource(config, dataSourcesManager);

-            currentDataSource.setProgressModel(progressModel);

-

-            // si on utilise la base local on lance une migration de la base si necessaire

-            if (DbMode.USE_LOCAL.equals((model.getDbMode()))) {

-

-                ObserveDataSourceInformation dataSourceInformation = currentDataSource.checkCanConnect(false);

-                currentDataSource.setOwner(dataSourceInformation.isOwner());

-                currentDataSource.setSuperUser(dataSourceInformation.isSuperUser());

-                progressModel.setExtent(1);

-

-                currentDataSource.migrateData(dataSourceInformation, config.getModelVersion());

-

-                progressModel.setExtent(1);

-

-            }

-

-            //FIXME:BodyContent this is already done in prepareMainStorage method

-//            dataSourcesManager.setMainDataSource(currentDataSource);

-            ObserveMainUI mainUI = getClientUIContext().getMainUI();

-

-            mainUI.getMainUIBodyContentManager().getBodyTyped(DataSourceEditor.class, DataSourceEditorBodyContent.class).prepareMainStorage(currentDataSource, true);

-

-            if (model.getDbMode() == DbMode.CREATE_LOCAL) {

-

-                DataSourceCreateConfigurationDto creationConfigurationDto = model.getCreationConfigurationDto();

-

-                try {

-

-                    currentDataSource.create(creationConfigurationDto);

-

-                } catch (Exception e) {

-                    //si il y a une erreur lor de la création de la base locla

-

-                    // on suprimer la base

-                    File localDBDirectory = config.getLocalDBDirectory();

-                    log.info(">>> destroy local db directory " + localDBDirectory);

-                    try {

-                        FileUtils.deleteDirectory(localDBDirectory);

-                    } catch (IOException e2) {

-                        UIHelper.handlingError(e2);

-                    }

-

-                    config.setLocalStorageExist(false);

-                    dataSourcesManager.setMainDataSource(null);

-

-                    throw e;

-                }

-            } else {

-                // ouverture du nouveau storage

-                currentDataSource.open();

-            }

-

-            progressModel.setExtent(1);

-

-            if (DbMode.CREATE_LOCAL.equals(model.getDbMode())

-                    && (IMPORT_REMOTE_STORAGE.equals(model.getCreationMode()) || IMPORT_SERVER_STORAGE.equals(model.getCreationMode()))

-                    && config.isLocalStorageExist()) {

-                // si on a creer la base locale a partir d'un import d'une base

-                // distante, on sauvegarde la base locale comme dump initial

-                // il s'agit d'un dump du référentiel

-                File f = config.getInitialDbDump();

-                if (f.exists()) {

-                    // on supprime le dump sql de la base embarquée

-                    if (!f.delete()) {

-                        throw new IllegalStateException("could not delete " + f);

-                    }

-                }

-                log.info(">>> create initial dump with " + currentDataSource + " in " + f);

-                try {

-                    SqlScriptProducerService dumpProducerService = currentDataSource.getSqlScriptProducerService();

-                    backupLocalDatabase(dumpProducerService, f);

-                    config.setInitialDumpExist(true);

-                } catch (Exception e) {

-                    UIHelper.handlingError(e);

-                }

-            }

-

-            log.info(">>> main storage opened " + currentDataSource.getLabel());

-

-            progressModel.setExtent(1);

-

-            mainUI.changeBodyContent(DataSourceEditor.class);

-

-        } catch (Exception ex) {

-            UIHelper.handlingError(ex);

-            throw new RuntimeException(ex);

-        } finally {

-            ObserveUtil.cleanMemory();

-        }

-    }

-

-    /**

-     * Effectue une sauvegarde de la base locale vers le fichier choisi.

-     *

-     * @param dumpProducerService le service de dump

-     * @param dst                 le fichier de sauvegarde

-     */

-    private void backupLocalDatabase(SqlScriptProducerService dumpProducerService, File dst) {

-        if (dst == null) {

-            throw new IllegalArgumentException("file where to backup can not be null");

-        }

-        if (log.isDebugEnabled()) {

-            log.debug(dst);

-        }

-

-        AddSqlScriptProducerRequest request = AddSqlScriptProducerRequest.forH2(getClientConfig().getModelVersion()).addSchema().addReferential().addAllData();

-        TopiaSqlScript dataDump = dumpProducerService.produceAddSqlScript(request);

-        try {

-            dataDump.copy(dst.toPath());

-        } catch (IOException e) {

-            UIHelper.handlingError(e);

-        }

-    }

-

     public void destroy() {

         ui.getModel().destroy();

         log.debug("destroy ui " + ui.getName());

         UIHelper.TabbedPaneIterator<Component> itr = UIHelper.newTabbedPaneIterator(ui.getTabs());

-        for (; itr.hasNext(); ) {

+        while (itr.hasNext()) {

             StorageTabUI tab = (StorageTabUI) itr.next();

             log.debug("destroy ui " + tab.getName());

             tab.destroy();

 import fr.ird.observe.client.WithClientUIContext;

 import fr.ird.observe.client.configuration.WithClientConfig;

 import fr.ird.observe.client.constants.DbMode;

-import fr.ird.observe.client.datasource.api.ObserveDataSourcesManagerApplicationComponent;

-import fr.ird.observe.client.datasource.api.ObserveSwingDataSource;

 import fr.ird.observe.client.datasource.api.WithObserveDataSourcesManager;

 import fr.ird.observe.client.util.UIHelper;

 import fr.ird.observe.dto.ObserveUtil;

-import org.apache.commons.collections4.CollectionUtils;

 import org.apache.logging.log4j.LogManager;

 import org.apache.logging.log4j.Logger;

 import org.nuiton.jaxx.runtime.JAXXContext;

 import java.awt.Window;

 import java.util.Arrays;

-import java.util.Set;

-import java.util.stream.Collectors;

 import static io.ultreia.java4all.i18n.I18n.t;

         this.title = title;

     }

-    /**

-     * Méthode pour lancer le changement de source de données.

-     *

-     * @param rootContext le context applicatif

-     * @param mainUI      main ui

-     * @param modes       les modes optionnel à utiliser

-     * @param title       le titre de la fenetre

-     * @see StorageUIHandler

-     * @see StorageUI

-     */

-    public static void changeStorage(JAXXContext rootContext, Window mainUI, Set<DbMode> modes, String title) {

-

-        new StorageUILauncher(rootContext, mainUI, title) {

-

-            @Override

-            protected void init(StorageUI ui) {

-                super.init(ui);

-                log.debug("Incoming db mode : " + modes.stream().map(DbMode::name).collect(Collectors.joining(", ")));

-                StorageUIModel model = ui.getModel();

-                if (CollectionUtils.isNotEmpty(modes)) {

-                    log.info("will use incoming mode " + modes.stream().map(DbMode::name).collect(Collectors.joining(", ")));

-

-                    model.setExcludeSteps(Arrays.asList(StorageStep.SELECT_DATA,

-                                                        StorageStep.BACKUP,

-                                                        StorageStep.CONFIG_REFERENTIAL,

-                                                        StorageStep.CONFIG_DATA,

-                                                        StorageStep.ROLES));

-                    model.setCanCreateLocalService(modes.contains(DbMode.CREATE_LOCAL));

-                    model.setCanUseLocalService(modes.contains(DbMode.USE_LOCAL));

-                    model.setCanUseRemoteService(modes.contains(DbMode.USE_REMOTE));

-                    model.setCanUseServerService(modes.contains(DbMode.USE_SERVER));

-

-                    model.updateUniverse();

-                    model.setDbMode(modes.stream().findFirst().orElse(null));

-

-                } else {

-                    boolean localOpened = ObserveDataSourcesManagerApplicationComponent.value().getOptionalMainDataSource().map(ObserveSwingDataSource::isLocal).orElse(false);

-                    if (localOpened) {

-                        log.debug("Can not use local db (already opened)");

-                        model.setCanUseLocalService(false);

-                    }

-                    model.setCanCreateLocalService(true);

-                    model.setCanUseRemoteService(true);

-                    model.setCanUseServerService(true);

-                }

-                model.updateUniverse();

-            }

-

-            @Override

-            public void doAction(StorageUI ui) {

-                super.doAction(ui);

-                ui.getHandler().doChangeStorage(ui.getModel());

-            }

-

-        }.start();

-    }

-

     /**

      * Méthode pour lancer l'action de connexion à une base distante.

      * <p>

 import java.lang.reflect.UndeclaredThrowableException;

 import java.net.MalformedURLException;

 import java.net.URL;

+import java.nio.file.Path;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.List;

         setDataSourceInformation(previousInfo);

     }

-    public ObserveSwingDataSource initFromDataSource(ClientConfig config, ObserveDataSourcesManager dataSourcesManager) {

+    public ObserveSwingDataSource initDataSourceFromModel(ClientConfig config, ObserveDataSourcesManager dataSourcesManager) {

         ObserveSwingDataSource dataSource = null;

         ObserveDataSourceConfiguration configuration;

         switch (getDbMode()) {

             case CREATE_LOCAL:

-            case USE_LOCAL:

                 configuration = toH2StorageConfig(t("observe.runner.initStorage.label.local"));

                 dataSource = dataSourcesManager.newDataSource(configuration);

-

                 dataSource.addObserveSwingDataSourceListener(

                         new ObserveSwingDataSourceListenerAdapter() {

                             @Override

                             public void onOpened(ObserveSwingDataSourceEvent event) {

-                                // la base locale existe desormais

+                                ObserveSwingDataSource dataSource = event.getSource();

+

+                                // local data source now exists

                                 config.setLocalStorageExist(true);

+

+                                switch (getCreationMode()) {

+                                    case IMPORT_EXTERNAL_DUMP:

+                                        // update import directory

+                                        File importDirectory = getDumpFile().getParentFile();

+                                        log.info(String.format("update import directory to: %s", importDirectory));

+                                        config.setImportDirectory(importDirectory);

+                                        break;

+                                    case IMPORT_REMOTE_STORAGE:

+                                    case IMPORT_SERVER_STORAGE:

+                                        // Let's generate again initial dump

+                                        Path f = config.getInitialDbDump().toPath();

+                                        log.info(String.format("create initial dump with %s to: %s", dataSource, f));

+                                        try {

+                                            dataSource.backupLocalDatabase(f);

+                                            config.setInitialDumpExist(true);

+                                        } catch (Exception e) {

+                                            UIHelper.handlingError(e);

+                                            //FIXME FeedBack ???

+

+                                        }

+                                        break;

+                                }

+                                config.saveForUser();

+

                             }

                         });

+                break;

+            case USE_LOCAL:

+                configuration = toH2StorageConfig(t("observe.runner.initStorage.label.local"));

+                dataSource = dataSourcesManager.newDataSource(configuration);

                 break;

             case USE_REMOTE:

                 configuration = toPGStorageConfig(t("observe.storage.label.remote"));

     public ObserveSwingDataSource getSafeSource(boolean open) {

         if (source == null || open && !source.isOpen()) {

-            source = initFromDataSource(getClientConfig(), ObserveDataSourcesManagerApplicationComponent.value());

+            source = initDataSourceFromModel(getClientConfig(), ObserveDataSourcesManagerApplicationComponent.value());

         }

         if (open) {

         }

     }

+    //FIXME Reuse the load storage action which will soon have the logic to load back a backup and anything else

+    //FIXME Need to have a unified API and only one

+    //FIXME first try to open specified ds (here local ds)

+    //FIXME if can not load local ds, then feedback it and propose to load automatic backup, or to create a new local ds

     private void initStorage(ClientConfig config, JFrame ui) {

         ObserveMainUI mainUI = (ObserveMainUI) ui;

     }

-    private void askToCreateLocalDatabase(ObserveMainUI mainUI,

-                                          ClientConfig config,

-                                          ObserveDataSourcesManager dataSourcesManager,

-                                          BackupStorage lastAutomaticBackup) {

+    public static void askToCreateLocalDatabase(ObserveMainUI mainUI,

+                                                ClientConfig config,

+                                                ObserveDataSourcesManager dataSourcesManager,

+                                                BackupStorage lastAutomaticBackup) {

         InitStorageModel initStorageModel = new InitStorageModel(config.getLocalDBDirectory(), lastAutomaticBackup);

         }

-        JLabel label = new JLabel();

-        label.setText(text);

+        JLabel label = new JLabel(text);

         int response = askUser(

                 null,

                 t("observe.runner.initStorage.title.no.local.db.found"),

                 options,

                 defaultOption

         );

-        log.debug("response : " + response);

+        log.debug(String.format("response : %d", response));

         if (noAutomaticBackup) {

             Set<DbMode> dbModes = EnumSet.noneOf(DbMode.class);

     }

-    private void loadBackup(ObserveDataSourcesManager dataSourcesManager, ObserveMainUI mainUI, BackupStorage backupStorage) {

+    public static void loadBackup(ObserveDataSourcesManager dataSourcesManager, ObserveMainUI mainUI, BackupStorage backupStorage) {

         log.info("Will load last backup: " + backupStorage.getFile());

         try {

 //            byte[] dump = Files.readAllBytes(backupStorage.getFile().toPath());

 observe.choice.dcp.default=Other opérations or objects (FOB)

 observe.choice.doNotSave=Do not save

 observe.choice.doNothing=Do nothing

+observe.choice.generateFeedBack=Generate

 observe.choice.loadLastAutomaticBackup=Use last automatic backup

 observe.choice.quit=Quit

 observe.choice.replace=Replace

 observe.config.defaultResourcesDirectory.description=Default user resources directory

 observe.config.defaultValidationReportDirectory.description=Default validation report directory

 observe.config.devMode=Dev mode

+observe.config.feedBackDirectory.description=FeedBack directory

 observe.config.floatingObjectPresets.description=Floating Objects references

 observe.config.h2.can.editReferential.description=Local database can edit referential

 observe.config.h2.can.migrate.description=Flag to know if you can migrate h2 data sources

 observe.error.LengthWeightParameterNotFoundException=No length weight relation found for species\: %s, ocean\: %s, sex\: %s, date\: %s \: %s

 observe.error.can.not.create.directory=Can't create directory %&$s\!

 observe.error.storage.could.not.backup.unsane.local.db=Can not save an borken database

+observe.error.storage.could.not.close.local.data.source.message=A feed back backup can be generate at %s, otherwise you can cancel.

+observe.error.storage.could.not.close.local.data.source.title=An error occurs while removing previous local data source

 observe.error.storage.could.not.load.local.db=Could not open local database for reason\: %s

+observe.error.storage.could.not.open.local.data.source.title=An error occurs while creating local data source

 observe.info.selected.validators=You must select at least one validator to continue.

 observe.info.validation.credentials=To validate referentiel (resp. data), You must have rw credentials.

 observe.init.local.db.detected=%1$s detected.

 observe.choice.dcp.default=Other opérations or objects (FOB) \#TODO

 observe.choice.doNotSave=No grabar

 observe.choice.doNothing=No hacer nada

+observe.choice.generateFeedBack=Generate \#TODO

 observe.choice.loadLastAutomaticBackup=Use last automatic backup \#TODO

 observe.choice.quit=Cerrar

 observe.choice.replace=Reemplazar

 observe.config.defaultResourcesDirectory.description=Directorio de almacenamiento de los recursos de usuario como las traducciones o la consultas de informes

 observe.config.defaultValidationReportDirectory.description=Directorio por defecto de almacenamiento de los informes de validación

 observe.config.devMode=Modo desarrollador

+observe.config.feedBackDirectory.description=FeedBack directory \#TODO

 observe.config.floatingObjectPresets.description=Objetos flotantes de referencia

 observe.config.h2.can.editReferential.description=Para poder editar el referencial de una base local

 observe.config.h2.can.migrate.description=Autorizar la actualización de las bases locales (h2)

 observe.error.LengthWeightParameterNotFoundException=No length weight relation found for species\: %s, ocean\: %s, sex\: %s, date\: %s \: %s \#TODO

 observe.error.can.not.create.directory=¡Imposible crear el directorio %1$s\!

 observe.error.storage.could.not.backup.unsane.local.db=Impossible grabar una base dañada

+observe.error.storage.could.not.close.local.data.source.message=A feed back backup can be generate at %s, otherwise you can cancel. \#TODO

+observe.error.storage.could.not.close.local.data.source.title=An error occurs while removing previous local data source \#TODO

 observe.error.storage.could.not.load.local.db=Impossible grabar la base local por la razón siguiente \: %s

+observe.error.storage.could.not.open.local.data.source.title=An error occurs while creating local data source \#TODO

 observe.info.selected.validators=Es necesario seleccionar un validador para continuar.

 observe.info.validation.credentials=Para validar el referencial (resp. los datos), debe tener los derechos de lectura y escritura correspondientes.

 observe.init.local.db.detected=%1$s detectado.

 observe.choice.dcp.default=Autre opérations et types d'objets (FOB)

 observe.choice.doNotSave=Ne pas enregistrer

 observe.choice.doNothing=Ne rien faire

+observe.choice.generateFeedBack=Générer

 observe.choice.loadLastAutomaticBackup=Charger la dernière sauvegarde automatique

 observe.choice.quit=Fermer

 observe.choice.replace=Remplacer

 observe.config.defaultResourcesDirectory.description=Le répertoire où sont stockées les ressources de l'utilisateur comme les traductions ou les requêtes de rapports.

 observe.config.defaultValidationReportDirectory.description=Le répertoire par défaut où sont stockés les rapports de validation

 observe.config.devMode=Mode développeur

+observe.config.feedBackDirectory.description=Répertoire où sont consigner les feedback

 observe.config.floatingObjectPresets.description=Objets flottants de référence

 observe.config.h2.can.editReferential.description=Pour pouvoir éditer le référentiel d'une base locale

 observe.config.h2.can.migrate.description=Autoriser la mise à jour des bases locales (H2)

 observe.error.LengthWeightParameterNotFoundException=Aucune relation taille-poids trouvée pour l'espèce\: %s, l'ocean\: %s, le sexe\: %s et la date\: %s

 observe.error.can.not.create.directory=Création du répertoire %1$s impossible\!

 observe.error.storage.could.not.backup.unsane.local.db=Impossible d'enregistrer une base non endommagée

+observe.error.storage.could.not.close.local.data.source.message=Vous pouvez générer un retour d'expérience utilisateur (avec toutes les données disponibles pour comprendre le problème de puis l'archive %s), ou annuler l'opération de changement de base

+observe.error.storage.could.not.close.local.data.source.title=Une erreur est survenue lors de la suppression de l'ancienne base locale 

 observe.error.storage.could.not.load.local.db=Impossible d'ouvrir la base locale pour la raison suivante \: %s

+observe.error.storage.could.not.open.local.data.source.title=Une erreur est survenue lors de la création de la nouvelle base locale

 observe.info.selected.validators=Il faut au moins un validateur sélectionné pour continuer.

 observe.info.validation.credentials=Pour valider le référentiel (resp. les données), vous devez posséder les droits en lecture correspondants.

 observe.init.local.db.detected=%1$s détectée.

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

Commits:

21 changed files:

Changes: