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

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

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

 import fr.ird.observe.navigation.model.edit.ObserveEditModel;

 import fr.ird.observe.navigation.model.select.ObserveSelectModel;

 import fr.ird.observe.services.ObserveDataSourceConfigurationMainFactory;

 import org.apache.logging.log4j.LogManager;

 import org.apache.logging.log4j.Logger;

 import java.io.Closeable;

 import java.io.File;

 import java.util.ArrayList;

                 try {

                     //FIXME:BodyContent Review progress model, not linked to ui any more...

                     if (getProgressModel() == null) {

                     }

                     create(createDto);

                 } catch (IncompatibleDataSourceCreateConfigurationException | DataSourceCreateWithNoReferentialImportException e) {

 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;

     private final Icon icon;

     private final ObserveServiceMainFactory serviceFactory;

     private ObserveDataSourceConnection connection;

     // indique que la connexion a expiré mais que la source n'est pas complétement fermer

     private boolean expired;

         return servicesProvider.getService(serviceType);

     }

         return progressModel;

     }

         this.progressModel = progressModel;

     }

         progressBar.setModel(this);

     }

 }

     public WizardState prepareCopy(ProgressModel progressModel, ObserveSwingDataSource centralSource, String centralSourceLabel, ObserveSwingDataSource targetSource, String targetSourceLabel, Collection<String> idsToCopy) {

         ReferentialService targetReferentialService = targetSource.getReferentialService();

         ImmutableSetStringMap targetSourceReferential = targetReferentialService.getReferentialIds();

         MissingReferentialRequest missingReferentialRequest = MissingReferentialRequest.of(targetSourceReferential, idsToCopy.toArray(new String[0]));

         MissingReferentialResult missingReferentialResult = centralSource.getReferentialService().computeMissingReferential(missingReferentialRequest);

         if (missingReferentialResult == null) {

             return WizardState.SUCCESSED;

         }

                 sendMessage(t("observe.actions.exportData.message.add.missing.referential", decorator.toString(reference)));

             }

         }

         targetReferentialService.insertMissingReferential(missingReferentialResult.getSqlCode());

         return WizardState.SUCCESSED;

     }

             ImmutableSet.Builder<ConsolidateTripSeineDataResult> resultsBuilder = ImmutableSet.builder();

             for (String tripId : tripIds) {

                 sendMessage(t("observe.actions.consolidate.start.trip", ++index, nbTrips, tripId));

                 ConsolidateTripSeineDataRequest request = new ConsolidateTripSeineDataRequest();

                 ObserveUtil.cleanMemory();

             }

             ImmutableSet<ConsolidateTripSeineDataResult> results = resultsBuilder.build();

             if (results.isEmpty()) {

         progressModel.setValue(0);

         try (ObserveSwingDataSource localDataSource = openSource(stepModel.getSource())) {

             TripManagementService localTripManagementService = localDataSource.getTripManagementService();

             try (ObserveSwingDataSource centralDataSource = openSource(stepModel.getCentralSource())) {

                 TripManagementService centralTripManagementService = centralDataSource.getTripManagementService();

                 for (TripEntry tripEntry : tripEntries) {

                     ExportTripRequest exportTripRequest = new ExportTripRequest(false, tripEntry.getProgramId(), tripEntry.getTripId());

                     ExportTripResult exportTripResult = localTripManagementService.exportTrip(exportTripRequest);

                     logExportResult(n("observe.actions.synchro.data.result.export.trip"),

                                     tripEntry.getProgram(),

                                     tripEntry.getTrip());

                     ImportTripRequest importTripRequest = new ImportTripRequest(exportTripResult);

                     ImportTripResult importTripResult = centralTripManagementService.importTrip(importTripRequest);

                     logImportResult(n("observe.actions.synchro.data.result.import.trip"),

             }

         }

         sendMessage(t("observe.actions.operation.message.done", new Date()));

                 log.info(sendMessage(String.format("[Program %d/%d - Trip %d/%d] Found %d logbook activities.", programIndex, nbProgram, tripIndex, nbTrip, tripLonglinePairingResult.getItems().size())));

                 ActivityLonglinePairingTripNode activityLonglinePairingTripNode = new ActivityLonglinePairingTripNode(tripLonglinePairingResult);

                 activityLonglinePairingProgramNode.add(activityLonglinePairingTripNode);

             }

         }

     ActivityLonglinePairingActivityNode(ActivityLonglinePairingResult userObject) {

         super(Objects.requireNonNull(userObject), false);

         if (selectedValue == null && !userObject.getItems().isEmpty()) {

             ActivityLonglinePairingResultItem activityLonglinePairingResultItem = userObject.getItems().get(0);

             setValueAt(activityLonglinePairingResultItem, 1);

             TripAware trip = task.getTrip();

             if (task instanceof DeleteFromLeftDataSynchronizeTask) {

                 executeDeleteTask(programDecorator, program, trip,

                         program,

                         trip);

         ImportTripRequest importTripRequest = new ImportTripRequest(exportTripResult);

         ImportTripResult importTripResult = targetTripManagementService.importTrip(importTripRequest);

         logImportResult(n("observe.actions.synchro.data.result.import.trip"),

             request.setValidationLengthWeightEnable(config.getValidationLengthWeightEnable());

             request.setValidationDisabledReferential(config.getValidationUseDisabledReferential());

             result = validateService.validateReferential(request);

                 //noinspection unchecked

                 sendMessage(t("observe.actions.validate.message.validate.trip", getDecoratorService().getDataReferenceDecorator((Class) dataReference.getReferenceType()).toString(dataReference)));

                 result = validateService.validateData(request);

                 resultBuilder.addMessages(result.getData());

         } else throw new IllegalStateException();

         dataSourceToValidate.close();

         stepModel.setValidationResult(result);

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

 import fr.ird.observe.client.main.body.HideBodyContentNotAcceptedException;

 import fr.ird.observe.client.main.body.MainUIBodyContent;

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

 import fr.ird.observe.client.util.busy.BusyModel;

 import fr.ird.observe.navigation.model.edit.ObserveEditModel;

 import org.apache.logging.log4j.LogManager;

 import org.apache.logging.log4j.Logger;

 import java.beans.PropertyChangeListener;

 import java.util.Set;

 import java.util.function.Supplier;

         log.info(String.format("loading ui for storage %s: %s", dataSource.getLabel(), mainUI));

         ObserveEditModel navigationEditModel = null;

         try {

         get().getHandler().loadNavigationUI(dataSource, progressModel);

     }

 import fr.ird.observe.client.datasource.editor.tree.navigation.nodes.NavigationTreeNodeSupport;

 import fr.ird.observe.client.datasource.editor.tree.navigation.nodes.ReferenceNavigationTreeNodeSupport;

 import fr.ird.observe.client.datasource.editor.tree.navigation.nodes.StringNavigationTreeNodeSupport;

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

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

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

 import fr.ird.observe.client.util.busy.BusyModel;

 import fr.ird.observe.client.util.session.WithObserveSwingSessionHelper;

 import org.nuiton.jaxx.runtime.spi.UIHandler;

 import org.nuiton.jaxx.validator.swing.SwingValidatorUtil;

 import javax.swing.SwingUtilities;

 import javax.swing.event.TreeSelectionEvent;

 import javax.swing.tree.TreePath;

      * @param servicesProvider services provider to load navigation model

      * @param progressModel    the progress model to interact with ui

      */

         NavigationTree tree = ui.getNavigationUI().getTree();

         NavigationTreeModel treeModel = tree.getModel();

         treeModel.populate(servicesProvider);

         // select initial node

         try {

         } catch (Exception e) {

             log.error("Could not load initial node", e);

         }

         tree.setVisible(true);

                         ExportTripRequest exportRequest = new ExportTripRequest(false, entry.getKey().getId(), trip.getId());

                         ExportTripResult exportTripResult = managementService.exportTrip(exportRequest);

                         ImportTripRequest importTripRequest = new ImportTripRequest(exportTripResult);

                         tmpManagementService.importTrip(importTripRequest);

                     }

             }

             sourceToBackup.getDataSourceService().backup(backupFile);

         } catch (DatabaseNotFoundException | DatabaseConnexionNotAuthorizedException | BabModelVersionException | IncompatibleDataSourceCreateConfigurationException | DataSourceCreateWithNoReferentialImportException e) {

             throw new ObserveSwingTechnicalException(e);

         } finally {

             if (sourceToBackup != localSource) {

                 sourceToBackup.close();

             }

     private transient GPSPoint gpsPoint;

     }

     public ActivityReference(DtoReferenceAware dto) {

 quadrant + {*:1} Integer

 samplePart + {*} fr.ird.observe.dto.data.ll.logbook.SamplePartDto | ordered

 startTimeStamp + {*:1} Date | notNull

 endTimeStamp + {*:1} Date | mayNotNull

 latitude + {*:1} Float | mayNotNull

   <parent>

     <groupId>io.ultreia.maven</groupId>

     <artifactId>pom</artifactId>

   </parent>

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

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

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

     <lib.version.nuiton.validation>3.1</lib.version.nuiton.validation>

     <!--can't use 1.4.197 (date has changed + blob also)-->

     <lib.version.h2>1.4.196</lib.version.h2>

     <lib.version.nuiton.utils>3.0</lib.version.nuiton.utils>

     <!--    <lib.version.java4all.topia>1.17</lib.version.java4all.topia>-->

     <!--<lib.version.java4all.application-context>1.0.3-SNAPSHOT</lib.version.java4all.application-context>-->

     <!--<lib.version.java4all.application-template>1.0.2-SNAPSHOT</lib.version.java4all.application-template>-->

     <!--<lib.version.java4all.i18n>4.0-beta-3-SNAPSHOT</lib.version.java4all.i18n>-->

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.List;

 import java.util.Set;

 /**

  * Created by tchemit on 15/10/2018.

         ImmutableList<ActivityReference> activityLonglineObsList = context.getActivityLonglineObsList(activityLonglineLogbook);

         List<ActivityLonglinePairingResultItem> itemBuilder = new ArrayList<>(activityLonglineObsList.size());

         for (ActivityReference activityLonglineObs : activityLonglineObsList) {

         }

         itemBuilder.sort(ActivityLonglinePairingResult.COMPARATOR);

         fr.ird.observe.dto.data.ll.logbook.ActivityReference reference;

         return new ActivityLonglinePairingResult(reference, ImmutableList.copyOf(itemBuilder));

     }

 }

     private final ActivityReference activityLonglineLogbook;

     private final ImmutableList<ActivityLonglinePairingResultItem> items;

     public ActivityLonglinePairingResult(ActivityReference activityLonglineLogbook, ImmutableList<ActivityLonglinePairingResultItem> items) {

         this.activityLonglineLogbook = Objects.requireNonNull(activityLonglineLogbook);

         this.items = Objects.requireNonNull(items);

     }

     }

     public ActivityReference getActivityLonglineLogbook() {

  * #L%

  */

 import fr.ird.observe.dto.data.ll.observation.ActivityReference;

 import fr.ird.observe.dto.spi.SimpleDto;

 import io.ultreia.java4all.lang.Numbers;

 import java.util.Objects;

 import java.util.concurrent.TimeUnit;

     private final float computedDistance;

     private String computedTimeStr;

         this.observationActivity = observationActivity;

         this.computedTime = computedTime;

         this.computedDistance = Numbers.roundTwoDigits((float) computedDistance);