-changed the hibernate, sprint, and data versions.

digows · digows · commit 573dff5a815f · 2018-01-03T22:01:35.000-02:00
diff --git a/.classpath b/.classpath
@@ -23,7 +23,7 @@
 			<attribute name="org.eclipse.jst.component.nondependency" value=""/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
 		<attributes>
 			<attribute name="owner.project.facets" value="java"/>
 		</attributes>
diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs
@@ -1,16 +1,16 @@
 eclipse.preferences.version=1
 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
 org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.7
+org.eclipse.jdt.core.compiler.compliance=1.8
 org.eclipse.jdt.core.compiler.debug.lineNumber=generate
 org.eclipse.jdt.core.compiler.debug.localVariable=generate
 org.eclipse.jdt.core.compiler.debug.sourceFile=generate
 org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
 org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
-org.eclipse.jdt.core.compiler.source=1.7
+org.eclipse.jdt.core.compiler.source=1.8
 org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
 org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
 org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
diff --git a/.settings/org.eclipse.wst.common.project.facet.core.xml b/.settings/org.eclipse.wst.common.project.facet.core.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <faceted-project>
   <installed facet="jst.utility" version="1.0"/>
-  <installed facet="java" version="1.7"/>
+  <installed facet="java" version="1.8"/>
 </faceted-project>
diff --git a/README.md b/README.md
@@ -16,18 +16,11 @@ This can be used on classes non managed by spring.
 This return a server full URL containing the scheme + the server host + port (if is not the 80) and the context name (when have).
 This can be used on classes non managed by spring.
 
-##DWR Converters (HibernateBeanConverter & LocalDateTimeConverter)
+##DWR Converters (HibernateBeanConverter, LocalDateTimeConverter, OptionalConverter)
 
 ##Custom Hibernate PostgreSQL Dialect
 Supporting a custom HQL function called `FILTER()`
 
-##Easy file management via Java JCR
-Infrastructure to store files via JCR implemented by Modeshape supported by a generic file repository `IMetaFileRepository` and its entity `MetaFile`.
-
-##Support of TRUNCATE TABLE to the DBUnit
-```java
-CascadeTruncateTableOperation.java
-```
 ##ReportManager
 ####Report generator implemented by `JasperReportManager`
 Supported methods:
diff --git a/pom.xml b/pom.xml
@@ -4,20 +4,17 @@
 	
 	<groupId>br.com.eits</groupId>
 	<artifactId>eits-java-common</artifactId>
-	<version>3.0.1-RELEASE</version>
+	<version>4.0.0-RELEASE</version>
 	
 	<!-- Properties -->
 	<properties>
-    	<!-- Maven -->
 		<maven.test.failure.ignore>true</maven.test.failure.ignore>
-		
-    	<!-- Java -->
-    	<java.version>1.8</java.version>
+    		<java.version>1.8</java.version>
     	
-		<hibernate.version>4.3.8.Final</hibernate.version>
-		<hibernate-validator.version>5.1.3.Final</hibernate-validator.version>
-		<springframework.version>4.2.0.RELEASE</springframework.version>
-		<spring-data.version>1.9.0.RELEASE</spring-data.version>
+		<hibernate.version>5.2.12.Final</hibernate.version>
+		<hibernate-validator.version>5.4.1.Final</hibernate-validator.version>
+		<springframework.version>5.0.2.RELEASE</springframework.version>
+		<spring-data.version>2.0.2.RELEASE</spring-data.version>
 		<jasper.version>6.2.2</jasper.version>
 		<dwr.version>3.0.2-RELEASE</dwr.version>
 		<apache-poi.version>3.14</apache-poi.version>
@@ -127,9 +124,9 @@
 		
   		<!-- DWR -->
 		<dependency>
-    		<groupId>org.directwebremoting</groupId>
-    		<artifactId>dwr</artifactId>
-    		<version>${dwr.version}</version>
+    			<groupId>org.directwebremoting</groupId>
+    			<artifactId>dwr</artifactId>
+    			<version>${dwr.version}</version>
   		</dependency>
   		
 		<dependency>
diff --git a/src/main/java/br/com/eits/common/application/dwr/converter/HibernateBeanConverter.java b/src/main/java/br/com/eits/common/application/dwr/converter/HibernateBeanConverter.java
@@ -16,7 +16,7 @@
 import org.directwebremoting.extend.PlainProperty;
 import org.directwebremoting.extend.Property;
 import org.hibernate.Hibernate;
-import org.hibernate.engine.spi.SessionImplementor;
+import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.proxy.HibernateProxy;
 import org.hibernate.proxy.LazyInitializer;
 
@@ -154,16 +154,16 @@ public Class<?> getClass(Object example)
     {
         if (example instanceof HibernateProxy)
         {
-            HibernateProxy proxy = (HibernateProxy) example;
-            LazyInitializer initializer = proxy.getHibernateLazyInitializer();
-            SessionImplementor implementor = initializer.getSession();
+        	final HibernateProxy proxy = (HibernateProxy) example;
+            final LazyInitializer initializer = proxy.getHibernateLazyInitializer();
+            final SharedSessionContractImplementor implementor = initializer.getSession();
 
-            if (initializer.isUninitialized())
+            if ( initializer.isUninitialized() )
             {
                 try
                 {
                     // getImplementation is going to want to talk to a session
-                    if (implementor.isClosed())
+                    if ( implementor.isClosed() )
                     {
                         // Give up and return example.getClass();
                         return example.getClass();
@@ -189,13 +189,15 @@ public Class<?> getClass(Object example)
      */
     protected Method findGetter(Object data, String property) throws IntrospectionException
     {
-        Class<?> clazz = getClass(data);
-        String key = clazz.getName() + ":" + property;
+    		final Class<?> clazz = getClass(data);
+        final String key = clazz.getName() + ":" + property;
         Method method = methods.get(key);
+        
         if (method == null)
         {
             Method newMethod = null;
-        	PropertyDescriptor[] props = Introspector.getBeanInfo(clazz).getPropertyDescriptors();
+            PropertyDescriptor[] props = Introspector.getBeanInfo(clazz).getPropertyDescriptors();
+            
             for (PropertyDescriptor prop : props)
             {
                 if (prop.getName().equalsIgnoreCase(property))
@@ -204,7 +206,9 @@ protected Method findGetter(Object data, String property) throws IntrospectionEx
                 }
             }
             method = methods.putIfAbsent(key, newMethod);
-            if (method == null) {
+            
+            if (method == null) 
+            {
                 // put succeeded, use new value
                 method = newMethod;
             }
diff --git a/src/main/java/br/com/eits/common/application/dwr/converter/OptionalConverter.java b/src/main/java/br/com/eits/common/application/dwr/converter/OptionalConverter.java
@@ -17,14 +17,29 @@
  */
 public class OptionalConverter implements Converter
 {
+	/*-------------------------------------------------------------------
+	 * 		 					ATTRIBUTES
+	 *-------------------------------------------------------------------*/
+	/**
+	 * 
+	 */
 	private ConverterManager converterManager;
 
+	/*-------------------------------------------------------------------
+	 * 		 					BEHAVIORS
+	 *-------------------------------------------------------------------*/
+	/**
+	 * 
+	 */
 	@Override
 	public void setConverterManager( ConverterManager converterManager )
 	{
 		this.converterManager = converterManager;
 	}
 
+	/**
+	 * 
+	 */
 	@Override
 	public Object convertInbound( Class<?> paramType, InboundVariable data ) throws ConversionException
 	{
@@ -33,12 +48,16 @@ public Object convertInbound( Class<?> paramType, InboundVariable data ) throws
 		return Optional.ofNullable( converterManager.convertInbound( optionalType, data, data.getContext().getCurrentProperty() ) );
 	}
 
+	/**
+	 * 
+	 */
 	@Override
 	public OutboundVariable convertOutbound( Object data, OutboundContext outctx ) throws ConversionException
 	{
 		Optional<?> optional = (Optional<?>) data;
-		return
-				optional.map( val -> converterManager.convertOutbound( val, outctx ) )
-						.orElse( new NonNestedOutboundVariable( "null" ) );
+		
+		return optional
+					.map( val -> this.converterManager.convertOutbound( val, outctx ) )
+					.orElse( new NonNestedOutboundVariable( "null" ) );
 	}
 }
diff --git a/src/main/java/br/com/eits/common/application/dwr/converter/hibernate/HibernatePropertyDescriptorProperty.java b/src/main/java/br/com/eits/common/application/dwr/converter/hibernate/HibernatePropertyDescriptorProperty.java
@@ -10,7 +10,7 @@
 import org.directwebremoting.extend.PropertyDescriptorProperty;
 import org.hibernate.Hibernate;
 import org.hibernate.Session;
-import org.hibernate.engine.spi.SessionImplementor;
+import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.proxy.HibernateProxy;
 import org.hibernate.proxy.LazyInitializer;
 
@@ -47,7 +47,7 @@ public HibernatePropertyDescriptorProperty(PropertyDescriptor descriptor)
     @Override
     public Object getValue(Object bean) throws ConversionException
     {
-        if (!(bean instanceof HibernateProxy))
+        if ( !(bean instanceof HibernateProxy) )
         {
             // This is not a hibernate dynamic proxy, just use it
             return super.getValue(bean);
@@ -56,32 +56,34 @@ public Object getValue(Object bean) throws ConversionException
         {
             // If the property is already initialized, use it
             boolean initialized = Hibernate.isPropertyInitialized(bean, descriptor.getName());
-            if (initialized)
+            
+            if ( initialized )
             {
                 // This might be a lazy-collection so we need to double check
                 Object reply = super.getValue(bean);
                 initialized = Hibernate.isInitialized(reply);
             }
 
-            if (initialized)
+            if ( initialized )
             {
                 return super.getValue(bean);
             }
             else
             {
                 // If the session bound to the property is live, use it
-                HibernateProxy proxy = (HibernateProxy) bean;
-                LazyInitializer initializer = proxy.getHibernateLazyInitializer();
-                SessionImplementor implementor = initializer.getSession();
-                if (implementor.isOpen())
+                final HibernateProxy proxy = (HibernateProxy) bean;
+                final LazyInitializer initializer = proxy.getHibernateLazyInitializer();
+                final SharedSessionContractImplementor implementor = initializer.getSession();
+                
+                if ( implementor.isOpen() )
                 {
                     return super.getValue(bean);
                 }
 
                 // So the property needs database access, and the session is closed
                 // We'll need to try get another session
-                ServletContext context = WebContextFactory.get().getServletContext();
-                Session session = HibernateSessionAjaxFilter.getCurrentSession(context);
+                final ServletContext context = WebContextFactory.get().getServletContext();
+                final Session session = HibernateSessionAjaxFilter.getCurrentSession(context);
 
                 if (session != null)
                 {
diff --git a/src/main/java/br/com/eits/common/domain/entity/AbstractEntity.java b/src/main/java/br/com/eits/common/domain/entity/AbstractEntity.java
@@ -1,7 +1,6 @@
 package br.com.eits.common.domain.entity;
 
 import java.time.LocalDateTime;
-import java.util.Calendar;
 
 import javax.persistence.Column;
 import javax.persistence.GeneratedValue;

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@`
`16`	`16`	`import org.directwebremoting.extend.PlainProperty;`
`17`	`17`	`import org.directwebremoting.extend.Property;`
`18`	`18`	`import org.hibernate.Hibernate;`
`19`		`-import org.hibernate.engine.spi.SessionImplementor;`
	`19`	`+import org.hibernate.engine.spi.SharedSessionContractImplementor;`
`20`	`20`	`import org.hibernate.proxy.HibernateProxy;`
`21`	`21`	`import org.hibernate.proxy.LazyInitializer;`
`22`	`22`
`@@ -154,16 +154,16 @@ public Class<?> getClass(Object example)`
`154`	`154`	`{`
`155`	`155`	`if (example instanceof HibernateProxy)`
`156`	`156`	`{`
`157`		`- HibernateProxy proxy = (HibernateProxy) example;`
`158`		`- LazyInitializer initializer = proxy.getHibernateLazyInitializer();`
`159`		`- SessionImplementor implementor = initializer.getSession();`
	`157`	`+ final HibernateProxy proxy = (HibernateProxy) example;`
	`158`	`+ final LazyInitializer initializer = proxy.getHibernateLazyInitializer();`
	`159`	`+ final SharedSessionContractImplementor implementor = initializer.getSession();`
`160`	`160`
`161`		`- if (initializer.isUninitialized())`
	`161`	`+ if ( initializer.isUninitialized() )`
`162`	`162`	`{`
`163`	`163`	`try`
`164`	`164`	`{`
`165`	`165`	`// getImplementation is going to want to talk to a session`
`166`		`- if (implementor.isClosed())`
	`166`	`+ if ( implementor.isClosed() )`
`167`	`167`	`{`
`168`	`168`	`// Give up and return example.getClass();`
`169`	`169`	`return example.getClass();`
`@@ -189,13 +189,15 @@ public Class<?> getClass(Object example)`
`189`	`189`	`*/`
`190`	`190`	`protected Method findGetter(Object data, String property) throws IntrospectionException`
`191`	`191`	`{`
`192`		`- Class<?> clazz = getClass(data);`
`193`		`- String key = clazz.getName() + ":" + property;`
	`192`	`+ final Class<?> clazz = getClass(data);`
	`193`	`+ final String key = clazz.getName() + ":" + property;`
`194`	`194`	`Method method = methods.get(key);`
	`195`	`+`
`195`	`196`	`if (method == null)`
`196`	`197`	`{`
`197`	`198`	`Method newMethod = null;`
`198`		`- PropertyDescriptor[] props = Introspector.getBeanInfo(clazz).getPropertyDescriptors();`
	`199`	`+ PropertyDescriptor[] props = Introspector.getBeanInfo(clazz).getPropertyDescriptors();`
	`200`	`+`
`199`	`201`	`for (PropertyDescriptor prop : props)`
`200`	`202`	`{`
`201`	`203`	`if (prop.getName().equalsIgnoreCase(property))`
`@@ -204,7 +206,9 @@ protected Method findGetter(Object data, String property) throws IntrospectionEx`
`204`	`206`	`}`
`205`	`207`	`}`
`206`	`208`	`method = methods.putIfAbsent(key, newMethod);`
`207`		`- if (method == null) {`
	`209`	`+`
	`210`	`+ if (method == null)`
	`211`	`+ {`
`208`	`212`	`// put succeeded, use new value`
`209`	`213`	`method = newMethod;`
`210`	`214`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`	`import org.directwebremoting.extend.PropertyDescriptorProperty;`
`11`	`11`	`import org.hibernate.Hibernate;`
`12`	`12`	`import org.hibernate.Session;`
`13`		`-import org.hibernate.engine.spi.SessionImplementor;`
	`13`	`+import org.hibernate.engine.spi.SharedSessionContractImplementor;`
`14`	`14`	`import org.hibernate.proxy.HibernateProxy;`
`15`	`15`	`import org.hibernate.proxy.LazyInitializer;`
`16`	`16`
`@@ -47,7 +47,7 @@ public HibernatePropertyDescriptorProperty(PropertyDescriptor descriptor)`
`47`	`47`	`@Override`
`48`	`48`	`public Object getValue(Object bean) throws ConversionException`
`49`	`49`	`{`
`50`		`- if (!(bean instanceof HibernateProxy))`
	`50`	`+ if ( !(bean instanceof HibernateProxy) )`
`51`	`51`	`{`
`52`	`52`	`// This is not a hibernate dynamic proxy, just use it`
`53`	`53`	`return super.getValue(bean);`
`@@ -56,32 +56,34 @@ public Object getValue(Object bean) throws ConversionException`
`56`	`56`	`{`
`57`	`57`	`// If the property is already initialized, use it`
`58`	`58`	`boolean initialized = Hibernate.isPropertyInitialized(bean, descriptor.getName());`
`59`		`- if (initialized)`
	`59`	`+`
	`60`	`+ if ( initialized )`
`60`	`61`	`{`
`61`	`62`	`// This might be a lazy-collection so we need to double check`
`62`	`63`	`Object reply = super.getValue(bean);`
`63`	`64`	`initialized = Hibernate.isInitialized(reply);`
`64`	`65`	`}`
`65`	`66`
`66`		`- if (initialized)`
	`67`	`+ if ( initialized )`
`67`	`68`	`{`
`68`	`69`	`return super.getValue(bean);`
`69`	`70`	`}`
`70`	`71`	`else`
`71`	`72`	`{`
`72`	`73`	`// If the session bound to the property is live, use it`
`73`		`- HibernateProxy proxy = (HibernateProxy) bean;`
`74`		`- LazyInitializer initializer = proxy.getHibernateLazyInitializer();`
`75`		`- SessionImplementor implementor = initializer.getSession();`
`76`		`- if (implementor.isOpen())`
	`74`	`+ final HibernateProxy proxy = (HibernateProxy) bean;`
	`75`	`+ final LazyInitializer initializer = proxy.getHibernateLazyInitializer();`
	`76`	`+ final SharedSessionContractImplementor implementor = initializer.getSession();`
	`77`	`+`
	`78`	`+ if ( implementor.isOpen() )`
`77`	`79`	`{`
`78`	`80`	`return super.getValue(bean);`
`79`	`81`	`}`
`80`	`82`
`81`	`83`	`// So the property needs database access, and the session is closed`
`82`	`84`	`// We'll need to try get another session`
`83`		`- ServletContext context = WebContextFactory.get().getServletContext();`
`84`		`- Session session = HibernateSessionAjaxFilter.getCurrentSession(context);`
	`85`	`+ final ServletContext context = WebContextFactory.get().getServletContext();`
	`86`	`+ final Session session = HibernateSessionAjaxFilter.getCurrentSession(context);`
`85`	`87`
`86`	`88`	`if (session != null)`
`87`	`89`	`{`