用户管理

whyclxw

2025-05-13 76ceb3eb8d2de784284e100b7f2f694d6db5ba2b

用户管理

 src/main/java/com/whyc/controller/UserController.java

@@ -10,6 +10,7 @@
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

@RestController
@RequestMapping("user")
@@ -18,74 +19,61 @@
public class UserController extends BaseController{

    @Resource
    private UserService userService;
    private UserService service;

    //@PostMapping
    //@ApiOperation(value = "添加")
    //public Response add(@RequestBody UserInf user){
    //    return userService.add(user);
    //}

    @PostMapping("add")
    @ApiOperation(value = "添加-RSA加密")
    public Response addByRSA(@RequestBody User user){
        return userService.addByRSA(user);
    @ApiOperation(value = "查询所有用户信息",notes = "排除uid在100以内的(100以内默认是管理员)")
    @GetMapping("getAllUser")
    public Response getAllUser(@RequestParam(required = false) String uname,@RequestParam(required = false) String realName,@RequestParam int pageCurr, @RequestParam int pageSize){
        return service.getAllUser(uname,realName,pageCurr,pageSize);
    }

    /*@PostMapping("register")
    @ApiOperation(value = "注册用户")
    public Response register(@RequestBody User user){
        return userService.registerUser(user);
    }*/
    @GetMapping("getById")
    @ApiOperation(value = "查询byId")
    public Response<User> getById(@RequestParam int id){
        return new Response<User>().set(1,userService.getById(id));
    @ApiOperation(value = "查询所有用户信息(不分页除内置用户外用于下拉)")
    @GetMapping("getUinf")
    public Response getUinf(){
        return service.getUinf();
    }

    /*@GetMapping("all")
    @ApiOperation(value = "查询所有")
    public Response<List<User>> getAll(){
        return new Response<List<User>>().set(1,userService.getAll());
    }*/

    @GetMapping("getPage")
    @ApiOperation(value = "查询分页")
    public Response getPage(@RequestParam int pageNum,@RequestParam int pageSize){
        return new Response().set(1,userService.getPage(pageNum,pageSize));
    @ApiOperation(value = "新添加用户信息")
    @PostMapping("addUser")
    public Response addUser(@RequestBody User uinf){
        return service.addUser(uinf);
    }
    @ApiOperation(value = "删除用户信息")
    @GetMapping("deleteUser")
    public Response deleteUser(@RequestParam String uname){
        return service.delUser(uname);
    }

    @PostMapping("update")
    @ApiOperation(value = "编辑")
    public Response update(@RequestBody User user){
        return userService.update(user);
    @ApiOperation(value = "将用户添加至100~1000管理员")
    @GetMapping("improveRole")
    public Response improveRole(@RequestParam int uid){
        return service.improveRole(uid);
    }

    @ApiOperation(value = "将管理员变成普通用户")
    @GetMapping("dropRole")
    public Response dropRole(@RequestParam int uid, HttpServletRequest request){
        return service.dropRole(uid,request);
    }

    @GetMapping("getUserNameList")
    @ApiOperation(tags = "操作日志",value = "操作人姓名-查询-操作日志使用")
    public Response getUserNameList(){
        return service.getUserNameList();
    }

    @GetMapping("resetSnId")
    @ApiOperation(value = "重置密码")
    public Response resetSnId(@RequestParam int uid){
        return service.resetSnId( uid);
    }


    /*@PostMapping("/checkUserPassword")
    @ApiOperation(value = "检查用户密码")
    public Response checkUserPassword(@RequestParam String password){
        User user = UserUtil.getUser();
        //前端传递的密码解密
        password = RSAUtil.decryptFrontP(password, RSAUtil.fontSeparator)[0];
        //内存存储的密码解密
        String userPassword = user.getPwd();
        userPassword = RSAUtil.decrypt(userPassword,RSAUtil.getPrivateKey());
        if (password.equals(userPassword)){
            return new Response().set(1);
        }else {
            return new Response().set(0);
    @ApiOperation(value = "编辑用户信息")
    @PostMapping("updateUinf")
    public Response updateUinf(@RequestBody User uinf){
        return service.updateUinf(uinf);
        }
    }*/


    @PostMapping("/updatePasswordByRSA")
    @ApiOperation(value = "修改密码-RSA")
    public Response updatePasswordByRSA(@RequestParam String password){
        User user = CommonUtil.getUser();
        return userService.updatePasswordByRSA(user,password);
    }





 src/main/java/com/whyc/mapper/UserMapper.java

@@ -6,12 +6,27 @@
import java.util.List;

public interface UserMapper extends CustomMapper<User> {

    int addJudge(@Param("name") String name,@Param("phoneNumber") String phoneNumber);

    //当前用户所在包机组下所有的用户(下拉)
    List<User> getBaojiUserByUid(@Param("baojiIdList") List<Integer> baojiIdList);
    //查询密码
    String selectSnId(@Param("uname") String uname);
    //判断是否存在普通用户(uid>100)，若无,初始为10001
    int judgeUname();
    //查询所有用户信息
    List<User> getAllUser(@Param("uname") String uname,@Param("realName")String realName);
    //查询100~1000中最大的uid
    String getIn10000();
    //创建100~1000的id表,不存在则创建
    void createNumber();
    //判断表是否存在
    String existTable();
    //插入默认数据
    void setUnumber(@Param("sql") String sql);
    //查询最大的uid
    String getMaxUid();
    //根据uname获取用户
    User getUinfByUname(@Param("uname") String uname);

    List<User> searchCS_All2();
    //当前用户所在包机组下所有的用户(下拉)
    List<User> getBaojiUserByUid(@Param("baojiIdList") List<Integer> baojiIdList);

}

 src/main/java/com/whyc/service/UserService.java

@@ -1,201 +1,348 @@
package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.whyc.dto.Response;
import com.whyc.dto.UserClient;
import com.whyc.mapper.BaojigroupUsrMapper;
import com.whyc.mapper.PermitGroupUserMapper;
import com.whyc.mapper.UserMapper;
import com.whyc.pojo.db_user.User;
import com.whyc.util.ActionUtil;
import com.whyc.util.CommonUtil;
import com.whyc.util.MD5Util;
import com.whyc.util.RSAUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.security.InvalidParameterException;
import java.util.*;
import java.util.stream.Collectors;

@Service
@Slf4j
public class UserService {

    @Resource
    private UserMapper userMapper;
    private UserMapper mapper;

    @Resource
    private UserBridgeService userBridgeService;
    @Autowired(required = false)
    private BaojigroupUsrMapper bjgroupUsrMapper;

    @Autowired
    private ApplicationContext applicationContext;
    @Autowired(required = false)
    private PermitGroupUserMapper pergroupUserMapper;


    public Response add(User user) {
        try {
            User userFound = userBridgeService.findPasswordByUserName(user.getName());
            if (userFound.getId() != 0) {
                return new Response<>().set(1, false, "用户已存在");
    //查询所有用户信息
    public Response getAllUser(String uname, String realName, int pageCurr, int pageSize) {
        PageHelper.startPage(pageCurr,pageSize);
        List<User> list=mapper.getAllUser(uname,realName);
        PageInfo pageInfo=new PageInfo(list);
        return new Response().setII(1,list!=null,pageInfo,"查询所有用户信息");
            }
            if (userMapper.addJudge(user.getName(),user.getPhoneNumber())>0){
                return new Response<>().set(1, false, "用户已存在");

    //新添加用户信息
    @Transactional
    public Response addUser(User uinf) {
        QueryWrapper wrapper=new QueryWrapper();
        //判断是否存在普通用户(uid>100)，若无,初始为10001
        int judgecount=mapper.judgeUname();
        if(judgecount==0){
            uinf.setId(10001);
            }
            //user.setCreateTime(new Date());
            String[] dataArr = RSAUtil.decryptFrontP(user.getPwd(), RSAUtil.fontSeparator);
            String password = dataArr[0];
            String passwordMD5 = dataArr[1];
            if(!CommonUtil.EncryptionMD5(password).equals(passwordMD5)){
                throw new InvalidParameterException("参数校验失败");
        String pwd= RSAUtil.encrypt("123456", RSAUtil.getPublicKey());
        uinf.setPwd(pwd);
        wrapper.select("uid","uname");
        wrapper.eq("uname",uinf.getName());
        User user=mapper.selectOne(wrapper);
        if(user!=null){
            return new Response().setII(1,false,user,"用户名已存在");
            }
            user.setPwd(RSAUtil.encrypt(password,RSAUtil.getPublicKey()));
            int flag = userMapper.insert(user);
            if (flag > 0) {
                return new Response<>().set(1, true);
        uinf.setCreateTime(new Date());
        int bl=mapper.insert(uinf);
        return new Response().set(1,bl>0);
    }
    //修改密码
    public Response changeSnId(String uname,String oldSnId, String newSnId) {
        if(uname==null||uname.equals("")){
            return new Response().set(1,false,"找不到用户");
        }
        //验证老密码是否正确
        String snIdRsa=mapper.selectSnId(uname);
        //解密
        String snId=RSAUtil.decrypt(snIdRsa,RSAUtil.getPrivateKey());
        String[] decOld=RSAUtil.decryptFrontP(oldSnId,RSAUtil.fontSeparator);
        String oldId=decOld[0];
        String[] newOld=RSAUtil.decryptFrontP(newSnId,RSAUtil.fontSeparator);
        String newId=newOld[0];
        if(oldId.equals(snId)){
            UpdateWrapper wrapper=new UpdateWrapper();
            wrapper.set("usnid",RSAUtil.encrypt(newId,RSAUtil.getPublicKey()));
            wrapper.eq("uname",uname);
            int flag=mapper.update(null,wrapper);
            return  new Response().set(1,flag>0,flag>0?"修改成功":"修改失败");
            } else {
                return new Response<>().set(1, false, "添加失败");
            return new Response().set(1,false,"原密码不正确");
        }
    }

    //校验密码
    public Response checkSnId(String uname, String checksnId) {
        //查询当前用户的密码
        String snIdRsa = mapper.selectSnId(uname);
        String snId = RSAUtil.decrypt(snIdRsa, RSAUtil.getPrivateKey());
        String[] oldchecksnId = RSAUtil.decryptFrontP(checksnId, RSAUtil.fontSeparator);
        String oldId = oldchecksnId[0];
        if (oldId.equals(snId)) {
            return new Response().set(1, true, "密码正确");
        } else {
            return new Response().set(1, false, "密码不正确");
        }
    }
    //重置密码
    public Response resetSnId(int uid ) {
        UpdateWrapper wrapper=new UpdateWrapper();
        wrapper.set("usnid",RSAUtil.encrypt("123456",RSAUtil.getPublicKey()));
        wrapper.eq("uid",uid);
        int flag=mapper.update(null,wrapper);
        return  new Response().set(1,flag>0,flag>0?"修改成功":"修改失败");

    }
    //删除用户信息
    @Transactional
    public Response delUser(String uname) {
        //获取用户的uid
        User User=mapper.getUinfByUname(uname);
        if(User==null){
            return new Response().set(1,false,"用户不存在");
        }else {
            int uid=User.getId();
            UpdateWrapper wrapper=new UpdateWrapper();
            wrapper.eq("uname",uname);
            int bl=mapper.delete(wrapper);
            if(bl>0){
                //删除权限组下的用户
                UpdateWrapper wrapper1=new UpdateWrapper();
                wrapper1.eq("uid",uid);
                pergroupUserMapper.delete(wrapper1);
                //删除包机组下的用户
                UpdateWrapper wrapper2=new UpdateWrapper();
                wrapper2.eq("uid",uid);
                bjgroupUsrMapper.delete(wrapper2);
            }
            return new Response().setII(1,bl>0,bl,"删除成功");
        }
    }

    public Response login(String uname, String usnId, Integer platFrom, HttpServletRequest request) {
        Response response = new Response();
        String[] dataArr = RSAUtil.decryptFrontP(usnId, RSAUtil.fontSeparator);
        //验签md5
        if(dataArr[0]==null||dataArr[1]==null){
            return response.set(1, false, "密码验签失败");
        }
        if (!dataArr[1].equals(MD5Util.encryptMD5(org.apache.commons.lang3.StringUtils.trim(dataArr[0])))) {
            return response.set(1, false, "密码验签失败");
        }
        UsernamePasswordToken userToken = new UsernamePasswordToken(uname, dataArr[0]);
        Subject subject = SecurityUtils.getSubject();
        try {
            subject.login(userToken);
        } catch (Exception e) {
            if(e instanceof UnknownAccountException){
                return response.set(1,false,"账号不存在");
            }
            return response.set(1,false,"密码错误");
        }
        //Session存储当前用户及权限组列表
        User userDB = (User) subject.getPrincipal();
        userDB.setPwd(null);
        //登录成功
        ServletContext servletContext = request.getServletContext();
        servletContext.setAttribute(uname, request.getSession().getId());
        request.getSession().setMaxInactiveInterval(60*30);
        request.getSession().setAttribute("user", userDB);

        return response.setII(1,true, userDB,"登录成功");
    }

    public void logout() {
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
    }
    //将用户添加至100~10000管理员
    public Response improveRole(int uid) {
        //判断表是否存在
        String tableName = mapper.existTable();
        if(tableName==null){
            ///创建100~1000的id表,不存在则创建
            mapper.createNumber();
            //插入默认数据
            String sql=" INSERT INTO temp_numbers(unumber) " +
                    " VALUES ";
            for(int i=101;i<=10000;i++){
                sql+="("+i+")";
                if(i!=10000){
                    sql+=",";
                }
            }
            mapper.setUnumber(sql);
        }
        String minUid=mapper.getIn10000();
        if(minUid==null){
            return new Response().set(1,false,"管理员个数超过上限");
        }
        UpdateWrapper wrapper =new UpdateWrapper();
        wrapper.set("uid",minUid);
        wrapper.eq("uid",uid);
        int flag= mapper.update(null,wrapper);
        return new Response().set(1,flag>0,flag>0?"身份变更成功":"身份变更失败");
    }
    //将管理员变成普通用户
    public Response dropRole(int uid, HttpServletRequest request) {
        //查询最大的uid
        String maxUid=mapper.getMaxUid();
        if(maxUid==null){
            maxUid="10001";
        }
        //根据用户id查询用户信息
        QueryWrapper qWrapper=new QueryWrapper();
        qWrapper.eq("uid",uid);
        qWrapper.last("limit 1");
        User uinf=mapper.selectOne(qWrapper);
        //编辑
        UpdateWrapper wrapper =new UpdateWrapper();
        wrapper.set("uid",Integer.valueOf(maxUid)+1);
        wrapper.eq("uid",uid);
        int flag= mapper.update(null,wrapper);
        //如果是普通用户自己强退，将用户名对应的sessionId变更
        ServletContext servletContext = request.getServletContext();
        servletContext.setAttribute(uinf.getName(),"123456");
        return new Response().set(1,flag>0,flag>0?"身份变更成功":"身份变更失败");
    }

    public Response getUserNameList() {
        QueryWrapper<User> query = Wrappers.query();
        query.select("uname");
        List<String> userNameList = mapper.selectList(query).stream().map(User::getName).collect(Collectors.toList());
        return new Response().set(1,userNameList);
    }

    //登录检测
    public Response checkUserWebSocket(HttpSession httpSession){
        Response model = new Response();
        try {
            User user = (User) httpSession.getAttribute("user");
            if(user!=null){
                String sessionId = (String) httpSession.getServletContext().getAttribute(user.getName());
                if(httpSession.getId().equals(sessionId)){
                    model.set(1,user,null);
                }else{
                    if(sessionId.equals("123456")){
                        model.set(1,false,"身份权限变更,请重新登录");
                    }else{
                        model.set(1,false,"不同主机登录");
                    }
                    //用户在其他主机登录,强迫用户在本机的session失效
                    httpSession.invalidate();
                }
            }
            else {
                model.set(1,false,"用户信息失效,请重新登录");
            }
        }catch (Exception e){
            e.printStackTrace();
            return new Response<>().set(0);
            model.set(1,false,"登录信息失效,重新登录");
        }
        return model;
    }
    //查询所有用户信息(不分页用于下拉)
    public Response getUinf() {
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.select("uid","uname","urole");
        wrapper.gt("uid",100);
        //wrapper.eq("urole",0);//普通用户
        wrapper.orderByAsc("uid");
        List<User> list=mapper.selectList(wrapper);
        return new Response().setII(1,list!=null,list,"查询所有用户信息(不分页用于下拉)");
    }
    //根据uId获取设备信息
    public User getUinfByUId(int uId){
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("id",uId);
        wrapper.last("limit 1");
        User uinf=mapper.selectOne(wrapper);
        return uinf;
    }
    //编辑用户信息
    @Transactional
    public Response updateUinf(User uinf) {
        UpdateWrapper wrapper=new UpdateWrapper();
        if(uinf.getPhoneNumber()!=null){
            wrapper.set("phone_number",uinf.getPhoneNumber());
        }
        wrapper.eq("id",uinf.getId());
        mapper.update(null,wrapper);

        return new Response().set(1,true,"编辑用户信息成功");
    }
    //根据Ukey查询用户
    public User getUserByUKeyId(String ukeyId){
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.select("uid","uname","real_name","urole","create_time","phone_number","address","face_id","ukey_id");
        queryWrapper.eq("ukey_id",ukeyId);
        queryWrapper.last("limit 1");
        User User = mapper.selectOne(queryWrapper);
        return User;
    }

    @CacheEvict(value = "userPage",allEntries = true)
    public Response addByRSA(User user) {
        User userFound = userBridgeService.findPasswordByUserName(user.getName());
        if (userFound.getId() != 0) {
            return new Response<>().set(1, false, "用户名已存在");
    //根据uname查询用户
    public User getUserByUserName(String uname){
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.select("uid","uname","real_name","urole","create_time","phone_number","address","face_id","ukey_id");
        queryWrapper.eq("uname",uname);
        queryWrapper.last("limit 1");
        User User = mapper.selectOne(queryWrapper);
        return User;
        }
        User userOfPhoneNumber = userBridgeService.getUserByPhoneNumber(user.getPhoneNumber());
        if (userOfPhoneNumber.getId()!=0) {
            return new Response<>().set(1, false, "手机号已存在");
        }
        //String password = URLDecoder.decode(user.getUpassword(), "utf-8");
        String password = user.getPwd();
        String[] dataArr = RSAUtil.decryptFront(password, RSAUtil.fontSeparator);
        String pwd = RSAUtil.encrypt(dataArr[0],RSAUtil.getPublicKey());
        user.setPwd(pwd);
        user.setCreateTime(new Date());
        int flag = userMapper.insert(user);
        if (flag > 0) {
            return new Response<>().set(1, true);
        } else {
            return new Response<>().set(1, false, "添加失败");
        }
    }

    /*public Response registerUser(User user){
        try {
            User userFound = userBridgeService.findPasswordByUserName(user.getName());
            if (userFound.getId() != 0) {
                return new Response<>().set(1, false, "用户名已存在");
            }
            User userOfMobilephone = userBridgeService.findUserByMobilephone(user.getPhoneNumber());
            if (userOfMobilephone.getId()!=0) {
                return new Response<>().set(1, false, "手机号已存在");
            }
            //String password = URLDecoder.decode(user.getUpassword(), "utf-8");
            String password = user.getPwd();

            String[] dataArr = RSAUtil.decryptFront(password, RSAUtil.fontSeparator);
            String pwd = RSAUtil.encrypt(dataArr[0],RSAUtil.getPublicKey());
            user.setPwd(pwd);
            int flag = userMapper.insert(user);
            if (flag > 0) {
                //添加成功,分配到默认初始化权限组
                return new Response<>().set(1, true,"注册成功");
            } else {
                return new Response<>().set(1, false, "注册失败");
            }
        }catch (Exception e){
            e.printStackTrace();
            return new Response<>().set(0);
        }
    }*/

    public User getById(int id) {
        User user = userMapper.selectById(id);
        user.setPwd((String) CommonUtil.objectNull);
        return user;
    }

    public List<User> getAll() {
        List<User> users = userMapper.selectList((Wrapper<User>) CommonUtil.objectNull);
        return users;
    }

    @Cacheable(value = "userPage")
    public Response getPage(int pageNum,int pageSize) {
        PageHelper.startPage(pageNum,pageSize);
        List<User> list = userMapper.selectList((Wrapper<User>) CommonUtil.objectNull);
        for (User user:list) {
            user.setPwd((String) CommonUtil.objectNull);
        }
        PageInfo<User> pageInfo = new PageInfo<>(list);
        return new Response().set(1,pageInfo,"查询成功");
    }

    @CacheEvict(value = "userPage",allEntries = true)
    public Response update(User user) {
        User userFound = userBridgeService.findPasswordByUserName(user.getName());
        User userOfPhoneNumber = userBridgeService.getUserByPhoneNumber(user.getPhoneNumber());
        if (userFound.getId() != 0 && !userFound.getId().equals(user.getId())) {
            return new Response().set(1,false,"用户名重复");
        }
        if( userOfPhoneNumber.getId()!=0 && !userFound.getId().equals(user.getId())){
            return new Response().set(1,false,"手机号重复");
        }
        user.setPwd(null);
        if(userMapper.updateById(user)>0){
            return new Response().set(1,true,"修改成功");
        }else{
            return new Response().set(1,false,"修改失败");
        }

    }


    // 将所有登陆的用户的信息存到application中
    public void setApplication(User user) {
        ServletContext application = CommonUtil.getApplication();
        ServletContext application = ActionUtil.getApplication();
        //查看全局中存储的users的Map的key-value集合
        Map<String, UserClient> map = (Map) application.getAttribute("users");
        if (map == CommonUtil.objectNull) {
        if (map == ActionUtil.objeNull) {
            map = new HashMap<String, UserClient>();
        } else {
            //如果集合中有值,则获取当前用户对应的用户信息,key为用户名username,Value为用户名,存储的时间
            UserClient client = map.get(user.getName());
            if (client != CommonUtil.objectNull) { //已存在
            if (client != ActionUtil.objeNull) { //已存在
                map.remove(user.getName());
            }
        }
        Long login_time = new Date().getTime();
        CommonUtil.getSession().setAttribute("login_time", login_time);
        map.put(user.getName(), new UserClient(CommonUtil.getRequest().getRemoteAddr(),user,login_time));
        ActionUtil.getSession().setAttribute("login_time", login_time);
        map.put(user.getName(), new UserClient(ActionUtil.getRequest().getRemoteAddr(),user,login_time));
        application.setAttribute("users", map);
    }


    public Response updatePasswordByRSA(User user, String newPwd){
        String[] dataArr = RSAUtil.decryptFrontP(newPwd, RSAUtil.fontSeparator);
        newPwd = dataArr[0];
        String passwordMD5 = dataArr[1];
        if(!CommonUtil.EncryptionMD5(newPwd).equals(passwordMD5)){
            throw new InvalidParameterException("参数校验失败");
        }
        String pwd = RSAUtil.encrypt(newPwd,RSAUtil.getPublicKey());
        user.setPwd(pwd);
        if (userMapper.updateById(user)>0){
            return new Response().set(1,true,"新密码修改成功");
        }else {
            return new Response().set(0,false,"新密码修改失败");
        }
    }
    public List<User> searchCS_All2() {
        return userMapper.searchCS_All2();
        return mapper.searchCS_All2();
    }
}

 src/main/resources/mapper/UserMapper.xml

@@ -2,15 +2,58 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.whyc.mapper.UserMapper" >

    <select id="addJudge" resultType="int">
        select count(id) as nums from db_user.tb_user where name=#{name} or phone_number=#{phoneNumber} limit 1
    <select id="searchCS_All2" resultType="com.whyc.pojo.db_user.User">
        SELECT id,name FROM db_user.tb_user  where id not in (select distinct id from db_user.tb_permitgroup_usr) and id>100
        order by id
    </select>
    <update id="createNumber">
        CREATE TABLE if not exists db_user.temp_numbers (unumber INT);
    </update>
    <update id="setUnumber">
        ${sql}
    </update>
    <select id="existTable" resultType="java.lang.String">
        select
            table_name
        from `INFORMATION_SCHEMA`.`TABLES`
        where table_name = 'temp_numbers'
          and TABLE_SCHEMA = 'db_user'
    </select>

    <select id="selectSnId" resultType="java.lang.String">
        select pwd from db_user.tb_user where name=#{name} limit 1
    </select>
    <select id="judgeUname" resultType="java.lang.Integer">
        select count(*) from  db_user.tb_user where id>10000
    </select>
    <select id="getAllUser" resultType="User">
        select distinct tb_user.id,tb_user.name,create_time,phone_number from db_user.tb_user
        <where>
            tb_user.id>100
            <if test="name!=null">
                and name LIKE CONCAT('%',#{uname},'%')
            </if>
        </where>
        order by create_time desc
    </select>
    <select id="getIn10000" resultType="java.lang.String">
        SELECT min(unumber)
        FROM db_user.temp_numbers t
        WHERE t.unumber NOT IN (SELECT id FROM db_user.tb_user);
    </select>
    <select id="getMaxUid" resultType="java.lang.String">
        SELECT max(id)
        FROM db_user.tb_user  where id>10000
    </select>
    <select id="getUinfByUname" resultType="com.whyc.pojo.db_user.User">
        select name,id from db_user.tb_user where name=#{name} limit 1
    </select>
    <select id="getBaojiUserByUid" resultType="com.whyc.pojo.db_user.User">
        SELECT id,uname FROM  db_user.tb_user
        SELECT id,name FROM  db_user.tb_user
        <where>
            id>100 and
            id in(
            select distinct uid from  db_user.tb_baojigroup_usr
            select distinct id from  db_user.tb_baojigroup_usr
            <where>
                baoji_id in(
                <foreach collection="baojiIdList" item="baojiId" open="(" separator="," close=")">
@@ -20,11 +63,6 @@
            </where>
            )
        </where>
    </select>

    <select id="searchCS_All2" resultType="com.whyc.pojo.db_user.User">
        SELECT uid,uname FROM db_user.tb_user  where uid not in (select distinct uid from db_user.tb_user_permitgroup_usr) and uid>100
        order by uid
    </select>

</mapper>