branch feature/refactor_reference created (now 2314dfc)
This is an automated email from the git hooks/post-receive script. New change to branch feature/refactor_reference in repository observe. See http://git.codelutin.com/observe.git at 2314dfc Début d'implantation d'un cache de référentiels (à finir) This branch includes the following new commits: new 1765ec2 Ajout de méthodes pour faire un rendu i18n plus facile new 85b03ab Ajout d'une méthode toString pour faire un rendu simple d'un dto new 17cdae8 Ajout de définition de requètes de données new b393c43 Ajout d'un service pour récupérer des referecne set (à finir) new 2314dfc Début d'implantation d'un cache de référentiels (à finir) The 5 revisions listed above as "new" are entirely new to this repository and will be described in separate emails. The revisions listed as "adds" were already present in the repository and have only been added to this reference. Detailed log of new commits: commit 2314dfc172d0a6d1cac4b2e509e0d67bf5748eaf Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Nov 12 09:44:34 2015 +0100 Début d'implantation d'un cache de référentiels (à finir) commit b393c43d960524e65e1aa98c34018cbe05ba1da0 Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Nov 12 09:44:07 2015 +0100 Ajout d'un service pour récupérer des referecne set (à finir) commit 17cdae834599aa6425dfb7e568f64e5902fdd3a4 Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Nov 12 09:43:36 2015 +0100 Ajout de définition de requètes de données commit 85b03aba25ae0784af7f984d4bacbf359bb8e459 Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Nov 12 09:42:33 2015 +0100 Ajout d'une méthode toString pour faire un rendu simple d'un dto commit 1765ec202e2a6c9a6ad7be1ec1e1824b689e091d Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Nov 12 09:41:33 2015 +0100 Ajout de méthodes pour faire un rendu i18n plus facile -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.
This is an automated email from the git hooks/post-receive script. New commit to branch feature/refactor_reference in repository observe. See http://git.codelutin.com/observe.git commit 1765ec202e2a6c9a6ad7be1ec1e1824b689e091d Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Nov 12 09:41:33 2015 +0100 Ajout de méthodes pour faire un rendu i18n plus facile --- .../entities/constants/ReferenceLocale.java | 31 ++----------------- .../referentiel/I18nReferenceEntities.java | 35 ++++++++++++++++++++++ 2 files changed, 37 insertions(+), 29 deletions(-) diff --git a/observe-entities/src/main/java/fr/ird/observe/entities/constants/ReferenceLocale.java b/observe-entities/src/main/java/fr/ird/observe/entities/constants/ReferenceLocale.java index 227588c..ebb4ebd 100644 --- a/observe-entities/src/main/java/fr/ird/observe/entities/constants/ReferenceLocale.java +++ b/observe-entities/src/main/java/fr/ird/observe/entities/constants/ReferenceLocale.java @@ -21,6 +21,7 @@ */ package fr.ird.observe.entities.constants; +import fr.ird.observe.entities.referentiel.I18nReferenceEntities; import fr.ird.observe.entities.referentiel.I18nReferenceEntity; import java.util.Locale; @@ -126,35 +127,7 @@ public enum ReferenceLocale { public <E extends I18nReferenceEntity> String getLabel(E i18nEntity) { - String result = null; - - switch (ordinal() + 1) { - case 1: - result = i18nEntity.getLabel1(); - break; - case 2: - result = i18nEntity.getLabel2(); - break; - case 3: - result = i18nEntity.getLabel3(); - break; - case 4: - result = i18nEntity.getLabel4(); - break; - case 5: - result = i18nEntity.getLabel5(); - break; - case 6: - result = i18nEntity.getLabel6(); - break; - case 7: - result = i18nEntity.getLabel7(); - break; - case 8: - result = i18nEntity.getLabel8(); - break; - } - + String result = I18nReferenceEntities.decorate(ordinal(), i18nEntity); return result; } diff --git a/observe-entities/src/main/java/fr/ird/observe/entities/referentiel/I18nReferenceEntities.java b/observe-entities/src/main/java/fr/ird/observe/entities/referentiel/I18nReferenceEntities.java index e82d81f..8dcd892 100644 --- a/observe-entities/src/main/java/fr/ird/observe/entities/referentiel/I18nReferenceEntities.java +++ b/observe-entities/src/main/java/fr/ird/observe/entities/referentiel/I18nReferenceEntities.java @@ -42,4 +42,39 @@ public class I18nReferenceEntities { } + public static <E extends I18nReferenceEntity> String decorate(int referenceLocaleOrdinal, E i18nEntity) { + + String result = null; + + switch (referenceLocaleOrdinal + 1) { + case 1: + result = i18nEntity.getLabel1(); + break; + case 2: + result = i18nEntity.getLabel2(); + break; + case 3: + result = i18nEntity.getLabel3(); + break; + case 4: + result = i18nEntity.getLabel4(); + break; + case 5: + result = i18nEntity.getLabel5(); + break; + case 6: + result = i18nEntity.getLabel6(); + break; + case 7: + result = i18nEntity.getLabel7(); + break; + case 8: + result = i18nEntity.getLabel8(); + break; + } + + return result; + + } + } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.
This is an automated email from the git hooks/post-receive script. New commit to branch feature/refactor_reference in repository observe. See http://git.codelutin.com/observe.git commit 85b03aba25ae0784af7f984d4bacbf359bb8e459 Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Nov 12 09:42:33 2015 +0100 Ajout d'une méthode toString pour faire un rendu simple d'un dto --- .../entities/referentiel/ReferenceEntities.java | 44 ++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/observe-entities/src/main/java/fr/ird/observe/entities/referentiel/ReferenceEntities.java b/observe-entities/src/main/java/fr/ird/observe/entities/referentiel/ReferenceEntities.java index 31d51c3..69f84aa 100644 --- a/observe-entities/src/main/java/fr/ird/observe/entities/referentiel/ReferenceEntities.java +++ b/observe-entities/src/main/java/fr/ird/observe/entities/referentiel/ReferenceEntities.java @@ -23,6 +23,7 @@ package fr.ird.observe.entities.referentiel; */ import com.google.common.base.Predicate; +import com.google.common.collect.ImmutableMap; import fr.ird.observe.ObserveEntityEnum; import fr.ird.observe.entities.Entities; import fr.ird.observe.entities.constants.ReferenceStatus; @@ -32,6 +33,7 @@ import org.nuiton.topia.persistence.TopiaEntity; import java.util.Iterator; import java.util.List; +import java.util.Map; /** * Helper class around {@link ReferenceEntity}. @@ -89,6 +91,7 @@ public class ReferenceEntities { } public static final Predicate<? extends ReferenceEntity> IS_ACTIF_PREDICATE = new Predicate<ReferenceEntity>() { + @Override public boolean apply(ReferenceEntity input) { return ReferenceStatus.disabled != input.getStatus(); @@ -123,4 +126,45 @@ public class ReferenceEntities { <E extends TopiaEntity> void walk(Class<E> beanClass) throws Exception; } + public static <E extends ReferenceEntity> String toString(int referenceLocaleOrdinal, E entity) { + + String result = null; + if (entity != null) { + for (Map.Entry<Class<?>, ReferenceEntityToString> entry : TO_STRING_CACHE.entrySet()) { + + if (entry.getKey().isAssignableFrom(entity.getClass())) { + + ReferenceEntityToString<E> value = entry.getValue(); + result = value.toString(referenceLocaleOrdinal, entity); + break; + } + } + if (result == null && entity instanceof I18nReferenceEntity) { + + + result = I18nReferenceEntities.decorate(referenceLocaleOrdinal, (I18nReferenceEntity) entity); + } + } + + return result; + + } + + private static final ImmutableMap<Class<?>, ReferenceEntityToString> TO_STRING_CACHE = ImmutableMap + .<Class<?>, ReferenceEntityToString>builder() + .put(Species.class, new ReferenceEntityToString<Species>() { + + @Override + public String toString(int referenceLocaleOrdinal, Species entity) { + return entity.getScientificLabel(); + } + }) + .build(); + + + interface ReferenceEntityToString<E extends ReferenceEntity> { + + String toString(int referenceLocaleOrdinal, E entity); + } + } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.
This is an automated email from the git hooks/post-receive script. New commit to branch feature/refactor_reference in repository observe. See http://git.codelutin.com/observe.git commit 17cdae834599aa6425dfb7e568f64e5902fdd3a4 Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Nov 12 09:43:36 2015 +0100 Ajout de définition de requètes de données --- .../services/service/ReferenceSetDefinition.java | 70 ++++++ .../services/service/ReferenceSetDefinitions.java | 253 +++++++++++++++++++++ .../service/ReferenceSetPropertyDefinition.java | 67 ++++++ .../services/service/ReferenceSetRequest.java | 31 +++ .../service/ReferenceSetRequestDefinition.java | 53 +++++ .../service/ReferenceSetRequestDefinitions.java | 39 ++++ .../service/ReferenceSetRequestKeyDefinition.java | 86 +++++++ .../service/ReferentialReferenceSetResult.java | 55 +++++ 8 files changed, 654 insertions(+) diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetDefinition.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetDefinition.java new file mode 100644 index 0000000..edac622 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetDefinition.java @@ -0,0 +1,70 @@ +package fr.ird.observe.services.service; + +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.services.dto.IdDto; +import fr.ird.observe.services.dto.ReferenceSetDto; + +import java.io.Serializable; + +/** + * Pour définir ce que l'on doit retrouver dans un ensemble de références d'un même type. + * + * Created on 11/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferenceSetDefinition<D extends IdDto> implements Serializable{ + + private static final long serialVersionUID = 1L; + + /** + * Le type du dto qui doit être transformé en références. + * {@link ReferenceSetDto#getType()}. + */ + private final Class<D> type; + + private final ImmutableSet<ReferenceSetPropertyDefinition> properties; + + public ReferenceSetDefinition(Class<D> type, ImmutableSet<ReferenceSetPropertyDefinition> properties) { + this.type = type; + this.properties = properties; + } + + public Class<D> getType() { + return type; + } + + public ImmutableSet<ReferenceSetPropertyDefinition> getProperties() { + return properties; + } + + public static <D extends IdDto> Builder<D> builder(Class<D> type) { + return new Builder<>(type); + } + + public static class Builder<D extends IdDto> { + + private final Class<D> type; + + private final ImmutableSet.Builder<ReferenceSetPropertyDefinition> propertiesBuilder; + + public Builder(Class<D> type) { + this.type = type; + this.propertiesBuilder = ImmutableSet.builder(); + } + + public <O> Builder<D> addProperty(Class<O> type, String name) { + return addProperty(ReferenceSetPropertyDefinition.of(type, name)); + } + + public Builder<D> addProperty(ReferenceSetPropertyDefinition propertyDefinition) { + propertiesBuilder.add(propertyDefinition); + return this; + } + + public ReferenceSetDefinition<D> build() { + return new ReferenceSetDefinition<>(type, propertiesBuilder.build()); + } + } + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetDefinitions.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetDefinitions.java new file mode 100644 index 0000000..be4abc9 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetDefinitions.java @@ -0,0 +1,253 @@ +package fr.ird.observe.services.service; + +import fr.ird.observe.services.dto.constants.GearType; +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; + +/** + * Contient les définitions de tous les ensembles de référence utilisables dans les services. + * + * Created on 11/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public enum ReferenceSetDefinitions { + + COUNTRY(newDefaultDefinitionBuilder(CountryDto.class)), + + FPA_ZONE(newDefaultDefinitionBuilder(FpaZoneDto.class)), + + GEAR_CARACTERISTIC(newDefinitionBuilder(GearCaracteristicDto.class) + .addProperty(String.class, GearCaracteristicDto.PROPERTY_GEAR_CARACTERISTIC_TYPE)), + + GEAR_CARACTERISTIC_TYPE(newDefaultDefinitionBuilder(GearCaracteristicTypeDto.class)), + + GEAR(newDefaultDefinitionBuilder(GearDto.class)), + + HARBOUR(newDefinitionBuilder(HarbourDto.class) + .addProperty(String.class, HarbourDto.PROPERTY_CODE) + .addProperty(String.class, HarbourDto.PROPERTY_NAME) + .addProperty(String.class, HarbourDto.PROPERTY_LOCODE)), + + LENGTH_WEIGHT_PARAMETER(newDefinitionBuilder(LengthWeightParameterDto.class) + .addProperty(String.class, LengthWeightParameterDto.PROPERTY_CODE) + .addProperty(String.class, LengthWeightParameterDto.PROPERTY_OCEAN) + .addProperty(String.class, LengthWeightParameterDto.PROPERTY_SPECIES) + .addProperty(String.class, LengthWeightParameterDto.PROPERTY_LENGTH_WEIGHT_FORMULA) + .addProperty(String.class, LengthWeightParameterDto.PROPERTY_WEIGHT_LENGTH_FORMULA)), + + OCEAN(newDefaultDefinitionBuilder(OceanDto.class)), + + ORGANISM(newDefaultDefinitionBuilder(OrganismDto.class)), + + PERSON(newDefinitionBuilder(PersonDto.class) + .addProperty(String.class, PersonDto.PROPERTY_FIRST_NAME) + .addProperty(String.class, PersonDto.PROPERTY_LAST_NAME) + .addProperty(String.class, PersonDto.PROPERTY_CAPTAIN) + .addProperty(String.class, PersonDto.PROPERTY_DATA_ENTRY_OPERATOR) + .addProperty(String.class, PersonDto.PROPERTY_OBSERVER)), + + PROGRAM(newDefinitionBuilder(ProgramDto.class) + .addProperty(GearType.class, ProgramDto.PROPERTY_GEAR_TYPE) + .addProperty(String.class, ProgramDto.PROPERTY_GEAR_TYPE_PREFIX)), + + SEX(newDefaultDefinitionBuilder(SexDto.class)), + + SPECIES(newDefinitionBuilder(SpeciesDto.class) + .addProperty(String.class, SpeciesDto.PROPERTY_SCIENTIFIC_LABEL) + .addProperty(String.class, SpeciesDto.PROPERTY_HOME_ID) + .addProperty(String.class, SpeciesDto.PROPERTY_LENGTH_MEASURE_TYPE)), + + SPECIES_GROUP(newDefaultDefinitionBuilder(SpeciesGroupDto.class)), + + SPECIES_LIST(newDefaultDefinitionBuilder(SpeciesListDto.class)), + + VESSEL_SIZE_CATEGORY(newDefinitionBuilder(VesselSizeCategoryDto.class) + .addProperty(String.class, VesselSizeCategoryDto.PROPERTY_GAUGE_LABEL) + .addProperty(String.class, VesselSizeCategoryDto.PROPERTY_CAPACITY_LABEL)), + + VESSEL(newDefaultDefinitionBuilder(VesselDto.class)), + + VESSEL_TYPE(newDefaultDefinitionBuilder(VesselTypeDto.class)), + + // -------------------------------------------------------------------------------------------------------------- // + // -- REFERENTIAL LONGLINE -------------------------------------------------------------------------------------- // + // -------------------------------------------------------------------------------------------------------------- // + + BAIT_HAULING_STATUS(newDefaultDefinitionBuilder(BaitHaulingStatusDto.class)), + + BAIT_SETTING_STATUS(newDefaultDefinitionBuilder(BaitSettingStatusDto.class)), + + BAITTYPE(newDefaultDefinitionBuilder(BaitTypeDto.class)), + + CATCH_FATE_LONGLINE(newDefaultDefinitionBuilder(CatchFateLonglineDto.class)), + + ENCOUNTER_TYPE(newDefaultDefinitionBuilder(EncounterTypeDto.class)), + + HEALTHNESS(newDefaultDefinitionBuilder(HealthnessDto.class)), + + HOOK_POSITION(newDefaultDefinitionBuilder(HookPositionDto.class)), + + HOOK_SIZE(newDefaultDefinitionBuilder(HookSizeDto.class)), + + HOOK_TYPE(newDefaultDefinitionBuilder(HookTypeDto.class)), + + ITEM_HORIZONTAL_POSITION(newDefaultDefinitionBuilder(ItemHorizontalPositionDto.class)), + + ITEM_VERTICAL_POSITION(newDefaultDefinitionBuilder(ItemVerticalPositionDto.class)), + + LIGHTSTICKS_COLOR(newDefaultDefinitionBuilder(LightsticksColorDto.class)), + + LIGHTSTICKS_TYPE(newDefaultDefinitionBuilder(LightsticksTypeDto.class)), + + LINE_TYPE(newDefaultDefinitionBuilder(LineTypeDto.class)), + + MATURITY_STATUS(newDefaultDefinitionBuilder(MaturityStatusDto.class)), + + MITIGATION_TYPE(newDefaultDefinitionBuilder(MitigationTypeDto.class)), + + SENSOR_BRAND(newDefinitionBuilder(SensorBrandDto.class) + .addProperty(String.class, SensorBrandDto.PROPERTY_BRAND_NAME)), + + SENSOR_DATA_FORMAT(newDefaultDefinitionBuilder(SensorDataFormatDto.class)), + + SENSOR_TYPE(newDefaultDefinitionBuilder(SensorTypeDto.class)), + + SETTING_SHAPE(newDefaultDefinitionBuilder(SettingShapeDto.class)), + + SIZE_MEASURE_TYPE(newDefaultDefinitionBuilder(SizeMeasureTypeDto.class)), + + STOMAC_FULLNESS(newDefaultDefinitionBuilder(StomacFullnessDto.class)), + + TRIP_TYPE(newDefaultDefinitionBuilder(TripTypeDto.class)), + + VESSEL_ACTIVITY_LONGLINE(newDefaultDefinitionBuilder(VesselActivityLonglineDto.class)), + + WEIGHT_MEASURE_TYPE(newDefaultDefinitionBuilder(WeightMeasureTypeDto.class)), + + // -------------------------------------------------------------------------------------------------------------- // + // -- REFERENTIAL SEINE ----------------------------------------------------------------------------------------- // + // -------------------------------------------------------------------------------------------------------------- // + + DETECTION_MODE(newDefaultDefinitionBuilder(DetectionModeDto.class)), + + OBJECT_FATE(newDefaultDefinitionBuilder(ObjectFateDto.class)), + + OBJECT_OPERATION(newDefaultDefinitionBuilder(ObjectOperationDto.class)), + + OBJECT_TYPE(newDefaultDefinitionBuilder(ObjectTypeDto.class)), + + OBSERVED_SYSTEM(newDefaultDefinitionBuilder(ObservedSystemDto.class)), + + REASON_FOR_DISCARD(newDefaultDefinitionBuilder(ReasonForDiscardDto.class)), + + REASON_FOR_NO_FISHING(newDefaultDefinitionBuilder(ReasonForNoFishingDto.class)), + + REASON_FOR_NULL_SET(newDefaultDefinitionBuilder(ReasonForNullSetDto.class)), + + SPECIES_FATE(newDefaultDefinitionBuilder(SpeciesFateDto.class)), + + SPECIES_STATUS(newDefaultDefinitionBuilder(SpeciesStatusDto.class)), + + SURROUNDING_ACTIVITY(newDefaultDefinitionBuilder(SurroundingActivityDto.class)), + + TRANSMITTING_BUOYO_PERATION(newDefaultDefinitionBuilder(TransmittingBuoyOperationDto.class)), + + TRANSMITTING_BUOY_TYPE(newDefaultDefinitionBuilder(TransmittingBuoyTypeDto.class)), + + VESSEL_ACTIVITY_SEINE(newDefaultDefinitionBuilder(VesselActivitySeineDto.class)), + + WEIGHT_CATEGORY(newDefinitionBuilder(WeightCategoryDto.class) + .addProperty(String.class, WeightCategoryDto.PROPERTY_LABEL) + .addProperty(String.class, WeightCategoryDto.PROPERTY_SPECIES)), + + WIND(newDefinitionBuilder(WindDto.class) + .addProperty(String.class, WindDto.PROPERTY_LABEL) + .addProperty(String.class, WindDto.PROPERTY_SPEED_RANGE) + ); + + private final ReferenceSetDefinition definition; + + ReferenceSetDefinitions(ReferenceSetDefinition.Builder definition) { + this.definition = definition.build(); + } + + public ReferenceSetDefinition<?> getDefinition() { + return definition; + } + + protected static <R extends ReferentialDto> ReferenceSetDefinition.Builder newDefinitionBuilder(Class<R> type) { + ReferenceSetDefinition.Builder<R> builder = ReferenceSetDefinition.builder(type); + return builder; + } + + protected static <R extends ReferentialDto> ReferenceSetDefinition.Builder newDefaultDefinitionBuilder(Class<R> type) { + ReferenceSetDefinition.Builder<R> builder = ReferenceSetDefinition + .builder(type) + .addProperty(String.class, ReferentialDto.PROPERTY_CODE); + if (I18nReferentialDto.class.isAssignableFrom(type)) { + builder.addProperty(String.class, I18nReferentialDto.PROPERTY_LABEL); + } + return builder; + } + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetPropertyDefinition.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetPropertyDefinition.java new file mode 100644 index 0000000..79035bd --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetPropertyDefinition.java @@ -0,0 +1,67 @@ +package fr.ird.observe.services.service; + +import com.google.common.base.MoreObjects; + +import java.io.Serializable; +import java.util.Objects; + +/** + * Pour définir une propriété à remonter dans un ensemble de référence. + * + * Created on 11/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferenceSetPropertyDefinition<O> implements Serializable { + + private static final long serialVersionUID = 1L; + + /** + * Le type de la propriété. + */ + private final Class<O> type; + + /** + * Le nom de la propriété. + */ + private final String name; + + public static <O> ReferenceSetPropertyDefinition<O> of(Class<O> type, String name) { + return new ReferenceSetPropertyDefinition<>(type, name); + } + + public ReferenceSetPropertyDefinition(Class<O> type, String name) { + this.type = type; + this.name = name; + } + + public Class<O> getType() { + return type; + } + + public String getName() { + return name; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof ReferenceSetPropertyDefinition)) return false; + ReferenceSetPropertyDefinition<?> that = (ReferenceSetPropertyDefinition<?>) o; + return Objects.equals(type, that.type) && + Objects.equals(name, that.name); + } + + @Override + public int hashCode() { + return Objects.hash(type, name); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("type", type) + .add("name", name) + .toString(); + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetRequest.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetRequest.java new file mode 100644 index 0000000..4801de4 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetRequest.java @@ -0,0 +1,31 @@ +package fr.ird.observe.services.service; + +import com.google.common.collect.ImmutableMap; + +import java.util.Date; + +/** + * Created on 10/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferenceSetRequest { + + private final String requestName; + + private final ImmutableMap<String, Date> lastUpdateDates; + + public ReferenceSetRequest(String requestName, ImmutableMap<String, Date> lastUpdateDates) { + this.requestName = requestName; + this.lastUpdateDates = lastUpdateDates; + } + + public String getRequestName() { + return requestName; + } + + public ImmutableMap<String, Date> getLastUpdateDates() { + return lastUpdateDates; + } + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetRequestDefinition.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetRequestDefinition.java new file mode 100644 index 0000000..2d49605 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetRequestDefinition.java @@ -0,0 +1,53 @@ +package fr.ird.observe.services.service; + +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.services.dto.IdDto; + +import java.io.Serializable; + +/** + * Pour définir une demande de récupération d'ensemble de références. + * + * Created on 11/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferenceSetRequestDefinition implements Serializable { + + private static final long serialVersionUID = 1L; + + private final ImmutableSet<ReferenceSetRequestKeyDefinition> keys; + + public ReferenceSetRequestDefinition(ImmutableSet<ReferenceSetRequestKeyDefinition> keys) { + this.keys = keys; + } + + public ImmutableSet<ReferenceSetRequestKeyDefinition> getKeys() { + return keys; + } + + public static <D extends IdDto> Builder<D> builder(Class<D> type) { + return new Builder<>(type); + } + + public static class Builder<D extends IdDto> { + + private final Class<D> parentType; + + private final ImmutableSet.Builder<ReferenceSetRequestKeyDefinition> keysBuilder; + + public Builder(Class<D> parentType) { + this.parentType = parentType; + this.keysBuilder = ImmutableSet.builder(); + } + + public Builder<D> addKey(String name, ReferenceSetDefinitions propertyDefinition) { + keysBuilder.add(new ReferenceSetRequestKeyDefinition<>(parentType, propertyDefinition.getDefinition(), name)); + return this; + } + + public ReferenceSetRequestDefinition build() { + return new ReferenceSetRequestDefinition(keysBuilder.build()); + } + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetRequestDefinitions.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetRequestDefinitions.java new file mode 100644 index 0000000..eef1c48 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetRequestDefinitions.java @@ -0,0 +1,39 @@ +package fr.ird.observe.services.service; + +import fr.ird.observe.services.dto.IdDto; +import fr.ird.observe.services.dto.seine.TripSeineDto; + +/** + * Contient les définitions de tous les requêtes que les services proposent. + * + * Created on 11/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public enum ReferenceSetRequestDefinitions { + + TRIP_SEINE_FORM(newBuilder(TripSeineDto.class) + .addKey(TripSeineDto.PROPERTY_OBSERVER, ReferenceSetDefinitions.PERSON) + .addKey(TripSeineDto.PROPERTY_CAPTAIN, ReferenceSetDefinitions.PERSON) + .addKey(TripSeineDto.PROPERTY_DATA_ENTRY_OPERATOR, ReferenceSetDefinitions.PERSON) + .addKey(TripSeineDto.PROPERTY_VESSEL, ReferenceSetDefinitions.VESSEL) + .addKey(TripSeineDto.PROPERTY_OCEAN, ReferenceSetDefinitions.OCEAN) + .addKey(TripSeineDto.PROPERTY_DEPARTURE_HARBOUR, ReferenceSetDefinitions.HARBOUR) + .addKey(TripSeineDto.PROPERTY_LANDING_HARBOUR, ReferenceSetDefinitions.HARBOUR) + .addKey(TripSeineDto.PROPERTY_PROGRAM, ReferenceSetDefinitions.PROGRAM)),; + + public final ReferenceSetRequestDefinition definition; + + ReferenceSetRequestDefinitions(ReferenceSetRequestDefinition.Builder definitionBuilder) { + this.definition = definitionBuilder.build(); + } + + public ReferenceSetRequestDefinition getDefinition() { + return definition; + } + + public static <D extends IdDto> ReferenceSetRequestDefinition.Builder<D> newBuilder(Class<D> parentType) { + return new ReferenceSetRequestDefinition.Builder<>(parentType); + } + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetRequestKeyDefinition.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetRequestKeyDefinition.java new file mode 100644 index 0000000..8d72a4f --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetRequestKeyDefinition.java @@ -0,0 +1,86 @@ +package fr.ird.observe.services.service; + +import com.google.common.base.Function; +import com.google.common.collect.Iterables; +import fr.ird.observe.services.dto.IdDto; +import fr.ird.observe.services.dto.referential.ReferentialDto; + +import java.util.Objects; + +/** + * Created on 10/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferenceSetRequestKeyDefinition<D extends IdDto> { + + private final Class<? extends IdDto> parentType; + + private final ReferenceSetDefinition<D> referenceSetDefinition; + + private final String name; + + private final String[] propertyNames; + + private final Class<?>[] propertyTypes; + + public ReferenceSetRequestKeyDefinition(Class<? extends IdDto> parentType, ReferenceSetDefinition<D> referenceSetDefinition, String name) { + this.parentType = parentType; + this.referenceSetDefinition = referenceSetDefinition; + this.name = name; + this.propertyNames = Iterables.toArray(Iterables.transform(referenceSetDefinition.getProperties(), new Function<ReferenceSetPropertyDefinition, String>() { + + @Override + public String apply(ReferenceSetPropertyDefinition input) { + return input.getName(); + } + }), String.class); + this.propertyTypes = Iterables.toArray(Iterables.transform(referenceSetDefinition.getProperties(), new Function<ReferenceSetPropertyDefinition, Class<?>>() { + + @Override + public Class<?> apply(ReferenceSetPropertyDefinition input) { + return input.getType(); + } + }), Class.class); + } + + public Class<? extends IdDto> getParentType() { + return parentType; + } + + public Class<D> getType() { + return referenceSetDefinition.getType(); + } + + public String[] getPropertyNames() { + return propertyNames; + } + + public Class<?>[] getPropertyTypes() { + return propertyTypes; + } + + public String getName() { + return name; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof ReferenceSetRequestKeyDefinition)) return false; + ReferenceSetRequestKeyDefinition that = (ReferenceSetRequestKeyDefinition) o; + return Objects.equals(parentType, that.parentType) && + Objects.equals(referenceSetDefinition.getType(), that.referenceSetDefinition.getType()) && + Objects.equals(name, that.name); + } + + @Override + public int hashCode() { + return Objects.hash(parentType, referenceSetDefinition.getType(), name); + } + + public boolean isReferential() { + Class<?> type = referenceSetDefinition.getType(); + return type.isAssignableFrom(ReferentialDto.class); + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferentialReferenceSetResult.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferentialReferenceSetResult.java new file mode 100644 index 0000000..1de8e9e --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferentialReferenceSetResult.java @@ -0,0 +1,55 @@ +package fr.ird.observe.services.service; + +import com.google.common.collect.ImmutableMap; +import fr.ird.observe.services.dto.ReferenceSetDto; + +/** + * Created on 10/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferentialReferenceSetResult { + + private final ReferenceSetRequest request; + + private final ImmutableMap<String, ReferenceSetDto> referenceSetsMap; + + public ReferentialReferenceSetResult(ReferenceSetRequest request, ImmutableMap<String, ReferenceSetDto> referenceSetsMap) { + this.request = request; + this.referenceSetsMap = referenceSetsMap; + } + + public ReferenceSetRequest getRequest() { + return request; + } + + public ImmutableMap<String, ReferenceSetDto> getReferenceSetsMap() { + return referenceSetsMap; + } + + public static Builder builder(final ReferenceSetRequest request) { + return new Builder(request); + } + + public static class Builder { + + private final ReferenceSetRequest request; + + private final ImmutableMap.Builder<String, ReferenceSetDto> referenceSetsMapBuilder; + + public Builder(ReferenceSetRequest request) { + this.request = request; + this.referenceSetsMapBuilder = ImmutableMap.builder(); + } + + public Builder addKey(String name, ReferenceSetDto referenceSet) { + referenceSetsMapBuilder.put(name, referenceSet); + return this; + } + + public ReferentialReferenceSetResult build() { + return new ReferentialReferenceSetResult(request, referenceSetsMapBuilder.build()); + } + } + +} -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.
This is an automated email from the git hooks/post-receive script. New commit to branch feature/refactor_reference in repository observe. See http://git.codelutin.com/observe.git commit b393c43d960524e65e1aa98c34018cbe05ba1da0 Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Nov 12 09:44:07 2015 +0100 Ajout d'un service pour récupérer des referecne set (à finir) --- .../v1/ReferenceSetServiceController.java | 28 ++++ .../services/service/ReferenceSetService.java | 24 +++ .../fr/ird/observe/services/dto/ReferenceDto.java | 9 +- .../dto/referential/ReferentialReferenceDto.java | 6 + .../EntityToReferentialReferenceDtoBuilder.java | 113 +++++++++++++- .../services/service/ReferenceSetServiceTopia.java | 162 +++++++++++++++++++++ 6 files changed, 339 insertions(+), 3 deletions(-) diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/ReferenceSetServiceController.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/ReferenceSetServiceController.java new file mode 100644 index 0000000..7dcc967 --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/ReferenceSetServiceController.java @@ -0,0 +1,28 @@ +package fr.ird.observe.application.web.controller.v1; + +import fr.ird.observe.services.service.ReferenceSetRequest; +import fr.ird.observe.services.service.ReferenceSetService; +import fr.ird.observe.services.service.ReferentialReferenceSetResult; + +/** + * Created on 11/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferenceSetServiceController extends ObserveAuthenticatedServiceControllerSupport<ReferenceSetService> implements ReferenceSetService { + + public ReferenceSetServiceController() { + super(ReferenceSetService.class); + } + + @Override + public ReferentialReferenceSetResult loadDataReferenceSets(ReferenceSetRequest request) { + return service.loadDataReferenceSets(request); + } + + @Override + public ReferentialReferenceSetResult loadReferentialReferenceSets(ReferenceSetRequest request) { + return service.loadReferentialReferenceSets(request); + } + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetService.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetService.java new file mode 100644 index 0000000..36f7d0e --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetService.java @@ -0,0 +1,24 @@ +package fr.ird.observe.services.service; + +import fr.ird.observe.services.ObserveService; +import fr.ird.observe.services.dto.ReferenceSetDto; +import fr.ird.observe.services.spi.ReadDataPermission; +import fr.ird.observe.services.spi.ReadReferentialPermission; + +/** + * Pour gérer les {@link ReferenceSetDto}. + * + * Created on 11/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public interface ReferenceSetService extends ObserveService { + + @ReadDataPermission + ReferentialReferenceSetResult loadDataReferenceSets(ReferenceSetRequest request); + + @ReadReferentialPermission + ReferentialReferenceSetResult loadReferentialReferenceSets(ReferenceSetRequest request); + + +} diff --git a/observe-services-model/src/main/java/fr/ird/observe/services/dto/ReferenceDto.java b/observe-services-model/src/main/java/fr/ird/observe/services/dto/ReferenceDto.java index 607195d..7301ecf 100644 --- a/observe-services-model/src/main/java/fr/ird/observe/services/dto/ReferenceDto.java +++ b/observe-services-model/src/main/java/fr/ird/observe/services/dto/ReferenceDto.java @@ -66,7 +66,14 @@ public class ReferenceDto<D extends IdDto> extends AbstractReferenceDto { init(type, false, labelPropertyNames); } - public void init(Class<D> type, boolean convertToReference,Iterable<String> labelPropertyNames) { + public void init(Class<D> type, String[] labelPropertyNames, Class[] labelPropertyTypes, Serializable... labelPropertyValues) { + this.type = type; + this.labelPropertyNames = Arrays.asList(labelPropertyNames); + this.labelPropertyValues = labelPropertyValues; + this.labelPropertyTypes = labelPropertyTypes; + } + + public void init(Class<D> type, boolean convertToReference, Iterable<String> labelPropertyNames) { this.type = type; this.labelPropertyNames = Lists.newArrayList(labelPropertyNames); this.labelPropertyValues = new Serializable[this.labelPropertyNames.size()]; diff --git a/observe-services-model/src/main/java/fr/ird/observe/services/dto/referential/ReferentialReferenceDto.java b/observe-services-model/src/main/java/fr/ird/observe/services/dto/referential/ReferentialReferenceDto.java index 982bc41..b594ae4 100644 --- a/observe-services-model/src/main/java/fr/ird/observe/services/dto/referential/ReferentialReferenceDto.java +++ b/observe-services-model/src/main/java/fr/ird/observe/services/dto/referential/ReferentialReferenceDto.java @@ -53,6 +53,12 @@ public class ReferentialReferenceDto<D extends ReferentialDto> extends AbstractR return super.getType(); } + @Override + public void init(Class type, String[] labelPropertyNames, Class[] labelPropertyTypes, Serializable... labelPropertyValues) { + + super.init(type, labelPropertyNames, labelPropertyTypes, labelPropertyValues); + } + public void setPropertyValue(ReferentialLocale referentialLocale, String propertyName, Serializable propertyValue) { Preconditions.checkNotNull(referentialLocale, "referentialLocale parameter can't be null"); Preconditions.checkNotNull(propertyName, "propertyName parameter can't be null"); diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferentialReferenceDtoBuilder.java b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferentialReferenceDtoBuilder.java index 2283ad3..25148fe 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferentialReferenceDtoBuilder.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferentialReferenceDtoBuilder.java @@ -24,6 +24,7 @@ package fr.ird.observe.services.builder; import com.google.common.base.Function; import com.google.common.base.Preconditions; +import fr.ird.observe.entities.referentiel.ReferenceEntities; import fr.ird.observe.entities.referentiel.ReferenceEntity; import fr.ird.observe.services.ObserveServiceTopia; import fr.ird.observe.services.dto.ObserveDtoBinders; @@ -32,12 +33,16 @@ import fr.ird.observe.services.dto.constants.ReferentialLocale; import fr.ird.observe.services.dto.referential.ReferentialDto; import fr.ird.observe.services.dto.referential.ReferentialReferenceDto; import fr.ird.observe.services.dto.referential.ReferentialReferenceDtos; +import fr.ird.observe.services.service.ReferenceSetRequestKeyDefinition; import org.hibernate.Hibernate; import org.hibernate.proxy.HibernateProxy; import org.nuiton.topia.persistence.TopiaEntity; import org.nuiton.util.beans.Binder; +import org.nuiton.util.beans.BinderFactory; import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; import java.util.Map; import java.util.Set; @@ -50,6 +55,110 @@ import java.util.Set; */ public class EntityToReferentialReferenceDtoBuilder<E extends ReferenceEntity, D extends ReferentialDto> { + private Class<D> type; + + private Binder<E, E> binder; + + private String[] propertyNames; + + private String[] entityPropertyNames; + + private Class<?>[] propertyTypes; + + private int referentialLocaleOrdinal; + + public static <E extends ReferenceEntity, D extends ReferentialDto> EntityToReferentialReferenceDtoBuilder<E, D> of(ReferentialLocale referentialLocale, ReferenceSetRequestKeyDefinition<D> requestKeyDefinition, Class<E> entityType) { + + EntityToReferentialReferenceDtoBuilder<E, D> referenceDtoBuilder = new EntityToReferentialReferenceDtoBuilder<>(); + + referenceDtoBuilder.type = requestKeyDefinition.getType(); + referenceDtoBuilder.referentialLocaleOrdinal = referentialLocale.ordinal(); + referenceDtoBuilder.binder = BinderFactory.newBinder(entityType); + referenceDtoBuilder.propertyNames = requestKeyDefinition.getPropertyNames(); + + List<String> entityPropertyNames = new ArrayList<>(); + + for (String propertyName : referenceDtoBuilder.propertyNames) { + + if (ReferentialReferenceDto.PROPERTY_LABEL.contains(propertyName)) { + propertyName = referentialLocale.getLibelle(); + } + entityPropertyNames.add(propertyName); + } + referenceDtoBuilder.entityPropertyNames = entityPropertyNames.toArray(new String[entityPropertyNames.size()]); + referenceDtoBuilder.propertyTypes = requestKeyDefinition.getPropertyTypes(); + + return referenceDtoBuilder; + + } + + public ReferentialReferenceDto<D> build(E entity) { + + Preconditions.checkNotNull(entity, "'entity' can't be null"); + + // on extrait l' entité du proxy hibernate + if (entity instanceof HibernateProxy) { + Hibernate.initialize(entity); + entity = (E) ((HibernateProxy) entity).getHibernateLazyInitializer().getImplementation(); + } + + Map<String, Object> entityProperties = binder.obtainProperties(entity, true, entityPropertyNames); + + Serializable[] propertyValues = new Serializable[propertyTypes.length]; + for (int i = 0; i < propertyTypes.length; i++) { + String propertyName = propertyNames[i]; + + Serializable propertyValue = (Serializable) entityProperties.get(propertyName); + if (propertyValue != null) { + + Class<?> propertyType = propertyTypes[i]; + + if (propertyValue instanceof ReferenceEntity) { + + ReferenceEntity referentialEntity = (ReferenceEntity) propertyValue; + if (String.class.equals(propertyType)) { + + // Conversion + + propertyValue = ReferenceEntities.toString(referentialLocaleOrdinal, referentialEntity); + + } else { + + // on veut récupérer une référence + //TODO + + } + + } else { + + propertyValue = transform(propertyValue); + + } + + Preconditions.checkState(propertyType.isAssignableFrom(propertyValue.getClass()), "Le type de la propriété " + propertyName + " devrait être du type " + propertyType.getName() + " mais vaut: " + propertyValue); + + } + + propertyValues[i] = propertyValue; + + } + + ReferentialReferenceDto<D> result = new ReferentialReferenceDto<>(); + result.init(type, propertyNames, propertyTypes, propertyValues); + + result.setId(entity.getTopiaId()); + result.setEnabled(entity.isEnabled()); + result.setNeedComment(entity.isNeedComment()); + + result.setVersion(entity.getTopiaVersion()); + result.setCreateDate(entity.getTopiaCreateDate()); + result.setLastUpdate(entity.getLastUpdate()); + result.setEnabled(fr.ird.observe.entities.constants.ReferenceStatus.enabled == entity.getStatus()); + + return result; + + } + public static <E extends ReferenceEntity, D extends ReferentialDto> ReferentialReferenceDto<D> build(Class<D> dtoType, ReferentialLocale referentialLocale, E entity) { Preconditions.checkNotNull(dtoType, "'dtoType' can't be null"); @@ -110,12 +219,12 @@ public class EntityToReferentialReferenceDtoBuilder<E extends ReferenceEntity, D } - protected static Object transform(Object propertyValue) { + protected static Serializable transform(Object propertyValue) { Function function = ObserveDtosInitializer.getEntityToDtoFunction(propertyValue); if (function != null) { propertyValue = function.apply(propertyValue); } - return propertyValue; + return (Serializable) propertyValue; } diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/ReferenceSetServiceTopia.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/ReferenceSetServiceTopia.java new file mode 100644 index 0000000..3178da1 --- /dev/null +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/ReferenceSetServiceTopia.java @@ -0,0 +1,162 @@ +package fr.ird.observe.services.service; + +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableMap; +import fr.ird.observe.entities.referentiel.ReferenceEntity; +import fr.ird.observe.services.ObserveServiceTopia; +import fr.ird.observe.services.builder.EntityToReferentialReferenceDtoBuilder; +import fr.ird.observe.services.dto.IdDto; +import fr.ird.observe.services.dto.ReferenceSetDto; +import fr.ird.observe.services.dto.ReferenceSetDtos; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReferenceDto; +import fr.ird.observe.services.entity.EntitiesExtractor; +import org.nuiton.topia.persistence.TopiaEntity; + +import java.util.Collections; +import java.util.Date; +import java.util.LinkedHashSet; +import java.util.Map; + +/** + * Created on 11/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferenceSetServiceTopia extends ObserveServiceTopia implements ReferenceSetService { + + @Override + public ReferentialReferenceSetResult loadDataReferenceSets(ReferenceSetRequest request) { + String requestName = request.getRequestName(); + ReferenceSetRequestDefinitions requestDefinitions = ReferenceSetRequestDefinitions.valueOf(requestName); + if (requestDefinitions == null) { + throw new IllegalArgumentException("No request with name " + requestName + "registred"); + } + + ReferenceSetRequestDefinition requestDefinition = requestDefinitions.getDefinition(); + + ReferentialReferenceSetResult.Builder resultBuilder = new ReferentialReferenceSetResult.Builder(request); + + for (ReferenceSetRequestKeyDefinition requestKeyDefinition : requestDefinition.getKeys()) { + + boolean referential = requestKeyDefinition.isReferential(); + Preconditions.checkArgument(!referential, "Can't obtain referenceSet of referential here, but try with " + requestKeyDefinition); + + String name = requestKeyDefinition.getName(); + + ReferenceSetDto referenceSet = loadDataReferenceSet(requestKeyDefinition); + resultBuilder.addKey(name, referenceSet); + + } + + return resultBuilder.build(); + + } + + @Override + public ReferentialReferenceSetResult loadReferentialReferenceSets(ReferenceSetRequest request) { + + String requestName = request.getRequestName(); + ReferenceSetRequestDefinitions requestDefinitions = ReferenceSetRequestDefinitions.valueOf(requestName); + if (requestDefinitions == null) { + throw new IllegalArgumentException("No request with name " + requestName + "registred"); + } + + ReferenceSetRequestDefinition requestDefinition = requestDefinitions.getDefinition(); + + ReferentialReferenceSetResult.Builder resultBuilder = new ReferentialReferenceSetResult.Builder(request); + ImmutableMap<String, Date> lastUpdateDates = request.getLastUpdateDates(); + + for (ReferenceSetRequestKeyDefinition requestKeyDefinition : requestDefinition.getKeys()) { + + boolean referential = requestKeyDefinition.isReferential(); + Preconditions.checkArgument(referential, "Can't obtain referenceSet of data here, but try with " + requestKeyDefinition); + + String name = requestKeyDefinition.getName(); + Date lastUpdateDate = lastUpdateDates.get(name); + + ReferenceSetDto referenceSet = loadReferentialReferenceSet(requestKeyDefinition, lastUpdateDate); + resultBuilder.addKey(name, referenceSet); + } + + return resultBuilder.build(); + + } + + protected <D extends IdDto> ReferenceSetDto<D> loadDataReferenceSet(ReferenceSetRequestKeyDefinition<D> requestKeyDefinition) { + + Class<D> type = requestKeyDefinition.getType(); + Class<TopiaEntity> entityType = getEntityType(type); + String name = requestKeyDefinition.getName(); + + Iterable<TopiaEntity> entitiesExtractor = getEntities(requestKeyDefinition, Collections.<String, Object>emptyMap()); + + //TODO + ReferenceSetDto<D> referenceSet = null; + + return referenceSet; + } + + protected <D extends ReferentialDto, E extends ReferenceEntity> ReferenceSetDto<D> loadReferentialReferenceSet(ReferenceSetRequestKeyDefinition<D> requestKeyDefinition, Date lastUpdateDate) { + + Class<D> type = requestKeyDefinition.getType(); + Class<E> entityType = getEntityType(type); + String name = requestKeyDefinition.getName(); + + Optional<Date> lastUpdateOptional = getLastUpdate(entityType); + + ReferenceSetDto<D> referenceSet; + if (lastUpdateOptional.isPresent() && lastUpdateOptional.get().after(lastUpdateDate)) { + + EntityToReferentialReferenceDtoBuilder<E, D> referenceBuilder = EntityToReferentialReferenceDtoBuilder.of(serviceContext.getReferentialLocale(), requestKeyDefinition, entityType); + + Iterable<E> entities = getEntities(requestKeyDefinition, Collections.<String, Object>emptyMap()); + + LinkedHashSet<ReferentialReferenceDto<D>> labels = new LinkedHashSet<>(); + for (E entity : entities) { + + ReferentialReferenceDto<D> dto = referenceBuilder.build(entity); + labels.add(dto); + + } + referenceSet = ReferenceSetDtos.newReferenceSetDto(type, name, labels, lastUpdateOptional.get()); + + + } else { + + referenceSet = null; + + } + + return referenceSet; + } + + + protected <E extends TopiaEntity, D extends IdDto> Iterable<E> getEntities(ReferenceSetRequestKeyDefinition<D> requestKeyDefinition, + Map<String, Object> dataContext) { + + + Class<D> type = requestKeyDefinition.getType(); + Class<E> entityType = getEntityType(type); + Class<TopiaEntity> entityParentType = getEntityType(requestKeyDefinition.getParentType()); + String name = requestKeyDefinition.getName(); + + Iterable<E> entities; + + EntitiesExtractor<E> entitiesExtractor = serviceContext.getEntitiesSetFactory().newEntitiesSet(entityParentType, + entityType, + name); + + if (entitiesExtractor == null) { + + entities = loadEntities(entityType); + + } else { + entities = entitiesExtractor.getEntities(serviceContext.getTopiaPersistenceContext(), dataContext); + } + + return entities; + } + +} -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.
This is an automated email from the git hooks/post-receive script. New commit to branch feature/refactor_reference in repository observe. See http://git.codelutin.com/observe.git commit 2314dfc172d0a6d1cac4b2e509e0d67bf5748eaf Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Nov 12 09:44:34 2015 +0100 Début d'implantation d'un cache de référentiels (à finir) --- .../fr/ird/observe/db/ObserveReferentialCache.java | 64 ++++++++++++++++++++++ .../ird/observe/db/ObserveReferentialCacheKey.java | 33 +++++++++++ 2 files changed, 97 insertions(+) diff --git a/observe-application-swing/src/main/java/fr/ird/observe/db/ObserveReferentialCache.java b/observe-application-swing/src/main/java/fr/ird/observe/db/ObserveReferentialCache.java new file mode 100644 index 0000000..7b9defc --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/db/ObserveReferentialCache.java @@ -0,0 +1,64 @@ +package fr.ird.observe.db; + +import fr.ird.observe.services.dto.ReferenceSetDto; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.service.ReferenceSetService; +import fr.ird.observe.services.service.ReferentialService; + +import java.io.Closeable; +import java.util.Date; +import java.util.LinkedHashMap; +import java.util.Map; + +/** + * Created on 10/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ObserveReferentialCache implements Closeable { + + private final Map<ObserveReferentialCacheKey<?>, ReferenceSetDto> cache; + + public ObserveReferentialCache() { + this.cache = new LinkedHashMap<>(); + } + + public <D extends ReferentialDto> ReferenceSetDto<D> getReferenceSet(ObserveSwingDataSource dataSource, Class<D> type, String optionalContext) { + + ObserveReferentialCacheKey<D> referentialCacheKey = ObserveReferentialCacheKey.of(type, optionalContext); + ReferenceSetDto<D> result = getReferenceSet0(dataSource, referentialCacheKey); + return result; + } + + protected <D extends ReferentialDto> ReferenceSetDto<D> getReferenceSet0(ObserveSwingDataSource dataSource, ObserveReferentialCacheKey<D> key) { + + ReferenceSetDto<D> result; + if (cache.containsKey(key)) { + result = cache.get(key); + + Date lastUpdate = result.getLastUpdate(); + + ReferenceSetService referentialService = dataSource.newService(ReferenceSetService.class); + ReferenceSetDto<D> update = referentialService.getReferentialReferenceSetIfModify(key.getType(), key.getContext().orNull(), lastUpdate); + if (update != null) { + result = update; + cache.remove(key); + cache.put(key, update); + } + + } else { + + ReferentialService referentialService = dataSource.newService(ReferenceSetService.class); + result = referentialService.getReferentialReferenceSet(key.getType(), key.getContext().orNull()); + cache.put(key, result); + + } + return result; + + } + + @Override + public void close() { + cache.clear(); + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/db/ObserveReferentialCacheKey.java b/observe-application-swing/src/main/java/fr/ird/observe/db/ObserveReferentialCacheKey.java new file mode 100644 index 0000000..3eda009 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/db/ObserveReferentialCacheKey.java @@ -0,0 +1,33 @@ +package fr.ird.observe.db; + +import com.google.common.base.Optional; +import fr.ird.observe.services.dto.referential.ReferentialDto; + +/** + * Created on 10/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ObserveReferentialCacheKey<D extends ReferentialDto> { + + private final Class<D> type; + + private final Optional<String> context; + + public ObserveReferentialCacheKey(Class<D> type, Optional<String> context) { + this.type = type; + this.context = context; + } + + public Class<D> getType() { + return type; + } + + public Optional<String> getContext() { + return context; + } + + public static <D extends ReferentialDto> ObserveReferentialCacheKey<D> of(Class<D> type, String optionalContext) { + return new ObserveReferentialCacheKey<>(type, Optional.fromNullable(optionalContext)); + } +} -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.
participants (1)
-
codelutin.com scm