server/src/main/java/cn/com/qmth/scancentral/service/impl/AdapteFileServiceImpl.java

package cn.com.qmth.scancentral.service.impl;

import cn.com.qmth.scancentral.dao.AdapteFileDao;
import cn.com.qmth.scancentral.entity.AdapteFileEntity;
import cn.com.qmth.scancentral.entity.AnswerCardEntity;
import cn.com.qmth.scancentral.enums.Role;
import cn.com.qmth.scancentral.service.AdapteFileService;
import cn.com.qmth.scancentral.service.AnswerCardService;
import cn.com.qmth.scancentral.service.FileService;
import cn.com.qmth.scancentral.vo.UriVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
import com.qmth.boot.core.exception.ParameterException;
import com.qmth.boot.core.exception.StatusException;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.util.ArrayList;
import java.util.List;

@Service
public class AdapteFileServiceImpl extends MppServiceImpl<AdapteFileDao, AdapteFileEntity>
        implements AdapteFileService {

    @Autowired
    private FileService fileService;

    @Autowired
    private AnswerCardService cardService;

    @Transactional
    @Override
    public UriVo save(String device, Role role, Long examId, Integer number, String md5, Integer dpi,
            MultipartFile file) {
        AnswerCardEntity card = this.cardService.findByExamAndNumber(examId, number);
        if (card == null) {
            throw new ParameterException("未找到科目,请先同步或创建考生获取科目");
        }
        if (!card.getNeedAdapte()) {
            throw new ParameterException("卡格式无需适配");
        }
        if (role == null || (!role.equals(Role.SCHOOL_ADMIN) && !role.equals(Role.SCANNER))) {
            throw new ParameterException("当前角色没有权限进行适配");
        }
        try {
            String uri = fileService.uploadAdapteFile(file.getInputStream(), md5, examId, number);
            if (role.equals(Role.SCHOOL_ADMIN)) {
                deleteByExamIdAndCardNumberAndRole(examId, number, role);
                AdapteFileEntity entity = new AdapteFileEntity();
                entity.setExamId(examId);
                entity.setCardNumber(number);
                entity.setRole(role);
                entity.setDevice(device);
                entity.setUri(uri);
                entity.setMd5(md5);
                entity.setDpi(dpi);
                this.saveOrUpdateByMultiId(entity);
            } else {
                AdapteFileEntity entity = findByExamIdAndCardNumberAndRoleAndDevice(examId, number, role, device);
                if (entity == null) {
                    entity = new AdapteFileEntity();
                    entity.setCardNumber(number);
                    entity.setDevice(device);
                    entity.setExamId(examId);
                    entity.setRole(role);
                    entity.setDpi(dpi);
                }
                entity.setUri(uri);
                entity.setMd5(md5);
                this.saveOrUpdateByMultiId(entity);
            }
            return UriVo.create(uri);
        } catch (Exception e) {
            log.error("适配文件上传失败，examId=" + examId + ", cardNumber=" + number, e);
            throw new StatusException("适配文件上传失败", e);
        }
    }

    @Override
    public List<AdapteFileEntity> listByExamIdAndCardNumber(Long examId, Integer number) {
        if (examId == null) {
            throw new ParameterException("examId不能为空");
        }
        if (number == null) {
            throw new ParameterException("cardnumber不能为空");
        }
        QueryWrapper<AdapteFileEntity> wrapper = new QueryWrapper<>();
        LambdaQueryWrapper<AdapteFileEntity> lw = wrapper.lambda();
        lw.eq(AdapteFileEntity::getExamId, examId);
        lw.eq(AdapteFileEntity::getCardNumber, number);
        return baseMapper.selectList(wrapper);
    }

    @Override
    public List<AdapteFileEntity> listByExamIdAndCardNumberForScanner(Long examId, Integer number, String device) {
        if (examId == null) {
            throw new ParameterException("examId不能为空");
        }
        if (number == null) {
            throw new ParameterException("cardnumber不能为空");
        }
        QueryWrapper<AdapteFileEntity> wrapper = new QueryWrapper<>();
        LambdaQueryWrapper<AdapteFileEntity> lw = wrapper.lambda();
        lw.eq(AdapteFileEntity::getExamId, examId);
        lw.eq(AdapteFileEntity::getCardNumber, number);
        List<AdapteFileEntity> list = baseMapper.selectList(wrapper);
        List<AdapteFileEntity> result = new ArrayList<>();
        for (AdapteFileEntity adapteFileEntity : list) {
            // 同device的扫描员适配文件
            if (adapteFileEntity.getRole().equals(Role.SCANNER) && adapteFileEntity.getDevice().equals(device)) {
                result.add(adapteFileEntity);
            }
            // 管理员的适配文件
            else if (adapteFileEntity.getRole().equals(Role.SCHOOL_ADMIN)) {
                result.add(adapteFileEntity);
            }
        }
        return result;
    }

    @Override
    public AdapteFileEntity findByExamIdAndCardNumberAndRoleAndDevice(Long examId, Integer number, Role role,
            String device) {
        if (examId == null) {
            throw new ParameterException("examId不能为空");
        }
        if (number == null) {
            throw new ParameterException("cardnumber不能为空");
        }
        if (StringUtils.isBlank(device)) {
            throw new ParameterException("device不能为空");
        }
        LambdaQueryWrapper<AdapteFileEntity> lw = new LambdaQueryWrapper<>();
        lw.eq(AdapteFileEntity::getExamId, examId);
        lw.eq(AdapteFileEntity::getCardNumber, number);
        lw.eq(AdapteFileEntity::getDevice, device);
        lw.eq(AdapteFileEntity::getRole, role);
        return baseMapper.selectOne(lw);
    }

    private void deleteByExamIdAndCardNumberAndRole(Long examId, Integer cardNumber, Role role) {
        LambdaQueryWrapper<AdapteFileEntity> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(AdapteFileEntity::getExamId, examId);
        wrapper.eq(AdapteFileEntity::getCardNumber, cardNumber);
        wrapper.eq(AdapteFileEntity::getRole, role);
        baseMapper.delete(wrapper);
    }

    @Transactional
    @Override
    public void deleteByExamIdAndCardNumber(Long examId, Integer number) {
        if (examId == null) {
            throw new ParameterException("examId 不能为空");
        }
        if (number == null) {
            throw new ParameterException("number 不能为空");
        }
        UpdateWrapper<AdapteFileEntity> updateWrapper = new UpdateWrapper<>();
        updateWrapper.lambda().eq(AdapteFileEntity::getExamId, examId);
        updateWrapper.lambda().eq(AdapteFileEntity::getCardNumber, number);
        this.baseMapper.delete(updateWrapper);
    }

}