Wispro-CodeWarehouse-BackEnd/PAS/src/main/java/cn/cslg/pas/service/upLoadPatent/ExcuteTaskToPatentService.java

package cn.cslg.pas.service.upLoadPatent;

import cn.cslg.pas.common.model.PatentCell;
import cn.cslg.pas.common.model.dto.*;
import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
import cn.cslg.pas.common.model.vo.UploadParamsVO;
import cn.cslg.pas.common.model.vo.UploadSettingVO;
import cn.cslg.pas.common.utils.*;
import cn.cslg.pas.domain.*;
import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.service.OutInterfaceService;
import cn.cslg.pas.service.TaskService;
import cn.cslg.pas.service.UploadPatentBatchService;
import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.spire.pdf.FileFormat;
import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfDocumentBase;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.poi.ss.usermodel.Sheet;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

/**
 * 根据不同类型任务生成专利入消费者队列的业务层
 *
 * @Author chenyu
 * @Date 2023/6/12
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class ExcuteTaskToPatentService implements Serializable {
    private final FileUtils fileUtils;
    private final ExcuteUploadSettingService excuteUploadSettingService;
    private final ExcuteDataToVOService excuteDataToVOService;
    private final PantentQueueService pantentQueueService;
    private final AssoOsTaskQrtzTaskService assoOsTaskQrtzTaskService;
    private final OutInterfaceService outInterfaceService;
    private final TaskService taskService;

    //TODO 工厂类
    public void taskToPatentQueue(Task task) throws IOException {
        //Excel导入任务
        if (task.getType() == 1) {
            excelTaskToPatentQueue(task);
            //EPO网站导入任务
        } else if (task.getType() == 3) {
            epoTaskToPatentQueue(task);
        }

    }

    /**
     * Excel导入专利
     *
     * @param task Excel导入专利任务
     */
    public void excelTaskToPatentQueue(Task task) throws IOException {
        //从任务中取出文件路径、总条数、成功条数、前台参数json
        String filePath = task.getUrl();  //相对路径
        filePath = fileUtils.getPath(filePath);  //绝对路径
        Integer total = task.getTotal();

        int lastIndex = task.getSuccessNum();
        String json = task.getPramJson();
        ProjectImportPatentVO projectImportPatentVO = JsonUtils.jsonToPojo(json, ProjectImportPatentVO.class);
        //解析数据源类，通过数据来源id（如1：智慧芽）解析数据源配置文件，获得数据源配置文件对象jsonData
        List<UploadSettingVO.Column> jsonData = excuteUploadSettingService.ExcuteUploadSetting(projectImportPatentVO.getSourceId());
        //解析Excel文件获得工作簿
        Sheet sheet = ReadExcelUtils.readExcel(filePath);
        //遍历专利总数量，在循环中保存专利
        for (int i = lastIndex; i < total; i++) {
            PatentData patentData = ReadExcelUtils.readExcelOneRow(filePath, sheet, i + 1);
            //调用装载数据类，专利数据转换为VO对象
            UploadParamsVO uploadParamsVO = excuteDataToVOService.fileToPatentVO(patentData, jsonData);

            //专利入消费者队列，并唤醒消费者执行专利入库
            //patentToQueueAwakeConsumer(uploadParamsVO, projectImportPatentVO);
            pantentQueueService.patentToQueue(uploadParamsVO, projectImportPatentVO);
        }
    }

    /**
     * EPO网站导入专利
     *
     * @param task EPO网站导入专利
     */
    public void epoTaskToPatentQueue(Task task) throws IOException {
        Integer taskId = task.getId();
        List<AssoOsTaskQrtzTask> assoOsTaskQrtzTasks = assoOsTaskQrtzTaskService.list(new LambdaQueryWrapper<AssoOsTaskQrtzTask>().eq(AssoOsTaskQrtzTask::getTaskId, taskId));
        AssoOsTaskQrtzTask assoOsTaskQrtzTask = assoOsTaskQrtzTasks.get(0);

        Integer successNum = task.getSuccessNum();

        //从任务关联网站导入任务对象中取出下载字段、检索信息
        String cellsStr = assoOsTaskQrtzTask.getConfigCells();
        List<String> cells = Arrays.asList(cellsStr.split(","));
        String conditions = assoOsTaskQrtzTask.getConditions();

        //定义每次检索的专利数量(每次检索50件)
        int size = 50;
        //2.根据检索式conditions先检索一件专利著录信息【此操作主要是为了获得专利总数量count】
//        SerachBiblioData serachBiblioData = getSerachBiblioData(conditions, 1, 1);
//        if (serachBiblioData == null || serachBiblioData.getTotals() == 0) {
//            //conditions没有检索到任何相关专利(杰哥处理)
//            ThrowException.throwXiaoShiException("检索失败，根据检索条件未检索出任何相关专利信息");
//            return;
//        }

        //获得专利总数量
//        Integer count = serachBiblioData.getTotals();
        Integer count = task.getTotal();

        //计算进度值
//        double percentage = count == 0 ? 0 : (count.equals(successNum) ? (successNum * 1D) : (successNum + 1D) / count * 100D);
//        percentage = MathUtils.saveTwoDecimal(percentage);
        //3.根据专利总数量count遍历检索专利
        for (int i = 1; i <= count; i += size) {
            //查看任务状态
//            QrtzTaskDetail qrtzTaskDetail1 = qrTaskDetailService.getById(webQueryDTO.getTaskId());
//            if (qrtzTaskDetail1.getTaskDetailState().equals(7)) {
//                qrtzTaskDetail1.setTaskDetailState(5);
//                qrtzTaskDetail1.setSuccessNum(successNum);
//                qrtzTaskDetail1.setTaskProcess(percentage);
//                qrtzTaskDetail1.updateById();
//                WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
//                        .setId(webQueryDTO.getTaskId())
//                        .setProjectId(task.getProjectId())
//                        .setComplete(false)
//                        .setIndex(successNum)
//                        .setTaskDetailState(5)
//                        .setTotal(count), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "null");
//                return null;
//            } else if (qrtzTaskDetail1.getTaskDetailState().equals(8)) {
//                qrtzTaskDetail1.setTaskDetailState(6);
//                qrtzTaskDetail1.setSuccessNum(successNum);
//                qrtzTaskDetail1.setTaskProcess(percentage);
//                qrtzTaskDetail1.updateById();
//                WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
//                        .setId(webQueryDTO.getTaskId())
//                        .setProjectId(task.getProjectId())
//                        .setComplete(false)
//                        .setIndex(successNum)
//                        .setTaskDetailState(6)
//                        .setTotal(count), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "null");
//                return null;
//            }
            //3.1根据检索式conditions、专利开始数i、专利最后数i + size - 1检索专利著录信息
            SerachBiblioData serachBiblioData = getSerachBiblioData(conditions, i, i + size - 1);
            //获取检索结果中的所有专利著录信息
            if (serachBiblioData == null || serachBiblioData.getTotals() == 0) {
                continue;
            }
            List<PatentZhuLu> patents = serachBiblioData.getPatents();
            //3.2遍历专利
            for (PatentZhuLu patent : patents) {
                PatentCell patentCell = new PatentCell();
                patentCell.setProjectId(task.getProjectId());
                PubNo pubNO = new PubNo();
                //装载专利著录
                if (cells.contains("1")) {
                    setPatentZhuLu(patentCell, patent, pubNO);
                }
                //装载权要
                if (cells.contains("2")) {
                    setPatentClaim(patentCell, pubNO);
                }
                //装载说明书文本
                if (cells.contains("3")) {
                    setPatentInstructionText(patentCell, pubNO);
                }

                //以下代码是在准备一会要调用拿取各种附图的接口所需的参数(FullDocument->说明书pdf、Drawing->其他附图、FirstPageClipping->摘要附图)
                String fullDocumentLink = "", fullDocumentType = "", drawingLink = "", drawingType = "", firstPageClippingLink = "", firstPageClippingType = "";
                Integer fullDocumentPage = 0, drawingPage = 0, firstPageClippingPage = 0;
                //根据当前专利号调用接口获取一会调用拿取各种附图的接口的参数
                try {
                    ImageInfo imageInfo = getImage(pubNO);
                    for (Image image : imageInfo.getImages()) {
                        //如果附件类型是说明书
                        if (image.getImageType().equals("FullDocument")) {
                            fullDocumentLink = image.getUrlLink();
                            fullDocumentPage = image.getNumberOfPages();
                            for (String formatOption : image.getFormatOptions()) {
                                if (formatOption.contains("pdf")) {
                                    fullDocumentType = formatOption;
                                }
                            }
                        }
                        //如果附件类型是其他附件
                        if (image.getImageType().equals("Drawing")) {
                            drawingLink = image.getUrlLink();
                            drawingPage = image.getNumberOfPages();
                            for (String formatOption : image.getFormatOptions()) {
                                if (formatOption.contains("tiff")) {
                                    drawingType = formatOption;
                                }
                            }
                        }
                        //如果附件类型是摘要附图
                        if (image.getImageType().equals("FirstPageClipping")) {
                            firstPageClippingLink = image.getUrlLink();
                            firstPageClippingPage = image.getNumberOfPages();
                            for (String formatOption : image.getFormatOptions()) {
                                if (formatOption.contains("jpeg")) {
                                    firstPageClippingType = formatOption;
                                }
                            }
                        }
                    }

                    //装载说明书pdf
                    if (cells.contains("4")) {
                        setFuJian(fullDocumentLink, fullDocumentPage, fullDocumentType, patentCell, ".pdf");
                    }
                    //装载摘要附图
                    if (cells.contains("6")) {
                        setFuJian(firstPageClippingLink, firstPageClippingPage, firstPageClippingType, patentCell, ".jpeg");
                    }
                    //装载其他附图
                    if (cells.contains("7")) {
                        setFuJian(drawingLink, drawingPage, drawingType, patentCell, ".tiff");
                    }

                    //将专利发送到分析系统（保存专利入库）
                    if (patentCell.getPatentNo() != null) {
                        String res = outInterfaceService.importPatents(patentCell);
                        JSONObject jsonObject = JSONObject.parseObject(res);
                        if (jsonObject.get("code").toString().equals("500")) {
                            //舍弃这个专利，继续下一个专利
                            continue;
                        }
                    }

//                    QrtzTaskDetail qrtzTaskDetail11 = qrTaskDetailService.getById(qrtzTaskDetail.getId());
//                    percentage = count == 0 ? 0 : (count.equals(successNum) ? (successNum * 1D) : (successNum + 1D) / count * 100D);
//                    percentage = MathUtils.saveTwoDecimal(percentage);
//                    WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
//                            .setId(webQueryDTO.getTaskId())
//                            .setProjectId(task.getProjectId())
//                            .setComplete(false)
//                            .setIndex(successNum)
//                            .setPercentage(percentage)
//                            .setTaskDetailState(qrtzTaskDetail11.getTaskDetailState())
//                            .setFileName("")
//                            .setUrl("")
//                            .setTotal(count), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "null");
                } catch (XiaoShiException e) {
                    //虽然拿不到所有附图，但已经拿到了专利著录，能拿到啥是啥
                    log.info(e.getMessage());
                } catch (Exception e) {
//                    qrtzTaskDetail.setTaskDetailState(3);
//                    qrtzTaskDetail.setSuccessNum(successNum);
//                    qrtzTaskDetail.setDefaultNum(qrtzTaskDetail.getAllNum() - successNum);
//                    qrtzTaskDetail.setFailure("拉取节点失败");
//                    qrtzTaskDetail.setEndTime(new Date());
//                    qrtzTaskDetail.updateById();
//                    if (qrtzTask.getTaskType() == 1) {
//                        qrtzTask.setTaskState(4);
//                    } else {
//                        qrtzTask.setTaskState(3);
//                    }
//                    qrtzTask.updateById();
//                    WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
//                            .setId(webQueryDTO.getTaskId())
//                            .setProjectId(task.getProjectId())
//                            .setComplete(true)
//                            .setIndex(successNum)
//                            .setPercentage(100D)
//                            .setTaskDetailState(qrtzTaskDetail.getTaskDetailState())
//                            .setFileName("")
//                            .setUrl("")
//                            .setTotal(successNum), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "");
                }

            }
        }
//        WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
//                .setId(webQueryDTO.getTaskId())
//                .setProjectId(task.getProjectId())
//                .setComplete(true)
//                .setIndex(count)
//                .setPercentage(100D)
//                .setTaskDetailState(qrtzTaskDetail.getTaskDetailState())
//                .setFileName("")
//                .setUrl("")
//                .setTotal(count), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "");
//        //任务执行情况状态设为成功，任务条件状态设为已完成(若是任务条件是定时任务则设为等待下一次执行)
//        qrtzTaskDetail.setTaskDetailState(2);
//        qrtzTaskDetail.setSuccessNum(successNum);
//        qrtzTaskDetail.setDefaultNum(qrtzTaskDetail.getAllNum() - successNum);
//        qrtzTaskDetail.setTaskProcess(100);
//        qrtzTaskDetail.setEndTime(new Date());
//        qrtzTaskDetail.updateById();
//        if (qrtzTask.getTaskType() == 1) {
//            qrtzTask.setTaskState(4);
//        } else {
//            qrtzTask.setTaskState(2);
//        }
//        qrtzTask.updateById();
//        return patentCells;
    }

    //调用接口获取一批专利著录信息
    public SerachBiblioData getSerachBiblioData(String conditions, Integer start, Integer size) throws IOException {
        GetSearchBiblioParamsDTO getSearchBiblioParamsDTO = new GetSearchBiblioParamsDTO()
                .setQuery(conditions)
                .setStart(start)
                .setEnd(size);
        String res = outInterfaceService.getSearchBiblio(getSearchBiblioParamsDTO);
        if (res == null || res.equals("")) {
            return null;
        }
        JSONObject jsonObject = JSONObject.parseObject(res);
        if (!jsonObject.get("status").toString().equals("200")) {
            //若发生类似400、500等异常(杰哥处理)
            return null;
        }
        //返回检索结果data
        return JSONObject.parseObject(jsonObject.get("data").toString(), SerachBiblioData.class);
    }

    /**
     * 装载著录方法
     *
     * @param patentCell 实体类对象
     * @param patent     专利对象
     * @param pubNo      公开号对象
     */
    private void setPatentZhuLu(PatentCell patentCell, PatentZhuLu patent, PubNo pubNo) {
        //装载申请号
        for (AppNo appNo : patent.getAppNos()) {
            if (appNo.getType().equals("docdb")) {
                patentCell.setApplicationNo(appNo.getCountry() + appNo.getNumber() + appNo.getKind());
            }
        }
        //装载申请日
        patentCell.setApplicationDate(patent.getAppDate());
        //装载国家/省市
        patentCell.setCountry(patent.getAppCountry());
        //装载公开号
        for (PubNo n : patent.getPubNos()) {
            if (n.getType().equals("docdb")) {
                BeanUtils.copyProperties(n, pubNo);
                patentCell.setPublicNo(n.getCountry() + n.getNumber() + n.getKind());
            }
        }
        //装载专利号
        patentCell.setPatentNo(patentCell.getPublicNo());
        //装载公开日
        patentCell.setPubilcDate(patent.getPubDate());
        //装载授权公告号(未找到)
        //装载授权公告日(未找到)
        //装载主分类号
        List<String> ipCs = patent.getIpCs();
        List<String> cpCs = patent.getCpCs();
        ipCs.addAll(cpCs);
        if (ipCs != null && ipCs.size() > 0) {
            patentCell.setMainIpc(ipCs.get(0));
        }
        //装载分类号
        if (ipCs != null && ipCs.size() > 0) {
            patentCell.setIpc(ipCs);
        }
        //装载申请人
        ArrayList<String> applicationPersons = new ArrayList<>();
        for (Application application : patent.getApplications()) {
            if (application.getOriginalName().contains("(标：)")) {
                application.setOriginalName(application.getOriginalName().substring(0, application.getOriginalName().indexOf("(标：)")));
            }
            applicationPersons.add(application.getOriginalName());
        }
        patentCell.setApplicationPersons(applicationPersons);
        //装载申请人地址(未找到)
        //装载发明人
        ArrayList<String> inventors = new ArrayList<>();
        for (Inventor inventor : patent.getInventors()) {
            inventors.add(inventor.getOriginalName());
        }
        patentCell.setInventors(inventors);
        //装载当前权利人(未找到)
        //装载代理人(未找到)
        //装载代理机构(未找到)
        //装载范畴分类(未找到)
        //装载当前状态(未找到)
        //装载同族号
        patentCell.setFamilyId(patent.getFamilyId());
        //装载著录标题
        String olTitle = patent.getOlTitle();
        String enTitle = patent.getEnTitle();
        if (olTitle == null) {
            patentCell.setTitle(enTitle);
        } else {
            patentCell.setTitle(olTitle);
        }
        //装载摘要
        String olAbstract = patent.getOlAbstract();
        String enAbstract = patent.getEnAbstract();
        if (olAbstract == null) {
            patentCell.setAbstrText(enAbstract);
        } else {
            patentCell.setAbstrText(olAbstract);
        }
        //装载优先权号、优先权国家、优先权日
        ArrayList<Priority> priorities = new ArrayList<>();
        List<Priorityy> priorties = patent.getPriorties();
        for (Priorityy priorty : priorties) {
            for (PriorityNumber number : priorty.getNumbers()) {
                if (number.getType().equals("epodoc")) {
                    Priority priority = new Priority()
                            .setPriorityNo(number.getNumber().substring(2))
                            .setPriorityCountry(number.getNumber().substring(0, 2))
                            .setPriorityDate(priorty.getDate());
                    priorities.add(priority);
                }
            }
        }
        patentCell.setPriorities(priorities);
    }

    /**
     * 装载权要方法
     *
     * @param patentCell 实体类对象
     * @param pubNo      公开号对象
     */
    private void setPatentClaim(PatentCell patentCell, PubNo pubNo) throws IOException {
        GetClaimsInfoParamsDTO getClaimsInfoParamsDTO = new GetClaimsInfoParamsDTO()
                .setCc(pubNo.getCountry())
                .setNumber(pubNo.getNumber())
                .setKind(pubNo.getKind());
        String res = outInterfaceService.getClaimsInfo(getClaimsInfoParamsDTO);
        JSONObject jsonObject = JSONObject.parseObject(res);
        if (!jsonObject.get("status").toString().equals("200")) {
            //若发生类似400、500等异常(杰哥处理)
            //ThrowException.throwXiaoShiException("权要接口无法检索该国家专利");
            log.info("权要接口无法检索该国家专利");
            return;
        }
        //拿到检索结果(未格式化的含有页面等标签的权要)并格式化权要
        //String unformatRight = JSONObject.parseObject(jsonObject.get("data").toString(), String.class);
        ArrayList<String> unformatRights = JSONObject.parseObject(jsonObject.get("data").toString(), ArrayList.class);
        //String[] rightArr = unformatRight.split("\n");
        //ArrayList<String> rights = new ArrayList<>(Arrays.asList(rightArr));
        patentCell.setRights(unformatRights);
    }

    /**
     * 装载说明书方法
     *
     * @param patentCell 实体类对象
     * @param pubNo      公开号对象
     */
    private void setPatentInstructionText(PatentCell patentCell, PubNo pubNo) throws IOException {
        GetDescriptionInfoParamsDTO getDescriptionInfoParamsDTO = new GetDescriptionInfoParamsDTO()
                .setCc(pubNo.getCountry())
                .setNumber(pubNo.getNumber())
                .setKind(pubNo.getKind());
        String res = outInterfaceService.getDescriptionInfo(getDescriptionInfoParamsDTO);
        JSONObject jsonObject = JSONObject.parseObject(res);
        if (!jsonObject.get("status").toString().equals("200")) {
            //若发生类似400、500等异常(杰哥处理)
            //ThrowException.throwXiaoShiException("说明书接口无法检索该国家专利");
            log.info("说明书接口无法检索该国家专利");
            return;
        }
        //拿到检索结果(未格式化的含有页面等标签的说明书)
        //String unformatInstructionText = JSONObject.parseObject(jsonObject.get("data").toString(), String.class);
        List<String> unformatInstructionText = JSONObject.parseObject(jsonObject.get("data").toString(), List.class);
        StringBuilder builder = new StringBuilder();
        for (String n : unformatInstructionText) {
            builder.append(n);
        }
//        String regex = "<p>(.+?)</p>";
//        Matcher matcher = Pattern.compile(regex).matcher(unformatInstructionText);
//        if (matcher.find()) {
//            patentCell.setPatentInstructionText(matcher.group());
//        }
        patentCell.setPatentInstructionText(builder + "");
    }

    /**
     * 获取Image信息方法(从信息中获取三种附图的检索参数)
     *
     * @param pubNo 公开号对象
     */
    private ImageInfo getImage(PubNo pubNo) throws IOException {
        String res = outInterfaceService.getImagesInfo(pubNo);
        JSONObject jsonObject = JSONObject.parseObject(res);
        if (!jsonObject.get("status").toString().equals("200")) {
            //若发生类似400、500等异常(杰哥处理)
            ThrowException.throwXiaoShiException("Image信息接口无法检索该国家专利");
        }
        //拿到检索结果(未格式化的含有页面等标签的说明书)
        String unFormatData = jsonObject.get("data").toString();
        String data = unFormatData.substring(unFormatData.indexOf("[") + 1, unFormatData.lastIndexOf("]"));
        ImageInfo imageInfo = JSONObject.parseObject(data, ImageInfo.class);
        return imageInfo;
    }

    /**
     * 装载说明书附件pdf方法
     *
     * @param link       附件链接
     * @param page       附件页数
     * @param type       附件类型
     * @param patentCell 实体类对象
     */
    private void setFuJian(String link, Integer page, String type, PatentCell patentCell, String FuJianSuffix) throws Exception {
        //合并说明书pdf文档时所需的读取流数组
        InputStream[] streams = new InputStream[page];
        //其他附图url数组
        ArrayList<String> otherUrls = new ArrayList<>();
        //遍历附件页数
        for (int i = 1; i <= page; i++) {
            GetFuTuParamsDTO getFuTuParamsDTO = new GetFuTuParamsDTO()
                    .setLink(link)
                    .setPage(i)
                    .setType(type);
            byte[] buffer = outInterfaceService.getPatentFile(getFuTuParamsDTO);
            InputStream inputStream = new ByteArrayInputStream(buffer);
            streams[i - 1] = inputStream;
            //如果不是说明书pdf
            if (!FuJianSuffix.equals(".pdf")) {
                File file = File.createTempFile("new_url", FuJianSuffix);
                FileOutputStream out = new FileOutputStream(file);
                out.write(buffer);
                out.close();
                streams[i - 1] = new FileInputStream(file);
                DiskFileItemFactory diskFileItemFactory = new DiskFileItemFactory(16, null);
                FileItem item = diskFileItemFactory.createItem(file.getName(), "text/plain", true, file.getName());
                int bytesRead = 0;
                buffer = new byte[8192];
                try {
                    FileInputStream fis = new FileInputStream(file);
                    OutputStream os = item.getOutputStream();
                    int len = 8192;
                    while ((bytesRead = fis.read(buffer, 0, len)) != -1) {
                        os.write(buffer, 0, bytesRead);
                    }
                    os.close();
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                MultipartFile multipartFile = new CommonsMultipartFile(item);
                UploadFileDTO fileDTO = fileUtils.uploadFile(multipartFile);
                //如果是摘要附图
                if (FuJianSuffix.equals(".jpeg")) {
                    patentCell.setPicUrl(fileDTO.getPath());
                }
                //如果是其他附图
                if (FuJianSuffix.equals(".tiff")) {
                    otherUrls.add(fileDTO.getPath());
                }
            }
        }

        //如果是说明书pdf
        if (FuJianSuffix.equals(".pdf")) {
            //合并说明书多个pdf文件
            PdfDocumentBase doc = PdfDocument.mergeFiles(streams);
            //保存结果文件
            doc.save("merge.pdf", FileFormat.PDF);
            doc.close();

            //手动将合并后的pdf文件转成MultipartFile，上传文件并获取path装载到patentCell
            File file = new File("merge.pdf");
            DiskFileItemFactory diskFileItemFactory = new DiskFileItemFactory(16, null);
            FileItem item = diskFileItemFactory.createItem(file.getName(), "text/plain", true, file.getName());
            int bytesRead = 0;
            byte[] buffer = new byte[8192];
            try {
                FileInputStream fis = new FileInputStream(file);
                OutputStream os = item.getOutputStream();
                int len = 8192;
                while ((bytesRead = fis.read(buffer, 0, len)) != -1) {
                    os.write(buffer, 0, bytesRead);
                }
                os.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            MultipartFile multipartFile = new CommonsMultipartFile(item);
            UploadFileDTO fileDTO = fileUtils.uploadFile(multipartFile);
            patentCell.setPdf(fileDTO);
        } else if (FuJianSuffix.equals(".tiff")) {
            patentCell.setOtherUrls(otherUrls);
        }


    }

}