博客

package com.heima.sky74.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateField;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.jwt.JWTPayload;
import cn.hutool.jwt.JWTUtil;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.heima.sky74.dto.PageDTO;
import com.heima.sky74.enums.EmpStatus;
import com.heima.sky74.mapper.EmployeeMapper;
import com.heima.sky74.pojo.Employee;
import com.heima.sky74.service.EmployeeService;
import com.heima.sky74.utils.TokenThreadLocal;
import com.heima.sky74.vo.PageResult;
import com.heima.sky74.vo.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;

/**
 * @author yunfei
 * @date 2023年06月21日 11:30
 */
@Service
public class EmployeeServiceImpl implements EmployeeService {
    @Autowired
    private EmployeeMapper employeeMapper;

    @Value("${token.key}")
    private String tokenKey;

    /**
     * 后台员工登录业务实现
     *
     * @param employee
     * @return
     */
    @Override
    public Result login(Employee employee) {
        // 校验参数
        // 校验对象是否为空 校验用户名是否为空 校验密码是否为空
        /**
         *isNotEmpty判断对象有值。
         *
         * isEmpty判断这个对象是否为空。
         */
        if (!ObjUtil.isAllNotEmpty(employee, employee.getUsername(), employee.getPassword()))
            return Result.error("参数不全");

        // 根据用户名查询数据库 (建议根据用户名去查询)
        Employee emp = employeeMapper.selectEmployeeByUsername(employee.getUsername());
        // 判断用户是否为空
        if (ObjUtil.isNull(emp))
            return Result.error("用户不存在");

        // 判断密码是否正确
        if (!emp.getPassword().equals(SecureUtil.md5(employee.getPassword())))
            return Result.error("密码错误");

        // 生成Token 组装Resut 并返回
        // 获取当前系统时间
        DateTime now = DateTime.now();
        // 三天以后的时间
        DateTime newTime = now.offsetNew(DateField.DAY_OF_MONTH, 3);

        // 第二部分信息
        Map<String, Object> payload = new HashMap<String, Object>();
        //签发时间
        payload.put(JWTPayload.ISSUED_AT, now);
        //过期时间
        payload.put(JWTPayload.EXPIRES_AT, newTime);
        //生效时间
        payload.put(JWTPayload.NOT_BEFORE, now);
        //载荷
        payload.put("userName", emp.getUsername());
        payload.put("id", emp.getId());
        /* 密钥不要在代码中写死 最安全的做法是写到配置文件中 然后定期更新 */
        String token = JWTUtil.createToken(payload, tokenKey.getBytes());

        HashMap<String, Object> mm = new HashMap<>();
        mm.put("token", token);
        mm.put("username", emp.getUsername());
        mm.put("id", emp.getId());
        mm.put("name", emp.getName());

        return Result.builder()
                .code(1)
                .msg("登录成功")
                .data(mm)
                .build();
    }

    /**
     * 新增员工的业务实现
     *
     * @param employee
     * @return
     */
    @Override
    public Result addEmployee(Employee employee) {
        // 校验参数非空 且数据库表中非空字段是非空的
        if (!ObjUtil.isAllNotEmpty(employee, employee.getName(), employee.getUsername(),
                employee.getPhone(), employee.getSex(), employee.getIdNumber()))
            return Result.error("参数不全");
        // 判断用户是否登录
        // 不需要写了 因为如果用户没有登录 在拦截器就返回了

        // 校验用户名是否已经被占用
        Employee usernameEmp = employeeMapper.selectEmployeeByUsername(employee.getUsername());
        if (ObjUtil.isNotNull(usernameEmp))
            return Result.error("用户名已被占用");

        // 校验手机号码是否被占用 手机号码格式是否正确
        if (!employee.getPhone().matches("^(13[0-9]|14[01456879]|15[0-35-9]|16[2567]|17[0-8]|18[0-9]|19[0-35-9])\\d{8}$")) {
            return Result.error("手机号码格式非法");
        }

        Employee phoneEmp = employeeMapper.selectEmployeeByPhoneNum(employee.getPhone());
        if (ObjUtil.isNotNull(phoneEmp))
            return Result.error("手机号码已被占用");

        // 校验身份证号码是否被占用 身份证号码是否正确
        if (!employee.getIdNumber().matches("(^\\d{15}$)|(^\\d{18}$)|(^\\d{17}(\\d|X|x)$)")) {
            return Result.error("身份证号码格式非法");
        }
        Employee idNumEmp = employeeMapper.selectEmployeeByIDNum(employee.getIdNumber());
        if (ObjUtil.isNotNull(idNumEmp))
            return Result.error("身份证已被占用");

        // 保存数据到数据库中
        // 设置默认属性值
        // 对密码进行加密
        employee.setPassword(SecureUtil.md5("123456"));
        employee.setStatus(1);
        employee.setCreateTime(LocalDateTime.now());
        employee.setUpdateTime(LocalDateTime.now());
        employee.setCreateUser(TokenThreadLocal.get());
        employee.setUpdateUser(TokenThreadLocal.get());
        employeeMapper.saveEmployee(employee);

        // 返回Result
        return Result.builder()
                .data(null)
                .code(1)
                .msg("新增员工成功")
                .build();
    }

    /**
     * 员工分页查询业务实现
     *
     * @param pageDTO
     * @return
     */
    @Override
    public Result selectPageEmp(PageDTO pageDTO) {
        // 校验分页参数
        pageDTO.checkPage();
        // 分页查询
        // 使用分页插件进行分页
        PageHelper.startPage(pageDTO.getPage(), pageDTO.getPageSize());
        Page<Employee> list = employeeMapper.selectPageEmp(pageDTO.getName());
        PageResult pageResult = new PageResult();
        pageResult.setTotal(list.getTotal());
        pageResult.setRecords(list.getResult());
        // 返回Result
        return Result.builder()
                .data(pageResult)
                .code(1)
                .msg("查询成功")
                .build();
    }

    /**
     * 修改员工状态
     *
     * @param status
     * @param id
     * @return
     */
    @Override
    public Result editEmpStatus(Integer status, Long id) {
        // 校验参数
        if (!ObjUtil.isAllNotEmpty(status, id)) return Result.error("参数不合法");
        // 实际开发中应该使用 枚举类
        // 直接在代码中写死的数字称之为 魔法数字
        if (status != EmpStatus.EMP_ENABLE.getStatus()
                && status != EmpStatus.EMP_DISENABLE.getStatus()) return Result.error("参数不合法");
        if (id < 1) return Result.error("参数不合法");
        // 调用Mapper更新数据
        Employee employee = new Employee();
        employee.setId(id);
        employee.setStatus(status);
        // 更新时间
        employee.setUpdateTime(LocalDateTime.now());
        // 更新人
        employee.setUpdateUser(TokenThreadLocal.get());
        employeeMapper.updateEmp(employee);

        return Result.success();
    }

    /**
     * 根据员工id查询员工信息
     *
     * @param id
     * @return
     */
    @Override
    public Result selectIdEmp(Long id) {
        // 参数校验
        if (ObjUtil.isNull(id) || id < 1) return Result.error("参数不合法");
        Employee employee = employeeMapper.selectIdEmp(id);
        if (ObjUtil.isNull(employee)) return Result.error("用户不存在");
        return Result.success(employee);
    }

    /**
     * 根据id更新员工信息
     *
     * @param employee
     * @return
     */
    @Override
    public Result updateEmp(Employee employee) {
        // 对参数进行校验
        // 参考新增用户校验
        // 更新到数据库中
        employee.setUpdateTime(LocalDateTime.now());
        employee.setUpdateUser(TokenThreadLocal.get());
        employeeMapper.updateEmp(employee);
        return Result.success();
    }

    /**
     * 修改密码
     *
     * @param employee
     * @return
     */
    @Override
    public Result editPassword(HashMap<String, String> employee) {

        // 校验参数


        /**
         * CollUtil.isEmpty（）判断集合是否为空
         */
        if (CollUtil.isEmpty(employee)) return Result.error("参数不合法");
        // 获取当前登录用户的id 判断和修改的用户ID是否一致

/**
 * 比较两个字符串是否相等,如果两个均为null，则也认为相等
 */
        // 根据id查询EMP对象 判断旧密码是否正确
        Employee selectIdEmp = employeeMapper.selectIdEmp(TokenThreadLocal.get());

        if (!StrUtil.equals(selectIdEmp.getPassword(),
                SecureUtil.md5(employee.get("oldPassword")))) {
            return Result.error("旧密码错误");
        }
        // 判断新旧密码是否一致
        if (StrUtil.equals(employee.get("oldPassword"), employee.get("newPassword"))) {
            return Result.error("新密码不能和旧密码一样");
        }

        // 修改新密码到数据库中
        selectIdEmp.setPassword(SecureUtil.md5(employee.get("newPassword")));
        employeeMapper.updateEmp(selectIdEmp);
        return Result.success();
    }

}