[Echobase-commits] 01/01: Revue des import (utilisation java 7 API + reformat code)

24 Mar 2016

This is an automated email from the git hooks/post-receive script.

New commit to branch feature/8170 in repository echobase.

See https://gitlab.nuiton.org/codelutin/echobase.git

commit 355c51f08147d01670037621b930e22d284d92c0
Author: Tony CHEMIT <chemit@codelutin.com>
Date:   Thu Mar 24 08:59:15 2016 +0100

    Revue des import (utilisation java 7 API + reformat code)
---
 .../importdata/AbstractImportDataService.java      | 135 ++----
 .../service/importdata/AcousticImportService.java  | 427 ++++++++---------
 .../importdata/CatchesImportConfiguration.java     |  15 +-
 .../service/importdata/CatchesImportService.java   | 516 ++++++++------------
 .../service/importdata/CommonAllImportService.java |  27 +-
 .../importdata/CommonImportConfiguration.java      |   9 +-
 .../service/importdata/CommonImportService.java    |   9 +-
 .../importdata/CommonTransectImportService.java    | 107 ++---
 .../importdata/CommonTransitImportService.java     |  74 ++-
 .../importdata/CommonVoyageImportService.java      |  86 ++--
 ...ion.java => DataMetadataNotFoundException.java} |  13 +-
 ...ception.java => EsduCellNotFoundException.java} |  15 +-
 .../service/importdata/ImportException.java        |   4 +-
 ...va => MoreThanOnceVoyageToImportException.java} |  12 +-
 ...ception.java => NoVoyageToImportException.java} |  12 +-
 .../importdata/OperationImportConfiguration.java   |  13 +-
 .../service/importdata/OperationImportService.java | 240 ++++------
 .../importdata/ResultsEsduCellImportService.java   | 529 +++++++++------------
 .../importdata/ResultsImportConfiguration.java     |  63 +--
 .../service/importdata/ResultsImportService.java   |   1 -
 .../ResultsMapFishCellImportService.java           | 213 ++++-----
 .../ResultsMapOtherCellImportService.java          | 180 ++++---
 .../importdata/ResultsRegionCellImportService.java | 269 +++++------
 .../ResultsVoyageImportAlreadyExistException.java  |   8 +-
 .../importdata/ResultsVoyageImportService.java     | 288 +++++------
 ...ception.java => TransectNotFoundException.java} |  15 +-
 ...xception.java => TransitNotFoundException.java} |  14 +-
 .../importdata/AbstractImportDataServiceIT.java    |  38 +-
 .../echobase/ui/actions/dbeditor/GetEntities.java  |   3 +-
 29 files changed, 1462 insertions(+), 1873 deletions(-)

diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/AbstractImportDataService.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/AbstractImportDataService.java
index 3c313f5..6c9be78 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/AbstractImportDataService.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/AbstractImportDataService.java
@@ -47,14 +47,12 @@ import fr.ifremer.echobase.services.service.UserDbPersistenceService;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
-import org.nuiton.csv.ImportRuntimeException;
 import org.nuiton.util.TimeLog;
 
 import javax.inject.Inject;
 import java.io.BufferedReader;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
-import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.sql.SQLException;
@@ -88,8 +86,7 @@ public abstract class AbstractImportDataService<M extends AbstractImportConfigur
     @Inject
     protected UserDbPersistenceService persistenceService;
 
-    public final String doImport(M configuration,
-                                 EchoBaseUser user) throws ImportException {
+    public final String doImport(M configuration, EchoBaseUser user) throws ImportException {
 
         long s0 = TimeLog.getTime();
 
@@ -102,6 +99,7 @@ public abstract class AbstractImportDataService<M extends AbstractImportConfigur
         s0 = TIME_LOG.log(s0, "computeNbSteps");
 
         try {
+
             startImport(configuration, user);
 
             s0 = TIME_LOG.log(s0, "importDone");
@@ -115,6 +113,7 @@ public abstract class AbstractImportDataService<M extends AbstractImportConfigur
             TIME_LOG.log(s0, "importCommited");
 
             return result;
+
         } catch (EchoBaseTechnicalException e) {
             throw new ImportException(e.getMessage(), e);
         }
@@ -211,53 +210,41 @@ public abstract class AbstractImportDataService<M extends AbstractImportConfigur
 
         String result = importLog.getImportText();
 
-        persistenceService.createEntityModificationLog(
-                "Import",
-                importType,
-                importUser,
-                importDate,
-                result
-        );
+        persistenceService.createEntityModificationLog("Import", importType, importUser, importDate, result);
         return result;
+
     }
 
     protected final String getImportLabel(M configuration) {
-        Locale locale = getLocale();
-        return l(locale, configuration.getImportType().getI18nKey());
+        return l(getLocale(), configuration.getImportType().getI18nKey());
     }
 
-    protected abstract void startImport(M configuration,
-                                        EchoBaseUser user) throws ImportException;
+    protected abstract void startImport(M configuration, EchoBaseUser user) throws ImportException;
 
     protected Reader getInputFileReader(InputFile inputFile) throws EchoBaseTechnicalException {
         try {
-            return new BufferedReader(new InputStreamReader(
-                    new FileInputStream(inputFile.getFile()), Charsets.UTF_8));
+            return new BufferedReader(new InputStreamReader(new FileInputStream(inputFile.getFile()), Charsets.UTF_8));
         } catch (FileNotFoundException e) {
-            throw new EchoBaseTechnicalException(
-                    "Could not find import file " + inputFile.getFile(), e);
+            throw new EchoBaseTechnicalException("Could not find import file " + inputFile.getFile(), e);
         }
     }
 
-    protected void closeReader(Reader reader, InputFile inputFile) {
-        try {
-            reader.close();
-        } catch (IOException e) {
-            throw new EchoBaseTechnicalException(
-                    "Could not close reader on file " +
-                    inputFile.getFile(), e
-            );
-        }
-    }
+//    protected void closeReader(Reader reader, InputFile inputFile) {
+//        try {
+//            reader.close();
+//        } catch (IOException e) {
+//            throw new EchoBaseTechnicalException(
+//                    "Could not close reader on file " +
+//                    inputFile.getFile(), e
+//            );
+//        }
+//    }
 
     protected String getImportMessage(M configuration, InputFile inputFile) {
-        return l(getLocale(), "echobase.importLabel.withFile",
-                 getImportLabel(configuration), inputFile.getFileName());
+        return l(getLocale(), "echobase.importLabel.withFile", getImportLabel(configuration), inputFile.getFileName());
     }
 
-    protected final void doFlushTransaction(int rowNumber,
-                                            InputFile inputFile,
-                                            M configuration) {
+    protected final void doFlushTransaction(int rowNumber, InputFile inputFile, M configuration) {
         configuration.incrementsProgress();
         if (rowNumber % 1000 == 0) {
             // flush each 1000 imported rows
@@ -268,12 +255,11 @@ public abstract class AbstractImportDataService<M extends AbstractImportConfigur
 
     protected Map<String, SpeciesCategory> speciesCategories = Maps.newTreeMap();
 
-    protected SpeciesCategory getSpeciesCategory(
-            Species species,
-            SizeCategory sizeCategory,
-            AgeCategory ageCategory,
-            SexCategory sexCategory,
-            EchoBaseCsvFileImportResult importResult) {
+    protected SpeciesCategory getSpeciesCategory(Species species,
+                                                 SizeCategory sizeCategory,
+                                                 AgeCategory ageCategory,
+                                                 SexCategory sexCategory,
+                                                 EchoBaseCsvFileImportResult importResult) {
 
         String key = species == null ? "" : species.getBaracoudaCode();
         key += "#" + (ageCategory == null ? "" : ageCategory.getName());
@@ -286,23 +272,13 @@ public abstract class AbstractImportDataService<M extends AbstractImportConfigur
 
             // try to find it in db
 
-            category = persistenceService.getSpeciesCategory(
-                    species,
-                    sizeCategory,
-                    ageCategory,
-                    sexCategory
-            );
+            category = persistenceService.getSpeciesCategory(species, sizeCategory, ageCategory, sexCategory);
 
             if (category == null) {
 
                 // not found in db, create it
 
-                category = persistenceService.createSpeciesCategory(
-                        species,
-                        sizeCategory,
-                        ageCategory,
-                        sexCategory
-                );
+                category = persistenceService.createSpeciesCategory(species, sizeCategory, ageCategory, sexCategory);
                 importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.SpeciesCategory);
             }
 
@@ -313,31 +289,20 @@ public abstract class AbstractImportDataService<M extends AbstractImportConfigur
 
     protected Map<String, Category> categories = Maps.newTreeMap();
 
-    protected Category getResultCategory(
-            Echotype echotype,
-            Species species,
-            SizeCategory sizeCategory,
-            AgeCategory ageCategory,
-            EchoBaseCsvFileImportResult importResult) {
+    protected Category getResultCategory(Echotype echotype,
+                                         Species species,
+                                         SizeCategory sizeCategory,
+                                         AgeCategory ageCategory,
+                                         EchoBaseCsvFileImportResult importResult) {
 
         // get species categorie first
 
-        SpeciesCategory speciesCategory = getSpeciesCategory(
-                species,
-                sizeCategory,
-                ageCategory,
-                null,
-                importResult);
+        SpeciesCategory speciesCategory = getSpeciesCategory(species, sizeCategory, ageCategory, null, importResult);
 
-        return getResultCategory(echotype,
-                                 speciesCategory,
-                                 importResult);
+        return getResultCategory(echotype, speciesCategory, importResult);
     }
 
-    protected Category getResultCategory(
-            Echotype echotype,
-            SpeciesCategory speciesCategory,
-            EchoBaseCsvFileImportResult importResult) {
+    protected Category getResultCategory(Echotype echotype, SpeciesCategory speciesCategory, EchoBaseCsvFileImportResult importResult) {
 
         String key = speciesCategory == null ? "" : speciesCategory.getTopiaId();
         key += "#" + (echotype == null ? "" : echotype.getName());
@@ -348,18 +313,12 @@ public abstract class AbstractImportDataService<M extends AbstractImportConfigur
 
             // try to find it in db
 
-            category = persistenceService.getCategoryByEchotypeAndSpeciesCategory(
-                    echotype,
-                    speciesCategory
-            );
+            category = persistenceService.getCategoryByEchotypeAndSpeciesCategory(echotype, speciesCategory);
 
             if (category == null) {
 
                 // not found in db, create it
-                category = persistenceService.createCategory(
-                        echotype,
-                        speciesCategory
-                );
+                category = persistenceService.createCategory(echotype, speciesCategory);
                 importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.Category);
             }
 
@@ -369,10 +328,7 @@ public abstract class AbstractImportDataService<M extends AbstractImportConfigur
         return category;
     }
 
-    protected List<DataMetadata> getMetas(
-            String[] columnNamesToExclude,
-            Map<String, DataMetadata> dataMetadataMap,
-            String... headers) {
+    protected List<DataMetadata> getMetas(String[] columnNamesToExclude, Map<String, DataMetadata> dataMetadataMap, String... headers) {
 
         List<String> metadataNames = Lists.newArrayList(headers);
         for (String columnToExclude : columnNamesToExclude) {
@@ -392,15 +348,12 @@ public abstract class AbstractImportDataService<M extends AbstractImportConfigur
             }
             DataMetadata dataMetadata = dataMetadataMap.get(metadataName);
             if (dataMetadata == null) {
-                throw new ImportRuntimeException(
-                        l(locale, "echobase.importError.dataMetadata.notFound",
-                          metadataName,
-                          dataMetadataMap.keySet())
-                );
+                throw new DataMetadataNotFoundException(locale, metadataName, dataMetadataMap.keySet());
             }
             result.add(dataMetadata);
         }
         return result;
+
     }
 
     protected void createCellData(Cell cell,
@@ -414,6 +367,7 @@ public abstract class AbstractImportDataService<M extends AbstractImportConfigur
         cell.setDataQuality(dataQuality);
 
         importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.Data);
+
     }
 
     protected void addResults(EchoBaseCsvUtil.ResultAble row,
@@ -423,6 +377,7 @@ public abstract class AbstractImportDataService<M extends AbstractImportConfigur
                               EchoBaseCsvFileImportResult importResult,
                               boolean collecIds,
                               boolean importNAResults) {
+
         List<Result> results = row.getResult();
 
         for (Result result : results) {
@@ -441,12 +396,14 @@ public abstract class AbstractImportDataService<M extends AbstractImportConfigur
 
             if (collecIds) {
 
-                // collect ids
                 importResult.addId(EchoBaseUserEntityEnum.Result, resultCreated);
+
             } else {
 
                 importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.Result);
             }
+
         }
+
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/AcousticImportService.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/AcousticImportService.java
index b7d3a0f..069c618 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/AcousticImportService.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/AcousticImportService.java
@@ -50,6 +50,7 @@ import org.apache.commons.logging.LogFactory;
 import org.nuiton.csv.Import;
 import org.nuiton.csv.ImportRuntimeException;
 
+import java.io.IOException;
 import java.io.Reader;
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
@@ -74,43 +75,33 @@ public class AcousticImportService extends AbstractImportDataService<AcousticImp
             LogFactory.getLog(AcousticImportService.class);
 
     @Override
-    protected void startImport(
-            AcousticImportConfiguration configuration,
-            EchoBaseUser user) throws ImportException {
+    protected void startImport(AcousticImportConfiguration configuration, EchoBaseUser user) throws ImportException {
 
         // get selected voyage
-        Voyage voyage = persistenceService.getVoyage(
-                configuration.getVoyageId());
+        Voyage voyage = persistenceService.getVoyage(configuration.getVoyageId());
 
         // get selected vessel
-        Vessel vessel = persistenceService.getVessel(
-                configuration.getVesselId());
+        Vessel vessel = persistenceService.getVessel(configuration.getVesselId());
 
-        CellType esduCellType = persistenceService.getCellTypeById(
-                CellTypeImpl.ESDU);
+        CellType esduCellType = persistenceService.getCellTypeById(CellTypeImpl.ESDU);
 
-        CellType elementaryCellType = persistenceService.getCellTypeById(
-                CellTypeImpl.ELEMENTARY);
+        CellType elementaryCellType = persistenceService.getCellTypeById(CellTypeImpl.ELEMENTARY);
 
-        EchoBaseCsvFileImportResult importResult =
-                importMoviesFile(configuration,
-                                 voyage,
-                                 vessel,
-                                 esduCellType,
-                                 elementaryCellType);
+        EchoBaseCsvFileImportResult importResult = importMoviesFile(configuration,
+                                                                    voyage,
+                                                                    vessel,
+                                                                    esduCellType,
+                                                                    elementaryCellType);
         configuration.addResult(importResult);
+
     }
 
-    private final DateFormat cellDateFormat = new SimpleDateFormat(
-            EchoBaseCsvUtil.CELLULE_DATE_FORMAT);
+    private final DateFormat cellDateFormat = new SimpleDateFormat(EchoBaseCsvUtil.CELLULE_DATE_FORMAT);
 
-    private DataAcquisition getDataAcquisition(Transect transect,
-                                               AcousticInstrument instrument,
-                                               boolean addDataAcquisition) throws ImportException {
+    private DataAcquisition getDataAcquisition(Transect transect, AcousticInstrument instrument, boolean addDataAcquisition) throws ImportException {
 
         DataAcquisition result = null;
-        if (!addDataAcquisition &&
-            !transect.isDataAcquisitionEmpty()) {
+        if (!addDataAcquisition && !transect.isDataAcquisitionEmpty()) {
 
             // try to obtain an existing data acquisiton
 
@@ -143,311 +134,267 @@ public class AcousticImportService extends AbstractImportDataService<AcousticImp
 
         AcousticImportResult importResult = newImportResult(inputFile);
 
-        Map<String, AcousticInstrument> instrumentsById =
-                persistenceService.getEntitiesMap(AcousticInstrument.class,
-                                                  AcousticInstruments.ACOUSTIC_INSTRUMENT_ID);
-
-        Map<String, DataMetadata> dataMetadatasByName = persistenceService.getEntitiesMap(
-                DataMetadata.class, DataMetadatas.DATA_METADATA_NAME);
+        Map<String, AcousticInstrument> instrumentsById = persistenceService.getEntitiesMap(AcousticInstrument.class, AcousticInstruments.ACOUSTIC_INSTRUMENT_ID);
 
-        Map<String, DataQuality> dataQualityMap = persistenceService.getEntitiesMap(
-                DataQuality.class, DataQualities.DATA_QUALITY_NAME);
+        Map<String, DataMetadata> dataMetadatasByName = persistenceService.getEntitiesMap(DataMetadata.class, DataMetadatas.DATA_METADATA_NAME);
 
-        AcousticImportModel csvModel = new AcousticImportModel(
-                getCsvSeparator(), instrumentsById, dataQualityMap);
+        Map<String, DataQuality> dataQualityMap = persistenceService.getEntitiesMap(DataQuality.class, DataQualities.DATA_QUALITY_NAME);
 
         boolean addDataAcquisition = configuration.isAddDataAcquisition();
 
-        String suffix =
-                configuration.getCellPositionReference().getMetadataNameSuffix();
+        String suffix = configuration.getCellPositionReference().getMetadataNameSuffix();
 
         List<Cell> elementaryCells = Lists.newArrayList();
 
-        Reader reader = getInputFileReader(inputFile);
         Locale locale = getLocale();
-        String dataProcessingId = null;
-        try {
 
-            Import<AcousticImportRow> importer = Import.newImport(csvModel,
-                                                                  reader);
-            DataAcquisition dataAcquisition = null;
-            DataProcessing dataProcessing = null;
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-            Cell elementaryCell;
-            int rowNumber = 0;
+            String dataProcessingId = null;
 
-            configuration.incrementsProgress();
+            AcousticImportModel csvModel = new AcousticImportModel(getCsvSeparator(), instrumentsById, dataQualityMap);
 
-            Set<String> createdDataAcquisitions = Sets.newHashSet();
+            try (Import<AcousticImportRow> importer = Import.newImport(csvModel, reader)) {
+                DataAcquisition dataAcquisition = null;
+                DataProcessing dataProcessing = null;
 
-            for (AcousticImportRow row : importer) {
+                Cell elementaryCell;
+                int rowNumber = 0;
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
+                configuration.incrementsProgress();
 
-                if (dataProcessingId == null) {
-
-                    // compute once for all the common dataprocessing id used
-                    // for hole the movies file
-                    dataProcessingId = row.getEiLayer() +
-                                       configuration.getProcessingTemplate();
-                }
+                Set<String> createdDataAcquisitions = Sets.newHashSet();
 
-                Date startDate = row.getCellDateStart();
-                Date endDate = row.getCellDateEnd();
-
-                // get transect to use
-                Transit transit = voyage.getTransit(startDate);
-                if (transit == null) {
-
-                    // can not find correct transit
-                    throw new ImportException(
-                            l(locale, "echobase.importError.transit.notfound",
-                              voyage.getName(),
-                              startDate,
-                              rowNumber));
-                }
+                for (AcousticImportRow row : importer) {
 
-                Transect transect = transit.getTransect(vessel);
-                if (transect == null) {
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
 
-                    // can not find correct transect
-                    throw new ImportException(
-                            l(locale, "echobase.importError.transect.notfound",
-                              voyage.getName(),
-                              startDate,
-                              vessel.getName(),
-                              rowNumber));
-                }
+                    if (dataProcessingId == null) {
 
-                AcousticInstrument instrument = row.getAcousticInstrument();
-                boolean isME70 =
-                        AcousticInstruments.IS_ACOUSTIC_INSTRUMENT_ME70.apply(instrument);
+                        // compute once for all the common dataprocessing id used
+                        // for hole the movies file
+                        dataProcessingId = row.getEiLayer() + configuration.getProcessingTemplate();
+                    }
 
-                if (dataAcquisition == null ||
-                    !instrument.equals(dataAcquisition.getAcousticInstrument())) {
+                    Date startDate = row.getCellDateStart();
+                    Date endDate = row.getCellDateEnd();
 
-                    // need to use another data acquisition
+                    // get transect to use
+                    Transit transit = voyage.getTransit(startDate);
+                    if (transit == null) {
 
-                    if (log.isDebugEnabled()) {
-                        log.debug("[row " + rowNumber +
-                                  "] New instrument to use (" +
-                                  instrument.getId() + ")");
+                        // can not find correct transit
+                        throw new TransitNotFoundException(locale, voyage, startDate, rowNumber);
                     }
 
-                    if (CollectionUtils.isNotEmpty(elementaryCells)) {
+                    Transect transect = transit.getTransect(vessel);
+                    if (transect == null) {
 
-                        // means miss a esdu cell
                         // can not find correct transect
-                        throw new ImportException(
-                                l(locale, "echobase.importError.esduCell.notfound",
-                                  voyage.getName(),
-                                  vessel.getName(),
-                                  instrument.getId(),
-                                  rowNumber));
+                        throw new TransectNotFoundException(locale, voyage, vessel, startDate, rowNumber);
                     }
 
-                    String softwareVersion =
-                            getSoftwareVersion(configuration, isME70);
-
-                    String soundSpeedCalculations =
-                            getSoundSpeedCalculations(configuration, isME70);
-
-                    // try to get existing data acquisition
-                    dataAcquisition = getDataAcquisition(
-                            transect,
-                            instrument,
-                            addDataAcquisition
-                    );
+                    AcousticInstrument instrument = row.getAcousticInstrument();
+                    boolean isME70 = AcousticInstruments.IS_ACOUSTIC_INSTRUMENT_ME70.apply(instrument);
 
-                    if (dataAcquisition == null) {
+                    if (dataAcquisition == null || !instrument.equals(dataAcquisition.getAcousticInstrument())) {
 
-                        // need to create the data acquisition
-                        dataAcquisition = createDataAcquisition(
-                                configuration,
-                                instrument,
-                                softwareVersion,
-                                soundSpeedCalculations,
-                                row);
-
-                        // collect id of the import
-                        importResult.addId(EchoBaseUserEntityEnum.DataAcquisition,
-                                           dataAcquisition);
-                        createdDataAcquisitions.add(
-                                dataAcquisition.getTopiaId());
-
-                        // add dataAcquisition to transect
-                        transect.addDataAcquisition(dataAcquisition);
+                        // need to use another data acquisition
 
                         if (log.isDebugEnabled()) {
-                            log.debug("[row " + rowNumber +
-                                      "] New dataAquisition to use (number: " +
-                                      importResult.getNumberCreated(
-                                              EchoBaseUserEntityEnum.DataAcquisition) + ")");
+                            log.debug("[row " + rowNumber + "] New instrument to use (" + instrument.getId() + ")");
                         }
 
-                        // create data processing
-                        dataProcessing = createDataProcessing(
-                                configuration,
-                                dataProcessingId,
-                                softwareVersion,
-                                soundSpeedCalculations,
-                                row);
+                        if (CollectionUtils.isNotEmpty(elementaryCells)) {
 
-                        if (log.isDebugEnabled()) {
-                            log.debug("[row " + rowNumber +
-                                      "] New dataProcessing to use (" +
-                                      dataProcessing.getId() + ")");
+                            // means miss a esdu cell
+                            // can not find correct transect
+                            throw new EsduCellNotFoundException(locale, voyage, vessel, instrument, rowNumber);
                         }
 
-                        importResult.incrementsNumberCreated(
-                                EchoBaseUserEntityEnum.DataProcessing);
+                        String softwareVersion = getSoftwareVersion(configuration, isME70);
 
-                        // add it to data acquisition
-                        dataAcquisition.addDataProcessing(dataProcessing);
-                    }
-                }
+                        String soundSpeedCalculations = getSoundSpeedCalculations(configuration, isME70);
 
-                int cellType = row.getCellType();
+                        // try to get existing data acquisition
+                        dataAcquisition = getDataAcquisition(transect, instrument, addDataAcquisition);
 
-                String esduCellId = cellDateFormat.format(endDate);
+                        if (dataAcquisition == null) {
 
-                String previousLastEsduId = lastEsduId;
+                            // need to create the data acquisition
+                            dataAcquisition = createDataAcquisition(configuration, instrument, softwareVersion, soundSpeedCalculations, row);
 
-                if (lastEsduId == null || !lastEsduId.equals(esduCellId)) {
+                            // collect id of the import
+                            importResult.addId(EchoBaseUserEntityEnum.DataAcquisition, dataAcquisition);
+                            createdDataAcquisitions.add(dataAcquisition.getTopiaId());
 
-                    lastEsduId = esduCellId;
-                    // find a new esdu cell id
-                    if (log.isDebugEnabled()) {
-                        log.debug("row: " + rowNumber + " - detects new esduCellId:" + lastEsduId);
-                    }
-                }
-                boolean isEsduCell = cellType == 4;
+                            // add dataAcquisition to transect
+                            transect.addDataAcquisition(dataAcquisition);
 
-                if (isEsduCell) {
+                            if (log.isDebugEnabled()) {
+                                log.debug("[row " + rowNumber + "] New dataAquisition to use (number: " + importResult.getNumberCreated(EchoBaseUserEntityEnum.DataAcquisition) + ")");
+                            }
 
-                    if (!esduCellId.equals(previousLastEsduId)) {
+                            // create data processing
+                            dataProcessing = createDataProcessing(
+                                    configuration,
+                                    dataProcessingId,
+                                    softwareVersion,
+                                    soundSpeedCalculations,
+                                    row);
 
-                        // This should not happen ?
-                        if (log.isWarnEnabled()) {
-                            log.warn("row: "+rowNumber+" A previous esduCellId was detected ("+previousLastEsduId+"); but the esdu id was never found.");
+                            if (log.isDebugEnabled()) {
+                                log.debug("[row " + rowNumber +
+                                                  "] New dataProcessing to use (" +
+                                                  dataProcessing.getId() + ")");
+                            }
+
+                            importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.DataProcessing);
+
+                            // add it to data acquisition
+                            dataAcquisition.addDataProcessing(dataProcessing);
                         }
                     }
-                    if (log.isDebugEnabled()) {
-                        log.debug("row: " + rowNumber + " - found esdu cell:" + lastEsduId);
-                    }
-                }
 
-                if (!row.isCellToAdd()) {
+                    int cellType = row.getCellType();
 
-                    // dead cell not to be imported
+                    String esduCellId = cellDateFormat.format(endDate);
 
-                    String id = rowNumber + " - " + cellType + " : " + esduCellId;
-                    if (isEsduCell) {
+                    String previousLastEsduId = lastEsduId;
 
-                        // keep this fact into import result
-                        if (log.isWarnEnabled()) {
-                            log.warn("Will not import esdu cell of row " + id);
+                    if (lastEsduId == null || !lastEsduId.equals(esduCellId)) {
+
+                        lastEsduId = esduCellId;
+                        // find a new esdu cell id
+                        if (log.isDebugEnabled()) {
+                            log.debug("row: " + rowNumber + " - detects new esduCellId:" + lastEsduId);
                         }
-                        importResult.addNotImportedEsduCellId(id);
-                    } else {
+                    }
+                    boolean isEsduCell = cellType == 4;
 
-                        // just a debug log
-                        if (log.isTraceEnabled()) {
-                            log.trace("Will not import cell of row " + id);
+                    if (isEsduCell) {
+
+                        if (!esduCellId.equals(previousLastEsduId)) {
+
+                            // This should not happen ?
+                            if (log.isWarnEnabled()) {
+                                log.warn("row: " + rowNumber + " A previous esduCellId was detected (" + previousLastEsduId + "); but the esdu id was never found.");
+                            }
+                        }
+                        if (log.isDebugEnabled()) {
+                            log.debug("row: " + rowNumber + " - found esdu cell:" + lastEsduId);
                         }
                     }
 
-                    continue;
-                }
+                    if (!row.isCellToAdd()) {
 
-                DataQuality dataQuality = row.getDataQuality();
+                        // dead cell not to be imported
 
-                // collect Esdu cellIds only if dataAcquisitions was not created here
-                boolean collectCellIds = !createdDataAcquisitions.contains(
-                        dataAcquisition.getTopiaId());
+                        String id = rowNumber + " - " + cellType + " : " + esduCellId;
+                        if (isEsduCell) {
 
+                            // keep this fact into import result
+                            if (log.isWarnEnabled()) {
+                                log.warn("Will not import esdu cell of row " + id);
+                            }
+                            importResult.addNotImportedEsduCellId(id);
+                        } else {
 
-                if (isEsduCell) {
+                            // just a debug log
+                            if (log.isTraceEnabled()) {
+                                log.trace("Will not import cell of row " + id);
+                            }
+                        }
 
-                    if (log.isDebugEnabled()) {
-                        log.debug("[row " + rowNumber + "] Esdu cell (" +
-                                  esduCellId + ")");
+                        continue;
                     }
 
-                    // this is a esdu cell row
+                    DataQuality dataQuality = row.getDataQuality();
 
-                    // create esdu cell
-                    Cell esduCell = persistenceService.createCell(
-                            esduCellType, esduCellId);
+                    // collect Esdu cellIds only if dataAcquisitions was not created here
+                    boolean collectCellIds = !createdDataAcquisitions.contains(dataAcquisition.getTopiaId());
 
-                    esduCell.setDataQuality(dataQuality);
 
-                    // add all found elementary cells
-                    esduCell.addAllChilds(elementaryCells);
+                    if (isEsduCell) {
 
-                    // clear elementary cells
-                    elementaryCells.clear();
+                        if (log.isDebugEnabled()) {
+                            log.debug("[row " + rowNumber + "] Esdu cell (" + esduCellId + ")");
+                        }
 
-                    if (collectCellIds) {
+                        // this is a esdu cell row
 
-                        // collect ids (dataProcessing already exists)
-                        importResult.addId(EchoBaseUserEntityEnum.Cell, esduCell);
-                    } else {
+                        // create esdu cell
+                        Cell esduCell = persistenceService.createCell(esduCellType, esduCellId);
 
-                        importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.Cell);
-                    }
+                        esduCell.setDataQuality(dataQuality);
 
-                    // add it to data processing
-                    dataProcessing.addCell(esduCell);
+                        // add all found elementary cells
+                        esduCell.addAllChilds(elementaryCells);
 
-                    // create esdu cell data
-                    createEsduCellData(suffix,
-                                       esduCell,
-                                       dataMetadatasByName,
-                                       row,
-                                       dataQuality,
-                                       importResult);
-                } else {
+                        // clear elementary cells
+                        elementaryCells.clear();
 
-                    // this is a elementary cell row
+                        if (collectCellIds) {
 
-                    int cellNum = row.getCellNum();
+                            // collect ids (dataProcessing already exists)
+                            importResult.addId(EchoBaseUserEntityEnum.Cell, esduCell);
+                        } else {
 
-                    boolean surface = cellType == 0;
+                            importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.Cell);
+                        }
 
-                    String elementaryCellId = cellNum + (surface ? "S" : "B");
+                        // add it to data processing
+                        dataProcessing.addCell(esduCell);
 
-                    if (log.isTraceEnabled()) {
-                        log.trace("[row " + rowNumber + "] elementary cell (" + elementaryCellId + ")");
-                    }
+                        // create esdu cell data
+                        createEsduCellData(suffix,
+                                           esduCell,
+                                           dataMetadatasByName,
+                                           row,
+                                           dataQuality,
+                                           importResult);
+                    } else {
+
+                        // this is a elementary cell row
+
+                        int cellNum = row.getCellNum();
 
-                    // create the elementary cell
-                    elementaryCell = persistenceService.createCell(
-                            elementaryCellType, elementaryCellId);
-                    elementaryCell.setDataQuality(dataQuality);
+                        boolean surface = cellType == 0;
 
-                    // keep (to attach them to esdu cell)
-                    elementaryCells.add(elementaryCell);
+                        String elementaryCellId = cellNum + (surface ? "S" : "B");
+
+                        if (log.isTraceEnabled()) {
+                            log.trace("[row " + rowNumber + "] elementary cell (" + elementaryCellId + ")");
+                        }
 
-                    importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.Cell);
+                        // create the elementary cell
+                        elementaryCell = persistenceService.createCell(
+                                elementaryCellType, elementaryCellId);
+                        elementaryCell.setDataQuality(dataQuality);
 
-                    // create datas of the elementary cell
-                    createElementaryCellData(suffix,
-                                             elementaryCell,
-                                             dataMetadatasByName,
-                                             surface,
-                                             row,
-                                             dataQuality,
-                                             importResult);
+                        // keep (to attach them to esdu cell)
+                        elementaryCells.add(elementaryCell);
+
+                        importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.Cell);
+
+                        // create datas of the elementary cell
+                        createElementaryCellData(suffix,
+                                                 elementaryCell,
+                                                 dataMetadatasByName,
+                                                 surface,
+                                                 row,
+                                                 dataQuality,
+                                                 importResult);
+                    }
                 }
             }
 
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(locale, inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
+
     }
 
     @Override
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CatchesImportConfiguration.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CatchesImportConfiguration.java
index 660ff63..4878cbc 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CatchesImportConfiguration.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CatchesImportConfiguration.java
@@ -47,12 +47,9 @@ public class CatchesImportConfiguration extends AbstractImportConfiguration {
     protected final InputFile biometrySampleFile;
 
     public CatchesImportConfiguration(Locale locale) {
-        totalSampleFile = InputFile.newFile(
-                l(locale, "echobase.common.totalSampleFile"));
-        subSampleFile = InputFile.newFile(
-                l(locale, "echobase.common.subSampleFile"));
-        biometrySampleFile = InputFile.newFile(
-                l(locale, "echobase.common.biometrySampleFile"));
+        totalSampleFile = InputFile.newFile(l(locale, "echobase.common.totalSampleFile"));
+        subSampleFile = InputFile.newFile(l(locale, "echobase.common.subSampleFile"));
+        biometrySampleFile = InputFile.newFile(l(locale, "echobase.common.biometrySampleFile"));
         importType = ImportType.CATCHES;
     }
 
@@ -69,9 +66,9 @@ public class CatchesImportConfiguration extends AbstractImportConfiguration {
     }
 
     public boolean isOneImportFile() {
-        return totalSampleFile.hasFile() ||
-               subSampleFile.hasFile() ||
-               biometrySampleFile.hasFile();
+        return totalSampleFile.hasFile()
+                || subSampleFile.hasFile()
+                || biometrySampleFile.hasFile();
     }
 
     @Override
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CatchesImportService.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CatchesImportService.java
index fb53f54..97adccb 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CatchesImportService.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CatchesImportService.java
@@ -26,10 +26,10 @@ import com.google.common.collect.Maps;
 import fr.ifremer.echobase.entities.EchoBaseUser;
 import fr.ifremer.echobase.entities.EchoBaseUserEntityEnum;
 import fr.ifremer.echobase.entities.data.Operation;
+import fr.ifremer.echobase.entities.data.Operations;
 import fr.ifremer.echobase.entities.data.Sample;
 import fr.ifremer.echobase.entities.data.SampleData;
 import fr.ifremer.echobase.entities.data.Voyage;
-import fr.ifremer.echobase.entities.data.Operations;
 import fr.ifremer.echobase.entities.references.SampleDataType;
 import fr.ifremer.echobase.entities.references.SampleDataTypeImpl;
 import fr.ifremer.echobase.entities.references.SampleDataTypes;
@@ -54,6 +54,7 @@ import org.apache.commons.logging.LogFactory;
 import org.nuiton.csv.Import;
 import org.nuiton.csv.ImportRuntimeException;
 
+import java.io.IOException;
 import java.io.Reader;
 import java.util.Collection;
 import java.util.Locale;
@@ -70,101 +71,75 @@ import static org.nuiton.i18n.I18n.l;
 public class CatchesImportService extends AbstractImportDataService<CatchesImportConfiguration> {
 
     /** Logger. */
-    private static final Log log =
-            LogFactory.getLog(CatchesImportService.class);
+    private static final Log log = LogFactory.getLog(CatchesImportService.class);
 
     @Override
-    protected void startImport(CatchesImportConfiguration configuration,
-                               EchoBaseUser user) throws ImportException {
+    protected void startImport(CatchesImportConfiguration configuration, EchoBaseUser user) throws ImportException {
 
-        Voyage voyage = persistenceService.getVoyage(
-                configuration.getVoyageId());
+        Voyage voyage = persistenceService.getVoyage(configuration.getVoyageId());
 
         // get all operation for this voyage and this vessel
         Collection<Operation> operations = voyage.getAllOperations();
 
         // split them by operation Id
-        Map<String, Operation> operationMap = Maps.uniqueIndex(
-                operations, Operations.OPERATION_ID);
-
-        Map<String, Species> speciesMap = persistenceService.getEntitiesMap(
-                Species.class,
-                Species2.SPECIES_BARACOUDA_CODE);
-
-        Map<String, SizeCategory> sizeCategoryMap = persistenceService.getEntitiesMap(
-                SizeCategory.class,
-                SizeCategories.SIZE_CATEGORY_NAME);
+        Map<String, Operation> operationMap = Maps.uniqueIndex(operations, Operations.OPERATION_ID);
 
+        Map<String, Species> speciesMap = persistenceService.getEntitiesMap(Species.class, Species2.SPECIES_BARACOUDA_CODE);
 
-        InputFile inputFile;
-        EchoBaseCsvFileImportResult importResult;
+        Map<String, SizeCategory> sizeCategoryMap = persistenceService.getEntitiesMap(SizeCategory.class, SizeCategories.SIZE_CATEGORY_NAME);
 
-        inputFile = configuration.getTotalSampleFile();
-        if (inputFile.hasFile()) {
+        InputFile totalSampleFile = configuration.getTotalSampleFile();
+        if (totalSampleFile.hasFile()) {
 
-            importResult = importTotalSampleFile(
-                    configuration,
-                    inputFile,
-                    operationMap,
-                    speciesMap,
-                    sizeCategoryMap);
+            EchoBaseCsvFileImportResult importResult = importTotalSampleFile(configuration,
+                                                                             totalSampleFile,
+                                                                             operationMap,
+                                                                             speciesMap,
+                                                                             sizeCategoryMap);
             configuration.addResult(importResult);
+
         }
 
-        // build for each operation the one with at least one sample typed
-        // *total* or *unsorted*
+        // build for each operation the one with at least one sample typed *total* or *unsorted*
 
-        Collection<Operation> operationWithTotalOrUnsortedSample =
-                Collections2.filter(
-                        operations,
-                        Operations.OPERATION_WITH_TOTAL_OR_UNSORTED_SAMPLE);
+        Collection<Operation> operationWithTotalOrUnsortedSample = Collections2.filter(operations, Operations.OPERATION_WITH_TOTAL_OR_UNSORTED_SAMPLE);
 
-        inputFile = configuration.getSubSampleFile();
-        if (inputFile.hasFile()) {
+        InputFile subSampleFile = configuration.getSubSampleFile();
+        if (subSampleFile.hasFile()) {
 
-            importResult = importSubSampleFile(
-                    configuration,
-                    inputFile,
-                    operationMap,
-                    operationWithTotalOrUnsortedSample,
-                    speciesMap,
-                    sizeCategoryMap);
+            EchoBaseCsvFileImportResult importResult = importSubSampleFile(configuration,
+                                                                           subSampleFile,
+                                                                           operationMap,
+                                                                           operationWithTotalOrUnsortedSample,
+                                                                           speciesMap,
+                                                                           sizeCategoryMap);
             configuration.addResult(importResult);
-        }
 
-        inputFile = configuration.getBiometrySampleFile();
-        if (inputFile.hasFile()) {
+        }
 
-            importResult = importBiometrySampleFile(
-                    configuration,
-                    inputFile,
-                    operationMap,
-                    operationWithTotalOrUnsortedSample,
-                    speciesMap);
+        InputFile biometrySampleFile = configuration.getBiometrySampleFile();
+        if (biometrySampleFile.hasFile()) {
 
+            EchoBaseCsvFileImportResult importResult = importBiometrySampleFile(configuration,
+                                                                                biometrySampleFile,
+                                                                                operationMap,
+                                                                                operationWithTotalOrUnsortedSample,
+                                                                                speciesMap);
             configuration.addResult(importResult);
+
         }
     }
 
-    private EchoBaseCsvFileImportResult importTotalSampleFile(
-            CatchesImportConfiguration configuration,
-            InputFile inputFile,
-            Map<String, Operation> operationMap,
-            Map<String, Species> speciesMap,
-            Map<String, SizeCategory> sizeCategoryMap) throws ImportException {
+    private EchoBaseCsvFileImportResult importTotalSampleFile(CatchesImportConfiguration configuration,
+                                                              InputFile inputFile,
+                                                              Map<String, Operation> operationMap,
+                                                              Map<String, Species> speciesMap,
+                                                              Map<String, SizeCategory> sizeCategoryMap) throws ImportException {
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of totalSample from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of totalSample from file " + inputFile.getFileName());
         }
 
-        EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
-
-        TotalSampleImportModel csvModel = new TotalSampleImportModel(getCsvSeparator(),
-                                                                     operationMap,
-                                                                     speciesMap,
-                                                                     sizeCategoryMap
-        );
 
         SampleType sampleTypeTotal = persistenceService.getSampleTypeByName(SampleTypeImpl.TOTAL_SAMPLE_TYPE);
         SampleType sampleTypeUnsorted = persistenceService.getSampleTypeByName(SampleTypeImpl.UNSORTED_SAMPLE_TYPE);
@@ -174,234 +149,186 @@ public class CatchesImportService extends AbstractImportDataService<CatchesImpor
         SampleDataType sampleDataTypeMeanWeight = persistenceService.getSampleDataTypeByName(SampleDataTypeImpl.MEAN_WEIGHTG);
         SampleDataType sampleDataTypeNoPerKg = persistenceService.getSampleDataTypeByName(SampleDataTypeImpl.NO_PER_KG);
 
-        Reader reader = getInputFileReader(inputFile);
         Locale locale = getLocale();
-        try {
-            Import<TotalSampleImportRow> importer =
-                    Import.newImport(csvModel, reader);
 
-            int rowNumber = 0;
-            configuration.incrementsProgress();
-            for (TotalSampleImportRow row : importer) {
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
-                Operation operation = row.getOperation();
+            EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-                Species species = row.getSpecies();
-                SizeCategory sizeCategory = row.getSizeCategory();
+            TotalSampleImportModel csvModel = new TotalSampleImportModel(getCsvSeparator(), operationMap, speciesMap, sizeCategoryMap);
 
-                SpeciesCategory category = getSpeciesCategory(
-                        species,
-                        sizeCategory,
-                        null,
-                        null,
-                        importResult);
+            try (Import<TotalSampleImportRow> importer = Import.newImport(csvModel, reader)) {
 
-                SampleType sampleType;
 
-                if (SizeCategories.IS_HORS_VRAC.apply(sizeCategory)) {
+                int rowNumber = 0;
+                configuration.incrementsProgress();
+                for (TotalSampleImportRow row : importer) {
 
-                    // hors vrac case
-                    sampleType = sampleTypeUnsorted;
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
+                    Operation operation = row.getOperation();
 
-                } else {
-                    // none hors vrac case
-                    sampleType = sampleTypeTotal;
-                }
+                    Species species = row.getSpecies();
+                    SizeCategory sizeCategory = row.getSizeCategory();
 
-                Sample sample = operation.getSample(category, sampleType);
+                    SpeciesCategory category = getSpeciesCategory(species, sizeCategory, null, null, importResult);
 
-                if (sample != null) {
+                    SampleType sampleType;
 
-                    // can not have twice same sample
-                    throw new ImportException(
-                            l(locale, "echobase.importError.duplicate.sample",
-                               operation.getId(),
-                               sampleType.getName(),
-                               species.getBaracoudaCode(),
-                               sizeCategory.getName()));
-                }
+                    if (SizeCategories.IS_HORS_VRAC.apply(sizeCategory)) {
 
+                        // hors vrac case
+                        sampleType = sampleTypeUnsorted;
 
-                // must create it
+                    } else {
+                        // none hors vrac case
+                        sampleType = sampleTypeTotal;
+                    }
 
-                sample = row.getSample();
-                sample.setSpeciesCategory(category);
-                sample.setSampleType(sampleType);
-                sample = addSample(operation, sample, importResult);
+                    Sample sample = operation.getSample(category, sampleType);
 
-                // create datas
+                    if (sample != null) {
 
-                if (row.getMeanLength() != null) {
+                        // can not have twice same sample
+                        throw new ImportException(l(locale, "echobase.importError.duplicate.sample",
+                                                    operation.getId(),
+                                                    sampleType.getName(),
+                                                    species.getBaracoudaCode(),
+                                                    sizeCategory.getName()));
+                    }
 
-                    //create meanLength data
-                    addSampleData(sampleDataTypeMeanLength,
-                                  null,
-                                  row.getMeanLength(),
-                                  sample,
-                                  importResult);
-                }
 
-                if (row.getMeanWeight() != null) {
+                    // must create it
 
-                    //create meanWeight data
-                    addSampleData(sampleDataTypeMeanWeight,
-                                  null,
-                                  row.getMeanWeight(),
-                                  sample,
-                                  importResult);
-                }
+                    sample = row.getSample();
+                    sample.setSpeciesCategory(category);
+                    sample.setSampleType(sampleType);
+                    sample = addSample(operation, sample, importResult);
 
-                if (row.getNoPerKg() != null) {
+                    // create datas
 
-                    //create noPerKg data
-                    addSampleData(sampleDataTypeNoPerKg,
-                                  null,
-                                  row.getNoPerKg(),
-                                  sample,
-                                  importResult);
-                }
+                    if (row.getMeanLength() != null) {
+
+                        //create meanLength data
+                        addSampleData(sampleDataTypeMeanLength, null, row.getMeanLength(), sample, importResult);
+                    }
+
+                    if (row.getMeanWeight() != null) {
+
+                        //create meanWeight data
+                        addSampleData(sampleDataTypeMeanWeight, null, row.getMeanWeight(), sample, importResult);
+                    }
 
-                Sample createdSortedSample = persistenceService.newSample();
-                createdSortedSample.setSampleType(sampleTypeSorted);
-                createdSortedSample.setSampleWeight(row.getSortedWeight());
+                    if (row.getNoPerKg() != null) {
 
-                // create sorted sample
-                createdSortedSample = addSample(
-                        operation,
-                        createdSortedSample,
-                        importResult);
+                        //create noPerKg data
+                        addSampleData(sampleDataTypeNoPerKg, null, row.getNoPerKg(), sample, importResult);
+                    }
+
+                    Sample createdSortedSample = persistenceService.newSample();
+                    createdSortedSample.setSampleType(sampleTypeSorted);
+                    createdSortedSample.setSampleWeight(row.getSortedWeight());
+
+                    // create sorted sample
+                    createdSortedSample = addSample(operation, createdSortedSample, importResult);
+                }
             }
 
             return importResult;
-        } catch (ImportRuntimeException e) {
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(locale, inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
+
     }
 
-    private EchoBaseCsvFileImportResult importSubSampleFile(
-            CatchesImportConfiguration configuration,
-            InputFile inputFile,
-            Map<String, Operation> operationMap,
-            Collection<Operation> operationWithTotalOrUnsortedSample,
-            Map<String, Species> speciesMap,
-            Map<String, SizeCategory> sizeCategoryMap
-    ) throws ImportException {
+    private EchoBaseCsvFileImportResult importSubSampleFile(CatchesImportConfiguration configuration,
+                                                            InputFile inputFile,
+                                                            Map<String, Operation> operationMap,
+                                                            Collection<Operation> operationWithTotalOrUnsortedSample,
+                                                            Map<String, Species> speciesMap,
+                                                            Map<String, SizeCategory> sizeCategoryMap) throws ImportException {
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of subSample from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of subSample from file " + inputFile.getFileName());
         }
 
-        Map<String, SexCategory> sexCategoryMap = persistenceService.getEntitiesMap(
-                SexCategory.class,
-                SexCategories.SEX_CATEGORY_NAME);
-
-
-        EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
-
-        SubSampleImportModel csvModel = new SubSampleImportModel(
-                getCsvSeparator(),
-                operationMap,
-                speciesMap,
-                sizeCategoryMap,
-                sexCategoryMap);
-
+        Map<String, SexCategory> sexCategoryMap = persistenceService.getEntitiesMap(SexCategory.class, SexCategories.SEX_CATEGORY_NAME);
         SampleType sampleTypeSubsample = persistenceService.getSampleTypeByName(SampleTypeImpl.SUB_SAMPLE_TYPE);
-
         SampleDataType sampleDataTypeNumberAtLength = persistenceService.getSampleDataTypeByName(SampleDataTypeImpl.NUMBER_AT_LENGTH);
         SampleDataType sampleDataTypeNumberAtLength05cm = persistenceService.getSampleDataTypeByName(SampleDataTypeImpl.LTCM0_5);
         SampleDataType sampleDataTypeNumberAtLength1cm = persistenceService.getSampleDataTypeByName(SampleDataTypeImpl.L_TCM_1);
         SampleDataType sampleDataTypeWeightAtLength = persistenceService.getSampleDataTypeByName(SampleDataTypeImpl.WEIGHT_AT_LENGTHKG);
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<SubSampleImportRow> importer =
-                    Import.newImport(csvModel, reader);
+        EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-            configuration.incrementsProgress();
-            int rowNumber = 0;
-            for (SubSampleImportRow row : importer) {
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
-                Operation operation = row.getOperation();
+            SubSampleImportModel csvModel = new SubSampleImportModel(getCsvSeparator(),
+                                                                     operationMap,
+                                                                     speciesMap,
+                                                                     sizeCategoryMap,
+                                                                     sexCategoryMap);
 
-                checkOperationWithTotalOrUnsortedSample(
-                        rowNumber,
-                        operationWithTotalOrUnsortedSample,
-                        operation);
+            try (Import<SubSampleImportRow> importer = Import.newImport(csvModel, reader)) {
 
-                Species species = row.getSpecies();
-                SizeCategory sizeCategory = row.getSizeCategory();
-                SexCategory sexCategory = row.getSexCategory();
+                configuration.incrementsProgress();
+                int rowNumber = 0;
+                for (SubSampleImportRow row : importer) {
 
-                SpeciesCategory category = getSpeciesCategory(species,
-                                                              sizeCategory,
-                                                              null,
-                                                              sexCategory,
-                                                              importResult);
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
+                    Operation operation = row.getOperation();
 
-                // find the sample with this category
-                Sample sample = operation.getSample(category,
-                                                    sampleTypeSubsample);
+                    checkOperationWithTotalOrUnsortedSample(rowNumber, operationWithTotalOrUnsortedSample, operation);
 
-                if (sample == null) {
+                    Species species = row.getSpecies();
+                    SizeCategory sizeCategory = row.getSizeCategory();
+                    SexCategory sexCategory = row.getSexCategory();
 
-                    // must create it
-                    sample = row.getSample();
+                    SpeciesCategory category = getSpeciesCategory(species, sizeCategory, null, sexCategory, importResult);
 
-                    sample.setSpeciesCategory(category);
-                    sample.setSampleType(sampleTypeSubsample);
+                    // find the sample with this category
+                    Sample sample = operation.getSample(category, sampleTypeSubsample);
 
-                    sample = addSample(operation,
-                                       sample,
-                                       importResult);
-                }
+                    if (sample == null) {
 
-                Integer round = row.getRound();
-                SampleDataType dataType = sampleDataTypeNumberAtLength;
+                        // must create it
+                        sample = row.getSample();
 
-                if (round == null) {
-                    dataType = sampleDataTypeNumberAtLength;
-                } else if (round == 5) {
-                    dataType = sampleDataTypeNumberAtLength05cm;
-                } else if (round == 1) {
-                    dataType = sampleDataTypeNumberAtLength1cm;
-                }
+                        sample.setSpeciesCategory(category);
+                        sample.setSampleType(sampleTypeSubsample);
+
+                        sample = addSample(operation, sample, importResult);
+                    }
+
+                    Integer round = row.getRound();
+                    SampleDataType dataType = sampleDataTypeNumberAtLength;
+
+                    if (round == null) {
+                        dataType = sampleDataTypeNumberAtLength;
+                    } else if (round == 5) {
+                        dataType = sampleDataTypeNumberAtLength05cm;
+                    } else if (round == 1) {
+                        dataType = sampleDataTypeNumberAtLength1cm;
+                    }
+
+                    //create numberAtLength data
+                    addSampleData(dataType, "" + row.getLengthClass(), row.getNumberAtLength(), sample, importResult);
 
-                //create numberAtLength data
-                addSampleData(dataType,
-                              "" + row.getLengthClass(),
-                              row.getNumberAtLength(),
-                              sample,
-                              importResult);
-
-                if (row.getWeightAtLength() != null) {
-
-                    //create weightAtLength data
-                    addSampleData(sampleDataTypeWeightAtLength,
-                                  "" + row.getLengthClass(),
-                                  row.getWeightAtLength(),
-                                  sample,
-                                  importResult);
+                    if (row.getWeightAtLength() != null) {
+
+                        //create weightAtLength data
+                        addSampleData(sampleDataTypeWeightAtLength, "" + row.getLengthClass(), row.getWeightAtLength(), sample, importResult);
+                    }
                 }
             }
 
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
     }
 
-    private void checkOperationWithTotalOrUnsortedSample(
-            int rowNumber,
-            Collection<Operation> operationWithTotalOrUnsortedSample,
-            Operation operation
-    ) throws ImportException {
+    private void checkOperationWithTotalOrUnsortedSample(int rowNumber, Collection<Operation> operationWithTotalOrUnsortedSample, Operation operation) throws ImportException {
         if (!operationWithTotalOrUnsortedSample.contains(operation)) {
 
             // can not accept this import
@@ -409,127 +336,98 @@ public class CatchesImportService extends AbstractImportDataService<CatchesImpor
         }
     }
 
-    private EchoBaseCsvFileImportResult importBiometrySampleFile(
-            CatchesImportConfiguration configuration,
-            InputFile inputFile,
-            Map<String, Operation> operationMap,
-            Collection<Operation> operationWithTotalOrUnsortedSample, Map<String, Species> speciesMap
-    ) throws ImportException {
+    private EchoBaseCsvFileImportResult importBiometrySampleFile(CatchesImportConfiguration configuration,
+                                                                 InputFile inputFile,
+                                                                 Map<String, Operation> operationMap,
+                                                                 Collection<Operation> operationWithTotalOrUnsortedSample, Map<String, Species> speciesMap) throws ImportException {
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of biometrySample from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of biometrySample from file " + inputFile.getFileName());
         }
 
-        Map<String, SampleDataType> sampleDataTypeMap = persistenceService.getEntitiesMap(
-                SampleDataType.class,
-                SampleDataTypes.SAMPLE_DATA_TYPE_NAME);
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-        EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
+            Map<String, SampleDataType> sampleDataTypeMap = persistenceService.getEntitiesMap(SampleDataType.class, SampleDataTypes.SAMPLE_DATA_TYPE_NAME);
+            SampleType sampleTypeIndividual = persistenceService.getSampleTypeByName(SampleTypeImpl.INDIVIDUAL_SAMPLE_TYPE);
+            Map<String, Sample> samples = Maps.newTreeMap();
 
-        BiometrySampleImportModel csvModel =
-                new BiometrySampleImportModel(getCsvSeparator(),
-                                              operationMap,
-                                              speciesMap,
-                                              sampleDataTypeMap);
+            EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
+            BiometrySampleImportModel csvModel = new BiometrySampleImportModel(getCsvSeparator(),
+                                                                               operationMap,
+                                                                               speciesMap,
+                                                                               sampleDataTypeMap);
 
-        SampleType sampleTypeIndividual = persistenceService.getSampleTypeByName(SampleTypeImpl.INDIVIDUAL_SAMPLE_TYPE);
+            try (Import<BiometrySampleImportRow> importer = Import.newImport(csvModel, reader)) {
 
-        Map<String, Sample> samples = Maps.newTreeMap();
+                configuration.incrementsProgress();
+                int rowNumber = 0;
+                for (BiometrySampleImportRow row : importer) {
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<BiometrySampleImportRow> importer = Import.newImport(
-                    csvModel, reader);
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
 
-            configuration.incrementsProgress();
-            int rowNumber = 0;
-            for (BiometrySampleImportRow row : importer) {
+                    Operation operation = row.getOperation();
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
+                    checkOperationWithTotalOrUnsortedSample(rowNumber, operationWithTotalOrUnsortedSample, operation);
 
-                Operation operation = row.getOperation();
+                    Species species = row.getSpecies();
 
-                checkOperationWithTotalOrUnsortedSample(
-                        rowNumber,
-                        operationWithTotalOrUnsortedSample,
-                        operation);
+                    int numFish = row.getNumFish();
 
-                Species species = row.getSpecies();
+                    String sampleKey = operation.getId() + "_" + species.getBaracoudaCode() + "_" + numFish;
 
-                int numFish = row.getNumFish();
+                    Sample sample = samples.get(sampleKey);
 
-                String sampleKey = operation.getId() + "_" +
-                                   species.getBaracoudaCode() + "_" + numFish;
+                    if (sample == null) {
 
-                Sample sample = samples.get(sampleKey);
+                        // create a new sample
+                        sample = persistenceService.newSample();
 
-                if (sample == null) {
+                        sample.setSampleType(sampleTypeIndividual);
 
-                    // create a new sample
-                    sample = persistenceService.newSample();
+                        SpeciesCategory category = getSpeciesCategory(species, null, null, null, importResult);
 
-                    sample.setSampleType(sampleTypeIndividual);
+                        sample.setSpeciesCategory(category);
 
-                    SpeciesCategory category = getSpeciesCategory(
-                            species,
-                            null,
-                            null,
-                            null,
-                            importResult);
+                        sample = addSample(operation, sample, importResult);
 
-                    sample.setSpeciesCategory(category);
+                        samples.put(sampleKey, sample);
+                    }
 
-                    sample = addSample(
-                            operation,
-                            sample,
-                            importResult);
+                    SampleData sampleData = row.getSampleData();
 
-                    samples.put(sampleKey, sample);
-                }
-
-                SampleData sampleData = row.getSampleData();
+                    SampleData sampleDataCreated = persistenceService.createSampleData(sampleData);
+                    sample.addSampleData(sampleDataCreated);
+                    importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.SampleData);
 
-                SampleData sampleDataCreated = persistenceService.createSampleData(sampleData);
-                sample.addSampleData(sampleDataCreated);
-                importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.SampleData);
+                }
             }
 
             return importResult;
-        } catch (ImportRuntimeException e) {
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
+
         }
     }
 
-    private Sample addSample(Operation operation,
-                             Sample sample,
-                             EchoBaseCsvFileImportResult importResult) {
+    private Sample addSample(Operation operation, Sample sample, EchoBaseCsvFileImportResult importResult) {
+
         Preconditions.checkNotNull(operation);
         Preconditions.checkNotNull(sample);
         Sample result = persistenceService.createSample(sample);
         operation.addSample(result);
-
-        // collect ids
         importResult.addId(EchoBaseUserEntityEnum.Sample, sample);
         return result;
+
     }
 
-    private SampleData addSampleData(SampleDataType sampleDataType,
-                                     String label,
-                                     float value,
-                                     Sample sample,
-                                     EchoBaseCsvFileImportResult importResult) {
-        SampleData sampleData = persistenceService.createSampleData(
-                sampleDataType,
-                label,
-                value);
-        sample.addSampleData(sampleData);
+    private SampleData addSampleData(SampleDataType sampleDataType, String label, float value, Sample sample, EchoBaseCsvFileImportResult importResult) {
 
+        SampleData sampleData = persistenceService.createSampleData(sampleDataType, label, value);
+        sample.addSampleData(sampleData);
         importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.SampleData);
         return sampleData;
+
     }
 
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonAllImportService.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonAllImportService.java
index 7815863..0bb4e3a 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonAllImportService.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonAllImportService.java
@@ -45,23 +45,24 @@ public class CommonAllImportService extends AbstractImportDataService<CommonImpo
     CommonTransectImportService commonTransectImportService;
 
     @Override
-    protected void startImport(CommonImportConfiguration configuration,
-                               EchoBaseUser user) throws ImportException {
+    protected void startImport(CommonImportConfiguration configuration, EchoBaseUser user) throws ImportException {
 
         // get usable vessels
-        Map<String, Vessel> vesselMap = persistenceService.getEntitiesMap(
-                Vessel.class, Vessels.VESSEL_NAME);
+        Map<String, Vessel> vesselMap = persistenceService.getEntitiesMap(Vessel.class, Vessels.VESSEL_NAME);
 
-        EchoBaseCsvFileImportResult importResult;
+        {
+            EchoBaseCsvFileImportResult result = commonVoyageImportService.importFile(configuration);
+            configuration.addResult(result);
+        }
+        {
+            EchoBaseCsvFileImportResult result = commonTransitImportService.importFile(configuration, false);
+            configuration.addResult(result);
+        }
+        {
+            EchoBaseCsvFileImportResult result = commonTransectImportService.importFile(vesselMap, configuration, false);
+            configuration.addResult(result);
+        }
 
-        importResult = commonVoyageImportService.importFile(configuration);
-        configuration.addResult(importResult);
-
-        importResult = commonTransitImportService.importFile(configuration, false);
-        configuration.addResult(importResult);
-
-        importResult = commonTransectImportService.importFile(vesselMap, configuration, false);
-        configuration.addResult(importResult);
     }
 
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonImportConfiguration.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonImportConfiguration.java
index 3747ae3..c252fe2 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonImportConfiguration.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonImportConfiguration.java
@@ -70,12 +70,9 @@ public class CommonImportConfiguration extends AbstractImportConfiguration {
     protected final InputFile transectFile;
 
     public CommonImportConfiguration(Locale locale) {
-        voyageFile = InputFile.newFile(
-                l(locale, "echobase.common.voyageFile"));
-        transitFile = InputFile.newFile(
-                l(locale, "echobase.common.transitFile"));
-        transectFile = InputFile.newFile(
-                l(locale, "echobase.common.transectFile"));
+        voyageFile = InputFile.newFile(l(locale, "echobase.common.voyageFile"));
+        transitFile = InputFile.newFile(l(locale, "echobase.common.transitFile"));
+        transectFile = InputFile.newFile(l(locale, "echobase.common.transectFile"));
     }
 
     public String getMissionId() {
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonImportService.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonImportService.java
index d9f3ac7..43b3055 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonImportService.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonImportService.java
@@ -50,8 +50,7 @@ public class CommonImportService extends AbstractImportDataService<CommonImportC
     CommonTransectImportService commonTransectImportService;
 
     @Override
-    public void startImport(CommonImportConfiguration configuration,
-                            EchoBaseUser user) throws ImportException {
+    public void startImport(CommonImportConfiguration configuration, EchoBaseUser user) throws ImportException {
 
         ImportType importMode = configuration.getImportType();
 
@@ -76,8 +75,7 @@ public class CommonImportService extends AbstractImportDataService<CommonImportC
                 break;
 
             default:
-                throw new EchoBaseTechnicalException(
-                        "Can not treate import result of type " + importMode);
+                throw new EchoBaseTechnicalException("Can not treate import result of type " + importMode);
         }
         service.startImport(configuration, user);
     }
@@ -88,8 +86,7 @@ public class CommonImportService extends AbstractImportDataService<CommonImportC
 
         try {
             // check mission name is unique
-            boolean exists = persistenceService.isMissionExistByName(
-                    mission.getName());
+            boolean exists = persistenceService.isMissionExistByName(mission.getName());
 
             if (exists) {
                 throw new MissionNameAlreadyExistException();
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonTransectImportService.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonTransectImportService.java
index d6804a4..1abe541 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonTransectImportService.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonTransectImportService.java
@@ -37,8 +37,9 @@ import org.apache.commons.logging.LogFactory;
 import org.nuiton.csv.Import;
 import org.nuiton.csv.ImportRuntimeException;
 
+import java.io.IOException;
 import java.io.Reader;
-import java.util.Arrays;
+import java.util.Collections;
 import java.util.Date;
 import java.util.Map;
 
@@ -53,17 +54,13 @@ import static org.nuiton.i18n.I18n.l;
 public class CommonTransectImportService extends AbstractImportDataService<CommonImportConfiguration> {
 
     /** Logger. */
-    private static final Log log =
-            LogFactory.getLog(CommonTransectImportService.class);
+    private static final Log log = LogFactory.getLog(CommonTransectImportService.class);
 
     @Override
-    protected void startImport(
-            CommonImportConfiguration configuration,
-            EchoBaseUser user) throws ImportException {
+    protected void startImport(CommonImportConfiguration configuration, EchoBaseUser user) throws ImportException {
 
         // get usable vessels
-        Map<String, Vessel> vesselMap = persistenceService.getEntitiesMap(
-                Vessel.class, Vessels.VESSEL_NAME);
+        Map<String, Vessel> vesselMap = persistenceService.getEntitiesMap(Vessel.class, Vessels.VESSEL_NAME);
 
         EchoBaseCsvFileImportResult importResult;
 
@@ -71,88 +68,70 @@ public class CommonTransectImportService extends AbstractImportDataService<Commo
         configuration.addResult(importResult);
     }
 
-    protected EchoBaseCsvFileImportResult importFile(
-            Map<String, Vessel> vesselMap,
-            CommonImportConfiguration configuration,
-            boolean collectIds) throws ImportException {
+    protected EchoBaseCsvFileImportResult importFile(Map<String, Vessel> vesselMap, CommonImportConfiguration configuration, boolean collectIds) throws ImportException {
 
         InputFile inputFile = configuration.getTransectFile();
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of transects from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of transects from file " + inputFile.getFileName());
         }
+        
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-        EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
+            EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        // get voyage
-        Voyage voyage = persistenceService.getVoyage(
-                configuration.getVoyageId());
+            // get voyage
+            Voyage voyage = persistenceService.getVoyage(configuration.getVoyageId());
 
-        // restrict voyage to use to this voyage
-        Map<String, Voyage> voyageMap = Maps.uniqueIndex(
-                Arrays.asList(voyage), Voyages.VOYAGE_NAME);
+            // restrict voyage to use to this voyage
+            Map<String, Voyage> voyageMap = Maps.uniqueIndex(Collections.singletonList(voyage), Voyages.VOYAGE_NAME);
 
-        String datum = configuration.getDatum();
-        String license = configuration.getTransectLicence();
-        String geospatialVerticalPositive =
-                configuration.getTransectGeospatialVerticalPositive();
-        String binUnitsPingAxis = configuration.getTransectBinUnitsPingAxis();
+            String datum = configuration.getDatum();
+            String license = configuration.getTransectLicence();
+            String geospatialVerticalPositive = configuration.getTransectGeospatialVerticalPositive();
+            String binUnitsPingAxis = configuration.getTransectBinUnitsPingAxis();
 
-        TransectImportModel csvModel =
-                new TransectImportModel(getCsvSeparator(),
-                                        voyageMap,
-                                        vesselMap);
-
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<TransectImportRow> importer =
-                    Import.newImport(csvModel, reader);
-
-            configuration.incrementsProgress();
-            for (TransectImportRow row : importer) {
+            TransectImportModel csvModel = new TransectImportModel(getCsvSeparator(), voyageMap, vesselMap);
+            try (Import<TransectImportRow> importer = Import.newImport(csvModel, reader)) {
 
                 configuration.incrementsProgress();
-                Transect transect = row.getTransect();
+                for (TransectImportRow row : importer) {
 
-                Date timeCoverageStart = transect.getTimeCoverageStart();
-                Date timeCoverageEnd = transect.getTimeCoverageEnd();
+                    configuration.incrementsProgress();
+                    Transect transect = row.getTransect();
 
-                Transit transit = voyage.getTransit(timeCoverageStart,
-                                                    timeCoverageEnd);
-                if (transit == null) {
-                    throw new ImportException(
-                            l(getLocale(), "echobase.importError.no.transit.between.date",
-                               voyage.getName(), timeCoverageStart, timeCoverageEnd));
-                }
+                    Date timeCoverageStart = transect.getTimeCoverageStart();
+                    Date timeCoverageEnd = transect.getTimeCoverageEnd();
+
+                    Transit transit = voyage.getTransit(timeCoverageStart, timeCoverageEnd);
+                    if (transit == null) {
+                        throw new ImportException(l(getLocale(), "echobase.importError.no.transit.between.date", voyage.getName(), timeCoverageStart, timeCoverageEnd));
+                    }
 
-                transect.setDatum(datum);
-                transect.setLicence(license);
-                transect.setGeospatialVerticalPositive(
-                        geospatialVerticalPositive);
-                transect.setBinUnitsPingAxis(binUnitsPingAxis);
+                    transect.setDatum(datum);
+                    transect.setLicence(license);
+                    transect.setGeospatialVerticalPositive(geospatialVerticalPositive);
+                    transect.setBinUnitsPingAxis(binUnitsPingAxis);
 
-                Transect createdTransect = persistenceService.createTransect(transect);
+                    Transect createdTransect = persistenceService.createTransect(transect);
 
-                transit.addTransect(createdTransect);
+                    transit.addTransect(createdTransect);
 
-                if (collectIds) {
+                    if (collectIds) {
 
-                    // collect id of the import
-                    importResult.addId(EchoBaseUserEntityEnum.Transect,
-                                       createdTransect);
-                } else {
+                        // collect id of the import
+                        importResult.addId(EchoBaseUserEntityEnum.Transect, createdTransect);
+                    } else {
 
-                    importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.Transect);
+                        importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.Transect);
+                    }
                 }
             }
 
             return importResult;
 
-        } catch (ImportRuntimeException e) {
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonTransitImportService.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonTransitImportService.java
index 155f90d..1355995 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonTransitImportService.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonTransitImportService.java
@@ -35,8 +35,9 @@ import org.apache.commons.logging.LogFactory;
 import org.nuiton.csv.Import;
 import org.nuiton.csv.ImportRuntimeException;
 
+import java.io.IOException;
 import java.io.Reader;
-import java.util.Arrays;
+import java.util.Collections;
 import java.util.Map;
 
 /**
@@ -48,76 +49,65 @@ import java.util.Map;
 public class CommonTransitImportService extends AbstractImportDataService<CommonImportConfiguration> {
 
     /** Logger. */
-    private static final Log log =
-            LogFactory.getLog(CommonTransitImportService.class);
+    private static final Log log = LogFactory.getLog(CommonTransitImportService.class);
 
     @Override
-    protected void startImport(
-            CommonImportConfiguration configuration,
-            EchoBaseUser user) throws ImportException {
+    protected void startImport(CommonImportConfiguration configuration, EchoBaseUser user) throws ImportException {
 
-        EchoBaseCsvFileImportResult importResult =
-                importFile(configuration, true);
+        EchoBaseCsvFileImportResult importResult = importFile(configuration, true);
         configuration.addResult(importResult);
+
     }
 
-    protected EchoBaseCsvFileImportResult importFile(
-            CommonImportConfiguration configuration,
-            boolean collectIds) throws ImportException {
+    protected EchoBaseCsvFileImportResult importFile(CommonImportConfiguration configuration, boolean collectIds) throws ImportException {
 
         InputFile inputFile = configuration.getTransitFile();
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of transits from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of transits from file " + inputFile.getFileName());
         }
-        EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        // get voyage
-        Voyage voyage = persistenceService.getVoyage(
-                configuration.getVoyageId());
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-        // restrict voyage to use to this voyage
-        Map<String, Voyage> voyageMap = Maps.uniqueIndex(
-                Arrays.asList(voyage), Voyages.VOYAGE_NAME);
+            EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        String relatedActivity = configuration.getTransitRelatedActivity();
+            // get voyage
+            Voyage voyage = persistenceService.getVoyage(configuration.getVoyageId());
 
-        TransitImportModel csvModel =
-                new TransitImportModel(getCsvSeparator(), voyageMap);
+            // restrict voyage to use to this voyage
+            Map<String, Voyage> voyageMap = Maps.uniqueIndex(Collections.singletonList(voyage), Voyages.VOYAGE_NAME);
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<TransitImportRow> importer =
-                    Import.newImport(csvModel, reader);
+            String relatedActivity = configuration.getTransitRelatedActivity();
 
-            configuration.incrementsProgress();
-            for (TransitImportRow row : importer) {
+            TransitImportModel csvModel = new TransitImportModel(getCsvSeparator(), voyageMap);
+            try (Import<TransitImportRow> importer = Import.newImport(csvModel, reader)) {
 
                 configuration.incrementsProgress();
-                Transit transit = row.getTransit();
+                for (TransitImportRow row : importer) {
+
+                    configuration.incrementsProgress();
+                    Transit transit = row.getTransit();
+
+                    transit.setRelatedActivity(relatedActivity);
 
-                transit.setRelatedActivity(relatedActivity);
+                    Transit createdTransit = persistenceService.createTransit(transit);
 
-                Transit createdTransit = persistenceService.createTransit(transit);
+                    voyage.addTransit(createdTransit);
 
-                voyage.addTransit(createdTransit);
+                    if (collectIds) {
 
-                if (collectIds) {
+                        // collect id of the import
+                        importResult.addId(EchoBaseUserEntityEnum.Transit, createdTransit);
 
-                    // collect id of the import
-                    importResult.addId(EchoBaseUserEntityEnum.Transit,
-                                       createdTransit);
-                } else {
+                    } else {
 
-                    importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.Transit);
+                        importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.Transit);
+                    }
                 }
             }
             return importResult;
-        } catch (ImportRuntimeException e) {
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonVoyageImportService.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonVoyageImportService.java
index 345a888..15a80ef 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonVoyageImportService.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/CommonVoyageImportService.java
@@ -34,11 +34,10 @@ import org.nuiton.csv.Import;
 import org.nuiton.csv.ImportModel;
 import org.nuiton.csv.ImportRuntimeException;
 
+import java.io.IOException;
 import java.io.Reader;
 import java.util.Locale;
 
-import static org.nuiton.i18n.I18n.l;
-
 /**
  * Service to launch a "common voyage data" import.
  *
@@ -48,86 +47,75 @@ import static org.nuiton.i18n.I18n.l;
 public class CommonVoyageImportService extends AbstractImportDataService<CommonImportConfiguration> {
 
     /** Logger. */
-    private static final Log log =
-            LogFactory.getLog(CommonVoyageImportService.class);
+    private static final Log log = LogFactory.getLog(CommonVoyageImportService.class);
 
     @Override
-    protected void startImport(
-            CommonImportConfiguration configuration,
-            EchoBaseUser user) throws ImportException {
-
-        EchoBaseCsvFileImportResult importResult;
+    protected void startImport(CommonImportConfiguration configuration, EchoBaseUser user) throws ImportException {
 
-        importResult = importFile(configuration);
+        EchoBaseCsvFileImportResult importResult = importFile(configuration);
         configuration.addResult(importResult);
+
     }
 
-    protected EchoBaseCsvFileImportResult importFile(
-            CommonImportConfiguration configuration) throws ImportException {
+    protected EchoBaseCsvFileImportResult importFile(CommonImportConfiguration configuration) throws ImportException {
 
         InputFile inputFile = configuration.getVoyageFile();
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of voyages from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of voyages from file " + inputFile.getFileName());
         }
 
-        Mission mission = persistenceService.getMission(
-                configuration.getMissionId());
-        AreaOfOperation areaOfOperation =
-                persistenceService.getAreaOfOperation(
-                        configuration.getAreaOfOperationId());
-
-        EchoBaseCsvFileImportResult result = newImportResult(inputFile);
-
+        Mission mission = persistenceService.getMission(configuration.getMissionId());
+        AreaOfOperation areaOfOperation = persistenceService.getAreaOfOperation(configuration.getAreaOfOperationId());
         String voyageDescription = configuration.getVoyageDescription();
         String datum = configuration.getDatum();
+        Locale locale = getLocale();
 
-        ImportModel<Voyage> csvModel = new VoyageImportModel(getCsvSeparator());
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-        Voyage newVoyage = null;
-        Locale locale = getLocale();
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<Voyage> importer = Import.newImport(csvModel, reader);
+            Voyage newVoyage = null;
 
-            configuration.incrementsProgress();
-            for (Voyage voyage : importer) {
+            EchoBaseCsvFileImportResult result = newImportResult(inputFile);
+            ImportModel<Voyage> csvModel = new VoyageImportModel(getCsvSeparator());
+            try (Import<Voyage> importer = Import.newImport(csvModel, reader)) {
 
                 configuration.incrementsProgress();
+                for (Voyage voyage : importer) {
 
-                voyage.setMission(mission);
-                voyage.setAreaOfOperation(areaOfOperation);
-                voyage.setDescription(voyageDescription);
-                voyage.setDatum(datum);
+                    configuration.incrementsProgress();
 
-                Voyage createdVoyage = persistenceService.createVoyage(voyage);
-                if (newVoyage == null) {
-                    newVoyage = createdVoyage;
-                } else {
-                    // this means a voyage file with more than one row not possible...
+                    voyage.setMission(mission);
+                    voyage.setAreaOfOperation(areaOfOperation);
+                    voyage.setDescription(voyageDescription);
+                    voyage.setDatum(datum);
 
-                    throw new ImportException(
-                            l(locale, "echobase.importError.can.only.import.one.voyage.atime"));
-                }
+                    Voyage createdVoyage = persistenceService.createVoyage(voyage);
+                    if (newVoyage == null) {
+                        newVoyage = createdVoyage;
+                    } else {
+                        // this means a voyage file with more than one row not possible...
+
+                        throw new MoreThanOnceVoyageToImportException(locale);
+                    }
+
+                    // collect id of the import
+                    result.addId(EchoBaseUserEntityEnum.Voyage, voyage);
 
-                // collect id of the import
-                result.addId(EchoBaseUserEntityEnum.Voyage, voyage);
+                }
             }
 
             if (newVoyage == null) {
-                throw new ImportException(
-                        l(locale, "echobase.importError.no.voyage.imported"));
+                throw new NoVoyageToImportException(locale);
             }
 
             // push back to id of the voyage in configuration for next imports
             configuration.setVoyageId(newVoyage.getTopiaId());
 
             return result;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(locale, inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
+
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/DataMetadataNotFoundException.java
similarity index 70%
copy from echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java
copy to echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/DataMetadataNotFoundException.java
index 016b3af..2c12b5a 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/DataMetadataNotFoundException.java
@@ -21,17 +21,24 @@ package fr.ifremer.echobase.services.service.importdata;
  * #L%
  */
 
+import org.nuiton.csv.ImportRuntimeException;
+
+import java.util.Locale;
+import java.util.Set;
+
+import static org.nuiton.i18n.I18n.l;
+
 /**
  * Created on 1/21/15.
  *
  * @author Tony Chemit - chemit@codelutin.com
  * @since 2.9
  */
-public class ResultsVoyageImportAlreadyExistException extends ImportException {
+public class DataMetadataNotFoundException extends ImportRuntimeException {
 
     private static final long serialVersionUID = 1L;
 
-    public ResultsVoyageImportAlreadyExistException(String message) {
-        super(message);
+    public DataMetadataNotFoundException(Locale locale, String metadataName, Set<String> rowNumber) {
+        super(l(locale, "echobase.importError.dataMetadata.notFound", metadataName, rowNumber));
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/EsduCellNotFoundException.java
similarity index 61%
copy from echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java
copy to echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/EsduCellNotFoundException.java
index 016b3af..35aac88 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/EsduCellNotFoundException.java
@@ -21,17 +21,26 @@ package fr.ifremer.echobase.services.service.importdata;
  * #L%
  */
 
+import fr.ifremer.echobase.entities.data.Voyage;
+import fr.ifremer.echobase.entities.references.AcousticInstrument;
+import fr.ifremer.echobase.entities.references.Vessel;
+import org.nuiton.csv.ImportRuntimeException;
+
+import java.util.Locale;
+
+import static org.nuiton.i18n.I18n.l;
+
 /**
  * Created on 1/21/15.
  *
  * @author Tony Chemit - chemit@codelutin.com
  * @since 2.9
  */
-public class ResultsVoyageImportAlreadyExistException extends ImportException {
+public class EsduCellNotFoundException extends ImportRuntimeException {
 
     private static final long serialVersionUID = 1L;
 
-    public ResultsVoyageImportAlreadyExistException(String message) {
-        super(message);
+    public EsduCellNotFoundException(Locale locale, Voyage voyage, Vessel vessel, AcousticInstrument instrument, int rowNumber) {
+        super(l(locale, "echobase.importError.esduCell.notfound", voyage.getName(), vessel.getName(), instrument.getId(), rowNumber));
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ImportException.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ImportException.java
index 481a5e6..2b53f47 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ImportException.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ImportException.java
@@ -45,8 +45,6 @@ public class ImportException extends Exception {
     }
 
     public ImportException(Locale locale, InputFile inputfile, Exception importError) {
-        this(l(locale, "echobase.importError.fromFile",
-                inputfile.getFile().getName(),
-                importError.getMessage()), importError);
+        this(l(locale, "echobase.importError.fromFile", inputfile.getFile().getName(), importError.getMessage()), importError);
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/MoreThanOnceVoyageToImportException.java
similarity index 74%
copy from echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java
copy to echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/MoreThanOnceVoyageToImportException.java
index 016b3af..7a2aa58 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/MoreThanOnceVoyageToImportException.java
@@ -21,17 +21,23 @@ package fr.ifremer.echobase.services.service.importdata;
  * #L%
  */
 
+import org.nuiton.csv.ImportRuntimeException;
+
+import java.util.Locale;
+
+import static org.nuiton.i18n.I18n.l;
+
 /**
  * Created on 1/21/15.
  *
  * @author Tony Chemit - chemit@codelutin.com
  * @since 2.9
  */
-public class ResultsVoyageImportAlreadyExistException extends ImportException {
+public class MoreThanOnceVoyageToImportException extends ImportRuntimeException {
 
     private static final long serialVersionUID = 1L;
 
-    public ResultsVoyageImportAlreadyExistException(String message) {
-        super(message);
+    public MoreThanOnceVoyageToImportException(Locale locale) {
+        super(l(locale, "echobase.importError.can.only.import.one.voyage.atime"));
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/NoVoyageToImportException.java
similarity index 76%
copy from echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java
copy to echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/NoVoyageToImportException.java
index 016b3af..88ce69f 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/NoVoyageToImportException.java
@@ -21,17 +21,23 @@ package fr.ifremer.echobase.services.service.importdata;
  * #L%
  */
 
+import org.nuiton.csv.ImportRuntimeException;
+
+import java.util.Locale;
+
+import static org.nuiton.i18n.I18n.l;
+
 /**
  * Created on 1/21/15.
  *
  * @author Tony Chemit - chemit@codelutin.com
  * @since 2.9
  */
-public class ResultsVoyageImportAlreadyExistException extends ImportException {
+public class NoVoyageToImportException extends ImportRuntimeException {
 
     private static final long serialVersionUID = 1L;
 
-    public ResultsVoyageImportAlreadyExistException(String message) {
-        super(message);
+    public NoVoyageToImportException(Locale locale) {
+        super(l(locale, "echobase.importError.no.voyage.imported"));
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/OperationImportConfiguration.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/OperationImportConfiguration.java
index 2aff4f0..341c938 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/OperationImportConfiguration.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/OperationImportConfiguration.java
@@ -47,12 +47,9 @@ public class OperationImportConfiguration extends AbstractImportConfiguration {
     protected final InputFile gearMetadataFile;
 
     public OperationImportConfiguration(Locale locale) {
-        operationFile = InputFile.newFile(
-                l(locale, "echobase.common.operationFile"));
-        operationMetadataFile = InputFile.newFile(
-                l(locale, "echobase.common.operationMetadataFile"));
-        gearMetadataFile = InputFile.newFile(
-                l(locale, "echobase.common.gearMetadataFile"));
+        operationFile = InputFile.newFile(l(locale, "echobase.common.operationFile"));
+        operationMetadataFile = InputFile.newFile(l(locale, "echobase.common.operationMetadataFile"));
+        gearMetadataFile = InputFile.newFile(l(locale, "echobase.common.gearMetadataFile"));
         importType = ImportType.OPERATION;
     }
 
@@ -70,8 +67,6 @@ public class OperationImportConfiguration extends AbstractImportConfiguration {
 
     @Override
     public InputFile[] getInputFiles() {
-        return new InputFile[]{operationFile,
-                               operationMetadataFile,
-                               gearMetadataFile};
+        return new InputFile[]{operationFile, operationMetadataFile, gearMetadataFile};
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/OperationImportService.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/OperationImportService.java
index ca66839..a567868 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/OperationImportService.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/OperationImportService.java
@@ -52,6 +52,7 @@ import org.apache.commons.logging.LogFactory;
 import org.nuiton.csv.Import;
 import org.nuiton.csv.ImportRuntimeException;
 
+import java.io.IOException;
 import java.io.Reader;
 import java.util.Collection;
 import java.util.Date;
@@ -66,219 +67,188 @@ import java.util.Map;
 public class OperationImportService extends AbstractImportDataService<OperationImportConfiguration> {
 
     /** Logger. */
-    private static final Log log =
-            LogFactory.getLog(OperationImportService.class);
+    private static final Log log = LogFactory.getLog(OperationImportService.class);
 
     @Override
-    protected void startImport(
-            OperationImportConfiguration configuration,
-            EchoBaseUser user) throws ImportException {
+    protected void startImport(OperationImportConfiguration configuration, EchoBaseUser user) throws ImportException {
 
         // get selected voyage
-        Voyage voyage = persistenceService.getVoyage(
-                configuration.getVoyageId());
+        Voyage voyage = persistenceService.getVoyage(configuration.getVoyageId());
 
         // get usable vessels from the voyage by their name
-        Map<String, Vessel> vesselMap = Maps.uniqueIndex(
-                voyage.getAllVessels(), Vessels.VESSEL_NAME);
+        Map<String, Vessel> vesselMap = Maps.uniqueIndex(voyage.getAllVessels(), Vessels.VESSEL_NAME);
 
         // get usable gears by their casino gear name
-        Map<String, Gear> gearMap = persistenceService.getEntitiesMap(
-                Gear.class, Gears.GEAR_CASINO_GEAR_NAME);
-
-        EchoBaseCsvFileImportResult importResult;
-
-        importResult = importOperationFile(configuration,
-                                           voyage,
-                                           vesselMap,
-                                           gearMap);
-        configuration.addResult(importResult);
+        Map<String, Gear> gearMap = persistenceService.getEntitiesMap(Gear.class, Gears.GEAR_CASINO_GEAR_NAME);
+
+        {
+            EchoBaseCsvFileImportResult result = importOperationFile(configuration,
+                                                                     voyage,
+                                                                     vesselMap,
+                                                                     gearMap);
+            configuration.addResult(result);
+        }
 
         // get all operation for this voyage and this vessel
         Collection<Operation> operations = voyage.getAllOperations();
 
         // split them by operation Id
-        Map<String, Operation> operationMap = Maps.uniqueIndex(
-                operations, Operations.OPERATION_ID);
-
-        importResult = importOperationMetadataFile(configuration,
-                                                   vesselMap,
-                                                   operationMap);
-        configuration.addResult(importResult);
-
-        importResult = importGearMetadataFile(configuration,
-                                              vesselMap,
-                                              gearMap,
-                                              operationMap);
-        configuration.addResult(importResult);
-    }
+        Map<String, Operation> operationMap = Maps.uniqueIndex(operations, Operations.OPERATION_ID);
 
-    protected EchoBaseCsvFileImportResult importOperationFile(
-            OperationImportConfiguration configuration,
-            Voyage voyage,
-            Map<String, Vessel> vesselMap,
-            Map<String, Gear> gearMap) throws ImportException {
+        {
+            EchoBaseCsvFileImportResult result = importOperationMetadataFile(configuration,
+                                                                             vesselMap,
+                                                                             operationMap);
+            configuration.addResult(result);
+        }
+        {
+            EchoBaseCsvFileImportResult result = importGearMetadataFile(configuration,
+                                                                        vesselMap,
+                                                                        gearMap,
+                                                                        operationMap);
+            configuration.addResult(result);
+        }
+    }
 
+    protected EchoBaseCsvFileImportResult importOperationFile(OperationImportConfiguration configuration,
+                                                              Voyage voyage,
+                                                              Map<String, Vessel> vesselMap,
+                                                              Map<String, Gear> gearMap) throws ImportException {
 
         InputFile inputFile = configuration.getOperationFile();
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of operation from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of operation from file " + inputFile.getFileName());
         }
 
         EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        Map<String, DepthStratum> depthStratumMap = persistenceService.getEntitiesMap(
-                DepthStratum.class, DepthStratums.DEPTH_STRATUM_ID);
+        Map<String, DepthStratum> depthStratumMap = persistenceService.getEntitiesMap(DepthStratum.class, DepthStratums.DEPTH_STRATUM_ID);
 
-        OperationImportModel csvModel =
-                new OperationImportModel(getCsvSeparator(),
-                                         vesselMap,
-                                         gearMap,
-                                         depthStratumMap);
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<OperationImportRow> importer =
-                    Import.newImport(csvModel, reader);
+            OperationImportModel csvModel = new OperationImportModel(getCsvSeparator(), vesselMap, gearMap, depthStratumMap);
+            try (Import<OperationImportRow> importer = Import.newImport(csvModel, reader)) {
 
-            configuration.incrementsProgress();
-            int rowNumber = 0;
-            for (OperationImportRow row : importer) {
+                configuration.incrementsProgress();
+                int rowNumber = 0;
+                for (OperationImportRow row : importer) {
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
-                Vessel vessel = row.getVessel();
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
+                    Vessel vessel = row.getVessel();
 
-                Operation operation = row.getOperation();
+                    Operation operation = row.getOperation();
 
-                Date startTime = operation.getGearShootingStartTime();
-                Date endTime = operation.getGearShootingEndTime();
+                    Date startTime = operation.getGearShootingStartTime();
+                    Date endTime = operation.getGearShootingEndTime();
 
-                Transit transit = voyage.getTransit(startTime, endTime);
+                    Transit transit = voyage.getTransit(startTime, endTime);
 
-                Transect transect = transit.getTransect(vessel);
+                    Transect transect = transit.getTransect(vessel);
 
-                Operation createdOperation = persistenceService.createOperation(operation);
+                    Operation createdOperation = persistenceService.createOperation(operation);
 
-                // collect ids
-                importResult.addId(EchoBaseUserEntityEnum.Operation,
-                                   createdOperation);
+                    // collect ids
+                    importResult.addId(EchoBaseUserEntityEnum.Operation, createdOperation);
 
-                transect.addOperation(createdOperation);
+                    transect.addOperation(createdOperation);
+                }
             }
 
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
+
         }
     }
 
-    protected EchoBaseCsvFileImportResult importOperationMetadataFile(
-            OperationImportConfiguration configuration,
-            Map<String, Vessel> vesselMap,
-            Map<String, Operation> operationMap) throws ImportException {
+    protected EchoBaseCsvFileImportResult importOperationMetadataFile(OperationImportConfiguration configuration,
+                                                                      Map<String, Vessel> vesselMap,
+                                                                      Map<String, Operation> operationMap) throws ImportException {
 
         InputFile inputFile = configuration.getOperationMetadataFile();
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of operation metadata values from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of operation metadata values from file " + inputFile.getFileName());
         }
 
         EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        Map<String, OperationMetadata> operationMetadatasByName =
-                persistenceService.getEntitiesMap(OperationMetadata.class,
-                                                  OperationMetadatas.OPERATION_METADATA_NAME);
+        Map<String, OperationMetadata> operationMetadatasByName = persistenceService.getEntitiesMap(OperationMetadata.class, OperationMetadatas.OPERATION_METADATA_NAME);
+
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-        OperationMetadataValueImportModel csvModel =
-                new OperationMetadataValueImportModel(getCsvSeparator(),
-                                                      vesselMap,
-                                                      operationMetadatasByName,
-                                                      operationMap);
+            OperationMetadataValueImportModel csvModel = new OperationMetadataValueImportModel(getCsvSeparator(), vesselMap, operationMetadatasByName, operationMap);
+            try (Import<OperationMetadataValueImportRow> importer = Import.newImport(csvModel, reader)) {
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<OperationMetadataValueImportRow> importer =
-                    Import.newImport(csvModel, reader);
+                int rowNumber = 0;
+                configuration.incrementsProgress();
+                for (OperationMetadataValueImportRow row : importer) {
 
-            int rowNumber = 0;
-            configuration.incrementsProgress();
-            for (OperationMetadataValueImportRow row : importer) {
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
+                    Operation operation = row.getOperation();
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
-                Operation operation = row.getOperation();
+                    OperationMetadataValue operationMetadataValueToCreate = row.getOperationMetadataValue();
+                    OperationMetadataValue operationMetadataValue = persistenceService.createOperationMetadataValue(operationMetadataValueToCreate);
 
-                OperationMetadataValue operationMetadataValueToCreate =
-                        row.getOperationMetadataValue();
-                OperationMetadataValue operationMetadataValue = persistenceService.createOperationMetadataValue(
-                        operationMetadataValueToCreate);
+                    operation.addOperationMetadataValue(operationMetadataValue);
+                    importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.OperationMetadataValue);
 
-                operation.addOperationMetadataValue(operationMetadataValue);
-                importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.OperationMetadataValue);
+                }
             }
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
     }
 
-    protected EchoBaseCsvFileImportResult importGearMetadataFile(
-            OperationImportConfiguration configuration,
-            Map<String, Vessel> vesselMap,
-            Map<String, Gear> gearMap,
-            Map<String, Operation> operationMap) throws ImportException {
+    protected EchoBaseCsvFileImportResult importGearMetadataFile(OperationImportConfiguration configuration,
+                                                                 Map<String, Vessel> vesselMap,
+                                                                 Map<String, Gear> gearMap,
+                                                                 Map<String, Operation> operationMap) throws ImportException {
 
         InputFile inputFile = configuration.getGearMetadataFile();
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of gear metadata values from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of gear metadata values from file " + inputFile.getFileName());
         }
 
         EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        Map<String, GearMetadata> gearMetadatasByType =
-                persistenceService.getEntitiesMap(GearMetadata.class,
-                                                  GearMetadatas.GEAR_METADATA_NAME);
+        Map<String, GearMetadata> gearMetadatasByType = persistenceService.getEntitiesMap(GearMetadata.class, GearMetadatas.GEAR_METADATA_NAME);
+
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-        GearMetadataValueImportModel csvModel =
-                new GearMetadataValueImportModel(getCsvSeparator(),
-                                                 vesselMap,
-                                                 gearMetadatasByType,
-                                                 gearMap,
-                                                 operationMap);
+            GearMetadataValueImportModel csvModel = new GearMetadataValueImportModel(getCsvSeparator(),
+                                                                                     vesselMap,
+                                                                                     gearMetadatasByType,
+                                                                                     gearMap,
+                                                                                     operationMap);
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<GearMetadataValueImportRow> importer =
-                    Import.newImport(csvModel, reader);
+            try (Import<GearMetadataValueImportRow> importer = Import.newImport(csvModel, reader)) {
 
-            int rowNumber = 0;
-            configuration.incrementsProgress();
-            for (GearMetadataValueImportRow row : importer) {
+                int rowNumber = 0;
+                configuration.incrementsProgress();
+                for (GearMetadataValueImportRow row : importer) {
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
-                Operation operation = row.getOperation();
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
+                    Operation operation = row.getOperation();
 
-                GearMetadataValue gearMetadataValuetoCreate =
-                        row.getGearMetadataValue();
-                GearMetadataValue gearMetadataValue = persistenceService.createGearMetadataValue(
-                        gearMetadataValuetoCreate);
+                    GearMetadataValue gearMetadataValuetoCreate = row.getGearMetadataValue();
+                    GearMetadataValue gearMetadataValue = persistenceService.createGearMetadataValue(gearMetadataValuetoCreate);
 
-                operation.addGearMetadataValue(gearMetadataValue);
-                importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.GearMetadataValue);
+                    operation.addGearMetadataValue(gearMetadataValue);
+                    importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.GearMetadataValue);
+
+                }
             }
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
+
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsEsduCellImportService.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsEsduCellImportService.java
index 349e97c..b7074fa 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsEsduCellImportService.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsEsduCellImportService.java
@@ -56,8 +56,9 @@ import org.nuiton.csv.Import;
 import org.nuiton.csv.ImportRuntimeException;
 import org.nuiton.csv.ext.CsvReaders;
 
+import java.io.IOException;
 import java.io.Reader;
-import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
@@ -70,431 +71,363 @@ import java.util.Map;
 public class ResultsEsduCellImportService extends AbstractImportDataService<ResultsImportConfiguration> {
 
     /** Logger. */
-    private static final Log log =
-            LogFactory.getLog(ResultsEsduCellImportService.class);
+    private static final Log log = LogFactory.getLog(ResultsEsduCellImportService.class);
 
     @Override
-    public void startImport(
-            ResultsImportConfiguration configuration,
-            EchoBaseUser user) throws ImportException {
+    public void startImport(ResultsImportConfiguration configuration, EchoBaseUser user) throws ImportException {
 
-        Map<String, Species> speciesMap = persistenceService.getEntitiesMap(
-                Species.class, Species2.SPECIES_BARACOUDA_CODE);
+        Map<String, Species> speciesMap = persistenceService.getEntitiesMap(Species.class, Species2.SPECIES_BARACOUDA_CODE);
 
         Map<String, SizeCategory> sizeCategoryMap = Maps.newTreeMap();
-        sizeCategoryMap.putAll(persistenceService.getEntitiesMap(
-                SizeCategory.class, SizeCategories.SIZE_CATEGORY_NAME));
+        sizeCategoryMap.putAll(persistenceService.getEntitiesMap(SizeCategory.class, SizeCategories.SIZE_CATEGORY_NAME));
 
         Map<String, AgeCategory> ageCategoryMap = Maps.newTreeMap();
-        ageCategoryMap.putAll(persistenceService.getEntitiesMap(
-                AgeCategory.class, AgeCategories.AGE_CATEGORY_NAME));
+        ageCategoryMap.putAll(persistenceService.getEntitiesMap(AgeCategory.class, AgeCategories.AGE_CATEGORY_NAME));
 
-        Map<String, DataMetadata> dataMetadataMap = persistenceService.getEntitiesMap(
-                DataMetadata.class, DataMetadatas.DATA_METADATA_NAME);
+        Map<String, DataMetadata> dataMetadataMap = persistenceService.getEntitiesMap(DataMetadata.class, DataMetadatas.DATA_METADATA_NAME);
 
-        Map<String, DataQuality> dataQualityMap = persistenceService.getEntitiesMap(
-                DataQuality.class, DataQualities.DATA_QUALITY_NAME);
+        Map<String, DataQuality> dataQualityMap = persistenceService.getEntitiesMap(DataQuality.class, DataQualities.DATA_QUALITY_NAME);
 
         // get selected voyage
-        Voyage voyage = persistenceService.getVoyage(
-                configuration.getVoyageId());
+        Voyage voyage = persistenceService.getVoyage(configuration.getVoyageId());
 
         // get selected dataProcessing
-        DataProcessing dataProcessing = persistenceService.getDataProcessing(
-                configuration.getDataProcessingId());
+        DataProcessing dataProcessing = persistenceService.getDataProcessing(configuration.getDataProcessingId());
 
         // authorize only the selected voyage to be imported
-        Map<String, Voyage> voyageMap = Maps.uniqueIndex(Arrays.asList(
-                voyage), Voyages.VOYAGE_NAME);
+        Map<String, Voyage> voyageMap = Maps.uniqueIndex(Collections.singletonList(voyage), Voyages.VOYAGE_NAME);
 
         // get esdu cells usables
-        Map<String, Cell> esduCellMap = Maps.uniqueIndex(
-                dataProcessing.getCell(), Cells.CELL_BY_NAME);
+        Map<String, Cell> esduCellMap = Maps.uniqueIndex(dataProcessing.getCell(), Cells.CELL_BY_NAME);
 
         // index all echotypes of this voyage
-        Map<String, Echotype> echotypeMap = Maps.uniqueIndex(
-                voyage.getEchotype(), Echotypes.ECHOTYPE_NAME);
-
-        InputFile inputFile;
-        EchoBaseCsvFileImportResult importResult;
-
-        inputFile = configuration.getEsduByEchotypeFile();
-        if (inputFile.hasFile()) {
-
-            importResult = importByEchotypeFile(configuration,
-                                                inputFile,
-                                                voyage,
-                                                voyageMap,
-                                                echotypeMap,
-                                                dataMetadataMap,
-                                                esduCellMap,
-                                                dataQualityMap);
-            configuration.addResult(importResult);
+        Map<String, Echotype> echotypeMap = Maps.uniqueIndex(voyage.getEchotype(), Echotypes.ECHOTYPE_NAME);
+
+        if (configuration.getEsduByEchotypeFile().hasFile()) {
+
+            EchoBaseCsvFileImportResult result = importByEchotypeFile(configuration,
+                                                                      configuration.getEsduByEchotypeFile(),
+                                                                      voyage,
+                                                                      voyageMap,
+                                                                      echotypeMap,
+                                                                      dataMetadataMap,
+                                                                      esduCellMap,
+                                                                      dataQualityMap);
+            configuration.addResult(result);
+
         }
 
-        inputFile = configuration.getEsduByEchotypeAndSpeciesCategoryFile();
-        if (inputFile.hasFile()) {
-            importResult = importByEchotypeAndSpeciesCategoryFile(
-                    configuration,
-                    inputFile,
-                    voyage,
-                    voyageMap,
-                    echotypeMap,
-                    dataMetadataMap,
-                    speciesMap,
-                    sizeCategoryMap,
-                    esduCellMap,
-                    dataQualityMap);
-            configuration.addResult(importResult);
+        if (configuration.getEsduByEchotypeAndSpeciesCategoryFile().hasFile()) {
+
+            EchoBaseCsvFileImportResult result = importByEchotypeAndSpeciesCategoryFile(configuration,
+                                                                                        configuration.getEsduByEchotypeAndSpeciesCategoryFile(),
+                                                                                        voyage,
+                                                                                        voyageMap,
+                                                                                        echotypeMap,
+                                                                                        dataMetadataMap,
+                                                                                        speciesMap,
+                                                                                        sizeCategoryMap,
+                                                                                        esduCellMap,
+                                                                                        dataQualityMap);
+            configuration.addResult(result);
+
         }
+        if (configuration.getEsduBySpeciesAndSizeCategoryFile().hasFile()) {
+
+            EchoBaseCsvFileImportResult result = importBySpeciesAndSizeCategoryFile(configuration,
+                                                                                    configuration.getEsduBySpeciesAndSizeCategoryFile(),
+                                                                                    voyage,
+                                                                                    voyageMap,
+                                                                                    dataMetadataMap,
+                                                                                    speciesMap,
+                                                                                    sizeCategoryMap,
+                                                                                    esduCellMap,
+                                                                                    dataQualityMap);
+            configuration.addResult(result);
 
-        inputFile = configuration.getEsduBySpeciesAndSizeCategoryFile();
-        if (inputFile.hasFile()) {
-            importResult = importBySpeciesAndSizeCategoryFile(
-                    configuration,
-                    inputFile,
-                    voyage,
-                    voyageMap,
-                    dataMetadataMap,
-                    speciesMap,
-                    sizeCategoryMap,
-                    esduCellMap,
-                    dataQualityMap);
-            configuration.addResult(importResult);
         }
 
-        inputFile = configuration.getEsduBySpeciesAndAgeCategoryFile();
-
-        if (inputFile.hasFile()) {
-            importResult = importBySpeciesAndAgeCategoryFile(
-                    configuration,
-                    inputFile,
-                    voyage,
-                    voyageMap,
-                    dataMetadataMap,
-                    speciesMap,
-                    ageCategoryMap,
-                    esduCellMap,
-                    dataQualityMap);
-            configuration.addResult(importResult);
+        if (configuration.getEsduBySpeciesAndAgeCategoryFile().hasFile()) {
+
+            EchoBaseCsvFileImportResult result = importBySpeciesAndAgeCategoryFile(configuration,
+                                                                                   configuration.getEsduBySpeciesAndAgeCategoryFile(),
+                                                                                   voyage,
+                                                                                   voyageMap,
+                                                                                   dataMetadataMap,
+                                                                                   speciesMap,
+                                                                                   ageCategoryMap,
+                                                                                   esduCellMap,
+                                                                                   dataQualityMap);
+            configuration.addResult(result);
+
         }
+
     }
 
-    private EchoBaseCsvFileImportResult importByEchotypeFile(
-            ResultsImportConfiguration configuration,
-            InputFile inputFile,
-            Voyage voyage,
-            Map<String, Voyage> voyageMap,
-            Map<String, Echotype> echotypeMap,
-            Map<String, DataMetadata> dataMetadataMap,
-            Map<String, Cell> esduCellMap,
-            Map<String, DataQuality> dataQualityMap) throws ImportException {
+    private EchoBaseCsvFileImportResult importByEchotypeFile(ResultsImportConfiguration configuration,
+                                                             InputFile inputFile,
+                                                             Voyage voyage,
+                                                             Map<String, Voyage> voyageMap,
+                                                             Map<String, Echotype> echotypeMap,
+                                                             Map<String, DataMetadata> dataMetadataMap,
+                                                             Map<String, Cell> esduCellMap,
+                                                             Map<String, DataQuality> dataQualityMap) throws ImportException {
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of esdu result by echotype from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of esdu result by echotype from file " + inputFile.getFileName());
         }
 
         // first get header of file to detect which results to import
-        String[] header = CsvReaders.getHeader(inputFile.getFile(),
-                                               getCsvSeparator());
+        String[] header = CsvReaders.getHeader(inputFile.getFile(), getCsvSeparator());
 
         EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        List<DataMetadata> metas = getMetas(
-                EsduResultByEchotypeImportModel.COLUMN_NAMES_TO_EXCLUDE,
-                dataMetadataMap,
-                header);
-
-        EsduResultByEchotypeImportModel csvModel = new EsduResultByEchotypeImportModel(
-                getCsvSeparator(),
-                voyageMap,
-                echotypeMap,
-                voyage,
-                esduCellMap,
-                metas,
-                dataQualityMap);
+        List<DataMetadata> metas = getMetas(EsduResultByEchotypeImportModel.COLUMN_NAMES_TO_EXCLUDE, dataMetadataMap, header);
 
         String resultLabel = configuration.getResultLabel();
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<EsduResultByEchotypeImportRow> importer =
-                    Import.newImport(csvModel, reader);
+        try (Reader reader = getInputFileReader(inputFile)) {
+
+            EsduResultByEchotypeImportModel csvModel = new EsduResultByEchotypeImportModel(getCsvSeparator(),
+                                                                                           voyageMap,
+                                                                                           echotypeMap,
+                                                                                           voyage,
+                                                                                           esduCellMap,
+                                                                                           metas,
+                                                                                           dataQualityMap);
 
-            configuration.incrementsProgress();
-            int rowNumber = 0;
+            try (Import<EsduResultByEchotypeImportRow> importer = Import.newImport(csvModel, reader)) {
 
-            for (EsduResultByEchotypeImportRow row : importer) {
+                configuration.incrementsProgress();
+                int rowNumber = 0;
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
+                for (EsduResultByEchotypeImportRow row : importer) {
 
-                Cell cell = row.getCell();
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
 
-                Category category = getResultCategory(row.getEchotype(),
-                                                      null,
-                                                      importResult);
+                    Cell cell = row.getCell();
 
-                addResults(row, cell, category, resultLabel, importResult, true, true);
+                    Category category = getResultCategory(row.getEchotype(), null, importResult);
+
+                    addResults(row, cell, category, resultLabel, importResult, true, true);
+                }
             }
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
+
     }
 
-    private EchoBaseCsvFileImportResult importByEchotypeAndSpeciesCategoryFile(
-            ResultsImportConfiguration configuration,
-            InputFile inputFile,
-            Voyage voyage,
-            Map<String, Voyage> voyageMap,
-            Map<String, Echotype> echotypeMap,
-            Map<String, DataMetadata> dataMetadataMap,
-            Map<String, Species> speciesMap,
-            Map<String, SizeCategory> sizeCategoryMap,
-            Map<String, Cell> esduCellMap,
-            Map<String, DataQuality> dataQualityMap) throws ImportException {
+    private EchoBaseCsvFileImportResult importByEchotypeAndSpeciesCategoryFile(ResultsImportConfiguration configuration,
+                                                                               InputFile inputFile,
+                                                                               Voyage voyage,
+                                                                               Map<String, Voyage> voyageMap,
+                                                                               Map<String, Echotype> echotypeMap,
+                                                                               Map<String, DataMetadata> dataMetadataMap,
+                                                                               Map<String, Species> speciesMap,
+                                                                               Map<String, SizeCategory> sizeCategoryMap,
+                                                                               Map<String, Cell> esduCellMap,
+                                                                               Map<String, DataQuality> dataQualityMap) throws ImportException {
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of acoustic result by echotype " +
-                     "and species category from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of acoustic result by echotype and species category from file " + inputFile.getFileName());
         }
 
         // first get header of file to detect which results to import
-        String[] header = CsvReaders.getHeader(inputFile.getFile(),
-                                               getCsvSeparator());
+        String[] header = CsvReaders.getHeader(inputFile.getFile(), getCsvSeparator());
 
         EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        List<DataMetadata> metas =
-                getMetas(
-                        EsduResultByEchotypeAndSpeciesCategoryImportModel.COLUMN_NAMES_TO_EXCLUDE,
-                        dataMetadataMap,
-                        header);
-
-        EsduResultByEchotypeAndSpeciesCategoryImportModel csvModel = new EsduResultByEchotypeAndSpeciesCategoryImportModel(
-                getCsvSeparator(),
-                voyageMap,
-                echotypeMap,
-                speciesMap,
-                sizeCategoryMap,
-                voyage,
-                esduCellMap,
-                metas,
-                dataQualityMap);
+        List<DataMetadata> metas = getMetas(EsduResultByEchotypeAndSpeciesCategoryImportModel.COLUMN_NAMES_TO_EXCLUDE, dataMetadataMap, header);
 
         String resultLabel = configuration.getResultLabel();
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<EsduResultByEchotypeAndSpeciesCategoryImportRow> importer =
-                    Import.newImport(csvModel, reader);
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-            configuration.incrementsProgress();
-            int rowNumber = 0;
-            for (EsduResultByEchotypeAndSpeciesCategoryImportRow row : importer) {
+            EsduResultByEchotypeAndSpeciesCategoryImportModel csvModel = new EsduResultByEchotypeAndSpeciesCategoryImportModel(getCsvSeparator(),
+                                                                                                                               voyageMap,
+                                                                                                                               echotypeMap,
+                                                                                                                               speciesMap,
+                                                                                                                               sizeCategoryMap,
+                                                                                                                               voyage,
+                                                                                                                               esduCellMap,
+                                                                                                                               metas,
+                                                                                                                               dataQualityMap);
+            try (Import<EsduResultByEchotypeAndSpeciesCategoryImportRow> importer = Import.newImport(csvModel, reader)) {
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
+                configuration.incrementsProgress();
+                int rowNumber = 0;
+                for (EsduResultByEchotypeAndSpeciesCategoryImportRow row : importer) {
 
-                Cell cell = row.getCell();
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
 
-                Category category = getResultCategory(row.getEchotype(),
-                                                      row.getSpecies(),
-                                                      row.getSizeCategory(),
-                                                      null,
-                                                      importResult);
+                    Cell cell = row.getCell();
 
-                addResults(row, cell, category, resultLabel, importResult, true, true);
+                    Category category = getResultCategory(row.getEchotype(),
+                                                          row.getSpecies(),
+                                                          row.getSizeCategory(),
+                                                          null,
+                                                          importResult);
+
+                    addResults(row, cell, category, resultLabel, importResult, true, true);
+                }
             }
 
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
+
         }
     }
 
-    private EchoBaseCsvFileImportResult importBySpeciesAndSizeCategoryFile(
-            ResultsImportConfiguration configuration, InputFile inputFile,
-            Voyage voyage,
-            Map<String, Voyage> voyageMap,
-            Map<String, DataMetadata> dataMetadataMap,
-            Map<String, Species> speciesMap,
-            Map<String, SizeCategory> sizeCategoryMap,
-            Map<String, Cell> esduCellMap,
-            Map<String, DataQuality> dataQualityMap) throws ImportException {
+    private EchoBaseCsvFileImportResult importBySpeciesAndSizeCategoryFile(ResultsImportConfiguration configuration, InputFile inputFile,
+                                                                           Voyage voyage,
+                                                                           Map<String, Voyage> voyageMap,
+                                                                           Map<String, DataMetadata> dataMetadataMap,
+                                                                           Map<String, Species> speciesMap,
+                                                                           Map<String, SizeCategory> sizeCategoryMap,
+                                                                           Map<String, Cell> esduCellMap,
+                                                                           Map<String, DataQuality> dataQualityMap) throws ImportException {
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of acoustic result by speices and size category from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of acoustic result by speices and size category from file " + inputFile.getFileName());
         }
 
         // first get header of file to detect which results to import
-        String[] header = CsvReaders.getHeader(inputFile.getFile(),
-                                               getCsvSeparator());
+        String[] header = CsvReaders.getHeader(inputFile.getFile(), getCsvSeparator());
 
 
+        List<DataMetadata> metas = getMetas(EsduResultBySpeciesAndSizeCategoryImportModel.COLUMN_NAMES_TO_EXCLUDE, dataMetadataMap, header);
+
+        String resultLabel = configuration.getResultLabel();
         EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        List<DataMetadata> metas =
-                getMetas(
-                        EsduResultBySpeciesAndSizeCategoryImportModel.COLUMN_NAMES_TO_EXCLUDE,
-                        dataMetadataMap,
-                        header);
-
-        EsduResultBySpeciesAndSizeCategoryImportModel csvModel = new EsduResultBySpeciesAndSizeCategoryImportModel(
-                getCsvSeparator(),
-                voyageMap,
-                speciesMap,
-                voyage,
-                esduCellMap,
-                metas,
-                dataQualityMap);
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-        String resultLabel = configuration.getResultLabel();
+            EsduResultBySpeciesAndSizeCategoryImportModel csvModel = new EsduResultBySpeciesAndSizeCategoryImportModel(getCsvSeparator(),
+                                                                                                                       voyageMap,
+                                                                                                                       speciesMap,
+                                                                                                                       voyage,
+                                                                                                                       esduCellMap,
+                                                                                                                       metas,
+                                                                                                                       dataQualityMap);
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<EsduResultBySpeciesAndSizeCategoryImportRow> importer =
-                    Import.newImport(csvModel, reader);
+            try (Import<EsduResultBySpeciesAndSizeCategoryImportRow> importer = Import.newImport(csvModel, reader)) {
 
-            configuration.incrementsProgress();
-            int rowNumber = 0;
-            for (EsduResultBySpeciesAndSizeCategoryImportRow row : importer) {
+                configuration.incrementsProgress();
+                int rowNumber = 0;
+                for (EsduResultBySpeciesAndSizeCategoryImportRow row : importer) {
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
 
-                Cell cell = row.getCell();
+                    Cell cell = row.getCell();
 
-                String sizeCategoryName = row.getSizeCategory();
+                    String sizeCategoryName = row.getSizeCategory();
 
-                SizeCategory sizeCategory =
-                        sizeCategoryMap.get(sizeCategoryName);
+                    SizeCategory sizeCategory = sizeCategoryMap.get(sizeCategoryName);
 
-                if (sizeCategory == null) {
+                    if (sizeCategory == null) {
 
-                    // create a new sizeCategory
-                    sizeCategory = persistenceService.createSizeCategory(
-                            sizeCategoryName,
-                            row.getSizeCategoryMeaning()
-                    );
-                    importResult.incrementsNumberCreated(
-                            EchoBaseUserEntityEnum.SizeCategory);
-                    if (log.isInfoEnabled()) {
-                        log.info("Creates a new SizeCategory " + sizeCategoryName);
+                        // create a new sizeCategory
+                        sizeCategory = persistenceService.createSizeCategory(sizeCategoryName, row.getSizeCategoryMeaning());
+                        importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.SizeCategory);
+                        if (log.isInfoEnabled()) {
+                            log.info("Creates a new SizeCategory " + sizeCategoryName);
+                        }
+                        sizeCategoryMap.put(sizeCategoryName, sizeCategory);
                     }
-                    sizeCategoryMap.put(sizeCategoryName, sizeCategory);
-                }
 
-                Category category = getResultCategory(null,
-                                                      row.getSpecies(),
-                                                      sizeCategory,
-                                                      null,
-                                                      importResult);
+                    Category category = getResultCategory(null,
+                                                          row.getSpecies(),
+                                                          sizeCategory,
+                                                          null,
+                                                          importResult);
 
-                addResults(row, cell, category, resultLabel, importResult, true, true);
+                    addResults(row, cell, category, resultLabel, importResult, true, true);
+                }
             }
 
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
+
     }
 
-    private EchoBaseCsvFileImportResult importBySpeciesAndAgeCategoryFile(
-            ResultsImportConfiguration configuration,
-            InputFile inputFile,
-            Voyage voyage,
-            Map<String, Voyage> voyageMap,
-            Map<String, DataMetadata> dataMetadataMap,
-            Map<String, Species> speciesMap,
-            Map<String, AgeCategory> ageCategoryMap,
-            Map<String, Cell> esduCellMap,
-            Map<String, DataQuality> dataQualityMap) throws ImportException {
+    private EchoBaseCsvFileImportResult importBySpeciesAndAgeCategoryFile(ResultsImportConfiguration configuration,
+                                                                          InputFile inputFile,
+                                                                          Voyage voyage,
+                                                                          Map<String, Voyage> voyageMap,
+                                                                          Map<String, DataMetadata> dataMetadataMap,
+                                                                          Map<String, Species> speciesMap,
+                                                                          Map<String, AgeCategory> ageCategoryMap,
+                                                                          Map<String, Cell> esduCellMap,
+                                                                          Map<String, DataQuality> dataQualityMap) throws ImportException {
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of acoustic result by species and age category from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of acoustic result by species and age category from file " + inputFile.getFileName());
         }
 
         // first get header of file to detect which results to import
-        String[] header = CsvReaders.getHeader(inputFile.getFile(),
-                                               getCsvSeparator());
+        String[] header = CsvReaders.getHeader(inputFile.getFile(), getCsvSeparator());
 
 
         EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        List<DataMetadata> metas =
-                getMetas(
-                        EsduResultBySpeciesAndAgeCategoryImportModel.COLUMN_NAMES_TO_EXCLUDE,
-                        dataMetadataMap,
-                        header);
-
-        EsduResultBySpeciesAndAgeCategoryImportModel csvModel = new EsduResultBySpeciesAndAgeCategoryImportModel(
-                getCsvSeparator(),
-                voyageMap,
-                speciesMap,
-                voyage,
-                esduCellMap,
-                metas,
-                dataQualityMap);
+        List<DataMetadata> metas = getMetas(EsduResultBySpeciesAndAgeCategoryImportModel.COLUMN_NAMES_TO_EXCLUDE, dataMetadataMap, header);
 
         String resultLabel = configuration.getResultLabel();
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<EsduResultBySpeciesAndAgeCategoryImportRow> importer =
-                    Import.newImport(csvModel, reader);
+        try (Reader reader = getInputFileReader(inputFile)) {
+
+            EsduResultBySpeciesAndAgeCategoryImportModel csvModel = new EsduResultBySpeciesAndAgeCategoryImportModel(getCsvSeparator(),
+                                                                                                                     voyageMap,
+                                                                                                                     speciesMap,
+                                                                                                                     voyage,
+                                                                                                                     esduCellMap,
+                                                                                                                     metas,
+                                                                                                                     dataQualityMap);
+            try (Import<EsduResultBySpeciesAndAgeCategoryImportRow> importer = Import.newImport(csvModel, reader)) {
 
-            configuration.incrementsProgress();
-            int rowNumber = 0;
-            for (EsduResultBySpeciesAndAgeCategoryImportRow row : importer) {
+                configuration.incrementsProgress();
+                int rowNumber = 0;
+                for (EsduResultBySpeciesAndAgeCategoryImportRow row : importer) {
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
 
-                Cell cell = row.getCell();
+                    Cell cell = row.getCell();
 
-                String ageCategoryName = row.getAgeCategory();
+                    String ageCategoryName = row.getAgeCategory();
 
-                AgeCategory ageCategory =
-                        ageCategoryMap.get(ageCategoryName);
+                    AgeCategory ageCategory = ageCategoryMap.get(ageCategoryName);
 
-                if (ageCategory == null) {
+                    if (ageCategory == null) {
 
-                    // create a new sizeCategory
-                    ageCategory = persistenceService.createAgeCategory(
-                            ageCategoryName,
-                            row.getAgeCategoryMeaning()
-                    );
-                    importResult.incrementsNumberCreated(
-                            EchoBaseUserEntityEnum.AgeCategory);
-                    if (log.isInfoEnabled()) {
-                        log.info("Creates a new AgeCategory " + ageCategoryName);
+                        // create a new sizeCategory
+                        ageCategory = persistenceService.createAgeCategory(ageCategoryName, row.getAgeCategoryMeaning());
+                        importResult.incrementsNumberCreated(EchoBaseUserEntityEnum.AgeCategory);
+                        if (log.isInfoEnabled()) {
+                            log.info("Creates a new AgeCategory " + ageCategoryName);
+                        }
+                        ageCategoryMap.put(ageCategoryName, ageCategory);
                     }
-                    ageCategoryMap.put(ageCategoryName, ageCategory);
-                }
 
-                Category category = getResultCategory(
-                        null,
-                        row.getSpecies(),
-                        null,
-                        ageCategory,
-                        importResult);
+                    Category category = getResultCategory(null, row.getSpecies(), null, ageCategory, importResult);
+
+                    addResults(row, cell, category, resultLabel, importResult, true, true);
 
-                addResults(row, cell, category, resultLabel, importResult, true, true);
+                }
             }
 
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
+
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsImportConfiguration.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsImportConfiguration.java
index 75cd1f2..f73ef83 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsImportConfiguration.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsImportConfiguration.java
@@ -79,28 +79,17 @@ public class ResultsImportConfiguration extends AbstractImportConfiguration {
     protected final InputFile lengthWeightKeyFile;
 
     public ResultsImportConfiguration(Locale locale) {
-        regionsFile = InputFile.newFile(
-                l(locale, "echobase.common.cellRegionsFile"));
-        regionAssociationFile = InputFile.newFile(
-                l(locale, "echobase.common.cellRegionAssociationFile"));
-        regionResultFile = InputFile.newFile(
-                l(locale, "echobase.common.cellRegionResultFile"));
-        mapsFile = InputFile.newFile(
-                l(locale, "echobase.common.cellMapsFile"));
-        echotypeFile = InputFile.newFile(
-                l(locale, "echobase.common.echotypeFile"));
-        lengthAgeKeyFile = InputFile.newFile(
-                l(locale, "echobase.common.lengthAgeKeyFile"));
-        lengthWeightKeyFile = InputFile.newFile(
-                l(locale, "echobase.common.lengthWeightKeyFile"));
-        esduByEchotypeFile = InputFile.newFile(
-                l(locale, "echobase.common.esduByEchotypeFile"));
-        esduByEchotypeAndSpeciesCategoryFile = InputFile.newFile(
-                l(locale, "echobase.common.esduByEchotypeAndSpeciesCategoryFile"));
-        esduBySpeciesAndSizeCategoryFile = InputFile.newFile(
-                l(locale, "echobase.common.esduBySpeciesAndSizeCategoryFile"));
-        esduBySpeciesAndAgeCategoryFile = InputFile.newFile(
-                l(locale, "echobase.common.esduBySpeciesAndAgeCategoryFile"));
+        regionsFile = InputFile.newFile(l(locale, "echobase.common.cellRegionsFile"));
+        regionAssociationFile = InputFile.newFile(l(locale, "echobase.common.cellRegionAssociationFile"));
+        regionResultFile = InputFile.newFile(l(locale, "echobase.common.cellRegionResultFile"));
+        mapsFile = InputFile.newFile(l(locale, "echobase.common.cellMapsFile"));
+        echotypeFile = InputFile.newFile(l(locale, "echobase.common.echotypeFile"));
+        lengthAgeKeyFile = InputFile.newFile(l(locale, "echobase.common.lengthAgeKeyFile"));
+        lengthWeightKeyFile = InputFile.newFile(l(locale, "echobase.common.lengthWeightKeyFile"));
+        esduByEchotypeFile = InputFile.newFile(l(locale, "echobase.common.esduByEchotypeFile"));
+        esduByEchotypeAndSpeciesCategoryFile = InputFile.newFile(l(locale, "echobase.common.esduByEchotypeAndSpeciesCategoryFile"));
+        esduBySpeciesAndSizeCategoryFile = InputFile.newFile(l(locale, "echobase.common.esduBySpeciesAndSizeCategoryFile"));
+        esduBySpeciesAndAgeCategoryFile = InputFile.newFile(l(locale, "echobase.common.esduBySpeciesAndAgeCategoryFile"));
     }
 
     public String getVesselId() {
@@ -172,29 +161,29 @@ public class ResultsImportConfiguration extends AbstractImportConfiguration {
     }
 
     public boolean isOneEsduImportFile() {
-        return esduByEchotypeFile.hasFile() ||
-               esduByEchotypeAndSpeciesCategoryFile.hasFile() ||
-               esduBySpeciesAndSizeCategoryFile.hasFile() ||
-               esduBySpeciesAndAgeCategoryFile.hasFile();
+        return esduByEchotypeFile.hasFile()
+                || esduByEchotypeAndSpeciesCategoryFile.hasFile()
+                || esduBySpeciesAndSizeCategoryFile.hasFile()
+                || esduBySpeciesAndAgeCategoryFile.hasFile();
 
     }
 
     public boolean isOneVoyageImportFile() {
-        return echotypeFile.hasFile() ||
-               lengthAgeKeyFile.hasFile() ||
-               lengthWeightKeyFile.hasFile();
+        return echotypeFile.hasFile() || lengthAgeKeyFile.hasFile() || lengthWeightKeyFile.hasFile();
 
     }
 
     @Override
     public InputFile[] getInputFiles() {
-        return new InputFile[]{regionsFile, regionAssociationFile,
-                               regionResultFile,
-                               mapsFile, echotypeFile,
-                               lengthAgeKeyFile, lengthWeightKeyFile,
-                               esduByEchotypeFile,
-                               esduByEchotypeAndSpeciesCategoryFile,
-                               esduBySpeciesAndSizeCategoryFile,
-                               esduBySpeciesAndAgeCategoryFile};
+        return new InputFile[]{regionsFile,
+                regionAssociationFile,
+                regionResultFile,
+                mapsFile, echotypeFile,
+                lengthAgeKeyFile,
+                lengthWeightKeyFile,
+                esduByEchotypeFile,
+                esduByEchotypeAndSpeciesCategoryFile,
+                esduBySpeciesAndSizeCategoryFile,
+                esduBySpeciesAndAgeCategoryFile};
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsImportService.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsImportService.java
index 82be42b..add3e36 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsImportService.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsImportService.java
@@ -112,7 +112,6 @@ public class ResultsImportService extends AbstractImportDataService<ResultsImpor
 
                                 String dataAcquisitionStr = transectStr + " / " + dataAcquisitionDecorator.toString(dataAcquisition);
 
-
                                 if (!dataAcquisition.isDataProcessingEmpty()) {
                                     for (DataProcessing dataProcessing : dataAcquisition.getDataProcessing()) {
 
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsMapFishCellImportService.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsMapFishCellImportService.java
index ab15c65..6efc78b 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsMapFishCellImportService.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsMapFishCellImportService.java
@@ -49,8 +49,9 @@ import org.nuiton.csv.Import;
 import org.nuiton.csv.ImportRuntimeException;
 import org.nuiton.csv.ext.CsvReaders;
 
+import java.io.IOException;
 import java.io.Reader;
-import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
@@ -67,28 +68,22 @@ public class ResultsMapFishCellImportService extends AbstractImportDataService<R
             LogFactory.getLog(ResultsMapFishCellImportService.class);
 
     @Override
-    public void startImport(
-            ResultsImportConfiguration configuration,
-            EchoBaseUser user) throws ImportException {
+    public void startImport(ResultsImportConfiguration configuration, EchoBaseUser user) throws ImportException {
 
         // get selected voyage
-        Voyage voyage = persistenceService.getVoyage(
-                configuration.getVoyageId());
+        Voyage voyage = persistenceService.getVoyage(configuration.getVoyageId());
 
-        EchoBaseCsvFileImportResult importResult;
-        importResult = importMapFile(configuration, voyage);
+        EchoBaseCsvFileImportResult importResult = importMapFile(configuration, voyage);
         configuration.addResult(importResult);
+
     }
 
-    protected EchoBaseCsvFileImportResult importMapFile(
-            ResultsImportConfiguration configuration,
-            Voyage voyage) throws ImportException {
+    protected EchoBaseCsvFileImportResult importMapFile(ResultsImportConfiguration configuration, Voyage voyage) throws ImportException {
 
         InputFile inputFile = configuration.getMapsFile();
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of Map cells from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of Map cells from file " + inputFile.getFileName());
         }
 
         String resultLabel = configuration.getResultLabel();
@@ -108,124 +103,114 @@ public class ResultsMapFishCellImportService extends AbstractImportDataService<R
         DataMetadata dataDepthLagMeta = persistenceService.getDataMetadataByName(DataMetadataImpl.GRID_DEPTH_LAG);
 
         // authorize only the selected voyage to be imported
-        Map<String, Voyage> voyageMap = Maps.uniqueIndex(Arrays.asList(
-                voyage), Voyages.VOYAGE_NAME);
+        Map<String, Voyage> voyageMap = Maps.uniqueIndex(Collections.singletonList(voyage), Voyages.VOYAGE_NAME);
 
-        Map<String, Species> speciesMap = persistenceService.getEntitiesMap(
-                Species.class, Species2.SPECIES_BARACOUDA_CODE);
+        Map<String, Species> speciesMap = persistenceService.getEntitiesMap(Species.class, Species2.SPECIES_BARACOUDA_CODE);
 
         Map<String, SizeCategory> sizeCategoryMap = Maps.newTreeMap();
-        sizeCategoryMap.putAll(persistenceService.getEntitiesMap(
-                SizeCategory.class, SizeCategories.SIZE_CATEGORY_NAME));
+        sizeCategoryMap.putAll(persistenceService.getEntitiesMap(SizeCategory.class, SizeCategories.SIZE_CATEGORY_NAME));
 
         Map<String, AgeCategory> ageCategoryMap = Maps.newTreeMap();
-        ageCategoryMap.putAll(persistenceService.getEntitiesMap(
-                AgeCategory.class, AgeCategories.AGE_CATEGORY_NAME));
+        ageCategoryMap.putAll(persistenceService.getEntitiesMap(AgeCategory.class, AgeCategories.AGE_CATEGORY_NAME));
 
-        Map<String, DataMetadata> dataMetadataMap = persistenceService.getEntitiesMap(
-                DataMetadata.class, DataMetadatas.DATA_METADATA_NAME);
+        Map<String, DataMetadata> dataMetadataMap = persistenceService.getEntitiesMap(DataMetadata.class, DataMetadatas.DATA_METADATA_NAME);
 
-        Map<String, DataQuality> dataQualityMap = persistenceService.getEntitiesMap(
-                DataQuality.class, DataQualities.DATA_QUALITY_NAME);
+        Map<String, DataQuality> dataQualityMap = persistenceService.getEntitiesMap(DataQuality.class, DataQualities.DATA_QUALITY_NAME);
 
         // first get header of file to detect which results to import
-        String[] header = CsvReaders.getHeader(inputFile.getFile(),
-                                               getCsvSeparator());
-
-        List<DataMetadata> metas = getMetas(
-                MapCellImportModel.COLUMN_NAMES_TO_EXCLUDE,
-                dataMetadataMap,
-                header);
-
-        MapCellImportModel csvModel = new MapCellImportModel(
-                getCsvSeparator(),
-                cellType,
-                voyageMap,
-                speciesMap,
-                sizeCategoryMap,
-                ageCategoryMap,
-                metas,
-                dataQualityMap);
+        String[] header = CsvReaders.getHeader(inputFile.getFile(), getCsvSeparator());
+
+        List<DataMetadata> metas = getMetas(MapCellImportModel.COLUMN_NAMES_TO_EXCLUDE, dataMetadataMap, header);
 
         EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<MapCellImportRow> importer =
-                    Import.newImport(csvModel, reader);
-
-            configuration.incrementsProgress();
-
-            int rowNumber = 0;
-            for (MapCellImportRow row : importer) {
-
-                doFlushTransaction(++rowNumber, inputFile, configuration);
-
-                Cell cell = persistenceService.createCell(row.getCell());
-                voyage.addPostCell(cell);
-
-                // collect ids
-                importResult.addId(EchoBaseUserEntityEnum.Cell, cell);
-
-                DataQuality dataQuality = row.getDataQuality();
-
-                // add gridCellLongitude data
-                createCellData(cell,
-                               dataLongitudeMeta,
-                               String.valueOf(row.getGridCellLongitude()),
-                               dataQuality,
-                               importResult);
-
-                // add gridCellLatitude data
-                createCellData(cell,
-                               dataLatitudeMeta,
-                               String.valueOf(row.getGridCellLatitude()),
-                               dataQuality,
-                               importResult);
-
-                // add gridCellDepth data
-                createCellData(cell,
-                               dataDepthMeta,
-                               String.valueOf(row.getGridCellDepth()),
-                               dataQuality,
-                               importResult);
-
-                // add gridLongitudeLag data
-                createCellData(cell,
-                               dataLongitudeLagMeta,
-                               String.valueOf(row.getGridLongitudeLag()),
-                               dataQuality,
-                               importResult);
-
-                // add gridLatitudeLag data
-                createCellData(cell,
-                               dataLatitudeLagMeta,
-                               String.valueOf(row.getGridLatitudeLag()),
-                               dataQuality,
-                               importResult);
-
-                // add gridDepthLag data
-                createCellData(cell,
-                               dataDepthLagMeta,
-                               String.valueOf(row.getGridDepthLag()),
-                               dataQuality,
-                               importResult);
-
-                Category category = getResultCategory(null,
-                                                      row.getSpecies(),
-                                                      row.getSizeCategory(),
-                                                      row.getAgeCategory(),
-                                                      importResult);
-
-                addResults(row, cell, category, resultLabel, importResult, false, true);
+        try (Reader reader = getInputFileReader(inputFile)) {
+
+            MapCellImportModel csvModel = new MapCellImportModel(getCsvSeparator(),
+                                                                 cellType,
+                                                                 voyageMap,
+                                                                 speciesMap,
+                                                                 sizeCategoryMap,
+                                                                 ageCategoryMap,
+                                                                 metas,
+                                                                 dataQualityMap);
+
+            try (Import<MapCellImportRow> importer = Import.newImport(csvModel, reader)) {
+
+                configuration.incrementsProgress();
+
+                int rowNumber = 0;
+                for (MapCellImportRow row : importer) {
+
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
+
+                    Cell cell = persistenceService.createCell(row.getCell());
+                    voyage.addPostCell(cell);
+
+                    // collect ids
+                    importResult.addId(EchoBaseUserEntityEnum.Cell, cell);
+
+                    DataQuality dataQuality = row.getDataQuality();
+
+                    // add gridCellLongitude data
+                    createCellData(cell,
+                                   dataLongitudeMeta,
+                                   String.valueOf(row.getGridCellLongitude()),
+                                   dataQuality,
+                                   importResult);
+
+                    // add gridCellLatitude data
+                    createCellData(cell,
+                                   dataLatitudeMeta,
+                                   String.valueOf(row.getGridCellLatitude()),
+                                   dataQuality,
+                                   importResult);
+
+                    // add gridCellDepth data
+                    createCellData(cell,
+                                   dataDepthMeta,
+                                   String.valueOf(row.getGridCellDepth()),
+                                   dataQuality,
+                                   importResult);
+
+                    // add gridLongitudeLag data
+                    createCellData(cell,
+                                   dataLongitudeLagMeta,
+                                   String.valueOf(row.getGridLongitudeLag()),
+                                   dataQuality,
+                                   importResult);
+
+                    // add gridLatitudeLag data
+                    createCellData(cell,
+                                   dataLatitudeLagMeta,
+                                   String.valueOf(row.getGridLatitudeLag()),
+                                   dataQuality,
+                                   importResult);
+
+                    // add gridDepthLag data
+                    createCellData(cell,
+                                   dataDepthLagMeta,
+                                   String.valueOf(row.getGridDepthLag()),
+                                   dataQuality,
+                                   importResult);
+
+                    Category category = getResultCategory(null,
+                                                          row.getSpecies(),
+                                                          row.getSizeCategory(),
+                                                          row.getAgeCategory(),
+                                                          importResult);
+
+                    addResults(row, cell, category, resultLabel, importResult, false, true);
+
+                }
             }
 
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
+
     }
 
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsMapOtherCellImportService.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsMapOtherCellImportService.java
index 8397c33..14ede15 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsMapOtherCellImportService.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsMapOtherCellImportService.java
@@ -43,8 +43,9 @@ import org.nuiton.csv.Import;
 import org.nuiton.csv.ImportRuntimeException;
 import org.nuiton.csv.ext.CsvReaders;
 
+import java.io.IOException;
 import java.io.Reader;
-import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
@@ -57,31 +58,25 @@ import java.util.Map;
 public class ResultsMapOtherCellImportService extends AbstractImportDataService<ResultsImportConfiguration> {
 
     /** Logger. */
-    private static final Log log =
-            LogFactory.getLog(ResultsMapOtherCellImportService.class);
+    private static final Log log = LogFactory.getLog(ResultsMapOtherCellImportService.class);
 
     @Override
-    public void startImport(
-            ResultsImportConfiguration configuration,
-            EchoBaseUser user) throws ImportException {
+    public void startImport(ResultsImportConfiguration configuration, EchoBaseUser user) throws ImportException {
 
         // get selected voyage
         Voyage voyage = persistenceService.getVoyage(configuration.getVoyageId());
 
-        EchoBaseCsvFileImportResult importResult;
-        importResult = importMapFile(configuration, voyage);
+        EchoBaseCsvFileImportResult importResult = importMapFile(configuration, voyage);
         configuration.addResult(importResult);
+
     }
 
-    protected EchoBaseCsvFileImportResult importMapFile(
-            ResultsImportConfiguration configuration,
-            Voyage voyage) throws ImportException {
+    protected EchoBaseCsvFileImportResult importMapFile(ResultsImportConfiguration configuration, Voyage voyage) throws ImportException {
 
         InputFile inputFile = configuration.getMapsFile();
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of Map Other cells from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of Map Other cells from file " + inputFile.getFileName());
         }
 
         String resultLabel = configuration.getResultLabel();
@@ -101,104 +96,93 @@ public class ResultsMapOtherCellImportService extends AbstractImportDataService<
         DataMetadata dataDepthLagMeta = persistenceService.getDataMetadataByName(DataMetadataImpl.GRID_DEPTH_LAG);
 
         // authorize only the selected voyage to be imported
-        Map<String, Voyage> voyageMap = Maps.uniqueIndex(Arrays.asList(
-                voyage), Voyages.VOYAGE_NAME);
+        Map<String, Voyage> voyageMap = Maps.uniqueIndex(Collections.singletonList(voyage), Voyages.VOYAGE_NAME);
 
-        Map<String, DataMetadata> dataMetadataMap = persistenceService.getEntitiesMap(
-                DataMetadata.class, DataMetadatas.DATA_METADATA_NAME);
+        Map<String, DataMetadata> dataMetadataMap = persistenceService.getEntitiesMap(DataMetadata.class, DataMetadatas.DATA_METADATA_NAME);
 
-        Map<String, DataQuality> dataQualityMap = persistenceService.getEntitiesMap(
-                DataQuality.class, DataQualities.DATA_QUALITY_NAME);
+        Map<String, DataQuality> dataQualityMap = persistenceService.getEntitiesMap(DataQuality.class, DataQualities.DATA_QUALITY_NAME);
 
         // first get header of file to detect which results to import
-        String[] header = CsvReaders.getHeader(inputFile.getFile(),
-                                               getCsvSeparator());
-
-        List<DataMetadata> metas = getMetas(
-                MapCellImportModel.COLUMN_NAMES_TO_EXCLUDE,
-                dataMetadataMap,
-                header);
+        String[] header = CsvReaders.getHeader(inputFile.getFile(), getCsvSeparator());
 
-        MapCellImportModel csvModel = new MapCellImportModel(
-                getCsvSeparator(),
-                cellType,
-                voyageMap,
-                metas,
-                dataQualityMap);
+        List<DataMetadata> metas = getMetas(MapCellImportModel.COLUMN_NAMES_TO_EXCLUDE, dataMetadataMap, header);
 
         EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<MapCellImportRow> importer =
-                    Import.newImport(csvModel, reader);
-
-            configuration.incrementsProgress();
-
-            int rowNumber = 0;
-            for (MapCellImportRow row : importer) {
-
-                doFlushTransaction(++rowNumber, inputFile, configuration);
-
-                Cell cell = persistenceService.createCell(row.getCell());
-                voyage.addPostCell(cell);
-
-                // collect ids
-                importResult.addId(EchoBaseUserEntityEnum.Cell, cell);
-
-                DataQuality dataQuality = row.getDataQuality();
-
-                // add gridCellLongitude data
-                createCellData(cell,
-                               dataLongitudeMeta,
-                               String.valueOf(row.getGridCellLongitude()),
-                               dataQuality,
-                               importResult);
-
-                // add gridCellLatitude data
-                createCellData(cell,
-                               dataLatitudeMeta,
-                               String.valueOf(row.getGridCellLatitude()),
-                               dataQuality,
-                               importResult);
-
-                // add gridCellDepth data
-                createCellData(cell,
-                               dataDepthMeta,
-                               String.valueOf(row.getGridCellDepth()),
-                               dataQuality,
-                               importResult);
-
-                // add gridLongitudeLag data
-                createCellData(cell,
-                               dataLongitudeLagMeta,
-                               String.valueOf(row.getGridLongitudeLag()),
-                               dataQuality,
-                               importResult);
-
-                // add gridLatitudeLag data
-                createCellData(cell,
-                               dataLatitudeLagMeta,
-                               String.valueOf(row.getGridLatitudeLag()),
-                               dataQuality,
-                               importResult);
-
-                // add gridDepthLag data
-                createCellData(cell,
-                               dataDepthLagMeta,
-                               String.valueOf(row.getGridDepthLag()),
-                               dataQuality,
-                               importResult);
-
-                addResults(row, cell, null, resultLabel, importResult, false, true);
+        try (Reader reader = getInputFileReader(inputFile)) {
+
+            MapCellImportModel csvModel = new MapCellImportModel(getCsvSeparator(), cellType, voyageMap, metas, dataQualityMap);
+
+            try (Import<MapCellImportRow> importer = Import.newImport(csvModel, reader)) {
+
+                configuration.incrementsProgress();
+
+                int rowNumber = 0;
+                for (MapCellImportRow row : importer) {
+
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
+
+                    Cell cell = persistenceService.createCell(row.getCell());
+                    voyage.addPostCell(cell);
+
+                    // collect ids
+                    importResult.addId(EchoBaseUserEntityEnum.Cell, cell);
+
+                    DataQuality dataQuality = row.getDataQuality();
+
+                    // add gridCellLongitude data
+                    createCellData(cell,
+                                   dataLongitudeMeta,
+                                   String.valueOf(row.getGridCellLongitude()),
+                                   dataQuality,
+                                   importResult);
+
+                    // add gridCellLatitude data
+                    createCellData(cell,
+                                   dataLatitudeMeta,
+                                   String.valueOf(row.getGridCellLatitude()),
+                                   dataQuality,
+                                   importResult);
+
+                    // add gridCellDepth data
+                    createCellData(cell,
+                                   dataDepthMeta,
+                                   String.valueOf(row.getGridCellDepth()),
+                                   dataQuality,
+                                   importResult);
+
+                    // add gridLongitudeLag data
+                    createCellData(cell,
+                                   dataLongitudeLagMeta,
+                                   String.valueOf(row.getGridLongitudeLag()),
+                                   dataQuality,
+                                   importResult);
+
+                    // add gridLatitudeLag data
+                    createCellData(cell,
+                                   dataLatitudeLagMeta,
+                                   String.valueOf(row.getGridLatitudeLag()),
+                                   dataQuality,
+                                   importResult);
+
+                    // add gridDepthLag data
+                    createCellData(cell,
+                                   dataDepthLagMeta,
+                                   String.valueOf(row.getGridDepthLag()),
+                                   dataQuality,
+                                   importResult);
+
+                    addResults(row, cell, null, resultLabel, importResult, false, true);
+
+                }
             }
 
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
+
     }
 
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsRegionCellImportService.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsRegionCellImportService.java
index b3e6773..18bfb28 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsRegionCellImportService.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsRegionCellImportService.java
@@ -54,8 +54,9 @@ import org.nuiton.csv.Import;
 import org.nuiton.csv.ImportRuntimeException;
 import org.nuiton.csv.ext.CsvReaders;
 
+import java.io.IOException;
 import java.io.Reader;
-import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -69,36 +70,33 @@ import java.util.Set;
 public class ResultsRegionCellImportService extends AbstractImportDataService<ResultsImportConfiguration> {
 
     /** Logger. */
-    private static final Log log =
-            LogFactory.getLog(ResultsRegionCellImportService.class);
+    private static final Log log = LogFactory.getLog(ResultsRegionCellImportService.class);
 
     @Override
-    public void startImport(ResultsImportConfiguration configuration,
-                            EchoBaseUser user) throws ImportException {
+    public void startImport(ResultsImportConfiguration configuration, EchoBaseUser user) throws ImportException {
 
         // get selected voyage
-        Voyage voyage = persistenceService.getVoyage(
-                configuration.getVoyageId());
+        Voyage voyage = persistenceService.getVoyage(configuration.getVoyageId());
 
-        Map<String, DataQuality> dataQualityMap = persistenceService.getEntitiesMap(
-                DataQuality.class, DataQualities.DATA_QUALITY_NAME);
+        Map<String, DataQuality> dataQualityMap = persistenceService.getEntitiesMap(DataQuality.class, DataQualities.DATA_QUALITY_NAME);
 
-        EchoBaseCsvFileImportResult importResult;
-
-        importResult = importRegionFile(configuration, voyage, dataQualityMap);
-        configuration.addResult(importResult);
-
-        importResult = importRegionAssociationFile(configuration, voyage);
-        configuration.addResult(importResult);
-
-        importResult = importRegionResultFile(configuration, voyage, dataQualityMap);
-        configuration.addResult(importResult);
+        {
+            EchoBaseCsvFileImportResult importResult = importRegionFile(configuration, voyage, dataQualityMap);
+            configuration.addResult(importResult);
+        }
+        {
+            EchoBaseCsvFileImportResult importResult = importRegionAssociationFile(configuration, voyage);
+            configuration.addResult(importResult);
+        }
+        {
+            EchoBaseCsvFileImportResult importResult = importRegionResultFile(configuration, voyage, dataQualityMap);
+            configuration.addResult(importResult);
+        }
     }
 
-    protected EchoBaseCsvFileImportResult importRegionFile(
-            ResultsImportConfiguration configuration,
-            Voyage voyage,
-            Map<String, DataQuality> dataQualityMap) throws ImportException {
+    protected EchoBaseCsvFileImportResult importRegionFile(ResultsImportConfiguration configuration,
+                                                           Voyage voyage,
+                                                           Map<String, DataQuality> dataQualityMap) throws ImportException {
 
         InputFile inputFile = configuration.getRegionsFile();
 
@@ -109,207 +107,184 @@ public class ResultsRegionCellImportService extends AbstractImportDataService<Re
         DataMetadata dataSurfaceMeta = persistenceService.getDataMetadataByName(DataMetadataImpl.SURFACE);
 
         // authorize only the selected voyage to be imported
-        Map<String, Voyage> voyageMap = Maps.uniqueIndex(Arrays.asList(
-                voyage), Voyages.VOYAGE_NAME);
+        Map<String, Voyage> voyageMap = Maps.uniqueIndex(Collections.singletonList(voyage), Voyages.VOYAGE_NAME);
 
         // authorize only to use region* cell types
-        Map<String, CellType> cellTypeMap = Maps.uniqueIndex(
-                allCellTypes,
-                CellTypes.CELL_TYPE_ID);
-
-        RegionCellImportModel csvModel = new RegionCellImportModel(
-                getCsvSeparator(),
-                voyageMap,
-                cellTypeMap,
-                dataQualityMap);
+        Map<String, CellType> cellTypeMap = Maps.uniqueIndex(allCellTypes, CellTypes.CELL_TYPE_ID);
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of Region cells from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of Region cells from file " + inputFile.getFileName());
         }
 
         EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<RegionCellImportRow> importer =
-                    Import.newImport(csvModel, reader);
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-            Cell cell = null;
+            RegionCellImportModel csvModel = new RegionCellImportModel(getCsvSeparator(),
+                                                                       voyageMap,
+                                                                       cellTypeMap,
+                                                                       dataQualityMap);
+            try (Import<RegionCellImportRow> importer = Import.newImport(csvModel, reader)) {
 
-            configuration.incrementsProgress();
-            int rowNumber = 0;
-            for (RegionCellImportRow row : importer) {
+                Cell cell = null;
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
-                if (cell == null || !row.getName().equals(cell.getName())) {
+                configuration.incrementsProgress();
+                int rowNumber = 0;
+                for (RegionCellImportRow row : importer) {
 
-                    cell = persistenceService.createCell(
-                            row.getCellType(), row.getName());
-                    voyage.addPostCell(cell);
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
+                    if (cell == null || !row.getName().equals(cell.getName())) {
 
-                    // collect ids
-                    importResult.addId(EchoBaseUserEntityEnum.Cell, cell);
+                        cell = persistenceService.createCell(row.getCellType(), row.getName());
+                        voyage.addPostCell(cell);
 
-                    // add surface data
+                        // collect ids
+                        importResult.addId(EchoBaseUserEntityEnum.Cell, cell);
+
+                        // add surface data
+                        createCellData(cell,
+                                       dataSurfaceMeta,
+                                       String.valueOf(row.getDataSurface()),
+                                       row.getDataQuality(),
+                                       importResult);
+                    }
+
+                    // add coordinate data
                     createCellData(cell,
-                                   dataSurfaceMeta,
-                                   String.valueOf(row.getDataSurface()),
+                                   dataCoordinateMeta,
+                                   row.getDataCoordinate(),
                                    row.getDataQuality(),
                                    importResult);
                 }
-
-                // add coordinate data
-                createCellData(cell,
-                               dataCoordinateMeta,
-                               row.getDataCoordinate(),
-                               row.getDataQuality(),
-                               importResult);
             }
 
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
+
     }
 
-    protected EchoBaseCsvFileImportResult importRegionAssociationFile(
-            ResultsImportConfiguration configuration,
-            Voyage voyage) throws ImportException {
+    protected EchoBaseCsvFileImportResult importRegionAssociationFile(ResultsImportConfiguration configuration,
+                                                                      Voyage voyage) throws ImportException {
 
         InputFile inputFile = configuration.getRegionAssociationFile();
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of Region cells association from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of Region cells association from file " + inputFile.getFileName());
         }
 
         // authorize only the selected voyage to be imported
-        Map<String, Voyage> voyageMap = Maps.uniqueIndex(Arrays.asList(
-                voyage), Voyages.VOYAGE_NAME);
-
-        Map<String, Cell> regionsMap = Maps.uniqueIndex(
-                voyage.getRegionCells(), Cells.CELL_BY_NAME);
+        Map<String, Voyage> voyageMap = Maps.uniqueIndex(Collections.singletonList(voyage), Voyages.VOYAGE_NAME);
 
-        RegionCellAssociationImportModel csvModel = new RegionCellAssociationImportModel(
-                getCsvSeparator(),
-                voyageMap,
-                regionsMap,
-                persistenceService.newCellValueParser(voyage));
+        Map<String, Cell> regionsMap = Maps.uniqueIndex(voyage.getRegionCells(), Cells.CELL_BY_NAME);
 
         EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<RegionCellAssociationImportRow> importer =
-                    Import.newImport(csvModel, reader);
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-            configuration.incrementsProgress();
-            int rowNumber = 0;
-            for (RegionCellAssociationImportRow row : importer) {
+            RegionCellAssociationImportModel csvModel = new RegionCellAssociationImportModel(getCsvSeparator(),
+                                                                                             voyageMap,
+                                                                                             regionsMap,
+                                                                                             persistenceService.newCellValueParser(voyage));
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
+            try (Import<RegionCellAssociationImportRow> importer = Import.newImport(csvModel, reader)) {
 
-                Cell regionCell = row.getRegionCell();
-                Cell esduCell = row.getEsduCell();
-                regionCell.addChilds(esduCell);
-                importResult.incrementsNumberUpdated(EchoBaseUserEntityEnum.Cell);
+                configuration.incrementsProgress();
+                int rowNumber = 0;
+                for (RegionCellAssociationImportRow row : importer) {
+
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
+
+                    Cell regionCell = row.getRegionCell();
+                    Cell esduCell = row.getEsduCell();
+                    regionCell.addChilds(esduCell);
+                    importResult.incrementsNumberUpdated(EchoBaseUserEntityEnum.Cell);
+                }
             }
 
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
+
     }
 
-    protected EchoBaseCsvFileImportResult importRegionResultFile(
-            ResultsImportConfiguration configuration,
-            Voyage voyage,
-            Map<String, DataQuality> dataQualityMap) throws ImportException {
+    protected EchoBaseCsvFileImportResult importRegionResultFile(ResultsImportConfiguration configuration,
+                                                                 Voyage voyage,
+                                                                 Map<String, DataQuality> dataQualityMap) throws ImportException {
 
         InputFile inputFile = configuration.getRegionResultFile();
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of Region cell results from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of Region cell results from file " + inputFile.getFileName());
         }
 
         // authorize only the selected voyage to be imported
-        Map<String, Voyage> voyageMap = Maps.uniqueIndex(Arrays.asList(
-                voyage), Voyages.VOYAGE_NAME);
+        Map<String, Voyage> voyageMap = Maps.uniqueIndex(Collections.singletonList(voyage), Voyages.VOYAGE_NAME);
 
         // index regions of the voyage
-        Map<String, Cell> regionsMap = Maps.uniqueIndex(
-                voyage.getRegionCells(), Cells.CELL_BY_NAME);
+        Map<String, Cell> regionsMap = Maps.uniqueIndex(voyage.getRegionCells(), Cells.CELL_BY_NAME);
 
         // index all echotypes of thi voyage
-        Map<String, Echotype> echotypeMap = Maps.uniqueIndex(
-                voyage.getEchotype(), Echotypes.ECHOTYPE_NAME);
+        Map<String, Echotype> echotypeMap = Maps.uniqueIndex(voyage.getEchotype(), Echotypes.ECHOTYPE_NAME);
 
-        Map<String, Species> speciesMap = persistenceService.getEntitiesMap(
-                Species.class, Species2.SPECIES_BARACOUDA_CODE);
+        Map<String, Species> speciesMap = persistenceService.getEntitiesMap(Species.class, Species2.SPECIES_BARACOUDA_CODE);
 
         Map<String, SizeCategory> sizeCategoryMap = Maps.newTreeMap();
-        sizeCategoryMap.putAll(persistenceService.getEntitiesMap(
-                SizeCategory.class, SizeCategories.SIZE_CATEGORY_NAME));
+        sizeCategoryMap.putAll(persistenceService.getEntitiesMap(SizeCategory.class, SizeCategories.SIZE_CATEGORY_NAME));
 
-        Map<String, DataMetadata> dataMetadataMap = persistenceService.getEntitiesMap(
-                DataMetadata.class, DataMetadatas.DATA_METADATA_NAME);
+        Map<String, DataMetadata> dataMetadataMap = persistenceService.getEntitiesMap(DataMetadata.class, DataMetadatas.DATA_METADATA_NAME);
 
         // first get header of file to detect which results to import
-        String[] header = CsvReaders.getHeader(inputFile.getFile(),
-                                               getCsvSeparator());
-
-        List<DataMetadata> metas = getMetas(
-                RegionCellResultImportModel.COLUMN_NAMES_TO_EXCLUDE,
-                dataMetadataMap,
-                header);
-
-        RegionCellResultImportModel csvModel = new RegionCellResultImportModel(
-                getCsvSeparator(),
-                voyageMap,
-                regionsMap,
-                echotypeMap,
-                speciesMap,
-                sizeCategoryMap,
-                metas,
-                dataQualityMap);
+        String[] header = CsvReaders.getHeader(inputFile.getFile(), getCsvSeparator());
+
+        List<DataMetadata> metas = getMetas(RegionCellResultImportModel.COLUMN_NAMES_TO_EXCLUDE, dataMetadataMap, header);
 
         String resultLabel = configuration.getResultLabel();
 
         EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<RegionCellResultImportRow> importer =
-                    Import.newImport(csvModel, reader);
+        try (Reader reader = getInputFileReader(inputFile)) {
+
+            RegionCellResultImportModel csvModel = new RegionCellResultImportModel(getCsvSeparator(),
+                                                                                   voyageMap,
+                                                                                   regionsMap,
+                                                                                   echotypeMap,
+                                                                                   speciesMap,
+                                                                                   sizeCategoryMap,
+                                                                                   metas,
+                                                                                   dataQualityMap);
 
-            configuration.incrementsProgress();
-            int rowNumber = 0;
-            for (RegionCellResultImportRow row : importer) {
+            try (Import<RegionCellResultImportRow> importer = Import.newImport(csvModel, reader)) {
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
+                configuration.incrementsProgress();
+                int rowNumber = 0;
+                for (RegionCellResultImportRow row : importer) {
 
-                Cell cell = row.getCell();
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
 
-                Category category = getResultCategory(row.getEchotype(),
-                                                      row.getSpecies(),
-                                                      row.getSizeCategory(),
-                                                      null,
-                                                      importResult);
+                    Cell cell = row.getCell();
 
-                addResults(row, cell, category, resultLabel, importResult, false, false);
+                    Category category = getResultCategory(row.getEchotype(),
+                                                          row.getSpecies(),
+                                                          row.getSizeCategory(),
+                                                          null,
+                                                          importResult);
+
+                    addResults(row, cell, category, resultLabel, importResult, false, false);
+
+                }
             }
 
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
+
         }
+
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java
index 016b3af..9ff9d50 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java
@@ -21,6 +21,10 @@ package fr.ifremer.echobase.services.service.importdata;
  * #L%
  */
 
+import java.util.Locale;
+
+import static org.nuiton.i18n.I18n.l;
+
 /**
  * Created on 1/21/15.
  *
@@ -31,7 +35,7 @@ public class ResultsVoyageImportAlreadyExistException extends ImportException {
 
     private static final long serialVersionUID = 1L;
 
-    public ResultsVoyageImportAlreadyExistException(String message) {
-        super(message);
+    public ResultsVoyageImportAlreadyExistException(Locale locale) {
+        super(l(locale, "echobase.importError.voyageResultImport.alreadyDone"));
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportService.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportService.java
index e47112f..5916172 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportService.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportService.java
@@ -52,13 +52,12 @@ import org.apache.commons.logging.LogFactory;
 import org.nuiton.csv.Import;
 import org.nuiton.csv.ImportRuntimeException;
 
+import java.io.IOException;
 import java.io.Reader;
-import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Map;
 
-import static org.nuiton.i18n.I18n.l;
-
 /**
  * To import results attached to a voyage (but not cells).
  *
@@ -73,12 +72,9 @@ public class ResultsVoyageImportService extends AbstractImportDataService<Result
     @Override
     public void startImport(ResultsImportConfiguration configuration, EchoBaseUser user) throws ImportException {
 
-        Map<String, Species> speciesMap = persistenceService.getEntitiesMap(
-                Species.class,
-                Species2.SPECIES_BARACOUDA_CODE);
+        Map<String, Species> speciesMap = persistenceService.getEntitiesMap(Species.class, Species2.SPECIES_BARACOUDA_CODE);
 
-        Map<String, Strata> strataMap = persistenceService.getEntitiesMap(
-                Strata.class, Stratas.STRATA_BY_NAME);
+        Map<String, Strata> strataMap = persistenceService.getEntitiesMap(Strata.class, Stratas.STRATA_BY_NAME);
 
         // get selected voyage
         Voyage voyage = persistenceService.getVoyage(configuration.getVoyageId());
@@ -89,257 +85,223 @@ public class ResultsVoyageImportService extends AbstractImportDataService<Result
             if (log.isWarnEnabled()) {
                 log.warn("there is already a voyage result import for this voyage, won't import.");
             }
-            throw new ResultsVoyageImportAlreadyExistException(l(getLocale(), "echobase.importError.voyageResultImport.alreadyDone"));
+            throw new ResultsVoyageImportAlreadyExistException(getLocale());
         }
 
         // authorize only the selected voyage to be imported
-        Map<String, Voyage> voyageMap = Maps.uniqueIndex(Arrays.asList(voyage), Voyages.VOYAGE_NAME);
+        Map<String, Voyage> voyageMap = Maps.uniqueIndex(Collections.singletonList(voyage), Voyages.VOYAGE_NAME);
 
         if (configuration.getLengthAgeKeyFile().hasFile()) {
 
-            EchoBaseCsvFileImportResult importResult = importLenthAgeKey(
-                    configuration,
-                    configuration.getLengthAgeKeyFile(),
-                    voyageMap,
-                    strataMap,
-                    speciesMap
-            );
+            EchoBaseCsvFileImportResult importResult = importLenthAgeKey(configuration,
+                                                                         configuration.getLengthAgeKeyFile(),
+                                                                         voyageMap,
+                                                                         strataMap,
+                                                                         speciesMap);
             configuration.addResult(importResult);
+
         }
 
         if (configuration.getLengthWeightKeyFile().hasFile()) {
 
-            EchoBaseCsvFileImportResult importResult = importLenghtWeightKey(
-                    configuration,
-                    configuration.getLengthWeightKeyFile(),
-                    voyageMap,
-                    strataMap,
-                    speciesMap
-            );
+            EchoBaseCsvFileImportResult importResult = importLenghtWeightKey(configuration,
+                                                                             configuration.getLengthWeightKeyFile(),
+                                                                             voyageMap,
+                                                                             strataMap,
+                                                                             speciesMap);
             configuration.addResult(importResult);
+
         }
 
         if (configuration.getEchotypeFile().hasFile()) {
 
-            EchoBaseCsvFileImportResult importResult = importEchotypeFile(
-                    configuration,
-                    configuration.getEchotypeFile(),
-                    voyageMap,
-                    speciesMap
-            );
+            EchoBaseCsvFileImportResult importResult = importEchotypeFile(configuration,
+                                                                          configuration.getEchotypeFile(),
+                                                                          voyageMap,
+                                                                          speciesMap);
             configuration.addResult(importResult);
+
         }
     }
 
-    protected EchoBaseCsvFileImportResult importLenghtWeightKey(
-            ResultsImportConfiguration configuration,
-            InputFile inputFile,
-            Map<String, Voyage> voyageMap,
-            Map<String, Strata> strataMap,
-            Map<String, Species> speciesMap) throws ImportException {
+    protected EchoBaseCsvFileImportResult importLenghtWeightKey(ResultsImportConfiguration configuration,
+                                                                InputFile inputFile,
+                                                                Map<String, Voyage> voyageMap,
+                                                                Map<String, Strata> strataMap,
+                                                                Map<String, Species> speciesMap) throws ImportException {
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of lenthWeightKey from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of lenthWeightKey from file " + inputFile.getFileName());
         }
 
-        EchoBaseCsvFileImportResult importResult = new EchoBaseCsvFileImportResult(
-                inputFile.getFileName());
+        Map<String, SizeCategory> sizeCategoryMap = persistenceService.getEntitiesMap(SizeCategory.class, SizeCategories.SIZE_CATEGORY_NAME);
+
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-        Map<String, SizeCategory> sizeCategoryMap = persistenceService.getEntitiesMap(
-                SizeCategory.class,
-                SizeCategories.SIZE_CATEGORY_NAME);
+            EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        LengthWeightKeyImportModel csvModel = new LengthWeightKeyImportModel(
-                getCsvSeparator(),
-                voyageMap,
-                strataMap,
-                sizeCategoryMap,
-                speciesMap);
+            LengthWeightKeyImportModel csvModel = new LengthWeightKeyImportModel(getCsvSeparator(),
+                                                                                 voyageMap,
+                                                                                 strataMap,
+                                                                                 sizeCategoryMap,
+                                                                                 speciesMap);
 
-        Reader reader = getInputFileReader(inputFile);
+            try (Import<LengthWeightKeyImportRow> importer = Import.newImport(csvModel, reader)) {
 
-        try {
-            Import<LengthWeightKeyImportRow> importer =
-                    Import.newImport(csvModel, reader);
+                configuration.incrementsProgress();
+                int rowNumber = 0;
+                for (LengthWeightKeyImportRow row : importer) {
 
-            configuration.incrementsProgress();
-            int rowNumber = 0;
-            for (LengthWeightKeyImportRow row : importer) {
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
+                    Voyage voyage = row.getVoyage();
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
-                Voyage voyage = row.getVoyage();
+                    // find speciesCategory
+                    SpeciesCategory speciesCategory = getSpeciesCategory(row.getSpecies(), row.getSizeCategory(), null, null, importResult);
 
-                // find speciesCategory
-                SpeciesCategory speciesCategory = getSpeciesCategory(
-                        row.getSpecies(),
-                        row.getSizeCategory(),
-                        null,
-                        null,
-                        importResult
-                );
+                    LengthWeightKey toCreate = row.getLengthWeightKey();
+                    toCreate.setSpeciesCategory(speciesCategory);
 
-                LengthWeightKey toCreate = row.getLengthWeightKey();
-                toCreate.setSpeciesCategory(speciesCategory);
+                    LengthWeightKey lengthWeightKey = persistenceService.createLengthWeightKey(toCreate);
 
-                LengthWeightKey lengthWeightKey = persistenceService.createLengthWeightKey(toCreate);
+                    //TODO should we import it ?
+                    //lengthWeightKey.setMetadata(row.getMetadata());
 
-                //TODO should we import it ?
-                //lengthWeightKey.setMetadata(row.getMetadata());
+                    // attach it to voyage
+                    voyage.addLengthWeightKey(lengthWeightKey);
 
-                // attach it to voyage
-                voyage.addLengthWeightKey(lengthWeightKey);
+                    // collect ids
+                    importResult.addId(EchoBaseUserEntityEnum.LengthWeightKey, lengthWeightKey);
 
-                // collect ids
-                importResult.addId(EchoBaseUserEntityEnum.LengthWeightKey,
-                                   lengthWeightKey);
+                }
             }
 
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
+
     }
 
-    protected EchoBaseCsvFileImportResult importLenthAgeKey(
-            ResultsImportConfiguration configuration,
-            InputFile inputFile,
-            Map<String, Voyage> voyageMap,
-            Map<String, Strata> strataMap,
-            Map<String, Species> speciesMap) throws ImportException {
+    protected EchoBaseCsvFileImportResult importLenthAgeKey(ResultsImportConfiguration configuration,
+                                                            InputFile inputFile,
+                                                            Map<String, Voyage> voyageMap,
+                                                            Map<String, Strata> strataMap,
+                                                            Map<String, Species> speciesMap) throws ImportException {
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of lenthAgeKey from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of lenthAgeKey from file " + inputFile.getFileName());
         }
 
         EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        LengthAgeKeyImportModel csvModel = new LengthAgeKeyImportModel(
-                getCsvSeparator(),
-                voyageMap,
-                strataMap,
-                speciesMap);
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<LengthAgeKeyImportRow> importer =
-                    Import.newImport(csvModel, reader);
+            LengthAgeKeyImportModel csvModel = new LengthAgeKeyImportModel(getCsvSeparator(), voyageMap, strataMap, speciesMap);
+            try (Import<LengthAgeKeyImportRow> importer = Import.newImport(csvModel, reader)) {
 
-            configuration.incrementsProgress();
+                configuration.incrementsProgress();
 
-            int rowNumber = 0;
-            for (LengthAgeKeyImportRow row : importer) {
+                int rowNumber = 0;
+                for (LengthAgeKeyImportRow row : importer) {
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
 
-                Voyage voyage = row.getVoyage();
+                    Voyage voyage = row.getVoyage();
 
-                LengthAgeKey lengthAgeKeyToCreate = row.getLengthAgeKey();
-                LengthAgeKey lengthAgeKey = persistenceService.createLengthAgeKey(lengthAgeKeyToCreate);
+                    LengthAgeKey lengthAgeKeyToCreate = row.getLengthAgeKey();
+                    LengthAgeKey lengthAgeKey = persistenceService.createLengthAgeKey(lengthAgeKeyToCreate);
 
-                // attach it to voyage
-                voyage.addLengthAgeKey(lengthAgeKey);
+                    // attach it to voyage
+                    voyage.addLengthAgeKey(lengthAgeKey);
 
-                // collect ids
-                importResult.addId(EchoBaseUserEntityEnum.LengthAgeKey,
-                                   lengthAgeKey);
+                    // collect ids
+                    importResult.addId(EchoBaseUserEntityEnum.LengthAgeKey, lengthAgeKey);
+
+                }
             }
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
+
     }
 
-    private EchoBaseCsvFileImportResult importEchotypeFile(
-            ResultsImportConfiguration configuration,
-            InputFile inputFile,
-            Map<String, Voyage> voyageMap,
-            Map<String, Species> speciesMap) throws ImportException {
+    private EchoBaseCsvFileImportResult importEchotypeFile(ResultsImportConfiguration configuration,
+                                                           InputFile inputFile,
+                                                           Map<String, Voyage> voyageMap,
+                                                           Map<String, Species> speciesMap) throws ImportException {
 
         if (log.isInfoEnabled()) {
-            log.info("Starts import of echotype from file " +
-                     inputFile.getFileName());
+            log.info("Starts import of echotype from file " + inputFile.getFileName());
         }
 
         EchoBaseCsvFileImportResult importResult = newImportResult(inputFile);
 
-        Map<String, DepthStratum> depthStratumMap = persistenceService.getEntitiesMap(
-                DepthStratum.class,
-                DepthStratums.DEPTH_STRATUM_ID);
+        Map<String, DepthStratum> depthStratumMap = persistenceService.getEntitiesMap(DepthStratum.class, DepthStratums.DEPTH_STRATUM_ID);
 
-        EchotypeImportModel csvModel = new EchotypeImportModel(
-                getCsvSeparator(),
-                voyageMap,
-                depthStratumMap,
-                speciesMap);
+        try (Reader reader = getInputFileReader(inputFile)) {
 
-        Reader reader = getInputFileReader(inputFile);
-        try {
-            Import<EchotypeImportRow> importer =
-                    Import.newImport(csvModel, reader);
+            EchotypeImportModel csvModel = new EchotypeImportModel(getCsvSeparator(), voyageMap, depthStratumMap, speciesMap);
 
-            configuration.incrementsProgress();
+            try (Import<EchotypeImportRow> importer = Import.newImport(csvModel, reader)) {
 
-            int rowNumber = 0;
-            for (EchotypeImportRow row : importer) {
+                configuration.incrementsProgress();
 
-                doFlushTransaction(++rowNumber, inputFile, configuration);
+                int rowNumber = 0;
+                for (EchotypeImportRow row : importer) {
 
-                Voyage voyage = row.getVoyage();
+                    doFlushTransaction(++rowNumber, inputFile, configuration);
 
-                Echotype rowEchotype = row.getEchotype();
+                    Voyage voyage = row.getVoyage();
 
-                String echotypeName = rowEchotype.getName();
+                    Echotype rowEchotype = row.getEchotype();
 
-                // check if there is a echotype for the voyage and this name
-                Echotype echotype = null;
+                    String echotypeName = rowEchotype.getName();
 
-                if (!voyage.isEchotypeEmpty()) {
+                    // check if there is a echotype for the voyage and this name
+                    Echotype echotype = null;
 
-                    Collection<Echotype> echotypes = voyage.getEchotype();
-                    Predicate<Echotype> predicate =
-                            Echotypes.newEchotypeByNamePredicate(
-                                    echotypeName);
-                    echotype = Iterables.find(echotypes, predicate, null);
+                    if (!voyage.isEchotypeEmpty()) {
 
-                }
+                        Collection<Echotype> echotypes = voyage.getEchotype();
+                        Predicate<Echotype> predicate = Echotypes.newEchotypeByNamePredicate(echotypeName);
+                        echotype = Iterables.find(echotypes, predicate, null);
 
-                if (echotype == null) {
+                    }
 
-                    // creates it
-                    echotype = persistenceService.createEchotype(rowEchotype);
+                    if (echotype == null) {
 
-                    // attach it to voyage
-                    voyage.addEchotype(echotype);
+                        // creates it
+                        echotype = persistenceService.createEchotype(rowEchotype);
 
-                    // collect ids
-                    importResult.addId(EchoBaseUserEntityEnum.Echotype, echotype);
+                        // attach it to voyage
+                        voyage.addEchotype(echotype);
+
+                        // collect ids
+                        importResult.addId(EchoBaseUserEntityEnum.Echotype, echotype);
 
-                } else {
+                    } else {
 
-                    Species species = rowEchotype.getSpecies().iterator().next();
-                    Species existingSpecie =
-                            echotype.getSpeciesByTopiaId(species.getTopiaId());
+                        Species species = rowEchotype.getSpecies().iterator().next();
+                        Species existingSpecie = echotype.getSpeciesByTopiaId(species.getTopiaId());
 
-                    if (existingSpecie == null) {
+                        if (existingSpecie == null) {
 
-                        // add this species
-                        echotype.addSpecies(species);
+                            // add this species
+                            echotype.addSpecies(species);
+                        }
                     }
                 }
             }
 
             return importResult;
-        } catch (ImportRuntimeException e) {
+
+        } catch (ImportRuntimeException | IOException e) {
             throw new ImportException(getLocale(), inputFile, e);
-        } finally {
-            closeReader(reader, inputFile);
         }
+
     }
 
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/TransectNotFoundException.java
similarity index 64%
copy from echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java
copy to echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/TransectNotFoundException.java
index 016b3af..913d0ff 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/TransectNotFoundException.java
@@ -21,17 +21,26 @@ package fr.ifremer.echobase.services.service.importdata;
  * #L%
  */
 
+import fr.ifremer.echobase.entities.data.Voyage;
+import fr.ifremer.echobase.entities.references.Vessel;
+import org.nuiton.csv.ImportRuntimeException;
+
+import java.util.Date;
+import java.util.Locale;
+
+import static org.nuiton.i18n.I18n.l;
+
 /**
  * Created on 1/21/15.
  *
  * @author Tony Chemit - chemit@codelutin.com
  * @since 2.9
  */
-public class ResultsVoyageImportAlreadyExistException extends ImportException {
+public class TransectNotFoundException extends ImportRuntimeException {
 
     private static final long serialVersionUID = 1L;
 
-    public ResultsVoyageImportAlreadyExistException(String message) {
-        super(message);
+    public TransectNotFoundException(Locale locale, Voyage voyage, Vessel vessel, Date startDate, int rowNumber) {
+        super(l(locale, "echobase.importError.transect.notfound", voyage.getName(), startDate, vessel.getName(), rowNumber));
     }
 }
diff --git a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/TransitNotFoundException.java
similarity index 68%
copy from echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java
copy to echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/TransitNotFoundException.java
index 016b3af..7fb6f70 100644
--- a/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/ResultsVoyageImportAlreadyExistException.java
+++ b/echobase-services/src/main/java/fr/ifremer/echobase/services/service/importdata/TransitNotFoundException.java
@@ -21,17 +21,25 @@ package fr.ifremer.echobase.services.service.importdata;
  * #L%
  */
 
+import fr.ifremer.echobase.entities.data.Voyage;
+import org.nuiton.csv.ImportRuntimeException;
+
+import java.util.Date;
+import java.util.Locale;
+
+import static org.nuiton.i18n.I18n.l;
+
 /**
  * Created on 1/21/15.
  *
  * @author Tony Chemit - chemit@codelutin.com
  * @since 2.9
  */
-public class ResultsVoyageImportAlreadyExistException extends ImportException {
+public class TransitNotFoundException extends ImportRuntimeException {
 
     private static final long serialVersionUID = 1L;
 
-    public ResultsVoyageImportAlreadyExistException(String message) {
-        super(message);
+    public TransitNotFoundException(Locale locale, Voyage voyage, Date startDate, int rowNumber) {
+        super(l(locale, "echobase.importError.transit.notfound", voyage.getName(), startDate, rowNumber));
     }
 }
diff --git a/echobase-services/src/test/java/fr/ifremer/echobase/services/service/importdata/AbstractImportDataServiceIT.java b/echobase-services/src/test/java/fr/ifremer/echobase/services/service/importdata/AbstractImportDataServiceIT.java
index 5018ac1..0fe2af2 100644
--- a/echobase-services/src/test/java/fr/ifremer/echobase/services/service/importdata/AbstractImportDataServiceIT.java
+++ b/echobase-services/src/test/java/fr/ifremer/echobase/services/service/importdata/AbstractImportDataServiceIT.java
@@ -56,6 +56,7 @@ import org.nuiton.topia.service.csv.in.AbstractImportModel;
 import org.nuiton.util.TimeLog;
 
 import java.io.File;
+import java.io.IOException;
 import java.io.Reader;
 import java.util.List;
 import java.util.Set;
@@ -147,7 +148,7 @@ public abstract class AbstractImportDataServiceIT extends EchoBaseTestServiceSup
 
     protected void addMissingEsduCells(String esduColumnName,
                                        String voyageId,
-                                       InputFile inputFile) throws TopiaException {
+                                       InputFile inputFile) throws TopiaException, IOException {
 
 
         UserDbPersistenceService persistenceService = serviceContext.newService(UserDbPersistenceService.class);
@@ -221,34 +222,31 @@ public abstract class AbstractImportDataServiceIT extends EchoBaseTestServiceSup
         CellType esduCellType = cellTypeDAO.forIdEquals("Esdu").findUnique();
 //        Preconditions.checkNotNull(esduCellType);
 
-        Reader reader = service.getInputFileReader(inputFile);
-        try {
-            Import<ResultEdsuImportMockImportModelRow> importer =
-                    Import.newImport(csvModel, reader);
+        try (Reader reader = service.getInputFileReader(inputFile)) {
 
-            for (ResultEdsuImportMockImportModelRow row : importer) {
+            try (Import<ResultEdsuImportMockImportModelRow> importer = Import.newImport(csvModel, reader)) {
 
-                String esduCellId = row.getName();
+                for (ResultEdsuImportMockImportModelRow row : importer) {
 
-                if (!cellsNames.contains(esduCellId)) {
+                    String esduCellId = row.getName();
 
-                    if (log.isDebugEnabled()) {
-                        log.debug("Adding missing esdu cell with name " +
-                                  esduCellId);
-                    }
+                    if (!cellsNames.contains(esduCellId)) {
+
+                        if (log.isDebugEnabled()) {
+                            log.debug("Adding missing esdu cell with name " +
+                                              esduCellId);
+                        }
 
-                    Cell cell = dao.create(Cell.PROPERTY_NAME, esduCellId,
-                                           Cell.PROPERTY_CELL_TYPE, esduCellType);
-                    dataProcessing.addCell(cell);
-                    cellsNames.add(esduCellId);
+                        Cell cell = dao.create(Cell.PROPERTY_NAME, esduCellId,
+                                               Cell.PROPERTY_CELL_TYPE, esduCellType);
+                        dataProcessing.addCell(cell);
+                        cellsNames.add(esduCellId);
+                    }
                 }
             }
 
             persistenceService.flush();
-        } finally {
-
 
-            service.closeReader(reader, inputFile);
         }
     }
 
@@ -266,7 +264,7 @@ public abstract class AbstractImportDataServiceIT extends EchoBaseTestServiceSup
             for (String columnHeader : header) {
 
                 if (!esduColumnName.equals(columnHeader) &&
-                    !("\"" + esduColumnName + "\"").equals(columnHeader)) {
+                        !("\"" + esduColumnName + "\"").equals(columnHeader)) {
                     Matcher matcher = AbstractImportDataService.REMOVE_DOUBLE_QUOTES_PATTERN.matcher(columnHeader);
                     if (matcher.matches()) {
                         newIgnoredColumn(matcher.group(1));
diff --git a/echobase-ui/src/main/java/fr/ifremer/echobase/ui/actions/dbeditor/GetEntities.java b/echobase-ui/src/main/java/fr/ifremer/echobase/ui/actions/dbeditor/GetEntities.java
index 4303948..35b9124 100644
--- a/echobase-ui/src/main/java/fr/ifremer/echobase/ui/actions/dbeditor/GetEntities.java
+++ b/echobase-ui/src/main/java/fr/ifremer/echobase/ui/actions/dbeditor/GetEntities.java
@@ -44,6 +44,7 @@ import org.nuiton.topia.persistence.pager.FilterRuleOperator;
 import javax.inject.Inject;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Map;
 
 /**
@@ -115,7 +116,7 @@ public class GetEntities extends AbstractJSONPaginedAction {
         if (StringUtils.isNotBlank(voyageId)) {
 
             // add a filter on voyageId
-            pager.setRules(Arrays.asList(new FilterRule(
+            pager.setRules(Collections.singletonList(new FilterRule(
                     FilterRuleOperator.eq, ImportLog.PROPERTY_VOYAGE_ID, voyageId
             )));
             pager.setGroupOp(FilterRuleGroupOperator.AND);

-- 
To stop receiving notification emails like this one, please contact
codelutin.com SCM administrator <admin+scm@codelutin.com>.

    

[Echobase-commits] 01/01: Revue des import (utilisation java 7 API + reformat code)

codelutin.com scm