kcim-cost/src/main/java/com/imed/costaccount/service/impl/UserServiceImpl.java

package com.imed.costaccount.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.SecureUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.imed.costaccount.common.exception.CostException;
import com.imed.costaccount.common.token.JwtUtil;
import com.imed.costaccount.common.util.BeanUtil;
import com.imed.costaccount.common.util.PageUtils;
import com.imed.costaccount.common.util.Result;
import com.imed.costaccount.mapper.UserMapper;
import com.imed.costaccount.model.Hosptail;
import com.imed.costaccount.model.User;
import com.imed.costaccount.model.dto.LoginDTO;
import com.imed.costaccount.model.dto.UserDto;
import com.imed.costaccount.model.vo.LoginVO;
import com.imed.costaccount.model.vo.UserVO;
import com.imed.costaccount.service.HosptailService;
import com.imed.costaccount.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;


/**
 * @author 11290
 */
@Slf4j
@Service("userService")
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    private JwtUtil jwtUtil;

    private HosptailService hosptailService;

    public UserServiceImpl(JwtUtil jwtUtil, HosptailService hosptailService) {
        this.jwtUtil = jwtUtil;
        this.hosptailService = hosptailService;
    }


    /**
     * 登录具体逻辑
     *
     * @param loginDTO {@link LoginDTO} 登录相关参数
     * @return
     */
    @Override
    public LoginVO login(LoginDTO loginDTO) {
        String hospSign = loginDTO.getHospSign();
        Integer id = loginDTO.getId();
        if (Objects.isNull(id)) {
            Hosptail hosptail = hosptailService.getBySign(hospSign);
            id = hosptail.getId();
        }
        // 院区情况
        User one = this.getOne(
                new LambdaQueryWrapper<User>()
                        .eq(User::getAccount, loginDTO.getAccount())
                        .eq(User::getHospId, id)
                        .last("limit 1")
        );
        if (Objects.isNull(one)) {
            throw new CostException("用户不存在");
        }
        if (!SecureUtil.md5(loginDTO.getPassword()).equals(one.getPassword())) {
            throw new CostException("密码错误");
        }
        String token = jwtUtil.createToken(one.getId());

        return LoginVO.builder().token(token).build();
    }

    /**
     * 查询查询用户的数据信息
     *
     * @param page
     * @param pageSize
     * @param hospId
     * @return
     */
    @Override
    public PageUtils queryList(Integer page, Integer pageSize, Integer hospId,String name) {
        Page<User> userPage = new Page<>(page, pageSize);
        Page<User> pages = this.page(userPage, new QueryWrapper<User>().lambda().eq(User::getHospId, hospId).like(!StringUtils.isEmpty(name),User::getName,name));
        List<User> records = pages.getRecords();
        List<UserVO> userVOS = BeanUtil.convertList(records, UserVO.class);
        PageUtils pageUtils = new PageUtils(pages);
        pageUtils.setList(userVOS);
        return pageUtils;
    }

    /**
     * 根据用户的姓名查询用户
     *
     * @param name
     * @return
     */
    @Override
    public List<UserVO> getByUserName(String name) {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        List<User> users = baseMapper.selectList(new QueryWrapper<User>().lambda().like(!StringUtils.isEmpty(name),User::getName,name));
        List<UserVO> userVOS = BeanUtil.convertList(users, UserVO.class);
        return userVOS;
    }

    /**
     * 保存用户信息
     *
     * @param userDto
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    public void saveUser(UserDto userDto) {
//        User user = (User) SecurityUtils.getSubject().getPrincipal();
//        // 医院的Id
//        Integer hospId = user.getHospId();

        Integer hospId=1;
        User userRequest = BeanUtil.convertObj(userDto, User.class);
        if (StringUtils.isEmpty(userDto.getPassword())){
            throw new CostException("密码不能为空");
        }
        userRequest.setPassword(SecureUtil.md5(userDto.getPassword()));
        userRequest.setHospId(hospId);
        userRequest.setCreateTime(System.currentTimeMillis());
        baseMapper.insert(userRequest);
    }

    /**
     * 修改用户
     *
     * @param userDto
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    public void updateByUser(UserDto userDto) {
        User user = baseMapper.selectOne(new QueryWrapper<User>().lambda().like(
                !StringUtils.isEmpty(userDto.getId()),User::getId,userDto.getId()));
        if (Objects.isNull(user)) {
            throw new CostException("用户不存在");
        }
        baseMapper.deleteById(user.getId());
        User userRequest = BeanUtil.convertObj(user,User.class);
        user.setId(null);
        user.setHospitalStatus(userDto.getHospitalStatus());
        if (!StringUtils.isEmpty(userDto.getPassword()) ){
            String newPassWord = SecureUtil.md5(userDto.getPassword());
            user.setPassword(newPassWord);
        }
        baseMapper.insert(userRequest);
    }

    /**
     *  导入用户
     * @param list 上传的文件读取的内容
     * @param currentUser 当前登录用户
     */
    @Override
    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    public Result importUser(List<List<Object>> list, User currentUser) {
        // TODO: 2021/7/26 校验excel格式是否正确
        for (int i = list.size() - 1; i >= 0; i--) {
            if (i == 0 || i == 1 || i == 2 || i == 3) {
                list.remove(list.get(i));
            }
        }
        log.info("读取的数据为：{}", list);
        List<User> users = new ArrayList<>();
        List<String> errRowNums = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            List<Object> data = list.get(i);
            log.info("得到用户输入的数据为：{}",data);
            User user = new User();
            // TODO: 2021/7/26 暂时写死
//            user.setHospId(currentUser.getHospId());
            user.setHospId(1);
            user.setCreateTime(new Date().getTime());
            int size = data.size();
            if (size != 3) {
                // 补充读取的null问题
                if (size == 2) {
                    data.add(StrUtil.EMPTY);
                }
                for (int j = 0; j < 3; j++) {
                    if (Objects.isNull(data.get(j))) {
                        data.set(j, StrUtil.EMPTY);
                    }
                }
            }
            for (int j = 0; j < 3; j++) {
                String str = String.valueOf(data.get(j));
                log.info("得到的字符串{}",str);
                if (StrUtil.isBlank(str)) {
                    errRowNums.add("" + (i + 5));
                }
                if (j == 0) {
                    user.setName(str);
                } else if (j == 1) {
                    user.setAccount(str);
                } else {
                    user.setPassword(SecureUtil.md5(str));
                }
            }
            users.add(user);
        }
        if (CollUtil.isNotEmpty(errRowNums)) {
            String collect = errRowNums.stream().collect(Collectors.joining(StrUtil.COMMA));
            throw new CostException(500, "第" + collect + "行数据异常");
        }
        // 校验users
        List<User> realUsers = new ArrayList<>();
        users.forEach(i -> {
            User one = getOne(
                    new QueryWrapper<User>().lambda()
                            .eq(User::getAccount, i.getAccount())
                            .eq(User::getHospId, i.getHospId())
            );
            if (Objects.nonNull(one)) {
                realUsers.add(one);
            }
        });
        users = users.stream().filter(i -> !realUsers.stream().map(User::getAccount).collect(Collectors.toList()).contains(i.getAccount())).collect(Collectors.toList());
        this.saveBatch(users);
        return Result.build(200, "有" + realUsers.size() + "条数据已存在，未被导入", null);
    }


}