guzijian / bsth-alcohol-sign · Files

package com.ruoyi.driver.service.impl;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Paths;
import java.util.*;
import java.util.stream.Collectors;

import com.ruoyi.common.config.RuoYiConfig;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.exception.file.InvalidExtensionException;
import com.ruoyi.common.utils.file.FileUploadUtils;
import com.ruoyi.common.utils.file.FileUtils;
import com.ruoyi.common.utils.file.MimeTypeUtils;
import com.ruoyi.equipment.mapper.EquipmentMapper;
import com.ruoyi.framework.config.ServerConfig;
import com.ruoyi.job.DriverJob;
import com.ruoyi.pojo.domain.EquipmentDriverExpand;
import com.ruoyi.pojo.request.FaceUpdateReqVo;
import com.ruoyi.pojo.response.ResponseScheduling;
import com.ruoyi.service.ThreadJobService;
import com.ruoyi.utils.ConstDateUtil;
import com.ruoyi.utils.HttpUtils;
import com.ruoyi.utils.ListUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.tomcat.util.buf.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import com.ruoyi.driver.mapper.DriverMapper;
import com.ruoyi.driver.domain.Driver;
import com.ruoyi.driver.service.IDriverService;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import static com.ruoyi.common.ApiProperties.PERSONNEL_API_KEY;
import static com.ruoyi.common.redispre.GlobalRedisPreName.DRIVER_SCHEDULING_PRE;

/**
 * 驾驶员信息Service业务层处理
 *
 * @author 古自健
 * @date 2023-07-04
 */
@Service
public class DriverServiceImpl implements IDriverService {

    private Logger log = LoggerFactory.getLogger(DriverServiceImpl.class);

    @Autowired
    private EquipmentMapper equipmentMapper;
    @Value("${api.url.getSchedulingInfo}")
    private String schedulingInfoUrl;
    @Value("${api.config.password}")
    private String password;
    @Value("${api.config.nonce}")
    private String nonce;
    @Autowired
    private DriverJob driverJob;

    @Autowired
    private ServerConfig serverConfig;
    @Autowired
    private DriverMapper driverMapper;

    @Autowired
    private ThreadJobService threadJobService;

    @Autowired
    private RedisCache redisCache;

    @Value("${api.headImage}")
    private String headImagePre;
    /**
     * 查询驾驶员信息
     *
     * @param id 驾驶员信息主键
     * @return 驾驶员信息
     */
    @Override
    public Driver selectDriverById(Long id) {
        return driverMapper.selectDriverById(id);
    }

    /**
     * 查询驾驶员信息列表
     *
     * @param driver 驾驶员信息
     * @return 驾驶员信息
     */
    @Override
    public List<Driver> selectDriverList(Driver driver) {
        List<Driver> drivers = driverMapper.selectDriverList(driver);
        List<EquipmentDriverExpand> list = equipmentMapper.querySignListByJobCode(drivers);
        for (Driver item : drivers) {
            // 查询对应工号的注册设备号 然后用，拼接展示在前端
            List<String> collect = list.stream().filter(todo -> item.getJobCode().equals(todo.getJobCode())).map(EquipmentDriverExpand::getDeviceId).collect(Collectors.toList());
            item.setSignInEquipment(StringUtils.join(collect));
        }
        return drivers;
    }

    /**
     * 新增驾驶员信息
     *
     * @param driver 驾驶员信息
     * @return 结果
     */
    @Override
    public int insertDriver(Driver driver) {
        return driverMapper.insertDriver(driver);
    }

    /**
     * 修改驾驶员信息
     *
     * @param driver 驾驶员信息
     * @return 结果
     */
    @Override
    public int updateDriver(Driver driver) {
        return driverMapper.updateDriver(driver);
    }

    /**
     * 批量删除驾驶员信息
     *
     * @param ids 需要删除的驾驶员信息主键
     * @return 结果
     */
    @Override
    public int deleteDriverByIds(Long[] ids) {
        return driverMapper.deleteDriverByIds(ids);
    }

    /**
     * 删除驾驶员信息信息
     *
     * @param id 驾驶员信息主键
     * @return 结果
     */
    @Override
    public int deleteDriverById(Long id) {
        return driverMapper.deleteDriverById(id);
    }

    @Override
    public void insertDrivers(List<Driver> driverList) {
        driverMapper.saveDrivers(driverList);
    }

    @Override
    public AjaxResult getDriverSchedulingInfo(String schedulingDate, String jobCode) {
        String key = DRIVER_SCHEDULING_PRE + schedulingDate;
        List<ResponseScheduling> cacheMapValue = redisCache.getCacheMapValue(key, jobCode);
        // 优先从缓存中读取
        if (cacheMapValue != null && cacheMapValue.size() > 0) {
            return AjaxResult.success(cacheMapValue);
        }
        // 没有再次请求地址获取值
        long timestamp = System.currentTimeMillis();
        // 请求资源地址格式化
        String getSchedulingInfoUrl = null;
        try {
            getSchedulingInfoUrl = String.format(schedulingInfoUrl, "99", schedulingDate, timestamp, nonce, password, driverJob.getSHA1(driverJob.getStringStringMap(String.valueOf(timestamp))));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        Map<String, List<ResponseScheduling>> scheduling = driverJob.saveSchedulingToRedis(getSchedulingInfoUrl, schedulingDate);
        // 数据库中读取所有接收到的排班信息
//        List<ResponseScheduling> responseSchedulings = driverMapper.getDriverSchedulingList(schedulingDate, jobCode);
        return AjaxResult.success(scheduling.get(jobCode));
    }

    @Override
    public void saveDriverScheduling(List<ResponseScheduling> schedulings) {
        List<List<ResponseScheduling>> lists = ListUtils.splitList(schedulings, 1000);
        for (List<ResponseScheduling> responseSchedulings : lists) {
            driverMapper.saveDriverScheduling(responseSchedulings);
        }
    }

    @Override
    public AjaxResult getDriverSchedulingAll() {
        return AjaxResult.success(redisCache.getHashKeys(DRIVER_SCHEDULING_PRE + ConstDateUtil.formatDate("yyyyMMdd")));
    }

    @Override
    public AjaxResult checkJobCode(Driver driver) {
        Integer result = driverMapper.jobCodeIsEmpty(driver.getJobCode());
        Map<String, Boolean> resultMap = new HashMap<>();
        if (result > 0) {
            resultMap.put("result", true);
        } else {
            resultMap.put("result", false);
        }
        return AjaxResult.success(resultMap);
    }

    @Override
    public AjaxResult uploadImage(MultipartFile file) throws InvalidExtensionException, IOException {
        // 上传并返回新文件名称

        // 上传文件路径
        String baseUrl = RuoYiConfig.getUploadPath() + headImagePre;
        // 校验文件格式
        FileUploadUtils.assertAllowed(file, MimeTypeUtils.DEFAULT_ALLOWED_EXTENSION);
        // 后期可以通过请求头拿到对应的工号
        String fileName = FilenameUtils.getBaseName(file.getOriginalFilename()) + "." + FileUploadUtils.getExtension(file);
        String absPath = FileUploadUtils.getAbsoluteFile(baseUrl, fileName).getAbsolutePath();
        fileName = FileUploadUtils.getPathFileName(baseUrl, fileName);
        file.transferTo(Paths.get(absPath));
        String url = serverConfig.getUrl() + fileName;
        AjaxResult ajax = AjaxResult.success();
        ajax.put("url", url);
        ajax.put("fileName", fileName);
        ajax.put("newFileName", FileUtils.getName(fileName));
        ajax.put("originalFilename", file.getOriginalFilename());
        return ajax;
    }

    @Override
    public void downloadHeadImage(String jobCode, HttpServletResponse response) {
        File file = getLocationFile(jobCode);
        ServletOutputStream ops = null;
        try {
            if (file.exists()) {
                byte[] bytes = com.alibaba.excel.util.FileUtils.readFileToByteArray(file);
                ops = response.getOutputStream();
                ops.write(bytes);
                ops.flush();
            }
        } catch (Exception e) {
            throw new RuntimeException("download fail cause:" + e.getMessage());
        } finally {
            try {
                if (ops != null) {
                    ops.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

    @Override
    public List<Driver> getDrivers(Driver driver) {
        // TODO 人事比对
        List<Driver> drivers = driverMapper.getDrivers(driver);
        return drivers;
    }


    @Override
    public AjaxResult faceRegistrationFeedback(String deviceId, List<String> jobCodes) {
        threadJobService.asyncInsertSignInContactEquipment(deviceId, jobCodes);
        return AjaxResult.success("注册成功");
    }

    @Override
    public void updateDriverByComputed() {
        Integer count = equipmentMapper.count();
        // 更新人脸认证状态
        driverMapper.updateDriverByComputed(count);
    }

    @Override
    public void updateFaceByJob(HttpServletRequest request, FaceUpdateReqVo vo) {
        // 获取校验
        String header = request.getHeader("X-TOKEN-AUTHORIZATION");
        if (!PERSONNEL_API_KEY.equals(header)){
            throw new RuntimeException("X-TOKEN-AUTHORIZATION value error");
        }
        Date date = new Date();
        List<Driver> drivers = vo.getFaceDataList().stream().map(item -> {
            Driver driver = new Driver();
            driver.setPosts(item.getPosts());
            driver.setJobCode(item.getJobCode());
            try {
                driver.setImage(getNewImageUrl(item.getJobCode(),item.getImageUrl()));
            } catch (IOException e) {
                log.info(e.getMessage());
                throw new RuntimeException(e);
            }
            driver.setPersonnelName(item.getName());
            driver.setUpdateTime(date);
            return driver;
        }).collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(s -> s.getJobCode()))), ArrayList::new));
        List<List<Driver>> lists = ListUtils.splitList(drivers, 400);
        log.info("开始人脸数据更新");
        // 数据更新 更新人脸注册标识 更新基本数据
        for (List<Driver> list : lists) {
            driverMapper.updateDriversByJobCodes(list);
        }
        log.info("人脸数据更新完成");
        // 删除注册表中对应工号的数据
        List<String> jobCodes = drivers.stream().map(Driver::getJobCode).collect(Collectors.toList());
        log.info("开始删除注册表中对应工号的数据");
        driverMapper.deleteDeviceIdAssociatedJobCode(jobCodes);
        log.info("删除注册表中对应工号的数据结束");
    }

    /**
     * 获取新的imageUrl
     *
     * @param jobCode
     * @param url
     * @return
     */
    private String getNewImageUrl(String jobCode,String url) throws IOException {
        // 生成文件路径
        String fileName = jobCode + ".png";
        String filePath = RuoYiConfig.getUploadPath() + headImagePre + "/" + fileName;
        try {
            fileName = FileUploadUtils.getPathFileName(RuoYiConfig.getUploadPath() + headImagePre, fileName);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        log.debug("图片开始上传");
        // 获取图片数据
        InputStream is = HttpUtils.doGet(url, new HashMap<>());
        // 上传图片
        ThreadJobService.uploadImage(is, filePath);
        log.debug("图片上传完毕");
        return fileName;
    }

    private File getLocationFile(String jobCode) {
        String image = driverMapper.getDriverImageByJobCode(jobCode);

        return new File(RuoYiConfig.getProfile() + File.separator + image.replace("/profile", ""));
    }
}