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>.