/**
    * Copyright By Grandsoft Company Limited.  
    * 2012-2-16 下午03:34:12
    */
   package gboat2.base.core.web;
   
   import gboat2.base.bridge.util.ClassHelper;
   import gboat2.base.core.GBoatClassLoader;
   import gboat2.base.core.annotation.DateFormat;
  import gboat2.base.core.dao.Page;
  import gboat2.base.core.dao.PageBean;
  import gboat2.base.core.model.Opera;
  import gboat2.base.core.service.IBaseService;
  import gboat2.base.core.service.IOperationProvider;
  import gboat2.base.core.service.ModuleService;
  import gboat2.base.core.util.ActionUtil;
  import gboat2.base.core.util.EnumTypeUtils;
  import gboat2.base.core.util.EnumTypeWrapper;
  import gboat2.base.core.util.JsonConfigUtil;
  import gboat2.base.core.util.JsonUtil;
  import gboat2.base.core.util.json.GboatJsonDateValueProcessor;
  import gboat2.base.core.validate.PrivilegeCheckServiceFactory;
  import gboat2.base.core.web.md.MetadataSupport;
  
  import java.beans.PropertyDescriptor;
  import java.lang.reflect.Field;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.text.SimpleDateFormat;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  
  import javax.persistence.Enumerated;
  
  import net.sf.json.JSONArray;
  import net.sf.json.JSONObject;
  import net.sf.json.JsonConfig;
  
  import org.apache.commons.beanutils.PropertyUtils;
  import org.apache.commons.collections.CollectionUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.osgi.framework.Bundle;
  import org.osgi.framework.BundleContext;
  import org.osgi.framework.FrameworkUtil;
  import org.osgi.framework.ServiceReference;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.util.Assert;
  import org.springframework.util.ReflectionUtils;
  
  import com.opensymphony.xwork2.ActionSupport;
  
  /**
   * 
   * 视图定义元数据处理类，根据定义元数据处理成符合前后台交互的元数据要求
   * @author lysming
   * @since jdk1.6
   * @date 2012-2-16
   *  
   */
  
  public abstract class MetadataSupportStrategy {
  	protected final static String FILTER_PARAMS = "filter_params_";
  	protected final static String DEFINED_OPERATIONS = "defined_operations_";
  	
  	//获得logger
  	protected static Logger logger = LoggerFactory.getLogger(MetadataSupportStrategy.class);
  
  	//缓存类所对应的枚举类，在内存中缓存,由于是共享变量，因此此属性非线程不安全：enumsInClass
  	static Map<Class<?>, List<Class<?>>> enumsInClass = new HashMap<Class<?>, List<Class<?>>>();
  
  	/**抽象方法：可以不同的需求实现不同策略
  	 * @param metadataType
  	 * @param invokeMethod
  	 * @param action
  	 * @return
  	 */
  	abstract Object getMetadata(String metadataType, String invokeMethod, BaseActionSupport action);
  
  	/**
  	 * 
  	 * 通过全部元数据json对象获取当前请求组件名称定义
  	 * @author zhaoxc
  	 * @since jdk1.6
  	 * @date 2012-5-23
  	 *  
  	 */
  	public JSONObject getMetadataFromResource(String invokeMethod, BaseActionSupport action) {
  		JSONObject jObj = MetadataSupport.parseMetadata(invokeMethod, action);
  		if (jObj == null) {
  			jObj = new JSONObject();
  			jObj.accumulate("success", false);
  			jObj.accumulate("message", "failed to read metadata for " + action.getClass().getName());
  		}
 
 		return jObj;
 	}
 
 	/**
 	 * 
 	 * 通过全部元数据json对象获取当前请求组件内容定义
 	 * @author zhaoxc
 	 * @since jdk1.6
 	 * @date 2012-5-23
 	 * @update by zhangxj-a 
 	 */
 	public JSONObject decorateMetadata(JSONObject returned, String invokeMethod, BaseActionSupport action) {
 		SplitMetadataStrategy splitMetadataStrategy;
 		if (ActionUtil.isListPage(invokeMethod, action)) {//列表页面
 			splitMetadataStrategy = MetadataList.getInstance();
 		} else if (ActionUtil.isFormPage(invokeMethod, action)) {//表单页面
 			splitMetadataStrategy = MetadataEdit.getInstance();
 		} else {//其他页面
 			splitMetadataStrategy = MetadataOthers.getInstance();
 		}
 		return splitMetadataStrategy.decorateMetadata(returned, invokeMethod, action);
 	}
 
 	/**
 	 * 
 	 * 通过全部元数据json对象获取当前请求组件数据定义
 	 * @param calledInvokeMethod invokedMethod是否已经调用过
 	 * @param metadata 元数据对象
 	 * @param invokeMethod	调用方法名
 	 * @param action action实例
 	 * @param returned 返回的json对象
 	 * @author zhaoxc
 	 * @since jdk1.6
 	 * @date 2012-5-23
 	 *  
 	 */
 	public JSONObject decorateWithData(boolean calledInvokeMethod, JSONObject metadata, String invokeMethod, BaseActionSupport action,
 			JSONObject returned) {
 		JsonConfig jsonConf;
 		Class<?> checkClazz;
 		//列表页面，init和post方法需要特殊处理
 		if (ActionUtil.isListPage(invokeMethod, action)) {
 			Bundle bundle = FrameworkUtil.getBundle(action.getClass());
 			
 			//首先获取所有可能的操作
 			List<Opera> operaList;
 			//TODO 修改为Declare Service模式
 			BundleContext context = bundle.getBundleContext();
 			ServiceReference<?> sf = context.getServiceReference(IOperationProvider.class);
             if (sf != null) {
                 // 获取到对应模块下的所有操作
                 IOperationProvider provider = (IOperationProvider) context.getService(sf);
                 List<Opera> moduleOperaList = provider.getOperations(action);
                 // 在 JSP 页面中定义的操作（逗号分隔）
                 String definedOperationsStr = action.request.getParameter(DEFINED_OPERATIONS);
                 
                 if(StringUtils.isBlank(definedOperationsStr) || CollectionUtils.isEmpty(moduleOperaList)) {
 //                    operaList = new ArrayList<Opera>();
                     operaList = moduleOperaList;
                 } else {
                     String[] definedOperations = StringUtils.split(definedOperationsStr, ',');
                     operaList = new ArrayList<Opera>(definedOperations.length);
                     // 根据 JSP 页面中定义的操作与模板下的所有操作逐一进行比对（为了保证按钮的显示顺序与定义顺序一致，所以先对 definedOperations 进行迭代）
                     for (String code : definedOperations) {
                         for (Opera opera : moduleOperaList) {
                             if(StringUtils.equals(StringUtils.trim(code), StringUtils.trim(opera.getCode()))) {
                                 operaList.add(opera);
                                 break;
                             }
                         }
                     }
                 }
             } else {
                 operaList = ModuleService.getOperaForMetadata(bundle.getSymbolicName(), action.getClass().getName());
             }
             
 			jsonConf = JsonConfigUtil.getJsonConfig(EnumTypeUtils.getEnumClassInDomain(action.getDomainClassAnnotationedForList()));
 			if (!calledInvokeMethod) {
 				try {
 					Method method = ReflectionUtils.findMethod(action.getClass(), invokeMethod);
 					if (method != null) {
 						ReflectionUtils.makeAccessible(method);
 						method.invoke(action, new Object[] {});
 					} else {
 						action.executeListQuery(action.getListParameterMap());
 					}
 				} catch (Exception e) {
 					throw new MetadataException(e);
 				}
 			}
 			Page<?> page = action.getPage();
 
 			//call postXXXX方法
 			String postMethodName = ActionUtil.getPostMethodName(invokeMethod);
 			//postList在BaseActionSupport的list方法中默认调用，该处不需要重复调用
 			if (!postMethodName.equals("postList")) {
 				try {
 					Method postListMethod = ReflectionUtils.findMethod(action.getClass(), postMethodName, new Class[] { Page.class });
 					if (null != postListMethod) {
 						ReflectionUtils.makeAccessible(postListMethod);
 						postListMethod.invoke(action, page);
 					}
 				} catch (Exception e) {
 					throw new MetadataException(e);
 				}
 			}
 
 			List<?> items = page.getResult();
 			JSONArray jsonObjs = new JSONArray();
 			List<Opera> priviArray = getOperationByPriviledge(operaList, action);
 			for (Object item : items) {
 				JSONObject finalObj = null;
 				if(StringUtils.isNotEmpty(action.request.getParameter(FILTER_PARAMS))){
 					//根据页面传递的过滤参数定义过滤数据
 					finalObj = filterDataByParam(item, action);
 				}else{
 					//根据元文件过滤数据
 					finalObj = filterDataByMetadata(metadata, item, action);
 				}
 				if(finalObj != null){
 					//将操作添加给每条数据，并提前进行权限过滤
 					finalObj.accumulate("operations", getOperationByData(priviArray, action, item));
 					jsonObjs.add(finalObj);
 				}
 			}
 			
             returned.accumulate("success", true);
 			returned.accumulate("data", jsonObjs);       // 实际数据的数组
 			PageBean pb = page.getPageBean();
 			returned.accumulate("results", pb.getCount());
 			returned.accumulate("total", pb.getPages()); // 总页数
 			returned.accumulate("page", pb.getPage());   // 当前页的页码
 		} else {
 			jsonConf = JsonConfigUtil.getJsonConfig(EnumTypeUtils.getEnumClassInDomain(action.getDomainClassAnnotationed()));
 			checkClazz = action.getClass();
 			Method ajaxMethod, initMethod;
 			ajaxMethod = ReflectionUtils.findMethod(checkClazz, invokeMethod);
 			initMethod = ReflectionUtils.findMethod(checkClazz, ActionUtil.getInitMethodName(invokeMethod));
 			if (ajaxMethod == null && initMethod == null) {
 				returned.accumulate("success", false);
 				returned.accumulate("message", "can't get method[" + invokeMethod + "] for " + action.getClass().getName());
 			} else {
 				try {
 					if (!calledInvokeMethod && ajaxMethod != null) {
 						ReflectionUtils.makeAccessible(ajaxMethod);
 						ajaxMethod.invoke(action);
 					}
 					returned.accumulate("success", true);
 					/** 如果不是backfill回填数据则不传回data** start*/
 					boolean isAddData = true;
 					JSONObject jso = (JSONObject) metadata.get("cfg");
 					if (jso != null && !"request".equals(jso.get("backfill"))) {
 						isAddData = false;
 					}
 					if (isAddData) {
 						Map<String, Object> models = new HashMap<String, Object>();
 						List<Object> result = new ArrayList<Object>();
 						addGetDataToModels(action, action.getClass(), models);
 						result.add(models);
 						returned.accumulate("data", result.toArray(), jsonConf);
 					}
 					/**如果不是backfill回填数据则不传回data** end */
 
 				} catch (InvocationTargetException e) {
 					logger.warn("error in get data", e);
 					returned.accumulate("success", false);
 					Throwable throwable = e.getTargetException();
 					String message = null;
 					if (throwable != null) {
 						message = throwable.getMessage();
 					}
 					returned.accumulate("message", "error: " + message);
 				} catch (Exception e) {
 					logger.warn("error in get data", e);
 					returned.accumulate("success", false);
 					returned.accumulate("message", "error while get data : " + e.getMessage());
 				}
 			}
 		}
 		return returned;
 	}
 
 	/**
 	 * 根据请求传回的过滤参数过滤数据中不需要的数据，减少数据传输压力，为jsp页面的list数据请求服务
 	 * 传递的参数名称为_filter_params,值为逗号分隔
 	 * @param data
 	 * @param action
 	 * @return JSONObject对象
 	 */
 	private JSONObject filterDataByParam(Object data, BaseActionSupport action){
 		String filterParams = action.request.getParameter(FILTER_PARAMS);
 		String[] params = filterParams.split(",");
 		List<String> toCompare = Arrays.asList(params);
 		
 		JsonConfig jsonConf = JsonConfigUtil.getJsonConfig(EnumTypeUtils.getEnumClassInDomain(action.getDomainClassAnnotationedForList()));
 		
 		return filter(data, toCompare, action, jsonConf);
 	}
 	
 	/**
 	 * 根据模板JSONObject，过滤数据中不需要的数据，这样可以减少网络压力 for list
 	 * @param metadata 模板JSONObject
 	 * @param data 数据object
 	 * @return JSONObject对象
 	 */
 	private JSONObject filterDataByMetadata(JSONObject metadata, Object data, BaseActionSupport action) {
 		//对列表中的枚举类型进行转换，变为json对象的形式
 		JsonConfig jsonConf = JsonConfigUtil.getJsonConfig(EnumTypeUtils.getEnumClassInDomain(action.getDomainClassAnnotationedForList()));
 		JSONObject returnJSONObj = new JSONObject();
 		List<String> toCompare = new LinkedList<String>();
 		if (null != metadata) {
 			//TODO 该部分可以按照md进行缓存
 			JSONArray headers = (JSONArray) metadata.get("headers");
 			if (null != headers) {
 				Iterator<?> headerItera = headers.iterator();
 				//可优化减少循环次数
 				while (headerItera.hasNext()) {
 					JSONObject tempObj = (JSONObject) headerItera.next();
 					//则设置日期字段该格式为自定义的格式
 					String dateFormat = (String) tempObj.get("dateFormat");
 					if (!StringUtils.isEmpty(dateFormat)) {
 						jsonConf.registerJsonValueProcessor((String) tempObj.get("dataIndex"), new GboatJsonDateValueProcessor(dateFormat));
 					}
 				}
 				String dataIndexObj;
 				Iterator<?> hIt = headers.iterator();
 				while (hIt.hasNext()) {
 					JSONObject tempObj = (JSONObject) hIt.next();
 					dataIndexObj = (String) tempObj.get("dataIndex");
 					if (!StringUtils.isEmpty(dataIndexObj) && !toCompare.contains(dataIndexObj)) {
 						toCompare.add(dataIndexObj);
 					}
 				}
 			}
 			
 			returnJSONObj = filter(data, toCompare, action, jsonConf);
 		}
 		return returnJSONObj;
 	}
 	
 	private JSONObject filter(Object data,List<String> toCompare,BaseActionSupport action,JsonConfig jsonConf){
 		JSONObject returnJSONObj = new JSONObject();
 		if(toCompare!=null && toCompare.size()>0){
 			//解析数据成json
 			JSONObject dataObj = JSONObject.fromObject(data, jsonConf);
 			JSONObject translatedObj;
 			Object value;
 			String dataIndexObj;
 			Iterator<?> hIt = toCompare.iterator();
 			while (hIt.hasNext()) {
 				dataIndexObj = (String) hIt.next();
 				if (!StringUtils.isEmpty(dataIndexObj)) {
 					value = dataObj.get(dataIndexObj);
 					if(value!=null){
 						translatedObj = JsonUtil.translateJSONOjbject(dataIndexObj, dataObj);
 						returnJSONObj.accumulate(dataIndexObj, translatedObj.get(dataIndexObj));
 					}
 				}
 			}
 		}else{
 			returnJSONObj = JSONObject.fromObject(data, jsonConf);
 		}
 		
 		return returnJSONObj;
 	}
 
 	private void addGetDataToModels(BaseActionSupport action, Class<?> actionClass, Map<String, Object> models) {
 		getActionPropertiesValues(action, models, Boolean.FALSE);
 	}
 
 	/**
 	 * 获取list中每条数据应该具有的操作
 	 * @param opera opera
 	 * @param action 当前action
 	 * @param data 被转换对象
 	 * @return JSONArray数据
 	 */
 	private JSONArray getOperationByData(List<Opera> priviArray, BaseActionSupport action, Object data) {
 		//1、获取数据操作判断方法
 		Method getOperMethod = ReflectionUtils.findMethod(action.getClass(), "operationCheck", new Class[] { data.getClass(), String.class });
 		if (getOperMethod == null) {
 			getOperMethod = ReflectionUtils.findMethod(action.getClass(), "operationCheck", new Class[] { Object.class, String.class });
 		}
 
 		Iterator<Opera> it = priviArray.iterator();
 		List<String> operList = new ArrayList<String>();
 		Opera opera;
 		while (it.hasNext()) {
 			opera = (Opera) it.next();
 			String operCode = opera.getCode();
 			if ("sumbit".equals(operCode) || "add".equals(operCode)) {
 				continue;
 			}
 			if (!StringUtils.isEmpty(operCode)) {
 
 				//2、执行数据操作判断方法（根据数据状态决定是否有某个操作）
 				boolean dataOperation = false;
 				if (null != getOperMethod) {
 					dataOperation = (Boolean) ReflectionUtils.invokeMethod(getOperMethod, action, new Object[] { data, operCode });
 				}
 				//只有list中的该条数据允许，才可以添加该操作
 				if (dataOperation) {
 					operList.add(operCode);
 				}
 			}
 		}
 
 		JSONArray returnJSONObj = JSONArray.fromObject(operList);
 		return returnJSONObj;
 	}
 
 	/**
 	 * 调用initXXXXX方法
 	 * @param invokeMethod
 	 * @param action
 	 * @return
 	 */
 	protected boolean callInitInvokedMethod(String invokeMethod, BaseActionSupport action) {
 	    Assert.hasText(invokeMethod, "被调用的方法不能为空！");
 	    
 		// 调用实际方法时会再次调用 init 方法
 		if ("edit".equals(invokeMethod) || "view".equals(invokeMethod) || "list".equals(invokeMethod)) {
 			// 如果子类覆盖了edit、view或list方法，依然执行initXXXX方法，否则不执行（BaseActionSupport中会显式调用）
 			try {
 				Method method = action.getClass().getDeclaredMethod(invokeMethod, new Class[] {});
 				if (method == null) {
 					return false;
 				}
 			} catch (Exception ignore) {
 				//ignore the exception
 				return false;
 			}
 		}
 	
 		String initMethodName = ActionUtil.getInitMethodName(invokeMethod);
 		try {
 			Method initMethod;
             if (ActionUtil.isListPage(invokeMethod, action)) { // 列表查询的 initXxx() 方法有一个 Map 类型的参数
                 // 检查是否存在带Map参数的init方法
                 initMethod = ReflectionUtils.findMethod(action.getClass(), initMethodName, new Class[] { Map.class });
                 if (initMethod != null) {
                     ReflectionUtils.makeAccessible(initMethod);
                     initMethod.invoke(action, action.getListParameterMap());
                     return true;
                 }
             } else { // 非列表查询的 initXxx() 方法没有参数
                 initMethod = ReflectionUtils.findMethod(action.getClass(), initMethodName);
                 if (null != initMethod) {
                     ReflectionUtils.makeAccessible(initMethod);
                     ReflectionUtils.invokeMethod(initMethod, action);
                     return true;
                 }
             }
 		} catch (SecurityException e) {
 			e.printStackTrace();
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 		return false;
 	}
 	
 	/**
 	 * 获取action中所有属性
 	 * @param action
 	 * @return
 	 */
 	public Map<String, Object> getActionParam(BaseActionSupport action) {
 		Map<String, Object> params = new HashMap<String, Object>();
 		//获取action中定义的属性
 		params = getActionPropertiesValues(action, params, Boolean.TRUE);
 
 		//检查Domain中的enum,将enum自动添加到context中 
 		List<Class<?>> toWrapper = new LinkedList<Class<?>>();
 
 		try {
 			if (action.getDomainClassAnnotationed() != null) {
 				toWrapper.add(action.getDomainClassAnnotationed());
 			}
 		} catch (Exception ignore) {
 			//ignore
 		}
 		try {
 			Class<?> listDomainClass = action.getDomainClassAnnotationedForList();
 			while (listDomainClass != null && listDomainClass != Object.class) {
 				if (!toWrapper.contains(listDomainClass)) {
 					toWrapper.add(listDomainClass);
 				}
 				listDomainClass = listDomainClass.getSuperclass();
 			}
 			params.putAll(getEnumWrappers(toWrapper));
 		} catch (Exception ignore) {
 			//ignore
 		}
 
 		//注册一些特殊的枚举类
 		EnumTypeUtils.registerEnumClass(action, params);
 
 		return params;
 	}
 
 	/**
 	 * @param action
 	 * @param actionPropertiesValues
 	 * @param isVelocityFill :是否借助velocity填充数据，true:velocity填充；false:前台自己填充
 	 * @return
 	 */
 	public Map<String, Object> getActionPropertiesValues(BaseActionSupport action, Map<String, Object> actionPropertiesValues, boolean isVelocityFill) {
 		//private与getter同时存在才添加为action param 注意:此方法和addGetDataToModels很多重复代码，待重构
 		PropertyDescriptor[] propertyDescriptors = PropertyUtils.getPropertyDescriptors(action);
 		List<PropertyDescriptor> asList = Arrays.asList(propertyDescriptors);
 
 		Map<String, Method> readMethodMap = new HashMap<String, Method>();
 
 		for (Iterator<PropertyDescriptor> iterator = asList.iterator(); iterator.hasNext();) {
 			PropertyDescriptor propertyDescriptor = (PropertyDescriptor) iterator.next();
 			String name = propertyDescriptor.getName();
 
 			//priCheckParams 这个属性里含有response
 			if (name.equals("priCheckParams")) {
 				continue;
 			}
 
 			Method readMethod = propertyDescriptor.getReadMethod();
 			if (readMethod != null) {
 				readMethodMap.put(name, readMethod);
 			}
 		}
 
 		Object value;
 		for (Class<?> clazz = action.getClass(); clazz != ActionSupport.class; clazz = clazz.getSuperclass()) {
 
 			Field[] declaredFields = clazz.getDeclaredFields();
 			for (int i = 0; i < declaredFields.length; i++) {
 				String name = declaredFields[i].getName();
 				Method readMethod = readMethodMap.get(name);
 				if (readMethod == null)
 					continue;
 				try {
 					value = readMethod.invoke(action, new Object[] {});
 
 					if (name.equals("model")) {
 						name = "_M";
 					}
 
 					//空值和service类忽略
 					if (value != null && !(value instanceof IBaseService)) {
 						actionPropertiesValues.put(name, value);
 						if (needToDealAsObject(value.getClass()) && !isVelocityFill) {
 							//java.lang、java.util等基本类型
 							parseGetterOfObject(value, actionPropertiesValues, name + ".");
 						}
 					}
 
 				} catch (Exception e) {
 				}
 			}
 
 		}
 
 		return actionPropertiesValues;
 	}
 
 	private Map<String, Object> getEnumWrappers(List<Class<?>> classes) {
 		Map<String, Object> wrappers = new HashMap<String, Object>();
 		for (Class<?> domainClass : classes) {
 			if (domainClass != null) {
 				List<Class<?>> clazzes;
 				if (enumsInClass.containsKey(domainClass)) {
 					clazzes = enumsInClass.get(domainClass);
 				} else {
 					clazzes = EnumTypeUtils.getEnumClassInDomain(domainClass);
 					enumsInClass.put(domainClass, clazzes);
 				}
 				EnumTypeWrapper wrapper;
 				for (Class<?> enumClass : clazzes) {
 					//名称支持两种方式:类名称和带包名全路径（使用'-'替代'.'）
 					wrapper = new EnumTypeWrapper(enumClass);
 					wrappers.put(enumClass.getName().replaceAll("\\.", "-"), wrapper);
 					wrappers.put(ClassHelper.getNameWithoutPackage(enumClass), wrapper);
 				}
 			}
 		}
 		return wrappers;
 	}
 
 	private boolean needToDealAsObject(Class<?> clazz) {
 		Package pack = clazz.getPackage();
 		return !(clazz.isPrimitive() || (pack != null && pack.getName().startsWith("java.lang"))
 				|| (pack != null && pack.getName().startsWith("java.util")) || (pack != null && pack.getName().startsWith("java.math")) || (pack != null && pack
 				.getName().startsWith("java.sql")));
 	}
 
 	private void parseGetterOfObject(Object obj, Map<String, Object> models, String prefix) {
 		Method[] ms = obj.getClass().getMethods();
 		String name;
 		Object attObj;
 		for (Method m : ms) {
 			if (m.getName().startsWith("get") && m.getName().length() > 3) {
 				name = String.valueOf(m.getName().charAt(3)).toLowerCase() + m.getName().substring(4);
 				try {
 					if (ReflectionUtils.findField(obj.getClass(), name) != null) {
 						attObj = m.invoke(obj, new Object[] {});
 						if (attObj != null) {
 							//date
 							if (attObj instanceof java.util.Date && m.isAnnotationPresent(DateFormat.class)) {
 								DateFormat pattern = m.getAnnotation(DateFormat.class);
 								SimpleDateFormat format = new SimpleDateFormat(pattern.value());
 								models.put(prefix + name, format.format(attObj));
 							} else if (m.isAnnotationPresent(Enumerated.class)) {
 								Enumerated enumAnno = m.getAnnotation(Enumerated.class);
 								if (enumAnno.value() == javax.persistence.EnumType.STRING) {
 									models.put(prefix + name, ((Enum<?>) attObj).name());
 								} else if (enumAnno.value() == javax.persistence.EnumType.ORDINAL) {
 									models.put(prefix + name, ((Enum<?>) attObj).ordinal());
 								}
 							} else {
 								if (!needToDealAsObject(attObj.getClass())) {
 									models.put(prefix + name, attObj);
 								} else {
 									parseGetterOfObject(attObj, models, prefix + name + ".");
 								}
 							}
 						}
 					}
 				} catch (SecurityException e) {
 					e.printStackTrace();
 				} catch (IllegalArgumentException e) {
 					e.printStackTrace();
 				} catch (IllegalAccessException e) {
 					e.printStackTrace();
 				} catch (InvocationTargetException e) {
 					e.printStackTrace();
 				}
 			}
 		}
 	}
 
 	private List<Opera> getOperationByPriviledge(List<Opera> operas, BaseActionSupport action) {
 		Iterator<Opera> it = operas.iterator();
 		List<Opera> operList = new LinkedList<Opera>();
 		Bundle bd = GBoatClassLoader.getInstance().getBundle(action.getClass().getPackage().getName());
 		Opera opera;
 		while (it.hasNext()) {
 			opera = it.next();
 			String operCode = opera.getCode();
 			if (!StringUtils.isEmpty(operCode)) {
                 Map<Object, Object> params = action.getPriCheckParams();
 				params.put("ACTION_NAME", action.getClass().getName());
 				params.put("METHOD_NAME", StringUtils.defaultIfBlank(opera.getInvokeMethod(), opera.getCode()));
 				params.put("REQUEST", action.request);
 				boolean priCheckResult = PrivilegeCheckServiceFactory.operationCheckServiceByMethodName(params, bd);
 				//只有权限允许添加该操作
 				if (priCheckResult) {
 					operList.add(opera);
 				}
 			}
 		}
 
 		return operList;
 	}
 }