doublePrevent.git

package com.gk.hotwork.Service.ServiceImpl;
 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.gk.hotwork.Domain.*;
import com.gk.hotwork.Domain.Exception.BusinessException;
import com.gk.hotwork.Domain.Utils.*;
import com.gk.hotwork.Domain.Vo.AccountUserVo;
import com.gk.hotwork.Domain.Vo.RegisterVo;
import com.gk.hotwork.Domain.Vo.UserVo;
import com.gk.hotwork.Mapper.UserInfoMapper;
import com.gk.hotwork.Service.*;
import org.apache.catalina.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import java.util.*;
 
@Service("UserService")
public class UserServiceImpl extends ServiceImpl<UserInfoMapper, UserInfo> implements UserService {
 
    @Autowired
    private UserInfoMapper userInfoMapper;
    @Autowired
    private RoleService roleService;
    @Autowired
    private UserFaceService userFaceService;
    @Autowired
    private UserRolesService userRolesService;
    @Autowired
    private CompanyService companyService;
    @Autowired
    private DepartmentService departmentService;
 
    @Value("${locationUrl}")
    private String url;
    @Value("${locationUsername}")
    private String username;
    @Value("${locationPassword}")
    private String password;
    @Value("${slice.size}")
    private Integer sliceSize;
 
    @Override
    public void selectUserDataGrid(PageInfo pageInfo) {
        Page<UserVo> page = new Page<>(pageInfo.getPageIndex(), pageInfo.getPageSize());
        List<OrderItem> orderItems = new ArrayList<>();
        OrderItem orderItem = new OrderItem();
        if (StringUtils.isNotBlank(pageInfo.getSort()) && StringUtils.isNotBlank(pageInfo.getOrder())) {
            orderItem.setAsc(pageInfo.getOrder().equalsIgnoreCase("ascending"));
            orderItem.setColumn(pageInfo.getSort());
        }else {
            orderItem.setAsc(false);
            orderItem.setColumn("createddate");
        }
        orderItems.add(orderItem);
        page.setOrders(orderItems);
        List<UserVo> list = userInfoMapper.selectUserDataGrid(page,pageInfo.getCondition());
        for (UserVo userVo : list) {
            List<RoleInfo> roleInfoList = roleService.selectRoleByUser(userVo.getId());
            userVo.setRoles(roleInfoList);
            UserFace userFace = userFaceService.selectByUserId(userVo.getId());
            if (userFace != null)
                userVo.setCode(userFace.getCode());
        }
        pageInfo.setResult(list);
        pageInfo.setTotalCount(page.getTotal());
    }
 
    @Override
    public UserInfo selectByUser(String username) {
        UserInfo userInfo = new UserInfo();
        userInfo.setUsername(username);
        userInfo.setStatus((byte)1);
        QueryWrapper<UserInfo> wrapper = new QueryWrapper<> (userInfo);
        return userInfoMapper.selectOne(wrapper);
    }
 
    @Override
    public List<UserInfo> selectUserInfo(Long id, String username) {
        return userInfoMapper.selectUserInfo(id,username);
    }
 
    @Override
    public boolean checkUserById(String userId) {
        if (StringUtils.isBlank(userId)){
            return false;
        }
        UserInfo userInfo = userInfoMapper.selectById(userId);
        return userInfo != null;
    }
 
    @Override
    public UserVo selectUserVoByName(String examtype,String username) {
        return userInfoMapper.selectUserVoByName(examtype,username);
    }
 
 
    @Override
    public void deleteById(Long id) {
        LambdaUpdateWrapper<UserInfo> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(UserInfo::getStatus, (byte) 0)
                .eq(UserInfo::getId, id);
        this.update(updateWrapper);
    }
 
    @Override
    public void recoverOneById(Long id) {
        LambdaUpdateWrapper<UserInfo> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(UserInfo::getStatus, (byte) 1)
                .eq(UserInfo::getId, id);
        this.update(updateWrapper);
    }
 
    @Override
    public UserInfo selectByRealName(Long id,String realname) {
        return userInfoMapper.selectByRealName(id,realname);
    }
 
    @Override
    public UserInfo getByRealName(String realname, String depName) {
        return userInfoMapper.getByRealName(realname, depName);
    }
 
    @Override
    public UserInfo selectByIdCard(Long id,String idcard) {
        return userInfoMapper.selectByIdCard(id, idcard);
    }
 
    @Override
    public List<UserInfo> selectNotUpload() {
        return userInfoMapper.selectNotUpload();
    }
 
    @Override
    public List<UserVo> selectAll(HashMap<String, Object> condition) {
        return userInfoMapper.selectAll(condition);
    }
 
    @Override
    public List<UserInfo> selectByCompany(String company) {
        LambdaQueryWrapper<UserInfo>wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(UserInfo::getCompany,company);
        return baseMapper.selectList(wrapper);
    }
 
    @Override
    public Msg saveEmployee(String realname, String empNo, String deviceNo) throws Exception {
        Map<String,String> params = new HashMap<>();
        params.put("username", username);
        params.put("password", password);
        params.put("empName", realname);
        params.put("empNo", empNo);
        params.put("deviceNo", deviceNo);
        String path = url + "/open/information/saveEmployee.do";
        return LocationUtils.net(params,path);
    }
 
    @Override
    public Msg setCardValid(String isValid, String cardId) throws Exception {
        Map<String,String> params = new HashMap<>();
        params.put("username", username);
        params.put("password", password);
        params.put("id", cardId);
        params.put("isvalid", isValid);
        String path = url + "/open/information/updEmployeeState.do";
        return LocationUtils.net(params,path);
    }
 
    @Override
    public Msg delEmployee(String cardId) throws Exception {
        Map<String,String> params = new HashMap<>();
        params.put("username", username);
        params.put("password", password);
        params.put("id", cardId);
        String path = url +  "/open/information/delEmployee.do";
        return LocationUtils.net(params,path);
    }
 
    @Override
    public Msg getRealGps() throws Exception {
        Map<String,String> params = new HashMap<>();
        params.put("username", username);
        params.put("password", password);
        String path = url + "/open/information/getRealGps.do";
        return LocationUtils.net(params,path);
    }
 
    @Override
    public UserInfo selectUserByCard(String deviceNo, String empNo, String name) {
        UserInfo userInfo = new UserInfo();
        userInfo.setDeviceNo(deviceNo);
        userInfo.setEmpNo(empNo);
        userInfo.setRealname(name);
        userInfo.setStatus((byte)1);
        QueryWrapper<UserInfo> wrapper = new QueryWrapper<> (userInfo);
        return userInfoMapper.selectOne(wrapper);
    }
 
    @Override
    public List<UserInfo> getGps(String username) {
        LambdaQueryWrapper<UserInfo>wrapper = new LambdaQueryWrapper<>();
        UserInfo userInfo = new UserInfo();
        userInfo.setStatus((byte)1);
        wrapper.ne(UserInfo::getDeviceNo, "");
        wrapper.eq(UserInfo::getStatus,(byte)1);
        if (StringUtils.isNotBlank(username)){
            wrapper.eq(UserInfo::getRealname,username);
        }
        return userInfoMapper.selectList(wrapper);
 
    }
 
    /**
    * @Description: 所有用户大小
    * @date 2021/12/27 10:48
    */
    @Override
    public int selectUserSize() {
        return userInfoMapper.selectCount(
                new LambdaQueryWrapper<>()
        );
    }
 
    @Override
    public UserInfo getByDeviceNo(String uid) {
        if (StringUtils.isBlank(uid)) throw new BusinessException("接收设备uid为空");
        return userInfoMapper.selectOne(
                new LambdaQueryWrapper<UserInfo>()
                        .eq(UserInfo::getDeviceNo,uid)
                        .eq(UserInfo::getStatus,1));
    }
 
    @Override
    public IPage<UserVo> selectUserPageInDepartment(Page<UserVo> page, Map<String, Object> filter, UserInfo user) {
        List<UserVo> userVos = userInfoMapper.selectUserDataGrid(page, filter);
        page.setRecords(userVos);
        return page;
    }
 
    @Override
    public List<UserVo> getUserList() {
        return userInfoMapper.getUserList();
    }
 
    @Override
    public UserInfo examForegroundLogin(String username, String password) {
        if (StringUtils.isBlank(username) || StringUtils.isBlank(password)) {
            throw new BusinessException("账号密码不能为空");
    }
        if (username.length() != 11) throw new BusinessException("请输入11位手机号");
        UserInfo userInfo = this.selectByUser(username);
        if (userInfo == null) throw new BusinessException("账号不存在");
        if (!MD5Utils.encode(password).equals(userInfo.getPassword())) throw new BusinessException("密码不正确");
        if (userInfo.getDepartment() != null) {
            DepartmentInfo de = departmentService.getById(userInfo.getDepartment());
            if (de != null) {
                userInfo.setDepartmentname(de.getDepartment());
            }
        }
        userInfo.setPassword(null);
        return userInfo;
    }
 
    @Override
    public Integer selectCountForExam(String name, String idno, String tel, String department,String company) {
        Map<Object, Object> params = new HashMap<>();
        params.put("name", name);
        params.put("idno", idno);
        params.put("tel", tel);
        params.put("department", department);
        params.put("company", company);
        return userInfoMapper.selectCountForExam(params);
    }
 
    @Override
    public List<UserInfo> selectPageForExam(String name, String idno, String tel, String department, String company, Integer first, Integer pageSize) {
        Map<Object, Object> params = new HashMap<>();
        params.put("name", name);
        params.put("idno", idno);
        params.put("tel", tel);
        params.put("department", department);
        params.put("company", company);
        params.put("first", first);
        params.put("pageSize", pageSize);
        return  userInfoMapper.selectPageForExam(params);
    }
 
    @Override
    @Transactional
    public void register(RegisterVo registerVo) {
        if (StringUtils.isBlank(registerVo.getRealname())) throw new BusinessException("用户姓名不能为空");
        if (StringUtils.isBlank(registerVo.getUsername()) ||registerVo.getUsername().length() != 11) throw new BusinessException("手机号不为11");
        if (StringUtils.isBlank(registerVo.getPassword())) throw new BusinessException("密码不能为空");
        if (StringUtils.isBlank(registerVo.getCompany())) throw new BusinessException("单位不能为空");
        if (registerVo.getCompanyid() == null) throw new BusinessException("单位参数不能为空");
        CompanyInfo company = companyService.getById(registerVo.getCompanyid());
        if (company == null) throw new BusinessException("单位不存在");
 
        if (StringUtils.isBlank(registerVo.getIdcard())|| !IdCardUtil.strongVerifyIdNumber(registerVo.getIdcard()))
            throw new BusinessException("身份证非法规则");
 
        if (this.phoneIsOccupied(registerVo.getRealname()))
            throw new BusinessException("手机号已经被占用");
        if (this.idCardIsOccupied(registerVo.getIdcard()))
            throw new BusinessException("身份证已经被占用");
 
        int count = userInfoMapper.selectCount(new LambdaQueryWrapper<>());
        int slice = (count + 1) % sliceSize;
        UserInfo userInfo = new UserInfo();
        userInfo.setRealname(registerVo.getRealname());
        userInfo.setPassword(MD5Utils.encode(registerVo.getPassword()));
        userInfo.setUsername(registerVo.getUsername());
        userInfo.setIdcard(registerVo.getIdcard());
        userInfo.setJob(registerVo.getJob());
        userInfo.setIsdel((byte) 0);
        userInfo.setStatus(((byte) 1));
        userInfo.setCreatedby(userInfo.getRealname());
        userInfo.setCompany(company.getCompany());
        userInfo.setCompanyid(company.getId());
        userInfo.setDepartment(registerVo.getDepartment());
        userInfo.setCreateddate(new Date());
        userInfo.setType(3);
        userInfo.setSlice(slice == 0 ? sliceSize + "" : slice + "");
        this.save(userInfo);
        //默认普通员工角色
        UserRolesInfo ur = new UserRolesInfo();
        ur.setUserid(userInfo.getId());
        RoleInfo role = roleService.getOne(new LambdaQueryWrapper<RoleInfo>().eq(RoleInfo::getName, "员工"));
        if (role == null) throw new BusinessException("请查询角色是否存在员工");
        ur.setRoleid(role.getId());
        userRolesService.save(ur);
 
    }
 
    @Override
    public void pwdChange(String username, String password, String phone) {
        if (StringUtils.isBlank(username)) throw new BusinessException("用户姓名不能为空");
        if (StringUtils.isBlank(password)) throw new BusinessException("密码不能为空");
        if (StringUtils.isBlank(phone)) throw new BusinessException("手机号不能为空");
        if (phone.length() != 11) throw new BusinessException("手机号不为11位");
        UserInfo userInfo = this.selectByUser(phone);
        if (userInfo == null) throw new BusinessException("用户不存在");
        if (username.equals(userInfo.getRealname())) {
            userInfo.setLastmodifiedby(username);
            userInfo.setLastmodifieddate(new Date());
            userInfo.setPassword(MD5Utils.encode(password));
            this.updateById(userInfo);
        }else{
            throw new BusinessException("用户信息不匹配");
        }
 
    }
 
    @Override
    public AccountUserVo getAccount(String username, String department) {
        if (StringUtils.isBlank(username)) throw new BusinessException("用户姓名不能为空");
        AccountUserVo accountUserVo = userInfoMapper.getAccountByUsername(username);
        if (accountUserVo == null){
            if (StringUtils.isBlank(department)){
                accountUserVo = userInfoMapper.getAccountByUsername("admin");
            }else {
                accountUserVo = userInfoMapper.getAccountByDepartment(department);
            }
        }
        return accountUserVo;
    }
    /**
    * @Description: 手机号是否被占用
    * @date 2022/5/11 9:38
    */
    @Override
    public boolean phoneIsOccupied(String phone) {
        if (StringUtils.isBlank(phone)) throw new BusinessException("手机号为空");
        Integer count = userInfoMapper.selectCount(new LambdaQueryWrapper<UserInfo>()
                .eq(UserInfo::getUsername, phone).eq(UserInfo::getStatus, 1));
        return count > 0;
    }
 
    /**
    * @Description: 身份证是否被占用
    * @date 2022/5/11 9:40
    */
    @Override
    public boolean idCardIsOccupied(String idCard) {
        if (StringUtils.isBlank(idCard)) throw new BusinessException("身份证号为空");
        Integer count = userInfoMapper.selectCount(new LambdaQueryWrapper<UserInfo>()
                .eq(UserInfo::getIdcard, idCard).eq(UserInfo::getStatus, 1));
        return count > 0;
    }
 
 
    /**
    * @Description: 考试后台登录
    * @date 2022/5/12 9:34
    */
    @Override
    public UserInfo examBackgroundLogin(String username, String password) {
        if (StringUtils.isBlank(username)) throw new BusinessException("用户姓名不能为空");
        if (StringUtils.isBlank(password)) throw new BusinessException("密码不能为空");
 
       //查找admin type = 1 的用户信息
        UserInfo admin = userInfoMapper.selectOne(
                new LambdaQueryWrapper<UserInfo>()
                        .eq(UserInfo::getUsername, username)
                        .eq(UserInfo::getType, 1)
                        .eq(UserInfo::getStatus, 1));
        if (admin == null) throw new BusinessException("账户不存在");
        if (!MD5Utils.encode(password).equals(admin.getPassword())) throw new BusinessException("密码输入错误");
        return admin;
    }
    /**
     查询by姓名
     */
    @Override
    public UserInfo getUserByRealName(String trim) {
        return userInfoMapper.getUserByRealName(trim);
    }
    /**
     查询by姓名 and dep
     */
    @Override
    public UserInfo getUserByRealNameAndDep(String name, Long dep) {
        return userInfoMapper.getUserByRealNameAndDep(name, dep);
    }
 
    /**
     查询by Id
     */
    @Override
    public UserInfo getByUserId(Long userId) {
        return userInfoMapper.getByUserId(userId);
    }
}