[Tutti-commits] [tutti] 01/02: split referential persistence service

4 Nov 2014

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

New commit to branch develop in repository tutti.

See http://git.codelutin.com/tutti.git

commit f1add9a3ca139a44cd1805f641032431c6b910af
Author: Tony CHEMIT <chemit@codelutin.com>
Date:   Tue Nov 4 07:37:57 2014 +0100

    split referential persistence service
---
 .../tutti/persistence/TuttiPersistence.java        |  16 +-
 .../tutti/persistence/TuttiPersistenceImpl.java    | 358 ++++++++++++--------
 .../persistence/TuttiPersistenceNoDbImpl.java      |  10 +
 .../AccidentalBatchPersistenceServiceImpl.java     |  32 +-
 .../service/AttachmentPersistenceServiceImpl.java  |   6 +-
 .../BenthosBatchPersistenceServiceImpl.java        |   9 +-
 .../service/CatchBatchPersistenceServiceImpl.java  |   3 -
 .../service/CruisePersistenceServiceImpl.java      |  37 ++-
 .../FishingOperationPersistenceServiceImpl.java    |  45 ++-
 ...dualObservationBatchPersistenceServiceImpl.java |  21 +-
 .../MarineLitterBatchPersistenceServiceImpl.java   |   9 +-
 .../service/ProgramPersistenceServiceImpl.java     |   3 -
 .../SpeciesBatchPersistenceServiceImpl.java        |  10 +-
 .../service/TechnicalPersistenceService.java       |   3 +
 .../service/TechnicalPersistenceServiceImpl.java   |  15 +
 .../service/TuttiPersistenceServiceLocator.java    |  48 ++-
 .../CaracteristicPersistenceService.java           |  83 +++++
 .../CaracteristicPersistenceServiceImpl.java       | 299 +++++++++++++++++
 .../referential/GearPersistenceService.java        |  78 +++++
 .../referential/GearPersistenceServiceImpl.java    | 194 +++++++++++
 .../referential/LocationPersistenceService.java    | 110 +++++++
 .../LocationPersistenceServiceImpl.java            | 204 ++++++++++++
 .../referential/ObjectTypePersistenceService.java  |  29 ++
 .../ObjectTypePersistenceServiceImpl.java          |  54 +++
 .../referential/PersonPersistenceService.java      |  80 +++++
 .../referential/PersonPersistenceServiceImpl.java  | 201 +++++++++++
 .../ReferentialPersistenceServiceSupport.java      |  68 ++++
 .../referential/SpeciesPersistenceService.java     | 117 +++++++
 .../referential/SpeciesPersistenceServiceImpl.java | 246 ++++++++++++++
 .../referential/VesselPersistenceService.java      | 101 ++++++
 .../referential/VesselPersistenceServiceImpl.java  | 304 +++++++++++++++++
 .../service/util/BatchPersistenceHelper.java       |  11 +-
 .../service/util/MeasurementPersistenceHelper.java |   8 +-
 .../service/util/SamplePersistenceHelper.java      |   8 +-
 .../tutti/persistence/test/DatabaseFixtures.java   |  40 ++-
 .../entities/protocol/TuttiProtocolsTest.java      |   5 -
 ...AccidentalBatchPersistenceServiceWriteTest.java |  23 +-
 .../BenthosBatchPersistenceServiceWriteTest.java   |  25 +-
 .../CatchBatchPersistenceServiceWriteTest.java     |   3 -
 .../service/CruisePersistenceServiceWriteTest.java |  27 +-
 ...ishingOperationPersistenceServiceWriteTest.java |  21 +-
 ...bservationBatchPersistenceServiceWriteTest.java |  22 +-
 ...rineLitterBatchPersistenceServiceWriteTest.java |  12 +-
 .../ProgramPersistenceServiceWriteTest.java        |   7 +-
 .../ReferentialPersistenceServiceReadTest.java     | 366 ---------------------
 .../ReferentialPersistenceServiceWriteTest.java    | 242 --------------
 .../SpeciesBatchPersistenceServiceWriteTest.java   |  19 +-
 .../CaracteristicPersistenceServiceReadTest.java   |  94 ++++++
 .../GearPersistenceServiceReadTest.java            |  37 +++
 .../GearPersistenceServiceWriteTest.java           |  80 +++++
 .../LocationPersistenceServiceReadTest.java        |  77 +++++
 .../ObjectTypePersistenceServiceReadTest.java      |  33 ++
 .../PersonPersistenceServiceReadTest.java          |  26 ++
 .../PersonPersistenceServiceWriteTest.java         |  87 +++++
 ...ferentialPersistenceServiceReadTestSupport.java |  64 ++++
 ...erentialPersistenceServiceWriteTestSupport.java |  11 +
 .../SpeciesPersistenceServiceReadTest.java         |  75 +++++
 .../SpeciesPersistenceServiceWriteTest.java        |  81 +++++
 .../VesselPersistenceServiceReadTest.java          |  58 ++++
 .../VesselPersistenceServiceWriteTest.java         |  83 +++++
 .../ifremer/tutti/service/PersistenceService.java  |  10 +
 61 files changed, 3526 insertions(+), 922 deletions(-)

diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistence.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistence.java
index 44ed83b..b594cb6 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistence.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistence.java
@@ -32,9 +32,15 @@ import fr.ifremer.tutti.persistence.service.IndividualObservationBatchPersistenc
 import fr.ifremer.tutti.persistence.service.MarineLitterBatchPersistenceService;
 import fr.ifremer.tutti.persistence.service.ProgramPersistenceService;
 import fr.ifremer.tutti.persistence.service.ProtocolPersistenceService;
-import fr.ifremer.tutti.persistence.service.ReferentialPersistenceService;
 import fr.ifremer.tutti.persistence.service.SpeciesBatchPersistenceService;
 import fr.ifremer.tutti.persistence.service.TechnicalPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.GearPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.LocationPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.ObjectTypePersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.PersonPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.SpeciesPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.VesselPersistenceService;
 import org.springframework.transaction.annotation.Transactional;
 
 /**
@@ -48,7 +54,13 @@ public interface TuttiPersistence extends TuttiPersistenceServiceImplementor,
         TechnicalPersistenceService,
         BenthosBatchPersistenceService,
         SpeciesBatchPersistenceService,
-        ReferentialPersistenceService,
+        CaracteristicPersistenceService,
+        GearPersistenceService,
+        LocationPersistenceService,
+        ObjectTypePersistenceService,
+        PersonPersistenceService,
+        SpeciesPersistenceService,
+        VesselPersistenceService,
         CatchBatchPersistenceService,
         AttachmentPersistenceService,
         ProgramPersistenceService,
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceImpl.java
index c47ee26..905ece3 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceImpl.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceImpl.java
@@ -62,10 +62,16 @@ import fr.ifremer.tutti.persistence.service.IndividualObservationBatchPersistenc
 import fr.ifremer.tutti.persistence.service.MarineLitterBatchPersistenceService;
 import fr.ifremer.tutti.persistence.service.ProgramPersistenceService;
 import fr.ifremer.tutti.persistence.service.ProtocolPersistenceService;
-import fr.ifremer.tutti.persistence.service.ReferentialPersistenceService;
 import fr.ifremer.tutti.persistence.service.SpeciesBatchPersistenceService;
 import fr.ifremer.tutti.persistence.service.TechnicalPersistenceService;
 import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.GearPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.LocationPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.ObjectTypePersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.PersonPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.SpeciesPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.VesselPersistenceService;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
@@ -90,8 +96,26 @@ public class TuttiPersistenceImpl implements TuttiPersistence {
     private static final Log log =
             LogFactory.getLog(TuttiPersistenceImpl.class);
 
-    @Resource(name = "referentialPersistenceService")
-    protected ReferentialPersistenceService referentialService;
+    @Resource(name = "caracteristicPersistenceService")
+    protected CaracteristicPersistenceService caracteristicService;
+
+    @Resource(name = "gearPersistenceService")
+    protected GearPersistenceService gearService;
+
+    @Resource(name = "locationPersistenceService")
+    protected LocationPersistenceService locationService;
+
+    @Resource(name = "objectTypePersistenceService")
+    protected ObjectTypePersistenceService objectTypeService;
+
+    @Resource(name = "personPersistenceService")
+    protected PersonPersistenceService personService;
+
+    @Resource(name = "speciesPersistenceService")
+    protected SpeciesPersistenceService speciesService;
+
+    @Resource(name = "vesselPersistenceService")
+    protected VesselPersistenceService vesselService;
 
     @Resource(name = "programPersistenceService")
     protected ProgramPersistenceService programService;
@@ -165,11 +189,24 @@ public class TuttiPersistenceImpl implements TuttiPersistence {
     }
 
     @Override
+    public boolean isTemporary(TuttiReferentialEntity entity) {
+        return technicalPersistenceService.isTemporary(entity);
+    }
+
+    @Override
     public void init() {
         if (log.isInfoEnabled()) {
             log.info("Open persistence driver " + getImplementationName());
         }
-        referentialService.init();
+
+        caracteristicService.init();
+        gearService.init();
+        locationService.init();
+        objectTypeService.init();
+        personService.init();
+        speciesService.init();
+        vesselService.init();
+
         programService.init();
         cruiseService.init();
         fishingOperationService.init();
@@ -195,7 +232,15 @@ public class TuttiPersistenceImpl implements TuttiPersistence {
                 if (log.isInfoEnabled()) {
                     log.info("Close persistence driver " + getImplementationName());
                 }
-                referentialService.close();
+
+                caracteristicService.close();
+                gearService.close();
+                locationService.close();
+                objectTypeService.close();
+                personService.close();
+                speciesService.close();
+                vesselService.close();
+
                 programService.close();
                 cruiseService.close();
                 fishingOperationService.close();
@@ -213,332 +258,361 @@ public class TuttiPersistenceImpl implements TuttiPersistence {
     }
 
     //------------------------------------------------------------------------//
-    //-- Referential methods                                                --//
+    //-- CaracteristicPersistenceService methods                            --//
     //------------------------------------------------------------------------//
 
     @Override
-    public List<TuttiLocation> getAllProgramZone() {
-        return referentialService.getAllProgramZone();
+    public List<Caracteristic> getAllCaracteristic() {
+        return caracteristicService.getAllCaracteristic();
     }
 
     @Override
-    public List<TuttiLocation> getAllCountry() {
-        return referentialService.getAllCountry();
+    public List<Caracteristic> getAllCaracteristicWithProtected() {
+        return caracteristicService.getAllCaracteristicWithProtected();
     }
 
     @Override
-    public List<TuttiLocation> getAllHarbour() {
-        return referentialService.getAllHarbour();
+    public List<Caracteristic> getAllCaracteristicForSampleCategory() {
+        return caracteristicService.getAllCaracteristicForSampleCategory();
     }
 
     @Override
-    public List<TuttiLocation> getAllFishingOperationStrata(String zoneId) {
-        return referentialService.getAllFishingOperationStrata(zoneId);
+    public List<Caracteristic> getAllNumericCaracteristic() {
+        return caracteristicService.getAllNumericCaracteristic();
     }
 
     @Override
-    public List<TuttiLocation> getAllFishingOperationSubStrata(String zoneId,
-                                                               String strataId) {
-        return referentialService.getAllFishingOperationSubStrata(zoneId,
-                                                                  strataId);
+    public Caracteristic getSizeCategoryCaracteristic() {
+        return caracteristicService.getSizeCategoryCaracteristic();
     }
 
     @Override
-    public List<TuttiLocation> getAllFishingOperationLocation(String zoneId,
-                                                              String strataId,
-                                                              String subStrataId) {
-        return referentialService.getAllFishingOperationLocation(zoneId,
-                                                                 strataId,
-                                                                 subStrataId);
+    public Caracteristic getSexCaracteristic() {
+        return caracteristicService.getSexCaracteristic();
     }
 
     @Override
-    public List<Vessel> getAllScientificVessel() {
-        return referentialService.getAllScientificVessel();
+    public Caracteristic getSortedUnsortedCaracteristic() {
+        return caracteristicService.getSortedUnsortedCaracteristic();
     }
 
     @Override
-    public List<Vessel> getAllFishingVessel() {
-        return referentialService.getAllFishingVessel();
+    public Caracteristic getMaturityCaracteristic() {
+        return caracteristicService.getMaturityCaracteristic();
     }
 
     @Override
-    public List<Species> getAllSpecies() {
-        List<Species> result = referentialService.getAllSpecies();
-        setSpeciesSurveyCode(result, getProtocol());
-        return result;
+    public Caracteristic getAgeCaracteristic() {
+        return caracteristicService.getAgeCaracteristic();
     }
 
     @Override
-    public List<Species> getAllReferentSpecies() {
-        List<Species> result = referentialService.getAllReferentSpecies();
-        setSpeciesSurveyCode(result, getProtocol());
-        return result;
+    public Caracteristic getMarineLitterCategoryCaracteristic() {
+        return caracteristicService.getMarineLitterCategoryCaracteristic();
     }
 
     @Override
-    public Species getSpeciesByReferenceTaxonIdWithVernacularCode(Integer referenceTaxonId) {
-        return referentialService.getSpeciesByReferenceTaxonIdWithVernacularCode(referenceTaxonId);
+    public Caracteristic getMarineLitterSizeCategoryCaracteristic() {
+        return caracteristicService.getMarineLitterSizeCategoryCaracteristic();
     }
 
     @Override
-    public Species getSpeciesByReferenceTaxonId(Integer referenceTaxonId) {
-        return referentialService.getSpeciesByReferenceTaxonId(referenceTaxonId);
+    public Caracteristic getVerticalOpeningCaracteristic() {
+        return caracteristicService.getVerticalOpeningCaracteristic();
     }
 
     @Override
-    public List<Caracteristic> getAllCaracteristic() {
-        return referentialService.getAllCaracteristic();
+    public Caracteristic getHorizontalOpeningWingsCaracteristic() {
+        return caracteristicService.getHorizontalOpeningWingsCaracteristic();
     }
 
     @Override
-    public List<Caracteristic> getAllCaracteristicWithProtected() {
-        return referentialService.getAllCaracteristicWithProtected();
+    public Caracteristic getHorizontalOpeningDoorCaracteristic() {
+        return caracteristicService.getHorizontalOpeningDoorCaracteristic();
     }
 
     @Override
-    public List<Caracteristic> getAllCaracteristicForSampleCategory() {
-        return referentialService.getAllCaracteristicForSampleCategory();
+    public Caracteristic getDeadOrAliveCaracteristic() {
+        return caracteristicService.getDeadOrAliveCaracteristic();
     }
 
     @Override
-    public List<Caracteristic> getAllNumericCaracteristic() {
-        return referentialService.getAllNumericCaracteristic();
+    public Caracteristic getPmfmIdCaracteristic() {
+        return caracteristicService.getPmfmIdCaracteristic();
     }
 
     @Override
-    public List<ObjectType> getAllObjectType() {
-        return referentialService.getAllObjectType();
+    public Caracteristic getWeightMeasuredCaracteristic() {
+        return caracteristicService.getWeightMeasuredCaracteristic();
     }
 
     @Override
-    public Caracteristic getSizeCategoryCaracteristic() {
-        return referentialService.getSizeCategoryCaracteristic();
+    public Caracteristic getCaracteristic(Integer pmfmId) {
+        return caracteristicService.getCaracteristic(pmfmId);
     }
 
     @Override
-    public Caracteristic getSexCaracteristic() {
-        return referentialService.getSexCaracteristic();
+    public boolean isVracBatch(SpeciesAbleBatch speciesBatch) {
+        return caracteristicService.isVracBatch(speciesBatch);
     }
 
     @Override
-    public Caracteristic getSortedUnsortedCaracteristic() {
-        return referentialService.getSortedUnsortedCaracteristic();
+    public Predicate<SpeciesAbleBatch> getVracBatchPredicate() {
+        return caracteristicService.getVracBatchPredicate();
     }
 
     @Override
-    public Caracteristic getMaturityCaracteristic() {
-        return referentialService.getMaturityCaracteristic();
+    public boolean isHorsVracBatch(SpeciesAbleBatch speciesBatch) {
+        return caracteristicService.isHorsVracBatch(speciesBatch);
     }
 
-    @Override
-    public Caracteristic getAgeCaracteristic() {
-        return referentialService.getAgeCaracteristic();
-    }
+    //------------------------------------------------------------------------//
+    //-- LocationPersistenceService methods                                 --//
+    //------------------------------------------------------------------------//
 
     @Override
-    public Caracteristic getMarineLitterCategoryCaracteristic() {
-        return referentialService.getMarineLitterCategoryCaracteristic();
+    public List<TuttiLocation> getAllProgramZone() {
+        return locationService.getAllProgramZone();
     }
 
     @Override
-    public Caracteristic getMarineLitterSizeCategoryCaracteristic() {
-        return referentialService.getMarineLitterSizeCategoryCaracteristic();
+    public List<TuttiLocation> getAllCountry() {
+        return locationService.getAllCountry();
     }
 
     @Override
-    public Caracteristic getVerticalOpeningCaracteristic() {
-        return referentialService.getVerticalOpeningCaracteristic();
+    public List<TuttiLocation> getAllHarbour() {
+        return locationService.getAllHarbour();
     }
 
     @Override
-    public Caracteristic getHorizontalOpeningWingsCaracteristic() {
-        return referentialService.getHorizontalOpeningWingsCaracteristic();
+    public List<TuttiLocation> getAllFishingOperationStrata(String zoneId) {
+        return locationService.getAllFishingOperationStrata(zoneId);
     }
 
     @Override
-    public Caracteristic getHorizontalOpeningDoorCaracteristic() {
-        return referentialService.getHorizontalOpeningDoorCaracteristic();
+    public List<TuttiLocation> getAllFishingOperationSubStrata(String zoneId,
+                                                               String strataId) {
+        return locationService.getAllFishingOperationSubStrata(zoneId,
+                                                                          strataId);
     }
 
     @Override
-    public Caracteristic getDeadOrAliveCaracteristic() {
-        return referentialService.getDeadOrAliveCaracteristic();
+    public List<TuttiLocation> getAllFishingOperationLocation(String zoneId,
+                                                              String strataId,
+                                                              String subStrataId) {
+        return locationService.getAllFishingOperationLocation(zoneId,
+                                                                         strataId,
+                                                                         subStrataId);
     }
 
     @Override
-    public Caracteristic getPmfmIdCaracteristic() {
-        return referentialService.getPmfmIdCaracteristic();
+    public String getLocationLabelByLatLong(Float latitude, Float longitude) {
+        return locationService.getLocationLabelByLatLong(latitude, longitude);
     }
 
     @Override
-    public Caracteristic getWeightMeasuredCaracteristic() {
-        return referentialService.getWeightMeasuredCaracteristic();
+    public Integer getLocationIdByLatLong(Float latitude, Float longitude) {
+        return locationService.getLocationIdByLatLong(latitude, longitude);
     }
 
     @Override
-    public Caracteristic getCaracteristic(Integer pmfmId) {
-        return referentialService.getCaracteristic(pmfmId);
+    public TuttiLocation getLocation(String id) {
+        return locationService.getLocation(id);
     }
 
+    //------------------------------------------------------------------------//
+    //-- ObjectTypePersistenceService methods                               --//
+    //------------------------------------------------------------------------//
+
     @Override
-    public boolean isVracBatch(SpeciesAbleBatch speciesBatch) {
-        return referentialService.isVracBatch(speciesBatch);
+    public List<ObjectType> getAllObjectType() {
+        return objectTypeService.getAllObjectType();
     }
 
     @Override
-    public boolean isHorsVracBatch(SpeciesAbleBatch speciesBatch) {
-        return referentialService.isHorsVracBatch(speciesBatch);
+    public ObjectType getObjectType(String objectTypeCode) {
+        return objectTypeService.getObjectType(objectTypeCode);
     }
 
+    //------------------------------------------------------------------------//
+    //-- GearPersistenceService methods                                     --//
+    //------------------------------------------------------------------------//
+
     @Override
-    public Predicate<SpeciesAbleBatch> getVracBatchPredicate() {
-        return referentialService.getVracBatchPredicate();
+    public List<Gear> getAllScientificGear() {
+        return gearService.getAllScientificGear();
     }
 
     @Override
-    public boolean isTemporary(TuttiReferentialEntity entity) {
-        return referentialService.isTemporary(entity);
+    public List<Gear> getAllFishingGear() {
+        return gearService.getAllFishingGear();
     }
 
     @Override
-    public List<Gear> getAllScientificGear() {
-        return referentialService.getAllScientificGear();
+    public Gear getGear(Integer gearId) {
+        return gearService.getGear(gearId);
     }
 
     @Override
-    public List<Gear> getAllFishingGear() {
-        return referentialService.getAllFishingGear();
+    public boolean isTemporaryGearUsed(Integer id) {
+        return gearService.isTemporaryGearUsed(id);
     }
 
     @Override
-    public List<Person> getAllPerson() {
-        return referentialService.getAllPerson();
+    public List<Gear> importTemporaryGear(List<Gear> gears) {
+        return gearService.importTemporaryGear(gears);
     }
 
     @Override
-    public Vessel getVessel(String vesselCode) {
-        return referentialService.getVessel(vesselCode);
+    public void replaceGear(Gear source, Gear target, boolean delete) {
+        gearService.replaceGear(source, target, delete);
     }
 
     @Override
-    public Person getPerson(Integer personId) {
-        return referentialService.getPerson(personId);
+    public void deleteTemporaryGear(Integer id, boolean checkIfUsed) {
+        gearService.deleteTemporaryGear(id, checkIfUsed);
     }
 
     @Override
-    public Gear getGear(Integer gearId) {
-        return referentialService.getGear(gearId);
+    public void deleteTemporaryGears(Collection<Integer> id, boolean checkIfUsed) {
+        gearService.deleteTemporaryGears(id, checkIfUsed);
     }
 
+    //------------------------------------------------------------------------//
+    //-- SpeciesPersistenceService methods                                  --//
+    //------------------------------------------------------------------------//
+
     @Override
-    public ObjectType getObjectType(String objectTypeCode) {
-        return referentialService.getObjectType(objectTypeCode);
+    public List<Species> getAllSpecies() {
+        List<Species> result = speciesService.getAllSpecies();
+        setSpeciesSurveyCode(result, getProtocol());
+        return result;
     }
 
     @Override
-    public TuttiLocation getLocation(String id) {
-        return referentialService.getLocation(id);
+    public List<Species> getAllReferentSpecies() {
+        List<Species> result = speciesService.getAllReferentSpecies();
+        setSpeciesSurveyCode(result, getProtocol());
+        return result;
     }
 
     @Override
-    public List<Species> importTemporarySpecies(List<Species> species) {
-        return referentialService.importTemporarySpecies(species);
+    public Species getSpeciesByReferenceTaxonIdWithVernacularCode(Integer referenceTaxonId) {
+        return speciesService.getSpeciesByReferenceTaxonIdWithVernacularCode(referenceTaxonId);
     }
 
     @Override
-    public List<Vessel> importTemporaryVessel(List<Vessel> vessels) {
-        return referentialService.importTemporaryVessel(vessels);
+    public Species getSpeciesByReferenceTaxonId(Integer referenceTaxonId) {
+        return speciesService.getSpeciesByReferenceTaxonId(referenceTaxonId);
     }
 
     @Override
-    public List<Person> importTemporaryPerson(List<Person> persons) {
-        return referentialService.importTemporaryPerson(persons);
+    public boolean isTemporarySpeciesUsed(Integer id) {
+        return speciesService.isTemporarySpeciesUsed(id);
     }
 
     @Override
-    public List<Gear> importTemporaryGear(List<Gear> gears) {
-        return referentialService.importTemporaryGear(gears);
+    public List<Species> importTemporarySpecies(List<Species> species) {
+        return speciesService.importTemporarySpecies(species);
     }
 
     @Override
-    public void replaceGear(Gear source, Gear target, boolean delete) {
-        referentialService.replaceGear(source, target, delete);
+    public void replaceSpecies(Species source, Species target, boolean delete) {
+        speciesService.replaceSpecies(source, target, delete);
     }
 
     @Override
-    public void replacePerson(Person source, Person target, boolean delete) {
-        referentialService.replacePerson(source, target, delete);
+    public void deleteTemporarySpecies(Integer id, boolean checkIfUsed) {
+        speciesService.deleteTemporarySpecies(id, checkIfUsed);
     }
 
     @Override
-    public void replaceSpecies(Species source, Species target, boolean delete) {
-        referentialService.replaceSpecies(source, target, delete);
+    public void deleteTemporarySpecies(Collection<Integer> ids, boolean checkIfUsed) {
+        speciesService.deleteTemporarySpecies(ids, checkIfUsed);
     }
 
+    //------------------------------------------------------------------------//
+    //-- PersonPersistenceService methods                                   --//
+    //------------------------------------------------------------------------//
+
     @Override
-    public void replaceVessel(Vessel source, Vessel target, boolean delete) {
-        referentialService.replaceVessel(source, target, delete);
+    public List<Person> getAllPerson() {
+        return personService.getAllPerson();
     }
 
     @Override
-    public void deleteTemporaryGear(Integer id, boolean checkIfUsed) {
-        referentialService.deleteTemporaryGear(id, checkIfUsed);
+    public Person getPerson(Integer personId) {
+        return personService.getPerson(personId);
     }
 
     @Override
-    public void deleteTemporaryGears(Collection<Integer> id, boolean checkIfUsed) {
-        referentialService.deleteTemporaryGears(id, checkIfUsed);
+    public boolean isTemporaryPersonUsed(Integer id) {
+        return personService.isTemporaryPersonUsed(id);
     }
 
     @Override
-    public void deleteTemporarySpecies(Integer id, boolean checkIfUsed) {
-        referentialService.deleteTemporarySpecies(id, checkIfUsed);
+    public List<Person> importTemporaryPerson(List<Person> persons) {
+        return personService.importTemporaryPerson(persons);
     }
 
     @Override
-    public void deleteTemporarySpecies(Collection<Integer> ids, boolean checkIfUsed) {
-        referentialService.deleteTemporarySpecies(ids, checkIfUsed);
+    public void replacePerson(Person source, Person target, boolean delete) {
+        personService.replacePerson(source, target, delete);
     }
 
     @Override
     public void deleteTemporaryPerson(Integer id, boolean checkIfUsed) {
-        referentialService.deleteTemporaryPerson(id, checkIfUsed);
+        personService.deleteTemporaryPerson(id, checkIfUsed);
     }
 
     @Override
     public void deleteTemporaryPersons(Collection<Integer> ids, boolean checkIfUsed) {
-        referentialService.deleteTemporaryPersons(ids, checkIfUsed);
+        personService.deleteTemporaryPersons(ids, checkIfUsed);
     }
 
+    //------------------------------------------------------------------------//
+    //-- VesselPersistenceService methods                                   --//
+    //------------------------------------------------------------------------//
+
     @Override
-    public void deleteTemporaryVessel(String code, boolean checkIfUsed) {
-        referentialService.deleteTemporaryVessel(code, checkIfUsed);
+    public List<Vessel> getAllScientificVessel() {
+        return vesselService.getAllScientificVessel();
     }
 
     @Override
-    public void deleteTemporaryVessels(Collection<String> codes, boolean checkIfUsed) {
-        referentialService.deleteTemporaryVessels(codes, checkIfUsed);
+    public List<Vessel> getAllFishingVessel() {
+        return vesselService.getAllFishingVessel();
     }
 
     @Override
-    public boolean isTemporaryPersonUsed(Integer id) {
-        return referentialService.isTemporaryPersonUsed(id);
+    public Vessel getVessel(String vesselCode) {
+        return vesselService.getVessel(vesselCode);
     }
 
     @Override
-    public boolean isTemporarySpeciesUsed(Integer id) {
-        return referentialService.isTemporarySpeciesUsed(id);
+    public boolean isTemporaryVesselUsed(String code) {
+        return vesselService.isTemporaryVesselUsed(code);
     }
 
     @Override
-    public boolean isTemporaryGearUsed(Integer id) {
-        return referentialService.isTemporaryGearUsed(id);
+    public List<Vessel> importTemporaryVessel(List<Vessel> vessels) {
+        return vesselService.importTemporaryVessel(vessels);
     }
 
     @Override
-    public boolean isTemporaryVesselUsed(String code) {
-        return referentialService.isTemporaryVesselUsed(code);
+    public void replaceVessel(Vessel source, Vessel target, boolean delete) {
+        vesselService.replaceVessel(source, target, delete);
+    }
+
+    @Override
+    public void deleteTemporaryVessel(String code, boolean checkIfUsed) {
+        vesselService.deleteTemporaryVessel(code, checkIfUsed);
+    }
+
+    @Override
+    public void deleteTemporaryVessels(Collection<String> codes, boolean checkIfUsed) {
+        vesselService.deleteTemporaryVessels(codes, checkIfUsed);
     }
 
     //------------------------------------------------------------------------//
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceNoDbImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceNoDbImpl.java
index fa96069..c851bd7 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceNoDbImpl.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceNoDbImpl.java
@@ -131,6 +131,16 @@ public class TuttiPersistenceNoDbImpl implements TuttiPersistence {
     }
 
     @Override
+    public String getLocationLabelByLatLong(Float latitude, Float longitude) {
+        throw notImplemented();
+    }
+
+    @Override
+    public Integer getLocationIdByLatLong(Float latitude, Float longitude) {
+        throw notImplemented();
+    }
+
+    @Override
     public List<Vessel> getAllScientificVessel() {
         throw notImplemented();
     }
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceImpl.java
index 7b6ea94..4271349 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceImpl.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceImpl.java
@@ -46,6 +46,8 @@ import fr.ifremer.tutti.persistence.entities.data.AccidentalBatchs;
 import fr.ifremer.tutti.persistence.entities.referential.Caracteristic;
 import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue;
 import fr.ifremer.tutti.persistence.entities.referential.Species;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.SpeciesPersistenceService;
 import fr.ifremer.tutti.persistence.service.util.SamplePersistenceHelper;
 import fr.ifremer.tutti.persistence.service.util.SynchronizationStatusHelper;
 import org.apache.commons.collections4.CollectionUtils;
@@ -71,8 +73,11 @@ public class AccidentalBatchPersistenceServiceImpl extends AbstractPersistenceSe
     private static final Log log =
             LogFactory.getLog(AccidentalBatchPersistenceServiceImpl.class);
 
-    @Resource(name = "referentialPersistenceService")
-    protected ReferentialPersistenceService referentialService;
+    @Resource(name = "caracteristicPersistenceService")
+    private CaracteristicPersistenceService caracteristicService;
+
+    @Resource(name = "speciesPersistenceService")
+    private SpeciesPersistenceService speciesService;
 
     @Resource(name = "samplePersistenceHelper")
     protected SamplePersistenceHelper samplePersistenceHelper;
@@ -103,7 +108,7 @@ public class AccidentalBatchPersistenceServiceImpl extends AbstractPersistenceSe
 
             // TaxonId
             Integer taxonId = (Integer) source[colIndex++];
-            Species species = referentialService.getSpeciesByReferenceTaxonId(taxonId);
+            Species species = speciesService.getSpeciesByReferenceTaxonId(taxonId);
             accidentalBatch.setSpecies(species);
 
             // Comment
@@ -257,28 +262,25 @@ public class AccidentalBatchPersistenceServiceImpl extends AbstractPersistenceSe
 
         if (source.getDeadOrAlive() != null) {
 
-            Caracteristic caracteristic =
-                    referentialService.getDeadOrAliveCaracteristic();
+            Caracteristic caracteristic = caracteristicService.getDeadOrAliveCaracteristic();
             caracteristics.put(caracteristic, source.getDeadOrAlive());
         }
 
         if (source.getGender() != null) {
 
-            Caracteristic caracteristic =
-                    referentialService.getSexCaracteristic();
+            Caracteristic caracteristic = caracteristicService.getSexCaracteristic();
             caracteristics.put(caracteristic, source.getGender());
         }
 
         if (source.getWeight() != null) {
 
-            Caracteristic caracteristic = referentialService.getWeightMeasuredCaracteristic();
+            Caracteristic caracteristic = caracteristicService.getWeightMeasuredCaracteristic();
             caracteristics.put(caracteristic, source.getWeight());
         }
 
         if (source.getLengthStepCaracteristic() != null) {
 
-            Caracteristic caracteristic = referentialService.getCaracteristic(
-                    PmfmId2.ID_PSFM.getValue());
+            Caracteristic caracteristic = caracteristicService.getCaracteristic(PmfmId2.ID_PSFM.getValue());
             caracteristics.put(caracteristic,
                                source.getLengthStepCaracteristic().getId());
 
@@ -293,9 +295,9 @@ public class AccidentalBatchPersistenceServiceImpl extends AbstractPersistenceSe
 
     protected void fillSampleMeasurements(AccidentalBatch batch) {
 
-        Caracteristic deadOrAliveCaracteristic = referentialService.getDeadOrAliveCaracteristic();
+        Caracteristic deadOrAliveCaracteristic = caracteristicService.getDeadOrAliveCaracteristic();
 
-        Caracteristic genderCaracteristic = referentialService.getSexCaracteristic();
+        Caracteristic genderCaracteristic = caracteristicService.getSexCaracteristic();
 
         CaracteristicMap result = batch.getCaracteristics();
 
@@ -314,14 +316,14 @@ public class AccidentalBatchPersistenceServiceImpl extends AbstractPersistenceSe
             batch.setGender(genderValue);
         }
 
-        Float weight = (Float) result.remove(referentialService.getCaracteristic(PmfmId.WEIGHT_MEASURED.getValue()));
+        Float weight = (Float) result.remove(caracteristicService.getCaracteristic(PmfmId.WEIGHT_MEASURED.getValue()));
         if (weight != null) {
             batch.setWeight(weight);
         }
 
-        String lengthClassId = (String) result.remove(referentialService.getCaracteristic(PmfmId2.ID_PSFM.getValue()));
+        String lengthClassId = (String) result.remove(caracteristicService.getCaracteristic(PmfmId2.ID_PSFM.getValue()));
         if (lengthClassId != null) {
-            Caracteristic lengthStepCaracteristic = referentialService.getCaracteristic(Integer.valueOf(lengthClassId));
+            Caracteristic lengthStepCaracteristic = caracteristicService.getCaracteristic(Integer.valueOf(lengthClassId));
             batch.setLengthStepCaracteristic(lengthStepCaracteristic);
 
             Serializable length = result.remove(lengthStepCaracteristic);
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceImpl.java
index c1b48f8..4c0d6dc 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceImpl.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceImpl.java
@@ -63,11 +63,7 @@ public class AttachmentPersistenceServiceImpl extends AbstractPersistenceService
     private static final Log log =
             LogFactory.getLog(AttachmentPersistenceServiceImpl.class);
 
-    protected static final String ATTACHMENT_PATH_FORMAT =
-            "%1$s/OBJ%2$s/%1$s-OBJ%2$s-%3$s.%4$s";
-
-    @Resource(name = "referentialPersistenceService")
-    protected ReferentialPersistenceService referentialService;
+    protected static final String ATTACHMENT_PATH_FORMAT = "%1$s/OBJ%2$s/%1$s-OBJ%2$s-%3$s.%4$s";
 
     @Resource(name = "measurementFileDao")
     protected MeasurementFileDao measurementFileDao;
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceImpl.java
index 9a5feda..86ac8d6 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceImpl.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceImpl.java
@@ -39,6 +39,7 @@ import fr.ifremer.tutti.persistence.entities.data.BenthosBatchs;
 import fr.ifremer.tutti.persistence.entities.data.FishingOperation;
 import fr.ifremer.tutti.persistence.entities.data.SampleCategoryModel;
 import fr.ifremer.tutti.persistence.entities.referential.Species;
+import fr.ifremer.tutti.persistence.service.referential.SpeciesPersistenceService;
 import fr.ifremer.tutti.persistence.service.util.BatchPersistenceHelper;
 import fr.ifremer.tutti.persistence.service.util.BatchTreeHelper;
 import fr.ifremer.tutti.persistence.service.util.MeasurementPersistenceHelper;
@@ -71,8 +72,8 @@ public class BenthosBatchPersistenceServiceImpl extends AbstractPersistenceServi
     private static final Log log =
             LogFactory.getLog(BenthosBatchPersistenceServiceImpl.class);
 
-    @Resource(name = "referentialPersistenceService")
-    protected ReferentialPersistenceService referentialService;
+    @Resource(name = "speciesPersistenceService")
+    private SpeciesPersistenceService speciesService;
 
     @Resource(name = "fishingOperationPersistenceService")
     protected FishingOperationPersistenceService fishingOperationPersistenceService;
@@ -115,7 +116,7 @@ public class BenthosBatchPersistenceServiceImpl extends AbstractPersistenceServi
                 SortingBatch source = (SortingBatch) batch;
                 ReferenceTaxon referenceTaxon = source.getReferenceTaxon();
                 Preconditions.checkNotNull(referenceTaxon, "Can't have a rootBenthosBatch with a null taxon, but was for " + batch.getId());
-                Species species = referentialService.getSpeciesByReferenceTaxonId(referenceTaxon.getId());
+                Species species = speciesService.getSpeciesByReferenceTaxonId(referenceTaxon.getId());
                 if (species == null) {
                     FishingOperation fishingOperation = fishingOperationPersistenceService.getFishingOperation(fishingOperationId);
                     String fishingOperationName = fishingOperation.getStationNumber() + " - " + fishingOperation.getFishingOperationNumber() + " - " + df.format(fishingOperation.getGearShootingStartDate());
@@ -140,7 +141,7 @@ public class BenthosBatchPersistenceServiceImpl extends AbstractPersistenceServi
                 SortingBatch source = (SortingBatch) batch;
                 ReferenceTaxon referenceTaxon = source.getReferenceTaxon();
                 Preconditions.checkNotNull(referenceTaxon, "Can't have a rootSpeciesBatch with a null taxon, but was for " + source.getId());
-                Species species = referentialService.getSpeciesByReferenceTaxonId(referenceTaxon.getId());
+                Species species = speciesService.getSpeciesByReferenceTaxonId(referenceTaxon.getId());
                 if (species == null) {
                     FishingOperation fishingOperation = fishingOperationPersistenceService.getFishingOperation(fishingOperationId);
                     String fishingOperationName = fishingOperation.getStationNumber() + " - " + fishingOperation.getFishingOperationNumber() + " - " + df.format(fishingOperation.getGearShootingStartDate());
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceImpl.java
index 2c6b5ca..670de9d 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceImpl.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceImpl.java
@@ -66,9 +66,6 @@ public class CatchBatchPersistenceServiceImpl
     private static final Log log =
             LogFactory.getLog(CatchBatchPersistenceServiceImpl.class);
 
-    @Resource(name = "referentialPersistenceService")
-    protected ReferentialPersistenceService referentialService;
-
     @Resource(name = "attachmentPersistenceService")
     protected AttachmentPersistenceService attachmentPersistenceService;
 
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceImpl.java
index d98351a..2d0d525 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceImpl.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceImpl.java
@@ -53,7 +53,6 @@ import fr.ifremer.adagio.core.dao.referential.location.LocationDao;
 import fr.ifremer.adagio.core.dao.referential.location.LocationImpl;
 import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmDao;
 import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId;
-import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2;
 import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValue;
 import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueDao;
 import fr.ifremer.tutti.persistence.dao.GearPhysicalFeaturesDaoTutti;
@@ -72,6 +71,11 @@ import fr.ifremer.tutti.persistence.entities.referential.Gears;
 import fr.ifremer.tutti.persistence.entities.referential.Person;
 import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation;
 import fr.ifremer.tutti.persistence.entities.referential.Vessel;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.GearPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.LocationPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.PersonPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.VesselPersistenceService;
 import fr.ifremer.tutti.persistence.service.util.MeasurementPersistenceHelper;
 import fr.ifremer.tutti.persistence.service.util.SynchronizationStatusHelper;
 import fr.ifremer.tutti.persistence.service.util.VesselPersonFeaturesPersistenceHelper;
@@ -111,8 +115,21 @@ public class CruisePersistenceServiceImpl extends AbstractPersistenceService imp
     private static final Log log =
             LogFactory.getLog(CruisePersistenceServiceImpl.class);
 
-    @Resource(name = "referentialPersistenceService")
-    protected ReferentialPersistenceService referentialService;
+
+    @Resource(name = "caracteristicPersistenceService")
+    private CaracteristicPersistenceService caracteristicService;
+
+    @Resource(name = "gearPersistenceService")
+    private GearPersistenceService gearService;
+
+    @Resource(name = "locationPersistenceService")
+    private LocationPersistenceService locationService;
+
+    @Resource(name = "personPersistenceService")
+    private PersonPersistenceService personService;
+
+    @Resource(name = "vesselPersistenceService")
+    private VesselPersistenceService vesselService;
 
     @Resource(name = "programPersistenceService")
     protected ProgramPersistenceService programService;
@@ -195,12 +212,12 @@ public class CruisePersistenceServiceImpl extends AbstractPersistenceService imp
 
         // departureLocation
         Integer departureLocationId = (Integer) source[index++];
-        TuttiLocation departureLocation = referentialService.getLocation(String.valueOf(departureLocationId));
+        TuttiLocation departureLocation = locationService.getLocation(String.valueOf(departureLocationId));
         result.setDepartureLocation(departureLocation);
 
         // returnLocation
         Integer returnLocationId = (Integer) source[index++];
-        TuttiLocation returnLocation = referentialService.getLocation(String.valueOf(returnLocationId));
+        TuttiLocation returnLocation = locationService.getLocation(String.valueOf(returnLocationId));
         result.setReturnLocation(returnLocation);
 
         // program
@@ -219,7 +236,7 @@ public class CruisePersistenceServiceImpl extends AbstractPersistenceService imp
 
         // vessel
         String vesselCode = (String) source[index++];
-        Vessel vessel = referentialService.getVessel(vesselCode);
+        Vessel vessel = vesselService.getVessel(vesselCode);
         result.setVessel(vessel);
 
         // head of sort room
@@ -229,7 +246,7 @@ public class CruisePersistenceServiceImpl extends AbstractPersistenceService imp
         result.setHeadOfSortRoom(headOfSortRoom);
 
         Integer managerId = (Integer) source[index++];
-        Person manager = referentialService.getPerson(managerId);
+        Person manager = personService.getPerson(managerId);
         headOfMissions.add(manager);
 
         // comment
@@ -251,7 +268,7 @@ public class CruisePersistenceServiceImpl extends AbstractPersistenceService imp
         int maxMultirigNumberFound = 0;
         while (list.hasNext()) {
             Object[] gearRow = list.next();
-            Gear simpleGear = referentialService.getGear((Integer) gearRow[0]);
+            Gear simpleGear = gearService.getGear((Integer) gearRow[0]);
             GearWithOriginalRankOrder target = GearWithOriginalRankOrders.newGearWithOriginalRankOrder(simpleGear);
             target.setRankOrder((Short) gearRow[1]);
             Float multirigNumber = (Float) gearRow[2];
@@ -272,7 +289,7 @@ public class CruisePersistenceServiceImpl extends AbstractPersistenceService imp
             Object[] vesselPersonFeatures = vesselPersonFeaturesList.next();
 
             Integer personId = (Integer) vesselPersonFeatures[0];
-            Person person = referentialService.getPerson(personId);
+            Person person = personService.getPerson(personId);
             Integer roleId = (Integer) vesselPersonFeatures[1];
             if (VesselPersonRoleId.SCIENTIFIC_CRUISE_MANAGER.getValue().equals(roleId)) {
                 headOfMissions.add(person);
@@ -407,7 +424,7 @@ public class CruisePersistenceServiceImpl extends AbstractPersistenceService imp
 
             Integer pmfmId = measurement.getPmfm().getId();
             if (!PmfmId.MULTIRIG_NUMBER.getValue().equals(pmfmId)) {
-                Caracteristic caracteristic = referentialService.getCaracteristic(pmfmId);
+                Caracteristic caracteristic = caracteristicService.getCaracteristic(pmfmId);
 
                 Serializable value = null;
                 switch (caracteristic.getCaracteristicType()) {
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceImpl.java
index cb42d2d..0242677 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceImpl.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceImpl.java
@@ -61,9 +61,7 @@ import fr.ifremer.adagio.core.dao.referential.location.LocationExtendDao;
 import fr.ifremer.adagio.core.dao.referential.location.LocationImpl;
 import fr.ifremer.adagio.core.dao.referential.location.LocationLevelId;
 import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId;
-import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2;
 import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId;
-import fr.ifremer.adagio.core.service.referential.location.LocationService;
 import fr.ifremer.tutti.persistence.dao.GearPhysicalFeaturesDaoTutti;
 import fr.ifremer.tutti.persistence.entities.CaracteristicMap;
 import fr.ifremer.tutti.persistence.entities.data.FishingOperation;
@@ -76,6 +74,11 @@ import fr.ifremer.tutti.persistence.entities.referential.GearWithOriginalRankOrd
 import fr.ifremer.tutti.persistence.entities.referential.Person;
 import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation;
 import fr.ifremer.tutti.persistence.entities.referential.Vessel;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.GearPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.LocationPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.PersonPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.VesselPersistenceService;
 import fr.ifremer.tutti.persistence.service.util.MeasurementPersistenceHelper;
 import fr.ifremer.tutti.persistence.service.util.SynchronizationStatusHelper;
 import fr.ifremer.tutti.persistence.service.util.VesselPersonFeaturesPersistenceHelper;
@@ -115,8 +118,20 @@ public class FishingOperationPersistenceServiceImpl extends AbstractPersistenceS
     private static final Log log =
             LogFactory.getLog(FishingOperationPersistenceServiceImpl.class);
 
-    @Resource(name = "referentialPersistenceService")
-    protected ReferentialPersistenceService referentialService;
+    @Resource(name = "caracteristicPersistenceService")
+    private CaracteristicPersistenceService caracteristicService;
+
+    @Resource(name = "gearPersistenceService")
+    private GearPersistenceService gearService;
+
+    @Resource(name = "locationPersistenceService")
+    private LocationPersistenceService locationService;
+
+    @Resource(name = "personPersistenceService")
+    private PersonPersistenceService personService;
+
+    @Resource(name = "vesselPersistenceService")
+    private VesselPersistenceService vesselService;
 
     @Resource(name = "batchPersistenceService")
     protected CatchBatchPersistenceService catchBatchService;
@@ -151,8 +166,8 @@ public class FishingOperationPersistenceServiceImpl extends AbstractPersistenceS
     @Resource(name = "operationVesselAssociationDao")
     protected OperationVesselAssociationDao operationVesselAssociationDao;
 
-    @Resource(name = "locationService")
-    protected LocationService locationService;
+//    @Resource(name = "locationService")
+//    protected LocationService locationService;
 
     @Resource(name = "locationDao")
     protected LocationExtendDao locationDao;
@@ -316,7 +331,7 @@ public class FishingOperationPersistenceServiceImpl extends AbstractPersistenceS
             Object[] vesselPersonFeatures = vesselPersonFeaturesList.next();
 
             Integer personId = (Integer) vesselPersonFeatures[0];
-            Person person = referentialService.getPerson(personId);
+            Person person = personService.getPerson(personId);
             Integer roleId = (Integer) vesselPersonFeatures[1];
             if (VesselPersonRoleId.RECORDER_PERSON.getValue().equals(roleId)) {
                 result.addRecorderPerson(person);
@@ -331,7 +346,7 @@ public class FishingOperationPersistenceServiceImpl extends AbstractPersistenceS
         Integer gearId = (Integer) source[colIndex++];
         if (gearId != null) {
             // get gear from referential
-            Gear gear = referentialService.getGear(gearId);
+            Gear gear = gearService.getGear(gearId);
             Preconditions.checkNotNull(gear);
             // use a copy of it with rankOrder
             Gear toSet = GearWithOriginalRankOrders.newGearWithOriginalRankOrder(gear);
@@ -367,28 +382,28 @@ public class FishingOperationPersistenceServiceImpl extends AbstractPersistenceS
         // Strata :
         Integer strataId = (Integer) source[colIndex++];
         if (strataId != null) {
-            TuttiLocation strata = referentialService.getLocation(strataId.toString());
+            TuttiLocation strata = locationService.getLocation(strataId.toString());
             result.setStrata(strata);
         }
 
         // Sub Strata :
         Integer subStrataId = (Integer) source[colIndex++];
         if (subStrataId != null) {
-            TuttiLocation subStrata = referentialService.getLocation(subStrataId.toString());
+            TuttiLocation subStrata = locationService.getLocation(subStrataId.toString());
             result.setSubStrata(subStrata);
         }
 
         // Localite :
         Integer localiteId = (Integer) source[colIndex++];
         if (localiteId != null) {
-            TuttiLocation localite = referentialService.getLocation(localiteId.toString());
+            TuttiLocation localite = locationService.getLocation(localiteId.toString());
             result.setLocation(localite);
         }
 
         // Vessel (the one with the catch batch)
         String vesselCode = (String) source[colIndex];
         if (vesselCode != null) {
-            Vessel vessel = referentialService.getVessel(vesselCode);
+            Vessel vessel = vesselService.getVessel(vesselCode);
             result.setVessel(vessel);
         }
 
@@ -419,7 +434,7 @@ public class FishingOperationPersistenceServiceImpl extends AbstractPersistenceS
                 Boolean isCatchOnOperationVessel = (Boolean) next[1];
                 if (isCatchOnOperationVessel == null || !isCatchOnOperationVessel) {
 
-                    Vessel vessel = referentialService.getVessel(secondaryVesselCode);
+                    Vessel vessel = vesselService.getVessel(secondaryVesselCode);
                     result.add(vessel);
                 }
             }
@@ -664,7 +679,7 @@ public class FishingOperationPersistenceServiceImpl extends AbstractPersistenceS
             // Vessel Use caracteristic
             else {
 
-                Caracteristic environmentCaracteristic = referentialService.getCaracteristic(pmfmId);
+                Caracteristic environmentCaracteristic = caracteristicService.getCaracteristic(pmfmId);
                 Serializable value = null;
                 if (environmentCaracteristic.getCaracteristicType() == CaracteristicType.NUMBER) {
                     value = numericalValue;
@@ -712,7 +727,7 @@ public class FishingOperationPersistenceServiceImpl extends AbstractPersistenceS
 
             // Gear Shooting Caracteristics
             else {
-                Caracteristic gearShootingCaracteristic = referentialService.getCaracteristic(pmfmId);
+                Caracteristic gearShootingCaracteristic = caracteristicService.getCaracteristic(pmfmId);
                 Serializable value = null;
                 if (gearShootingCaracteristic.getCaracteristicType() == CaracteristicType.NUMBER) {
                     value = numericalValue;
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceImpl.java
index 849ebb8..ccb9772 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceImpl.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceImpl.java
@@ -46,6 +46,8 @@ import fr.ifremer.tutti.persistence.entities.data.IndividualObservationBatch;
 import fr.ifremer.tutti.persistence.entities.data.IndividualObservationBatchs;
 import fr.ifremer.tutti.persistence.entities.referential.Caracteristic;
 import fr.ifremer.tutti.persistence.entities.referential.Species;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.SpeciesPersistenceService;
 import fr.ifremer.tutti.persistence.service.util.BatchPersistenceHelper;
 import fr.ifremer.tutti.persistence.service.util.SamplePersistenceHelper;
 import fr.ifremer.tutti.persistence.service.util.SynchronizationStatusHelper;
@@ -72,8 +74,11 @@ public class IndividualObservationBatchPersistenceServiceImpl extends AbstractPe
     private static final Log log =
             LogFactory.getLog(IndividualObservationBatchPersistenceServiceImpl.class);
 
-    @Resource(name = "referentialPersistenceService")
-    protected ReferentialPersistenceService referentialService;
+    @Resource(name = "caracteristicPersistenceService")
+    private CaracteristicPersistenceService caracteristicService;
+
+    @Resource(name = "speciesPersistenceService")
+    private SpeciesPersistenceService speciesService;
 
     @Resource(name = "attachmentPersistenceService")
     protected AttachmentPersistenceService attachmentPersistenceService;
@@ -117,7 +122,7 @@ public class IndividualObservationBatchPersistenceServiceImpl extends AbstractPe
 
             // TaxonId
             Integer taxonId = (Integer) source[colIndex++];
-            Species species = referentialService.getSpeciesByReferenceTaxonId(taxonId);
+            Species species = speciesService.getSpeciesByReferenceTaxonId(taxonId);
             batch.setSpecies(species);
 
             // Comment
@@ -285,13 +290,13 @@ public class IndividualObservationBatchPersistenceServiceImpl extends AbstractPe
 
         if (source.getWeight() != null) {
 
-            Caracteristic caracteristic = referentialService.getWeightMeasuredCaracteristic();
+            Caracteristic caracteristic = caracteristicService.getWeightMeasuredCaracteristic();
             caracteristics.put(caracteristic, source.getWeight());
         }
 
         if (source.getLengthStepCaracteristic() != null) {
 
-            Caracteristic caracteristic = referentialService.getPmfmIdCaracteristic();
+            Caracteristic caracteristic = caracteristicService.getPmfmIdCaracteristic();
             caracteristics.put(caracteristic,
                                source.getLengthStepCaracteristic().getId());
 
@@ -317,14 +322,14 @@ public class IndividualObservationBatchPersistenceServiceImpl extends AbstractPe
         samplePersistenceHelper.fillSampleMeasurements(
                 result, batch.getIdAsInt());
 
-        Float weight = (Float) result.remove(referentialService.getWeightMeasuredCaracteristic());
+        Float weight = (Float) result.remove(caracteristicService.getWeightMeasuredCaracteristic());
         if (weight != null) {
             batch.setWeight(weight);
         }
 
-        String lengthClassId = (String) result.remove(referentialService.getPmfmIdCaracteristic());
+        String lengthClassId = (String) result.remove(caracteristicService.getPmfmIdCaracteristic());
         if (lengthClassId != null) {
-            Caracteristic lengthStepCaracteristic = referentialService.getCaracteristic(Integer.valueOf(lengthClassId));
+            Caracteristic lengthStepCaracteristic = caracteristicService.getCaracteristic(Integer.valueOf(lengthClassId));
             batch.setLengthStepCaracteristic(lengthStepCaracteristic);
 
             Serializable length = result.remove(lengthStepCaracteristic);
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceImpl.java
index 618bd69..61fd223 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceImpl.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceImpl.java
@@ -37,6 +37,7 @@ import fr.ifremer.tutti.persistence.entities.data.MarineLitterBatch;
 import fr.ifremer.tutti.persistence.entities.data.MarineLitterBatchs;
 import fr.ifremer.tutti.persistence.entities.referential.Caracteristic;
 import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
 import fr.ifremer.tutti.persistence.service.util.BatchPersistenceHelper;
 import fr.ifremer.tutti.persistence.service.util.BatchTreeHelper;
 import fr.ifremer.tutti.persistence.service.util.MeasurementPersistenceHelper;
@@ -60,8 +61,8 @@ public class MarineLitterBatchPersistenceServiceImpl extends AbstractPersistence
     private static final Log log =
             LogFactory.getLog(MarineLitterBatchPersistenceServiceImpl.class);
 
-    @Resource(name = "referentialPersistenceService")
-    protected ReferentialPersistenceService referentialService;
+    @Resource(name = "caracteristicPersistenceService")
+    private CaracteristicPersistenceService caracteristicService;
 
     @Resource(name = "batchPersistenceHelper")
     protected BatchPersistenceHelper batchHelper;
@@ -84,11 +85,11 @@ public class MarineLitterBatchPersistenceServiceImpl extends AbstractPersistence
     public void init() {
         super.init();
 
-        Caracteristic marineLitterCategoryCaracteristic = referentialService.getMarineLitterCategoryCaracteristic();
+        Caracteristic marineLitterCategoryCaracteristic = caracteristicService.getMarineLitterCategoryCaracteristic();
         marineLitterCategory = marineLitterCategoryCaracteristic.getIdAsInt();
         marineLitterCategoryCaracteristicValues = TuttiEntities.splitByIdAsInt(marineLitterCategoryCaracteristic.getQualitativeValue());
 
-        Caracteristic marineLitterSizeCategoryCaracteristic = referentialService.getMarineLitterSizeCategoryCaracteristic();
+        Caracteristic marineLitterSizeCategoryCaracteristic = caracteristicService.getMarineLitterSizeCategoryCaracteristic();
         marineLitterSizeCategory = marineLitterSizeCategoryCaracteristic.getIdAsInt();
         marineLitterSizeCategoryCaracteristicValues = TuttiEntities.splitByIdAsInt(marineLitterSizeCategoryCaracteristic.getQualitativeValue());
     }
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceImpl.java
index 43959a9..27ab686 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceImpl.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceImpl.java
@@ -61,9 +61,6 @@ public class ProgramPersistenceServiceImpl extends AbstractPersistenceService im
     private static final Log log =
             LogFactory.getLog(ProgramPersistenceServiceImpl.class);
 
-    @Resource(name = "referentialPersistenceService")
-    protected ReferentialPersistenceService referentialService;
-
     @Resource(name = "programDao")
     protected ProgramDao programDao;
 
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceImpl.java
index e803abd..1f54f3b 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceImpl.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceImpl.java
@@ -39,6 +39,8 @@ import fr.ifremer.tutti.persistence.entities.data.SpeciesBatchFrequency;
 import fr.ifremer.tutti.persistence.entities.data.SpeciesBatchFrequencys;
 import fr.ifremer.tutti.persistence.entities.data.SpeciesBatchs;
 import fr.ifremer.tutti.persistence.entities.referential.Species;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.SpeciesPersistenceService;
 import fr.ifremer.tutti.persistence.service.util.BatchPersistenceHelper;
 import fr.ifremer.tutti.persistence.service.util.BatchTreeHelper;
 import fr.ifremer.tutti.persistence.service.util.MeasurementPersistenceHelper;
@@ -71,8 +73,8 @@ public class SpeciesBatchPersistenceServiceImpl extends AbstractPersistenceServi
     private static final Log log =
             LogFactory.getLog(SpeciesBatchPersistenceServiceImpl.class);
 
-    @Resource(name = "referentialPersistenceService")
-    protected ReferentialPersistenceService referentialService;
+    @Resource(name = "speciesPersistenceService")
+    private SpeciesPersistenceService speciesService;
 
     @Resource(name = "fishingOperationPersistenceService")
     protected FishingOperationPersistenceService fishingOperationPersistenceService;
@@ -122,7 +124,7 @@ public class SpeciesBatchPersistenceServiceImpl extends AbstractPersistenceServi
                 if (log.isTraceEnabled()) {
                     log.trace("Loading CatchBatch Vrac > Species > Alive Itemized > " + referenceTaxon.getId() + " - " + " (batch:" + source.getId() + ")");
                 }
-                Species species = referentialService.getSpeciesByReferenceTaxonId(referenceTaxon.getId());
+                Species species = speciesService.getSpeciesByReferenceTaxonId(referenceTaxon.getId());
                 if (species == null) {
                     FishingOperation fishingOperation = fishingOperationPersistenceService.getFishingOperation(fishingOperationId);
                     String fishingOperationName = fishingOperation.getStationNumber() + " - " + fishingOperation.getFishingOperationNumber() + " - " + df.format(fishingOperation.getGearShootingStartDate());
@@ -151,7 +153,7 @@ public class SpeciesBatchPersistenceServiceImpl extends AbstractPersistenceServi
                 if (log.isTraceEnabled()) {
                     log.trace("Loading CatchBatch Hors Vrac > Species > " + referenceTaxon.getId() + " - " + " (batch:" + source.getId() + ")");
                 }
-                Species species = referentialService.getSpeciesByReferenceTaxonId(referenceTaxon.getId());
+                Species species = speciesService.getSpeciesByReferenceTaxonId(referenceTaxon.getId());
                 if (species == null) {
                     FishingOperation fishingOperation = fishingOperationPersistenceService.getFishingOperation(fishingOperationId);
                     String fishingOperationName = fishingOperation.getStationNumber() + " - " + fishingOperation.getFishingOperationNumber() + " - " + df.format(fishingOperation.getGearShootingStartDate());
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceService.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceService.java
index 3292e44..3ade09a 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceService.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceService.java
@@ -23,6 +23,7 @@ package fr.ifremer.tutti.persistence.service;
  */
 
 import fr.ifremer.tutti.persistence.TuttiPersistenceServiceImplementor;
+import fr.ifremer.tutti.persistence.entities.referential.TuttiReferentialEntity;
 import org.nuiton.util.version.Version;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -39,6 +40,8 @@ import java.util.concurrent.Callable;
 @Transactional(readOnly = true)
 public interface TechnicalPersistenceService extends TuttiPersistenceServiceImplementor {
 
+    boolean isTemporary(TuttiReferentialEntity entity);
+
     /**
      * To clear all caches.
      *
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceServiceImpl.java
index 9638603..29e00e6 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceServiceImpl.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceServiceImpl.java
@@ -22,11 +22,15 @@ package fr.ifremer.tutti.persistence.service;
  * #L%
  */
 
+import com.google.common.base.Preconditions;
+import fr.ifremer.adagio.core.dao.referential.StatusCode;
 import fr.ifremer.adagio.core.dao.technical.DatabaseSchemaDao;
 import fr.ifremer.adagio.core.dao.technical.DatabaseSchemaUpdateException;
 import fr.ifremer.adagio.core.dao.technical.VersionNotFoundException;
+import fr.ifremer.adagio.core.dao.technical.hibernate.TemporaryDataHelper;
 import fr.ifremer.adagio.core.service.technical.CacheService;
 import fr.ifremer.adagio.core.service.technical.sanity.DatabaseSanityService;
+import fr.ifremer.tutti.persistence.entities.referential.TuttiReferentialEntity;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.nuiton.jaxx.application.ApplicationTechnicalException;
@@ -115,4 +119,15 @@ public class TechnicalPersistenceServiceImpl extends AbstractPersistenceService
         cacheService.clearAllCaches();
     }
 
+    @Override
+    public boolean isTemporary(TuttiReferentialEntity entity) {
+        Preconditions.checkNotNull(entity);
+        Preconditions.checkNotNull(entity.getId());
+        Preconditions.checkNotNull(entity.getStatus());
+
+        return StatusCode.TEMPORARY.getValue().equals(entity.getStatus().getId()) &&
+               (entity.getIdAsInt() != null && entity.getIdAsInt() < 0
+                || entity.getId() != null && entity.getId().startsWith(TemporaryDataHelper.TEMPORARY_NAME_PREFIX));
+    }
+
 }
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiPersistenceServiceLocator.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiPersistenceServiceLocator.java
index c0c30f9..5134dc9 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiPersistenceServiceLocator.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiPersistenceServiceLocator.java
@@ -27,6 +27,13 @@ import fr.ifremer.adagio.core.service.technical.sanity.DatabaseSanityService;
 import fr.ifremer.adagio.core.service.technical.synchro.ReferentialSynchroService;
 import fr.ifremer.tutti.persistence.TuttiPersistence;
 import fr.ifremer.tutti.persistence.TuttiPersistenceServiceImplementor;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.GearPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.LocationPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.ObjectTypePersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.PersonPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.SpeciesPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.VesselPersistenceService;
 
 /**
  * To obtain services from spring context.
@@ -59,11 +66,6 @@ public class TuttiPersistenceServiceLocator extends ServiceLocator {
                                      TechnicalPersistenceService.class);
     }
 
-    public static ReferentialPersistenceService getReferentialPersistenceService() {
-        return instance().getService("referentialPersistenceService",
-                                     ReferentialPersistenceService.class);
-    }
-
     public static ProgramPersistenceService getProgramPersistenceService() {
         return getPersistenceService("programPersistenceService",
                                      ProgramPersistenceService.class);
@@ -142,4 +144,40 @@ public class TuttiPersistenceServiceLocator extends ServiceLocator {
     public static void shutdownTutti() {
         instance().shutdown();
     }
+
+    public static CaracteristicPersistenceService getCaracteristicPersistenceService() {
+        return getPersistenceService("caracteristicPersistenceService",
+                                     CaracteristicPersistenceService.class);
+    }
+
+    public static GearPersistenceService getGearPersistenceService() {
+        return getPersistenceService("gearPersistenceService",
+                                     GearPersistenceService.class);
+    }
+
+    public static LocationPersistenceService getLocationPersistenceService() {
+        return getPersistenceService("locationPersistenceService",
+                                     LocationPersistenceService.class);
+    }
+
+    public static ObjectTypePersistenceService getObjectTypePersistenceService() {
+        return getPersistenceService("objectTypePersistenceService",
+                                     ObjectTypePersistenceService.class);
+    }
+
+    public static PersonPersistenceService getPersonPersistenceService() {
+        return getPersistenceService("personPersistenceService",
+                                     PersonPersistenceService.class);
+    }
+
+    public static SpeciesPersistenceService getSpeciesPersistenceService() {
+        return getPersistenceService("speciesPersistenceService",
+                                     SpeciesPersistenceService.class);
+    }
+
+
+    public static VesselPersistenceService getVesselPersistenceService() {
+        return getPersistenceService("vesselPersistenceService",
+                                     VesselPersistenceService.class);
+    }
 }
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/CaracteristicPersistenceService.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/CaracteristicPersistenceService.java
new file mode 100644
index 0000000..f9daae2
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/CaracteristicPersistenceService.java
@@ -0,0 +1,83 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import com.google.common.base.Predicate;
+import fr.ifremer.tutti.persistence.TuttiPersistenceServiceImplementor;
+import fr.ifremer.tutti.persistence.entities.data.SampleCategoryModel;
+import fr.ifremer.tutti.persistence.entities.data.SpeciesAbleBatch;
+import fr.ifremer.tutti.persistence.entities.referential.Caracteristic;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+@Transactional(readOnly = true)
+public interface CaracteristicPersistenceService extends TuttiPersistenceServiceImplementor {
+
+    /**
+     * @return all caracteristics of the system.
+     * @since 1.0
+     */
+    @Cacheable(value = "pmfms")
+    List<Caracteristic> getAllCaracteristic();
+
+    /**
+     * @return all caracteristics of the system with the ones which are kind of protected.
+     * @since 2.3
+     */
+    @Cacheable(value = "pmfmsWithProtected")
+    List<Caracteristic> getAllCaracteristicWithProtected();
+
+    /**
+     * @return all caracteristics of the system useable for {@link SampleCategoryModel}.
+     * @since 2.4
+     */
+    List<Caracteristic> getAllCaracteristicForSampleCategory();
+
+    /**
+     * @return all numeric caracteristics of the system.
+     * @since 1.0.2
+     */
+    List<Caracteristic> getAllNumericCaracteristic();
+
+    Caracteristic getSizeCategoryCaracteristic();
+
+    Caracteristic getSexCaracteristic();
+
+    Caracteristic getSortedUnsortedCaracteristic();
+
+    Caracteristic getMaturityCaracteristic();
+
+    Caracteristic getAgeCaracteristic();
+
+    Caracteristic getMarineLitterCategoryCaracteristic();
+
+    Caracteristic getMarineLitterSizeCategoryCaracteristic();
+
+    Caracteristic getVerticalOpeningCaracteristic();
+
+    Caracteristic getHorizontalOpeningWingsCaracteristic();
+
+    Caracteristic getHorizontalOpeningDoorCaracteristic();
+
+    Caracteristic getDeadOrAliveCaracteristic();
+
+    Caracteristic getPmfmIdCaracteristic();
+
+    Caracteristic getWeightMeasuredCaracteristic();
+
+    @Cacheable(value = "pmfmById", key = "#pmfmId")
+    Caracteristic getCaracteristic(Integer pmfmId);
+
+    Predicate<SpeciesAbleBatch> getVracBatchPredicate();
+
+    boolean isVracBatch(SpeciesAbleBatch speciesBatch);
+
+    boolean isHorsVracBatch(SpeciesAbleBatch speciesBatch);
+
+}
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/CaracteristicPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/CaracteristicPersistenceServiceImpl.java
new file mode 100644
index 0000000..722a9f2
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/CaracteristicPersistenceServiceImpl.java
@@ -0,0 +1,299 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId;
+import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2;
+import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId;
+import fr.ifremer.adagio.core.dao.referential.pmfm.UnitId;
+import fr.ifremer.tutti.persistence.entities.data.SpeciesAbleBatch;
+import fr.ifremer.tutti.persistence.entities.data.SpeciesAbleBatchs;
+import fr.ifremer.tutti.persistence.entities.referential.Caracteristic;
+import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue;
+import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValues;
+import fr.ifremer.tutti.persistence.entities.referential.CaracteristicType;
+import fr.ifremer.tutti.persistence.entities.referential.Caracteristics;
+import org.hibernate.type.IntegerType;
+import org.springframework.cache.Cache;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+@Service("caracteristicPersistenceService")
+public class CaracteristicPersistenceServiceImpl extends ReferentialPersistenceServiceSupport implements CaracteristicPersistenceService {
+
+    //TODO-TC We should prefer AOP thant Proxy stuff to avoid this.
+    @Resource(name = "caracteristicPersistenceService")
+    protected CaracteristicPersistenceService thisService;
+
+    protected Set<Integer> propertedPmfmIds;
+
+    protected Predicate<SpeciesAbleBatch> batchVracPredicate;
+
+    @Override
+    public void init() {
+        super.init();
+
+        batchVracPredicate = SpeciesAbleBatchs.newSpeciesAbleBatchCategoryPredicate(
+                PmfmId.SORTED_UNSORTED.getValue(),
+                QualitativeValueId.SORTED_VRAC.getValue());
+
+        // init protected pmfm ids
+        propertedPmfmIds = Sets.newHashSet(
+                PmfmId.MULTIRIG_AGGREGATION.getValue(),
+                PmfmId.MULTIRIG_NUMBER.getValue(),
+                PmfmId.STATION_NUMBER.getValue(),
+                PmfmId.RECTILINEAR_OPERATION.getValue(),
+                PmfmId.HAUL_VALID.getValue(),
+                PmfmId.TRAWL_DISTANCE.getValue(),
+                PmfmId.SURVEY_PART.getValue(),
+                PmfmId.SORTED_UNSORTED.getValue(),
+                PmfmId2.ID_PSFM.getValue()
+        );
+
+    }
+
+    @Override
+    public List<Caracteristic> getAllCaracteristic() {
+        return getAllCaracteristics(false);
+    }
+
+    @Override
+    public List<Caracteristic> getAllCaracteristicWithProtected() {
+        return getAllCaracteristics(true);
+    }
+
+    @Override
+    public List<Caracteristic> getAllCaracteristicForSampleCategory() {
+        List<Caracteristic> allCaracteristicWithProtected = thisService.getAllCaracteristicWithProtected();
+        List<Caracteristic> result = Lists.newArrayList(
+                Iterables.filter(allCaracteristicWithProtected, Caracteristics.newSampleCategoryModelPredicate()));
+        return result;
+    }
+
+    protected List<Caracteristic> getAllCaracteristics(boolean withProtected) {
+        Iterator<Object[]> sources = queryListWithStatus(
+                "allPmfm",
+                "unitIdNone", IntegerType.INSTANCE, UnitId.NONE.getValue());
+        List<Caracteristic> result = Lists.newArrayList();
+        Cache pmfmByIdCache = cacheService.getCache("pmfmById");
+        while (sources.hasNext()) {
+            Object[] source = sources.next();
+            Integer pmfmId = (Integer) source[0];
+            Caracteristic target = loadCaracteristic(source);
+            // Skip some protected PSFM
+            if (withProtected || !isProtectedCaracteristic(pmfmId)) {
+                result.add(target);
+            }
+            pmfmByIdCache.put(pmfmId, target);
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public List<Caracteristic> getAllNumericCaracteristic() {
+        List<Caracteristic> result = Lists.newArrayList();
+
+        for (Caracteristic caracteristic : getAllCaracteristic()) {
+            if (caracteristic.isNumericType()) {
+                result.add(caracteristic);
+            }
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public Caracteristic getSizeCategoryCaracteristic() {
+        Integer pmfmId = PmfmId.SIZE_CATEGORY.getValue();
+        Caracteristic result = getCaracteristic(pmfmId);
+        return result;
+    }
+
+    @Override
+    public Caracteristic getSexCaracteristic() {
+        Integer pmfmId = PmfmId.SEX.getValue();
+        Caracteristic result = getCaracteristic(pmfmId);
+        return result;
+    }
+
+    @Override
+    public Caracteristic getSortedUnsortedCaracteristic() {
+        Integer pmfmId = PmfmId.SORTED_UNSORTED.getValue();
+        Caracteristic result = thisService.getCaracteristic(pmfmId);
+
+        // Search the qualitative value to skip
+        //FIXME-TC How can this works with cache ? result is the cached instance, so we are modifing cache
+        List<CaracteristicQualitativeValue> qualitativeValue =
+                Lists.newArrayList(result.getQualitativeValue());
+        Iterator<CaracteristicQualitativeValue> iterator = qualitativeValue.iterator();
+        while (iterator.hasNext()) {
+            CaracteristicQualitativeValue qv = iterator.next();
+            if (QualitativeValueId.UNSORTED.getValue().equals(Integer.valueOf(qv.getId()))) {
+                iterator.remove();
+                break;
+            }
+        }
+        result.setQualitativeValue(Collections.unmodifiableList(qualitativeValue));
+        return result;
+    }
+
+    @Override
+    public Caracteristic getMaturityCaracteristic() {
+        Integer pmfmId = PmfmId.MATURITY.getValue();
+        Caracteristic result = thisService.getCaracteristic(pmfmId);
+        return result;
+    }
+
+    @Override
+    public Caracteristic getAgeCaracteristic() {
+        Integer pmfmId = PmfmId.AGE.getValue();
+        Caracteristic result = thisService.getCaracteristic(pmfmId);
+        return result;
+    }
+
+    @Override
+    public Caracteristic getMarineLitterCategoryCaracteristic() {
+        Integer pmfmId = PmfmId.MARINE_LITTER_TYPE.getValue();
+        Caracteristic result = thisService.getCaracteristic(pmfmId);
+        return result;
+    }
+
+    @Override
+    public Caracteristic getMarineLitterSizeCategoryCaracteristic() {
+        Integer pmfmId = PmfmId.MARINE_LITTER_SIZE_CATEGORY.getValue();
+        Caracteristic result = thisService.getCaracteristic(pmfmId);
+        return result;
+    }
+
+    @Override
+    public Caracteristic getVerticalOpeningCaracteristic() {
+        Integer pmfmId = PmfmId.VERTICAL_OPENING.getValue();
+        Caracteristic result = thisService.getCaracteristic(pmfmId);
+        return result;
+    }
+
+    @Override
+    public Caracteristic getHorizontalOpeningWingsCaracteristic() {
+        Integer pmfmId = PmfmId.HORIZONTAL_OPENING_WINGS.getValue();
+        Caracteristic result = thisService.getCaracteristic(pmfmId);
+        return result;
+    }
+
+    @Override
+    public Caracteristic getHorizontalOpeningDoorCaracteristic() {
+        Integer pmfmId = PmfmId.HORIZONTAL_OPENING_DOOR.getValue();
+        Caracteristic result = thisService.getCaracteristic(pmfmId);
+        return result;
+    }
+
+    @Override
+    public Caracteristic getDeadOrAliveCaracteristic() {
+        Integer pmfmId = PmfmId.DEAD_OR_ALIVE.getValue();
+        Caracteristic result = thisService.getCaracteristic(pmfmId);
+        return result;
+    }
+
+    @Override
+    public Caracteristic getPmfmIdCaracteristic() {
+        Integer pmfmId = PmfmId2.ID_PSFM.getValue();
+        Caracteristic result = thisService.getCaracteristic(pmfmId);
+        return result;
+    }
+
+    @Override
+    public Caracteristic getWeightMeasuredCaracteristic() {
+        Integer pmfmId = PmfmId.WEIGHT_MEASURED.getValue();
+        Caracteristic result = thisService.getCaracteristic(pmfmId);
+        return result;
+    }
+
+    @Override
+    public Caracteristic getCaracteristic(Integer pmfmId) {
+        Object[] source = queryUniqueWithStatus("pmfmById",
+                                                "pmfmId", IntegerType.INSTANCE, pmfmId,
+                                                "unitIdNone", IntegerType.INSTANCE, UnitId.NONE.getValue());
+        Caracteristic target = loadCaracteristic(source);
+        return target;
+    }
+
+    @Override
+    public boolean isVracBatch(SpeciesAbleBatch speciesBatch) {
+        return batchVracPredicate.apply(speciesBatch);
+    }
+
+    @Override
+    public boolean isHorsVracBatch(SpeciesAbleBatch speciesBatch) {
+        return !batchVracPredicate.apply(speciesBatch);
+    }
+
+    @Override
+    public Predicate<SpeciesAbleBatch> getVracBatchPredicate() {
+        return batchVracPredicate;
+    }
+
+    protected Caracteristic loadCaracteristic(Object[] source) {
+
+        Integer pmfmId = (Integer) source[0];
+
+        Caracteristic result = Caracteristics.newCaracteristic();
+        result.setId(pmfmId);
+        result.setParameterName((String) source[1]);
+        result.setMatrixName((String) source[2]);
+        result.setFractionName((String) source[3]);
+        result.setMethodName((String) source[4]);
+        CaracteristicType type = Caracteristics.getType((Boolean) source[5],
+                                                        (Boolean) source[6]);
+        result.setCaracteristicType(type);
+        result.setNumericType(Caracteristics.isNumberCaracteristic(result));
+
+        result.setSignifFiguresNumber((Integer) source[7]);
+        result.setMaximumNumberDecimals((Integer) source[8]);
+        result.setPrecision((Float) source[9]);
+        result.setUnit((String) source[10]);
+        setStatus((fr.ifremer.adagio.core.dao.referential.Status) source[11], result);
+
+        if (Caracteristics.isQualitativeCaracteristic(result)) {
+
+            // load qualitative values
+
+            Iterator<Object[]> sources = queryListWithStatus(
+                    "pmfmQualitativeValues",
+                    "pmfmId", IntegerType.INSTANCE, pmfmId);
+
+            List<CaracteristicQualitativeValue> values = Lists.newArrayList();
+            while (sources.hasNext()) {
+                Object[] source2 = sources.next();
+                CaracteristicQualitativeValue target2 = CaracteristicQualitativeValues.newCaracteristicQualitativeValue();
+                target2.setId(String.valueOf(source2[0]));
+                target2.setName(String.valueOf(source2[1]));
+                target2.setDescription(String.valueOf(source2[2]));
+                setStatus((fr.ifremer.adagio.core.dao.referential.Status) source2[3], target2);
+                values.add(target2);
+            }
+            result.setQualitativeValue(Collections.unmodifiableList(values));
+        }
+        return result;
+    }
+
+    /**
+     * @param pmfmId id of pmfm to test
+     * @return {@code true} if the pmfm should NOT be used for caracteristics lists
+     * (i.e. because used somewhere when storing some properties into the database)
+     */
+    protected boolean isProtectedCaracteristic(Integer pmfmId) {
+        return propertedPmfmIds.contains(pmfmId);
+    }
+
+}
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/GearPersistenceService.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/GearPersistenceService.java
new file mode 100644
index 0000000..b1db9f0
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/GearPersistenceService.java
@@ -0,0 +1,78 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import fr.ifremer.tutti.persistence.TuttiPersistenceServiceImplementor;
+import fr.ifremer.tutti.persistence.entities.referential.Gear;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+@Transactional(readOnly = true)
+public interface GearPersistenceService extends TuttiPersistenceServiceImplementor {
+
+    List<Gear> getAllScientificGear();
+
+    List<Gear> getAllFishingGear();
+
+    Gear getGear(Integer gearId);
+
+    /**
+     * Check if the temporary gear with the given {@code id} is used.
+     *
+     * @param id id of the gear to remove
+     * @since 3.8
+     */
+    boolean isTemporaryGearUsed(Integer id);
+
+    /**
+     * Import given temporary gears.
+     *
+     * @param gears gears to import
+     * @since 1.0
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = "gears", allEntries = true)
+    List<Gear> importTemporaryGear(List<Gear> gears);
+
+    /**
+     * Replace the {@code source} gear by
+     * the {@code target} one in all data.
+     *
+     * @param source the source gear to replace
+     * @param target the target gear to use
+     * @param delete flag to delete the temporary vessel after replacement
+     * @since 3.6
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = {"fr.ifremer.adagio.core.dao.data.batch.CatchBatchCache", "gears"}, allEntries = true)
+    void replaceGear(Gear source, Gear target, boolean delete);
+
+    /**
+     * Delete the temporary gear with the given {@code id}.
+     *
+     * @param id          id of the gear to remove
+     * @param checkIfUsed to check if gear is used before trying to delete it
+     * @since 3.8
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = "gears", allEntries = true)
+    void deleteTemporaryGear(Integer id, boolean checkIfUsed);
+
+    /**
+     * Delete the temporary gears with the given {@code idss}.
+     *
+     * @param ids         ids of the gears to remove
+     * @param checkIfUsed to check if gear is used before trying to delete it
+     * @since 3.8
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = "gears", allEntries = true)
+    void deleteTemporaryGears(Collection<Integer> ids, boolean checkIfUsed);
+}
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/GearPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/GearPersistenceServiceImpl.java
new file mode 100644
index 0000000..31b2caa
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/GearPersistenceServiceImpl.java
@@ -0,0 +1,194 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Lists;
+import fr.ifremer.adagio.core.dao.referential.StatusCode;
+import fr.ifremer.adagio.core.dao.referential.gear.FishingGearExtendDao;
+import fr.ifremer.adagio.core.dao.referential.gear.GearClassification;
+import fr.ifremer.adagio.core.dao.referential.gear.GearClassificationId;
+import fr.ifremer.tutti.persistence.entities.referential.Gear;
+import fr.ifremer.tutti.persistence.entities.referential.Gears;
+import org.hibernate.type.IntegerType;
+import org.nuiton.jaxx.application.ApplicationBusinessException;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+@Service("gearPersistenceService")
+public class GearPersistenceServiceImpl extends ReferentialPersistenceServiceSupport implements GearPersistenceService {
+
+    @Resource(name = "fishingGearDao")
+    protected FishingGearExtendDao fishingGearDao;
+
+    @Override
+    public List<Gear> getAllScientificGear() {
+
+        Iterator<Object[]> sources = queryListWithStatus(
+                "allGears",
+                "gearClassificiationId", IntegerType.INSTANCE, GearClassificationId.SCIENTIFIC_CRUISE.getValue());
+        List<Gear> result = Lists.newArrayList();
+        while (sources.hasNext()) {
+            Object[] source = sources.next();
+            Gear target = loadGear(source);
+            result.add(target);
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public List<Gear> getAllFishingGear() {
+        Iterator<Object[]> sources = queryListWithStatus(
+                "allGears",
+                "gearClassificiationId", IntegerType.INSTANCE, GearClassificationId.FAO.getValue());
+        List<Gear> result = Lists.newArrayList();
+        while (sources.hasNext()) {
+            Object[] source = sources.next();
+            Gear target = loadGear(source);
+            result.add(target);
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public Gear getGear(Integer gearId) {
+        Object[] source = queryUnique(
+                "gear",
+                "gearId", IntegerType.INSTANCE, gearId);
+
+        Gear result = source == null ? null : loadGear(source);
+        return result;
+    }
+
+    @Override
+    public boolean isTemporaryGearUsed(Integer id) {
+        Long count = queryUniqueTyped("countGearInGearPhysicalFeatures", "id", IntegerType.INSTANCE, id);
+        boolean result = count > 0;
+
+        if (!result) {
+            count = queryUniqueTyped("countGearInGearUseFeatures", "id", IntegerType.INSTANCE, id);
+            result = count > 0;
+        }
+        return result;
+    }
+
+    @Override
+    public List<Gear> importTemporaryGear(List<Gear> gears) {
+        List<Gear> result = Lists.newArrayList();
+
+        fr.ifremer.adagio.core.dao.referential.Status status =
+                statusDao.load(StatusCode.TEMPORARY.getValue());
+        for (Gear source : gears) {
+            source = importTemporaryGear(source, status);
+            result.add(source);
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public void replaceGear(Gear source, Gear target, boolean delete) {
+
+        Preconditions.checkNotNull(source);
+        Preconditions.checkNotNull(target);
+        Preconditions.checkState(isTemporary(source));
+        Preconditions.checkState(!isTemporary(target));
+
+        Integer sourceId = source.getIdAsInt();
+        Integer targetId = target.getIdAsInt();
+
+        queryUpdate("replaceGearInGearPhysicalFeatures",
+                    "sourceId", IntegerType.INSTANCE, sourceId,
+                    "targetId", IntegerType.INSTANCE, targetId);
+
+        queryUpdate("replaceGearInGearUseFeatures",
+                    "sourceId", IntegerType.INSTANCE, sourceId,
+                    "targetId", IntegerType.INSTANCE, targetId);
+
+        //TODO Check doublon...
+
+        if (delete) {
+
+            deleteTemporaryGear(sourceId, false);
+
+        }
+
+    }
+
+    @Override
+    public void deleteTemporaryGear(Integer id, boolean checkIfUsed) {
+
+        Preconditions.checkNotNull(id);
+        if (id > 0) {
+            throw new ApplicationBusinessException(String.format("Can't delete a Gear with a positive id %d.", id));
+        }
+        Gear gear = getGear(id);
+        if (gear == null) {
+            throw new ApplicationBusinessException(String.format("Gear with id %d does not exists", id));
+        }
+
+        fishingGearDao.remove(id);
+
+    }
+
+    @Override
+    public void deleteTemporaryGears(Collection<Integer> ids, boolean checkIfUsed) {
+        for (Integer id : ids) {
+            deleteTemporaryGear(id, checkIfUsed);
+        }
+    }
+
+    protected Gear importTemporaryGear(Gear source, fr.ifremer.adagio.core.dao.referential.Status status) {
+        Preconditions.checkNotNull(source);
+        Preconditions.checkNotNull(source.getLabel());
+        Preconditions.checkNotNull(source.getName());
+
+        Integer gearClassificationId;
+        if (source.isScientificGear()) {
+            gearClassificationId = GearClassificationId.SCIENTIFIC_CRUISE.getValue();
+        } else {
+            gearClassificationId = GearClassificationId.FAO.getValue();
+        }
+
+        Gear result;
+        if (source.getId() != null) {
+            result = getGear(source.getIdAsInt());
+
+        } else {
+            fr.ifremer.adagio.core.dao.referential.gear.Gear target = fishingGearDao.createAsTemporary(source.getLabel(), source.getName(), gearClassificationId);
+            result = Gears.newGear();
+            result.setId(target.getId());
+        }
+
+        // Fill the result bean
+        result.setLabel(source.getLabel());
+        result.setName(source.getName());
+        result.setScientificGear(source.isScientificGear());
+        setStatus(status, result);
+        return result;
+    }
+
+    protected Gear loadGear(Object[] source) {
+        Gear result = Gears.newGear();
+        result.setId(String.valueOf(source[0]));
+        result.setLabel((String) source[1]);
+        result.setName((String) source[2]);
+        GearClassification classification = (GearClassification) source[3];
+        boolean scientific = false;
+        if (classification != null) {
+            scientific = classification.getId().equals(GearClassificationId.SCIENTIFIC_CRUISE.getValue());
+        }
+        result.setScientificGear(scientific);
+
+        setStatus((fr.ifremer.adagio.core.dao.referential.Status) source[4], result);
+        return result;
+    }
+}
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/LocationPersistenceService.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/LocationPersistenceService.java
new file mode 100644
index 0000000..b40c5b5
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/LocationPersistenceService.java
@@ -0,0 +1,110 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import fr.ifremer.tutti.persistence.TuttiPersistenceServiceImplementor;
+import fr.ifremer.tutti.persistence.entities.data.Cruise;
+import fr.ifremer.tutti.persistence.entities.data.Program;
+import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+@Transactional(readOnly = true)
+public interface LocationPersistenceService extends TuttiPersistenceServiceImplementor {
+
+    /**
+     * @return all available zones (used by a {@link Program}.
+     * @see Program#getZone()
+     * @see Program#setZone(TuttiLocation)
+     * @since 0.3
+     */
+    @Cacheable(value = "programZones")
+    List<TuttiLocation> getAllProgramZone();
+
+    /**
+     * @return all countries (used by a {@link Cruise}).
+     * @since 0.1
+     */
+    @Cacheable(value = "countries")
+    List<TuttiLocation> getAllCountry();
+
+    /**
+     * @return all harbours (used by a {@link Cruise}).
+     * @see {@link Cruise#getDepartureLocation()}
+     * @see {@link Cruise#setDepartureLocation(TuttiLocation)}
+     * @see {@link Cruise#getReturnLocation()}
+     * @see {@link Cruise#setReturnLocation(TuttiLocation)}
+     * @since 1.2
+     */
+    @Cacheable(value = "harbours")
+    List<TuttiLocation> getAllHarbour();
+
+    /**
+     * Get the list of location of type strata that match the given zone id.
+     *
+     * @param zoneId id of the parent zone (can not be null)
+     * @return the stratas with given zone id as location parent
+     * @since 1.0
+     */
+    List<TuttiLocation> getAllFishingOperationStrata(String zoneId);
+
+    /**
+     * Get the list of location of type substra that match the given zone id or
+     * if not null the given strata id.
+     *
+     * @param zoneId   id of the parent zone (can not be null)
+     * @param strataId id of the optional parent strata
+     * @return the list of localite with given zone id as location parent / or strata
+     * @since 1.0
+     */
+    List<TuttiLocation> getAllFishingOperationSubStrata(String zoneId, String strataId);
+
+    /**
+     * Get the list of location of type substra that  match the given zone id or
+     * if not null the given strata id or if not null the given substrata id if
+     * not null.
+     *
+     * @param zoneId      id of the parent zone (can not be null)
+     * @param strataId    id of the optional parent strata
+     * @param subStrataId id of the optional parent subStrata
+     * @return the list of localite with given zone id as location parent / or strata or substrata
+     * @since 1.0
+     */
+    List<TuttiLocation> getAllFishingOperationLocation(String zoneId, String strataId, String subStrataId);
+
+    /**
+     * Get a location by id .
+     *
+     * @param id the id of location to load
+     * @return the location for the given id, or {@code null} if not found
+     * @since 1.0
+     */
+    TuttiLocation getLocation(String id);
+
+    /**
+     * Return location label from a longitude and a latitude (in decimal degrees - WG84).
+     *
+     * @param latitude  a latitude (in decimal degrees - WG84)
+     * @param longitude a longitude (in decimal degrees - WG84)
+     * @return A location label (corresponding to a statistical rectangle), or null if no statistical rectangle exists for this position
+     */
+    String getLocationLabelByLatLong(Float latitude, Float longitude);
+
+    /**
+     * Return a location Id, from a longitude and a latitude (in decimal degrees - WG84).
+     * This method typically use getLocationLabelByLatLong().
+     *
+     * @param latitude  a latitude (in decimal degrees - WG84)
+     * @param longitude a longitude (in decimal degrees - WG84)
+     * @return A location Id (corresponding to a statistical rectangle), or null if no statistical rectangle exists for this position
+     */
+    Integer getLocationIdByLatLong(Float latitude, Float longitude);
+
+
+}
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/LocationPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/LocationPersistenceServiceImpl.java
new file mode 100644
index 0000000..3c436c5
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/LocationPersistenceServiceImpl.java
@@ -0,0 +1,204 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Lists;
+import fr.ifremer.adagio.core.dao.referential.location.LocationClassificationId;
+import fr.ifremer.adagio.core.dao.referential.location.LocationExtendDao;
+import fr.ifremer.adagio.core.dao.referential.location.LocationLevelId;
+import fr.ifremer.adagio.core.service.referential.location.LocationService;
+import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation;
+import fr.ifremer.tutti.persistence.entities.referential.TuttiLocations;
+import org.hibernate.type.IntegerType;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+@Service("locationPersistenceService")
+public class LocationPersistenceServiceImpl extends ReferentialPersistenceServiceSupport implements LocationPersistenceService {
+
+    @Resource(name = "locationDao")
+    protected LocationExtendDao locationDao;
+
+    @Resource(name = "locationService")
+    protected LocationService locationService;
+
+    @Override
+    public List<TuttiLocation> getAllProgramZone() {
+        Iterator<Object[]> list = queryListWithStatus(
+                "allLocationsByLevelAndClassificiation",
+                "locationClassificationId", IntegerType.INSTANCE, LocationClassificationId.SECTOR.getValue(),
+                "locationLevelId", IntegerType.INSTANCE, LocationLevelId.SCIENTIFIC_CRUISE_PROGRAM.getValue());
+
+        List<TuttiLocation> result = Lists.newArrayList();
+        while (list.hasNext()) {
+            Object[] source = list.next();
+            TuttiLocation target = loadLocation(source);
+            result.add(target);
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public List<TuttiLocation> getAllCountry() {
+        Iterator<Object[]> list = queryListWithStatus(
+                "allLocationsByLevelAndClassificiation",
+                "locationClassificationId", IntegerType.INSTANCE, LocationClassificationId.TERRITORIAL.getValue(),
+                "locationLevelId", IntegerType.INSTANCE, LocationLevelId.PAYS_ISO3.getValue());
+
+        List<TuttiLocation> result = Lists.newArrayList();
+        while (list.hasNext()) {
+            Object[] source = list.next();
+            TuttiLocation target = loadLocation(source);
+            result.add(target);
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public List<TuttiLocation> getAllHarbour() {
+        Iterator<Object[]> list = queryListWithStatus(
+                "allLocationsByLevelAndClassificiation",
+                "locationClassificationId", IntegerType.INSTANCE, LocationClassificationId.TERRITORIAL.getValue(),
+                "locationLevelId", IntegerType.INSTANCE, LocationLevelId.PORT.getValue());
+
+        List<TuttiLocation> result = Lists.newArrayList();
+        while (list.hasNext()) {
+            Object[] source = list.next();
+            TuttiLocation target = loadLocation(source);
+            result.add(target);
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public List<TuttiLocation> getAllFishingOperationStrata(String zoneId) {
+        Preconditions.checkNotNull(zoneId);
+        List<TuttiLocation> result = getFishingOperationLocationsByParent(
+                LocationLevelId.SCIENTIFIC_CRUISE_STRATA.getValue(),
+                Integer.valueOf(zoneId),
+                LocationLevelId.SCIENTIFIC_CRUISE_PROGRAM.getValue());
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public List<TuttiLocation> getAllFishingOperationSubStrata(String zoneId,
+                                                               String strataId) {
+
+        String parentId;
+        Integer parentLocationLevelId;
+
+        if (strataId != null) {
+
+            // use strata as parent
+            parentId = strataId;
+            parentLocationLevelId = LocationLevelId.SCIENTIFIC_CRUISE_STRATA.getValue();
+
+        } else {
+
+            // use zoneId as parent
+            parentId = zoneId;
+            parentLocationLevelId = LocationLevelId.SCIENTIFIC_CRUISE_PROGRAM.getValue();
+        }
+
+        Preconditions.checkNotNull(parentId);
+        List<TuttiLocation> result = getFishingOperationLocationsByParent(
+                LocationLevelId.SCIENTIFIC_CRUISE_SUB_STRATA.getValue(),
+                Integer.valueOf(parentId),
+                parentLocationLevelId);
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public List<TuttiLocation> getAllFishingOperationLocation(String zoneId,
+                                                              String strataId,
+                                                              String subStrataId) {
+
+        String parentId;
+        Integer parentLocationLevelId;
+
+        if (subStrataId != null) {
+
+            // use substrata as parent
+            parentId = subStrataId;
+            parentLocationLevelId = LocationLevelId.SCIENTIFIC_CRUISE_SUB_STRATA.getValue();
+
+        } else if (strataId != null) {
+
+            // use strata as parent
+            parentId = strataId;
+            parentLocationLevelId = LocationLevelId.SCIENTIFIC_CRUISE_STRATA.getValue();
+
+        } else {
+
+            // use zoneId as parent
+            parentId = zoneId;
+            parentLocationLevelId = LocationLevelId.SCIENTIFIC_CRUISE_PROGRAM.getValue();
+        }
+
+        Preconditions.checkNotNull(parentId);
+        List<TuttiLocation> result = getFishingOperationLocationsByParent(
+                LocationLevelId.SCIENTIFIC_CRUISE_LOCALITE.getValue(),
+                Integer.valueOf(parentId),
+                parentLocationLevelId);
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public TuttiLocation getLocation(String id) {
+        Object[] source = queryUnique(
+                "locationById",
+                "locationId", IntegerType.INSTANCE, Integer.valueOf(id)
+        );
+        if (source == null) {
+            return null;
+        }
+        TuttiLocation target = loadLocation(source);
+        return target;
+    }
+
+    @Override
+    public String getLocationLabelByLatLong(Float latitude, Float longitude) {
+        return locationService.getLocationLabelByLatLong(latitude, longitude);
+    }
+
+    @Override
+    public Integer getLocationIdByLatLong(Float latitude, Float longitude) {
+        return locationService.getLocationIdByLatLong(latitude, longitude);
+    }
+
+    protected List<TuttiLocation> getFishingOperationLocationsByParent(Integer locationLevelId, Integer parentId, Integer parentLocationLevelId) {
+        Iterator<Object[]> sources = queryListWithStatus(
+                "allFishingOperationLocationByParent",
+                "parentId", IntegerType.INSTANCE, parentId,
+                "parentLocationLevelId", IntegerType.INSTANCE, parentLocationLevelId,
+                "locationClassificationId", IntegerType.INSTANCE, LocationClassificationId.SECTOR.getValue(),
+                "locationLevelId", IntegerType.INSTANCE, locationLevelId
+        );
+        List<TuttiLocation> result = Lists.newArrayList();
+        while (sources.hasNext()) {
+            Object[] source = sources.next();
+            TuttiLocation target = loadLocation(source);
+            result.add(target);
+        }
+        return result;
+    }
+
+    protected TuttiLocation loadLocation(Object[] source) {
+        TuttiLocation target = TuttiLocations.newTuttiLocation();
+        target.setId((Integer) source[0]);
+        target.setLabel((String) source[1]);
+        target.setName((String) source[2]);
+        setStatus((fr.ifremer.adagio.core.dao.referential.Status) source[3], target);
+        return target;
+    }
+
+}
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/ObjectTypePersistenceService.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/ObjectTypePersistenceService.java
new file mode 100644
index 0000000..ca05c6f
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/ObjectTypePersistenceService.java
@@ -0,0 +1,29 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import fr.ifremer.tutti.persistence.TuttiPersistenceServiceImplementor;
+import fr.ifremer.tutti.persistence.entities.referential.ObjectType;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+@Transactional(readOnly = true)
+public interface ObjectTypePersistenceService extends TuttiPersistenceServiceImplementor {
+
+    /**
+     * @return all object type
+     * @since 1.0.2
+     */
+    @Cacheable(value = "objectTypes")
+    List<ObjectType> getAllObjectType();
+
+    @Cacheable(value = "objectTypeByCode", key = "#objectTypeCode")
+    ObjectType getObjectType(String objectTypeCode);
+
+}
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/ObjectTypePersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/ObjectTypePersistenceServiceImpl.java
new file mode 100644
index 0000000..8ca962d
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/ObjectTypePersistenceServiceImpl.java
@@ -0,0 +1,54 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import com.google.common.collect.Lists;
+import fr.ifremer.tutti.persistence.entities.referential.ObjectType;
+import fr.ifremer.tutti.persistence.entities.referential.ObjectTypes;
+import org.hibernate.type.StringType;
+import org.springframework.cache.Cache;
+import org.springframework.stereotype.Service;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+@Service("objectTypePersistenceService")
+public class ObjectTypePersistenceServiceImpl extends ReferentialPersistenceServiceSupport implements ObjectTypePersistenceService {
+
+    @Override
+    public List<ObjectType> getAllObjectType() {
+        Iterator<Object[]> sources = queryList("allObjectType");
+        List<ObjectType> result = Lists.newArrayList();
+        Cache cache = cacheService.getCache("objectTypeByCode");
+        while (sources.hasNext()) {
+            Object[] source = sources.next();
+            String code = (String) source[0];
+            ObjectType target = loadObjectType(source);
+            cache.put(code, target);
+            result.add(target);
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public ObjectType getObjectType(String objectTypeCode) {
+        Object[] source = queryUnique("objectType",
+                                      "objectTypeCode", StringType.INSTANCE, objectTypeCode);
+        ObjectType target = loadObjectType(source);
+        return target;
+    }
+
+    protected ObjectType loadObjectType(Object[] source) {
+        ObjectType result = ObjectTypes.newObjectType();
+        result.setId((String) source[0]);
+        result.setName((String) source[1]);
+        result.setDescription((String) source[2]);
+        return result;
+    }
+
+}
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/PersonPersistenceService.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/PersonPersistenceService.java
new file mode 100644
index 0000000..94a920a
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/PersonPersistenceService.java
@@ -0,0 +1,80 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import fr.ifremer.tutti.persistence.TuttiPersistenceServiceImplementor;
+import fr.ifremer.tutti.persistence.entities.referential.Person;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+@Transactional(readOnly = true)
+public interface PersonPersistenceService extends TuttiPersistenceServiceImplementor {
+
+    @Cacheable(value = "persons")
+    List<Person> getAllPerson();
+
+    @Cacheable(value = "personById", key = "#personId")
+    Person getPerson(Integer personId);
+
+    /**
+     * Import given temporary persons.
+     *
+     * @param persons persons to import
+     * @since 1.0
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = {"persons", "personById"}, allEntries = true)
+    List<Person> importTemporaryPerson(List<Person> persons);
+
+    /**
+     * Replace the {@code source} person by
+     * the {@code target} one in all data.
+     *
+     * @param source the source person to replace
+     * @param target the target person to use
+     * @param delete flag to delete the temporary vessel after replacement
+     * @since 3.6
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = {"fr.ifremer.adagio.core.dao.data.batch.CatchBatchCache", "persons", "personById"},
+            allEntries = true)
+    void replacePerson(Person source, Person target, boolean delete);
+
+    /**
+     * Delete the temporary person with the given {@code id}.
+     *
+     * @param id          id of the person to remove
+     * @param checkIfUsed to check if person is used before trying to delete it
+     * @since 3.8
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = {"persons", "personById"}, allEntries = true)
+    void deleteTemporaryPerson(Integer id, boolean checkIfUsed);
+
+    /**
+     * Delete the temporary persons with the given {@code ids}.
+     *
+     * @param ids          ids of the persons to remove
+     * @param checkIfUsed to check if person is used before trying to delete it
+     * @since 3.8
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = {"persons", "personById"}, allEntries = true)
+    void deleteTemporaryPersons(Collection<Integer> ids, boolean checkIfUsed);
+
+    /**
+     * Check if the temporary person with the given {@code id} is used.
+     *
+     * @param id          id of the person to check
+     * @since 3.8
+     */
+    boolean isTemporaryPersonUsed(Integer id);
+}
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/PersonPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/PersonPersistenceServiceImpl.java
new file mode 100644
index 0000000..a3ae17e
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/PersonPersistenceServiceImpl.java
@@ -0,0 +1,201 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Lists;
+import fr.ifremer.adagio.core.dao.administration.user.DepartmentId;
+import fr.ifremer.adagio.core.dao.administration.user.PersonExtendDao;
+import fr.ifremer.adagio.core.dao.administration.user.UserProfilId;
+import fr.ifremer.adagio.core.dao.referential.StatusCode;
+import fr.ifremer.tutti.persistence.entities.referential.Person;
+import fr.ifremer.tutti.persistence.entities.referential.Persons;
+import org.hibernate.type.IntegerType;
+import org.hibernate.type.StringType;
+import org.nuiton.jaxx.application.ApplicationBusinessException;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+@Service("personPersistenceService")
+public class PersonPersistenceServiceImpl extends ReferentialPersistenceServiceSupport implements PersonPersistenceService {
+
+    @Resource(name = "personDao")
+    protected PersonExtendDao personDao;
+
+    @Override
+    public List<Person> getAllPerson() {
+
+        Iterator<Object[]> list = queryListWithStatus(
+                "allPersons",
+                "observerProfilId", IntegerType.INSTANCE, UserProfilId.OBSERVER.getValue(),
+                "projectMemberProfilId", IntegerType.INSTANCE, UserProfilId.PROJECT_MEMBER.getValue(),
+                "userProfilId", IntegerType.INSTANCE, UserProfilId.USER.getValue(),
+                "departementPrefixCode", StringType.INSTANCE, "PDG-" //FIXME Use the Departement enum when it will exists in adagio
+//                "departementPrefixCode", StringType.INSTANCE, enumeration.USER_PROFIL_ID_DEPARTEMENT_PREFIX
+        );
+
+        List<Person> result = Lists.newArrayList();
+        while (list.hasNext()) {
+            Object[] source = list.next();
+            Person target = loadPerson(source);
+            result.add(target);
+        }
+        return Collections.unmodifiableList(result);
+
+    }
+
+    @Override
+    public Person getPerson(Integer personId) {
+
+        Object[] source = queryUnique(
+                "person",
+                "personId", IntegerType.INSTANCE, personId);
+
+        Person result = source == null ? null : loadPerson(source);
+        return result;
+
+    }
+
+    @Override
+    public List<Person> importTemporaryPerson(List<Person> persons) {
+
+        List<Person> result = Lists.newArrayList();
+
+        fr.ifremer.adagio.core.dao.referential.Status status =
+                statusDao.load(StatusCode.TEMPORARY.getValue());
+        for (Person source : persons) {
+            source = importTemporaryPerson(source, status);
+            result.add(source);
+        }
+        return Collections.unmodifiableList(result);
+
+    }
+
+    @Override
+    public void replacePerson(Person source, Person target, boolean delete) {
+
+        Preconditions.checkNotNull(source);
+        Preconditions.checkNotNull(target);
+        Preconditions.checkState(isTemporary(source));
+        Preconditions.checkState(!isTemporary(target));
+
+        Integer sourceId = source.getIdAsInt();
+        Integer targetId = target.getIdAsInt();
+
+        queryUpdate("replaceManagerPersonInScientificCruise",
+                    "sourceId", IntegerType.INSTANCE, sourceId,
+                    "targetId", IntegerType.INSTANCE, targetId);
+
+        queryUpdate("replaceRecorderPersonInScientificCruise",
+                    "sourceId", IntegerType.INSTANCE, sourceId,
+                    "targetId", IntegerType.INSTANCE, targetId);
+
+        queryUpdate("replaceRecorderPersonInFishingTrip",
+                    "sourceId", IntegerType.INSTANCE, sourceId,
+                    "targetId", IntegerType.INSTANCE, targetId);
+
+        queryUpdate("replacePersonInVesselPersonFeatures",
+                    "sourceId", IntegerType.INSTANCE, sourceId,
+                    "targetId", IntegerType.INSTANCE, targetId);
+
+        cacheService.clearAllCaches();
+
+        //TODO Check doublon...
+
+        if (delete) {
+
+            deleteTemporaryPerson(sourceId, false);
+
+        }
+
+    }
+
+    @Override
+    public void deleteTemporaryPerson(Integer id, boolean checkIfUsed) {
+
+        Preconditions.checkNotNull(id);
+        if (id > 0) {
+            throw new ApplicationBusinessException(String.format("Can't delete a Person with a positive id %d.", id));
+        }
+        Person person = getPerson(id);
+        if (person == null) {
+            throw new ApplicationBusinessException(String.format("Person with id %d does not exists", id));
+        }
+        personDao.remove(id);
+
+    }
+
+    @Override
+    public void deleteTemporaryPersons(Collection<Integer> ids, boolean checkIfUsed) {
+        for (Integer id : ids) {
+            deleteTemporaryPerson(id, checkIfUsed);
+        }
+    }
+
+    @Override
+    public boolean isTemporaryPersonUsed(Integer id) {
+        Long count = queryUniqueTyped("countManagerPersonInScientificCruise", "id", IntegerType.INSTANCE, id);
+        boolean result = count > 0;
+
+        if (!result) {
+            count = queryUniqueTyped("countRecorderPersonInScientificCruise", "id", IntegerType.INSTANCE, id);
+            result = count > 0;
+        }
+
+        if (!result) {
+            count = queryUniqueTyped("countRecorderPersonInFishingTrip", "id", IntegerType.INSTANCE, id);
+            result = count > 0;
+        }
+
+        if (!result) {
+            count = queryUniqueTyped("countPersonInVesselPersonFeatures", "id", IntegerType.INSTANCE, id);
+            result = count > 0;
+        }
+
+        return result;
+    }
+
+    protected Person loadPerson(Object[] source) {
+        Person target = Persons.newPerson();
+        target.setId(String.valueOf(source[0]));
+        target.setLastName((String) source[1]);
+        target.setFirstName((String) source[2]);
+        target.setDepartment((String) source[3]);
+        setStatus((fr.ifremer.adagio.core.dao.referential.Status) source[4], target);
+        return target;
+    }
+
+    protected Person importTemporaryPerson(Person source, fr.ifremer.adagio.core.dao.referential.Status status) {
+        Preconditions.checkNotNull(source);
+        Preconditions.checkNotNull(source.getFirstName());
+        Preconditions.checkNotNull(source.getLastName());
+
+        Person result;
+        if (source.getId() != null) {
+            result = getPerson(source.getIdAsInt());
+
+        } else {
+            fr.ifremer.adagio.core.dao.administration.user.Person target =
+                    personDao.createAsTemporary(source.getLastName(), source.getFirstName(),
+                                                DepartmentId.UNKNOWN_RECORDER_DEPARTMENT.getValue());
+            result = Persons.newPerson();
+            result.setId(target.getId());
+        }
+
+        // Fill the result bean
+        result.setLastName(source.getLastName());
+        result.setFirstName(source.getFirstName());
+        setStatus(status, result);
+        return result;
+    }
+
+}
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/ReferentialPersistenceServiceSupport.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/ReferentialPersistenceServiceSupport.java
new file mode 100644
index 0000000..a3bb498
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/ReferentialPersistenceServiceSupport.java
@@ -0,0 +1,68 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import com.google.common.base.Preconditions;
+import fr.ifremer.adagio.core.dao.referential.StatusCode;
+import fr.ifremer.adagio.core.dao.referential.StatusDao;
+import fr.ifremer.adagio.core.dao.technical.hibernate.TemporaryDataHelper;
+import fr.ifremer.adagio.core.service.technical.CacheService;
+import fr.ifremer.tutti.persistence.entities.referential.Status;
+import fr.ifremer.tutti.persistence.entities.referential.Statuss;
+import fr.ifremer.tutti.persistence.entities.referential.TuttiReferentialEntity;
+import fr.ifremer.tutti.persistence.service.AbstractPersistenceService;
+import org.hibernate.Query;
+
+import javax.annotation.Resource;
+import java.util.Iterator;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+public abstract class ReferentialPersistenceServiceSupport extends AbstractPersistenceService {
+
+    @Resource(name = "statusDao")
+    protected StatusDao statusDao;
+
+    @Resource(name = "cacheService")
+    protected CacheService cacheService;
+    
+    public boolean isTemporary(TuttiReferentialEntity entity) {
+        Preconditions.checkNotNull(entity);
+        Preconditions.checkNotNull(entity.getId());
+        Preconditions.checkNotNull(entity.getStatus());
+
+        return StatusCode.TEMPORARY.getValue().equals(entity.getStatus().getId()) &&
+               (entity.getIdAsInt() != null && entity.getIdAsInt() < 0
+                || entity.getId() != null && entity.getId().startsWith(TemporaryDataHelper.TEMPORARY_NAME_PREFIX));
+    }
+
+    protected Iterator<Object[]> queryListWithStatus(String queryName,
+                                                     Object... params) {
+        Query query = createQuery(queryName, params);
+        query.setString("statusValidCode", StatusCode.ENABLE.getValue());
+        query.setString("statusTemporaryCode", StatusCode.TEMPORARY.getValue());
+
+        Iterator<Object[]> result = query.iterate();
+        return result;
+    }
+
+    protected Object[] queryUniqueWithStatus(String queryName, Object... params) {
+
+        Query query = createQuery(queryName, params);
+        query.setString("statusValidCode", StatusCode.ENABLE.getValue());
+        query.setString("statusTemporaryCode", StatusCode.TEMPORARY.getValue());
+
+        Object result = query.uniqueResult();
+        return (Object[]) result;
+    }
+
+    protected <E extends TuttiReferentialEntity> void setStatus(fr.ifremer.adagio.core.dao.referential.Status status, E entity) {
+        Status newStatus = Statuss.newStatus();
+        newStatus.setId(status.getCode());
+        newStatus.setName(status.getName());
+        entity.setStatus(newStatus);
+    }
+
+}
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/SpeciesPersistenceService.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/SpeciesPersistenceService.java
new file mode 100644
index 0000000..892d85f
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/SpeciesPersistenceService.java
@@ -0,0 +1,117 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import fr.ifremer.tutti.persistence.TuttiPersistenceServiceImplementor;
+import fr.ifremer.tutti.persistence.entities.referential.Species;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+@Transactional(readOnly = true)
+public interface SpeciesPersistenceService extends TuttiPersistenceServiceImplementor {
+
+    /**
+     * @return all referent species
+     * @since 0.3
+     */
+    @Cacheable(value = "referentSpecies")
+    List<Species> getAllReferentSpecies();
+
+    /**
+     * @return all species
+     * @since 0.3
+     */
+    @Cacheable(value = "species")
+    List<Species> getAllSpecies();
+
+    /**
+     * Obtain a species given his referenceTaxonId.
+     *
+     * @param referenceTaxonId id of the reference taxon of the species to load
+     * @return the species or {@code null} if not found.
+     * @see Species#getReferenceTaxonId()
+     * @see Species#getRefTaxCode()
+     * @since 0.3
+     */
+    @Cacheable(value = "referentSpeciesById", key = "#referenceTaxonId")
+    Species getSpeciesByReferenceTaxonId(Integer referenceTaxonId);
+
+    /**
+     * Obtain a species with external code as vernacular code given his referenceTaxonId.
+     * <p/>
+     * <strong>Note:</strong> {@link Species#getRefTaxCode()} will not be
+     * filled by with method.
+     *
+     * @param referenceTaxonId id of the reference taxon of the species to load
+     * @return the species or {@code null} if not found.
+     * @see Species#getReferenceTaxonId()
+     * @see Species#getVernacularCode()
+     * @since 2.0
+     */
+    @Cacheable(value = "referentSpeciesByIdVernacular", key = "#referenceTaxonId")
+    Species getSpeciesByReferenceTaxonIdWithVernacularCode(Integer referenceTaxonId);
+
+    /**
+     * Check if the temporary species with the given {@code id} is used.
+     *
+     * @param id id of the species to check
+     * @since 3.8
+     */
+    boolean isTemporarySpeciesUsed(Integer id);
+
+    /**
+     * Import given temporary species.
+     *
+     * @param species species to import
+     * @since 1.0
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = {"species", "referentSpecies", "referentSpeciesById", "referentSpeciesByIdVernacular"}, allEntries = true)
+    List<Species> importTemporarySpecies(List<Species> species);
+
+    /**
+     * Replace the {@code source} species by
+     * the {@code target} one in all data.
+     *
+     * @param source the source species to replace
+     * @param target the target species to use
+     * @param delete flag to delete the temporary vessel after replacement
+     * @since 3.6
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = {"fr.ifremer.adagio.core.dao.data.batch.CatchBatchCache",
+                         "species", "referentSpecies", "referentSpeciesById", "referentSpeciesByIdVernacular"},
+            allEntries = true)
+    void replaceSpecies(Species source, Species target, boolean delete);
+
+    /**
+     * Delete the temporary species with the given {@code id}.
+     *
+     * @param id          id of the species to remove
+     * @param checkIfUsed to check if species is used before trying to delete it
+     * @since 3.8
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = {"species", "referentSpecies", "referentSpeciesById", "referentSpeciesByIdVernacular"}, allEntries = true)
+    void deleteTemporarySpecies(Integer id, boolean checkIfUsed);
+
+    /**
+     * Delete the temporary species with the given {@code ids}.
+     *
+     * @param ids         ids of the species to remove
+     * @param checkIfUsed to check if species is used before trying to delete it
+     * @since 3.8
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = {"species", "referentSpecies", "referentSpeciesById", "referentSpeciesByIdVernacular"}, allEntries = true)
+    void deleteTemporarySpecies(Collection<Integer> ids, boolean checkIfUsed);
+
+}
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/SpeciesPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/SpeciesPersistenceServiceImpl.java
new file mode 100644
index 0000000..3377430
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/SpeciesPersistenceServiceImpl.java
@@ -0,0 +1,246 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Lists;
+import fr.ifremer.adagio.core.dao.referential.taxon.TaxonName;
+import fr.ifremer.adagio.core.dao.referential.taxon.TaxonNameExtendDao;
+import fr.ifremer.adagio.core.dao.referential.taxon.TaxonNameImpl;
+import fr.ifremer.adagio.core.dao.referential.taxon.TaxonRefVO;
+import fr.ifremer.adagio.core.dao.referential.transcribing.TranscribingItemTypeId;
+import fr.ifremer.tutti.persistence.entities.referential.Species;
+import fr.ifremer.tutti.persistence.entities.referential.Speciess;
+import org.apache.commons.lang3.StringUtils;
+import org.hibernate.type.IntegerType;
+import org.nuiton.jaxx.application.ApplicationBusinessException;
+import org.springframework.cache.Cache;
+import org.springframework.dao.DataRetrievalFailureException;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+@Service("speciesPersistenceService")
+public class SpeciesPersistenceServiceImpl extends ReferentialPersistenceServiceSupport implements SpeciesPersistenceService {
+
+    @Resource(name = "taxonNameDao")
+    protected TaxonNameExtendDao taxonNameDao;
+
+    @Override
+    public List<Species> getAllSpecies() {
+
+        TaxonRefVO[] sources = taxonNameDao.getAllTaxonNames(
+                true, TranscribingItemTypeId.TAXON_NAME_REFTAX_CODE.getValue());
+
+        List<Species> result = Lists.newArrayListWithCapacity(sources.length);
+        List<Species> referenceTaxonsOnly = Lists.newArrayList();
+        Cache referentSpeciesByIdCache = cacheService.getCache("referentSpeciesById");
+        for (TaxonRefVO source : sources) {
+            Species target = loadSpecies(source);
+
+            // FIXME kmorin 20130423 http://forge.codelutin.com/issues/2350
+            target.setRefTaxCode(StringUtils.trim(target.getExternalCode()));
+
+            if (target.isReferenceTaxon()) {
+
+                // Add to cache :
+                referentSpeciesByIdCache.put(target.getReferenceTaxonId(), target);
+
+                referenceTaxonsOnly.add(target);
+            }
+            result.add(target);
+        }
+
+        // Add to cache :
+        Cache allReferentSpeciesCache = cacheService.getCache("referentSpecies");
+        allReferentSpeciesCache.put("", referenceTaxonsOnly);
+
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public List<Species> getAllReferentSpecies() {
+
+        TaxonRefVO[] sources = taxonNameDao.getAllTaxonNames(
+                false, TranscribingItemTypeId.TAXON_NAME_REFTAX_CODE.getValue());
+        List<Species> result = Lists.newArrayListWithCapacity(sources.length);
+        Cache referentSpeciesByIdCache = cacheService.getCache("referentSpeciesById");
+        for (TaxonRefVO source : sources) {
+            Species target = loadSpecies(source);
+
+            // FIXME kmorin 20130423 http://forge.codelutin.com/issues/2350
+            target.setRefTaxCode(StringUtils.trim(target.getExternalCode()));
+
+            // Add to cache :
+            referentSpeciesByIdCache.put(target.getReferenceTaxonId(), target);
+
+            result.add(target);
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public Species getSpeciesByReferenceTaxonId(Integer referenceTaxonId) {
+        Species result = getSpeciesByReferenceTaxonId(
+                referenceTaxonId,
+                TranscribingItemTypeId.TAXON_NAME_REFTAX_CODE.getValue());
+        if (result != null) {
+            result.setRefTaxCode(result.getExternalCode());
+        }
+        return result;
+    }
+
+    @Override
+    public Species getSpeciesByReferenceTaxonIdWithVernacularCode(Integer referenceTaxonId) {
+        Species result = getSpeciesByReferenceTaxonId(
+                referenceTaxonId,
+                TranscribingItemTypeId.TAXON_NAME_LOCAL_NAME.getValue());
+        if (result != null) {
+            result.setVernacularCode(result.getExternalCode());
+        }
+        return result;
+    }
+
+    protected Species getSpeciesByReferenceTaxonId(Integer referenceTaxonId,
+                                                   Integer transcribingTypeId) {
+        Species target;
+        try {
+            TaxonRefVO source = taxonNameDao.getTaxonNameReferent(
+                    referenceTaxonId, transcribingTypeId);
+            target = loadSpecies(source);
+        } catch (DataRetrievalFailureException drfe) {
+            target = null;
+        }
+        return target;
+    }
+
+    @Override
+    public boolean isTemporarySpeciesUsed(Integer id) {
+        Long count = queryUniqueTyped("countReferenceTaxonInSortingBatch", "id", IntegerType.INSTANCE, id);
+        boolean result = count > 0;
+
+        if (!result) {
+            count = queryUniqueTyped("countReferenceTaxonInSample", "id", IntegerType.INSTANCE, id);
+            result = count > 0;
+        }
+        return result;
+    }
+
+    @Override
+    public List<Species> importTemporarySpecies(List<Species> species) {
+        List<Species> result = Lists.newArrayList();
+        for (Species source : species) {
+            source = importTemporarySpecies(source);
+            result.add(source);
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public void replaceSpecies(Species source, Species target, boolean delete) {
+
+        Preconditions.checkNotNull(source);
+        Preconditions.checkNotNull(target);
+        Preconditions.checkState(isTemporary(source));
+        Preconditions.checkState(!isTemporary(target));
+
+        Integer sourceId = source.getReferenceTaxonId();
+        Integer targetId = target.getReferenceTaxonId();
+
+        queryUpdate("replaceReferenceTaxonInSortingBatch",
+                    "sourceId", IntegerType.INSTANCE, sourceId,
+                    "targetId", IntegerType.INSTANCE, targetId);
+
+        queryUpdate("replaceReferenceTaxonInSample",
+                    "sourceId", IntegerType.INSTANCE, sourceId,
+                    "targetId", IntegerType.INSTANCE, targetId);
+
+        //TODO Check doublon...
+
+        if (delete) {
+
+            deleteTemporarySpecies(sourceId, false);
+
+        }
+
+    }
+
+    @Override
+    public void deleteTemporarySpecies(Integer id, boolean checkIfUsed) {
+
+        Preconditions.checkNotNull(id);
+        if (id > 0) {
+            throw new ApplicationBusinessException(String.format("Can't delete a Species with a positive id %d.", id));
+        }
+        Species species = getSpeciesByReferenceTaxonId(id);
+        if (species == null) {
+            throw new ApplicationBusinessException(String.format("Species with id %d does not exists", id));
+        }
+
+        if (checkIfUsed) {
+            isTemporarySpeciesUsed(id);
+        }
+
+        taxonNameDao.remove(id);
+
+    }
+
+    @Override
+    public void deleteTemporarySpecies(Collection<Integer> ids, boolean checkIfUsed) {
+        for (Integer id : ids) {
+            deleteTemporarySpecies(id, checkIfUsed);
+        }
+    }
+
+    protected Species importTemporarySpecies(Species source) {
+        Preconditions.checkNotNull(source);
+        Preconditions.checkNotNull(source.getName());
+        Preconditions.checkArgument(source.getIdAsInt() == null || source.getIdAsInt() < 0);
+
+        TaxonRefVO taxonRefVO = null;
+        if (source.getReferenceTaxonId() != null) {
+            taxonRefVO = taxonNameDao.getTaxonNameReferent(source.getReferenceTaxonId());
+        }
+        if (taxonRefVO == null) {
+            taxonRefVO = new TaxonRefVO();
+            taxonRefVO.setName(source.getName());
+            taxonRefVO = taxonNameDao.createAsTemporary(
+                    taxonRefVO,
+                    "Added by tutti (file import).");
+        } else {
+            TaxonName taxonName = load(TaxonNameImpl.class, taxonRefVO.getTaxonNameId());
+            taxonName.setName(source.getName());
+            taxonRefVO.setName(source.getName());
+            taxonNameDao.update(taxonName);
+        }
+
+        // update the source
+        Species result = loadSpecies(taxonRefVO);
+        result.setRefTaxCode(result.getExternalCode());
+
+        // Add to cache
+        Cache cache = cacheService.getCache("referentSpeciesById");
+        cache.put(result.getIdAsInt(), result);
+
+        return result;
+    }
+
+    protected Species loadSpecies(TaxonRefVO source) {
+        Species target = Speciess.newSpecies();
+        target.setId(source.getTaxonNameId());
+        target.setName(source.getName());
+        target.setExternalCode(source.getExternalCode());
+        target.setReferenceTaxonId(source.getReferenceTaxonId());
+        target.setReferenceTaxon(source.getIsReference());
+        fr.ifremer.adagio.core.dao.referential.Status status = statusDao.load(source.getStatus().getValue());
+        setStatus(status, target);
+        return target;
+    }
+}
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/VesselPersistenceService.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/VesselPersistenceService.java
new file mode 100644
index 0000000..0e8986c
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/VesselPersistenceService.java
@@ -0,0 +1,101 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import fr.ifremer.tutti.persistence.TuttiPersistenceServiceImplementor;
+import fr.ifremer.tutti.persistence.entities.data.Cruise;
+import fr.ifremer.tutti.persistence.entities.referential.Vessel;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+@Transactional(readOnly = true)
+public interface VesselPersistenceService extends TuttiPersistenceServiceImplementor {
+
+    /**
+     * @return all scientific vessels (used by a {@link Cruise}).
+     * @see Cruise#getVessel()
+     * @see Cruise#setVessel(Vessel)
+     * @since 0.3
+     */
+    List<Vessel> getAllScientificVessel();
+
+    /**
+     * @return all commercial vessels (used by a {@link Cruise}).
+     * @see Cruise#getVessel()
+     * @see Cruise#setVessel(Vessel)
+     * @since 0.3
+     */
+    @Cacheable(value = "fishingVessels")
+    List<Vessel> getAllFishingVessel();
+
+    /**
+     * @param vesselCode code of the vessel to find
+     * @return the vessel
+     * @since 0.3
+     */
+    @Cacheable(value = "vesselByCode", key = "#vesselCode")
+    Vessel getVessel(String vesselCode);
+
+    /**
+     * Check if the temporary vessel with the given {@code id} is used.
+     *
+     * @param code code of the vessel to remove
+     * @since 3.8
+     */
+    boolean isTemporaryVesselUsed(String code);
+
+    /**
+     * Import given temporary vessels.
+     *
+     * @param vessels vessels to import
+     * @since 1.0
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = {"fishingVessels", "vesselByCode"}, allEntries = true)
+    List<Vessel> importTemporaryVessel(List<Vessel> vessels);
+
+    /**
+     * Replace the {@code source} vessel by
+     * the {@code target} one in all data.
+     *
+     * @param source the source vessel to replace
+     * @param target the target vessel to use
+     * @param delete flag to delete the temporary vessel after replacement
+     * @since 3.6
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = {"fr.ifremer.adagio.core.dao.data.batch.CatchBatchCache", "fishingVessels", "vesselByCode"},
+            allEntries = true)
+    void replaceVessel(Vessel source, Vessel target, boolean delete);
+
+    /**
+     * Delete the temporary vessel with the given {@code code}.
+     *
+     * @param code        code of the vessel to remove
+     * @param checkIfUsed to check if vessel is used before trying to delete it
+     * @since 3.8
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = {"fishingVessels", "vesselByCode"}, allEntries = true)
+    void deleteTemporaryVessel(String code, boolean checkIfUsed);
+
+    /**
+     * Delete the temporary vessels with the given {@code codes}.
+     *
+     * @param codes       code of the vessels to remove
+     * @param checkIfUsed to check if vessel is used before trying to delete it
+     * @since 3.8
+     */
+    @Transactional(readOnly = false)
+    @CacheEvict(value = {"fishingVessels", "vesselByCode"}, allEntries = true)
+    void deleteTemporaryVessels(Collection<String> codes, boolean checkIfUsed);
+
+}
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/VesselPersistenceServiceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/VesselPersistenceServiceImpl.java
new file mode 100644
index 0000000..aa3dc4a
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/referential/VesselPersistenceServiceImpl.java
@@ -0,0 +1,304 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Lists;
+import fr.ifremer.adagio.core.dao.data.vessel.VesselExtendDao;
+import fr.ifremer.adagio.core.dao.referential.StatusCode;
+import fr.ifremer.adagio.core.dao.referential.VesselTypeId;
+import fr.ifremer.adagio.core.dao.referential.location.LocationExtendDao;
+import fr.ifremer.adagio.core.dao.referential.location.LocationLabel;
+import fr.ifremer.adagio.core.dao.referential.location.LocationLevelId;
+import fr.ifremer.adagio.core.dao.technical.hibernate.TemporaryDataHelper;
+import fr.ifremer.tutti.persistence.entities.referential.Vessel;
+import fr.ifremer.tutti.persistence.entities.referential.Vessels;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.hibernate.type.DateType;
+import org.hibernate.type.IntegerType;
+import org.hibernate.type.StringType;
+import org.nuiton.jaxx.application.ApplicationBusinessException;
+import org.springframework.cache.Cache;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+@Service("vesselPersistenceService")
+public class VesselPersistenceServiceImpl extends ReferentialPersistenceServiceSupport implements VesselPersistenceService {
+
+    /** Logger. */
+    private static final Log log = LogFactory.getLog(VesselPersistenceServiceImpl.class);
+
+    @Resource(name = "vesselExtendDao")
+    protected VesselExtendDao vesselExtendDao;
+
+    @Resource(name = "locationDao")
+    protected LocationExtendDao locationDao;
+
+    @Override
+    public List<Vessel> getAllScientificVessel() {
+
+        Iterator<Object[]> list = queryListWithStatus(
+                "allVessels",
+                "refDate", DateType.INSTANCE, new Date(),
+                "vesselTypeId", IntegerType.INSTANCE, VesselTypeId.SCIENTIFIC_RESEARCH_VESSEL.getValue());
+
+        List<Vessel> result = Lists.newArrayList();
+        Cache vesselByCodeCache = cacheService.getCache("vesselByCode");
+
+        while (list.hasNext()) {
+            Object[] source = list.next();
+            Vessel target = loadVessel(source, true);
+            result.add(target);
+            // Add to cache
+            vesselByCodeCache.put(target.getId(), target);
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public List<Vessel> getAllFishingVessel() {
+        Iterator<Object[]> list = queryListWithStatus(
+                "allVessels",
+                "refDate", DateType.INSTANCE, new Date(),
+                "vesselTypeId", IntegerType.INSTANCE, VesselTypeId.FISHING_VESSEL.getValue()
+        );
+
+        List<Vessel> result = Lists.newArrayList();
+        Cache vesselByCodeCache = cacheService.getCache("vesselByCode");
+
+        while (list.hasNext()) {
+            Object[] source = list.next();
+            Vessel target = loadVessel(source, true);
+            target.setScientificVessel(false);
+            result.add(target);
+
+            // Add to cache
+            vesselByCodeCache.put(target.getId(), target);
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public Vessel getVessel(String vesselCode) {
+        if (log.isDebugEnabled()) {
+            log.debug("get vessel: " + vesselCode);
+        }
+        // Warning : return a list because more than one line could be found,
+        // but 'order by' assume that the first one in the good row
+        Iterator<Object[]> source = queryListWithStatus(
+                "vessel",
+                "vesselCode", StringType.INSTANCE, vesselCode,
+                "refDate", DateType.INSTANCE, new Date()
+        );
+        Vessel result;
+        if (source.hasNext())
+            result = loadVessel(source.next(), false);
+        else
+            result = null;
+        return result;
+    }
+
+    @Override
+    public boolean isTemporaryVesselUsed(String code) {
+        Long count = queryUniqueTyped("countVesselInCruise", "id", StringType.INSTANCE, code);
+        boolean result = count > 0;
+
+        if (!result) {
+            count = queryUniqueTyped("countVesselInFishingOperation", "id", StringType.INSTANCE, code);
+            result = count > 0;
+        }
+
+        if (!result) {
+            count = queryUniqueTyped("countVesselInOperationVesselAssociation", "id", StringType.INSTANCE, code);
+            result = count > 0;
+        }
+
+        if (!result) {
+            count = queryUniqueTyped("countVesselInDailyActivityCalendar", "id", StringType.INSTANCE, code);
+            result = count > 0;
+        }
+
+        if (!result) {
+            count = queryUniqueTyped("countVesselInLanding", "id", StringType.INSTANCE, code);
+            result = count > 0;
+        }
+
+        if (!result) {
+            count = queryUniqueTyped("countVesselInFishingtrip", "id", StringType.INSTANCE, code);
+            result = count > 0;
+        }
+
+        if (!result) {
+            count = queryUniqueTyped("countVesselInVesselUseFeatures", "id", StringType.INSTANCE, code);
+            result = count > 0;
+        }
+
+        if (!result) {
+            count = queryUniqueTyped("countVesselInGearUseFeatures", "id", StringType.INSTANCE, code);
+            result = count > 0;
+        }
+
+        if (!result) {
+            count = queryUniqueTyped("countVesselInGearPhysicalFeatures", "id", StringType.INSTANCE, code);
+            result = count > 0;
+        }
+
+        return result;
+    }
+
+    @Override
+    public List<Vessel> importTemporaryVessel(List<Vessel> vessels) {
+        List<Vessel> result = Lists.newArrayList();
+
+        fr.ifremer.adagio.core.dao.referential.Status status =
+                statusDao.load(StatusCode.TEMPORARY.getValue());
+        Integer countryLocationId =
+                locationDao.getLocationIdByLabelAndLocationLevel(
+                        LocationLabel.FRANCE.getValue(),
+                        new Integer[]{LocationLevelId.PAYS_ISO3.getValue()});
+        if (countryLocationId == null) {
+            throw new DataIntegrityViolationException("Default country location not found, with label=" + LocationLabel.FRANCE.getValue());
+        }
+
+        for (Vessel source : vessels) {
+            source = importTemporaryVessel(source, countryLocationId, status);
+            result.add(source);
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    @Override
+    public void replaceVessel(Vessel source, Vessel target, boolean delete) {
+
+        Preconditions.checkNotNull(source);
+        Preconditions.checkNotNull(target);
+        Preconditions.checkState(isTemporary(source));
+        Preconditions.checkState(!isTemporary(target));
+
+        String sourceId = source.getId();
+        String targetId = target.getId();
+
+        queryUpdate("replaceVesselInCruise",
+                    "sourceId", StringType.INSTANCE, sourceId,
+                    "targetId", StringType.INSTANCE, targetId);
+
+        queryUpdate("replaceVesselInFishingOperation",
+                    "sourceId", StringType.INSTANCE, sourceId,
+                    "targetId", StringType.INSTANCE, targetId);
+
+        queryUpdate("replaceVesselInOperationVesselAssociation",
+                    "sourceId", StringType.INSTANCE, sourceId,
+                    "targetId", StringType.INSTANCE, targetId);
+
+        queryUpdate("replaceVesselInDailyActivityCalendar",
+                    "sourceId", StringType.INSTANCE, sourceId,
+                    "targetId", StringType.INSTANCE, targetId);
+
+        queryUpdate("replaceVesselInLanding",
+                    "sourceId", StringType.INSTANCE, sourceId,
+                    "targetId", StringType.INSTANCE, targetId);
+
+        queryUpdate("replaceVesselInFishingtrip",
+                    "sourceId", StringType.INSTANCE, sourceId,
+                    "targetId", StringType.INSTANCE, targetId);
+
+        queryUpdate("replaceVesselInVesselUseFeatures",
+                    "sourceId", StringType.INSTANCE, sourceId,
+                    "targetId", StringType.INSTANCE, targetId);
+
+        queryUpdate("replaceVesselInGearUseFeatures",
+                    "sourceId", StringType.INSTANCE, sourceId,
+                    "targetId", StringType.INSTANCE, targetId);
+
+        queryUpdate("replaceVesselInGearPhysicalFeatures",
+                    "sourceId", StringType.INSTANCE, sourceId,
+                    "targetId", StringType.INSTANCE, targetId);
+
+        //TODO Check doublon...
+
+        if (delete) {
+
+            deleteTemporaryVessel(sourceId, false);
+
+        }
+
+    }
+
+    @Override
+    public void deleteTemporaryVessel(String code, boolean checkIfUsed) {
+
+        Preconditions.checkNotNull(code);
+        if (!code.startsWith(TemporaryDataHelper.TEMPORARY_NAME_PREFIX)) {
+            throw new ApplicationBusinessException(String.format("Can't delete a Vessel with a code %s not beginning with %s.", code, TemporaryDataHelper.TEMPORARY_NAME_PREFIX));
+        }
+        Vessel vessel = getVessel(code);
+        if (vessel == null) {
+            throw new ApplicationBusinessException(String.format("Vessel with code %s does not exists", code));
+        }
+
+        vesselExtendDao.remove(code);
+
+    }
+
+    @Override
+    public void deleteTemporaryVessels(Collection<String> codes, boolean checkIfUsed) {
+        for (String code : codes) {
+            deleteTemporaryVessel(code, checkIfUsed);
+        }
+    }
+
+    protected Vessel importTemporaryVessel(Vessel source, Integer registrationLocationId, fr.ifremer.adagio.core.dao.referential.Status status) {
+        Preconditions.checkNotNull(source);
+        Preconditions.checkNotNull(source.getName());
+        Preconditions.checkNotNull(source.getInternationalRegistrationCode());
+
+        Integer vesselTypeId;
+        if (source.isScientificVessel()) {
+            vesselTypeId = VesselTypeId.SCIENTIFIC_RESEARCH_VESSEL.getValue();
+        } else {
+            vesselTypeId = VesselTypeId.FISHING_VESSEL.getValue();
+        }
+
+        fr.ifremer.adagio.core.dao.data.vessel.Vessel target =
+                vesselExtendDao.createAsTemporary(
+                        null,
+                        source.getInternationalRegistrationCode(),
+                        registrationLocationId, source.getName(),
+                        vesselTypeId,
+                        false);
+
+        // Fill the result bean
+        Vessel result = Vessels.newVessel();
+        result.setId(target.getCode());
+        result.setName(source.getName());
+        result.setRegistrationCode(source.getRegistrationCode());
+        result.setInternationalRegistrationCode(source.getInternationalRegistrationCode());
+        result.setScientificVessel(source.isScientificVessel());
+        setStatus(status, result);
+        return result;
+    }
+
+    protected Vessel loadVessel(Object[] source, boolean scientificVessel) {
+        Vessel target = Vessels.newVessel();
+        target.setId((String) source[0]);
+        target.setRegistrationCode((String) source[1]);
+        target.setInternationalRegistrationCode((String) source[2]);
+        target.setName((String) source[3]);
+        target.setScientificVessel(scientificVessel);
+        setStatus((fr.ifremer.adagio.core.dao.referential.Status) source[4], target);
+        return target;
+    }
+
+}
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/BatchPersistenceHelper.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/BatchPersistenceHelper.java
index f49d954..afdd991 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/BatchPersistenceHelper.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/BatchPersistenceHelper.java
@@ -62,8 +62,8 @@ import fr.ifremer.tutti.persistence.entities.referential.Species;
 import fr.ifremer.tutti.persistence.service.AbstractPersistenceService;
 import fr.ifremer.tutti.persistence.service.AttachmentPersistenceService;
 import fr.ifremer.tutti.persistence.service.IndividualObservationBatchPersistenceService;
-import fr.ifremer.tutti.persistence.service.ReferentialPersistenceService;
 import fr.ifremer.tutti.persistence.service.batch.TuttiCatchBatchValidator;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
@@ -76,7 +76,6 @@ import java.io.Serializable;
 import java.text.MessageFormat;
 import java.util.Collection;
 import java.util.List;
-import java.util.Objects;
 import java.util.Set;
 
 import static org.nuiton.i18n.I18n.t;
@@ -94,8 +93,8 @@ public class BatchPersistenceHelper extends AbstractPersistenceService {
     private static final Log log =
             LogFactory.getLog(BatchPersistenceHelper.class);
 
-    @Resource(name = "referentialPersistenceService")
-    protected ReferentialPersistenceService referentialService;
+    @Resource(name = "caracteristicPersistenceService")
+    private CaracteristicPersistenceService caracteristicService;
 
     @Resource(name = "attachmentPersistenceService")
     protected AttachmentPersistenceService attachmentPersistenceService;
@@ -875,7 +874,7 @@ public class BatchPersistenceHelper extends AbstractPersistenceService {
         Preconditions.checkNotNull(sm.getPmfm().getId(), "SortingMeasurement [" + sm.getId() + "] can not have a pmfm with null id");
 
         // Length step category
-        Caracteristic lengthStepCaracteristic = referentialService.getCaracteristic(sm.getPmfm().getId());
+        Caracteristic lengthStepCaracteristic = caracteristicService.getCaracteristic(sm.getPmfm().getId());
         target.setLengthStepCaracteristic(lengthStepCaracteristic);
 
         // Length
@@ -894,7 +893,7 @@ public class BatchPersistenceHelper extends AbstractPersistenceService {
             return alphanumericalValue;
         }
 
-        Caracteristic caracteristic = referentialService.getCaracteristic(pmfmId);
+        Caracteristic caracteristic = caracteristicService.getCaracteristic(pmfmId);
         if (caracteristic == null || caracteristic.getCaracteristicType() != CaracteristicType.QUALITATIVE) {
             return null;
         }
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/MeasurementPersistenceHelper.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/MeasurementPersistenceHelper.java
index e576e13..e370e92 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/MeasurementPersistenceHelper.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/MeasurementPersistenceHelper.java
@@ -48,7 +48,7 @@ import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueImpl;
 import fr.ifremer.tutti.persistence.entities.referential.Caracteristic;
 import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue;
 import fr.ifremer.tutti.persistence.service.AbstractPersistenceService;
-import fr.ifremer.tutti.persistence.service.ReferentialPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
 import org.springframework.stereotype.Component;
 
 import javax.annotation.Resource;
@@ -66,8 +66,8 @@ import java.util.Set;
 @Component("measurementPersistenceHelper")
 public class MeasurementPersistenceHelper extends AbstractPersistenceService {
 
-    @Resource(name = "referentialPersistenceService")
-    protected ReferentialPersistenceService referentialService;
+    @Resource(name = "caracteristicPersistenceService")
+    private CaracteristicPersistenceService caracteristicService;
 
     @Resource(name = "catchBatchDao")
     protected CatchBatchExtendDao catchBatchDao;
@@ -110,7 +110,7 @@ public class MeasurementPersistenceHelper extends AbstractPersistenceService {
         Preconditions.checkNotNull(pmfmId);
         Preconditions.checkNotNull(value);
 
-        Caracteristic caracteristic = referentialService.getCaracteristic(pmfmId);
+        Caracteristic caracteristic = caracteristicService.getCaracteristic(pmfmId);
         SortingMeasurement sortingMeasurement = catchBatchDao.getSortingMeasurement(
                 sortingBatch, pmfmId, getRecorderDepartmentId(), true);
         setMeasurement(sortingMeasurement,
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/SamplePersistenceHelper.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/SamplePersistenceHelper.java
index 595f6d3..e5fb6ad 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/SamplePersistenceHelper.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/SamplePersistenceHelper.java
@@ -35,7 +35,7 @@ import fr.ifremer.tutti.persistence.entities.referential.Caracteristic;
 import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValues;
 import fr.ifremer.tutti.persistence.service.AbstractPersistenceService;
 import fr.ifremer.tutti.persistence.service.AttachmentPersistenceService;
-import fr.ifremer.tutti.persistence.service.ReferentialPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
 import org.hibernate.type.IntegerType;
 import org.springframework.dao.DataRetrievalFailureException;
 import org.springframework.stereotype.Component;
@@ -54,8 +54,8 @@ import java.util.Set;
 @Component("samplePersistenceHelper")
 public class SamplePersistenceHelper extends AbstractPersistenceService {
 
-    @Resource(name = "referentialPersistenceService")
-    protected ReferentialPersistenceService referentialService;
+    @Resource(name = "caracteristicPersistenceService")
+    private CaracteristicPersistenceService caracteristicService;
 
     @Resource(name = "measurementPersistenceHelper")
     protected MeasurementPersistenceHelper measurementPersistenceHelper;
@@ -141,7 +141,7 @@ public class SamplePersistenceHelper extends AbstractPersistenceService {
             String alphanumericalValue = (String) source[colIndex++];
             Integer qualitativeValueId = (Integer) source[colIndex];
 
-            Caracteristic caracteristic = referentialService.getCaracteristic(pmfmId);
+            Caracteristic caracteristic = caracteristicService.getCaracteristic(pmfmId);
             Serializable value = null;
             switch (caracteristic.getCaracteristicType()) {
 
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseFixtures.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseFixtures.java
index 5c9c25f..27aebc2 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseFixtures.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseFixtures.java
@@ -50,8 +50,12 @@ import fr.ifremer.tutti.persistence.service.CruisePersistenceService;
 import fr.ifremer.tutti.persistence.service.FishingOperationPersistenceService;
 import fr.ifremer.tutti.persistence.service.IndividualObservationBatchPersistenceService;
 import fr.ifremer.tutti.persistence.service.ProgramPersistenceService;
-import fr.ifremer.tutti.persistence.service.ReferentialPersistenceService;
 import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.GearPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.LocationPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.PersonPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.SpeciesPersistenceService;
 import org.junit.Assert;
 import org.nuiton.util.version.Version;
 import org.nuiton.util.version.Versions;
@@ -220,15 +224,27 @@ public class DatabaseFixtures {
 
     protected CatchBatchPersistenceService catchBatchService;
 
-    protected ReferentialPersistenceService referentialService;
+    private CaracteristicPersistenceService caracteristicService;
+
+    private GearPersistenceService gearService;
+
+    private LocationPersistenceService locationService;
+
+    private PersonPersistenceService personService;
+
+    private SpeciesPersistenceService speciesService;
 
     protected AccidentalBatchPersistenceService accidentalBatchService;
 
     protected IndividualObservationBatchPersistenceService individualObservationBatchService;
 
     public void setUp() {
-        if (referentialService == null) {
-            referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService();
+        if (caracteristicService == null) {
+            caracteristicService = TuttiPersistenceServiceLocator.getCaracteristicPersistenceService();
+            gearService = TuttiPersistenceServiceLocator.getGearPersistenceService();
+            locationService = TuttiPersistenceServiceLocator.getLocationPersistenceService();
+            personService = TuttiPersistenceServiceLocator.getPersonPersistenceService();
+            speciesService = TuttiPersistenceServiceLocator.getSpeciesPersistenceService();
             programService = TuttiPersistenceServiceLocator.getProgramPersistenceService();
             cruiseService = TuttiPersistenceServiceLocator.getCruisePersistenceService();
             fishingOperationService = TuttiPersistenceServiceLocator.getFishingOperationPersistenceService();
@@ -260,13 +276,13 @@ public class DatabaseFixtures {
         calendar.add(Calendar.MONTH, 1); // add one month
         cruise.setEndDate(calendar.getTime());
 
-        List<TuttiLocation> allHarbour = referentialService.getAllHarbour();
+        List<TuttiLocation> allHarbour = locationService.getAllHarbour();
         Assert.assertNotNull(allHarbour);
         Assert.assertTrue(allHarbour.size() > 1);
         cruise.setDepartureLocation(allHarbour.get(0));
         cruise.setReturnLocation(allHarbour.get(1));
 
-        List<Gear> gears = referentialService.getAllFishingGear();
+        List<Gear> gears = gearService.getAllFishingGear();
         List<GearWithOriginalRankOrder> gearsWithOrder = Lists.newArrayListWithCapacity(gears.size());
         short rankOrder = (short) 0;
         for (Gear gear : gears) {
@@ -281,7 +297,7 @@ public class DatabaseFixtures {
         cruise.setComment("My comments on cruise");
         cruise.setSurveyPart("SurveyPart");
 
-        Person managerPerson = referentialService.getAllPerson().get(0);
+        Person managerPerson = personService.getAllPerson().get(0);
         cruise.setHeadOfMission(Lists.newArrayList(managerPerson));
 
         Vessel fishingVessel = Vessels.newVessel();
@@ -304,7 +320,7 @@ public class DatabaseFixtures {
         fishingOperation.setFishingOperationNumber(1);
 
         // Retrieve some environment caracteristics
-        List<Caracteristic> allEnvironmentCaracteristics = referentialService.getAllCaracteristic();
+        List<Caracteristic> allEnvironmentCaracteristics = caracteristicService.getAllCaracteristic();
         CaracteristicMap environmentCaracteristics = new CaracteristicMap();
         CaracteristicMap environmentValuesOneEntry = new CaracteristicMap();
         int count = 0;
@@ -334,7 +350,7 @@ public class DatabaseFixtures {
         }
 
         // Retrieve some gear use caracteristics
-        List<Caracteristic> allGearShootingCaracteristics = referentialService.getAllCaracteristic();
+        List<Caracteristic> allGearShootingCaracteristics = caracteristicService.getAllCaracteristic();
         CaracteristicMap gearShootingCaracteristics = new CaracteristicMap();
         CaracteristicMap gearShootingCaracteristicsOneEntry = new CaracteristicMap();
         count = 0;
@@ -420,7 +436,7 @@ public class DatabaseFixtures {
 
         AccidentalBatch minimalAccidentalBatch = AccidentalBatchs.newAccidentalBatch();
         minimalAccidentalBatch.setFishingOperation(fishingOperation);
-        minimalAccidentalBatch.setSpecies(referentialService.getSpeciesByReferenceTaxonId(refSpeciesTaxonId()));
+        minimalAccidentalBatch.setSpecies(speciesService.getSpeciesByReferenceTaxonId(refSpeciesTaxonId()));
         minimalAccidentalBatch.setCaracteristics(new CaracteristicMap());
         AccidentalBatch result =
                 accidentalBatchService.createAccidentalBatch(minimalAccidentalBatch);
@@ -433,9 +449,9 @@ public class DatabaseFixtures {
 
         IndividualObservationBatch minimalAccidentalBatch = IndividualObservationBatchs.newIndividualObservationBatch();
         minimalAccidentalBatch.setFishingOperation(fishingOperation);
-        minimalAccidentalBatch.setSpecies(referentialService.getSpeciesByReferenceTaxonId(refSpeciesTaxonId()));
+        minimalAccidentalBatch.setSpecies(speciesService.getSpeciesByReferenceTaxonId(refSpeciesTaxonId()));
         minimalAccidentalBatch.setCaracteristics(new CaracteristicMap());
-        minimalAccidentalBatch.setLengthStepCaracteristic(referentialService.getCaracteristic(refNumericalPmfmId()));
+        minimalAccidentalBatch.setLengthStepCaracteristic(caracteristicService.getCaracteristic(refNumericalPmfmId()));
         minimalAccidentalBatch.setSize(10.0f);
         minimalAccidentalBatch.setWeight(5.f);
 
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocolsTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocolsTest.java
index 1d54b20..9993a55 100644
--- a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocolsTest.java
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocolsTest.java
@@ -50,7 +50,6 @@ public class TuttiProtocolsTest {
             "- !SpeciesProtocol\n" +
             "   id: 1\n" +
             "   calcifySampleEnabled: true\n" +
-            "   idAsInt: 1\n" +
             "   lengthStepPmfmId: 1394\n" +
             "   mandatorySampleCategoryId: \n" +
             "   - 174\n" +
@@ -62,7 +61,6 @@ public class TuttiProtocolsTest {
             "   id: 2\n" +
             "   calcifySampleEnabled: true\n" +
             "   countIfNoFrequencyEnabled: true\n" +
-            "   idAsInt: 2\n" +
             "   lengthStepPmfmId: 323\n" +
             "   mandatorySampleCategoryId: \n" +
             "   - 1430\n" +
@@ -76,7 +74,6 @@ public class TuttiProtocolsTest {
             "gearUseFeaturePmfmId: \n" +
             "- 21\n" +
             "- 22\n" +
-            "idAsInt: 1\n" +
             "lengthClassesPmfmId: \n" +
             "- 14\n" +
             "- 18\n" +
@@ -84,7 +81,6 @@ public class TuttiProtocolsTest {
             "- !SpeciesProtocol\n" +
             "   id: 1\n" +
             "   calcifySampleEnabled: true\n" +
-            "   idAsInt: 1\n" +
             "   lengthStepPmfmId: 1394\n" +
             "   mandatorySampleCategoryId: \n" +
             "   - 174\n" +
@@ -96,7 +92,6 @@ public class TuttiProtocolsTest {
             "   id: 2\n" +
             "   calcifySampleEnabled: true\n" +
             "   countIfNoFrequencyEnabled: true\n" +
-            "   idAsInt: 2\n" +
             "   lengthStepPmfmId: 323\n" +
             "   mandatorySampleCategoryId: \n" +
             "   - 1430\n" +
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceWriteTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceWriteTest.java
index 8e28e0f..8aa9ca8 100644
--- a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceWriteTest.java
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceWriteTest.java
@@ -28,6 +28,7 @@ import fr.ifremer.tutti.persistence.entities.data.AccidentalBatch;
 import fr.ifremer.tutti.persistence.entities.data.Cruise;
 import fr.ifremer.tutti.persistence.entities.data.FishingOperation;
 import fr.ifremer.tutti.persistence.entities.referential.Caracteristic;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
 import fr.ifremer.tutti.persistence.test.DatabaseResource;
 import org.apache.commons.collections4.CollectionUtils;
 import org.junit.Assert;
@@ -48,15 +49,15 @@ public class AccidentalBatchPersistenceServiceWriteTest {
     @ClassRule
     public static final DatabaseResource dbResource = DatabaseResource.writeDb();
 
-    protected AccidentalBatchPersistenceService service;
+    protected CaracteristicPersistenceService caracteristicService;
 
-    protected ReferentialPersistenceService referentialService;
+    protected AccidentalBatchPersistenceService service;
 
     protected FishingOperation fishingOperation;
 
     @Before
     public void setUp() throws Exception {
-        referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService();
+        caracteristicService = TuttiPersistenceServiceLocator.getCaracteristicPersistenceService();
         service = TuttiPersistenceServiceLocator.getAccidentalBatchPersistenceService();
         Cruise cruise = dbResource.getFixtures().createCruise();
         fishingOperation = dbResource.getFixtures().createFishingOperation(cruise);
@@ -92,22 +93,22 @@ public class AccidentalBatchPersistenceServiceWriteTest {
         fullAccidentalBatch.setCaracteristics(caracteristicMap);
 
         // add a qualitative caracteristic
-        Caracteristic maturityCaracteristic = referentialService.getMaturityCaracteristic();
+        Caracteristic maturityCaracteristic = caracteristicService.getMaturityCaracteristic();
         caracteristicMap.put(maturityCaracteristic, maturityCaracteristic.getQualitativeValue(0));
 
         // add a numeric caracteristic
-        Caracteristic ageCaracteristic = referentialService.getAgeCaracteristic();
+        Caracteristic ageCaracteristic = caracteristicService.getAgeCaracteristic();
         caracteristicMap.put(ageCaracteristic, 10.f);
 
         // add a string caracteristic
-        Caracteristic stringCaracteristic = referentialService.getCaracteristic(dbResource.getFixtures().refAlphanumericPmfmId());
+        Caracteristic stringCaracteristic = caracteristicService.getCaracteristic(dbResource.getFixtures().refAlphanumericPmfmId());
         caracteristicMap.put(stringCaracteristic, "Un texte!");
 
         fullAccidentalBatch.setComment("AccidentalBatch-full");
-        fullAccidentalBatch.setDeadOrAlive(referentialService.getDeadOrAliveCaracteristic().getQualitativeValue(0));
-        fullAccidentalBatch.setGender(referentialService.getSexCaracteristic().getQualitativeValue(0));
+        fullAccidentalBatch.setDeadOrAlive(caracteristicService.getDeadOrAliveCaracteristic().getQualitativeValue(0));
+        fullAccidentalBatch.setGender(caracteristicService.getSexCaracteristic().getQualitativeValue(0));
 
-        fullAccidentalBatch.setLengthStepCaracteristic(referentialService.getCaracteristic(dbResource.getFixtures().refNumericalPmfmId()));
+        fullAccidentalBatch.setLengthStepCaracteristic(caracteristicService.getCaracteristic(dbResource.getFixtures().refNumericalPmfmId()));
         fullAccidentalBatch.setSize(10.0f);
 
         fullAccidentalBatch.setWeight(5.f);
@@ -136,8 +137,8 @@ public class AccidentalBatchPersistenceServiceWriteTest {
         modifiedAccidentalBatch.setComment("Comment2");
         modifiedAccidentalBatch.setSize(15f);
         modifiedAccidentalBatch.setWeight(35f);
-        modifiedAccidentalBatch.setDeadOrAlive(referentialService.getDeadOrAliveCaracteristic().getQualitativeValue(1));
-        modifiedAccidentalBatch.setGender(referentialService.getSexCaracteristic().getQualitativeValue(1));
+        modifiedAccidentalBatch.setDeadOrAlive(caracteristicService.getDeadOrAliveCaracteristic().getQualitativeValue(1));
+        modifiedAccidentalBatch.setGender(caracteristicService.getSexCaracteristic().getQualitativeValue(1));
         modifiedAccidentalBatch.getCaracteristics().clear();
 
         AccidentalBatch savedAccidentalBatch = service.saveAccidentalBatch(modifiedAccidentalBatch);
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceWriteTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceWriteTest.java
index e4aa0f3..4fa29e1 100644
--- a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceWriteTest.java
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceWriteTest.java
@@ -38,6 +38,9 @@ import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativ
 import fr.ifremer.tutti.persistence.entities.referential.CaracteristicType;
 import fr.ifremer.tutti.persistence.entities.referential.Species;
 import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.LocationPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.SpeciesPersistenceService;
 import fr.ifremer.tutti.persistence.test.DatabaseResource;
 import org.junit.Assert;
 import org.junit.Before;
@@ -78,7 +81,11 @@ public class BenthosBatchPersistenceServiceWriteTest {
 
     protected FishingOperationPersistenceService fishingOperationService;
 
-    protected ReferentialPersistenceService referentialService;
+    protected CaracteristicPersistenceService caracteristicService;
+
+    private LocationPersistenceService locationService;
+
+    private SpeciesPersistenceService speciesService;
 
     /* 
      * Entities prepared in setUp() :
@@ -120,9 +127,11 @@ public class BenthosBatchPersistenceServiceWriteTest {
         cruiseService = TuttiPersistenceServiceLocator.getCruisePersistenceService();
         catchBatchService = TuttiPersistenceServiceLocator.getCatchBatchPersistenceService();
         fishingOperationService = TuttiPersistenceServiceLocator.getFishingOperationPersistenceService();
-        referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService();
+        caracteristicService = TuttiPersistenceServiceLocator.getCaracteristicPersistenceService();
+        locationService = TuttiPersistenceServiceLocator.getLocationPersistenceService();
+        speciesService = TuttiPersistenceServiceLocator.getSpeciesPersistenceService();
 
-        species = referentialService.getAllSpecies();
+        species = speciesService.getAllSpecies();
         assertNotNull(species);
         assertTrue(species.size() > 2);
 
@@ -132,7 +141,7 @@ public class BenthosBatchPersistenceServiceWriteTest {
         cruise.setBeginDate(calendar.getTime());
         calendar.add(Calendar.MONTH, 1); // add one month
         cruise.setEndDate(calendar.getTime());
-        List<TuttiLocation> allHarbour = referentialService.getAllHarbour();
+        List<TuttiLocation> allHarbour = locationService.getAllHarbour();
         Assert.assertNotNull(allHarbour);
         Assert.assertTrue(allHarbour.size() > 1);
         cruise.setDepartureLocation(allHarbour.get(0));
@@ -177,17 +186,17 @@ public class BenthosBatchPersistenceServiceWriteTest {
         catchBacth.setFishingOperation(fishingOperationWithEmptyBatch);
         catchBacth = catchBatchService.createCatchBatch(catchBacth);
 
-        sortedUnsortedPMFM = referentialService.getSortedUnsortedCaracteristic();
+        sortedUnsortedPMFM = caracteristicService.getSortedUnsortedCaracteristic();
         horsVracQualitativeValue = sortedUnsortedPMFM.getQualitativeValue(0);
         vracQualitativeValue = sortedUnsortedPMFM.getQualitativeValue(1);
-        maturityPMFM = referentialService.getMaturityCaracteristic();
+        maturityPMFM = caracteristicService.getMaturityCaracteristic();
         firstMaturityQualitativeValue = maturityPMFM.getQualitativeValue(0);
-        sexPMFM = referentialService.getSexCaracteristic();
+        sexPMFM = caracteristicService.getSexCaracteristic();
         maleQualitativeValue = sexPMFM.getQualitativeValue(1);
         femaleQualitativeValue = sexPMFM.getQualitativeValue(2);
         unkQualitativeValue = sexPMFM.getQualitativeValue(3);
 
-        List<Caracteristic> cara = referentialService.getAllCaracteristic();
+        List<Caracteristic> cara = caracteristicService.getAllCaracteristic();
         for (Caracteristic caracteristic : cara) {
             if (caracteristic.getCaracteristicType() == CaracteristicType.NUMBER
                 && caracteristic.getPrecision() != null
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceWriteTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceWriteTest.java
index 6829d81..30af732 100644
--- a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceWriteTest.java
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceWriteTest.java
@@ -60,8 +60,6 @@ public class CatchBatchPersistenceServiceWriteTest {
 
     protected IndividualObservationBatchPersistenceService individualObservationBatchPersistenceService;
 
-    protected ReferentialPersistenceService referentialService;
-
     /* 
      * Entities prepared in setUp() :
      * */
@@ -74,7 +72,6 @@ public class CatchBatchPersistenceServiceWriteTest {
         service = TuttiPersistenceServiceLocator.getCatchBatchPersistenceService();
         cruiseService = TuttiPersistenceServiceLocator.getCruisePersistenceService();
         fishingOperationService = TuttiPersistenceServiceLocator.getFishingOperationPersistenceService();
-        referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService();
         individualObservationBatchPersistenceService = TuttiPersistenceServiceLocator.getIndividualObservationBatchPersistenceService();
 
         cruise = dbResource.getFixtures().createCruise();
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceWriteTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceWriteTest.java
index b800171..e74e0a1 100644
--- a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceWriteTest.java
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceWriteTest.java
@@ -32,6 +32,9 @@ import fr.ifremer.tutti.persistence.entities.referential.Person;
 import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation;
 import fr.ifremer.tutti.persistence.entities.referential.Vessel;
 import fr.ifremer.tutti.persistence.entities.referential.Vessels;
+import fr.ifremer.tutti.persistence.service.referential.GearPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.LocationPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.PersonPersistenceService;
 import fr.ifremer.tutti.persistence.test.DatabaseResource;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
@@ -64,7 +67,11 @@ public class CruisePersistenceServiceWriteTest {
     @ClassRule
     public static final DatabaseResource dbResource = DatabaseResource.writeDb();
 
-    protected ReferentialPersistenceService referentialService;
+    private GearPersistenceService gearService;
+
+    private LocationPersistenceService locationService;
+
+    private PersonPersistenceService personService;
 
     protected ProgramPersistenceService programService;
 
@@ -73,7 +80,9 @@ public class CruisePersistenceServiceWriteTest {
     @Before
     public void setUp() throws Exception {
         service = TuttiPersistenceServiceLocator.getCruisePersistenceService();
-        referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService();
+        gearService = TuttiPersistenceServiceLocator.getGearPersistenceService();
+        locationService = TuttiPersistenceServiceLocator.getLocationPersistenceService();
+        personService = TuttiPersistenceServiceLocator.getPersistenceService();
         programService = TuttiPersistenceServiceLocator.getProgramPersistenceService();
     }
 
@@ -97,13 +106,13 @@ public class CruisePersistenceServiceWriteTest {
         calendar.add(Calendar.MONTH, 1); // add one month
         cruise.setEndDate(calendar.getTime());
 
-        List<TuttiLocation> allHarbour = referentialService.getAllHarbour();
+        List<TuttiLocation> allHarbour = locationService.getAllHarbour();
         Assert.assertNotNull(allHarbour);
         Assert.assertTrue(allHarbour.size() > 1);
         cruise.setDepartureLocation(allHarbour.get(0));
         cruise.setReturnLocation(allHarbour.get(1));
 
-        List<Gear> gears = referentialService.getAllFishingGear();
+        List<Gear> gears = gearService.getAllFishingGear();
         List<GearWithOriginalRankOrder> gears2 = Lists.newArrayListWithCapacity(gears.size());
         for (Gear gear : gears) {
             gears2.add(GearWithOriginalRankOrders.newGearWithOriginalRankOrder(gear));
@@ -113,7 +122,7 @@ public class CruisePersistenceServiceWriteTest {
         cruise.setComment("My comments on cruise");
         cruise.setSurveyPart("SurveyPart");
 
-        Person managerPerson = referentialService.getAllPerson().get(0);
+        Person managerPerson = personService.getAllPerson().get(0);
         cruise.setHeadOfMission(Lists.newArrayList(managerPerson));
         cruise.setHeadOfSortRoom(Lists.newArrayList(managerPerson));
 
@@ -226,7 +235,7 @@ public class CruisePersistenceServiceWriteTest {
 
         calendar.add(Calendar.MONTH, 1); // add one month
         cruise.setEndDate(calendar.getTime());
-        List<TuttiLocation> allHarbour = referentialService.getAllHarbour();
+        List<TuttiLocation> allHarbour = locationService.getAllHarbour();
         Assert.assertNotNull(allHarbour);
         Assert.assertTrue(allHarbour.size() > 1);
         cruise.setDepartureLocation(allHarbour.get(0));
@@ -247,7 +256,7 @@ public class CruisePersistenceServiceWriteTest {
         // Remove gear, then add another gear
         Gear previousGear = cruise.getGear(0);
         cruise.getGear().clear();
-        List<Gear> gears = referentialService.getAllFishingGear();
+        List<Gear> gears = gearService.getAllFishingGear();
         for (Gear gear : gears) {
             // Make sure the gear is different before to add it
             if (!gear.equals(previousGear)) {
@@ -256,8 +265,8 @@ public class CruisePersistenceServiceWriteTest {
             }
         }
 
-        cruise.addHeadOfMission(referentialService.getAllPerson().get(1));
-        cruise.setHeadOfSortRoom(Lists.<Person>newArrayList(referentialService.getAllPerson().get(0)));
+        cruise.addHeadOfMission(personService.getAllPerson().get(1));
+        cruise.setHeadOfSortRoom(Lists.<Person>newArrayList(personService.getAllPerson().get(0)));
 
         // Save changes, then check
         Cruise savedCruise = service.saveCruise(cruise, true, true);
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceWriteTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceWriteTest.java
index 58e3106..749efb3 100644
--- a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceWriteTest.java
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceWriteTest.java
@@ -32,6 +32,9 @@ import fr.ifremer.tutti.persistence.entities.referential.Gear;
 import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation;
 import fr.ifremer.tutti.persistence.entities.referential.TuttiLocations;
 import fr.ifremer.tutti.persistence.entities.referential.Vessel;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.GearPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.VesselPersistenceService;
 import fr.ifremer.tutti.persistence.test.DatabaseResource;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.logging.Log;
@@ -79,7 +82,9 @@ public class FishingOperationPersistenceServiceWriteTest {
 
     protected IndividualObservationBatchPersistenceService individualObservationBatchPersistenceService;
 
-    protected ReferentialPersistenceService referentialService;
+    private CaracteristicPersistenceService caracteristicService;
+
+    private GearPersistenceService gearService;
 
     protected Cruise cruise = null;
 
@@ -90,7 +95,10 @@ public class FishingOperationPersistenceServiceWriteTest {
     @Before
     public void setUp() throws Exception {
         service = TuttiPersistenceServiceLocator.getFishingOperationPersistenceService();
-        referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService();
+        caracteristicService = TuttiPersistenceServiceLocator.getCaracteristicPersistenceService();
+        gearService = TuttiPersistenceServiceLocator.getGearPersistenceService();
+
+
         catchBatchPersistenceService = TuttiPersistenceServiceLocator.getCatchBatchPersistenceService();
         accidentalBatchPersistenceService = TuttiPersistenceServiceLocator.getAccidentalBatchPersistenceService();
         individualObservationBatchPersistenceService = TuttiPersistenceServiceLocator.getIndividualObservationBatchPersistenceService();
@@ -100,7 +108,8 @@ public class FishingOperationPersistenceServiceWriteTest {
         cruiseGear = cruise.getGear().get(0);
 
         // Find a vessel, different from the cruise vessel
-        notCruiseVessel = referentialService.getVessel(dbResource.getFixtures().fishingVesselCode());
+        VesselPersistenceService vesselService = TuttiPersistenceServiceLocator.getVesselPersistenceService();
+        notCruiseVessel = vesselService.getVessel(dbResource.getFixtures().fishingVesselCode());
         assertNotNull(notCruiseVessel.getId());
     }
 
@@ -114,7 +123,7 @@ public class FishingOperationPersistenceServiceWriteTest {
         FishingOperation createdFishingOperation;
 
         // Retrieve some environment caracteristics
-        List<Caracteristic> allEnvironmentCaracteristics = referentialService.getAllCaracteristic();
+        List<Caracteristic> allEnvironmentCaracteristics = caracteristicService.getAllCaracteristic();
         CaracteristicMap environmentCaracteristics = new CaracteristicMap();
         CaracteristicMap environmentValuesOneEntry = new CaracteristicMap();
         for (Caracteristic caracteristic : allEnvironmentCaracteristics) {
@@ -137,7 +146,7 @@ public class FishingOperationPersistenceServiceWriteTest {
         }
 
         // Retrieve some gear use caracteristics
-        List<Caracteristic> allGearShootingCaracteristics = referentialService.getAllCaracteristic();
+        List<Caracteristic> allGearShootingCaracteristics = caracteristicService.getAllCaracteristic();
         CaracteristicMap gearShootingCaracteristics = new CaracteristicMap();
         CaracteristicMap gearShootingCaracteristicsOneEntry = new CaracteristicMap();
         for (Caracteristic caracteristic : allGearShootingCaracteristics) {
@@ -308,7 +317,7 @@ public class FishingOperationPersistenceServiceWriteTest {
         fishingOperation.setId((String) null);
 
         // Find and set a gear not used in the cruise
-        List<Gear> gears = referentialService.getAllScientificGear();
+        List<Gear> gears = gearService.getAllScientificGear();
         assertNotNull(gears);
         assertTrue(gears.size() > 0);
         for (Gear gear : gears) {
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceWriteTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceWriteTest.java
index 8a3afc9..5febba4 100644
--- a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceWriteTest.java
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceWriteTest.java
@@ -28,6 +28,7 @@ import fr.ifremer.tutti.persistence.entities.data.Cruise;
 import fr.ifremer.tutti.persistence.entities.data.FishingOperation;
 import fr.ifremer.tutti.persistence.entities.data.IndividualObservationBatch;
 import fr.ifremer.tutti.persistence.entities.referential.Caracteristic;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
 import fr.ifremer.tutti.persistence.test.DatabaseResource;
 import org.apache.commons.collections4.CollectionUtils;
 import org.junit.Assert;
@@ -51,13 +52,13 @@ public class IndividualObservationBatchPersistenceServiceWriteTest {
 
     protected IndividualObservationBatchPersistenceService service;
 
-    protected ReferentialPersistenceService referentialService;
+    private CaracteristicPersistenceService caracteristicService;
 
     protected FishingOperation fishingOperation;
 
     @Before
     public void setUp() throws Exception {
-        referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService();
+        caracteristicService = TuttiPersistenceServiceLocator.getCaracteristicPersistenceService();
         service = TuttiPersistenceServiceLocator.getIndividualObservationBatchPersistenceService();
         Cruise cruise = dbResource.getFixtures().createCruise();
         fishingOperation = dbResource.getFixtures().createFishingOperation(cruise);
@@ -95,22 +96,22 @@ public class IndividualObservationBatchPersistenceServiceWriteTest {
         fullIndividualObservationBatch.setCaracteristics(caracteristicMap);
 
         // add a qualitative caracteristic
-        Caracteristic maturityCaracteristic = referentialService.getMaturityCaracteristic();
+        Caracteristic maturityCaracteristic = caracteristicService.getMaturityCaracteristic();
         caracteristicMap.put(maturityCaracteristic, maturityCaracteristic.getQualitativeValue(0));
 
         // add a numeric caracteristic
-        Caracteristic ageCaracteristic = referentialService.getAgeCaracteristic();
+        Caracteristic ageCaracteristic = caracteristicService.getAgeCaracteristic();
         caracteristicMap.put(ageCaracteristic, 10.f);
 
         // add a string caracteristic
-        Caracteristic stringCaracteristic = referentialService.getCaracteristic(dbResource.getFixtures().refAlphanumericPmfmId());
+        Caracteristic stringCaracteristic = caracteristicService.getCaracteristic(dbResource.getFixtures().refAlphanumericPmfmId());
         caracteristicMap.put(stringCaracteristic, "Un texte!");
 
         fullIndividualObservationBatch.setComment("IndividualObservationBatch-full");
 //        fullIndividualObservationBatch.setSamplingCode("SamplingCode");
 //        fullIndividualObservationBatch.setCalcifiedPieceSamplingCode("CalcifiedPieceSamplingCode");
 
-        fullIndividualObservationBatch.setLengthStepCaracteristic(referentialService.getCaracteristic(dbResource.getFixtures().refNumericalPmfmId()));
+        fullIndividualObservationBatch.setLengthStepCaracteristic(caracteristicService.getCaracteristic(dbResource.getFixtures().refNumericalPmfmId()));
         fullIndividualObservationBatch.setSize(10.0f);
         fullIndividualObservationBatch.setWeight(5.f);
 
@@ -156,8 +157,7 @@ public class IndividualObservationBatchPersistenceServiceWriteTest {
     public void deleteIndividualObservationBatch(/*String id*/) {
 
         IndividualObservationBatch createdIndividualObservationBatch =
-                dbResource.getFixtures().createMinimalIndividualObservationBatch(
-                        fishingOperation);
+                dbResource.getFixtures().createMinimalIndividualObservationBatch(fishingOperation);
 
         List<IndividualObservationBatch> allIndividualObservationBatch = service.getAllIndividualObservationBatch(fishingOperation.getId());
         Assert.assertFalse(CollectionUtils.isEmpty(allIndividualObservationBatch));
@@ -171,11 +171,9 @@ public class IndividualObservationBatchPersistenceServiceWriteTest {
     @Test
     public void deleteIndividualObservationBatchForFishingOperation(/*String fishingOperationId*/) {
 
-        dbResource.getFixtures().createMinimalIndividualObservationBatch(
-                fishingOperation);
+        dbResource.getFixtures().createMinimalIndividualObservationBatch(fishingOperation);
 
-        dbResource.getFixtures().createMinimalIndividualObservationBatch(
-                fishingOperation);
+        dbResource.getFixtures().createMinimalIndividualObservationBatch(fishingOperation);
 
         List<IndividualObservationBatch> allIndividualObservationBatch = service.getAllIndividualObservationBatch(fishingOperation.getId());
         Assert.assertFalse(CollectionUtils.isEmpty(allIndividualObservationBatch));
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceWriteTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceWriteTest.java
index 93d88f8..644976a 100644
--- a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceWriteTest.java
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceWriteTest.java
@@ -31,6 +31,8 @@ import fr.ifremer.tutti.persistence.entities.data.MarineLitterBatch;
 import fr.ifremer.tutti.persistence.entities.data.MarineLitterBatchs;
 import fr.ifremer.tutti.persistence.entities.referential.Caracteristic;
 import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.LocationPersistenceService;
 import fr.ifremer.tutti.persistence.test.DatabaseResource;
 import org.junit.Assert;
 import org.junit.Before;
@@ -82,11 +84,13 @@ public class MarineLitterBatchPersistenceServiceWriteTest {
         CruisePersistenceService cruiseService = TuttiPersistenceServiceLocator.getCruisePersistenceService();
         CatchBatchPersistenceService catchBatchService = TuttiPersistenceServiceLocator.getCatchBatchPersistenceService();
         FishingOperationPersistenceService fishingOperationService = TuttiPersistenceServiceLocator.getFishingOperationPersistenceService();
-        ReferentialPersistenceService referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService();
 
-        marineLitterCategoryCaracteristic = referentialService.getMarineLitterCategoryCaracteristic();
+        LocationPersistenceService locationService = TuttiPersistenceServiceLocator.getLocationPersistenceService();
+        CaracteristicPersistenceService caracteristicService = TuttiPersistenceServiceLocator.getCaracteristicPersistenceService();
 
-        marineLitterSizeCategoryCaracteristic = referentialService.getMarineLitterSizeCategoryCaracteristic();
+        marineLitterCategoryCaracteristic = caracteristicService.getMarineLitterCategoryCaracteristic();
+
+        marineLitterSizeCategoryCaracteristic = caracteristicService.getMarineLitterSizeCategoryCaracteristic();
 
         Cruise cruise = cruiseService.getCruise(dbResource.getFixtures().cruiseId());
         cruise.setId((String) null);
@@ -94,7 +98,7 @@ public class MarineLitterBatchPersistenceServiceWriteTest {
         cruise.setBeginDate(calendar.getTime());
         calendar.add(Calendar.MONTH, 1); // add one month
         cruise.setEndDate(calendar.getTime());
-        List<TuttiLocation> allHarbour = referentialService.getAllHarbour();
+        List<TuttiLocation> allHarbour = locationService.getAllHarbour();
         Assert.assertNotNull(allHarbour);
         Assert.assertTrue(allHarbour.size() > 1);
         cruise.setDepartureLocation(allHarbour.get(0));
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceWriteTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceWriteTest.java
index 92b302c..285be8b 100644
--- a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceWriteTest.java
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceWriteTest.java
@@ -25,6 +25,7 @@ package fr.ifremer.tutti.persistence.service;
 import fr.ifremer.tutti.persistence.entities.data.Program;
 import fr.ifremer.tutti.persistence.entities.data.Programs;
 import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation;
+import fr.ifremer.tutti.persistence.service.referential.LocationPersistenceService;
 import fr.ifremer.tutti.persistence.test.DatabaseResource;
 import org.junit.Before;
 import org.junit.ClassRule;
@@ -49,18 +50,18 @@ public class ProgramPersistenceServiceWriteTest {
 
     protected ProgramPersistenceService service;
 
-    protected ReferentialPersistenceService referentialService;
+    private LocationPersistenceService locationService;
 
     @Before
     public void setUp() throws Exception {
         service = TuttiPersistenceServiceLocator.getProgramPersistenceService();
-        referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService();
+        locationService = TuttiPersistenceServiceLocator.getLocationPersistenceService();
     }
 
     @Test
     public void createAndSaveProgram(/*Program bean*/) {
 
-        List<TuttiLocation> zones = referentialService.getAllProgramZone();
+        List<TuttiLocation> zones = locationService.getAllProgramZone();
         assertNotNull(zones);
         assertTrue(zones.size() > 0);
 
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceReadTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceReadTest.java
deleted file mode 100644
index 6168a10..0000000
--- a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceReadTest.java
+++ /dev/null
@@ -1,366 +0,0 @@
-package fr.ifremer.tutti.persistence.service;
-
-/*
- * #%L
- * Tutti :: Persistence
- * %%
- * Copyright (C) 2012 - 2014 Ifremer
- * %%
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as
- * published by the Free Software Foundation, either version 3 of the 
- * License, or (at your option) any later version.
- * 
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public 
- * License along with this program.  If not, see
- * <http://www.gnu.org/licenses/gpl-3.0.html>.
- * #L%
- */
-
-import fr.ifremer.adagio.core.service.technical.CacheService;
-import fr.ifremer.tutti.persistence.entities.TuttiEntities;
-import fr.ifremer.tutti.persistence.entities.TuttiEntity;
-import fr.ifremer.tutti.persistence.entities.referential.Caracteristic;
-import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue;
-import fr.ifremer.tutti.persistence.entities.referential.Caracteristics;
-import fr.ifremer.tutti.persistence.entities.referential.Gear;
-import fr.ifremer.tutti.persistence.entities.referential.ObjectType;
-import fr.ifremer.tutti.persistence.entities.referential.Person;
-import fr.ifremer.tutti.persistence.entities.referential.Species;
-import fr.ifremer.tutti.persistence.entities.referential.Speciess;
-import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation;
-import fr.ifremer.tutti.persistence.entities.referential.Vessel;
-import fr.ifremer.tutti.persistence.test.DatabaseFixtures;
-import fr.ifremer.tutti.persistence.test.DatabaseResource;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.ClassRule;
-import org.junit.Ignore;
-import org.junit.Test;
-
-import java.io.IOException;
-import java.util.List;
-
-/**
- * To test {@link ReferentialPersistenceService} for read operation.
- *
- * @author tchemit <chemit@codelutin.com>
- * @since 0.3
- */
-public class ReferentialPersistenceServiceReadTest {
-
-    @ClassRule
-    public static final DatabaseResource dbResource = DatabaseResource.readDb();
-
-    /** Logger. */
-    private static final Log log =
-            LogFactory.getLog(ReferentialPersistenceServiceReadTest.class);
-
-    protected ReferentialPersistenceService service;
-
-    protected CacheService cacheService;
-
-    protected DatabaseFixtures fixtures;
-
-    @BeforeClass
-    public static void beforeClass() throws IOException {
-
-        TuttiPersistenceServiceLocator.instance().getCacheService().clearAllCaches();
-    }
-
-    @Before
-    public void setUp() throws Exception {
-        service = TuttiPersistenceServiceLocator.getReferentialPersistenceService();
-        cacheService = TuttiPersistenceServiceLocator.instance().getCacheService();
-
-        // This is need for test : getAllFishingVessel()
-//        cacheService.clearAllCaches();
-        fixtures = dbResource.getFixtures();
-    }
-
-    @Test
-    public void getAllProgramZone() {
-        List<TuttiLocation> result = service.getAllProgramZone();
-        assertResultList(result, fixtures.refNbProgramZone());
-    }
-
-    @Test
-    public void getAllCountry() {
-        List<TuttiLocation> result = service.getAllCountry();
-        assertResultList(result, fixtures.refNbCountry());
-    }
-
-    @Test
-    public void getAllHarbour() {
-        List<TuttiLocation> result = service.getAllHarbour();
-        assertResultList(result, fixtures.refNbHarbour());
-    }
-
-    @Test
-    public void getAllObjectType() {
-        List<ObjectType> result = service.getAllObjectType();
-        assertResultList(result, fixtures.refNbObjectType());
-    }
-
-    @Test
-    public void getObjectType() {
-        ObjectType result = service.getObjectType(fixtures.objectTypeCode());
-        Assert.assertNotNull(result);
-    }
-
-    @Test
-    public void getAllFishingOperationStrata(/*String zoneId*/) {
-        String zoneId = dbResource.getFixtures().zoneId();
-        List<TuttiLocation> result =
-                service.getAllFishingOperationStrata(zoneId);
-        assertResultList(result, fixtures.refNbStrata());
-    }
-
-    @Test
-    public void getAllFishingOperationSubStrata(/*String zoneId, String strataId*/) {
-        String zoneId = dbResource.getFixtures().zoneId();
-        List<TuttiLocation> result =
-                service.getAllFishingOperationSubStrata(zoneId, null);
-        assertResultList(result, 0);
-
-        // try with a strataId
-        String strataId = dbResource.getFixtures().strataId();
-        result = service.getAllFishingOperationSubStrata(zoneId, strataId);
-        assertResultList(result, 0);
-    }
-
-    @Test
-    public void getAllFishingOperationLocation(/*String zoneId, String strataId, String subStrataId*/) {
-        String zoneId = dbResource.getFixtures().zoneId();
-        List<TuttiLocation> result =
-                service.getAllFishingOperationLocation(zoneId, null, null);
-        assertResultList(result, fixtures.refNbLocalite());
-
-        // try with a strataId
-        String strataId = dbResource.getFixtures().strataId();
-        result = service.getAllFishingOperationLocation(zoneId, strataId, null);
-        assertResultList(result, 1);
-
-        // try with a subStrataId
-        String subStrataId = dbResource.getFixtures().subStrataId();
-        result = service.getAllFishingOperationLocation(zoneId, strataId, subStrataId);
-        assertResultList(result, 3);
-    }
-
-    @Test
-    public void getAllScientificVessel() {
-        List<Vessel> result = service.getAllScientificVessel();
-        assertResultList(result, fixtures.refNbScientificVessel());
-    }
-
-    @Test
-    public void getAllFishingVessel() {
-
-        // clear cache before this test
-        cacheService.clearCache("fishingVessels");
-
-        long time = System.currentTimeMillis();
-        List<Vessel> result = service.getAllFishingVessel();
-        long delta1 = System.currentTimeMillis() - time;
-
-        assertResultList(result, fixtures.refNbFishingVessel());
-        log.debug("Load fishing vessels (without cache) in: " + delta1 + "ms");
-
-        // try again, to check cache is enable
-        time = System.currentTimeMillis();
-        result = service.getAllFishingVessel();
-        assertResultList(result, fixtures.refNbFishingVessel());
-
-        long delta2 = System.currentTimeMillis() - time;
-        log.debug("Load fishing vessels (with cache enable) in: " + delta2 + "ms");
-
-        //TODO-tc We should not test cache performance like this, depends to much of the computer usage,...
-//        float reduceFactor = delta2 * 100 / delta1;
-//        Assert.assertTrue("The cache on getAllFishingVessel() should have speed up more than factor 10. Make sure EhCache is well configured.", reduceFactor < 0.1);
-    }
-
-    @Test
-    public void getAllScientificGear() {
-        List<Gear> result = service.getAllScientificGear();
-        assertResultList(result, fixtures.refNbScientificGear());
-    }
-
-    @Test
-    public void getAllFishingGear() {
-        List<Gear> result = service.getAllFishingGear();
-        assertResultList(result, fixtures.refNbFishingGear());
-    }
-
-    @Test
-    public void getAllPerson() {
-        List<Person> result = service.getAllPerson();
-        assertResultList(result, fixtures.refNbPerson());
-    }
-
-    @Test
-    public void getAllSpecies() {
-        List<Species> result = service.getAllSpecies();
-        assertResultList(result, fixtures.refNbSpecies());
-    }
-
-    @Test
-    public void getAllReferentSpecies() {
-        List<Species> result = service.getAllReferentSpecies();
-        TuttiEntities.splitById(result);
-        assertResultList(result, fixtures.refNbReferentSpecies());
-
-        Speciess.splitByTaxonId(result);
-    }
-
-    @Test
-    public void getSpeciesByReferenceTaxonId(/*String speciesReferenceTaxonId*/) {
-        String speciesId = fixtures.refSpeciesId();
-        Integer taxonId = fixtures.refSpeciesTaxonId();
-        Species species = service.getSpeciesByReferenceTaxonId(taxonId);
-        Assert.assertNotNull(species);
-        Assert.assertNull(species.getVernacularCode());
-        Assert.assertEquals(speciesId, species.getId());
-        Assert.assertEquals(taxonId, species.getReferenceTaxonId());
-        Assert.assertEquals(fixtures.refSpeciesRefTaxCode(), species.getRefTaxCode());
-    }
-
-    @Test
-    public void getSpeciesByReferenceTaxonIdWithVernacularCode(/*String speciesReferenceTaxonId*/) {
-        String speciesId = fixtures.refSpeciesId();
-        Integer taxonId = fixtures.refSpeciesTaxonId();
-        Species species = service.getSpeciesByReferenceTaxonIdWithVernacularCode(taxonId);
-        Assert.assertNotNull(species);
-        Assert.assertNull(species.getRefTaxCode());
-        Assert.assertEquals(speciesId, species.getId());
-        Assert.assertEquals(taxonId, species.getReferenceTaxonId());
-        Assert.assertEquals(fixtures.refSpeciesVernacularCode(), species.getVernacularCode());
-    }
-
-    @Test
-    public void getBadSpeciesByReferenceTaxonId(/*String speciesReferenceTaxonId*/) {
-        Integer taxonId = fixtures.refBadSpeciesTaxonId();
-        service.getSpeciesByReferenceTaxonId(taxonId);
-    }
-
-    @Test
-    public void getBad2SpeciesByReferenceTaxonId(/*String speciesReferenceTaxonId*/) {
-        Integer taxonId = fixtures.refBad2SpeciesTaxonId();
-        service.getSpeciesByReferenceTaxonId(taxonId);
-    }
-
-    @Test
-    public void getAllCaracteristic() {
-        List<Caracteristic> result = service.getAllCaracteristic();
-        assertResultList(result, fixtures.refNbCaracteristic());
-    }
-
-    @Test
-    public void getSizeCategoryCaracteristic() {
-        Caracteristic result = service.getSizeCategoryCaracteristic();
-        assertCaracteristicQualitative(result, 6);
-    }
-
-    @Test
-    public void getSexCaracteristic() {
-        Caracteristic result = service.getSexCaracteristic();
-        assertCaracteristicQualitative(result, 4);
-    }
-
-    @Test
-    public void getSortedUnsortedCaracteristic() {
-        Caracteristic result = service.getSortedUnsortedCaracteristic();
-        assertCaracteristicQualitative(result, 2);
-    }
-
-    @Test
-    public void getMaturityCaracteristic() {
-        Caracteristic result = service.getMaturityCaracteristic();
-        assertCaracteristicQualitative(result, 6);
-    }
-
-    @Test
-    public void getMacroWasteCategoryCaracteristic() {
-        Caracteristic result = service.getMarineLitterCategoryCaracteristic();
-        assertCaracteristicQualitative(result, 34);
-    }
-
-    @Test
-    public void getMacroWasteSizeCategoryCaracteristic() {
-        Caracteristic result = service.getMarineLitterSizeCategoryCaracteristic();
-        assertCaracteristicQualitative(result, 7);
-    }
-
-    @Test(expected = UnsupportedOperationException.class)
-    public void getCaracteristicWithNullQualitativeValue() {
-        Caracteristic result = service.getCaracteristic(fixtures.caracteristicWithNullQualitativeValue());
-        assertCaracteristicQualitative(result, 2);
-        result.getQualitativeValue().add(null);
-    }
-
-    @Test
-    @Ignore
-    public void testCaches() {
-        cacheService.clearAllCaches();
-
-        Object obj = service.getAllCaracteristic();
-        System.out.println(obj);
-
-        obj = service.getCaracteristic(1429);
-        System.out.println(obj);
-
-        obj = service.getCaracteristic(1428);
-        System.out.println(obj);
-    }
-
-    protected void assertSize(List<?> expectedList, List<?> storageList) {
-        Assert.assertNotNull(expectedList);
-        Assert.assertNotNull(storageList);
-        expectedList.removeAll(storageList);
-        Assert.assertTrue("Some " + expectedList.size() + " entities were not persisted in storage :" +
-                          expectedList, expectedList.isEmpty());
-
-    }
-
-    protected void assertCaracteristicQualitative(Caracteristic result, int nbValues) {
-        Assert.assertNotNull(result);
-        Assert.assertNotNull(result.getCaracteristicType());
-        Assert.assertTrue(Caracteristics.isQualitativeCaracteristic(result));
-        Assert.assertNotNull(result.getQualitativeValue());
-        Assert.assertEquals(nbValues, result.sizeQualitativeValue());
-        for (CaracteristicQualitativeValue qualitativeValue : result.getQualitativeValue()) {
-            Assert.assertNotNull(qualitativeValue);
-        }
-    }
-
-    protected void assertCaracteristicSize(Caracteristic incoming,
-                                           Caracteristic caracteristic) {
-        Assert.assertNotNull(incoming);
-        Assert.assertNotNull(caracteristic);
-        Assert.assertEquals(incoming, caracteristic);
-        Assert.assertEquals(incoming.getCaracteristicType(),
-                            caracteristic.getCaracteristicType());
-        Assert.assertEquals(incoming.sizeQualitativeValue(),
-                            caracteristic.sizeQualitativeValue());
-    }
-
-    protected <E extends TuttiEntity> void assertResultList(List<E> result,
-                                                            int expectedsize) {
-
-        // result not null
-        Assert.assertNotNull(result);
-
-        // id are unique
-        TuttiEntities.splitById(result);
-
-        // correct size
-        Assert.assertEquals(expectedsize, result.size());
-    }
-}
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceWriteTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceWriteTest.java
index 077f862..bf05ca9 100644
--- a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceWriteTest.java
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceWriteTest.java
@@ -22,26 +22,10 @@ package fr.ifremer.tutti.persistence.service;
  * #L%
  */
 
-import com.google.common.collect.Lists;
-import fr.ifremer.tutti.persistence.entities.referential.Gear;
-import fr.ifremer.tutti.persistence.entities.referential.Gears;
-import fr.ifremer.tutti.persistence.entities.referential.Person;
-import fr.ifremer.tutti.persistence.entities.referential.Persons;
-import fr.ifremer.tutti.persistence.entities.referential.Species;
-import fr.ifremer.tutti.persistence.entities.referential.Speciess;
-import fr.ifremer.tutti.persistence.entities.referential.Vessel;
-import fr.ifremer.tutti.persistence.entities.referential.Vessels;
 import fr.ifremer.tutti.persistence.test.DatabaseResource;
-import org.junit.Assert;
-import org.junit.Before;
 import org.junit.ClassRule;
-import org.junit.Test;
-
-import java.util.List;
 
 /**
- * To test {@link ReferentialPersistenceService} for write operation.
- *
  * @author tchemit <chemit@codelutin.com>
  * @since 1.0
  */
@@ -50,230 +34,4 @@ public class ReferentialPersistenceServiceWriteTest {
     @ClassRule
     public static final DatabaseResource dbResource = DatabaseResource.writeDb();
 
-    protected ReferentialPersistenceService service;
-
-    @Before
-    public void setUp() throws Exception {
-        service = TuttiPersistenceServiceLocator.getReferentialPersistenceService();
-    }
-
-    @Test
-    public void importSpecies() {
-        List<Species> species = Lists.newArrayList();
-
-        long timestamp1 = System.nanoTime();
-        Species sp1 = Speciess.newSpecies();
-        sp1.setReferenceTaxonId((int) timestamp1);
-        sp1.setId("Don't care" + timestamp1);
-        sp1.setRefTaxCode("Don't care" + timestamp1);
-        sp1.setSurveyCode("Don't care" + timestamp1);
-        sp1.setName("Genus name" + timestamp1);
-        species.add(sp1);
-
-        long timestamp2 = System.nanoTime();
-        Species sp2 = Speciess.newSpecies();
-        sp2.setReferenceTaxonId((int) timestamp2);
-        sp2.setId("Don't care" + timestamp2);
-        sp2.setRefTaxCode("Don't care" + timestamp2);
-        sp2.setSurveyCode("Don't care" + timestamp2);
-        sp2.setName("Genus name" + timestamp2);
-        species.add(sp2);
-
-        Assert.assertNull(service.getSpeciesByReferenceTaxonId(sp1.getReferenceTaxonId()));
-        //Assert.assertNull(service.getSpecies(sp2.getId()));
-
-        List<Species> speciesList = service.importTemporarySpecies(species);
-        Assert.assertNotNull(speciesList);
-        Assert.assertEquals(2, speciesList.size());
-
-        Species createdSp1 = speciesList.get(0);
-        Assert.assertNotNull(createdSp1);
-        Assert.assertEquals(sp1.getName(), createdSp1.getName());
-        // TODO TC :question pour TC  pourquoi faire le test suivant NotNull, car tu n'a rien mis en entree de ce code ?
-        // faut-il que le genere ? 
-        //Assert.assertNotNull(createdSp1.getExternalCode());
-        //Assert.assertNotSame(sp1.getExternalCode(), createdSp1.getExternalCode());
-        Assert.assertNull(createdSp1.getSurveyCode());
-        Assert.assertNotNull(createdSp1.getId());
-        Assert.assertNotSame(sp1.getId(), createdSp1.getId());
-        Assert.assertEquals(createdSp1, service.getSpeciesByReferenceTaxonId(createdSp1.getReferenceTaxonId()));
-
-        Species createdSp2 = speciesList.get(1);
-        Assert.assertNotNull(createdSp2);
-        Assert.assertEquals(sp2.getName(), createdSp2.getName());
-        Assert.assertTrue(createdSp2.isReferenceTaxon());
-        Assert.assertNotSame(sp2.getReferenceTaxonId(), createdSp2.getReferenceTaxonId());
-        Assert.assertNull(createdSp2.getRefTaxCode());
-        Assert.assertNull(createdSp2.getSurveyCode());
-        Assert.assertNotNull(createdSp2.getId());
-        Assert.assertNotSame(sp2.getId(), createdSp2.getId());
-        Assert.assertEquals(createdSp2, service.getSpeciesByReferenceTaxonId(createdSp2.getReferenceTaxonId()));
-    }
-
-    @Test
-    public void importVessel() {
-        List<Vessel> vessels = Lists.newArrayList();
-
-        // scientificVessel
-        long timestamp1 = System.nanoTime();
-        Vessel v1 = Vessels.newVessel();
-        v1.setId("Don't care" + timestamp1);
-        v1.setName("Name" + timestamp1);
-        v1.setInternationalRegistrationCode("Immat" + timestamp1);
-        v1.setScientificVessel(true);
-        vessels.add(v1);
-
-        // fishingVessel
-        long timestamp2 = System.nanoTime();
-        Vessel v2 = Vessels.newVessel();
-        v2.setId("Don't care" + timestamp2);
-        v2.setName("Name" + timestamp2);
-        v2.setInternationalRegistrationCode("Immat" + timestamp2);
-        v2.setScientificVessel(false);
-        vessels.add(v2);
-
-        Assert.assertNull(service.getVessel(v1.getId()));
-        Assert.assertNull(service.getVessel(v2.getId()));
-
-        List<Vessel> vesselList = service.importTemporaryVessel(vessels);
-
-        Assert.assertNotNull(vesselList);
-        Assert.assertEquals(2, vesselList.size());
-
-        List<Vessel> allScientificVessel = service.getAllScientificVessel();
-        List<Vessel> allFishingVessel = service.getAllFishingVessel();
-
-        Vessel createdV1 = vesselList.get(0);
-        Assert.assertNotNull(createdV1);
-        Assert.assertEquals(v1.getName(), createdV1.getName());
-        Assert.assertEquals(v1.getInternationalRegistrationCode(), createdV1.getInternationalRegistrationCode());
-        Assert.assertNotNull(createdV1.getId());
-        Assert.assertNotSame(v1.getId(), createdV1.getId());
-        Assert.assertEquals(createdV1, service.getVessel(createdV1.getId()));
-
-        Assert.assertTrue(allScientificVessel.contains(createdV1));
-        Assert.assertFalse(allFishingVessel.contains(createdV1));
-
-        Vessel createdV2 = vesselList.get(1);
-        Assert.assertNotNull(createdV2);
-        Assert.assertEquals(v2.getName(), createdV2.getName());
-        Assert.assertEquals(v2.getInternationalRegistrationCode(), createdV2.getInternationalRegistrationCode());
-        Assert.assertNotNull(createdV2.getId());
-        Assert.assertNotSame(v2.getId(), createdV2.getId());
-        Assert.assertEquals(createdV2, service.getVessel(createdV2.getId()));
-        Assert.assertFalse(allScientificVessel.contains(createdV2));
-        Assert.assertTrue(allFishingVessel.contains(createdV2));
-    }
-
-    @Test
-    public void importPerson() {
-        List<Person> persons = Lists.newArrayList();
-
-        long timestamp1 = System.nanoTime();
-        Person p1 = Persons.newPerson();
-        p1.setId("Don't care" + timestamp1);
-        p1.setName("Don't care" + timestamp1);
-        p1.setFirstName("FirstName" + timestamp1);
-        p1.setLastName("MastName" + timestamp1);
-        p1.setDescription("Dont care" + timestamp1);
-        p1.setDescription("Dont care" + timestamp1);
-        persons.add(p1);
-
-        long timestamp2 = System.nanoTime();
-        Person p2 = Persons.newPerson();
-        p2.setId("Don't care" + timestamp2);
-        p2.setName("Don't care" + timestamp2);
-        p2.setFirstName("FirstName" + timestamp2);
-        p2.setLastName("LastName" + timestamp2);
-        p2.setDescription("Don't care" + timestamp2);
-        p2.setDepartment("Don't care" + timestamp2);
-        persons.add(p2);
-
-        List<Person> personList = service.importTemporaryPerson(persons);
-
-        Assert.assertNotNull(personList);
-        Assert.assertEquals(2, personList.size());
-
-        Person createdP1 = personList.get(0);
-        Assert.assertNotNull(createdP1);
-        Assert.assertEquals(p1.getFirstName(), createdP1.getFirstName());
-        Assert.assertEquals(p1.getLastName(), createdP1.getLastName());
-
-        Assert.assertNull(createdP1.getName());
-        Assert.assertNull(createdP1.getDepartment());
-        Assert.assertNull(createdP1.getDescription());
-
-        Assert.assertNotNull(createdP1.getId());
-        Assert.assertNotSame(p1.getId(), createdP1.getId());
-
-        Assert.assertEquals(createdP1, service.getPerson(Integer.valueOf(createdP1.getId())));
-
-
-        Person createdP2 = personList.get(1);
-        Assert.assertNotNull(createdP2);
-        Assert.assertEquals(p2.getFirstName(), createdP2.getFirstName());
-        Assert.assertEquals(p2.getLastName(), createdP2.getLastName());
-
-        Assert.assertNull(createdP1.getName());
-        Assert.assertNull(createdP1.getDepartment());
-        Assert.assertNull(createdP1.getDescription());
-
-        Assert.assertNotNull(createdP2.getId());
-        Assert.assertNotSame(p2.getId(), createdP2.getId());
-
-        Assert.assertEquals(createdP2, service.getPerson(Integer.valueOf(createdP2.getId())));
-    }
-
-    @Test
-    public void importGear() {
-        List<Gear> gears = Lists.newArrayList();
-
-        // scientific gear
-        long timestamp1 = System.nanoTime();
-        Gear g1 = Gears.newGear();
-        g1.setId("Don't care" + timestamp1);
-        g1.setDescription("Don't care" + timestamp1);
-        g1.setName("Name" + timestamp1);
-        g1.setLabel("Label" + timestamp1);
-        g1.setScientificGear(true);
-        gears.add(g1);
-
-        // fishing gear
-        long timestamp2 = System.nanoTime();
-        Gear g2 = Gears.newGear();
-        g2.setId("Don't care" + timestamp2);
-        g2.setDescription("Don't care" + timestamp2);
-        g2.setName("Name" + timestamp2);
-        g2.setLabel("Label" + timestamp2);
-        g2.setScientificGear(false);
-
-        gears.add(g2);
-
-        List<Gear> gearList = service.importTemporaryGear(gears);
-
-        List<Gear> allScientificGear = service.getAllScientificGear();
-        List<Gear> allFishingGear = service.getAllFishingGear();
-
-        Gear createdG1 = gearList.get(0);
-        Assert.assertNotNull(createdG1);
-        Assert.assertEquals(g1.getName(), createdG1.getName());
-        Assert.assertEquals(g1.getLabel(), createdG1.getLabel());
-
-        Assert.assertNotNull(createdG1.getId());
-        Assert.assertNotSame(g1.getId(), createdG1.getId());
-        Assert.assertEquals(createdG1, service.getGear(Integer.valueOf(createdG1.getId())));
-        Assert.assertTrue(allScientificGear.contains(createdG1));
-        Assert.assertFalse(allFishingGear.contains(createdG1));
-
-        Gear createdG2 = gearList.get(1);
-        Assert.assertNotNull(createdG2);
-        Assert.assertEquals(g2.getName(), createdG2.getName());
-        Assert.assertEquals(g2.getLabel(), createdG2.getLabel());
-
-        Assert.assertNotNull(createdG2.getId());
-        Assert.assertNotSame(g2.getId(), createdG2.getId());
-        Assert.assertEquals(createdG2, service.getGear(Integer.valueOf(createdG2.getId())));
-        Assert.assertFalse(allScientificGear.contains(createdG2));
-        Assert.assertTrue(allFishingGear.contains(createdG2));
-    }
 }
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceWriteTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceWriteTest.java
index 1b90972..442c5f3 100644
--- a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceWriteTest.java
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceWriteTest.java
@@ -39,6 +39,9 @@ import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativ
 import fr.ifremer.tutti.persistence.entities.referential.CaracteristicType;
 import fr.ifremer.tutti.persistence.entities.referential.Species;
 import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation;
+import fr.ifremer.tutti.persistence.service.referential.CaracteristicPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.LocationPersistenceService;
+import fr.ifremer.tutti.persistence.service.referential.SpeciesPersistenceService;
 import fr.ifremer.tutti.persistence.test.DatabaseResource;
 import org.junit.Assert;
 import org.junit.Before;
@@ -112,9 +115,11 @@ public class SpeciesBatchPersistenceServiceWriteTest {
         CruisePersistenceService cruiseService = TuttiPersistenceServiceLocator.getCruisePersistenceService();
         CatchBatchPersistenceService catchBatchService = TuttiPersistenceServiceLocator.getCatchBatchPersistenceService();
         FishingOperationPersistenceService fishingOperationService = TuttiPersistenceServiceLocator.getFishingOperationPersistenceService();
-        ReferentialPersistenceService referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService();
+        SpeciesPersistenceService speciesService = TuttiPersistenceServiceLocator.getSpeciesPersistenceService();
+        LocationPersistenceService locationService = TuttiPersistenceServiceLocator.getLocationPersistenceService();
+        CaracteristicPersistenceService caracteristicService = TuttiPersistenceServiceLocator.getCaracteristicPersistenceService();
 
-        species = referentialService.getAllSpecies();
+        species = speciesService.getAllSpecies();
         assertNotNull(species);
         assertTrue(species.size() > 2);
 
@@ -124,7 +129,7 @@ public class SpeciesBatchPersistenceServiceWriteTest {
         cruise.setBeginDate(calendar.getTime());
         calendar.add(Calendar.MONTH, 1); // add one month
         cruise.setEndDate(calendar.getTime());
-        List<TuttiLocation> allHarbour = referentialService.getAllHarbour();
+        List<TuttiLocation> allHarbour = locationService.getAllHarbour();
         Assert.assertNotNull(allHarbour);
         Assert.assertTrue(allHarbour.size() > 1);
         cruise.setDepartureLocation(allHarbour.get(0));
@@ -169,17 +174,17 @@ public class SpeciesBatchPersistenceServiceWriteTest {
         catchBacth.setFishingOperation(fishingOperationWithEmptyBatch);
         catchBacth = catchBatchService.createCatchBatch(catchBacth);
 
-        sortedUnsortedPMFM = referentialService.getSortedUnsortedCaracteristic();
+        sortedUnsortedPMFM = caracteristicService.getSortedUnsortedCaracteristic();
         horsVracQualitativeValue = sortedUnsortedPMFM.getQualitativeValue(0);
         vracQualitativeValue = sortedUnsortedPMFM.getQualitativeValue(1);
-        maturityPMFM = referentialService.getMaturityCaracteristic();
+        maturityPMFM = caracteristicService.getMaturityCaracteristic();
         firstMaturityQualitativeValue = maturityPMFM.getQualitativeValue(0);
-        sexPMFM = referentialService.getSexCaracteristic();
+        sexPMFM = caracteristicService.getSexCaracteristic();
         maleQualitativeValue = sexPMFM.getQualitativeValue(1);
         femaleQualitativeValue = sexPMFM.getQualitativeValue(2);
         unkQualitativeValue = sexPMFM.getQualitativeValue(3);
 
-        List<Caracteristic> cara = referentialService.getAllCaracteristic();
+        List<Caracteristic> cara = caracteristicService.getAllCaracteristic();
         for (Caracteristic caracteristic : cara) {
             if (caracteristic.getCaracteristicType() == CaracteristicType.NUMBER
                 && caracteristic.getPrecision() != null
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/CaracteristicPersistenceServiceReadTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/CaracteristicPersistenceServiceReadTest.java
new file mode 100644
index 0000000..a85265d
--- /dev/null
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/CaracteristicPersistenceServiceReadTest.java
@@ -0,0 +1,94 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import fr.ifremer.tutti.persistence.entities.referential.Caracteristic;
+import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue;
+import fr.ifremer.tutti.persistence.entities.referential.Caracteristics;
+import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+public class CaracteristicPersistenceServiceReadTest extends ReferentialPersistenceServiceReadTestSupport {
+
+    protected CaracteristicPersistenceService service;
+
+    @Before
+    public void setUp() throws Exception {
+        service = TuttiPersistenceServiceLocator.getCaracteristicPersistenceService();
+        super.setUp();
+    }
+
+    @Test
+    public void getAllCaracteristic() {
+        List<Caracteristic> result = service.getAllCaracteristic();
+        assertResultList(result, fixtures.refNbCaracteristic());
+    }
+
+    @Test
+    public void getSizeCategoryCaracteristic() {
+        Caracteristic result = service.getSizeCategoryCaracteristic();
+        assertCaracteristicQualitative(result, 6);
+    }
+
+    @Test
+    public void getSexCaracteristic() {
+        Caracteristic result = service.getSexCaracteristic();
+        assertCaracteristicQualitative(result, 4);
+    }
+
+    @Test
+    public void getSortedUnsortedCaracteristic() {
+        Caracteristic result = service.getSortedUnsortedCaracteristic();
+        assertCaracteristicQualitative(result, 2);
+    }
+
+    @Test
+    public void getMaturityCaracteristic() {
+        Caracteristic result = service.getMaturityCaracteristic();
+        assertCaracteristicQualitative(result, 6);
+    }
+
+    @Test
+    public void getMacroWasteCategoryCaracteristic() {
+        Caracteristic result = service.getMarineLitterCategoryCaracteristic();
+        assertCaracteristicQualitative(result, 34);
+    }
+
+    @Test
+    public void getMacroWasteSizeCategoryCaracteristic() {
+        Caracteristic result = service.getMarineLitterSizeCategoryCaracteristic();
+        assertCaracteristicQualitative(result, 7);
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void getCaracteristicWithNullQualitativeValue() {
+        Caracteristic result = service.getCaracteristic(fixtures.caracteristicWithNullQualitativeValue());
+        assertCaracteristicQualitative(result, 2);
+        result.getQualitativeValue().add(null);
+    }
+
+    protected void assertCaracteristicQualitative(Caracteristic result, int nbValues) {
+        Assert.assertNotNull(result);
+        Assert.assertNotNull(result.getCaracteristicType());
+        Assert.assertTrue(Caracteristics.isQualitativeCaracteristic(result));
+        Assert.assertNotNull(result.getQualitativeValue());
+        Assert.assertEquals(nbValues, result.sizeQualitativeValue());
+        for (CaracteristicQualitativeValue qualitativeValue : result.getQualitativeValue()) {
+            Assert.assertNotNull(qualitativeValue);
+        }
+    }
+
+    protected void assertCaracteristicSize(Caracteristic incoming,
+                                           Caracteristic caracteristic) {
+        Assert.assertNotNull(incoming);
+        Assert.assertNotNull(caracteristic);
+        Assert.assertEquals(incoming, caracteristic);
+        Assert.assertEquals(incoming.getCaracteristicType(),
+                            caracteristic.getCaracteristicType());
+        Assert.assertEquals(incoming.sizeQualitativeValue(),
+                            caracteristic.sizeQualitativeValue());
+    }
+
+}
\ No newline at end of file
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/GearPersistenceServiceReadTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/GearPersistenceServiceReadTest.java
new file mode 100644
index 0000000..920db65
--- /dev/null
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/GearPersistenceServiceReadTest.java
@@ -0,0 +1,37 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import fr.ifremer.tutti.persistence.entities.referential.Gear;
+import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.List;
+
+public class GearPersistenceServiceReadTest extends ReferentialPersistenceServiceReadTestSupport {
+
+    protected GearPersistenceService service;
+
+    @Before
+    public void setUp() throws Exception {
+        service = TuttiPersistenceServiceLocator.getGearPersistenceService();
+        super.setUp();
+
+    }
+
+    @Test
+    public void getAllScientificGear() {
+        List<Gear> result = service.getAllScientificGear();
+        assertResultList(result, fixtures.refNbScientificGear());
+    }
+
+    @Test
+    public void getAllFishingGear() {
+        List<Gear> result = service.getAllFishingGear();
+        assertResultList(result, fixtures.refNbFishingGear());
+    }
+
+}
\ No newline at end of file
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/GearPersistenceServiceWriteTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/GearPersistenceServiceWriteTest.java
new file mode 100644
index 0000000..ac22a46
--- /dev/null
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/GearPersistenceServiceWriteTest.java
@@ -0,0 +1,80 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import com.google.common.collect.Lists;
+import fr.ifremer.tutti.persistence.entities.referential.Gear;
+import fr.ifremer.tutti.persistence.entities.referential.Gears;
+import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+public class GearPersistenceServiceWriteTest extends ReferentialPersistenceServiceWriteTestSupport {
+
+    protected GearPersistenceService service;
+
+    @Before
+    public void setUp() throws Exception {
+        service = TuttiPersistenceServiceLocator.getGearPersistenceService();
+    }
+
+    @Test
+    public void importGear() {
+        List<Gear> gears = Lists.newArrayList();
+
+        // scientific gear
+        long timestamp1 = System.nanoTime();
+        Gear g1 = Gears.newGear();
+        g1.setId("Don't care" + timestamp1);
+        g1.setDescription("Don't care" + timestamp1);
+        g1.setName("Name" + timestamp1);
+        g1.setLabel("Label" + timestamp1);
+        g1.setScientificGear(true);
+        gears.add(g1);
+
+        // fishing gear
+        long timestamp2 = System.nanoTime();
+        Gear g2 = Gears.newGear();
+        g2.setId("Don't care" + timestamp2);
+        g2.setDescription("Don't care" + timestamp2);
+        g2.setName("Name" + timestamp2);
+        g2.setLabel("Label" + timestamp2);
+        g2.setScientificGear(false);
+
+        gears.add(g2);
+
+        List<Gear> gearList = service.importTemporaryGear(gears);
+
+        List<Gear> allScientificGear = service.getAllScientificGear();
+        List<Gear> allFishingGear = service.getAllFishingGear();
+
+        Gear createdG1 = gearList.get(0);
+        Assert.assertNotNull(createdG1);
+        Assert.assertEquals(g1.getName(), createdG1.getName());
+        Assert.assertEquals(g1.getLabel(), createdG1.getLabel());
+
+        Assert.assertNotNull(createdG1.getId());
+        Assert.assertNotSame(g1.getId(), createdG1.getId());
+        Assert.assertEquals(createdG1, service.getGear(Integer.valueOf(createdG1.getId())));
+        Assert.assertTrue(allScientificGear.contains(createdG1));
+        Assert.assertFalse(allFishingGear.contains(createdG1));
+
+        Gear createdG2 = gearList.get(1);
+        Assert.assertNotNull(createdG2);
+        Assert.assertEquals(g2.getName(), createdG2.getName());
+        Assert.assertEquals(g2.getLabel(), createdG2.getLabel());
+
+        Assert.assertNotNull(createdG2.getId());
+        Assert.assertNotSame(g2.getId(), createdG2.getId());
+        Assert.assertEquals(createdG2, service.getGear(Integer.valueOf(createdG2.getId())));
+        Assert.assertFalse(allScientificGear.contains(createdG2));
+        Assert.assertTrue(allFishingGear.contains(createdG2));
+    }
+}
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/LocationPersistenceServiceReadTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/LocationPersistenceServiceReadTest.java
new file mode 100644
index 0000000..e57e683
--- /dev/null
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/LocationPersistenceServiceReadTest.java
@@ -0,0 +1,77 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation;
+import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+public class LocationPersistenceServiceReadTest extends ReferentialPersistenceServiceReadTestSupport {
+
+    protected LocationPersistenceService service;
+
+    @Before
+    public void setUp() throws Exception {
+        service = TuttiPersistenceServiceLocator.getLocationPersistenceService();
+        super.setUp();
+    }
+
+    @Test
+    public void getAllProgramZone() {
+        List<TuttiLocation> result = service.getAllProgramZone();
+        assertResultList(result, fixtures.refNbProgramZone());
+    }
+
+    @Test
+    public void getAllCountry() {
+        List<TuttiLocation> result = service.getAllCountry();
+        assertResultList(result, fixtures.refNbCountry());
+    }
+
+    @Test
+    public void getAllHarbour() {
+        List<TuttiLocation> result = service.getAllHarbour();
+        assertResultList(result, fixtures.refNbHarbour());
+    }
+
+    @Test
+    public void getAllFishingOperationStrata(/*String zoneId*/) {
+        String zoneId = dbResource.getFixtures().zoneId();
+        List<TuttiLocation> result =
+                service.getAllFishingOperationStrata(zoneId);
+        assertResultList(result, fixtures.refNbStrata());
+    }
+
+    @Test
+    public void getAllFishingOperationSubStrata(/*String zoneId, String strataId*/) {
+        String zoneId = dbResource.getFixtures().zoneId();
+        List<TuttiLocation> result =
+                service.getAllFishingOperationSubStrata(zoneId, null);
+        assertResultList(result, 0);
+
+        // try with a strataId
+        String strataId = dbResource.getFixtures().strataId();
+        result = service.getAllFishingOperationSubStrata(zoneId, strataId);
+        assertResultList(result, 0);
+    }
+
+    @Test
+    public void getAllFishingOperationLocation(/*String zoneId, String strataId, String subStrataId*/) {
+        String zoneId = dbResource.getFixtures().zoneId();
+        List<TuttiLocation> result =
+                service.getAllFishingOperationLocation(zoneId, null, null);
+        assertResultList(result, fixtures.refNbLocalite());
+
+        // try with a strataId
+        String strataId = dbResource.getFixtures().strataId();
+        result = service.getAllFishingOperationLocation(zoneId, strataId, null);
+        assertResultList(result, 1);
+
+        // try with a subStrataId
+        String subStrataId = dbResource.getFixtures().subStrataId();
+        result = service.getAllFishingOperationLocation(zoneId, strataId, subStrataId);
+        assertResultList(result, 3);
+    }
+
+}
\ No newline at end of file
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/ObjectTypePersistenceServiceReadTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/ObjectTypePersistenceServiceReadTest.java
new file mode 100644
index 0000000..ae29732
--- /dev/null
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/ObjectTypePersistenceServiceReadTest.java
@@ -0,0 +1,33 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import fr.ifremer.tutti.persistence.entities.referential.ObjectType;
+import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+public class ObjectTypePersistenceServiceReadTest extends ReferentialPersistenceServiceReadTestSupport {
+
+    protected ObjectTypePersistenceService service;
+
+    @Before
+    public void setUp() throws Exception {
+        service = TuttiPersistenceServiceLocator.getObjectTypePersistenceService();
+        super.setUp();
+    }
+
+    @Test
+    public void getAllObjectType() {
+        List<ObjectType> result = service.getAllObjectType();
+        assertResultList(result, fixtures.refNbObjectType());
+    }
+
+    @Test
+    public void getObjectType() {
+        ObjectType result = service.getObjectType(fixtures.objectTypeCode());
+        Assert.assertNotNull(result);
+    }
+
+}
\ No newline at end of file
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/PersonPersistenceServiceReadTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/PersonPersistenceServiceReadTest.java
new file mode 100644
index 0000000..d8420e1
--- /dev/null
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/PersonPersistenceServiceReadTest.java
@@ -0,0 +1,26 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import fr.ifremer.tutti.persistence.entities.referential.Person;
+import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+public class PersonPersistenceServiceReadTest extends ReferentialPersistenceServiceReadTestSupport {
+
+    protected PersonPersistenceService service;
+
+    @Before
+    public void setUp() throws Exception {
+        service = TuttiPersistenceServiceLocator.getPersonPersistenceService();
+        super.setUp();
+    }
+
+    @Test
+    public void getAllPerson() {
+        List<Person> result = service.getAllPerson();
+        assertResultList(result, fixtures.refNbPerson());
+    }
+
+}
\ No newline at end of file
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/PersonPersistenceServiceWriteTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/PersonPersistenceServiceWriteTest.java
new file mode 100644
index 0000000..0f1550c
--- /dev/null
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/PersonPersistenceServiceWriteTest.java
@@ -0,0 +1,87 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import com.google.common.collect.Lists;
+import fr.ifremer.tutti.persistence.entities.referential.Person;
+import fr.ifremer.tutti.persistence.entities.referential.Persons;
+import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+public class PersonPersistenceServiceWriteTest extends ReferentialPersistenceServiceWriteTestSupport {
+
+    protected PersonPersistenceService service;
+
+    @Before
+    public void setUp() throws Exception {
+        service = TuttiPersistenceServiceLocator.getPersonPersistenceService();
+    }
+
+    @Test
+    public void importPerson() {
+        List<Person> persons = Lists.newArrayList();
+
+        long timestamp1 = System.nanoTime();
+        Person p1 = Persons.newPerson();
+        p1.setId("Don't care" + timestamp1);
+        p1.setName("Don't care" + timestamp1);
+        p1.setFirstName("FirstName" + timestamp1);
+        p1.setLastName("MastName" + timestamp1);
+        p1.setDescription("Dont care" + timestamp1);
+        p1.setDescription("Dont care" + timestamp1);
+        persons.add(p1);
+
+        long timestamp2 = System.nanoTime();
+        Person p2 = Persons.newPerson();
+        p2.setId("Don't care" + timestamp2);
+        p2.setName("Don't care" + timestamp2);
+        p2.setFirstName("FirstName" + timestamp2);
+        p2.setLastName("LastName" + timestamp2);
+        p2.setDescription("Don't care" + timestamp2);
+        p2.setDepartment("Don't care" + timestamp2);
+        persons.add(p2);
+
+        List<Person> personList = service.importTemporaryPerson(persons);
+
+        Assert.assertNotNull(personList);
+        Assert.assertEquals(2, personList.size());
+
+        Person createdP1 = personList.get(0);
+        Assert.assertNotNull(createdP1);
+        Assert.assertEquals(p1.getFirstName(), createdP1.getFirstName());
+        Assert.assertEquals(p1.getLastName(), createdP1.getLastName());
+
+        Assert.assertNull(createdP1.getName());
+        Assert.assertNull(createdP1.getDepartment());
+        Assert.assertNull(createdP1.getDescription());
+
+        Assert.assertNotNull(createdP1.getId());
+        Assert.assertNotSame(p1.getId(), createdP1.getId());
+
+        Assert.assertEquals(createdP1, service.getPerson(Integer.valueOf(createdP1.getId())));
+
+
+        Person createdP2 = personList.get(1);
+        Assert.assertNotNull(createdP2);
+        Assert.assertEquals(p2.getFirstName(), createdP2.getFirstName());
+        Assert.assertEquals(p2.getLastName(), createdP2.getLastName());
+
+        Assert.assertNull(createdP1.getName());
+        Assert.assertNull(createdP1.getDepartment());
+        Assert.assertNull(createdP1.getDescription());
+
+        Assert.assertNotNull(createdP2.getId());
+        Assert.assertNotSame(p2.getId(), createdP2.getId());
+
+        Assert.assertEquals(createdP2, service.getPerson(Integer.valueOf(createdP2.getId())));
+    }
+
+}
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/ReferentialPersistenceServiceReadTestSupport.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/ReferentialPersistenceServiceReadTestSupport.java
new file mode 100644
index 0000000..b26bee1
--- /dev/null
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/ReferentialPersistenceServiceReadTestSupport.java
@@ -0,0 +1,64 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import fr.ifremer.adagio.core.service.technical.CacheService;
+import fr.ifremer.tutti.persistence.entities.TuttiEntities;
+import fr.ifremer.tutti.persistence.entities.TuttiEntity;
+import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator;
+import fr.ifremer.tutti.persistence.test.DatabaseFixtures;
+import fr.ifremer.tutti.persistence.test.DatabaseResource;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.ClassRule;
+
+import java.io.IOException;
+import java.util.List;
+
+public abstract class ReferentialPersistenceServiceReadTestSupport {
+
+
+    @ClassRule
+    public static final DatabaseResource dbResource = DatabaseResource.readDb();
+
+    protected CacheService cacheService;
+
+    protected DatabaseFixtures fixtures;
+
+    @BeforeClass
+    public static void beforeClass() throws IOException {
+
+        TuttiPersistenceServiceLocator.instance().getCacheService().clearAllCaches();
+    }
+
+    @Before
+    public void setUp() throws Exception {
+        cacheService = TuttiPersistenceServiceLocator.instance().getCacheService();
+
+        // This is need for test : getAllFishingVessel()
+//        cacheService.clearAllCaches();
+        fixtures = dbResource.getFixtures();
+    }
+
+
+    protected void assertSize(List<?> expectedList, List<?> storageList) {
+        Assert.assertNotNull(expectedList);
+        Assert.assertNotNull(storageList);
+        expectedList.removeAll(storageList);
+        Assert.assertTrue("Some " + expectedList.size() + " entities were not persisted in storage :" +
+                          expectedList, expectedList.isEmpty());
+
+    }
+
+    protected <E extends TuttiEntity> void assertResultList(List<E> result,
+                                                            int expectedsize) {
+
+        // result not null
+        Assert.assertNotNull(result);
+
+        // id are unique
+        TuttiEntities.splitById(result);
+
+        // correct size
+        Assert.assertEquals(expectedsize, result.size());
+    }
+}
\ No newline at end of file
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/ReferentialPersistenceServiceWriteTestSupport.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/ReferentialPersistenceServiceWriteTestSupport.java
new file mode 100644
index 0000000..0da0328
--- /dev/null
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/ReferentialPersistenceServiceWriteTestSupport.java
@@ -0,0 +1,11 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import fr.ifremer.tutti.persistence.test.DatabaseResource;
+import org.junit.ClassRule;
+
+public abstract class ReferentialPersistenceServiceWriteTestSupport {
+
+    @ClassRule
+    public static final DatabaseResource dbResource = DatabaseResource.writeDb();
+
+}
\ No newline at end of file
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/SpeciesPersistenceServiceReadTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/SpeciesPersistenceServiceReadTest.java
new file mode 100644
index 0000000..96aedff
--- /dev/null
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/SpeciesPersistenceServiceReadTest.java
@@ -0,0 +1,75 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import fr.ifremer.tutti.persistence.entities.TuttiEntities;
+import fr.ifremer.tutti.persistence.entities.referential.Species;
+import fr.ifremer.tutti.persistence.entities.referential.Speciess;
+import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+public class SpeciesPersistenceServiceReadTest extends ReferentialPersistenceServiceReadTestSupport {
+
+    protected SpeciesPersistenceService service;
+
+    @Before
+    public void setUp() throws Exception {
+        service = TuttiPersistenceServiceLocator.getSpeciesPersistenceService();
+        super.setUp();
+
+    }
+
+    @Test
+    public void getAllSpecies() {
+        List<Species> result = service.getAllSpecies();
+        assertResultList(result, fixtures.refNbSpecies());
+    }
+
+    @Test
+    public void getAllReferentSpecies() {
+        List<Species> result = service.getAllReferentSpecies();
+        TuttiEntities.splitById(result);
+        assertResultList(result, fixtures.refNbReferentSpecies());
+
+        Speciess.splitByTaxonId(result);
+    }
+
+    @Test
+    public void getSpeciesByReferenceTaxonId(/*String speciesReferenceTaxonId*/) {
+        String speciesId = fixtures.refSpeciesId();
+        Integer taxonId = fixtures.refSpeciesTaxonId();
+        Species species = service.getSpeciesByReferenceTaxonId(taxonId);
+        Assert.assertNotNull(species);
+        Assert.assertNull(species.getVernacularCode());
+        Assert.assertEquals(speciesId, species.getId());
+        Assert.assertEquals(taxonId, species.getReferenceTaxonId());
+        Assert.assertEquals(fixtures.refSpeciesRefTaxCode(), species.getRefTaxCode());
+    }
+
+    @Test
+    public void getSpeciesByReferenceTaxonIdWithVernacularCode(/*String speciesReferenceTaxonId*/) {
+        String speciesId = fixtures.refSpeciesId();
+        Integer taxonId = fixtures.refSpeciesTaxonId();
+        Species species = service.getSpeciesByReferenceTaxonIdWithVernacularCode(taxonId);
+        Assert.assertNotNull(species);
+        Assert.assertNull(species.getRefTaxCode());
+        Assert.assertEquals(speciesId, species.getId());
+        Assert.assertEquals(taxonId, species.getReferenceTaxonId());
+        Assert.assertEquals(fixtures.refSpeciesVernacularCode(), species.getVernacularCode());
+    }
+
+    @Test
+    public void getBadSpeciesByReferenceTaxonId(/*String speciesReferenceTaxonId*/) {
+        Integer taxonId = fixtures.refBadSpeciesTaxonId();
+        service.getSpeciesByReferenceTaxonId(taxonId);
+    }
+
+    @Test
+    public void getBad2SpeciesByReferenceTaxonId(/*String speciesReferenceTaxonId*/) {
+        Integer taxonId = fixtures.refBad2SpeciesTaxonId();
+        service.getSpeciesByReferenceTaxonId(taxonId);
+    }
+
+}
\ No newline at end of file
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/SpeciesPersistenceServiceWriteTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/SpeciesPersistenceServiceWriteTest.java
new file mode 100644
index 0000000..b829060
--- /dev/null
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/SpeciesPersistenceServiceWriteTest.java
@@ -0,0 +1,81 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import com.google.common.collect.Lists;
+import fr.ifremer.tutti.persistence.entities.referential.Species;
+import fr.ifremer.tutti.persistence.entities.referential.Speciess;
+import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+public class SpeciesPersistenceServiceWriteTest extends ReferentialPersistenceServiceWriteTestSupport {
+
+    protected SpeciesPersistenceService service;
+
+    @Before
+    public void setUp() throws Exception {
+        service = TuttiPersistenceServiceLocator.getSpeciesPersistenceService();
+    }
+
+    @Test
+    public void importSpecies() {
+        List<Species> species = Lists.newArrayList();
+
+        long timestamp1 = System.nanoTime();
+        Species sp1 = Speciess.newSpecies();
+        sp1.setReferenceTaxonId((int) timestamp1);
+        sp1.setId("Don't care" + timestamp1);
+        sp1.setRefTaxCode("Don't care" + timestamp1);
+        sp1.setSurveyCode("Don't care" + timestamp1);
+        sp1.setName("Genus name" + timestamp1);
+        species.add(sp1);
+
+        long timestamp2 = System.nanoTime();
+        Species sp2 = Speciess.newSpecies();
+        sp2.setReferenceTaxonId((int) timestamp2);
+        sp2.setId("Don't care" + timestamp2);
+        sp2.setRefTaxCode("Don't care" + timestamp2);
+        sp2.setSurveyCode("Don't care" + timestamp2);
+        sp2.setName("Genus name" + timestamp2);
+        species.add(sp2);
+
+        Assert.assertNull(service.getSpeciesByReferenceTaxonId(sp1.getReferenceTaxonId()));
+        //Assert.assertNull(service.getSpecies(sp2.getId()));
+
+        List<Species> speciesList = service.importTemporarySpecies(species);
+        Assert.assertNotNull(speciesList);
+        Assert.assertEquals(2, speciesList.size());
+
+        Species createdSp1 = speciesList.get(0);
+        Assert.assertNotNull(createdSp1);
+        Assert.assertEquals(sp1.getName(), createdSp1.getName());
+        // TODO TC :question pour TC  pourquoi faire le test suivant NotNull, car tu n'a rien mis en entree de ce code ?
+        // faut-il que le genere ?
+        //Assert.assertNotNull(createdSp1.getExternalCode());
+        //Assert.assertNotSame(sp1.getExternalCode(), createdSp1.getExternalCode());
+        Assert.assertNull(createdSp1.getSurveyCode());
+        Assert.assertNotNull(createdSp1.getId());
+        Assert.assertNotSame(sp1.getId(), createdSp1.getId());
+        Assert.assertEquals(createdSp1, service.getSpeciesByReferenceTaxonId(createdSp1.getReferenceTaxonId()));
+
+        Species createdSp2 = speciesList.get(1);
+        Assert.assertNotNull(createdSp2);
+        Assert.assertEquals(sp2.getName(), createdSp2.getName());
+        Assert.assertTrue(createdSp2.isReferenceTaxon());
+        Assert.assertNotSame(sp2.getReferenceTaxonId(), createdSp2.getReferenceTaxonId());
+        Assert.assertNull(createdSp2.getRefTaxCode());
+        Assert.assertNull(createdSp2.getSurveyCode());
+        Assert.assertNotNull(createdSp2.getId());
+        Assert.assertNotSame(sp2.getId(), createdSp2.getId());
+        Assert.assertEquals(createdSp2, service.getSpeciesByReferenceTaxonId(createdSp2.getReferenceTaxonId()));
+    }
+
+}
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/VesselPersistenceServiceReadTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/VesselPersistenceServiceReadTest.java
new file mode 100644
index 0000000..eeb256e
--- /dev/null
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/VesselPersistenceServiceReadTest.java
@@ -0,0 +1,58 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import fr.ifremer.tutti.persistence.entities.referential.Vessel;
+import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+public class VesselPersistenceServiceReadTest extends ReferentialPersistenceServiceReadTestSupport {
+
+    /** Logger. */
+    private static final Log log = LogFactory.getLog(VesselPersistenceServiceReadTest.class);
+    
+    protected VesselPersistenceService service;
+
+    @Before
+    public void setUp() throws Exception {
+        service = TuttiPersistenceServiceLocator.getVesselPersistenceService();
+        super.setUp();
+
+    }
+
+    @Test
+    public void getAllScientificVessel() {
+        List<Vessel> result = service.getAllScientificVessel();
+        assertResultList(result, fixtures.refNbScientificVessel());
+    }
+
+    @Test
+    public void getAllFishingVessel() {
+
+        // clear cache before this test
+        cacheService.clearCache("fishingVessels");
+
+        long time = System.currentTimeMillis();
+        List<Vessel> result = service.getAllFishingVessel();
+        long delta1 = System.currentTimeMillis() - time;
+
+        assertResultList(result, fixtures.refNbFishingVessel());
+        log.debug("Load fishing vessels (without cache) in: " + delta1 + "ms");
+
+        // try again, to check cache is enable
+        time = System.currentTimeMillis();
+        result = service.getAllFishingVessel();
+        assertResultList(result, fixtures.refNbFishingVessel());
+
+        long delta2 = System.currentTimeMillis() - time;
+        log.debug("Load fishing vessels (with cache enable) in: " + delta2 + "ms");
+
+        //TODO-tc We should not test cache performance like this, depends to much of the computer usage,...
+//        float reduceFactor = delta2 * 100 / delta1;
+//        Assert.assertTrue("The cache on getAllFishingVessel() should have speed up more than factor 10. Make sure EhCache is well configured.", reduceFactor < 0.1);
+    }
+
+}
\ No newline at end of file
diff --git a/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/VesselPersistenceServiceWriteTest.java b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/VesselPersistenceServiceWriteTest.java
new file mode 100644
index 0000000..e3215d8
--- /dev/null
+++ b/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/referential/VesselPersistenceServiceWriteTest.java
@@ -0,0 +1,83 @@
+package fr.ifremer.tutti.persistence.service.referential;
+
+import com.google.common.collect.Lists;
+import fr.ifremer.tutti.persistence.entities.referential.Vessel;
+import fr.ifremer.tutti.persistence.entities.referential.Vessels;
+import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+/**
+ * Created on 11/3/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.8
+ */
+public class VesselPersistenceServiceWriteTest extends ReferentialPersistenceServiceWriteTestSupport {
+
+    protected VesselPersistenceService service;
+
+    @Before
+    public void setUp() throws Exception {
+        service = TuttiPersistenceServiceLocator.getVesselPersistenceService();
+    }
+
+    @Test
+    public void importVessel() {
+        List<Vessel> vessels = Lists.newArrayList();
+
+        // scientificVessel
+        long timestamp1 = System.nanoTime();
+        Vessel v1 = Vessels.newVessel();
+        v1.setId("Don't care" + timestamp1);
+        v1.setName("Name" + timestamp1);
+        v1.setInternationalRegistrationCode("Immat" + timestamp1);
+        v1.setScientificVessel(true);
+        vessels.add(v1);
+
+        // fishingVessel
+        long timestamp2 = System.nanoTime();
+        Vessel v2 = Vessels.newVessel();
+        v2.setId("Don't care" + timestamp2);
+        v2.setName("Name" + timestamp2);
+        v2.setInternationalRegistrationCode("Immat" + timestamp2);
+        v2.setScientificVessel(false);
+        vessels.add(v2);
+
+        Assert.assertNull(service.getVessel(v1.getId()));
+        Assert.assertNull(service.getVessel(v2.getId()));
+
+        List<Vessel> vesselList = service.importTemporaryVessel(vessels);
+
+        Assert.assertNotNull(vesselList);
+        Assert.assertEquals(2, vesselList.size());
+
+        List<Vessel> allScientificVessel = service.getAllScientificVessel();
+        List<Vessel> allFishingVessel = service.getAllFishingVessel();
+
+        Vessel createdV1 = vesselList.get(0);
+        Assert.assertNotNull(createdV1);
+        Assert.assertEquals(v1.getName(), createdV1.getName());
+        Assert.assertEquals(v1.getInternationalRegistrationCode(), createdV1.getInternationalRegistrationCode());
+        Assert.assertNotNull(createdV1.getId());
+        Assert.assertNotSame(v1.getId(), createdV1.getId());
+        Assert.assertEquals(createdV1, service.getVessel(createdV1.getId()));
+
+        Assert.assertTrue(allScientificVessel.contains(createdV1));
+        Assert.assertFalse(allFishingVessel.contains(createdV1));
+
+        Vessel createdV2 = vesselList.get(1);
+        Assert.assertNotNull(createdV2);
+        Assert.assertEquals(v2.getName(), createdV2.getName());
+        Assert.assertEquals(v2.getInternationalRegistrationCode(), createdV2.getInternationalRegistrationCode());
+        Assert.assertNotNull(createdV2.getId());
+        Assert.assertNotSame(v2.getId(), createdV2.getId());
+        Assert.assertEquals(createdV2, service.getVessel(createdV2.getId()));
+        Assert.assertFalse(allScientificVessel.contains(createdV2));
+        Assert.assertTrue(allFishingVessel.contains(createdV2));
+    }
+
+}
diff --git a/tutti-service/src/main/java/fr/ifremer/tutti/service/PersistenceService.java b/tutti-service/src/main/java/fr/ifremer/tutti/service/PersistenceService.java
index 86700fb..b9e5026 100644
--- a/tutti-service/src/main/java/fr/ifremer/tutti/service/PersistenceService.java
+++ b/tutti-service/src/main/java/fr/ifremer/tutti/service/PersistenceService.java
@@ -1046,6 +1046,16 @@ public class PersistenceService extends AbstractTuttiService implements TuttiPer
         return driver.isTemporaryVesselUsed(code);
     }
 
+    @Override
+    public String getLocationLabelByLatLong(Float latitude, Float longitude) {
+        return driver.getLocationLabelByLatLong(latitude, longitude);
+    }
+
+    @Override
+    public Integer getLocationIdByLatLong(Float latitude, Float longitude) {
+        return driver.getLocationIdByLatLong(latitude, longitude);
+    }
+
     //------------------------------------------------------------------------//
     //-- Attachment methods                                                 --//
     //------------------------------------------------------------------------//

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

    

[Tutti-commits] [tutti] 01/02: split referential persistence service

codelutin.com scm