userhibernate.java

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

package com.hongsoft.res.database;

import com.hongsoft.res.pojo.*;

import org.hibernate.*;
import org.hibernate.type.*;
import java.util.*;
import com.hongsoft.res.util.*;

public class UserHibernate {
    private static UserHibernate hib = null;

    static UserHibernate getInstance() {
        return new UserHibernate();
    }

    private UserHibernate() {
        super();
    }

    /**
     * 从数据库获取用户信息对象
     *
     * @param loginName 用户登录名
     * @return 用户信息对象,如果搜索不到返回null
     * @throws ResException
     */
    public User getUser(Session session, String loginName) throws ResException {
        int errorCode = ResException.OTHER_DATABASE_ERROR;
        User user = null;
        try {
            List userList = null;
            // session.find(ResQuery.LOAD_USER_BY_LOGIN_NAME,loginName,new StringType());
            Iterator itr = userList.iterator();
            if (itr.hasNext())
                user = (User) itr.next();
        } catch (HibernateException e) {
            throw new ResException(errorCode);
        }
        return user;

    }

    /**
     * 从数据库获取用户信息对象
     *
     * @param id 用户对应的资源ID
     * @return User,如果搜索不到返回null
     */
    public User getUser(Session session, long id) throws ResException {
        int errorCode = ResException.OTHER_DATABASE_ERROR;
        User user = null;
        try {
            List userList = null;
            // session.find(ResQuery.LOAD_USER_BY_ID,new Long(id),new LongType());
            Iterator itr = userList.iterator();
            if (itr.hasNext())
                user = (User) itr.next();
        } catch (HibernateException e) {
            throw new ResException(errorCode);
        }
        return user;
    }

    /**
     * 根据User信息,先生成新的ID,写入资源对象表,然后写入user表
     *
     * @param user User
     * @return 用户对应的资源ID
     * @throws ResException
     */
    public synchronized long createUser(Session session, User user) throws ResException {
        int errorCode = ResException.USER_LOGIN_NAME_UNIQUE_ERROR;
        long value = 0;
        try {
            List user2 = null;
            // session.find(ResQuery.LOAD_USER_BY_LOGIN_NAME, user.getLoginName(), new StringType());
            if (user2 == null || user2.isEmpty()) {
                errorCode = ResException.OTHER_DATABASE_ERROR;
                value = IDGenerator.newID(session, ResObjectName.RES_OBJECT);
                ResObject resObject = new ResObject();
                resObject.setId(value);
                resObject.setType(ResType.USER);
                user.setId(value);
                resObject.setUser(user);
                session.save(resObject);
            } else {
                throw new ResException(errorCode);
            }
        } catch (HibernateException e) {
            throw new ResException(errorCode);
        }
        return value;
    }

    /**
     * 修改数据库用户信息,用户登录名不允许修改
     *
     * @param user User
     * @throws ResException
     */
    public void modifyUser(Session session, User user) throws ResException {
        try {
            session.update(user);
        } catch (HibernateException e) {
            throw new ResException(ResException.OTHER_DATABASE_ERROR);
        }
    }

    /**
     * 从数据库删除用户信息,用户不存在时,会抛出异常 因为有可能ResObject有该id,但不是user type,所以只能用User.class
     *
     * @param id 用户资源ID
     */
    public void deleteUser(Session session, long id) throws ResException {
        try {
            // session.delete(ResQuery.LOAD_USER_BY_ID_FROM_RESOBJECT, new Long(id), new LongType());
        } catch (HibernateException e) {
            throw new ResException(ResException.RES_NOT_FOUND_ERROR);
        }
    }

    /**
     * 从数据库查询用户信息对象List。
     *
     * @param loginName 用户登录名
     * @param name 用户名
     * @param isAnd 两个关键字连接是AND还是OR
     * @param isLike 查询关键字是LIKE还是=
     * @return 用户对象(User)集合,如果搜索不到返回null
     */
    public List searchUsers(Session session, String loginName, String name, boolean isAnd, boolean isLike,
            int startIndex, int endIndex) throws ResException {
        int errorCode = ResException.OTHER_DATABASE_ERROR;
        List userList = new ArrayList();
        try {
            StringBuffer searchQuery = new StringBuffer();
            searchQuery.append("SELECT u FROM User as u WHERE u.loginName like :loginName");
            if (isAnd)
                searchQuery.append(" and u.name like :name");
            else
                searchQuery.append(" or u.name like :name");
            Query q = session.createQuery(searchQuery.toString());
            if (isLike)
                q.setString("loginName", '%' + loginName + '%');
            else
                q.setString("loginName", loginName);
            if (isLike)
                q.setString("name", '%' + name + '%');
            else
                q.setString("name", name);
            q.setFirstResult(startIndex);
            q.setMaxResults(endIndex - startIndex + 1);
            userList = q.list();
        } catch (HibernateException e) {
            throw new ResException(errorCode);
        }
        return userList;
    }

    /**
     * 查询特定部门内部的,登录名/姓名满足条件的用户列表 1月7号yhb添加,为了实现只查出部门内部用户的功能
     *
     * @param loginName 用户登录名
     * @param name 用户名
     * @param isAnd 两个关键字连接是AND还是OR
     * @param isLike 查询关键字是LIKE还是=
     * @return 用户对象(User)集合,如果搜索不到返回null
     */
    public List searchUsers(Session session, int orgID, String loginName, String name, boolean isAnd, boolean isLike,
            int startIndex, int endIndex) throws ResException {
        int errorCode = ResException.OTHER_DATABASE_ERROR;
        List userList = new ArrayList();
        try {
            StringBuffer searchQuery = new StringBuffer();
            searchQuery.append("SELECT u FROM User as u,ResObjectRela as r  WHERE u.loginName like :loginName");
            // 部门ID
            searchQuery.append(" AND u.id=r.id.child_id AND r.id.parent_id=:orgID");
            if (isAnd)
                searchQuery.append(" and u.name like :name");
            else
                searchQuery.append(" or u.name like :name");
            Query q = session.createQuery(searchQuery.toString());
            q.setInteger("orgID", orgID);
            if (isLike)
                q.setString("loginName", '%' + loginName + '%');
            else
                q.setString("loginName", loginName);
            if (isLike)
                q.setString("name", '%' + name + '%');
            else
                q.setString("name", name);
            q.setFirstResult(startIndex);
            q.setMaxResults(endIndex - startIndex + 1);
            userList = q.list();
        } catch (HibernateException e) {
            throw new ResException(errorCode);
        }
        return userList;
    }

    /**
     * 查询满足条件的用户总数
     *
     * @param userName
     * @param loginName
     * @param isAnd
     * @param isLike
     * @return
     * @throws ResException
     */
    public int searchUserCount(Session session, String userName, String loginName, boolean isAnd, boolean isLike)
            throws ResException {
        int errorCode = ResException.OTHER_DATABASE_ERROR;
        int userCount = 0;
        try {
            StringBuffer searchQuery = new StringBuffer();
            searchQuery.append("SELECT count(u.id) FROM User as u WHERE u.loginName like :loginName");
            if (isAnd)
                searchQuery.append(" and u.name like :name");
            else
                searchQuery.append(" or u.name like :name");
            Query q = session.createQuery(searchQuery.toString());
            if (isLike)
                q.setString("loginName", '%' + loginName + '%');
            else
                q.setString("loginName", loginName);
            if (isLike)
                q.setString("name", '%' + userName + '%');
            else
                q.setString("name", userName);
            Iterator itr = q.iterate();
            if (itr.hasNext())
                userCount = ((Integer) itr.next()).intValue();
        } catch (HibernateException e) {
            throw new ResException(errorCode);
        }
        return userCount;
    }
}