PAS/src/main/java/cn/cslg/pas/service/importPatent/GetPatentPictureFromWebThread.java

package cn.cslg.pas.service.importPatent;

import cn.cslg.pas.common.core.IgnoreDTDEntityResolver;
import cn.cslg.pas.common.dto.UploadPatentWebDTO;
import cn.cslg.pas.common.utils.FileUtils;
import cn.cslg.pas.common.utils.FormatUtil;
import cn.cslg.pas.common.vo.ImportTaskAMVO;
import cn.cslg.pas.common.vo.StarPatentVO;
import cn.cslg.pas.domain.business.PatentImportErrorLog;
import cn.cslg.pas.domain.es.Patent;
import cn.cslg.pas.domain.es.Text;
import cn.cslg.pas.service.common.FileManagerService;
import cn.cslg.pas.service.common.PatentStarApiService;
import cn.hutool.core.util.IdUtil;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.ApplicationContext;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@Configurable
public class GetPatentPictureFromWebThread extends Thread {
    private ImportTaskAMVO importTaskAMVO;
    private ApplicationContext applicationContext;
    private ImportFromWebToEsService importFromWebToEsService;
    private List<UploadPatentWebDTO> uploadPatentWebDTOs = new ArrayList<>();
    private final Lock taskLock = new ReentrantLock();
    private final Condition taskCondition = taskLock.newCondition();
    private Boolean ifProductAll = false;
    private TaskThread taskThread;

    @Override
    public void run() {
        while ((!ifProductAll || uploadPatentWebDTOs.size() > 0) && importTaskAMVO.getState().equals(1)) {

            try {
                if (uploadPatentWebDTOs.size() == 0) {
                    taskLock.lock();
                    taskCondition.await();
                }
            } catch (Exception e) {
            }
            if (uploadPatentWebDTOs.size() == 0) {
                break;
            }
            UploadPatentWebDTO uploadPatentWebDTO = uploadPatentWebDTOs.remove(0);
            try {
                String usedNo = uploadPatentWebDTO.getStarPatentVO().getPN();
                if (usedNo == null||usedNo.trim().equals("")) {
                    usedNo = uploadPatentWebDTO.getStarPatentVO().getGN();
                }
                if (usedNo.contains("CN")) {
                    PatentStarApiService patentStarApiService = applicationContext.getBean(PatentStarApiService.class);

                    String pictureUrl = patentStarApiService.getPictureApi(uploadPatentWebDTO.getStarPatentVO().getANO());

                    if (pictureUrl != null && !pictureUrl.contains("408")) {
                        File file = FileUtils.getPictureFileByUrl(pictureUrl);
                        FileManagerService fileManagerService = applicationContext.getBean(FileManagerService.class);
                        String guid = FormatUtil.getPictureFormat(uploadPatentWebDTO.getStarPatentVO().getANO());
                        fileManagerService.uploadFileWithGuid(file, guid);
                    } else {
                        recordQuestionPatent(uploadPatentWebDTO.getStarPatentVO().getANO());
                    }

                } else {
                    ImportSinglePatentService importSinglePatentService = applicationContext.getBean(ImportSinglePatentService.class);
                    byte[] bytes = importSinglePatentService.getImages(usedNo);
                    if (bytes != null) {
                        File file = FileUtils.getFileByBytes(bytes, usedNo, "jpg");
                        FileManagerService fileManagerService = applicationContext.getBean(FileManagerService.class);
                        String guid = FormatUtil.getPictureFormat(uploadPatentWebDTO.getStarPatentVO().getANO());
                        fileManagerService.uploadFileWithGuid(file, guid);
                        file.delete();
                    } else {
                        recordQuestionPatent(uploadPatentWebDTO.getStarPatentVO().getANO());

                    }

                }
                taskThread.updateProcess(false, 2, "");
            } catch (Exception e) {
                taskThread.updateProcess(true, 2, "");
                recordQuestionPatent(uploadPatentWebDTO.getStarPatentVO().getAN());

                e.printStackTrace();
            }

        }
        taskThread.awakeTaskThread();
    }


    public GetPatentPictureFromWebThread(TaskThread taskThread, ImportFromWebToEsService importFromWebToEsService) {
        this.importTaskAMVO = taskThread.getImportTaskAMVO();
        this.importFromWebToEsService = importFromWebToEsService;
        this.applicationContext = taskThread.getApplicationContext();
        this.taskThread = taskThread;
    }

    public void awakeTask(UploadPatentWebDTO uploadPatentWebDTO) {
        UploadPatentWebDTO uploadPatentWebDTO1 = new UploadPatentWebDTO();
        BeanUtils.copyProperties(uploadPatentWebDTO, uploadPatentWebDTO1);
        uploadPatentWebDTOs.add(uploadPatentWebDTO1);
        if (taskLock.tryLock()) {
            taskCondition.signalAll();
            taskLock.unlock();
        }
    }

    public void setIfProductAll(Boolean ifProductAll) {

        this.ifProductAll = ifProductAll;
        if (taskLock.tryLock()) {
            System.out.println("专利导入到es解锁" + importTaskAMVO.getId());
            taskCondition.signalAll();
            taskLock.unlock();
        }
    }

    public void recordQuestionPatent(String appNo) {
        PatentImportErrorLog patentImportErrorLog = new PatentImportErrorLog();
        patentImportErrorLog.setPatentNo(appNo);
        patentImportErrorLog.setErrorType(3);
        patentImportErrorLog.setTaskId(importTaskAMVO.getId());
        patentImportErrorLog.insert();
    }
}