package net.javabeat.spring.audit;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;

import javax.annotation.Resource;

import org.apache.commons.beanutils.BeanMap;
import org.apache.commons.beanutils.PropertyUtilsBean;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.hibernate.SessionFactory;
import org.hibernate.metadata.ClassMetadata;
import org.infinispan.commons.api.BasicCache;
import org.springframework.aop.framework.Advised;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;

import net.javabeat.spring.cache.LocalCacheManager;
import net.javabeat.spring.model.AuditTable;
import net.javabeat.spring.service.AuditFlowService;
import net.javabeat.spring.service.AuditTableService;
import net.javabeat.spring.util.JsonUtils;

@Aspect
@Component("auditTrailAspect")
@Configurable
@EnableAspectJAutoProxy
public class AuditTrailAspect {
	
	@Autowired
	private AuditTableService auditTableService;
	
	@Resource
    private SessionFactory sessionFactory;
	
	@Autowired private AuditFlowService auditFlowService;
	
	
	private static BasicCache<Object, Object> caches = LocalCacheManager.getCache();
	
	@Before("execution(public * net.javabeat.spring.dao..*.genericUpdate(..)) && args(bean)")
	public void traceBeforeUpdate(JoinPoint joinPoint, Object bean) {
		try {
			Advised advised = (Advised) joinPoint.getThis();
		    Class<?> cls = advised.getTargetSource().getTargetClass();
		    ClassMetadata metadata = sessionFactory.getClassMetadata(bean.getClass());
			String entityPrimaryKey = metadata.getIdentifierPropertyName();
			JsonUtils utils = new JsonUtils();
			int typeid = Integer.parseInt(utils.getProperty(bean, entityPrimaryKey)) ;

			Object service  = advised.getTargetSource().getTarget();
			Method findMethod = cls.getSuperclass().getMethod("genericGetById", new Class[] {int.class});

	        Object oldValue = findMethod.invoke(service, typeid);
	        
	        String key = bean.toString() + typeid;
	        caches.put(key, oldValue);
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
      
	}
	
	
	@AfterReturning("execution(public * net.javabeat.spring.dao..*.genericUpdate(..)) && args(bean)")
	public void traceAfterUpdate(JoinPoint joinPoint, Object bean) {
		String key = null;
		try {
			Advised advised = (Advised) joinPoint.getThis();
		    Class<?> cls = advised.getTargetSource().getTargetClass();
		    
		    JsonUtils utils = new JsonUtils();
		    ClassMetadata metadata = sessionFactory.getClassMetadata(bean.getClass());
		    String entityPrimaryKey = metadata.getIdentifierPropertyName();
			int typeid = Integer.parseInt(utils.getProperty(bean,entityPrimaryKey)) ;
		    key = bean.toString() +  typeid;
		    Object oldValue =  (caches.get(key) == null ? null : caches.get(key));
		    
		    ObjectMapper mapper = new ObjectMapper();
			ChangeSetRecord changeSetRecord = new ChangeSetRecord ();
			changeSetRecord =  compareObjects(oldValue, bean);
			
			if (changeSetRecord != null){
				AuditTable auditRecord = new AuditTable();
				auditRecord.setEntityname(bean.getClass().getSimpleName());
				auditRecord.setAction("Update");
				auditRecord.setChangeset(mapper.writeValueAsString( changeSetRecord ) );
				auditTableService.createAudit(auditRecord);
			}
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	private class ChangeSetRecord extends HashMap<String, List<String>> {
        public void put(String key,String index) {
            List<String> current = get(key);
            if (current == null) {
                current = new ArrayList<String>();
                super.put(key, current);
            }
            current.add(index);
        }
    }
	
	public ChangeSetRecord compareObjects(Object oldObject, Object newObject) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        BeanMap map = new BeanMap(oldObject);
        PropertyUtilsBean propUtils = new PropertyUtilsBean();
        ChangeSetRecord changeSetRecord = new ChangeSetRecord();
        
        for (Object propNameObject : map.keySet()) {
            String propertyName = (String) propNameObject;
            Object property1 = propUtils.getProperty(oldObject, propertyName);
            Object property2 = propUtils.getProperty(newObject, propertyName);
            if (property1.equals(property2)) {
                System.out.println("  " + propertyName + " is equal");
            } else {
                System.out.println("> " + propertyName + " is different (oldValue=\"" + property1 + "\", newValue=\"" + property2 + "\")");
                
                
                changeSetRecord.put(propertyName, (property1 == null ? "" : property1.toString()));
                changeSetRecord.put(propertyName, (property2 == null ? "" : property2.toString()));
            }
        }
        return changeSetRecord;
    }

}

Audit Trail

Spring AOP Audit Trail

Java