fxkh-txl-service/src/main/java/com/whdc/service/impl/UserServiceImpl.java

package com.whdc.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.sun.org.apache.bcel.internal.generic.NEW;
import com.whdc.exception.MyException;
import com.whdc.mapper.AddressBookMapper;
import com.whdc.mapper.UserMapper;
import com.whdc.model.dto.LoginDto;
import com.whdc.model.dto.UserDto;
import com.whdc.model.entity.AddressBook;
import com.whdc.model.entity.User;
import com.whdc.model.vo.LoginVo;
import com.whdc.service.IUserService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.whdc.utils.HttpUtil;
import org.apache.commons.lang3.StringUtils;
import com.whdc.utils.ResultJson;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

import java.util.Date;
import java.util.List;
import java.util.Random;
import java.util.Objects;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

import static com.whdc.model.MyConstant.REDIS_KEY;


/**
 * <p>
 * 服务实现类
 * </p>
 * @author xusan
 * @date 2024-05-11
 */
@Service
@Slf4j
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {

    public static final String DEFAULT_PASSWORD = "Fxkh@123456";

    @Autowired
    private AddressBookMapper addressBookMapper;

    @Autowired
    private RedisTemplate stringRedisTemplate;

    @Override
    public IPage<User> page(User dto) {
        return baseMapper.page(new Page<>(), dto);
    }


    @Override
    public List<User> find(User dto) {
        return baseMapper.find(dto);
    }



    @Override
    public LoginVo login(LoginDto dto) {

        User sysUser = findByLoginName(dto.getLoginName());

        if (sysUser == null) {
            throw new MyException("用户名或密码错误");
        }

        if (getPassword(sysUser.getSalt() ,dto.getPassword()).equals(sysUser.getPassword())) {
            LoginVo out = new LoginVo();
            BeanUtils.copyProperties(sysUser, out);

            AddressBook book = addressBookMapper.selectById(sysUser.getAbId());
            if (Objects.nonNull(book)){
                out.setName(book.getName());
            }
            return out;

        }

        throw new MyException("用户名或密码错误");
    }

    @Override
    public boolean register(User entity) {
        // 生成盐值
        String salt = UUID.randomUUID().toString().replaceAll("-", "");
        // 生成密码
        entity.setSalt(salt)
                .setPassword(getPassword(salt, DEFAULT_PASSWORD));
        return this.save(entity);
    }

    @Override
    public String getRole(Integer id) {

        User byId = this.getById(id);
        if (byId == null){
            throw new MyException("该用户不存在");
        }

        return byId.getRole();
    }

    @Override
    public boolean register(String phone, Integer abId, String role) {
        User user = new User();
        user.setAbId(abId)
                .setRole(role)
                .setUsername(phone);
        return register(user);
    }

    @Override
    public boolean updateLastDate(Integer id) {
        return this.lambdaUpdate()
                .set(User::getLastLoginDate,new Date())
                .eq(User::getId,id)
                .update();
    }

    @Override
    public boolean pushCode(String phone) {

        // 匹配手机号是否存在
        LambdaQueryWrapper<AddressBook> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(AddressBook::getPhone, phone);
        if (addressBookMapper.selectOne(queryWrapper) == null) {
            throw new MyException("当前手机号不存在");
        }
        // 判断是否以发送
        String key = REDIS_KEY + "code:" + phone;
        String code = String.valueOf(stringRedisTemplate.opsForValue().get(key));
        if (StringUtils.isBlank(code)) {
            // 生成验证码
            String numCode = getNumCode();
            push(phone, numCode);
            stringRedisTemplate.opsForValue().set(key, numCode, 60, TimeUnit.SECONDS);
        } else {
            throw new MyException("请勿重复发送验证码");
        }


        return true;
    }

    @Override
    public LoginVo loginByCode(String phone, String code) {
        // 匹配手机号是否存在
        LambdaQueryWrapper<AddressBook> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(AddressBook::getPhone, phone);
        AddressBook addressBook = addressBookMapper.selectOne(queryWrapper);
        if (addressBook == null) {
            throw new MyException("当前手机号不存在");
        }

        // 判断是否以发送
        String key = REDIS_KEY + "code:" + phone;
        String pushCode = String.valueOf(stringRedisTemplate.opsForValue().get(key));
        if (StringUtils.isBlank(pushCode)) {
            throw new MyException("当前验证码已过期");
        }

        if (!pushCode.equals(code)) {
            throw new MyException("验证码错误");
        }


        User sysUser = this.lambdaQuery().eq(User::getAbId, addressBook.getId()).one();

        if (sysUser == null) {
            throw new MyException("当前账号暂未注册");
        }

        LoginVo out = new LoginVo();
        BeanUtils.copyProperties(sysUser, out);
        out.setName(addressBook.getName());
        return out;
    }


    public static String getCode() {
        Random yzm = new Random();                          //定义一个随机生成数技术，用来生成随机数
        //2，用String常用API-charAit生成验证码
        String yzm1 = "1234567890abcdefghijklmnopqrstuvwxwzABCDEFGHIJKLMNOPQRSTUVWXYZ";//定义一个String变量存放需要的数据，一共58位
        String yzm3 = "";//定义一个空的Atring变量用来接收生成的验证码
        for (int i = 0; i < 5; i++) {
            int a = yzm.nextInt(58);//随机生成0-57之间的数，提供索引位置
            yzm3 += yzm1.charAt(a);//用get 和提供的索引找到相应位置的数据给变量
        }
        return yzm3;

    }

    public static String getNumCode() {
        //1，用随机生成数方法，生成验证码
        Random yzm = new Random();                          //定义一个随机生成数技术，用来生成随机数

        String yzm2 = "";                                   //定义一个空的Atring变量用来接收生成的验证码

        for (int i = 0; i < 5; i++) {                       //循环5次每次生成一位，5位验证码

            int a = yzm.nextInt(3);                             //验证码包括数字、大小写字母组成
            switch (a) {                                          //a:    0       1       2
                case 0:                                         //      数字   小写字母   大写字母
                    char s = (char) (yzm.nextInt(26) + 65);
                    yzm2 = yzm2 + s;
                    break;
                case 1:
                    char s1 = (char) (yzm.nextInt(26) + 97);
                    yzm2 = yzm2 + s1;
                    break;
                case 2:
                    int s2 = yzm.nextInt(10);
                    yzm2 = yzm2 + s2;
                    break;
            }
        }
        return yzm2;
    }

    /**
     * 消息推送
     *
     * @param phone
     * @param code
     */
    public void push(String phone, String code) {

        String content = "您正在登录湖北省防汛抗旱通讯录，验证码为：" + code + "，若非本人操作，请勿将验证码泄露他人。";

        String body = "{\n" +
                "  \"channel\": \"[phone]\",\n" +
                "  \"content\": \"" + content + "\",\n" +
                "  \"devices\": \"['" + phone + "']\",\n" +
                "  \"foreignId\": \"" + UUID.randomUUID() + "\",\n" +
                "  \"source\": \"山洪app\",\n" +
//                "  \"token\": \"\",\n" +

//                消息类别，3为监测预警，4为预报预警，5自定义短信,示例值(3)
                "  \"type\": 5\n" +
                "}";

        HttpUtil.sendPost("http://223.75.53.141:82/shpush/v1/push/", body);
    }


    @Override
    public ResultJson updatePwd(UserDto dto) {


        User sysUser = this.getById(dto.getId());
        if (Objects.isNull(sysUser)) {

            return ResultJson.error("当前数据不存在");

        }


        if (getPassword(sysUser.getSalt() ,dto.getOldPassword()).equals(sysUser.getPassword())) {
            // 更新密码
            sysUser.setPassword(getPassword(sysUser.getSalt() ,dto.getNewPassword()));
            log.info("修改密码" + sysUser.getUsername() + "_" +  dto.getNewPassword());
            return ResultJson.ok(sysUser.updateById());
        }

        return ResultJson.error("密码错误");
    }

    private User findByLoginName(String loginName) {
        if (loginName == null) {
            throw new MyException("登录名不能为空");
        }

        return this.lambdaQuery().eq(User::getUsername, loginName).one();

    }

    public static String getPassword(String salt,String password) {
        return DigestUtils.md5DigestAsHex((salt + password).getBytes());
    }

    public static void main(String[] args) {
        String salt = UUID.randomUUID().toString().replaceAll("-", "");
        System.out.println(salt);
        System.out.println(DigestUtils.md5DigestAsHex((salt + DEFAULT_PASSWORD).getBytes()));
    }
}