Author: tchemit Date: 2013-05-11 17:53:26 +0200 (Sat, 11 May 2013) New Revision: 935 Url: http://forge.codelutin.com/projects/tutti/repository/revisions/935 Log: refs #1875: [IMP/EXP] - Export des donn?\195?\169es de campagne : format g?\195?\169n?\195?\169rique (ajout du rankOrder) ajout du framework de test au niveau persistence pour l'utiliser dans le module service Added: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseFixtures.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseResource.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/TuttiRunListener.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/TuttiRunner.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/AccidentalCatchExportModel.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/AccidentalCatchExportRow.java trunk/tutti-service/src/test/java/fr/ifremer/tutti/service/ServiceDbResource.java trunk/tutti-service/src/test/resources/tutti-test-read-dbGenericExport.properties Removed: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/DatabaseFixtures.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/DatabaseResource.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/TuttiRunListener.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/TuttiRunner.java Modified: trunk/tutti-persistence/pom.xml trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistence.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceImpl.java trunk/tutti-persistence/src/main/xmi/tutti-persistence.zargo trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceReadTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceReadTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceReadTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceReadTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceReadTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceReadTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/PlanktonBatchPersistenceServiceReadTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/PlanktonBatchPersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceReadTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProtocolPersistenceServiceReadTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProtocolPersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceReadTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceReadTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFileTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeHelperTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceCopyTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImplTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImplUpTodateTest.java trunk/tutti-service/pom.xml trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/ExportCatchesReportService.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/TuttiWeightComputingService.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/ValidateCruiseOperationsService.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/config/TuttiServiceConfig.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/CatchExportModel.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/CatchExportRow.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/ExportSampleCategory.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/IndividualObservationExportModel.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/IndividualObservationExportRow.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/TuttiExportService.java trunk/tutti-service/src/main/resources/i18n/tutti-service_en_GB.properties trunk/tutti-service/src/main/resources/i18n/tutti-service_fr_FR.properties trunk/tutti-service/src/test/java/fr/ifremer/tutti/service/export/TuttiExportServiceTest.java trunk/tutti-ui-swing/pom.xml trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/home/ExportCruiseAction.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/home/ExportProgramAction.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/EditFishingOperationAction.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/accidental/AccidentalBatchRowModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/BenthosBatchRowModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/frequency/BenthosFrequencyRowModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/IndividualObservationBatchRowModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/marinelitter/MarineLitterBatchRowModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/SpeciesBatchRowModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyRowModel.java Modified: trunk/tutti-persistence/pom.xml =================================================================== --- trunk/tutti-persistence/pom.xml 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/pom.xml 2013-05-11 15:53:26 UTC (rev 935) @@ -164,6 +164,7 @@ <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> + <scope>provided</scope> </dependency> <dependency> @@ -244,7 +245,7 @@ <properties> <property> <name>listener</name> - <value>fr.ifremer.tutti.persistence.TuttiRunListener</value> + <value>fr.ifremer.tutti.persistence.test.TuttiRunListener</value> </property> </properties> </configuration> Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistence.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistence.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistence.java 2013-05-11 15:53:26 UTC (rev 935) @@ -453,7 +453,6 @@ * operation, {@code false} otherwise. * @since 2.2 */ - boolean isFishingOperationWithCatchBatch(String operationId); /** Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceImpl.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceImpl.java 2013-05-11 15:53:26 UTC (rev 935) @@ -341,6 +341,9 @@ target.setId(source.getId().toString()); + // Rank order + target.setRankOrder(Integer.valueOf(source.getRankOrder())); + // Individual count target.setNumber(source.getIndividualCount()); @@ -407,6 +410,9 @@ target.setId(source.getId()); + // Rank order + target.setRankOrder(Integer.valueOf(source.getRankOrder())); + target.setNumber(source.getIndividualCount()); target.setWeight(source.getWeight()); Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceImpl.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceImpl.java 2013-05-11 15:53:26 UTC (rev 935) @@ -165,6 +165,9 @@ target.setId(source.getId().toString()); + // Rank order + target.setRankOrder(Integer.valueOf(source.getRankOrder())); + // Individual count target.setNumber(source.getIndividualCount()); Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceImpl.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceImpl.java 2013-05-11 15:53:26 UTC (rev 935) @@ -383,6 +383,9 @@ target.setId(source.getId().toString()); + // Rank order + target.setRankOrder(Integer.valueOf(source.getRankOrder())); + // Individual count target.setNumber(source.getIndividualCount()); @@ -449,6 +452,9 @@ target.setId(source.getId()); + // Rank order + target.setRankOrder(Integer.valueOf(source.getRankOrder())); + target.setNumber(source.getIndividualCount()); target.setWeight(source.getWeight()); Copied: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseFixtures.java (from rev 927, trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/DatabaseFixtures.java) =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseFixtures.java (rev 0) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseFixtures.java 2013-05-11 15:53:26 UTC (rev 935) @@ -0,0 +1,421 @@ +package fr.ifremer.tutti.persistence.test; + +/* + * #%L + * Tutti :: Persistence API + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2012 - 2013 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 com.google.common.collect.Lists; +import fr.ifremer.tutti.persistence.entities.CaracteristicMap; +import fr.ifremer.tutti.persistence.entities.TuttiBeanFactory; +import fr.ifremer.tutti.persistence.entities.data.AccidentalBatch; +import fr.ifremer.tutti.persistence.entities.data.CatchBatch; +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.entities.referential.CaracteristicType; +import fr.ifremer.tutti.persistence.entities.referential.Gear; +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.AccidentalBatchPersistenceService; +import fr.ifremer.tutti.persistence.service.CatchBatchPersistenceService; +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 org.junit.Assert; + +import java.io.Serializable; +import java.util.Calendar; +import java.util.Date; +import java.util.GregorianCalendar; +import java.util.List; + +/** + * Fixtures for the allegro db. + * + * @author tchemit <chemit@codelutin.com> + * @since 0.3 + */ +public class DatabaseFixtures { + + public String programCode() { + // campaign CGFS + return "CAM-CGFS"; + } + + public String cruiseId() { + // cruise CGFS2010 + return "100000"; + } + + public String fishingVesselCode() { + return "851751"; + } + + public String zoneId() { + // zone CGFS + return "61979"; + } + + public String strataId() { + // strate 6M + return "57377"; + } + + public String subStrataId() { + // substrata 61995 + return "61995"; + } + + public String localite() { + // Localite 8Q3 + return "57774"; + } + + public int refNbCaracteristic() { + return 481; + } + + public int refNbSpecies() { + return 16961; + } + + public int refNbReferentSpecies() { + return 8649; + } + + public int refNbScientificGear() { + return 9; + } + + public int refNbFishingGear() { + return 75; + } + + public int refNbCountry() { + return 239; + } + + public int refNbHarbour() { + return 1898; + } + + public int refNbProgramZone() { + return 14; + } + + public int refNbStrata() { + return 76; + } + + public int refNbSubStrata() { + return 16; + } + + public int refNbLocalite() { + return 129; + } + + public int refNbFishingVessel() { + return 24837; + } + + public int refNbScientificVessel() { + return 3; + } + + public int refNbPerson() { + return 128; + } + + public int refNbObjectType() { + return 57; + } + + public String refSpeciesId() { + return "15923"; + } + + public Integer refSpeciesTaxonId() { + return 467; + } + + public Integer refNumericalPmfmId() { + return 113; + } + + public Integer refAlphanumericPmfmId() { + return 1424; + } + + public String refSpeciesRefTaxCode() { + return "SEPIOFF "; + } + + public String refSpeciesVernacularCode() { + return "Seiche"; + } + + public Integer refBadSpeciesTaxonId() { + return 7632; + } + + public Integer refBad2SpeciesTaxonId() { + return 2320; + } + + public String objectTypeCode() { + return "BATCH"; + } + + public Integer caracteristicWithNullQualitativeValue() { + return 114; + } + + protected CruisePersistenceService cruiseService; + + protected ProgramPersistenceService programService; + + protected FishingOperationPersistenceService fishingOperationService; + + protected CatchBatchPersistenceService catchBatchService; + + protected ReferentialPersistenceService referentialService; + + protected AccidentalBatchPersistenceService accidentalBatchService; + + protected IndividualObservationBatchPersistenceService individualObservationBatchService; + + public void setUp() { + if (referentialService == null) { + referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService(); + programService = TuttiPersistenceServiceLocator.getProgramPersistenceService(); + cruiseService = TuttiPersistenceServiceLocator.getCruisePersistenceService(); + fishingOperationService = TuttiPersistenceServiceLocator.getFishingOperationPersistenceService(); + catchBatchService = TuttiPersistenceServiceLocator.getCatchBatchPersistenceService(); + accidentalBatchService = TuttiPersistenceServiceLocator.getAccidentalBatchPersistenceService(); + individualObservationBatchService = TuttiPersistenceServiceLocator.getIndividualObservationBatchPersistenceService(); + } + } + + public Cruise createCruise() { + + setUp(); + + String programCode = programCode(); + Cruise cruise = TuttiBeanFactory.newCruise(); + + // ----------------------------------------------------------------------------- + // 1. Test with all properties filled + // ----------------------------------------------------------------------------- + cruise.setId((String) null); + + cruise.setName("Unit-test-" + System.currentTimeMillis()); + + cruise.setProgram(programService.getProgram(programCode)); + + Calendar calendar = new GregorianCalendar(); + cruise.setBeginDate(calendar.getTime()); + + calendar.add(Calendar.MONTH, 1); // add one month + cruise.setEndDate(calendar.getTime()); + + List<TuttiLocation> allHarbour = referentialService.getAllHarbour(); + Assert.assertNotNull(allHarbour); + Assert.assertTrue(allHarbour.size() > 1); + cruise.setDepartureLocation(allHarbour.get(0)); + cruise.setReturnLocation(allHarbour.get(1)); + + List<Gear> gears = referentialService.getAllFishingGear(); + cruise.setGear(Lists.newArrayList(gears)); + + cruise.setComment("My comments on cruise"); + cruise.setSurveyPart("SurveyPart"); + + Person managerPerson = referentialService.getAllPerson().get(0); + cruise.setHeadOfMission(Lists.newArrayList(managerPerson)); + + Vessel fishingVessel = TuttiBeanFactory.newVessel(); + fishingVessel.setId(fishingVesselCode()); + + cruise.setVessel(fishingVessel); + + cruise.setMultirigNumber(2); + + Cruise result = cruiseService.createCruise(cruise); + return result; + } + + public FishingOperation createFishingOperation(Cruise cruise) { + setUp(); + + FishingOperation fishingOperation = TuttiBeanFactory.newFishingOperation(); + fishingOperation.setCruise(cruise); + fishingOperation.setComment("newFishingOperation"); + fishingOperation.setFishingOperationNumber(1); + + // Retrieve some environment caracteristics + List<Caracteristic> allEnvironmentCaracteristics = referentialService.getAllCaracteristic(); + CaracteristicMap environmentCaracteristics = new CaracteristicMap(); + CaracteristicMap environmentValuesOneEntry = new CaracteristicMap(); + int count=0; + for (Caracteristic caracteristic : allEnvironmentCaracteristics) { + if (count==3) { + break; + } + Serializable value = null; + if (caracteristic.getCaracteristicType() == CaracteristicType.NUMBER) { + value = 1.0f; + count++; + } else if (caracteristic.getCaracteristicType() == CaracteristicType.TEXT) { + value = "some text"; + count++; + } else if (caracteristic.getCaracteristicType() == CaracteristicType.QUALITATIVE + && caracteristic.getQualitativeValue(0) != null) { + // Choose the first qualitative value + value = caracteristic.getQualitativeValue(0); + count++; + } + if (value != null) { + environmentCaracteristics.put(caracteristic, value); + if (environmentValuesOneEntry.size() == 0) { + environmentValuesOneEntry.put(caracteristic, value); + } + } + } + + // Retrieve some gear use caracteristics + List<Caracteristic> allGearShootingCaracteristics = referentialService.getAllCaracteristic(); + CaracteristicMap gearShootingCaracteristics = new CaracteristicMap(); + CaracteristicMap gearShootingCaracteristicsOneEntry = new CaracteristicMap(); + count=0; + for (Caracteristic caracteristic : allGearShootingCaracteristics) { + if (count==3) { + break; + } + Serializable value = null; + if (caracteristic.getCaracteristicType() == CaracteristicType.NUMBER) { + value = 1.0f; + count++; + } else if (caracteristic.getCaracteristicType() == CaracteristicType.TEXT) { + value = "some text"; + count++; + } else if (caracteristic.getCaracteristicType() == CaracteristicType.QUALITATIVE + && caracteristic.getQualitativeValue(0) != null) { + // Choose the first qualitative value + value = caracteristic.getQualitativeValue(0); + count++; + } + if (value != null) { + gearShootingCaracteristics.put(caracteristic, value); + if (gearShootingCaracteristicsOneEntry.size() == 0) { + gearShootingCaracteristicsOneEntry.put(caracteristic, value); + } + } + } + + Calendar calendar = Calendar.getInstance(); + fishingOperation.setId((String) null); + fishingOperation.setStationNumber("STA2"); + fishingOperation.setFishingOperationNumber(2); + fishingOperation.setMultirigAggregation("1"); + calendar.setTime(new Date()); + calendar.set(Calendar.HOUR_OF_DAY, 1); + calendar.set(Calendar.MILLISECOND, 99); + fishingOperation.setGearShootingStartDate(calendar.getTime()); + calendar.setTime(new Date()); + calendar.set(Calendar.HOUR_OF_DAY, 10); + calendar.set(Calendar.MILLISECOND, 99); + fishingOperation.setGearShootingEndDate(calendar.getTime()); + fishingOperation.setGearShootingStartLatitude(47.6f); + fishingOperation.setGearShootingStartLongitude(-5.05f); + fishingOperation.setGearShootingEndLatitude(47.9854f); + fishingOperation.setGearShootingEndLongitude(-5.597f); + + fishingOperation.setTrawlDistance(100.12345f); + fishingOperation.setFishingOperationRectiligne(true); + fishingOperation.setFishingOperationValid(Boolean.TRUE); + fishingOperation.setComment("Unit test createFishingOperation() - Part n°2 : All properties set"); + fishingOperation.setGear(cruise.getGear(0)); + fishingOperation.setVessel(cruise.getVessel()); + fishingOperation.setVesselUseFeatures(environmentCaracteristics); + fishingOperation.setGearUseFeatures(gearShootingCaracteristics); + + TuttiLocation strata = TuttiBeanFactory.newTuttiLocation(); + strata.setId(strataId()); + fishingOperation.setStrata(strata); + TuttiLocation subStrata = TuttiBeanFactory.newTuttiLocation(); + subStrata.setId(subStrataId()); + fishingOperation.setSubStrata(subStrata); + TuttiLocation localite = TuttiBeanFactory.newTuttiLocation(); + localite.setId(localite()); + fishingOperation.setLocation(localite); + + FishingOperation result = fishingOperationService.createFishingOperation(fishingOperation); + return result; + } + + public CatchBatch createMinimalCatchBatch(FishingOperation fishingOperation) { + + setUp(); + + CatchBatch catchBatch = TuttiBeanFactory.newCatchBatch(); + catchBatch.setFishingOperation(fishingOperation); + CatchBatch result = catchBatchService.createCatchBatch(catchBatch); + return result; + } + + public AccidentalBatch createMinimalAccidentalBatch(FishingOperation fishingOperation) { + + setUp(); + + AccidentalBatch minimalAccidentalBatch = TuttiBeanFactory.newAccidentalBatch(); + minimalAccidentalBatch.setFishingOperation(fishingOperation); + minimalAccidentalBatch.setSpecies(referentialService.getSpeciesByReferenceTaxonId(refSpeciesTaxonId())); + minimalAccidentalBatch.setCaracteristics(new CaracteristicMap()); + AccidentalBatch result = + accidentalBatchService.createAccidentalBatch(minimalAccidentalBatch); + return result; + } + + public IndividualObservationBatch createMinimalIndividualObservationBatch(FishingOperation fishingOperation) { + + setUp(); + + IndividualObservationBatch minimalAccidentalBatch = TuttiBeanFactory.newIndividualObservationBatch(); + minimalAccidentalBatch.setFishingOperation(fishingOperation); + minimalAccidentalBatch.setSpecies(referentialService.getSpeciesByReferenceTaxonId(refSpeciesTaxonId())); + minimalAccidentalBatch.setCaracteristics(new CaracteristicMap()); + minimalAccidentalBatch.setLengthStepCaracteristic(referentialService.getCaracteristic(refNumericalPmfmId())); + minimalAccidentalBatch.setSize(10.0f); + minimalAccidentalBatch.setWeight(5.f); + + IndividualObservationBatch result = + individualObservationBatchService.createIndividualObservationBatch(minimalAccidentalBatch); + return result; + } +} Copied: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseResource.java (from rev 927, trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/DatabaseResource.java) =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseResource.java (rev 0) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseResource.java 2013-05-11 15:53:26 UTC (rev 935) @@ -0,0 +1,453 @@ +package fr.ifremer.tutti.persistence.test; + +/* + * #%L + * Tutti :: Persistence API + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2012 - 2013 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 com.google.common.base.Charsets; +import com.google.common.base.Preconditions; +import com.google.common.base.Predicate; +import com.google.common.collect.Lists; +import com.google.common.collect.Sets; +import com.google.common.io.Files; +import fr.ifremer.tutti.persistence.RessourceClassLoader; +import fr.ifremer.tutti.persistence.config.TuttiPersistenceConfig; +import fr.ifremer.tutti.persistence.config.TuttiPersistenceConfigOption; +import fr.ifremer.tutti.persistence.entities.TuttiEntities; +import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator; +import org.apache.commons.io.FileUtils; +import org.apache.commons.lang3.StringUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.junit.Assume; +import org.junit.rules.TestRule; +import org.junit.runner.Description; +import org.junit.runner.notification.Failure; +import org.junit.runners.model.Statement; +import org.nuiton.util.FileUtil; +import org.nuiton.util.config.ApplicationConfig; + +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.util.List; +import java.util.Properties; +import java.util.Set; + +/** + * To box the persistence service as a test resource. + * + * @author tchemit <chemit@codelutin.com> + * @since 0.3 + */ +public class DatabaseResource implements TestRule { + + /** Logger. */ + private static final Log log = LogFactory.getLog(DatabaseResource.class); + + public static final String TUTTI_PERSISTENCE_JDBC_CREATE_SCRIPT = + "tutti.persistence.jdbc.createScript"; + + public static long BUILD_TIMESTAMP = System.nanoTime(); + + private static ClassLoader oldClassLoader; + + protected RessourceClassLoader loader; + + private File resourceDirectory; + + private TuttiPersistenceConfig config; + + private DatabaseFixtures fixtures; + + private final String beanFactoryReferenceLocation; + + private final String beanRefFactoryReferenceId; + + private final boolean writeDb; + + private String dbName; + + public static DatabaseResource readDb() { + return new DatabaseResource(""); + } + + public static DatabaseResource writeDb() { + return new DatabaseResource("", true); + } + + public static DatabaseResource readDb(String dbName) { + return new DatabaseResource(dbName); + } + + public static DatabaseResource writeDb(String dbName) { + return new DatabaseResource(dbName, true); + } + + public static DatabaseResource noDb() { + return new DatabaseResource( + "", "beanRefFactoryWitNoDb.xml", "TuttiBeanRefFactoryWithNoDb"); + } + + protected DatabaseResource(String dbName) { + this(dbName, null, null, false); + } + + protected DatabaseResource(String dbName, boolean writeDb) { + this(dbName, null, null, writeDb); + } + + protected DatabaseResource(String dbName, String beanFactoryReferenceLocation, + String beanRefFactoryReferenceId) { + this(dbName, beanFactoryReferenceLocation, + beanRefFactoryReferenceId, false); + } + + protected DatabaseResource(String dbName, String beanFactoryReferenceLocation, + String beanRefFactoryReferenceId, + boolean writeDb) { + this.dbName = dbName; + this.beanFactoryReferenceLocation = beanFactoryReferenceLocation; + this.beanRefFactoryReferenceId = beanRefFactoryReferenceId; + this.writeDb = writeDb; + } + + public TuttiPersistenceConfig getConfig() { + return config; + } + + public DatabaseFixtures getFixtures() { + return fixtures; + } + + public File getResourceDirectory(String name) { + return new File(resourceDirectory, name); + } + + @Override + public Statement apply(final Statement base, final Description description) { + + return new Statement() { + @Override + public void evaluate() throws Throwable { + before(description); + try { + base.evaluate(); + } finally { + after(description); + } + } + }; + } + + Class<?> testClass; + + protected void before(Description description) throws Throwable { + + TuttiRunListener.beforeClass(description); + + testClass = description.getTestClass(); + + boolean defaultDbName = StringUtils.isEmpty(dbName); + + if (defaultDbName) { + dbName = "db"; + } + File db = new File("src/test/" + dbName); + if (!db.exists()) { + + if (log.isWarnEnabled()) { + log.warn("Could not find db at " + db + ", test [" + + testClass + "] is skipped."); + } + Assume.assumeTrue(false); + } + + if (log.isInfoEnabled()) { + log.info("Prepare test " + testClass); + } + + fixtures = new DatabaseFixtures(); + + resourceDirectory = FileUtil.getTestSpecificDirectory(testClass, "", null, BUILD_TIMESTAMP); + + loader = new RessourceClassLoader(testClass.getClassLoader()); + + oldClassLoader = Thread.currentThread().getContextClassLoader(); + Thread.currentThread().setContextClassLoader(loader); + + // check that config file is in classpath (avoid to find out why it does not works...) + String configFilename = writeDb ? + "tutti-test-write" : + "tutti-test-read"; + if (!defaultDbName) { + configFilename += "-" + dbName; + } + configFilename += ".properties"; + InputStream resourceAsStream = getClass().getResourceAsStream("/" + configFilename); + Preconditions.checkNotNull(resourceAsStream, "Could not find " + configFilename + " in test class-path"); + + ApplicationConfig applicationConfig = new ApplicationConfig(configFilename); + applicationConfig.loadDefaultOptions( + TuttiPersistenceConfigOption.values()); + applicationConfig.setDefaultOption( + "tutti.data.directory", + new File(resourceDirectory, "data").getAbsolutePath()); + applicationConfig.parse(); + + config = new TuttiPersistenceConfig(applicationConfig); + + if (writeDb) { + copyDb(config.getDbDirectory(), !writeDb, null); + } + + toDetroy.add(config.getDbAttachmentDirectory()); + + // load db config + File dbConfig = new File(config.getDbDirectory(), config.getDbName() + ".properties"); + Properties p = new Properties(); + BufferedReader reader = Files.newReader(dbConfig, Charsets.UTF_8); + p.load(reader); + reader.close(); + + if (log.isDebugEnabled()) { + log.debug("Db config: " + dbConfig + "\n" + p); + } + + if (writeDb) { + + // make sure db is on readonly mode + String readonly = p.getProperty("readonly"); + Preconditions.checkNotNull(readonly, "Could not find readonly property on db confg: " + dbConfig); + Preconditions.checkState("false".equals(readonly), "readonly property must be at false value in write mode test in db confg: " + dbConfig); + } else { + // make sure db is on readonly mode + String readonly = p.getProperty("readonly"); + Preconditions.checkNotNull(readonly, "Could not find readonly property on db confg: " + dbConfig); + Preconditions.checkState("true".equals(readonly), "readonly property must be at true value in read mode test in db confg: " + dbConfig); + } + + config.initConfig(loader); + + TuttiPersistenceConfig.setInstance(config); + + if (log.isInfoEnabled()) { + log.info("Use db: " + config.getJdbcUrl()); + } + + if (log.isDebugEnabled()) { + log.debug("Use conf.properties at " + config.getDbConfigurationPath()); + } + + if (beanFactoryReferenceLocation != null) { + TuttiPersistenceServiceLocator.initTutti( + beanFactoryReferenceLocation, + beanRefFactoryReferenceId); + } + } + + protected final Set<File> toDetroy = Sets.newHashSet(); + + public void addToDestroy(File dir) { + toDetroy.add(dir); + } + + public void copyDb(String dbDirectory, boolean readonly, Properties p) throws IOException { + File externalDbFile = getResourceDirectory(dbDirectory); + copyDb(externalDbFile, readonly, p); + } + + public void copyDb(File target, boolean readonly, Properties p) throws IOException { + File db = new File("src/test/" + dbName); + if (!db.exists()) { + + if (log.isWarnEnabled()) { + log.warn("Could not find db at " + db + ", test [" + + testClass + "] is skipped."); + } + Assume.assumeTrue(false); + } + toDetroy.add(target); + FileUtils.copyDirectory(db, target); + if (p != null) { + TuttiEntities.fillConnectionProperties( + p, + TuttiEntities.getJdbcUrl(target, config.getDbName()), + config.getJdbcUsername(), + config.getJdbcPassword()); + } + + // load db config + File dbConfig = new File(target, config.getDbName() + ".properties"); + Properties dbconf = new Properties(); + BufferedReader reader = Files.newReader(dbConfig, Charsets.UTF_8); + dbconf.load(reader); + reader.close(); + + // switch readonly flag according to the write parameter + dbconf.setProperty("readonly", String.valueOf(readonly)); + BufferedWriter writer = Files.newWriter(dbConfig, Charsets.UTF_8); + dbconf.store(writer, ""); + writer.close(); + + } + + protected void after(Description description) throws IOException { + if (log.isInfoEnabled()) { + log.info("After test " + testClass); + } + + Set<Failure> failures = TuttiRunListener.getFailuresForClass( + description.getClassName()); + + if (failures.isEmpty()) { + + // can destroy directories + for (File file : toDetroy) { + if (file.exists()) { + if (log.isInfoEnabled()) { + log.info("Destroy directory: " + file); + } + try { + FileUtils.deleteDirectory(file); + } catch (IOException e) { + if (log.isErrorEnabled()) { + log.error("Could not delete directory: " + file, e); + } + } + } + } + } else { + if (log.isWarnEnabled()) { + log.warn("Won't destroy directories cause of failures in test."); + } + } + + // push back old classLoader + if (oldClassLoader != null) { + Thread.currentThread().setContextClassLoader(oldClassLoader); + } + + TuttiPersistenceServiceLocator.close(); + + if (beanFactoryReferenceLocation != null) { + + // push back default tutti configuration + TuttiPersistenceServiceLocator.initTuttiDefault(); + } + + TuttiPersistenceConfig.setInstance(null); + } + + public Connection createEmptyDb(String dbDirectory, + String dbName) throws IOException, SQLException { + return createEmptyDb(dbDirectory, dbName, null); + } + + public Connection createEmptyDb(String dbDirectory, + String dbName, Properties p) throws IOException, SQLException { + File externalDbFile = getResourceDirectory(dbDirectory); + return createEmptyDb(externalDbFile, dbName, p); + } + + public Connection createEmptyDb(File directory, + String dbName) throws SQLException, IOException { + + return createEmptyDb(directory, dbName, null); + } + + public Connection createEmptyDb(File directory, + String dbName, Properties p) throws SQLException, IOException { + + if (log.isInfoEnabled()) { + log.info("Create new db at " + directory); + } + addToDestroy(directory); + String jdbcUrl = TuttiEntities.getJdbcUrl(directory, dbName); + String user = "SA"; + String password = ""; + + if (p != null) { + TuttiEntities.fillConnectionProperties(p, jdbcUrl, user, password); + } + File scriptFile = config.getConfig().getOptionAsFile(TUTTI_PERSISTENCE_JDBC_CREATE_SCRIPT); + + Preconditions.checkNotNull("Could not find db script in configuration with key " + TUTTI_PERSISTENCE_JDBC_CREATE_SCRIPT); + Preconditions.checkState(scriptFile.exists(), "Could not find db script at " + scriptFile); + + if (log.isInfoEnabled()) { + log.info("Will use create script: " + scriptFile); + } + Connection connection = TuttiEntities.createConnection(jdbcUrl, user, password); + + if (log.isInfoEnabled()) { + log.info("Created connection at " + connection.getMetaData().getURL()); + } + + List<String> importScriptSql = getImportScriptSql(scriptFile); + for (String sql : importScriptSql) { + PreparedStatement statement = connection.prepareStatement(sql); + statement.execute(); + } + connection.commit(); + return connection; + } + + protected List<String> getImportScriptSql(File scriptFile) throws IOException { + List<String> lines = Files.readLines(scriptFile, Charsets.UTF_8); + + List<String> result = Lists.newArrayListWithCapacity(lines.size()); + + Predicate<String> predicate = new Predicate<String>() { + + Set<String> forbiddenStarts = Sets.newHashSet( + "SET ", + "CREATE USER ", + "CREATE SCHEMA ", + "GRANT DBA TO "); + + @Override + public boolean apply(String input) { + boolean accept = true; + for (String forbiddenStart : forbiddenStarts) { + if (input.startsWith(forbiddenStart)) { + accept = false; + break; + } + } + return accept; + } + }; + for (String line : lines) { + if (predicate.apply(line.trim().toUpperCase())) { + result.add(line); + } + } + return result; + } +} Copied: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/TuttiRunListener.java (from rev 927, trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/TuttiRunListener.java) =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/TuttiRunListener.java (rev 0) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/TuttiRunListener.java 2013-05-11 15:53:26 UTC (rev 935) @@ -0,0 +1,95 @@ +package fr.ifremer.tutti.persistence.test; + +/* + * #%L + * Tutti :: Persistence + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2012 - 2013 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 com.google.common.collect.Sets; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.junit.runner.Description; +import org.junit.runner.notification.Failure; +import org.junit.runner.notification.RunListener; + +import java.util.Iterator; +import java.util.Set; + +/** + * Listen JUnit test and keep failures (in order to remove or not directories + * in {@link DatabaseResource}. + * + * @author tchemit <chemit@codelutin.com> + * @since 1.0.2 + */ +public final class TuttiRunListener extends RunListener { + + /** Logger. */ + private static final Log log = LogFactory.getLog(TuttiRunListener.class); + + protected static final Set<Failure> failures = Sets.newHashSet(); + + public static synchronized void beforeClass(Description description) { + + if (log.isDebugEnabled()) { + log.debug("Start to listen test " + description); + } + + Iterator<Failure> iterator = failures.iterator(); + String className = description.getClassName(); + while (iterator.hasNext()) { + Failure failure = iterator.next(); + if (className.equals(failure.getDescription().getClassName())) { + iterator.remove(); + } + } + } + + public static synchronized Set<Failure> getFailuresForClass(String className) { + Set<Failure> result = Sets.newHashSet(); + for (Failure failure : failures) { + if (className.equals(failure.getDescription().getClassName())) { + result.add(failure); + } + } + return result; + } + + @Override + public void testFailure(Failure failure) throws Exception { + if (log.isDebugEnabled()) { + log.debug("Adding failure: " + failure + ", for description: " + failure.getDescription()); + } + failures.add(failure); + super.testFailure(failure); + + } + + @Override + public void testAssumptionFailure(Failure failure) { + if (log.isDebugEnabled()) { + log.debug("Adding assumptionFailure: " + failure + ", for description: " + failure.getDescription()); + } + failures.add(failure); + super.testAssumptionFailure(failure); + } +} Copied: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/TuttiRunner.java (from rev 927, trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/TuttiRunner.java) =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/TuttiRunner.java (rev 0) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/TuttiRunner.java 2013-05-11 15:53:26 UTC (rev 935) @@ -0,0 +1,64 @@ +package fr.ifremer.tutti.persistence.test; + +/* + * #%L + * Tutti :: Persistence + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2012 - 2013 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 org.junit.runner.notification.RunNotifier; +import org.junit.runners.BlockJUnit4ClassRunner; +import org.junit.runners.model.FrameworkMethod; +import org.junit.runners.model.InitializationError; + +/** + * To use {@link TuttiRunListener}. + * <p/> + * Add this on top of your test (when run in IDE, otherise maven already add + * the listener for you, so no need of the runner). + * <pre> + * \@RunWith(TuttiRunner.class) + * </pre> + * + * @author tchemit <chemit@codelutin.com> + * @since 1.0.2 + */ + +public class TuttiRunner extends BlockJUnit4ClassRunner { + + public static final TuttiRunListener TUTTI_RUN_LISTENER = new TuttiRunListener(); + + /** + * Creates a BlockJUnit4ClassRunner to run {@code klass} + * + * @throws InitializationError if the test class is malformed. + */ + public TuttiRunner(Class<?> klass) throws InitializationError { + super(klass); + } + + @Override + protected void runChild(FrameworkMethod method, RunNotifier notifier) { + notifier.removeListener(TUTTI_RUN_LISTENER); + notifier.addListener(TUTTI_RUN_LISTENER); + super.runChild(method, notifier); + } +} Modified: trunk/tutti-persistence/src/main/xmi/tutti-persistence.zargo =================================================================== (Binary files differ) Deleted: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/DatabaseFixtures.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/DatabaseFixtures.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/DatabaseFixtures.java 2013-05-11 15:53:26 UTC (rev 935) @@ -1,421 +0,0 @@ -package fr.ifremer.tutti.persistence; - -/* - * #%L - * Tutti :: Persistence API - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2012 - 2013 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 com.google.common.collect.Lists; -import fr.ifremer.tutti.persistence.entities.CaracteristicMap; -import fr.ifremer.tutti.persistence.entities.TuttiBeanFactory; -import fr.ifremer.tutti.persistence.entities.data.AccidentalBatch; -import fr.ifremer.tutti.persistence.entities.data.CatchBatch; -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.entities.referential.CaracteristicType; -import fr.ifremer.tutti.persistence.entities.referential.Gear; -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.AccidentalBatchPersistenceService; -import fr.ifremer.tutti.persistence.service.CatchBatchPersistenceService; -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 org.junit.Assert; - -import java.io.Serializable; -import java.util.Calendar; -import java.util.Date; -import java.util.GregorianCalendar; -import java.util.List; - -/** - * Fixtures for the allegro db. - * - * @author tchemit <chemit@codelutin.com> - * @since 0.3 - */ -public class DatabaseFixtures { - - public String programCode() { - // campaign CGFS - return "CAM-CGFS"; - } - - public String cruiseId() { - // cruise CGFS2010 - return "100000"; - } - - public String fishingVesselCode() { - return "851751"; - } - - public String zoneId() { - // zone CGFS - return "61979"; - } - - public String strataId() { - // strate 6M - return "57377"; - } - - public String subStrataId() { - // substrata 61995 - return "61995"; - } - - public String localite() { - // Localite 8Q3 - return "57774"; - } - - public int refNbCaracteristic() { - return 481; - } - - public int refNbSpecies() { - return 16961; - } - - public int refNbReferentSpecies() { - return 8649; - } - - public int refNbScientificGear() { - return 9; - } - - public int refNbFishingGear() { - return 75; - } - - public int refNbCountry() { - return 239; - } - - public int refNbHarbour() { - return 1898; - } - - public int refNbProgramZone() { - return 14; - } - - public int refNbStrata() { - return 76; - } - - public int refNbSubStrata() { - return 16; - } - - public int refNbLocalite() { - return 129; - } - - public int refNbFishingVessel() { - return 24837; - } - - public int refNbScientificVessel() { - return 3; - } - - public int refNbPerson() { - return 128; - } - - public int refNbObjectType() { - return 57; - } - - public String refSpeciesId() { - return "15923"; - } - - public Integer refSpeciesTaxonId() { - return 467; - } - - public Integer refNumericalPmfmId() { - return 113; - } - - public Integer refAlphanumericPmfmId() { - return 1424; - } - - public String refSpeciesRefTaxCode() { - return "SEPIOFF "; - } - - public String refSpeciesVernacularCode() { - return "Seiche"; - } - - public Integer refBadSpeciesTaxonId() { - return 7632; - } - - public Integer refBad2SpeciesTaxonId() { - return 2320; - } - - public String objectTypeCode() { - return "BATCH"; - } - - public Integer caracteristicWithNullQualitativeValue() { - return 114; - } - - protected CruisePersistenceService cruiseService; - - protected ProgramPersistenceService programService; - - protected FishingOperationPersistenceService fishingOperationService; - - protected CatchBatchPersistenceService catchBatchService; - - protected ReferentialPersistenceService referentialService; - - protected AccidentalBatchPersistenceService accidentalBatchService; - - protected IndividualObservationBatchPersistenceService individualObservationBatchService; - - public void setUp() { - if (referentialService == null) { - referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService(); - programService = TuttiPersistenceServiceLocator.getProgramPersistenceService(); - cruiseService = TuttiPersistenceServiceLocator.getCruisePersistenceService(); - fishingOperationService = TuttiPersistenceServiceLocator.getFishingOperationPersistenceService(); - catchBatchService = TuttiPersistenceServiceLocator.getCatchBatchPersistenceService(); - accidentalBatchService = TuttiPersistenceServiceLocator.getAccidentalBatchPersistenceService(); - individualObservationBatchService = TuttiPersistenceServiceLocator.getIndividualObservationBatchPersistenceService(); - } - } - - public Cruise createCruise() { - - setUp(); - - String programCode = programCode(); - Cruise cruise = TuttiBeanFactory.newCruise(); - - // ----------------------------------------------------------------------------- - // 1. Test with all properties filled - // ----------------------------------------------------------------------------- - cruise.setId((String) null); - - cruise.setName("Unit-test-" + System.currentTimeMillis()); - - cruise.setProgram(programService.getProgram(programCode)); - - Calendar calendar = new GregorianCalendar(); - cruise.setBeginDate(calendar.getTime()); - - calendar.add(Calendar.MONTH, 1); // add one month - cruise.setEndDate(calendar.getTime()); - - List<TuttiLocation> allHarbour = referentialService.getAllHarbour(); - Assert.assertNotNull(allHarbour); - Assert.assertTrue(allHarbour.size() > 1); - cruise.setDepartureLocation(allHarbour.get(0)); - cruise.setReturnLocation(allHarbour.get(1)); - - List<Gear> gears = referentialService.getAllFishingGear(); - cruise.setGear(Lists.newArrayList(gears)); - - cruise.setComment("My comments on cruise"); - cruise.setSurveyPart("SurveyPart"); - - Person managerPerson = referentialService.getAllPerson().get(0); - cruise.setHeadOfMission(Lists.newArrayList(managerPerson)); - - Vessel fishingVessel = TuttiBeanFactory.newVessel(); - fishingVessel.setId(fishingVesselCode()); - - cruise.setVessel(fishingVessel); - - cruise.setMultirigNumber(2); - - Cruise result = cruiseService.createCruise(cruise); - return result; - } - - public FishingOperation createFishingOperation(Cruise cruise) { - setUp(); - - FishingOperation fishingOperation = TuttiBeanFactory.newFishingOperation(); - fishingOperation.setCruise(cruise); - fishingOperation.setComment("newFishingOperation"); - fishingOperation.setFishingOperationNumber(1); - - // Retrieve some environment caracteristics - List<Caracteristic> allEnvironmentCaracteristics = referentialService.getAllCaracteristic(); - CaracteristicMap environmentCaracteristics = new CaracteristicMap(); - CaracteristicMap environmentValuesOneEntry = new CaracteristicMap(); - int count=0; - for (Caracteristic caracteristic : allEnvironmentCaracteristics) { - if (count==3) { - break; - } - Serializable value = null; - if (caracteristic.getCaracteristicType() == CaracteristicType.NUMBER) { - value = 1.0f; - count++; - } else if (caracteristic.getCaracteristicType() == CaracteristicType.TEXT) { - value = "some text"; - count++; - } else if (caracteristic.getCaracteristicType() == CaracteristicType.QUALITATIVE - && caracteristic.getQualitativeValue(0) != null) { - // Choose the first qualitative value - value = caracteristic.getQualitativeValue(0); - count++; - } - if (value != null) { - environmentCaracteristics.put(caracteristic, value); - if (environmentValuesOneEntry.size() == 0) { - environmentValuesOneEntry.put(caracteristic, value); - } - } - } - - // Retrieve some gear use caracteristics - List<Caracteristic> allGearShootingCaracteristics = referentialService.getAllCaracteristic(); - CaracteristicMap gearShootingCaracteristics = new CaracteristicMap(); - CaracteristicMap gearShootingCaracteristicsOneEntry = new CaracteristicMap(); - count=0; - for (Caracteristic caracteristic : allGearShootingCaracteristics) { - if (count==3) { - break; - } - Serializable value = null; - if (caracteristic.getCaracteristicType() == CaracteristicType.NUMBER) { - value = 1.0f; - count++; - } else if (caracteristic.getCaracteristicType() == CaracteristicType.TEXT) { - value = "some text"; - count++; - } else if (caracteristic.getCaracteristicType() == CaracteristicType.QUALITATIVE - && caracteristic.getQualitativeValue(0) != null) { - // Choose the first qualitative value - value = caracteristic.getQualitativeValue(0); - count++; - } - if (value != null) { - gearShootingCaracteristics.put(caracteristic, value); - if (gearShootingCaracteristicsOneEntry.size() == 0) { - gearShootingCaracteristicsOneEntry.put(caracteristic, value); - } - } - } - - Calendar calendar = Calendar.getInstance(); - fishingOperation.setId((String) null); - fishingOperation.setStationNumber("STA2"); - fishingOperation.setFishingOperationNumber(2); - fishingOperation.setMultirigAggregation("1"); - calendar.setTime(new Date()); - calendar.set(Calendar.HOUR_OF_DAY, 1); - calendar.set(Calendar.MILLISECOND, 99); - fishingOperation.setGearShootingStartDate(calendar.getTime()); - calendar.setTime(new Date()); - calendar.set(Calendar.HOUR_OF_DAY, 10); - calendar.set(Calendar.MILLISECOND, 99); - fishingOperation.setGearShootingEndDate(calendar.getTime()); - fishingOperation.setGearShootingStartLatitude(47.6f); - fishingOperation.setGearShootingStartLongitude(-5.05f); - fishingOperation.setGearShootingEndLatitude(47.9854f); - fishingOperation.setGearShootingEndLongitude(-5.597f); - - fishingOperation.setTrawlDistance(100.12345f); - fishingOperation.setFishingOperationRectiligne(true); - fishingOperation.setFishingOperationValid(Boolean.TRUE); - fishingOperation.setComment("Unit test createFishingOperation() - Part n°2 : All properties set"); - fishingOperation.setGear(cruise.getGear(0)); - fishingOperation.setVessel(cruise.getVessel()); - fishingOperation.setVesselUseFeatures(environmentCaracteristics); - fishingOperation.setGearUseFeatures(gearShootingCaracteristics); - - TuttiLocation strata = TuttiBeanFactory.newTuttiLocation(); - strata.setId(strataId()); - fishingOperation.setStrata(strata); - TuttiLocation subStrata = TuttiBeanFactory.newTuttiLocation(); - subStrata.setId(subStrataId()); - fishingOperation.setSubStrata(subStrata); - TuttiLocation localite = TuttiBeanFactory.newTuttiLocation(); - localite.setId(localite()); - fishingOperation.setLocation(localite); - - FishingOperation result = fishingOperationService.createFishingOperation(fishingOperation); - return result; - } - - public CatchBatch createMinimalCatchBatch(FishingOperation fishingOperation) { - - setUp(); - - CatchBatch catchBatch = TuttiBeanFactory.newCatchBatch(); - catchBatch.setFishingOperation(fishingOperation); - CatchBatch result = catchBatchService.createCatchBatch(catchBatch); - return result; - } - - public AccidentalBatch createMinimalAccidentalBatch(FishingOperation fishingOperation) { - - setUp(); - - AccidentalBatch minimalAccidentalBatch = TuttiBeanFactory.newAccidentalBatch(); - minimalAccidentalBatch.setFishingOperation(fishingOperation); - minimalAccidentalBatch.setSpecies(referentialService.getSpeciesByReferenceTaxonId(refSpeciesTaxonId())); - minimalAccidentalBatch.setCaracteristics(new CaracteristicMap()); - AccidentalBatch result = - accidentalBatchService.createAccidentalBatch(minimalAccidentalBatch); - return result; - } - - public IndividualObservationBatch createMinimalIndividualObservationBatch(FishingOperation fishingOperation) { - - setUp(); - - IndividualObservationBatch minimalAccidentalBatch = TuttiBeanFactory.newIndividualObservationBatch(); - minimalAccidentalBatch.setFishingOperation(fishingOperation); - minimalAccidentalBatch.setSpecies(referentialService.getSpeciesByReferenceTaxonId(refSpeciesTaxonId())); - minimalAccidentalBatch.setCaracteristics(new CaracteristicMap()); - minimalAccidentalBatch.setLengthStepCaracteristic(referentialService.getCaracteristic(refNumericalPmfmId())); - minimalAccidentalBatch.setSize(10.0f); - minimalAccidentalBatch.setWeight(5.f); - - IndividualObservationBatch result = - individualObservationBatchService.createIndividualObservationBatch(minimalAccidentalBatch); - return result; - } -} Deleted: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/DatabaseResource.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/DatabaseResource.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/DatabaseResource.java 2013-05-11 15:53:26 UTC (rev 935) @@ -1,450 +0,0 @@ -package fr.ifremer.tutti.persistence; - -/* - * #%L - * Tutti :: Persistence API - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2012 - 2013 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 com.google.common.base.Charsets; -import com.google.common.base.Preconditions; -import com.google.common.base.Predicate; -import com.google.common.collect.Lists; -import com.google.common.collect.Sets; -import com.google.common.io.Files; -import fr.ifremer.tutti.persistence.config.TuttiPersistenceConfig; -import fr.ifremer.tutti.persistence.config.TuttiPersistenceConfigOption; -import fr.ifremer.tutti.persistence.entities.TuttiEntities; -import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator; -import org.apache.commons.io.FileUtils; -import org.apache.commons.lang3.StringUtils; -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.junit.Assume; -import org.junit.rules.TestRule; -import org.junit.runner.Description; -import org.junit.runner.notification.Failure; -import org.junit.runners.model.Statement; -import org.nuiton.util.FileUtil; -import org.nuiton.util.config.ApplicationConfig; - -import java.io.BufferedReader; -import java.io.BufferedWriter; -import java.io.File; -import java.io.IOException; -import java.io.InputStream; -import java.sql.Connection; -import java.sql.PreparedStatement; -import java.sql.SQLException; -import java.util.List; -import java.util.Properties; -import java.util.Set; - -/** - * To box the persistence service as a test resource. - * - * @author tchemit <chemit@codelutin.com> - * @since 0.3 - */ -public class DatabaseResource implements TestRule { - - /** Logger. */ - private static final Log log = LogFactory.getLog(DatabaseResource.class); - - public static final String TUTTI_PERSISTENCE_JDBC_CREATE_SCRIPT = "tutti.persistence.jdbc.createScript"; - - public static long BUILD_TIMESTAMP = System.nanoTime(); - - private static ClassLoader oldClassLoader; - - private File resourceDirectory; - - private TuttiPersistenceConfig config; - - private DatabaseFixtures fixtures; - - private final String beanFactoryReferenceLocation; - - private final String beanRefFactoryReferenceId; - - private final boolean writeDb; - - private String dbName; - - public static DatabaseResource readDb() { - return new DatabaseResource(""); - } - - public static DatabaseResource writeDb() { - return new DatabaseResource("", true); - } - - public static DatabaseResource readDb(String dbName) { - return new DatabaseResource(dbName); - } - - public static DatabaseResource writeDb(String dbName) { - return new DatabaseResource(dbName, true); - } - - public static DatabaseResource noDb() { - return new DatabaseResource( - "", "beanRefFactoryWitNoDb.xml", "TuttiBeanRefFactoryWithNoDb"); - } - - protected DatabaseResource(String dbName) { - this(dbName, null, null, false); - } - - protected DatabaseResource(String dbName, boolean writeDb) { - this(dbName, null, null, writeDb); - } - - protected DatabaseResource(String dbName, String beanFactoryReferenceLocation, - String beanRefFactoryReferenceId) { - this(dbName, beanFactoryReferenceLocation, - beanRefFactoryReferenceId, false); - } - - protected DatabaseResource(String dbName, String beanFactoryReferenceLocation, - String beanRefFactoryReferenceId, - boolean writeDb) { - this.dbName = dbName; - this.beanFactoryReferenceLocation = beanFactoryReferenceLocation; - this.beanRefFactoryReferenceId = beanRefFactoryReferenceId; - this.writeDb = writeDb; - } - - public TuttiPersistenceConfig getConfig() { - return config; - } - - public DatabaseFixtures getFixtures() { - return fixtures; - } - - public File getResourceDirectory(String name) { - return new File(resourceDirectory, name); - } - - @Override - public Statement apply(final Statement base, final Description description) { - - return new Statement() { - @Override - public void evaluate() throws Throwable { - before(description); - try { - base.evaluate(); - } finally { - after(description); - } - } - }; - } - - Class<?> testClass; - - protected void before(Description description) throws Throwable { - - TuttiRunListener.beforeClass(description); - - testClass = description.getTestClass(); - - boolean defaultDbName = StringUtils.isEmpty(dbName); - - if (defaultDbName) { - dbName = "db"; - } - File db = new File("src/test/" + dbName); - if (!db.exists()) { - - if (log.isWarnEnabled()) { - log.warn("Could not find db at " + db + ", test [" + - testClass + "] is skipped."); - } - Assume.assumeTrue(false); - } - - if (log.isInfoEnabled()) { - log.info("Prepare test " + testClass); - } - - fixtures = new DatabaseFixtures(); - - resourceDirectory = FileUtil.getTestSpecificDirectory(testClass, "", null, BUILD_TIMESTAMP); - - RessourceClassLoader loader = - new RessourceClassLoader(testClass.getClassLoader()); - - oldClassLoader = Thread.currentThread().getContextClassLoader(); - Thread.currentThread().setContextClassLoader(loader); - - // check that config file is in classpath (avoid to find out why it does not works...) - String configFilename = writeDb ? - "tutti-test-write" : - "tutti-test-read"; - if (!defaultDbName) { - configFilename += "-" + dbName; - } - configFilename += ".properties"; - InputStream resourceAsStream = getClass().getResourceAsStream("/" + configFilename); - Preconditions.checkNotNull(resourceAsStream, "Could not find " + configFilename + " in test class-path"); - - ApplicationConfig applicationConfig = new ApplicationConfig(configFilename); - applicationConfig.loadDefaultOptions( - TuttiPersistenceConfigOption.values()); - applicationConfig.setDefaultOption( - "tutti.data.directory", - new File(resourceDirectory, "data").getAbsolutePath()); - applicationConfig.parse(); - - config = new TuttiPersistenceConfig(applicationConfig); - - if (writeDb) { - copyDb(config.getDbDirectory(), !writeDb, null); - } - - toDetroy.add(config.getDbAttachmentDirectory()); - - // load db config - File dbConfig = new File(config.getDbDirectory(), config.getDbName() + ".properties"); - Properties p = new Properties(); - BufferedReader reader = Files.newReader(dbConfig, Charsets.UTF_8); - p.load(reader); - reader.close(); - - if (log.isDebugEnabled()) { - log.debug("Db config: " + dbConfig + "\n" + p); - } - - if (writeDb) { - - // make sure db is on readonly mode - String readonly = p.getProperty("readonly"); - Preconditions.checkNotNull(readonly, "Could not find readonly property on db confg: " + dbConfig); - Preconditions.checkState("false".equals(readonly), "readonly property must be at false value in write mode test in db confg: " + dbConfig); - } else { - // make sure db is on readonly mode - String readonly = p.getProperty("readonly"); - Preconditions.checkNotNull(readonly, "Could not find readonly property on db confg: " + dbConfig); - Preconditions.checkState("true".equals(readonly), "readonly property must be at true value in read mode test in db confg: " + dbConfig); - } - - config.initConfig(loader); - - TuttiPersistenceConfig.setInstance(config); - - if (log.isInfoEnabled()) { - log.info("Use db: " + config.getJdbcUrl()); - } - - if (log.isDebugEnabled()) { - log.debug("Use conf.properties at " + config.getDbConfigurationPath()); - } - - if (beanFactoryReferenceLocation != null) { - TuttiPersistenceServiceLocator.initTutti( - beanFactoryReferenceLocation, - beanRefFactoryReferenceId); - } - } - - protected final Set<File> toDetroy = Sets.newHashSet(); - - public void addToDestroy(File dir) { - toDetroy.add(dir); - } - - public void copyDb(String dbDirectory, boolean readonly, Properties p) throws IOException { - File externalDbFile = getResourceDirectory(dbDirectory); - copyDb(externalDbFile, readonly, p); - } - - public void copyDb(File target, boolean readonly, Properties p) throws IOException { - File db = new File("src/test/db"); - if (!db.exists()) { - - if (log.isWarnEnabled()) { - log.warn("Could not find db at " + db + ", test [" + - testClass + "] is skipped."); - } - Assume.assumeTrue(false); - } - toDetroy.add(target); - FileUtils.copyDirectory(db, target); - if (p != null) { - TuttiEntities.fillConnectionProperties( - p, - TuttiEntities.getJdbcUrl(target, config.getDbName()), - config.getJdbcUsername(), - config.getJdbcPassword()); - } - - // load db config - File dbConfig = new File(target, config.getDbName() + ".properties"); - Properties dbconf = new Properties(); - BufferedReader reader = Files.newReader(dbConfig, Charsets.UTF_8); - dbconf.load(reader); - reader.close(); - - // switch readonly flag according to the write parameter - dbconf.setProperty("readonly", String.valueOf(readonly)); - BufferedWriter writer = Files.newWriter(dbConfig, Charsets.UTF_8); - dbconf.store(writer, ""); - writer.close(); - - } - - protected void after(Description description) throws IOException { - if (log.isInfoEnabled()) { - log.info("After test " + testClass); - } - - Set<Failure> failures = TuttiRunListener.getFailuresForClass( - description.getClassName()); - - if (failures.isEmpty()) { - - // can destroy directories - for (File file : toDetroy) { - if (file.exists()) { - if (log.isInfoEnabled()) { - log.info("Destroy directory: " + file); - } - try { - FileUtils.deleteDirectory(file); - } catch (IOException e) { - if (log.isErrorEnabled()) { - log.error("Could not delete directory: " + file, e); - } - } - } - } - } else { - if (log.isWarnEnabled()) { - log.warn("Won't destroy directories cause of failures in test."); - } - } - - // push back old classLoader - if (oldClassLoader != null) { - Thread.currentThread().setContextClassLoader(oldClassLoader); - } - - TuttiPersistenceServiceLocator.close(); - - if (beanFactoryReferenceLocation != null) { - - // push back default tutti configuration - TuttiPersistenceServiceLocator.initTuttiDefault(); - } - - TuttiPersistenceConfig.setInstance(null); - } - - public Connection createEmptyDb(String dbDirectory, - String dbName) throws IOException, SQLException { - return createEmptyDb(dbDirectory, dbName, null); - } - - public Connection createEmptyDb(String dbDirectory, - String dbName, Properties p) throws IOException, SQLException { - File externalDbFile = getResourceDirectory(dbDirectory); - return createEmptyDb(externalDbFile, dbName, p); - } - - public Connection createEmptyDb(File directory, - String dbName) throws SQLException, IOException { - - return createEmptyDb(directory, dbName, null); - } - - public Connection createEmptyDb(File directory, - String dbName, Properties p) throws SQLException, IOException { - - if (log.isInfoEnabled()) { - log.info("Create new db at " + directory); - } - addToDestroy(directory); - String jdbcUrl = TuttiEntities.getJdbcUrl(directory, dbName); - String user = "SA"; - String password = ""; - - if (p != null) { - TuttiEntities.fillConnectionProperties(p, jdbcUrl, user, password); - } - File scriptFile = config.getConfig().getOptionAsFile(TUTTI_PERSISTENCE_JDBC_CREATE_SCRIPT); - - Preconditions.checkNotNull("Could not find db script in configuration with key " + TUTTI_PERSISTENCE_JDBC_CREATE_SCRIPT); - Preconditions.checkState(scriptFile.exists(), "Could not find db script at " + scriptFile); - - if (log.isInfoEnabled()) { - log.info("Will use create script: " + scriptFile); - } - Connection connection = TuttiEntities.createConnection(jdbcUrl, user, password); - - if (log.isInfoEnabled()) { - log.info("Created connection at " + connection.getMetaData().getURL()); - } - - List<String> importScriptSql = getImportScriptSql(scriptFile); - for (String sql : importScriptSql) { - PreparedStatement statement = connection.prepareStatement(sql); - statement.execute(); - } - connection.commit(); - return connection; - } - - protected List<String> getImportScriptSql(File scriptFile) throws IOException { - List<String> lines = Files.readLines(scriptFile, Charsets.UTF_8); - - List<String> result = Lists.newArrayListWithCapacity(lines.size()); - - Predicate<String> predicate = new Predicate<String>() { - - Set<String> forbiddenStarts = Sets.newHashSet( - "SET ", - "CREATE USER ", - "CREATE SCHEMA ", - "GRANT DBA TO "); - - @Override - public boolean apply(String input) { - boolean accept = true; - for (String forbiddenStart : forbiddenStarts) { - if (input.startsWith(forbiddenStart)) { - accept = false; - break; - } - } - return accept; - } - }; - for (String line : lines) { - if (predicate.apply(line.trim().toUpperCase())) { - result.add(line); - } - } - return result; - } -} Deleted: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/TuttiRunListener.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/TuttiRunListener.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/TuttiRunListener.java 2013-05-11 15:53:26 UTC (rev 935) @@ -1,95 +0,0 @@ -package fr.ifremer.tutti.persistence; - -/* - * #%L - * Tutti :: Persistence - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2012 - 2013 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 com.google.common.collect.Sets; -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.junit.runner.Description; -import org.junit.runner.notification.Failure; -import org.junit.runner.notification.RunListener; - -import java.util.Iterator; -import java.util.Set; - -/** - * Listen JUnit test and keep failures (in order to remove or not directories - * in {@link DatabaseResource}. - * - * @author tchemit <chemit@codelutin.com> - * @since 1.0.2 - */ -public final class TuttiRunListener extends RunListener { - - /** Logger. */ - private static final Log log = LogFactory.getLog(TuttiRunListener.class); - - protected static final Set<Failure> failures = Sets.newHashSet(); - - public static synchronized void beforeClass(Description description) { - - if (log.isDebugEnabled()) { - log.debug("Start to listen test " + description); - } - - Iterator<Failure> iterator = failures.iterator(); - String className = description.getClassName(); - while (iterator.hasNext()) { - Failure failure = iterator.next(); - if (className.equals(failure.getDescription().getClassName())) { - iterator.remove(); - } - } - } - - public static synchronized Set<Failure> getFailuresForClass(String className) { - Set<Failure> result = Sets.newHashSet(); - for (Failure failure : failures) { - if (className.equals(failure.getDescription().getClassName())) { - result.add(failure); - } - } - return result; - } - - @Override - public void testFailure(Failure failure) throws Exception { - if (log.isDebugEnabled()) { - log.debug("Adding failure: " + failure + ", for description: " + failure.getDescription()); - } - failures.add(failure); - super.testFailure(failure); - - } - - @Override - public void testAssumptionFailure(Failure failure) { - if (log.isDebugEnabled()) { - log.debug("Adding assumptionFailure: " + failure + ", for description: " + failure.getDescription()); - } - failures.add(failure); - super.testAssumptionFailure(failure); - } -} Deleted: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/TuttiRunner.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/TuttiRunner.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/TuttiRunner.java 2013-05-11 15:53:26 UTC (rev 935) @@ -1,64 +0,0 @@ -package fr.ifremer.tutti.persistence; - -/* - * #%L - * Tutti :: Persistence - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2012 - 2013 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 org.junit.runner.notification.RunNotifier; -import org.junit.runners.BlockJUnit4ClassRunner; -import org.junit.runners.model.FrameworkMethod; -import org.junit.runners.model.InitializationError; - -/** - * To use {@link TuttiRunListener}. - * <p/> - * Add this on top of your test (when run in IDE, otherise maven already add - * the listener for you, so no need of the runner). - * <pre> - * \@RunWith(TuttiRunner.class) - * </pre> - * - * @author tchemit <chemit@codelutin.com> - * @since 1.0.2 - */ - -public class TuttiRunner extends BlockJUnit4ClassRunner { - - public static final TuttiRunListener TUTTI_RUN_LISTENER = new TuttiRunListener(); - - /** - * Creates a BlockJUnit4ClassRunner to run {@code klass} - * - * @throws InitializationError if the test class is malformed. - */ - public TuttiRunner(Class<?> klass) throws InitializationError { - super(klass); - } - - @Override - protected void runChild(FrameworkMethod method, RunNotifier notifier) { - notifier.removeListener(TUTTI_RUN_LISTENER); - notifier.addListener(TUTTI_RUN_LISTENER); - super.runChild(method, notifier); - } -} Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceReadTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceReadTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceReadTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import org.junit.Before; import org.junit.ClassRule; import org.junit.Ignore; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceWriteTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceWriteTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.CaracteristicMap; import fr.ifremer.tutti.persistence.entities.TuttiEntities; import fr.ifremer.tutti.persistence.entities.data.AccidentalBatch; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceWriteTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceWriteTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.TuttiBeanFactory; import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.Attachment; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceReadTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceReadTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceReadTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -25,7 +25,7 @@ */ import com.google.common.collect.Maps; -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; import fr.ifremer.tutti.persistence.entities.data.BenthosBatch; import fr.ifremer.tutti.persistence.entities.data.FishingOperation; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceWriteTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceWriteTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -26,7 +26,7 @@ import com.google.common.collect.Lists; import com.google.common.collect.Maps; -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.TuttiBeanFactory; import fr.ifremer.tutti.persistence.entities.data.BenthosBatch; import fr.ifremer.tutti.persistence.entities.data.BenthosBatchFrequency; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceReadTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceReadTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceReadTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.InvalidBatchModelException; import fr.ifremer.tutti.persistence.entities.data.FishingOperation; import org.junit.Before; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceWriteTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceWriteTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.InvalidBatchModelException; import fr.ifremer.tutti.persistence.entities.TuttiBeanFactory; import fr.ifremer.tutti.persistence.entities.data.CatchBatch; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceReadTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceReadTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceReadTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.data.Cruise; import org.junit.Assert; import org.junit.Before; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceWriteTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceWriteTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -25,7 +25,7 @@ */ import com.google.common.collect.Lists; -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.TuttiBeanFactory; import fr.ifremer.tutti.persistence.entities.data.Cruise; import fr.ifremer.tutti.persistence.entities.referential.Gear; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceReadTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceReadTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceReadTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.data.FishingOperation; import org.junit.Before; import org.junit.ClassRule; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceWriteTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceWriteTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.CaracteristicMap; import fr.ifremer.tutti.persistence.entities.TuttiBeanFactory; import fr.ifremer.tutti.persistence.entities.data.Cruise; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceWriteTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceWriteTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.CaracteristicMap; import fr.ifremer.tutti.persistence.entities.TuttiEntities; import fr.ifremer.tutti.persistence.entities.data.Cruise; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceReadTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceReadTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceReadTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import org.junit.Before; import org.junit.ClassRule; import org.junit.Ignore; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceWriteTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceWriteTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.TuttiBeanFactory; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; import fr.ifremer.tutti.persistence.entities.data.CatchBatch; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/PlanktonBatchPersistenceServiceReadTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/PlanktonBatchPersistenceServiceReadTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/PlanktonBatchPersistenceServiceReadTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import org.junit.Before; import org.junit.ClassRule; import org.junit.Ignore; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/PlanktonBatchPersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/PlanktonBatchPersistenceServiceWriteTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/PlanktonBatchPersistenceServiceWriteTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import org.junit.Before; import org.junit.ClassRule; import org.junit.Ignore; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceReadTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceReadTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceReadTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.data.Program; import org.junit.Assert; import org.junit.Before; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceWriteTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceWriteTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.TuttiBeanFactory; import fr.ifremer.tutti.persistence.entities.data.Program; import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProtocolPersistenceServiceReadTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProtocolPersistenceServiceReadTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProtocolPersistenceServiceReadTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -25,7 +25,7 @@ */ import com.google.common.collect.Lists; -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.TuttiBeanFactory; import fr.ifremer.tutti.persistence.entities.protocol.SpeciesProtocol; import fr.ifremer.tutti.persistence.entities.protocol.TuttiProtocol; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProtocolPersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProtocolPersistenceServiceWriteTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ProtocolPersistenceServiceWriteTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -25,7 +25,7 @@ */ import com.google.common.collect.Lists; -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.TuttiBeanFactory; import fr.ifremer.tutti.persistence.entities.protocol.SpeciesProtocol; import fr.ifremer.tutti.persistence.entities.protocol.TuttiProtocol; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceReadTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceReadTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceReadTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -25,8 +25,8 @@ */ import fr.ifremer.adagio.core.service.technical.CacheService; -import fr.ifremer.tutti.persistence.DatabaseFixtures; -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseFixtures; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.TuttiEntities; import fr.ifremer.tutti.persistence.entities.TuttiEntity; import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceWriteTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceWriteTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -25,7 +25,7 @@ */ import com.google.common.collect.Lists; -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.TuttiBeanFactory; import fr.ifremer.tutti.persistence.entities.referential.Gear; import fr.ifremer.tutti.persistence.entities.referential.Person; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceReadTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceReadTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceReadTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -25,7 +25,7 @@ */ import com.google.common.collect.Maps; -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; import fr.ifremer.tutti.persistence.entities.data.FishingOperation; import fr.ifremer.tutti.persistence.entities.data.SampleCategoryEnum; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceWriteTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceWriteTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -26,7 +26,7 @@ import com.google.common.collect.Lists; import com.google.common.collect.Maps; -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.TuttiBeanFactory; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; import fr.ifremer.tutti.persistence.entities.data.CatchBatch; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFileTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFileTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFileTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import org.junit.Assert; import org.junit.ClassRule; import org.junit.Test; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeHelperTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeHelperTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeHelperTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.TuttiEntities; import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator; import org.apache.commons.lang3.ObjectUtils; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceCopyTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceCopyTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceCopyTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.ProgressionModel; import fr.ifremer.tutti.persistence.entities.TuttiEntities; import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImplTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImplTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImplTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.ProgressionModel; import fr.ifremer.tutti.persistence.entities.TuttiEntities; import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator; Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImplUpTodateTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImplUpTodateTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/synchro/ReferentialSynchronizeServiceImplUpTodateTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.test.DatabaseResource; import fr.ifremer.tutti.persistence.entities.TuttiEntities; import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator; import org.hibernate.dialect.Dialect; Modified: trunk/tutti-service/pom.xml =================================================================== --- trunk/tutti-service/pom.xml 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-service/pom.xml 2013-05-11 15:53:26 UTC (rev 935) @@ -192,6 +192,23 @@ </plugins> + + <pluginManagement> + <plugins> + <plugin> + <artifactId>maven-surefire-plugin</artifactId> + <configuration> + <properties> + <property> + <name>listener</name> + <value>fr.ifremer.tutti.persistence.test.TuttiRunListener</value> + </property> + </properties> + </configuration> + </plugin> + </plugins> + </pluginManagement> + </build> </project> Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/ExportCatchesReportService.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/ExportCatchesReportService.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/ExportCatchesReportService.java 2013-05-11 15:53:26 UTC (rev 935) @@ -26,10 +26,13 @@ import com.google.common.collect.Lists; import com.google.common.collect.Maps; -import com.itextpdf.text.DocumentException; import fr.ifremer.tutti.TuttiBusinessException; import fr.ifremer.tutti.TuttiTechnicalException; -import fr.ifremer.tutti.persistence.entities.data.*; +import fr.ifremer.tutti.persistence.entities.data.BatchContainer; +import fr.ifremer.tutti.persistence.entities.data.BenthosBatch; +import fr.ifremer.tutti.persistence.entities.data.CatchBatch; +import fr.ifremer.tutti.persistence.entities.data.FishingOperation; +import fr.ifremer.tutti.persistence.entities.data.SpeciesBatch; import fr.ifremer.tutti.persistence.entities.referential.Species; import fr.ifremer.tutti.service.AbstractTuttiService; import fr.ifremer.tutti.service.PersistenceService; @@ -38,13 +41,20 @@ import freemarker.ext.beans.BeansWrapper; import freemarker.template.Configuration; import freemarker.template.Template; -import freemarker.template.TemplateException; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.io.IOUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; import org.xhtmlrenderer.pdf.ITextRenderer; -import java.io.*; -import java.util.*; +import java.io.File; +import java.io.FileOutputStream; +import java.io.OutputStream; +import java.io.StringWriter; +import java.io.Writer; +import java.util.List; +import java.util.Locale; +import java.util.Map; import static org.nuiton.i18n.I18n._; @@ -54,6 +64,10 @@ */ public class ExportCatchesReportService extends AbstractTuttiService { + /** Logger. */ + private static final Log log = + LogFactory.getLog(ExportCatchesReportService.class); + protected Configuration freemarkerConfiguration; protected PersistenceService persistenceService; @@ -88,7 +102,7 @@ * Generate the PDF report * * @param targetFile pdf file to generate - * @param locale generated pdf locale + * @param locale generated pdf locale * @return the generated file * @throws TuttiBusinessException */ @@ -108,6 +122,18 @@ // get operation and catch data String fishingOperationId = fishingOperation.getId(); + + boolean withCatchBatch = + persistenceService.isFishingOperationWithCatchBatch( + fishingOperationId); + + if (!withCatchBatch) { + if (log.isWarnEnabled()) { + log.warn("Skip fishing operation " + fishingOperation + + " since no catchBatch associated."); + } + continue; + } CatchBatch catchBatch = persistenceService.getCatchBatchFromFishingOperation(fishingOperationId); BatchContainer<SpeciesBatch> rootSpeciesBatch; Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/TuttiWeightComputingService.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/TuttiWeightComputingService.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/TuttiWeightComputingService.java 2013-05-11 15:53:26 UTC (rev 935) @@ -24,7 +24,6 @@ * #L% */ -import com.google.common.collect.Lists; import com.google.common.collect.Maps; import fr.ifremer.tutti.TuttiBusinessException; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; @@ -45,7 +44,6 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.nuiton.validator.NuitonValidatorResult; -import org.nuiton.validator.NuitonValidatorScope; import java.util.List; import java.util.Map; @@ -99,6 +97,18 @@ for (FishingOperation fishingOperation : allFishingOperation) { String fishingOperationId = fishingOperation.getId(); + + boolean withCatchBatch = + persistenceService.isFishingOperationWithCatchBatch( + fishingOperationId); + + if (!withCatchBatch) { + if (log.isWarnEnabled()) { + log.warn("Skip fishing operation " + fishingOperation + + " since no catchBatch associated."); + } + continue; + } CatchBatch catchBatch = persistenceService.getCatchBatchFromFishingOperation(fishingOperationId); BatchContainer<SpeciesBatch> rootSpeciesBatch; Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/ValidateCruiseOperationsService.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/ValidateCruiseOperationsService.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/ValidateCruiseOperationsService.java 2013-05-11 15:53:26 UTC (rev 935) @@ -50,7 +50,6 @@ import org.apache.commons.logging.LogFactory; import org.nuiton.validator.NuitonValidatorResult; import org.nuiton.validator.NuitonValidatorScope; -import org.springframework.dao.DataRetrievalFailureException; import java.io.File; import java.io.IOException; @@ -180,31 +179,35 @@ String fishingOperationId = fishingOperation.getId(); - try { - CatchBatch catchBatch = - persistenceService.getCatchBatchFromFishingOperation(fishingOperationId); + boolean withCatchBatch = + persistenceService.isFishingOperationWithCatchBatch( + fishingOperationId); - checkOperation(fishingOperation, catchBatch, validator); - } catch (DataRetrievalFailureException e) { - // batch not found - if (log.isDebugEnabled()) { - log.debug("Catch batch not found", e); + if (!withCatchBatch) { + if (log.isWarnEnabled()) { + log.warn("Skip fishing operation " + fishingOperation + + " since no catchBatch associated."); } Map<String, List<String>> errorMap = Maps.newHashMap(); errorMap.put("catches", Lists.newArrayList(_("tutti.validator.warning.fishingOperation.batch.notFound"))); validator.addMessagesForScope(NuitonValidatorScope.WARNING, errorMap); + } else { + try { + CatchBatch catchBatch = + persistenceService.getCatchBatchFromFishingOperation(fishingOperationId); - } catch (InvalidBatchModelException e) { + checkOperation(fishingOperation, catchBatch, validator); + } catch (InvalidBatchModelException e) { - // batch is not compatible with Tutti - if (log.isDebugEnabled()) { - log.debug("Invalid batch model", e); + // batch is not compatible with Tutti + if (log.isDebugEnabled()) { + log.debug("Invalid batch model", e); + } + Map<String, List<String>> errorMap = Maps.newHashMap(); + errorMap.put("catches", Lists.newArrayList(_("tutti.validator.warning.fishingOperation.invalid.batch.model"))); + validator.addMessagesForScope(NuitonValidatorScope.WARNING, errorMap); } - Map<String, List<String>> errorMap = Maps.newHashMap(); - errorMap.put("catches", Lists.newArrayList(_("tutti.validator.warning.fishingOperation.invalid.batch.model"))); - validator.addMessagesForScope(NuitonValidatorScope.WARNING, errorMap); } - } /** Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/config/TuttiServiceConfig.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/config/TuttiServiceConfig.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/config/TuttiServiceConfig.java 2013-05-11 15:53:26 UTC (rev 935) @@ -49,10 +49,14 @@ protected final TuttiPersistenceConfig persistenceConfig; public TuttiServiceConfig(ApplicationConfig applicationConfig) { + this(new TuttiPersistenceConfig(applicationConfig)); + } - this.applicationConfig = applicationConfig; + public TuttiServiceConfig(TuttiPersistenceConfig persistenceConfig) { - this.persistenceConfig = new TuttiPersistenceConfig(applicationConfig); + this.applicationConfig = persistenceConfig.getConfig(); + + this.persistenceConfig = persistenceConfig; } public ApplicationConfig getApplicationConfig() { @@ -142,4 +146,9 @@ applicationConfig.setOption( TuttiServiceConfigOption.CSV_SEPARATOR.getKey(), c + ""); } + + public void setExportCountry(String exportCountryId) { + applicationConfig.setOption( + TuttiServiceConfigOption.EXPORT_COUNTRY_ID.getKey(), exportCountryId); + } } Added: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/AccidentalCatchExportModel.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/AccidentalCatchExportModel.java (rev 0) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/AccidentalCatchExportModel.java 2013-05-11 15:53:26 UTC (rev 935) @@ -0,0 +1,171 @@ +package fr.ifremer.tutti.service.export; + +/* + * #%L + * Tutti :: Service + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2012 - 2013 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.tutti.persistence.entities.CaracteristicMap; +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.data.Program; +import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; +import fr.ifremer.tutti.persistence.entities.referential.Gear; +import fr.ifremer.tutti.persistence.entities.referential.Species; +import fr.ifremer.tutti.persistence.entities.referential.Vessel; +import fr.ifremer.tutti.service.PersistenceService; +import fr.ifremer.tutti.service.TuttiCsvUtil; +import org.apache.commons.collections.CollectionUtils; +import org.apache.commons.collections.MapUtils; + +import java.io.Serializable; +import java.util.List; +import java.util.Map; + +/** + * TODO + * + * @author tchemit <chemit@codelutin.com> + * @since 2.2 + */ +public class AccidentalCatchExportModel extends TuttiCsvUtil.AbstractTuttiExportModel<AccidentalCatchExportRow> { + + protected final Caracteristic caracteristicDeadOrAliveSize; + + protected final Caracteristic caracteristicGender; + + protected final Caracteristic caracteristicWeight; + + protected final Caracteristic caracteristicPmfmId; + + public AccidentalCatchExportModel( + char separator, + Caracteristic caracteristicDeadOrAliveSize, + Caracteristic caracteristicGender, + Caracteristic caracteristicWeight, + Caracteristic caracteristicPmfmId) { + super(separator); + + this.caracteristicDeadOrAliveSize = caracteristicDeadOrAliveSize; + this.caracteristicGender = caracteristicGender; + this.caracteristicWeight = caracteristicWeight; + this.caracteristicPmfmId = caracteristicPmfmId; + + newColumnForExport("Annee", Cruise.PROPERTY_BEGIN_DATE, TuttiCsvUtil.YEAR); + newColumnForExport("Serie", Cruise.PROPERTY_PROGRAM, Program.PROPERTY_NAME); + newColumnForExport("Serie_Partielle", Cruise.PROPERTY_SURVEY_PART); + newColumnForExport("Engin", FishingOperation.PROPERTY_GEAR, Gear.PROPERTY_NAME); + newColumnForExport("Poche", FishingOperation.PROPERTY_MULTIRIG_AGGREGATION); + newColumnForExport("Id_Operation", FishingOperation.PROPERTY_STATION_NUMBER); + newColumnForExport("NumOrdre_Station", FishingOperation.PROPERTY_FISHING_OPERATION_NUMBER, TuttiCsvUtil.INTEGER); + newColumnForExport("Navire", Cruise.PROPERTY_VESSEL, Vessel.PROPERTY_NAME); + + newColumnForExport("BatchId", AccidentalCatchExportRow.PROPERTY_BATCH_ID, TuttiCsvUtil.PRIMITIVE_INTEGER); + newColumnForExport("ReferenceTaxonId", AccidentalBatch.PROPERTY_SPECIES + "." + Species.PROPERTY_REFERENCE_TAXON_ID, TuttiCsvUtil.PRIMITIVE_INTEGER); + newColumnForExport("ReferenceTaxonName", AccidentalBatch.PROPERTY_SPECIES + "." + Species.PROPERTY_NAME); + newColumnForExport("Comment", AccidentalBatch.PROPERTY_COMMENT); + newColumnForExport("CaracteristicId", AccidentalCatchExportRow.PROPERTY_CARACTERISTIC, Caracteristic.PROPERTY_ID); + newColumnForExport("CaracteristicValue", AccidentalCatchExportRow.PROPERTY_CARACTERISTIC_VALUE, TuttiCsvUtil.CARACTERISTIC_VALUE_FORMATTER); + } + + public void prepareRows(PersistenceService persistenceService, + List<AccidentalCatchExportRow> rows, + Cruise cruise, + FishingOperation operation) { + + List<AccidentalBatch> observations = + persistenceService.getAllAccidentalBatch(operation.getId()); + + if (CollectionUtils.isNotEmpty(observations)) { + for (AccidentalBatch child : observations) { + + addCaracteristicRow(rows, + cruise, + operation, + child, + caracteristicDeadOrAliveSize, + child.getDeadOrAlive()); + + addCaracteristicRow(rows, + cruise, + operation, + child, + caracteristicGender, + child.getGender()); + + addCaracteristicRow(rows, + cruise, + operation, + child, + caracteristicWeight, + child.getWeight()); + + if (child.getLengthStepCaracteristic() != null) { + addCaracteristicRow(rows, + cruise, + operation, + child, + caracteristicPmfmId, + child.getLengthStepCaracteristic().getIdAsInt()); + + addCaracteristicRow(rows, + cruise, + operation, + child, + child.getLengthStepCaracteristic(), + child.getSize()); + } + + CaracteristicMap caracteristics = child.getCaracteristics(); + if (MapUtils.isNotEmpty(caracteristics)) { + for (Map.Entry<Caracteristic, Serializable> entry : caracteristics.entrySet()) { + addCaracteristicRow(rows, + cruise, + operation, + child, + entry.getKey(), + entry.getValue()); + } + } + } + } + } + + private void addCaracteristicRow(List<AccidentalCatchExportRow> rows, + Cruise cruise, + FishingOperation operation, + AccidentalBatch child, + Caracteristic caracteristic, + Serializable caracteristicValue) { + if (caracteristicValue != null) { + + AccidentalCatchExportRow row = new AccidentalCatchExportRow(); + row.setCruise(cruise); + row.setFishingOperation(operation); + row.setBatch(child); + row.setCaracteristic(caracteristic); + row.setCaracteristicValue(caracteristicValue); + rows.add(row); + } + } +} \ No newline at end of file Property changes on: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/AccidentalCatchExportModel.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native Added: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/AccidentalCatchExportRow.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/AccidentalCatchExportRow.java (rev 0) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/AccidentalCatchExportRow.java 2013-05-11 15:53:26 UTC (rev 935) @@ -0,0 +1,139 @@ +package fr.ifremer.tutti.service.export; + +/* + * #%L + * Tutti :: Service + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2012 - 2013 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.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.data.Program; +import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; +import fr.ifremer.tutti.persistence.entities.referential.Gear; +import fr.ifremer.tutti.persistence.entities.referential.Species; +import fr.ifremer.tutti.persistence.entities.referential.Vessel; + +import java.io.Serializable; +import java.util.Date; + +/** + * A row in a accidental catch export. + * + * @author tchemit <chemit@codelutin.com> + * @since 2.2 + */ +public class AccidentalCatchExportRow implements Serializable { + + public static final String PROPERTY_BATCH = "batch"; + + private static final long serialVersionUID = 1L; + + public static final String PROPERTY_BATCH_ID = "batchId"; + + public static final String PROPERTY_CARACTERISTIC = "caracteristic"; + + public static final String PROPERTY_CARACTERISTIC_VALUE = "caracteristicValue"; + + protected Cruise cruise; + + protected FishingOperation fishingOperation; + + protected AccidentalBatch batch; + + protected Caracteristic caracteristic; + + protected Serializable caracteristicValue; + + public void setCruise(Cruise cruise) { + this.cruise = cruise; + } + + public void setFishingOperation(FishingOperation fishingOperation) { + this.fishingOperation = fishingOperation; + } + + public void setBatch(AccidentalBatch batch) { + this.batch = batch; + } + + public void setCaracteristic(Caracteristic caracteristic) { + this.caracteristic = caracteristic; + } + + public void setCaracteristicValue(Serializable caracteristicValue) { + this.caracteristicValue = caracteristicValue; + } + + public Integer getBatchId() { + return batch.getIdAsInt(); + } + + public Caracteristic getCaracteristic() { + return caracteristic; + } + + public Serializable getCaracteristicValue() { + return caracteristicValue; + } + + public String getComment() { + return batch.getComment(); + } + + public Species getSpecies() { + return batch.getSpecies(); + } + + public Date getBeginDate() { + return cruise.getBeginDate(); + } + + public Program getProgram() { + return cruise.getProgram(); + } + + public String getSurveyPart() { + return cruise.getSurveyPart(); + } + + public String getStationNumber() { + return fishingOperation.getStationNumber(); + } + + public Integer getFishingOperationNumber() { + return fishingOperation.getFishingOperationNumber(); + } + + public Gear getGear() { + return fishingOperation.getGear(); + } + + public Vessel getVessel() { + return fishingOperation.getVessel(); + } + + public String getMultirigAggregation() { + return fishingOperation.getMultirigAggregation(); + } + +} Property changes on: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/AccidentalCatchExportRow.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/CatchExportModel.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/CatchExportModel.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/CatchExportModel.java 2013-05-11 15:53:26 UTC (rev 935) @@ -51,6 +51,8 @@ */ public class CatchExportModel extends TuttiCsvUtil.AbstractTuttiExportModel<CatchExportRow> { + public static final String WEIGHT_OR_VOL_TYPE = "Poids"; + public CatchExportModel(char separator, List<SampleCategoryEnum> samplingOrder) { super(separator); @@ -64,46 +66,46 @@ newColumnForExport("Navire", Cruise.PROPERTY_VESSEL, Vessel.PROPERTY_NAME); newColumnForExport("Taxon", CatchExportRow.SPECIES_SAMPLE_CATEGORY); - newColumnForExport("NumOrdre_Taxon_H2", CatchExportRow.SPECIES_SAMPLE_CATEGORY); + newColumnForExport("NumOrdre_Taxon_H2", CatchExportRow.SPECIES_SAMPLE_CATEGORY + "." + ExportSampleCategory.PROPERTY_RANK_ORDER, TuttiCsvUtil.INTEGER); newColumnForExport("Tot_Taxon", CatchExportRow.SPECIES_SAMPLE_CATEGORY); newColumnForExport("Ech_Taxon", CatchExportRow.SPECIES_SAMPLE_CATEGORY); - newColumnForExport("Type_Volume_Poids_Taxon", CatchExportRow.SPECIES_SAMPLE_CATEGORY); - newColumnForExport("Unite_Volume_Poids_Taxon", CatchExportRow.SPECIES_SAMPLE_CATEGORY); + newColumnForExport("Type_Volume_Poids_Taxon", CatchExportRow.SPECIES_SAMPLE_CATEGORY + "." + ExportSampleCategory.PROPERTY_WEIGHT_OR_VOL_TYPE); + newColumnForExport("Unite_Volume_Poids_Taxon", CatchExportRow.SPECIES_SAMPLE_CATEGORY + "." + Caracteristic.PROPERTY_UNIT); for (SampleCategoryEnum sampleCategoryEnum : samplingOrder) { switch (sampleCategoryEnum) { case sortedUnsorted: newColumnForExport("Vrac/Hors_Vrac", CatchExportRow.SORTED_UNSORTED_SAMPLE_CATEGORY); - newColumnForExport("NumOrdre_Vrac_H2", CatchExportRow.SORTED_UNSORTED_SAMPLE_CATEGORY); + newColumnForExport("NumOrdre_Vrac_H2", CatchExportRow.SORTED_UNSORTED_SAMPLE_CATEGORY + "." + ExportSampleCategory.PROPERTY_RANK_ORDER, TuttiCsvUtil.INTEGER); newColumnForExport("Tot_Vrac", CatchExportRow.SORTED_UNSORTED_SAMPLE_CATEGORY); newColumnForExport("Ech_Vrac", CatchExportRow.SORTED_UNSORTED_SAMPLE_CATEGORY); - newColumnForExport("Type_Volume_Poids_Vrac", CatchExportRow.SORTED_UNSORTED_SAMPLE_CATEGORY); - newColumnForExport("Unite_Volume_Poids_Vrac", CatchExportRow.SORTED_UNSORTED_SAMPLE_CATEGORY); + newColumnForExport("Type_Volume_Poids_Vrac", CatchExportRow.SORTED_UNSORTED_SAMPLE_CATEGORY + "." + ExportSampleCategory.PROPERTY_WEIGHT_OR_VOL_TYPE); + newColumnForExport("Unite_Volume_Poids_Vrac", CatchExportRow.SORTED_UNSORTED_SAMPLE_CATEGORY + "." + Caracteristic.PROPERTY_UNIT); break; case size: newColumnForExport("Categorie", CatchExportRow.SIZE_SAMPLE_CATEGORY); - newColumnForExport("NumOrdre_Cat_H2", CatchExportRow.SIZE_SAMPLE_CATEGORY); + newColumnForExport("NumOrdre_Cat_H2", CatchExportRow.SIZE_SAMPLE_CATEGORY + "." + ExportSampleCategory.PROPERTY_RANK_ORDER, TuttiCsvUtil.INTEGER); newColumnForExport("Tot_Cat", CatchExportRow.SIZE_SAMPLE_CATEGORY); newColumnForExport("Ech_Cat", CatchExportRow.SIZE_SAMPLE_CATEGORY); - newColumnForExport("Type_Volume_Poids_Cat", CatchExportRow.SIZE_SAMPLE_CATEGORY); - newColumnForExport("Unite_Volume_Poids_Cat", CatchExportRow.SIZE_SAMPLE_CATEGORY); + newColumnForExport("Type_Volume_Poids_Cat", CatchExportRow.SIZE_SAMPLE_CATEGORY + "." + ExportSampleCategory.PROPERTY_WEIGHT_OR_VOL_TYPE); + newColumnForExport("Unite_Volume_Poids_Cat", CatchExportRow.SIZE_SAMPLE_CATEGORY + "." + Caracteristic.PROPERTY_UNIT); break; case sex: newColumnForExport("Sexe", CatchExportRow.SEX_SAMPLE_CATEGORY); - newColumnForExport("NumOrdre_Sexe_H2", CatchExportRow.SEX_SAMPLE_CATEGORY); + newColumnForExport("NumOrdre_Sexe_H2", CatchExportRow.SEX_SAMPLE_CATEGORY + "." + ExportSampleCategory.PROPERTY_RANK_ORDER, TuttiCsvUtil.INTEGER); newColumnForExport("Tot_Sexe", CatchExportRow.SEX_SAMPLE_CATEGORY); newColumnForExport("Ech_Sexe", CatchExportRow.SEX_SAMPLE_CATEGORY); - newColumnForExport("Type_Volume_Poids_Sexe", CatchExportRow.SEX_SAMPLE_CATEGORY); - newColumnForExport("Unite_Volume_Poids_Sexe", CatchExportRow.SEX_SAMPLE_CATEGORY); + newColumnForExport("Type_Volume_Poids_Sexe", CatchExportRow.SEX_SAMPLE_CATEGORY + "." + ExportSampleCategory.PROPERTY_WEIGHT_OR_VOL_TYPE); + newColumnForExport("Unite_Volume_Poids_Sexe", CatchExportRow.SEX_SAMPLE_CATEGORY + "." + Caracteristic.PROPERTY_UNIT); break; case maturity: newColumnForExport("Maturite", CatchExportRow.MATURITY_SAMPLE_CATEGORY); - newColumnForExport("NumOrdre_Maturite_H2", CatchExportRow.MATURITY_SAMPLE_CATEGORY); + newColumnForExport("NumOrdre_Maturite_H2", CatchExportRow.MATURITY_SAMPLE_CATEGORY + "." + ExportSampleCategory.PROPERTY_RANK_ORDER, TuttiCsvUtil.INTEGER); newColumnForExport("Tot_Maturite", CatchExportRow.MATURITY_SAMPLE_CATEGORY); newColumnForExport("Ech_Maturite", CatchExportRow.MATURITY_SAMPLE_CATEGORY); - newColumnForExport("Type_Volume_Poids_Maturite", CatchExportRow.MATURITY_SAMPLE_CATEGORY); - newColumnForExport("Unite_Volume_Poids_Maturite", CatchExportRow.MATURITY_SAMPLE_CATEGORY); + newColumnForExport("Type_Volume_Poids_Maturite", CatchExportRow.MATURITY_SAMPLE_CATEGORY + "." + ExportSampleCategory.PROPERTY_WEIGHT_OR_VOL_TYPE); + newColumnForExport("Unite_Volume_Poids_Maturite", CatchExportRow.MATURITY_SAMPLE_CATEGORY + "." + Caracteristic.PROPERTY_UNIT); break; case age: newColumnForExport("Age", CatchExportRow.AGE_SAMPLE_CATEGORY); @@ -116,11 +118,11 @@ newColumnForExport("Code_Longueur", CatchExportRow.FREQUENCY_LENGTH_STEP_CARACTERISTIC, Caracteristic.PROPERTY_ID); newColumnForExport("Taille", CatchExportRow.FREQUENCY_LENGTH_STEP); - newColumnForExport("NumOrdre_Taille_H2", Cruise.PROPERTY_HEAD_OF_MISSION); - newColumnForExport("Poids_Classe_Taille", CatchExportRow.FREQUENCY_WEIGHT); - newColumnForExport("Unite_Taille", CatchExportRow.FREQUENCY_LENGTH_STEP_CARACTERISTIC); - newColumnForExport("Precision_Mesure", CatchExportRow.FREQUENCY_LENGTH_STEP_CARACTERISTIC); - newColumnForExport("Nbr", CatchExportRow.FREQUENCY_NUMBER); + newColumnForExport("NumOrdre_Taille_H2", CatchExportRow.FREQUENCY_RANK_ORDER, TuttiCsvUtil.INTEGER); + newColumnForExport("Poids_Classe_Taille", CatchExportRow.FREQUENCY_WEIGHT, TuttiCsvUtil.FLOAT); + newColumnForExport("Unite_Taille", CatchExportRow.FREQUENCY_LENGTH_STEP_CARACTERISTIC + "." + Caracteristic.PROPERTY_UNIT); + newColumnForExport("Precision_Mesure", CatchExportRow.FREQUENCY_LENGTH_STEP_CARACTERISTIC + "." + Caracteristic.PROPERTY_PRECISION, TuttiCsvUtil.FLOAT); + newColumnForExport("Nbr", CatchExportRow.FREQUENCY_NUMBER, TuttiCsvUtil.INTEGER); newColumnForExport("Poids_Reference", Cruise.PROPERTY_HEAD_OF_SORT_ROOM); newColumnForExport("Coef_Final_Elevation", Cruise.PROPERTY_COMMENT); @@ -144,7 +146,8 @@ speciesCategory.setComputedWeight(speciesBatch.getComputedWeight()); speciesCategory.setNumber(speciesBatch.getNumber()); speciesCategory.setComputedNumber(speciesBatch.getComputedNumber()); - + speciesCategory.setWeightOrVolType(WEIGHT_OR_VOL_TYPE); + speciesCategory.setRankOrder(speciesBatch.getRankOrder()); row.setSpeciesCategory(speciesCategory); prepareRows(persistenceService, row, rows, speciesBatch); } @@ -158,7 +161,8 @@ speciesCategory.setComputedWeight(benthosBatch.getComputedWeight()); speciesCategory.setNumber(benthosBatch.getNumber()); speciesCategory.setComputedNumber(benthosBatch.getComputedNumber()); - + speciesCategory.setWeightOrVolType(WEIGHT_OR_VOL_TYPE); + speciesCategory.setRankOrder(benthosBatch.getRankOrder()); row.setSpeciesCategory(speciesCategory); prepareRows(persistenceService, row, rows, benthosBatch); } @@ -177,6 +181,8 @@ sampleCategory.setComputedWeight(speciesBatch.getSampleCategoryComputedWeight()); sampleCategory.setNumber(speciesBatch.getNumber()); sampleCategory.setComputedNumber(speciesBatch.getComputedNumber()); + sampleCategory.setWeightOrVolType(WEIGHT_OR_VOL_TYPE); + sampleCategory.setRankOrder(speciesBatch.getRankOrder()); currentRow.addCategory(sampleCategory); @@ -195,7 +201,7 @@ } else { for (SpeciesBatchFrequency batchFrequency : speciesBatchFrequency) { CatchExportRow row = currentRow.copy(); - row.setSpeciesFrequency(batchFrequency); + row.setFrequency(batchFrequency); rows.add(row); } } @@ -212,7 +218,6 @@ CatchExportRow currentRow, List<CatchExportRow> rows, BenthosBatch benthosBatch) { + } - - } } \ No newline at end of file Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/CatchExportRow.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/CatchExportRow.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/CatchExportRow.java 2013-05-11 15:53:26 UTC (rev 935) @@ -25,7 +25,6 @@ */ import com.google.common.collect.Maps; -import fr.ifremer.tutti.persistence.entities.data.BenthosBatchFrequency; import fr.ifremer.tutti.persistence.entities.data.Cruise; import fr.ifremer.tutti.persistence.entities.data.FishingOperation; import fr.ifremer.tutti.persistence.entities.data.Program; @@ -57,6 +56,8 @@ public static final String FREQUENCY_NUMBER = "frequencyNumber"; + public static final String FREQUENCY_RANK_ORDER = "frequencyRankOrder"; + public static final String SPECIES_SAMPLE_CATEGORY = "speciesSampleCategory"; public static final String SORTED_UNSORTED_SAMPLE_CATEGORY = "sortedUnsortedSampleCategory"; @@ -77,10 +78,8 @@ protected final Map<SampleCategoryEnum, ExportSampleCategory> categories = Maps.newEnumMap(SampleCategoryEnum.class); - protected SpeciesBatchFrequency speciesFrequency; + protected SpeciesBatchFrequency frequency; - protected BenthosBatchFrequency benthosFrequency; - public void setCruise(Cruise cruise) { this.cruise = cruise; } @@ -97,14 +96,10 @@ categories.put(sampleCategory.getCategoryType(), sampleCategory); } - public void setSpeciesFrequency(SpeciesBatchFrequency speciesFrequency) { - this.speciesFrequency = speciesFrequency; + public void setFrequency(SpeciesBatchFrequency speciesFrequency) { + this.frequency = speciesFrequency; } - public void setBenthosFrequency(BenthosBatchFrequency benthosFrequency) { - this.benthosFrequency = benthosFrequency; - } - public Date getBeginDate() { return cruise.getBeginDate(); } @@ -138,45 +133,25 @@ } public Caracteristic getFrequencyLengthStepCaracteristic() { - Caracteristic result; - if (speciesFrequency == null) { - result = benthosFrequency.getLengthStepCaracteristic(); - } else { - result = speciesFrequency.getLengthStepCaracteristic(); - } - return result; + return frequency == null ? null : frequency.getLengthStepCaracteristic(); } public Float getFrequencyLengthStep() { - Float result; - if (speciesFrequency == null) { - result = benthosFrequency.getLengthStep(); - } else { - result = speciesFrequency.getLengthStep(); - } - return result; + return frequency == null ? null : frequency.getLengthStep(); } public Float getFrequencyWeight() { - Float result; - if (speciesFrequency == null) { - result = benthosFrequency.getWeight(); - } else { - result = speciesFrequency.getWeight(); - } - return result; + return frequency == null ? null : frequency.getWeight(); } public Integer getFrequencyNumber() { - Integer result; - if (speciesFrequency == null) { - result = benthosFrequency.getNumber(); - } else { - result = speciesFrequency.getNumber(); - } - return result; + return frequency == null ? null : frequency.getNumber(); } + public Integer getFrequencyRankOrder() { + return frequency == null ? null : frequency.getRankOrder(); + } + public ExportSampleCategory getSpeciesSampleCategory() { return speciesCategory; } @@ -207,8 +182,7 @@ result.setFishingOperation(fishingOperation); result.setSpeciesCategory(speciesCategory); result.categories.putAll(categories); - result.setSpeciesFrequency(speciesFrequency); - result.setBenthosFrequency(benthosFrequency); + result.setFrequency(frequency); return result; } Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/ExportSampleCategory.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/ExportSampleCategory.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/ExportSampleCategory.java 2013-05-11 15:53:26 UTC (rev 935) @@ -39,10 +39,27 @@ private static final long serialVersionUID = 1L; + public static final String PROPERTY_CATEGORY_VALUE = "categoryValue"; + + public static final String PROPERTY_CATEGORY_WEIGHT = "categoryWeight"; + + public static final String PROPERTY_NUMBER = "number"; + + public static final String PROPERTY_COMPUTED_WEIGHT = "computedWeight"; + + public static final String PROPERTY_COMPUTED_NUMBER = "computedNumber"; + + public static final String PROPERTY_WEIGHT_OR_VOL_TYPE = "weightOrVolType"; + + public static final String PROPERTY_RANK_ORDER= "rankOrder"; + private Integer number; private Integer computedNumber; + private Integer rankOrder; + private String weightOrVolType; + public Integer getNumber() { return number; } @@ -58,4 +75,20 @@ public void setComputedNumber(Integer computedNumber) { this.computedNumber = computedNumber; } + + public String getWeightOrVolType() { + return weightOrVolType; + } + + public void setWeightOrVolType(String weightOrVolType) { + this.weightOrVolType = weightOrVolType; + } + + public Integer getRankOrder() { + return rankOrder; + } + + public void setRankOrder(Integer rankOrder) { + this.rankOrder = rankOrder; + } } Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/IndividualObservationExportModel.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/IndividualObservationExportModel.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/IndividualObservationExportModel.java 2013-05-11 15:53:26 UTC (rev 935) @@ -31,6 +31,7 @@ import fr.ifremer.tutti.persistence.entities.data.Program; import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; import fr.ifremer.tutti.persistence.entities.referential.Gear; +import fr.ifremer.tutti.persistence.entities.referential.Species; import fr.ifremer.tutti.persistence.entities.referential.Vessel; import fr.ifremer.tutti.service.PersistenceService; import fr.ifremer.tutti.service.TuttiCsvUtil; @@ -80,6 +81,8 @@ newColumnForExport("Navire", Cruise.PROPERTY_VESSEL, Vessel.PROPERTY_NAME); newColumnForExport("BatchId", IndividualObservationExportRow.PROPERTY_BATCH_ID, TuttiCsvUtil.PRIMITIVE_INTEGER); + newColumnForExport("ReferenceTaxonId", IndividualObservationBatch.PROPERTY_SPECIES + "." + Species.PROPERTY_REFERENCE_TAXON_ID, TuttiCsvUtil.PRIMITIVE_INTEGER); + newColumnForExport("ReferenceTaxonName", IndividualObservationBatch.PROPERTY_SPECIES + "." + Species.PROPERTY_NAME); newColumnForExport("Comment", IndividualObservationBatch.PROPERTY_COMMENT); newColumnForExport("CaracteristicId", IndividualObservationExportRow.PROPERTY_CARACTERISTIC, Caracteristic.PROPERTY_ID); newColumnForExport("CaracteristicValue", IndividualObservationExportRow.PROPERTY_CARACTERISTIC_VALUE, TuttiCsvUtil.CARACTERISTIC_VALUE_FORMATTER); Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/IndividualObservationExportRow.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/IndividualObservationExportRow.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/IndividualObservationExportRow.java 2013-05-11 15:53:26 UTC (rev 935) @@ -30,6 +30,7 @@ import fr.ifremer.tutti.persistence.entities.data.Program; import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; import fr.ifremer.tutti.persistence.entities.referential.Gear; +import fr.ifremer.tutti.persistence.entities.referential.Species; import fr.ifremer.tutti.persistence.entities.referential.Vessel; import java.io.Serializable; @@ -130,4 +131,8 @@ public String getMultirigAggregation() { return fishingOperation.getMultirigAggregation(); } + + public Species getSpecies() { + return batch.getSpecies(); + } } Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/TuttiExportService.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/TuttiExportService.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/export/TuttiExportService.java 2013-05-11 15:53:26 UTC (rev 935) @@ -101,6 +101,10 @@ protected Caracteristic otolitheIdCaracteristic; + protected Caracteristic deadOrAliveCaracteristic; + + protected Caracteristic genderCaracteristic; + protected Caracteristic weightMeasuredCaracteristic; protected Caracteristic pmfmIdCaracteristic; @@ -120,6 +124,8 @@ otolitheIdCaracteristic = persistenceService.getOtolitheIdCaracteristic(); weightMeasuredCaracteristic = persistenceService.getWeightMeasuredCaracteristic(); pmfmIdCaracteristic = persistenceService.getPmfmIdCaracteristic(); + deadOrAliveCaracteristic = persistenceService.getDeadOrAliveCaracteristic(); + genderCaracteristic = persistenceService.getSexCaracteristic(); List<TuttiLocation> allCountry = persistenceService.getAllCountry(); String countryId = context.getConfig().getExportCountryId(); @@ -149,6 +155,9 @@ Program program = persistenceService.getProgram(programId); Preconditions.checkNotNull(program); + if (log.isDebugEnabled()) { + log.debug("Will export program: " + programId); + } List<Cruise> allCruise = persistenceService.getAllCruise(programId); for (Cruise cruise : allCruise) { checkCruise(progressionModel, cruise); @@ -189,6 +198,10 @@ Cruise cruise = persistenceService.getCruise(cruiseId); Preconditions.checkNotNull(cruise); + if (log.isDebugEnabled()) { + log.debug("Will export cruise: " + cruiseId); + } + // check cruise fishing operations checkCruise(progressionModel, cruise); @@ -224,6 +237,8 @@ sampleIdCaracteristic, otolitheIdCaracteristic, weightMeasuredCaracteristic, + deadOrAliveCaracteristic, + genderCaracteristic, pmfmIdCaracteristic, samplingOrder); } @@ -306,8 +321,13 @@ progressionModel.increments(1); progressionModel.setMessage( + _("tutti.service.exportCruise.exportAccidentalCatches", cruiseName)); + exportAccidentalCatch(exportContext, cruise, loadedOperations); + progressionModel.increments(1); + + progressionModel.setMessage( _("tutti.service.exportCruise.exportCatches", cruiseName)); -// exportCatches(exportContext, cruise, loadedOperations); + exportCatches(exportContext, cruise, loadedOperations); progressionModel.increments(1); } @@ -389,6 +409,23 @@ } } + protected void exportAccidentalCatch(ExportContext exportContext, + Cruise cruise, + List<FishingOperation> operations) { + + try { + + for (FishingOperation operation : operations) { + List<AccidentalCatchExportRow> rows = Lists.newArrayList(); + exportContext.accidentalCatchModel.prepareRows(persistenceService, rows, cruise, operation); + exportContext.accidentalCatchExport.write(rows, exportContext.accidentalCatchWriter); + } + + } catch (Exception e) { + throw new TuttiTechnicalException(_("tutti.service.export.parameters.error"), e); + } + } + protected void exportCatches(ExportContext exportContext, Cruise cruise, List<FishingOperation> operations) { @@ -398,6 +435,17 @@ String operationId = operation.getId(); + boolean withCatchBatch = + persistenceService.isFishingOperationWithCatchBatch( + operationId); + + if (!withCatchBatch) { + if (log.isWarnEnabled()) { + log.warn("Skip fishing operation " + operationId + + " since no catchBatch associated."); + } + continue; + } CatchBatch catchBatch = persistenceService.getCatchBatchFromFishingOperation( operationId); @@ -429,7 +477,8 @@ } } catch (Exception e) { - throw new TuttiTechnicalException(_("tutti.service.export.catches.error"), e); + throw new TuttiTechnicalException( + _("tutti.service.export.catches.error"), e); } } @@ -447,6 +496,8 @@ File catchFile; + File accidentalCatchFile; + BufferedWriter surveyWriter; BufferedWriter operationWriter; @@ -457,6 +508,8 @@ BufferedWriter catchWriter; + BufferedWriter accidentalCatchWriter; + BufferedWriter individualObservationWriter; SurveyExportModel surveyModel; @@ -469,6 +522,8 @@ CatchExportModel catchModel; + AccidentalCatchExportModel accidentalCatchModel; + IndividualObservationExportModel individualObservationModel; TuttiCsvUtil.TuttiRepeatableExport<SurveyExportRow> surveyExport; @@ -481,6 +536,8 @@ TuttiCsvUtil.TuttiRepeatableExport<CatchExportRow> catchExport; + TuttiCsvUtil.TuttiRepeatableExport<AccidentalCatchExportRow> accidentalCatchExport; + TuttiCsvUtil.TuttiRepeatableExport<IndividualObservationExportRow> individualObservationExport; ExportContext(File basedir, @@ -492,6 +549,8 @@ Caracteristic sampleIdCaracteristic, Caracteristic otolitheIdCaracteristic, Caracteristic weightMeasuredCaracteristic, + Caracteristic deadOrAliveCaracteristic, + Caracteristic genderCaracteristic, Caracteristic pmfmIdCaracteristic, List<SampleCategoryEnum> samplingOrder) { @@ -512,6 +571,9 @@ catchFile = new File(basedir, "catch.csv"); catchWriter = Files.newWriter(catchFile, Charsets.UTF_8); + accidentalCatchFile = new File(basedir, "accidentalCatch.csv"); + accidentalCatchWriter = Files.newWriter(accidentalCatchFile, Charsets.UTF_8); + individualObservationFile = new File(basedir, "individualObservation.csv"); individualObservationWriter = Files.newWriter(individualObservationFile, Charsets.UTF_8); @@ -535,6 +597,12 @@ marineLitterModel = new MarineLitterExportModel(csvSeparator); catchModel = new CatchExportModel(csvSeparator, samplingOrder); + accidentalCatchModel = new AccidentalCatchExportModel( + csvSeparator, + deadOrAliveCaracteristic, + genderCaracteristic, + weightMeasuredCaracteristic, + pmfmIdCaracteristic); individualObservationModel = new IndividualObservationExportModel( csvSeparator, sampleIdCaracteristic, @@ -555,6 +623,7 @@ marineLitterModel); catchExport = TuttiCsvUtil.newRepeatableExport(catchModel); + accidentalCatchExport = TuttiCsvUtil.newRepeatableExport(accidentalCatchModel); individualObservationExport = TuttiCsvUtil.newRepeatableExport(individualObservationModel); } @@ -564,6 +633,7 @@ IOUtils.closeQuietly(operationWriter); IOUtils.closeQuietly(parameterWriter); IOUtils.closeQuietly(catchWriter); + IOUtils.closeQuietly(accidentalCatchWriter); IOUtils.closeQuietly(marineLitterWriter); IOUtils.closeQuietly(individualObservationWriter); } Modified: trunk/tutti-service/src/main/resources/i18n/tutti-service_en_GB.properties =================================================================== --- trunk/tutti-service/src/main/resources/i18n/tutti-service_en_GB.properties 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-service/src/main/resources/i18n/tutti-service_en_GB.properties 2013-05-11 15:53:26 UTC (rev 935) @@ -69,6 +69,7 @@ tutti.service.export.zip.error= tutti.service.exportCruise.buildZip= tutti.service.exportCruise.checkCruise= +tutti.service.exportCruise.exportAccidentalCatches= tutti.service.exportCruise.exportCatches= tutti.service.exportCruise.exportIndividualObservations= tutti.service.exportCruise.exportMarineLitters= Modified: trunk/tutti-service/src/main/resources/i18n/tutti-service_fr_FR.properties =================================================================== --- trunk/tutti-service/src/main/resources/i18n/tutti-service_fr_FR.properties 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-service/src/main/resources/i18n/tutti-service_fr_FR.properties 2013-05-11 15:53:26 UTC (rev 935) @@ -67,6 +67,7 @@ tutti.service.export.zip.error=Erreur lors de la création du zip d'export %s tutti.service.exportCruise.buildZip=Création de l'archive de l'export (fichier %s) tutti.service.exportCruise.checkCruise=Vérification de la campagne %s +tutti.service.exportCruise.exportAccidentalCatches=Export du fichier <strong>accidentalCatch.csv</strong> pour la campagne %s tutti.service.exportCruise.exportCatches=Export du fichier <strong>catch.csv</strong> pour la campagne %s tutti.service.exportCruise.exportIndividualObservations=Export du fichier <strong>individualObservation.csv</strong> pour la campagne %s tutti.service.exportCruise.exportMarineLitters=Export du fichier <strong>marineLitter.csv</strong> pour la campagne %s Added: trunk/tutti-service/src/test/java/fr/ifremer/tutti/service/ServiceDbResource.java =================================================================== --- trunk/tutti-service/src/test/java/fr/ifremer/tutti/service/ServiceDbResource.java (rev 0) +++ trunk/tutti-service/src/test/java/fr/ifremer/tutti/service/ServiceDbResource.java 2013-05-11 15:53:26 UTC (rev 935) @@ -0,0 +1,117 @@ +package fr.ifremer.tutti.service; + +/* + * #%L + * Tutti :: Service + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2012 - 2013 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.tutti.persistence.RessourceClassLoader; +import fr.ifremer.tutti.persistence.test.DatabaseResource; +import fr.ifremer.tutti.service.config.TuttiServiceConfig; +import org.apache.commons.io.IOUtils; +import org.junit.runner.Description; +import org.nuiton.i18n.I18n; + +import java.io.IOException; +import java.util.Locale; + +/** + * TODO + * + * @author tchemit <chemit@codelutin.com> + * @since 2.2 + */ +public class ServiceDbResource extends DatabaseResource { + + protected TuttiServiceContext createServiceContext(RessourceClassLoader loader, + TuttiServiceConfig config) { + return new TuttiServiceContext(loader, config); + } + + protected TuttiServiceContext serviceContext; + + protected TuttiServiceConfig serviceConfig; + + public static ServiceDbResource readDb() { + return new ServiceDbResource(""); + } + + public static ServiceDbResource writeDb() { + return new ServiceDbResource("", true); + } + + public static ServiceDbResource readDb(String dbName) { + return new ServiceDbResource(dbName); + } + + public static ServiceDbResource writeDb(String dbName) { + return new ServiceDbResource(dbName, true); + } + + public static ServiceDbResource noDb() { + return new ServiceDbResource( + "", "beanRefFactoryWitNoDb.xml", "TuttiBeanRefFactoryWithNoDb"); + } + + protected ServiceDbResource(String dbName) { + super(dbName); + } + + protected ServiceDbResource(String dbName, boolean writeDb) { + super(dbName, writeDb); + } + + protected ServiceDbResource(String dbName, String beanFactoryReferenceLocation, String beanRefFactoryReferenceId) { + super(dbName, beanFactoryReferenceLocation, beanRefFactoryReferenceId); + } + + protected ServiceDbResource(String dbName, String beanFactoryReferenceLocation, String beanRefFactoryReferenceId, boolean writeDb) { + super(dbName, beanFactoryReferenceLocation, beanRefFactoryReferenceId, writeDb); + } + + public TuttiServiceContext getServiceContext() { + return serviceContext; + } + + public TuttiServiceConfig getServiceConfig() { + return serviceConfig; + } + + @Override + protected void before(Description description) throws Throwable { + super.before(description); + + serviceConfig = new TuttiServiceConfig(getConfig()); + + serviceContext = createServiceContext(loader, serviceConfig); + + I18n.init(null, Locale.FRANCE); + serviceContext.getConfig().setCsvSeparator(';'); + } + + @Override + protected void after(Description description) throws IOException { + + IOUtils.closeQuietly(serviceContext); + super.after(description); + } +} Property changes on: trunk/tutti-service/src/test/java/fr/ifremer/tutti/service/ServiceDbResource.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native Modified: trunk/tutti-service/src/test/java/fr/ifremer/tutti/service/export/TuttiExportServiceTest.java =================================================================== --- trunk/tutti-service/src/test/java/fr/ifremer/tutti/service/export/TuttiExportServiceTest.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-service/src/test/java/fr/ifremer/tutti/service/export/TuttiExportServiceTest.java 2013-05-11 15:53:26 UTC (rev 935) @@ -27,75 +27,99 @@ import com.google.common.collect.Lists; import com.google.common.io.Files; import fr.ifremer.tutti.persistence.ProgressionModel; -import fr.ifremer.tutti.persistence.RessourceClassLoader; -import fr.ifremer.tutti.persistence.entities.CaracteristicMap; -import fr.ifremer.tutti.persistence.entities.TuttiBeanFactory; import fr.ifremer.tutti.persistence.entities.TuttiEntities; -import fr.ifremer.tutti.persistence.entities.data.BatchContainer; 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.data.MarineLitterBatch; import fr.ifremer.tutti.persistence.entities.data.Program; -import fr.ifremer.tutti.persistence.entities.data.SampleCategoryEnum; -import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; -import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue; -import fr.ifremer.tutti.persistence.entities.referential.CaracteristicType; -import fr.ifremer.tutti.persistence.entities.referential.Gear; -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.service.AbstractServiceTest; import fr.ifremer.tutti.service.PersistenceService; +import fr.ifremer.tutti.service.ServiceDbResource; import fr.ifremer.tutti.service.TuttiServiceContext; -import fr.ifremer.tutti.service.catches.TuttiWeightComputingService; -import fr.ifremer.tutti.service.config.TuttiServiceConfig; import org.apache.commons.io.Charsets; -import org.apache.commons.lang3.time.DateUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.junit.Assert; import org.junit.Before; +import org.junit.ClassRule; import org.junit.Test; -import org.mockito.Mockito; import java.io.File; -import java.util.Date; +import java.io.IOException; import java.util.List; -import java.util.Map; /** * @author tchemit <chemit@codelutin.com> * @since 1.3 */ -public class TuttiExportServiceTest extends AbstractServiceTest { +public class TuttiExportServiceTest { /** Logger. */ private static final Log log = LogFactory.getLog(TuttiExportServiceTest.class); - protected TuttiExportService service; + @ClassRule + public static final ServiceDbResource dbResource = + ServiceDbResource.readDb("dbGenericExport"); - protected Caracteristic marineLitterCategory; + public static final String PROGRAM_ID = "CAM-CGFS"; - protected Caracteristic marineLitterSizeCategory; + public static final String CRUISE_ID = "100001"; - protected Caracteristic caracteristicVerticalOpening; + public static final String OPERATION_1_ID = "100106"; - protected Caracteristic caracteristicHorizontalOpeningWing; + public static final String OPERATION_2_ID = "100107"; - protected Caracteristic caracteristicHorizontalOpeningDoor; + public static final String SURVEY_CONTENT = + "Annee;Serie;Serie_Partielle;Navire;Pays;Zone_Etude;Id_Sismer;Date_Deb_Campagne;Port_Deb_Campagne;Date_Fin_Campagne;Port_Fin_Campagne;Chef_Mission;Resp_Salle_Tri;Commentaire\n" + + "2013;Campagne CGFS;;GWEN DREZ;FRA;CGFS - Manche Est / Sud Mer du Nord;Campagne CGFS_2013;01/05/2013 00:00:00;La Barbotière (Gujan-Mestras);31/05/2013 00:00:00;Etang de Palo;Vincent AURECHE;;;"; - protected Caracteristic sampleIdCaracteristic; + public static final String OPERATION_CONTENT = + "Annee;Serie;Serie_Partielle;Id_Operation;NumOrdre_Station;Engin;Navire;DateDeb_Op;LatDeb;LongDeb;DateFin_Op;LatFin;LongFin;Duree;Strate;Sous-Strate;Localite;Validite_OP;Rectiligne;Distance;Ouv_Verticale;Ouv_Horizontale_Ailes;Ouv_Horizontale_Panneaux;Commentaire\n" + + "2013;Campagne CGFS;;A;1;GOV 19.7/25.9;GWEN DREZ;01/05/2013 00:00:00;;;01/05/2013 00:23:00;;;23;Strate 1D;NA;Localité 1D2;?;N;;NA;NA;NA;op1;\n" + + "2013;Campagne CGFS;;A;2;GOV 19.7/25.9;GWEN DREZ;11/05/2013 08:00:00;;;11/05/2013 08:23:00;;;23;Strate 1D;NA;Localité 1D2;?;N;;NA;NA;NA;OP2;"; - protected Caracteristic otolitheIdCaracteristic; + public static final String PARAMETER_CONTENT = + "Annee;Serie;Serie_Partielle;Id_Operation;NumOrdre_Station;Code_PMFM;Libelle_PMFm;Valeur\n" + + "2013;Campagne CGFS;;A;1;1164;Catégorie UE - produit/lot - totale - Diffusion par une Halle à marée;Cat UE10;\n" + + "2013;Campagne CGFS;;A;1;1302;(Gross Tonnage) : augmentation de tonnage accordée pour des raisons de sécurité - navire - totale - Déclaration d'un professionnel;10.0;\n" + + "2013;Campagne CGFS;;A;1;194;\"Etat de la mer - masse d'eau, eau brute - totale - Observation par un observateur\";\"2 - belle, vagues de 0.1 à 0.5 mètres\";\n" + + "2013;Campagne CGFS;;A;1;821;Direction vent - air - totale - Instrument de bord;0.1;\n" + + "2013;Campagne CGFS;;A;1;149;Coût de la glace - navire - totale - Déclaration d'un professionnel;10.0;\n" + + "2013;Campagne CGFS;;A;2;1062;Catégorie de fraicheur - produit/lot - totale - Diffusion par une Halle à marée;A - Catégorie A;\n" + + "2013;Campagne CGFS;;A;2;308;Nombre d'engin - engin - totale - Déclaration d'un professionnel;2.0;"; - protected Caracteristic weightMeasuredCaracteristic; + public static final String CATCH_CONTENT = ""; - protected Caracteristic pmfmIdCaracteristic; + public static final String MARINE_LITTER_CONTENT = + "Annee;Serie;Serie_Partielle;Engin;Poche;Id_Operation;NumOrdre_Station;Navire;MarineLitterCategory;MarineLitterSizeCategory;Number;Weight;Comment\n" + + "2013;Campagne CGFS;;GOV 19.7/25.9;1;A;1;GWEN DREZ;L1 PLASTIQUE;A: <5*5 cm= 25 cm2;2;5.0;S1;\n" + + "2013;Campagne CGFS;;GOV 19.7/25.9;1;A;1;GWEN DREZ;L1a Sacs;B: <10*10 cm= 100 cm2;3;1.0;S2;"; - protected List<TuttiLocation> countries; + public static final String INDIVIDUAL_OBSERVATION_CONTENT = + "Annee;Serie;Serie_Partielle;Engin;Poche;Id_Operation;NumOrdre_Station;Navire;BatchId;ReferenceTaxonId;ReferenceTaxonName;Comment;CaracteristicId;CaracteristicValue\n" + + "2013;Campagne CGFS;;GOV 19.7/25.9;1;A;1;GWEN DREZ;100000;11242;Aaptos;P1;1435;A20;\n" + + "2013;Campagne CGFS;;GOV 19.7/25.9;1;A;1;GWEN DREZ;100000;11242;Aaptos;P1;1436;10;\n" + + "2013;Campagne CGFS;;GOV 19.7/25.9;1;A;1;GWEN DREZ;100000;11242;Aaptos;P1;220;0.1;\n" + + "2013;Campagne CGFS;;GOV 19.7/25.9;1;A;1;GWEN DREZ;100000;11242;Aaptos;P1;1433;307;\n" + + "2013;Campagne CGFS;;GOV 19.7/25.9;1;A;1;GWEN DREZ;100000;11242;Aaptos;P1;307;10.0;\n" + + "2013;Campagne CGFS;;GOV 19.7/25.9;1;A;1;GWEN DREZ;100000;11242;Aaptos;P1;101;10.0;\n" + + "2013;Campagne CGFS;;GOV 19.7/25.9;1;A;1;GWEN DREZ;100000;11242;Aaptos;P1;46;0L - 0 VMS - 1 LB;\n" + + "2013;Campagne CGFS;;GOV 19.7/25.9;1;A;1;GWEN DREZ;100000;11242;Aaptos;P1;1388;5.0;"; + public static final String ACCIDENTAL_CATCH_CONTENT = + "Annee;Serie;Serie_Partielle;Engin;Poche;Id_Operation;NumOrdre_Station;Navire;BatchId;ReferenceTaxonId;ReferenceTaxonName;Comment;CaracteristicId;CaracteristicValue\n" + + "2013;Campagne CGFS;;GOV 19.7/25.9;1;A;1;GWEN DREZ;100001;3835;Abalistes;;1393;Rejet mort;\n" + + "2013;Campagne CGFS;;GOV 19.7/25.9;1;A;1;GWEN DREZ;100001;3835;Abalistes;;196;Femelle;\n" + + "2013;Campagne CGFS;;GOV 19.7/25.9;1;A;1;GWEN DREZ;100001;3835;Abalistes;;220;10.0;\n" + + "2013;Campagne CGFS;;GOV 19.7/25.9;1;A;1;GWEN DREZ;100001;3835;Abalistes;;1433;1425;\n" + + "2013;Campagne CGFS;;GOV 19.7/25.9;1;A;1;GWEN DREZ;100001;3835;Abalistes;;1425;4.0;"; + + protected TuttiExportService service; + + protected PersistenceService persistenceService; + protected Program program; protected Cruise cruise; @@ -108,120 +132,71 @@ protected ProgressionModel progressionModel; - @Override - protected TuttiServiceContext createServiceContext(RessourceClassLoader loader, - TuttiServiceConfig config) { - return new TuttiServiceContext(loader, config); - } + protected File dataDirectory; @Before public void setUp() throws Exception { - super.setUp(); - createCaracteristics(); + dataDirectory = dbResource.getServiceConfig().getDataDirectory(); - countries = createCountries(); + TuttiServiceContext serviceContext = dbResource.getServiceContext(); - program = createProgram(); + persistenceService = serviceContext.getService(PersistenceService.class); - cruise = createCruise(); - operations = createOperations(cruise); - marineLitters = createMarineLitters(operations); - individualObservations = createIndividualObservations(operations); + // set export country id in configuration + List<TuttiLocation> allCountry = persistenceService.getAllCountry(); + Assert.assertNotNull(allCountry); + Assert.assertFalse(allCountry.isEmpty()); + TuttiLocation franceCountry = TuttiEntities.splitById(allCountry).get("12"); + Assert.assertNotNull(franceCountry); + dbResource.getServiceConfig().setExportCountry(franceCountry.getId()); - SampleCategoryEnum.sortedUnsorted.setFieldValue(1428); - SampleCategoryEnum.sortedUnsorted.setInit(true); - SampleCategoryEnum.size.setFieldValue(198); - SampleCategoryEnum.size.setInit(true); - SampleCategoryEnum.sex.setFieldValue(196); - SampleCategoryEnum.sex.setInit(true); - SampleCategoryEnum.maturity.setFieldValue(174); - SampleCategoryEnum.maturity.setInit(true); - SampleCategoryEnum.age.setFieldValue(1430); - SampleCategoryEnum.age.setInit(true); + service = serviceContext.getService(TuttiExportService.class); - Map<String, FishingOperation> operationMap = TuttiEntities.splitById(operations); - serviceContext.getConfig().setCsvSeparator(';'); + program = persistenceService.getProgram(PROGRAM_ID); + Assert.assertNotNull(program); - PersistenceService persistenceService = Mockito.mock(PersistenceService.class); - persistenceService.setServiceContext(serviceContext); + cruise = persistenceService.getCruise(CRUISE_ID); + Assert.assertNotNull(cruise); - Mockito.when(persistenceService.getVerticalOpeningCaracteristic()).thenReturn(caracteristicVerticalOpening); - Mockito.when(persistenceService.getHorizontalOpeningDoorCaracteristic()).thenReturn(caracteristicHorizontalOpeningDoor); - Mockito.when(persistenceService.getHorizontalOpeningWingCaracteristic()).thenReturn(caracteristicHorizontalOpeningWing); - Mockito.when(persistenceService.getSampleIdCaracteristic()).thenReturn(sampleIdCaracteristic); - Mockito.when(persistenceService.getOtolitheIdCaracteristic()).thenReturn(otolitheIdCaracteristic); - Mockito.when(persistenceService.getWeightMeasuredCaracteristic()).thenReturn(weightMeasuredCaracteristic); - Mockito.when(persistenceService.getPmfmIdCaracteristic()).thenReturn(pmfmIdCaracteristic); + operations = persistenceService.getAllFishingOperation(cruise.getId()); + Assert.assertNotNull(operations); + Assert.assertEquals(2, operations.size()); + Assert.assertEquals(OPERATION_1_ID, operations.get(0).getId()); + Assert.assertEquals(OPERATION_2_ID, operations.get(1).getId()); - Mockito.when(persistenceService.getProgram(Mockito.<String>any())).thenReturn(program); - Mockito.when(persistenceService.getCruise(Mockito.<String>any())).thenReturn(cruise); - Mockito.when(persistenceService.getAllCruise(Mockito.<String>any())).thenReturn(Lists.newArrayList(cruise)); - Mockito.when(persistenceService.getAllCountry()).thenReturn(countries); - Mockito.when(persistenceService.getAllFishingOperation(Mockito.<String>any())).thenReturn(operations); - Mockito.when(persistenceService.getFishingOperation("0")).thenReturn(operationMap.get("0")); - Mockito.when(persistenceService.getFishingOperation("1")).thenReturn(operationMap.get("1")); - Mockito.when(persistenceService.getFishingOperation("2")).thenReturn(operationMap.get("2")); - Mockito.when(persistenceService.getFishingOperation("3")).thenReturn(operationMap.get("3")); + // load fully operations + List<FishingOperation> loadedOperations = + Lists.newArrayListWithCapacity(operations.size()); + for (FishingOperation operation : operations) { + FishingOperation loadedOeration = + persistenceService.getFishingOperation(operation.getId()); + loadedOperations.add(loadedOeration); + } + operations = loadedOperations; - BatchContainer<MarineLitterBatch> marineLitterBatchBatchContainer; - marineLitterBatchBatchContainer = new BatchContainer<MarineLitterBatch>(); - marineLitterBatchBatchContainer.addChildren(marineLitters.get(0)); - marineLitterBatchBatchContainer.addChildren(marineLitters.get(1)); - Mockito.when(persistenceService.getRootMarineLitterBatch("0")).thenReturn(marineLitterBatchBatchContainer); - - marineLitterBatchBatchContainer = new BatchContainer<MarineLitterBatch>(); - marineLitterBatchBatchContainer.addChildren(marineLitters.get(2)); - marineLitterBatchBatchContainer.addChildren(marineLitters.get(3)); - Mockito.when(persistenceService.getRootMarineLitterBatch("1")).thenReturn(marineLitterBatchBatchContainer); - - marineLitterBatchBatchContainer = new BatchContainer<MarineLitterBatch>(); - Mockito.when(persistenceService.getRootMarineLitterBatch("2")).thenReturn(marineLitterBatchBatchContainer); - - marineLitterBatchBatchContainer = new BatchContainer<MarineLitterBatch>(); - Mockito.when(persistenceService.getRootMarineLitterBatch("3")).thenReturn(marineLitterBatchBatchContainer); - - Mockito.when(persistenceService.getAllIndividualObservationBatch("0")).thenReturn(Lists.newArrayList(individualObservations.get(0), individualObservations.get(1))); - Mockito.when(persistenceService.getAllIndividualObservationBatch("1")).thenReturn(Lists.newArrayList(individualObservations.get(2), individualObservations.get(3))); - Mockito.when(persistenceService.getAllIndividualObservationBatch("2")).thenReturn(Lists.<IndividualObservationBatch>newArrayList()); - Mockito.when(persistenceService.getAllIndividualObservationBatch("3")).thenReturn(Lists.<IndividualObservationBatch>newArrayList()); - - TuttiServiceContext serviceContextSpy = Mockito.spy(serviceContext); - Mockito.when(serviceContextSpy.getService(Mockito.eq(PersistenceService.class))).thenReturn(persistenceService); - - service = Mockito.mock(TuttiExportService.class, Mockito.withSettings().defaultAnswer(Mockito.CALLS_REAL_METHODS)); - - service.setServiceContext(serviceContextSpy); - - TuttiWeightComputingService tuttiWeightComputingService = Mockito.mock( - TuttiWeightComputingService.class, - Mockito.withSettings().defaultAnswer(Mockito.CALLS_REAL_METHODS)); - tuttiWeightComputingService.setServiceContext(serviceContextSpy); - service.tuttiWeightComputingService = tuttiWeightComputingService; - progressionModel = new ProgressionModel(); - progressionModel.setTotal(6); - + progressionModel.setTotal(7); } @Test public void exportProgram() throws Exception { - File exportFile = new File(datadirectory, "exportProgram.zip"); + File exportFile = new File(dataDirectory, "exportProgram.zip"); Files.createParentDirs(exportFile); Assert.assertFalse(exportFile.exists()); - service.exportProgram(cruise.getId(), exportFile, progressionModel); + service.exportProgram(program.getId(), exportFile, progressionModel); Assert.assertTrue(exportFile.exists()); } @Test public void exportCruise() throws Exception { - File exportFile = new File(datadirectory, "exportCruise.zip"); + File exportFile = new File(dataDirectory, "exportCruise.zip"); Files.createParentDirs(exportFile); @@ -235,19 +210,28 @@ public void exportSurvey() throws Exception { TuttiExportService.ExportContext exportContext = - service.createExportContext(datadirectory); + service.createExportContext(dataDirectory); try { service.exportSurvey(exportContext, cruise); } finally { exportContext.close(); } - Assert.assertTrue(exportContext.surveyFile.exists()); - Assert.assertEquals(1 + 1, Files.readLines(exportContext.surveyFile, Charsets.UTF_8).size()); + assertFileContent("Survey export:\n", + exportContext.surveyFile, + SURVEY_CONTENT); + } + protected void assertFileContent(String message, + File actualFile, + String expectedContent) throws IOException { + Assert.assertTrue(actualFile.exists()); + String fileContent = Files.toString(actualFile, + Charsets.UTF_8).trim(); + Assert.assertEquals(expectedContent, fileContent); + if (log.isInfoEnabled()) { - log.info("Survey export:\n" + - Files.toString(exportContext.surveyFile, Charsets.UTF_8)); + log.info(message + fileContent); } } @@ -255,516 +239,95 @@ public void exportOperations() throws Exception { TuttiExportService.ExportContext exportContext = - service.createExportContext(datadirectory); + service.createExportContext(dataDirectory); try { service.exportOperations(exportContext, cruise, operations); } finally { exportContext.close(); } - Assert.assertTrue(exportContext.operationFile.exists()); - Assert.assertEquals(operations.size() + 1, Files.readLines(exportContext.operationFile, Charsets.UTF_8).size()); - - if (log.isInfoEnabled()) { - log.info("Operation export:\n" + - Files.toString(exportContext.operationFile, Charsets.UTF_8)); - } + assertFileContent("Operation export:\n", + exportContext.operationFile, + OPERATION_CONTENT); } @Test public void exportParameters() throws Exception { TuttiExportService.ExportContext exportContext = - service.createExportContext(datadirectory); + service.createExportContext(dataDirectory); try { service.exportParameters(exportContext, cruise, operations); } finally { exportContext.close(); } - Assert.assertTrue(exportContext.parameterFile.exists()); - Assert.assertEquals(1 + operations.size() * 7, Files.readLines(exportContext.parameterFile, Charsets.UTF_8).size()); - - if (log.isInfoEnabled()) { - log.info("Parameter export:\n" + - Files.toString(exportContext.parameterFile, Charsets.UTF_8)); - } + assertFileContent("Parameter export:\n", + exportContext.parameterFile, + PARAMETER_CONTENT); } //TODO public void exportCatches() throws Exception { TuttiExportService.ExportContext exportContext = - service.createExportContext(datadirectory); + service.createExportContext(dataDirectory); try { service.exportCatches(exportContext, cruise, operations); } finally { exportContext.close(); } - Assert.assertTrue(exportContext.catchFile.exists()); - Assert.assertEquals(2, Files.readLines(exportContext.catchFile, Charsets.UTF_8).size()); - if (log.isInfoEnabled()) { - log.info("Catch export:\n" + - Files.toString(exportContext.catchFile, Charsets.UTF_8)); - } + assertFileContent("Catch export:\n", + exportContext.catchFile, + CATCH_CONTENT); } @Test public void exportMarineLitters() throws Exception { TuttiExportService.ExportContext exportContext = - service.createExportContext(datadirectory); + service.createExportContext(dataDirectory); try { service.exportMarineLitters(exportContext, cruise, operations); } finally { exportContext.close(); } - Assert.assertTrue(exportContext.marineLitterFile.exists()); - Assert.assertEquals(marineLitters.size() + 1, Files.readLines(exportContext.marineLitterFile, Charsets.UTF_8).size()); - - if (log.isInfoEnabled()) { - log.info("MarineLitter export:\n" + - Files.toString(exportContext.marineLitterFile, Charsets.UTF_8)); - } + assertFileContent("MarineLitter export:\n", + exportContext.marineLitterFile, + MARINE_LITTER_CONTENT); } @Test public void exportIndividualObservations() throws Exception { TuttiExportService.ExportContext exportContext = - service.createExportContext(datadirectory); + service.createExportContext(dataDirectory); try { service.exportIndividualObservations(exportContext, cruise, operations); } finally { exportContext.close(); } - Assert.assertTrue(exportContext.individualObservationFile.exists()); - int expectedRow = 1 /* header*/ - + 5 /* individualObservation 0 */ - + 3 /* individualObservation 1 */ - + 5 /* individualObservation 2 */ - + 3 /* individualObservation 3 */; - - if (log.isInfoEnabled()) { - log.info("individualObservation export:\n" + - Files.toString(exportContext.individualObservationFile, Charsets.UTF_8)); - } - - Assert.assertEquals(expectedRow, Files.readLines(exportContext.individualObservationFile, Charsets.UTF_8).size()); + assertFileContent("individualObservation export:\n", + exportContext.individualObservationFile, + INDIVIDUAL_OBSERVATION_CONTENT); } - private List<TuttiLocation> createCountries() { - List<TuttiLocation> result = Lists.newArrayList(); - TuttiLocation country = TuttiBeanFactory.newTuttiLocation(); - country.setId(serviceContext.getConfig().getExportCountryId()); - country.setName("CountryName"); - country.setLabel("CountryLabel"); - result.add(country); - return result; - } + @Test + public void exportAccidentalCatch() throws Exception { - private Program createProgram() { - TuttiLocation programZone = TuttiBeanFactory.newTuttiLocation(); - programZone.setId(0); - programZone.setName("ProgramZoneName"); - programZone.setLabel("ProgramZoneLabel"); + TuttiExportService.ExportContext exportContext = + service.createExportContext(dataDirectory); - TuttiLocation departureLocation = TuttiBeanFactory.newTuttiLocation(); - departureLocation.setId(1); - departureLocation.setName("DepartureLocationName"); - departureLocation.setLabel("DepartureLocationLabel"); - - TuttiLocation returnLocation = TuttiBeanFactory.newTuttiLocation(); - returnLocation.setId(2); - returnLocation.setName("ReturnLocationName"); - returnLocation.setLabel("ReturnLocationLabel"); - - Program program = TuttiBeanFactory.newProgram(); - program.setId(1); - program.setName("ProgramName"); - program.setZone(programZone); - return program; - } - - private Cruise createCruise() { - - TuttiLocation departureLocation = TuttiBeanFactory.newTuttiLocation(); - departureLocation.setId(1); - departureLocation.setName("DepartureLocationName"); - departureLocation.setLabel("DepartureLocationLabel"); - - TuttiLocation returnLocation = TuttiBeanFactory.newTuttiLocation(); - returnLocation.setId(2); - returnLocation.setName("ReturnLocationName"); - returnLocation.setLabel("ReturnLocationLabel"); - - Cruise cruise = TuttiBeanFactory.newCruise(); - cruise.setId(2); - cruise.setName("CruiseName"); - cruise.setComment("CruiseComment"); - cruise.setMultirigNumber(1); - cruise.setProgram(program); - cruise.setSurveyPart("CruiseSurveyPart"); - - cruise.setBeginDate(getDate(2013, 4, 5)); - cruise.setEndDate(getDate(2013, 5, 5)); - cruise.setDepartureLocation(departureLocation); - cruise.setReturnLocation(returnLocation); - - List<Gear> gears = Lists.newArrayList(); - Gear gear = TuttiBeanFactory.newGear(); - gear.setId(4); - gear.setLabel("GearLabel"); - gear.setName("GearName"); - gear.setScientificGear(false); - - gears.add(gear); - cruise.setGear(gears); - List<Person> headOfMission = Lists.newArrayList(); - cruise.setHeadOfMission(headOfMission); - List<Person> headOfSortRoom = Lists.newArrayList(); - cruise.setHeadOfSortRoom(headOfSortRoom); - - Vessel vessel = TuttiBeanFactory.newVessel(); - vessel.setId(4); - vessel.setName("VesselName"); - vessel.setRegistrationCode("VesselRegistrationCode"); - vessel.setInternationalRegistrationCode("VesselInternationalRegistrationCode"); - - cruise.setVessel(vessel); - - return cruise; - } - - private List<MarineLitterBatch> createMarineLitters(List<FishingOperation> operations) { - - List<MarineLitterBatch> result = Lists.newArrayList(); - - MarineLitterBatch marineLitterBatch; - - marineLitterBatch = TuttiBeanFactory.newMarineLitterBatch(); - result.add(marineLitterBatch); - marineLitterBatch.setFishingOperation(operations.get(0)); - marineLitterBatch.setId(1); - marineLitterBatch.setMarineLitterCategory(marineLitterCategory.getQualitativeValue(0)); - marineLitterBatch.setMarineLitterSizeCategory(marineLitterSizeCategory.getQualitativeValue(0)); - marineLitterBatch.setComment("Comment1"); - marineLitterBatch.setNumber(10); - marineLitterBatch.setWeight(10f); - - marineLitterBatch = TuttiBeanFactory.newMarineLitterBatch(); - result.add(marineLitterBatch); - marineLitterBatch.setFishingOperation(operations.get(0)); - marineLitterBatch.setId(2); - marineLitterBatch.setMarineLitterCategory(marineLitterCategory.getQualitativeValue(1)); - marineLitterBatch.setMarineLitterSizeCategory(marineLitterSizeCategory.getQualitativeValue(1)); - marineLitterBatch.setComment("Comment2"); - marineLitterBatch.setNumber(20); - marineLitterBatch.setWeight(20f); - - marineLitterBatch = TuttiBeanFactory.newMarineLitterBatch(); - result.add(marineLitterBatch); - marineLitterBatch.setFishingOperation(operations.get(1)); - marineLitterBatch.setId(10); - marineLitterBatch.setMarineLitterCategory(marineLitterCategory.getQualitativeValue(0)); - marineLitterBatch.setMarineLitterSizeCategory(marineLitterSizeCategory.getQualitativeValue(0)); - marineLitterBatch.setComment("Comment10"); - marineLitterBatch.setNumber(100); - marineLitterBatch.setWeight(100f); - - marineLitterBatch = TuttiBeanFactory.newMarineLitterBatch(); - result.add(marineLitterBatch); - marineLitterBatch.setFishingOperation(operations.get(1)); - marineLitterBatch.setId(20); - marineLitterBatch.setMarineLitterCategory(marineLitterCategory.getQualitativeValue(1)); - marineLitterBatch.setMarineLitterSizeCategory(marineLitterSizeCategory.getQualitativeValue(1)); - marineLitterBatch.setComment("Comment20"); - marineLitterBatch.setNumber(200); - marineLitterBatch.setWeight(200f); - - return result; - } - - private List<IndividualObservationBatch> createIndividualObservations(List<FishingOperation> operations) { - - List<IndividualObservationBatch> result = Lists.newArrayList(); - - Caracteristic lengthStepCaracteristic = TuttiBeanFactory.newCaracteristic(); - lengthStepCaracteristic.setCaracteristicType(CaracteristicType.NUMBER); - lengthStepCaracteristic.setId(200); - - IndividualObservationBatch batch; - - // 5 caracteristics (lengthStep - size - weight - samplingCode - CalcifiedPieceSamplingCode) - batch = TuttiBeanFactory.newIndividualObservationBatch(); - result.add(batch); - batch.setFishingOperation(operations.get(0)); - batch.setId(1); - batch.setComment("Comment1"); - batch.setLengthStepCaracteristic(lengthStepCaracteristic); - batch.setSize(10f); - batch.setWeight(10f); - batch.setSamplingCode("0"); - batch.setCalcifiedPieceSamplingCode("C1"); - - // 3 caracteristics (lengthStep - size - weight) - batch = TuttiBeanFactory.newIndividualObservationBatch(); - result.add(batch); - batch.setFishingOperation(operations.get(0)); - batch.setId(2); - batch.setComment("Comment2"); - batch.setLengthStepCaracteristic(lengthStepCaracteristic); - batch.setSize(20f); - batch.setWeight(20f); - - // 5 caracteristics (lengthStep - size - weight + 2 others) - batch = TuttiBeanFactory.newIndividualObservationBatch(); - result.add(batch); - batch.setFishingOperation(operations.get(1)); - batch.setId(10); - batch.setComment("Comment10"); - batch.setLengthStepCaracteristic(lengthStepCaracteristic); - batch.setSize(100f); - batch.setWeight(100f); - batch.setCaracteristics(new CaracteristicMap()); - - Caracteristic caracteristic; - - caracteristic = TuttiBeanFactory.newCaracteristic(); - caracteristic.setCaracteristicType(CaracteristicType.NUMBER); - caracteristic.setId(100); - batch.getCaracteristics().put(caracteristic, 100); - - caracteristic = TuttiBeanFactory.newCaracteristic(); - caracteristic.setCaracteristicType(CaracteristicType.TEXT); - caracteristic.setId(101); - batch.getCaracteristics().put(caracteristic, "Text"); - - // 3 caracteristics (weight - samplingCode - calcifiedPieceSamplingCode) - batch = TuttiBeanFactory.newIndividualObservationBatch(); - result.add(batch); - batch.setFishingOperation(operations.get(1)); - batch.setId(20); - batch.setComment("Comment20"); - batch.setWeight(200f); - batch.setSamplingCode("20"); - batch.setCalcifiedPieceSamplingCode("2C1"); - - return result; - } - - private void createCaracteristics() { - - caracteristicVerticalOpening = TuttiBeanFactory.newCaracteristic(); - caracteristicVerticalOpening.setCaracteristicType(CaracteristicType.NUMBER); - caracteristicVerticalOpening.setId(10); - caracteristicVerticalOpening.setNumericType(true); - caracteristicVerticalOpening.setParameterName("CaracteristicVerticalOpeningParameterName"); - caracteristicVerticalOpening.setMatrixName("CaracteristicVerticalOpeningMatrixName"); - caracteristicVerticalOpening.setFractionName("CaracteristicVerticalOpeningFractionName"); - caracteristicVerticalOpening.setMethodName("CaracteristicVerticalOpeningMethodName"); - - caracteristicHorizontalOpeningWing = TuttiBeanFactory.newCaracteristic(); - caracteristicHorizontalOpeningWing.setCaracteristicType(CaracteristicType.NUMBER); - caracteristicHorizontalOpeningWing.setId(11); - caracteristicHorizontalOpeningWing.setNumericType(true); - caracteristicHorizontalOpeningWing.setParameterName("CaracteristicHorizontalOpeningWingParameterName"); - caracteristicHorizontalOpeningWing.setMatrixName("CaracteristicHorizontalOpeningWingMatrixName"); - caracteristicHorizontalOpeningWing.setFractionName("CaracteristicHorizontalOpeningWingFractionName"); - caracteristicHorizontalOpeningWing.setMethodName("CaracteristicHorizontalOpeningWingMethodName"); - - caracteristicHorizontalOpeningDoor = TuttiBeanFactory.newCaracteristic(); - caracteristicHorizontalOpeningDoor.setCaracteristicType(CaracteristicType.NUMBER); - caracteristicHorizontalOpeningDoor.setId(12); - caracteristicHorizontalOpeningDoor.setNumericType(true); - caracteristicHorizontalOpeningDoor.setParameterName("CaracteristicHorizontalOpeningDoorParameterName"); - caracteristicHorizontalOpeningDoor.setMatrixName("CaracteristicHorizontalOpeningDoorMatrixName"); - caracteristicHorizontalOpeningDoor.setFractionName("CaracteristicHorizontalOpeningDoorFractionName"); - caracteristicHorizontalOpeningDoor.setMethodName("CaracteristicHorizontalOpeningDoorMethodName"); - - marineLitterCategory = TuttiBeanFactory.newCaracteristic(); - marineLitterCategory.setCaracteristicType(CaracteristicType.QUALITATIVE); - marineLitterCategory.setId(13); - marineLitterCategory.setQualitativeValue(Lists.<CaracteristicQualitativeValue>newArrayList()); - CaracteristicQualitativeValue qualitativeValue; - qualitativeValue = TuttiBeanFactory.newCaracteristicQualitativeValue(); - qualitativeValue.setId(1); - qualitativeValue.setName("Plastic"); - marineLitterCategory.addQualitativeValue(qualitativeValue); - qualitativeValue = TuttiBeanFactory.newCaracteristicQualitativeValue(); - qualitativeValue.setId(2); - qualitativeValue.setName("Machine à laver"); - marineLitterCategory.addQualitativeValue(qualitativeValue); - - marineLitterSizeCategory = TuttiBeanFactory.newCaracteristic(); - marineLitterSizeCategory.setCaracteristicType(CaracteristicType.QUALITATIVE); - marineLitterSizeCategory.setId(14); - marineLitterSizeCategory.setQualitativeValue(Lists.<CaracteristicQualitativeValue>newArrayList()); - - qualitativeValue = TuttiBeanFactory.newCaracteristicQualitativeValue(); - qualitativeValue.setId(3); - qualitativeValue.setName("Petit"); - marineLitterSizeCategory.addQualitativeValue(qualitativeValue); - qualitativeValue = TuttiBeanFactory.newCaracteristicQualitativeValue(); - qualitativeValue.setId(4); - qualitativeValue.setName("Gros"); - marineLitterSizeCategory.addQualitativeValue(qualitativeValue); - - sampleIdCaracteristic = TuttiBeanFactory.newCaracteristic(); - sampleIdCaracteristic.setCaracteristicType(CaracteristicType.TEXT); - sampleIdCaracteristic.setId(15); - - otolitheIdCaracteristic = TuttiBeanFactory.newCaracteristic(); - otolitheIdCaracteristic.setCaracteristicType(CaracteristicType.TEXT); - otolitheIdCaracteristic.setId(16); - - weightMeasuredCaracteristic = TuttiBeanFactory.newCaracteristic(); - weightMeasuredCaracteristic.setCaracteristicType(CaracteristicType.NUMBER); - weightMeasuredCaracteristic.setId(17); - - pmfmIdCaracteristic = TuttiBeanFactory.newCaracteristic(); - pmfmIdCaracteristic.setCaracteristicType(CaracteristicType.TEXT); - pmfmIdCaracteristic.setId(18); - - - } - - private List<FishingOperation> createOperations(Cruise cruise) { - List<FishingOperation> result = Lists.newArrayList(); - - Caracteristic caracteristicInteger = TuttiBeanFactory.newCaracteristic(); - caracteristicInteger.setCaracteristicType(CaracteristicType.NUMBER); - caracteristicInteger.setId(0); - caracteristicInteger.setNumericType(true); - caracteristicInteger.setParameterName("CaracteristicIntegerParameterName"); - caracteristicInteger.setMatrixName("CaracteristicIntegerMatrixName"); - caracteristicInteger.setFractionName("CaracteristicIntegerFractionName"); - caracteristicInteger.setMethodName("CaracteristicIntegerMethodName"); - - Caracteristic caracteristicFloat = TuttiBeanFactory.newCaracteristic(); - caracteristicFloat.setCaracteristicType(CaracteristicType.NUMBER); - caracteristicFloat.setId(0); - caracteristicFloat.setNumericType(true); - caracteristicFloat.setParameterName("CaracteristicFloatParameterName"); - caracteristicFloat.setMatrixName("CaracteristicFloatMatrixName"); - caracteristicFloat.setFractionName("CaracteristicFloatFractionName"); - caracteristicFloat.setMethodName("CaracteristicFloatMethodName"); - - Caracteristic caracteristicText = TuttiBeanFactory.newCaracteristic(); - caracteristicText.setCaracteristicType(CaracteristicType.TEXT); - caracteristicText.setId(1); - caracteristicText.setNumericType(false); - caracteristicText.setParameterName("CaracteristicTextParameterName"); - caracteristicText.setMatrixName("CaracteristicTextMatrixName"); - caracteristicText.setFractionName("CaracteristicTextFractionName"); - caracteristicText.setMethodName("CaracteristicTextMethodName"); - - Caracteristic caracteristicQualitative = TuttiBeanFactory.newCaracteristic(); - caracteristicQualitative.setCaracteristicType(CaracteristicType.QUALITATIVE); - caracteristicQualitative.setId(2); - caracteristicQualitative.setNumericType(false); - caracteristicQualitative.setParameterName("CaracteristicQualitativeParameterName1"); - caracteristicQualitative.setMatrixName("CaracteristicQualitativeMatrixName1"); - caracteristicQualitative.setFractionName("CaracteristicQualitativeFractionName1"); - caracteristicQualitative.setMethodName("CaracteristicQualitativeMethodName1"); - caracteristicQualitative.setQualitativeValue(Lists.<CaracteristicQualitativeValue>newArrayList()); - - Caracteristic caracteristicQualitative2 = TuttiBeanFactory.newCaracteristic(); - caracteristicQualitative2.setCaracteristicType(CaracteristicType.QUALITATIVE); - caracteristicQualitative2.setId(3); - caracteristicQualitative2.setNumericType(false); - caracteristicQualitative2.setParameterName("CaracteristicQualitativeParameterName2"); - caracteristicQualitative2.setMatrixName("CaracteristicQualitativeMatrixName2"); - caracteristicQualitative2.setFractionName("CaracteristicQualitativeFractionName2"); - caracteristicQualitative2.setMethodName("CaracteristicQualitativeMethodName2"); - caracteristicQualitative2.setQualitativeValue(Lists.<CaracteristicQualitativeValue>newArrayList()); - - for (int i = 0; i < 3; i++) { - CaracteristicQualitativeValue caracteristicQualitativeValue = TuttiBeanFactory.newCaracteristicQualitativeValue(); - caracteristicQualitativeValue.setId(i); - caracteristicQualitativeValue.setName("CaracteristicQualitativeValueName" + i); - caracteristicQualitativeValue.setDescription("CaracteristicQualitativeValueDescription" + i); - caracteristicQualitative.addQualitativeValue(caracteristicQualitativeValue); - - caracteristicQualitativeValue = TuttiBeanFactory.newCaracteristicQualitativeValue(); - caracteristicQualitativeValue.setId(5 + i); - caracteristicQualitativeValue.setName("CaracteristicQualitativeValueName2_" + i); - caracteristicQualitativeValue.setDescription("CaracteristicQualitativeValueDescription2_" + i); - caracteristicQualitative2.addQualitativeValue(caracteristicQualitativeValue); + try { + service.exportAccidentalCatch(exportContext, cruise, operations); + } finally { + exportContext.close(); } - - for (int i = 0; i < 3; i++) { - - TuttiLocation location = TuttiBeanFactory.newTuttiLocation(); - location.setId(i); - location.setName("LocationName" + i); - location.setLabel("LocationLabel" + i); - - TuttiLocation strata = TuttiBeanFactory.newTuttiLocation(); - strata.setId(3 * i); - strata.setName("StrataName" + i); - strata.setLabel("StrataLabel" + i); - - TuttiLocation subStrata = TuttiBeanFactory.newTuttiLocation(); - subStrata.setId(5 * i); - subStrata.setName("SubStrataName" + i); - subStrata.setLabel("SubStrataLabel" + i); - - CaracteristicMap gearUseFeatures = new CaracteristicMap(); - gearUseFeatures.put(caracteristicInteger, 10); - gearUseFeatures.put(caracteristicFloat, 5.2f); - gearUseFeatures.put(caracteristicText, "Text"); - gearUseFeatures.put(caracteristicQualitative, caracteristicQualitative.getQualitativeValue(0)); - gearUseFeatures.put(caracteristicQualitative2, caracteristicQualitative.getQualitativeValue(1)); - gearUseFeatures.put(caracteristicVerticalOpening, 5); - gearUseFeatures.put(caracteristicHorizontalOpeningDoor, -2); - gearUseFeatures.put(caracteristicHorizontalOpeningWing, -9); - - CaracteristicMap vesselUseFeatures = new CaracteristicMap(); - gearUseFeatures.put(caracteristicInteger, 20); - gearUseFeatures.put(caracteristicFloat, 10.4f); - gearUseFeatures.put(caracteristicText, "Text2"); - gearUseFeatures.put(caracteristicQualitative, caracteristicQualitative.getQualitativeValue(2)); - gearUseFeatures.put(caracteristicQualitative2, caracteristicQualitative.getQualitativeValue(1)); - - FishingOperation operation = TuttiBeanFactory.newFishingOperation(); - operation.setId(i); - operation.setCruise(cruise); - operation.setComment("OperationComment" + i); - operation.setFishingOperationNumber(100 + i); - operation.setFishingOperationRectiligne(true); - operation.setFishingOperationValid(i % 2 == 0 ? null : false); - operation.setGear(cruise.getGear().get(0)); - operation.setGearShootingEndDate(getDate(2013, 4, 6)); - operation.setGearShootingEndLatitude(45.4f); - operation.setGearShootingEndLongitude(23.7f); - operation.setGearShootingStartDate(getDate(2013, 4, 6)); - operation.setGearShootingStartLatitude(45.3f); - operation.setGearShootingStartLongitude(23.6f); - - operation.setGearUseFeatures(gearUseFeatures); - operation.setLocation(i % 2 == 0 ? null : location); - operation.setMultirigAggregation("1,2"); - operation.setRecorderPerson(null); - operation.setStationNumber("A" + i); - operation.setStrata(i % 2 == 0 ? null : strata); - operation.setSubStrata(i % 2 == 0 ? null : subStrata); - operation.setTrawlDistance(10.4f + i); - operation.setVessel(cruise.getVessel()); - operation.setVesselUseFeatures(vesselUseFeatures); - - result.add(operation); - } - return result; + assertFileContent("accidentalCatch export:\n", + exportContext.accidentalCatchFile, + ACCIDENTAL_CATCH_CONTENT); } - - public static Date getDate(int year, int month, int day) { - Date fromDate = DateUtils.setYears(new Date(), year); - fromDate = DateUtils.setMonths(fromDate, month); - fromDate = DateUtils.setDays(fromDate, day); - return fromDate; - } } Added: trunk/tutti-service/src/test/resources/tutti-test-read-dbGenericExport.properties =================================================================== --- trunk/tutti-service/src/test/resources/tutti-test-read-dbGenericExport.properties (rev 0) +++ trunk/tutti-service/src/test/resources/tutti-test-read-dbGenericExport.properties 2013-05-11 15:53:26 UTC (rev 935) @@ -0,0 +1,27 @@ +### +# #%L +# Tutti :: Service +# $Id$ +# $HeadURL$ +# %% +# Copyright (C) 2012 - 2013 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% +### +tutti.persistence.db.directory=src/test/dbGenericExport +tutti.persistence.jdbc.url=jdbc:hsqldb:file:src/test/dbGenericExport/allegro +#tutti.persistence.jdbc.url=jdbc:hsqldb:hsql://localhost/allegro +#tutti.persistence.jdbc.createScript=src/test/dbEmpty/allegro.script \ No newline at end of file Property changes on: trunk/tutti-service/src/test/resources/tutti-test-read-dbGenericExport.properties ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native Modified: trunk/tutti-ui-swing/pom.xml =================================================================== --- trunk/tutti-ui-swing/pom.xml 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-ui-swing/pom.xml 2013-05-11 15:53:26 UTC (rev 935) @@ -371,11 +371,6 @@ </dependency> <dependency> - <groupId>org.springframework</groupId> - <artifactId>spring-tx</artifactId> - </dependency> - - <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> </dependency> Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/home/ExportCruiseAction.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/home/ExportCruiseAction.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/home/ExportCruiseAction.java 2013-05-11 15:53:26 UTC (rev 935) @@ -102,8 +102,8 @@ ProgressionModel progressionModel = new ProgressionModel(); setProgressionModel(progressionModel); - // check cruise / export cruise / operation / parameter / catches / zip - progressionModel.setTotal(6); + // (check cruise / export cruise / operation / parameter / accidental catches / catches / individual observation) / zip + progressionModel.setTotal(8); TuttiExportService service = getContext().getTuttiExportService(); service.exportCruise(cruise.getId(), file, progressionModel); Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/home/ExportProgramAction.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/home/ExportProgramAction.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/home/ExportProgramAction.java 2013-05-11 15:53:26 UTC (rev 935) @@ -101,13 +101,13 @@ " to file: " + file); } - // nbCruise * (check cruise / export cruise / operation / parameter / catches) + zip + // nbCruise * (check cruise / export cruise / operation / parameter / catches / individual observation / accidental catches) + zip List<Cruise> allCruise = getContext().getPersistenceService().getAllCruise(program.getId()); ProgressionModel progressionModel = new ProgressionModel(); setProgressionModel(progressionModel); - progressionModel.setTotal(5 * allCruise.size() + 1); + progressionModel.setTotal(7 * allCruise.size() + 1); TuttiExportService service = getContext().getTuttiExportService(); service.exportProgram(program.getId(), file, progressionModel); Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/EditFishingOperationAction.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/EditFishingOperationAction.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/EditFishingOperationAction.java 2013-05-11 15:53:26 UTC (rev 935) @@ -47,7 +47,6 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.nuiton.util.decorator.Decorator; -import org.springframework.dao.DataRetrievalFailureException; import javax.swing.JLabel; import javax.swing.JOptionPane; @@ -537,34 +536,40 @@ PersistenceService persistenceService = getContext().getPersistenceService(); - try { - batch = persistenceService.getCatchBatchFromFishingOperation(operationId); - batch.setFishingOperation(bean); - Integer objectId = Integer.valueOf(batch.getId()); - attachments = persistenceService.getAllAttachments(catchesUIModel.getObjectType(), objectId); - getModel().setCatchNotFound(false); - getModel().setCatchEnabled(true); + boolean withCatchBath = + persistenceService.isFishingOperationWithCatchBatch( + operationId); - } catch (DataRetrievalFailureException e) { - // batch not found - if (log.isDebugEnabled()) { - log.debug("Batch not found", e); - } - batch = null; - attachments = Collections.emptyList(); + if (withCatchBath) { - getModel().setCatchEnabled(false); - getModel().setCatchNotFound(true); - } catch (InvalidBatchModelException e) { + // load it + try { + batch = persistenceService.getCatchBatchFromFishingOperation(operationId); + batch.setFishingOperation(bean); + Integer objectId = Integer.valueOf(batch.getId()); + attachments = persistenceService.getAllAttachments(catchesUIModel.getObjectType(), objectId); + getModel().setCatchNotFound(false); + getModel().setCatchEnabled(true); - // batch is not compatible with Tutti - if (log.isDebugEnabled()) { - log.debug("Invalid batch model", e); + } catch (InvalidBatchModelException e) { + + // batch is not compatible with Tutti + if (log.isDebugEnabled()) { + log.debug("Invalid batch model", e); + } + batch = null; + attachments = Collections.emptyList(); + + getModel().setCatchEnabled(false); } + } else { + + // no catch batch batch = null; attachments = Collections.emptyList(); getModel().setCatchEnabled(false); + getModel().setCatchNotFound(true); } } Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/accidental/AccidentalBatchRowModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/accidental/AccidentalBatchRowModel.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/accidental/AccidentalBatchRowModel.java 2013-05-11 15:53:26 UTC (rev 935) @@ -201,6 +201,16 @@ firePropertyChange(PROPERTY_COMMENT, oldValue, comment); } + @Override + public void setRankOrder(Integer rankOrder) { + editObject.setRankOrder(rankOrder); + } + + @Override + public Integer getRankOrder() { + return editObject.getRankOrder(); + } + //------------------------------------------------------------------------// //-- AttachmentModelAware --// //------------------------------------------------------------------------// Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/BenthosBatchRowModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/BenthosBatchRowModel.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/BenthosBatchRowModel.java 2013-05-11 15:53:26 UTC (rev 935) @@ -622,7 +622,7 @@ @Override public AttachementObjectTypeEnum getObjectType() { - return AttachementObjectTypeEnum.SAMPLE; + return AttachementObjectTypeEnum.BATCH; } @Override @@ -865,4 +865,13 @@ } return result; } + + @Override + public Integer getRankOrder() { + return null; + } + + @Override + public void setRankOrder(Integer rankOrder) { + } } Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/frequency/BenthosFrequencyRowModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/frequency/BenthosFrequencyRowModel.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/frequency/BenthosFrequencyRowModel.java 2013-05-11 15:53:26 UTC (rev 935) @@ -185,4 +185,13 @@ protected BenthosBatchFrequency newEntity() { return TuttiBeanFactory.newBenthosBatchFrequency(); } + + @Override + public Integer getRankOrder() { + return null; + } + + @Override + public void setRankOrder(Integer rankOrder) { + } } Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/IndividualObservationBatchRowModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/IndividualObservationBatchRowModel.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/IndividualObservationBatchRowModel.java 2013-05-11 15:53:26 UTC (rev 935) @@ -200,6 +200,16 @@ firePropertyChange(PROPERTY_COMMENT, oldValue, comment); } + @Override + public Integer getRankOrder() { + return editObject.getRankOrder(); + } + + @Override + public void setRankOrder(Integer rankOrder) { + editObject.setRankOrder(rankOrder); + } + //------------------------------------------------------------------------// //-- AttachmentModelAware --// //------------------------------------------------------------------------// Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/marinelitter/MarineLitterBatchRowModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/marinelitter/MarineLitterBatchRowModel.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/marinelitter/MarineLitterBatchRowModel.java 2013-05-11 15:53:26 UTC (rev 935) @@ -160,13 +160,23 @@ firePropertyChange(PROPERTY_COMMENT, oldValue, comment); } + @Override + public Integer getRankOrder() { + return editObject.getRankOrder(); + } + + @Override + public void setRankOrder(Integer rankOrder) { + editObject.setRankOrder(rankOrder); + } + //------------------------------------------------------------------------// //-- AttachmentModelAware --// //------------------------------------------------------------------------// @Override public AttachementObjectTypeEnum getObjectType() { - return AttachementObjectTypeEnum.SAMPLE; + return AttachementObjectTypeEnum.BATCH; } @Override Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/SpeciesBatchRowModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/SpeciesBatchRowModel.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/SpeciesBatchRowModel.java 2013-05-11 15:53:26 UTC (rev 935) @@ -432,6 +432,16 @@ public void setChildBatchs(List<SpeciesBatch> childBatchs) { } + @Override + public Integer getRankOrder() { + return editObject.getRankOrder(); + } + + @Override + public void setRankOrder(Integer rankOrder) { + editObject.setRankOrder(rankOrder); + } + //------------------------------------------------------------------------// //-- Sample category --// //------------------------------------------------------------------------// @@ -714,7 +724,7 @@ @Override public AttachementObjectTypeEnum getObjectType() { - return AttachementObjectTypeEnum.SAMPLE; + return AttachementObjectTypeEnum.BATCH; } @Override Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyRowModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyRowModel.java 2013-05-11 15:08:49 UTC (rev 934) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyRowModel.java 2013-05-11 15:53:26 UTC (rev 935) @@ -185,4 +185,13 @@ protected SpeciesBatchFrequency newEntity() { return TuttiBeanFactory.newSpeciesBatchFrequency(); } + + @Override + public Integer getRankOrder() { + return null; + } + + @Override + public void setRankOrder(Integer rankOrder) { + } }