Author: tchemit Date: 2014-04-24 12:17:09 +0200 (Thu, 24 Apr 2014) New Revision: 1725 Url: http://forge.codelutin.com/projects/tutti/repository/revisions/1725 Log: fixes #4979 Added: trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/ trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/ trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/ trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/ trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/ trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/MatrixId2.java trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/ObjectTypeCode2.java trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/PmfmId2.java trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/QualitativeValueId2.java Removed: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/data/AttachementObjectTypeEnum.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFile.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFileTest.java Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceNoDbImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocols.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AbstractPersistenceService.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceService.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CruisePersistenceService.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ProtocolPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceService.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceServiceImpl.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiPersistenceServiceLocator.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/BatchPersistenceHelper.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/BatchTreeHelper.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/MeasurementPersistenceHelper.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/SamplePersistenceHelper.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/VesselPersonFeaturesPersistenceHelper.java trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseFixtures.java trunk/tutti-persistence/src/main/resources/applicationContext-service-tutti.xml trunk/tutti-persistence/src/main/resources/i18n/tutti-persistence_en_GB.properties trunk/tutti-persistence/src/main/resources/i18n/tutti-persistence_fr_FR.properties trunk/tutti-persistence/src/main/resources/tutti-db-enumerations.properties trunk/tutti-persistence/src/main/xmi/tutti-persistence.zargo trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocolsTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceReadTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceWriteTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceReadTest.java trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceWriteTest.java trunk/tutti-service/pom.xml trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/PersistenceService.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/multipost/MultiPostExportService.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/multipost/MultiPostImportService.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/protocol/ProtocolImportExportService.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/psionimport/PsionImportService.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/pupitri/PupitriCatch.java trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/pupitri/PupitriImportExportService.java trunk/tutti-ui-swing/pom.xml trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/action/ImportPupitriAction.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/category/EditSampleCategoryModelUIHandler.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/category/EditSampleCategoryModelUIModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/EditCruiseUIModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/ValidateCruiseUI.jaxx trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/ValidateCruiseUIHandler.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/ValidateCruiseUIModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/EditFishingOperationUIModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/EditCatchesUIModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/accidental/AccidentalBatchRowModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/BenthosBatchRowModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/BenthosBatchUIHandler.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/create/CreateBenthosBatchUIHandler.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/IndividualObservationBatchRowModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/marinelitter/MarineLitterBatchRowModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/SpeciesBatchRowModel.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/SpeciesBatchUIHandler.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/create/CreateSpeciesBatchUIHandler.java trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/util/attachment/AttachmentModelAware.java Added: trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/MatrixId2.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/MatrixId2.java (rev 0) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/MatrixId2.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -0,0 +1,196 @@ +/* + * #%L + * SIH-Adagio + * $Id$ + * $HeadURL: https://forge.ifremer.fr/svn/sih-adagio/trunk/adagio/mda/src/main/config/jav... $ + * %% + * Copyright (C) 2012 - 2013 Ifremer + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * #L% + */ + +package fr.ifremer.adagio.core.dao.referential.pmfm; + +import fr.ifremer.adagio.core.dao.technical.AdagioEnumerationDef; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import static org.nuiton.i18n.I18n.n; + +/** + * + */ +public enum MatrixId2 + implements Serializable, AdagioEnumerationDef<Integer> { + /** TODO: Model Documentation for Enumeration Literal PRODUCT_BATCH value 1 */ + PRODUCT_BATCH( + "adagio.enumeration.MatrixId.PRODUCT_BATCH", + n("adagio.enumeration.MatrixId.PRODUCT_BATCH.description"), + 1); + + /** + * The serial version UID of this class. Needed for serialization. + */ + private static final long serialVersionUID = 1L; + + private String key; + + private String description; + + private Integer enumValue; + + private MatrixId2(String key, String description, Integer value) { + this.key = key; + this.description = description; + this.enumValue = value; + } + + @Override + public void setValue(Integer newValue) { + if (newValue != null && !this.enumValue.equals(newValue)) { + // Update static lists + values.remove(this.enumValue); + literals.remove(this.enumValue); + this.enumValue = newValue; + values.put(this.enumValue, this); + literals.add(this.enumValue); + } + } + + @Override + public String getValueAsString() { + return String.valueOf(this.enumValue); + } + + /** + * Retrieves an instance of MatrixId from <code>its name</code>. + * + * @param name + * the name to create the MatrixId from. + * @return The enumeration literal named after the 'name' argument + */ + public static MatrixId2 fromString(String name) { + return MatrixId2.valueOf(name); + } + + /** + * Returns an enumeration literal Integer <code>value</code>. + * Required by JAXB2 enumeration implementation + * + * @return Integer with corresponding value + */ + public Integer value() { + return this.enumValue; + } + + /** + * Returns an instance of MatrixId from Integer <code>value</code>. + * Required by JAXB2 enumeration implementation + * + * @param value + * the value to create the MatrixId from. + * @return static Enumeration with corresponding value + */ + public static MatrixId2 fromValue(Integer value) { + for (MatrixId2 enumName : MatrixId2.values()) { + if (enumName.getValue().equals(value)) { + return enumName; + } + } + throw new IllegalArgumentException("MatrixId.fromValue(" + value.toString() + ')'); + } + + /** + * Gets the underlying value of this type safe enumeration. + * This method is necessary to comply with DaoBase implementation. + * + * @return The name of this literal. + */ + public Integer getValue() { + return this.enumValue; + } + + @Override + public String getDescription() { + return description; + } + + @Override + public String getKey() { + return key; + } + + @Override + public Class<?> getType() { + return Integer.class; + } + + /** + * Returns an unmodifiable list containing the literals that are known by this enumeration. + * + * @return A List containing the actual literals defined by this enumeration, this list + * can not be modified. + */ + public static List<Integer> literals() { + return MatrixId2.literals; + } + + /** + * Returns an unmodifiable list containing the names of the literals that are known + * by this enumeration. + * + * @return A List containing the actual names of the literals defined by this + * enumeration, this list can not be modified. + */ + public static List<String> names() { + return MatrixId2.names; + } + + private static Map<Integer, MatrixId2> values = new LinkedHashMap<Integer, MatrixId2>(4, 1); + + private static List<Integer> literals = new ArrayList<Integer>(4); + + private static List<String> names = new ArrayList<String>(4); + + private static List<MatrixId2> valueList = new ArrayList<MatrixId2>(4); + + /** + * Initializes the values. + */ + static { + synchronized (MatrixId2.values) { + MatrixId2.values.put(PRODUCT_BATCH.enumValue, PRODUCT_BATCH); + } + synchronized (MatrixId2.valueList) { + MatrixId2.valueList.add(PRODUCT_BATCH); + // For Adagio, lists could be reload from configuration + // MatrixId.valueList = Collections.unmodifiableList(valueList); + } + synchronized (MatrixId2.literals) { + MatrixId2.literals.add(PRODUCT_BATCH.enumValue); + // For Adagio, lists could be reload from configuration + // MatrixId.literals = Collections.unmodifiableList(literals); + } + synchronized (MatrixId2.names) { + MatrixId2.names.add("PRODUCT_BATCH"); + MatrixId2.names = Collections.unmodifiableList(names); + } + } +} \ No newline at end of file Property changes on: trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/MatrixId2.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Added: svn:eol-style + native Added: trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/ObjectTypeCode2.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/ObjectTypeCode2.java (rev 0) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/ObjectTypeCode2.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -0,0 +1,252 @@ +package fr.ifremer.adagio.core.dao.referential.pmfm; + +import fr.ifremer.adagio.core.dao.technical.AdagioEnumerationDef; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import static org.nuiton.i18n.I18n.n; + +/** + * Created on 4/24/14. + * + * @author Tony Chemit <chemit@codelutin.com> + * @since 3.5 + */ +public enum ObjectTypeCode2 implements Serializable, AdagioEnumerationDef<String> { + /** TODO: Model Documentation for Enumeration Literal ACTIVITY_CALENDAR value "ACTIVITY_CALENDAR" */ + ACTIVITY_CALENDAR( + "adagio.enumeration.ObjectTypeCode.ACTIVITY_CALENDAR", + n("adagio.enumeration.ObjectTypeCode.ACTIVITY_CALENDAR.description"), + "ACTIVITY_CALENDAR"), + /** TODO: Model Documentation for Enumeration Literal FISHING_TRIP value "FISHING_TRIP" */ + FISHING_TRIP( + "adagio.enumeration.ObjectTypeCode.FISHING_TRIP", + n("adagio.enumeration.ObjectTypeCode.FISHING_TRIP.description"), + "FISHING_TRIP"), + /** TODO: Model Documentation for Enumeration Literal OPERATION value "OPERATION" */ + OPERATION( + "adagio.enumeration.ObjectTypeCode.OPERATION", + n("adagio.enumeration.ObjectTypeCode.OPERATION.description"), + "OPERATION"), + /** TODO: Model Documentation for Enumeration Literal BATCH value "BATCH" */ + CATCH_BATCH( + "adagio.enumeration.ObjectTypeCode.CATCH_BATCH", + n("adagio.enumeration.ObjectTypeCode.CATCH_BATCH.description"), + "CATCH_BATCH"), + /** TODO: Model Documentation for Enumeration Literal BATCH value "BATCH" */ + BATCH( + "adagio.enumeration.ObjectTypeCode.BATCH", + n("adagio.enumeration.ObjectTypeCode.BATCH.description"), + "BATCH"), + /** TODO: Model Documentation for Enumeration Literal SAMPLE value "SAMPLE" */ + SAMPLE( + "adagio.enumeration.ObjectTypeCode.SAMPLE", + n("adagio.enumeration.ObjectTypeCode.SAMPLE.description"), + "SAMPLE"), + /** TODO: Model Documentation for Enumeration Literal SCIENTIFIC_CRUISE value "SCIENTIFIC_CRUISE" */ + SCIENTIFIC_CRUISE( + "adagio.enumeration.ObjectTypeCode.SCIENTIFIC_CRUISE", + n("adagio.enumeration.ObjectTypeCode.SCIENTIFIC_CRUISE.description"), + "SCIENTIFIC_CRUISE"), + /** TODO: Model Documentation for Enumeration Literal SALE value "SALE" */ + SALE( + "adagio.enumeration.ObjectTypeCode.SALE", + n("adagio.enumeration.ObjectTypeCode.SALE.description"), + "SALE"), + /** TODO: Model Documentation for Enumeration Literal LANDING value "LANDING" */ + LANDING( + "adagio.enumeration.ObjectTypeCode.LANDING", + n("adagio.enumeration.ObjectTypeCode.LANDING.description"), + "LANDING"), + /** TODO: Model Documentation for Enumeration Literal DAILY_ACTIVITY_CALENDAR value "DAILY_ACTIVITY_CALENDAR" */ + DAILY_ACTIVITY_CALENDAR( + "adagio.enumeration.ObjectTypeCode.DAILY_ACTIVITY_CALENDAR", + n("adagio.enumeration.ObjectTypeCode.DAILY_ACTIVITY_CALENDAR.description"), + "DAILY_ACTIVITY_CALENDAR"); + + /** + * The serial version UID of this class. Needed for serialization. + */ + private static final long serialVersionUID = -8263283045204115976L; + + private String key; + + private String description; + + private String enumValue; + + private ObjectTypeCode2(String key, String description, String value) { + this.key = key; + this.description = description; + this.enumValue = value; + } + + @Override + public void setValue(String newValue) { + if (newValue != null && !this.enumValue.equals(newValue)) { + // Update static lists + values.remove(this.enumValue); + literals.remove(this.enumValue); + this.enumValue = newValue; + values.put(this.enumValue, this); + literals.add(this.enumValue); + } + } + + + @Override + public String getValueAsString() { + return String.valueOf(this.enumValue); + } + + /** + * Retrieves an instance of ObjectTypeCode2 from <code>its name</code>. + * + * @param name the name to create the ObjectTypeCode2 from. + * @return The enumeration literal named after the 'name' argument + */ + public static ObjectTypeCode2 fromString(String name) { + return ObjectTypeCode2.valueOf(name); + } + + /** + * Returns an enumeration literal String <code>value</code>. + * Required by JAXB2 enumeration implementation + * + * @return String with corresponding value + */ + public String value() { + return this.enumValue; + } + + /** + * Returns an instance of ObjectTypeCode2 from String <code>value</code>. + * Required by JAXB2 enumeration implementation + * + * @param value the value to create the ObjectTypeCode2 from. + * @return static Enumeration with corresponding value + */ + public static ObjectTypeCode2 fromValue(String value) { + for (ObjectTypeCode2 enumName : ObjectTypeCode2.values()) { + if (enumName.getValue().equals(value)) { + return enumName; + } + } + throw new IllegalArgumentException("ObjectTypeCode2.fromValue(" + value + ')'); + } + + /** + * Gets the underlying value of this type safe enumeration. + * This method is necessary to comply with DaoBase implementation. + * + * @return The name of this literal. + */ + public String getValue() { + return this.enumValue; + } + + @Override + public String getDescription() { + return description; + } + + @Override + public String getKey() { + return key; + } + + @Override + public Class<?> getType() { + return String.class; + } + + /** + * Returns an unmodifiable list containing the literals that are known by this enumeration. + * + * @return A List containing the actual literals defined by this enumeration, this list + * can not be modified. + */ + public static List<String> literals() { + return ObjectTypeCode2.literals; + } + + /** + * Returns an unmodifiable list containing the names of the literals that are known + * by this enumeration. + * + * @return A List containing the actual names of the literals defined by this + * enumeration, this list can not be modified. + */ + public static List<String> names() { + return ObjectTypeCode2.names; + } + + private static Map<String, ObjectTypeCode2> values = new LinkedHashMap<String, ObjectTypeCode2>(9, 1); + + private static List<String> literals = new ArrayList<String>(9); + + private static List<String> names = new ArrayList<String>(9); + + private static List<ObjectTypeCode2> valueList = new ArrayList<ObjectTypeCode2>(9); + + /** + * Initializes the values. + */ + static { + synchronized (ObjectTypeCode2.values) { + ObjectTypeCode2.values.put(ACTIVITY_CALENDAR.enumValue, ACTIVITY_CALENDAR); + ObjectTypeCode2.values.put(FISHING_TRIP.enumValue, FISHING_TRIP); + ObjectTypeCode2.values.put(OPERATION.enumValue, OPERATION); + ObjectTypeCode2.values.put(BATCH.enumValue, BATCH); + ObjectTypeCode2.values.put(SAMPLE.enumValue, SAMPLE); + ObjectTypeCode2.values.put(SCIENTIFIC_CRUISE.enumValue, SCIENTIFIC_CRUISE); + ObjectTypeCode2.values.put(SALE.enumValue, SALE); + ObjectTypeCode2.values.put(LANDING.enumValue, LANDING); + ObjectTypeCode2.values.put(DAILY_ACTIVITY_CALENDAR.enumValue, DAILY_ACTIVITY_CALENDAR); + } + synchronized (ObjectTypeCode2.valueList) { + ObjectTypeCode2.valueList.add(ACTIVITY_CALENDAR); + ObjectTypeCode2.valueList.add(FISHING_TRIP); + ObjectTypeCode2.valueList.add(OPERATION); + ObjectTypeCode2.valueList.add(BATCH); + ObjectTypeCode2.valueList.add(SAMPLE); + ObjectTypeCode2.valueList.add(SCIENTIFIC_CRUISE); + ObjectTypeCode2.valueList.add(SALE); + ObjectTypeCode2.valueList.add(LANDING); + ObjectTypeCode2.valueList.add(DAILY_ACTIVITY_CALENDAR); + // For Adagio, lists could be reload from configuration + //ObjectTypeCode2.valueList = Collections.unmodifiableList(valueList); + } + synchronized (ObjectTypeCode2.literals) { + ObjectTypeCode2.literals.add(ACTIVITY_CALENDAR.enumValue); + ObjectTypeCode2.literals.add(FISHING_TRIP.enumValue); + ObjectTypeCode2.literals.add(OPERATION.enumValue); + ObjectTypeCode2.literals.add(BATCH.enumValue); + ObjectTypeCode2.literals.add(SAMPLE.enumValue); + ObjectTypeCode2.literals.add(SCIENTIFIC_CRUISE.enumValue); + ObjectTypeCode2.literals.add(SALE.enumValue); + ObjectTypeCode2.literals.add(LANDING.enumValue); + ObjectTypeCode2.literals.add(DAILY_ACTIVITY_CALENDAR.enumValue); + // For Adagio, lists could be reload from configuration + //ObjectTypeCode2.literals = Collections.unmodifiableList(literals); + } + synchronized (ObjectTypeCode2.names) { + ObjectTypeCode2.names.add("ACTIVITY_CALENDAR"); + ObjectTypeCode2.names.add("FISHING_TRIP"); + ObjectTypeCode2.names.add("OPERATION"); + ObjectTypeCode2.names.add("BATCH"); + ObjectTypeCode2.names.add("SAMPLE"); + ObjectTypeCode2.names.add("SCIENTIFIC_CRUISE"); + ObjectTypeCode2.names.add("SALE"); + ObjectTypeCode2.names.add("LANDING"); + ObjectTypeCode2.names.add("DAILY_ACTIVITY_CALENDAR"); + ObjectTypeCode2.names = Collections.unmodifiableList(names); + } + } + // type-safe-enumeration-object java merge-point +} \ No newline at end of file Property changes on: trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/ObjectTypeCode2.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Added: svn:eol-style + native Added: trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/PmfmId2.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/PmfmId2.java (rev 0) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/PmfmId2.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -0,0 +1,504 @@ +/* + * #%L + * SIH-Adagio + * $Id$ + * $HeadURL: https://forge.ifremer.fr/svn/sih-adagio/trunk/adagio/mda/src/main/config/jav... $ + * %% + * Copyright (C) 2012 - 2013 Ifremer + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * #L% + */ + +package fr.ifremer.adagio.core.dao.referential.pmfm; + +import fr.ifremer.adagio.core.dao.technical.AdagioEnumerationDef; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import static org.nuiton.i18n.I18n.n; + +/** + * + */ +public enum PmfmId2 + implements Serializable, AdagioEnumerationDef<Integer> +{ + // /** TODO: Model Documentation for Enumeration Literal ALIVE_WEIGHT_CALCULATED value "POIDS_CALCULE;6;1;6" */ + // ALIVE_WEIGHT_CALCULATED ( + // "adagio.enumeration.PmfmId.ALIVE_WEIGHT_CALCULATED", + // n("adagio.enumeration.PmfmId.ALIVE_WEIGHT_CALCULATED.description"), + // "POIDS_CALCULE;6;1;6"), + // /** TODO: Model Documentation for Enumeration Literal WEIGHT_SIZE_CALCULATED value "POIDS_CALCULE;6;1;7" */ + // WEIGHT_SIZE_CALCULATED ( + // "adagio.enumeration.PmfmId.WEIGHT_SIZE_CALCULATED", + // n("adagio.enumeration.PmfmId.WEIGHT_SIZE_CALCULATED.description"), + // "POIDS_CALCULE;6;1;7"), + // /** TODO: Model Documentation for Enumeration Literal WEIGHT_TOTAL_CALCULATED value "POIDS_CALCULE;6;1;17" */ + // WEIGHT_TOTAL_CALCULATED ( + // "adagio.enumeration.PmfmId.WEIGHT_TOTAL_CALCULATED", + // n("adagio.enumeration.PmfmId.WEIGHT_TOTAL_CALCULATED.description"), + // "POIDS_CALCULE;6;1;17"), + // /** TODO: Model Documentation for Enumeration Literal WEIGHT_SIZE_EXTRAPOLATE value "POIDS_CALCULE;6;1;21" */ + // WEIGHT_SIZE_EXTRAPOLATE ( + // "adagio.enumeration.PmfmId.WEIGHT_SIZE_EXTRAPOLATE", + // n("adagio.enumeration.PmfmId.WEIGHT_SIZE_EXTRAPOLATE.description"), + // "POIDS_CALCULE;6;1;21"), + // /** TODO: Model Documentation for Enumeration Literal CALCULATED_WEIGHT_CHILDREN_SUM value "POIDS_CALCULE;6;1;24" + // */ + // CALCULATED_WEIGHT_CHILDREN_SUM ( + // "adagio.enumeration.PmfmId.CALCULATED_WEIGHT_CHILDREN_SUM", + // n("adagio.enumeration.PmfmId.CALCULATED_WEIGHT_CHILDREN_SUM.description"), + // "POIDS_CALCULE;6;1;24"), + // /** TODO: Model Documentation for Enumeration Literal CALCULATED_ALIVE_WEIGHT_CHILDREN_SUM value "POIDS_CALCULE;6;1;25" */ + // CALCULATED_ALIVE_WEIGHT_CHILDREN_SUM ( + // "adagio.enumeration.PmfmId.CALCULATED_ALIVE_WEIGHT_CHILDREN_SUM", + // n("adagio.enumeration.PmfmId.CALCULATED_ALIVE_WEIGHT_CHILDREN_SUM.description"), + // "POIDS_CALCULE;6;1;25"), + // /** TODO: Model Documentation for Enumeration Literal MAX_DISTANCE_FOR_OPERATION_WITH_GEAR value "DISTANCE_MAX_OPERATION;17;1;1" */ + // MAX_DISTANCE_FOR_OPERATION_WITH_GEAR ( + // "adagio.enumeration.PmfmId.MAX_DISTANCE_FOR_OPERATION_WITH_GEAR", + // n("adagio.enumeration.PmfmId.MAX_DISTANCE_FOR_OPERATION_WITH_GEAR.description"), + // "DISTANCE_MAX_OPERATION;17;1;1"), + // /** TODO: Model Documentation for Enumeration Literal MAX_DURATION_FOR_OPERATION_WITH_GEAR value "DUREE_MAX_OPERATION;17;1;1" */ + // MAX_DURATION_FOR_OPERATION_WITH_GEAR ( + // "adagio.enumeration.PmfmId.MAX_DURATION_FOR_OPERATION_WITH_GEAR", + // n("adagio.enumeration.PmfmId.MAX_DURATION_FOR_OPERATION_WITH_GEAR.description"), + // "DUREE_MAX_OPERATION;17;1;1"), + // /** TODO: Model Documentation for Enumeration Literal MAX_DURATION_FOR_OPERATION_WITH_METIER value "DUREE_MAX_OPERATION;18;1;1" */ + // MAX_DURATION_FOR_OPERATION_WITH_METIER ( + // "adagio.enumeration.PmfmId.MAX_DURATION_FOR_OPERATION_WITH_METIER", + // n("adagio.enumeration.PmfmId.MAX_DURATION_FOR_OPERATION_WITH_METIER.description"), + // "DUREE_MAX_OPERATION;18;1;1"), + // /** TODO: Model Documentation for Enumeration Literal MAX_DISTANCE_FOR_OPERATION_WITH_METIER value "DISTANCE_MAX_OPERATION;18;1;1" */ + // MAX_DISTANCE_FOR_OPERATION_WITH_METIER ( + // "adagio.enumeration.PmfmId.MAX_DISTANCE_FOR_OPERATION_WITH_METIER", + // n("adagio.enumeration.PmfmId.MAX_DISTANCE_FOR_OPERATION_WITH_METIER.description"), + // "DISTANCE_MAX_OPERATION;18;1;1"), + // /** TODO: Model Documentation for Enumeration Literal STORAGE_STATE value "A_DEFINIR;1;1;1" */ + // STORAGE_STATE ( + // "adagio.enumeration.PmfmId.STORAGE_STATE", + // n("adagio.enumeration.PmfmId.STORAGE_STATE.description"), + // "A_DEFINIR;1;1;1"), + /** TODO: Model Documentation for Enumeration Literal SEX value "196" */ + SEX( + "adagio.enumeration.PmfmId.SEX", + n("adagio.enumeration.PmfmId.SEX.description"), + 196), + /** TODO: Model Documentation for Enumeration Literal SIZE_CATEGORY value "198" */ + SIZE_CATEGORY( + "adagio.enumeration.PmfmId.SIZE_CATEGORY", + n("adagio.enumeration.PmfmId.SIZE_CATEGORY.description"), + 198), + /** TODO: Model Documentation for Enumeration Literal AGE value "1430" */ + AGE( + "adagio.enumeration.PmfmId.AGE", + n("adagio.enumeration.PmfmId.AGE.description"), + 1430), + /** TODO: Model Documentation for Enumeration Literal MATURITY value "174" */ + MATURITY( + "adagio.enumeration.PmfmId.MATURITY", + n("adagio.enumeration.PmfmId.MATURITY.description"), + 174), + /** TODO: Model Documentation for Enumeration Literal MARINE_LITTER_TYPE value "1421" */ + MARINE_LITTER_TYPE( + "adagio.enumeration.PmfmId.MARINE_LITTER_TYPE", + n("adagio.enumeration.PmfmId.MARINE_LITTER_TYPE.description"), + 1421), + /** TODO: Model Documentation for Enumeration Literal MARINE_LITTER_SIZE_CATEGORY value "1422" */ + MARINE_LITTER_SIZE_CATEGORY( + "adagio.enumeration.PmfmId.MARINE_LITTER_SIZE_CATEGORY", + n("adagio.enumeration.PmfmId.MARINE_LITTER_SIZE_CATEGORY.description"), + 1422), + /** TODO: Model Documentation for Enumeration Literal SURVEY_PART value "1432" */ + SURVEY_PART( + "adagio.enumeration.PmfmId.SURVEY_PART", + n("adagio.enumeration.PmfmId.SURVEY_PART.description"), + 1432), + /** TODO: Model Documentation for Enumeration Literal STATION_NUMBER value "1243" */ + STATION_NUMBER( + "adagio.enumeration.PmfmId.STATION_NUMBER", + n("adagio.enumeration.PmfmId.STATION_NUMBER.description"), + 1243), + /** TODO: Model Documentation for Enumeration Literal TRAWL_DISTANCE value "113" */ + TRAWL_DISTANCE( + "adagio.enumeration.PmfmId.TRAWL_DISTANCE", + n("adagio.enumeration.PmfmId.TRAWL_DISTANCE.description"), + 113), + /** TODO: Model Documentation for Enumeration Literal HAUL_VALID value "1163" */ + HAUL_VALID( + "adagio.enumeration.PmfmId.HAUL_VALID", + n("adagio.enumeration.PmfmId.HAUL_VALID.description"), + 1163), + /** TODO: Model Documentation for Enumeration Literal RECTILINEAR_OPERATION value "192" */ + RECTILINEAR_OPERATION( + "adagio.enumeration.PmfmId.RECTILINEAR_OPERATION", + n("adagio.enumeration.PmfmId.RECTILINEAR_OPERATION.description"), + 192), + /** TODO: Model Documentation for Enumeration Literal MULTIRIG_NUMBER value "1420" */ + MULTIRIG_NUMBER( + "adagio.enumeration.PmfmId.MULTIRIG_NUMBER", + n("adagio.enumeration.PmfmId.MULTIRIG_NUMBER.description"), + 1420), + /** TODO: Model Documentation for Enumeration Literal MULTIRIG_AGGREGATION value "1424" */ + MULTIRIG_AGGREGATION( + "adagio.enumeration.PmfmId.MULTIRIG_AGGREGATION", + n("adagio.enumeration.PmfmId.MULTIRIG_AGGREGATION.description"), + 1424), + /** TODO: Model Documentation for Enumeration Literal WEIGHT_MEASURED value "220" */ + WEIGHT_MEASURED( + "adagio.enumeration.PmfmId.WEIGHT_MEASURED", + n("adagio.enumeration.PmfmId.WEIGHT_MEASURED.description"), + 220), + /** TODO: Model Documentation for Enumeration Literal SORTED_UNSORTED value "1428" */ + SORTED_UNSORTED( + "adagio.enumeration.PmfmId.SORTED_UNSORTED", + n("adagio.enumeration.PmfmId.SORTED_UNSORTED.description"), + 1428), + /** TODO: Model Documentation for Enumeration Literal SCIENTIFIC_CRUISE_SORTING_TYPE value "1429" */ + SCIENTIFIC_CRUISE_SORTING_TYPE( + "adagio.enumeration.PmfmId.SCIENTIFIC_CRUISE_SORTING_TYPE", + n("adagio.enumeration.PmfmId.SCIENTIFIC_CRUISE_SORTING_TYPE.description"), + 1429), + /** TODO: Model Documentation for Enumeration Literal SCIENTIFIC_CRUISE_SORTING_TYPE2 value "1431" */ + SCIENTIFIC_CRUISE_SORTING_TYPE2( + "adagio.enumeration.PmfmId.SCIENTIFIC_CRUISE_SORTING_TYPE2", + n("adagio.enumeration.PmfmId.SCIENTIFIC_CRUISE_SORTING_TYPE2.description"), + 1431), + /** TODO: Model Documentation for Enumeration Literal VERTICAL_OPENING value "832" */ + VERTICAL_OPENING( + "adagio.enumeration.PmfmId.VERTICAL_OPENING", + n("adagio.enumeration.PmfmId.VERTICAL_OPENING.description"), + 832), + /** TODO: Model Documentation for Enumeration Literal HORIZONTAL_OPENING_WINGS value "827" */ + HORIZONTAL_OPENING_WINGS( + "adagio.enumeration.PmfmId.HORIZONTAL_OPENING_WINGS", + n("adagio.enumeration.PmfmId.HORIZONTAL_OPENING_WINGS.description"), + 827), + /** TODO: Model Documentation for Enumeration Literal HORIZONTAL_OPENING_DOOR value "830" */ + HORIZONTAL_OPENING_DOOR( + "adagio.enumeration.PmfmId.HORIZONTAL_OPENING_DOOR", + n("adagio.enumeration.PmfmId.HORIZONTAL_OPENING_DOOR.description"), + 830), + /** TODO: Model Documentation for Enumeration Literal DEAD_OR_ALIVE value "1393" */ + DEAD_OR_ALIVE( + "adagio.enumeration.PmfmId.DEAD_OR_ALIVE", + n("adagio.enumeration.PmfmId.DEAD_OR_ALIVE.description"), + 1393), + /** TODO: Model Documentation for Enumeration Literal SORTING_TYPE_TCC value "1747" */ + SORTING_TYPE_TCC( + "adagio.enumeration.PmfmId.SORTING_TYPE_TCC", + n("adagio.enumeration.PmfmId.SORTING_TYPE_TCC.description"), + 1747), + + // NEW FOR TUTTI # PSFM "Pour référencer un autre id de pmfm" + ID_PSFM( + "adagio.enumeration.PmfmId.ID_PSFM", + n("adagio.enumeration.PmfmId.ID_PSFM.description"), + 1433); + + /** + * The serial version UID of this class. Needed for serialization. + */ + private static final long serialVersionUID = 1L; + + private String key; + private String description; + private Integer enumValue; + + private PmfmId2(String key, String description, Integer value) + { + this.key = key; + this.description = description; + this.enumValue = value; + } + + @Override + public void setValue(Integer newValue) { + if (newValue != null && !this.enumValue.equals(newValue)) { + // Update static lists + values.remove(this.enumValue); + literals.remove(this.enumValue); + this.enumValue = newValue; + values.put(this.enumValue, this); + literals.add(this.enumValue); + } + } + + @Override + public String getValueAsString() + { + return String.valueOf(this.enumValue); + } + + /** + * Retrieves an instance of PmfmId from <code>its name</code>. + * + * @param name + * the name to create the PmfmId from. + * @return The enumeration literal named after the 'name' argument + */ + public static PmfmId2 fromString(String name) + { + return PmfmId2.valueOf(name); + } + + /** + * Returns an enumeration literal String <code>value</code>. + * Required by JAXB2 enumeration implementation + * + * @return String with corresponding value + */ + public Integer value() + { + return this.enumValue; + } + + /** + * Returns an instance of PmfmId from String <code>value</code>. + * Required by JAXB2 enumeration implementation + * + * @param value + * the value to create the PmfmId from. + * @return static Enumeration with corresponding value + */ + public static PmfmId2 fromValue(String value) + { + for (PmfmId2 enumName : PmfmId2.values()) + { + if (enumName.getValue().equals(value)) + { + return enumName; + } + } + throw new IllegalArgumentException("PmfmId.fromValue(" + value + ')'); + } + + /** + * Gets the underlying value of this type safe enumeration. + * This method is necessary to comply with DaoBase implementation. + * + * @return The name of this literal. + */ + public Integer getValue() + { + return this.enumValue; + } + + @Override + public String getDescription() { + return description; + } + + @Override + public String getKey() { + return key; + } + + @Override + public Class<?> getType() { + return String.class; + } + + /** + * Returns an unmodifiable list containing the literals that are known by this enumeration. + * + * @return A List containing the actual literals defined by this enumeration, this list + * can not be modified. + */ + public static List<Integer> literals() + { + return PmfmId2.literals; + } + + /** + * Returns an unmodifiable list containing the names of the literals that are known + * by this enumeration. + * + * @return A List containing the actual names of the literals defined by this + * enumeration, this list can not be modified. + */ + public static List<String> names() + { + return PmfmId2.names; + } + + private static final Map<Integer, PmfmId2> values = new LinkedHashMap<Integer, PmfmId2>(33, 1); + private static final List<Integer> literals = new ArrayList<Integer>(33); + private static List<String> names = new ArrayList<String>(33); + private static final List<PmfmId2> valueList = new ArrayList<PmfmId2>(33); + + /** + * Initializes the values. + */ + static + { + synchronized (PmfmId2.values) + { + // PmfmId2.values.put(ALIVE_WEIGHT_CALCULATED.enumValue, ALIVE_WEIGHT_CALCULATED); + // PmfmId2.values.put(WEIGHT_SIZE_CALCULATED.enumValue, WEIGHT_SIZE_CALCULATED); + // PmfmId2.values.put(WEIGHT_TOTAL_CALCULATED.enumValue, WEIGHT_TOTAL_CALCULATED); + // PmfmId2.values.put(WEIGHT_SIZE_EXTRAPOLATE.enumValue, WEIGHT_SIZE_EXTRAPOLATE); + // PmfmId2.values.put(CALCULATED_WEIGHT_CHILDREN_SUM.enumValue, CALCULATED_WEIGHT_CHILDREN_SUM); + // PmfmId2.values.put(CALCULATED_ALIVE_WEIGHT_CHILDREN_SUM.enumValue, CALCULATED_ALIVE_WEIGHT_CHILDREN_SUM); + // PmfmId2.values.put(MAX_DISTANCE_FOR_OPERATION_WITH_GEAR.enumValue, MAX_DISTANCE_FOR_OPERATION_WITH_GEAR); + // PmfmId2.values.put(MAX_DURATION_FOR_OPERATION_WITH_GEAR.enumValue, MAX_DURATION_FOR_OPERATION_WITH_GEAR); + // PmfmId2.values.put(MAX_DURATION_FOR_OPERATION_WITH_METIER.enumValue, + // MAX_DURATION_FOR_OPERATION_WITH_METIER); + // PmfmId2.values.put(MAX_DISTANCE_FOR_OPERATION_WITH_METIER.enumValue, + // MAX_DISTANCE_FOR_OPERATION_WITH_METIER); + // PmfmId2.values.put(STORAGE_STATE.enumValue, STORAGE_STATE); + PmfmId2.values.put(SEX.enumValue, SEX); + PmfmId2.values.put(SIZE_CATEGORY.enumValue, SIZE_CATEGORY); + PmfmId2.values.put(AGE.enumValue, AGE); + PmfmId2.values.put(MATURITY.enumValue, MATURITY); + PmfmId2.values.put(MARINE_LITTER_TYPE.enumValue, MARINE_LITTER_TYPE); + PmfmId2.values.put(MARINE_LITTER_SIZE_CATEGORY.enumValue, MARINE_LITTER_SIZE_CATEGORY); + PmfmId2.values.put(SURVEY_PART.enumValue, SURVEY_PART); + PmfmId2.values.put(STATION_NUMBER.enumValue, STATION_NUMBER); + PmfmId2.values.put(TRAWL_DISTANCE.enumValue, TRAWL_DISTANCE); + PmfmId2.values.put(HAUL_VALID.enumValue, HAUL_VALID); + PmfmId2.values.put(RECTILINEAR_OPERATION.enumValue, RECTILINEAR_OPERATION); + PmfmId2.values.put(MULTIRIG_NUMBER.enumValue, MULTIRIG_NUMBER); + PmfmId2.values.put(MULTIRIG_AGGREGATION.enumValue, MULTIRIG_AGGREGATION); + PmfmId2.values.put(WEIGHT_MEASURED.enumValue, WEIGHT_MEASURED); + PmfmId2.values.put(SORTED_UNSORTED.enumValue, SORTED_UNSORTED); + PmfmId2.values.put(SCIENTIFIC_CRUISE_SORTING_TYPE.enumValue, SCIENTIFIC_CRUISE_SORTING_TYPE); + PmfmId2.values.put(SCIENTIFIC_CRUISE_SORTING_TYPE2.enumValue, SCIENTIFIC_CRUISE_SORTING_TYPE2); + PmfmId2.values.put(VERTICAL_OPENING.enumValue, VERTICAL_OPENING); + PmfmId2.values.put(HORIZONTAL_OPENING_WINGS.enumValue, HORIZONTAL_OPENING_WINGS); + PmfmId2.values.put(HORIZONTAL_OPENING_DOOR.enumValue, HORIZONTAL_OPENING_DOOR); + PmfmId2.values.put(DEAD_OR_ALIVE.enumValue, DEAD_OR_ALIVE); + PmfmId2.values.put(SORTING_TYPE_TCC.enumValue, SORTING_TYPE_TCC); + } + synchronized (PmfmId2.valueList) + { + // PmfmId2.valueList.add(ALIVE_WEIGHT_CALCULATED); + // PmfmId2.valueList.add(WEIGHT_SIZE_CALCULATED); + // PmfmId2.valueList.add(WEIGHT_TOTAL_CALCULATED); + // PmfmId2.valueList.add(WEIGHT_SIZE_EXTRAPOLATE); + // PmfmId2.valueList.add(CALCULATED_WEIGHT_CHILDREN_SUM); + // PmfmId2.valueList.add(CALCULATED_ALIVE_WEIGHT_CHILDREN_SUM); + // PmfmId2.valueList.add(MAX_DISTANCE_FOR_OPERATION_WITH_GEAR); + // PmfmId2.valueList.add(MAX_DURATION_FOR_OPERATION_WITH_GEAR); + // PmfmId2.valueList.add(MAX_DURATION_FOR_OPERATION_WITH_METIER); + // PmfmId2.valueList.add(MAX_DISTANCE_FOR_OPERATION_WITH_METIER); + // PmfmId2.valueList.add(STORAGE_STATE); + PmfmId2.valueList.add(SEX); + PmfmId2.valueList.add(SIZE_CATEGORY); + PmfmId2.valueList.add(AGE); + PmfmId2.valueList.add(MATURITY); + PmfmId2.valueList.add(MARINE_LITTER_TYPE); + PmfmId2.valueList.add(MARINE_LITTER_SIZE_CATEGORY); + PmfmId2.valueList.add(SURVEY_PART); + PmfmId2.valueList.add(STATION_NUMBER); + PmfmId2.valueList.add(TRAWL_DISTANCE); + PmfmId2.valueList.add(HAUL_VALID); + PmfmId2.valueList.add(RECTILINEAR_OPERATION); + PmfmId2.valueList.add(MULTIRIG_NUMBER); + PmfmId2.valueList.add(MULTIRIG_AGGREGATION); + PmfmId2.valueList.add(WEIGHT_MEASURED); + PmfmId2.valueList.add(SORTED_UNSORTED); + PmfmId2.valueList.add(SCIENTIFIC_CRUISE_SORTING_TYPE); + PmfmId2.valueList.add(SCIENTIFIC_CRUISE_SORTING_TYPE2); + PmfmId2.valueList.add(VERTICAL_OPENING); + PmfmId2.valueList.add(HORIZONTAL_OPENING_WINGS); + PmfmId2.valueList.add(HORIZONTAL_OPENING_DOOR); + PmfmId2.valueList.add(DEAD_OR_ALIVE); + PmfmId2.valueList.add(SORTING_TYPE_TCC); + // For Adagio, lists could be reload from configuration + // PmfmId.valueList = Collections.unmodifiableList(valueList); + } + synchronized (PmfmId2.literals) + { + // PmfmId2.literals.add(ALIVE_WEIGHT_CALCULATED.enumValue); + // PmfmId2.literals.add(WEIGHT_SIZE_CALCULATED.enumValue); + // PmfmId2.literals.add(WEIGHT_TOTAL_CALCULATED.enumValue); + // PmfmId2.literals.add(WEIGHT_SIZE_EXTRAPOLATE.enumValue); + // PmfmId2.literals.add(CALCULATED_WEIGHT_CHILDREN_SUM.enumValue); + // PmfmId2.literals.add(CALCULATED_ALIVE_WEIGHT_CHILDREN_SUM.enumValue); + // PmfmId2.literals.add(MAX_DISTANCE_FOR_OPERATION_WITH_GEAR.enumValue); + // PmfmId2.literals.add(MAX_DURATION_FOR_OPERATION_WITH_GEAR.enumValue); + // PmfmId2.literals.add(MAX_DURATION_FOR_OPERATION_WITH_METIER.enumValue); + // PmfmId2.literals.add(MAX_DISTANCE_FOR_OPERATION_WITH_METIER.enumValue); + // PmfmId2.literals.add(STORAGE_STATE.enumValue); + PmfmId2.literals.add(SEX.enumValue); + PmfmId2.literals.add(SIZE_CATEGORY.enumValue); + PmfmId2.literals.add(AGE.enumValue); + PmfmId2.literals.add(MATURITY.enumValue); + PmfmId2.literals.add(MARINE_LITTER_TYPE.enumValue); + PmfmId2.literals.add(MARINE_LITTER_SIZE_CATEGORY.enumValue); + PmfmId2.literals.add(SURVEY_PART.enumValue); + PmfmId2.literals.add(STATION_NUMBER.enumValue); + PmfmId2.literals.add(TRAWL_DISTANCE.enumValue); + PmfmId2.literals.add(HAUL_VALID.enumValue); + PmfmId2.literals.add(RECTILINEAR_OPERATION.enumValue); + PmfmId2.literals.add(MULTIRIG_NUMBER.enumValue); + PmfmId2.literals.add(MULTIRIG_AGGREGATION.enumValue); + PmfmId2.literals.add(WEIGHT_MEASURED.enumValue); + PmfmId2.literals.add(SORTED_UNSORTED.enumValue); + PmfmId2.literals.add(SCIENTIFIC_CRUISE_SORTING_TYPE.enumValue); + PmfmId2.literals.add(SCIENTIFIC_CRUISE_SORTING_TYPE2.enumValue); + PmfmId2.literals.add(VERTICAL_OPENING.enumValue); + PmfmId2.literals.add(HORIZONTAL_OPENING_WINGS.enumValue); + PmfmId2.literals.add(HORIZONTAL_OPENING_DOOR.enumValue); + PmfmId2.literals.add(DEAD_OR_ALIVE.enumValue); + PmfmId2.literals.add(SORTING_TYPE_TCC.enumValue); + // For Adagio, lists could be reload from configuration + // PmfmId.literals = Collections.unmodifiableList(literals); + } + synchronized (PmfmId2.names) + { + PmfmId2.names.add("ALIVE_WEIGHT_CALCULATED"); + PmfmId2.names.add("WEIGHT_SIZE_CALCULATED"); + PmfmId2.names.add("WEIGHT_TOTAL_CALCULATED"); + PmfmId2.names.add("WEIGHT_SIZE_EXTRAPOLATE"); + PmfmId2.names.add("CALCULATED_WEIGHT_CHILDREN_SUM"); + PmfmId2.names.add("CALCULATED_ALIVE_WEIGHT_CHILDREN_SUM"); + PmfmId2.names.add("MAX_DISTANCE_FOR_OPERATION_WITH_GEAR"); + PmfmId2.names.add("MAX_DURATION_FOR_OPERATION_WITH_GEAR"); + PmfmId2.names.add("MAX_DURATION_FOR_OPERATION_WITH_METIER"); + PmfmId2.names.add("MAX_DISTANCE_FOR_OPERATION_WITH_METIER"); + PmfmId2.names.add("STORAGE_STATE"); + PmfmId2.names.add("SEX"); + PmfmId2.names.add("SIZE_CATEGORY"); + PmfmId2.names.add("AGE"); + PmfmId2.names.add("MATURITY"); + PmfmId2.names.add("MARINE_LITTER_TYPE"); + PmfmId2.names.add("MARINE_LITTER_SIZE_CATEGORY"); + PmfmId2.names.add("SURVEY_PART"); + PmfmId2.names.add("STATION_NUMBER"); + PmfmId2.names.add("TRAWL_DISTANCE"); + PmfmId2.names.add("HAUL_VALID"); + PmfmId2.names.add("RECTILINEAR_OPERATION"); + PmfmId2.names.add("MULTIRIG_NUMBER"); + PmfmId2.names.add("MULTIRIG_AGGREGATION"); + PmfmId2.names.add("WEIGHT_MEASURED"); + PmfmId2.names.add("SORTED_UNSORTED"); + PmfmId2.names.add("SCIENTIFIC_CRUISE_SORTING_TYPE"); + PmfmId2.names.add("SCIENTIFIC_CRUISE_SORTING_TYPE2"); + PmfmId2.names.add("VERTICAL_OPENING"); + PmfmId2.names.add("HORIZONTAL_OPENING_WINGS"); + PmfmId2.names.add("HORIZONTAL_OPENING_DOOR"); + PmfmId2.names.add("DEAD_OR_ALIVE"); + PmfmId2.names.add("SORTING_TYPE_TCC"); + PmfmId2.names = Collections.unmodifiableList(names); + } + } +} \ No newline at end of file Property changes on: trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/PmfmId2.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Added: svn:eol-style + native Added: trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/QualitativeValueId2.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/QualitativeValueId2.java (rev 0) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/QualitativeValueId2.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -0,0 +1,247 @@ +/* + * #%L + * SIH-Adagio + * $Id$ + * $HeadURL: https://forge.ifremer.fr/svn/sih-adagio/trunk/adagio/mda/src/main/config/jav... $ + * %% + * Copyright (C) 2012 - 2013 Ifremer + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * #L% + */ +// +// Attention: Generated code! Do not modify by hand! +// Generated by: TypeSafeEnumeration.vsl in andromda-java-cartridge. +// Model Class: Data::fr.ifremer.adagio.core.dao::referential::pmfm::QualitativeValueId +// Metafacade: org.andromda.metafacades.uml.Enumeration +// Stereotype: Enumeration +// +package fr.ifremer.adagio.core.dao.referential.pmfm; + +import fr.ifremer.adagio.core.dao.technical.AdagioEnumerationDef; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import static org.nuiton.i18n.I18n.n; + +/** + * + */ +public enum QualitativeValueId2 + implements Serializable, AdagioEnumerationDef<Integer> { + /** TODO: Model Documentation for Enumeration Literal SEX_UNDEFINED value 203 */ + SEX_UNDEFINED( + "adagio.enumeration.QualitativeValueId.SEX_UNDEFINED", + n("adagio.enumeration.QualitativeValueId.SEX_UNDEFINED.description"), + 299), + /** TODO: Model Documentation for Enumeration Literal MATURITY_1 value 272 */ + MATURITY_1( + "adagio.enumeration.QualitativeValueId.MATURITY_1", + n("adagio.enumeration.QualitativeValueId.MATURITY_1.description"), + 272), + /** TODO: Model Documentation for Enumeration Literal MATURITY_2 value 273 */ + MATURITY_2( + "adagio.enumeration.QualitativeValueId.MATURITY_2", + n("adagio.enumeration.QualitativeValueId.MATURITY_2.description"), + 273), + /** TODO: Model Documentation for Enumeration Literal MATURITY_3 value 274 */ + MATURITY_3( + "adagio.enumeration.QualitativeValueId.MATURITY_3", + n("adagio.enumeration.QualitativeValueId.MATURITY_3.description"), + 274), + /** TODO: Model Documentation for Enumeration Literal MATURITY_4 value 275 */ + MATURITY_4( + "adagio.enumeration.QualitativeValueId.MATURITY_4", + n("adagio.enumeration.QualitativeValueId.MATURITY_4.description"), + 275), + /** TODO: Model Documentation for Enumeration Literal MATURITY_5 value 276 */ + MATURITY_5( + "adagio.enumeration.QualitativeValueId.MATURITY_5", + n("adagio.enumeration.QualitativeValueId.MATURITY_5.description"), + 276); + + /** + * The serial version UID of this class. Needed for serialization. + */ + private static final long serialVersionUID = 1L; + + private String key; + + private String description; + + private Integer enumValue; + + private QualitativeValueId2(String key, String description, Integer value) { + this.key = key; + this.description = description; + this.enumValue = value; + } + + @Override + public void setValue(Integer newValue) { + if (newValue != null && !this.enumValue.equals(newValue)) { + // Update static lists + values.remove(this.enumValue); + literals.remove(this.enumValue); + this.enumValue = newValue; + values.put(this.enumValue, this); + literals.add(this.enumValue); + } + } + + @Override + public String getValueAsString() { + return String.valueOf(this.enumValue); + } + + /** + * Retrieves an instance of QualitativeValueId from <code>its name</code>. + * + * @param name + * the name to create the QualitativeValueId from. + * @return The enumeration literal named after the 'name' argument + */ + public static QualitativeValueId2 fromString(String name) { + return QualitativeValueId2.valueOf(name); + } + + /** + * Returns an enumeration literal Integer <code>value</code>. + * Required by JAXB2 enumeration implementation + * + * @return Integer with corresponding value + */ + public Integer value() { + return this.enumValue; + } + + /** + * Returns an instance of QualitativeValueId from Integer <code>value</code>. + * Required by JAXB2 enumeration implementation + * + * @param value + * the value to create the QualitativeValueId from. + * @return static Enumeration with corresponding value + */ + public static QualitativeValueId2 fromValue(Integer value) { + for (QualitativeValueId2 enumName : QualitativeValueId2.values()) { + if (enumName.getValue().equals(value)) { + return enumName; + } + } + throw new IllegalArgumentException("QualitativeValueId.fromValue(" + value.toString() + ')'); + } + + /** + * Gets the underlying value of this type safe enumeration. + * This method is necessary to comply with DaoBase implementation. + * + * @return The name of this literal. + */ + public Integer getValue() { + return this.enumValue; + } + + @Override + public String getDescription() { + return description; + } + + @Override + public String getKey() { + return key; + } + + @Override + public Class<?> getType() { + return Integer.class; + } + + /** + * Returns an unmodifiable list containing the literals that are known by this enumeration. + * + * @return A List containing the actual literals defined by this enumeration, this list + * can not be modified. + */ + public static List<Integer> literals() { + return QualitativeValueId2.literals; + } + + /** + * Returns an unmodifiable list containing the names of the literals that are known + * by this enumeration. + * + * @return A List containing the actual names of the literals defined by this + * enumeration, this list can not be modified. + */ + public static List<String> names() { + return QualitativeValueId2.names; + } + + private static Map<Integer, QualitativeValueId2> values = new LinkedHashMap<Integer, QualitativeValueId2>(38, 1); + + private static List<Integer> literals = new ArrayList<Integer>(38); + + private static List<String> names = new ArrayList<String>(38); + + private static List<QualitativeValueId2> valueList = new ArrayList<QualitativeValueId2>(38); + + /** + * Initializes the values. + */ + static { + synchronized (QualitativeValueId2.values) { + QualitativeValueId2.values.put(SEX_UNDEFINED.enumValue, SEX_UNDEFINED); + QualitativeValueId2.values.put(MATURITY_1.enumValue, MATURITY_1); + QualitativeValueId2.values.put(MATURITY_2.enumValue, MATURITY_2); + QualitativeValueId2.values.put(MATURITY_3.enumValue, MATURITY_3); + QualitativeValueId2.values.put(MATURITY_4.enumValue, MATURITY_4); + QualitativeValueId2.values.put(MATURITY_5.enumValue, MATURITY_5); + } + synchronized (QualitativeValueId2.valueList) { + QualitativeValueId2.valueList.add(SEX_UNDEFINED); + QualitativeValueId2.valueList.add(MATURITY_1); + QualitativeValueId2.valueList.add(MATURITY_2); + QualitativeValueId2.valueList.add(MATURITY_3); + QualitativeValueId2.valueList.add(MATURITY_4); + QualitativeValueId2.valueList.add(MATURITY_5); + // For Adagio, lists could be reload from configuration + // QualitativeValueId.valueList = Collections.unmodifiableList(valueList); + } + synchronized (QualitativeValueId2.literals) { + QualitativeValueId2.literals.add(SEX_UNDEFINED.enumValue); + QualitativeValueId2.literals.add(MATURITY_1.enumValue); + QualitativeValueId2.literals.add(MATURITY_2.enumValue); + QualitativeValueId2.literals.add(MATURITY_3.enumValue); + QualitativeValueId2.literals.add(MATURITY_4.enumValue); + QualitativeValueId2.literals.add(MATURITY_5.enumValue); + // For Adagio, lists could be reload from configuration + // QualitativeValueId.literals = Collections.unmodifiableList(literals); + } + synchronized (QualitativeValueId2.names) { + QualitativeValueId2.names.add("SEX_UNDEFINED"); + QualitativeValueId2.names.add("MATURITY_1"); + QualitativeValueId2.names.add("MATURITY_2"); + QualitativeValueId2.names.add("MATURITY_3"); + QualitativeValueId2.names.add("MATURITY_4"); + QualitativeValueId2.names.add("MATURITY_5"); + QualitativeValueId2.names = Collections.unmodifiableList(names); + } + } +} \ No newline at end of file Property changes on: trunk/tutti-persistence/src/main/java/fr/ifremer/adagio/core/dao/referential/pmfm/QualitativeValueId2.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Added: svn:eol-style + native Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceImpl.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceImpl.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -27,10 +27,10 @@ import com.google.common.base.Predicate; import com.google.common.collect.Maps; import com.google.common.collect.Multimap; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.entities.CaracteristicMap; import fr.ifremer.tutti.persistence.entities.TuttiEntities; import fr.ifremer.tutti.persistence.entities.data.AccidentalBatch; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; import fr.ifremer.tutti.persistence.entities.data.BenthosBatch; @@ -67,7 +67,6 @@ import fr.ifremer.tutti.persistence.service.ReferentialPersistenceService; import fr.ifremer.tutti.persistence.service.SpeciesBatchPersistenceService; import fr.ifremer.tutti.persistence.service.TechnicalPersistenceService; -import fr.ifremer.tutti.persistence.service.TuttiEnumerationFile; import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator; import org.apache.commons.lang3.StringUtils; import org.apache.commons.logging.Log; @@ -143,11 +142,6 @@ } @Override - public TuttiEnumerationFile getEnumerationFile() { - return technicalPersistenceService.getEnumerationFile(); - } - - @Override public <V> V invoke(Callable<V> call) { return technicalPersistenceService.invoke(call); } @@ -173,11 +167,6 @@ } @Override - public void clearCache(String cacheName) { - technicalPersistenceService.clearCache(cacheName); - } - - @Override public void init() { if (log.isInfoEnabled()) { log.info("Open persistence driver " + getImplementationName()); @@ -474,7 +463,7 @@ //------------------------------------------------------------------------// @Override - public List<Attachment> getAllAttachments(AttachementObjectTypeEnum objectType, + public List<Attachment> getAllAttachments(ObjectTypeCode2 objectType, Integer objectId) { return attachmentService.getAllAttachments(objectType, objectId); } @@ -500,7 +489,7 @@ } @Override - public void deleteAllAttachment(AttachementObjectTypeEnum objectType, Integer... objectIds) { + public void deleteAllAttachment(ObjectTypeCode2 objectType, Integer... objectIds) { attachmentService.deleteAllAttachment(objectType, objectIds); } Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceNoDbImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceNoDbImpl.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceNoDbImpl.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -26,9 +26,9 @@ import com.google.common.base.Predicate; import com.google.common.collect.Multimap; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.entities.CaracteristicMap; import fr.ifremer.tutti.persistence.entities.data.AccidentalBatch; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; import fr.ifremer.tutti.persistence.entities.data.BenthosBatch; @@ -51,7 +51,6 @@ import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation; import fr.ifremer.tutti.persistence.entities.referential.TuttiReferentialEntity; import fr.ifremer.tutti.persistence.entities.referential.Vessel; -import fr.ifremer.tutti.persistence.service.TuttiEnumerationFile; import org.nuiton.util.Version; import java.io.File; @@ -74,11 +73,6 @@ } @Override - public TuttiEnumerationFile getEnumerationFile() { - throw notImplemented(); - } - - @Override public <V> V invoke(Callable<V> call) { throw notImplemented(); } @@ -107,10 +101,6 @@ public void clearAllCaches() { throw notImplemented(); } - @Override - public void clearCache(String cacheName) { - throw notImplemented(); - } @Override public List<TuttiLocation> getAllProgramZone() { @@ -625,7 +615,7 @@ } @Override - public List<Attachment> getAllAttachments(AttachementObjectTypeEnum objectType, + public List<Attachment> getAllAttachments(ObjectTypeCode2 objectType, Integer objectId) { throw notImplemented(); } @@ -688,7 +678,7 @@ } @Override - public void deleteAllAttachment(AttachementObjectTypeEnum objectType, Integer... objectIds) { + public void deleteAllAttachment(ObjectTypeCode2 objectType, Integer... objectIds) { throw notImplemented(); } Deleted: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/data/AttachementObjectTypeEnum.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/data/AttachementObjectTypeEnum.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/data/AttachementObjectTypeEnum.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -1,97 +0,0 @@ -package fr.ifremer.tutti.persistence.entities.data; - -/* - * #%L - * Tutti :: Persistence - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2012 - 2013 Ifremer - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/gpl-3.0.html>. - * #L% - */ - -import com.google.common.base.Preconditions; -import fr.ifremer.adagio.core.dao.referential.ObjectType; -import fr.ifremer.tutti.persistence.entities.TuttiEnumerable; -import fr.ifremer.tutti.persistence.service.TuttiEnumerationFile; - -/** - * Define all usable {@link ObjectType} in {@link Attachment}. - * <p/> - * <strong>Note: </strong>This enumeration implements {@link TuttiEnumerable}, - * so all values must be synched to the enumeration file and before usage we - * must be invoke the {@link TuttiEnumerationFile#init()} method. - * - * @author tchemit <chemit@codelutin.com> - * @see Attachment#getObjectType() - * @since 1.0.2 - */ -public enum AttachementObjectTypeEnum implements TuttiEnumerable<String> { - - /** For cruise only. */ - SCIENTIFIC_CRUISE("OBJECT_TYPE_SCIENTIFIC_CRUISE"), - - /** For {@link FishingOperation} only. */ - OPERATION("OBJECT_TYPE_OPERATION"), - - /** For {@link CatchBatch} only. */ - CATCH_BATCH("OBJECT_TYPE_CATCH_BATCH"), - - /** For batch only ({@link SpeciesBatch} / {@link BenthosBatch} / {@link MarineLitterBatch}). */ - BATCH("OBJECT_TYPE_BATCH"), - - /** For sample only ({@link AccidentalBatch} / {@link IndividualObservationBatch}).. */ - SAMPLE("OBJECT_TYPE_SAMPLE"); - - private final String fieldName; - - private String fieldValue; - - private boolean init; - - AttachementObjectTypeEnum(String fieldName) { - this.fieldName = fieldName; - } - - @Override - public String getFieldName() { - return fieldName; - } - - @Override - public String getFieldValue() { - Preconditions.checkState( - isInit(), - "Enumeration " + getClass() + " was not init!"); - return fieldValue; - } - - @Override - public void setFieldValue(String fieldValue) { - this.fieldValue = fieldValue; - } - - @Override - public boolean isInit() { - return init; - } - - @Override - public void setInit(boolean init) { - this.init = init; - } -} Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocols.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocols.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocols.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -31,7 +31,8 @@ import com.google.common.base.Joiner; import com.google.common.collect.Lists; import com.google.common.io.Files; -import org.nuiton.jaxx.application.ApplicationTechnicalException; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; import fr.ifremer.tutti.persistence.TuttiPersistence; import fr.ifremer.tutti.persistence.entities.data.SampleCategoryModel; import fr.ifremer.tutti.persistence.entities.protocol.v1.SpeciesProtocol1; @@ -40,12 +41,12 @@ import fr.ifremer.tutti.persistence.entities.protocol.v1.TuttiProtocolBean1; import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; import fr.ifremer.tutti.persistence.entities.referential.Species; -import fr.ifremer.tutti.persistence.service.TuttiEnumerationFile; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.io.IOUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.nuiton.decorator.Decorator; +import org.nuiton.jaxx.application.ApplicationTechnicalException; import org.nuiton.util.beans.Binder; import org.nuiton.util.beans.BinderFactory; @@ -88,7 +89,7 @@ } } - public static TuttiProtocol fromFile(TuttiEnumerationFile enumeration, File file) { + public static TuttiProtocol fromFile(File file) { Reader fileReader = null; try { @@ -99,7 +100,7 @@ // transform String to Integer... - Integer sampleCategoryIdToRemove = enumeration.PMFM_ID_SORTED_UNSORTED; + Integer sampleCategoryIdToRemove = PmfmId2.SORTED_UNSORTED.getValue(); if (!result.isBenthosEmpty()) { for (SpeciesProtocol speciesProtocol : result.getBenthos()) { @@ -130,7 +131,7 @@ // try to load a v1 TuttiProtocol1 tuttiProtocol1 = fromFileV1(file); - TuttiProtocol result = fromTuttiProtocol1(enumeration, tuttiProtocol1); + TuttiProtocol result = fromTuttiProtocol1(tuttiProtocol1); return result; } finally { @@ -249,7 +250,7 @@ return message; } - protected static TuttiProtocol fromTuttiProtocol1(TuttiEnumerationFile enumeration, TuttiProtocol1 tuttiProtocol1) { + protected static TuttiProtocol fromTuttiProtocol1(TuttiProtocol1 tuttiProtocol1) { TuttiProtocol result = newTuttiProtocol(); Binder<TuttiProtocol1, TuttiProtocol> binder = BinderFactory.newBinder(TuttiProtocol1.class, TuttiProtocol.class); binder.copy(tuttiProtocol1, result); @@ -261,16 +262,16 @@ row.setMandatorySampleCategoryId(Lists.<Integer>newArrayList()); binderSpecies.copy(speciesProtocol1, row); if (speciesProtocol1.isAgeEnabled()) { - row.addMandatorySampleCategoryId(enumeration.PMFM_ID_AGE); + row.addMandatorySampleCategoryId(PmfmId2.AGE.getValue()); } if (speciesProtocol1.isSizeEnabled()) { - row.addMandatorySampleCategoryId(enumeration.PMFM_ID_SIZE_CATEGORY); + row.addMandatorySampleCategoryId(PmfmId2.SIZE_CATEGORY.getValue()); } if (speciesProtocol1.isMaturityEnabled()) { - row.addMandatorySampleCategoryId(enumeration.PMFM_ID_MATURITY); + row.addMandatorySampleCategoryId(PmfmId2.MATURITY.getValue()); } if (speciesProtocol1.isSexEnabled()) { - row.addMandatorySampleCategoryId(enumeration.PMFM_ID_SEX); + row.addMandatorySampleCategoryId(PmfmId2.SEX.getValue()); } result.addSpecies(row); } @@ -283,16 +284,16 @@ row.setMandatorySampleCategoryId(Lists.<Integer>newArrayList()); binderSpecies.copy(speciesProtocol1, row); if (speciesProtocol1.isAgeEnabled()) { - row.addMandatorySampleCategoryId(enumeration.PMFM_ID_AGE); + row.addMandatorySampleCategoryId(PmfmId2.AGE.getValue()); } if (speciesProtocol1.isSizeEnabled()) { - row.addMandatorySampleCategoryId(enumeration.PMFM_ID_SIZE_CATEGORY); + row.addMandatorySampleCategoryId(PmfmId2.SIZE_CATEGORY.getValue()); } if (speciesProtocol1.isMaturityEnabled()) { - row.addMandatorySampleCategoryId(enumeration.PMFM_ID_MATURITY); + row.addMandatorySampleCategoryId(PmfmId2.MATURITY.getValue()); } if (speciesProtocol1.isSexEnabled()) { - row.addMandatorySampleCategoryId(enumeration.PMFM_ID_SEX); + row.addMandatorySampleCategoryId(PmfmId2.SEX.getValue()); } result.addBenthos(row); } Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AbstractPersistenceService.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AbstractPersistenceService.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AbstractPersistenceService.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -65,9 +65,6 @@ @Resource protected SessionFactory sessionFactory; - @Resource(name = "tuttiEnumerationFile") - protected TuttiEnumerationFile enumeration; - @Resource(name = "tuttiConfiguration") protected TuttiConfiguration config; Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceImpl.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AccidentalBatchPersistenceServiceImpl.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -27,13 +27,18 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; import fr.ifremer.adagio.core.dao.administration.programStrategy.Program; +import fr.ifremer.adagio.core.dao.administration.user.DepartmentId; import fr.ifremer.adagio.core.dao.administration.user.DepartmentImpl; +import fr.ifremer.adagio.core.dao.administration.user.PersonId; import fr.ifremer.adagio.core.dao.administration.user.PersonImpl; import fr.ifremer.adagio.core.dao.data.operation.FishingOperationImpl; import fr.ifremer.adagio.core.dao.data.sample.Sample; +import fr.ifremer.adagio.core.dao.referential.QualityFlagCode; import fr.ifremer.adagio.core.dao.referential.QualityFlagImpl; import fr.ifremer.adagio.core.dao.referential.pmfm.Matrix; +import fr.ifremer.adagio.core.dao.referential.pmfm.MatrixId2; import fr.ifremer.adagio.core.dao.referential.pmfm.MatrixImpl; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; import fr.ifremer.adagio.core.dao.referential.taxon.ReferenceTaxonImpl; import fr.ifremer.adagio.core.dao.technical.synchronization.SynchronizationStatus; import fr.ifremer.tutti.persistence.entities.CaracteristicMap; @@ -202,14 +207,14 @@ target.setLabel(label); // Matrix (product / batch) - Matrix matrix = load(MatrixImpl.class, enumeration.MATRIX_ID_PRODUCT_BATCH); + Matrix matrix = load(MatrixImpl.class, MatrixId2.PRODUCT_BATCH.getValue()); target.setMatrix(matrix); // IndividualCount target.setIndividualCount((short) 1); // Quality Flag - target.setQualityFlag(load(QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED)); + target.setQualityFlag(load(QualityFlagImpl.class, QualityFlagCode.NOTQUALIFIED.getValue())); // Sample Date if (target.getSampleDate() == null) { @@ -221,11 +226,11 @@ // Recorder Departement target.setRecorderDepartment(load(DepartmentImpl.class, - enumeration.DEPARTMENT_ID_UNKNOWN_RECORDER_DEPARTMENT)); + DepartmentId.UNKOWN_RECODER_DEPARTMENT.getValue())); // Recorder Person target.setRecorderPerson(load(PersonImpl.class, - enumeration.PERSON_ID_UNKNOWN_RECORDER_PERSON)); + PersonId.UNKNOWN_RECORDER_PERSON.getValue())); // Program Program program = fishingOperation.getFishingTrip().getProgram(); @@ -281,7 +286,7 @@ if (source.getLengthStepCaracteristic() != null) { Caracteristic caracteristic = referentialService.getCaracteristic( - enumeration.PMFM_ID_ID_PSFM); + PmfmId2.ID_PSFM.getValue()); caracteristics.put(caracteristic, source.getLengthStepCaracteristic().getId()); @@ -317,12 +322,12 @@ batch.setGender(genderValue); } - Float weight = (Float) result.remove(referentialService.getCaracteristic(enumeration.PMFM_ID_WEIGHT_MEASURED)); + Float weight = (Float) result.remove(referentialService.getCaracteristic(PmfmId2.WEIGHT_MEASURED.getValue())); if (weight != null) { batch.setWeight(weight); } - String lengthClassId = (String) result.remove(referentialService.getCaracteristic(enumeration.PMFM_ID_ID_PSFM)); + String lengthClassId = (String) result.remove(referentialService.getCaracteristic(PmfmId2.ID_PSFM.getValue())); if (lengthClassId != null) { Caracteristic lengthStepCaracteristic = referentialService.getCaracteristic(Integer.valueOf(lengthClassId)); batch.setLengthStepCaracteristic(lengthStepCaracteristic); Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceService.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceService.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceService.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -24,8 +24,8 @@ * #L% */ +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.TuttiPersistenceServiceImplementor; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.Attachment; import org.springframework.transaction.annotation.Transactional; @@ -47,9 +47,9 @@ * @param objectType type of object. * @param objectId id of the object * @return list of all attachments for the given {@code objectId}. - * (see {@link AttachementObjectTypeEnum}) + * (see {@link ObjectTypeCode2}) */ - List<Attachment> getAllAttachments(AttachementObjectTypeEnum objectType, + List<Attachment> getAllAttachments(ObjectTypeCode2 objectType, Integer objectId); /** @@ -96,7 +96,7 @@ * @param objectIds ids of object */ @Transactional(readOnly = false) - void deleteAllAttachment(AttachementObjectTypeEnum objectType, + void deleteAllAttachment(ObjectTypeCode2 objectType, Integer... objectIds); } Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceImpl.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceImpl.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -29,8 +29,9 @@ import fr.ifremer.adagio.core.dao.data.measure.file.MeasurementFile; import fr.ifremer.adagio.core.dao.data.measure.file.MeasurementFileDao; import fr.ifremer.adagio.core.dao.referential.ObjectTypeImpl; +import fr.ifremer.adagio.core.dao.referential.QualityFlagCode; import fr.ifremer.adagio.core.dao.referential.QualityFlagImpl; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.Attachments; import org.apache.commons.lang3.ObjectUtils; @@ -90,12 +91,12 @@ //------------------------------------------------------------------------// @Override - public List<Attachment> getAllAttachments(AttachementObjectTypeEnum objectType, + public List<Attachment> getAllAttachments(ObjectTypeCode2 objectType, Integer objectId) { Iterator<Object[]> list = queryList( "allAttachment", "objectId", IntegerType.INSTANCE, objectId, - "objectTypeCode", StringType.INSTANCE, objectType.getFieldValue() + "objectTypeCode", StringType.INSTANCE, objectType.getValue() ); List<Attachment> result = Lists.newArrayList(); @@ -142,10 +143,10 @@ measurementFile.setPmfm(null); // set not qualifed flag - measurementFile.setQualityFlag(load(QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED)); + measurementFile.setQualityFlag(load(QualityFlagImpl.class, QualityFlagCode.NOTQUALIFIED.getValue())); // set objectType - measurementFile.setObjectType(load(ObjectTypeImpl.class, attachment.getObjectType().getFieldValue())); + measurementFile.setObjectType(load(ObjectTypeImpl.class, attachment.getObjectType().getValue())); // set objectId measurementFile.setObjectId(attachment.getObjectId()); @@ -205,7 +206,7 @@ // can't change the objectType String oldObjectTypeCode = measurementFile.getObjectType().getCode(); - if (ObjectUtils.notEqual(attachment.getObjectType().getFieldValue(), + if (ObjectUtils.notEqual(attachment.getObjectType().getValue(), oldObjectTypeCode)) { throw new InvalidDataAccessResourceUsageException( "Can't change objectType, was before " + oldObjectTypeCode); @@ -244,8 +245,7 @@ } @Override - public void deleteAllAttachment(AttachementObjectTypeEnum objectType, - Integer... objectIds) { + public void deleteAllAttachment(ObjectTypeCode2 objectType, Integer... objectIds) { for (Integer objectId : objectIds) { List<Attachment> attachments = getAllAttachments(objectType, objectId); for (Attachment attachment : attachments) { @@ -261,7 +261,7 @@ protected void loadAttachment(Object[] source, Attachment target) { - target.setObjectType(AttachementObjectTypeEnum.valueOf((String) source[0])); + target.setObjectType(ObjectTypeCode2.valueOf((String) source[0])); target.setObjectId((Integer) source[1]); target.setId(String.valueOf(source[2])); target.setPath((String) source[3]); Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceImpl.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceImpl.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -35,7 +35,9 @@ import fr.ifremer.adagio.core.dao.data.measure.QuantificationMeasurement; import fr.ifremer.adagio.core.dao.data.measure.SortingMeasurement; import fr.ifremer.adagio.core.dao.referential.QualityFlag; +import fr.ifremer.adagio.core.dao.referential.QualityFlagCode; import fr.ifremer.adagio.core.dao.referential.QualityFlagImpl; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; import fr.ifremer.adagio.core.dao.referential.taxon.ReferenceTaxon; import fr.ifremer.adagio.core.dao.referential.taxon.ReferenceTaxonImpl; import fr.ifremer.tutti.persistence.InvalidBatchModelException; @@ -414,7 +416,7 @@ } QualityFlag qualityFlag = source.getQualityFlag(); - target.setSpeciesToConfirm(qualityFlag != null && enumeration.QUALITY_FLAG_CODE_DOUBTFUL.equals(qualityFlag.getCode())); + target.setSpeciesToConfirm(qualityFlag != null && QualityFlagCode.DOUBTFUL.getValue().equals(qualityFlag.getCode())); return target; } @@ -516,7 +518,7 @@ if (source.getSampleCategoryId() != null && source.getSampleCategoryValue() != null) { Integer pmfmId = source.getSampleCategoryId(); // Do not store sorting measurement if pmfm = SORTED (already store in an ancestor batch) - if (!pmfmId.equals(enumeration.PMFM_ID_SORTED_UNSORTED)) { + if (!pmfmId.equals(PmfmId2.SORTED_UNSORTED.getValue())) { SortingMeasurement sortingMeasurement = measurementPersistenceHelper.setSortingMeasurement( target, pmfmId, @@ -540,9 +542,9 @@ // QualityFlag String qualityFlag; if (source.isSpeciesToConfirm()) { - qualityFlag = enumeration.QUALITY_FLAG_CODE_DOUBTFUL; + qualityFlag = QualityFlagCode.DOUBTFUL.getValue(); } else { - qualityFlag = enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED; + qualityFlag = QualityFlagCode.NOTQUALIFIED.getValue(); } target.setQualityFlag(load(QualityFlagImpl.class, qualityFlag)); Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceImpl.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CatchBatchPersistenceServiceImpl.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -31,6 +31,7 @@ import fr.ifremer.adagio.core.dao.data.batch.SortingBatch; import fr.ifremer.adagio.core.dao.data.measure.QuantificationMeasurement; import fr.ifremer.adagio.core.dao.data.operation.FishingOperationImpl; +import fr.ifremer.adagio.core.dao.referential.QualityFlagCode; import fr.ifremer.adagio.core.dao.referential.QualityFlagImpl; import fr.ifremer.adagio.core.dao.technical.synchronization.SynchronizationStatus; import fr.ifremer.tutti.persistence.entities.data.CatchBatch; @@ -266,7 +267,7 @@ Integer fishingOperationId = source.getFishingOperation().getIdAsInt(); target.setFishingOperation(load(FishingOperationImpl.class, fishingOperationId)); - target.setQualityFlag(load(QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED)); + target.setQualityFlag(load(QualityFlagImpl.class, QualityFlagCode.NOTQUALIFIED.getValue())); target.setRankOrder((short) 1); // SynchronizationStatus Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CruisePersistenceService.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CruisePersistenceService.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CruisePersistenceService.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -32,7 +32,6 @@ import java.util.Collection; import java.util.List; -import java.util.Set; /** * CRUD of {@link Cruise} entity. Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceImpl.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/CruisePersistenceServiceImpl.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -32,6 +32,7 @@ import fr.ifremer.adagio.core.dao.administration.programStrategy.ProgramDao; import fr.ifremer.adagio.core.dao.administration.programStrategy.ProgramImpl; import fr.ifremer.adagio.core.dao.administration.user.PersonDao; +import fr.ifremer.adagio.core.dao.administration.user.PersonId; import fr.ifremer.adagio.core.dao.administration.user.PersonImpl; import fr.ifremer.adagio.core.dao.data.measure.GearPhysicalMeasurement; import fr.ifremer.adagio.core.dao.data.survey.fishingTrip.FishingTrip; @@ -43,14 +44,17 @@ import fr.ifremer.adagio.core.dao.data.vessel.feature.person.VesselPersonFeatures; import fr.ifremer.adagio.core.dao.data.vessel.feature.physical.GearPhysicalFeatures; import fr.ifremer.adagio.core.dao.referential.QualityFlag; +import fr.ifremer.adagio.core.dao.referential.QualityFlagCode; import fr.ifremer.adagio.core.dao.referential.QualityFlagDao; import fr.ifremer.adagio.core.dao.referential.QualityFlagImpl; import fr.ifremer.adagio.core.dao.referential.VesselPersonRole; +import fr.ifremer.adagio.core.dao.referential.VesselPersonRoleId; import fr.ifremer.adagio.core.dao.referential.gear.GearDao; import fr.ifremer.adagio.core.dao.referential.location.Location; import fr.ifremer.adagio.core.dao.referential.location.LocationDao; import fr.ifremer.adagio.core.dao.referential.location.LocationImpl; import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmDao; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValue; import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueDao; import fr.ifremer.tutti.persistence.dao.GearPhysicalFeaturesDaoTutti; @@ -179,7 +183,7 @@ Object[] source = queryUnique( "cruise", "cruiseId", IntegerType.INSTANCE, Integer.valueOf(id), - "pmfmIdSurveyPart", IntegerType.INSTANCE, enumeration.PMFM_ID_SURVEY_PART); + "pmfmIdSurveyPart", IntegerType.INSTANCE, PmfmId2.SURVEY_PART.getValue()); if (source == null) { throw new DataRetrievalFailureException("Could not retrieve cruise with id=" + id); @@ -242,7 +246,7 @@ Iterator<Object[]> list = queryList( "allCruiseGears", "cruiseId", IntegerType.INSTANCE, Integer.valueOf(id), - "pmfmIdTrawlNet", IntegerType.INSTANCE, enumeration.PMFM_ID_MULTIRIG_NUMBER); + "pmfmIdTrawlNet", IntegerType.INSTANCE, PmfmId2.MULTIRIG_NUMBER.getValue()); List<GearWithOriginalRankOrder> gears = Lists.newArrayList(); int maxMultirigNumberFound = 0; @@ -272,10 +276,10 @@ Integer personId = (Integer) vesselPersonFeatures[0]; Person person = referentialService.getPerson(personId); Integer roleId = (Integer) vesselPersonFeatures[1]; - if (enumeration.VESSEL_PERSON_ROLE_ID_SCIENTIFIC_CRUISE_MANAGER.equals(roleId)) { + if (VesselPersonRoleId.SCIENTIFIC_CRUISE_MANAGER.getValue().equals(roleId)) { headOfMissions.add(person); - } else if (enumeration.VESSEL_PERSON_ROLE_ID_SORT_ROOM_MANAGER.equals(roleId)) { + } else if (VesselPersonRoleId.SORT_ROOM_MANAGER.getValue().equals(roleId)) { headOfSortRoom.add(person); } } @@ -399,7 +403,7 @@ GearPhysicalMeasurement measurement = list.next(); Integer pmfmId = measurement.getPmfm().getId(); - if (!enumeration.PMFM_ID_MULTIRIG_NUMBER.equals(pmfmId)) { + if (!PmfmId2.MULTIRIG_NUMBER.getValue().equals(pmfmId)) { Caracteristic caracteristic = referentialService.getCaracteristic(pmfmId); Serializable value = null; @@ -462,7 +466,7 @@ if (gpf.getGearPhysicalMeasurements() != null) { for (GearPhysicalMeasurement measurement : gpf.getGearPhysicalMeasurements()) { Integer pmfmId = measurement.getPmfm().getId(); - if (!enumeration.PMFM_ID_MULTIRIG_NUMBER.equals(pmfmId)) { + if (!PmfmId2.MULTIRIG_NUMBER.getValue().equals(pmfmId)) { measurementsToRemove.add(pmfmId); } } @@ -554,7 +558,7 @@ protected void cruiseToEntity(Cruise source, ScientificCruise target) { QualityFlag qualityFlagNotQualified = load( - QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED); + QualityFlagImpl.class, QualityFlagCode.NOTQUALIFIED.getValue()); // Retrieve entities : FishingTrip ObservedFishingTrip fishingTrip; @@ -593,7 +597,7 @@ // Optional values in UI, but mandatory in DB if (target.getManagerPerson() == null) { - target.setManagerPerson(load(PersonImpl.class, enumeration.PERSON_ID_UNKNOWN_RECORDER_PERSON)); + target.setManagerPerson(load(PersonImpl.class, PersonId.UNKNOWN_RECORDER_PERSON.getValue())); } // Default values : @@ -629,11 +633,11 @@ if (StringUtils.isEmpty(source.getSurveyPart())) { // remove surveyMeasurement if exists - measurementPersistenceHelper.removeSurveyMeasurement(fishingTrip, enumeration.PMFM_ID_SURVEY_PART); + measurementPersistenceHelper.removeSurveyMeasurement(fishingTrip, PmfmId2.SURVEY_PART.getValue()); } else { // update it or create it - measurementPersistenceHelper.setSurveyMeasurement(fishingTrip, enumeration.PMFM_ID_SURVEY_PART, null, source.getSurveyPart(), null); + measurementPersistenceHelper.setSurveyMeasurement(fishingTrip, PmfmId2.SURVEY_PART.getValue(), null, source.getSurveyPart(), null); } // Gear @@ -687,9 +691,9 @@ // Trawl net (store in Gear Physical features) if (source.getMultirigNumber() == null) { - gearPhysicalFeaturesDao.removeGearPhysicalMeasurement(guf, enumeration.PMFM_ID_MULTIRIG_NUMBER); + gearPhysicalFeaturesDao.removeGearPhysicalMeasurement(guf, PmfmId2.MULTIRIG_NUMBER.getValue()); } else { - gearPhysicalFeaturesDao.setGearPhysicalMeasurement(target, guf, enumeration.PMFM_ID_MULTIRIG_NUMBER, Float.valueOf(source.getMultirigNumber()), null, null); + gearPhysicalFeaturesDao.setGearPhysicalMeasurement(target, guf, PmfmId2.MULTIRIG_NUMBER.getValue(), Float.valueOf(source.getMultirigNumber()), null, null); } } Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceImpl.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/FishingOperationPersistenceServiceImpl.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -53,16 +53,21 @@ import fr.ifremer.adagio.core.dao.data.vessel.feature.use.VesselUseFeatures; import fr.ifremer.adagio.core.dao.data.vessel.feature.use.isActive; import fr.ifremer.adagio.core.dao.data.vessel.position.VesselPosition; +import fr.ifremer.adagio.core.dao.referential.QualityFlagCode; import fr.ifremer.adagio.core.dao.referential.QualityFlagImpl; import fr.ifremer.adagio.core.dao.referential.VesselPersonRole; +import fr.ifremer.adagio.core.dao.referential.VesselPersonRoleId; import fr.ifremer.adagio.core.dao.referential.gear.GearImpl; import fr.ifremer.adagio.core.dao.referential.location.LocationExtendDao; import fr.ifremer.adagio.core.dao.referential.location.LocationImpl; +import fr.ifremer.adagio.core.dao.referential.location.LocationLevelId; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId; import fr.ifremer.adagio.core.dao.technical.synchronization.SynchronizationStatus; import fr.ifremer.adagio.core.service.referential.location.LocationService; import fr.ifremer.tutti.persistence.dao.GearPhysicalFeaturesDaoTutti; import fr.ifremer.tutti.persistence.entities.CaracteristicMap; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.FishingOperation; import fr.ifremer.tutti.persistence.entities.data.FishingOperations; import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; @@ -199,8 +204,8 @@ Iterator<Object[]> list = queryList( "allFishingOperations", "cruiseId", IntegerType.INSTANCE, Integer.valueOf(cruiseId), - "pmfmIdStationNumber", IntegerType.INSTANCE, enumeration.PMFM_ID_STATION_NUMBER, - "pmfmIdMultirigAggregation", IntegerType.INSTANCE, enumeration.PMFM_ID_MULTIRIG_AGGREGATION + "pmfmIdStationNumber", IntegerType.INSTANCE, PmfmId2.STATION_NUMBER.getValue(), + "pmfmIdMultirigAggregation", IntegerType.INSTANCE, PmfmId2.MULTIRIG_AGGREGATION.getValue() ); List<FishingOperation> result = Lists.newArrayList(); @@ -261,9 +266,9 @@ Object[] source = queryUnique( "fishingOperation", "fishingOperationId", IntegerType.INSTANCE, Integer.valueOf(id), - "locationLevelIdStrata", IntegerType.INSTANCE, enumeration.LOCATION_LEVEL_ID_STRATA, - "locationLevelIdSubStrata", IntegerType.INSTANCE, enumeration.LOCATION_LEVEL_ID_SUB_STRATA, - "locationLevelIdLocalite", IntegerType.INSTANCE, enumeration.LOCATION_LEVEL_ID_LOCALITE + "locationLevelIdStrata", IntegerType.INSTANCE, LocationLevelId.SCIENTIFIC_CRUISE_STRATA.getValue(), + "locationLevelIdSubStrata", IntegerType.INSTANCE, LocationLevelId.SCIENTIFIC_CRUISE_SUB_STRATA.getValue(), + "locationLevelIdLocalite", IntegerType.INSTANCE, LocationLevelId.SCIENTIFIC_CRUISE_LOCALITE.getValue() ); if (source == null) { @@ -314,7 +319,7 @@ Integer personId = (Integer) vesselPersonFeatures[0]; Person person = referentialService.getPerson(personId); Integer roleId = (Integer) vesselPersonFeatures[1]; - if (enumeration.VESSEL_PERSON_ROLE_ID_RECORDER_PERSON.equals(roleId)) { + if (VesselPersonRoleId.RECORDER_PERSON.getValue().equals(roleId)) { result.addRecorderPerson(person); } } @@ -608,7 +613,7 @@ getCurrentSession().flush(); attachmentPersistenceService.deleteAllAttachment( - AttachementObjectTypeEnum.OPERATION, + ObjectTypeCode2.OPERATION, fishingOperationId); } @@ -633,26 +638,26 @@ Integer qualitativeValueId = (Integer) source[colIndex]; // Trawl distance - if (enumeration.PMFM_ID_TRAWL_DISTANCE.equals(pmfmId)) { + if (PmfmId2.TRAWL_DISTANCE.getValue().equals(pmfmId)) { result.setTrawlDistance(numericalValue); } // Rectilinear operation ? - else if (enumeration.PMFM_ID_RECTILINEAR_OPERATION.equals(pmfmId)) { - result.setFishingOperationRectiligne(enumeration.QUALITATIVE_RECTILINEAR_OPERATION_YES.equals(qualitativeValueId)); + else if (PmfmId2.RECTILINEAR_OPERATION.getValue().equals(pmfmId)) { + result.setFishingOperationRectiligne(QualitativeValueId.RECTILINEAR_OPERATION_YES.getValue().equals(qualitativeValueId)); } // Haul valid ? - else if (enumeration.PMFM_ID_HAUL_VALID.equals(pmfmId)) { + else if (PmfmId2.HAUL_VALID.getValue().equals(pmfmId)) { if (qualitativeValueId != null) { - result.setFishingOperationValid(enumeration.QUALITATIVE_HAUL_VALID_YES.equals(qualitativeValueId)); + result.setFishingOperationValid(QualitativeValueId.HAUL_VALID_YES.getValue().equals(qualitativeValueId)); } else { result.setFishingOperationValid(null); } } // Station Number : - else if (enumeration.PMFM_ID_STATION_NUMBER.equals(pmfmId)) { + else if (PmfmId2.STATION_NUMBER.getValue().equals(pmfmId)) { result.setStationNumber(alphanumericalValue); } @@ -699,7 +704,7 @@ Integer qualitativeValueId = (Integer) source[colIndex]; // Trawl net number - if (enumeration.PMFM_ID_MULTIRIG_AGGREGATION.equals(pmfmId) + if (PmfmId2.MULTIRIG_AGGREGATION.getValue().equals(pmfmId) && alphanumericalValue != null && alphanumericalValue.matches("\\d+")) { result.setMultirigAggregation(alphanumericalValue); @@ -870,7 +875,7 @@ // Retrieve multirig number, from Gear physical features int cruiseMultirigCount = 1; // default value if (gearPhysicalFeatures != null) { - GearPhysicalMeasurement gpmMultirigCount = gearPhysicalFeaturesDao.getGearPhysicalMeasurement(gearPhysicalFeatures, enumeration.PMFM_ID_MULTIRIG_NUMBER); + GearPhysicalMeasurement gpmMultirigCount = gearPhysicalFeaturesDao.getGearPhysicalMeasurement(gearPhysicalFeatures, PmfmId2.MULTIRIG_NUMBER.getValue()); if (gpmMultirigCount != null && gpmMultirigCount.getNumericalValue() != null) { cruiseMultirigCount = gpmMultirigCount.getNumericalValue().intValue(); } @@ -878,7 +883,7 @@ // StationNumber if (source.getStationNumber() != null) { - VesselUseMeasurement vum = measurementPersistenceHelper.setVesselUseMeasurement(scientificCruise, vesselUseFeatures, enumeration.PMFM_ID_STATION_NUMBER, null, source.getStationNumber(), null); + VesselUseMeasurement vum = measurementPersistenceHelper.setVesselUseMeasurement(scientificCruise, vesselUseFeatures, PmfmId2.STATION_NUMBER.getValue(), null, source.getStationNumber(), null); notChangedVesselUseMeasurements.remove(vum); } @@ -897,7 +902,7 @@ } // Store into Gear Use Features - GearUseMeasurement gum = measurementPersistenceHelper.setGearUseMeasurement(scientificCruise, gearUseFeatures, enumeration.PMFM_ID_MULTIRIG_AGGREGATION, null, source.getMultirigAggregation(), null); + GearUseMeasurement gum = measurementPersistenceHelper.setGearUseMeasurement(scientificCruise, gearUseFeatures, PmfmId2.MULTIRIG_AGGREGATION.getValue(), null, source.getMultirigAggregation(), null); notChangedGearUseMeasurements.remove(gum); } @@ -925,19 +930,19 @@ // Trawl distance if (source.getTrawlDistance() != null) { - VesselUseMeasurement vum = measurementPersistenceHelper.setVesselUseMeasurement(scientificCruise, vesselUseFeatures, enumeration.PMFM_ID_TRAWL_DISTANCE, source.getTrawlDistance(), null, null); + VesselUseMeasurement vum = measurementPersistenceHelper.setVesselUseMeasurement(scientificCruise, vesselUseFeatures, PmfmId2.TRAWL_DISTANCE.getValue(), source.getTrawlDistance(), null, null); notChangedVesselUseMeasurements.remove(vum); } // Rectilinear operation { - VesselUseMeasurement vum = measurementPersistenceHelper.setVesselUseMeasurement(scientificCruise, vesselUseFeatures, enumeration.PMFM_ID_RECTILINEAR_OPERATION, null, null, source.isFishingOperationRectiligne() ? enumeration.QUALITATIVE_RECTILINEAR_OPERATION_YES : enumeration.QUALITATIVE_RECTILINEAR_OPERATION_NO); + VesselUseMeasurement vum = measurementPersistenceHelper.setVesselUseMeasurement(scientificCruise, vesselUseFeatures, PmfmId2.RECTILINEAR_OPERATION.getValue(), null, null, source.isFishingOperationRectiligne() ? QualitativeValueId.RECTILINEAR_OPERATION_YES.getValue() : QualitativeValueId.RECTILINEAR_OPERATION_NO.getValue()); notChangedVesselUseMeasurements.remove(vum); } // Operation is valid ? if (source.getFishingOperationValid() != null) { - VesselUseMeasurement vum = measurementPersistenceHelper.setVesselUseMeasurement(scientificCruise, vesselUseFeatures, enumeration.PMFM_ID_HAUL_VALID, null, null, source.getFishingOperationValid() ? enumeration.QUALITATIVE_HAUL_VALID_YES : enumeration.QUALITATIVE_HAUL_VALID_NO); + VesselUseMeasurement vum = measurementPersistenceHelper.setVesselUseMeasurement(scientificCruise, vesselUseFeatures, PmfmId2.HAUL_VALID.getValue(), null, null, source.getFishingOperationValid() ? QualitativeValueId.HAUL_VALID_YES.getValue() : QualitativeValueId.HAUL_VALID_NO.getValue()); notChangedVesselUseMeasurements.remove(vum); } @@ -955,7 +960,7 @@ // Quality Flag : if (target.getQualityFlag() == null) { - target.setQualityFlag(load(QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED)); + target.setQualityFlag(load(QualityFlagImpl.class, QualityFlagCode.NOTQUALIFIED.getValue())); } // Settings not null properties : @@ -980,7 +985,7 @@ vesselUseFeatures.setCreationDate(d); } if (vesselUseFeatures.getQualityFlag() == null) { - vesselUseFeatures.setQualityFlag(load(QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED)); + vesselUseFeatures.setQualityFlag(load(QualityFlagImpl.class, QualityFlagCode.NOTQUALIFIED.getValue())); } // GearUseFeatures : @@ -996,7 +1001,7 @@ gearUseFeatures.setCreationDate(d); } if (gearUseFeatures.getQualityFlag() == null) { - gearUseFeatures.setQualityFlag(load(QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED)); + gearUseFeatures.setQualityFlag(load(QualityFlagImpl.class, QualityFlagCode.NOTQUALIFIED.getValue())); } // GearUseFeatures.Gear Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceImpl.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/IndividualObservationBatchPersistenceServiceImpl.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -27,14 +27,18 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; import fr.ifremer.adagio.core.dao.administration.programStrategy.Program; +import fr.ifremer.adagio.core.dao.administration.user.DepartmentId; import fr.ifremer.adagio.core.dao.administration.user.DepartmentImpl; +import fr.ifremer.adagio.core.dao.administration.user.PersonId; import fr.ifremer.adagio.core.dao.administration.user.PersonImpl; import fr.ifremer.adagio.core.dao.data.batch.Batch; import fr.ifremer.adagio.core.dao.data.batch.CatchBatch; import fr.ifremer.adagio.core.dao.data.operation.FishingOperationImpl; import fr.ifremer.adagio.core.dao.data.sample.Sample; +import fr.ifremer.adagio.core.dao.referential.QualityFlagCode; import fr.ifremer.adagio.core.dao.referential.QualityFlagImpl; import fr.ifremer.adagio.core.dao.referential.pmfm.Matrix; +import fr.ifremer.adagio.core.dao.referential.pmfm.MatrixId2; import fr.ifremer.adagio.core.dao.referential.pmfm.MatrixImpl; import fr.ifremer.adagio.core.dao.referential.taxon.ReferenceTaxonImpl; import fr.ifremer.adagio.core.dao.technical.synchronization.SynchronizationStatus; @@ -231,14 +235,14 @@ target.setLabel(label); // Matrix (product / batch) - Matrix matrix = load(MatrixImpl.class, enumeration.MATRIX_ID_PRODUCT_BATCH); + Matrix matrix = load(MatrixImpl.class, MatrixId2.PRODUCT_BATCH.getValue()); target.setMatrix(matrix); // IndividualCount target.setIndividualCount((short) 1); // Quality Flag - target.setQualityFlag(load(QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED)); + target.setQualityFlag(load(QualityFlagImpl.class, QualityFlagCode.NOTQUALIFIED.getValue())); // Sample Date if (target.getSampleDate() == null) { @@ -250,11 +254,11 @@ // Recorder Departement target.setRecorderDepartment(load(DepartmentImpl.class, - enumeration.DEPARTMENT_ID_UNKNOWN_RECORDER_DEPARTMENT)); + DepartmentId.UNKOWN_RECODER_DEPARTMENT.getValue())); // Recorder Person target.setRecorderPerson(load(PersonImpl.class, - enumeration.PERSON_ID_UNKNOWN_RECORDER_PERSON)); + PersonId.UNKNOWN_RECORDER_PERSON.getValue())); // Program Program program = fishingOperation.getFishingTrip().getProgram(); Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceImpl.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/MarineLitterBatchPersistenceServiceImpl.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -31,6 +31,7 @@ import fr.ifremer.adagio.core.dao.data.batch.SortingBatch; import fr.ifremer.adagio.core.dao.data.measure.QuantificationMeasurement; import fr.ifremer.adagio.core.dao.data.measure.SortingMeasurement; +import fr.ifremer.adagio.core.dao.referential.QualityFlagCode; import fr.ifremer.adagio.core.dao.referential.QualityFlagImpl; import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValue; import fr.ifremer.tutti.persistence.entities.TuttiEntities; @@ -288,7 +289,7 @@ target.setIndividualCount(source.getNumber()); // QualityFlag - QualityFlagImpl qualityFlag = load(QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED); + QualityFlagImpl qualityFlag = load(QualityFlagImpl.class, QualityFlagCode.NOTQUALIFIED.getValue()); target.setQualityFlag(qualityFlag); // Comments Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceImpl.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ProgramPersistenceServiceImpl.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -26,10 +26,15 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; +import fr.ifremer.adagio.core.dao.administration.programStrategy.ProgramCode; import fr.ifremer.adagio.core.dao.administration.programStrategy.ProgramDao; +import fr.ifremer.adagio.core.dao.referential.gear.GearClassificationId; import fr.ifremer.adagio.core.dao.referential.gear.GearClassificationImpl; import fr.ifremer.adagio.core.dao.referential.location.Location; +import fr.ifremer.adagio.core.dao.referential.location.LocationClassificationId; import fr.ifremer.adagio.core.dao.referential.location.LocationDao; +import fr.ifremer.adagio.core.dao.referential.location.LocationLevelId; +import fr.ifremer.adagio.core.dao.referential.taxon.TaxonGroupTypeCode; import fr.ifremer.adagio.core.dao.referential.taxon.TaxonGroupTypeImpl; import fr.ifremer.tutti.persistence.entities.data.Program; import fr.ifremer.tutti.persistence.entities.data.Programs; @@ -72,14 +77,14 @@ @Override public List<Program> getAllProgram() { String codePattern = "%"; - if (enumeration.PROGRAM_CODE_SCIENTIFIC_CRUISE_PREFIX != null) { - codePattern = enumeration.PROGRAM_CODE_SCIENTIFIC_CRUISE_PREFIX + codePattern; + if (ProgramCode.SCIENTIFIC_CRUISE_PREFIX.getValue() != null) { + codePattern = ProgramCode.SCIENTIFIC_CRUISE_PREFIX.getValue() + codePattern; } Iterator<Object[]> list = queryList( "allPrograms", "codePattern", StringType.INSTANCE, codePattern, - "locationLevelId", IntegerType.INSTANCE, enumeration.LOCATION_LEVEL_ID_PROGRAM, - "locationClassificationId", IntegerType.INSTANCE, enumeration.LOCATION_CLASSIFICATION_ID_SECTOR + "locationLevelId", IntegerType.INSTANCE, LocationLevelId.SCIENTIFIC_CRUISE_PROGRAM.getValue(), + "locationClassificationId", IntegerType.INSTANCE, LocationClassificationId.SECTOR.getValue() ); List<Program> result = Lists.newArrayList(); @@ -97,8 +102,8 @@ Iterator<Object[]> list = queryList( "program", "programCode", StringType.INSTANCE, id, - "locationLevelId", IntegerType.INSTANCE, enumeration.LOCATION_LEVEL_ID_PROGRAM, - "locationClassificationId", IntegerType.INSTANCE, enumeration.LOCATION_CLASSIFICATION_ID_SECTOR); + "locationLevelId", IntegerType.INSTANCE, LocationLevelId.SCIENTIFIC_CRUISE_PROGRAM.getValue(), + "locationClassificationId", IntegerType.INSTANCE, LocationClassificationId.SECTOR.getValue()); Program result; @@ -178,8 +183,8 @@ // Compute a program code (remove spaces, and capitalize the name) String programCode = source.getName().toUpperCase().replaceAll(" ", "_"); // Add a prefix - if (enumeration.PROGRAM_CODE_SCIENTIFIC_CRUISE_PREFIX != null) { - programCode = enumeration.PROGRAM_CODE_SCIENTIFIC_CRUISE_PREFIX + programCode; + if (ProgramCode.SCIENTIFIC_CRUISE_PREFIX.getValue() != null) { + programCode = ProgramCode.SCIENTIFIC_CRUISE_PREFIX.getValue() + programCode; } // Trunc the code if too long if (programCode.length() > maxCodeLengthInDatabase) { @@ -189,10 +194,10 @@ // Mandatory properties : // Gear classification : - target.setGearClassification(load(GearClassificationImpl.class, enumeration.GEAR_CLASSIFICIATION_ID_SCIENTIFIC)); + target.setGearClassification(load(GearClassificationImpl.class, GearClassificationId.SCIENTIFIC_CRUISE.getValue())); // taxon group type - target.setTaxonGroupType(load(TaxonGroupTypeImpl.class, enumeration.TAXON_GROUP_TYPE_ID_COMMERCIAL_SPECIES)); + target.setTaxonGroupType(load(TaxonGroupTypeImpl.class, TaxonGroupTypeCode.COMMERCIAL_SPECIES.getValue())); // Creation date target.setCreationDate(newCreateDate()); @@ -237,10 +242,10 @@ public int getProgramNameMaxLength() { int maxCodeLengthInDatabase = 40; - if (enumeration.PROGRAM_CODE_SCIENTIFIC_CRUISE_PREFIX == null - || enumeration.PROGRAM_CODE_SCIENTIFIC_CRUISE_PREFIX.trim().isEmpty()) { + if (ProgramCode.SCIENTIFIC_CRUISE_PREFIX.getValue() == null + || ProgramCode.SCIENTIFIC_CRUISE_PREFIX.getValue().trim().isEmpty()) { return maxCodeLengthInDatabase; } - return (maxCodeLengthInDatabase - enumeration.PROGRAM_CODE_SCIENTIFIC_CRUISE_PREFIX.length()); + return (maxCodeLengthInDatabase - ProgramCode.SCIENTIFIC_CRUISE_PREFIX.getValue().length()); } } Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ProtocolPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ProtocolPersistenceServiceImpl.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ProtocolPersistenceServiceImpl.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -25,6 +25,7 @@ */ import com.google.common.collect.Lists; +import fr.ifremer.adagio.core.service.technical.CacheService; import fr.ifremer.tutti.persistence.entities.TuttiEntities; import fr.ifremer.tutti.persistence.entities.protocol.SpeciesProtocol; import fr.ifremer.tutti.persistence.entities.protocol.SpeciesProtocols; @@ -62,8 +63,8 @@ public static TuttiProtocol sharedProtocol; - @Resource(name = "technicalPersistenceService") - protected TechnicalPersistenceService technicalService; + @Resource(name = "cacheService") + protected CacheService cacheService; public TuttiProtocol getProtocol() { return sharedProtocol; @@ -76,10 +77,10 @@ sharedProtocol = protocol; try { - technicalService.clearCache("species"); - technicalService.clearCache("referentSpecies"); - technicalService.clearCache("referentSpeciesById"); - technicalService.clearCache("referentSpeciesByIdVernacula"); + cacheService.clearCache("species"); + cacheService.clearCache("referentSpecies"); + cacheService.clearCache("referentSpeciesById"); + cacheService.clearCache("referentSpeciesByIdVernacula"); } catch (Exception e) { //FIXME This @@ -137,7 +138,7 @@ @Override public TuttiProtocol getProtocol(String id) { File file = getProtocolFile(id); - TuttiProtocol result = TuttiProtocols.fromFile(enumeration, file); + TuttiProtocol result = TuttiProtocols.fromFile(file); return result; } Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceImpl.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/ReferentialPersistenceServiceImpl.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -28,14 +28,27 @@ import com.google.common.base.Predicate; import com.google.common.collect.Iterables; import com.google.common.collect.Lists; +import com.google.common.collect.Sets; +import fr.ifremer.adagio.core.dao.administration.user.DepartmentId; import fr.ifremer.adagio.core.dao.administration.user.PersonExtendDao; +import fr.ifremer.adagio.core.dao.administration.user.UserProfilId; import fr.ifremer.adagio.core.dao.data.vessel.VesselExtendDao; +import fr.ifremer.adagio.core.dao.referential.StatusCode; import fr.ifremer.adagio.core.dao.referential.StatusDao; +import fr.ifremer.adagio.core.dao.referential.VesselTypeId; import fr.ifremer.adagio.core.dao.referential.gear.FishingGearExtendDao; import fr.ifremer.adagio.core.dao.referential.gear.GearClassification; +import fr.ifremer.adagio.core.dao.referential.gear.GearClassificationId; +import fr.ifremer.adagio.core.dao.referential.location.LocationClassificationId; import fr.ifremer.adagio.core.dao.referential.location.LocationExtendDao; +import fr.ifremer.adagio.core.dao.referential.location.LocationLabel; +import fr.ifremer.adagio.core.dao.referential.location.LocationLevelId; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId; +import fr.ifremer.adagio.core.dao.referential.pmfm.UnitId; import fr.ifremer.adagio.core.dao.referential.taxon.TaxonNameExtendDao; import fr.ifremer.adagio.core.dao.referential.taxon.TaxonRefVO; +import fr.ifremer.adagio.core.dao.referential.transcribing.TranscribingItemTypeId; import fr.ifremer.adagio.core.service.technical.CacheService; import fr.ifremer.tutti.persistence.entities.TuttiEntities; import fr.ifremer.tutti.persistence.entities.data.SpeciesAbleBatch; @@ -76,6 +89,7 @@ import java.util.Date; import java.util.Iterator; import java.util.List; +import java.util.Set; /** * Implementation of the {@link ReferentialPersistenceService} using a adagio @@ -118,15 +132,39 @@ protected Predicate<SpeciesAbleBatch> batchVracPredicate; + protected Set<Integer> propertedPmfmIds; + @Override public void init() { super.init(); batchVracPredicate = TuttiEntities.newSpeciesAbleBatchCategoryPredicate( - enumeration.PMFM_ID_SORTED_UNSORTED, - enumeration.QUALITATIVE_VRAC_ID); + PmfmId2.SORTED_UNSORTED.getValue(), + QualitativeValueId.SORTED_VRAC.getValue()); + + // init protected pmfm ids + propertedPmfmIds = Sets.newHashSet( + PmfmId2.MULTIRIG_AGGREGATION.getValue(), + PmfmId2.MULTIRIG_NUMBER.getValue(), + PmfmId2.STATION_NUMBER.getValue(), + PmfmId2.RECTILINEAR_OPERATION.getValue(), + PmfmId2.HAUL_VALID.getValue(), + PmfmId2.TRAWL_DISTANCE.getValue(), + PmfmId2.SURVEY_PART.getValue(), + PmfmId2.SORTED_UNSORTED.getValue(), + PmfmId2.ID_PSFM.getValue() + ); } + /** + * @param pmfmId id of pmfm to test + * @return {@code true} if the pmfm should NOT be used for caracteristics lists + * (i.e. because used somewhere when storing some properties into the database) + */ + protected boolean isProtectedCaracteristic(Integer pmfmId) { + return propertedPmfmIds.contains(pmfmId); + } + //------------------------------------------------------------------------// //-- ReferentialPersistenceService implentation --// //------------------------------------------------------------------------// @@ -135,8 +173,8 @@ public List<TuttiLocation> getAllProgramZone() { Iterator<Object[]> list = queryListWithStatus( "allLocationsByLevelAndClassificiation", - "locationClassificationId", IntegerType.INSTANCE, enumeration.LOCATION_CLASSIFICATION_ID_SECTOR, - "locationLevelId", IntegerType.INSTANCE, enumeration.LOCATION_LEVEL_ID_PROGRAM); + "locationClassificationId", IntegerType.INSTANCE, LocationClassificationId.SECTOR.getValue(), + "locationLevelId", IntegerType.INSTANCE, LocationLevelId.SCIENTIFIC_CRUISE_PROGRAM.getValue()); List<TuttiLocation> result = Lists.newArrayList(); while (list.hasNext()) { @@ -151,8 +189,8 @@ public List<TuttiLocation> getAllCountry() { Iterator<Object[]> list = queryListWithStatus( "allLocationsByLevelAndClassificiation", - "locationClassificationId", IntegerType.INSTANCE, enumeration.LOCATION_CLASSIFICATION_ID_TERRITORIAL, - "locationLevelId", IntegerType.INSTANCE, enumeration.LOCATION_LEVEL_ID_COUNTRY); + "locationClassificationId", IntegerType.INSTANCE, LocationClassificationId.TERRITORIAL.getValue(), + "locationLevelId", IntegerType.INSTANCE, LocationLevelId.PAYS_ISO3.getValue()); List<TuttiLocation> result = Lists.newArrayList(); while (list.hasNext()) { @@ -167,8 +205,8 @@ public List<TuttiLocation> getAllHarbour() { Iterator<Object[]> list = queryListWithStatus( "allLocationsByLevelAndClassificiation", - "locationClassificationId", IntegerType.INSTANCE, enumeration.LOCATION_CLASSIFICATION_ID_TERRITORIAL, - "locationLevelId", IntegerType.INSTANCE, enumeration.LOCATION_LEVEL_ID_HARBOUR); + "locationClassificationId", IntegerType.INSTANCE, LocationClassificationId.TERRITORIAL.getValue(), + "locationLevelId", IntegerType.INSTANCE, LocationLevelId.PORT.getValue()); List<TuttiLocation> result = Lists.newArrayList(); while (list.hasNext()) { @@ -183,9 +221,9 @@ public List<TuttiLocation> getAllFishingOperationStrata(String zoneId) { Preconditions.checkNotNull(zoneId); List<TuttiLocation> result = getFishingOperationLocationsByParent( - enumeration.LOCATION_LEVEL_ID_STRATA, + LocationLevelId.SCIENTIFIC_CRUISE_STRATA.getValue(), Integer.valueOf(zoneId), - enumeration.LOCATION_LEVEL_ID_PROGRAM); + LocationLevelId.SCIENTIFIC_CRUISE_PROGRAM.getValue()); return Collections.unmodifiableList(result); } @@ -200,18 +238,18 @@ // use strata as parent parentId = strataId; - parentLocationLevelId = enumeration.LOCATION_LEVEL_ID_STRATA; + parentLocationLevelId = LocationLevelId.SCIENTIFIC_CRUISE_STRATA.getValue(); } else { // use zoneId as parent parentId = zoneId; - parentLocationLevelId = enumeration.LOCATION_LEVEL_ID_PROGRAM; + parentLocationLevelId = LocationLevelId.SCIENTIFIC_CRUISE_PROGRAM.getValue(); } Preconditions.checkNotNull(parentId); List<TuttiLocation> result = getFishingOperationLocationsByParent( - enumeration.LOCATION_LEVEL_ID_SUB_STRATA, + LocationLevelId.SCIENTIFIC_CRUISE_SUB_STRATA.getValue(), Integer.valueOf(parentId), parentLocationLevelId); return Collections.unmodifiableList(result); @@ -229,24 +267,24 @@ // use substrata as parent parentId = subStrataId; - parentLocationLevelId = enumeration.LOCATION_LEVEL_ID_SUB_STRATA; + parentLocationLevelId = LocationLevelId.SCIENTIFIC_CRUISE_SUB_STRATA.getValue(); } else if (strataId != null) { // use strata as parent parentId = strataId; - parentLocationLevelId = enumeration.LOCATION_LEVEL_ID_STRATA; + parentLocationLevelId = LocationLevelId.SCIENTIFIC_CRUISE_STRATA.getValue(); } else { // use zoneId as parent parentId = zoneId; - parentLocationLevelId = enumeration.LOCATION_LEVEL_ID_PROGRAM; + parentLocationLevelId = LocationLevelId.SCIENTIFIC_CRUISE_PROGRAM.getValue(); } Preconditions.checkNotNull(parentId); List<TuttiLocation> result = getFishingOperationLocationsByParent( - enumeration.LOCATION_LEVEL_ID_LOCALITE, + LocationLevelId.SCIENTIFIC_CRUISE_LOCALITE.getValue(), Integer.valueOf(parentId), parentLocationLevelId); return Collections.unmodifiableList(result); @@ -271,7 +309,7 @@ Iterator<Object[]> list = queryListWithStatus( "allVessels", "refDate", DateType.INSTANCE, new Date(), - "vesselTypeId", IntegerType.INSTANCE, enumeration.VESSEL_TYPE_ID_SCIENTIFIC); + "vesselTypeId", IntegerType.INSTANCE, VesselTypeId.SCIENTIFIC_RESEARCH_VESSEL.getValue()); List<Vessel> result = Lists.newArrayList(); Cache vesselByCodeCache = cacheService.getCache("vesselByCode"); @@ -291,7 +329,7 @@ Iterator<Object[]> list = queryListWithStatus( "allVessels", "refDate", DateType.INSTANCE, new Date(), - "vesselTypeId", IntegerType.INSTANCE, enumeration.VESSEL_TYPE_ID_FISHING + "vesselTypeId", IntegerType.INSTANCE, VesselTypeId.FISHING_VESSEL.getValue() ); List<Vessel> result = Lists.newArrayList(); @@ -334,7 +372,7 @@ Iterator<Object[]> sources = queryListWithStatus( "allGears", - "gearClassificiationId", IntegerType.INSTANCE, enumeration.GEAR_CLASSIFICIATION_ID_SCIENTIFIC); + "gearClassificiationId", IntegerType.INSTANCE, GearClassificationId.SCIENTIFIC_CRUISE.getValue()); List<Gear> result = Lists.newArrayList(); while (sources.hasNext()) { Object[] source = sources.next(); @@ -348,7 +386,7 @@ public List<Gear> getAllFishingGear() { Iterator<Object[]> sources = queryListWithStatus( "allGears", - "gearClassificiationId", IntegerType.INSTANCE, enumeration.GEAR_CLASSIFICIATION_ID_FISHING); + "gearClassificiationId", IntegerType.INSTANCE, GearClassificationId.FAO.getValue()); List<Gear> result = Lists.newArrayList(); while (sources.hasNext()) { Object[] source = sources.next(); @@ -362,10 +400,11 @@ public List<Person> getAllPerson() { Iterator<Object[]> list = queryListWithStatus( "allPersons", - "observerProfilId", IntegerType.INSTANCE, enumeration.USER_PROFIL_ID_OBSERVER, - "projectMemberProfilId", IntegerType.INSTANCE, enumeration.USER_PROFIL_ID_PROJECT_MEMBER, - "userProfilId", IntegerType.INSTANCE, enumeration.USER_PROFIL_ID_USER, - "departementPrefixCode", StringType.INSTANCE, enumeration.USER_PROFIL_ID_DEPARTEMENT_PREFIX + "observerProfilId", IntegerType.INSTANCE, UserProfilId.OBSERVER.getValue(), + "projectMemberProfilId", IntegerType.INSTANCE, UserProfilId.PROJECT_MEMBER.getValue(), + "userProfilId", IntegerType.INSTANCE, UserProfilId.USER.getValue(), + "departementPrefixCode", StringType.INSTANCE, "PDG-" //FIXME Use the Departement enum when it will exists in adagio +// "departementPrefixCode", StringType.INSTANCE, enumeration.USER_PROFIL_ID_DEPARTEMENT_PREFIX ); List<Person> result = Lists.newArrayList(); @@ -401,7 +440,7 @@ public List<Species> getAllSpecies() { TaxonRefVO[] sources = taxonNameDao.getAllTaxonNames( - true, enumeration.TRANSCRIBING_TYPE_ID_REFTAX); + true, TranscribingItemTypeId.TAXON_NAME_REFTAX_CODE.getValue()); List<Species> result = Lists.newArrayListWithCapacity(sources.length); List<Species> referenceTaxonsOnly = Lists.newArrayList(); @@ -433,7 +472,7 @@ public List<Species> getAllReferentSpecies() { TaxonRefVO[] sources = taxonNameDao.getAllTaxonNames( - false, enumeration.TRANSCRIBING_TYPE_ID_REFTAX); + false, TranscribingItemTypeId.TAXON_NAME_REFTAX_CODE.getValue()); List<Species> result = Lists.newArrayListWithCapacity(sources.length); Cache referentSpeciesByIdCache = cacheService.getCache("referentSpeciesById"); for (TaxonRefVO source : sources) { @@ -454,7 +493,7 @@ public Species getSpeciesByReferenceTaxonId(Integer referenceTaxonId) { Species result = getSpeciesByReferenceTaxonId( referenceTaxonId, - enumeration.TRANSCRIBING_TYPE_ID_REFTAX); + TranscribingItemTypeId.TAXON_NAME_REFTAX_CODE.getValue()); if (result != null) { result.setRefTaxCode(result.getExternalCode()); } @@ -465,7 +504,7 @@ public Species getSpeciesByReferenceTaxonIdWithVernacularCode(Integer referenceTaxonId) { Species result = getSpeciesByReferenceTaxonId( referenceTaxonId, - enumeration.TRANSCRIBING_TYPE_ID_VERNACULAIRE); + TranscribingItemTypeId.TAXON_NAME_LOCAL_NAME.getValue()); if (result != null) { result.setVernacularCode(result.getExternalCode()); } @@ -506,7 +545,7 @@ protected List<Caracteristic> getAllCaracteristics(boolean withProtected) { Iterator<Object[]> sources = queryListWithStatus( "allPmfm", - "unitIdNone", IntegerType.INSTANCE, enumeration.UNIT_ID_NONE); + "unitIdNone", IntegerType.INSTANCE, UnitId.NONE.getValue()); List<Caracteristic> result = Lists.newArrayList(); Cache pmfmByIdCache = cacheService.getCache("pmfmById"); while (sources.hasNext()) { @@ -514,7 +553,7 @@ Integer pmfmId = (Integer) source[0]; Caracteristic target = loadCaracteristic(source); // Skip some protected PSFM - if (withProtected || !enumeration.isProtectedCaracteristic(pmfmId)) { + if (withProtected || !isProtectedCaracteristic(pmfmId)) { result.add(target); } pmfmByIdCache.put(pmfmId, target); @@ -559,21 +598,21 @@ @Override public Caracteristic getSizeCategoryCaracteristic() { - Integer pmfmId = enumeration.PMFM_ID_SIZE_CATEGORY; + Integer pmfmId = PmfmId2.SIZE_CATEGORY.getValue(); Caracteristic result = getCaracteristic(pmfmId); return result; } @Override public Caracteristic getSexCaracteristic() { - Integer pmfmId = enumeration.PMFM_ID_SEX; + Integer pmfmId = PmfmId2.SEX.getValue(); Caracteristic result = getCaracteristic(pmfmId); return result; } @Override public Caracteristic getSortedUnsortedCaracteristic() { - Integer pmfmId = enumeration.PMFM_ID_SORTED_UNSORTED; + Integer pmfmId = PmfmId2.SORTED_UNSORTED.getValue(); Caracteristic result = thisService.getCaracteristic(pmfmId); // Search the qualitative value to skip @@ -583,7 +622,7 @@ Iterator<CaracteristicQualitativeValue> iterator = qualitativeValue.iterator(); while (iterator.hasNext()) { CaracteristicQualitativeValue qv = iterator.next(); - if (enumeration.QUALITATIVE_UNSORTED_ID.equals(Integer.valueOf(qv.getId()))) { + if (QualitativeValueId.UNSORTED.getValue().equals(Integer.valueOf(qv.getId()))) { iterator.remove(); break; } @@ -594,70 +633,70 @@ @Override public Caracteristic getMaturityCaracteristic() { - Integer pmfmId = enumeration.PMFM_ID_MATURITY; + Integer pmfmId = PmfmId2.MATURITY.getValue(); Caracteristic result = thisService.getCaracteristic(pmfmId); return result; } @Override public Caracteristic getAgeCaracteristic() { - Integer pmfmId = enumeration.PMFM_ID_AGE; + Integer pmfmId = PmfmId2.AGE.getValue(); Caracteristic result = thisService.getCaracteristic(pmfmId); return result; } @Override public Caracteristic getMarineLitterCategoryCaracteristic() { - Integer pmfmId = enumeration.PMFM_ID_MARINE_LITTER_TYPE; + Integer pmfmId = PmfmId2.MARINE_LITTER_TYPE.getValue(); Caracteristic result = thisService.getCaracteristic(pmfmId); return result; } @Override public Caracteristic getMarineLitterSizeCategoryCaracteristic() { - Integer pmfmId = enumeration.PMFM_ID_MARINE_LITTER_SIZE_CATEGORY; + Integer pmfmId = PmfmId2.MARINE_LITTER_SIZE_CATEGORY.getValue(); Caracteristic result = thisService.getCaracteristic(pmfmId); return result; } @Override public Caracteristic getVerticalOpeningCaracteristic() { - Integer pmfmId = enumeration.PMFM_ID_VERTICAL_OPENING; + Integer pmfmId = PmfmId2.VERTICAL_OPENING.getValue(); Caracteristic result = thisService.getCaracteristic(pmfmId); return result; } @Override public Caracteristic getHorizontalOpeningWingsCaracteristic() { - Integer pmfmId = enumeration.PMFM_ID_HORIZONTAL_OPENING_WINGS; + Integer pmfmId = PmfmId2.HORIZONTAL_OPENING_WINGS.getValue(); Caracteristic result = thisService.getCaracteristic(pmfmId); return result; } @Override public Caracteristic getHorizontalOpeningDoorCaracteristic() { - Integer pmfmId = enumeration.PMFM_ID_HORIZONTAL_OPENING_DOOR; + Integer pmfmId = PmfmId2.HORIZONTAL_OPENING_DOOR.getValue(); Caracteristic result = thisService.getCaracteristic(pmfmId); return result; } @Override public Caracteristic getDeadOrAliveCaracteristic() { - Integer pmfmId = enumeration.PMFM_ID_DEAD_OR_ALIVE; + Integer pmfmId = PmfmId2.DEAD_OR_ALIVE.getValue(); Caracteristic result = thisService.getCaracteristic(pmfmId); return result; } @Override public Caracteristic getPmfmIdCaracteristic() { - Integer pmfmId = enumeration.PMFM_ID_ID_PSFM; + Integer pmfmId = PmfmId2.ID_PSFM.getValue(); Caracteristic result = thisService.getCaracteristic(pmfmId); return result; } @Override public Caracteristic getWeightMeasuredCaracteristic() { - Integer pmfmId = enumeration.PMFM_ID_WEIGHT_MEASURED; + Integer pmfmId = PmfmId2.WEIGHT_MEASURED.getValue(); Caracteristic result = thisService.getCaracteristic(pmfmId); return result; } @@ -666,7 +705,7 @@ public boolean isTemporary(TuttiReferentialEntity entity) { Preconditions.checkNotNull(entity); Preconditions.checkNotNull(entity.getStatus()); - return enumeration.STATUS_TEMPORARY_CODE.equals( + return StatusCode.TEMPORARY.getValue().equals( entity.getStatus().getId()); } @@ -674,7 +713,7 @@ public Caracteristic getCaracteristic(Integer pmfmId) { Object[] source = queryUniqueWithStatus("pmfmById", "pmfmId", IntegerType.INSTANCE, pmfmId, - "unitIdNone", IntegerType.INSTANCE, enumeration.UNIT_ID_NONE); + "unitIdNone", IntegerType.INSTANCE, UnitId.NONE.getValue()); Caracteristic target = loadCaracteristic(source); return target; } @@ -704,13 +743,13 @@ List<Vessel> result = Lists.newArrayList(); fr.ifremer.adagio.core.dao.referential.Status status = - statusDao.load(enumeration.STATUS_TEMPORARY_CODE); + statusDao.load(StatusCode.TEMPORARY.getValue()); Integer countryLocationId = locationDao.getLocationIdByLabelAndLocationLevel( - enumeration.LOCATION_LABEL_DEFAULT_COUNTRY, - new Integer[]{enumeration.LOCATION_LEVEL_ID_COUNTRY}); + LocationLabel.FRANCE.getValue(), + new Integer[]{LocationLevelId.PAYS_ISO3.getValue()}); if (countryLocationId == null) { - throw new DataIntegrityViolationException("Default country location not found, with label=" + enumeration.LOCATION_LABEL_DEFAULT_COUNTRY); + throw new DataIntegrityViolationException("Default country location not found, with label=" + LocationLabel.FRANCE.getValue()); } for (Vessel source : vessels) { @@ -725,7 +764,7 @@ List<Person> result = Lists.newArrayList(); fr.ifremer.adagio.core.dao.referential.Status status = - statusDao.load(enumeration.STATUS_TEMPORARY_CODE); + statusDao.load(StatusCode.TEMPORARY.getValue()); for (Person source : persons) { source = importTemporaryPerson(source, status); result.add(source); @@ -738,7 +777,7 @@ List<Gear> result = Lists.newArrayList(); fr.ifremer.adagio.core.dao.referential.Status status = - statusDao.load(enumeration.STATUS_TEMPORARY_CODE); + statusDao.load(StatusCode.TEMPORARY.getValue()); for (Gear source : gears) { source = importTemporaryGear(source, status); result.add(source); @@ -762,9 +801,9 @@ Integer vesselTypeId; if (source.isScientificVessel()) { - vesselTypeId = enumeration.VESSEL_TYPE_ID_SCIENTIFIC; + vesselTypeId = VesselTypeId.SCIENTIFIC_RESEARCH_VESSEL.getValue(); } else { - vesselTypeId = enumeration.VESSEL_TYPE_ID_FISHING; + vesselTypeId = VesselTypeId.FISHING_VESSEL.getValue(); } fr.ifremer.adagio.core.dao.data.vessel.Vessel target = @@ -791,7 +830,7 @@ Preconditions.checkNotNull(source.getFirstName()); Preconditions.checkNotNull(source.getLastName()); - fr.ifremer.adagio.core.dao.administration.user.Person target = personDao.createAsTemporary(source.getLastName(), source.getFirstName(), enumeration.DEPARTMENT_ID_UNKNOWN_RECORDER_DEPARTMENT); + fr.ifremer.adagio.core.dao.administration.user.Person target = personDao.createAsTemporary(source.getLastName(), source.getFirstName(), DepartmentId.UNKOWN_RECODER_DEPARTMENT.getValue()); // Fill the result bean Person result = Persons.newPerson(); @@ -830,9 +869,9 @@ Integer gearClassificationId; if (source.isScientificGear()) { - gearClassificationId = enumeration.GEAR_CLASSIFICIATION_ID_SCIENTIFIC; + gearClassificationId = GearClassificationId.SCIENTIFIC_CRUISE.getValue(); } else { - gearClassificationId = enumeration.GEAR_CLASSIFICIATION_ID_FISHING; + gearClassificationId = GearClassificationId.FAO.getValue(); } fr.ifremer.adagio.core.dao.referential.gear.Gear target = fishingGearDao.createAsTemporary(source.getLabel(), source.getName(), gearClassificationId); @@ -852,7 +891,7 @@ "allFishingOperationLocationByParent", "parentId", IntegerType.INSTANCE, parentId, "parentLocationLevelId", IntegerType.INSTANCE, parentLocationLevelId, - "locationClassificationId", IntegerType.INSTANCE, enumeration.LOCATION_CLASSIFICATION_ID_SECTOR, + "locationClassificationId", IntegerType.INSTANCE, LocationClassificationId.SECTOR.getValue(), "locationLevelId", IntegerType.INSTANCE, locationLevelId ); List<TuttiLocation> result = Lists.newArrayList(); @@ -957,7 +996,7 @@ GearClassification classification = (GearClassification) source[3]; boolean scientific = false; if (classification != null) { - scientific = classification.getId().equals(enumeration.GEAR_CLASSIFICIATION_ID_SCIENTIFIC); + scientific = classification.getId().equals(GearClassificationId.SCIENTIFIC_CRUISE.getValue()); } result.setScientificGear(scientific); @@ -977,8 +1016,8 @@ protected Iterator<Object[]> queryListWithStatus(String queryName, Object... params) { Query query = createQuery(queryName, params); - query.setString("statusValidCode", enumeration.STATUS_VALID_CODE); - query.setString("statusTemporaryCode", enumeration.STATUS_TEMPORARY_CODE); + query.setString("statusValidCode", StatusCode.ENABLE.getValue()); + query.setString("statusTemporaryCode", StatusCode.TEMPORARY.getValue()); Iterator<Object[]> result = query.iterate(); return result; @@ -987,8 +1026,8 @@ protected Object[] queryUniqueWithStatus(String queryName, Object... params) { Query query = createQuery(queryName, params); - query.setString("statusValidCode", enumeration.STATUS_VALID_CODE); - query.setString("statusTemporaryCode", enumeration.STATUS_TEMPORARY_CODE); + query.setString("statusValidCode", StatusCode.ENABLE.getValue()); + query.setString("statusTemporaryCode", StatusCode.TEMPORARY.getValue()); Object result = query.uniqueResult(); return (Object[]) result; Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceImpl.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceImpl.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -35,7 +35,9 @@ import fr.ifremer.adagio.core.dao.data.measure.QuantificationMeasurement; import fr.ifremer.adagio.core.dao.data.measure.SortingMeasurement; import fr.ifremer.adagio.core.dao.referential.QualityFlag; +import fr.ifremer.adagio.core.dao.referential.QualityFlagCode; import fr.ifremer.adagio.core.dao.referential.QualityFlagImpl; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; import fr.ifremer.adagio.core.dao.referential.taxon.ReferenceTaxon; import fr.ifremer.adagio.core.dao.referential.taxon.ReferenceTaxonImpl; import fr.ifremer.tutti.persistence.InvalidBatchModelException; @@ -452,7 +454,7 @@ } QualityFlag qualityFlag = source.getQualityFlag(); - target.setSpeciesToConfirm(qualityFlag != null && enumeration.QUALITY_FLAG_CODE_DOUBTFUL.equals(qualityFlag.getCode())); + target.setSpeciesToConfirm(qualityFlag != null && QualityFlagCode.DOUBTFUL.getValue().equals(qualityFlag.getCode())); return target; } @@ -556,7 +558,7 @@ if (source.getSampleCategoryId() != null && source.getSampleCategoryValue() != null) { Integer pmfmId = source.getSampleCategoryId(); // Do not store sorting measurement if pmfm = SORTED (already store in an ancestor batch) - if (!pmfmId.equals(enumeration.PMFM_ID_SORTED_UNSORTED)) { + if (!pmfmId.equals(PmfmId2.SORTED_UNSORTED.getValue())) { SortingMeasurement sortingMeasurement = measurementPersistenceHelper.setSortingMeasurement( target, pmfmId, @@ -580,9 +582,9 @@ // QualityFlag String qualityFlag; if (source.isSpeciesToConfirm()) { - qualityFlag = enumeration.QUALITY_FLAG_CODE_DOUBTFUL; + qualityFlag = QualityFlagCode.DOUBTFUL.getValue(); } else { - qualityFlag = enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED; + qualityFlag = QualityFlagCode.NOTQUALIFIED.getValue(); } target.setQualityFlag(load(QualityFlagImpl.class, qualityFlag)); Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceService.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceService.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceService.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -18,20 +18,12 @@ public interface TechnicalPersistenceService extends TuttiPersistenceServiceImplementor { /** - * @return the enumeration file (where all constant mapping are defined). - * @since 2.4 - */ - TuttiEnumerationFile getEnumerationFile(); - - /** * To clear all caches. * * @since 1.0.1 */ void clearAllCaches(); - void clearCache(String cacheName); - /** * To invoke the given call code. * <p/> Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceServiceImpl.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceServiceImpl.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TechnicalPersistenceServiceImpl.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -5,14 +5,11 @@ import fr.ifremer.adagio.core.dao.technical.VersionNotFoundException; import fr.ifremer.adagio.core.service.technical.CacheService; import fr.ifremer.adagio.core.service.technical.sanity.DatabaseSanityService; -import net.sf.ehcache.Ehcache; -import net.sf.ehcache.Status; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.nuiton.jaxx.application.ApplicationTechnicalException; import org.nuiton.util.Version; import org.nuiton.util.VersionUtil; -import org.springframework.cache.Cache; import org.springframework.stereotype.Service; import javax.annotation.Resource; @@ -40,11 +37,6 @@ protected DatabaseSchemaDao databaseSchemaDao; @Override - public TuttiEnumerationFile getEnumerationFile() { - return enumeration; - } - - @Override public <V> V invoke(Callable<V> call) { try { @@ -101,14 +93,4 @@ cacheService.clearAllCaches(); } - @Override - public void clearCache(String cacheName) { - Cache cache = cacheService.getCache(cacheName); - if (cache != null) { - Ehcache nativeCache = (Ehcache) cache.getNativeCache(); - if (Status.STATUS_ALIVE.equals(nativeCache.getStatus())) { - cacheService.clearCache(cacheName); - } - } - } } Deleted: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFile.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFile.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFile.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -1,373 +0,0 @@ -package fr.ifremer.tutti.persistence.service; - -/* - * #%L - * Tutti :: Persistence API - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2012 - 2013 Ifremer - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/gpl-3.0.html>. - * #L% - */ - -import com.google.common.base.Preconditions; -import com.google.common.collect.Maps; -import com.google.common.collect.Sets; -import fr.ifremer.tutti.persistence.entities.TuttiEnumerable; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; -import org.springframework.beans.factory.annotation.Value; -import org.springframework.util.ReflectionUtils; - -import java.lang.reflect.Field; -import java.util.Map; -import java.util.Set; - -/** - * Contains all constants usable via the enumeration file. - * - * @author tchemit <chemit@codelutin.com> - * @since 0.3 - */ -public class TuttiEnumerationFile { - - @Value("${adagio.enumeration.GearClassificationId.SCIENTIFIC_CRUISE}") - public final Integer GEAR_CLASSIFICIATION_ID_SCIENTIFIC = null; - - @Value("${adagio.enumeration.GearClassificationId.FAO}") - public final Integer GEAR_CLASSIFICIATION_ID_FISHING = null; - - @Value("${adagio.enumeration.LocationClassificationId.TERRITORIAL}") - public final Integer LOCATION_CLASSIFICATION_ID_TERRITORIAL = null; - - @Value("${adagio.enumeration.LocationClassificationId.SECTOR}") - public final Integer LOCATION_CLASSIFICATION_ID_SECTOR = null; - - @Value("${adagio.enumeration.LocationLabel.FRANCE}") - public final String LOCATION_LABEL_DEFAULT_COUNTRY = null; - - @Value("${adagio.enumeration.LocationLevelId.PAYS_ISO3}") - public final Integer LOCATION_LEVEL_ID_COUNTRY = null; - - @Value("${adagio.enumeration.LocationLevelId.PORT}") - public final Integer LOCATION_LEVEL_ID_HARBOUR = null; - - @Value("${adagio.enumeration.LocationLevelId.SCIENTIFIC_CRUISE_LOCALITE}") - public final Integer LOCATION_LEVEL_ID_LOCALITE = null; - - @Value("${adagio.enumeration.LocationLevelId.SCIENTIFIC_CRUISE_PROGRAM}") - public final Integer LOCATION_LEVEL_ID_PROGRAM = null; - - @Value("${adagio.enumeration.LocationLevelId.SCIENTIFIC_CRUISE_STRATA}") - public final Integer LOCATION_LEVEL_ID_STRATA = null; - - @Value("${adagio.enumeration.LocationLevelId.SCIENTIFIC_CRUISE_SUB_STRATA}") - public final Integer LOCATION_LEVEL_ID_SUB_STRATA = null; - - @Value("${adagio.enumeration.ParameterCode.AGE}") - public final String PARAMETER_CODE_AGE = null; - - @Value("${adagio.enumeration.ParameterCode.WEIGHT}") - public final String PARAMETER_CODE_WEIGHT = null; - - @Value("${adagio.enumeration.PmfmId.SIZE_CATEGORY}") - public final Integer PMFM_ID_SIZE_CATEGORY = null; - - @Value("${adagio.enumeration.PmfmId.SEX}") - public final Integer PMFM_ID_SEX = null; - - @Value("${adagio.enumeration.PmfmId.SORTED_UNSORTED}") - public final Integer PMFM_ID_SORTED_UNSORTED = null; - - @Value("${adagio.enumeration.PmfmId.MATURITY}") - public final Integer PMFM_ID_MATURITY = null; - - @Value("${adagio.enumeration.PmfmId.MARINE_LITTER_TYPE}") - public final Integer PMFM_ID_MARINE_LITTER_TYPE = null; - - @Value("${adagio.enumeration.PmfmId.MARINE_LITTER_SIZE_CATEGORY}") - public final Integer PMFM_ID_MARINE_LITTER_SIZE_CATEGORY = null; - - @Value("${adagio.enumeration.PmfmId.SCIENTIFIC_CRUISE_SORTING_TYPE}") - public final Integer PMFM_ID_SORTING_TYPE = null; - - @Value("${adagio.enumeration.PmfmId.SCIENTIFIC_CRUISE_SORTING_TYPE_2}") - public final Integer PMFM_ID_SORTING_TYPE_2 = null; - - @Value("${adagio.enumeration.UnitId.NONE}") - public final Integer UNIT_ID_NONE = null; - - @Value("${adagio.enumeration.UserProfilId.OBSERVER}") - public final Integer USER_PROFIL_ID_OBSERVER = null; - - @Value("${adagio.enumeration.UserProfilId.PROJECT_MEMBER}") - public final Integer USER_PROFIL_ID_PROJECT_MEMBER = null; - - @Value("${adagio.enumeration.UserProfilId.USER}") - public final Integer USER_PROFIL_ID_USER = null; - - @Value("${adagio.enumeration.UserProfilId.DEPARTEMENT_PREFIX}") - public final String USER_PROFIL_ID_DEPARTEMENT_PREFIX = null; - - @Value("${adagio.enumeration.VesselTypeId.SCIENTIFIC_RESEARCH_VESSEL}") - public final Integer VESSEL_TYPE_ID_SCIENTIFIC = null; - - @Value("${adagio.enumeration.VesselTypeId.FISHING_VESSEL}") - public final Integer VESSEL_TYPE_ID_FISHING = null; - -// @Value("${adagio.enumeration.LocationLevelId.RECTANGLE_STATISTIQUE_MED}") -// public final Integer RECTANGLE_STATISTIQUE_MED = null; - - @Value("${adagio.enumeration.LocationLevelId.RECTANGLE_STATISTIQUE}") - public final Integer RECTANGLE_STATISTIQUE = null; - - @Value("${adagio.enumeration.QualitativeValueId.SORTED_VRAC}") - public final Integer QUALITATIVE_VRAC_ID = null; - - @Value("${adagio.enumeration.QualitativeValueId.SORTED_HORS_VRAC}") - public final Integer QUALITATIVE_HORS_VRAC_ID = null; - - @Value("${adagio.enumeration.QualitativeValueId.UNSORTED}") - public final Integer QUALITATIVE_UNSORTED_ID = null; - - @Value("${adagio.enumeration.QualitativeValueId.SEX_MALE}") - public final Integer QUALITATIVE_SEX_MALE_ID = null; - - @Value("${adagio.enumeration.QualitativeValueId.SEX_FEMALE}") - public final Integer QUALITATIVE_SEX_FEMALE_ID = null; - - @Value("${adagio.enumeration.QualitativeValueId.SEX_UNDEFINED}") - public final Integer QUALITATIVE_SEX_UNDEFINED_ID = null; - - @Value("${adagio.enumeration.QualitativeValueId.MATURITY_1}") - public final Integer QUALITATIVE_MATURITY_1_ID = null; - - @Value("${adagio.enumeration.QualitativeValueId.MATURITY_2}") - public final Integer QUALITATIVE_MATURITY_2_ID = null; - - @Value("${adagio.enumeration.QualitativeValueId.MATURITY_3}") - public final Integer QUALITATIVE_MATURITY_3_ID = null; - - @Value("${adagio.enumeration.QualitativeValueId.MATURITY_4}") - public final Integer QUALITATIVE_MATURITY_4_ID = null; - - @Value("${adagio.enumeration.QualitativeValueId.MATURITY_5}") - public final Integer QUALITATIVE_MATURITY_5_ID = null; - - @Value("${adagio.enumeration.QualitativeValueId.SIZE_SMALL}") - public final Integer QUALITATIVE_SIZE_SMALL_ID = null; - - @Value("${adagio.enumeration.QualitativeValueId.SIZE_MEDIUM}") - public final Integer QUALITATIVE_SIZE_MEDIUM_ID = null; - - @Value("${adagio.enumeration.QualitativeValueId.SIZE_BIG}") - public final Integer QUALITATIVE_SIZE_BIG_ID = null; - - @Value("${adagio.enumeration.QualitativeValueId.SORTING_TYPE_SPECIES}") - public final Integer QUALITATIVE_ID_SORTING_TYPE_SPECIES = null; - - @Value("${adagio.enumeration.QualitativeValueId.SORTING_TYPE_BENTHOS}") - public final Integer QUALITATIVE_ID_SORTING_TYPE_BENTHOS = null; - - @Value("${adagio.enumeration.QualitativeValueId.SORTING_TYPE_MARINE_LITTER}") - public final Integer QUALITATIVE_ID_SORTING_TYPE_MARINE_LITTER = null; - - @Value("${adagio.enumeration.QualitativeValueId.SORTING_TYPE_2_ALIVE_NOT_ITEMIZED}") - public final Integer QUALITATIVE_ID_SORTING_TYPE_2_ALIVE_NOT_ITEMIZED = null; - - @Value("${adagio.enumeration.QualitativeValueId.SORTING_TYPE_2_INERT}") - public final Integer QUALITATIVE_ID_SORTING_TYPE_2_INERT = null; - - @Value("${adagio.enumeration.QualitativeValueId.SORTING_TYPE_2_ALIVE_ITEMIZED}") - public final Integer QUALITATIVE_ID_SORTING_TYPE_2_ALIVE_ITEMIZED = null; - - @Value("${adagio.enumeration.StatusCode.ENABLE}") - public final String STATUS_VALID_CODE = null; - - @Value("${adagio.enumeration.StatusCode.TEMPORARY}") - public final String STATUS_TEMPORARY_CODE = null; - - @Value("${adagio.enumeration.PersonId.UNKNOWN_RECORDER_PERSON}") - public final Integer PERSON_ID_UNKNOWN_RECORDER_PERSON = null; - - @Value("${adagio.enumeration.QualityFlagCode.NOTQUALIFIED}") - public final String QUALITY_FLAG_CODE_NOT_QUALIFIED = null; - - @Value("${adagio.enumeration.QualityFlagCode.DOUBTFUL}") - public final String QUALITY_FLAG_CODE_DOUBTFUL = null; - - @Value("${adagio.enumeration.PmfmId.STATION_NUMBER}") - public final Integer PMFM_ID_STATION_NUMBER = null; - - @Value("${adagio.enumeration.PmfmId.TRAWL_DISTANCE}") - public final Integer PMFM_ID_TRAWL_DISTANCE = null; - - @Value("${adagio.enumeration.PmfmId.RECTILINEAR_OPERATION}") - public final Integer PMFM_ID_RECTILINEAR_OPERATION = null; - - @Value("${adagio.enumeration.QualitativeValueId.RECTILINEAR_OPERATION_YES}") - public final Integer QUALITATIVE_RECTILINEAR_OPERATION_YES = null; - - @Value("${adagio.enumeration.QualitativeValueId.RECTILINEAR_OPERATION_NO}") - public final Integer QUALITATIVE_RECTILINEAR_OPERATION_NO = null; - - @Value("${adagio.enumeration.PmfmId.HAUL_VALID}") - public final Integer PMFM_ID_HAUL_VALID = null; - - @Value("${adagio.enumeration.QualitativeValueId.HAUL_VALID_YES}") - public final Integer QUALITATIVE_HAUL_VALID_YES = null; - - @Value("${adagio.enumeration.QualitativeValueId.HAUL_VALID_NO}") - public final Integer QUALITATIVE_HAUL_VALID_NO = null; - - @Value("${adagio.enumeration.PmfmId.MULTIRIG_NUMBER}") - public final Integer PMFM_ID_MULTIRIG_NUMBER = null; - - @Value("${adagio.enumeration.PmfmId.MULTIRIG_AGGREGATION}") - public final Integer PMFM_ID_MULTIRIG_AGGREGATION = null; - - @Value("${adagio.enumeration.PmfmId.WEIGHT_MEASURED}") - public final Integer PMFM_ID_WEIGHT_MEASURED = null; - - @Value("${adagio.enumeration.DepartmentId.UNKNOWN_RECORDER_DEPARTMENT}") - public final Integer DEPARTMENT_ID_UNKNOWN_RECORDER_DEPARTMENT = null; - - @Value("${adagio.enumeration.PmfmId.AGE}") - public final Integer PMFM_ID_AGE = null; - - @Value("${adagio.enumeration.PmfmId.SURVEY_PART}") - public final Integer PMFM_ID_SURVEY_PART = null; - - @Value("${adagio.enumeration.PmfmId.VERTICAL_OPENING}") - public final Integer PMFM_ID_VERTICAL_OPENING = null; - - @Value("${adagio.enumeration.PmfmId.HORIZONTAL_OPENING_WINGS}") - public final Integer PMFM_ID_HORIZONTAL_OPENING_WINGS = null; - - @Value("${adagio.enumeration.PmfmId.HORIZONTAL_OPENING_DOOR}") - public final Integer PMFM_ID_HORIZONTAL_OPENING_DOOR = null; - - @Value("${adagio.enumeration.PmfmId.DEAD_OR_ALIVE}") - public final Integer PMFM_ID_DEAD_OR_ALIVE = null; - - @Value("${adagio.enumeration.ProgramCode.SCIENTIFIC_CRUISE_PREFIX}") - public final String PROGRAM_CODE_SCIENTIFIC_CRUISE_PREFIX = null; - - @Value("${adagio.enumeration.TaxonGroupTypeCode.COMMERCIAL_SPECIES}") - public final String TAXON_GROUP_TYPE_ID_COMMERCIAL_SPECIES = null; - - @Value("${adagio.enumeration.ObjectTypeCode.SCIENTIFIC_CRUISE}") - public final String OBJECT_TYPE_SCIENTIFIC_CRUISE = null; - - @Value("${adagio.enumeration.ObjectTypeCode.CATCH_BATCH}") - public final String OBJECT_TYPE_CATCH_BATCH = null; - - @Value("${adagio.enumeration.ObjectTypeCode.BATCH}") - public final String OBJECT_TYPE_BATCH = null; - - @Value("${adagio.enumeration.ObjectTypeCode.OPERATION}") - public final String OBJECT_TYPE_OPERATION = null; - - @Value("${adagio.enumeration.ObjectTypeCode.SAMPLE}") - public final String OBJECT_TYPE_SAMPLE = null; - - @Value("${adagio.enumeration.VesselPersonRoleId.SCIENTIFIC_CRUISE_MANAGER}") - public final Integer VESSEL_PERSON_ROLE_ID_SCIENTIFIC_CRUISE_MANAGER = null; - - @Value("${adagio.enumeration.VesselPersonRoleId.SORT_ROOM_MANAGER}") - public final Integer VESSEL_PERSON_ROLE_ID_SORT_ROOM_MANAGER = null; - - @Value("${adagio.enumeration.VesselPersonRoleId.RECORDER_PERSON}") - public final Integer VESSEL_PERSON_ROLE_ID_RECORDER_PERSON = null; - - @Value("${adagio.enumeration.TranscribingTypeId.TAXINOMIE_REFTAX_MNEMONIQUE}") - public final Integer TRANSCRIBING_TYPE_ID_REFTAX = null; - - @Value("${adagio.enumeration.TranscribingTypeId.TAXINOMIE_COMMUN_NOM_VERNACULAIRE}") - public final Integer TRANSCRIBING_TYPE_ID_VERNACULAIRE = null; - - @Value("${adagio.enumeration.MatrixId.PRODUCT_BATCH}") - public final Integer MATRIX_ID_PRODUCT_BATCH = null; - - @Value("${adagio.enumeration.PmfmId.ID_PSFM}") - public final Integer PMFM_ID_ID_PSFM = null; - - protected Set<Integer> propertedPmfmIds; - - public void init() { - - Map<String, Object> annotatedFieldValues = Maps.newTreeMap(); - - Field[] declaredFields = getClass().getDeclaredFields(); - for (Field declaredField : declaredFields) { - Value annotation = declaredField.getAnnotation(Value.class); - if (annotation != null) { - - // check on that field that his value is here - Object fieldValue = ReflectionUtils.getField(declaredField, this); - String fieldName = declaredField.getName(); - Preconditions.checkNotNull( - fieldValue, - annotation.value() + " constant not found (field " + - fieldName + ")"); - annotatedFieldValues.put(fieldName, fieldValue); - } - } - - // init enums - initEnum(AttachementObjectTypeEnum.class, annotatedFieldValues); - - //FIXME Should also add the one from sample category model ? - // init protected pmfm ids - propertedPmfmIds = Sets.newHashSet( - PMFM_ID_MULTIRIG_AGGREGATION, - PMFM_ID_MULTIRIG_NUMBER, - PMFM_ID_STATION_NUMBER, - PMFM_ID_RECTILINEAR_OPERATION, - PMFM_ID_HAUL_VALID, - PMFM_ID_TRAWL_DISTANCE, - PMFM_ID_SURVEY_PART, - PMFM_ID_SORTED_UNSORTED, - PMFM_ID_ID_PSFM - ); - } - - /** - * @param pmfmId id of pmfm to test - * @return {@code true} if the pmfm should NOT be used for caracteristics lists - * (i.e. because used somewhere when storing some properties into the database) - */ - public boolean isProtectedCaracteristic(Integer pmfmId) { - return propertedPmfmIds.contains(pmfmId); - } - - protected <O, E extends Enum<E> & TuttiEnumerable<O>> void initEnum( - Class<E> enumType, - Map<String, Object> annotatedFieldValues) { - for (E e : enumType.getEnumConstants()) { - if (!e.isInit()) { - String fieldName = e.getFieldName(); - Object field = annotatedFieldValues.get(fieldName); - Preconditions.checkNotNull( - field, - "Could not find field " + fieldName + ")"); - e.setFieldValue((O) field); - e.setInit(true); - } - - } - } -} Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiPersistenceServiceLocator.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiPersistenceServiceLocator.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/TuttiPersistenceServiceLocator.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -51,11 +51,6 @@ instance().init(beanFactoryReferenceLocation, beanRefFactoryReferenceId); } - public static TuttiEnumerationFile getTuttiEnumerationFile() { - return instance().getService("tuttiEnumerationFile", - TuttiEnumerationFile.class); - } - public static TuttiPersistence getPersistenceService() { return getPersistenceService("tuttiPersistence", TuttiPersistence.class); Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/BatchPersistenceHelper.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/BatchPersistenceHelper.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/BatchPersistenceHelper.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -27,6 +27,7 @@ import com.google.common.base.Joiner; import com.google.common.base.Preconditions; import com.google.common.collect.Lists; +import fr.ifremer.adagio.core.dao.administration.user.DepartmentId; import fr.ifremer.adagio.core.dao.data.batch.Batch; import fr.ifremer.adagio.core.dao.data.batch.CatchBatch; import fr.ifremer.adagio.core.dao.data.batch.CatchBatchExtendDao; @@ -35,10 +36,12 @@ import fr.ifremer.adagio.core.dao.data.batch.validator.CatchBatchValidationError; import fr.ifremer.adagio.core.dao.data.batch.validator.CatchBatchValidationException; import fr.ifremer.adagio.core.dao.data.measure.SortingMeasurement; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.adagio.core.dao.referential.pmfm.Pmfm; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId; import fr.ifremer.tutti.persistence.InvalidBatchModelException; import fr.ifremer.tutti.persistence.entities.TuttiEntity; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; import fr.ifremer.tutti.persistence.entities.data.BenthosBatch; import fr.ifremer.tutti.persistence.entities.data.SampleCategoryModel; @@ -168,7 +171,7 @@ getCurrentSession().flush(); attachmentPersistenceService.deleteAllAttachment( - AttachementObjectTypeEnum.BATCH, + ObjectTypeCode2.BATCH, ids.toArray(new Integer[ids.size()])); } @@ -184,7 +187,7 @@ catchBatchDao.removeWithChildren(batchId); attachmentPersistenceService.deleteAllAttachment( - AttachementObjectTypeEnum.BATCH, + ObjectTypeCode2.BATCH, ids.toArray(new Integer[ids.size()])); } @@ -194,7 +197,7 @@ catchBatchDao.removeWithChildren(batchId, parentCatchBatch); attachmentPersistenceService.deleteAllAttachment( - AttachementObjectTypeEnum.BATCH, + ObjectTypeCode2.BATCH, ids.toArray(new Integer[ids.size()])); } @@ -315,16 +318,16 @@ // Or retrieve parent batch, from pmfm id // Retrieve category type - if (!sampleCategoryId.equals(enumeration.PMFM_ID_SORTED_UNSORTED)) { + if (!sampleCategoryId.equals(PmfmId2.SORTED_UNSORTED.getValue())) { throw new DataIntegrityViolationException(MessageFormat.format( "A species or benthos batch with no parent should have a sampleCategoryType {0} (PMFM.ID={1})", sampleCategoryId, - enumeration.PMFM_ID_SORTED_UNSORTED)); + PmfmId2.SORTED_UNSORTED.getValue())); } Integer qualitativeValueId = convertSampleCategoryValueIntoQualitativeId(sampleCategoryValue); - if (enumeration.QUALITATIVE_VRAC_ID.equals(qualitativeValueId)) { + if (QualitativeValueId.SORTED_VRAC.getValue().equals(qualitativeValueId)) { // -- Vrac > Species > Alive itemized parentBatch = batchTreeHelper.getSpeciesVracAliveItemizedRootBatch(catchBatch); @@ -349,7 +352,7 @@ parentBatch = batchTreeHelper.getOrCreateSpeciesVracAliveItemizedRootBatch(catchBatch, vracSpeciesBatch); } - } else if (enumeration.QUALITATIVE_HORS_VRAC_ID.equals(qualitativeValueId)) { + } else if (QualitativeValueId.SORTED_HORS_VRAC.getValue().equals(qualitativeValueId)) { // -- Hors Vrac > Species parentBatch = batchTreeHelper.getSpeciesHorsVracRootBatch(catchBatch); @@ -394,16 +397,16 @@ // Or retrieve parent batch, from pmfm id // Retrieve category type - if (!sampleCategoryType.equals(enumeration.PMFM_ID_SORTED_UNSORTED)) { + if (!sampleCategoryType.equals(PmfmId2.SORTED_UNSORTED.getValue())) { throw new DataIntegrityViolationException(MessageFormat.format( "A species or benthos batch with no parent should have a sampleCategoryType {0} (PMFM.ID={1})", sampleCategoryType, - enumeration.PMFM_ID_SORTED_UNSORTED)); + PmfmId2.SORTED_UNSORTED.getValue())); } Integer qualitativeValueId = convertSampleCategoryValueIntoQualitativeId(sampleCategoryValue); - if (enumeration.QUALITATIVE_VRAC_ID.equals(qualitativeValueId)) { + if (QualitativeValueId.SORTED_VRAC.getValue().equals(qualitativeValueId)) { // -- Vrac > Benthos > Alive Itemized parentBatch = batchTreeHelper.getBenthosVracAliveItemizedRootBatch(catchBatch); @@ -428,7 +431,7 @@ parentBatch = batchTreeHelper.getOrCreateBenthosVracAliveItemizedRootBatch(catchBatch, vracBenthosBatch); } - } else if (enumeration.QUALITATIVE_HORS_VRAC_ID.equals(qualitativeValueId)) { + } else if (QualitativeValueId.SORTED_HORS_VRAC.getValue().equals(qualitativeValueId)) { // -- Hors Vrac > Benthos parentBatch = batchTreeHelper.getBenthosHorsVracRootBatch(catchBatch); @@ -512,6 +515,9 @@ } } +// protected Integer getSortingTypeId() { +// return Integer.valueOf(PmfmId2.SCIENTIFIC_CRUISE_SORTING_TYPE.getValue()); +// } public <S extends SpeciesAbleBatch> void setSampleCategoryQualitative(S target, Integer pmfmId, @@ -519,7 +525,7 @@ String alphanumericalValue, Integer qualitativeValueId) { // skip if null or corresponding to the SORTING_TYPE PMFM (Espèce, Benthos, Plancton, etc.) - if (pmfmId == null || pmfmId.equals(enumeration.PMFM_ID_SORTING_TYPE)) { + if (pmfmId == null || pmfmId.equals(BatchTreeHelper.SORTING_TYPE_ID)) { return; } SampleCategoryModel sampleCategoryModel = getSampleCategoryModel(); @@ -593,7 +599,7 @@ protected Integer getRecorderDepartmentId() { // TODO BL : voir si on peut récupérer le departement (du 1er saisisseur ?) - return enumeration.DEPARTMENT_ID_UNKNOWN_RECORDER_DEPARTMENT; + return DepartmentId.UNKOWN_RECODER_DEPARTMENT.getValue(); } /** Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/BatchTreeHelper.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/BatchTreeHelper.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/BatchTreeHelper.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -9,7 +9,10 @@ import fr.ifremer.adagio.core.dao.data.batch.SortingBatch; import fr.ifremer.adagio.core.dao.data.measure.QuantificationMeasurement; import fr.ifremer.adagio.core.dao.data.measure.SortingMeasurement; +import fr.ifremer.adagio.core.dao.referential.QualityFlagCode; import fr.ifremer.adagio.core.dao.referential.QualityFlagImpl; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId; import fr.ifremer.adagio.core.dao.referential.taxon.ReferenceTaxon; import fr.ifremer.adagio.core.dao.referential.taxon.ReferenceTaxonImpl; import fr.ifremer.tutti.persistence.service.AbstractPersistenceService; @@ -40,6 +43,10 @@ @Component("batchTreeHelper") public class BatchTreeHelper extends AbstractPersistenceService { + public static final Integer SORTING_TYPE_ID = PmfmId2.SCIENTIFIC_CRUISE_SORTING_TYPE.getValue(); + + public static final Integer SORTING_TYPE2_ID = PmfmId2.SCIENTIFIC_CRUISE_SORTING_TYPE2.getValue(); + /** Logger. */ private static final Log log = LogFactory.getLog(BatchTreeHelper.class); @@ -59,9 +66,9 @@ return getSortingBatch( batch, "Vrac > Species > Alive Itemized", - enumeration.PMFM_ID_SORTED_UNSORTED, enumeration.QUALITATIVE_VRAC_ID, - enumeration.PMFM_ID_SORTING_TYPE, enumeration.QUALITATIVE_ID_SORTING_TYPE_SPECIES, - enumeration.PMFM_ID_SORTING_TYPE_2, enumeration.QUALITATIVE_ID_SORTING_TYPE_2_ALIVE_ITEMIZED + PmfmId2.SORTED_UNSORTED.getValue(), QualitativeValueId.SORTED_VRAC.getValue(), + SORTING_TYPE_ID, QualitativeValueId.SORTING_TYPE_SPECIES.getValue(), + SORTING_TYPE2_ID, QualitativeValueId.SORTING_TYPE2_ALIVE_ITEMIZED.getValue() ); } @@ -69,9 +76,9 @@ return getSortingBatch( batch, "Vrac > Benthos > Alive itemized", - enumeration.PMFM_ID_SORTED_UNSORTED, enumeration.QUALITATIVE_VRAC_ID, - enumeration.PMFM_ID_SORTING_TYPE, enumeration.QUALITATIVE_ID_SORTING_TYPE_BENTHOS, - enumeration.PMFM_ID_SORTING_TYPE_2, enumeration.QUALITATIVE_ID_SORTING_TYPE_2_ALIVE_ITEMIZED + PmfmId2.SORTED_UNSORTED.getValue(), QualitativeValueId.SORTED_VRAC.getValue(), + SORTING_TYPE_ID, QualitativeValueId.SORTING_TYPE_BENTHOS.getValue(), + SORTING_TYPE2_ID, QualitativeValueId.SORTING_TYPE2_ALIVE_ITEMIZED.getValue() ); } @@ -79,8 +86,8 @@ return getSortingBatch( batch, "Hors Vrac > Species", - enumeration.PMFM_ID_SORTED_UNSORTED, enumeration.QUALITATIVE_HORS_VRAC_ID, - enumeration.PMFM_ID_SORTING_TYPE, enumeration.QUALITATIVE_ID_SORTING_TYPE_SPECIES + PmfmId2.SORTED_UNSORTED.getValue(), QualitativeValueId.SORTED_HORS_VRAC.getValue(), + SORTING_TYPE_ID, QualitativeValueId.SORTING_TYPE_SPECIES.getValue() ); } @@ -88,8 +95,8 @@ return getSortingBatch( batch, "Hors Vrac > Benthos", - enumeration.PMFM_ID_SORTED_UNSORTED, enumeration.QUALITATIVE_HORS_VRAC_ID, - enumeration.PMFM_ID_SORTING_TYPE, enumeration.QUALITATIVE_ID_SORTING_TYPE_BENTHOS + PmfmId2.SORTED_UNSORTED.getValue(), QualitativeValueId.SORTED_HORS_VRAC.getValue(), + SORTING_TYPE_ID, QualitativeValueId.SORTING_TYPE_BENTHOS.getValue() ); } @@ -97,10 +104,10 @@ return getSortingBatch( batch, "Hors Vrac > Marine Litter", - enumeration.PMFM_ID_SORTED_UNSORTED, - enumeration.QUALITATIVE_HORS_VRAC_ID, - enumeration.PMFM_ID_SORTING_TYPE, - enumeration.QUALITATIVE_ID_SORTING_TYPE_MARINE_LITTER + PmfmId2.SORTED_UNSORTED.getValue(), + QualitativeValueId.SORTED_HORS_VRAC.getValue(), + SORTING_TYPE_ID, + QualitativeValueId.SORTING_TYPE_MARINE_LITTER.getValue() ); } @@ -108,8 +115,8 @@ return getSortingBatch( batch, "Vrac", - enumeration.PMFM_ID_SORTED_UNSORTED, - enumeration.QUALITATIVE_VRAC_ID + PmfmId2.SORTED_UNSORTED.getValue(), + QualitativeValueId.SORTED_VRAC.getValue() ); } @@ -117,8 +124,8 @@ return getSortingBatch( batch, "Hors Vrac", - enumeration.PMFM_ID_SORTED_UNSORTED, - enumeration.QUALITATIVE_HORS_VRAC_ID + PmfmId2.SORTED_UNSORTED.getValue(), + QualitativeValueId.SORTED_HORS_VRAC.getValue() ); } @@ -126,8 +133,8 @@ return getSortingBatch( batch, "Unsorted", - enumeration.PMFM_ID_SORTED_UNSORTED, - enumeration.QUALITATIVE_UNSORTED_ID + PmfmId2.SORTED_UNSORTED.getValue(), + QualitativeValueId.UNSORTED.getValue() ); } @@ -139,8 +146,8 @@ return getSortingBatch( batch, "Vrac > Species", - enumeration.PMFM_ID_SORTING_TYPE, - enumeration.QUALITATIVE_ID_SORTING_TYPE_SPECIES + SORTING_TYPE_ID, + QualitativeValueId.SORTING_TYPE_SPECIES.getValue() ); } @@ -148,8 +155,8 @@ return getSortingBatch( batch, "Vrac > Benthos", - enumeration.PMFM_ID_SORTING_TYPE, - enumeration.QUALITATIVE_ID_SORTING_TYPE_BENTHOS + SORTING_TYPE_ID, + QualitativeValueId.SORTING_TYPE_BENTHOS.getValue() ); } @@ -157,8 +164,8 @@ return getSortingBatch( batch, "Vrac > Species > Alive not itemized", - enumeration.PMFM_ID_SORTING_TYPE_2, - enumeration.QUALITATIVE_ID_SORTING_TYPE_2_ALIVE_NOT_ITEMIZED + SORTING_TYPE2_ID, + QualitativeValueId.SORTING_TYPE2_ALIVE_NOT_ITEMIZED.getValue() ); } @@ -166,8 +173,8 @@ return getSortingBatch( batch, "Vrac > Benthos > Alive not itemized", - enumeration.PMFM_ID_SORTING_TYPE_2, - enumeration.QUALITATIVE_ID_SORTING_TYPE_2_ALIVE_NOT_ITEMIZED + SORTING_TYPE2_ID, + QualitativeValueId.SORTING_TYPE2_ALIVE_NOT_ITEMIZED.getValue() ); } @@ -175,8 +182,8 @@ return getSortingBatch( batch, "Vrac > Species > Inert (not alive)", - enumeration.PMFM_ID_SORTING_TYPE_2, - enumeration.QUALITATIVE_ID_SORTING_TYPE_2_INERT + SORTING_TYPE2_ID, + QualitativeValueId.SORTING_TYPE2_INERT.getValue() ); } @@ -184,8 +191,8 @@ return getSortingBatch( batch, "Vrac > Benthos > Inert (not alive)", - enumeration.PMFM_ID_SORTING_TYPE_2, - enumeration.QUALITATIVE_ID_SORTING_TYPE_2_INERT + SORTING_TYPE2_ID, + QualitativeValueId.SORTING_TYPE2_INERT.getValue() ); } @@ -193,8 +200,8 @@ return getSortingBatch( batch, "Vrac > Species > Alive itemized", - enumeration.PMFM_ID_SORTING_TYPE_2, - enumeration.QUALITATIVE_ID_SORTING_TYPE_2_ALIVE_ITEMIZED + SORTING_TYPE2_ID, + QualitativeValueId.SORTING_TYPE2_ALIVE_ITEMIZED.getValue() ); } @@ -202,8 +209,8 @@ return getSortingBatch( batch, "Vrac > Benthos > Alive itemized", - enumeration.PMFM_ID_SORTING_TYPE_2, - enumeration.QUALITATIVE_ID_SORTING_TYPE_2_ALIVE_ITEMIZED + SORTING_TYPE2_ID, + QualitativeValueId.SORTING_TYPE2_ALIVE_ITEMIZED.getValue() ); } @@ -211,8 +218,8 @@ return getSortingBatch( batch, "Hors Vrac > Species", - enumeration.PMFM_ID_SORTING_TYPE, - enumeration.QUALITATIVE_ID_SORTING_TYPE_SPECIES + SORTING_TYPE_ID, + QualitativeValueId.SORTING_TYPE_SPECIES.getValue() ); } @@ -220,8 +227,8 @@ return getSortingBatch( batch, "Hors Vrac > Benthos", - enumeration.PMFM_ID_SORTING_TYPE, - enumeration.QUALITATIVE_ID_SORTING_TYPE_BENTHOS + SORTING_TYPE_ID, + QualitativeValueId.SORTING_TYPE_BENTHOS.getValue() ); } @@ -229,8 +236,8 @@ return getSortingBatch( batch, "Hors Vrac > MarineLitter", - enumeration.PMFM_ID_SORTING_TYPE, - enumeration.QUALITATIVE_ID_SORTING_TYPE_MARINE_LITTER + SORTING_TYPE_ID, + QualitativeValueId.SORTING_TYPE_MARINE_LITTER.getValue() ); } @@ -245,8 +252,8 @@ batch, batch, "Vrac", - enumeration.PMFM_ID_SORTED_UNSORTED, - enumeration.QUALITATIVE_VRAC_ID, + PmfmId2.SORTED_UNSORTED.getValue(), + QualitativeValueId.SORTED_VRAC.getValue(), weight, weightBeforeSampling, (short) 1 @@ -260,8 +267,8 @@ target, batch, "Vrac > Species", - enumeration.PMFM_ID_SORTING_TYPE, - enumeration.QUALITATIVE_ID_SORTING_TYPE_SPECIES, + SORTING_TYPE_ID, + QualitativeValueId.SORTING_TYPE_SPECIES.getValue(), totalWeight, (short) 1 ); @@ -274,8 +281,8 @@ target, batch, "Vrac > Species > Alive Not Itemized", - enumeration.PMFM_ID_SORTING_TYPE_2, - enumeration.QUALITATIVE_ID_SORTING_TYPE_2_ALIVE_NOT_ITEMIZED, + SORTING_TYPE2_ID, + QualitativeValueId.SORTING_TYPE2_ALIVE_NOT_ITEMIZED.getValue(), totalWeight, (short) 1 ); @@ -288,8 +295,8 @@ target, batch, "Vrac > Species > Inert", - enumeration.PMFM_ID_SORTING_TYPE_2, - enumeration.QUALITATIVE_ID_SORTING_TYPE_2_INERT, + SORTING_TYPE2_ID, + QualitativeValueId.SORTING_TYPE2_INERT.getValue(), totalWeight, (short) 2 ); @@ -301,8 +308,8 @@ target, batch, "Vrac > Benthos > Alive Itemized", - enumeration.PMFM_ID_SORTING_TYPE_2, - enumeration.QUALITATIVE_ID_SORTING_TYPE_2_ALIVE_ITEMIZED, + SORTING_TYPE2_ID, + QualitativeValueId.SORTING_TYPE2_ALIVE_ITEMIZED.getValue(), null, (short) 3 ); @@ -315,8 +322,8 @@ target, batch, "Vrac > Benthos", - enumeration.PMFM_ID_SORTING_TYPE, - enumeration.QUALITATIVE_ID_SORTING_TYPE_BENTHOS, + SORTING_TYPE_ID, + QualitativeValueId.SORTING_TYPE_BENTHOS.getValue(), totalWeight, (short) 2 ); @@ -329,8 +336,8 @@ target, batch, "Vrac > Benthos > Alive Not itemized", - enumeration.PMFM_ID_SORTING_TYPE_2, - enumeration.QUALITATIVE_ID_SORTING_TYPE_2_ALIVE_NOT_ITEMIZED, + SORTING_TYPE2_ID, + QualitativeValueId.SORTING_TYPE2_ALIVE_NOT_ITEMIZED.getValue(), totalWeight, (short) 1 ); @@ -343,8 +350,8 @@ target, batch, "Vrac > Benthos > Inert", - enumeration.PMFM_ID_SORTING_TYPE_2, - enumeration.QUALITATIVE_ID_SORTING_TYPE_2_INERT, + SORTING_TYPE2_ID, + QualitativeValueId.SORTING_TYPE2_INERT.getValue(), totalWeight, (short) 2 ); @@ -356,8 +363,8 @@ target, batch, "Vrac > Benthos > Alive Itemized", - enumeration.PMFM_ID_SORTING_TYPE_2, - enumeration.QUALITATIVE_ID_SORTING_TYPE_2_ALIVE_ITEMIZED, + SORTING_TYPE2_ID, + QualitativeValueId.SORTING_TYPE2_ALIVE_ITEMIZED.getValue(), null, (short) 3 ); @@ -368,8 +375,8 @@ batch, batch, "Hors Vrac", - enumeration.PMFM_ID_SORTED_UNSORTED, - enumeration.QUALITATIVE_HORS_VRAC_ID, + PmfmId2.SORTED_UNSORTED.getValue(), + QualitativeValueId.SORTED_HORS_VRAC.getValue(), null, (short) 2 ); @@ -381,8 +388,8 @@ target, batch, "Hors Vrac > Species", - enumeration.PMFM_ID_SORTING_TYPE, - enumeration.QUALITATIVE_ID_SORTING_TYPE_SPECIES, + SORTING_TYPE_ID, + QualitativeValueId.SORTING_TYPE_SPECIES.getValue(), null, (short) 1 ); @@ -394,8 +401,8 @@ target, batch, "Hors Vrac > Benthos", - enumeration.PMFM_ID_SORTING_TYPE, - enumeration.QUALITATIVE_ID_SORTING_TYPE_BENTHOS, + SORTING_TYPE_ID, + QualitativeValueId.SORTING_TYPE_BENTHOS.getValue(), null, (short) 2 ); @@ -408,8 +415,8 @@ target, batch, "Hors Vrac > Marine Litter", - enumeration.PMFM_ID_SORTING_TYPE, - enumeration.QUALITATIVE_ID_SORTING_TYPE_MARINE_LITTER, + SORTING_TYPE_ID, + QualitativeValueId.SORTING_TYPE_MARINE_LITTER.getValue(), totalWeight, (short) 3 ); @@ -422,8 +429,8 @@ batch, batch, "Unsorted", - enumeration.PMFM_ID_SORTED_UNSORTED, - enumeration.QUALITATIVE_UNSORTED_ID, + PmfmId2.SORTED_UNSORTED.getValue(), + QualitativeValueId.UNSORTED.getValue(), weight, (short) 3 ); @@ -522,7 +529,7 @@ } // Some mandatory properties : - QualityFlagImpl qualityFlag = load(QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED); + QualityFlagImpl qualityFlag = load(QualityFlagImpl.class, QualityFlagCode.NOTQUALIFIED.getValue()); result.setQualityFlag(qualityFlag); result.setRootBatch(rootBatch); result.setParentBatch(batch); Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/MeasurementPersistenceHelper.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/MeasurementPersistenceHelper.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/MeasurementPersistenceHelper.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -26,6 +26,7 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Sets; +import fr.ifremer.adagio.core.dao.administration.user.DepartmentId; import fr.ifremer.adagio.core.dao.data.batch.Batch; import fr.ifremer.adagio.core.dao.data.batch.CatchBatchExtendDao; import fr.ifremer.adagio.core.dao.data.batch.SortingBatch; @@ -39,8 +40,10 @@ import fr.ifremer.adagio.core.dao.data.survey.scientificCruise.ScientificCruise; import fr.ifremer.adagio.core.dao.data.vessel.feature.use.GearUseFeatures; import fr.ifremer.adagio.core.dao.data.vessel.feature.use.VesselUseFeatures; +import fr.ifremer.adagio.core.dao.referential.QualityFlagCode; import fr.ifremer.adagio.core.dao.referential.QualityFlagImpl; import fr.ifremer.adagio.core.dao.referential.pmfm.Pmfm; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmImpl; import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValue; import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueImpl; @@ -116,16 +119,16 @@ } public QuantificationMeasurement setWeightMeasurementQuantificationMeasurement(Batch batch, Float weightValue) { - return catchBatchDao.setQuantificationMeasurement(batch, enumeration.PMFM_ID_WEIGHT_MEASURED, getRecorderDepartmentId(), weightValue, true); + return catchBatchDao.setQuantificationMeasurement(batch, PmfmId2.WEIGHT_MEASURED.getValue(), getRecorderDepartmentId(), weightValue, true); } public QuantificationMeasurement getWeightMeasurementQuantificationMeasurement(Batch batch) { - QuantificationMeasurement quantificationMeasurement = catchBatchDao.getQuantificationMeasurement(batch, enumeration.PMFM_ID_WEIGHT_MEASURED, getRecorderDepartmentId(), false); + QuantificationMeasurement quantificationMeasurement = catchBatchDao.getQuantificationMeasurement(batch, PmfmId2.WEIGHT_MEASURED.getValue(), getRecorderDepartmentId(), false); return quantificationMeasurement; } public SortingMeasurement getInheritedSortingMeasurement(SortingBatch sortingBatch) { - return catchBatchDao.getInheritedSortingMeasurement(sortingBatch, enumeration.PMFM_ID_SORTED_UNSORTED); + return catchBatchDao.getInheritedSortingMeasurement(sortingBatch, PmfmId2.SORTED_UNSORTED.getValue()); } //------------------------------------------------------------------------// @@ -133,10 +136,10 @@ //------------------------------------------------------------------------// public VesselUseMeasurement setVesselUseMeasurement(ScientificCruise scientificCruise, VesselUseFeatures vesselUseFeatures, - Integer pmfmId, - Float numericalValue, - String alphanumericalValue, - Integer qualitativevalueId) { + Integer pmfmId, + Float numericalValue, + String alphanumericalValue, + Integer qualitativevalueId) { VesselUseMeasurement vesselUseMeasurement = getVesselUseMeasurement(scientificCruise, vesselUseFeatures, pmfmId, true); if (alphanumericalValue != null) { @@ -179,7 +182,7 @@ } else { vesselUseFeatures.getVesselUseMeasurements().add(vesselUseMeasurement); } - vesselUseMeasurement.setQualityFlag(load(QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED)); + vesselUseMeasurement.setQualityFlag(load(QualityFlagImpl.class, QualityFlagCode.NOTQUALIFIED.getValue())); vesselUseMeasurement.setDepartment(scientificCruise.getRecorderDepartment()); vesselUseMeasurement.setPmfm(load(PmfmImpl.class, pmfmId)); } @@ -208,10 +211,10 @@ //------------------------------------------------------------------------// public GearUseMeasurement setGearUseMeasurement(ScientificCruise scientificCruise, GearUseFeatures gearUseFeatures, - Integer pmfmId, - Float numericalValue, - String alphanumericalValue, - Integer qualitativevalueId) { + Integer pmfmId, + Float numericalValue, + String alphanumericalValue, + Integer qualitativevalueId) { GearUseMeasurement gearUseMeasurement = getGearUseMeasurement(scientificCruise, gearUseFeatures, pmfmId, true); if (alphanumericalValue != null) { @@ -255,7 +258,7 @@ } else { gearUseFeatures.getGearUseMeasurements().add(gearUseMeasurement); } - gearUseMeasurement.setQualityFlag(load(QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED)); + gearUseMeasurement.setQualityFlag(load(QualityFlagImpl.class, QualityFlagCode.NOTQUALIFIED.getValue())); gearUseMeasurement.setDepartment(scientificCruise.getRecorderDepartment()); Pmfm pmfm = (Pmfm) getCurrentSession().load(PmfmImpl.class, pmfmId); gearUseMeasurement.setPmfm(pmfm); @@ -328,7 +331,7 @@ Integer qualitativevalueId) { SurveyMeasurement result = SurveyMeasurement.Factory.newInstance(); - result.setQualityFlag(load(QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED)); + result.setQualityFlag(load(QualityFlagImpl.class, QualityFlagCode.NOTQUALIFIED.getValue())); result.setDepartment(fishingTrip.getRecorderDepartment()); Pmfm pmfm = load(PmfmImpl.class, pmfmId); result.setPmfm(pmfm); @@ -369,6 +372,6 @@ protected Integer getRecorderDepartmentId() { // TODO BL : voir si on peut récupérer le departement (du 1er saisisseur ?) - return enumeration.DEPARTMENT_ID_UNKNOWN_RECORDER_DEPARTMENT; + return DepartmentId.UNKOWN_RECODER_DEPARTMENT.getValue(); } } Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/SamplePersistenceHelper.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/SamplePersistenceHelper.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/SamplePersistenceHelper.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -28,11 +28,12 @@ import fr.ifremer.adagio.core.dao.data.measure.SampleMeasurement; import fr.ifremer.adagio.core.dao.data.sample.Sample; import fr.ifremer.adagio.core.dao.data.sample.SampleDao; +import fr.ifremer.adagio.core.dao.referential.QualityFlagCode; import fr.ifremer.adagio.core.dao.referential.QualityFlagImpl; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmImpl; import fr.ifremer.tutti.persistence.entities.CaracteristicMap; import fr.ifremer.tutti.persistence.entities.TuttiEntities; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; import fr.ifremer.tutti.persistence.service.AbstractPersistenceService; import fr.ifremer.tutti.persistence.service.AttachmentPersistenceService; @@ -85,7 +86,7 @@ sample.getSampleMeasurements().clear(); sampleDao.remove(sample); attachmentPersistenceService.deleteAllAttachment( - AttachementObjectTypeEnum.SAMPLE, + ObjectTypeCode2.SAMPLE, sampleId); } } @@ -169,7 +170,7 @@ } else { sample.getSampleMeasurements().add(result); } - result.setQualityFlag(load(QualityFlagImpl.class, enumeration.QUALITY_FLAG_CODE_NOT_QUALIFIED)); + result.setQualityFlag(load(QualityFlagImpl.class, QualityFlagCode.NOTQUALIFIED.getValue())); result.setDepartment(sample.getRecorderDepartment()); result.setPmfm(load(PmfmImpl.class, pmfmId)); } Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/VesselPersonFeaturesPersistenceHelper.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/VesselPersonFeaturesPersistenceHelper.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/util/VesselPersonFeaturesPersistenceHelper.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -30,6 +30,7 @@ import fr.ifremer.adagio.core.dao.data.survey.fishingTrip.FishingTrip; import fr.ifremer.adagio.core.dao.data.vessel.feature.person.VesselPersonFeatures; import fr.ifremer.adagio.core.dao.referential.VesselPersonRole; +import fr.ifremer.adagio.core.dao.referential.VesselPersonRoleId; import fr.ifremer.adagio.core.dao.referential.VesselPersonRoleImpl; import fr.ifremer.tutti.persistence.service.AbstractPersistenceService; import org.apache.commons.logging.Log; @@ -56,15 +57,15 @@ } public VesselPersonRole getScientificCruiseManagerRole() { - return load(VesselPersonRoleImpl.class, enumeration.VESSEL_PERSON_ROLE_ID_SCIENTIFIC_CRUISE_MANAGER); + return load(VesselPersonRoleImpl.class, VesselPersonRoleId.SCIENTIFIC_CRUISE_MANAGER.getValue()); } public VesselPersonRole getSortRoomManagerRole() { - return load(VesselPersonRoleImpl.class, enumeration.VESSEL_PERSON_ROLE_ID_SORT_ROOM_MANAGER); + return load(VesselPersonRoleImpl.class, VesselPersonRoleId.SORT_ROOM_MANAGER.getValue()); } public VesselPersonRole getRecorderPersonRole() { - return load(VesselPersonRoleImpl.class, enumeration.VESSEL_PERSON_ROLE_ID_RECORDER_PERSON); + return load(VesselPersonRoleImpl.class, VesselPersonRoleId.RECORDER_PERSON.getValue()); } public void fillVesselPersonFeatures(Map<Integer, VesselPersonFeatures> vesselPersonFeaturesPerPerson, Modified: trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseFixtures.java =================================================================== --- trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseFixtures.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/test/DatabaseFixtures.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -73,7 +73,7 @@ public class DatabaseFixtures { public Version lastAdagioSchemaVersion() { - return VersionUtil.valueOf("3.4.1"); + return VersionUtil.valueOf("3.5.0"); } public Version currentAdagioSchemaVersion() { Modified: trunk/tutti-persistence/src/main/resources/applicationContext-service-tutti.xml =================================================================== --- trunk/tutti-persistence/src/main/resources/applicationContext-service-tutti.xml 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/resources/applicationContext-service-tutti.xml 2014-04-24 10:17:09 UTC (rev 1725) @@ -36,9 +36,6 @@ <bean id="tuttiPersistence" class="fr.ifremer.tutti.persistence.TuttiPersistenceImpl"/> - <bean id="tuttiEnumerationFile" init-method="init" - class="fr.ifremer.tutti.persistence.service.TuttiEnumerationFile"/> - <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> <!-- Caches management for tutti (not defined in adagio-core files) --> <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> @@ -47,26 +44,18 @@ <bean id="tuttiProgramsCache" parent="abstractEternalCache"> <property name="cacheName" value="programs" /> - <!--<property name="maxElementsInMemory" value="1"/>--> - <!--<property name="maxElementsOnDisk" value="1"/>--> </bean> <bean id="tuttiProgramZonesCache" parent="abstractEternalCache"> <property name="cacheName" value="programZones" /> - <!--<property name="maxElementsInMemory" value="1"/>--> - <!--<property name="maxElementsOnDisk" value="1"/>--> </bean> <bean id="countriesCache" parent="abstractEternalCache"> <property name="cacheName" value="countries" /> - <!--<property name="maxElementsInMemory" value="1"/>--> - <!--<property name="maxElementsOnDisk" value="1"/>--> </bean> <bean id="harboursCache" parent="abstractEternalCache"> <property name="cacheName" value="harbours" /> - <!--<property name="maxElementsInMemory" value="1"/>--> - <!--<property name="maxElementsOnDisk" value="1"/>--> </bean> <bean id="tuttiPmfmsCache" parent="abstractEternalCache"> @@ -90,56 +79,38 @@ <bean id="tuttiFishingVesselsCache" parent="abstractEternalCache"> <property name="cacheName" value="fishingVessels" /> - <!--<property name="maxElementsInMemory" value="1"/>--> - <!--<property name="maxElementsOnDisk" value="1"/>--> </bean> <bean id="tuttiFishingVesselByCodeCache" parent="abstractEternalCache"> <property name="cacheName" value="vesselByCode" /> - <!--<property name="maxElementsInMemory" value="40000"/>--> - <!--<property name="maxElementsOnDisk" value="40000"/>--> </bean> <bean id="tuttiSpeciesCache" parent="abstractEternalCache"> <property name="cacheName" value="species" /> - <!--<property name="maxElementsInMemory" value="1"/>--> - <!--<property name="maxElementsOnDisk" value="1"/>--> </bean> <bean id="tuttiReferentSpeciesCache" parent="abstractEternalCache"> <property name="cacheName" value="referentSpecies" /> - <!--<property name="maxElementsInMemory" value="1"/>--> - <!--<property name="maxElementsOnDisk" value="1"/>--> </bean> <bean id="tuttiReferentSpeciesByIdCache" parent="abstractEternalCache"> <property name="cacheName" value="referentSpeciesById" /> - <!--<property name="maxElementsInMemory" value="20000"/>--> - <!--<property name="maxElementsOnDisk" value="20000"/>--> </bean> <bean id="tuttiReferentSpeciesByIdVenacularCache" parent="abstractEternalCache"> <property name="cacheName" value="referentSpeciesByIdVernacular" /> - <!--<property name="maxElementsInMemory" value="20000"/>--> - <!--<property name="maxElementsOnDisk" value="20000"/>--> </bean> <bean id="tuttiGearsCache" parent="abstractEternalCache"> <property name="cacheName" value="gears" /> - <!--<property name="maxElementsInMemory" value="1"/>--> - <!--<property name="maxElementsOnDisk" value="1"/>--> </bean> <bean id="tuttiPersonsCache" parent="abstractEternalCache"> <property name="cacheName" value="persons" /> - <!--<property name="maxElementsInMemory" value="1"/>--> - <!--<property name="maxElementsOnDisk" value="1"/>--> </bean> <bean id="tuttiPersonByIdCache" parent="abstractEternalCache"> <property name="cacheName" value="personById" /> - <!--<property name="maxElementsInMemory" value="1000"/>--> - <!--<property name="maxElementsOnDisk" value="1000"/>--> </bean> </beans> \ No newline at end of file Modified: trunk/tutti-persistence/src/main/resources/i18n/tutti-persistence_en_GB.properties =================================================================== --- trunk/tutti-persistence/src/main/resources/i18n/tutti-persistence_en_GB.properties 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/resources/i18n/tutti-persistence_en_GB.properties 2014-04-24 10:17:09 UTC (rev 1725) @@ -1,3 +1,43 @@ +adagio.enumeration.MatrixId.PRODUCT_BATCH.description= +adagio.enumeration.ObjectTypeCode.ACTIVITY_CALENDAR.description= +adagio.enumeration.ObjectTypeCode.BATCH.description= +adagio.enumeration.ObjectTypeCode.CATCH_BATCH.description= +adagio.enumeration.ObjectTypeCode.DAILY_ACTIVITY_CALENDAR.description= +adagio.enumeration.ObjectTypeCode.FISHING_TRIP.description= +adagio.enumeration.ObjectTypeCode.LANDING.description= +adagio.enumeration.ObjectTypeCode.OPERATION.description= +adagio.enumeration.ObjectTypeCode.SALE.description= +adagio.enumeration.ObjectTypeCode.SAMPLE.description= +adagio.enumeration.ObjectTypeCode.SCIENTIFIC_CRUISE.description= +adagio.enumeration.PmfmId.AGE.description= +adagio.enumeration.PmfmId.DEAD_OR_ALIVE.description= +adagio.enumeration.PmfmId.HAUL_VALID.description= +adagio.enumeration.PmfmId.HORIZONTAL_OPENING_DOOR.description= +adagio.enumeration.PmfmId.HORIZONTAL_OPENING_WINGS.description= +adagio.enumeration.PmfmId.ID_PSFM.description= +adagio.enumeration.PmfmId.MARINE_LITTER_SIZE_CATEGORY.description= +adagio.enumeration.PmfmId.MARINE_LITTER_TYPE.description= +adagio.enumeration.PmfmId.MATURITY.description= +adagio.enumeration.PmfmId.MULTIRIG_AGGREGATION.description= +adagio.enumeration.PmfmId.MULTIRIG_NUMBER.description= +adagio.enumeration.PmfmId.RECTILINEAR_OPERATION.description= +adagio.enumeration.PmfmId.SCIENTIFIC_CRUISE_SORTING_TYPE.description= +adagio.enumeration.PmfmId.SCIENTIFIC_CRUISE_SORTING_TYPE2.description= +adagio.enumeration.PmfmId.SEX.description= +adagio.enumeration.PmfmId.SIZE_CATEGORY.description= +adagio.enumeration.PmfmId.SORTED_UNSORTED.description= +adagio.enumeration.PmfmId.SORTING_TYPE_TCC.description= +adagio.enumeration.PmfmId.STATION_NUMBER.description= +adagio.enumeration.PmfmId.SURVEY_PART.description= +adagio.enumeration.PmfmId.TRAWL_DISTANCE.description= +adagio.enumeration.PmfmId.VERTICAL_OPENING.description= +adagio.enumeration.PmfmId.WEIGHT_MEASURED.description= +adagio.enumeration.QualitativeValueId.MATURITY_1.description= +adagio.enumeration.QualitativeValueId.MATURITY_2.description= +adagio.enumeration.QualitativeValueId.MATURITY_3.description= +adagio.enumeration.QualitativeValueId.MATURITY_4.description= +adagio.enumeration.QualitativeValueId.MATURITY_5.description= +adagio.enumeration.QualitativeValueId.SEX_UNDEFINED.description= application.common.unit=Unit application.common.unit.g=Gram application.common.unit.kg=Kilogram Modified: trunk/tutti-persistence/src/main/resources/i18n/tutti-persistence_fr_FR.properties =================================================================== --- trunk/tutti-persistence/src/main/resources/i18n/tutti-persistence_fr_FR.properties 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/resources/i18n/tutti-persistence_fr_FR.properties 2014-04-24 10:17:09 UTC (rev 1725) @@ -1,3 +1,43 @@ +adagio.enumeration.MatrixId.PRODUCT_BATCH.description= +adagio.enumeration.ObjectTypeCode.ACTIVITY_CALENDAR.description= +adagio.enumeration.ObjectTypeCode.BATCH.description= +adagio.enumeration.ObjectTypeCode.CATCH_BATCH.description= +adagio.enumeration.ObjectTypeCode.DAILY_ACTIVITY_CALENDAR.description= +adagio.enumeration.ObjectTypeCode.FISHING_TRIP.description= +adagio.enumeration.ObjectTypeCode.LANDING.description= +adagio.enumeration.ObjectTypeCode.OPERATION.description= +adagio.enumeration.ObjectTypeCode.SALE.description= +adagio.enumeration.ObjectTypeCode.SAMPLE.description= +adagio.enumeration.ObjectTypeCode.SCIENTIFIC_CRUISE.description= +adagio.enumeration.PmfmId.AGE.description= +adagio.enumeration.PmfmId.DEAD_OR_ALIVE.description= +adagio.enumeration.PmfmId.HAUL_VALID.description= +adagio.enumeration.PmfmId.HORIZONTAL_OPENING_DOOR.description= +adagio.enumeration.PmfmId.HORIZONTAL_OPENING_WINGS.description= +adagio.enumeration.PmfmId.ID_PSFM.description= +adagio.enumeration.PmfmId.MARINE_LITTER_SIZE_CATEGORY.description= +adagio.enumeration.PmfmId.MARINE_LITTER_TYPE.description= +adagio.enumeration.PmfmId.MATURITY.description= +adagio.enumeration.PmfmId.MULTIRIG_AGGREGATION.description= +adagio.enumeration.PmfmId.MULTIRIG_NUMBER.description= +adagio.enumeration.PmfmId.RECTILINEAR_OPERATION.description= +adagio.enumeration.PmfmId.SCIENTIFIC_CRUISE_SORTING_TYPE.description= +adagio.enumeration.PmfmId.SCIENTIFIC_CRUISE_SORTING_TYPE2.description= +adagio.enumeration.PmfmId.SEX.description= +adagio.enumeration.PmfmId.SIZE_CATEGORY.description= +adagio.enumeration.PmfmId.SORTED_UNSORTED.description= +adagio.enumeration.PmfmId.SORTING_TYPE_TCC.description= +adagio.enumeration.PmfmId.STATION_NUMBER.description= +adagio.enumeration.PmfmId.SURVEY_PART.description= +adagio.enumeration.PmfmId.TRAWL_DISTANCE.description= +adagio.enumeration.PmfmId.VERTICAL_OPENING.description= +adagio.enumeration.PmfmId.WEIGHT_MEASURED.description= +adagio.enumeration.QualitativeValueId.MATURITY_1.description= +adagio.enumeration.QualitativeValueId.MATURITY_2.description= +adagio.enumeration.QualitativeValueId.MATURITY_3.description= +adagio.enumeration.QualitativeValueId.MATURITY_4.description= +adagio.enumeration.QualitativeValueId.MATURITY_5.description= +adagio.enumeration.QualitativeValueId.SEX_UNDEFINED.description= application.common.unit=Unité application.common.unit.g=Gramme application.common.unit.kg=Kilogramme Modified: trunk/tutti-persistence/src/main/resources/tutti-db-enumerations.properties =================================================================== --- trunk/tutti-persistence/src/main/resources/tutti-db-enumerations.properties 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/main/resources/tutti-db-enumerations.properties 2014-04-24 10:17:09 UTC (rev 1725) @@ -22,130 +22,24 @@ # #L% ### -#MatrixId.SUPPORT_WITH_GEAR=17 -#MatrixId.SUPPORT_WITH_METIER=18 -#LocationLevelId.RECTANGLE_STATISTIQUE_MED=145 - ################################################################################ ### Ajout pour Tutti ########################################################### ################################################################################ -# zone d'étude SCIENTIFIC_CRUISE_PROGRAM -#LocationLevelId.PROGRAM=301 -# strate SCIENTIFIC_CRUISE_STRATA -#LocationLevelId.STRATA=302 -# sous strate SCIENTIFIC_CRUISE_SUB_STRATA -#LocationLevelId.SUB_STRATA=303 -# localité SCIENTIFIC_CRUISE_LOCALITE -#LocationLevelId.LOCALITE=304 -# radiale SCIENTIFIC_CRUISE_RADIALE -#LocationLevelId.RADIALE=305 +# PSFM "Pour référencer un autre id de pmfm" +PmfmId.ID_PSFM=1433 -# Catégorie Sex -#PmfmId.SEX=196 -QualitativeValueId.SEX_UNDEFINED=299 -#QualitativeValueId.SEX_MALE=300 -#QualitativeValueId.SEX_FEMALE=301 +MatrixId.PRODUCT_BATCH=1 -# Catégorie classe de tri -#PmfmId.SIZE_CATEGORY=198 -#QualitativeValueId.SIZE_SMALL=307 -#QualitativeValueId.SIZE_MEDIUM=306 -#QualitativeValueId.SIZE_BIG=305 +ObjectTypeCode.CATCH_BATCH=CATCH_BATCH -# Catégorie Age -#PmfmId.AGE=1430 -# Catégorie maturité -#PmfmId.MATURITY=174 +QualitativeValueId.SEX_UNDEFINED=299 QualitativeValueId.MATURITY_1=272 QualitativeValueId.MATURITY_2=273 QualitativeValueId.MATURITY_3=274 QualitativeValueId.MATURITY_4=275 QualitativeValueId.MATURITY_5=276 - -# Catégorie macro-déchet -#PmfmId.MARINE_LITTER_TYPE=1421 -# Classe de taille macro-déchet -#PmfmId.MARINE_LITTER_SIZE_CATEGORY=1422 - -# Pour stocker Cruise.surveyPart -#PmfmId.SURVEY_PART=1432 - -#PmfmId.STATION_NUMBER=1243 -#PmfmId.TRAWL_DISTANCE=113 - -#PmfmId.HAUL_VALID=1163 -#QualitativeValueId.HAUL_VALID_YES=1575 -#QualitativeValueId.HAUL_VALID_NO=1576 - -#PmfmId.RECTILINEAR_OPERATION=192 -#QualitativeValueId.RECTILINEAR_OPERATION_YES=277 -#QualitativeValueId.RECTILINEAR_OPERATION_NO=278 - -# PSFM "Nombre de poche" d'un chalut (écran campagne) -#PmfmId.MULTIRIG_NUMBER=1420 -# PSFM "Liste des poches observées" (écran opération) -#PmfmId.MULTIRIG_AGGREGATION=1424 - -# PSFM "Poids - observation par une observateur" (écran captures, onglet espèce, benthos, etc) -#PmfmId.WEIGHT_MEASURED=220 - -# PSFM "Vrac/Hors Vrac" - "Organisation des données campagnes" -#PmfmId.SORTED_UNSORTED=1428 -#QualitativeValueId.SORTED_VRAC=311 -#QualitativeValueId.SORTED_HORS_VRAC=310 -#QualitativeValueId.UNSORTED=2146 - -#PmfmId.SCIENTIFIC_CRUISE_SORTING_TYPE=1429 -#QualitativeValueId.SORTING_TYPE_SPECIES=2147 -#QualitativeValueId.SORTING_TYPE_BENTHOS=2148 -#QualitativeValueId.SORTING_TYPE_PLANCTON=2149 -#QualitativeValueId.SORTING_TYPE_MARINE_LITTER=2150 -#QualitativeValueId.SORTING_TYPE_ACCIDENTAL_CATCH=2151 - -PmfmId.SCIENTIFIC_CRUISE_SORTING_TYPE_2=1431 QualitativeValueId.SORTING_TYPE_2_ALIVE_NOT_ITEMIZED=2161 QualitativeValueId.SORTING_TYPE_2_INERT=2162 QualitativeValueId.SORTING_TYPE_2_ALIVE_ITEMIZED=2160 - -# PSFM "Ouverture verticale (chalut ou drague)" (pour export operation) -#PmfmId.VERTICAL_OPENING=832 -# PSFM "Ouverture Horizontale aux pointes d'ailes" (pour export operation) -#PmfmId.HORIZONTAL_OPENING_WING=827 -# PSFM "Ouverture horizontale aux panneaux" (pour export operation) -#PmfmId.HORIZONTAL_OPENING_DOOR=830 - -#PSFM "Remis à l'eau mort ou vivant" -#PmfmId.DEAD_OR_ALIVE=1393 - -# PSFM "Pour référencer un autre id de pmfm" -PmfmId.ID_PSFM=1433 - -PmfmId.SAMPLE_ID=1435 - -PmfmId.OTOLITHE_ID=1436 - -# (20=observateur volant, 95=Administrateur SIH) -> L'avantage du 20 est qu'il est inactif (=20), donc plus facilement detectable -#PersonId.UNKNOWN_RECORDER_PERSON=20 - UserProfilId.DEPARTEMENT_PREFIX=PDG- - -# 181=PDG-RBE (à confirmer par Vincent) -#DepartmentId.UNKNOWN_RECORDER_DEPARTMENT=181 - -#ProgramCode.SCIENTIFIC_CRUISE_PREFIX=CAM- - -#ObjectTypeCode.SCIENTIFIC_CRUISE=SCIENTIFIC_CRUISE -#ObjectTypeCode.OPERATION=OPERATION -ObjectTypeCode.CATCH_BATCH=CATCH_BATCH -#ObjectTypeCode.BATCH=BATCH -#ObjectTypeCode.SAMPLE=SAMPLE - -#VesselPersonRoleId.SCIENTIFIC_CRUISE_MANAGER=2 -#VesselPersonRoleId.SORT_ROOM_MANAGER=3 -#VesselPersonRoleId.RECORDER_PERSON=4 - -TranscribingTypeId.TAXINOMIE_REFTAX_MNEMONIQUE=55 -TranscribingTypeId.TAXINOMIE_COMMUN_NOM_VERNACULAIRE=56 - -MatrixId.PRODUCT_BATCH=1 \ No newline at end of file Modified: trunk/tutti-persistence/src/main/xmi/tutti-persistence.zargo =================================================================== (Binary files differ) Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocolsTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocolsTest.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocolsTest.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -27,7 +27,6 @@ import com.google.common.base.Charsets; import com.google.common.collect.Lists; import com.google.common.io.Files; -import fr.ifremer.tutti.persistence.service.TuttiEnumerationFile; import org.apache.commons.lang3.reflect.FieldUtils; import org.junit.Assert; import org.junit.Before; @@ -168,16 +167,16 @@ Files.write(PROTOCOL_FILE_CONTENT, file, Charsets.UTF_8); - TuttiEnumerationFile enumeration = new TuttiEnumerationFile(); +// TuttiEnumerationFile enumeration = new TuttiEnumerationFile(); +// +// setField(enumeration, "PMFM_ID_SORTED_UNSORTED", VRAC_HORS_VRAC); +// setField(enumeration, "PMFM_ID_SIZE_CATEGORY", SIZE); +// setField(enumeration, "PMFM_ID_SEX", SEX); +// setField(enumeration, "PMFM_ID_MATURITY", MATURITY); +// setField(enumeration, "PMFM_ID_AGE", AGE); - setField(enumeration, "PMFM_ID_SORTED_UNSORTED", VRAC_HORS_VRAC); - setField(enumeration, "PMFM_ID_SIZE_CATEGORY", SIZE); - setField(enumeration, "PMFM_ID_SEX", SEX); - setField(enumeration, "PMFM_ID_MATURITY", MATURITY); - setField(enumeration, "PMFM_ID_AGE", AGE); + TuttiProtocol protocol = TuttiProtocols.fromFile(file); - TuttiProtocol protocol = TuttiProtocols.fromFile(enumeration, file); - Assert.assertNotNull(protocol); Assert.assertEquals("1", protocol.getId()); Assert.assertEquals("protocolName", protocol.getName()); Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceWriteTest.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/AttachmentPersistenceServiceWriteTest.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.Attachments; import fr.ifremer.tutti.persistence.test.DatabaseResource; @@ -62,7 +62,7 @@ Integer cruiseId = Integer.valueOf(dbResource.getFixtures().cruiseId()); allAttachments = service.getAllAttachments( - AttachementObjectTypeEnum.SCIENTIFIC_CRUISE, cruiseId); + ObjectTypeCode2.SCIENTIFIC_CRUISE, cruiseId); Assert.assertTrue(allAttachments.isEmpty()); // @@ -70,7 +70,7 @@ // Attachment attachment = Attachments.newAttachment(); - attachment.setObjectType(AttachementObjectTypeEnum.SCIENTIFIC_CRUISE); + attachment.setObjectType(ObjectTypeCode2.SCIENTIFIC_CRUISE); attachment.setObjectId(cruiseId); long buildTime = System.nanoTime(); attachment.setName("AttachmentName-" + buildTime); @@ -93,7 +93,7 @@ // allAttachments = service.getAllAttachments( - AttachementObjectTypeEnum.SCIENTIFIC_CRUISE, cruiseId); + ObjectTypeCode2.SCIENTIFIC_CRUISE, cruiseId); Assert.assertFalse(allAttachments.isEmpty()); Assert.assertEquals(1, allAttachments.size()); @@ -115,7 +115,7 @@ // allAttachments = service.getAllAttachments( - AttachementObjectTypeEnum.SCIENTIFIC_CRUISE, cruiseId); + ObjectTypeCode2.SCIENTIFIC_CRUISE, cruiseId); Assert.assertFalse(allAttachments.isEmpty()); Assert.assertEquals(1, allAttachments.size()); @@ -128,7 +128,7 @@ service.deleteAttachment(attachment.getId()); allAttachments = service.getAllAttachments( - AttachementObjectTypeEnum.SCIENTIFIC_CRUISE, cruiseId); + ObjectTypeCode2.SCIENTIFIC_CRUISE, cruiseId); Assert.assertTrue(allAttachments.isEmpty()); Assert.assertFalse(attachmentFile.exists()); } Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceReadTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceReadTest.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceReadTest.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -25,6 +25,7 @@ */ import com.google.common.collect.Maps; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; import fr.ifremer.tutti.persistence.entities.data.BenthosBatch; import fr.ifremer.tutti.persistence.entities.data.FishingOperation; @@ -63,11 +64,8 @@ protected FishingOperation fishingOperation; - protected TuttiEnumerationFile enumerationFile; - @Before public void setUp() throws Exception { - enumerationFile = TuttiPersistenceServiceLocator.getTechnicalPersistenceService().getEnumerationFile(); service = TuttiPersistenceServiceLocator.getBenthosBatchPersistenceService(); fishingOperationService = TuttiPersistenceServiceLocator.getFishingOperationPersistenceService(); @@ -120,7 +118,7 @@ // Check species only if Vrac/HorsVrac or if batch has been load throw getAllxxx method // (Because getBenthosBatch(id) could not always retrieve the species) if (expectedBatch.getSpecies() != null && ( - enumerationFile.PMFM_ID_SORTED_UNSORTED.equals(expectedBatch.getSampleCategoryId()) + PmfmId2.SORTED_UNSORTED.getValue().equals(expectedBatch.getSampleCategoryId()) || actualBatch.getSpecies() != null)) { assertNotNull(actualBatch.getSpecies()); assertEquals(expectedBatch.getSpecies().getId(), actualBatch.getSpecies().getId()); Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceWriteTest.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/BenthosBatchPersistenceServiceWriteTest.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -26,6 +26,7 @@ import com.google.common.collect.Lists; import com.google.common.collect.Maps; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; import fr.ifremer.tutti.persistence.entities.data.BenthosBatch; import fr.ifremer.tutti.persistence.entities.data.BenthosBatchFrequency; import fr.ifremer.tutti.persistence.entities.data.BenthosBatchFrequencys; @@ -114,8 +115,6 @@ protected Caracteristic frequencyPMFM; - protected TuttiEnumerationFile enumerationFile; - @Before public void setUp() throws Exception { @@ -124,7 +123,6 @@ catchBatchService = TuttiPersistenceServiceLocator.getCatchBatchPersistenceService(); fishingOperationService = TuttiPersistenceServiceLocator.getFishingOperationPersistenceService(); referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService(); - enumerationFile = TuttiPersistenceServiceLocator.getTechnicalPersistenceService().getEnumerationFile(); species = referentialService.getAllSpecies(); assertNotNull(species); @@ -221,7 +219,7 @@ batch.setParentBatch(null); batch.setFishingOperation(fishingOperationNoCatchBatch); batch.setSpecies(taxon1); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_SORTED_UNSORTED); + batch.setSampleCategoryId(PmfmId2.SORTED_UNSORTED.getValue()); batch.setSampleCategoryValue(vracQualitativeValue); batch.setSampleCategoryWeight(5f); @@ -239,7 +237,7 @@ batch.setParentBatch(esp1Batch); batch.setSpecies(taxon1); batch.setComment("ESP1 - Vrac/5 Male/2 ss-ech/1 Nombre/7"); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_SEX); + batch.setSampleCategoryId(PmfmId2.SEX.getValue()); batch.setSampleCategoryValue(maleQualitativeValue); batch.setSampleCategoryWeight(2f); batch.setWeight(1f); @@ -256,7 +254,7 @@ batch.setParentBatch(esp1Batch); batch.setSpecies(taxon1); batch.setComment("ESP1 - Vrac/5 Female/3 Nombre/14"); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_SEX); + batch.setSampleCategoryId(PmfmId2.SEX.getValue()); batch.setSampleCategoryValue(femaleQualitativeValue); batch.setSampleCategoryWeight(3f); batch.setWeight(null); @@ -272,7 +270,7 @@ batch = BenthosBatchs.newBenthosBatch(); batch.setParentBatch(null); batch.setSpecies(taxon2); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_SORTED_UNSORTED); + batch.setSampleCategoryId(PmfmId2.SORTED_UNSORTED.getValue()); batch.setSampleCategoryValue(vracQualitativeValue); batch.setSampleCategoryWeight(7f); @@ -285,7 +283,7 @@ batch.setParentBatch(esp2Batch); batch.setSpecies(taxon2); batch.setComment("ESP2 - Vrac/7 UNK/2 ss-ech/1 Nombre/11"); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_MATURITY); + batch.setSampleCategoryId(PmfmId2.MATURITY.getValue()); batch.setSampleCategoryValue(firstMaturityQualitativeValue); batch.setSampleCategoryWeight(2f); batch.setWeight(1f); @@ -298,7 +296,7 @@ // ----------------------------------------------------------------------------- // Batch : ESP2 - Vrac/7 UNK/1.75 ss-ech/1.11 Nombre/99 batch.setComment("ESP2 - Vrac/7 UNK/1.75 ss-ech/1.11 Nombre/99"); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_SEX); + batch.setSampleCategoryId(PmfmId2.SEX.getValue()); batch.setSampleCategoryValue(unkQualitativeValue); batch.setSampleCategoryWeight(1.75f); batch.setWeight(1.11f); @@ -384,7 +382,7 @@ batch.setParentBatch(null); batch.setFishingOperation(fishingOperationWithEmptyBatch); batch.setSpecies(taxon1); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_SORTED_UNSORTED); + batch.setSampleCategoryId(PmfmId2.SORTED_UNSORTED.getValue()); batch.setSampleCategoryValue(vracQualitativeValue); batch.setSampleCategoryWeight(5f); assertCreateAndReloadBenthosBatch(batch, null); @@ -395,7 +393,7 @@ batch.setParentBatch(esp1Batch); batch.setFishingOperation(fishingOperationWithEmptyBatch); batch.setSpecies(taxon1); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_SEX); + batch.setSampleCategoryId(PmfmId2.SEX.getValue()); batch.setSampleCategoryValue(maleQualitativeValue); batch.setSampleCategoryWeight(2f); assertCreateAndReloadBenthosBatch(batch, esp1Batch.getId()); @@ -458,7 +456,7 @@ // Check species only if Vrac/HorsVrac or if batch has been load throw getAllxxx method // (Because getBenthosBatch(id) could not always retrieve the species) if (expectedBatch.getSpecies() != null && ( - enumerationFile.PMFM_ID_SORTED_UNSORTED.equals(expectedBatch.getSampleCategoryId()) + PmfmId2.SORTED_UNSORTED.getValue().equals(expectedBatch.getSampleCategoryId()) || actualBatch.getSpecies() != null)) { assertNotNull(actualBatch.getSpecies()); assertEquals(expectedBatch.getSpecies().getId(), actualBatch.getSpecies().getId()); Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceReadTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceReadTest.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceReadTest.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -25,6 +25,7 @@ */ import com.google.common.collect.Maps; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; import fr.ifremer.tutti.persistence.entities.data.FishingOperation; import fr.ifremer.tutti.persistence.entities.data.SpeciesBatch; @@ -62,11 +63,8 @@ protected FishingOperation fishingOperation; - protected TuttiEnumerationFile enumerationFile; - @Before public void setUp() throws Exception { - enumerationFile = TuttiPersistenceServiceLocator.getTechnicalPersistenceService().getEnumerationFile(); service = TuttiPersistenceServiceLocator.getSpeciesBatchPersistenceService(); fishingOperationService = TuttiPersistenceServiceLocator.getFishingOperationPersistenceService(); @@ -124,7 +122,7 @@ // Check species only if Vrac/HorsVrac or if batch has been load throw getAllxxx method // (Because getSpeciesBatch(id) could not always retrieve the species) if (expectedBatch.getSpecies() != null && ( - enumerationFile.PMFM_ID_SORTED_UNSORTED.equals(expectedBatch.getSampleCategoryId()) + PmfmId2.SORTED_UNSORTED.getValue().equals(expectedBatch.getSampleCategoryId()) || actualBatch.getSpecies() != null)) { assertNotNull(actualBatch.getSpecies()); assertEquals(expectedBatch.getSpecies().getId(), actualBatch.getSpecies().getId()); Modified: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceWriteTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceWriteTest.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/SpeciesBatchPersistenceServiceWriteTest.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -26,6 +26,7 @@ import com.google.common.collect.Lists; import com.google.common.collect.Maps; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; import fr.ifremer.tutti.persistence.entities.data.CatchBatch; import fr.ifremer.tutti.persistence.entities.data.CatchBatchs; @@ -105,8 +106,6 @@ protected Caracteristic frequencyPMFM; - protected TuttiEnumerationFile enumerationFile; - @Before public void setUp() throws Exception { @@ -116,7 +115,6 @@ CatchBatchPersistenceService catchBatchService = TuttiPersistenceServiceLocator.getCatchBatchPersistenceService(); FishingOperationPersistenceService fishingOperationService = TuttiPersistenceServiceLocator.getFishingOperationPersistenceService(); ReferentialPersistenceService referentialService = TuttiPersistenceServiceLocator.getReferentialPersistenceService(); - enumerationFile = TuttiPersistenceServiceLocator.getTechnicalPersistenceService().getEnumerationFile(); species = referentialService.getAllSpecies(); assertNotNull(species); @@ -213,7 +211,7 @@ batch.setParentBatch(null); batch.setFishingOperation(fishingOperationNoCatchBatch); batch.setSpecies(taxon1); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_SORTED_UNSORTED); + batch.setSampleCategoryId(PmfmId2.SORTED_UNSORTED.getValue()); batch.setSampleCategoryValue(vracQualitativeValue); batch.setSampleCategoryWeight(5f); @@ -231,7 +229,7 @@ batch.setParentBatch(esp1Batch); batch.setSpecies(taxon1); batch.setComment("ESP1 - Vrac/5 Male/2 ss-ech/1 Nombre/7"); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_SEX); + batch.setSampleCategoryId(PmfmId2.SEX.getValue()); batch.setSampleCategoryValue(maleQualitativeValue); batch.setSampleCategoryWeight(2f); batch.setWeight(1f); @@ -248,7 +246,7 @@ batch.setParentBatch(esp1Batch); batch.setSpecies(taxon1); batch.setComment("ESP1 - Vrac/5 Female/3 Nombre/14"); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_SEX); + batch.setSampleCategoryId(PmfmId2.SEX.getValue()); batch.setSampleCategoryValue(femaleQualitativeValue); batch.setSampleCategoryWeight(3f); batch.setWeight(null); @@ -264,7 +262,7 @@ batch = SpeciesBatchs.newSpeciesBatch(); batch.setParentBatch(null); batch.setSpecies(taxon2); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_SORTED_UNSORTED); + batch.setSampleCategoryId(PmfmId2.SORTED_UNSORTED.getValue()); batch.setSampleCategoryValue(vracQualitativeValue); batch.setSampleCategoryWeight(7f); @@ -277,7 +275,7 @@ batch.setParentBatch(esp2Batch); batch.setSpecies(taxon2); batch.setComment("ESP2 - Vrac/7 UNK/2 ss-ech/1 Nombre/11"); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_MATURITY); + batch.setSampleCategoryId(PmfmId2.MATURITY.getValue()); batch.setSampleCategoryValue(firstMaturityQualitativeValue); batch.setSampleCategoryWeight(2f); batch.setWeight(1f); @@ -290,7 +288,7 @@ // ----------------------------------------------------------------------------- // Batch : ESP2 - Vrac/7 UNK/1.75 ss-ech/1.11 Nombre/99 batch.setComment("ESP2 - Vrac/7 UNK/1.75 ss-ech/1.11 Nombre/99"); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_SEX); + batch.setSampleCategoryId(PmfmId2.SEX.getValue()); batch.setSampleCategoryValue(unkQualitativeValue); batch.setSampleCategoryWeight(1.75f); batch.setWeight(1.11f); @@ -318,7 +316,7 @@ // ----------------------------------------------------------------------------- // 7. Test get all root species // ----------------------------------------------------------------------------- - BatchContainer<SpeciesBatch> rootSpeciesBatc = service.getRootSpeciesBatch(fishingOperationWithEmptyBatch.getId(),false ); + BatchContainer<SpeciesBatch> rootSpeciesBatc = service.getRootSpeciesBatch(fishingOperationWithEmptyBatch.getId(), false); List<SpeciesBatch> rootSpeciesBatch = rootSpeciesBatc.getChildren(); assertNotNull(rootSpeciesBatch); assertEquals(2, rootSpeciesBatch.size()); @@ -377,7 +375,7 @@ batch.setParentBatch(null); batch.setFishingOperation(fishingOperationWithEmptyBatch); batch.setSpecies(taxon1); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_SORTED_UNSORTED); + batch.setSampleCategoryId(PmfmId2.SORTED_UNSORTED.getValue()); batch.setSampleCategoryValue(vracQualitativeValue); batch.setSampleCategoryWeight(5f); assertCreateAndReloadSpeciesBatch(batch, null); @@ -388,7 +386,7 @@ batch.setParentBatch(esp1Batch); batch.setFishingOperation(fishingOperationWithEmptyBatch); batch.setSpecies(taxon1); - batch.setSampleCategoryId(enumerationFile.PMFM_ID_SEX); + batch.setSampleCategoryId(PmfmId2.SEX.getValue()); batch.setSampleCategoryValue(maleQualitativeValue); batch.setSampleCategoryWeight(2f); assertCreateAndReloadSpeciesBatch(batch, esp1Batch.getId()); @@ -451,7 +449,7 @@ // Check species only if Vrac/HorsVrac or if batch has been load throw getAllxxx method // (Because getSpeciesBatch(id) could not always retrieve the species) if (expectedBatch.getSpecies() != null && ( - enumerationFile.PMFM_ID_SORTED_UNSORTED.equals(expectedBatch.getSampleCategoryId()) + PmfmId2.SORTED_UNSORTED.getValue().equals(expectedBatch.getSampleCategoryId()) || actualBatch.getSpecies() != null)) { assertNotNull(actualBatch.getSpecies()); assertEquals(expectedBatch.getSpecies().getId(), actualBatch.getSpecies().getId()); Deleted: trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFileTest.java =================================================================== --- trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFileTest.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-persistence/src/test/java/fr/ifremer/tutti/persistence/service/TuttiEnumerationFileTest.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -1,53 +0,0 @@ -package fr.ifremer.tutti.persistence.service; - -/* - * #%L - * Tutti :: Persistence API - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2012 - 2013 Ifremer - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/gpl-3.0.html>. - * #L% - */ - -import fr.ifremer.tutti.persistence.test.DatabaseResource; -import org.junit.Assert; -import org.junit.ClassRule; -import org.junit.Test; - -/** - * This test load the {@link TuttiEnumerationFile} via Spring and then - * validates that we miss not constant. - * - * @author tchemit <chemit@codelutin.com> - * @see TuttiEnumerationFile#init() - * @since 1.0 - */ -public class TuttiEnumerationFileTest { - - @ClassRule - public static final DatabaseResource dbResource = DatabaseResource.noDb(); - - @Test - public void init() { - - TuttiEnumerationFile file = - TuttiPersistenceServiceLocator.getTuttiEnumerationFile(); - Assert.assertNotNull(file); - } - -} Modified: trunk/tutti-service/pom.xml =================================================================== --- trunk/tutti-service/pom.xml 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-service/pom.xml 2014-04-24 10:17:09 UTC (rev 1725) @@ -48,6 +48,12 @@ <version>${project.version}</version> </dependency> + <!-- Adagio --> + <dependency> + <groupId>fr.ifremer.adagio</groupId> + <artifactId>adagio-core-allegro</artifactId> + </dependency> + <!-- JAXX --> <dependency> <groupId>org.nuiton.jaxx</groupId> Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/PersistenceService.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/PersistenceService.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/PersistenceService.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -30,6 +30,7 @@ import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.google.common.collect.Multimap; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.TuttiConfiguration; import fr.ifremer.tutti.persistence.InvalidBatchModelException; import fr.ifremer.tutti.persistence.TuttiPersistence; @@ -37,7 +38,6 @@ import fr.ifremer.tutti.persistence.entities.CaracteristicMap; import fr.ifremer.tutti.persistence.entities.TuttiEntities; import fr.ifremer.tutti.persistence.entities.data.AccidentalBatch; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; import fr.ifremer.tutti.persistence.entities.data.BenthosBatch; @@ -62,7 +62,6 @@ import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation; import fr.ifremer.tutti.persistence.entities.referential.TuttiReferentialEntity; import fr.ifremer.tutti.persistence.entities.referential.Vessel; -import fr.ifremer.tutti.persistence.service.TuttiEnumerationFile; import fr.ifremer.tutti.persistence.service.TuttiPersistenceServiceLocator; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.io.IOUtils; @@ -190,11 +189,6 @@ } @Override - public TuttiEnumerationFile getEnumerationFile() { - return driver.getEnumerationFile(); - } - - @Override public <V> V invoke(Callable<V> call) { return driver.invoke(call); } @@ -219,11 +213,6 @@ driver.sanityDb(); } - @Override - public void clearCache(String cacheName) { - driver.clearCache(cacheName); - } - public static final DateFormat EXPORT_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd"); public static final String EXPORT_DIRECTORY_FORMAT = "tutti-%s-%s"; @@ -950,7 +939,7 @@ //------------------------------------------------------------------------// @Override - public List<Attachment> getAllAttachments(AttachementObjectTypeEnum objectType, + public List<Attachment> getAllAttachments(ObjectTypeCode2 objectType, Integer objectId) { return driver.getAllAttachments(objectType, objectId); } @@ -976,7 +965,7 @@ } @Override - public void deleteAllAttachment(AttachementObjectTypeEnum objectType, Integer... objectIds) { + public void deleteAllAttachment(ObjectTypeCode2 objectType, Integer... objectIds) { driver.deleteAllAttachment(objectType, objectIds); } Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/multipost/MultiPostExportService.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/multipost/MultiPostExportService.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/multipost/MultiPostExportService.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -27,9 +27,9 @@ import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.google.common.io.Files; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.entities.CaracteristicMap; import fr.ifremer.tutti.persistence.entities.data.AccidentalBatch; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; import fr.ifremer.tutti.persistence.entities.data.BenthosBatch; @@ -246,7 +246,7 @@ addAttachments(id, batch.getIdAsInt(), - AttachementObjectTypeEnum.BATCH, + ObjectTypeCode2.BATCH, attachmentRows); } @@ -331,7 +331,7 @@ caracteristicRows.add(caracteristicRow); } - addAttachments(id, batch.getIdAsInt(), AttachementObjectTypeEnum.SAMPLE, attachmentRows); + addAttachments(id, batch.getIdAsInt(), ObjectTypeCode2.SAMPLE, attachmentRows); } File directory = Files.createTempDir(); @@ -420,7 +420,7 @@ caracteristicRows.add(caracteristicRow); } - addAttachments(id, batch.getIdAsInt(), AttachementObjectTypeEnum.SAMPLE, attachmentRows); + addAttachments(id, batch.getIdAsInt(), ObjectTypeCode2.SAMPLE, attachmentRows); } // export accidental catches @@ -538,7 +538,7 @@ rows.add(row); addFrequencies(id, batch.getId(), frequencyRows); - addAttachments(id, batch.getIdAsInt(), AttachementObjectTypeEnum.BATCH, attachmentRows); + addAttachments(id, batch.getIdAsInt(), ObjectTypeCode2.BATCH, attachmentRows); for (SpeciesBatch child : batch.getChildBatchs()) { createSpeciesRow(child, id, rows, frequencyRows, attachmentRows); @@ -568,7 +568,7 @@ rows.add(row); addFrequencies(id, batch.getId(), frequencyRows); - addAttachments(id, batch.getIdAsInt(), AttachementObjectTypeEnum.BATCH, attachmentRows); + addAttachments(id, batch.getIdAsInt(), ObjectTypeCode2.BATCH, attachmentRows); for (BenthosBatch child : batch.getChildBatchs()) { createBenthosRow(child, id, rows, frequencyRows, attachmentRows); @@ -600,7 +600,7 @@ protected void addAttachments(String batchId, int objectId, - AttachementObjectTypeEnum objectType, + ObjectTypeCode2 objectType, List<AttachmentRow> attachmentRows) { List<Attachment> attachments = persistenceService.getAllAttachments(objectType, objectId); Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/multipost/MultiPostImportService.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/multipost/MultiPostImportService.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/catches/multipost/MultiPostImportService.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -29,14 +29,12 @@ import com.google.common.collect.ArrayListMultimap; import com.google.common.collect.ListMultimap; import com.google.common.collect.Maps; -import org.nuiton.jaxx.application.ApplicationBusinessException; -import org.nuiton.jaxx.application.ApplicationIOUtil; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.entities.CaracteristicMap; import fr.ifremer.tutti.persistence.entities.TuttiEntities; import fr.ifremer.tutti.persistence.entities.TuttiEntity; import fr.ifremer.tutti.persistence.entities.data.AccidentalBatch; import fr.ifremer.tutti.persistence.entities.data.AccidentalBatchs; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.Attachments; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; @@ -70,6 +68,8 @@ import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.tuple.Pair; import org.nuiton.csv.Import; +import org.nuiton.jaxx.application.ApplicationBusinessException; +import org.nuiton.jaxx.application.ApplicationIOUtil; import java.io.File; import java.io.Reader; @@ -81,8 +81,8 @@ import java.util.Map; import java.util.concurrent.Callable; +import static org.nuiton.i18n.I18n.n; import static org.nuiton.i18n.I18n.t; -import static org.nuiton.i18n.I18n.n; /** * Service to export batches from a satellite post or import batches @@ -211,7 +211,7 @@ importAttachments(tempDir, batches, notImportedBatches, - AttachementObjectTypeEnum.BATCH); + ObjectTypeCode2.BATCH); // Import weights @@ -477,7 +477,7 @@ importAttachments(tempDir, batches, notImportedBatches, - AttachementObjectTypeEnum.BATCH); + ObjectTypeCode2.BATCH); // Import weights @@ -736,7 +736,7 @@ importAttachments(tempDir, batches, notImportedBatches, - AttachementObjectTypeEnum.BATCH); + ObjectTypeCode2.BATCH); // Import weights @@ -904,7 +904,7 @@ // Import attachments - importAttachments(tempDir, batches, AttachementObjectTypeEnum.SAMPLE); + importAttachments(tempDir, batches, ObjectTypeCode2.SAMPLE); return null; } }; @@ -1061,7 +1061,7 @@ // Import attachments - importAttachments(tempDir, batches, AttachementObjectTypeEnum.SAMPLE); + importAttachments(tempDir, batches, ObjectTypeCode2.SAMPLE); return null; } }; @@ -1214,7 +1214,8 @@ throw new ApplicationBusinessException(t("tutti.service.multipost.import.wrongOperation.error", decoratorService.getDecoratorByType(FishingOperation.class) - .toString(operation))); + .toString(operation) + )); } } } finally { @@ -1228,7 +1229,7 @@ protected <R extends TuttiEntity> void importAttachments(File directory, final Map<String, R> data, final Map<String, R> notImportedData, - AttachementObjectTypeEnum objectType) { + ObjectTypeCode2 objectType) { Function<AttachmentRow, Integer> getObjetcIdFunction = new Function<AttachmentRow, Integer>() { @Override @@ -1292,7 +1293,7 @@ protected <R extends TuttiEntity> void importAttachments(File directory, final Map<String, R> data, - AttachementObjectTypeEnum objectType) { + ObjectTypeCode2 objectType) { Function<AttachmentRow, Integer> getObjetcIdFunction = new Function<AttachmentRow, Integer>() { @Override Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/protocol/ProtocolImportExportService.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/protocol/ProtocolImportExportService.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/protocol/ProtocolImportExportService.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -38,7 +38,6 @@ import fr.ifremer.tutti.persistence.entities.protocol.TuttiProtocols; import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; import fr.ifremer.tutti.persistence.entities.referential.Species; -import fr.ifremer.tutti.persistence.service.TuttiEnumerationFile; import fr.ifremer.tutti.service.AbstractTuttiService; import fr.ifremer.tutti.service.PersistenceService; import fr.ifremer.tutti.service.TuttiServiceContext; @@ -75,21 +74,12 @@ private static final Log log = LogFactory.getLog(ProtocolImportExportService.class); - protected TuttiEnumerationFile enumerationFile; - - @Override - public void setServiceContext(TuttiServiceContext context) { - super.setServiceContext(context); - PersistenceService service = getService(PersistenceService.class); - enumerationFile = service.getEnumerationFile(); - } - public void exportProtocol(TuttiProtocol protocol, File file) { TuttiProtocols.toFile(protocol, file); } public TuttiProtocol importProtocol(File file) { - TuttiProtocol result = TuttiProtocols.fromFile(enumerationFile, file); + TuttiProtocol result = TuttiProtocols.fromFile(file); return result; } Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/psionimport/PsionImportService.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/psionimport/PsionImportService.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/psionimport/PsionImportService.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -31,8 +31,11 @@ import com.google.common.collect.Maps; import com.google.common.collect.Sets; import com.google.common.io.Files; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId2; import fr.ifremer.tutti.persistence.entities.TuttiEntities; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.Attachments; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; @@ -48,7 +51,6 @@ 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.persistence.service.TuttiEnumerationFile; import fr.ifremer.tutti.service.AbstractTuttiService; import fr.ifremer.tutti.service.PersistenceService; import fr.ifremer.tutti.service.TuttiServiceContext; @@ -111,8 +113,6 @@ protected PersistenceService persistenceService; - protected TuttiEnumerationFile enumerationFile; - protected CaracteristicQualitativeValue sortedCaracteristic; protected CaracteristicQualitativeValue unsortedCaracteristic; @@ -128,14 +128,12 @@ super.setServiceContext(context); persistenceService = getService(PersistenceService.class); - enumerationFile = persistenceService.getEnumerationFile(); - { // sorted/unsorted caracteristic Caracteristic caracteristic = persistenceService.getSortedUnsortedCaracteristic(); - sortedCaracteristic = TuttiEntities.getQualitativeValue(caracteristic, enumerationFile.QUALITATIVE_VRAC_ID); - unsortedCaracteristic = TuttiEntities.getQualitativeValue(caracteristic, enumerationFile.QUALITATIVE_HORS_VRAC_ID); + sortedCaracteristic = TuttiEntities.getQualitativeValue(caracteristic, QualitativeValueId.SORTED_VRAC.getValue()); + unsortedCaracteristic = TuttiEntities.getQualitativeValue(caracteristic, QualitativeValueId.SORTED_HORS_VRAC.getValue()); } { // sex caracteristic @@ -147,13 +145,13 @@ List<CaracteristicQualitativeValue> qualitativeValues = caracteristic.getQualitativeValue(); Map<Integer, CaracteristicQualitativeValue> sexById = TuttiEntities.splitByIdAsInt(qualitativeValues); - CaracteristicQualitativeValue femaleCaracteristic = sexById.get(enumerationFile.QUALITATIVE_SEX_FEMALE_ID); + CaracteristicQualitativeValue femaleCaracteristic = sexById.get(QualitativeValueId.SEX_FEMALE.getValue()); sexCaracteristicValues.put("F", femaleCaracteristic); sexCaracteristicValues.put("f", femaleCaracteristic); - CaracteristicQualitativeValue maleCaracteristic = sexById.get(enumerationFile.QUALITATIVE_SEX_MALE_ID); + CaracteristicQualitativeValue maleCaracteristic = sexById.get(QualitativeValueId.SEX_MALE.getValue()); sexCaracteristicValues.put("M", maleCaracteristic); sexCaracteristicValues.put("m", maleCaracteristic); - CaracteristicQualitativeValue unkownCaracteristic = sexById.get(enumerationFile.QUALITATIVE_SEX_UNDEFINED_ID); + CaracteristicQualitativeValue unkownCaracteristic = sexById.get(QualitativeValueId2.SEX_UNDEFINED.getValue()); sexCaracteristicValues.put("I", unkownCaracteristic); sexCaracteristicValues.put("i", unkownCaracteristic); } @@ -167,11 +165,11 @@ List<CaracteristicQualitativeValue> qualitativeValues = caracteristic.getQualitativeValue(); Map<Integer, CaracteristicQualitativeValue> byIds = TuttiEntities.splitByIdAsInt(qualitativeValues); - maturityCaracteristicValues.put("1", byIds.get(enumerationFile.QUALITATIVE_MATURITY_1_ID)); - maturityCaracteristicValues.put("2", byIds.get(enumerationFile.QUALITATIVE_MATURITY_2_ID)); - maturityCaracteristicValues.put("3", byIds.get(enumerationFile.QUALITATIVE_MATURITY_3_ID)); - maturityCaracteristicValues.put("4", byIds.get(enumerationFile.QUALITATIVE_MATURITY_4_ID)); - maturityCaracteristicValues.put("5", byIds.get(enumerationFile.QUALITATIVE_MATURITY_5_ID)); + maturityCaracteristicValues.put("1", byIds.get(QualitativeValueId2.MATURITY_1.getValue())); + maturityCaracteristicValues.put("2", byIds.get(QualitativeValueId2.MATURITY_2.getValue())); + maturityCaracteristicValues.put("3", byIds.get(QualitativeValueId2.MATURITY_3.getValue())); + maturityCaracteristicValues.put("4", byIds.get(QualitativeValueId2.MATURITY_4.getValue())); + maturityCaracteristicValues.put("5", byIds.get(QualitativeValueId2.MATURITY_5.getValue())); } } @@ -492,8 +490,6 @@ // insert all imported species batches - TuttiEnumerationFile enumerationFile = persistenceService.getEnumerationFile(); - Set<Species> species = importModel.getSpecies(); for (Species specy : species) { @@ -509,7 +505,7 @@ batchModel.getSpecies(), batchModel.getWeight(), batchModel.getSampleWeight(), - enumerationFile.PMFM_ID_SORTED_UNSORTED, + PmfmId2.SORTED_UNSORTED.getValue(), sortedCaracteristic); batch = persistenceService.createSpeciesBatch(batch, null); @@ -524,7 +520,7 @@ specy, null, null, - enumerationFile.PMFM_ID_SORTED_UNSORTED, + PmfmId2.SORTED_UNSORTED.getValue(), sortedCaracteristic); rootBatch = persistenceService.createSpeciesBatch(rootBatch, null); @@ -610,7 +606,7 @@ if (SEX_VALUES.contains(categoryCode)) { // sex caracteristic - caracteristicId = enumerationFile.PMFM_ID_SEX; + caracteristicId = PmfmId2.SEX.getValue(); caracteristicQualitativeValue = sexCaracteristicValues.get(categoryCode); result = new PsionImportBatchModel.SampleCategory(caracteristicId, caracteristicQualitativeValue); @@ -618,7 +614,7 @@ } else if (MATURITY_VALUES.contains(categoryCode)) { // maturity caracteristic - caracteristicId = enumerationFile.PMFM_ID_MATURITY; + caracteristicId = PmfmId2.MATURITY.getValue(); caracteristicQualitativeValue = maturityCaracteristicValues.get(categoryCode); result = new PsionImportBatchModel.SampleCategory(caracteristicId, caracteristicQualitativeValue); @@ -677,7 +673,7 @@ protected void addFileAsAttachment(File f, CatchBatch catchBatch) { Attachment attachment = Attachments.newAttachment(); - attachment.setObjectType(AttachementObjectTypeEnum.CATCH_BATCH); + attachment.setObjectType(ObjectTypeCode2.CATCH_BATCH); attachment.setObjectId(Integer.valueOf(catchBatch.getId())); attachment.setName(f.getName()); String date = DateFormat.getDateTimeInstance().format(context.currentDate()); Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/pupitri/PupitriCatch.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/pupitri/PupitriCatch.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/pupitri/PupitriCatch.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -25,11 +25,13 @@ */ import com.google.common.collect.Maps; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId2; import fr.ifremer.tutti.persistence.entities.TuttiEntities; 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.persistence.service.TuttiEnumerationFile; import org.apache.commons.lang3.mutable.MutableFloat; import java.io.Serializable; @@ -46,68 +48,68 @@ public static enum Signs { DEFAULT("0") { @Override - public Integer getCategory(TuttiEnumerationFile enumerationFile) { - return enumerationFile.PMFM_ID_SEX; + public Integer getCategory() { + return PmfmId2.SEX.getValue(); } @Override - public Integer getQualitativeValueId(TuttiEnumerationFile enumerationFile) { - return enumerationFile.QUALITATIVE_SEX_UNDEFINED_ID; + public Integer getQualitativeValueId() { + return QualitativeValueId2.SEX_UNDEFINED.getValue(); } }, MALE("1") { @Override - public Integer getCategory(TuttiEnumerationFile enumerationFile) { - return enumerationFile.PMFM_ID_SEX; + public Integer getCategory() { + return PmfmId2.SEX.getValue(); } @Override - public Integer getQualitativeValueId(TuttiEnumerationFile enumerationFile) { - return enumerationFile.QUALITATIVE_SEX_MALE_ID; + public Integer getQualitativeValueId() { + return QualitativeValueId.SEX_MALE.getValue(); } }, FEMALE("2") { @Override - public Integer getCategory(TuttiEnumerationFile enumerationFile) { - return enumerationFile.PMFM_ID_SEX; + public Integer getCategory() { + return PmfmId2.SEX.getValue(); } @Override - public Integer getQualitativeValueId(TuttiEnumerationFile enumerationFile) { - return enumerationFile.QUALITATIVE_SEX_FEMALE_ID; + public Integer getQualitativeValueId() { + return QualitativeValueId.SEX_FEMALE.getValue(); } }, SMALL("P") { @Override - public Integer getCategory(TuttiEnumerationFile enumerationFile) { - return enumerationFile.PMFM_ID_SIZE_CATEGORY; + public Integer getCategory() { + return PmfmId2.SIZE_CATEGORY.getValue(); } @Override - public Integer getQualitativeValueId(TuttiEnumerationFile enumerationFile) { - return enumerationFile.QUALITATIVE_SIZE_SMALL_ID; + public Integer getQualitativeValueId() { + return QualitativeValueId.SIZE_SMALL.getValue(); } }, MEDIUM("M") { @Override - public Integer getCategory(TuttiEnumerationFile enumerationFile) { - return enumerationFile.PMFM_ID_SIZE_CATEGORY; + public Integer getCategory() { + return PmfmId2.SIZE_CATEGORY.getValue(); } @Override - public Integer getQualitativeValueId(TuttiEnumerationFile enumerationFile) { - return enumerationFile.QUALITATIVE_SIZE_MEDIUM_ID; + public Integer getQualitativeValueId() { + return QualitativeValueId.SIZE_MEDIUM.getValue(); } }, BIG("G") { @Override - public Integer getCategory(TuttiEnumerationFile enumerationFile) { - return enumerationFile.PMFM_ID_SIZE_CATEGORY; + public Integer getCategory() { + return PmfmId2.SIZE_CATEGORY.getValue(); } @Override - public Integer getQualitativeValueId(TuttiEnumerationFile enumerationFile) { - return enumerationFile.QUALITATIVE_SIZE_BIG_ID; + public Integer getQualitativeValueId() { + return QualitativeValueId.SIZE_BIG.getValue(); } }; @@ -128,14 +130,13 @@ return result; } - public abstract Integer getCategory(TuttiEnumerationFile enumerationFile); + public abstract Integer getCategory(); - public abstract Integer getQualitativeValueId(TuttiEnumerationFile enumerationFile); + public abstract Integer getQualitativeValueId(); - public void registerSign(TuttiEnumerationFile enumerationFile, - Caracteristic caracteristic, + public void registerSign(Caracteristic caracteristic, Map<Signs, CaracteristicQualitativeValue> map) { - Integer valueId = getQualitativeValueId(enumerationFile); + Integer valueId = getQualitativeValueId(); CaracteristicQualitativeValue result = TuttiEntities.getQualitativeValue(caracteristic, valueId); map.put(this, result); } Modified: trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/pupitri/PupitriImportExportService.java =================================================================== --- trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/pupitri/PupitriImportExportService.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-service/src/main/java/fr/ifremer/tutti/service/pupitri/PupitriImportExportService.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -32,8 +32,10 @@ import com.google.common.collect.Maps; import com.google.common.collect.Multimaps; import com.google.common.collect.Sets; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId; import fr.ifremer.tutti.persistence.entities.TuttiEntities; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.Attachments; import fr.ifremer.tutti.persistence.entities.data.BatchContainer; @@ -44,7 +46,6 @@ 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.persistence.service.TuttiEnumerationFile; import fr.ifremer.tutti.service.AbstractTuttiService; import fr.ifremer.tutti.service.DecoratorService; import fr.ifremer.tutti.service.PersistenceService; @@ -105,32 +106,29 @@ decoratorService = getService(DecoratorService.class); dataContext = context.getDataContext(); - TuttiEnumerationFile enumerationFile = - persistenceService.getEnumerationFile(); - signsToCaracteristicValue = Maps.newEnumMap(PupitriCatch.Signs.class); { // sorted/unsorted caracteristic Caracteristic caracteristic = persistenceService.getSortedUnsortedCaracteristic(); - sortedCaracteristic = TuttiEntities.getQualitativeValue(caracteristic, enumerationFile.QUALITATIVE_VRAC_ID); - unsortedCaracteristic = TuttiEntities.getQualitativeValue(caracteristic, enumerationFile.QUALITATIVE_HORS_VRAC_ID); + sortedCaracteristic = TuttiEntities.getQualitativeValue(caracteristic, QualitativeValueId.SORTED_VRAC.getValue()); + unsortedCaracteristic = TuttiEntities.getQualitativeValue(caracteristic, QualitativeValueId.SORTED_HORS_VRAC.getValue()); } { // sex category Caracteristic caracteristic = persistenceService.getSexCaracteristic(); - PupitriCatch.Signs.DEFAULT.registerSign(enumerationFile, caracteristic, signsToCaracteristicValue); - PupitriCatch.Signs.FEMALE.registerSign(enumerationFile, caracteristic, signsToCaracteristicValue); - PupitriCatch.Signs.MALE.registerSign(enumerationFile, caracteristic, signsToCaracteristicValue); + PupitriCatch.Signs.DEFAULT.registerSign(caracteristic, signsToCaracteristicValue); + PupitriCatch.Signs.FEMALE.registerSign(caracteristic, signsToCaracteristicValue); + PupitriCatch.Signs.MALE.registerSign(caracteristic, signsToCaracteristicValue); } { // size category Caracteristic caracteristic = persistenceService.getSizeCategoryCaracteristic(); - PupitriCatch.Signs.SMALL.registerSign(enumerationFile, caracteristic, signsToCaracteristicValue); - PupitriCatch.Signs.MEDIUM.registerSign(enumerationFile, caracteristic, signsToCaracteristicValue); - PupitriCatch.Signs.BIG.registerSign(enumerationFile, caracteristic, signsToCaracteristicValue); + PupitriCatch.Signs.SMALL.registerSign(caracteristic, signsToCaracteristicValue); + PupitriCatch.Signs.MEDIUM.registerSign(caracteristic, signsToCaracteristicValue); + PupitriCatch.Signs.BIG.registerSign(caracteristic, signsToCaracteristicValue); } } @@ -194,7 +192,7 @@ protected void addFileAsAttachment(File f, CatchBatch catchBatch) { Attachment attachment = Attachments.newAttachment(); - attachment.setObjectType(AttachementObjectTypeEnum.CATCH_BATCH); + attachment.setObjectType(ObjectTypeCode2.CATCH_BATCH); attachment.setObjectId(Integer.valueOf(catchBatch.getId())); attachment.setName(f.getName()); String date = DateFormat.getDateTimeInstance().format(context.currentDate()); @@ -391,7 +389,6 @@ // insert all imported species batches - TuttiEnumerationFile enumerationFile = persistenceService.getEnumerationFile(); Decorator<Species> speciesDecorator = decoratorService.getDecoratorByType(Species.class); for (PupitriCatch pupitriCatch : result.getCatches()) { @@ -413,7 +410,7 @@ SpeciesBatch batch = createSpeciesBatch(operation, species, null, - enumerationFile.PMFM_ID_SORTED_UNSORTED, + PmfmId2.SORTED_UNSORTED.getValue(), cqv); batch = persistenceService.createSpeciesBatch(batch, null); @@ -425,7 +422,7 @@ PupitriCatch.Signs signs = entry.getKey(); float catchWeight = entry.getValue().floatValue(); - Integer categoryId = signs.getCategory(enumerationFile); + Integer categoryId = signs.getCategory(); CaracteristicQualitativeValue splitCqv = signsToCaracteristicValue.get(signs); SpeciesBatch childBatch = createSpeciesBatch( operation, @@ -453,7 +450,7 @@ SpeciesBatch batch = createSpeciesBatch(operation, species, totalWeight, - enumerationFile.PMFM_ID_SORTED_UNSORTED, + PmfmId2.SORTED_UNSORTED.getValue(), cqv); persistenceService.createSpeciesBatch(batch, null); Modified: trunk/tutti-ui-swing/pom.xml =================================================================== --- trunk/tutti-ui-swing/pom.xml 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/pom.xml 2014-04-24 10:17:09 UTC (rev 1725) @@ -111,6 +111,16 @@ <version>${project.version}</version> </dependency> + <!-- Adagio --> + <dependency> + <groupId>fr.ifremer.adagio</groupId> + <artifactId>adagio-core-shared</artifactId> + </dependency> + <dependency> + <groupId>fr.ifremer.adagio</groupId> + <artifactId>adagio-core-allegro</artifactId> + </dependency> + <!-- Nuiton --> <dependency> <groupId>org.nuiton</groupId> Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/action/ImportPupitriAction.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/action/ImportPupitriAction.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/action/ImportPupitriAction.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -26,10 +26,11 @@ import com.google.common.base.Joiner; import com.google.common.collect.Lists; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; import fr.ifremer.tutti.persistence.entities.data.CatchBatch; import fr.ifremer.tutti.persistence.entities.data.FishingOperation; import fr.ifremer.tutti.persistence.entities.data.SampleCategoryModel; -import fr.ifremer.tutti.persistence.service.TuttiEnumerationFile; import fr.ifremer.tutti.service.PersistenceService; import fr.ifremer.tutti.service.pupitri.PupitriImportExportService; import fr.ifremer.tutti.service.pupitri.PupitriImportResult; @@ -89,14 +90,13 @@ // must check that sample category model is compatible for pupitri import // means need some categories - TuttiEnumerationFile enumerationFile = persistenceService.getEnumerationFile(); SampleCategoryModel sampleCategoryModel = getDataContext().getSampleCategoryModel(); List<String> missingCategories = Lists.newArrayList(); - if (!sampleCategoryModel.containsCategoryId(enumerationFile.PMFM_ID_SIZE_CATEGORY)) { + if (!sampleCategoryModel.containsCategoryId(PmfmId2.SIZE_CATEGORY.getValue())) { missingCategories.add("<li>" + persistenceService.getSizeCategoryCaracteristic().getParameterName() + "</li>"); } - if (!sampleCategoryModel.containsCategoryId(enumerationFile.PMFM_ID_SEX)) { + if (!sampleCategoryModel.containsCategoryId(PmfmId2.SEX.getValue())) { missingCategories.add("<li>" + persistenceService.getSexCaracteristic().getParameterName() + "</li>"); } if (!missingCategories.isEmpty()) { Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/category/EditSampleCategoryModelUIHandler.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/category/EditSampleCategoryModelUIHandler.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/category/EditSampleCategoryModelUIHandler.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -228,7 +228,6 @@ getDataContext().getSampleCategoryModel(); EditSampleCategoryModelUIModel model = new EditSampleCategoryModelUIModel( - getPersistenceService().getEnumerationFile(), sampleCategoryModel.getCategory(), caracteristics); Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/category/EditSampleCategoryModelUIModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/category/EditSampleCategoryModelUIModel.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/category/EditSampleCategoryModelUIModel.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -26,10 +26,10 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; +import fr.ifremer.adagio.core.dao.referential.pmfm.PmfmId2; import fr.ifremer.tutti.persistence.entities.data.SampleCategoryModel; import fr.ifremer.tutti.persistence.entities.data.SampleCategoryModelEntry; import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; -import fr.ifremer.tutti.persistence.service.TuttiEnumerationFile; import fr.ifremer.tutti.ui.swing.util.table.AbstractTuttiTableUIModel; import org.nuiton.util.beans.Binder; import org.nuiton.util.beans.BinderFactory; @@ -71,19 +71,17 @@ private boolean moveDownEntryEnabled; - public EditSampleCategoryModelUIModel(TuttiEnumerationFile enumerationFile, - List<SampleCategoryModelEntry> category, + public EditSampleCategoryModelUIModel(List<SampleCategoryModelEntry> category, List<Caracteristic> caracteristicList) { super(SampleCategoryModel.class, fromBeanBinder, toBeanBinder); Preconditions.checkNotNull(caracteristicList, "need a not null caracteristicList"); - Preconditions.checkNotNull(enumerationFile, "need a not null enumerationFile"); Preconditions.checkNotNull(category, "need a not null category list"); Preconditions.checkArgument(!category.isEmpty(), "need at least one first category (sorted-unsorted)"); this.caracteristicList = caracteristicList; this.firstCategory = category.get(0); - Preconditions.checkArgument(enumerationFile.PMFM_ID_SORTED_UNSORTED.equals(firstCategory.getCategoryId()), "first category must be sorted-unsorted caracteristic but was: " + firstCategory.getCategoryId()); + Preconditions.checkArgument(PmfmId2.SORTED_UNSORTED.getValue().equals(firstCategory.getCategoryId()), "first category must be sorted-unsorted caracteristic but was: " + firstCategory.getCategoryId()); List<EditSampleCategoryModelRowModel> rows = Lists.newArrayList(); Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/EditCruiseUIModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/EditCruiseUIModel.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/EditCruiseUIModel.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -25,7 +25,7 @@ */ import com.google.common.collect.Lists; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.Cruise; import fr.ifremer.tutti.persistence.entities.data.Cruises; @@ -192,8 +192,8 @@ //------------------------------------------------------------------------// @Override - public AttachementObjectTypeEnum getObjectType() { - return AttachementObjectTypeEnum.SCIENTIFIC_CRUISE; + public ObjectTypeCode2 getObjectType() { + return ObjectTypeCode2.SCIENTIFIC_CRUISE; } @Override Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/ValidateCruiseUI.jaxx =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/ValidateCruiseUI.jaxx 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/ValidateCruiseUI.jaxx 2014-04-24 10:17:09 UTC (rev 1725) @@ -65,8 +65,7 @@ </JXTitledPanel> - <FishingOperationsUI id='operationPanel' - constructorParams='this'> + <FishingOperationsUI id='operationPanel' constructorParams='this'> </FishingOperationsUI> </JSplitPane> \ No newline at end of file Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/ValidateCruiseUIHandler.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/ValidateCruiseUIHandler.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/ValidateCruiseUIHandler.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -248,7 +248,7 @@ } } - protected class OperationTreeNode extends DefaultMutableTreeNode { + protected static class OperationTreeNode extends DefaultMutableTreeNode { private static final long serialVersionUID = 1L; @@ -282,7 +282,7 @@ } } - protected class MessageTreeNode extends DefaultMutableTreeNode { + protected static class MessageTreeNode extends DefaultMutableTreeNode { private static final long serialVersionUID = 1L; Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/ValidateCruiseUIModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/ValidateCruiseUIModel.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/cruise/ValidateCruiseUIModel.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -48,10 +48,14 @@ public static final String PROPERTY_VALIDATOR = "validator"; + public static final String PROPERTY_CAN_SYNCH = "canSynch"; + protected FishingOperation selectedFishingOperation; protected Map<FishingOperation, NuitonValidatorResult> validator; + protected boolean canSynch; + public FishingOperation getSelectedFishingOperation() { return selectedFishingOperation; } @@ -71,4 +75,14 @@ this.validator = validator; firePropertyChange(PROPERTY_VALIDATOR, oldValue, validator); } + + public boolean isCanSynch() { + return canSynch; + } + + public void setCanSynch(boolean canSynch) { + Object oldValue = isCanSynch(); + this.canSynch = canSynch; + firePropertyChange(PROPERTY_CAN_SYNCH, oldValue, canSynch); + } } Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/EditFishingOperationUIModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/EditFishingOperationUIModel.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/EditFishingOperationUIModel.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -25,11 +25,9 @@ */ import com.google.common.collect.Lists; -import org.nuiton.jaxx.application.swing.tab.TabContentModel; -import fr.ifremer.tutti.type.CoordinateEditorType; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.entities.CaracteristicMap; import fr.ifremer.tutti.persistence.entities.TuttiEntities; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.Cruise; import fr.ifremer.tutti.persistence.entities.data.FishingOperation; @@ -38,12 +36,14 @@ import fr.ifremer.tutti.persistence.entities.referential.Person; import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation; import fr.ifremer.tutti.persistence.entities.referential.Vessel; +import fr.ifremer.tutti.type.CoordinateEditorType; import fr.ifremer.tutti.ui.swing.util.AbstractTuttiBeanUIModel; import fr.ifremer.tutti.ui.swing.util.attachment.AttachmentModelAware; import jaxx.runtime.swing.editor.gis.DmdCoordinate; import jaxx.runtime.swing.editor.gis.DmsCoordinate; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang3.StringUtils; +import org.nuiton.jaxx.application.swing.tab.TabContentModel; import org.nuiton.util.DateUtil; import org.nuiton.util.beans.Binder; import org.nuiton.util.beans.BinderFactory; @@ -965,8 +965,8 @@ //------------------------------------------------------------------------// @Override - public AttachementObjectTypeEnum getObjectType() { - return AttachementObjectTypeEnum.OPERATION; + public ObjectTypeCode2 getObjectType() { + return ObjectTypeCode2.OPERATION; } @Override Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/EditCatchesUIModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/EditCatchesUIModel.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/EditCatchesUIModel.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -28,7 +28,7 @@ import com.google.common.collect.HashMultimap; import com.google.common.collect.Lists; import com.google.common.collect.Multimap; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.CatchBatch; import fr.ifremer.tutti.persistence.entities.data.CatchBatchs; @@ -762,8 +762,8 @@ //------------------------------------------------------------------------// @Override - public AttachementObjectTypeEnum getObjectType() { - return AttachementObjectTypeEnum.CATCH_BATCH; + public ObjectTypeCode2 getObjectType() { + return ObjectTypeCode2.CATCH_BATCH; } @Override Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/accidental/AccidentalBatchRowModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/accidental/AccidentalBatchRowModel.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/accidental/AccidentalBatchRowModel.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -25,16 +25,16 @@ */ import com.google.common.collect.Lists; -import fr.ifremer.tutti.type.WeightUnit; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.entities.CaracteristicMap; import fr.ifremer.tutti.persistence.entities.data.AccidentalBatch; import fr.ifremer.tutti.persistence.entities.data.AccidentalBatchs; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.FishingOperation; 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.type.WeightUnit; import fr.ifremer.tutti.ui.swing.util.AbstractTuttiBeanUIModel; import fr.ifremer.tutti.ui.swing.util.attachment.AttachmentModelAware; import fr.ifremer.tutti.ui.swing.util.caracteristics.CaracteristicMapColumnRowModel; @@ -259,8 +259,8 @@ //------------------------------------------------------------------------// @Override - public AttachementObjectTypeEnum getObjectType() { - return AttachementObjectTypeEnum.SAMPLE; + public ObjectTypeCode2 getObjectType() { + return ObjectTypeCode2.SAMPLE; } @Override Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/BenthosBatchRowModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/BenthosBatchRowModel.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/BenthosBatchRowModel.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -26,10 +26,8 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; -import fr.ifremer.tutti.ui.swing.util.computable.ComputableData; -import fr.ifremer.tutti.type.WeightUnit; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.entities.TuttiEntities; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.BenthosBatch; import fr.ifremer.tutti.persistence.entities.data.BenthosBatchFrequency; @@ -39,12 +37,13 @@ import fr.ifremer.tutti.persistence.entities.data.SampleCategoryModel; import fr.ifremer.tutti.persistence.entities.data.SampleCategoryModelEntry; import fr.ifremer.tutti.persistence.entities.referential.Species; +import fr.ifremer.tutti.type.WeightUnit; import fr.ifremer.tutti.ui.swing.content.operation.catches.SampleCategoryAble; import fr.ifremer.tutti.ui.swing.content.operation.catches.benthos.frequency.BenthosFrequencyRowModel; import fr.ifremer.tutti.ui.swing.util.AbstractTuttiBeanUIModel; import fr.ifremer.tutti.ui.swing.util.attachment.AttachmentModelAware; +import fr.ifremer.tutti.ui.swing.util.computable.ComputableData; import org.apache.commons.collections.CollectionUtils; -import org.apache.commons.lang3.ObjectUtils; import org.nuiton.util.beans.Binder; import org.nuiton.util.beans.BinderFactory; @@ -445,8 +444,8 @@ //------------------------------------------------------------------------// @Override - public AttachementObjectTypeEnum getObjectType() { - return AttachementObjectTypeEnum.BATCH; + public ObjectTypeCode2 getObjectType() { + return ObjectTypeCode2.BATCH; } @Override Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/BenthosBatchUIHandler.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/BenthosBatchUIHandler.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/BenthosBatchUIHandler.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -27,6 +27,7 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; import com.google.common.collect.Sets; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId; import fr.ifremer.tutti.ui.swing.util.computable.ComputableDataTableCell; import org.nuiton.jaxx.application.swing.table.ColumnIdentifier; import fr.ifremer.tutti.type.WeightUnit; @@ -674,8 +675,7 @@ super.beforeInit(ui); - qualitative_unsorted_id = - getContext().getPersistenceService().getEnumerationFile().QUALITATIVE_UNSORTED_ID; + qualitative_unsorted_id = QualitativeValueId.UNSORTED.getValue(); weightUnit = getConfig().getBenthosWeightUnit(); Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/create/CreateBenthosBatchUIHandler.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/create/CreateBenthosBatchUIHandler.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/benthos/create/CreateBenthosBatchUIHandler.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -27,6 +27,7 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; import com.google.common.collect.Multimap; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId; import org.nuiton.jaxx.application.swing.util.Cancelable; import fr.ifremer.tutti.type.WeightUnit; import fr.ifremer.tutti.persistence.entities.data.SampleCategoryModel; @@ -174,7 +175,7 @@ SampleCategoryModelEntry caracteristic = sampleCategoryModel.getCategoryById(sampleCategoryModel.getFirstCategoryId()); - Integer vracId = getPersistenceService().getEnumerationFile().QUALITATIVE_VRAC_ID; + Integer vracId = QualitativeValueId.SORTED_VRAC.getValue(); CaracteristicQualitativeValue vracValue = null; for (CaracteristicQualitativeValue caracteristicQualitativeValue : caracteristic.getCaracteristic().getQualitativeValue()) { Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/IndividualObservationBatchRowModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/IndividualObservationBatchRowModel.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/IndividualObservationBatchRowModel.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -23,8 +23,8 @@ */ import com.google.common.collect.Lists; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.entities.CaracteristicMap; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.FishingOperation; import fr.ifremer.tutti.persistence.entities.data.IndividualObservationBatch; @@ -271,8 +271,8 @@ //------------------------------------------------------------------------// @Override - public AttachementObjectTypeEnum getObjectType() { - return AttachementObjectTypeEnum.SAMPLE; + public ObjectTypeCode2 getObjectType() { + return ObjectTypeCode2.SAMPLE; } @Override Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/marinelitter/MarineLitterBatchRowModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/marinelitter/MarineLitterBatchRowModel.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/marinelitter/MarineLitterBatchRowModel.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -25,14 +25,14 @@ */ import com.google.common.collect.Lists; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.FishingOperation; import fr.ifremer.tutti.persistence.entities.data.MarineLitterBatch; import fr.ifremer.tutti.persistence.entities.data.MarineLitterBatchs; import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue; +import fr.ifremer.tutti.type.WeightUnit; import fr.ifremer.tutti.ui.swing.util.AbstractTuttiBeanUIModel; -import fr.ifremer.tutti.type.WeightUnit; import fr.ifremer.tutti.ui.swing.util.attachment.AttachmentModelAware; import org.nuiton.util.beans.Binder; import org.nuiton.util.beans.BinderFactory; @@ -206,8 +206,8 @@ //------------------------------------------------------------------------// @Override - public AttachementObjectTypeEnum getObjectType() { - return AttachementObjectTypeEnum.BATCH; + public ObjectTypeCode2 getObjectType() { + return ObjectTypeCode2.BATCH; } @Override Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/SpeciesBatchRowModel.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/SpeciesBatchRowModel.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/SpeciesBatchRowModel.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -26,8 +26,8 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.entities.TuttiEntities; -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.FishingOperation; import fr.ifremer.tutti.persistence.entities.data.SampleCategory; @@ -547,8 +547,8 @@ //------------------------------------------------------------------------// @Override - public AttachementObjectTypeEnum getObjectType() { - return AttachementObjectTypeEnum.BATCH; + public ObjectTypeCode2 getObjectType() { + return ObjectTypeCode2.BATCH; } @Override Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/SpeciesBatchUIHandler.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/SpeciesBatchUIHandler.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/SpeciesBatchUIHandler.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -27,6 +27,7 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; import com.google.common.collect.Sets; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId; import fr.ifremer.tutti.ui.swing.util.computable.ComputableDataTableCell; import org.nuiton.jaxx.application.swing.table.ColumnIdentifier; import fr.ifremer.tutti.type.WeightUnit; @@ -632,8 +633,7 @@ log.debug("beforeInit: " + ui); } - qualitative_unsorted_id = - getContext().getPersistenceService().getEnumerationFile().QUALITATIVE_UNSORTED_ID; + qualitative_unsorted_id = QualitativeValueId.UNSORTED.getValue(); weightUnit = getConfig().getSpeciesWeightUnit(); Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/create/CreateSpeciesBatchUIHandler.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/create/CreateSpeciesBatchUIHandler.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/create/CreateSpeciesBatchUIHandler.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -27,6 +27,7 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; import com.google.common.collect.Multimap; +import fr.ifremer.adagio.core.dao.referential.pmfm.QualitativeValueId; import org.nuiton.jaxx.application.swing.util.Cancelable; import fr.ifremer.tutti.type.WeightUnit; import fr.ifremer.tutti.persistence.entities.data.SampleCategoryModel; @@ -175,7 +176,7 @@ SampleCategoryModelEntry caracteristic = sampleCategoryModel.getCategoryById(sampleCategoryModel.getFirstCategoryId()); - Integer vracId = getPersistenceService().getEnumerationFile().QUALITATIVE_VRAC_ID; + Integer vracId = QualitativeValueId.SORTED_VRAC.getValue(); CaracteristicQualitativeValue vracValue = null; for (CaracteristicQualitativeValue caracteristicQualitativeValue : caracteristic.getCaracteristic().getQualitativeValue()) { Modified: trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/util/attachment/AttachmentModelAware.java =================================================================== --- trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/util/attachment/AttachmentModelAware.java 2014-04-24 10:05:12 UTC (rev 1724) +++ trunk/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/util/attachment/AttachmentModelAware.java 2014-04-24 10:17:09 UTC (rev 1725) @@ -24,7 +24,7 @@ * #L% */ -import fr.ifremer.tutti.persistence.entities.data.AttachementObjectTypeEnum; +import fr.ifremer.adagio.core.dao.referential.pmfm.ObjectTypeCode2; import fr.ifremer.tutti.persistence.entities.data.Attachment; import java.io.Serializable; @@ -43,7 +43,7 @@ String PROPERTY_OBJECT_ID = "objectId"; - AttachementObjectTypeEnum getObjectType(); + ObjectTypeCode2 getObjectType(); Integer getObjectId();