第一次修改

whyclxw

2 天以前 a6cc744ff61cdea5453b8661694b1be0220f8533

第一次修改

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

New file
@@ -0,0 +1,495 @@
/*
package com.whyc.service;

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.constant.OperationLogEnum;
import com.whyc.constant.UserConstant;
import com.whyc.dto.Response;
import com.whyc.dto.UserClient;
import com.whyc.mapper.BaojigroupUsrMapper;
import com.whyc.mapper.PageParamMapper;
import com.whyc.mapper.PermitGroupUserMapper;
import com.whyc.mapper.UserMapper;
import com.whyc.pojo.db_app_sys.PageParam;
import com.whyc.pojo.db_user.Baojigroup;
import com.whyc.pojo.db_user.BaojigroupUsr;
import com.whyc.pojo.db_user.User;
import com.whyc.util.ActionUtil;
import com.whyc.util.CommonUtil;
import com.whyc.util.RSAUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
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.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
@Slf4j
public class UserService {

    @Resource
    private UserMapper mapper;

    @Autowired(required = false)
    private BaojigroupUsrMapper bjgroupUsrMapper;

    @Autowired(required = false)
    private PermitGroupUserMapper pergroupUserMapper;

    @Resource
    private PageParamMapper pageParamMapper;


    //查询所有用户信息
    public Response getAllUser(String uname, int pageCurr, int pageSize) {
        PageHelper.startPage(pageCurr,pageSize);
        List<User> list=mapper.getAllUser(uname);
        PageInfo pageInfo=new PageInfo(list);
        return new Response().setII(1,list!=null,pageInfo,"查询所有用户信息");
    }

    //新添加用户信息
    @Transactional
    public Response addUser(User uinf) {
        QueryWrapper wrapper=new QueryWrapper();
        //判断是否存在普通用户(uid>100)，若无,初始为10001
        int judgecount=mapper.judgeUname();
        if(judgecount==0){
            uinf.setId(10001);
        }
        String pwd= RSAUtil.encrypt("123456", RSAUtil.getPublicKey());
        uinf.setPwd(pwd);
        wrapper.select("id","name");
        wrapper.eq("name",uinf.getName());
        User user=mapper.selectOne(wrapper);
        if(user!=null){
            return new Response().setII(1,false,user,"用户名已存在");
        }
        uinf.setCreateTime(new Date());
        int flag=mapper.insert(uinf);
        if(flag>0){
            //记录日志
            CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_ADD.getType(),
                    OperationLogEnum.TYPE_2_USER_ADD.getName(),"添加用户成功,用户名为:"+uinf.getName());
            return new Response().set(1,true,"用户添加成功");
        }else {
            //记录日志
            CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_ADD.getType(),
                    OperationLogEnum.TYPE_2_USER_ADD.getName(),"添加用户失败,用户名为:"+uinf.getName());
            return new Response().set(1,false,"用户添加失败");
        }
    }
    //修改密码
    public Response changeSnId(String uname,String oldSnId, String newSnId) {
        if(uname==null||uname.equals("")){
            //记录日志
            CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_CHANGEPWD.getType(),
                    OperationLogEnum.TYPE_2_USER_CHANGEPWD.getName(),"修改用户失败,找不到用户,用户名为:"+uname);
            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("pwd",RSAUtil.encrypt(newId,RSAUtil.getPublicKey()));
            wrapper.eq("name",uname);
            int flag=mapper.update(null,wrapper);
            if(flag>0){
                //记录日志
                CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_CHANGEPWD.getType(),
                        OperationLogEnum.TYPE_2_USER_CHANGEPWD.getName(),"修改用户成功,用户名为:"+uname);
                return  new Response().set(1,true,"修改成功");
            }else{
                //记录日志
                CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_CHANGEPWD.getType(),
                        OperationLogEnum.TYPE_2_USER_CHANGEPWD.getName(),"修改用户失败,用户名为:"+uname);
                return  new Response().set(1,true,"修改失败");
            }
        }else {
            //记录日志
            CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_CHANGEPWD.getType(),
                    OperationLogEnum.TYPE_2_USER_CHANGEPWD.getName(),"修改用户失败,原密码不正确,用户名为:"+uname);
            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("pwd",RSAUtil.encrypt("123456",RSAUtil.getPublicKey()));
        wrapper.eq("id",uid);
        int flag=mapper.update(null,wrapper);
        //记录日志
        QueryWrapper<User> query = Wrappers.query();
        query.eq("id",uid);
        User userInDB = mapper.selectOne(query);
        if(flag>0){
            CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_UPDATE_PASSWORD.getType(),
                    OperationLogEnum.TYPE_2_USER_UPDATE_PASSWORD.getName(),"重置密码成功,用户名为:"+userInDB.getName());
            return  new Response().set(1,true,"重置密码成功");
        }else{
            CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_UPDATE_PASSWORD.getType(),
                    OperationLogEnum.TYPE_2_USER_UPDATE_PASSWORD.getName(),"重置密码失败,用户名为:"+userInDB.getName());
            return  new Response().set(1,false,"重置密码失败");
        }
    }
    //删除用户信息
    @Transactional
    public Response delUser(String uname) {
        //获取用户的uid
        User User=mapper.getUinfByUname(uname);
        if(User==null){
            //记录日志
            CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_DELETE.getType(),
                    OperationLogEnum.TYPE_2_USER_DELETE.getName(),"删除用户成功,用户不存在,用户名为:"+uname);
            return new Response().set(1,false,"用户不存在");
        }else {
            int uid=User.getId();
            UpdateWrapper wrapper=new UpdateWrapper();
            wrapper.eq("name",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);
            }
            //记录日志
            CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_DELETE.getType(),
                    OperationLogEnum.TYPE_2_USER_DELETE.getName(),"删除用户成功,用户名为:"+uname);
            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){
            CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_IN_ADMIN.getType(),
                    OperationLogEnum.TYPE_2_USER_IN_ADMIN.getName(),"被加入管理员失败,管理员个数超过上限");
            return new Response().set(1,false,"管理员个数超过上限");
        }
        UpdateWrapper wrapper =new UpdateWrapper();
        wrapper.set("id",minUid);
        wrapper.eq("id",uid);
        int flag= mapper.update(null,wrapper);
        //记录日志
        QueryWrapper query = Wrappers.query();
        query.eq("id",minUid);
        User userInDB = mapper.selectOne(query);
        if(flag>0){
            CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_IN_ADMIN.getType(),
                    OperationLogEnum.TYPE_2_USER_IN_ADMIN.getName(),"被加入管理员成功,用户为:"+userInDB.getName());
            return new Response().set(1,true,"身份变更管理员成功");
        }else{
            CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_IN_ADMIN.getType(),
                    OperationLogEnum.TYPE_2_USER_IN_ADMIN.getName(),"被加入管理员失败,用户为:"+userInDB.getName());
            return new Response().set(1,false,"身份变更管理员失败");
        }
    }
    //将管理员变成普通用户
    public Response dropRole(int uid, HttpServletRequest request) {
        //查询最大的uid
        String maxUid=mapper.getMaxUid();
        if(maxUid==null){
            maxUid="10001";
        }
        //根据用户id查询用户信息
        QueryWrapper qWrapper=new QueryWrapper();
        qWrapper.eq("id",uid);
        qWrapper.last("limit 1");
        User uinf=mapper.selectOne(qWrapper);
        //编辑
        UpdateWrapper wrapper =new UpdateWrapper();
        wrapper.set("id",Integer.valueOf(maxUid)+1);
        wrapper.eq("id",uid);
        int flag= mapper.update(null,wrapper);
        //如果是普通用户自己强退，将用户名对应的sessionId变更
        ServletContext servletContext = request.getServletContext();
        servletContext.setAttribute(uinf.getName(),"123456");
        //查询被更改的用户信息
        QueryWrapper<User> query = Wrappers.query();
        query.eq("id",uid);
        User userInDB = mapper.selectOne(query);
        if(flag>0){
            CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_OUT_ADMIN.getType(),
                    OperationLogEnum.TYPE_2_USER_OUT_ADMIN.getName(),"被加入普通用户成功,用户为:"+userInDB.getName());
            return new Response().set(1,true,"身份变更普通用户成功");
        }else{
            CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_OUT_ADMIN.getType(),
                    OperationLogEnum.TYPE_2_USER_OUT_ADMIN.getName(),"被加入普通用户失败,用户为:"+userInDB.getName());
            return new Response().set(1,false,"身份变更普通用户失败");
        }
    }

    public Response getUserNameList() {
        QueryWrapper<User> query = Wrappers.query();
        query.select("distinct name");
        query.ge("id",100);
        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){
            model.set(1,false,"登录信息失效,重新登录");
        }
        return model;
    }
    //查询所有用户信息(不分页用于下拉)
    public Response getUinf() {
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.select("id","name");
        wrapper.gt("id",100);
        wrapper.orderByAsc("id");
        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());
        }
        if(uinf.getSex()!=null){
            wrapper.set("sex",uinf.getSex());
        }
        if(uinf.getEmail()!=null){
            wrapper.set("email",uinf.getEmail());
        }
        if(uinf.getRole()!=null){
            wrapper.set("role",uinf.getRole());
        }
        if(uinf.getDischrRole()!=null){
            if(uinf.getDischrRole()==2){
                //判断当要将用户改为2工作负责人时，需要检测用户所在的班组下是否存在工作负责人（一个班组包机组只能有一个工作负责人）
                Integer flag=checkUidIsNotDischrRole2(uinf.getId());
                if(flag==1){
                    CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_UPDATE.getType(),
                            OperationLogEnum.TYPE_2_USER_UPDATE.getName(),"编辑用户权限为工作负责人失败");
                    return new Response().set(1,false,"该用户不能变更为工作负责人,用户所在班组已存在其他工作负责人");
                }else{
                    wrapper.set("dischr_role",uinf.getDischrRole());
                }
            }else{
                wrapper.set("dischr_role",uinf.getDischrRole());
            }

        }
        wrapper.eq("id",uinf.getId());
        mapper.update((User) ActionUtil.objeNull,wrapper);
        CommonUtil.record(OperationLogEnum.TYPE_1_SYS.getType(), OperationLogEnum.TYPE_2_USER_UPDATE.getType(),
                OperationLogEnum.TYPE_2_USER_UPDATE.getName(),"编辑用户权限成功");
        return new Response().set(1,true,"编辑用户信息成功");
    }
    //判断当要将用户改为2工作负责人时，需要检测用户所在的班组下是否存在工作负责人（一个班组包机组只能有一个工作负责人）
    private Integer checkUidIsNotDischrRole2(Integer uid) {
        Integer flag=0;
        //用户是否存在班组包机组
        List<Baojigroup> banzuList = bjgroupUsrMapper.getBanZuBaojiByUid(uid);
        if(banzuList!=null&&banzuList.size()>0){
            for(Baojigroup bj:banzuList){
                //班组包机组下是否存在用户是工作负责人
                List<BaojigroupUsr> dischrRole2UsrList = bjgroupUsrMapper.getDischrRole2ByBjId(bj.getBaojiGroupId());
                if(dischrRole2UsrList!=null&&dischrRole2UsrList.size()>0){
                    flag=1;
                    break;
                }
            }
        }else{
            flag=0;
        }
        return flag;
    }

    //根据uname查询用户
    public User getUserByUserName(String uname){
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.select("id","name","create_time","phone_number");
        queryWrapper.eq("name",uname);
        queryWrapper.last("limit 1");
        User User = mapper.selectOne(queryWrapper);
        return User;
    }
    */
/**锁定账号*//*

    public void lock(Integer uId) {
        UpdateWrapper<User> wrapper = Wrappers.update();
        wrapper.set("status", UserConstant.ACCOUNT_STATUS_LOCK_FAIL.getValue()).set("lock_time",new Date()).eq("id",uId);
        mapper.update((User) ActionUtil.objeNull,wrapper);
    }

    */
/**更新登录时间*//*

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

    //验证密码的时效性
    public int checkPasswordValidity(User uinf) {
        int flag=1;
        //获取系统设置的密码时效(57,15)
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("categoryId",15);
        wrapper.eq("id",57);
        wrapper.last("limit 1");
        PageParam pageParam=pageParamMapper.selectOne(wrapper);
        if(pageParam!=null){
            int dayDifference=ActionUtil.daysBetween(uinf.getPasswordUpdateTime(),new Date());
            if((pageParam.getStatus()>0)&&(dayDifference>pageParam.getStatus())){
                flag= -1;
            }
        }
        return flag;
    }
    //查询未被添加到所有权限组的用户(一个人只能存在一个权限组)
    public List<User> searchCS_All2() {
        return mapper.searchCS_All2();
    }
}
*/