rightdelegate.java

Java开发的权限管理的例子

package org.artemis.right;

import java.util.ArrayList;
import java.util.List;
import org.artemis.right.common.ErrorCode;
import org.artemis.right.common.ServiceConsts;
import org.artemis.right.model.Function;
import org.artemis.right.model.Permission;
import org.artemis.right.model.Role;
import org.artemis.right.model.User;
import org.artemis.right.model.UserRole;
import com.gsta.eshore.framework.daoutil.CriteriaQuery;
import com.gsta.eshore.framework.daoutil.PageSupport;
import com.gsta.eshore.framework.exeception.ClientException;
import com.gsta.eshore.framework.facade.AbstractBizDelegate;
import com.gsta.eshore.framework.facade.DelegateUtil;
import com.gsta.eshore.framework.jcf.IState;
import com.gsta.eshore.framework.jcf.JCFException;
import com.gsta.eshore.framework.jcf.Request;
import com.gsta.eshore.framework.jcf.Response;
import com.gsta.eshore.framework.util.AppUtils;
import com.gsta.eshore.framework.daoutil.HqlQuery;

public class RightDelegate extends AbstractBizDelegate implements RightDelegateIF {
	
	public RightDelegate() {
	}

	public boolean findWorkflow(IState state) {
		Request req = new Request();
		req.setServiceName("RunByResultProcessor");
		try {
			Response resp = getDelegate().execute(req);
			DelegateUtil.setIState(state, resp);
			return true;
		} catch (Exception e) {
			DelegateUtil.handleException(e, "workflow", state);
		}
		return false;
	}

	/**
	 * 从数据库中查找该角色Role所拥有的Function
	 */
	public Role findgrantedAuthorityFromDataBase(String authority, IState state) {
		try {
			return (Role)getDelegate().execute("authority", authority, 
					ServiceConsts.FindgrantedAuthorityFromDataBaseProcessor, "resultObject", state);
		} catch (Exception e) {
			DelegateUtil.handleException(e, "findgrantedAuthorityFromDataBase", state);
			return null;
		}
	}
	/**
	 * 从数据库中查找名为protectFunction的Function以及拥有这个function的角色
	 */
	public Function findFunctionFromDataBase(String protectfunction,
			IState state) {
		try {
			return (Function)getDelegate().execute("protectfunction", protectfunction, 
					ServiceConsts.FindFunctionFromDataBaseProcessor, "resultObject", state);
		} catch (Exception e) {
			DelegateUtil.handleException(e, "findFunctionFromDataBase", state);
			return null;
		}
	}
	
	public List findRoleByFunction(String functionId, IState state){
		
		try {
			return (List)getDelegate().execute("functionId", functionId, 
					ServiceConsts.FindRoleByFunctionProcessor, "roles", state);
		} catch (Exception e) {
			throw new ClientException(e,"findRoleByFunction error");
		}
	}
	
	public List findRoleByUser(String userId, IState state){
		try {
			return (List)getDelegate().execute("userId", userId, 
					ServiceConsts.FindRoleByUserProcessor, "roles", state);
		} catch (Exception e) {
			DelegateUtil.handleException(e, "findRoleByUser", state);
			return null;
		}
	}
	
	/**
	 * 从数据库中查找该用户User以及所拥有的role
	 */
	public User findUserByNameFromDataBase(String name, IState state) {	
		try {
			return (User)getDelegate().execute("name", name, 
					ServiceConsts.FindUserByNameFromDataBaseProcessor, "resultObject", state);
		} catch (Exception e) {
			DelegateUtil.handleException(e, "findUserByNameFromDataBase", state);
			return null;
		}
	}
	
	public String saveFunction(Function function, IState state) {
		try {
			return (String)getDelegate().execute("function", function, 
					ServiceConsts.SaveFunctionProcessor, "id", state);
		} catch (Exception e) {
			throw new ClientException(e,"findUserByNameFromDataBase error");
		}
		
	}

	public boolean saveFunctionToRole(Permission permission, IState state) {
		try {
			getDelegate().execute("permission", permission, 
					ServiceConsts.SaveFunctionToRoleProcessor, "id", state);
			return true;
		} catch (Exception e) {
			throw new ClientException(e,"saveFunctionToRole error");
		}
	}
	

	public void saveFunctionsToRole(List permissions, IState state) {
		if (DelegateUtil.isNullParam(permissions, "permissions", state)) {
			return;
		}
		Request req = new Request();
		req.setServiceName(ServiceConsts.SaveFunctionsToRoleProcessor);
		req.setValue("permissions", permissions);
		try {
			Response resp = getDelegate().execute(req);
			DelegateUtil.setIState(state, resp);
		} catch (Exception e) {
			DelegateUtil.handleException(e, "saveFunctionsToRole", state);
		}
	}

	public void updateFunction(Function function, IState state) {
		if (DelegateUtil.isNullParam(function, "function", state)) {
			return;
		}
		Request req = new Request();
		req.setServiceName(ServiceConsts.UpdateFunctionProcessor);
		req.setValue("function", function);
		try {
			Response resp = getDelegate().execute(req);
			DelegateUtil.setIState(state, resp);
		} catch (Exception e) {
			DelegateUtil.handleException(e, "updateFunction", state);
		}
	}

	public boolean isUserExist(String name, IState state) {
		if (DelegateUtil.isNullParam(name, "name", state)) {
			return false;
		}
		Request req = new Request();
		req.setServiceName(ServiceConsts.IsUserExistProcessor);
		req.setValue("name", name);

		try {
			Response resp = getDelegate().execute(req);
			DelegateUtil.setIState(state, resp);
			return ((Boolean) resp.getValue("resultBoolean")).booleanValue();
		} catch (Exception e) {
			DelegateUtil.handleException(e, "isUserExist", state);
			return false;
		}
	}


	public String saveUser(User user, IState state) {
		try {
			return (String)getDelegate().execute("user", user, 
					ServiceConsts.SaveUserProcessor,"result", state);
		} catch (Exception e) {
			DelegateUtil.handleException(e, "saveUser", state);
			return null;
		}
		
	}

	public PageSupport findAllUser(CriteriaQuery cq, IState state) {
		if (DelegateUtil.isNullParam(cq, "CriteriaQuery", state)) {
			return null;
		}
		Request req = new Request();
		req.setServiceName(ServiceConsts.FindAllUserProcessor);
		req.setValue("CriteriaQuery", cq);
		try {
			Response resp = getDelegate().execute(req);
			DelegateUtil.setIState(state, resp);
			return (PageSupport) (resp.getValue("PageSupport"));
		} catch (Exception e) {
			DelegateUtil.handleException(e, "findAllUser", state);
			throw new ClientException(e,"findAllUser error");
		}
		
	}
	/**
	 * 根据FunctionId删除功能点，同时删除function和role的对应关系 deletePermissionByFunctionId
	 */
	public boolean deleteFunctionById(String functionId, IState state) {
		if (DelegateUtil.isNullParam(functionId, "functionId", state)) {
			return false;
		}
		Request req = new Request();
		req.setServiceName(ServiceConsts.DeleteFunctionByIdProcessor);
		req.setValue("functionId", functionId);
		try {
			Response resp = getDelegate().execute(req);
			DelegateUtil.setIState(state, resp);
			return ((Boolean) resp.getValue("resultBoolean")).booleanValue();
		} catch (Exception e) {
			DelegateUtil.handleException(e, "deleteFunctionById", state);
			return false;
		}		
	}
	
	public void deleteFunction(Function function, IState state) {
		if (DelegateUtil.isNullParam(function, "function", state)) {
			return;
		}
		Request req = new Request();
		req.setServiceName(ServiceConsts.DeleteFunctionProcessor);
		req.setValue("function", function);
		try {
			Response resp = getDelegate().execute(req);
			DelegateUtil.setIState(state, resp);
		} catch (Exception e) {
			DelegateUtil.handleException(e, "deleteFunction", state);
		}		
	}
	
	
	public PageSupport findAllFunction(CriteriaQuery cq, IState state) {
		if (DelegateUtil.isNullParam(cq, "CriteriaQuery", state)) {
			return null;
		}
		Request req = new Request();
		req.setServiceName(ServiceConsts.FindAllFunctionProcessor);
		req.setValue("CriteriaQuery", cq);
		try {
			Response resp = getDelegate().execute(req);
			DelegateUtil.setIState(state, resp);
			return (PageSupport) (resp.getValue("PageSupport"));
		} catch (Exception e) {
			DelegateUtil.handleException(e, "findAllFunction", state);
			throw new ClientException(e,"findAllFunction error");
		}
	}
	public Function findFunctionById(String id, IState state) {
		if (DelegateUtil.isNullParam(id, "id", state)) {
			return null;
		}
		Request req = new Request();
		req.setServiceName(ServiceConsts.FindFunctionByIdProcessor);
		req.setValue("id", id);
		try {
			Response resp = getDelegate().execute(req);
			DelegateUtil.setIState(state, resp);
			Function function = (Function) resp.getValue("function");
			DelegateUtil.setIState(state, resp);
			return function;
		} catch (Exception e) {
			DelegateUtil.handleException(e, "findFunctionById", state);
			return null;
		}
	}
	/**
	 * 查找该用户的所有权限
	 */
	public List findFunctionByUser(String userId, IState state) {
		try {
			return (List)getDelegate().execute("userId", userId, 
					ServiceConsts.FindFunctionByUserProcessor,"functions", state);
		} catch (Exception e) {
			DelegateUtil.handleException(e, "findFunctionByUser", state);
			return null;
		}
	}
	
	/**
	 * 查找该用户的还没有授权的角色，用来增加角色
	 */
	public PageSupport findOtherRoleByUser(HqlQuery hqlQuery,String userId, IState state) {	
		if (DelegateUtil.isNullParam(hqlQuery, "hqlQuery", state)||DelegateUtil.isNullParam(userId, "userId", state)) {
			return null;
		}
		Request req = new Request();
		req.setServiceName(ServiceConsts.FindOtherRoleByUserProcessor);
		req.setValue("hqlQuery", hqlQuery);
		req.setValue("userId", userId);
		try {