useraction.java

tbuy1.1.5是在netbeans环境下用JSF技术编写的一个论坛tbuy1.1.5是在netbeans环境下用JSF技术编写的一个论坛

/*
 * 作者: 胡李青
 * qq: 31703299
 * Copyright (c) 2007 huliqing
 * 主页 http://www.tbuy.biz/
 * 你可以免费使用该软件，未经许可请勿作用于任何商业目的
 */

package biz.tbuy.user;

import biz.tbuy.common.Constants;
import biz.tbuy.common.logs.Elog;
import biz.tbuy.common.pool.*;
import biz.tbuy.user.bean.BaseBean;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
/**
 * @author huliqing
 * <p><b>qq：</b>31703299
 * <p><b>E-mail：</b><a href="mailto:[e-mail]">[e-mail]</a>
 * <p><b>Homepage：</b><a href="http://www.tbuy.biz/">http://www.tbuy.biz/</a>
 */
public class UserAction extends BaseBean{
    private UserModel userModel;
    
    public UserAction() {
    }

    public void setUserModel(UserModel userModel) {
        this.userModel = userModel;
    }
    
    /** method ****************************************************************/
    
    /**
     * 判断用户id是否已经存在于数据库中
     * @param userId 需要判断的用户ID
     * @return true 如果该id已经存在，否则返回false;
     */
    public static boolean isExistUserId(String userId) {
        boolean isOk = true;
        String sql = "select * from user where u_id = ?";
        ProxyConn myConn = getConn();
        try {
            PreparedStatement ps = myConn.prepareStatement(sql);
            ps.setString(1, userId);
            isOk = ps.executeQuery().next();
        } catch (Exception e) {
            Elog.log("Exception:UserAction:isExistUserId:" + e.getMessage());
        } finally {
            myConn.close();
        }
        return isOk;
    }
    
    /**
     * 添加用户进数据库，即注册新用户
     * @param user 需要注册的UserModel对象
     * @return true 注册成功，否则返回false
     */
    public static boolean addMember(UserModel user) {
        boolean isOk = false;
        String sql = "insert into user (u_id, u_password, u_enabled, u_date) " +
                "values (?, ?, ?, now())";
        ProxyConn myConn = getConn();
        try {
            PreparedStatement ps = myConn.prepareStatement(sql);
            ps.setString(1, user.getId());
            ps.setString(2, user.getPassword());
            ps.setBoolean(3, user.getEnabled());
            isOk = ps.executeUpdate() > 0;
        } catch (Exception e) {
            Elog.log("Exception:UserAction:addMember:" + e.getMessage());
        } finally {
            myConn.close();
        }
        return isOk;
    }
    
    /**
     * 更新用户信息,当前只更新enabled及beRevoke,更新用户信息都使用这一方法
     * @param user 用户信息
     * @return true 如果更新成功，否则false
     */
    public static boolean updateUser(UserModel user) {
        boolean isOk = false;
        String sql = "update user set u_enabled=?, u_beRevoke=? " +
                "where u_id=? ";
        ProxyConn myConn = getConn();
        try {
            PreparedStatement ps = myConn.prepareStatement(sql);
            ps.setBoolean(1, user.getEnabled());
            ps.setBoolean(2, user.getBeRevoke());
            ps.setString(3, user.getId());
            isOk = ps.executeUpdate() > 0;
        } catch (Exception e) {
            Elog.log("Exception:UserAction:updateUser:" + e.getMessage());
        } finally {
            myConn.close();
        }
        return isOk;
    }
    
    /**
     * 通过用户名及密码获取用户信息.
     * @param id 用户的id
     * @param password 用户的登录密码
     * @return user 获取成功则返回UserModel,否则返回null;
     */
    public static UserModel getUser(String id, String password) {
        UserModel user = null;
        String sql = "select * from user where u_id = ? and u_password = ?";
        ProxyConn myConn = getConn();
        try {
            PreparedStatement ps = myConn.prepareStatement(sql);
            ps.setString(1, id);
            ps.setString(2, password);
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                user = getUser(rs);
            }
        } catch (Exception e) {
            Elog.log("Exception:UserAction:getUser:" + e.getMessage());
        } finally {
            myConn.close();
        }
        return user;
    }
    
    /**
     * 通过用户名获取用户信息.
     * @param id 用户的id
     * @return user 获取成功则返回UserModel,否则返回null;
     */
    public static UserModel getUser(String id) {
        UserModel user = null;
        String sql = "select * from user where u_id = ?";
        ProxyConn myConn = getConn();
        try {
            PreparedStatement ps = myConn.prepareStatement(sql);
            ps.setString(1, id);
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                user = getUser(rs);
            }
        } catch (Exception e) {
            Elog.log("Exception:UserAction:getUser:" + e.getMessage());
        } finally {
            myConn.close();
        }
        return user;
    }
    
    /**
     * 获取最后一个注册的用户信息，且该用户为已经激活的!
     * @return user or null
     */
    public static UserModel getLastRegister() {
        UserModel user = null;
        String sql = "select * from user where u_enabled=1 order by u_num desc limit 1";
        ProxyConn myConn = getConn();
        try {
            PreparedStatement ps = myConn.prepareStatement(sql);
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                user = getUser(rs);
            }
        } catch (SQLException sqle) {
            Elog.log("Exception:UserAction:getLastRegister:" + sqle.getMessage());
        } finally {
            myConn.close();
        }
        return user;
    }
    
    /**
     * 获得当前总站的admin列表信息
     * @return admins ArrayList类型的集合。
     * @deprecated 已经无意义
     */
    public static List<UserModel> getAdmins() {
        List<UserModel> admins = new ArrayList<UserModel>();
        String sql = "select * from user where u_group=?";
        ProxyConn myConn = getConn();
        try {
            PreparedStatement ps = myConn.prepareStatement(sql);
            ps.setString(1, Constants.GROUP_ADMIN);
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                admins.add(getUser(rs));
            }
        } catch (Exception e) {
            Elog.log("Exception:UserAction:getAdmins:" + e.getMessage());
        } finally {
            myConn.close();
        }
        return admins;
    }
    
    /**
     * 更新用户的密码
     * @param id 需要更新密码的用户id
     * @param password 用户的新的密码
     * @return true 如果更新密码成功，否则返回false;
     */
    public static boolean updatePassword(String id, String password) {
        boolean isOk = false;
        String sql = "update user set u_password = ? where u_id = ?";
        ProxyConn myConn = getConn();
        try {
            PreparedStatement ps = myConn.prepareStatement(sql);
            ps.setString(1, password);
            ps.setString(2, id);
            isOk = ps.executeUpdate() > 0;
        } catch (Exception e) {
            Elog.log("Exception:UserAction:updatePassword:" + e.getMessage());
        } finally {
            myConn.close();
        }
        return isOk;
    }
    
    /**
     * 激活用户的id,当系统开启邮件认证时，用户需要通过电子邮件进行确认注册
     * @param userId 需要被激活的用户ID
     * @return true 如果成功激活，否则返回false;
     */ 
    public static boolean enableUser(String userId) {
        boolean isOk = false;
        String sql = "update user set u_enabled=1 where u_id=?";
        ProxyConn myConn = getConn();
        try {
            PreparedStatement ps = myConn.prepareStatement(sql);
            ps.setString(1, userId);
            isOk = ps.executeUpdate() > 0;
        } catch (Exception e) {
            Elog.log("Exception:UserAction:enableUser:" + e.getMessage());
        } finally {
            myConn.close();
        }
        return isOk;
    }
    
    /**
     * 获取所有已经注册的用户数
     * @return total 已经注册的用户总数
     */ 
    public static int getTotalUsers() {
        int total = 0;
        String sql = "select * from user";
        ProxyConn myConn = getConn();
        try {
            PreparedStatement ps = myConn.prepareStatement(sql);
            ResultSet rs = ps.executeQuery();
            rs.last();
            total = rs.getRow();
        } catch (Exception e) {
            Elog.log("Exception:UserAction:getTotalUsers:" + e.getMessage());
        } finally {
            myConn.close();
        }
        return total;
    }
    
    /**
     * 获取所有已经激活的用户.
     * @return total 已经激活的用户总数
     */ 
    public static int getTotalEnabled() {
        int total = 0;
        String sql = "select * from user where u_enabled=1";
        ProxyConn myConn = getConn();
        try {
            PreparedStatement ps = myConn.prepareStatement(sql);
            ResultSet rs = ps.executeQuery();
            rs.last();
            total = rs.getRow();
        } catch (Exception e) {
            Elog.log("Exception:UserAction:getTotalEnabled:" + e.getMessage());
        } finally {
            myConn.close();
        }
        return total;
    }
    
    /**
     * 获取所有未激活帐号的用户总数
     * @return total 
     */ 
    public static int getTotalNoEnabled() {
        int total = 0;
        String sql = "select * from user where u_enabled=0";
        ProxyConn myConn = getConn();
        try {
            PreparedStatement ps = myConn.prepareStatement(sql);
            ResultSet rs = ps.executeQuery();
            rs.last();
            total = rs.getRow();
        } catch (Exception e) {
            Elog.log("Exception:UserAction:getTotalNoEnabled:" + e.getMessage());
        } finally {
            myConn.close();
        }
        return total;
    }

    /**
     * 获取未激活用户，只获取一定数量，该方法用于分页查询
     * @param startRow 获取的起始行
     * @param pageSize 获取的数量
     * @return users 未激活的用户
     */ 
    public static List<UserModel> getNoEnabledForPage(int startRow, int pageSize) {
        List<UserModel> users = new ArrayList<UserModel>();
        String sql = "select * from user where u_enabled=0 " +
                "order by u_num desc " +
                "limit ?, ?";
        ProxyConn myConn = getConn();
        try {
            PreparedStatement ps = myConn.prepareStatement(sql);
            ps.setInt(1, startRow);
            ps.setInt(2, pageSize);
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                users.add(getUser(rs));
            }
        } catch (Exception e) {
            Elog.log("Exception:UserAction:getNoEnabledForPage:" + e.getMessage());
        } finally {
            myConn.close();
        }
        return users;
    }

    /**
     * 获取所有已经被封停的用户总数
     * @return total 所有已经被封停的用户数
     */ 
    public static int getTotalRevokes() {
        int total = 0;
        String sql = "select * from user where u_beRevoke=1";
        ProxyConn myConn = getConn();
        try {
            PreparedStatement ps = myConn.prepareStatement(sql);
            ResultSet rs = ps.executeQuery();
            rs.last();
            total = rs.getRow();
        } catch (Exception e) {
            Elog.log("Exception:UserAction:getTotalRevokes:" + e.getMessage());
        } finally {
            myConn.close();
        }
        return total;
    }
    
    /**
     * 获取<b>一定数量</b>的已经被封停的用户,该方法主要用于分页查询
     * @param startRow 获取的起始行
     * @param pageSize 获取的数量
     * @return users 被封停的用户
     */ 
    public static List<UserModel> getRevokesForPage(int startRow, int pageSize) {
        List<UserModel> users = new ArrayList<UserModel>();
        String sql = "select * from user where u_beRevoke=1 " +
                "order by u_num desc " +
                "limit ?, ?";
        ProxyConn myConn = getConn();
        try {
            PreparedStatement ps = myConn.prepareStatement(sql);
            ps.setInt(1, startRow);
            ps.setInt(2, pageSize);
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                users.add(getUser(rs));
            }
        } catch (Exception e) {
            Elog.log("Exception:UserAction:getRevokesForPage:" + e.getMessage());
        } finally {
            myConn.close();
        }
        return users;
    }
    
    /**
     * 通过ResultSet获取当前行的数据
     * @param rs ResultSet
     * @return user UserModel
     */
    public static UserModel getUser(ResultSet rs) {
        UserModel user = new UserModel();
        try {
            user.setId(rs.getString("u_id"));
            user.setPassword(rs.getString("u_password"));
            user.setGroup(rs.getString("u_group"));
            user.setEnabled(rs.getBoolean("u_enabled"));
            user.setBeRevoke(rs.getBoolean("u_beRevoke"));
            user.setDate(rs.getTimestamp("u_date"));
        } catch (Exception e) {
            Elog.log("Exception:UserAction:getUser:" + e.getMessage());
        }
        return user;
    }
}