Author: tchemit Date: 2013-04-18 17:22:51 +0200 (Thu, 18 Apr 2013) New Revision: 822 Url: http://forge.codelutin.com/projects/tutti/repository/revisions/822 Log: refs #1866: [CAPTURE] - Captures accidentelles Added: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MeasurementPersistenceHelper.java Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFile.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/VesselPersonFeaturesPersistenceHelper.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/batch/BatchPersistenceHelper.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/measure/MeasurementPersistenceHelper.java trunk/tutti-persistence/src/main/resources/queries-override.hbm.xml trunk/tutti-persistence/src/main/resources/tutti-db-enumerations.properties trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/DatabaseFixtures.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/CatchBatchPersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceWriteTest.java Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceImpl.java 2013-04-18 15:00:28 UTC (rev 821) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceImpl.java 2013-04-18 15:22:51 UTC (rev 822) @@ -26,15 +26,48 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; +import com.google.common.collect.Sets; +import fr.ifremer.adagio.core.dao.administration.programStrategy.Program; +import fr.ifremer.adagio.core.dao.administration.user.DepartmentImpl; +import fr.ifremer.adagio.core.dao.administration.user.PersonImpl; +import fr.ifremer.adagio.core.dao.data.measure.SampleMeasurement; +import fr.ifremer.adagio.core.dao.data.operation.FishingOperationDao; +import fr.ifremer.adagio.core.dao.data.operation.FishingOperationImpl; +import fr.ifremer.adagio.core.dao.data.sample.Sample; +import fr.ifremer.adagio.core.dao.data.sample.SampleDao; +import fr.ifremer.adagio.core.dao.referential.QualityFlagImpl; +import fr.ifremer.adagio.core.dao.referential.pmfm.Matrix; +import fr.ifremer.adagio.core.dao.referential.pmfm.MatrixImpl; +import fr.ifremer.adagio.core.dao.referential.pmfm.Pmfm; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmDao; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmImpl; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueImpl; +import fr.ifremer.adagio.core.dao.referential.pmfm.Unit; +import fr.ifremer.adagio.core.dao.referential.taxon.ReferenceTaxonImpl; +import fr.ifremer.adagio.core.dao.technical.synchronization.SynchronizationStatus; +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.AccidentalBatch; +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.Species; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.hibernate.FlushMode; +import org.hibernate.type.IntegerType; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.dao.DataRetrievalFailureException; import org.springframework.stereotype.Service; +import javax.annotation.Resource; +import java.io.Serializable; +import java.util.Collections; +import java.util.Iterator; import java.util.List; -import java.util.UUID; +import java.util.Map; +import java.util.Set; /** * @author tchemit <chemit@codelutin.com> @@ -48,23 +81,77 @@ LogFactory.getLog(AccidentalBatchPersistenceServiceImpl.class); @Autowired + protected ReferentialPersistenceService referentialService; + + @Autowired protected AttachmentPersistenceService attachmentPersistenceService; + @Autowired + protected MeasurementPersistenceHelper measurementPersistenceHelper; + + @Resource(name = "fishingOperationDao") + protected FishingOperationDao fishingOperationDao; + + @Resource(name = "sampleDao") + protected SampleDao sampleDao; + + @Resource(name = "pmfmDao") + protected PmfmDao pmfmDao; + @Override public List<AccidentalBatch> getAllAccidentalBatch(String fishingOperationId) { Preconditions.checkNotNull(fishingOperationId); + + Iterator<Object[]> list = queryList( + "allFishingOperationSamples", + "fishingOperationId", IntegerType.INSTANCE, Integer.valueOf(fishingOperationId) + ); + List<AccidentalBatch> result = Lists.newArrayList(); - // TODO - return result; + while (list.hasNext()) { + Object[] source = list.next(); + + AccidentalBatch accidentalBatch = TuttiBeanFactory.newAccidentalBatch(); + + int colIndex = 0; + + // Id + accidentalBatch.setId((Integer) source[colIndex++]); + + // TaxonId + Integer taxonId = (Integer) source[colIndex++]; + Species species = referentialService.getSpeciesByReferenceTaxonId(taxonId); + accidentalBatch.setSpecies(species); + + // Comment + accidentalBatch.setComment((String) source[colIndex]); + + // Sample Measurements + accidentalBatch.setCaracteristics(new CaracteristicMap()); + + // fill all measurements + fillSampleMeasurements(accidentalBatch); + + result.add(accidentalBatch); + } + return Collections.unmodifiableList(result); } @Override public AccidentalBatch createAccidentalBatch(AccidentalBatch bean) { Preconditions.checkNotNull(bean); Preconditions.checkState(TuttiEntities.isNew(bean)); - // TODO - bean.setId(UUID.randomUUID().toString()); + Preconditions.checkNotNull(bean.getSpecies()); + Preconditions.checkNotNull(bean.getFishingOperation()); + Preconditions.checkState(!TuttiEntities.isNew(bean.getFishingOperation())); + + getCurrentSession().setFlushMode(FlushMode.COMMIT); + Sample sample = Sample.Factory.newInstance(); + beanToEntity(bean, sample); + sampleDao.create(sample); + bean.setId(String.valueOf(sample.getId())); + getCurrentSession().flush(); return bean; } @@ -72,14 +159,372 @@ public AccidentalBatch saveAccidentalBatch(AccidentalBatch bean) { Preconditions.checkNotNull(bean); Preconditions.checkState(!TuttiEntities.isNew(bean)); - // TODO + Preconditions.checkNotNull(bean.getSpecies()); + Preconditions.checkNotNull(bean.getFishingOperation()); + Preconditions.checkState(!TuttiEntities.isNew(bean.getFishingOperation())); + + getCurrentSession().setFlushMode(FlushMode.COMMIT); + Sample sample = sampleDao.load(bean.getIdAsInt()); + if (sample == null) { + throw new DataRetrievalFailureException("Could not retrieve sample id=" + bean.getId()); + } + beanToEntity(bean, sample); + sampleDao.update(sample); + getCurrentSession().flush(); return bean; } @Override public void deleteAccidentalBatch(String id) { Preconditions.checkNotNull(id); - // TODO - attachmentPersistenceService.deleteAllAttachment(Integer.valueOf(id)); + + Integer accidentalId = Integer.valueOf(id); + sampleDao.remove(accidentalId); + attachmentPersistenceService.deleteAllAttachment(accidentalId); } + + protected void beanToEntity(AccidentalBatch source, Sample target) { + + if (TuttiEntities.isNew(source)) { + + // operation + + fr.ifremer.adagio.core.dao.data.operation.FishingOperation fishingOperation; + + fishingOperation = load(FishingOperationImpl.class, source.getFishingOperation().getIdAsInt()); + fishingOperation.getSamples().add(target); // Inverse link + + // Link to parent operation + target.setFishingOperation(fishingOperation); + + // Label + String label = fishingOperation.getId() + "_" + source.getSpecies().getReferenceTaxonId(); + target.setLabel(label); + + // Matrix (product / batch) + Matrix matrix = load(MatrixImpl.class, enumeration.MATRIX_ID_PRODUCT_BATCH); + target.setMatrix(matrix); + + // IndividualCount + target.setIndividualCount((short) 1); + + // Quality Flag + target.setQualityFlag(load(QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED)); + + // Sample Date + if (target.getSampleDate() == null) { + target.setSampleDate(fishingOperation.getFishingStartDateTime()); + } + + // Create Date + target.setCreationDate(fishingOperation.getFishingStartDateTime()); + + // Recorder Departement + target.setRecorderDepartment(load(DepartmentImpl.class, + enumeration.DEPARTMENT_ID_UNKNOWN_RECORDER_DEPARTMENT)); + + // Recorder Person + target.setRecorderPerson(load(PersonImpl.class, + enumeration.PERSON_ID_UNKNOWN_RECORDER_PERSON)); + + // Program + Program program = fishingOperation.getFishingTrip().getProgram(); + target.setProgram(program); + } + + // Id + target.setId(source.getIdAsInt()); + + + // Size + // Size Unit + if (source.getSize() == null) { + + // no size + target.setSize(null); + target.setSizeUnit(null); + } else { + + target.setSize(source.getSize()); + + Caracteristic lengthStepCaracteristic = + source.getLengthStepCaracteristic(); + + if (lengthStepCaracteristic != null) { + Pmfm pmfm = pmfmDao.load(lengthStepCaracteristic.getIdAsInt()); + + Unit unit = pmfm.getUnit(); + target.setSizeUnit(unit); + } else { + + if (log.isWarnEnabled()) { + log.warn("There is a size but no lengthStepCaracteristic, " + + "will nullify the unit."); + } + target.setSizeUnit(null); + } + } + + // Synchronization Status + target.setSynchronizationStatus(SynchronizationStatus.DIRTY.getValue()); + + // Comment + target.setComments(source.getComment()); + + // ReferenceTaxon + Species species = source.getSpecies(); + Integer referenceTaxonId = species.getReferenceTaxonId(); + target.setReferenceTaxon(load(ReferenceTaxonImpl.class, referenceTaxonId)); + + // Taxongroup TODO + + // FishingAreas TODO + + // SampleMeasurement + + Set<SampleMeasurement> notChangedSampleMeasurements = Sets.newHashSet(); + if (target.getSampleMeasurements() != null) { + notChangedSampleMeasurements.addAll(target.getSampleMeasurements()); + } + + CaracteristicMap caracteristics = source.getCaracteristics(); + if (caracteristics != null && caracteristics.size() > 0) { + for (Caracteristic caracteristic : caracteristics.keySet()) { + SampleMeasurement vum = setSampleMeasurement( + target, + caracteristic, + caracteristics.get(caracteristic)); + notChangedSampleMeasurements.remove(vum); + } + } + + if (source.getDeadOrAlive() != null) { + + // add it as a measurement + + Caracteristic caracteristic = + referentialService.getDeadOrAliveCaracteristic(); + + SampleMeasurement vum = setSampleMeasurement( + target, + caracteristic, + source.getDeadOrAlive()); + notChangedSampleMeasurements.remove(vum); + } + + if (source.getGender() != null) { + + // add it as a measurement + + Caracteristic caracteristic = + referentialService.getSexCaracteristic(); + + SampleMeasurement vum = setSampleMeasurement( + target, + caracteristic, + source.getGender()); + notChangedSampleMeasurements.remove(vum); + } + + if (source.getWeight() != null) { + + // add it as a measurement + + Caracteristic caracteristic = + referentialService.getCaracteristic(enumeration.PMFM_ID_WEIGHT_MEASURED); + + SampleMeasurement vum = setSampleMeasurement( + target, + caracteristic, + source.getWeight()); + notChangedSampleMeasurements.remove(vum); + } + + if (source.getLengthStepCaracteristic() != null) { + + // add it as a measurement + + Caracteristic caracteristic = + referentialService.getCaracteristic(enumeration.PMFM_ID_SAMPLE_LENGTH_STEP); + + SampleMeasurement vum = setSampleMeasurement( + target, + caracteristic, + source.getLengthStepCaracteristic().getId()); + notChangedSampleMeasurements.remove(vum); + + caracteristic = source.getLengthStepCaracteristic(); + vum = setSampleMeasurement( + target, + caracteristic, + source.getSize()); + notChangedSampleMeasurements.remove(vum); + + } + + // ---------------------------------------------------------------- + // Removed unecessary *SampleMeasurement* --- + // ---------------------------------------------------------------- + + if (target.getSampleMeasurements() != null && + notChangedSampleMeasurements.size() > 0) { + target.getSampleMeasurements().removeAll(notChangedSampleMeasurements); + } + } + + protected void fillSampleMeasurements(AccidentalBatch accidentalBatch) { + + Caracteristic deadOrAliveCaracteristic = referentialService.getDeadOrAliveCaracteristic(); + Map<String, CaracteristicQualitativeValue> deadOrAliveValues = TuttiEntities.splitById(deadOrAliveCaracteristic.getQualitativeValue()); + + Caracteristic genderCaracteristic = referentialService.getSexCaracteristic(); + Map<String, CaracteristicQualitativeValue> genderValues = TuttiEntities.splitById(genderCaracteristic.getQualitativeValue()); + + Iterator<Object[]> list = queryList( + "sampleMeasurements", + "sampleId", IntegerType.INSTANCE, accidentalBatch.getIdAsInt()); + + CaracteristicMap result = accidentalBatch.getCaracteristics(); + while (list.hasNext()) { + int colIndex = 0; + Object[] source = list.next(); + Integer pmfmId = (Integer) source[colIndex++]; + Float numericalValue = (Float) source[colIndex++]; + String alphanumericalValue = (String) source[colIndex++]; + Integer qualitativeValueId = (Integer) source[colIndex]; + + // dead or alive + if (enumeration.PMFM_ID_DEAD_OR_ALIVE.equals(pmfmId)) { + + CaracteristicQualitativeValue caracteristicQualitativeValue = deadOrAliveValues.get(qualitativeValueId.toString()); + accidentalBatch.setDeadOrAlive(caracteristicQualitativeValue); + + continue; + } + + // gender + if (enumeration.PMFM_ID_SEX.equals(pmfmId)) { + + CaracteristicQualitativeValue caracteristicQualitativeValue = genderValues.get(qualitativeValueId.toString()); + accidentalBatch.setGender(caracteristicQualitativeValue); + continue; + } + + // weight + if (enumeration.PMFM_ID_WEIGHT_MEASURED.equals(pmfmId)) { + + accidentalBatch.setWeight(numericalValue); + continue; + } + + // length step + if (enumeration.PMFM_ID_SAMPLE_LENGTH_STEP.equals(pmfmId)) { + + Caracteristic lengthStepCaracteristic = referentialService.getCaracteristic(Integer.valueOf(alphanumericalValue)); + accidentalBatch.setLengthStepCaracteristic(lengthStepCaracteristic); + continue; + } + + // other sample measurements + + Caracteristic caracteristic = referentialService.getCaracteristic(pmfmId); + Serializable value = null; + if (CaracteristicType.NUMBER == caracteristic.getCaracteristicType()) { + value = numericalValue; + } else if (CaracteristicType.TEXT == caracteristic.getCaracteristicType()) { + value = alphanumericalValue; + } else if (CaracteristicType.QUALITATIVE == caracteristic.getCaracteristicType()) { + for (CaracteristicQualitativeValue qv : caracteristic.getQualitativeValue()) { + if (qualitativeValueId.equals(qv.getIdAsInt())) { + value = qv; + break; + } + } + } + result.put(caracteristic, value); + } + + Caracteristic lengthStepCaracteristic = accidentalBatch.getLengthStepCaracteristic(); + if (lengthStepCaracteristic != null) { + + // get size from result + Serializable length = result.remove(lengthStepCaracteristic); + accidentalBatch.setSize((Float) length); + } + } + + protected SampleMeasurement getSampleMeasurement(Sample sample, + Integer pmfmId, + boolean createIfNotExists) { + SampleMeasurement result = null; + if (sample.getSampleMeasurements() != null) { + for (SampleMeasurement vum : sample.getSampleMeasurements()) { + if (pmfmId.equals(vum.getPmfm().getId())) { + result = vum; + break; + } + } + } + if (result == null) { + if (!createIfNotExists) { + return null; + } + result = SampleMeasurement.Factory.newInstance(); + + result.setSample(sample); + if (sample.getSampleMeasurements() == null) { + sample.setSampleMeasurements(Sets.newHashSet(result)); + } else { + sample.getSampleMeasurements().add(result); + } + result.setQualityFlag(load(QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED)); + result.setDepartment(sample.getRecorderDepartment()); + result.setPmfm(load(PmfmImpl.class, pmfmId)); + } + + return result; + } + + protected SampleMeasurement setSampleMeasurement(Sample sample, + Integer pmfmId, + Float numericalValue, + String alphanumericalValue, + Integer qualitativevalueId) { + SampleMeasurement result = getSampleMeasurement(sample, pmfmId, true); + + if (alphanumericalValue != null) { + result.setAlphanumericalValue(alphanumericalValue); + } else if (numericalValue != null) { + result.setNumericalValue(numericalValue); + } else if (qualitativevalueId != null) { + result.setQualitativeValue(load(QualitativeValueImpl.class, qualitativevalueId)); + } + + return result; + } + + protected SampleMeasurement setSampleMeasurement(Sample sample, + Integer pmfmId, + Serializable value) { + SampleMeasurement result = getSampleMeasurement(sample, pmfmId, true); + + if (value instanceof String) { + result.setAlphanumericalValue((String) value); + } else if (value instanceof Float) { + result.setNumericalValue((Float) value); + } else if (value instanceof Integer) { + result.setQualitativeValue(load(QualitativeValueImpl.class, value)); + } + + return result; + } + + protected SampleMeasurement setSampleMeasurement(Sample sample, + Caracteristic caracteristic, + Serializable value) { + SampleMeasurement result = getSampleMeasurement(sample, caracteristic.getIdAsInt(), true); + measurementPersistenceHelper.setMeasurement(result, caracteristic, value); + return result; + } + } Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceImpl.java 2013-04-18 15:00:28 UTC (rev 821) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceImpl.java 2013-04-18 15:22:51 UTC (rev 822) @@ -34,7 +34,6 @@ import fr.ifremer.adagio.core.dao.data.fishingArea.FishingArea2RegulationLocationPK; import fr.ifremer.adagio.core.dao.data.measure.GearPhysicalMeasurement; import fr.ifremer.adagio.core.dao.data.measure.GearUseMeasurement; -import fr.ifremer.adagio.core.dao.data.measure.Measurement; import fr.ifremer.adagio.core.dao.data.measure.VesselUseMeasurement; import fr.ifremer.adagio.core.dao.data.operation.FishingOperationDao; import fr.ifremer.adagio.core.dao.data.operation.Operation; @@ -114,6 +113,9 @@ @Autowired protected VesselPersonFeaturesPersistenceHelper vesselPersonFeaturesPersistenceHelper; + @Autowired + protected MeasurementPersistenceHelper measurementPersistenceHelper; + @Resource(name = "scientificCruiseDao") protected ScientificCruiseDao scientificCruiseDao; @@ -1110,29 +1112,29 @@ protected VesselUseMeasurement setVesselUseMeasurement(ScientificCruise scientificCruise, VesselUseFeatures vesselUseFeatures, Caracteristic caracteristic, Serializable value) { VesselUseMeasurement vesselUseMeasurement = getVesselUseMeasurement(scientificCruise, vesselUseFeatures, Integer.valueOf(caracteristic.getId()), true); - setMeasurement(vesselUseMeasurement, caracteristic, value); + measurementPersistenceHelper.setMeasurement(vesselUseMeasurement, caracteristic, value); return vesselUseMeasurement; } - protected void setMeasurement(Measurement measurement, Caracteristic caracteristic, Serializable value) { - if (value == null) { - return; - } - if (caracteristic.getCaracteristicType() == CaracteristicType.TEXT) { - measurement.setAlphanumericalValue((String) value); - } else if (caracteristic.getCaracteristicType() == CaracteristicType.NUMBER) { - measurement.setNumericalValue((Float) value); - } else if (caracteristic.getCaracteristicType() == CaracteristicType.QUALITATIVE) { - Integer qvId = null; - if (value instanceof CaracteristicQualitativeValue) { - qvId = Integer.valueOf(((CaracteristicQualitativeValue) value).getId()); - } else if (value instanceof Integer) { - qvId = (Integer) value; - } - QualitativeValue qv = load(QualitativeValueImpl.class, qvId); - measurement.setQualitativeValue(qv); - } - } +// protected void setMeasurement(Measurement measurement, Caracteristic caracteristic, Serializable value) { +// if (value == null) { +// return; +// } +// if (caracteristic.getCaracteristicType() == CaracteristicType.TEXT) { +// measurement.setAlphanumericalValue((String) value); +// } else if (caracteristic.getCaracteristicType() == CaracteristicType.NUMBER) { +// measurement.setNumericalValue((Float) value); +// } else if (caracteristic.getCaracteristicType() == CaracteristicType.QUALITATIVE) { +// Integer qvId = null; +// if (value instanceof CaracteristicQualitativeValue) { +// qvId = Integer.valueOf(((CaracteristicQualitativeValue) value).getId()); +// } else if (value instanceof Integer) { +// qvId = (Integer) value; +// } +// QualitativeValue qv = load(QualitativeValueImpl.class, qvId); +// measurement.setQualitativeValue(qv); +// } +// } protected GearUseMeasurement setGearUseMeasurement(ScientificCruise scientificCruise, GearUseFeatures gearUseFeatures, Integer pmfmId, @@ -1156,7 +1158,7 @@ protected GearUseMeasurement setGearUseMeasurement(ScientificCruise scientificCruise, GearUseFeatures gearUseFeatures, Caracteristic caracteristic, Serializable value) { GearUseMeasurement gearUseMeasurement = getGearUseMeasurement(scientificCruise, gearUseFeatures, Integer.valueOf(caracteristic.getId()), true); - setMeasurement(gearUseMeasurement, caracteristic, value); + measurementPersistenceHelper.setMeasurement(gearUseMeasurement, caracteristic, value); return gearUseMeasurement; } Added: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MeasurementPersistenceHelper.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MeasurementPersistenceHelper.java (rev 0) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MeasurementPersistenceHelper.java 2013-04-18 15:22:51 UTC (rev 822) @@ -0,0 +1,67 @@ +package fr.ifremer.tutti.persistence.service; + +/* + * #%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 fr.ifremer.adagio.core.dao.data.measure.Measurement; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValue; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueImpl; +import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; +import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue; +import fr.ifremer.tutti.persistence.entities.referential.CaracteristicType; +import org.springframework.stereotype.Component; + +import java.io.Serializable; + +/** + * Helper around {@link Measurement}. + * + * @author tchemit <chemit@codelutin.com> + * @since 1.5 + */ +@Component("measurementPersistenceHelper") +public class MeasurementPersistenceHelper extends AbstractPersistenceService { + + public void setMeasurement(Measurement measurement, + Caracteristic caracteristic, + Serializable value) { + if (value == null) { + return; + } + if (caracteristic.getCaracteristicType() == CaracteristicType.TEXT) { + measurement.setAlphanumericalValue((String) value); + } else if (caracteristic.getCaracteristicType() == CaracteristicType.NUMBER) { + measurement.setNumericalValue((Float) value); + } else if (caracteristic.getCaracteristicType() == CaracteristicType.QUALITATIVE) { + Integer qvId = null; + if (value instanceof CaracteristicQualitativeValue) { + qvId = Integer.valueOf(((CaracteristicQualitativeValue) value).getId()); + } else if (value instanceof Integer) { + qvId = (Integer) value; + } + QualitativeValue qv = load(QualitativeValueImpl.class, qvId); + measurement.setQualitativeValue(qv); + } + } +} Property changes on: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MeasurementPersistenceHelper.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFile.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFile.java 2013-04-18 15:00:28 UTC (rev 821) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFile.java 2013-04-18 15:22:51 UTC (rev 822) @@ -278,6 +278,12 @@ @Value("${TranscribingTypeId.TAXINOMIE_COMMUN_NOM_VERNACULAIRE}") public final Integer TRANSCRIBING_TYPE_ID_VERNACULAIRE = null; + @Value("${MatrixId.PRODUCT_BATCH}") + public final Integer MATRIX_ID_PRODUCT_BATCH= null; + + @Value("${PmfmId.SAMPLE_LENGTH_STEP}") + public final Integer PMFM_ID_SAMPLE_LENGTH_STEP = null; + /** * Contract to place on enumeration that must be synched to field inside this class. * <p/> Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/VesselPersonFeaturesPersistenceHelper.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/VesselPersonFeaturesPersistenceHelper.java 2013-04-18 15:00:28 UTC (rev 821) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/VesselPersonFeaturesPersistenceHelper.java 2013-04-18 15:22:51 UTC (rev 822) @@ -1,5 +1,29 @@ package fr.ifremer.tutti.persistence.service; +/* + * #%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 fr.ifremer.adagio.core.dao.administration.user.PersonImpl; import fr.ifremer.adagio.core.dao.data.operation.FishingOperation; import fr.ifremer.adagio.core.dao.data.survey.fishingTrip.FishingTrip; Property changes on: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/VesselPersonFeaturesPersistenceHelper.java ___________________________________________________________________ Modified: svn:keywords - Author Date Id Revision + Author Date Id Revision HeadURL Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/batch/BatchPersistenceHelper.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/batch/BatchPersistenceHelper.java 2013-04-18 15:00:28 UTC (rev 821) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/batch/BatchPersistenceHelper.java 2013-04-18 15:22:51 UTC (rev 822) @@ -30,17 +30,16 @@ import fr.ifremer.adagio.core.dao.data.batch.CatchBatch; import fr.ifremer.adagio.core.dao.data.batch.CatchBatchExtendDao; import fr.ifremer.adagio.core.dao.data.batch.SortingBatch; -import fr.ifremer.adagio.core.dao.data.measure.Measurement; import fr.ifremer.adagio.core.dao.data.measure.SortingMeasurement; import fr.ifremer.adagio.core.dao.referential.pmfm.Pmfm; -import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValue; -import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueImpl; 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.service.AbstractPersistenceService; +import fr.ifremer.tutti.persistence.service.MeasurementPersistenceHelper; import fr.ifremer.tutti.persistence.service.ReferentialPersistenceService; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.dao.DataIntegrityViolationException; import org.springframework.stereotype.Component; @@ -70,6 +69,9 @@ @Resource(name = "catchBatchDao") protected CatchBatchExtendDao catchBatchDao; + @Autowired + protected MeasurementPersistenceHelper measurementPersistenceHelper; + public List<SortingBatch> getFrequencyChilds(SortingBatch sortingBatch) { List<SortingBatch> result = Lists.newArrayList(); @@ -82,18 +84,6 @@ return result; } -// public List<SortingBatch> getNotFrequencyChilds(SortingBatch sortingBatch) { -// List<SortingBatch> result = Lists.newArrayList(); -// -// for (Batch batch : sortingBatch.getChildBatchs()) { -// SortingBatch child = (SortingBatch) batch; -// if (isFrequencyBatch(child)) { -// result.add(child); -// } -// } -// return result; -// } - public List<SortingBatch> getFrequencies(String batchId) { Preconditions.checkNotNull(batchId); Integer sortingBatchId = Integer.valueOf(batchId); @@ -216,28 +206,28 @@ return enumeration.DEPARTMENT_ID_UNKNOWN_RECORDER_DEPARTMENT; } - public void setMeasurement(Measurement measurement, - Caracteristic caracteristic, - Serializable value) { - if (caracteristic.getCaracteristicType() == CaracteristicType.TEXT) { - measurement.setAlphanumericalValue((String) value); - } else if (caracteristic.getCaracteristicType() == CaracteristicType.NUMBER) { - measurement.setNumericalValue((Float) value); - } else if (caracteristic.getCaracteristicType() == CaracteristicType.QUALITATIVE) { - Integer qvId; - if (value instanceof CaracteristicQualitativeValue) { - qvId = ((CaracteristicQualitativeValue) value).getIdAsInt(); - } else if (value instanceof Integer) { - qvId = (Integer) value; - } - // TODO BL : not used ? => to remove - else { - qvId = Integer.valueOf(value.toString()); - } - QualitativeValue qv = load(QualitativeValueImpl.class, qvId); - measurement.setQualitativeValue(qv); - } - } +// public void setMeasurement(Measurement measurement, +// Caracteristic caracteristic, +// Serializable value) { +// if (caracteristic.getCaracteristicType() == CaracteristicType.TEXT) { +// measurement.setAlphanumericalValue((String) value); +// } else if (caracteristic.getCaracteristicType() == CaracteristicType.NUMBER) { +// measurement.setNumericalValue((Float) value); +// } else if (caracteristic.getCaracteristicType() == CaracteristicType.QUALITATIVE) { +// Integer qvId; +// if (value instanceof CaracteristicQualitativeValue) { +// qvId = ((CaracteristicQualitativeValue) value).getIdAsInt(); +// } else if (value instanceof Integer) { +// qvId = (Integer) value; +// } +// // TODO BL : not used ? => to remove +// else { +// qvId = Integer.valueOf(value.toString()); +// } +// QualitativeValue qv = load(QualitativeValueImpl.class, qvId); +// measurement.setQualitativeValue(qv); +// } +// } public SortingMeasurement setSortingMeasurement( SortingBatch sortingBatch, @@ -252,7 +242,7 @@ Caracteristic caracteristic = referentialService.getCaracteristic(pmfmId); SortingMeasurement sortingMeasurement = catchBatchDao.getSortingMeasurement( sortingBatch, pmfmId, recorderDepartmentId, true); - setMeasurement(sortingMeasurement, caracteristic, value); + measurementPersistenceHelper.setMeasurement(sortingMeasurement, caracteristic, value); return sortingMeasurement; } @@ -267,7 +257,9 @@ Caracteristic caracteristic = referentialService.getCaracteristic(pmfmId); SortingMeasurement sortingMeasurement = catchBatchDao.getSortingMeasurement( sortingBatch, pmfmId, recorderDepartmentId, true); - setMeasurement(sortingMeasurement, caracteristic, value); + measurementPersistenceHelper.setMeasurement(sortingMeasurement, + caracteristic, + value); return sortingMeasurement; } Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/measure/MeasurementPersistenceHelper.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/measure/MeasurementPersistenceHelper.java 2013-04-18 15:00:28 UTC (rev 821) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/measure/MeasurementPersistenceHelper.java 2013-04-18 15:22:51 UTC (rev 822) @@ -51,12 +51,11 @@ import fr.ifremer.tutti.persistence.entities.referential.CaracteristicType; import fr.ifremer.tutti.persistence.service.AbstractPersistenceService; import fr.ifremer.tutti.persistence.service.ReferentialPersistenceService; -import org.springframework.stereotype.Component; import javax.annotation.Resource; import java.io.Serializable; -@Component("measurementPersistenceHelper") +//@Component("measurementPersistenceHelper") public class MeasurementPersistenceHelper extends AbstractPersistenceService { @Resource(name = "referentialPersistenceService") Modified: trunk/tutti-persistence/src/main/resources/queries-override.hbm.xml =================================================================== --- trunk/tutti-persistence/src/main/resources/queries-override.hbm.xml 2013-04-18 15:00:28 UTC (rev 821) +++ trunk/tutti-persistence/src/main/resources/queries-override.hbm.xml 2013-04-18 15:22:51 UTC (rev 822) @@ -192,18 +192,18 @@ <query cacheable="true" name="allFishingOperations"> <![CDATA[ - SELECT - o.id AS id, - o.name AS name, - g.label AS gearLabel, - o.startDateTime AS startDateTime, - (select vum.alphanumericalValue from VesselUseMeasurementImpl vum where vum.vesselUseFeatures.id = vuf.id and vum.pmfm.id=:pmfmIdStationNumber) AS stationNumber, - (select gum.alphanumericalValue from GearUseMeasurementImpl gum where gum.gearUseFeatures.id = guf.id and gum.pmfm.id=:pmfmIdMultirigAggregation) AS multirigAggregation - FROM + SELECT + o.id AS id, + o.name AS name, + g.label AS gearLabel, + o.startDateTime AS startDateTime, + (select vum.alphanumericalValue from VesselUseMeasurementImpl vum where vum.vesselUseFeatures.id = vuf.id and vum.pmfm.id=:pmfmIdStationNumber) AS stationNumber, + (select gum.alphanumericalValue from GearUseMeasurementImpl gum where gum.gearUseFeatures.id = guf.id and gum.pmfm.id=:pmfmIdMultirigAggregation) AS multirigAggregation + FROM FishingOperationImpl o LEFT OUTER JOIN o.gearUseFeatures guf LEFT OUTER JOIN guf.gear g - LEFT OUTER JOIN o.vesselUseFeatures vuf + LEFT OUTER JOIN o.vesselUseFeatures vuf WHERE o.fishingTrip.scientificCruise.id=:cruiseId ORDER BY @@ -213,12 +213,12 @@ <query-param name="pmfmIdStationNumber" type="java.lang.Integer"/> <query-param name="pmfmIdMultirigAggregation" type="java.lang.Integer"/> </query> - + <query cacheable="true" name="fishingOperation"> <![CDATA[ SELECT - o.name AS name, - max(g.label) AS gearLabel, + o.name AS name, + max(g.label) AS gearLabel, max(o.startDateTime) AS startDateTime, max(o.endDateTime) AS endDateTime, max(o.comments) AS comments, @@ -230,16 +230,16 @@ max(case when (rl.locationLevel.id = :locationLevelIdLocalite) then rl.id else null end) AS localiteId, max(case when (va.isCatchOnOperationVessel = false) then va.id.vessel.code else o.vessel.code end) as vesselCode FROM - FishingOperationImpl o - INNER JOIN o.gearUseFeatures guf - LEFT OUTER JOIN guf.gear g - LEFT OUTER JOIN guf.fishingAreas fa - LEFT OUTER JOIN fa.regulationLocation fa2rl - LEFT OUTER JOIN fa2rl.id.location rl - LEFT OUTER JOIN o.operationVesselAssociations va - WHERE - o.id=:fishingOperationId - GROUP BY o.name + FishingOperationImpl o + INNER JOIN o.gearUseFeatures guf + LEFT OUTER JOIN guf.gear g + LEFT OUTER JOIN guf.fishingAreas fa + LEFT OUTER JOIN fa.regulationLocation fa2rl + LEFT OUTER JOIN fa2rl.id.location rl + LEFT OUTER JOIN o.operationVesselAssociations va + WHERE + o.id=:fishingOperationId + GROUP BY o.name ]]> <query-param name="fishingOperationId" type="java.lang.Integer"/> <query-param name="locationLevelIdStrata" type="java.lang.Integer"/> @@ -250,8 +250,8 @@ <query cacheable="true" name="fishingOperationRankOrder"> <![CDATA[ SELECT - count(o1.id) + 1 as fishingOperationRankOrder - FROM + count(o1.id) + 1 as fishingOperationRankOrder + FROM FishingOperationImpl o1, FishingOperationImpl o2 WHERE @@ -319,7 +319,38 @@ <query-param name="fishingOperationId" type="java.lang.Integer"/> <query-param name="catchBatchId" type="java.lang.Integer"/> </query> - + + <query cacheable="true" name="allFishingOperationSamples"> + <![CDATA[ + SELECT + s.id AS id, + s.referenceTaxon.id AS referenceTaxon, + s.comments AS comment + FROM + SampleImpl s + WHERE + s.fishingOperation.id= :fishingOperationId + ORDER BY + s.creationDate + ]]> + <query-param name="fishingOperationId" type="java.lang.Integer"/> + </query> + + <query cacheable="true" name="sampleMeasurements"> + <![CDATA[ + SELECT + sm.pmfm.id as pmfmId, + sm.numericalValue as numericalValue, + sm.alphanumericalValue as alphanumericalValue, + sm.qualitativeValue.id as qualitativeValueId + from + SampleMeasurementImpl sm + WHERE + sm.sample.id = :sampleId + ]]> + <query-param name="sampleId" type="java.lang.Integer"/> + </query> + <query cacheable="true" name="catchBatch"> <![CDATA[ SELECT Modified: trunk/tutti-persistence/src/main/resources/tutti-db-enumerations.properties =================================================================== --- trunk/tutti-persistence/src/main/resources/tutti-db-enumerations.properties 2013-04-18 15:00:28 UTC (rev 821) +++ trunk/tutti-persistence/src/main/resources/tutti-db-enumerations.properties 2013-04-18 15:22:51 UTC (rev 822) @@ -385,6 +385,10 @@ #PSFM "Remis à l'eau mort ou vivant" PmfmId.DEAD_OR_ALIVE=1393 +#TODO A creer (type alphanumeric) +# PSFM "Classe de Taille dans captures accidentelles / données individuelles" (écran capture accidentelle / observation individuelle) +PmfmId.SAMPLE_LENGTH_STEP=1432 + # (20=observateur volant, 95=Administrateur SIH) -> L'avantage du 20 est qu'il est inactif (=20), donc plus facilement detectable PersonId.UNKNOWN_RECORDER_PERSON=20 @@ -403,4 +407,6 @@ VesselPersonRoleId.RECORDER_PERSON=4 TranscribingTypeId.TAXINOMIE_REFTAX_MNEMONIQUE=101 -TranscribingTypeId.TAXINOMIE_COMMUN_NOM_VERNACULAIRE=102 \ No newline at end of file +TranscribingTypeId.TAXINOMIE_COMMUN_NOM_VERNACULAIRE=102 + +MatrixId.PRODUCT_BATCH=1 \ No newline at end of file Modified: 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-04-18 15:00:28 UTC (rev 821) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/DatabaseFixtures.java 2013-04-18 15:22:51 UTC (rev 822) @@ -25,18 +25,28 @@ */ 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.Cruise; +import fr.ifremer.tutti.persistence.entities.data.FishingOperation; +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.CruisePersistenceService; +import fr.ifremer.tutti.persistence.service.FishingOperationPersistenceService; 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; @@ -150,6 +160,14 @@ return 467; } + public Integer refNumericalPmfmId() { + return 113; + } + + public Integer refAlphanumericPmfmId() { + return 1424; + } + public String refSpeciesRefTaxCode() { return "SEPIOFF"; } @@ -174,10 +192,30 @@ return 114; } - public Cruise createCruise(ReferentialPersistenceService referentialService, - ProgramPersistenceService programService, - CruisePersistenceService service) { + protected CruisePersistenceService cruiseService; + protected ProgramPersistenceService programService; + + protected FishingOperationPersistenceService fishingOperationService; + + protected ReferentialPersistenceService referentialService; + + protected AccidentalBatchPersistenceService accidentalBatchService; + + public void setUp() { + if (referentialService == null) { + referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService(); + programService = TuttiPersistenceServiceLocator.getProgramPersistenceService(); + cruiseService = TuttiPersistenceServiceLocator.getCruisePersistenceService(); + fishingOperationService = TuttiPersistenceServiceLocator.getFishingOperationPersistenceService(); + accidentalBatchService = TuttiPersistenceServiceLocator.getAccidentalBatchPersistenceService(); + } + } + + public Cruise createCruise() { + + setUp(); + String programCode = programCode(); Cruise cruise = TuttiBeanFactory.newCruise(); @@ -218,7 +256,115 @@ cruise.setMultirigNumber(2); - Cruise result = service.createCruise(cruise); + 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(); + for (Caracteristic caracteristic : allEnvironmentCaracteristics) { + Serializable value = null; + if (caracteristic.getCaracteristicType() == CaracteristicType.NUMBER) { + value = 1.0f; + } else if (caracteristic.getCaracteristicType() == CaracteristicType.TEXT) { + value = "some text"; + } else if (caracteristic.getCaracteristicType() == CaracteristicType.QUALITATIVE + && caracteristic.getQualitativeValue(0) != null) { + // Choose the first qualitative value + value = caracteristic.getQualitativeValue(0); + } + 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(); + for (Caracteristic caracteristic : allGearShootingCaracteristics) { + Serializable value = null; + if (caracteristic.getCaracteristicType() == CaracteristicType.NUMBER) { + value = 1.0f; + } else if (caracteristic.getCaracteristicType() == CaracteristicType.TEXT) { + value = "some text"; + } else if (caracteristic.getCaracteristicType() == CaracteristicType.QUALITATIVE + && caracteristic.getQualitativeValue(0) != null) { + // Choose the first qualitative value + value = caracteristic.getQualitativeValue(0); + } + 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 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; + } } 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-04-18 15:00:28 UTC (rev 821) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceWriteTest.java 2013-04-18 15:22:51 UTC (rev 822) @@ -25,18 +25,26 @@ */ import fr.ifremer.tutti.persistence.DatabaseResource; +import fr.ifremer.tutti.persistence.entities.CaracteristicMap; +import fr.ifremer.tutti.persistence.entities.TuttiEntities; +import fr.ifremer.tutti.persistence.entities.data.AccidentalBatch; +import fr.ifremer.tutti.persistence.entities.data.Cruise; +import fr.ifremer.tutti.persistence.entities.data.FishingOperation; +import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; +import org.apache.commons.collections.CollectionUtils; +import org.junit.Assert; import org.junit.Before; import org.junit.ClassRule; -import org.junit.Ignore; import org.junit.Test; +import java.util.List; + /** * To test {@link AccidentalBatchPersistenceService} for write operation. * * @author tchemit <chemit@codelutin.com> * @since 0.3 */ -@Ignore public class AccidentalBatchPersistenceServiceWriteTest { @ClassRule @@ -44,22 +52,131 @@ protected AccidentalBatchPersistenceService service; + protected ReferentialPersistenceService referentialService; + + protected FishingOperation fishingOperation; + @Before public void setUp() throws Exception { + referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService(); service = TuttiPersistenceServiceLocator.getAccidentalBatchPersistenceService(); + Cruise cruise = dbResource.getFixtures().createCruise(); + fishingOperation = dbResource.getFixtures().createFishingOperation(cruise); } @Test public void createAccidentalBatch(/*AccidentalBatch bean*/) { - } + // ----------------------------------------------------------------------------- + // 1. Create with only mandatory properties + // ----------------------------------------------------------------------------- - @Test - public void saveAccidentalBatch(/*AccidentalBatch bean*/) { + AccidentalBatch createdAccidentalBatch = dbResource.getFixtures().createMinimalAccidentalBatch(fishingOperation); + Assert.assertNotNull(createdAccidentalBatch); + Assert.assertNotNull(createdAccidentalBatch.getId()); + + // reload it + List<AccidentalBatch> allAccidentalBatch = service.getAllAccidentalBatch(fishingOperation.getId()); + Assert.assertTrue(CollectionUtils.isNotEmpty(allAccidentalBatch)); + AccidentalBatch reloadedAccidentalBatch = allAccidentalBatch.get(0); + reloadedAccidentalBatch.setFishingOperation(fishingOperation); + assertEqualsAccidentalBatch(createdAccidentalBatch, reloadedAccidentalBatch); + + // ----------------------------------------------------------------------------- + // 2. Create a full with all properties + // ----------------------------------------------------------------------------- + + AccidentalBatch fullAccidentalBatch = createdAccidentalBatch; + fullAccidentalBatch.setId((String) null); + + CaracteristicMap caracteristicMap = new CaracteristicMap(); + fullAccidentalBatch.setCaracteristics(caracteristicMap); + + // add a qualitative caracteristic + Caracteristic maturityCaracteristic = referentialService.getMaturityCaracteristic(); + caracteristicMap.put(maturityCaracteristic, maturityCaracteristic.getQualitativeValue(0)); + + // add a numeric caracteristic + Caracteristic ageCaracteristic = referentialService.getAgeCaracteristic(); + caracteristicMap.put(ageCaracteristic, 10.f); + + // add a string caracteristic + Caracteristic stringCaracteristic = referentialService.getCaracteristic(dbResource.getFixtures().refAlphanumericPmfmId()); + caracteristicMap.put(stringCaracteristic, "Un texte!"); + + fullAccidentalBatch.setSize(10.0f); + fullAccidentalBatch.setComment("AccidentalBatch-full"); + fullAccidentalBatch.setDeadOrAlive(referentialService.getDeadOrAliveCaracteristic().getQualitativeValue(0)); + fullAccidentalBatch.setGender(referentialService.getSexCaracteristic().getQualitativeValue(0)); + + fullAccidentalBatch.setLengthStepCaracteristic(referentialService.getCaracteristic(dbResource.getFixtures().refNumericalPmfmId())); + fullAccidentalBatch.setWeight(5.f); + + AccidentalBatch createdAccidentalBatch2 = + service.createAccidentalBatch(fullAccidentalBatch); + + assertEqualsAccidentalBatch(fullAccidentalBatch, createdAccidentalBatch2); + + Assert.assertNotNull(createdAccidentalBatch2); + Assert.assertNotNull(createdAccidentalBatch2.getId()); + assertEqualsAccidentalBatch(fullAccidentalBatch, createdAccidentalBatch2); + + // reload it + allAccidentalBatch = service.getAllAccidentalBatch(fishingOperation.getId()); + Assert.assertTrue(CollectionUtils.isNotEmpty(allAccidentalBatch)); + Assert.assertEquals(2, allAccidentalBatch.size()); + AccidentalBatch reloadedAccidentalBatch2 = TuttiEntities.splitById(allAccidentalBatch).get(createdAccidentalBatch2.getId()); + reloadedAccidentalBatch2.setFishingOperation(fishingOperation); + assertEqualsAccidentalBatch(createdAccidentalBatch2, reloadedAccidentalBatch2); + + // ----------------------------------------------------------------------------- + // 2. Modify some properties and save + // ----------------------------------------------------------------------------- + AccidentalBatch modifiedAccidentalBatch = reloadedAccidentalBatch2; + modifiedAccidentalBatch.setComment("Comment2"); + modifiedAccidentalBatch.setSize(15f); + modifiedAccidentalBatch.setWeight(35f); + modifiedAccidentalBatch.setDeadOrAlive(referentialService.getDeadOrAliveCaracteristic().getQualitativeValue(1)); + modifiedAccidentalBatch.setGender(referentialService.getSexCaracteristic().getQualitativeValue(1)); + modifiedAccidentalBatch.getCaracteristics().clear(); + + AccidentalBatch savedAccidentalBatch = service.saveAccidentalBatch(modifiedAccidentalBatch); + assertEqualsAccidentalBatch(modifiedAccidentalBatch, savedAccidentalBatch); + + allAccidentalBatch = service.getAllAccidentalBatch(fishingOperation.getId()); + Assert.assertTrue(CollectionUtils.isNotEmpty(allAccidentalBatch)); + AccidentalBatch reloadedAccidentalBatch3 = TuttiEntities.splitById(allAccidentalBatch).get(createdAccidentalBatch2.getId()); + reloadedAccidentalBatch3.setFishingOperation(fishingOperation); + assertEqualsAccidentalBatch(savedAccidentalBatch, reloadedAccidentalBatch3); } + protected void assertEqualsAccidentalBatch(AccidentalBatch expected, + AccidentalBatch actual) { + Assert.assertEquals(expected, actual); + Assert.assertEquals(expected.getSize(), actual.getSize()); + Assert.assertEquals(expected.getComment(), actual.getComment()); + Assert.assertEquals(expected.getDeadOrAlive(), actual.getDeadOrAlive()); + Assert.assertEquals(expected.getGender(), actual.getGender()); + Assert.assertEquals(expected.getLengthStepCaracteristic(), actual.getLengthStepCaracteristic()); + Assert.assertEquals(expected.getWeight(), actual.getWeight()); + Assert.assertEquals(expected.getCaracteristics(), actual.getCaracteristics()); + Assert.assertEquals(expected.getFishingOperation(), actual.getFishingOperation()); + } + @Test public void deleteAccidentalBatch(/*String id*/) { + + AccidentalBatch createdAccidentalBatch = + dbResource.getFixtures().createMinimalAccidentalBatch( + fishingOperation); + + List<AccidentalBatch> allAccidentalBatch = service.getAllAccidentalBatch(fishingOperation.getId()); + Assert.assertFalse(CollectionUtils.isEmpty(allAccidentalBatch)); + + service.deleteAccidentalBatch(createdAccidentalBatch.getId()); + + List<AccidentalBatch> allAccidentalBatch2 = service.getAllAccidentalBatch(fishingOperation.getId()); + Assert.assertTrue(CollectionUtils.isEmpty(allAccidentalBatch2)); } } 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-04-18 15:00:28 UTC (rev 821) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceWriteTest.java 2013-04-18 15:22:51 UTC (rev 822) @@ -82,7 +82,7 @@ fishingOperationService = TuttiPersistenceServiceLocator.getFishingOperationPersistenceService(); referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService(); - cruise = dbResource.getFixtures().createCruise(referentialService, programService, cruiseService); + cruise = dbResource.getFixtures().createCruise(); // cruiseService.getCruise(dbResource.getFixtures().cruiseId()); // cruise.setId((String) null); Calendar calendar = new GregorianCalendar(); 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-04-18 15:00:28 UTC (rev 821) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceWriteTest.java 2013-04-18 15:22:51 UTC (rev 822) @@ -46,7 +46,6 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; /** * To test {@link CruisePersistenceService} for write operation. @@ -214,7 +213,7 @@ // 1. Init a cruise (by copy) // ----------------------------------------------------------------------------- // Cruise cruise = service.getCruise(dbResource.getFixtures().cruiseId()); - Cruise cruise = dbResource.getFixtures().createCruise(referentialService, programService, service); + Cruise cruise = dbResource.getFixtures().createCruise(); cruise.setId((String) null); Calendar calendar = new GregorianCalendar();