This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository observe. See http://git.codelutin.com/observe.git commit 5e48a71456549f04d9163766519eddc64f53855f Author: Tony CHEMIT <chemit@codelutin.com> Date: Sat Aug 29 10:47:46 2015 +0200 Ajout des résultats de l'action de consolidation des données de marée Seine (See #7488) --- .../ConsolidateActivitySeineDataResult.java | 180 ++++++++++++-- .../ConsolidateTripSeineDataRequest.java | 19 +- .../ConsolidateTripSeineDataResult.java | 50 ++-- .../consolidate/ConsolidationDataService.java | 5 +- .../ConsolidateActivitySeineDataResultBuilder.java | 232 ++++++++++++++++++ .../consolidate/ConsolidationDataServiceTopia.java | 268 +++++++-------------- 6 files changed, 538 insertions(+), 216 deletions(-) diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateActivitySeineDataResult.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateActivitySeineDataResult.java index 8cc778f..b017438 100644 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateActivitySeineDataResult.java +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateActivitySeineDataResult.java @@ -1,10 +1,13 @@ package fr.ird.observe.services.service.actions.consolidate; +import com.google.common.collect.ImmutableSet; + import java.io.Serializable; -import java.util.Date; /** - * Pour retourner le résultat de la consolidation d'une activité de type seine. + * Pour retourner le résultat de la consolidation d'une activité de type Seine. + * + * Un tel objet est créé uniquement si des modifications on été effectuée sur l'activité. * * Created on 28/08/15. * @@ -14,49 +17,192 @@ public class ConsolidateActivitySeineDataResult implements Serializable { private static final long serialVersionUID = 1L; - protected String schoolTypeChanged; - - public void registerLengthWeightParameterNotFound(String speciesId, String oceanId, String sexId, Date routeDate) { + /** + * L'indentifiant de l'activité. + */ + protected String activitySeineId; + + /** + * Le libellé de l'activité. + */ + protected String activitySeineLabel; + + /** + * L'ancien type de banc (si le type de banc a été modifié). + */ + protected String oldSchoolType; + + /** + * Le nouveau type de banc (s'il a été modifié). + */ + protected String newSchoolType; + + /** + * L'ensemble des modifications sur les échantillons cibles. + */ + protected ImmutableSet<TargetLengthModification> targetLengthModifications; + + /** + * L'ensemble des modifications sur les échantillons non cibles. + */ + protected ImmutableSet<NonTargetLengthModification> nonTargetLengthModifications; + + /** + * L'ensemble des modifications sur les captures non cibles. + */ + protected ImmutableSet<NonTargetCatchModification> nonTargetCatchModifications; + + public String getActivitySeineId() { + return activitySeineId; + } + public String getActivitySeineLabel() { + return activitySeineLabel; } - public void registerTargetLengthLengthWasComputed(String targetLengthId, Float length) { + public boolean isSchoolTypeModified() { + return newSchoolType != null; + } + public String getOldSchoolType() { + return oldSchoolType; } - public void registerTargetLengthWeightWasComputed(String targetLengthId, Float weight) { + public String getNewSchoolType() { + return newSchoolType; + } + public ImmutableSet<TargetLengthModification> getTargetLengthModifications() { + return targetLengthModifications; } - public void registerNonTargetLengthLengthWasComputed(String nonTargetLengthId, Float length) { + public ImmutableSet<NonTargetLengthModification> getNonTargetLengthModifications() { + return nonTargetLengthModifications; + } + public ImmutableSet<NonTargetCatchModification> getNonTargetCatchModifications() { + return nonTargetCatchModifications; } - public void registerNonTargetLengthWeightWasComputed(String nonTargetLengthId, Float weight) { + public static class TargetLengthModification implements Serializable { + + private static final long serialVersionUID = 1L; + + protected String targetLengthId; + + protected String speciesLabel; + + protected String propertyName; + + protected Float newValue; + + public String getTargetLengthId() { + return targetLengthId; + } + + public String getSpeciesLabel() { + return speciesLabel; + } + + public String getPropertyName() { + return propertyName; + } + + public Float getNewValue() { + return newValue; + } } - public void registerNonTargetCatchMeanLengthWasComputed(String nonTargetCatchId, Float meanLength, String computeValueSource) { + public static class NonTargetLengthModification implements Serializable { + + private static final long serialVersionUID = 1L; + + protected String nonTargetLengthId; + + protected String speciesLabel; + + protected String propertyName; + + protected Float newValue; + + public String getNonTargetLengthId() { + return nonTargetLengthId; + } + + public String getSpeciesLabel() { + return speciesLabel; + } + + public String getPropertyName() { + return propertyName; + } + + public Float getNewValue() { + return newValue; + } } - public void registerNonTargetCatchMeanWeightWasComputed(String nonTargetCatchId, Float meanWeight, String computeValueSource) { + public static class NonTargetCatchModification implements Serializable { + + private static final long serialVersionUID = 1L; + + protected String nonTargetCatchId; + + protected String speciesLabel; + + protected String propertyName; + + protected Number newValue; + + protected String computeValueSource; + + public String getNonTargetCatchId() { + return nonTargetCatchId; + } + + public String getSpeciesLabel() { + return speciesLabel; + } + + public String getPropertyName() { + return propertyName; + } + + public Number getNewValue() { + return newValue; + } + + public String getComputeValueSource() { + return computeValueSource; + } } - public void registerNonTargetCatchCatchWeightWasComputed(String nonTargetCatchId, Float catchWeight, String computeValueSource) { + void setActivitySeineId(String activitySeineId) { + this.activitySeineId = activitySeineId; + } + void setActivitySeineLabel(String activitySeineLabel) { + this.activitySeineLabel = activitySeineLabel; } - public void registerNonTargetCatchTotalCountWasComputed(String nonTargetCatchId, Integer totalCount, String computeValueSource) { + void setSchoolTypeChanged(String oldSchoolType, String newSchoolType) { + this.oldSchoolType = oldSchoolType; + this.newSchoolType = newSchoolType; + } + void setTargetLengthModifications(ImmutableSet<TargetLengthModification> targetLengthModifications) { + this.targetLengthModifications = targetLengthModifications; } - public void setSchoolTypeChanged(String schoolTypeChanged) { - this.schoolTypeChanged = schoolTypeChanged; + void setNonTargetLengthModifications(ImmutableSet<NonTargetLengthModification> nonTargetLengthModifications) { + this.nonTargetLengthModifications = nonTargetLengthModifications; } - public String getSchoolTypeChanged() { - return schoolTypeChanged; + void setNonTargetCatchModifications(ImmutableSet<NonTargetCatchModification> nonTargetCatchModifications) { + this.nonTargetCatchModifications = nonTargetCatchModifications; } + } diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateTripSeineDataRequest.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateTripSeineDataRequest.java index a43081f..0077f09 100644 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateTripSeineDataRequest.java +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateTripSeineDataRequest.java @@ -5,19 +5,34 @@ import com.google.common.collect.ImmutableSet; import java.io.Serializable; /** - * Pour configurer l'opération de consolidation. + * Pour configurer l'opération de consolidation de données sur les marées de type Seine. * * Created on 28/08/15. * * @author Tony Chemit - chemit@codelutin.com - * @see ConsolidationDataService#consolidateTripSeines(ConsolidateTripSeineDataRequest) */ public class ConsolidateTripSeineDataRequest implements Serializable { private static final long serialVersionUID = 1L; + /** + * Pour générer une exception si une relation RTP n'est pas trouvée. + */ + protected boolean failIfLenghtWeightParameterNotFound; + + /** + * Les identifiants des marées à consolider. + */ protected ImmutableSet<String> tripSeineIds; + public boolean isFailIfLenghtWeightParameterNotFound() { + return failIfLenghtWeightParameterNotFound; + } + + public void setFailIfLenghtWeightParameterNotFound(boolean failIfLenghtWeightParameterNotFound) { + this.failIfLenghtWeightParameterNotFound = failIfLenghtWeightParameterNotFound; + } + public ImmutableSet<String> getTripSeineIds() { return tripSeineIds; } diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateTripSeineDataResult.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateTripSeineDataResult.java index 7da61b1..4eeaf55 100644 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateTripSeineDataResult.java +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateTripSeineDataResult.java @@ -1,42 +1,52 @@ package fr.ird.observe.services.service.actions.consolidate; +import com.google.common.collect.ImmutableSet; + import java.io.Serializable; -import java.util.LinkedHashSet; -import java.util.Set; /** * Pour retourner le résultat de la consolidation d'une marée de type seine. * + * Un tel objet n'est créé que si des modifications ont été effectuée sur la marée. + * * Created on 28/08/15. * * @author Tony Chemit - chemit@codelutin.com - * @see ConsolidationDataService#consolidateTripSeines(ConsolidateTripSeineDataRequest) */ -public class ConsolidateTripSeineDataResult implements Serializable{ +public class ConsolidateTripSeineDataResult implements Serializable { private static final long serialVersionUID = 1L; - protected boolean tripWasModified; - - protected final Set<ConsolidateActivitySeineDataResult> activitySeineDataResults = new LinkedHashSet<>(); - - public boolean isNoActivityFound() { - return activitySeineDataResults.isEmpty(); - } - - public boolean isTripWasModified() { - return tripWasModified; + /** + * L'identifiant de la marée. + */ + protected final String tripSeineId; + + /** + * Le libéllé de la marée. + */ + protected final String tripSeineLabel; + + /** + * Les résultats pour les activités modifiées lors de l'opération de consolidation. + */ + protected final ImmutableSet<ConsolidateActivitySeineDataResult> consolidateActivitySeineDataResults; + + public ConsolidateTripSeineDataResult(String tripSeineId, String tripSeineLabel, ImmutableSet<ConsolidateActivitySeineDataResult> consolidateActivitySeineDataResults) { + this.tripSeineId = tripSeineId; + this.tripSeineLabel=tripSeineLabel; + this.consolidateActivitySeineDataResults = consolidateActivitySeineDataResults; } - public void setTripWasModified(boolean tripWasModified) { - this.tripWasModified = tripWasModified; + public String getTripSeineId() { + return tripSeineId; } - public void addActivityResult(ConsolidateActivitySeineDataResult activitySeineDataResult) { - activitySeineDataResults.add(activitySeineDataResult); + public String getTripSeineLabel() { + return tripSeineLabel; } - public Set<ConsolidateActivitySeineDataResult> getActivitySeineDataResults() { - return activitySeineDataResults; + public ImmutableSet<ConsolidateActivitySeineDataResult> getConsolidateActivitySeineDataResults() { + return consolidateActivitySeineDataResults; } } diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidationDataService.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidationDataService.java index b76ead7..5fed694 100644 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidationDataService.java +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidationDataService.java @@ -13,8 +13,11 @@ import com.google.common.collect.ImmutableSet; public interface ConsolidationDataService { /** + * Effectue la consolitation à partir de la demande passé en paramètre et retourne les résultats pour les marées + * modifiées. + * * @param consolidateTripSeineDataRequest la demande de consolidation - * @return le résultat de la consolidation de données pour chaque marée. + * @return le résultat de la consolidation de données pour chaque marée qui a été modifée. */ ImmutableSet<ConsolidateTripSeineDataResult> consolidateTripSeines(ConsolidateTripSeineDataRequest consolidateTripSeineDataRequest); diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateActivitySeineDataResultBuilder.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateActivitySeineDataResultBuilder.java new file mode 100644 index 0000000..27739fa --- /dev/null +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateActivitySeineDataResultBuilder.java @@ -0,0 +1,232 @@ +package fr.ird.observe.services.service.actions.consolidate; + +import com.google.common.base.Optional; +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.entities.constants.ReferenceLocale; +import fr.ird.observe.entities.constants.seine.SchoolType; +import fr.ird.observe.entities.referentiel.I18nReferenceEntities; +import fr.ird.observe.entities.referentiel.Ocean; +import fr.ird.observe.entities.referentiel.Sex; +import fr.ird.observe.entities.referentiel.Species; +import fr.ird.observe.entities.referentiel.Species2; +import fr.ird.observe.entities.seine.ActivitySeine; +import fr.ird.observe.entities.seine.ActivitySeines; +import fr.ird.observe.entities.seine.NonTargetCatch; +import fr.ird.observe.entities.seine.NonTargetLength; +import fr.ird.observe.entities.seine.TargetLength; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import java.util.Date; +import java.util.Locale; + +import static fr.ird.observe.services.service.actions.consolidate.ConsolidateActivitySeineDataResult.NonTargetCatchModification; +import static fr.ird.observe.services.service.actions.consolidate.ConsolidateActivitySeineDataResult.NonTargetLengthModification; +import static fr.ird.observe.services.service.actions.consolidate.ConsolidateActivitySeineDataResult.TargetLengthModification; +import static org.nuiton.i18n.I18n.l; + +/** + * Created on 29/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ConsolidateActivitySeineDataResultBuilder { + + /** Logger. */ + private static final Log log = LogFactory.getLog(ConsolidateActivitySeineDataResultBuilder.class); + + public static ConsolidateActivitySeineDataResultBuilder create(Locale locale, ReferenceLocale referenceLocale, ActivitySeine activitySeine) { + return new ConsolidateActivitySeineDataResultBuilder(locale, referenceLocale, activitySeine); + } + + protected final ReferenceLocale referenceLocale; + + protected final Locale locale; + protected final ActivitySeine activitySeine; + + protected String oldSchoolType; + + protected String newSchoolType; + + protected ImmutableSet.Builder<String> lengthWeightParameterNotFoundBuilder = new ImmutableSet.Builder<>(); + + protected ImmutableSet.Builder<TargetLengthModification> targetLengthModificationBuilder = new ImmutableSet.Builder<>(); + + protected ImmutableSet.Builder<NonTargetLengthModification> nonTargetLengthModificationBuilder = new ImmutableSet.Builder<>(); + + protected ImmutableSet.Builder<NonTargetCatchModification> nonTargetCatchModificationBuilder = new ImmutableSet.Builder<>(); + + public void flushTargetLengthModification(TargetLength targetLength, String... propertyNamesModified) { + + Species species = targetLength.getSpecies(); + String speciesLabel = Species2.decorate(locale, species); + for (String modifiedProperty : propertyNamesModified) { + if (modifiedProperty.equals(TargetLength.PROPERTY_LENGTH)) { + + TargetLengthModification element = new TargetLengthModification(); + element.targetLengthId = targetLength.getTopiaId(); + element.speciesLabel = speciesLabel; + element.propertyName = TargetLength.PROPERTY_LENGTH; + element.newValue = targetLength.getLength(); + targetLengthModificationBuilder.add(element); + + } else if (modifiedProperty.equals(TargetLength.PROPERTY_WEIGHT)) { + + TargetLengthModification element = new TargetLengthModification(); + element.targetLengthId = targetLength.getTopiaId(); + element.speciesLabel = speciesLabel; + element.propertyName = TargetLength.PROPERTY_LENGTH; + element.newValue = targetLength.getLength(); + targetLengthModificationBuilder.add(element); + + } + } + + } + + public void flushNonTargetLengthModification(NonTargetLength nonTargetLength, String... propertyNamesModified) { + + Species species = nonTargetLength.getSpecies(); + String speciesLabel = Species2.decorate(locale, species); + for (String modifiedProperty : propertyNamesModified) { + if (modifiedProperty.equals(NonTargetLength.PROPERTY_LENGTH)) { + + NonTargetLengthModification element = new NonTargetLengthModification(); + element.nonTargetLengthId = nonTargetLength.getTopiaId(); + element.speciesLabel = speciesLabel; + element.propertyName = NonTargetLength.PROPERTY_LENGTH; + element.newValue = nonTargetLength.getLength(); + nonTargetLengthModificationBuilder.add(element); + + } else if (modifiedProperty.equals(NonTargetLength.PROPERTY_WEIGHT)) { + + NonTargetLengthModification element = new NonTargetLengthModification(); + element.nonTargetLengthId = nonTargetLength.getTopiaId(); + element.speciesLabel = speciesLabel; + element.propertyName = NonTargetLength.PROPERTY_LENGTH; + element.newValue = nonTargetLength.getLength(); + nonTargetLengthModificationBuilder.add(element); + + } + } + + } + + public void flushNonTargetCatchModification(NonTargetCatch nonTargetCatch, String... propertyNamesModified) { + + Species species = nonTargetCatch.getSpecies(); + String speciesLabel = Species2.decorate(locale, species); + for (String modifiedProperty : propertyNamesModified) { + switch (modifiedProperty) { + case NonTargetCatch.PROPERTY_MEAN_LENGTH: { + + NonTargetCatchModification element = new NonTargetCatchModification(); + element.nonTargetCatchId = nonTargetCatch.getTopiaId(); + element.speciesLabel = speciesLabel; + element.propertyName = NonTargetCatch.PROPERTY_MEAN_LENGTH; + element.newValue = nonTargetCatch.getMeanLength(); + element.computeValueSource = l(locale, nonTargetCatch.getMeanLengthComputedSource().getI18nKey()); + nonTargetCatchModificationBuilder.add(element); + + break; + } + case NonTargetCatch.PROPERTY_MEAN_WEIGHT: { + + NonTargetCatchModification element = new NonTargetCatchModification(); + element.nonTargetCatchId = nonTargetCatch.getTopiaId(); + element.speciesLabel = speciesLabel; + element.propertyName = NonTargetCatch.PROPERTY_MEAN_WEIGHT; + element.newValue = nonTargetCatch.getMeanWeight(); + element.computeValueSource = l(locale, nonTargetCatch.getMeanWeightComputedSource().getI18nKey()); + nonTargetCatchModificationBuilder.add(element); + + break; + } + case NonTargetCatch.PROPERTY_CATCH_WEIGHT: { + + NonTargetCatchModification element = new NonTargetCatchModification(); + element.nonTargetCatchId = nonTargetCatch.getTopiaId(); + element.speciesLabel = speciesLabel; + element.propertyName = NonTargetCatch.PROPERTY_CATCH_WEIGHT; + element.newValue = nonTargetCatch.getCatchWeight(); + element.computeValueSource = l(locale, nonTargetCatch.getCatchWeightComputedSource().getI18nKey()); + nonTargetCatchModificationBuilder.add(element); + + break; + } + case NonTargetCatch.PROPERTY_TOTAL_COUNT: { + + NonTargetCatchModification element = new NonTargetCatchModification(); + element.nonTargetCatchId = nonTargetCatch.getTopiaId(); + element.speciesLabel = speciesLabel; + element.propertyName = NonTargetCatch.PROPERTY_TOTAL_COUNT; + element.newValue = nonTargetCatch.getTotalCount(); + element.computeValueSource = l(locale, nonTargetCatch.getTotalCountComputedSource().getI18nKey()); + nonTargetCatchModificationBuilder.add(element); + + break; + } + } + } + + } + + public ConsolidateActivitySeineDataResultBuilder registerLengthWeightParameterNotFound(Species species, Ocean ocean, Sex sex, Date routeDate) { + String speciesLabel = Species2.decorate(locale, species); + String oceanLabel = I18nReferenceEntities.decorate(referenceLocale, ocean); + String sexLabel = sex == null ? l(locale, "observe.service.actions.consolidate.noSex") : I18nReferenceEntities.decorate(referenceLocale, sex); + String message = l(locale, "observe.service.actions.consolidate.lengthWeightParameterNotFound", speciesLabel, oceanLabel, sexLabel, routeDate); + lengthWeightParameterNotFoundBuilder.add(message); + if (log.isWarnEnabled()) { + log.warn(message); + } + return this; + } + + public ConsolidateActivitySeineDataResultBuilder setSchoolTypeChanged(SchoolType oldSchoolType, SchoolType newSchoolType) { + this.oldSchoolType = l(locale, oldSchoolType.getI18nKey()); + this.newSchoolType = l(locale, newSchoolType.getI18nKey()); + return this; + } + + public Optional<ConsolidateActivitySeineDataResult> build() { + + ImmutableSet<TargetLengthModification> targetLengthModifications = targetLengthModificationBuilder.build(); + ImmutableSet<NonTargetLengthModification> nonTargetLengthModifications = nonTargetLengthModificationBuilder.build(); + ImmutableSet<NonTargetCatchModification> nonTargetCatchModifications = nonTargetCatchModificationBuilder.build(); + + boolean noModification = (targetLengthModifications.isEmpty() + && nonTargetLengthModifications.isEmpty() + && nonTargetCatchModifications.isEmpty() + && newSchoolType == null); + + ConsolidateActivitySeineDataResult consolidateActivitySeineDataResult; + if (noModification) { + + consolidateActivitySeineDataResult = null; + + } else { + + consolidateActivitySeineDataResult = new ConsolidateActivitySeineDataResult(); + consolidateActivitySeineDataResult.setActivitySeineId(activitySeine.getTopiaId()); + consolidateActivitySeineDataResult.setActivitySeineLabel(ActivitySeines.decorate(referenceLocale, activitySeine)); + + if (newSchoolType != null) { + consolidateActivitySeineDataResult.setSchoolTypeChanged(oldSchoolType, newSchoolType); + } + consolidateActivitySeineDataResult.setTargetLengthModifications(targetLengthModifications); + consolidateActivitySeineDataResult.setNonTargetLengthModifications(nonTargetLengthModifications); + consolidateActivitySeineDataResult.setNonTargetCatchModifications(nonTargetCatchModifications); + + } + + return Optional.fromNullable(consolidateActivitySeineDataResult); + + } + + protected ConsolidateActivitySeineDataResultBuilder(Locale locale, ReferenceLocale referenceLocale, ActivitySeine activitySeine) { + this.locale = locale; + this.referenceLocale = referenceLocale; + this.activitySeine = activitySeine; + } +} diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidationDataServiceTopia.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidationDataServiceTopia.java index ca30c16..a7fb520 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidationDataServiceTopia.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidationDataServiceTopia.java @@ -1,11 +1,15 @@ package fr.ird.observe.services.service.actions.consolidate; +import com.google.common.base.Optional; import com.google.common.collect.ImmutableSet; +import fr.ird.observe.ObserveTopiaDaoSupplier; +import fr.ird.observe.ObserveTopiaPersistenceContext; import fr.ird.observe.entities.LengthWeightComputable; +import fr.ird.observe.entities.constants.ReferenceLocale; import fr.ird.observe.entities.constants.seine.NonTargetCatchComputedValueSource; import fr.ird.observe.entities.constants.seine.SchoolType; import fr.ird.observe.entities.referentiel.LengthWeightParameter; -import fr.ird.observe.entities.referentiel.LengthWeightParameterTopiaDao; +import fr.ird.observe.entities.referentiel.LengthWeightParameterNotFoundException; import fr.ird.observe.entities.referentiel.LengthWeightParameters; import fr.ird.observe.entities.referentiel.Ocean; import fr.ird.observe.entities.referentiel.Sex; @@ -21,6 +25,7 @@ import fr.ird.observe.entities.seine.SetSeines; import fr.ird.observe.entities.seine.TargetLength; import fr.ird.observe.entities.seine.TargetSample; import fr.ird.observe.entities.seine.TripSeine; +import fr.ird.observe.entities.seine.TripSeines; import fr.ird.observe.services.ObserveServiceTopia; import fr.ird.observe.services.dto.seine.TripSeineDto; import org.apache.commons.collections4.CollectionUtils; @@ -30,6 +35,7 @@ import org.nuiton.util.beans.BeanMonitor; import java.util.Collection; import java.util.Date; +import java.util.Locale; /** * Created on 28/08/15. @@ -41,9 +47,13 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement /** Logger. */ private static final Log log = LogFactory.getLog(ConsolidationDataServiceTopia.class); -// private static final String MESSAGE_FORMAT_3 = "[%1$s] %2$s calculé : %3$s (%4$s:%5$s, %6$s:%7$s)"; + protected static class ConsolidationActivitySeineDataContext { - class ConsolidationActivitySeineDataContext { + protected ObserveTopiaDaoSupplier daoSupplier; + + protected Locale locale; + + protected boolean failIfLenghtWeightParameterNotFound; protected TripSeine tripSeine; @@ -51,15 +61,13 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement protected ActivitySeine activity; - protected LengthWeightParameterTopiaDao lengthWeightParameterTopiaDao; + protected BeanMonitor targetLengthMonitor; - protected ConsolidateActivitySeineDataResult consolidateActivitySeineDataResult; + protected BeanMonitor nonTargetLengthMonitor; - BeanMonitor targetLengthMonitor; + protected BeanMonitor nonTargetCatchMonitor; - BeanMonitor nonTargetLengthMonitor; - - BeanMonitor nonTargetCatchMonitor; + protected ConsolidateActivitySeineDataResultBuilder resultBuilder; public Ocean getOcean() { return tripSeine.getOcean(); @@ -76,18 +84,21 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement public LengthWeightParameter findLengthWeightParameter(Species species, Sex sex) { Ocean ocean = getOcean(); Date routeDate = getRouteDate(); - LengthWeightParameter lengthWeightParameter = LengthWeightParameters.findLengthWeightParameter(getTopiaPersistenceContext(), species, ocean, sex, routeDate); + LengthWeightParameter lengthWeightParameter = LengthWeightParameters.findLengthWeightParameter(daoSupplier, species, ocean, sex, routeDate); if (lengthWeightParameter == null) { - //FIXME On devrait retourner une erreur plutôt - consolidateActivitySeineDataResult.registerLengthWeightParameterNotFound(species.getTopiaId(), ocean.getTopiaId(), sex == null ? null : sex.getTopiaId(), routeDate); + if (failIfLenghtWeightParameterNotFound) { + throw new LengthWeightParameterNotFoundException(species, ocean, sex, routeDate); + } + + resultBuilder.registerLengthWeightParameterNotFound(species, ocean, sex, routeDate); } return lengthWeightParameter; } - public void setSchoolTypeChanged(SchoolType schoolTypeChanged) { - consolidateActivitySeineDataResult.setSchoolTypeChanged(schoolTypeChanged.name()); + public void setSchoolTypeChanged(SchoolType oldSchoolType, SchoolType newSchoolType) { + resultBuilder.setSchoolTypeChanged(oldSchoolType, newSchoolType); } public void watchTargetLength(TargetLength targetLength) { @@ -101,15 +112,7 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement public void flushTargetLength() { if (targetLengthMonitor.wasModified()) { TargetLength targetLength = (TargetLength) targetLengthMonitor.getBean(); - Species species = targetLength.getSpecies(); - String speciesLabel = ""; - for (String modifiedProperty : targetLengthMonitor.getModifiedProperties()) { - if (modifiedProperty.equals(TargetLength.PROPERTY_LENGTH)) { - consolidateActivitySeineDataResult.registerTargetLengthLengthWasComputed(targetLength.getTopiaId(), targetLength.getLength()); - } else if (modifiedProperty.equals(TargetLength.PROPERTY_WEIGHT)) { - consolidateActivitySeineDataResult.registerTargetLengthWeightWasComputed(targetLength.getTopiaId(), targetLength.getWeight()); - } - } + resultBuilder.flushTargetLengthModification(targetLength, targetLengthMonitor.getModifiedProperties()); } targetLengthMonitor.setBean(null); } @@ -117,16 +120,7 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement public void flushNonTargetLength() { if (nonTargetLengthMonitor.wasModified()) { NonTargetLength nonTargetLength = (NonTargetLength) nonTargetLengthMonitor.getBean(); - Species species = nonTargetLength.getSpecies(); - String speciesLabel = ""; - for (String modifiedProperty : nonTargetLengthMonitor.getModifiedProperties()) { - if (modifiedProperty.equals(NonTargetLength.PROPERTY_LENGTH)) { - consolidateActivitySeineDataResult.registerNonTargetLengthLengthWasComputed(nonTargetLength.getTopiaId(), nonTargetLength.getLength()); - } else if (modifiedProperty.equals(NonTargetLength.PROPERTY_WEIGHT)) { - consolidateActivitySeineDataResult.registerNonTargetLengthWeightWasComputed(nonTargetLength.getTopiaId(), nonTargetLength.getWeight()); - } - } - + resultBuilder.flushNonTargetLengthModification(nonTargetLength, nonTargetLengthMonitor.getModifiedProperties()); } nonTargetLengthMonitor.setBean(null); } @@ -138,43 +132,36 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement public void flushNonTargetCatch() { if (nonTargetCatchMonitor.wasModified()) { NonTargetCatch nonTargetCatch = (NonTargetCatch) nonTargetCatchMonitor.getBean(); - Species species = nonTargetCatch.getSpecies(); - String speciesLabel = ""; - for (String modifiedProperty : nonTargetCatchMonitor.getModifiedProperties()) { - if (modifiedProperty.equals(NonTargetCatch.PROPERTY_MEAN_LENGTH)) { - consolidateActivitySeineDataResult.registerNonTargetCatchMeanLengthWasComputed(nonTargetCatch.getTopiaId(), nonTargetCatch.getMeanLength(), nonTargetCatch.getMeanLengthComputedSource().name()); - } else if (modifiedProperty.equals(NonTargetCatch.PROPERTY_MEAN_WEIGHT)) { - consolidateActivitySeineDataResult.registerNonTargetCatchMeanWeightWasComputed(nonTargetCatch.getTopiaId(), nonTargetCatch.getMeanWeight(), nonTargetCatch.getMeanWeightComputedSource().name()); - } else if (modifiedProperty.equals(NonTargetCatch.PROPERTY_CATCH_WEIGHT)) { - consolidateActivitySeineDataResult.registerNonTargetCatchCatchWeightWasComputed(nonTargetCatch.getTopiaId(), nonTargetCatch.getCatchWeight(), nonTargetCatch.getCatchWeightComputedSource().name()); - } else if (modifiedProperty.equals(NonTargetCatch.PROPERTY_TOTAL_COUNT)) { - consolidateActivitySeineDataResult.registerNonTargetCatchTotalCountWasComputed(nonTargetCatch.getTopiaId(), nonTargetCatch.getTotalCount(), nonTargetCatch.getTotalCountComputedSource().name()); - } - } - + resultBuilder.flushNonTargetCatchModification(nonTargetCatch, nonTargetCatchMonitor.getModifiedProperties()); } nonTargetCatchMonitor.setBean(null); } + } @Override public ImmutableSet<ConsolidateTripSeineDataResult> consolidateTripSeines(ConsolidateTripSeineDataRequest consolidateTripSeineDataRequest) { + ReferenceLocale referenceLocale = getReferenceLocale(); + boolean failIfLenghtWeightParameterNotFound = consolidateTripSeineDataRequest.isFailIfLenghtWeightParameterNotFound(); ImmutableSet.Builder<ConsolidateTripSeineDataResult> resultBuilder = new ImmutableSet.Builder<>(); for (String tripSeineId : consolidateTripSeineDataRequest.getTripSeineIds()) { - ConsolidateTripSeineDataResult consolidateTripSeineDataResult = consolidateTripSeine(tripSeineId); - resultBuilder.add(consolidateTripSeineDataResult); + + Optional<ConsolidateTripSeineDataResult> consolidateTripSeineDataResult = consolidateTripSeine(referenceLocale, tripSeineId, failIfLenghtWeightParameterNotFound); + + if (consolidateTripSeineDataResult.isPresent()) { + resultBuilder.add(consolidateTripSeineDataResult.get()); + } + } return resultBuilder.build(); } - protected ConsolidateTripSeineDataResult consolidateTripSeine(String tripSeineId) { + protected Optional<ConsolidateTripSeineDataResult> consolidateTripSeine(ReferenceLocale referenceLocale, String tripSeineId, boolean failIfLenghtWeightParameterNotFound) { TripSeine tripSeine = loadEntity(TripSeineDto.class, TripSeine.class, tripSeineId); - ConsolidateTripSeineDataResult computationResult = new ConsolidateTripSeineDataResult(); - BeanMonitor targetLengthMonitor = new BeanMonitor( TargetLength.PROPERTY_LENGTH, TargetLength.PROPERTY_LENGTH_SOURCE, @@ -198,35 +185,60 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement NonTargetCatch.PROPERTY_TOTAL_COUNT_COMPUTED_SOURCE ); - LengthWeightParameterTopiaDao lengthWeightParameterDao = getTopiaPersistenceContext().getLengthWeightParameterDao(); + Locale applicationLocale = serviceContext.getApplicationLocale(); + + ObserveTopiaPersistenceContext persistenceContext = getTopiaPersistenceContext(); + + ImmutableSet.Builder<ConsolidateActivitySeineDataResult> actititiesResultBuilder = new ImmutableSet.Builder<>(); for (Route route : tripSeine.getRoute()) { for (ActivitySeine activitySeine : route.getActivitySeine()) { - ConsolidateActivitySeineDataResult consolidateActivitySeineDataResult = new ConsolidateActivitySeineDataResult(); + ConsolidateActivitySeineDataResultBuilder resultBuilder = ConsolidateActivitySeineDataResultBuilder.create(applicationLocale, referenceLocale, activitySeine); + ConsolidationActivitySeineDataContext activityContext = new ConsolidationActivitySeineDataContext(); + activityContext.locale = applicationLocale; + activityContext.failIfLenghtWeightParameterNotFound = failIfLenghtWeightParameterNotFound; + activityContext.daoSupplier = persistenceContext; + activityContext.resultBuilder = resultBuilder; activityContext.tripSeine = tripSeine; activityContext.route = route; activityContext.activity = activitySeine; - activityContext.lengthWeightParameterTopiaDao = lengthWeightParameterDao; - activityContext.consolidateActivitySeineDataResult = consolidateActivitySeineDataResult; activityContext.targetLengthMonitor = targetLengthMonitor; activityContext.nonTargetLengthMonitor = nonTargetSampleMonitor; activityContext.nonTargetCatchMonitor = nonTargetCatchMonitor; - computationResult.addActivityResult(consolidateActivitySeineDataResult); consolidateActivitySeine(activityContext); + Optional<ConsolidateActivitySeineDataResult> consolidateActivitySeineDataResult = resultBuilder.build(); + if (consolidateActivitySeineDataResult.isPresent()) { + + // Des modifications ont été enregistrées sur l'activité + if (log.isInfoEnabled()) { + log.info("Found some modifications on activity: " + activitySeine.getTopiaId()); + } + actititiesResultBuilder.add(consolidateActivitySeineDataResult.get()); + + } + } } - // on devra mettre a jour en base la maree -// messager1.sendMessage(t("observe.message.consolidate.maree.need.update", -// mareeStr)); + ImmutableSet<ConsolidateActivitySeineDataResult> consolidateActivitySeineDataResults = actititiesResultBuilder.build(); + + ConsolidateTripSeineDataResult computationResult; + + if (consolidateActivitySeineDataResults.isEmpty()) { + computationResult = null; + } else { + + computationResult = new ConsolidateTripSeineDataResult(tripSeineId, TripSeines.decorate(referenceLocale, tripSeine), consolidateActivitySeineDataResults); + + } + return Optional.fromNullable(computationResult); - return computationResult; } @@ -239,13 +251,13 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement } SetSeine setSeine = activity.getSetSeine(); - SchoolType oldTypeBanc = setSeine.getSchoolType(); - SchoolType newTypeBanc = activity.getSchoolType(); - if (oldTypeBanc == null || oldTypeBanc != newTypeBanc) { + SchoolType oldSchoolType = setSeine.getSchoolType(); + SchoolType newSchoolType = activity.getSchoolType(); + if (oldSchoolType == null || oldSchoolType != newSchoolType) { // le type de banc a changé, on doit sauver l'activité - setSeine.setSchoolType(newTypeBanc); - activityContext.setSchoolTypeChanged(newTypeBanc); + setSeine.setSchoolType(newSchoolType); + activityContext.setSchoolTypeChanged(oldSchoolType, newSchoolType); } @@ -350,18 +362,6 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement Collection<NonTargetLength> nonTargetLengths = SetSeines.getNonTargetLengths(activityContext.getSetSeine(), species); -// SetSeine setSeine = activityContext.getSetSeine(); -// -// if (!setSeine.isNonTargetSampleEmpty()) { -// nonTargetLengths = Collections2.filter(setSeine.getNonTargetSample().iterator().next().getNonTargetLength(), new Predicate<NonTargetLength>() { -// -// @Override -// public boolean apply(NonTargetLength input) { -// return species.equals(input.getSpecies()); -// } -// }); -// } - if (nonTargetCatch.getCatchWeight() != null || nonTargetCatch.getTotalCount() != null) { // -- Cas n°2 (pas de taille / poids moyen mais au moins un des deux taille / poids) @@ -499,7 +499,6 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement nonTargetCatch.setTotalCount(totalCount); nonTargetCatch.setTotalCountComputedSource(NonTargetCatchComputedValueSource.FROM_SAMPLE); - } } @@ -518,19 +517,24 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement if (lengthWeightParameter != null) { if (nonTargetCatch.getMeanLength() == null) { + nonTargetCatch.setMeanLength(lengthWeightParameter.getMeanLength()); nonTargetCatch.setMeanLengthComputedSource(NonTargetCatchComputedValueSource.FROM_REFERENTIEL); + } if (nonTargetCatch.getMeanWeight() == null) { + nonTargetCatch.setMeanWeight(lengthWeightParameter.getMeanWeight()); nonTargetCatch.setMeanWeightComputedSource(NonTargetCatchComputedValueSource.FROM_REFERENTIEL); + } if (nonTargetCatch.getMeanWeight() != null || nonTargetCatch.getMeanLength() != null) { // on peut aussi relancer la calcul du cas n°1 updateNonTargetCatchByLengthWeightRelation(nonTargetCatch, lengthWeightParameter); + } } @@ -542,25 +546,13 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement Float catchWeight = nonTargetCatch.getCatchWeight(); Integer totalCount = nonTargetCatch.getTotalCount(); -// String entityLabel = getNonTargetCatcheLabel(); - if (catchWeight == null && totalCount != null && meanWeight != null) { // calcul le weight poids à partir de nb estime et du poids moyen catchWeight = meanWeight * (float) totalCount / 1000; nonTargetCatch.setCatchWeight(catchWeight); nonTargetCatch.setCatchWeightComputedSource(NonTargetCatchComputedValueSource.FROM_DATA); -// String message = String.format(MESSAGE_FORMAT_3, -// entityLabel, -// t("observe.common.catchWeight"), -// catchWeight, -// t("observe.common.meanWeight"), -// meanWeight, -// t("observe.common.totalCount"), -// totalCount); -// if (log.isInfoEnabled()) { -// log.info(message); -// } + } if (totalCount == null && catchWeight != null && meanWeight != null) { @@ -569,17 +561,7 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement totalCount = (int) ((float) 1000 * catchWeight / meanWeight); nonTargetCatch.setTotalCount(totalCount); nonTargetCatch.setTotalCountComputedSource(NonTargetCatchComputedValueSource.FROM_DATA); -// String message = String.format(MESSAGE_FORMAT_3, -// entityLabel, -// t("observe.common.totalCount"), -// totalCount, -// t("observe.common.meanWeight"), -// meanWeight, -// t("observe.common.catchWeight"), -// catchWeight); -// if (log.isInfoEnabled()) { -// log.info(message); -// } + } if (meanWeight == null && totalCount != null && totalCount != 0 && catchWeight != null && @@ -591,17 +573,7 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement meanWeight = catchWeight * (float) 1000 / (float) totalCount; nonTargetCatch.setMeanWeight(meanWeight); nonTargetCatch.setMeanWeightComputedSource(NonTargetCatchComputedValueSource.FROM_DATA); -// String message = String.format(MESSAGE_FORMAT_3, -// entityLabel, -// t("observe.common.meanWeight"), -// meanWeight, -// t("observe.common.totalCount"), -// totalCount, -// t("observe.common.catchWeight"), -// catchWeight); -// if (log.isInfoEnabled()) { -// log.info(message); -// } + } } @@ -610,8 +582,6 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement Sex sex, LengthWeightComputable lengthWeightComputable) { -// String entityLabel = getSpeciesLabel(); - Float weight = lengthWeightComputable.getWeight(); Float length = lengthWeightComputable.getLength(); @@ -643,13 +613,6 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement // aucun parametrage connu -// String message = t("observe.message.consolidate.no.parametrage.found", -// t(entityLabel), -// decorate(species) -// ); -// if (log.isWarnEnabled()) { -// log.warn(message); -// } return; } @@ -657,52 +620,31 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement Float newLength = lengthWeightParameter.computeLength(weight); if (newLength != null) { -// // la taille a ete calculee -// String message = -// "[" + t(entityLabel) + "] " + -// t("observe.message.consolidate.computed.taille", -// newLength, -// weight, -// lengthWeightParameter.getWeightLengthFormula(), -// lengthWeightParameter.getCoefficients() -// ); -// if (log.isInfoEnabled()) { -// log.info(message); -// } lengthWeightComputable.setLength(newLength); lengthWeightComputable.setLengthSource(true); return; + } // la taille n'a pas ete changee, on peut quitter car il est impossible // de calculer et la taille et le poids... return; + } // on cherche obligatoirement a calculer le poids Float newWeight = lengthWeightParameter.computeWeight(length); if (newWeight != null) { - // le poids a ete calcule -// String message = "[" + t(entityLabel) + "] " + -// t("observe.message.consolidate.computed.weight", -// newWeight, -// length, -// lengthWeightParameter.getLengthWeightFormula(), -// lengthWeightParameter.getCoefficients()); -// if (log.isInfoEnabled()) { -// log.info(message); -// } lengthWeightComputable.setWeight(newWeight); lengthWeightComputable.setWeightSource(true); + } } protected void updateLengthWeightAble(LengthWeightComputable lengthWeightComputable, LengthWeightParameter lengthWeightParameter) { -// String entityLabel = getSpeciesLabel(); - Float weight = lengthWeightComputable.getWeight(); boolean computeWeight = false; boolean computeLength = false; @@ -712,12 +654,14 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement // on essaye de calculer le poids computeWeight = true; + } if (length == null && weight != null) { // on essaye de calcule la taille computeLength = true; + } if (!computeLength && !computeWeight) { @@ -730,13 +674,6 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement // aucun parametrage connu -// String message = t("observe.message.consolidate.no.parametrage.found", -// t(entityLabel), -// decorate(species) -// ); -// if (log.isWarnEnabled()) { -// log.warn(message); -// } return; } @@ -744,18 +681,6 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement Float newLength = lengthWeightParameter.computeLength(weight); if (newLength != null) { - // la taille a ete calculee -// String message = -// "[" + t(entityLabel) + "] " + -// t("observe.message.consolidate.computed.taille", -// newLength, -// weight, -// lengthWeightParameter.getWeightLengthFormula(), -// lengthWeightParameter.getCoefficients() -// ); -// if (log.isInfoEnabled()) { -// log.info(message); -// } lengthWeightComputable.setLength(newLength); lengthWeightComputable.setLengthSource(true); return; @@ -770,18 +695,9 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement Float newWeight = lengthWeightParameter.computeWeight(length); if (newWeight != null) { - // le poids a ete calcule -// String message = "[" + t(entityLabel) + "] " + -// t("observe.message.consolidate.computed.weight", -// newWeight, -// length, -// lengthWeightParameter.getLengthWeightFormula(), -// lengthWeightParameter.getCoefficients()); -// if (log.isInfoEnabled()) { -// log.info(message); -// } lengthWeightComputable.setWeight(newWeight); lengthWeightComputable.setWeightSource(true); + } } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.