This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository tutti. See http://git.codelutin.com/tutti.git commit 740d00d919faf35b49d0cd8b215e298a59d4d120 Author: Tony CHEMIT <chemit@codelutin.com> Date: Tue Feb 3 19:11:34 2015 +0100 introduction de classes différentes pour les différentes types de signes --- .../fr/ifremer/tutti/service/bigfin/signs/Sex.java | 109 ++++++++++++++++++++ .../ifremer/tutti/service/bigfin/signs/Sign.java | 27 +++++ .../ifremer/tutti/service/bigfin/signs/Size.java | 111 +++++++++++++++++++++ .../tutti/service/bigfin/signs/VracHorsVrac.java | 92 +++++++++++++++++ 4 files changed, 339 insertions(+) diff --git a/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/signs/Sex.java b/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/signs/Sex.java new file mode 100644 index 0000000..cce79c8 --- /dev/null +++ b/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/signs/Sex.java @@ -0,0 +1,109 @@ +package fr.ifremer.tutti.service.bigfin.signs; + +import com.google.common.base.Function; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId; +import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; +import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue; +import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValues; +import fr.ifremer.tutti.service.bigfin.csv.BigfinDataRow; + +import java.util.Map; + +/** + * Created on 2/3/15. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.13 + */ +public enum Sex implements Sign { + + NONE("NONE") { + @Override + public Integer getCategory() { + return PmfmId.SEX.getValue(); + } + + @Override + public Integer getQualitativeValueId() { + return QualitativeValueId.NON_SEXED_SEX.getValue(); + } + + @Override + public boolean isNullEquivalent() { + return false; + } + }, + MALE("MALE") { + @Override + public Integer getCategory() { + return PmfmId.SEX.getValue(); + } + + @Override + public Integer getQualitativeValueId() { + return QualitativeValueId.SEX_MALE.getValue(); + } + + @Override + public boolean isNullEquivalent() { + return false; + } + }, + FEMALE("FEMALE") { + @Override + public Integer getCategory() { + return PmfmId.SEX.getValue(); + } + + @Override + public Integer getQualitativeValueId() { + return QualitativeValueId.SEX_FEMALE.getValue(); + } + + @Override + public boolean isNullEquivalent() { + return false; + } + }; + + private String sign; + + Sex(String sign) { + this.sign = sign; + } + + @Override + public String getSign() { + return sign; + } + + @Override + public void registerSign(Caracteristic caracteristic, Map<Sign, CaracteristicQualitativeValue> map) { + Integer valueId = getQualitativeValueId(); + CaracteristicQualitativeValue result = CaracteristicQualitativeValues.getQualitativeValue(caracteristic, valueId); + map.put(this, result); + } + + public static Sex getValue(String sign) { + Sex result = null; + for (Sex s : values()) { + if (s.sign.equals(sign)) { + result = s; + break; + } + } + return result; + } + + public static Function<BigfinDataRow, Sign> newExtractValueFunction() { + return new Function<BigfinDataRow, Sign>() { + @Override + public Sign apply(BigfinDataRow bigfinDataRow) { + Sign result = bigfinDataRow.getSex(); + return result; + } + }; + } + +} diff --git a/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/signs/Sign.java b/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/signs/Sign.java new file mode 100644 index 0000000..d735381 --- /dev/null +++ b/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/signs/Sign.java @@ -0,0 +1,27 @@ +package fr.ifremer.tutti.service.bigfin.signs; + +import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; +import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue; + +import java.util.Map; + +/** + * Created on 2/3/15. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.13 + */ +public interface Sign { + + public abstract Integer getCategory(); + + public abstract Integer getQualitativeValueId(); + + // if true, can use this value in the import file to replace a skipped category + public abstract boolean isNullEquivalent(); + + public String getSign(); + + public void registerSign(Caracteristic caracteristic, Map<Sign, CaracteristicQualitativeValue> map); + +} diff --git a/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/signs/Size.java b/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/signs/Size.java new file mode 100644 index 0000000..065f20c --- /dev/null +++ b/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/signs/Size.java @@ -0,0 +1,111 @@ +package fr.ifremer.tutti.service.bigfin.signs; + +import com.google.common.base.Function; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId; +import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; +import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue; +import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValues; +import fr.ifremer.tutti.service.bigfin.csv.BigfinDataRow; + +import java.util.Map; + +/** + * Created on 2/3/15. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.13 + */ +public enum Size implements Sign { + + // classe de taille, 1 = petit ; 2 = gros ; 0 = pas de classe de taille (saisie libre donc risque fort de mauvaise saisie) + NOT_SIZED("0") { + @Override + public Integer getCategory() { + return PmfmId.SIZE_CATEGORY.getValue(); + } + + @Override + public Integer getQualitativeValueId() { + return QualitativeValueId.UNSORTED.getValue(); + } + + @Override + public boolean isNullEquivalent() { + return true; + } + + }, + SMALL("1") { + @Override + public Integer getCategory() { + return PmfmId.SIZE_CATEGORY.getValue(); + } + + @Override + public Integer getQualitativeValueId() { + return QualitativeValueId.SIZE_SMALL.getValue(); + } + + @Override + public boolean isNullEquivalent() { + return false; + } + }, + BIG("2") { + @Override + public Integer getCategory() { + return PmfmId.SIZE_CATEGORY.getValue(); + } + + @Override + public Integer getQualitativeValueId() { + return QualitativeValueId.SIZE_BIG.getValue(); + } + + @Override + public boolean isNullEquivalent() { + return false; + } + }; + + private String sign; + + Size(String sign) { + this.sign = sign; + } + + @Override + public String getSign() { + return sign; + } + + @Override + public void registerSign(Caracteristic caracteristic, Map<Sign, CaracteristicQualitativeValue> map) { + Integer valueId = getQualitativeValueId(); + CaracteristicQualitativeValue result = CaracteristicQualitativeValues.getQualitativeValue(caracteristic, valueId); + map.put(this, result); + } + + public static Size getValue(String sign) { + Size result = null; + for (Size s : values()) { + if (s.sign.equals(sign)) { + result = s; + break; + } + } + return result; + } + + public static Function<BigfinDataRow, Sign> newExtractValueFunction() { + return new Function<BigfinDataRow, Sign>() { + @Override + public Sign apply(BigfinDataRow bigfinDataRow) { + Sign result = bigfinDataRow.getSize(); + return result; + } + }; + } + +} diff --git a/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/signs/VracHorsVrac.java b/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/signs/VracHorsVrac.java new file mode 100644 index 0000000..27b9cbe --- /dev/null +++ b/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/signs/VracHorsVrac.java @@ -0,0 +1,92 @@ +package fr.ifremer.tutti.service.bigfin.signs; + +import com.google.common.base.Function; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId; +import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; +import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue; +import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValues; +import fr.ifremer.tutti.service.bigfin.csv.BigfinDataRow; + +import java.util.Map; + +/** + * Created on 2/3/15. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.13 + */ +public enum VracHorsVrac implements Sign { + + VRAC("") { + @Override + public Integer getCategory() { + return PmfmId.SORTED_UNSORTED.getValue(); + } + + @Override + public Integer getQualitativeValueId() { + return QualitativeValueId.SORTED_VRAC.getValue(); + } + + @Override + public boolean isNullEquivalent() { + return false; + } + }, + HORS_VRAC("HV") { + @Override + public Integer getCategory() { + return PmfmId.SORTED_UNSORTED.getValue(); + } + + @Override + public Integer getQualitativeValueId() { + return QualitativeValueId.SORTED_HORS_VRAC.getValue(); + } + + @Override + public boolean isNullEquivalent() { + return false; + } + }; + + private String sign; + + VracHorsVrac(String sign) { + this.sign = sign; + } + + @Override + public String getSign() { + return sign; + } + + @Override + public void registerSign(Caracteristic caracteristic, Map<Sign, CaracteristicQualitativeValue> map) { + Integer valueId = getQualitativeValueId(); + CaracteristicQualitativeValue result = CaracteristicQualitativeValues.getQualitativeValue(caracteristic, valueId); + map.put(this, result); + } + + public static VracHorsVrac getValue(String sign) { + VracHorsVrac result = null; + for (VracHorsVrac s : values()) { + if (s.sign.equals(sign)) { + result = s; + break; + } + } + return result; + } + + public static Function<BigfinDataRow, Sign> newExtractValueFunction() { + return new Function<BigfinDataRow, Sign>() { + @Override + public Sign apply(BigfinDataRow bigfinDataRow) { + Sign result = bigfinDataRow.getVracHorsVrac(); + return result; + } + }; + } +} -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository tutti. See http://git.codelutin.com/tutti.git commit 412db5483e727fc6a109450da37c82c747d5dbf7 Author: Tony CHEMIT <chemit@codelutin.com> Date: Tue Feb 3 19:12:42 2015 +0100 ajout d'une méthode pour retrouver tous les lots d'un lot racine --- .../persistence/entities/data/SpeciesBatchs.java | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/data/SpeciesBatchs.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/data/SpeciesBatchs.java index 3076167..bf7b3d6 100644 --- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/data/SpeciesBatchs.java +++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/data/SpeciesBatchs.java @@ -27,6 +27,8 @@ package fr.ifremer.tutti.persistence.entities.data; import com.google.common.base.Function; import java.io.Serializable; +import java.util.Map; +import java.util.TreeMap; /** * @author Kevin Morin (Code Lutin) @@ -41,4 +43,22 @@ public class SpeciesBatchs extends AbstractSpeciesBatchs { } }; + public static Map<Integer, SpeciesBatch> getAllSpeciesBatchesById(BatchContainer<SpeciesBatch> rootSpeciesBatch) { + Map<Integer, SpeciesBatch> result = new TreeMap<>(); + + for (SpeciesBatch speciesBatch : rootSpeciesBatch.getChildren()) { + getAllspeciesBatchesById(speciesBatch, result); + } + return result; + } + + private static void getAllspeciesBatchesById(SpeciesBatch speciesBatch, Map<Integer, SpeciesBatch> result) { + result.put(speciesBatch.getIdAsInt(), speciesBatch); + if (!speciesBatch.isChildBatchsEmpty()) { + for (SpeciesBatch batch : speciesBatch.getChildBatchs()) { + getAllspeciesBatchesById(batch, result); + } + } + } + } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository tutti. See http://git.codelutin.com/tutti.git commit 11bae16b4b4318842ed0cc14c12ac59bb13e47bc Author: Tony CHEMIT <chemit@codelutin.com> Date: Tue Feb 3 19:13:23 2015 +0100 introduction d'un objet context de l'import --- .../tutti/service/bigfin/BigfinImportContext.java | 357 +++++++++++++++++++++ 1 file changed, 357 insertions(+) diff --git a/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/BigfinImportContext.java b/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/BigfinImportContext.java new file mode 100644 index 0000000..e295f10 --- /dev/null +++ b/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/BigfinImportContext.java @@ -0,0 +1,357 @@ +package fr.ifremer.tutti.service.bigfin; + +import com.google.common.base.Function; +import com.google.common.base.Preconditions; +import com.google.common.collect.Multimap; +import com.google.common.collect.Multimaps; +import fr.ifremer.tutti.persistence.entities.data.BatchContainer; +import fr.ifremer.tutti.persistence.entities.data.CatchBatch; +import fr.ifremer.tutti.persistence.entities.data.FishingOperation; +import fr.ifremer.tutti.persistence.entities.data.SpeciesBatch; +import fr.ifremer.tutti.persistence.entities.data.SpeciesBatchs; +import fr.ifremer.tutti.persistence.entities.protocol.SpeciesProtocol; +import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; +import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue; +import fr.ifremer.tutti.persistence.entities.referential.Species; +import fr.ifremer.tutti.service.PersistenceService; +import fr.ifremer.tutti.service.bigfin.csv.BigfinDataRow; +import fr.ifremer.tutti.service.bigfin.csv.SpeciesOrSpeciesBatch; +import fr.ifremer.tutti.service.bigfin.signs.Sign; +import org.apache.commons.lang3.StringUtils; +import org.apache.commons.lang3.time.DateUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import java.io.File; +import java.util.ArrayList; +import java.util.Date; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 2/3/15. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.13 + */ +public class BigfinImportContext { + + /** Logger. */ + private static final Log log = LogFactory.getLog(BigfinImportContext.class); + + protected final FishingOperation operation; + + protected final CatchBatch catchBatch; + + protected final Map<Sign, CaracteristicQualitativeValue> signsToCaracteristicValue; + + protected final Map<String, Species> speciesBySurveyCode; + + protected final Map<String, SpeciesProtocol> speciesProtocolBySurveyCode; + + // set of not found species already added in the errors + protected final Set<Species> speciesNotRecognized = new HashSet<>(); + + //set of species not in the protocol + protected final Set<Species> speciesNotInProtocol = new HashSet<>(); + + // set of species without lengthstep already added in the errors + protected final Set<Species> speciesInProtocolButWithoutLengthStepPmfmId = new HashSet<>(); + + private final List<BigfinDataRow> speciesRows = new ArrayList<>(); + + private final List<BigfinDataRow> speciesBatchRows = new ArrayList<>(); + + private final BigfinImportResult bigfinImportResult; + + private final BatchContainer<SpeciesBatch> rootSpeciesBatch; + + private final Map<Species, Caracteristic> lengthStepPmfmBySpecies; + + public BigfinImportContext(File importFile, + FishingOperation operation, + CatchBatch catchBatch, + Map<Sign, CaracteristicQualitativeValue> signsToCaracteristicValue, + Map<String, Species> speciesBySurveyCode, + Map<String, SpeciesProtocol> speciesProtocolBySurveyCode, + BatchContainer<SpeciesBatch> rootSpeciesBatch) { + this.rootSpeciesBatch = rootSpeciesBatch; + this.bigfinImportResult = new BigfinImportResult(importFile); + this.operation = operation; + this.catchBatch = catchBatch; + this.signsToCaracteristicValue = signsToCaracteristicValue; + this.speciesBySurveyCode = speciesBySurveyCode; + this.speciesProtocolBySurveyCode = speciesProtocolBySurveyCode; + this.lengthStepPmfmBySpecies = new HashMap<>(); + } + + public Caracteristic getLengthStepPmfm(Species species, PersistenceService persistenceService) { + Caracteristic caracteristic = lengthStepPmfmBySpecies.get(species); + if (caracteristic == null) { + + SpeciesProtocol speciesProtocol = getSpeciesProtocol(species); + caracteristic = persistenceService.getCaracteristic(Integer.parseInt(speciesProtocol.getLengthStepPmfmId())); + lengthStepPmfmBySpecies.put(species, caracteristic); + + } + return caracteristic; + } + + public boolean isNoError() { + return bigfinImportResult.getErrors().isEmpty(); + } + + public void addRowToProcess(BigfinDataRow bigfinDataRow) { + + if (bigfinDataRow.getSpeciesOrSpeciesBatch().isSpecies()) { + speciesRows.add(bigfinDataRow); + } else { + speciesBatchRows.add(bigfinDataRow); + } + + } + + public Map<Integer, SpeciesBatch> getSpeciesBatchesById() { + return SpeciesBatchs.getAllSpeciesBatchesById(this.rootSpeciesBatch); + } + + public Multimap<Species, SpeciesBatch> getRootSpeciesBatchBySpecies() { + Multimap<Species, SpeciesBatch> batchesBySpecies = Multimaps.index(rootSpeciesBatch.getChildren(), new Function<SpeciesBatch, Species>() { + @Override + public Species apply(SpeciesBatch input) { + return input.getSpecies(); + } + }); + return batchesBySpecies; + } + + public Multimap<Species, BigfinDataRow> getSpeciesRowsBySpecies() { + + // separate the imported rows by species + Multimap<Species, BigfinDataRow> rowsBySpecies = Multimaps.index(speciesRows, new Function<BigfinDataRow, Species>() { + @Override + public Species apply(BigfinDataRow bigfinDataRow) { + return bigfinDataRow.getSpeciesOrSpeciesBatch().getSpecies(); + } + }); + + return rowsBySpecies; + } + + public Multimap<SpeciesBatch, BigfinDataRow> getSpeciesBatchRowsBySpeciesBatch() { + + Multimap<SpeciesBatch, BigfinDataRow> rowsBySpeciesBatch = Multimaps.index(speciesBatchRows, new Function<BigfinDataRow, SpeciesBatch>() { + @Override + public SpeciesBatch apply(BigfinDataRow input) { + return input.getSpeciesOrSpeciesBatch().getBatch(); + } + }); + + return rowsBySpeciesBatch; + + } + + public boolean isStationFound(BigfinDataRow bean) { + + String station = bean.getStation(); + Date date = bean.getDate(); + boolean result = station != null + && station.equals(operation.getStationNumber()) + && date != null + && DateUtils.isSameDay(date, operation.getGearShootingStartDate()); + return result; + + } + + public SpeciesProtocol getSpeciesProtocol(Species species) { + + String code = species.getSurveyCode(); + if (StringUtils.isBlank(code)) { + code = species.getReferenceTaxonId().toString(); + } + SpeciesProtocol speciesProtocol = speciesProtocolBySurveyCode.get(code); + return speciesProtocol; + + } + + public boolean checkRow(BigfinDataRow bigfinDataRow) { + + // check if the station is the one of the operation + // and do not check again a species that has not been recognized before + boolean stationFound = isStationFound(bigfinDataRow); + + boolean canBeAdd = false; + + if (stationFound) { + + SpeciesOrSpeciesBatch speciesOrspeciesBatch = bigfinDataRow.getSpeciesOrSpeciesBatch(); + + if (speciesOrspeciesBatch.isSpecies()) { + + // do some checks on the given species + + checkSizeIsDefined(bigfinDataRow); + + Species species = speciesOrspeciesBatch.getSpecies(); + + boolean speciesIsKnown = checkSpeciesIsKnown(species); + + if (speciesIsKnown) { + + boolean speciesProtocoleIsSafe = checkSpeciesProtocol(species); + + if (speciesProtocoleIsSafe) { + + canBeAdd = true; + + } + } + + } else { + + // do some checks on the given species batch + + boolean speciesBatchIsLeaf = checkSpeciesBatchIsLeaf(bigfinDataRow); + + if (speciesBatchIsLeaf) { + + canBeAdd = true; + + } + } + + } else { + if (log.isInfoEnabled()) { + log.info("Station is not matching for record: " + bigfinDataRow.getRecordId()); + } + } + + return canBeAdd; + } + + public boolean checkSpeciesBatchIsLeaf(BigfinDataRow bigfinDataRow) { + + Preconditions.checkArgument(bigfinDataRow.getSpeciesOrSpeciesBatch().isBatch()); + + + SpeciesBatch batch = bigfinDataRow.getSpeciesOrSpeciesBatch().getBatch(); + boolean speciesBatchIsLeaf = batch.isChildBatchsEmpty(); + + if (!speciesBatchIsLeaf) { + + String warning = t("tutti.service.bigfinImport.warning.speciesBatch.tooCategorized", batch.getId()); + if (log.isWarnEnabled()) { + log.warn(warning); + } + bigfinImportResult.addWarning(warning); + } + + return speciesBatchIsLeaf; + + } + + public void checkSizeIsDefined(BigfinDataRow bigfinDataRow) { + + Preconditions.checkArgument(bigfinDataRow.getSpeciesOrSpeciesBatch().isSpecies()); + + if (bigfinDataRow.getSize() == null) { + String error = t("tutti.service.bigfinImport.error.szClass.unknwon", bigfinDataRow.getRecordId()); + if (log.isErrorEnabled()) { + log.error(error); + } + bigfinImportResult.addError(error); + } + + } + + public boolean checkSpeciesIsKnown(Species species) { + + boolean speciesIsKnown = true; + + if (species.getId() == null) { + + // bloquer tout si un "species" ne match pas le référentiel de Tutti : lister dans ce cas les codes non reconnus + if (speciesNotRecognized.add(species)) { + String error = t("tutti.service.bigfinImport.error.species.not.found", species.getExternalCode()); + if (log.isErrorEnabled()) { + log.error(error); + } + bigfinImportResult.addError(error); + } + + speciesIsKnown = false; + + } + + return speciesIsKnown; + + } + + public boolean checkSpeciesProtocol(Species species) { + + boolean speciesProtocoleIsSafe = true; + + String speciesLabel = getSpeciesLabel(species); + + SpeciesProtocol speciesProtocol = getSpeciesProtocol(species); + + // On n'importe pas les espèces non présentes dans le protocole et + // on liste les espèces/catégorisées non importées pour aider l'utilisateur + // à identifier le problème et on fait l'import des autres + if (speciesProtocol == null) { + + speciesProtocoleIsSafe = false; + + if (speciesNotInProtocol.add(species)) { + + String error = t("tutti.service.bigfinImport.warning.species.notInProtocol", speciesLabel); + if (log.isWarnEnabled()) { + log.warn(error); + } + bigfinImportResult.addWarning(error); + } + + } else { + + if (speciesProtocol.getLengthStepPmfmId() == null) { + + speciesProtocoleIsSafe = false; + + if (speciesInProtocolButWithoutLengthStepPmfmId.add(species)) { + // bloquer toute espèce reconnue du protocole mais qui n'a pas de méthode de mesure + String error = t("tutti.service.bigfinImport.error.species.without.lengthstep", speciesLabel); + if (log.isErrorEnabled()) { + log.error(error); + } + bigfinImportResult.addError(error); + } + } + } + + return speciesProtocoleIsSafe; + + } + + public BigfinImportResult getResult() { + return bigfinImportResult; + } + + protected String getSpeciesLabel(Species species) { + String speciesLabel = species.getSurveyCode(); + if (StringUtils.isBlank(speciesLabel)) { + speciesLabel = species.getRefTaxCode(); + } + return speciesLabel; + } + + public Species getSpeciesWithSurveyCode(Species species) { + String refTaxCode = species.getRefTaxCode(); + Species speciesWithSurveyCode = speciesBySurveyCode.get(refTaxCode); + return speciesWithSurveyCode; + } +} \ No newline at end of file -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository tutti. See http://git.codelutin.com/tutti.git commit 8e2435c767b55bf3171a1ea9fe98fe8b9272234d Author: Tony CHEMIT <chemit@codelutin.com> Date: Tue Feb 3 19:15:39 2015 +0100 réusinage du code d'import et prise en compte du nouveau mode d'import (en indiquant le lot plutot que l'espèce carégorisée) --- .../tutti/service/bigfin/BigfinImportService.java | 366 +++++++++------------ .../resources/i18n/tutti-service_en_GB.properties | 1 + .../resources/i18n/tutti-service_fr_FR.properties | 3 +- 3 files changed, 159 insertions(+), 211 deletions(-) diff --git a/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/BigfinImportService.java b/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/BigfinImportService.java index eb2e061..3ccb390 100644 --- a/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/BigfinImportService.java +++ b/tutti-service/src/main/java/fr/ifremer/tutti/service/bigfin/BigfinImportService.java @@ -53,11 +53,15 @@ import fr.ifremer.tutti.persistence.entities.referential.Species; import fr.ifremer.tutti.service.AbstractTuttiService; import fr.ifremer.tutti.service.PersistenceService; import fr.ifremer.tutti.service.TuttiServiceContext; +import fr.ifremer.tutti.service.bigfin.csv.BigfinDataRow; +import fr.ifremer.tutti.service.bigfin.csv.BigfinDataRowModel; +import fr.ifremer.tutti.service.bigfin.signs.Sex; +import fr.ifremer.tutti.service.bigfin.signs.Sign; +import fr.ifremer.tutti.service.bigfin.signs.Size; +import fr.ifremer.tutti.service.bigfin.signs.VracHorsVrac; import fr.ifremer.tutti.util.Weights; import org.apache.commons.collections4.CollectionUtils; -import org.apache.commons.io.IOUtils; import org.apache.commons.lang3.StringUtils; -import org.apache.commons.lang3.time.DateUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.nuiton.csv.Import; @@ -65,14 +69,13 @@ import org.nuiton.csv.ImportRuntimeException; import org.nuiton.jaxx.application.ApplicationBusinessException; import java.io.File; +import java.io.IOException; import java.io.Reader; import java.io.Serializable; import java.text.DateFormat; import java.util.ArrayList; import java.util.Collection; -import java.util.Date; import java.util.HashMap; -import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; @@ -91,46 +94,38 @@ public class BigfinImportService extends AbstractTuttiService { protected Caracteristic sizeCaracteristic; - protected Caracteristic genderCaracteristic; + protected Caracteristic sexCaracteristic; - protected Map<Signs, CaracteristicQualitativeValue> signsToCaracteristicValue; - - protected Map<String, SpeciesProtocol> speciesProtocolBySurveyCode; + protected Map<Sign, CaracteristicQualitativeValue> signsToCaracteristicValue; @Override public void setServiceContext(TuttiServiceContext context) { + super.setServiceContext(context); persistenceService = getService(PersistenceService.class); - signsToCaracteristicValue = Maps.newEnumMap(Signs.class); + signsToCaracteristicValue = new HashMap<>(); - { // sorted/unsorted caracteristic - Caracteristic caracteristic = - persistenceService.getSortedUnsortedCaracteristic(); - Signs.VRAC.registerSign(caracteristic, signsToCaracteristicValue); - Signs.HORS_VRAC.registerSign(caracteristic, signsToCaracteristicValue); - } + // sex caracteristic + sexCaracteristic = persistenceService.getSexCaracteristic(); + Sex.NONE.registerSign(sexCaracteristic, signsToCaracteristicValue); + Sex.MALE.registerSign(sexCaracteristic, signsToCaracteristicValue); + Sex.FEMALE.registerSign(sexCaracteristic, signsToCaracteristicValue); - { // size caracteristic - sizeCaracteristic = persistenceService.getSizeCategoryCaracteristic(); - Signs.NOT_SIZED.registerSign(sizeCaracteristic, signsToCaracteristicValue); - Signs.SMALL.registerSign(sizeCaracteristic, signsToCaracteristicValue); - Signs.BIG.registerSign(sizeCaracteristic, signsToCaracteristicValue); - } + // size caracteristic + sizeCaracteristic = persistenceService.getSizeCategoryCaracteristic(); + Size.NOT_SIZED.registerSign(sizeCaracteristic, signsToCaracteristicValue); + Size.SMALL.registerSign(sizeCaracteristic, signsToCaracteristicValue); + Size.BIG.registerSign(sizeCaracteristic, signsToCaracteristicValue); - { // sex caracteristic - genderCaracteristic = persistenceService.getSexCaracteristic(); - Signs.NOT_SEXED.registerSign(genderCaracteristic, signsToCaracteristicValue); - Signs.MALE.registerSign(genderCaracteristic, signsToCaracteristicValue); - Signs.FEMALE.registerSign(genderCaracteristic, signsToCaracteristicValue); - } + // sorted/unsorted caracteristic + Caracteristic vracHorsVracCaracteristic = persistenceService.getSortedUnsortedCaracteristic(); + VracHorsVrac.VRAC.registerSign(vracHorsVracCaracteristic, signsToCaracteristicValue); + VracHorsVrac.HORS_VRAC.registerSign(vracHorsVracCaracteristic, signsToCaracteristicValue); } - public BigfinImportResult importFile(File bigfinFile, FishingOperation operation, CatchBatch catchBatch) { - - Preconditions.checkNotNull(bigfinFile); - Preconditions.checkArgument(bigfinFile.exists(), "Bigfin file " + bigfinFile + " does not exist."); + private BigfinImportContext prepareImportContext(File importFile, FishingOperation operation, CatchBatch catchBatch) { TuttiProtocol protocol = persistenceService.getProtocol(); @@ -139,7 +134,6 @@ public class BigfinImportService extends AbstractTuttiService { } List<Species> allReferentSpecies = persistenceService.getAllReferentSpecies(); - List<Species> allSpeciesWithSurveyCode = persistenceService.getReferentSpeciesWithSurveyCode(allReferentSpecies); Map<String, Species> speciesBySurveyCode = Maps.newTreeMap(); for (Species species : allReferentSpecies) { @@ -147,12 +141,13 @@ public class BigfinImportService extends AbstractTuttiService { if (StringUtils.isNotBlank(surveyCode)) { speciesBySurveyCode.put(surveyCode, species); - } else if (species.getRefTaxCode() != null) { + } + if (species.getRefTaxCode() != null) { speciesBySurveyCode.put(species.getRefTaxCode(), species); } } - speciesProtocolBySurveyCode = Maps.newTreeMap(); + Map<String, SpeciesProtocol> speciesProtocolBySurveyCode = Maps.newTreeMap(); for (SpeciesProtocol speciesProtocol : protocol.getSpecies()) { if (StringUtils.isNotBlank(speciesProtocol.getSpeciesSurveyCode())) { speciesProtocolBySurveyCode.put(speciesProtocol.getSpeciesSurveyCode(), speciesProtocol); @@ -164,196 +159,147 @@ public class BigfinImportService extends AbstractTuttiService { BatchContainer<SpeciesBatch> rootSpeciesBatch = persistenceService.getRootSpeciesBatch(operation.getId(), false); - // set of not found species already added in the errors - Set<Species> speciesNotRecognized = new HashSet<>(); - //set of species not in the protocol - Set<Species> speciesNotInProtocol = new HashSet<>(); - // set of species without lengthstep alreay added in the errors - Set<Species> speciesInProtocolButWithoutLengthStepPmfmId = new HashSet<>(); - - List<BigfinDataRow> rows = new ArrayList<>(); - BigfinImportResult result = new BigfinImportResult(bigfinFile); - - // load model - BigfinDataRowModel importModel = new BigfinDataRowModel(';', speciesBySurveyCode); - Reader reader = null; - Import<BigfinDataRow> importer = null; - try { - reader = Files.newReader(bigfinFile, Charsets.UTF_8); - importer = Import.newImport(importModel, reader); - - for (BigfinDataRow bean : importer) { - - Species species = bean.getSpecies(); - - // check if the station is the one of the operation - // and do not check again a species that has not been recognized before - String station = bean.getStation(); - Date dt = bean.getDt(); - if (station != null && station.equals(operation.getStationNumber()) - && dt != null && DateUtils.isSameDay(dt, operation.getGearShootingStartDate())) { - - if (bean.getSzClass() == null) { - String error = t("tutti.service.bigfinImport.error.szClass.unknwon", bean.getRecordId()); - if (log.isErrorEnabled()) { - log.error(error); - } - result.addError(error); - } - if (species == null || species.getId() == null) { -// bloquer tout si un "species" ne match pas le référentiel de Tutti : lister dans ce cas les codes non reconnus - if (speciesNotRecognized.add(species)) { - String error = t("tutti.service.bigfinImport.error.species.not.found", species.getExternalCode()); - if (log.isErrorEnabled()) { - log.error(error); - } - result.addError(error); - } + BigfinImportContext bigfinImportContext = new BigfinImportContext(importFile, operation, catchBatch, signsToCaracteristicValue, speciesBySurveyCode, speciesProtocolBySurveyCode, rootSpeciesBatch); + return bigfinImportContext; - } else { - String code = species.getSurveyCode(); - if (StringUtils.isBlank(code)) { - code = species.getReferenceTaxonId().toString(); - } - SpeciesProtocol speciesProtocol = speciesProtocolBySurveyCode.get(code); + } - String speciesLabel = species.getSurveyCode(); - if (StringUtils.isBlank(speciesLabel)) { - speciesLabel = species.getRefTaxCode(); - } + public BigfinImportResult importFile(File importFile, FishingOperation operation, CatchBatch catchBatch) { -// On n'importe pas les espèces non présentes dans le protocole et -// on liste les espèces/catégorisées non importées pour aider l'utilisateur -// à identifier le problème et on fait l'import des autres - if (speciesProtocol == null) { - if (speciesNotInProtocol.add(species)) { - String error = t("tutti.service.bigfinImport.warning.species.notInProtocol", speciesLabel); - if (log.isWarnEnabled()) { - log.warn(error); - } - result.addWarning(error); - } + Preconditions.checkNotNull(importFile); + Preconditions.checkArgument(importFile.exists(), "Bigfin file " + importFile + " does not exist."); - } else if (speciesProtocol.getLengthStepPmfmId() == null) { - if (speciesInProtocolButWithoutLengthStepPmfmId.add(species)) { -// bloquer toute espèce reconnue du protocole mais qui n'a pas de méthode de mesure - String error = t("tutti.service.bigfinImport.error.species.without.lengthstep", speciesLabel); - if (log.isErrorEnabled()) { - log.error(error); - } - result.addError(error); - } - } else { - rows.add(bean); - } + BigfinImportContext importContext = prepareImportContext(importFile, operation, catchBatch); + + BigfinDataRowModel importModel = new BigfinDataRowModel(importContext.speciesBySurveyCode, importContext.getSpeciesBatchesById()); + + try (Reader reader = Files.newReader(importFile, Charsets.UTF_8)) { + + try (Import<BigfinDataRow> importer = Import.newImport(importModel, reader)) { + + for (BigfinDataRow bigfinDataRow : importer) { + + if (log.isInfoEnabled()) { + log.info("Check row: " + bigfinDataRow.getRecordId()); } + boolean rowIsSafe = importContext.checkRow(bigfinDataRow); + + if (rowIsSafe) { + + importContext.addRowToProcess(bigfinDataRow); + } + } + } - } catch (ImportRuntimeException e) { - throw e; + } catch (IOException e) { + throw new ImportRuntimeException("Could not import bigfin data from file " + importFile, e); - } catch (Exception e) { - throw new ImportRuntimeException("Could not import bigfin data from file " + bigfinFile, e); + } + + if (importContext.isNoError()) { + + processSpeciesBatchRows(importContext); + + processSpeciesRows(importContext); + + addFileAsAttachment(importFile, importContext.catchBatch); - } finally { - IOUtils.closeQuietly(importer); - IOUtils.closeQuietly(reader); } - // if no error - if (result.isDone()) { - // get the root batches - List<SpeciesBatch> rootSpeciesBatches = rootSpeciesBatch.getChildren(); - // and separate them by species - Multimap<Species, SpeciesBatch> batchesBySpecies = Multimaps.index(rootSpeciesBatches, new Function<SpeciesBatch, Species>() { - @Override - public Species apply(SpeciesBatch input) { - return input.getSpecies(); - } - }); + BigfinImportResult result = importContext.getResult(); + return result; - // separate the imported rows by species - Multimap<Species, BigfinDataRow> rowsBySpecies = Multimaps.index(rows, new Function<BigfinDataRow, Species>() { - @Override - public Species apply(BigfinDataRow bigfinDataRow) { - return bigfinDataRow.getSpecies(); - } - }); - - SampleCategoryModel sampleCategoryModel = context.getSampleCategoryModel(); - List<Integer> samplingOrder = sampleCategoryModel.getSamplingOrder(); - - List<Integer> pmfmIds = new ArrayList<>(); - pmfmIds.add(PmfmId.SORTED_UNSORTED.getValue()); - List<Function<BigfinDataRow, Signs>> functions = new ArrayList<>(); - - // put the size and order in the right order - for (Integer categoryId : samplingOrder) { - if (PmfmId.SIZE_CATEGORY.getValue().equals(categoryId)) { - pmfmIds.add(categoryId); - functions.add(new Function<BigfinDataRow, Signs>() { - @Override - public Signs apply(BigfinDataRow bigfinDataRow) { - Signs result = bigfinDataRow.getSzClass(); - return result; - } - }); - - } else if (PmfmId.SEX.getValue().equals(categoryId)) { - pmfmIds.add(categoryId); - functions.add(new Function<BigfinDataRow, Signs>() { - @Override - public Signs apply(BigfinDataRow bigfinDataRow) { - Signs result = bigfinDataRow.getGender(); - return result; - } - }); - } - } + } - List<Category> categories = new ArrayList<>(); - for (int i = 0; i < pmfmIds.size(); i++) { - Category category = new Category(pmfmIds.get(i), i < functions.size() ? functions.get(i) : null); - categories.add(category); - } - // for each species imported - for (Species species : rowsBySpecies.keySet()) { + private void processSpeciesBatchRows(BigfinImportContext importContext) { - // get the speciesprotocol and its lengthstep pmfm - String code = species.getSurveyCode(); - if (StringUtils.isBlank(code)) { - code = species.getReferenceTaxonId().toString(); - } - SpeciesProtocol speciesProtocol = speciesProtocolBySurveyCode.get(code); - Caracteristic lengthStepPmfm = persistenceService.getCaracteristic(Integer.parseInt(speciesProtocol.getLengthStepPmfmId())); - - // get the rows with the current species and separate them by vrac/hors varc - Collection<BigfinDataRow> speciesRows = rowsBySpecies.get(species); - Multimap<Signs, BigfinDataRow> rowsByVracHorsVrac = - Multimaps.index(speciesRows, new Function<BigfinDataRow, Signs>() { - @Override - public Signs apply(BigfinDataRow bigfinDataRow) { - Signs result = bigfinDataRow.getVracHorsVrac(); - return result; - } - }); + BigfinImportResult result = importContext.getResult(); + + Multimap<SpeciesBatch, BigfinDataRow> speciesBatchRowsBySpeciesBatch = importContext.getSpeciesBatchRowsBySpeciesBatch(); + + for (SpeciesBatch batch : speciesBatchRowsBySpeciesBatch.keySet()) { + + List<SpeciesBatchFrequency> existingSpeciesFrequencies = persistenceService.getAllSpeciesBatchFrequency(batch.getId()); + + Integer deletedNb = persistenceService.countFrequenciesNumber(existingSpeciesFrequencies, false); + + Collection<BigfinDataRow> bigfinDataRows = speciesBatchRowsBySpeciesBatch.get(batch); + + Species species = importContext.getSpeciesWithSurveyCode(batch.getSpecies()); + Caracteristic lengthStepPmfm = importContext.getLengthStepPmfm(species, persistenceService); + List<SpeciesBatchFrequency> frequencies = createFrequencies(batch, bigfinDataRows, lengthStepPmfm); + + persistenceService.saveSpeciesBatchFrequency(batch.getId(), frequencies); + + result.incrementNbFrequenciesDeleted(deletedNb != null ? deletedNb : 0); + + Integer importedNb = persistenceService.countFrequenciesNumber(frequencies, false); + result.incrementNbFrequenciesImported(importedNb != null ? importedNb : 0); + + } - Collection<SpeciesBatch> speciesBatches = batchesBySpecies.get(species); - Map<Serializable, SpeciesBatch> speciesBatchByVracHorsVrac = Maps.uniqueIndex(speciesBatches, SpeciesBatchs.GET_SAMPLE_CATEGORY_VALUE); + } + + private void processSpeciesRows(BigfinImportContext importContext) { + + BigfinImportResult result = importContext.getResult(); + + SampleCategoryModel sampleCategoryModel = context.getSampleCategoryModel(); + List<Integer> samplingOrder = sampleCategoryModel.getSamplingOrder(); + + List<Integer> pmfmIds = new ArrayList<>(); + pmfmIds.add(PmfmId.SORTED_UNSORTED.getValue()); + List<Function<BigfinDataRow, Sign>> functions = new ArrayList<>(); - BrowseBatchesParameter commonParameter = new BrowseBatchesParameter(operation, species, - lengthStepPmfm, categories, result); - browseBatchesToAddFrequencies(commonParameter, null, 0, speciesBatchByVracHorsVrac, rowsByVracHorsVrac); + // put the size and order in the right order + for (Integer categoryId : samplingOrder) { + if (PmfmId.SIZE_CATEGORY.getValue().equals(categoryId)) { + pmfmIds.add(categoryId); + functions.add(Size.newExtractValueFunction()); + + } else if (PmfmId.SEX.getValue().equals(categoryId)) { + pmfmIds.add(categoryId); + functions.add(Sex.newExtractValueFunction()); } + } + + List<Category> categories = new ArrayList<>(); + for (int i = 0; i < pmfmIds.size(); i++) { + Category category = new Category(pmfmIds.get(i), i < functions.size() ? functions.get(i) : null); + categories.add(category); + } + + // and separate them by species + Multimap<Species, SpeciesBatch> batchesBySpecies = importContext.getRootSpeciesBatchBySpecies(); + + // separate the imported rows by species + Multimap<Species, BigfinDataRow> rowsBySpecies = importContext.getSpeciesRowsBySpecies(); + + // for each species imported + for (Species species : rowsBySpecies.keySet()) { + + // get the lengthstep pmfm associated with the species + Caracteristic lengthStepPmfm = importContext.getLengthStepPmfm(species, persistenceService); + + // get the rows with the current species and separate them by vrac/hors varc + Collection<BigfinDataRow> speciesRows = rowsBySpecies.get(species); + Multimap<Sign, BigfinDataRow> rowsByVracHorsVrac = Multimaps.index(speciesRows, VracHorsVrac.newExtractValueFunction()); + + // get the existing species batches for the current species and separate them by vrac/hors varc + Collection<SpeciesBatch> speciesBatches = batchesBySpecies.get(species); + Map<Serializable, SpeciesBatch> speciesBatchByVracHorsVrac = Maps.uniqueIndex(speciesBatches, SpeciesBatchs.GET_SAMPLE_CATEGORY_VALUE); + + BrowseBatchesParameter commonParameter = new BrowseBatchesParameter(importContext.operation, species, lengthStepPmfm, categories, result); + browseBatchesToAddFrequencies(commonParameter, null, 0, speciesBatchByVracHorsVrac, rowsByVracHorsVrac); - addFileAsAttachment(bigfinFile, catchBatch); } - return result; } + /** * Go deeper in the batches until it finds the last of gender or size class, then add the frequencies * @@ -367,11 +313,11 @@ public class BigfinImportService extends AbstractTuttiService { SpeciesBatch parentBatch, int depth, Map<Serializable, SpeciesBatch> batchesByCaracteristic, - Multimap<Signs, BigfinDataRow> rowsByCaracteristic) { + Multimap<Sign, BigfinDataRow> rowsByCaracteristic) { Category category = commonParameter.getCategories().get(depth++); - for (Signs caracteristic : rowsByCaracteristic.keySet()) { + for (Sign caracteristic : rowsByCaracteristic.keySet()) { Collection<BigfinDataRow> bigfinDataRows = rowsByCaracteristic.get(caracteristic); // get the batch with the caracteristic @@ -404,7 +350,7 @@ public class BigfinImportService extends AbstractTuttiService { commonParameter.getResult().addWarning(t("tutti.service.bigfinImport.warning.species.tooCategorized", commonParameter.getSpeciesLabel(), sizeCaracteristic.getParameterName(), - genderCaracteristic.getParameterName())); + sexCaracteristic.getParameterName())); } else { // create the frequencies @@ -429,7 +375,7 @@ public class BigfinImportService extends AbstractTuttiService { } else { List<SpeciesBatch> batchChildren = batch.getChildBatchs(); - Multimap<Signs, BigfinDataRow> rowsByNewCaracteristic = Multimaps.index(bigfinDataRows, category.getCategoryValueGetter()); + Multimap<Sign, BigfinDataRow> rowsByNewCaracteristic = Multimaps.index(bigfinDataRows, category.getCategoryValueGetter()); // get the children of the current batch and separate them by caracteristic Map<Serializable, SpeciesBatch> childrenByCaracteristic = new HashMap<>(); @@ -444,7 +390,7 @@ public class BigfinImportService extends AbstractTuttiService { // if all the rows to import have a gender or size (the first category in the list) null equivalent // then ok // else error - Set<Signs> signsSet = rowsByNewCaracteristic.keySet(); + Set<Sign> signsSet = rowsByNewCaracteristic.keySet(); if (signsSet.size() == 1 && signsSet.iterator().next().isNullEquivalent()) {// we can go deeper category = commonParameter.getCategories().get(depth++); rowsByNewCaracteristic = Multimaps.index(bigfinDataRows, category.getCategoryValueGetter()); @@ -455,7 +401,7 @@ public class BigfinImportService extends AbstractTuttiService { commonParameter.getResult().addWarning(t("tutti.service.bigfinImport.warning.species.categoriesSkipped", commonParameter.getSpeciesLabel(), sizeCaracteristic.getParameterName(), - genderCaracteristic.getParameterName() + sexCaracteristic.getParameterName() )); continue; } @@ -481,7 +427,7 @@ public class BigfinImportService extends AbstractTuttiService { protected SpeciesBatch createSpeciesBatch(Species species, FishingOperation operation, Integer categoryId, - Signs signs, + Sign signs, String parentBatchId) { Preconditions.checkArgument(signs.getCategory().equals(categoryId)); @@ -571,9 +517,9 @@ public class BigfinImportService extends AbstractTuttiService { private Integer pmfmId; /** function to get the value of the caracteristic we want to group the batches by (eg size or gender) */ - private Function<BigfinDataRow, Signs> categoryValueGetter; + private Function<BigfinDataRow, Sign> categoryValueGetter; - public Category(Integer pmfmId, Function<BigfinDataRow, Signs> dataGetter) { + public Category(Integer pmfmId, Function<BigfinDataRow, Sign> dataGetter) { this.pmfmId = pmfmId; this.categoryValueGetter = dataGetter; } @@ -582,7 +528,7 @@ public class BigfinImportService extends AbstractTuttiService { return pmfmId; } - public Function<BigfinDataRow, Signs> getCategoryValueGetter() { + public Function<BigfinDataRow, Sign> getCategoryValueGetter() { return categoryValueGetter; } } diff --git a/tutti-service/src/main/resources/i18n/tutti-service_en_GB.properties b/tutti-service/src/main/resources/i18n/tutti-service_en_GB.properties index 1639fd0..2e482a1 100644 --- a/tutti-service/src/main/resources/i18n/tutti-service_en_GB.properties +++ b/tutti-service/src/main/resources/i18n/tutti-service_en_GB.properties @@ -69,6 +69,7 @@ tutti.service.bigfinImport.warning.species.categoriesSkipped= tutti.service.bigfinImport.warning.species.categorySkipped= tutti.service.bigfinImport.warning.species.notInProtocol= tutti.service.bigfinImport.warning.species.tooCategorized= +tutti.service.bigfinImport.warning.speciesBatch.tooCategorized= tutti.service.bigfinimport.error.no.protocol= tutti.service.compressZipFile.error= tutti.service.context.serviceInstanciation.error= diff --git a/tutti-service/src/main/resources/i18n/tutti-service_fr_FR.properties b/tutti-service/src/main/resources/i18n/tutti-service_fr_FR.properties index 22d5621..cdde34a 100644 --- a/tutti-service/src/main/resources/i18n/tutti-service_fr_FR.properties +++ b/tutti-service/src/main/resources/i18n/tutti-service_fr_FR.properties @@ -52,12 +52,13 @@ tutti.report.step.load.fishingOperation=Charger le trait sélectionné tutti.service.bigfin.import.attachment.comment=Import Bigfin du %s tutti.service.bigfinImport.error.species.not.found=L'espèce '<strong>%s</strong>' est inconnue tutti.service.bigfinImport.error.species.without.lengthstep=L'espèce '<strong>%s</strong>' n'a pas de classe de taille associée dans le protocole. -tutti.service.bigfinImport.error.szClass.unknwon=Ligne <i>%s</i>, code inconnu (doit être 0, 1 ou 2) +tutti.service.bigfinImport.error.szClass.unknwon=Ligne <i>%s</i>, catégorie de taille inconnue (doit être 0, 1 ou 2) tutti.service.bigfinImport.warning.species.batch.frequenciesOnHigherLevel=Le lot de '<strong>%1s / %2s</strong>' a déjà des mensurations tutti.service.bigfinImport.warning.species.categoriesSkipped=L'espèce '<strong>%1s</strong>' a été catégorisée sans les catégories '<strong>%2s</strong>' et '<strong>%3s</strong>' tutti.service.bigfinImport.warning.species.categorySkipped=L'espèce '<strong>%1s</strong>' a été catégorisée sans la catégorie '<strong>%2s</strong>' tutti.service.bigfinImport.warning.species.notInProtocol=L'espèce '<strong>%1s</strong>' n'est pas présente dans le protocole tutti.service.bigfinImport.warning.species.tooCategorized=L'espèce '<strong>%1s</strong>' est trop catégorisée (pas limitée à '<strong>%2s</strong>' et '<strong>%3s</strong>') +tutti.service.bigfinImport.warning.speciesBatch.tooCategorized=Le lot '<strong>%1s</strong>' contient des sous catégories, on ne peut pas y ajouter des mensurations. tutti.service.bigfinimport.error.no.protocol=Impossible de faire un import Bigfin sans protocol. tutti.service.compressZipFile.error=Erreur lors de la compression du dossier %1s dans le fichier %2s tutti.service.context.serviceInstanciation.error=Erreur lors de l'instanciation du service %s -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.