This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository observe. See http://git.codelutin.com/observe.git commit 3c3e86a84444588627505a1bdf0d357a81dc2d99 Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Aug 20 18:53:55 2015 +0200 Ajout du GsonSupplier --- observe-services-model/pom.xml | 4 + .../ird/observe/services/dto/gson/DateAdapter.java | 94 ++++++++++++++++++++++ .../observe/services/dto/gson/IntegerAdapter.java | 36 +++++++++ .../services/dto/gson/ObserveDtoGsonSupplier.java | 52 ++++++++++++ 4 files changed, 186 insertions(+) diff --git a/observe-services-model/pom.xml b/observe-services-model/pom.xml index a35de0f..7c25fff 100644 --- a/observe-services-model/pom.xml +++ b/observe-services-model/pom.xml @@ -62,6 +62,10 @@ <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> </dependency> + <dependency> + <groupId>com.google.code.gson</groupId> + <artifactId>gson</artifactId> + </dependency> </dependencies> diff --git a/observe-services-model/src/main/java/fr/ird/observe/services/dto/gson/DateAdapter.java b/observe-services-model/src/main/java/fr/ird/observe/services/dto/gson/DateAdapter.java new file mode 100644 index 0000000..a5f99c9 --- /dev/null +++ b/observe-services-model/src/main/java/fr/ird/observe/services/dto/gson/DateAdapter.java @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2008 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package fr.ird.observe.services.dto.gson; + + +import com.google.gson.JsonDeserializationContext; +import com.google.gson.JsonDeserializer; +import com.google.gson.JsonElement; +import com.google.gson.JsonParseException; +import com.google.gson.JsonPrimitive; +import com.google.gson.JsonSerializationContext; +import com.google.gson.JsonSerializer; +import com.google.gson.JsonSyntaxException; + +import java.lang.reflect.Type; +import java.sql.Timestamp; +import java.text.DateFormat; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.TimeZone; + +/** + * This type adapter supports three subclasses of date: Date, Timestamp, and + * java.sql.Date. + * + * @author Inderjeet Singh + * @author Joel Leitch + * @author Kevin Morin : morin@codelutin.com + */ +public class DateAdapter implements JsonSerializer<Date>, JsonDeserializer<Date> { + + private final DateFormat iso8601Format; + + public DateAdapter() { + this.iso8601Format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"); + this.iso8601Format.setTimeZone(TimeZone.getTimeZone("UTC")); + } + + // These methods need to be synchronized since JDK DateFormat classes are not thread-safe + public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context) { + synchronized (iso8601Format) { + String dateFormatAsString = iso8601Format.format(src); + return new JsonPrimitive(dateFormatAsString); + } + } + + public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) + throws JsonParseException { + if (!(json instanceof JsonPrimitive)) { + throw new JsonParseException("The date should be a string value"); + } + Date date = deserializeToDate(json); + if (typeOfT == Date.class) { + return date; + } else if (typeOfT == Timestamp.class) { + return new Timestamp(date.getTime()); + } else if (typeOfT == java.sql.Date.class) { + return new java.sql.Date(date.getTime()); + } else { + throw new IllegalArgumentException(getClass() + " cannot deserialize to " + typeOfT); + } + } + + private Date deserializeToDate(JsonElement json) { + String stringDate = json.getAsString(); + if (stringDate.matches("^([\\+-]?\\d{4}(?!\\d{2}\\b))((-?)((0[1-9]|1[0-2])(\\3([12]\\d|0[1-9]|3[01]))?|W([0-4]\\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\\d|[12]\\d{2}|3([0-5]\\d|6[1-6])))([T\\s]((([01]\\d|2[0-3])((:?)[0-5]\\d)?|24\\:?00)([\\.,]\\d+(?!:))?)?(\\17[0-5]\\d([\\.,]\\d+)?)?([zZ]|([\\+-])([01]\\d|2[0-3]):?([0-5]\\d)?)?)?)?$")) { + synchronized (iso8601Format) { + try { + return iso8601Format.parse(json.getAsString()); + } catch (ParseException e) { + throw new JsonSyntaxException(json.getAsString(), e); + } + } + } else { + return null; + } + + } + +} diff --git a/observe-services-model/src/main/java/fr/ird/observe/services/dto/gson/IntegerAdapter.java b/observe-services-model/src/main/java/fr/ird/observe/services/dto/gson/IntegerAdapter.java new file mode 100644 index 0000000..f833db4 --- /dev/null +++ b/observe-services-model/src/main/java/fr/ird/observe/services/dto/gson/IntegerAdapter.java @@ -0,0 +1,36 @@ +package fr.ird.observe.services.dto.gson; + +import com.google.gson.JsonSyntaxException; +import com.google.gson.TypeAdapter; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonToken; +import com.google.gson.stream.JsonWriter; + +import java.io.IOException; + +/** + * @author Arnaud Thimel : thimel@codelutin.com + */ +public class IntegerAdapter extends TypeAdapter<Integer> { + @Override + public void write(JsonWriter out, Integer value) throws IOException { + out.value(value); + } + + @Override + public Integer read(JsonReader in) throws IOException { + if (in.peek() == JsonToken.NULL) { + in.nextNull(); + return null; + } + try { + String result = in.nextString(); + if ("".equals(result)) { + return null; + } + return Integer.valueOf(result); + } catch (NumberFormatException e) { + throw new JsonSyntaxException(e); + } + } +} diff --git a/observe-services-model/src/main/java/fr/ird/observe/services/dto/gson/ObserveDtoGsonSupplier.java b/observe-services-model/src/main/java/fr/ird/observe/services/dto/gson/ObserveDtoGsonSupplier.java new file mode 100644 index 0000000..453f6db --- /dev/null +++ b/observe-services-model/src/main/java/fr/ird/observe/services/dto/gson/ObserveDtoGsonSupplier.java @@ -0,0 +1,52 @@ +package fr.ird.observe.services.dto.gson; + +import com.google.common.base.Supplier; +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; + +import java.sql.Timestamp; +import java.util.Date; + +/** + * @author Arnaud Thimel - thimel@codelutin.com + * @author Tony Chemit - chemit@codelutin.com + */ +public class ObserveDtoGsonSupplier implements Supplier<Gson> { + + public static final Supplier<GsonBuilder> GSON_BUILDER_SUPPLIER = new Supplier<GsonBuilder>() { + + @Override + public GsonBuilder get() { + GsonBuilder result = new GsonBuilder(); + + // Type adapters : base types + result.registerTypeAdapter(Integer.class, new IntegerAdapter()); + result.registerTypeAdapter(Date.class, new DateAdapter()); + result.registerTypeAdapter(Timestamp.class, new DateAdapter()); + result.registerTypeAdapter(java.sql.Date.class, new DateAdapter()); + + return result; + } + }; + + protected static GsonBuilder gsonBuilder; + + protected Gson gson; + + protected static GsonBuilder getGsonBuilder() { + if (gsonBuilder == null) { + // Assign only when initialization is finished to be thread-safe + gsonBuilder = GSON_BUILDER_SUPPLIER.get(); + } + return gsonBuilder; + } + + @Override + public Gson get() { + if (gson == null) { + gson = getGsonBuilder().create(); + } + return gson; + } + +} -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.

This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository observe. See http://git.codelutin.com/observe.git commit 65e8b19254abc65fad1d8beccf16d6bd0527e82c Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Aug 20 18:54:49 2015 +0200 Ajout de l'implantation du client rest (merci Arnaud) --- observe-services-rest/pom.xml | 24 + .../services/ObserveServiceContextRest.java | 10 + .../services/ObserveServiceFactoryRest.java | 129 ++++- .../ird/observe/services/http/RequestBuilder.java | 531 +++++++++++++++++++++ .../ird/observe/services/http/RequestResult.java | 112 +++++ .../services/service/ReferentialServiceRest.java | 53 -- .../service/ReferentialServiceRestTest.java | 44 -- pom.xml | 24 +- 8 files changed, 820 insertions(+), 107 deletions(-) diff --git a/observe-services-rest/pom.xml b/observe-services-rest/pom.xml index 52b344e..d294413 100644 --- a/observe-services-rest/pom.xml +++ b/observe-services-rest/pom.xml @@ -61,6 +61,30 @@ <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> </dependency> + <dependency> + <groupId>com.google.code.gson</groupId> + <artifactId>gson</artifactId> + </dependency> + + <!-- paranamer --> + <dependency> + <groupId>com.thoughtworks.paranamer</groupId> + <artifactId>paranamer</artifactId> + </dependency> + + <!-- httpcomponents --> + <dependency> + <groupId>org.apache.httpcomponents</groupId> + <artifactId>httpclient</artifactId> + </dependency> + <dependency> + <groupId>org.apache.httpcomponents</groupId> + <artifactId>httpcore</artifactId> + </dependency> + <dependency> + <groupId>org.apache.httpcomponents</groupId> + <artifactId>httpmime</artifactId> + </dependency> <!-- Nuiton --> <dependency> diff --git a/observe-services-rest/src/main/java/fr/ird/observe/services/ObserveServiceContextRest.java b/observe-services-rest/src/main/java/fr/ird/observe/services/ObserveServiceContextRest.java index f742f0b..926a7dc 100644 --- a/observe-services-rest/src/main/java/fr/ird/observe/services/ObserveServiceContextRest.java +++ b/observe-services-rest/src/main/java/fr/ird/observe/services/ObserveServiceContextRest.java @@ -3,6 +3,7 @@ package fr.ird.observe.services; import fr.ird.observe.services.configuration.ObserveDataSourceConfigurationRest; import fr.ird.observe.services.dto.constants.ReferentialLocale; +import java.net.URL; import java.util.Date; /** @@ -34,4 +35,13 @@ public class ObserveServiceContextRest implements ObserveServiceContext { this.applicationContext = applicationContext; } + public URL getServicesRemoteBaseUrl() { + return dataSourceConfiguration.getServerUrl(); + } + + public String getAuthenticationToken() { + return dataSourceConfiguration.getAuthenticationToken(); + } + + } diff --git a/observe-services-rest/src/main/java/fr/ird/observe/services/ObserveServiceFactoryRest.java b/observe-services-rest/src/main/java/fr/ird/observe/services/ObserveServiceFactoryRest.java index cf14936..11fc3d3 100644 --- a/observe-services-rest/src/main/java/fr/ird/observe/services/ObserveServiceFactoryRest.java +++ b/observe-services-rest/src/main/java/fr/ird/observe/services/ObserveServiceFactoryRest.java @@ -1,9 +1,24 @@ package fr.ird.observe.services; import com.google.common.base.Preconditions; -import com.google.common.cache.LoadingCache; +import com.google.common.base.Strings; +import com.google.common.base.Supplier; +import com.google.common.reflect.Reflection; +import com.google.gson.Gson; +import com.thoughtworks.paranamer.CachingParanamer; +import com.thoughtworks.paranamer.Paranamer; import fr.ird.observe.services.configuration.ObserveDataSourceConfiguration; import fr.ird.observe.services.configuration.ObserveDataSourceConfigurationRest; +import fr.ird.observe.services.dto.gson.ObserveDtoGsonSupplier; +import fr.ird.observe.services.http.RequestBuilder; +import fr.ird.observe.services.spi.Write; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.net.URL; +import java.util.Collection; /** * Created on 16/08/15. @@ -12,7 +27,14 @@ import fr.ird.observe.services.configuration.ObserveDataSourceConfigurationRest; */ public class ObserveServiceFactoryRest extends ObserveServiceFactorySupport { - protected static final LoadingCache<Class<?>, Class<?>> serviceTypeCache = newServiceImplementationTypesCache("Rest"); + /** Logger. */ + private static final Log log = LogFactory.getLog(ObserveServiceFactoryRest.class); + + public static final String AUTHENTICATION_TOKEN = "authenticationToken"; + + protected final CachingParanamer paranamer = new CachingParanamer(); + + protected final Supplier<Gson> gsonSupplier = new ObserveDtoGsonSupplier(); @Override public <S extends ObserveService> boolean accept(ObserveDataSourceConfiguration dataSourceConfiguration, Class<S> serviceType) { @@ -29,16 +51,105 @@ public class ObserveServiceFactoryRest extends ObserveServiceFactorySupport { Preconditions.checkArgument(dataSourceConfiguration instanceof ObserveDataSourceConfigurationRest, "dataSourceConfiguration must be of type ObserveRestClientDataSourceConfiguration"); Preconditions.checkNotNull(serviceType, "serviceType can't be null."); - Class<S> serviceTypeImpl = getServiceClassType(serviceTypeCache, serviceType); - Preconditions.checkNotNull(serviceTypeImpl, "serviceTypeImpl not found for : " + serviceType.getName()); - - ObserveServiceContextRest serviceContext = new ObserveServiceContextRest(); - serviceContext.setApplicationContext(applicationContext); - serviceContext.setDataSourceConfiguration((ObserveDataSourceConfigurationRest) dataSourceConfiguration); + ObserveDataSourceConfigurationRest dataSourceConfigurationRest = (ObserveDataSourceConfigurationRest) dataSourceConfiguration; - S service = newServiceInstance(serviceTypeImpl, serviceContext); + S service = newRemoteProxyServiceInstance(serviceType, dataSourceConfigurationRest); return service; } + protected <S extends ObserveService> S newRemoteProxyServiceInstance(Class<S> serviceType, ObserveDataSourceConfigurationRest dataSourceConfigurationRest) { + + String authenticationToken = dataSourceConfigurationRest.getAuthenticationToken(); + URL serverUrl = dataSourceConfigurationRest.getServerUrl(); + + RemoteInvocationHandler handler = new RemoteInvocationHandler<>(paranamer, serviceType, serverUrl, authenticationToken, gsonSupplier); + S result = Reflection.newProxy(serviceType, handler); + return result; + } + + protected static class RemoteInvocationHandler<E extends ObserveService> implements InvocationHandler { + + protected final String authenticationToken; + + protected final Supplier<Gson> gsonSupplier; + + protected final Paranamer paranamer; + + protected final Class<E> serviceClass; + + protected final String serviceUrl; + + public RemoteInvocationHandler(Paranamer paranamer, Class<E> serviceClass, URL serverUrl, String authenticationToken, Supplier<Gson> gsonSupplier) { + this.paranamer = paranamer; + this.serviceClass = serviceClass; + this.authenticationToken = authenticationToken; + this.gsonSupplier = gsonSupplier; + serviceUrl = serverUrl + "/" + serviceClass.getSimpleName(); + } + + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + String methodName = method.getName(); + if ("toString".equals(methodName)) { + return String.format("%s<%s>.toString()", RemoteInvocationHandler.class.getName(), serviceClass.getName()); + } + if ("hashcode".equals(methodName)) { + return String.format("%s<%s>.hashcode()", RemoteInvocationHandler.class.getName(), serviceClass.getName()).hashCode(); + } + if ("equals".equals(methodName)) { + return false; + } + if ("finalize".equals(methodName)) { + return null; + } + if ("clone".equals(methodName)) { + return null; + } + + String url = String.format("%s/%s", serviceUrl, methodName); + if (log.isDebugEnabled()) { + log.debug("Invoke remote service on endpoint: " + url); + } + RequestBuilder requestBuilder = new RequestBuilder(url, gsonSupplier); + String[] strings = paranamer.lookupParameterNames(method); + int index = 0; + for (String name : strings) { + if (args.length >= (index + 1)) { + Object value = args[index]; + if (value != null && value instanceof String) { + requestBuilder.addParameter(name, (String) value); // Make sure String is not converted to JSON + } else if (value != null && value instanceof Collection) { + requestBuilder.addParameter(name, (Collection) value); // Make sure List is not converted to JSON + } else { + requestBuilder.addParameter(name, value); + } + } + index++; + } + if (!Strings.isNullOrEmpty(authenticationToken)) { + requestBuilder.addHeader(AUTHENTICATION_TOKEN, authenticationToken); + } + Object result; + try { + + boolean writeData = method.isAnnotationPresent(Write.class); + + if (writeData) { + result = requestBuilder.postAndGetJsonAndCloseConnection(method.getGenericReturnType()); + } else { + result = requestBuilder.getJsonAndCloseConnection(method.getGenericReturnType()); + } + } catch (RuntimeException re) { + if (log.isWarnEnabled()) { + log.warn("An error occurred during remote service call", re); + } + throw re; + } + return result; + + } + + } + } diff --git a/observe-services-rest/src/main/java/fr/ird/observe/services/http/RequestBuilder.java b/observe-services-rest/src/main/java/fr/ird/observe/services/http/RequestBuilder.java new file mode 100644 index 0000000..8eb1e0b --- /dev/null +++ b/observe-services-rest/src/main/java/fr/ird/observe/services/http/RequestBuilder.java @@ -0,0 +1,531 @@ +package fr.ird.observe.services.http; + +import com.google.common.base.Charsets; +import com.google.common.base.MoreObjects; +import com.google.common.base.Objects; +import com.google.common.base.Preconditions; +import com.google.common.base.Supplier; +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.google.gson.Gson; +import org.apache.commons.lang3.StringUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.apache.http.HttpResponse; +import org.apache.http.HttpStatus; +import org.apache.http.NameValuePair; +import org.apache.http.client.HttpClient; +import org.apache.http.client.entity.UrlEncodedFormEntity; +import org.apache.http.client.methods.HttpDelete; +import org.apache.http.client.methods.HttpEntityEnclosingRequestBase; +import org.apache.http.client.methods.HttpGet; +import org.apache.http.client.methods.HttpPost; +import org.apache.http.client.methods.HttpPut; +import org.apache.http.client.methods.HttpRequestBase; +import org.apache.http.client.utils.URLEncodedUtils; +import org.apache.http.entity.ContentType; +import org.apache.http.entity.StringEntity; +import org.apache.http.entity.mime.HttpMultipartMode; +import org.apache.http.entity.mime.MultipartEntity; +import org.apache.http.entity.mime.content.FileBody; +import org.apache.http.entity.mime.content.StringBody; +import org.apache.http.impl.client.DefaultHttpClient; +import org.apache.http.impl.conn.PoolingClientConnectionManager; +import org.apache.http.message.BasicNameValuePair; +import org.apache.http.params.BasicHttpParams; +import org.apache.http.params.CoreConnectionPNames; +import org.apache.http.params.HttpParams; + +import java.io.File; +import java.io.IOException; +import java.io.UnsupportedEncodingException; +import java.lang.reflect.Type; +import java.net.URLEncoder; +import java.nio.charset.Charset; +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.concurrent.TimeUnit; + +/** + * @author Arnaud Thimel - thimel@codelutin.com + */ +public class RequestBuilder { + + private static final Log log = LogFactory.getLog(RequestBuilder.class); + + protected static final Supplier<Gson> DEFAULT_GSON_SUPPLIER = new Supplier<Gson>() { + + @Override + public Gson get() { + return new Gson(); + } + }; + + protected HttpClient client; + + protected Map<String, String> header; + + protected List<NameValuePair> params; + + protected String baseUrl; + + protected String requestBody; + + protected String contentType; + + protected Map<String, File> files = Maps.newHashMap(); + + protected Supplier<Gson> gsonSupplier; + + protected Gson gson; + + public RequestBuilder(String baseUrl, HttpClient client, Supplier<Gson> gsonSupplier) { + this.baseUrl = baseUrl; + this.client = client; + this.header = Maps.newHashMap(); + this.params = Lists.newArrayList(); + this.gsonSupplier = MoreObjects.firstNonNull(gsonSupplier, DEFAULT_GSON_SUPPLIER); + } + +// public RequestBuilder(String baseUrl, HttpClient client) { +// this(baseUrl, client, null); +// } + + public RequestBuilder(String baseUrl, Supplier<Gson> gsonSupplier) { + this(baseUrl, new DefaultHttpClient(new PoolingClientConnectionManager()), gsonSupplier); + } + +// public RequestBuilder(String baseUrl) { +// this(baseUrl, (Supplier) null); +// } + + public RequestBuilder addToUrl(Collection<?> toJsonList) throws IOException { + + // we must add values with same paramName to get List<?> in service + for (Object toJson : toJsonList) { + if (toJson instanceof String) { + + // don't serialize String objects + addToUrl((String) toJson); + } else { + addToUrl(toJson); + } + } + return this; + } + + public Gson getGson() { + if (gson == null) { + gson = gsonSupplier.get(); + } + return gson; + } + + public RequestBuilder addToUrl(Object toJson) throws IOException { + String json = getGson().toJson(toJson); + return addToUrl(json); + } + + public RequestBuilder addToUrl(String url) throws UnsupportedEncodingException { + baseUrl = baseUrl + "/" + URLEncoder.encode(url, Charsets.UTF_8.name()); + return this; + } + + public RequestBuilder addHeader(String key, String value) { + checkRequestNotNull(key, value); + header.put(key, value); + return this; + } + + public void setContentType(String contentType) { + this.contentType = contentType; + } + + public RequestBuilder addParameter(String paramName, File file) { + files.put(paramName, file); + return this; + } + + public RequestBuilder addParameter(String paramName, Collection<?> toJsonList) throws IOException { + + // we must add values with same paramName to get List<?> in service + for (Object toJson : toJsonList) { + if (toJson instanceof String) { + + // don't serialize String objects + addParameter(paramName, (String) toJson); + } else { + addParameter(paramName, toJson); + } + } + return this; + } + + public RequestBuilder addParameter(String paramName, Object toJson) throws IOException { + String json = getGson().toJson(toJson); + return addParameter(paramName, json); + } + + public RequestBuilder addParameter(String paramName, String value) { + checkParameterNotNull(paramName, value); + params.add(new BasicNameValuePair(paramName, value)); + return this; + } + + public RequestBuilder addParameter(String paramName, int value) { + return addParameter(paramName, String.valueOf(value)); + } + + public RequestBuilder addParameters(String paramName, String value, String... others) { + checkParameterNotNull(paramName, value); + params.add(new BasicNameValuePair(paramName, value)); + String name = null; + for (int i = 0; i < others.length; ) { + try { + name = others[i++]; + value = others[i++]; + checkParameterNotNull(paramName, value); + params.add(new BasicNameValuePair(name, value)); + } catch (ArrayIndexOutOfBoundsException eee) { + throw new IllegalArgumentException( + "Parameters number must be pair number : " + + (others.length + 2) + " Last parameter is : " + name, eee); + } + } + return this; + } + + public RequestBuilder setRequestBody(String requestBody) { + this.requestBody = requestBody; + return this; + } + + protected void checkParameterNotNull(String paramName, String value) { + checkKeyValueNotNull(paramName, value, "Parameter key must be not null", "Parameter value must be not null for paramName : " + paramName); + } + + protected void checkRequestNotNull(String key, String value) { + checkKeyValueNotNull(key, value, "Request key must be not null", "Request value must be not null for key : " + key); + } + + protected void checkKeyValueNotNull(String key, String value, String keyErrorMessage, String valueErrorMessage) { + Preconditions.checkNotNull(key, keyErrorMessage); + Preconditions.checkNotNull(value, valueErrorMessage); + } + + protected <M extends HttpRequestBase> M addHeaders(M httpMethod) { + for (Map.Entry<String, String> entry : header.entrySet()) { + httpMethod.setHeader(entry.getKey(), entry.getValue()); + } + return httpMethod; + } + + protected <M extends HttpEntityEnclosingRequestBase> M addParameters(M method) throws UnsupportedEncodingException { + UrlEncodedFormEntity encodedFormEntity = new UrlEncodedFormEntity(params, "UTF-8"); + if (StringUtils.isNotBlank(contentType)) { + encodedFormEntity.setContentType(contentType); + } + method.setEntity(encodedFormEntity); + return method; + } + + protected <M extends HttpEntityEnclosingRequestBase> M addRequestBody(M method) throws UnsupportedEncodingException { + if (StringUtils.isNotEmpty(requestBody)) { + if (StringUtils.isNotBlank(contentType)) { + method.setEntity(new StringEntity(requestBody, ContentType.parse(contentType))); + } else { + method.setEntity(new StringEntity(requestBody)); + } + } + return method; + } + + public String buildUrlWithParams(String baseUrl) { + return baseUrl + "?" + URLEncodedUtils.format(params, "UTF-8"); + } + + protected RequestResult get0() throws IOException { + + HttpGet getMethod = new HttpGet(buildUrlWithParams(baseUrl)); + + getMethod = addHeaders(getMethod); + + HttpResponse response = null; + try { + response = client.execute(getMethod); + + RequestResult result = new RequestResult(response); + if (log.isDebugEnabled()) { + log.debug("GET '" + baseUrl + "' return status code : " + result.getStatusCode()); + } + + return result; + } finally { + + if (response != null && response.getEntity() != null) { + response.getEntity().getContent().close(); + } + + // Release the connection. + getMethod.releaseConnection(); + } + } + + public RequestResult getAndCloseConnection() throws IOException { + + try { + RequestResult result = get0(); + return result; + } finally { + releaseConnections(); + } + } + + public <T> T getJsonAndCloseConnection(Type type) throws IOException { + RequestResult getResult = getAndCloseConnection(); + if (getResult.getStatusCode() != 200 && log.isWarnEnabled()) { + log.warn(String.format("Unexpected status code for url: %s%n%s", baseUrl, getResult)); + } + T result = convertJson(getResult.getResponse(), type, getGson()); + return result; + } + + protected RequestResult post0(Integer timeout) throws IOException { + + HttpPost postMethod = new HttpPost(baseUrl); + + if (timeout != null) { + HttpParams httpParams = new BasicHttpParams(); + httpParams.setParameter(CoreConnectionPNames.SO_TIMEOUT, timeout); + httpParams.setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, timeout); + postMethod.setParams(httpParams); + } + + if (files.isEmpty()) { + postMethod = addHeaders(postMethod); + postMethod = addParameters(postMethod); + postMethod = addRequestBody(postMethod); + } else { + postMethod = addHeaders(postMethod); + postMethod = addParameters(postMethod); + postMethod = addRequestBody(postMethod); + MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE); + for (Map.Entry<String, File> paramFile : files.entrySet()) { + entity.addPart(paramFile.getKey(), new FileBody(paramFile.getValue())); + } + for (NameValuePair param : params) { + if (StringUtils.isBlank(contentType)) { + contentType = "text/plain"; + } + entity.addPart(param.getName(), new StringBody(param.getValue(), contentType, + Charset.forName("UTF-8"))); + } + postMethod.setEntity(entity); + } + + HttpResponse response = null; + try { + response = client.execute(postMethod); + + RequestResult result = new RequestResult(response); + if (log.isDebugEnabled()) { + log.debug("POST '" + baseUrl + "' return status code : " + result.getStatusCode()); + } + + return result; + } finally { + + if (response != null && response.getEntity() != null) { + response.getEntity().getContent().close(); + } + + // Release the connection. + postMethod.releaseConnection(); + } + } + + public RequestResult postAndCloseConnection() throws IOException { + RequestResult result = postAndCloseConnection(null); + return result; + } + + public RequestResult postAndCloseConnection(Integer timeout) throws IOException { + try { + RequestResult result = post0(timeout); + return result; +// } catch (ConnectTimeoutException cte) { +// throw new RemoteCallTimeoutException("Timeout (" + timeout + ") reached", cte); + } finally { + releaseConnections(); + } + } + + public <T> T postAndGetJsonAndCloseConnection(Type type) throws IOException { + RequestResult postResult = postAndCloseConnection(); + if (postResult.getStatusCode() != 200 && log.isWarnEnabled()) { + log.warn(String.format("Unexpected status code: %d%nResponse is: %s", postResult.getStatusCode(), postResult)); + } + T result = convertJson(postResult.getResponse(), type, getGson()); + return result; + } + + protected RequestResult put0() throws IOException { + + HttpPut putMethod = new HttpPut(baseUrl); + + putMethod = addHeaders(putMethod); + putMethod = addParameters(putMethod); + putMethod = addRequestBody(putMethod); + + HttpResponse response = null; + try { + response = client.execute(putMethod); + + RequestResult result = new RequestResult(response); + + if (log.isDebugEnabled()) { + log.debug("PUT '" + baseUrl + "' return status code : " + result.getStatusCode()); + if (result.getStatusCode() != HttpStatus.SC_OK) { + log.debug(result.getResponse()); + } + } + + return result; + } finally { + + if (response != null && response.getEntity() != null) { + response.getEntity().getContent().close(); + } + + // Release the connection. + putMethod.releaseConnection(); + } + } + + protected RequestResult delete0() throws IOException { + + HttpDelete deleteMethod = new HttpDelete(buildUrlWithParams(baseUrl)); + + deleteMethod = addHeaders(deleteMethod); + + HttpResponse response = null; + try { + response = client.execute(deleteMethod); + + RequestResult result = new RequestResult(response); + if (log.isDebugEnabled()) { + log.debug("DELETE '" + baseUrl + "' return status code : " + result.getStatusCode()); + } + + return result; + } finally { + + if (response != null && response.getEntity() != null) { + response.getEntity().getContent().close(); + } + + // Release the connection. + deleteMethod.releaseConnection(); + } + } + + public static <T> T convertJson(String json, Type type) throws IOException { + return convertJson(json, type, DEFAULT_GSON_SUPPLIER.get()); + } + + public static <T> T convertJson(String json, Type type, Gson gson) throws IOException { + + Preconditions.checkNotNull(json); + Preconditions.checkNotNull(gson); + + // we must try to convert json to a T instance + T result = null; + +// try { + + // let's first try to convert json to T + if (!Void.TYPE.equals(type)) { + result = gson.fromJson(json, type); + } + +// } catch (IOException e) { +// +// // conversion to T failed, we will throw a json exception +// RemoteCallUnexpectedJsonException remoteCallUnexpectedJsonException; +// +// try { +// +// // before, try to read json as an error message +// remoteCallUnexpectedJsonException = RemoteCallUnexpectedJsonException.newFromJson(json); +// +// if (log.isInfoEnabled()) { +// log.info("service returned a json showing an error occurred ", remoteCallUnexpectedJsonException); +// } +// +// } catch (IOException ee) { +// +// if (log.isErrorEnabled()) { +// log.error("json parsing failed, json=" + json, e); +// } +// +// // json is not of type T and not an error message, +// // throw the exception with e as cause cause it may be the real problem +// remoteCallUnexpectedJsonException = RemoteCallUnexpectedJsonException.newFromParsingException(e); +// +// } +// +// throw remoteCallUnexpectedJsonException; +// +// } + + if (log.isTraceEnabled()) { + log.trace("parsing json " + json + " returns " + result); + } + + + return result; + } + + @Override + public String toString() { + Objects.ToStringHelper helper = Objects.toStringHelper(this).add("url", baseUrl); + if (header != null) { + for (Map.Entry<String, String> entry : header.entrySet()) { + String key = String.format("Header [%s]", entry.getKey()); + String value = entry.getValue(); + helper.add(key, value); + } + } + if (params != null) { + for (NameValuePair pair : params) { + String key = String.format("Param [%s]", pair.getName()); + String value = pair.getValue(); + helper.add(key, value); + } + } + + if (StringUtils.isNotBlank(contentType)) { + helper.add("Content-type", contentType); + } + + String result = helper.toString(); + return result; + } + + public void releaseConnections() { + if (client != null && client.getConnectionManager() != null) { + client.getConnectionManager().shutdown(); + } + } + + @Override + protected void finalize() throws Throwable { + if (client != null && client.getConnectionManager() != null) { + client.getConnectionManager().closeExpiredConnections(); + client.getConnectionManager().closeIdleConnections(1, TimeUnit.MINUTES); + } + super.finalize(); + } + +} diff --git a/observe-services-rest/src/main/java/fr/ird/observe/services/http/RequestResult.java b/observe-services-rest/src/main/java/fr/ird/observe/services/http/RequestResult.java new file mode 100644 index 0000000..b83da5b --- /dev/null +++ b/observe-services-rest/src/main/java/fr/ird/observe/services/http/RequestResult.java @@ -0,0 +1,112 @@ +package fr.ird.observe.services.http; + +import org.apache.commons.io.IOUtils; +import org.apache.http.Header; +import org.apache.http.HttpResponse; + +import java.io.IOException; +import java.io.InputStream; +import java.io.StringWriter; + +/** + * @author Arnaud Thimel - thimel@codelutin.com + */ +public class RequestResult { + + protected int statusCode; + protected Header[] headers; + protected String responseAsString; + + public RequestResult(HttpResponse response) throws IOException { + this.statusCode = response.getStatusLine().getStatusCode(); + this.headers = response.getAllHeaders(); + response.getEntity(); + + StringWriter writer = new StringWriter(); + InputStream inputStream = response.getEntity().getContent(); + try { + IOUtils.copy(inputStream, writer, "UTF-8"); + inputStream.close(); + } finally { + IOUtils.closeQuietly(inputStream); + } + responseAsString = writer.toString(); + } + + public int getStatusCode() { + return statusCode; + } + + public Header[] getHeaders() { + return headers; + } + + public String getHeader(String key) { + return getHeader(key, headers); + } + + public boolean containsHeader(String key) { + for (Header header : headers) { + if (key.equals(header.getName())) { + return true; + } + } + return false; + } + + protected String getHeader(String key, Header[] headers) { + + for (Header header : headers) { + if (key.equals(header.getName())) { + return header.getValue(); + } + } + throw new IllegalArgumentException(key + " key is not found in header"); + } + +// public String getResponseAsString(String fieldName) throws IOException { +// if (responseAsString == null) { +// return null; +// } +// JsonNode jsonNodes = new Gson().(responseAsString).get(fieldName); +// if (jsonNodes == null) { +// return null; +// } +// return jsonNodes.asText(); +// } +// +// public Boolean getResponseAsBoolean(String fieldName) throws IOException { +// JsonNode jsonNodes = getResponseAsJsonNode(fieldName); +// if (jsonNodes == null) return null; +// return jsonNodes.asBoolean(); +// } +// +// public JsonNode getResponseAsJsonNode(String fieldName) throws IOException { +// if (responseAsString == null) { +// return null; +// } +// JsonNode jsonNodes = new ObjectMapper().readTree(responseAsString).get(fieldName); +// if (jsonNodes == null) { +// return null; +// } +// return jsonNodes; +// } + + public String getResponse() throws IOException { + return responseAsString; + } + + @Override + public String toString() { + StringBuilder buffer = new StringBuilder(). + append("HTTP ").append(statusCode).append('\n'); + if (headers != null) { + for (Header header : headers) { + buffer.append('[').append(header.getName()).append("] ").append(header.getValue()).append('\n'); + } + } + buffer.append('\n').append(responseAsString); + String result = buffer.toString(); + return result; + } +} diff --git a/observe-services-rest/src/main/java/fr/ird/observe/services/service/ReferentialServiceRest.java b/observe-services-rest/src/main/java/fr/ird/observe/services/service/ReferentialServiceRest.java deleted file mode 100644 index 153f6f6..0000000 --- a/observe-services-rest/src/main/java/fr/ird/observe/services/service/ReferentialServiceRest.java +++ /dev/null @@ -1,53 +0,0 @@ -package fr.ird.observe.services.service; - -import fr.ird.observe.services.ObserveServiceRest; -import fr.ird.observe.services.dto.FormDto; -import fr.ird.observe.services.dto.ReferenceSetDto; -import fr.ird.observe.services.dto.referential.ReferentialDto; - -import java.util.Collection; - -/** - * Created on 16/08/15. - * - * @author Tony Chemit - chemit@codelutin.com - */ -public class ReferentialServiceRest extends ObserveServiceRest implements ReferentialService { - - @Override - public <R extends ReferentialDto> ReferenceSetDto<R> getReferentialReferenceSet(Class<R> type) { - - return new ReferenceSetDto<>(type); - } - - @Override - public <R extends ReferentialDto> FormDto<R> loadToRead(Class<R> type, String id) { - return null; - } - - @Override - public <R extends ReferentialDto> FormDto<R> loadToEdit(Class<R> type, String id) { - return null; - } - - @Override - public <R extends ReferentialDto> FormDto<R> preCreate(Class<R> type) { - return null; - } - - @Override - public <R extends ReferentialDto> String save(FormDto<R> form) { - return null; - } - - @Override - public <R extends ReferentialDto> void delete(Class<R> type, String id) { - - } - - @Override - public <R extends ReferentialDto> void delete(Class<R> type, Collection<String> ids) { - - } - -} diff --git a/observe-services-rest/src/test/java/fr/ird/observe/services/service/ReferentialServiceRestTest.java b/observe-services-rest/src/test/java/fr/ird/observe/services/service/ReferentialServiceRestTest.java deleted file mode 100644 index dea122a..0000000 --- a/observe-services-rest/src/test/java/fr/ird/observe/services/service/ReferentialServiceRestTest.java +++ /dev/null @@ -1,44 +0,0 @@ -package fr.ird.observe.services.service; - -import fr.ird.observe.services.ObserveServiceFactoryRest; -import fr.ird.observe.services.ObserveServiceApplicationContext; -import fr.ird.observe.services.configuration.ObserveDataSourceConfigurationRest; -import fr.ird.observe.services.dto.ReferenceSetDto; -import fr.ird.observe.services.dto.constants.ReferentialLocale; -import fr.ird.observe.services.dto.referential.SexDto; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; - -/** - * Created on 16/08/15. - * - * @author Tony Chemit - chemit@codelutin.com - */ -public class ReferentialServiceRestTest { - - protected ReferentialService service; - - @Before - public void setUp() throws Exception { - - ObserveDataSourceConfigurationRest dataSourceConfiguration = new ObserveDataSourceConfigurationRest(); - dataSourceConfiguration.setServerUrl(null); - dataSourceConfiguration.setAuthenticationToken(null); - - ObserveServiceApplicationContext serviceApplicationContext = new ObserveServiceApplicationContext(); - serviceApplicationContext.setReferentialLocale(ReferentialLocale.FR); - - service = new ObserveServiceFactoryRest().newService(serviceApplicationContext, dataSourceConfiguration, ReferentialService.class); - - } - - @Test - public void testGetReferentialLabelSet() throws Exception { - - ReferenceSetDto referentialLabelSet = service.getReferentialReferenceSet(SexDto.class); - Assert.assertNotNull(referentialLabelSet); - - } - -} \ No newline at end of file diff --git a/pom.xml b/pom.xml index 2b8eb07..d75e223 100644 --- a/pom.xml +++ b/pom.xml @@ -131,6 +131,8 @@ <geoToolsVersion>13.2</geoToolsVersion> <webmotionVersion>2.5</webmotionVersion> + <paranamerVersion>2.7</paranamerVersion> + <httpComponentsVersion>4.3.5</httpComponentsVersion> <!-- license header configuration --> <license.licenseName>gpl_v3</license.licenseName> @@ -143,7 +145,6 @@ <!-- Site configuration --> <locales>fr</locales> - <paranamerVersion>2.7</paranamerVersion> </properties> <repositories> @@ -225,6 +226,27 @@ <artifactId>guava</artifactId> <version>18.0</version> </dependency> + <dependency> + <groupId>com.google.code.gson</groupId> + <artifactId>gson</artifactId> + <version>2.3</version> + </dependency> + + <dependency> + <groupId>org.apache.httpcomponents</groupId> + <artifactId>httpclient</artifactId> + <version>${httpComponentsVersion}</version> + </dependency> + <dependency> + <groupId>org.apache.httpcomponents</groupId> + <artifactId>httpcore</artifactId> + <version>4.3.2</version> + </dependency> + <dependency> + <groupId>org.apache.httpcomponents</groupId> + <artifactId>httpmime</artifactId> + <version>${httpComponentsVersion}</version> + </dependency> <dependency> <groupId>log4j</groupId> -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.

This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository observe. See http://git.codelutin.com/observe.git commit d39727a2a17e8c24845190c530eee585d53178f8 Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Aug 20 20:33:04 2015 +0200 - Ajout aussi de binder entityImpl -> Dto - Séparation des caches dto-> entity - Correction d'une propriété manquante dans le binding - correction et amélioration du code de recopie dto -> entité (il faudrait encore tester avec des listes de références) --- .../ird/observe/services/ObserveServiceTopia.java | 16 +- .../services/builder/DtoToEntityBuilder.java | 42 +- .../services/builder/EntityToDtoBuilder.java | 110 +++- .../builder/EntityToReferenceDtoBuilder.java | 2 +- .../services/dto/ObserveDtosInitializer.java | 712 +++++++++++---------- .../services/builder/EntityToDtoBuilderTest.java | 3 +- 6 files changed, 495 insertions(+), 390 deletions(-) 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 b0836f7..51cb177 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,7 +1,7 @@ package fr.ird.observe.services; import com.google.common.base.Preconditions; -import com.google.common.collect.ImmutableBiMap; +import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import fr.ird.observe.ObserveDAOHelper; import fr.ird.observe.services.dto.IdDto; @@ -26,7 +26,9 @@ public class ObserveServiceTopia implements ObserveService { protected ObserveServiceContextTopia serviceContext; - protected static ImmutableBiMap<Class<?>, Class<?>> DTO_TO_ENTITY_TYPES; + protected static ImmutableMap<Class<?>, Class<?>> DTO_TO_ENTITY_TYPES; + + protected static ImmutableMap<Class<?>, Class<?>> ENTITY_TO_DTO_TYPES; private static boolean init; @@ -34,6 +36,7 @@ public class ObserveServiceTopia implements ObserveService { if (!init) { ObserveModelInitializerRunner.init(new ObserveDtosInitializer()); DTO_TO_ENTITY_TYPES = ObserveDtosInitializer.getDtoToEntityTypes(); + ENTITY_TO_DTO_TYPES = ObserveDtosInitializer.getEntityToDtoTypes(); init = true; } } @@ -55,7 +58,7 @@ public class ObserveServiceTopia implements ObserveService { } public static <E extends TopiaEntity, M extends IdDto> Class<M> getDtoType(Class<E> entityType) { - Class<?> modelType = DTO_TO_ENTITY_TYPES.inverse().get(entityType); + Class<?> modelType = ENTITY_TO_DTO_TYPES.get(entityType); return (Class<M>) modelType; } @@ -63,11 +66,10 @@ public class ObserveServiceTopia implements ObserveService { return DTO_TO_ENTITY_TYPES.entrySet(); } - public TopiaEntity getEntityFromReference(ReferenceDto referenceDto) { - Preconditions.checkNotNull(referenceDto,"'referenceDto' can't be null"); + public <E extends TopiaEntity> E getEntityFromReference(Class<E> entityType, ReferenceDto referenceDto) { + Preconditions.checkNotNull(referenceDto, "'referenceDto' can't be null"); String id = referenceDto.getId(); - Class entityType = getEntityType(referenceDto.getType()); - TopiaEntity entity = loadEntity(referenceDto.getType(), entityType, id); + E entity = (E) loadEntity(referenceDto.getType(), entityType, id); return entity; } diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/builder/DtoToEntityBuilder.java b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/DtoToEntityBuilder.java index f440a1a..d8868d7 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/builder/DtoToEntityBuilder.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/DtoToEntityBuilder.java @@ -2,7 +2,7 @@ package fr.ird.observe.services.builder; import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableMap; -import com.google.common.collect.Iterables; +import com.google.common.reflect.TypeToken; import fr.ird.observe.entities.Set; import fr.ird.observe.services.ObserveServiceTopia; import fr.ird.observe.services.dto.IdDto; @@ -12,6 +12,8 @@ import org.nuiton.topia.persistence.TopiaEntity; import org.nuiton.util.beans.Binder; import java.io.Closeable; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; @@ -60,7 +62,9 @@ public class DtoToEntityBuilder<D extends IdDto, E extends TopiaEntity> implemen if (isCollectionProperty(propertyValue)) { - Class<?> collectionType = binder.getTargetPropertyType(propertyName); + Type collectionGenericType = binder.getTargetPropertyGenericType(propertyName); + + Class<?> collectionType = TypeToken.of(collectionGenericType).getRawType(); Collection<Object> entityCollection = newCollection(collectionType); @@ -68,25 +72,27 @@ public class DtoToEntityBuilder<D extends IdDto, E extends TopiaEntity> implemen if (!collection.isEmpty()) { - Object o1 = Iterables.get(collection, 0); + ParameterizedType collectionGenericTypeType = (ParameterizedType) collectionGenericType; + ParameterizedType type1 = (ParameterizedType) collectionGenericTypeType.getActualTypeArguments()[0]; + Class type = (Class) type1.getActualTypeArguments()[0]; - if (o1 instanceof ReferenceDto) { + if (ReferenceDto.class.isAssignableFrom(type)) { Collection<ReferenceDto> referenceDtos = (Collection<ReferenceDto>) collection; for (ReferenceDto referenceDto : referenceDtos) { - TopiaEntity propertyEntity = toEntity(referenceDto); + TopiaEntity propertyEntity = toEntity(type, referenceDto); entityCollection.add(propertyEntity); } - } else if (o1 instanceof IdDto) { + } else if (IdDto.class.isAssignableFrom(type)) { Collection<IdDto> idDtos = (Collection<IdDto>) collection; for (IdDto idDto : idDtos) { - TopiaEntity propertyEntity = toEntity(idDto); + TopiaEntity propertyEntity = toEntity(type, idDto); entityCollection.add(propertyEntity); } @@ -105,7 +111,9 @@ public class DtoToEntityBuilder<D extends IdDto, E extends TopiaEntity> implemen if (propertyValue instanceof ReferenceDto) { - propertyValue = toEntity((ReferenceDto) propertyValue); + Class entityType = binder.getTargetPropertyType(propertyName); + + propertyValue = toEntity(entityType, (ReferenceDto) propertyValue); entityProperties.put(propertyName, propertyValue); continue; @@ -113,7 +121,9 @@ public class DtoToEntityBuilder<D extends IdDto, E extends TopiaEntity> implemen if (propertyValue instanceof IdDto) { - propertyValue = toEntity((IdDto) propertyValue); + Class entityType = binder.getTargetPropertyType(propertyName); + + propertyValue = toEntity(entityType, (IdDto) propertyValue); entityProperties.put(propertyName, propertyValue); continue; @@ -128,17 +138,17 @@ public class DtoToEntityBuilder<D extends IdDto, E extends TopiaEntity> implemen } - protected TopiaEntity toEntity(ReferenceDto referenceDto) { - return serviceTopia.getEntityFromReference(referenceDto); + protected <EE extends TopiaEntity, DD extends IdDto> EE toEntity(Class<EE> entityType, ReferenceDto<DD> referenceDto) { + return serviceTopia.getEntityFromReference(entityType, referenceDto); } - protected TopiaEntity toEntity(IdDto idDto) { + protected <EE extends TopiaEntity, DD extends IdDto> EE toEntity(Class<EE> entityType, DD idDto) { - Class<IdDto> aClass = (Class<IdDto>) idDto.getClass(); - Class<TopiaEntity> entityType = ObserveServiceTopia.getEntityType(aClass); - TopiaEntity entity = serviceTopia.newEntity(entityType); + Class<DD> dtoType = (Class<DD>) idDto.getClass(); +// Class<TopiaEntity> entityType = ObserveServiceTopia.getEntityType(aClass); + EE entity = serviceTopia.newEntity(entityType); - DtoToEntityBuilder<IdDto, TopiaEntity> builder = create(aClass, entityType, serviceTopia); + DtoToEntityBuilder<DD, EE> builder = create(dtoType, entityType, serviceTopia); builder.build(idDto, entity); return entity; diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToDtoBuilder.java b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToDtoBuilder.java index 3930cea..0bf4d24 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToDtoBuilder.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToDtoBuilder.java @@ -3,7 +3,6 @@ package fr.ird.observe.services.builder; import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; -import com.google.common.collect.Iterables; import com.google.common.reflect.TypeToken; import fr.ird.observe.entities.Set; import fr.ird.observe.services.dto.IdDto; @@ -14,9 +13,10 @@ import fr.ird.observe.services.dto.referential.ReferentialDto; import fr.ird.observe.services.dto.referential.ReferentialReferenceDto; import org.nuiton.topia.persistence.TopiaEntity; import org.nuiton.util.beans.Binder; -import sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl; import java.io.Closeable; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; @@ -77,31 +77,34 @@ public class EntityToDtoBuilder<E extends TopiaEntity, D extends IdDto> implemen Collection collection = (Collection) propertyValue; - //FIXME Trouver par quoi remplacer (ne pas utiliser une api de sun) + à améliorer - TypeToken<?> collectionGenericType = TypeToken.of(binder.getTargetPropertyGenericType(propertyName)); + Type collectionGenericType = binder.getTargetPropertyGenericType(propertyName); - Class<?> collectionType = collectionGenericType.getRawType(); - - ParameterizedTypeImpl collectionGenericTypeType = (ParameterizedTypeImpl) collectionGenericType.getType(); - - ParameterizedTypeImpl type1 = (ParameterizedTypeImpl) collectionGenericTypeType.getActualTypeArguments()[0]; - Class type = (Class) type1.getActualTypeArguments()[0]; + Class<?> collectionType = TypeToken.of(collectionGenericType).getRawType(); Collection<Object> dtoCollection = newCollection(collectionType); if (!collection.isEmpty()) { - Object o1 = Iterables.get(collection, 0); + ParameterizedType collectionGenericTypeType = (ParameterizedType) collectionGenericType; + Type type1 = collectionGenericTypeType.getActualTypeArguments()[0]; + Class type; + boolean useReference = false; + if (type1 instanceof Class) { + type = (Class) type1; + } else { + type = (Class) ((ParameterizedType) type1).getActualTypeArguments()[0]; + useReference = true; + } - if (o1 instanceof TopiaEntity) { + if (IdDto.class.isAssignableFrom(type)) { Class dtoType = type; - Collection<? extends TopiaEntity> topiaEntities = (Collection<? extends TopiaEntity>) collection; + for (Object entityValue : collection) { - for (TopiaEntity entityValue : topiaEntities) { + IdDto dto = addEntity(dtoType, (TopiaEntity) entityValue, referentialLocale, useReference, referenceTypesBuilder); + dtoCollection.add(dto); - dtoCollection.add(entityToRef(referentialLocale, dtoType, entityValue, referenceTypesBuilder)); } } else { @@ -121,19 +124,24 @@ public class EntityToDtoBuilder<E extends TopiaEntity, D extends IdDto> implemen TopiaEntity entityValue = (TopiaEntity) propertyValue; + Type typeToken = binder.getTargetPropertyGenericType(propertyName); + Class<?> rawType = TypeToken.of(typeToken).getRawType(); + Class dtoType; - TypeToken<?> typeToken = TypeToken.of(binder.getTargetPropertyGenericType(propertyName)); - Class<?> rawType = typeToken.getRawType(); + boolean useReference = false; + if (rawType.isAssignableFrom(ReferenceDto.class) || rawType.isAssignableFrom(ReferentialReferenceDto.class)) { + Preconditions.checkArgument(typeToken instanceof ParameterizedType, "Un type générique devrait être mis sur une référence de dto: " + result.getClass().getName() + "." + propertyName ); - //FIXME Trouver par quoi remplacer (ne pas utiliser une api de sun) - ParameterizedTypeImpl type = (ParameterizedTypeImpl) typeToken.getType(); + ParameterizedType type = (ParameterizedType) typeToken; dtoType = (Class) type.getActualTypeArguments()[0]; + useReference = true; } else { dtoType = rawType; } - propertyValue = entityToRef(referentialLocale, dtoType, entityValue, referenceTypesBuilder); + propertyValue = addEntity(dtoType, entityValue, referentialLocale, useReference, referenceTypesBuilder); + addProperty(propertyName, propertyValue, dtoPropertiesBuilder); continue; @@ -153,6 +161,38 @@ public class EntityToDtoBuilder<E extends TopiaEntity, D extends IdDto> implemen } + protected <EE extends TopiaEntity> IdDto addEntity(Class dtoType, + EE entityValue, + ReferentialLocale referentialLocale, + boolean useReference, + ImmutableSet.Builder<Class<? extends IdDto>> referenceTypesBuilder) { + + IdDto dto; + boolean isReferential = ReferentialDto.class.isAssignableFrom(dtoType); + + Class entityType = entityValue.getClass(); + if (useReference) { + + if (isReferential) { + + dto = entityToReferentialRef(referentialLocale, dtoType, entityType, entityValue, referenceTypesBuilder); + + } else { + + dto = entityToRef(dtoType, entityValue, referenceTypesBuilder); + + } + + } else { + + dto = entityToDto(referentialLocale, dtoType, entityType, entityValue, referenceTypesBuilder); + + } + + return dto; + + } + public ImmutableSet<Class<? extends IdDto>> getReferenceTypes() { return referencesTypes; } @@ -190,26 +230,36 @@ public class EntityToDtoBuilder<E extends TopiaEntity, D extends IdDto> implemen } - protected <R extends IdDto> ReferenceDto<R> entityToRef(ReferentialLocale referentialLocale, Class<R> dtoType, TopiaEntity entityValue, ImmutableSet.Builder<Class<? extends IdDto>> referenceTypesBuilder) { + protected <EE extends TopiaEntity, R extends IdDto> ReferenceDto<R> entityToRef(Class<R> dtoType, EE entityValue, ImmutableSet.Builder<Class<? extends IdDto>> referenceTypesBuilder) { referenceTypesBuilder.add(dtoType); + ReferenceDto<R> dto = EntityToReferenceDtoBuilder.build(dtoType, entityValue); + dto.setId(entityValue.getTopiaId()); + return dto; + + } - ReferenceDto<R> label; - if (ReferentialDto.class.isAssignableFrom(dtoType)) { + protected <EE extends TopiaEntity, R extends ReferentialDto> ReferentialReferenceDto<R> entityToReferentialRef(ReferentialLocale referentialLocale, Class<R> dtoType, Class<EE> entityType, EE entityValue, ImmutableSet.Builder<Class<? extends IdDto>> referenceTypesBuilder) { - label = EntityToReferentialReferenceDtoBuilder.build((Class) dtoType, referentialLocale, entityValue); + referenceTypesBuilder.add(dtoType); + ReferentialReferenceDto<R> dto = EntityToReferentialReferenceDtoBuilder.build(dtoType, referentialLocale, entityValue); + dto.setId(entityValue.getTopiaId()); + return dto; - } else { - label = EntityToReferenceDtoBuilder.build(dtoType, entityValue); - } + } + + protected <EE extends TopiaEntity, R extends IdDto> R entityToDto(ReferentialLocale referentialLocale, Class<R> dtoType, Class<EE> entityType, EE entityValue, ImmutableSet.Builder<Class<? extends IdDto>> referenceTypesBuilder) { - label.setId(entityValue.getTopiaId()); - return label; + EntityToDtoBuilder<EE, R> dtoBuilder = EntityToDtoBuilder.create(entityType, dtoType); + R dto = dtoBuilder.build(referentialLocale, entityValue); + referenceTypesBuilder.addAll(dtoBuilder.getReferenceTypes()); + dto.setId(entityValue.getTopiaId()); + return dto; } @Override public void close() { - } + } diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferenceDtoBuilder.java b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferenceDtoBuilder.java index a9e9cc2..f3b4899 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferenceDtoBuilder.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferenceDtoBuilder.java @@ -24,7 +24,7 @@ public class EntityToReferenceDtoBuilder<E extends TopiaEntity, D extends IdDto> public static <E extends TopiaEntity, D extends IdDto> ReferenceDto<D> build(Class<D> dtoType, E entity) { Preconditions.checkNotNull(dtoType, "'dtoType' can't be null"); - Preconditions.checkArgument(ReferentialDto.class.isAssignableFrom(dtoType), "'dtoType' can't be of type ReferentialDto, use the method buildReferential insteadnull"); + Preconditions.checkArgument(!ReferentialDto.class.isAssignableFrom(dtoType), "'dtoType' can't be of type ReferentialDto, use the method buildReferential insteadnull"); Preconditions.checkNotNull(entity, "'entity' can't be null"); Class<E> entityType = (Class<E>) ObserveEntityEnum.valueOf(entity).getContract(); 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 index 734dac9..b08b10c 100644 --- 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 @@ -1,7 +1,8 @@ package fr.ird.observe.services.dto; import com.google.common.base.Function; -import com.google.common.collect.ImmutableBiMap; +import com.google.common.collect.ImmutableMap; +import fr.ird.observe.ObserveEntityEnum; import fr.ird.observe.entities.longline.ActivityLongline; import fr.ird.observe.entities.longline.BaitsComposition; import fr.ird.observe.entities.longline.Basket; @@ -207,6 +208,7 @@ import fr.ird.observe.services.dto.seine.TargetSampleDto; import fr.ird.observe.services.dto.seine.TransmittingBuoyDto; import fr.ird.observe.services.dto.seine.TripSeineDto; import org.nuiton.topia.persistence.TopiaEntity; +import org.nuiton.util.beans.Binder; import org.nuiton.util.beans.BinderFactory; import org.nuiton.util.beans.BinderModelBuilder; @@ -260,22 +262,32 @@ public class ObserveDtosInitializer implements ObserveModelInitializer { // } - protected static ImmutableBiMap.Builder<Class<?>, Class<?>> DTO_TO_ENTITY_TYPE_BUILDER; + protected static ImmutableMap.Builder<Class<?>, Class<?>> DTO_TO_ENTITY_TYPE_BUILDER; - protected static ImmutableBiMap<Class<?>, Class<?>> DTO_TO_ENTITY_TYPES; + protected static ImmutableMap.Builder<Class<?>, Class<?>> ENTITY_TO_DTO_TYPE_BUILDER; - public static ImmutableBiMap<Class<?>, Class<?>> getDtoToEntityTypes() { + protected static ImmutableMap<Class<?>, Class<?>> DTO_TO_ENTITY_TYPES; + + protected static ImmutableMap<Class<?>, Class<?>> ENTITY_TO_DTO_TYPES; + + public static ImmutableMap<Class<?>, Class<?>> getDtoToEntityTypes() { return DTO_TO_ENTITY_TYPES; } + public static ImmutableMap<Class<?>, Class<?>> getEntityToDtoTypes() { + return ENTITY_TO_DTO_TYPES; + } + @Override public void start() { - DTO_TO_ENTITY_TYPE_BUILDER = new ImmutableBiMap.Builder<>(); + DTO_TO_ENTITY_TYPE_BUILDER = new ImmutableMap.Builder<>(); + ENTITY_TO_DTO_TYPE_BUILDER = new ImmutableMap.Builder<>(); } @Override public void end() { DTO_TO_ENTITY_TYPES = DTO_TO_ENTITY_TYPE_BUILDER.build(); + ENTITY_TO_DTO_TYPES = ENTITY_TO_DTO_TYPE_BUILDER.build(); } // -------------------------------------------------------------------------------------------------------------- // @@ -319,334 +331,334 @@ public class ObserveDtosInitializer implements ObserveModelInitializer { @Override public void initActivityLonglineDto() { registerMainDto(ActivityLonglineDto.class, ActivityLongline.class, - ActivityLonglineDto.PROPERTY_COMMENT, - ActivityLonglineDto.PROPERTY_OPEN, - ActivityLonglineDto.PROPERTY_TIME_STAMP, - ActivityLonglineDto.PROPERTY_LATITUDE, - ActivityLonglineDto.PROPERTY_LONGITUDE, - ActivityLonglineDto.PROPERTY_SEA_SURFACE_TEMPERATURE, - ActivityLonglineDto.PROPERTY_VESSEL_ACTIVITY_LONGLINE, - ActivityLonglineDto.PROPERTY_FPA_ZONE + ActivityLonglineDto.PROPERTY_COMMENT, + ActivityLonglineDto.PROPERTY_OPEN, + ActivityLonglineDto.PROPERTY_TIME_STAMP, + ActivityLonglineDto.PROPERTY_LATITUDE, + ActivityLonglineDto.PROPERTY_LONGITUDE, + ActivityLonglineDto.PROPERTY_SEA_SURFACE_TEMPERATURE, + ActivityLonglineDto.PROPERTY_VESSEL_ACTIVITY_LONGLINE, + ActivityLonglineDto.PROPERTY_FPA_ZONE ); } @Override public void initActivityLonglineEncouterDto() { registerDto(ActivityLonglineEncouterDto.class, ActivityLongline.class, - ActivityLonglineEncouterDto.PROPERTY_COMMENT, - ActivityLonglineEncouterDto.PROPERTY_ENCOUNTER + ActivityLonglineEncouterDto.PROPERTY_COMMENT, + ActivityLonglineEncouterDto.PROPERTY_ENCOUNTER ); } @Override public void initActivityLonglineSensorUsedDto() { registerDto(ActivityLonglineSensorUsedDto.class, ActivityLongline.class, - ActivityLonglineSensorUsedDto.PROPERTY_COMMENT, - ActivityLonglineSensorUsedDto.PROPERTY_SENSOR_USED + ActivityLonglineSensorUsedDto.PROPERTY_COMMENT, + ActivityLonglineSensorUsedDto.PROPERTY_SENSOR_USED ); } @Override public void initBaitsCompositionDto() { registerMainDto(BaitsCompositionDto.class, BaitsComposition.class, - BaitsCompositionDto.PROPERTY_PROPORTION, - BaitsCompositionDto.PROPERTY_INDIVIDUAL_SIZE, - BaitsCompositionDto.PROPERTY_INDIVIDUAL_WEIGHT, - BaitsCompositionDto.PROPERTY_BAIT_SETTING_STATUS, - BaitsCompositionDto.PROPERTY_BAIT_TYPE + BaitsCompositionDto.PROPERTY_PROPORTION, + BaitsCompositionDto.PROPERTY_INDIVIDUAL_SIZE, + BaitsCompositionDto.PROPERTY_INDIVIDUAL_WEIGHT, + BaitsCompositionDto.PROPERTY_BAIT_SETTING_STATUS, + BaitsCompositionDto.PROPERTY_BAIT_TYPE ); } @Override public void initBasketDto() { registerMainDto(BasketDto.class, Basket.class, - BasketDto.PROPERTY_SETTING_IDENTIFIER, - BasketDto.PROPERTY_HAULING_IDENTIFIER, - BasketDto.PROPERTY_FLOATLINE1_LENGTH, - BasketDto.PROPERTY_FLOATLINE2_LENGTH, - BasketDto.PROPERTY_BRANCHLINE + BasketDto.PROPERTY_SETTING_IDENTIFIER, + BasketDto.PROPERTY_HAULING_IDENTIFIER, + BasketDto.PROPERTY_FLOATLINE1_LENGTH, + BasketDto.PROPERTY_FLOATLINE2_LENGTH, + BasketDto.PROPERTY_BRANCHLINE ); } @Override public void initBranchlineDto() { registerMainDto(BranchlineDto.class, Branchline.class, - BranchlineDto.PROPERTY_COMMENT, - BranchlineDto.PROPERTY_SETTING_IDENTIFIER, - BranchlineDto.PROPERTY_HAULING_IDENTIFIER, - BranchlineDto.PROPERTY_DEPTH_RECORDER, - BranchlineDto.PROPERTY_TIMER, - BranchlineDto.PROPERTY_TIME_SINCE_CONTACT, - BranchlineDto.PROPERTY_HOOK_OFFSET, - BranchlineDto.PROPERTY_BRANCHLINE_LENGTH, - BranchlineDto.PROPERTY_WEIGHTED_SWIVEL, - BranchlineDto.PROPERTY_TIMER_TIME_ON_BOARD, - BranchlineDto.PROPERTY_WEIGHTED_SNAP, - BranchlineDto.PROPERTY_SWIVEL_WEIGHT, - BranchlineDto.PROPERTY_SNAP_WEIGHT, - BranchlineDto.PROPERTY_TRACELINE_LENGTH, - BranchlineDto.PROPERTY_HOOK_LOST, - BranchlineDto.PROPERTY_TRACE_CUT_OFF, - BranchlineDto.PROPERTY_TOP_TYPE, - BranchlineDto.PROPERTY_TRACELINE_TYPE, - BranchlineDto.PROPERTY_HOOK_TYPE, - BranchlineDto.PROPERTY_HOOK_SIZE, - BranchlineDto.PROPERTY_BAIT_TYPE, - BranchlineDto.PROPERTY_BAIT_SETTING_STATUS, - BranchlineDto.PROPERTY_BAIT_HAULING_STATUS + BranchlineDto.PROPERTY_COMMENT, + BranchlineDto.PROPERTY_SETTING_IDENTIFIER, + BranchlineDto.PROPERTY_HAULING_IDENTIFIER, + BranchlineDto.PROPERTY_DEPTH_RECORDER, + BranchlineDto.PROPERTY_TIMER, + BranchlineDto.PROPERTY_TIME_SINCE_CONTACT, + BranchlineDto.PROPERTY_HOOK_OFFSET, + BranchlineDto.PROPERTY_BRANCHLINE_LENGTH, + BranchlineDto.PROPERTY_WEIGHTED_SWIVEL, + BranchlineDto.PROPERTY_TIMER_TIME_ON_BOARD, + BranchlineDto.PROPERTY_WEIGHTED_SNAP, + BranchlineDto.PROPERTY_SWIVEL_WEIGHT, + BranchlineDto.PROPERTY_SNAP_WEIGHT, + BranchlineDto.PROPERTY_TRACELINE_LENGTH, + BranchlineDto.PROPERTY_HOOK_LOST, + BranchlineDto.PROPERTY_TRACE_CUT_OFF, + BranchlineDto.PROPERTY_TOP_TYPE, + BranchlineDto.PROPERTY_TRACELINE_TYPE, + BranchlineDto.PROPERTY_HOOK_TYPE, + BranchlineDto.PROPERTY_HOOK_SIZE, + BranchlineDto.PROPERTY_BAIT_TYPE, + BranchlineDto.PROPERTY_BAIT_SETTING_STATUS, + BranchlineDto.PROPERTY_BAIT_HAULING_STATUS ); } @Override public void initBranchlinesCompositionDto() { registerMainDto(BranchlinesCompositionDto.class, BranchlinesComposition.class, - BranchlinesCompositionDto.PROPERTY_LENGTH, - BranchlinesCompositionDto.PROPERTY_PROPORTION, - BranchlinesCompositionDto.PROPERTY_TOP_TYPE, - BranchlinesCompositionDto.PROPERTY_TRACELINE_TYPE + BranchlinesCompositionDto.PROPERTY_LENGTH, + BranchlinesCompositionDto.PROPERTY_PROPORTION, + BranchlinesCompositionDto.PROPERTY_TOP_TYPE, + BranchlinesCompositionDto.PROPERTY_TRACELINE_TYPE ); } @Override public void initCatchLonglineDto() { registerMainDto(CatchLonglineDto.class, CatchLongline.class, - CatchLonglineDto.PROPERTY_COMMENT, - CatchLonglineDto.PROPERTY_HOME_ID, - CatchLonglineDto.PROPERTY_COUNT, - CatchLonglineDto.PROPERTY_TOTAL_WEIGHT, - CatchLonglineDto.PROPERTY_HOOK_WHEN_DISCARDED, - CatchLonglineDto.PROPERTY_DEPREDATED, - CatchLonglineDto.PROPERTY_BEAT_DIAMETER, - CatchLonglineDto.PROPERTY_GONADE_WEIGHT, - CatchLonglineDto.PROPERTY_PHOTO_REFERENCES, - CatchLonglineDto.PROPERTY_NUMBER, - CatchLonglineDto.PROPERTY_ACQUISITION_MODE, - CatchLonglineDto.PROPERTY_SPECIES_CATCH, - CatchLonglineDto.PROPERTY_CATCH_HEALTHNESS, - CatchLonglineDto.PROPERTY_HOOK_POSITION, - CatchLonglineDto.PROPERTY_CATCH_FATE_LONGLINE, - CatchLonglineDto.PROPERTY_DISCARD_HEALTHNESS, - CatchLonglineDto.PROPERTY_PREDATOR, - CatchLonglineDto.PROPERTY_STOMAC_FULLNESS, - CatchLonglineDto.PROPERTY_SEX, - CatchLonglineDto.PROPERTY_MATURITY_STATUS, - CatchLonglineDto.PROPERTY_SIZE_MEASURE, - CatchLonglineDto.PROPERTY_WEIGHT_MEASURE, - CatchLonglineDto.PROPERTY_SECTION, - CatchLonglineDto.PROPERTY_BASKET, - CatchLonglineDto.PROPERTY_BRANCHLINE + CatchLonglineDto.PROPERTY_COMMENT, + CatchLonglineDto.PROPERTY_HOME_ID, + CatchLonglineDto.PROPERTY_COUNT, + CatchLonglineDto.PROPERTY_TOTAL_WEIGHT, + CatchLonglineDto.PROPERTY_HOOK_WHEN_DISCARDED, + CatchLonglineDto.PROPERTY_DEPREDATED, + CatchLonglineDto.PROPERTY_BEAT_DIAMETER, + CatchLonglineDto.PROPERTY_GONADE_WEIGHT, + CatchLonglineDto.PROPERTY_PHOTO_REFERENCES, + CatchLonglineDto.PROPERTY_NUMBER, + CatchLonglineDto.PROPERTY_ACQUISITION_MODE, + CatchLonglineDto.PROPERTY_SPECIES_CATCH, + CatchLonglineDto.PROPERTY_CATCH_HEALTHNESS, + CatchLonglineDto.PROPERTY_HOOK_POSITION, + CatchLonglineDto.PROPERTY_CATCH_FATE_LONGLINE, + CatchLonglineDto.PROPERTY_DISCARD_HEALTHNESS, + CatchLonglineDto.PROPERTY_PREDATOR, + CatchLonglineDto.PROPERTY_STOMAC_FULLNESS, + CatchLonglineDto.PROPERTY_SEX, + CatchLonglineDto.PROPERTY_MATURITY_STATUS, + CatchLonglineDto.PROPERTY_SIZE_MEASURE, + CatchLonglineDto.PROPERTY_WEIGHT_MEASURE, + CatchLonglineDto.PROPERTY_SECTION, + CatchLonglineDto.PROPERTY_BASKET, + CatchLonglineDto.PROPERTY_BRANCHLINE ); } @Override public void initEncounterDto() { registerMainDto(EncounterDto.class, Encounter.class, - EncounterDto.PROPERTY_DISTANCE, - EncounterDto.PROPERTY_COUNT, - EncounterDto.PROPERTY_ENCOUNTER_TYPE, - EncounterDto.PROPERTY_SPECIES + EncounterDto.PROPERTY_DISTANCE, + EncounterDto.PROPERTY_COUNT, + EncounterDto.PROPERTY_ENCOUNTER_TYPE, + EncounterDto.PROPERTY_SPECIES ); } @Override public void initFloatlinesCompositionDto() { registerMainDto(FloatlinesCompositionDto.class, FloatlinesComposition.class, - FloatlinesCompositionDto.PROPERTY_LENGTH, - FloatlinesCompositionDto.PROPERTY_PROPORTION, - FloatlinesCompositionDto.PROPERTY_LINE_TYPE + FloatlinesCompositionDto.PROPERTY_LENGTH, + FloatlinesCompositionDto.PROPERTY_PROPORTION, + FloatlinesCompositionDto.PROPERTY_LINE_TYPE ); } @Override public void initGearUseFeaturesLonglineDto() { registerMainDto(GearUseFeaturesLonglineDto.class, GearUseFeaturesLongline.class, - GearUseFeaturesLonglineDto.PROPERTY_NUMBER, - GearUseFeaturesLonglineDto.PROPERTY_USED_IN_TRIP, - GearUseFeaturesLonglineDto.PROPERTY_GEAR, - GearUseFeaturesLonglineDto.PROPERTY_GEAR_USE_FEATURES_MEASUREMENT + GearUseFeaturesLonglineDto.PROPERTY_NUMBER, + GearUseFeaturesLonglineDto.PROPERTY_USED_IN_TRIP, + GearUseFeaturesLonglineDto.PROPERTY_GEAR, + GearUseFeaturesLonglineDto.PROPERTY_GEAR_USE_FEATURES_MEASUREMENT ); } @Override public void initGearUseFeaturesMeasurementLonglineDto() { registerMainDto(GearUseFeaturesMeasurementLonglineDto.class, GearUseFeaturesMeasurementLongline.class, - GearUseFeaturesMeasurementLonglineDto.PROPERTY_MEASUREMENT_VALUE, - GearUseFeaturesMeasurementLonglineDto.PROPERTY_GEAR_CARACTERISTIC + GearUseFeaturesMeasurementLonglineDto.PROPERTY_MEASUREMENT_VALUE, + GearUseFeaturesMeasurementLonglineDto.PROPERTY_GEAR_CARACTERISTIC ); } @Override public void initHooksCompositionDto() { registerMainDto(HooksCompositionDto.class, HooksComposition.class, - HooksCompositionDto.PROPERTY_PROPORTION, - HooksCompositionDto.PROPERTY_HOOK_OFFSET, - HooksCompositionDto.PROPERTY_HOOK_TYPE, - HooksCompositionDto.PROPERTY_HOOK_SIZE + HooksCompositionDto.PROPERTY_PROPORTION, + HooksCompositionDto.PROPERTY_HOOK_OFFSET, + HooksCompositionDto.PROPERTY_HOOK_TYPE, + HooksCompositionDto.PROPERTY_HOOK_SIZE ); } @Override public void initSectionDto() { registerMainDto(SectionDto.class, Section.class, - SectionDto.PROPERTY_SETTING_IDENTIFIER, - SectionDto.PROPERTY_HAULING_IDENTIFIER, - SectionDto.PROPERTY_BASKET + SectionDto.PROPERTY_SETTING_IDENTIFIER, + SectionDto.PROPERTY_HAULING_IDENTIFIER, + SectionDto.PROPERTY_BASKET ); } @Override public void initSensorUsedDto() { registerMainDto(SensorUsedDto.class, SensorUsed.class, - SensorUsedDto.PROPERTY_DATA, - SensorUsedDto.PROPERTY_DATA_FILENAME, - SensorUsedDto.PROPERTY_DATA_LOCATION, - SensorUsedDto.PROPERTY_SENSOR_SERIAL_NO, - SensorUsedDto.PROPERTY_SENSOR_TYPE, - SensorUsedDto.PROPERTY_SENSOR_BRAND, - SensorUsedDto.PROPERTY_SENSOR_DATA_FORMAT + SensorUsedDto.PROPERTY_DATA, + SensorUsedDto.PROPERTY_DATA_FILENAME, + SensorUsedDto.PROPERTY_DATA_LOCATION, + SensorUsedDto.PROPERTY_SENSOR_SERIAL_NO, + SensorUsedDto.PROPERTY_SENSOR_TYPE, + SensorUsedDto.PROPERTY_SENSOR_BRAND, + SensorUsedDto.PROPERTY_SENSOR_DATA_FORMAT ); } @Override public void initSetLonglineDto() { registerMainDto(SetLonglineDto.class, SetLongline.class, - SetLonglineDto.PROPERTY_COMMENT, - SetLonglineDto.PROPERTY_HOME_ID, - SetLonglineDto.PROPERTY_NUMBER, - SetLonglineDto.PROPERTY_BASKETS_PER_SECTION_COUNT, - SetLonglineDto.PROPERTY_BRANCHLINES_PER_BASKET_COUNT, - SetLonglineDto.PROPERTY_TOTAL_SECTIONS_COUNT, - SetLonglineDto.PROPERTY_TOTAL_BASKETS_COUNT, - SetLonglineDto.PROPERTY_TOTAL_HOOKS_COUNT, - SetLonglineDto.PROPERTY_WEIGHTED_SNAP, - SetLonglineDto.PROPERTY_SNAP_WEIGHT, - SetLonglineDto.PROPERTY_WEIGHTED_SWIVEL, - SetLonglineDto.PROPERTY_SWIVEL_WEIGHT, - SetLonglineDto.PROPERTY_LIGHTSTICKS_PER_BASKET_COUNT, - SetLonglineDto.PROPERTY_TIME_BETWEEN_HOOKS, - SetLonglineDto.PROPERTY_SHOOTER_USED, - SetLonglineDto.PROPERTY_SHOOTER_SPEED, - SetLonglineDto.PROPERTY_MAX_DEPTH_TARGETED, - SetLonglineDto.PROPERTY_SETTING_START_TIME_STAMP, - SetLonglineDto.PROPERTY_SETTING_START_LATITUDE, - SetLonglineDto.PROPERTY_SETTING_START_LONGITUDE, - SetLonglineDto.PROPERTY_SETTING_START_TIME_STAMP, - SetLonglineDto.PROPERTY_SETTING_END_LATITUDE, - SetLonglineDto.PROPERTY_SETTING_END_LONGITUDE, - SetLonglineDto.PROPERTY_SETTING_VESSEL_SPEED, - SetLonglineDto.PROPERTY_HAULING_DIRECTION_SAME_AS_SETTING, - SetLonglineDto.PROPERTY_HAULING_START_TIME_STAMP, - SetLonglineDto.PROPERTY_HAULING_START_LATITUDE, - SetLonglineDto.PROPERTY_HAULING_START_LONGITUDE, - SetLonglineDto.PROPERTY_HAULING_END_TIME_STAMP, - SetLonglineDto.PROPERTY_HAULING_END_LATITUDE, - SetLonglineDto.PROPERTY_HAULING_END_LONGITUDE, - SetLonglineDto.PROPERTY_HAULING_BREAKS, - SetLonglineDto.PROPERTY_MONITORED, - SetLonglineDto.PROPERTY_LINE_TYPE, - SetLonglineDto.PROPERTY_LIGHTSTICKS_COLOR, - SetLonglineDto.PROPERTY_LIGHTSTICKS_TYPE, - SetLonglineDto.PROPERTY_SETTING_SHAPE + SetLonglineDto.PROPERTY_COMMENT, + SetLonglineDto.PROPERTY_HOME_ID, + SetLonglineDto.PROPERTY_NUMBER, + SetLonglineDto.PROPERTY_BASKETS_PER_SECTION_COUNT, + SetLonglineDto.PROPERTY_BRANCHLINES_PER_BASKET_COUNT, + SetLonglineDto.PROPERTY_TOTAL_SECTIONS_COUNT, + SetLonglineDto.PROPERTY_TOTAL_BASKETS_COUNT, + SetLonglineDto.PROPERTY_TOTAL_HOOKS_COUNT, + SetLonglineDto.PROPERTY_WEIGHTED_SNAP, + SetLonglineDto.PROPERTY_SNAP_WEIGHT, + SetLonglineDto.PROPERTY_WEIGHTED_SWIVEL, + SetLonglineDto.PROPERTY_SWIVEL_WEIGHT, + SetLonglineDto.PROPERTY_LIGHTSTICKS_PER_BASKET_COUNT, + SetLonglineDto.PROPERTY_TIME_BETWEEN_HOOKS, + SetLonglineDto.PROPERTY_SHOOTER_USED, + SetLonglineDto.PROPERTY_SHOOTER_SPEED, + SetLonglineDto.PROPERTY_MAX_DEPTH_TARGETED, + SetLonglineDto.PROPERTY_SETTING_START_TIME_STAMP, + SetLonglineDto.PROPERTY_SETTING_START_LATITUDE, + SetLonglineDto.PROPERTY_SETTING_START_LONGITUDE, + SetLonglineDto.PROPERTY_SETTING_START_TIME_STAMP, + SetLonglineDto.PROPERTY_SETTING_END_LATITUDE, + SetLonglineDto.PROPERTY_SETTING_END_LONGITUDE, + SetLonglineDto.PROPERTY_SETTING_VESSEL_SPEED, + SetLonglineDto.PROPERTY_HAULING_DIRECTION_SAME_AS_SETTING, + SetLonglineDto.PROPERTY_HAULING_START_TIME_STAMP, + SetLonglineDto.PROPERTY_HAULING_START_LATITUDE, + SetLonglineDto.PROPERTY_HAULING_START_LONGITUDE, + SetLonglineDto.PROPERTY_HAULING_END_TIME_STAMP, + SetLonglineDto.PROPERTY_HAULING_END_LATITUDE, + SetLonglineDto.PROPERTY_HAULING_END_LONGITUDE, + SetLonglineDto.PROPERTY_HAULING_BREAKS, + SetLonglineDto.PROPERTY_MONITORED, + SetLonglineDto.PROPERTY_LINE_TYPE, + SetLonglineDto.PROPERTY_LIGHTSTICKS_COLOR, + SetLonglineDto.PROPERTY_LIGHTSTICKS_TYPE, + SetLonglineDto.PROPERTY_SETTING_SHAPE ); } @Override public void initSetLonglineCatchDto() { registerDto(SetLonglineCatchDto.class, SetLongline.class, - SetLonglineCatchDto.PROPERTY_CATCH_LONGLINE + SetLonglineCatchDto.PROPERTY_CATCH_LONGLINE ); } @Override public void initSetLonglineDetailCompositionDto() { registerDto(SetLonglineDetailCompositionDto.class, SetLongline.class, - SetLonglineDetailCompositionDto.PROPERTY_SECTION + SetLonglineDetailCompositionDto.PROPERTY_SECTION ); } @Override public void initSetLonglineGlobalCompositionDto() { registerDto(SetLonglineGlobalCompositionDto.class, SetLongline.class, - SetLonglineGlobalCompositionDto.PROPERTY_FLOATLINES_COMPOSITION, - SetLonglineGlobalCompositionDto.PROPERTY_BRANCHLINES_COMPOSITION, - SetLonglineGlobalCompositionDto.PROPERTY_HOOKS_COMPOSITION, - SetLonglineGlobalCompositionDto.PROPERTY_BAITS_COMPOSITION, - SetLonglineGlobalCompositionDto.PROPERTY_MITIGATION_TYPE + SetLonglineGlobalCompositionDto.PROPERTY_FLOATLINES_COMPOSITION, + SetLonglineGlobalCompositionDto.PROPERTY_BRANCHLINES_COMPOSITION, + SetLonglineGlobalCompositionDto.PROPERTY_HOOKS_COMPOSITION, + SetLonglineGlobalCompositionDto.PROPERTY_BAITS_COMPOSITION, + SetLonglineGlobalCompositionDto.PROPERTY_MITIGATION_TYPE ); } @Override public void initSetLonglineTdrDto() { registerDto(SetLonglineTdrDto.class, SetLongline.class, - SetLonglineTdrDto.PROPERTY_TDR + SetLonglineTdrDto.PROPERTY_TDR ); } @Override public void initSizeMeasureDto() { registerMainDto(SizeMeasureDto.class, SizeMeasure.class, - SizeMeasureDto.PROPERTY_SIZE, - SizeMeasureDto.PROPERTY_SIZE_MEASURE_TYPE + SizeMeasureDto.PROPERTY_SIZE, + SizeMeasureDto.PROPERTY_SIZE_MEASURE_TYPE ); } @Override public void initTdrDto() { registerMainDto(TdrDto.class, Tdr.class, - TdrDto.PROPERTY_HOME_ID, - TdrDto.PROPERTY_FLOATLINE1_LENGTH, - TdrDto.PROPERTY_FLOATLINE2_LENGTH, - TdrDto.PROPERTY_SERIAL_NO, - TdrDto.PROPERTY_DATA, - TdrDto.PROPERTY_DATA_FILENAME, - TdrDto.PROPERTY_DATA_LOCATION, - TdrDto.PROPERTY_DEPLOYEMENT_START, - TdrDto.PROPERTY_DEPLOYEMENT_END, - TdrDto.PROPERTY_FISHING_START, - TdrDto.PROPERTY_FISHING_END, - TdrDto.PROPERTY_FISHING_START_DEPTH, - TdrDto.PROPERTY_FISHING_END_DEPTH, - TdrDto.PROPERTY_MEAN_DEPLOYEMENT_DEPTH, - TdrDto.PROPERTY_MEDIAN_DEPLOYEMENT_DEPTH, - TdrDto.PROPERTY_MIN_FISHING_DEPTH, - TdrDto.PROPERTY_MAX_FISHING_DEPTH, - TdrDto.PROPERTY_MEAN_FISHING_DEPTH, - TdrDto.PROPERTY_MEDIAN_FISHING_DEPTH, - TdrDto.PROPERTY_SENSOR_BRAND, - TdrDto.PROPERTY_ITEM_HORIZONTAL_POSITION, - TdrDto.PROPERTY_ITEM_VERTICAL_POSITION, - TdrDto.PROPERTY_SPECIES, - TdrDto.PROPERTY_BASKET, - TdrDto.PROPERTY_SECTION, - TdrDto.PROPERTY_BRANCHLINE + TdrDto.PROPERTY_HOME_ID, + TdrDto.PROPERTY_FLOATLINE1_LENGTH, + TdrDto.PROPERTY_FLOATLINE2_LENGTH, + TdrDto.PROPERTY_SERIAL_NO, + TdrDto.PROPERTY_DATA, + TdrDto.PROPERTY_DATA_FILENAME, + TdrDto.PROPERTY_DATA_LOCATION, + TdrDto.PROPERTY_DEPLOYEMENT_START, + TdrDto.PROPERTY_DEPLOYEMENT_END, + TdrDto.PROPERTY_FISHING_START, + TdrDto.PROPERTY_FISHING_END, + TdrDto.PROPERTY_FISHING_START_DEPTH, + TdrDto.PROPERTY_FISHING_END_DEPTH, + TdrDto.PROPERTY_MEAN_DEPLOYEMENT_DEPTH, + TdrDto.PROPERTY_MEDIAN_DEPLOYEMENT_DEPTH, + TdrDto.PROPERTY_MIN_FISHING_DEPTH, + TdrDto.PROPERTY_MAX_FISHING_DEPTH, + TdrDto.PROPERTY_MEAN_FISHING_DEPTH, + TdrDto.PROPERTY_MEDIAN_FISHING_DEPTH, + TdrDto.PROPERTY_SENSOR_BRAND, + TdrDto.PROPERTY_ITEM_HORIZONTAL_POSITION, + TdrDto.PROPERTY_ITEM_VERTICAL_POSITION, + TdrDto.PROPERTY_SPECIES, + TdrDto.PROPERTY_BASKET, + TdrDto.PROPERTY_SECTION, + TdrDto.PROPERTY_BRANCHLINE ); } @Override public void initTripLonglineDto() { registerMainDto(TripLonglineDto.class, TripLongline.class, - TripLonglineDto.PROPERTY_COMMENT, - TripLonglineDto.PROPERTY_OPEN, - TripLonglineDto.PROPERTY_START_DATE, - TripLonglineDto.PROPERTY_END_DATE, - TripLonglineDto.PROPERTY_TOTAL_FISHING_OPERATIONS_NUMBER, - TripLonglineDto.PROPERTY_HOME_ID, - TripLonglineDto.PROPERTY_TRIP_TYPE, - TripLonglineDto.PROPERTY_CAPTAIN, - TripLonglineDto.PROPERTY_OBSERVER, - TripLonglineDto.PROPERTY_DATA_ENTRY_OPERATOR, - TripLonglineDto.PROPERTY_VESSEL, - TripLonglineDto.PROPERTY_OCEAN, - TripLonglineDto.PROPERTY_DEPARTURE_HARBOUR, - TripLonglineDto.PROPERTY_LANDING_HARBOUR + TripLonglineDto.PROPERTY_COMMENT, + TripLonglineDto.PROPERTY_OPEN, + TripLonglineDto.PROPERTY_START_DATE, + TripLonglineDto.PROPERTY_END_DATE, + TripLonglineDto.PROPERTY_TOTAL_FISHING_OPERATIONS_NUMBER, + TripLonglineDto.PROPERTY_HOME_ID, + TripLonglineDto.PROPERTY_TRIP_TYPE, + TripLonglineDto.PROPERTY_CAPTAIN, + TripLonglineDto.PROPERTY_OBSERVER, + TripLonglineDto.PROPERTY_DATA_ENTRY_OPERATOR, + TripLonglineDto.PROPERTY_VESSEL, + TripLonglineDto.PROPERTY_OCEAN, + TripLonglineDto.PROPERTY_DEPARTURE_HARBOUR, + TripLonglineDto.PROPERTY_LANDING_HARBOUR ); } @Override public void initWeightMeasureDto() { registerMainDto(WeightMeasureDto.class, WeightMeasure.class, - WeightMeasureDto.PROPERTY_WEIGHT, - WeightMeasureDto.PROPERTY_WEIGHT_MEASURE_TYPE); + WeightMeasureDto.PROPERTY_WEIGHT, + WeightMeasureDto.PROPERTY_WEIGHT_MEASURE_TYPE); } // -------------------------------------------------------------------------------------------------------------- // @@ -1224,22 +1236,22 @@ public class ObserveDtosInitializer implements ObserveModelInitializer { @Override public void initActivitySeineDto() { registerMainDto(ActivitySeineDto.class, ActivitySeine.class, - ActivitySeineDto.PROPERTY_COMMENT, - ActivitySeineDto.PROPERTY_OPEN, - ActivitySeineDto.PROPERTY_TIME, - ActivitySeineDto.PROPERTY_LATITUDE, - ActivitySeineDto.PROPERTY_LONGITUDE, - ActivitySeineDto.PROPERTY_VESSEL_SPEED, - ActivitySeineDto.PROPERTY_SEA_SURFACE_TEMPERATURE, - ActivitySeineDto.PROPERTY_ERS_ID, - ActivitySeineDto.PROPERTY_VESSEL_ACTIVITY_SEINE, - ActivitySeineDto.PROPERTY_SURROUNDING_ACTIVITY, - ActivitySeineDto.PROPERTY_DETECTION_MODE, - ActivitySeineDto.PROPERTY_REASON_FOR_NO_FISHING, - ActivitySeineDto.PROPERTY_PREVIOUS_FPA_ZONE, - ActivitySeineDto.PROPERTY_CURRENT_FPA_ZONE, - ActivitySeineDto.PROPERTY_NEXT_FPA_ZONE, - ActivitySeineDto.PROPERTY_NEXT_FPA_ZONE + ActivitySeineDto.PROPERTY_COMMENT, + ActivitySeineDto.PROPERTY_OPEN, + ActivitySeineDto.PROPERTY_TIME, + ActivitySeineDto.PROPERTY_LATITUDE, + ActivitySeineDto.PROPERTY_LONGITUDE, + ActivitySeineDto.PROPERTY_VESSEL_SPEED, + ActivitySeineDto.PROPERTY_SEA_SURFACE_TEMPERATURE, + ActivitySeineDto.PROPERTY_ERS_ID, + ActivitySeineDto.PROPERTY_VESSEL_ACTIVITY_SEINE, + ActivitySeineDto.PROPERTY_SURROUNDING_ACTIVITY, + ActivitySeineDto.PROPERTY_DETECTION_MODE, + ActivitySeineDto.PROPERTY_REASON_FOR_NO_FISHING, + ActivitySeineDto.PROPERTY_PREVIOUS_FPA_ZONE, + ActivitySeineDto.PROPERTY_CURRENT_FPA_ZONE, + ActivitySeineDto.PROPERTY_NEXT_FPA_ZONE, + ActivitySeineDto.PROPERTY_NEXT_FPA_ZONE ); } @@ -1247,263 +1259,267 @@ public class ObserveDtosInitializer implements ObserveModelInitializer { @Override public void initActivitySeineObservedSystemDto() { registerDto(ActivitySeineObservedSystemDto.class, ActivitySeine.class, - ActivitySeineObservedSystemDto.PROPERTY_COMMENT, - ActivitySeineObservedSystemDto.PROPERTY_OPEN, - ActivitySeineObservedSystemDto.PROPERTY_OBSERVED_SYSTEM_DISTANCE, - ActivitySeineObservedSystemDto.PROPERTY_OBSERVED_SYSTEM + ActivitySeineObservedSystemDto.PROPERTY_COMMENT, + ActivitySeineObservedSystemDto.PROPERTY_OPEN, + ActivitySeineObservedSystemDto.PROPERTY_OBSERVED_SYSTEM_DISTANCE, + ActivitySeineObservedSystemDto.PROPERTY_OBSERVED_SYSTEM ); } @Override public void initFloatingObjectDto() { registerMainDto(FloatingObjectDto.class, FloatingObject.class, - FloatingObjectDto.PROPERTY_COMMENT, - FloatingObjectDto.PROPERTY_DAYS_AT_SEA_COUNT, - FloatingObjectDto.PROPERTY_SUPPORT_VESSEL_NAME, - FloatingObjectDto.PROPERTY_OBJECT_FATE, - FloatingObjectDto.PROPERTY_OBJECT_OPERATION, - FloatingObjectDto.PROPERTY_OBJECT_TYPE + FloatingObjectDto.PROPERTY_COMMENT, + FloatingObjectDto.PROPERTY_DAYS_AT_SEA_COUNT, + FloatingObjectDto.PROPERTY_SUPPORT_VESSEL_NAME, + FloatingObjectDto.PROPERTY_OBJECT_FATE, + FloatingObjectDto.PROPERTY_OBJECT_OPERATION, + FloatingObjectDto.PROPERTY_OBJECT_TYPE ); } @Override public void initFloatingObjectObservedSpeciesDto() { registerDto(FloatingObjectObservedSpeciesDto.class, FloatingObject.class, - FloatingObjectObservedSpeciesDto.PROPERTY_COMMENT, - FloatingObjectObservedSpeciesDto.PROPERTY_OBJECT_OBSERVED_SPECIES + FloatingObjectObservedSpeciesDto.PROPERTY_COMMENT, + FloatingObjectObservedSpeciesDto.PROPERTY_OBJECT_OBSERVED_SPECIES ); } @Override public void initFloatingObjectSchoolEstimateDto() { registerDto(FloatingObjectSchoolEstimateDto.class, FloatingObject.class, - FloatingObjectSchoolEstimateDto.PROPERTY_COMMENT, - FloatingObjectSchoolEstimateDto.PROPERTY_OBJECT_SCHOOL_ESTIMATE + FloatingObjectSchoolEstimateDto.PROPERTY_COMMENT, + FloatingObjectSchoolEstimateDto.PROPERTY_OBJECT_SCHOOL_ESTIMATE ); } @Override public void initFloatingObjectTransmittingBuoyDto() { registerDto(FloatingObjectTransmittingBuoyDto.class, FloatingObject.class, - FloatingObjectTransmittingBuoyDto.PROPERTY_COMMENT, - FloatingObjectTransmittingBuoyDto.PROPERTY_TRANSMITTING_BUOY + FloatingObjectTransmittingBuoyDto.PROPERTY_COMMENT, + FloatingObjectTransmittingBuoyDto.PROPERTY_TRANSMITTING_BUOY ); } @Override public void initGearUseFeaturesMeasurementSeineDto() { registerMainDto(GearUseFeaturesMeasurementSeineDto.class, GearUseFeaturesMeasurementSeine.class, - GearUseFeaturesMeasurementSeineDto.PROPERTY_MEASUREMENT_VALUE, - GearUseFeaturesMeasurementSeineDto.PROPERTY_GEAR_CARACTERISTIC + GearUseFeaturesMeasurementSeineDto.PROPERTY_MEASUREMENT_VALUE, + GearUseFeaturesMeasurementSeineDto.PROPERTY_GEAR_CARACTERISTIC ); } @Override public void initGearUseFeaturesSeineDto() { registerMainDto(GearUseFeaturesSeineDto.class, GearUseFeaturesSeine.class, - GearUseFeaturesSeineDto.PROPERTY_COMMENT, - GearUseFeaturesSeineDto.PROPERTY_NUMBER, - GearUseFeaturesSeineDto.PROPERTY_USED_IN_TRIP, - GearUseFeaturesSeineDto.PROPERTY_GEAR_USE_FEATURES_MEASUREMENT + GearUseFeaturesSeineDto.PROPERTY_GEAR, + GearUseFeaturesSeineDto.PROPERTY_COMMENT, + GearUseFeaturesSeineDto.PROPERTY_NUMBER, + GearUseFeaturesSeineDto.PROPERTY_USED_IN_TRIP, + GearUseFeaturesSeineDto.PROPERTY_GEAR_USE_FEATURES_MEASUREMENT ); } @Override public void initNonTargetCatchDto() { registerMainDto(NonTargetCatchDto.class, NonTargetCatch.class, - NonTargetCatchDto.PROPERTY_COMMENT, - NonTargetCatchDto.PROPERTY_CATCH_WEIGHT, - NonTargetCatchDto.PROPERTY_CATCH_WEIGHT_COMPUTED_SOURCE, - NonTargetCatchDto.PROPERTY_MEAN_WEIGHT, - NonTargetCatchDto.PROPERTY_MEAN_WEIGHT_COMPUTED_SOURCE, - NonTargetCatchDto.PROPERTY_MEAN_LENGTH, - NonTargetCatchDto.PROPERTY_MEAN_LENGTH_COMPUTED_SOURCE, - NonTargetCatchDto.PROPERTY_TOTAL_COUNT, - NonTargetCatchDto.PROPERTY_TOTAL_COUNT_COMPUTED_SOURCE, - NonTargetCatchDto.PROPERTY_SPECIES_FATE, - NonTargetCatchDto.PROPERTY_REASON_FOR_DISCARD + NonTargetCatchDto.PROPERTY_COMMENT, + NonTargetCatchDto.PROPERTY_CATCH_WEIGHT, + NonTargetCatchDto.PROPERTY_CATCH_WEIGHT_COMPUTED_SOURCE, + NonTargetCatchDto.PROPERTY_MEAN_WEIGHT, + NonTargetCatchDto.PROPERTY_MEAN_WEIGHT_COMPUTED_SOURCE, + NonTargetCatchDto.PROPERTY_MEAN_LENGTH, + NonTargetCatchDto.PROPERTY_MEAN_LENGTH_COMPUTED_SOURCE, + NonTargetCatchDto.PROPERTY_TOTAL_COUNT, + NonTargetCatchDto.PROPERTY_TOTAL_COUNT_COMPUTED_SOURCE, + NonTargetCatchDto.PROPERTY_SPECIES_FATE, + NonTargetCatchDto.PROPERTY_REASON_FOR_DISCARD ); } @Override public void initNonTargetLengthDto() { registerMainDto(NonTargetLengthDto.class, NonTargetLength.class, - NonTargetLengthDto.PROPERTY_LENGTH, - NonTargetLengthDto.PROPERTY_LENGTH, - NonTargetLengthDto.PROPERTY_LENGTH_SOURCE, - NonTargetLengthDto.PROPERTY_PICTURES_REFERENCES, - NonTargetLengthDto.PROPERTY_WEIGHT, - NonTargetLengthDto.PROPERTY_WEIGHT_SOURCE, - NonTargetLengthDto.PROPERTY_COUNT, - NonTargetLengthDto.PROPERTY_ACQUISITION_MODE, - NonTargetLengthDto.PROPERTY_SPECIES + NonTargetLengthDto.PROPERTY_LENGTH, + NonTargetLengthDto.PROPERTY_LENGTH, + NonTargetLengthDto.PROPERTY_LENGTH_SOURCE, + NonTargetLengthDto.PROPERTY_PICTURES_REFERENCES, + NonTargetLengthDto.PROPERTY_WEIGHT, + NonTargetLengthDto.PROPERTY_WEIGHT_SOURCE, + NonTargetLengthDto.PROPERTY_COUNT, + NonTargetLengthDto.PROPERTY_ACQUISITION_MODE, + NonTargetLengthDto.PROPERTY_SPECIES ); } @Override public void initNonTargetSampleDto() { registerMainDto(NonTargetSampleDto.class, NonTargetSample.class, - NonTargetSampleDto.PROPERTY_COMMENT, - NonTargetSampleDto.PROPERTY_NON_TARGET_LENGTH + NonTargetSampleDto.PROPERTY_COMMENT, + NonTargetSampleDto.PROPERTY_NON_TARGET_LENGTH ); } @Override public void initObjectObservedSpeciesDto() { registerMainDto(ObjectObservedSpeciesDto.class, ObjectObservedSpecies.class, - ObjectObservedSpeciesDto.PROPERTY_COUNT, - ObjectObservedSpeciesDto.PROPERTY_STATUT, - ObjectObservedSpeciesDto.PROPERTY_SPECIES, - ObjectObservedSpeciesDto.PROPERTY_SPECIES_STATUS + ObjectObservedSpeciesDto.PROPERTY_COUNT, + ObjectObservedSpeciesDto.PROPERTY_STATUT, + ObjectObservedSpeciesDto.PROPERTY_SPECIES, + ObjectObservedSpeciesDto.PROPERTY_SPECIES_STATUS ); } @Override public void initObjectSchoolEstimateDto() { registerMainDto(ObjectSchoolEstimateDto.class, ObjectSchoolEstimate.class, - ObjectSchoolEstimateDto.PROPERTY_TOTAL_WEIGHT, - ObjectSchoolEstimateDto.PROPERTY_SPECIES + ObjectSchoolEstimateDto.PROPERTY_TOTAL_WEIGHT, + ObjectSchoolEstimateDto.PROPERTY_SPECIES ); } @Override public void initRouteDto() { registerMainDto(RouteDto.class, Route.class, - RouteDto.PROPERTY_COMMENT, - RouteDto.PROPERTY_OPEN, - RouteDto.PROPERTY_DATE, - RouteDto.PROPERTY_START_LOG_VALUE, - RouteDto.PROPERTY_END_LOG_VALUE, - RouteDto.PROPERTY_CHECK_LEVEL + RouteDto.PROPERTY_COMMENT, + RouteDto.PROPERTY_OPEN, + RouteDto.PROPERTY_DATE, + RouteDto.PROPERTY_START_LOG_VALUE, + RouteDto.PROPERTY_END_LOG_VALUE, + RouteDto.PROPERTY_CHECK_LEVEL ); } @Override public void initSchoolEstimateDto() { registerMainDto(SchoolEstimateDto.class, SchoolEstimate.class, - SchoolEstimateDto.PROPERTY_TOTAL_WEIGHT, - SchoolEstimateDto.PROPERTY_MEAN_WEIGHT, - SchoolEstimateDto.PROPERTY_SPECIES + SchoolEstimateDto.PROPERTY_TOTAL_WEIGHT, + SchoolEstimateDto.PROPERTY_MEAN_WEIGHT, + SchoolEstimateDto.PROPERTY_SPECIES ); } @Override public void initSetSeineDto() { registerMainDto(SetSeineDto.class, SetSeine.class, - SetSeineDto.PROPERTY_COMMENT, - SetSeineDto.PROPERTY_START_TIME, - SetSeineDto.PROPERTY_END_PURSING_TIME_STAMP, - SetSeineDto.PROPERTY_END_SET_TIME_STAMP, - SetSeineDto.PROPERTY_MAX_GEAR_DEPTH, - SetSeineDto.PROPERTY_CURRENT_SPEED, - SetSeineDto.PROPERTY_CURRENT_DIRECTION, - SetSeineDto.PROPERTY_SCHOOL_TOP_DEPTH, - SetSeineDto.PROPERTY_SCHOOL_MEAN_DEPTH, - SetSeineDto.PROPERTY_SCHOOL_THICKNESS, - SetSeineDto.PROPERTY_SONAR_USED, - SetSeineDto.PROPERTY_SUPPORT_VESSEL_NAME, - SetSeineDto.PROPERTY_NON_TARGET_DISCARDED, - SetSeineDto.PROPERTY_CURRENT_MEASURE_DEPTH, - SetSeineDto.PROPERTY_SCHOOL_TYPE, - SetSeineDto.PROPERTY_REASON_FOR_NULL_SET + SetSeineDto.PROPERTY_COMMENT, + SetSeineDto.PROPERTY_START_TIME, + SetSeineDto.PROPERTY_END_PURSING_TIME_STAMP, + SetSeineDto.PROPERTY_END_SET_TIME_STAMP, + SetSeineDto.PROPERTY_MAX_GEAR_DEPTH, + SetSeineDto.PROPERTY_CURRENT_SPEED, + SetSeineDto.PROPERTY_CURRENT_DIRECTION, + SetSeineDto.PROPERTY_SCHOOL_TOP_DEPTH, + SetSeineDto.PROPERTY_SCHOOL_MEAN_DEPTH, + SetSeineDto.PROPERTY_SCHOOL_THICKNESS, + SetSeineDto.PROPERTY_SONAR_USED, + SetSeineDto.PROPERTY_SUPPORT_VESSEL_NAME, + SetSeineDto.PROPERTY_NON_TARGET_DISCARDED, + SetSeineDto.PROPERTY_CURRENT_MEASURE_DEPTH, + SetSeineDto.PROPERTY_SCHOOL_TYPE, + SetSeineDto.PROPERTY_REASON_FOR_NULL_SET ); } @Override public void initSetSeineNonTargetCatchDto() { registerDto(SetSeineNonTargetCatchDto.class, SetSeine.class, - SetSeineNonTargetCatchDto.PROPERTY_NON_TARGET_CATCH + SetSeineNonTargetCatchDto.PROPERTY_NON_TARGET_CATCH ); } @Override public void initSetSeineSchoolEstimateDto() { registerDto(SetSeineSchoolEstimateDto.class, SetSeine.class, - SetSeineSchoolEstimateDto.PROPERTY_COMMENT, - SetSeineSchoolEstimateDto.PROPERTY_SCHOOL_ESTIMATE + SetSeineSchoolEstimateDto.PROPERTY_COMMENT, + SetSeineSchoolEstimateDto.PROPERTY_SCHOOL_ESTIMATE ); } @Override public void initSetSeineTargetCatchDto() { registerDto(SetSeineTargetCatchDto.class, SetSeine.class, - SetSeineTargetCatchDto.PROPERTY_TARGET_CATCH + SetSeineTargetCatchDto.PROPERTY_TARGET_CATCH ); } @Override public void initTargetCatchDto() { registerMainDto(TargetCatchDto.class, TargetCatch.class, - TargetCatchDto.PROPERTY_COMMENT, - TargetCatchDto.PROPERTY_CATCH_WEIGHT, - TargetCatchDto.PROPERTY_WELL, - TargetCatchDto.PROPERTY_BROUGHT_ON_DECK, - TargetCatchDto.PROPERTY_DISCARDED, - TargetCatchDto.PROPERTY_SPECIES, - TargetCatchDto.PROPERTY_REASON_FOR_DISCARD, - TargetCatchDto.PROPERTY_WEIGHT_CATEGORY + TargetCatchDto.PROPERTY_COMMENT, + TargetCatchDto.PROPERTY_CATCH_WEIGHT, + TargetCatchDto.PROPERTY_WELL, + TargetCatchDto.PROPERTY_BROUGHT_ON_DECK, + TargetCatchDto.PROPERTY_DISCARDED, + TargetCatchDto.PROPERTY_SPECIES, + TargetCatchDto.PROPERTY_REASON_FOR_DISCARD, + TargetCatchDto.PROPERTY_WEIGHT_CATEGORY ); } @Override public void initTargetLengthDto() { registerMainDto(TargetLengthDto.class, TargetLength.class, - TargetLengthDto.PROPERTY_MEASURE_TYPE, - TargetLengthDto.PROPERTY_LENGTH, - TargetLengthDto.PROPERTY_LENGTH_SOURCE, - TargetLengthDto.PROPERTY_COUNT, - TargetLengthDto.PROPERTY_WEIGHT, - TargetLengthDto.PROPERTY_WEIGHT_SOURCE, - TargetLengthDto.PROPERTY_ACQUISITION_MODE, - TargetLengthDto.PROPERTY_SPECIES + TargetLengthDto.PROPERTY_MEASURE_TYPE, + TargetLengthDto.PROPERTY_LENGTH, + TargetLengthDto.PROPERTY_LENGTH_SOURCE, + TargetLengthDto.PROPERTY_COUNT, + TargetLengthDto.PROPERTY_WEIGHT, + TargetLengthDto.PROPERTY_WEIGHT_SOURCE, + TargetLengthDto.PROPERTY_ACQUISITION_MODE, + TargetLengthDto.PROPERTY_SPECIES ); } @Override public void initTargetSampleDto() { registerMainDto(TargetSampleDto.class, TargetSample.class, - TargetSampleDto.PROPERTY_COMMENT, - TargetSampleDto.PROPERTY_NATURE, - TargetSampleDto.PROPERTY_DISCARDED, - TargetSampleDto.PROPERTY_TARGET_LENGTH); + TargetSampleDto.PROPERTY_COMMENT, + TargetSampleDto.PROPERTY_NATURE, + TargetSampleDto.PROPERTY_DISCARDED, + TargetSampleDto.PROPERTY_TARGET_LENGTH); } @Override public void initTransmittingBuoyDto() { registerMainDto(TransmittingBuoyDto.class, TransmittingBuoy.class, - TransmittingBuoyDto.PROPERTY_CODE, - TransmittingBuoyDto.PROPERTY_BRAND, - TransmittingBuoyDto.PROPERTY_OWNERSHIP, - TransmittingBuoyDto.PROPERTY_TRANSMITTING_BUOY_OPERATION, - TransmittingBuoyDto.PROPERTY_TRANSMITTING_BUOY_TYPE + TransmittingBuoyDto.PROPERTY_CODE, + TransmittingBuoyDto.PROPERTY_BRAND, + TransmittingBuoyDto.PROPERTY_OWNERSHIP, + TransmittingBuoyDto.PROPERTY_TRANSMITTING_BUOY_OPERATION, + TransmittingBuoyDto.PROPERTY_TRANSMITTING_BUOY_TYPE ); } @Override public void initTripSeineDto() { registerMainDto(TripSeineDto.class, TripSeine.class, - TripSeineDto.PROPERTY_COMMENT, - TripSeineDto.PROPERTY_OPEN, - TripSeineDto.PROPERTY_START_DATE, - TripSeineDto.PROPERTY_END_DATE, - TripSeineDto.PROPERTY_DATE_ARRIVEE_PORT, - TripSeineDto.PROPERTY_CHECK_LEVEL, - TripSeineDto.PROPERTY_FORMS_URL, - TripSeineDto.PROPERTY_REPORTS_URL, - TripSeineDto.PROPERTY_HISTORICAL_DATA, - TripSeineDto.PROPERTY_ERS_ID, - TripSeineDto.PROPERTY_OBSERVER, - TripSeineDto.PROPERTY_CAPTAIN, - TripSeineDto.PROPERTY_DATA_ENTRY_OPERATOR, - TripSeineDto.PROPERTY_VESSEL, - TripSeineDto.PROPERTY_OCEAN, - TripSeineDto.PROPERTY_DEPARTURE_HARBOUR, - TripSeineDto.PROPERTY_LANDING_HARBOUR + TripSeineDto.PROPERTY_COMMENT, + TripSeineDto.PROPERTY_OPEN, + TripSeineDto.PROPERTY_START_DATE, + TripSeineDto.PROPERTY_END_DATE, + TripSeineDto.PROPERTY_DATE_ARRIVEE_PORT, + TripSeineDto.PROPERTY_CHECK_LEVEL, + TripSeineDto.PROPERTY_FORMS_URL, + TripSeineDto.PROPERTY_REPORTS_URL, + TripSeineDto.PROPERTY_HISTORICAL_DATA, + TripSeineDto.PROPERTY_ERS_ID, + TripSeineDto.PROPERTY_OBSERVER, + TripSeineDto.PROPERTY_CAPTAIN, + TripSeineDto.PROPERTY_DATA_ENTRY_OPERATOR, + TripSeineDto.PROPERTY_VESSEL, + TripSeineDto.PROPERTY_OCEAN, + TripSeineDto.PROPERTY_DEPARTURE_HARBOUR, + TripSeineDto.PROPERTY_LANDING_HARBOUR ); } protected <R extends IdDto, E extends TopiaEntity> void registerDtoType(Class<R> dtoType, Class<E> entityType) { + Class<? extends TopiaEntity> entityImplementationType = ObserveEntityEnum.valueOf(entityType).getImplementation(); DTO_TO_ENTITY_TYPE_BUILDER.put(dtoType, entityType); + ENTITY_TO_DTO_TYPE_BUILDER.put(entityType, dtoType); + ENTITY_TO_DTO_TYPE_BUILDER.put(entityImplementationType, dtoType); } protected <D extends IdDto, E extends TopiaEntity> void registerMainDto(Class<D> dtoType, Class<E> entityType, String... properties) { @@ -1574,7 +1590,20 @@ public class ObserveDtosInitializer implements ObserveModelInitializer { addEntityToDtoFunctions(entityToDtoToBuilder); BinderFactory.registerBinderModel(dtoToEntityBuilder, ObserveDtoBinders.DTO_TO_ENTITY); - BinderFactory.registerBinderModel(entityToDtoToBuilder, ObserveDtoBinders.ENTITY_TO_DTO); + + Binder.BinderModel<E, R> binderModel = BinderFactory.registerBinderModel(entityToDtoToBuilder, ObserveDtoBinders.ENTITY_TO_DTO); + + // On enregistre aussi un binder depuis l'implantation de l'entité, pour ne pas à avoir à tout le temps + // revenir sur le contrat d'une entité + Class<E> entityImplementationType = (Class<E>) ObserveEntityEnum.valueOf(binderModel.getSourceType()).getImplementation(); + + BinderModelBuilder<E, R> entityImplToDtoToBuilder = newBinderBuilder(entityImplementationType, binderModel.getTargetType()); + for (String propertyName : binderModel.getSourceDescriptors()) { + if (binderModel.containsSourceProperty(propertyName)) { + entityImplToDtoToBuilder.addProperty(propertyName, binderModel.getTargetProperty(propertyName)); + } + } + BinderFactory.registerBinderModel(entityImplToDtoToBuilder, ObserveDtoBinders.ENTITY_TO_DTO); } @@ -1588,7 +1617,20 @@ public class ObserveDtosInitializer implements ObserveModelInitializer { addEntityToDtoFunctions(entityToReferenceBuilder); BinderFactory.registerBinderModel(dtoToReferenceBuilder, ObserveDtoBinders.DTO_TO_REFERENCE); - BinderFactory.registerBinderModel(entityToReferenceBuilder, ObserveDtoBinders.ENTITY_TO_REFERENCE); + Binder.BinderModel<E, R> binderModel = + BinderFactory.registerBinderModel(entityToReferenceBuilder, ObserveDtoBinders.ENTITY_TO_REFERENCE); + + // On enregistre aussi un binder depuis l'implantation de l'entité, pour ne pas à avoir à tout le temps + // revenir sur le contrat d'une entité + Class<E> entityImplementationType = (Class<E>) ObserveEntityEnum.valueOf(binderModel.getSourceType()).getImplementation(); + + BinderModelBuilder<E, R> entityImplToDtoToBuilder = newBinderBuilder(entityImplementationType, binderModel.getTargetType()); + for (String propertyName : binderModel.getSourceDescriptors()) { + if (binderModel.containsSourceProperty(propertyName)) { + entityImplToDtoToBuilder.addProperty(propertyName, binderModel.getTargetProperty(propertyName)); + } + } + BinderFactory.registerBinderModel(entityImplToDtoToBuilder, ObserveDtoBinders.ENTITY_TO_REFERENCE); } @@ -1600,7 +1642,6 @@ public class ObserveDtosInitializer implements ObserveModelInitializer { return builder; } - protected static <Source extends IdDto, Target> void addDtoToEntityFunctions(BinderModelBuilder<Source, Target> builder) { builder.addFunction(fr.ird.observe.services.dto.constants.GearType.class, new Function<fr.ird.observe.services.dto.constants.GearType, fr.ird.observe.entities.constants.GearType>() { @@ -1698,4 +1739,5 @@ public class ObserveDtosInitializer implements ObserveModelInitializer { }); } + } diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/builder/EntityToDtoBuilderTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/builder/EntityToDtoBuilderTest.java index ba4956d..80ac7de 100644 --- a/observe-services-topia/src/test/java/fr/ird/observe/services/builder/EntityToDtoBuilderTest.java +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/builder/EntityToDtoBuilderTest.java @@ -210,7 +210,8 @@ public class EntityToDtoBuilderTest { GearUseFeaturesMeasurementSeineDto measurementDto = featuresDto.getGearUseFeaturesMeasurement().get(0); Assert.assertEquals(measurement.getTopiaId(), measurementDto.getId()); Assert.assertEquals(measurement.getMeasurementValue(), measurementDto.getMeasurementValue()); - Assert.assertEquals(measurement.getGearCaracteristic().getTopiaId(), measurementDto.getGearCaracteristic().getId()); + Assert.assertNotNull(measurementDto.getGearCaracteristic()); + Assert.assertEquals(measurement.getGearCaracteristic().getTopiaId(), measurementDto.getGearCaracteristic().getId()); } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.