resmanager.java

java实现的可配置的工作流引擎,采用jsp+javabean实现

package com.hongsoft.res.pojo;

import java.util.List;
import java.util.Set;

import org.hibernate.Session;

import com.hongsoft.agile.Agile;
import com.hongsoft.agile.AgileConnection;
import com.hongsoft.res.database.OrgUnitCache;
import com.hongsoft.res.database.PrivilegeHibernate;
import com.hongsoft.res.database.ResHibernateFactory;

/**
 * 资源管理类,是资源管理的界面。通过该类操作资料系统。
 */

public class ResManager {
    /**
     * 创建用户信息
     * @param user User
     * @return 包含user id的User对象
     * @throws Exception
     */
    public static User createUser(Session session,User user) throws Exception {
        long id= ResHibernateFactory.createUserHibernate().createUser(session,user);
        user.setId(id);
        return user;
    }
    /**
     * 向特定的组织添加用户
     * @param user User
     * @return 包含user id的User对象
     * @throws Exception
     */
    public static User createUser(Session session,User user,int orgID) throws Exception {
        long id= ResHibernateFactory.createUserHibernate().createUser(session,user);
        //加入父子关联
        if(id!=0)
        ResHibernateFactory.createResObjectHibernate().addAssociate(session,orgID,id);
        user.setId(id);
        return user;
    }


    /**
     * 获取用户信息
     * @param id 用户ID
     * @return User对象
     * @throws Exception
     */
    public static User getUser(Session session,long id) throws Exception {
        return ResHibernateFactory.createUserHibernate().getUser(session,id);
    }

    /**
     * 获取用户信息
     * @param loginName 用户登录名
     * @return User对象
     * @throws Exception
     */
    public static User getUser(Session session,String loginName) throws Exception {
        return ResHibernateFactory.createUserHibernate().getUser(session,loginName);
    }

    /**
     * 修改用户信息
     * @param user User
     * @throws Exception
     */
    public static void modifyUser(Session session,User user) throws Exception {
        ResHibernateFactory.createUserHibernate().modifyUser(session,user);
    }

    /**
     * 删除用户
     * @param uid 用户ID
     * @throws Exception
     */
    public static void deleteUser(Session session,long uid) throws Exception {
       //先删掉父子关系  yhb 1/8 添加
       ResHibernateFactory.createResObjectHibernate().deleteOrgRela(session,uid);
       //then,we delete the relation of priv and user;  yhb added 2/2
       ResHibernateFactory.createPrivilegeHibernate().deletePrivilegeRelation(session,uid);
       //再删用户
        ResHibernateFactory.createUserHibernate().deleteUser(session,uid);
    }

    /**
     * 查询用户信息
     * @param userName 用户名
     * @param loginName 登录名
     * @param isAnd 使用and还是or
     * @param isLike 使用匹配还是=
     * @param startIndex 返回结果起始位置
     * @param endIndex 返回结果结束位置
     * @return User对象的List
     * @throws Exception 如果查询不到任何结果抛出RES_NOT_FOUND_ERROR的Exception
     */
    public static List searchUser(Session session,
        String userName,String loginName,boolean isAnd,
        boolean isLike,int startIndex,int endIndex)throws Exception {
        if (userName == null)
            userName= "";
        if (loginName == null)
            loginName= "";
        return ResHibernateFactory.createUserHibernate().searchUsers(session,
            loginName,
            userName,
            isAnd,
            isLike,
            startIndex,
            endIndex);
    }
    /**
    * 查询特定部门下的用户
    * @param userName 用户名
    * @param loginName 登录名
    * @param isAnd 使用and还是or
    * @param isLike 使用匹配还是=
    * @param startIndex 返回结果起始位置
    * @param endIndex 返回结果结束位置
    * @return User对象的List
    * @throws Exception 如果查询不到任何结果抛出RES_NOT_FOUND_ERROR的Exception
    */
   public static List searchUser(
       int orgID,String userName,String loginName,boolean isAnd,
       boolean isLike,int startIndex,int endIndex)throws Exception {
       if (userName == null)
           userName= "";
       if (loginName == null)
           loginName= "";
       AgileConnection ac=Agile.connectToServer();
       List list= ResHibernateFactory.createUserHibernate().searchUsers(ac.getHibernateSession(),
           orgID,loginName,userName,isAnd,
           isLike,startIndex,endIndex);
       Agile.disConnectServer(ac,true);
       return list;
   }
   public static List searchUser(Session session,
        int orgID,String userName,String loginName,boolean isAnd,
        boolean isLike,int startIndex,int endIndex)throws Exception {
        if (userName == null)
            userName= "";
        if (loginName == null)
            loginName= "";
        return ResHibernateFactory.createUserHibernate().searchUsers(session,
            orgID,loginName,userName,isAnd,
            isLike,startIndex,endIndex);
    }


    /**
     * 返回符合条件的记录总数
     * @param userName用户名
     * @param loginName登录名
     * @param isAnd 与的关系
     * @param isLike LIKE的关系
     * @return 记录总数
     * @throws Exception
     */
    public static int searchUserCount(Session session,String userName, String loginName, boolean isAnd, boolean isLike)
        throws Exception {
        if (userName == null)
            userName= "";
        if (loginName == null)
            loginName= "";
        return ResHibernateFactory.createUserHibernate().searchUserCount(session,userName, loginName, isAnd, isLike);
    }

    /**
     * 获取角色信息
     * @param id 角色ID
     * @return Role对象
     * @throws Exception
     */
    public static Role getRole(Session session,long id) throws Exception {
        return ResHibernateFactory.createRoleHibernate().getRole(session,id);
    }

    /**
     * 修改角色信息
     * @param role Role
     * @throws Exception
     */
    public static void modifyRole(Session session,Role role) throws Exception {
        ResHibernateFactory.createRoleHibernate().modifyRole(session,role);
    }

    /**
     * 删除角色
     * @param rid 角色ID
     * @throws Exception
     */
    public static void deleteRole(Session session,long rid) throws Exception {
        ResHibernateFactory.createRoleHibernate().deleteRole(session,rid);
    }

    /**
     * 查询角色信息
     * @param roleName 角色名
     * @param startIndex 返回结果起始位置
     * @param endIndex 返回结果结束位置
     * @return Role对象的List
     * @throws Exception 如果查询不到任何结果抛出RES_NOT_FOUND_ERROR的Exception
     */
    public static List searchRole(Session session,String roleName, boolean isLike) throws Exception {
        if (roleName == null)
            roleName= "";
        return ResHibernateFactory.createRoleHibernate().searchRole(session,roleName, isLike);
    }

    /**
     * 创建角色信息
     * @param role Role
     * @return 包含role id的Role对象
     * @throws Exception
     */
    public static Role createRole(Session session,Role role) throws Exception {
        return ResHibernateFactory.createRoleHibernate().createRole(session,role);
    }

    /**
     * 创建组织信息
     * @param parentOrgID 上级组织ID
     * @param ou OrgUnit
     * @return 包含ou id的OrgUnit对象
     * @throws Exception
     */
    public static long createOrgUnit(Session session,long parentOrgID, OrgUnit ou, int is_extend) throws Exception {
        long orgID= ResHibernateFactory.createOrgUnitHibernate().createOrgUnit(session,ou, parentOrgID, is_extend);
        OrgUnitCache.reload(session);
        return orgID;
    }

    /**
     * 获取组织信息
     * @param id 组织对象ID
     * @return 组织对象信息
     * @throws Exception
     */
    public static OrgUnit getOrgUnit(Session session,long id) throws Exception {
      //return OrgUnitCache.getOrgUnitElem(id).getOrgUnit();
      return ResHibernateFactory.createOrgUnitHibernate().getOrgUnit(session,id);
    }
    /**
     * 根据用户ID获取所属的组织ID
     * @param userId
     * @return
     * @throws Exception
     */
    public static long gerOrgidByUserid(Session session,long userId) throws Exception {
        return ResHibernateFactory.createResObjectHibernate().gerOrgidByUserid(session,userId);
    }

    /**
     * 修改组织信息
     * @param ou OrgUnit对象
     * @throws Exception
     */
    public static void modifyOrgUnit(Session session,OrgUnit ou) throws Exception {
        ResHibernateFactory.createOrgUnitHibernate().modifyOrgUnit(session,ou);
    }
    /**
     * 判断一个部门下面是否有子部门
     * @param id long
     * @throws Exception
     * @return boolean
     */
    public static boolean thereIsChildOrg(long id) throws Exception
    {
      //1月14号修改为:  只要有子部门或子用户,则该组织不能删除
      AgileConnection ac=Agile.connectToServer();
      boolean b=(ResHibernateFactory.createOrgUnitHibernate().thereIsChild(ac.getHibernateSession(),id)==true);
      Agile.disConnectServer(ac,true);
      return b;
    }

    /**
     * 删除组织
     * @param id 组织对象对应的ID
     * @throws Exception
     */
    public static void deleteOrgUnit(Session session,long id) throws Exception {
        //先删掉向上和向下的父子关系  yhb 1/8 添加
       ResHibernateFactory.createResObjectHibernate().deleteOrgRela(session,id);
       //再删组织信息
        ResHibernateFactory.createOrgUnitHibernate().deleteOrgUnit(session,id);
        OrgUnitCache.reload(session);
    }

    /**
     * 修改资源对象关联关系,替换原有的关联关系
     * @param parentID 父资源对象ID
     * @param childIDs 子资源对象ID数组
     * @throws Exception
     */
    public static void modifyResObjectAssociate(Session session,long parentID, long[] childIDs) throws Exception {
        ResHibernateFactory.createResObjectHibernate().updateAssociate(session,parentID, childIDs);
    }

    /**
     * 获取资源对象拥有的所有权限Set
     * @param resID 资源对象ID
     * @return 权限Set
     * @throws Exception
     */
    public static Set getPrivileges(Session session,long resID) throws Exception {
        return ResHibernateFactory.createPrivilegeHibernate().getResAllPrivileges(session,resID);
    }

    /**
     * 只获指定资源对象ID的权限
     * @param resID
     * @return
     * @throws Exception
     */
    public static Set getResPriv(Session session,long resID)throws Exception{
      return ResHibernateFactory.createPrivilegeHibernate().getPrivileges(session,resID);
    }

    /**
     * 获得系统整个组织树状结构
     * @return OrgUnitElement
     * @throws Exception
     */
    public static OrgUnitElement getOrgUnitElement(Session session) throws Exception {
      return OrgUnitCache.getGlobalOrgUnitElem(session);
        //return ResHibernateFactory.createOrgUnitHibernate().getOUElement(Global.TOP_ORG_UNIT);
    }


    /**
     * 获得整个组织树状结构
     * @return OrgUnitElement
     * @throws Exception
     */
    public static OrgUnitElement getOrgUnitElement(Session session,long orgID) throws Exception {
      return OrgUnitCache.getOrgUnitElem(session,orgID);
      //return ResHibernateFactory.createOrgUnitHibernate().getOUElement(orgID);
    }
    

    /**
     * 获取指定资源对象所属的所有资源对象的树，树的根为该资源对象
     * @param id 资源对象ID
     * @return 资源对象树
     */
    public static ResObjectElement getResObjectElment(Session session,long id) throws Exception {
        return ResHibernateFactory.createResObjectHibernate().getResObjectElement(session,id, false, true);
    }
    /**
     * 获得整个组织树状结构
     * @return OrgUnitElement
     * @throws Exception
     */
    public static OrgUnitElement getOrgUnitElement(long orgID) throws Exception {
      AgileConnection ac=Agile.connectToServer();
      OrgUnitElement oe= OrgUnitCache.getOrgUnitElem(ac.getHibernateSession(),orgID);
      Agile.disConnectServer(ac,true);
	  return oe;
      //return ResHibernateFactory.createOrgUnitHibernate().getOUElement(orgID);
    }
    

    /**
     * 获取指定资源对象所属的所有资源对象的树，树的根为该资源对象
     * @param id 资源对象ID
     * @return 资源对象树
     */
    public static ResObjectElement getResObjectElment(long id) throws Exception {
    	AgileConnection ac=Agile.connectToServer();
    	ResObjectElement re=ResHibernateFactory.createResObjectHibernate().getResObjectElement(ac.getHibernateSession(),id, false, true);
    	Agile.disConnectServer(ac,true);
  	    return re;
    }

    /**
     * 获取指定资源对象所有父资源对象的树，树的根为该资源对象
     * @param id 资源对象ID
     * @return 资源对象树
     */
    public static ResObjectElement getParentResObjectElment(Session session,long id) throws
        Exception {
      return ResHibernateFactory.createResObjectHibernate().getResObjectElement(
      		session,id, true, true);
    }  


     /**
      * 权限更新
      * @param resID
      * @param listPriv,listPriv存储的对象为：com.zznode.gz.pmes.res.Privilege对象
      * @throws Exception
      */
     public static void modifyPriv(Session session,long resID,List listPriv)throws Exception{
		PrivilegeHibernate privHib=PrivilegeHibernate.getInstance();
		privHib.updatePrivilege(session,resID,listPriv);
     }
}