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 1163ce4c15e14be824f5e42150c2891556e22e16 Author: Tony CHEMIT <chemit@codelutin.com> Date: Fri Aug 28 12:27:59 2015 +0200 Mise en place de consolidation des données sur les marées Seine Reste à finaliser le contenu des résultats See #7488 --- .../ConsolidateActivitySeineDataResult.java | 59 ++ .../ConsolidateTripSeineDataRequest.java | 25 + .../ConsolidateTripSeineDataResult.java | 45 ++ .../consolidate/ConsolidationDataService.java | 21 + .../service/ConsolidationDataServiceTopia.java | 788 +++++++++++++++++++++ 5 files changed, 938 insertions(+) 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 new file mode 100644 index 0000000..0298edd --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateActivitySeineDataResult.java @@ -0,0 +1,59 @@ +package fr.ird.observe.services.service.actions.consolidate; + +import java.util.Date; + +/** + * Pour retourner le résultat de la consolidation d'une activité de type seine. + * + * Created on 28/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ConsolidateActivitySeineDataResult { + + protected String schoolTypeChanged; + + public void registerLengthWeightParameterNotFound(String speciesId, String oceanId, String sexId, Date routeDate) { + + } + + public void registerTargetLengthLengthWasComputed(String targetLengthId, Float length) { + + } + + public void registerTargetLengthWeightWasComputed(String targetLengthId, Float weight) { + + } + + public void registerNonTargetLengthLengthWasComputed(String nonTargetLengthId, Float length) { + + } + + public void registerNonTargetLengthWeightWasComputed(String nonTargetLengthId, Float weight) { + + } + + public void registerNonTargetCatchMeanLengthWasComputed(String nonTargetCatchId, Float meanLength, String computeValueSource) { + + } + + public void registerNonTargetCatchMeanWeightWasComputed(String nonTargetCatchId, Float meanWeight, String computeValueSource) { + + } + + public void registerNonTargetCatchCatchWeightWasComputed(String nonTargetCatchId, Float catchWeight, String computeValueSource) { + + } + + public void registerNonTargetCatchTotalCountWasComputed(String nonTargetCatchId, Integer totalCount, String computeValueSource) { + + } + + public void setSchoolTypeChanged(String schoolTypeChanged) { + this.schoolTypeChanged = schoolTypeChanged; + } + + public String getSchoolTypeChanged() { + return schoolTypeChanged; + } +} 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 new file mode 100644 index 0000000..5205e33 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateTripSeineDataRequest.java @@ -0,0 +1,25 @@ +package fr.ird.observe.services.service.actions.consolidate; + +import com.google.common.collect.ImmutableSet; + +/** + * Pour configurer l'opération de consolidation. + * + * Created on 28/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + * @see ConsolidationDataService#consolidateTripSeine(String) + */ +public class ConsolidateTripSeineDataRequest { + + protected ImmutableSet<String> tripSeineIds; + + public ImmutableSet<String> getTripSeineIds() { + return tripSeineIds; + } + + public void setTripSeineIds(ImmutableSet<String> tripSeineIds) { + this.tripSeineIds = 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 new file mode 100644 index 0000000..ff9c6a1 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidateTripSeineDataResult.java @@ -0,0 +1,45 @@ +package fr.ird.observe.services.service.actions.consolidate; + +import java.util.LinkedHashSet; +import java.util.Set; + +/** + * Pour retourner le résultat de la consolidation d'une marée de type seine. + * + * Created on 28/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + * @see ConsolidationDataService#consolidateTripSeine(String) + */ +public class ConsolidateTripSeineDataResult { + + protected boolean noActivityFound; + + protected boolean tripWasModified; + + protected final Set<ConsolidateActivitySeineDataResult> activitySeineDataResults = new LinkedHashSet<>(); + + public boolean isNoActivityFound() { + return noActivityFound; + } + + public void setNoActivityFound(boolean noActivityFound) { + this.noActivityFound = noActivityFound; + } + + public boolean isTripWasModified() { + return tripWasModified; + } + + public void setTripWasModified(boolean tripWasModified) { + this.tripWasModified = tripWasModified; + } + + public void addActivityResult(ConsolidateActivitySeineDataResult activitySeineDataResult) { + activitySeineDataResults.add(activitySeineDataResult); + } + + public Set<ConsolidateActivitySeineDataResult> getActivitySeineDataResults() { + return activitySeineDataResults; + } +} 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 new file mode 100644 index 0000000..b76ead7 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidationDataService.java @@ -0,0 +1,21 @@ +package fr.ird.observe.services.service.actions.consolidate; + +import com.google.common.collect.ImmutableSet; + +/** + * Le service pour effectuer les consolidations de données, i.e + * de pouvoir effectuer remplir certains champs à partir de champs observés. + * + * Created on 28/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public interface ConsolidationDataService { + + /** + * @param consolidateTripSeineDataRequest la demande de consolidation + * @return le résultat de la consolidation de données pour chaque marée. + */ + ImmutableSet<ConsolidateTripSeineDataResult> consolidateTripSeines(ConsolidateTripSeineDataRequest consolidateTripSeineDataRequest); + +} diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/ConsolidationDataServiceTopia.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/ConsolidationDataServiceTopia.java new file mode 100644 index 0000000..13ef1a9 --- /dev/null +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/ConsolidationDataServiceTopia.java @@ -0,0 +1,788 @@ +package fr.ird.observe.services.service; + +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Sets; +import fr.ird.observe.entities.LengthWeightComputable; +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.LengthWeightParameters; +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.seine.ActivitySeine; +import fr.ird.observe.entities.seine.NonTargetCatch; +import fr.ird.observe.entities.seine.NonTargetCatches; +import fr.ird.observe.entities.seine.NonTargetLength; +import fr.ird.observe.entities.seine.NonTargetSample; +import fr.ird.observe.entities.seine.Route; +import fr.ird.observe.entities.seine.SetSeine; +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.services.ObserveServiceTopia; +import fr.ird.observe.services.dto.seine.TripSeineDto; +import fr.ird.observe.services.service.actions.consolidate.ConsolidateActivitySeineDataResult; +import fr.ird.observe.services.service.actions.consolidate.ConsolidateTripSeineDataRequest; +import fr.ird.observe.services.service.actions.consolidate.ConsolidateTripSeineDataResult; +import fr.ird.observe.services.service.actions.consolidate.ConsolidationDataService; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.util.beans.BeanMonitor; + +import java.util.Collection; +import java.util.Date; +import java.util.Set; + +/** + * Created on 28/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ConsolidationDataServiceTopia extends ObserveServiceTopia implements ConsolidationDataService { + + /** 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)"; + + class ConsolidationActivitySeineDataContext { + + protected TripSeine tripSeine; + + protected Route route; + + protected ActivitySeine activity; + + protected LengthWeightParameterTopiaDao lengthWeightParameterTopiaDao; + + protected ConsolidateActivitySeineDataResult consolidateActivitySeineDataResult; + + BeanMonitor targetLengthMonitor; + + BeanMonitor nonTargetLengthMonitor; + + BeanMonitor nonTargetCatchMonitor; + + public Ocean getOcean() { + return tripSeine.getOcean(); + } + + public Date getRouteDate() { + return route.getDate(); + } + + public SetSeine getSetSeine() { + return activity.getSetSeine(); + } + + public LengthWeightParameter findLengthWeightParameter(Species species, Sex sex) { + Ocean ocean = getOcean(); + Date routeDate = getRouteDate(); + LengthWeightParameter lengthWeightParameter = LengthWeightParameters.findLengthWeightParameter(getTopiaPersistenceContext(), 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); + + } + return lengthWeightParameter; + } + + public void setSchoolTypeChanged(SchoolType schoolTypeChanged) { + consolidateActivitySeineDataResult.setSchoolTypeChanged(schoolTypeChanged.name()); + } + + public void watchTargetLength(TargetLength targetLength) { + targetLengthMonitor.setBean(targetLength); + } + + public void watchNonTargetLenght(NonTargetLength nonTargetLength) { + nonTargetLengthMonitor.setBean(nonTargetLength); + } + + public void flushTargetLength() { + if (targetLengthMonitor.wasModified()) { + TargetLength targetLength = (TargetLength) targetLengthMonitor.getBean(); + Set<String> modifiedProperties = Sets.newHashSet(targetLengthMonitor.getModifiedProperties()); + if (modifiedProperties.contains(TargetLength.PROPERTY_LENGTH)) { + consolidateActivitySeineDataResult.registerTargetLengthLengthWasComputed(targetLength.getTopiaId(), targetLength.getLength()); + } + if (modifiedProperties.contains(TargetLength.PROPERTY_WEIGHT)) { + consolidateActivitySeineDataResult.registerTargetLengthWeightWasComputed(targetLength.getTopiaId(), targetLength.getWeight()); + } + } + targetLengthMonitor.setBean(null); + } + + public void flushNonTargetLength() { + if (nonTargetLengthMonitor.wasModified()) { + NonTargetLength nonTargetLength = (NonTargetLength) nonTargetLengthMonitor.getBean(); + Set<String> modifiedProperties = Sets.newHashSet(nonTargetLengthMonitor.getModifiedProperties()); + if (modifiedProperties.contains(NonTargetLength.PROPERTY_LENGTH)) { + consolidateActivitySeineDataResult.registerNonTargetLengthLengthWasComputed(nonTargetLength.getTopiaId(), nonTargetLength.getLength()); + } + if (modifiedProperties.contains(NonTargetLength.PROPERTY_WEIGHT)) { + consolidateActivitySeineDataResult.registerNonTargetLengthWeightWasComputed(nonTargetLength.getTopiaId(), nonTargetLength.getWeight()); + } + } + nonTargetLengthMonitor.setBean(null); + } + + public void watchNonTargetCatch(NonTargetCatch nonTargetCatch) { + nonTargetCatchMonitor.setBean(nonTargetCatch); + } + + public void flushNonTargetCatch() { + if (nonTargetCatchMonitor.wasModified()) { + NonTargetCatch nonTargetCatch = (NonTargetCatch) nonTargetCatchMonitor.getBean(); + Set<String> modifiedProperties = Sets.newHashSet(nonTargetCatchMonitor.getModifiedProperties()); + if (modifiedProperties.contains(NonTargetCatch.PROPERTY_MEAN_LENGTH)) { + consolidateActivitySeineDataResult.registerNonTargetCatchMeanLengthWasComputed(nonTargetCatch.getTopiaId(), nonTargetCatch.getMeanLength(), nonTargetCatch.getMeanLengthComputedSource().name()); + } + if (modifiedProperties.contains(NonTargetCatch.PROPERTY_MEAN_WEIGHT)) { + consolidateActivitySeineDataResult.registerNonTargetCatchMeanWeightWasComputed(nonTargetCatch.getTopiaId(), nonTargetCatch.getMeanWeight(), nonTargetCatch.getMeanWeightComputedSource().name()); + } + if (modifiedProperties.contains(NonTargetCatch.PROPERTY_CATCH_WEIGHT)) { + consolidateActivitySeineDataResult.registerNonTargetCatchCatchWeightWasComputed(nonTargetCatch.getTopiaId(), nonTargetCatch.getCatchWeight(), nonTargetCatch.getCatchWeightComputedSource().name()); + } + if (modifiedProperties.contains(NonTargetCatch.PROPERTY_TOTAL_COUNT)) { + consolidateActivitySeineDataResult.registerNonTargetCatchTotalCountWasComputed(nonTargetCatch.getTopiaId(), nonTargetCatch.getTotalCount(), nonTargetCatch.getTotalCountComputedSource().name()); + } + } + nonTargetCatchMonitor.setBean(null); + } + } + + @Override + public ImmutableSet<ConsolidateTripSeineDataResult> consolidateTripSeines(ConsolidateTripSeineDataRequest consolidateTripSeineDataRequest) { + + ImmutableSet.Builder<ConsolidateTripSeineDataResult> resultBuilder = new ImmutableSet.Builder<>(); + for (String tripSeineId : consolidateTripSeineDataRequest.getTripSeineIds()) { + ConsolidateTripSeineDataResult consolidateTripSeineDataResult = consolidateTripSeine(tripSeineId); + resultBuilder.add(consolidateTripSeineDataResult); + } + return resultBuilder.build(); + + } + + protected ConsolidateTripSeineDataResult consolidateTripSeine(String tripSeineId) { + + TripSeine tripSeine = loadEntity(TripSeineDto.class, TripSeine.class, tripSeineId); + + ConsolidateTripSeineDataResult computationResult = new ConsolidateTripSeineDataResult(); + + BeanMonitor targetLengthMonitor = new BeanMonitor( + TargetLength.PROPERTY_LENGTH, + TargetLength.PROPERTY_LENGTH_SOURCE, + TargetLength.PROPERTY_WEIGHT, + TargetLength.PROPERTY_WEIGHT_SOURCE); + + BeanMonitor nonTargetSampleMonitor = new BeanMonitor( + NonTargetLength.PROPERTY_LENGTH, + NonTargetLength.PROPERTY_LENGTH_SOURCE, + NonTargetLength.PROPERTY_WEIGHT, + NonTargetLength.PROPERTY_WEIGHT_SOURCE); + + BeanMonitor nonTargetCatchMonitor = new BeanMonitor( + NonTargetCatch.PROPERTY_MEAN_LENGTH, + NonTargetCatch.PROPERTY_MEAN_LENGTH_COMPUTED_SOURCE, + NonTargetCatch.PROPERTY_MEAN_WEIGHT, + NonTargetCatch.PROPERTY_MEAN_WEIGHT_COMPUTED_SOURCE, + NonTargetCatch.PROPERTY_CATCH_WEIGHT, + NonTargetCatch.PROPERTY_CATCH_WEIGHT_COMPUTED_SOURCE, + NonTargetCatch.PROPERTY_TOTAL_COUNT, + NonTargetCatch.PROPERTY_TOTAL_COUNT_COMPUTED_SOURCE + ); + + LengthWeightParameterTopiaDao lengthWeightParameterDao = getTopiaPersistenceContext().getLengthWeightParameterDao(); + + for (Route route : tripSeine.getRoute()) { + + for (ActivitySeine activitySeine : route.getActivitySeine()) { + + ConsolidateActivitySeineDataResult consolidateActivitySeineDataResult = new ConsolidateActivitySeineDataResult(); + ConsolidationActivitySeineDataContext activityContext = new ConsolidationActivitySeineDataContext(); + 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); + + } + + } + + // on devra mettre a jour en base la maree +// messager1.sendMessage(t("observe.message.consolidate.maree.need.update", +// mareeStr)); + + return computationResult; + } + + + protected void consolidateActivitySeine(ConsolidationActivitySeineDataContext activityContext) { + + ActivitySeine activity = activityContext.activity; + + if (log.isInfoEnabled()) { + log.info("Start consolidate activity: " + activity.getTopiaId()); + } + + SetSeine setSeine = activity.getSetSeine(); + SchoolType oldTypeBanc = setSeine.getSchoolType(); + SchoolType newTypeBanc = activity.getSchoolType(); + if (oldTypeBanc == null || oldTypeBanc != newTypeBanc) { + + // le type de banc a changé, on doit sauver l'activité + setSeine.setSchoolType(newTypeBanc); + activityContext.setSchoolTypeChanged(newTypeBanc); + + } + + if (!setSeine.isTargetSampleEmpty()) { + + // des echantillons thons trouves + for (TargetSample targetSample : setSeine.getTargetSample()) { + if (!targetSample.isTargetLengthEmpty()) { + for (TargetLength targetLength : targetSample.getTargetLength()) { + + activityContext.watchTargetLength(targetLength); + + updateLengthWeightAble(activityContext, + targetLength.getSpecies(), + null, /* pas de sexe precise */ + targetLength); + + activityContext.flushTargetLength(); + + } + } + } + } + + if (!setSeine.isNonTargetSampleEmpty()) { + + // des echantillons faunes trouves + for (NonTargetSample nonTargetSample : setSeine.getNonTargetSample()) { + + if (!nonTargetSample.isNonTargetLengthEmpty()) { + for (NonTargetLength nonTargetLength : nonTargetSample.getNonTargetLength()) { + + activityContext.watchNonTargetLenght(nonTargetLength); + + updateLengthWeightAble(activityContext, + nonTargetLength.getSpecies(), + nonTargetLength.getSex(), + nonTargetLength); + + activityContext.flushNonTargetLength(); + + } + } + } + } + + if (!setSeine.isNonTargetCatchEmpty()) { + + // des captures (ou rejets) faunes trouves + for (NonTargetCatch nonTargetCatch : setSeine.getNonTargetCatch()) { + + activityContext.watchNonTargetCatch(nonTargetCatch); + + // suppression de tous les champs précédemment calculés + + if (nonTargetCatch.isCatchWeightComputed()) { + nonTargetCatch.setCatchWeight(null); + nonTargetCatch.setCatchWeightComputedSource(null); + } + + if (nonTargetCatch.isTotalCountComputed()) { + nonTargetCatch.setTotalCount(null); + nonTargetCatch.setTotalCountComputedSource(null); + } + + if (nonTargetCatch.isMeanWeightComputed()) { + nonTargetCatch.setMeanWeight(null); + nonTargetCatch.setMeanWeightComputedSource(null); + } + + if (nonTargetCatch.isMeanLengthComputed()) { + nonTargetCatch.setMeanLength(null); + nonTargetCatch.setMeanLengthComputedSource(null); + } + + updateNonTargetCatch(activityContext, nonTargetCatch); + + activityContext.flushNonTargetCatch(); + + } + } + + } + + protected void updateNonTargetCatch(ConsolidationActivitySeineDataContext activityContext, NonTargetCatch nonTargetCatch) { + + Species species = nonTargetCatch.getSpecies(); + + // récupération du référentiel + LengthWeightParameter lengthWeightParameter = activityContext.findLengthWeightParameter(species, null /* pas de sexe spécifié*/); + + // -- Cas n°1 (calcul uniquement à partir des relations taille - poids) + updateNonTargetCatchByLengthWeightRelation(nonTargetCatch, lengthWeightParameter); + + if (NonTargetCatches.allNonTargetCatchDataFilled(nonTargetCatch)) { + + // tout est rempli, plus rien à faire + return; + } + + // répération des échantillon de cette espèce sur les calée + + 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) + computeNonTargetCatchMeanLength(nonTargetCatch, nonTargetLengths, lengthWeightParameter); + } + + if (NonTargetCatches.allNonTargetCatchDataFilled(nonTargetCatch)) { + + // tout est rempli, plus rien à faire + return; + } + + // -- Cas n°3 (pas de nombre estimé) + + if (nonTargetCatch.getTotalCount() == null) { + + computeNonTargetCatchNombreEstime(nonTargetCatch, nonTargetLengths, lengthWeightParameter); + + } + + if (NonTargetCatches.allNonTargetCatchDataFilled(nonTargetCatch)) { + + // tout est rempli, plus rien à faire + return; + } + + // -- Cas n°4 (pas de poids moyen, taille moyenne) + + computeNonTargetCatchMeanValues(nonTargetCatch, lengthWeightParameter); + } + + protected void updateNonTargetCatchByLengthWeightRelation(NonTargetCatch nonTargetCatch, + LengthWeightParameter lengthWeightParameter) { + + // calcul via le paramétrage taille - poids + updateLengthWeightAble(nonTargetCatch, lengthWeightParameter); + + // calcule l'un des trois champs poids estimé - nbEstime - poids moyen + updateNonTargetCatchPoidsEstimeNbEstimePoidsMoyen(nonTargetCatch); + + // on ressaye d'appliquer la relation taille - poids au cas où une des + // trois valeurs précédentes a été calculée, on pourrait peut-être + // ainsi en déduire via le paramétrage la taille moyenne + updateLengthWeightAble(nonTargetCatch, lengthWeightParameter); + + } + + protected void computeNonTargetCatchMeanLength(NonTargetCatch nonTargetCatch, + Collection<NonTargetLength> samples, + LengthWeightParameter lengthWeightParameter) { + + Float meanLength = nonTargetCatch.getMeanLength(); + + if (meanLength == null) { + + // on essaye de calculer la taille moyenne à partir des échantillons + + NonTargetCatchComputedValueSource computedSource = null; + + if (CollectionUtils.isNotEmpty(samples)) { + + // on calcul la taille moyenne à partir des échantillons + float totalLength = 0f; + int totalCount = 0; + for (NonTargetLength sample : samples) { + + Integer count = sample.getCount(); + Float length = sample.getLength(); + + if (count != null && length != null) { + totalCount += count; + totalLength += length * count; + } + } + + if (totalCount != 0) { + + meanLength = totalLength / totalCount; + + computedSource = NonTargetCatchComputedValueSource.FROM_SAMPLE; + } + } + + if (meanLength == null && lengthWeightParameter != null) { + + // on prend directement la valeur fournie par le référentiel + + meanLength = lengthWeightParameter.getMeanLength(); + computedSource = NonTargetCatchComputedValueSource.FROM_REFERENTIEL; + } + + if (meanLength != null) { + + // la taille moyenne a pu etre calculee, on la pousse alors + nonTargetCatch.setMeanLength(meanLength); + nonTargetCatch.setMeanLengthComputedSource(computedSource); + + } + + } + + if (meanLength != null) { + + // on peut aussi relancer la calcul du cas n°1 + updateNonTargetCatchByLengthWeightRelation(nonTargetCatch, lengthWeightParameter); + + } + + } + + protected void computeNonTargetCatchNombreEstime(NonTargetCatch nonTargetCatch, + Collection<NonTargetLength> samples, + LengthWeightParameter lengthWeightParameter) { + + + Integer totalCount = nonTargetCatch.getTotalCount(); + + if (totalCount == null) { + + if (CollectionUtils.isNotEmpty(samples)) { + + // on calcul la nombre d'individus à partir des échantillons + totalCount = 0; + for (NonTargetLength sample : samples) { + + Integer count = sample.getCount(); + + if (count != null) { + totalCount += count; + } + } + + if (totalCount != 0) { + + nonTargetCatch.setTotalCount(totalCount); + nonTargetCatch.setTotalCountComputedSource(NonTargetCatchComputedValueSource.FROM_SAMPLE); + + + } + } + + } + + if (nonTargetCatch.getMeanWeight() != null || nonTargetCatch.getMeanLength() != null) { + + // on peut aussi relancer la calcul du cas n°1 + updateNonTargetCatchByLengthWeightRelation(nonTargetCatch, lengthWeightParameter); + } + + } + + protected void computeNonTargetCatchMeanValues(NonTargetCatch nonTargetCatch, LengthWeightParameter lengthWeightParameter) { + + 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); + } + + } + } + + protected void updateNonTargetCatchPoidsEstimeNbEstimePoidsMoyen(NonTargetCatch nonTargetCatch) { + + Float meanWeight = nonTargetCatch.getMeanWeight(); + 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) { + + // calcul le nb estime à partir du poids estime et du poids moyen + 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 && + !NonTargetCatchComputedValueSource.FROM_SAMPLE.equals(nonTargetCatch.getTotalCountComputedSource())) { + + // calcul le poids moyen à partir de nb estime et du poids estime + // uniquement si le nombre estimé ne vient pas des échantillons (voir http://forge.codelutin.com/issues/4670) + + 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); +// } + } + } + + protected void updateLengthWeightAble(ConsolidationActivitySeineDataContext activityContext, + Species species, + Sex sex, + LengthWeightComputable lengthWeightComputable) { + +// String entityLabel = getSpeciesLabel(); + + Float weight = lengthWeightComputable.getWeight(); + Float length = lengthWeightComputable.getLength(); + + boolean computeWeight = false; + boolean computeLength = false; + + if (weight == null && length != null) { + + // on essaye de calculer le poids + computeWeight = true; + } + + if (length == null && weight != null) { + + // on essaye de calcule la taille + computeLength = true; + } + + if (!computeLength && !computeWeight) { + + // rien a calculer + return; + } + + // recherche du parametrage adequate + LengthWeightParameter lengthWeightParameter = activityContext.findLengthWeightParameter(species, sex); + + if (lengthWeightParameter == null) { + + // aucun parametrage connu + +// String message = t("observe.message.consolidate.no.parametrage.found", +// t(entityLabel), +// decorate(species) +// ); +// if (log.isWarnEnabled()) { +// log.warn(message); +// } + return; + } + + if (computeLength) { + 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; + Float length = lengthWeightComputable.getLength(); + + if (weight == null && length != null) { + + // on essaye de calculer le poids + computeWeight = true; + } + + if (length == null && weight != null) { + + // on essaye de calcule la taille + computeLength = true; + } + + if (!computeLength && !computeWeight) { + + // rien a calculer + return; + } + + if (lengthWeightParameter == null) { + + // aucun parametrage connu + +// String message = t("observe.message.consolidate.no.parametrage.found", +// t(entityLabel), +// decorate(species) +// ); +// if (log.isWarnEnabled()) { +// log.warn(message); +// } + return; + } + + if (computeLength) { + 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); + } + } + +} -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.

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 4c1bcb53528a8453c3c3a9a107f70930aab66920 Author: Tony CHEMIT <chemit@codelutin.com> Date: Sat Aug 29 08:26:13 2015 +0200 Déplacement de l'implantation du service de consolidation (See #7488) --- .../{ => actions/consolidate}/ConsolidationDataServiceTopia.java | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/ConsolidationDataServiceTopia.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidationDataServiceTopia.java similarity index 98% rename from observe-services-topia/src/main/java/fr/ird/observe/services/service/ConsolidationDataServiceTopia.java rename to observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidationDataServiceTopia.java index 4f033a4..ca30c16 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/service/ConsolidationDataServiceTopia.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/consolidate/ConsolidationDataServiceTopia.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service; +package fr.ird.observe.services.service.actions.consolidate; import com.google.common.collect.ImmutableSet; import fr.ird.observe.entities.LengthWeightComputable; @@ -23,10 +23,6 @@ import fr.ird.observe.entities.seine.TargetSample; import fr.ird.observe.entities.seine.TripSeine; import fr.ird.observe.services.ObserveServiceTopia; import fr.ird.observe.services.dto.seine.TripSeineDto; -import fr.ird.observe.services.service.actions.consolidate.ConsolidateActivitySeineDataResult; -import fr.ird.observe.services.service.actions.consolidate.ConsolidateTripSeineDataRequest; -import fr.ird.observe.services.service.actions.consolidate.ConsolidateTripSeineDataResult; -import fr.ird.observe.services.service.actions.consolidate.ConsolidationDataService; import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.

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 6f72a08c5233fc8bfbca6536c5566c62b6cd86d5 Author: Tony CHEMIT <chemit@codelutin.com> Date: Sat Aug 29 10:05:54 2015 +0200 Ajout d'un exception si la relation RTP n'est pas trouvée --- .../LengthWeightParameterNotFoundException.java | 45 ++++++++++++++++++++++ 1 file changed, 45 insertions(+) diff --git a/observe-entities/src/main/java/fr/ird/observe/entities/referentiel/LengthWeightParameterNotFoundException.java b/observe-entities/src/main/java/fr/ird/observe/entities/referentiel/LengthWeightParameterNotFoundException.java new file mode 100644 index 0000000..76a257e --- /dev/null +++ b/observe-entities/src/main/java/fr/ird/observe/entities/referentiel/LengthWeightParameterNotFoundException.java @@ -0,0 +1,45 @@ +package fr.ird.observe.entities.referentiel; + +import java.util.Date; + +/** + * Created on 29/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class LengthWeightParameterNotFoundException extends RuntimeException { + + private static final long serialVersionUID = 1L; + + protected final Species species; + + protected final Ocean ocean; + + protected final Sex sex; + + protected final Date date; + + public LengthWeightParameterNotFoundException(Species species, Ocean ocean, Sex sex, Date date) { + this.species = species; + this.ocean = ocean; + this.sex = sex; + this.date = date; + } + + public Species getSpecies() { + return species; + } + + public Ocean getOcean() { + return ocean; + } + + public Sex getSex() { + return sex; + } + + public Date getDate() { + return date; + } + +} -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.

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

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 41aebf8295434f06402d89137231ca794fab9c50 Author: Tony CHEMIT <chemit@codelutin.com> Date: Sat Aug 29 11:49:18 2015 +0200 Revue des logs et ajout d'un test sur le service (See #7488) --- .../consolidate/ConsolidationDataService.java | 3 +- .../consolidate/ConsolidationDataServiceTopia.java | 31 ++++++++---- .../ConsolidationDataServiceTopiaTest.java | 55 ++++++++++++++++++++++ 3 files changed, 78 insertions(+), 11 deletions(-) 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 5fed694..57af31b 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 @@ -1,6 +1,7 @@ package fr.ird.observe.services.service.actions.consolidate; import com.google.common.collect.ImmutableSet; +import fr.ird.observe.services.ObserveService; /** * Le service pour effectuer les consolidations de données, i.e @@ -10,7 +11,7 @@ import com.google.common.collect.ImmutableSet; * * @author Tony Chemit - chemit@codelutin.com */ -public interface ConsolidationDataService { +public interface ConsolidationDataService extends ObserveService{ /** * Effectue la consolitation à partir de la demande passé en paramètre et retourne les résultats pour les marées 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 a7fb520..b07193d 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 @@ -195,6 +195,13 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement for (ActivitySeine activitySeine : route.getActivitySeine()) { + if (!activitySeine.isSetOperation()) { + if (log.isDebugEnabled()) { + log.debug("No set on activity " + activitySeine); + } + continue; + } + ConsolidateActivitySeineDataResultBuilder resultBuilder = ConsolidateActivitySeineDataResultBuilder.create(applicationLocale, referenceLocale, activitySeine); ConsolidationActivitySeineDataContext activityContext = new ConsolidationActivitySeineDataContext(); @@ -211,14 +218,15 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement consolidateActivitySeine(activityContext); - Optional<ConsolidateActivitySeineDataResult> consolidateActivitySeineDataResult = resultBuilder.build(); - if (consolidateActivitySeineDataResult.isPresent()) { + Optional<ConsolidateActivitySeineDataResult> optionalConsolidateActivitySeineDataResult = resultBuilder.build(); + if (optionalConsolidateActivitySeineDataResult.isPresent()) { // Des modifications ont été enregistrées sur l'activité + ConsolidateActivitySeineDataResult consolidateActivitySeineDataResult = optionalConsolidateActivitySeineDataResult.get(); if (log.isInfoEnabled()) { - log.info("Found some modifications on activity: " + activitySeine.getTopiaId()); + log.info("Found some modifications on activity: " + consolidateActivitySeineDataResult.getActivitySeineLabel()); } - actititiesResultBuilder.add(consolidateActivitySeineDataResult.get()); + actititiesResultBuilder.add(consolidateActivitySeineDataResult); } @@ -228,16 +236,19 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement ImmutableSet<ConsolidateActivitySeineDataResult> consolidateActivitySeineDataResults = actititiesResultBuilder.build(); - ConsolidateTripSeineDataResult computationResult; + ConsolidateTripSeineDataResult consolidateTripSeineDataResult; if (consolidateActivitySeineDataResults.isEmpty()) { - computationResult = null; + consolidateTripSeineDataResult = null; } else { - computationResult = new ConsolidateTripSeineDataResult(tripSeineId, TripSeines.decorate(referenceLocale, tripSeine), consolidateActivitySeineDataResults); + consolidateTripSeineDataResult = new ConsolidateTripSeineDataResult(tripSeineId, TripSeines.decorate(referenceLocale, tripSeine), consolidateActivitySeineDataResults); + if (log.isInfoEnabled()) { + log.info("Found some modifications on trip: " + consolidateTripSeineDataResult.getTripSeineLabel()); + } } - return Optional.fromNullable(computationResult); + return Optional.fromNullable(consolidateTripSeineDataResult); } @@ -246,8 +257,8 @@ public class ConsolidationDataServiceTopia extends ObserveServiceTopia implement ActivitySeine activity = activityContext.activity; - if (log.isInfoEnabled()) { - log.info("Start consolidate activity: " + activity.getTopiaId()); + if (log.isDebugEnabled()) { + log.debug("Start consolidate activity: " + activity.getTopiaId()); } SetSeine setSeine = activity.getSetSeine(); diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/consolidate/ConsolidationDataServiceTopiaTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/consolidate/ConsolidationDataServiceTopiaTest.java new file mode 100644 index 0000000..8ca5ec8 --- /dev/null +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/consolidate/ConsolidationDataServiceTopiaTest.java @@ -0,0 +1,55 @@ +package fr.ird.observe.services.service.actions.consolidate; + +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.ObserveTopiaPersistenceContext; +import fr.ird.observe.services.service.AbstractServiceTopiaTest; +import org.junit.Assert; +import org.junit.Test; + +import java.util.List; +import java.util.Set; + +/** + * Created on 29/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ConsolidationDataServiceTopiaTest extends AbstractServiceTopiaTest { + + protected ConsolidationDataService service; + + @Override + public Set<String> getTestNamesChangeDataBase() { + return ImmutableSet.of("testConsolidateTripSeines"); + } + + @Override + public String getScriptName() { + return "dataForTestSeine"; + } + + @Override + public void setUp() throws Exception { + super.setUp(); + service = newService(ConsolidationDataService.class); + } + + @Test + public void testConsolidateTripSeines() throws Exception { + + ObserveTopiaPersistenceContext persistenceContext = dataSourceResource.newPersistenceContext(); + + List<String> tripSeineIds = persistenceContext.getTripSeineDao().findAllIds(); + + ConsolidateTripSeineDataRequest request = new ConsolidateTripSeineDataRequest(); + request.setTripSeineIds(ImmutableSet.copyOf(tripSeineIds)); + request.setFailIfLenghtWeightParameterNotFound(false); + + ImmutableSet<ConsolidateTripSeineDataResult> results = service.consolidateTripSeines(request); + Assert.assertNotNull(results); + //FIXME Il faudrait avoir des données modifiées dans la base de test + Assert.assertEquals(0, results.size()); + + + } +} \ No newline at end of file -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.