fu-hsi-service/src/main/java/com/supervision/police/service/impl/OCREvidenceServiceImpl.java

package com.supervision.police.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.supervision.constant.EvidencePropertyName;
import com.supervision.police.domain.EvidenceFile;
import com.supervision.police.domain.FileEvidenceProperty;
import com.supervision.police.domain.FileOcrProcess;
import com.supervision.police.dto.*;
import com.supervision.police.service.*;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.aop.framework.AopContext;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

@Slf4j
@Service
@RequiredArgsConstructor
public class OCREvidenceServiceImpl implements OCREvidenceService {

    private final FileOcrProcessService ocrProcessService;

    private final OCRService ocrService;

    private final FileEvidencePropertyService fileEvidencePropertyService;

    private final EvidenceFileService evidenceFileService;

    private final CaseEvidenceService caseEvidenceService;
    @Override
    public Boolean submitOrcTask(String fileId) {
        Assert.notEmpty(fileId, "文件id不能为空");

        ((OCREvidenceService)AopContext.currentProxy()).asyncDoOrcTask(null, fileId);
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class,transactionManager = "dataSourceTransactionManager")
    public List<FileEvidenceProperty> doOrcTask(String evidenceId,String fileId) {

        List<FileEvidenceProperty> evidencePropertyList = new ArrayList<>();
        // 识别文件信息
        List<FileOcrProcess> fileOcrProcesses = ocrProcessService.syncSubmitOCR(CollUtil.newArrayList(fileId));

        if (CollUtil.isEmpty(fileOcrProcesses)){
            log.warn("subOrcTask:文件id:{} 识别失败", fileId);
            return evidencePropertyList;
        }

        for (FileOcrProcess fileOcrProcess : fileOcrProcesses) {

            // 调用提取属性接口
            fileOcrProcess = ocrProcessService.getById(fileOcrProcess.getId());
            if (StrUtil.isEmpty(fileOcrProcess.getOcrText())){
                log.warn("subOrcTask:文件id:{}, 对应的ocrText属性为空，跳过属性识别...", fileId);
                continue;
            }
            log.debug("subOrcTask:远程接口retrieve开始识别文本...：{}", fileOcrProcess.getOcrText());
            RetrieveResDTO retrieve = ocrService.retrieve(new RetrieveReqDTO(fileOcrProcess.getOcrText()));
            log.info("subOrcTask:文件id:{} 识别结果:{}", fileId, JSONUtil.toJsonStr(retrieve));

            if (Integer.valueOf(0).equals(retrieve.getStatus())){
                // 保存属性信息
                String title = retrieve.getTitle();
                if (StrUtil.isNotEmpty(title)){

                    evidencePropertyList.addAll(this.saveEvidenceProperty(evidenceId, fileId,
                            Map.of(EvidencePropertyName.TITLE.getName(), retrieve.getTitle())));

                    if (StrUtil.isNotEmpty(evidenceId)){
                        evidenceFileService.save(new EvidenceFile(evidenceId,fileId));
                    }

                }else {
                    log.warn("subOrcTask:文件id:{} 识别结果为空", fileId);
                }
            }
        }

        return evidencePropertyList;
    }

    @Async
    @Override
    public void asyncDoOrcTask(String evidenceId, String fileId) {
        doOrcTask(evidenceId, fileId);
    }

    @Override
    @Transactional(rollbackFor = Exception.class,transactionManager = "dataSourceTransactionManager")
    public List<FileEvidenceProperty> saveEvidenceProperty(String evidenceId,String fileId ,Map<String, String> propertyMap) {

        // 先清空数据
        fileEvidencePropertyService.removeByEvidenceAndFileId(evidenceId,fileId);

        List<FileEvidenceProperty> fileEvidence = toFileEvidence(evidenceId, fileId, propertyMap);
        for (FileEvidenceProperty property : fileEvidence) {
            fileEvidencePropertyService.save(property);
        }

        return fileEvidence;
    }

    @Override
    public List<EvidenceFileOCRDTO> queryFileList(List<String> fileIdList) {

        if (CollUtil.isEmpty(fileIdList)){
            return new ArrayList<>(1);
        }
        List<OCREvidencePropertyDTO> ocrEvidencePropertyDTOS = fileEvidencePropertyService.listPrewByFileIdList(fileIdList);

        List<EvidenceFileOCRDTO> collect = ocrEvidencePropertyDTOS.stream()
                .collect(Collectors.groupingBy(OCREvidencePropertyDTO::getFileId))
                .values().stream()
                .map(EvidenceFileOCRDTO::new)
                .collect(Collectors.toList());

        return sortByIdOrder(fileIdList, collect);
    }

    @Override
    @Transactional(rollbackFor = Exception.class,transactionManager = "dataSourceTransactionManager")
    public String saveEvidence(EvidenceFileOCRDTO evidenceFileOCRDTO) {
        Assert.notEmpty(evidenceFileOCRDTO.getFileId(), "文件id不能为空");
        Assert.notEmpty(evidenceFileOCRDTO.getCaseId(), "案件id不能为空");
        Assert.notEmpty(evidenceFileOCRDTO.getEvidenceName(), "案件证据名称不能为空");
        Assert.notEmpty(evidenceFileOCRDTO.getEvidenceType(), "案件证据类型不能为空");

        //保存证据信息
        String evidenceId = caseEvidenceService.saveEvidence(evidenceFileOCRDTO.toCaseEvidenceDTO());

        //保存证据文件关联信息
        evidenceFileService.save(new EvidenceFile(evidenceId, evidenceFileOCRDTO.getFileId()));

        // 保存证据属性
        List<FileEvidenceProperty> evidencePropertyList = saveEvidenceProperty(evidenceId,
                evidenceFileOCRDTO.getFileId(), evidenceFileOCRDTO.getProperty());

        if (CollUtil.isEmpty(evidencePropertyList)){
            return null;
        }
        return CollUtil.getFirst(evidencePropertyList).getEvidenceId();
    }


    private List<EvidenceFileOCRDTO> sortByIdOrder(List<String> fileIdList, List<EvidenceFileOCRDTO> evidenceFileOCRDTOS){

        Map<String, EvidenceFileOCRDTO> fileOCRDTOMap = evidenceFileOCRDTOS.stream()
                .collect(Collectors.toMap(EvidenceFileOCRDTO::getFileId, recordFileDTO -> recordFileDTO, (k1, k2) -> k1));
        return fileIdList.stream().map(fileId -> {
                    EvidenceFileOCRDTO evidenceFileOCRDTO = fileOCRDTOMap.get(fileId);
                    if (Objects.isNull(evidenceFileOCRDTO)) {
                        evidenceFileOCRDTO = new EvidenceFileOCRDTO();
                        evidenceFileOCRDTO.setFileId(fileId);
                        evidenceFileOCRDTO.setOcrStatus(-1);
                    }
                    return evidenceFileOCRDTO;
                }
        ).collect(Collectors.toList());
    }

    private List<FileEvidenceProperty> toFileEvidence(String evidenceId,String fileId ,Map<String, String> propertyMap){

        if (StrUtil.isAllEmpty(evidenceId,fileId) || CollUtil.isEmpty(propertyMap)){
            log.warn("saveEvidenceProperty:参数为空");
            return new ArrayList<>(1);
        }

        return EvidencePropertyName.getByNames(propertyMap)
                .stream().map(evidence ->
                        new FileEvidenceProperty(evidenceId, fileId, evidence.getName(), propertyMap.get(evidence.getName())))
                .toList();

    }
}