This is an automated email from the git hooks/post-receive script. New commit to branch feature/7458 in repository observe. See http://git.codelutin.com/observe.git commit a8f3901d865d49b26668c1f17eaacefa173da4d4 Author: Tony CHEMIT <chemit@codelutin.com> Date: Wed Aug 19 10:33:32 2015 +0200 Mise en place d'une classe pour initialiser tous les dto du modèle --- .../ird/observe/services/ObserveServiceTopia.java | 39 + .../services/dto/ObserveDtosInitializer.java | 1033 ++++++++++++++++++++ 2 files changed, 1072 insertions(+) diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/ObserveServiceTopia.java b/observe-services-topia/src/main/java/fr/ird/observe/services/ObserveServiceTopia.java index 2b22014..bf2d0da 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/ObserveServiceTopia.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/ObserveServiceTopia.java @@ -1,6 +1,14 @@ package fr.ird.observe.services; import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableBiMap; +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.services.dto.IdDto; +import fr.ird.observe.services.dto.ObserveDtosInitializer; +import fr.ird.observe.services.dto.ObserveModelInitializerRunner; +import org.nuiton.topia.persistence.TopiaEntity; + +import java.util.Map; /** * Created on 16/08/15. @@ -11,10 +19,41 @@ public class ObserveServiceTopia implements ObserveService { protected ObserveServiceContextTopia serviceContext; + protected static ImmutableBiMap<Class<?>, Class<?>> DTO_TO_ENTITY_TYPES; + + private static boolean init; + + public static synchronized void init() { + if (!init) { + ObserveModelInitializerRunner.init(new ObserveDtosInitializer()); + DTO_TO_ENTITY_TYPES = ObserveDtosInitializer.getDtoToEntityTypes(); + init = true; + } + } + + static { + init(); + } + @Override public void setServiceContext(ObserveServiceContext serviceContext) { Preconditions.checkNotNull(serviceContext, "serviceContext can't be null."); Preconditions.checkArgument(serviceContext instanceof ObserveServiceContextTopia, "serviceContext must be of type " + ObserveServiceContextTopia.class.getName()); this.serviceContext = (ObserveServiceContextTopia) serviceContext; } + + public static <D extends IdDto, E extends TopiaEntity> Class<E> getEntityType(Class<D> dtoType) { + Class<?> entityType = DTO_TO_ENTITY_TYPES.get(dtoType); + return (Class<E>) entityType; + } + + public static <E extends TopiaEntity, M extends IdDto> Class<M> getDtoType(Class<E> entityType) { + Class<?> modelType = DTO_TO_ENTITY_TYPES.inverse().get(entityType); + return (Class<M>) modelType; + } + + public static ImmutableSet<Map.Entry<Class<?>, Class<?>>> getDtoTypes() { + return DTO_TO_ENTITY_TYPES.entrySet(); + } + } diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/dto/ObserveDtosInitializer.java b/observe-services-topia/src/main/java/fr/ird/observe/services/dto/ObserveDtosInitializer.java new file mode 100644 index 0000000..7606aa7 --- /dev/null +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/dto/ObserveDtosInitializer.java @@ -0,0 +1,1033 @@ +package fr.ird.observe.services.dto; + +import com.google.common.collect.ImmutableBiMap; +import fr.ird.observe.entities.referentiel.Country; +import fr.ird.observe.entities.referentiel.FpaZone; +import fr.ird.observe.entities.referentiel.Gear; +import fr.ird.observe.entities.referentiel.GearCaracteristic; +import fr.ird.observe.entities.referentiel.GearCaracteristicType; +import fr.ird.observe.entities.referentiel.Harbour; +import fr.ird.observe.entities.referentiel.I18nReferenceEntity; +import fr.ird.observe.entities.referentiel.LengthWeightParameter; +import fr.ird.observe.entities.referentiel.Ocean; +import fr.ird.observe.entities.referentiel.Organism; +import fr.ird.observe.entities.referentiel.Person; +import fr.ird.observe.entities.referentiel.Program; +import fr.ird.observe.entities.referentiel.Sex; +import fr.ird.observe.entities.referentiel.Species; +import fr.ird.observe.entities.referentiel.SpeciesGroup; +import fr.ird.observe.entities.referentiel.SpeciesList; +import fr.ird.observe.entities.referentiel.Vessel; +import fr.ird.observe.entities.referentiel.VesselSizeCategory; +import fr.ird.observe.entities.referentiel.VesselType; +import fr.ird.observe.entities.referentiel.longline.BaitHaulingStatus; +import fr.ird.observe.entities.referentiel.longline.BaitSettingStatus; +import fr.ird.observe.entities.referentiel.longline.BaitType; +import fr.ird.observe.entities.referentiel.longline.CatchFateLongline; +import fr.ird.observe.entities.referentiel.longline.EncounterType; +import fr.ird.observe.entities.referentiel.longline.Healthness; +import fr.ird.observe.entities.referentiel.longline.HookPosition; +import fr.ird.observe.entities.referentiel.longline.HookSize; +import fr.ird.observe.entities.referentiel.longline.HookType; +import fr.ird.observe.entities.referentiel.longline.ItemHorizontalPosition; +import fr.ird.observe.entities.referentiel.longline.ItemVerticalPosition; +import fr.ird.observe.entities.referentiel.longline.LightsticksColor; +import fr.ird.observe.entities.referentiel.longline.LightsticksType; +import fr.ird.observe.entities.referentiel.longline.LineType; +import fr.ird.observe.entities.referentiel.longline.MaturityStatus; +import fr.ird.observe.entities.referentiel.longline.MitigationType; +import fr.ird.observe.entities.referentiel.longline.SensorBrand; +import fr.ird.observe.entities.referentiel.longline.SensorDataFormat; +import fr.ird.observe.entities.referentiel.longline.SensorType; +import fr.ird.observe.entities.referentiel.longline.SettingShape; +import fr.ird.observe.entities.referentiel.longline.SizeMeasureType; +import fr.ird.observe.entities.referentiel.longline.StomacFullness; +import fr.ird.observe.entities.referentiel.longline.TripType; +import fr.ird.observe.entities.referentiel.longline.VesselActivityLongline; +import fr.ird.observe.entities.referentiel.longline.WeightMeasureType; +import fr.ird.observe.entities.referentiel.seine.DetectionMode; +import fr.ird.observe.entities.referentiel.seine.ObjectFate; +import fr.ird.observe.entities.referentiel.seine.ObjectOperation; +import fr.ird.observe.entities.referentiel.seine.ObjectType; +import fr.ird.observe.entities.referentiel.seine.ObservedSystem; +import fr.ird.observe.entities.referentiel.seine.ReasonForDiscard; +import fr.ird.observe.entities.referentiel.seine.ReasonForNoFishing; +import fr.ird.observe.entities.referentiel.seine.ReasonForNullSet; +import fr.ird.observe.entities.referentiel.seine.SpeciesFate; +import fr.ird.observe.entities.referentiel.seine.SpeciesStatus; +import fr.ird.observe.entities.referentiel.seine.SurroundingActivity; +import fr.ird.observe.entities.referentiel.seine.TransmittingBuoyOperation; +import fr.ird.observe.entities.referentiel.seine.TransmittingBuoyType; +import fr.ird.observe.entities.referentiel.seine.VesselActivitySeine; +import fr.ird.observe.entities.referentiel.seine.WeightCategory; +import fr.ird.observe.entities.referentiel.seine.Wind; +import fr.ird.observe.services.dto.referential.CountryDto; +import fr.ird.observe.services.dto.referential.FpaZoneDto; +import fr.ird.observe.services.dto.referential.GearCaracteristicDto; +import fr.ird.observe.services.dto.referential.GearCaracteristicTypeDto; +import fr.ird.observe.services.dto.referential.GearDto; +import fr.ird.observe.services.dto.referential.HarbourDto; +import fr.ird.observe.services.dto.referential.I18nReferentialDto; +import fr.ird.observe.services.dto.referential.LengthWeightParameterDto; +import fr.ird.observe.services.dto.referential.OceanDto; +import fr.ird.observe.services.dto.referential.OrganismDto; +import fr.ird.observe.services.dto.referential.PersonDto; +import fr.ird.observe.services.dto.referential.ProgramDto; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.SexDto; +import fr.ird.observe.services.dto.referential.SpeciesDto; +import fr.ird.observe.services.dto.referential.SpeciesGroupDto; +import fr.ird.observe.services.dto.referential.SpeciesListDto; +import fr.ird.observe.services.dto.referential.VesselDto; +import fr.ird.observe.services.dto.referential.VesselSizeCategoryDto; +import fr.ird.observe.services.dto.referential.VesselTypeDto; +import fr.ird.observe.services.dto.referential.longline.BaitHaulingStatusDto; +import fr.ird.observe.services.dto.referential.longline.BaitSettingStatusDto; +import fr.ird.observe.services.dto.referential.longline.BaitTypeDto; +import fr.ird.observe.services.dto.referential.longline.CatchFateLonglineDto; +import fr.ird.observe.services.dto.referential.longline.EncounterTypeDto; +import fr.ird.observe.services.dto.referential.longline.HealthnessDto; +import fr.ird.observe.services.dto.referential.longline.HookPositionDto; +import fr.ird.observe.services.dto.referential.longline.HookSizeDto; +import fr.ird.observe.services.dto.referential.longline.HookTypeDto; +import fr.ird.observe.services.dto.referential.longline.ItemHorizontalPositionDto; +import fr.ird.observe.services.dto.referential.longline.ItemVerticalPositionDto; +import fr.ird.observe.services.dto.referential.longline.LightsticksColorDto; +import fr.ird.observe.services.dto.referential.longline.LightsticksTypeDto; +import fr.ird.observe.services.dto.referential.longline.LineTypeDto; +import fr.ird.observe.services.dto.referential.longline.MaturityStatusDto; +import fr.ird.observe.services.dto.referential.longline.MitigationTypeDto; +import fr.ird.observe.services.dto.referential.longline.SensorBrandDto; +import fr.ird.observe.services.dto.referential.longline.SensorDataFormatDto; +import fr.ird.observe.services.dto.referential.longline.SensorTypeDto; +import fr.ird.observe.services.dto.referential.longline.SettingShapeDto; +import fr.ird.observe.services.dto.referential.longline.SizeMeasureTypeDto; +import fr.ird.observe.services.dto.referential.longline.StomacFullnessDto; +import fr.ird.observe.services.dto.referential.longline.TripTypeDto; +import fr.ird.observe.services.dto.referential.longline.VesselActivityLonglineDto; +import fr.ird.observe.services.dto.referential.longline.WeightMeasureTypeDto; +import fr.ird.observe.services.dto.referential.seine.DetectionModeDto; +import fr.ird.observe.services.dto.referential.seine.ObjectFateDto; +import fr.ird.observe.services.dto.referential.seine.ObjectOperationDto; +import fr.ird.observe.services.dto.referential.seine.ObjectTypeDto; +import fr.ird.observe.services.dto.referential.seine.ObservedSystemDto; +import fr.ird.observe.services.dto.referential.seine.ReasonForDiscardDto; +import fr.ird.observe.services.dto.referential.seine.ReasonForNoFishingDto; +import fr.ird.observe.services.dto.referential.seine.ReasonForNullSetDto; +import fr.ird.observe.services.dto.referential.seine.SpeciesFateDto; +import fr.ird.observe.services.dto.referential.seine.SpeciesStatusDto; +import fr.ird.observe.services.dto.referential.seine.SurroundingActivityDto; +import fr.ird.observe.services.dto.referential.seine.TransmittingBuoyOperationDto; +import fr.ird.observe.services.dto.referential.seine.TransmittingBuoyTypeDto; +import fr.ird.observe.services.dto.referential.seine.VesselActivitySeineDto; +import fr.ird.observe.services.dto.referential.seine.WeightCategoryDto; +import fr.ird.observe.services.dto.referential.seine.WindDto; +import org.nuiton.topia.persistence.TopiaEntity; +import org.nuiton.util.beans.BinderFactory; +import org.nuiton.util.beans.BinderModelBuilder; + +/** + * Pour initialiser tous les binders. + * + * Created on 18/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ObserveDtosInitializer implements ObserveModelInitializer { + + protected final static String[] DEFAULT_REFERENTIAL_PROPERTIES = { + ReferentialDto.PROPERTY_CODE, + ReferentialDto.PROPERTY_URI, + ReferentialDto.PROPERTY_STATUS, + ReferentialDto.PROPERTY_NEED_COMMENT + }; + + protected final static String[] DEFAULT_REFERENTIAL_LENGTH_WEIGHT_PARAMETER_PROPERTIES = { + LengthWeightParameterDto.PROPERTY_START_DATE, + LengthWeightParameterDto.PROPERTY_END_DATE, + LengthWeightParameterDto.PROPERTY_OCEAN, + LengthWeightParameterDto.PROPERTY_SPECIES, + LengthWeightParameterDto.PROPERTY_SEX, + LengthWeightParameterDto.PROPERTY_LENGTH_WEIGHT_FORMULA, + LengthWeightParameterDto.PROPERTY_WEIGHT_LENGTH_FORMULA, + LengthWeightParameterDto.PROPERTY_COEFFICIENTS, + LengthWeightParameterDto.PROPERTY_MEAN_LENGTH, + LengthWeightParameterDto.PROPERTY_MEAN_WEIGHT + }; + + protected final static String[] DEFAULT_REFERENTIAL_I18N_PROPERTIES = { + I18nReferentialDto.PROPERTY_LABEL1, + I18nReferentialDto.PROPERTY_LABEL2, + I18nReferentialDto.PROPERTY_LABEL3, + I18nReferentialDto.PROPERTY_LABEL4, + I18nReferentialDto.PROPERTY_LABEL5, + I18nReferentialDto.PROPERTY_LABEL6, + I18nReferentialDto.PROPERTY_LABEL7, + I18nReferentialDto.PROPERTY_LABEL8 + }; + + private static final String[] DEFAULT_REFERENTIAL_REFERENCE_PROPERTIES = {ReferentialDto.PROPERTY_CODE, I18nReferentialDto.PROPERTY_LABEL1, I18nReferentialDto.PROPERTY_LABEL2, I18nReferentialDto.PROPERTY_LABEL3}; + +// { +// // Need to add by hand a speciesList binder +// // see https://forge.codelutin.com/issues/6963 +// BinderModelBuilder<SpeciesListDto, SpeciesList> builderModel = newBinderBuilder(SpeciesListDto.class, SpeciesList.class); +// registerDtoBinder(builderModel, "Observe"); + + // } + + protected static ImmutableBiMap.Builder<Class<?>, Class<?>> DTO_TO_ENTITY_TYPE_BUILDER; + + protected static ImmutableBiMap<Class<?>, Class<?>> DTO_TO_ENTITY_TYPES; + + public static ImmutableBiMap<Class<?>, Class<?>> getDtoToEntityTypes() { + return DTO_TO_ENTITY_TYPES; + } + + @Override + public void start() { + DTO_TO_ENTITY_TYPE_BUILDER = new ImmutableBiMap.Builder<>(); + } + + @Override + public void end() { + DTO_TO_ENTITY_TYPES = DTO_TO_ENTITY_TYPE_BUILDER.build(); + } + + @Override + public void initFormDto() { + // Rien à faire + } + + @Override + public void initIdDto() { + // Rien à faire + } + + @Override + public void initReferenceDto() { + // Rien à faire + } + + @Override + public void initReferenceSetDto() { + // Rien à faire + } + + @Override + public void initActivityLonglineDto() { + + } + + @Override + public void initBaitsCompositionDto() { + + } + + @Override + public void initBasketDto() { + + } + + @Override + public void initBranchlineDto() { + + } + + @Override + public void initBranchlinesCompositionDto() { + + } + + @Override + public void initCatchLonglineDto() { + + } + + @Override + public void initEncounterDto() { + + } + + @Override + public void initFloatlinesCompositionDto() { + + } + + @Override + public void initGearUseFeaturesLonglineDto() { + + } + + @Override + public void initGearUseFeaturesMeasurementLonglineDto() { + + } + + @Override + public void initHooksCompositionDto() { + + } + + @Override + public void initSectionDto() { + + } + + @Override + public void initSensorUsedDto() { + + } + + @Override + public void initSetLonglineDto() { + + } + + @Override + public void initSizeMeasureDto() { + + } + + @Override + public void initTdrDto() { + + } + + @Override + public void initTdrRecordDto() { + + } + + @Override + public void initTripLonglineDto() { + + } + + @Override + public void initWeightMeasureDto() { + + } + + @Override + public void initCountryDto() { + registerDtoType(CountryDto.class, Country.class); + registerReferentialDtoBinder(CountryDto.class, Country.class, CountryDto.PROPERTY_ISO2_CODE, CountryDto.PROPERTY_ISO3_CODE); + registerReferentialReferenceDtoBinder(CountryDto.class, Country.class); + } + + + @Override + public void initFpaZoneDto() { + registerDtoType(FpaZoneDto.class, FpaZone.class); + registerReferentialDtoBinder(FpaZoneDto.class, FpaZone.class, FpaZoneDto.PROPERTY_START_DATE, FpaZoneDto.PROPERTY_END_DATE); + registerReferentialReferenceDtoBinder(FpaZoneDto.class, FpaZone.class); + } + + @Override + public void initGearCaracteristicDto() { + registerDtoType(GearCaracteristicDto.class, GearCaracteristic.class); + registerReferentialDtoBinder(GearCaracteristicDto.class, GearCaracteristic.class, GearCaracteristicDto.PROPERTY_GEAR_CARACTERISTIC_TYPE, GearCaracteristicDto.PROPERTY_UNIT); + registerReferentialReferenceDtoBinder(GearCaracteristicDto.class, GearCaracteristic.class); + } + + @Override + public void initGearCaracteristicTypeDto() { + registerDtoType(GearCaracteristicTypeDto.class, GearCaracteristicType.class); + registerReferentialDtoBinder(GearCaracteristicTypeDto.class, GearCaracteristicType.class); + registerReferentialReferenceDtoBinder(GearCaracteristicTypeDto.class, GearCaracteristicType.class); + } + + @Override + public void initGearDto() { + registerDtoType(GearDto.class, Gear.class); + registerReferentialDtoBinder(GearDto.class, Gear.class, GearDto.PROPERTY_GEAR_CARACTERISTIC); + registerReferentialReferenceDtoBinder(GearDto.class, Gear.class); + } + + @Override + public void initHarbourDto() { + registerDtoType(HarbourDto.class, Harbour.class); + registerReferentialDtoBinder(HarbourDto.class, Harbour.class, + HarbourDto.PROPERTY_NAME, + HarbourDto.PROPERTY_COUNTRY, + HarbourDto.PROPERTY_LOCODE, + HarbourDto.PROPERTY_LATITUDE, + HarbourDto.PROPERTY_LONGITUDE, + HarbourDto.PROPERTY_QUADRANT); + registerReferentialReferenceDtoBinder(HarbourDto.class, Harbour.class, + false, + ReferentialDto.PROPERTY_CODE, + HarbourDto.PROPERTY_NAME, + HarbourDto.PROPERTY_LOCODE); + } + + @Override + public void initI18nReferentialDto() { + + } + + @Override + public void initLengthWeightParameterDto() { + registerDtoType(LengthWeightParameterDto.class, LengthWeightParameter.class); + registerReferentialDtoBinder(LengthWeightParameterDto.class, LengthWeightParameter.class, + LengthWeightParameterDto.PROPERTY_SEX, + LengthWeightParameterDto.PROPERTY_OCEAN, + LengthWeightParameterDto.PROPERTY_SPECIES, + LengthWeightParameterDto.PROPERTY_START_DATE); + + // FIXME A revoir car on veut en fait ocean/libelle et species/scientificLabel + registerReferentialReferenceDtoBinder(LengthWeightParameterDto.class, LengthWeightParameter.class, + false, + LengthWeightParameterDto.PROPERTY_SEX, + LengthWeightParameterDto.PROPERTY_OCEAN, + LengthWeightParameterDto.PROPERTY_SPECIES, + LengthWeightParameterDto.PROPERTY_LENGTH_WEIGHT_FORMULA, + LengthWeightParameterDto.PROPERTY_WEIGHT_LENGTH_FORMULA); + } + + @Override + public void initOceanDto() { + registerDtoType(OceanDto.class, Ocean.class); + registerReferentialDtoBinder(OceanDto.class, Ocean.class); + registerReferentialReferenceDtoBinder(OceanDto.class, Ocean.class); + } + + @Override + public void initOrganismDto() { + registerDtoType(OrganismDto.class, Organism.class); + registerReferentialDtoBinder(OrganismDto.class, Organism.class, + OrganismDto.PROPERTY_COUNTRY, OrganismDto.PROPERTY_DESCRIPTION); + registerReferentialReferenceDtoBinder(OrganismDto.class, Organism.class); + } + + @Override + public void initPersonDto() { + registerDtoType(PersonDto.class, Person.class); + registerReferentialDtoBinder(PersonDto.class, Person.class, + PersonDto.PROPERTY_CODE, + PersonDto.PROPERTY_LAST_NAME, + PersonDto.PROPERTY_FIRST_NAME, + PersonDto.PROPERTY_CAPTAIN, + PersonDto.PROPERTY_OBSERVER, + PersonDto.PROPERTY_DATA_ENTRY_OPERATOR, + PersonDto.PROPERTY_COUNTRY); + registerReferentialReferenceDtoBinder(PersonDto.class, Person.class, false, + PersonDto.PROPERTY_FIRST_NAME, PersonDto.PROPERTY_LAST_NAME); + } + + @Override + public void initProgramDto() { + +// { +// +// BinderModelBuilder<ProgramDto, Program> builder = newBinderBuilder( +// ProgramDto.class, +// Program.class, +// ProgramDto.PROPERTY_LABEL1, +// ProgramDto.PROPERTY_LABEL2, +// ProgramDto.PROPERTY_LABEL3, +// ProgramDto.PROPERTY_LABEL4, +// ProgramDto.PROPERTY_LABEL5, +// ProgramDto.PROPERTY_LABEL6, +// ProgramDto.PROPERTY_LABEL7, +// ProgramDto.PROPERTY_LABEL8 +// ); +// +// registerDtoBinder(builder); +// +// } + +// { +// +// BinderModelBuilder<ProgramDto, Program> builder = newBinderBuilder( +// ProgramDto.class, +// Program.class, +// ProgramDto.PROPERTY_LABEL1, +// ProgramDto.PROPERTY_LABEL2, +// ProgramDto.PROPERTY_LABEL3, +// ProgramDto.PROPERTY_LABEL4, +// ProgramDto.PROPERTY_LABEL5, +// ProgramDto.PROPERTY_LABEL6, +// ProgramDto.PROPERTY_LABEL7, +// ProgramDto.PROPERTY_LABEL8); +// +// registerTopiaBinder(Program.class, builder, DISPLAY_LIST); +// +// } + registerDtoType(ProgramDto.class, Program.class); + registerReferentialDtoBinder(ProgramDto.class, Program.class, + ProgramDto.PROPERTY_ORGANISM, + ProgramDto.PROPERTY_START_DATE, + ProgramDto.PROPERTY_END_DATE, + ProgramDto.PROPERTY_DETAILLED_ACTIVITIES_OBSERVATION, + ProgramDto.PROPERTY_NON_TARGET_OBSERVATION, + ProgramDto.PROPERTY_BAIT_OBSERVATION, + ProgramDto.PROPERTY_MAMMALS_OBSERVATION, + ProgramDto.PROPERTY_SAMPLES_OBSERVATION, + ProgramDto.PROPERTY_OBJECTS_OBSERVATION, + ProgramDto.PROPERTY_BIRDS_OBSERVATION, + ProgramDto.PROPERTY_TARGET_DISCARDS_OBSERVATION, + ProgramDto.PROPERTY_GEAR_TYPE); + registerReferentialReferenceDtoBinder(ProgramDto.class, Program.class); + } + + @Override + public void initReferentialDto() { + // Rien à faire + } + + @Override + public void initReferentialReferenceDto() { + // Rien à faire + } + + @Override + public void initSexDto() { + registerDtoType(SexDto.class, Sex.class); + registerReferentialDtoBinder(SexDto.class, Sex.class); + registerReferentialReferenceDtoBinder(SexDto.class, Sex.class); + } + + + @Override + public void initSpeciesDto() { + registerDtoType(SpeciesDto.class, Species.class); + registerReferentialDtoBinder(SpeciesDto.class, Species.class, SpeciesDto.PROPERTY_SPECIES_GROUP, + SpeciesDto.PROPERTY_OCEAN, + SpeciesDto.PROPERTY_LENGTH_MEASURE_TYPE, + SpeciesDto.PROPERTY_MIN_LENGTH, + SpeciesDto.PROPERTY_MAX_LENGTH, + SpeciesDto.PROPERTY_MIN_WEIGHT, + SpeciesDto.PROPERTY_MAX_WEIGHT, + SpeciesDto.PROPERTY_HOME_ID, + SpeciesDto.PROPERTY_FAO_CODE, + SpeciesDto.PROPERTY_WORMS_ID, + SpeciesDto.PROPERTY_SCIENTIFIC_LABEL); + registerReferentialReferenceDtoBinder(SpeciesDto.class, Species.class, + SpeciesDto.PROPERTY_FAO_CODE, + SpeciesDto.PROPERTY_SCIENTIFIC_LABEL, + SpeciesDto.PROPERTY_HOME_ID); + } + + @Override + public void initSpeciesGroupDto() { + registerDtoType(SpeciesGroupDto.class, SpeciesGroup.class); + registerReferentialDtoBinder(SpeciesGroupDto.class, SpeciesGroup.class); + registerReferentialReferenceDtoBinder(SpeciesGroupDto.class, SpeciesGroup.class); + } + + @Override + public void initSpeciesListDto() { + registerDtoType(SpeciesListDto.class, SpeciesList.class); + registerReferentialDtoBinder(SpeciesListDto.class, SpeciesList.class, SpeciesListDto.PROPERTY_SPECIES); + registerReferentialReferenceDtoBinder(SpeciesListDto.class, SpeciesList.class); + } + + @Override + public void initVesselSizeCategoryDto() { + registerDtoType(VesselSizeCategoryDto.class, VesselSizeCategory.class); + registerReferentialDtoBinder(VesselSizeCategoryDto.class, VesselSizeCategory.class, + VesselSizeCategoryDto.PROPERTY_GAUGE_LABEL, + VesselSizeCategoryDto.PROPERTY_CAPACITY_LABEL); + registerReferentialReferenceDtoBinder(VesselSizeCategoryDto.class, VesselSizeCategory.class, + false, + ReferentialDto.PROPERTY_CODE, + VesselSizeCategoryDto.PROPERTY_GAUGE_LABEL, + VesselSizeCategoryDto.PROPERTY_CAPACITY_LABEL); + } + + @Override + public void initVesselDto() { + registerDtoType(VesselDto.class, Vessel.class); + registerReferentialDtoBinder(VesselDto.class, Vessel.class, + VesselDto.PROPERTY_VESSEL_TYPE, + VesselDto.PROPERTY_VESSEL_SIZE_CATEGORY, + VesselDto.PROPERTY_FLAG_COUNTRY, + VesselDto.PROPERTY_KEEL_CODE, + VesselDto.PROPERTY_FLEET_COUNTRY, + VesselDto.PROPERTY_YEAR_SERVICE, + VesselDto.PROPERTY_LENGTH, + VesselDto.PROPERTY_CAPACITY, + VesselDto.PROPERTY_POWER, + VesselDto.PROPERTY_SEARCH_MAXIMUM, + VesselDto.PROPERTY_CHANGE_DATE); + registerReferentialReferenceDtoBinder(VesselDto.class, Vessel.class); + } + + @Override + public void initVesselTypeDto() { + registerDtoType(VesselTypeDto.class, VesselType.class); + registerReferentialDtoBinder(VesselTypeDto.class, VesselType.class); + registerReferentialReferenceDtoBinder(VesselTypeDto.class, VesselType.class); + } + + @Override + public void initDetectionModeDto() { + registerDtoType(DetectionModeDto.class, DetectionMode.class); + registerReferentialDtoBinder(DetectionModeDto.class, DetectionMode.class); + registerReferentialReferenceDtoBinder(DetectionModeDto.class, DetectionMode.class); + } + + @Override + public void initObjectFateDto() { + registerDtoType(ObjectFateDto.class, ObjectFate.class); + registerReferentialDtoBinder(ObjectFateDto.class, ObjectFate.class); + registerReferentialReferenceDtoBinder(ObjectFateDto.class, ObjectFate.class); + } + + @Override + public void initObjectOperationDto() { + registerDtoType(ObjectOperationDto.class, ObjectOperation.class); + registerReferentialDtoBinder(ObjectOperationDto.class, ObjectOperation.class); + registerReferentialReferenceDtoBinder(ObjectOperationDto.class, ObjectOperation.class); + } + + @Override + public void initObjectTypeDto() { + registerDtoType(ObjectTypeDto.class, ObjectType.class); + registerReferentialDtoBinder(ObjectTypeDto.class, ObjectType.class); + registerReferentialReferenceDtoBinder(ObjectTypeDto.class, ObjectType.class); + } + + @Override + public void initObservedSystemDto() { + registerDtoType(ObservedSystemDto.class, ObservedSystem.class); + registerReferentialDtoBinder(ObservedSystemDto.class, ObservedSystem.class, + ObservedSystemDto.PROPERTY_SCHOOL_TYPE); + registerReferentialReferenceDtoBinder(ObservedSystemDto.class, ObservedSystem.class); + } + + @Override + public void initReasonForDiscardDto() { + registerDtoType(ReasonForDiscardDto.class, ReasonForDiscard.class); + registerReferentialDtoBinder(ReasonForDiscardDto.class, ReasonForDiscard.class); + registerReferentialReferenceDtoBinder(ReasonForDiscardDto.class, ReasonForDiscard.class); + } + + @Override + public void initReasonForNoFishingDto() { + registerDtoType(ReasonForNoFishingDto.class, ReasonForNoFishing.class); + registerReferentialDtoBinder(ReasonForNoFishingDto.class, ReasonForNoFishing.class); + registerReferentialReferenceDtoBinder(ReasonForNoFishingDto.class, ReasonForNoFishing.class); + } + + @Override + public void initReasonForNullSetDto() { + registerDtoType(ReasonForNullSetDto.class, ReasonForNullSet.class); + registerReferentialDtoBinder(ReasonForNullSetDto.class, ReasonForNullSet.class); + registerReferentialReferenceDtoBinder(ReasonForNullSetDto.class, ReasonForNullSet.class); + } + + @Override + public void initSpeciesFateDto() { + registerDtoType(SpeciesFateDto.class, SpeciesFate.class); + registerReferentialDtoBinder(SpeciesFateDto.class, SpeciesFate.class); + registerReferentialReferenceDtoBinder(SpeciesFateDto.class, SpeciesFate.class); + } + + @Override + public void initSpeciesStatusDto() { + registerDtoType(SpeciesStatusDto.class, SpeciesStatus.class); + registerReferentialDtoBinder(SpeciesStatusDto.class, SpeciesStatus.class); + registerReferentialReferenceDtoBinder(SpeciesStatusDto.class, SpeciesStatus.class); + } + + @Override + public void initSurroundingActivityDto() { + registerDtoType(SurroundingActivityDto.class, SurroundingActivity.class); + registerReferentialDtoBinder(SurroundingActivityDto.class, SurroundingActivity.class); + registerReferentialReferenceDtoBinder(SurroundingActivityDto.class, SurroundingActivity.class); + } + + @Override + public void initTransmittingBuoyOperationDto() { + registerDtoType(TransmittingBuoyOperationDto.class, TransmittingBuoyOperation.class); + registerReferentialDtoBinder(TransmittingBuoyOperationDto.class, TransmittingBuoyOperation.class); + registerReferentialReferenceDtoBinder(TransmittingBuoyOperationDto.class, TransmittingBuoyOperation.class); + } + + @Override + public void initTransmittingBuoyTypeDto() { + registerDtoType(TransmittingBuoyTypeDto.class, TransmittingBuoyType.class); + registerReferentialDtoBinder(TransmittingBuoyTypeDto.class, TransmittingBuoyType.class); + registerReferentialReferenceDtoBinder(TransmittingBuoyTypeDto.class, TransmittingBuoyType.class); + } + + @Override + public void initVesselActivitySeineDto() { + registerDtoType(VesselActivitySeineDto.class, VesselActivitySeine.class); + registerReferentialDtoBinder(VesselActivitySeineDto.class, VesselActivitySeine.class); + registerReferentialReferenceDtoBinder(VesselActivitySeineDto.class, VesselActivitySeine.class); + } + + @Override + public void initWeightCategoryDto() { + registerDtoType(WeightCategoryDto.class, WeightCategory.class); + registerReferentialDtoBinder(WeightCategoryDto.class, WeightCategory.class, + WeightCategoryDto.PROPERTY_CODE, WeightCategoryDto.PROPERTY_SPECIES); + registerReferentialReferenceDtoBinder(WeightCategoryDto.class, WeightCategory.class); + } + + @Override + public void initWindDto() { + + + registerDtoType(WindDto.class, Wind.class); + registerReferentialDtoBinder(WindDto.class, Wind.class, + WindDto.PROPERTY_SPEED_RANGE, WindDto.PROPERTY_WAVE_HEIGHT); + + registerReferentialReferenceDtoBinder(WindDto.class, Wind.class, + ReferentialDto.PROPERTY_CODE, + I18nReferentialDto.PROPERTY_LABEL1, + I18nReferentialDto.PROPERTY_LABEL2, + I18nReferentialDto.PROPERTY_LABEL3, + WindDto.PROPERTY_SPEED_RANGE); + } + + @Override + public void initActivitySeineDto() { + + } + + @Override + public void initActivitySeineObservedSystemDto() { + + } + + @Override + public void initFloatingObjectDto() { + + } + + @Override + public void initGearUseFeaturesMeasurementSeineDto() { + + } + + @Override + public void initGearUseFeaturesSeineDto() { + + } + + @Override + public void initNonTargetCatchDto() { + + } + + @Override + public void initNonTargetLengthDto() { + + } + + @Override + public void initNonTargetSampleDto() { + + } + + @Override + public void initObjectObservedSpeciesDto() { + + } + + @Override + public void initObjectSchoolEstimateDto() { + + } + + @Override + public void initRouteDto() { + + } + + @Override + public void initSchoolEstimateDto() { + + } + + @Override + public void initSetSeineDto() { + + } + + @Override + public void initTargetCatchDto() { + + } + + @Override + public void initTargetLengthDto() { + + } + + @Override + public void initTargetSampleDto() { + + } + + @Override + public void initTransmittingBuoyDto() { + + } + + @Override + public void initTripSeineDto() { + + } + + @Override + public void initBaitHaulingStatusDto() { + registerDtoType(BaitHaulingStatusDto.class, BaitHaulingStatus.class); + registerReferentialDtoBinder(BaitHaulingStatusDto.class, BaitHaulingStatus.class); + registerReferentialReferenceDtoBinder(BaitHaulingStatusDto.class, BaitHaulingStatus.class); + } + + @Override + public void initBaitSettingStatusDto() { + registerDtoType(BaitSettingStatusDto.class, BaitSettingStatus.class); + registerReferentialDtoBinder(BaitSettingStatusDto.class, BaitSettingStatus.class); + registerReferentialReferenceDtoBinder(BaitSettingStatusDto.class, BaitSettingStatus.class); + } + + @Override + public void initBaitTypeDto() { + registerDtoType(BaitTypeDto.class, BaitType.class); + registerReferentialDtoBinder(BaitTypeDto.class, BaitType.class); + registerReferentialReferenceDtoBinder(BaitTypeDto.class, BaitType.class); + } + + @Override + public void initCatchFateLonglineDto() { + registerDtoType(CatchFateLonglineDto.class, CatchFateLongline.class); + registerReferentialDtoBinder(CatchFateLonglineDto.class, CatchFateLongline.class); + registerReferentialReferenceDtoBinder(CatchFateLonglineDto.class, CatchFateLongline.class); + } + + @Override + public void initEncounterTypeDto() { + registerDtoType(EncounterTypeDto.class, EncounterType.class); + registerReferentialDtoBinder(EncounterTypeDto.class, EncounterType.class); + registerReferentialReferenceDtoBinder(EncounterTypeDto.class, EncounterType.class); + } + + @Override + public void initHealthnessDto() { + registerDtoType(HealthnessDto.class, Healthness.class); + registerReferentialDtoBinder(HealthnessDto.class, Healthness.class); + registerReferentialReferenceDtoBinder(HealthnessDto.class, Healthness.class); + } + + @Override + public void initHookPositionDto() { + registerDtoType(HookPositionDto.class, HookPosition.class); + registerReferentialDtoBinder(HookPositionDto.class, HookPosition.class); + registerReferentialReferenceDtoBinder(HookPositionDto.class, HookPosition.class); + } + + @Override + public void initHookSizeDto() { + registerDtoType(HookSizeDto.class, HookSize.class); + registerReferentialDtoBinder(HookSizeDto.class, HookSize.class); + registerReferentialReferenceDtoBinder(HookSizeDto.class, HookSize.class); + } + + @Override + public void initHookTypeDto() { + registerDtoType(HookTypeDto.class, HookType.class); + registerReferentialDtoBinder(HookTypeDto.class, HookType.class); + registerReferentialReferenceDtoBinder(HookTypeDto.class, HookType.class); + } + + @Override + public void initItemHorizontalPositionDto() { + registerDtoType(ItemHorizontalPositionDto.class, ItemHorizontalPosition.class); + registerReferentialDtoBinder(ItemHorizontalPositionDto.class, ItemHorizontalPosition.class); + registerReferentialReferenceDtoBinder(ItemHorizontalPositionDto.class, ItemHorizontalPosition.class); + } + + @Override + public void initItemVerticalPositionDto() { + registerDtoType(ItemVerticalPositionDto.class, ItemVerticalPosition.class); + registerReferentialDtoBinder(ItemVerticalPositionDto.class, ItemVerticalPosition.class); + registerReferentialReferenceDtoBinder(ItemVerticalPositionDto.class, ItemVerticalPosition.class); + } + + @Override + public void initLightsticksColorDto() { + registerDtoType(LightsticksColorDto.class, LightsticksColor.class); + registerReferentialDtoBinder(LightsticksColorDto.class, LightsticksColor.class); + registerReferentialReferenceDtoBinder(LightsticksColorDto.class, LightsticksColor.class); + } + + @Override + public void initLightsticksTypeDto() { + registerDtoType(LightsticksTypeDto.class, LightsticksType.class); + registerReferentialDtoBinder(LightsticksTypeDto.class, LightsticksType.class); + registerReferentialReferenceDtoBinder(LightsticksTypeDto.class, LightsticksType.class); + } + + @Override + public void initLineTypeDto() { + registerDtoType(LineTypeDto.class, LineType.class); + registerReferentialDtoBinder(LineTypeDto.class, LineType.class); + registerReferentialReferenceDtoBinder(LineTypeDto.class, LineType.class); + } + + @Override + public void initMaturityStatusDto() { + registerDtoType(MaturityStatusDto.class, MaturityStatus.class); + registerReferentialDtoBinder(MaturityStatusDto.class, MaturityStatus.class, + MaturityStatusDto.PROPERTY_LOWER_VALUE, + MaturityStatusDto.PROPERTY_UPPER_VALUE); + registerReferentialReferenceDtoBinder(MaturityStatusDto.class, MaturityStatus.class); + } + + @Override + public void initMitigationTypeDto() { + registerDtoType(MitigationTypeDto.class, MitigationType.class); + registerReferentialDtoBinder(MitigationTypeDto.class, MitigationType.class); + registerReferentialReferenceDtoBinder(MitigationTypeDto.class, MitigationType.class); + } + + @Override + public void initSensorBrandDto() { + registerDtoType(SensorBrandDto.class, SensorBrand.class); + registerReferentialDtoBinder(SensorBrandDto.class, SensorBrand.class, SensorBrandDto.PROPERTY_BRAND_NAME); + registerReferentialReferenceDtoBinder(SensorBrandDto.class, SensorBrand.class, + false, + ReferentialDto.PROPERTY_CODE, SensorBrandDto.PROPERTY_BRAND_NAME); + } + + @Override + public void initSensorDataFormatDto() { + registerDtoType(SensorDataFormatDto.class, SensorDataFormat.class); + registerReferentialDtoBinder(SensorDataFormatDto.class, SensorDataFormat.class); + registerReferentialReferenceDtoBinder(SensorDataFormatDto.class, SensorDataFormat.class); + } + + @Override + public void initSensorTypeDto() { + registerDtoType(SensorTypeDto.class, SensorType.class); + registerReferentialDtoBinder(SensorTypeDto.class, SensorType.class); + registerReferentialReferenceDtoBinder(SensorTypeDto.class, SensorType.class); + } + + @Override + public void initSettingShapeDto() { + registerDtoType(SettingShapeDto.class, SettingShape.class); + registerReferentialDtoBinder(SettingShapeDto.class, SettingShape.class); + registerReferentialReferenceDtoBinder(SettingShapeDto.class, SettingShape.class); + } + + @Override + public void initSizeMeasureTypeDto() { + registerDtoType(SizeMeasureTypeDto.class, SizeMeasureType.class); + registerReferentialDtoBinder(SizeMeasureTypeDto.class, SizeMeasureType.class); + registerReferentialReferenceDtoBinder(SizeMeasureTypeDto.class, SizeMeasureType.class); + } + + @Override + public void initStomacFullnessDto() { + registerDtoType(StomacFullnessDto.class, StomacFullness.class); + registerReferentialDtoBinder(StomacFullnessDto.class, StomacFullness.class); + registerReferentialReferenceDtoBinder(StomacFullnessDto.class, StomacFullness.class); + } + + @Override + public void initTripTypeDto() { + registerDtoType(TripTypeDto.class, TripType.class); + registerReferentialDtoBinder(TripTypeDto.class, TripType.class); + registerReferentialReferenceDtoBinder(TripTypeDto.class, TripType.class); + } + + @Override + public void initVesselActivityLonglineDto() { + registerDtoType(VesselActivityLonglineDto.class, VesselActivityLongline.class); + registerReferentialDtoBinder(VesselActivityLonglineDto.class, VesselActivityLongline.class); + registerReferentialReferenceDtoBinder(VesselActivityLonglineDto.class, VesselActivityLongline.class); + } + + @Override + public void initWeightMeasureTypeDto() { + registerDtoType(WeightMeasureTypeDto.class, WeightMeasureType.class); + registerReferentialDtoBinder(WeightMeasureTypeDto.class, WeightMeasureType.class); + registerReferentialReferenceDtoBinder(WeightMeasureTypeDto.class, WeightMeasureType.class); + } + + protected <R extends IdDto, E extends TopiaEntity> void registerDtoType(Class<R> dtoType, Class<E> entityType) { + DTO_TO_ENTITY_TYPE_BUILDER.put(dtoType, entityType); + } + + protected <R extends ReferentialDto, E extends TopiaEntity> void registerReferentialDtoBinder(Class<R> dtoType, Class<E> entityType, String... extraProperties) { + + BinderModelBuilder<R, E> dtoToEntityBuilder = newBinderBuilder(dtoType, entityType) + .canTypeMismatch(true) + .addSimpleProperties(DEFAULT_REFERENTIAL_PROPERTIES); + + if (I18nReferenceEntity.class.isAssignableFrom(entityType)) { + dtoToEntityBuilder.addSimpleProperties(DEFAULT_REFERENTIAL_I18N_PROPERTIES); + } + if (LengthWeightParameter.class.isAssignableFrom(entityType)) { + dtoToEntityBuilder.addSimpleProperties(DEFAULT_REFERENTIAL_LENGTH_WEIGHT_PARAMETER_PROPERTIES); + } + + if (extraProperties.length > 0) { + dtoToEntityBuilder.addSimpleProperties(extraProperties); + } + + registerDtoBinder(dtoToEntityBuilder); + + } + + protected static <R extends ReferentialDto, E extends TopiaEntity> void registerReferentialReferenceDtoBinder(Class<R> dtoType, Class<E> entityType, String... extraProperties) { + + registerReferentialReferenceDtoBinder(dtoType, entityType, true, extraProperties); + + } + + protected static <R extends ReferentialDto, E extends TopiaEntity> void registerReferentialReferenceDtoBinder(Class<R> dtoType, Class<E> entityType, boolean useDefault, String... extraProperties) { + + BinderModelBuilder<R, E> dtoToReferenceBuilder = + newBinderBuilder(dtoType, entityType) + .canTypeMismatch(true); + + if (useDefault) { + dtoToReferenceBuilder.addSimpleProperties(DEFAULT_REFERENTIAL_REFERENCE_PROPERTIES); + } + + if (extraProperties.length > 0) { + dtoToReferenceBuilder.addSimpleProperties(extraProperties); + } + + registerReferenceBinder(dtoToReferenceBuilder); + + } + + protected static <R extends IdDto, E extends TopiaEntity> void registerDtoBinder(BinderModelBuilder<R, E> dtoToEntityBuilder) { + + dtoToEntityBuilder.addProperty(IdDto.PROPERTY_ID, TopiaEntity.TOPIA_ID); + + BinderModelBuilder<E, R> entityToDtoToBuilder = dtoToEntityBuilder.buildInverseModelBuilder(); + BinderFactory.registerBinderModel(dtoToEntityBuilder, ObserveDtoBinders.DTO_TO_ENTITY); + BinderFactory.registerBinderModel(entityToDtoToBuilder, ObserveDtoBinders.ENTITY_TO_DTO); + + } + + protected static <R extends ReferentialDto, E extends TopiaEntity> void registerReferenceBinder(BinderModelBuilder<R, E> dtoToReferenceBuilder) { + + dtoToReferenceBuilder.addProperty(IdDto.PROPERTY_ID, TopiaEntity.TOPIA_ID); + + BinderModelBuilder<E, R> entityToReferenceBuilder = dtoToReferenceBuilder.buildInverseModelBuilder(); + + BinderFactory.registerBinderModel(dtoToReferenceBuilder, ObserveDtoBinders.DTO_TO_REFERENCE); + BinderFactory.registerBinderModel(entityToReferenceBuilder, ObserveDtoBinders.ENTITY_TO_REFERENCE); + + } + + protected static <Source, Target> BinderModelBuilder<Source, Target> newBinderBuilder(Class<Source> source, Class<Target> target, String... properties) { + BinderModelBuilder<Source, Target> builder = BinderModelBuilder.newEmptyBuilder(source, target); + builder.addSimpleProperties(properties); + return builder; + } + +} -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.