PAS/src/main/java/cn/cslg/pas/service/FinalInvalidStatueService.java

package cn.cslg.pas.service;

import cn.cslg.pas.common.dto.invalidDTO.PatentClaimDTO;
import cn.cslg.pas.common.model.finalInvalid.FinalProfGroupEditDTO;
import cn.cslg.pas.common.model.finalInvalid.FinalProfGroupQueryDTO;
import cn.cslg.pas.common.model.finalInvalid.FinalProfGroupVO;
import cn.cslg.pas.common.vo.invalidVO.PatentClaimHistoryVO;
import cn.cslg.pas.domain.FinalInvalidStatue;
import cn.cslg.pas.domain.FinalProofGroup;
import cn.cslg.pas.domain.business.InvalidStatutes;
import cn.cslg.pas.domain.business.ProofGroup;
import cn.cslg.pas.mapper.FinalInvalidStatueMapper;
import cn.cslg.pas.service.business.InvalidStatutesService;
import cn.cslg.pas.service.business.ProofGroupService;
import cn.cslg.pas.service.business.invalidReport.PatentClaimHistoryService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
import org.springframework.data.elasticsearch.core.query.UpdateQuery;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author admin
 * @description 针对表【final_invalid_statue(最终无效理由和证据)】的数据库操作Service实现
 * @createDate 2024-06-20 17:09:07
 */
@Service
@RequiredArgsConstructor
public class FinalInvalidStatueService extends ServiceImpl<FinalInvalidStatueMapper, FinalInvalidStatue> {
    private final InvalidStatutesService invalidStatutesService;
    private final PatentClaimHistoryService patentClaimHistoryService;
    private static List<Integer> inStatueIds = Arrays.asList(2, 3, 4);
    private final ProofGroupService proofGroupService;
    private final FinalProofGroupService finalProofGroupService;

    public void ImportByProjectId(Integer projectId, Integer statueType) {

    }

    @Transactional(rollbackFor = Exception.class)
    public void importFinalInvalidStatutes(Integer projectId) {

        //删除原来保存数据
        this.removeFinalInvalidStatus(projectId);
        //根据projectId 查询无效理由和证据
        LambdaQueryWrapper<InvalidStatutes> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(InvalidStatutes::getProjectId, projectId);
        List<InvalidStatutes> invalidStatutes = invalidStatutesService.list(queryWrapper);

        for (InvalidStatutes invalidStatute : invalidStatutes) {
            FinalInvalidStatue finalInvalidStatue = new FinalInvalidStatue();
            Integer claimId = invalidStatute.getClaimId();
            finalInvalidStatue.setStatuteId(invalidStatute.getStatutesId());
            Map<String, String> claimMess = this.getClaimText(claimId);
            finalInvalidStatue.setClaimText(claimMess.get("claimText"));
            finalInvalidStatue.setCourtOpinions1(claimMess.get("court1"));
            finalInvalidStatue.setCourtOpinions2(claimMess.get("court2"));
            if (claimMess.get("index") != null) {
                Integer index = Integer.parseInt(claimMess.get("index").toString());
                finalInvalidStatue.setClaimOrder(index);
            }
            finalInvalidStatue.setProjectId(projectId);
            finalInvalidStatue.insert();
            finalProofGroupService.addFinalProofGroup(invalidStatute.getId(), finalInvalidStatue);
        }

    }

    public Map<String, String> getClaimText(Integer claimId) {
        String claimText = "";
        PatentClaimDTO patentClaimDTO = new PatentClaimDTO();
        patentClaimDTO.setClaimId(claimId);

        PatentClaimHistoryVO patentClaimHistoryVO = patentClaimHistoryService.queryPatentClaimHistory(patentClaimDTO);
        if (patentClaimHistoryVO.getSecondClaimVO() != null && patentClaimHistoryVO.getSecondClaimVO().getOperateType().equals(0)) {
            claimText = patentClaimHistoryVO.getSecondClaimVO().getContent();
        } else if (patentClaimHistoryVO.getFirstClaimVO() != null && patentClaimHistoryVO.getFirstClaimVO().getOperateType().equals(0)) {
            claimText = patentClaimHistoryVO.getFirstClaimVO().getContent();
        } else {
            claimText = patentClaimHistoryVO.getOriginalClaimVO().getContent();
        }
        Map<String, String> map = new HashMap<>();
        map.put("claimText", claimText);
        map.put("court1", patentClaimHistoryVO.getOriginalClaimVO().getCourtDecision1());
        map.put("court2", patentClaimHistoryVO.getOriginalClaimVO().getCourtDecision2());
        if( patentClaimHistoryVO.getOriginalClaimVO().getSysOrder()!=null) {
            map.put("index", patentClaimHistoryVO.getOriginalClaimVO().getSysOrder().toString());
        }
        return map;
    }

    public List<FinalProfGroupVO> queryFinalProofGroup(FinalProfGroupQueryDTO finalProfGroupQueryDTO) {
        List<FinalProfGroupVO> finalProfGroupVOS = new ArrayList<>();

        Integer projectId = finalProfGroupQueryDTO.getId();
        Integer statusType = finalProfGroupQueryDTO.getStatueType();
        //根据projectId查询最终无效理由和证据
        LambdaQueryWrapper<FinalInvalidStatue> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(FinalInvalidStatue::getProjectId, projectId)
                    .orderByAsc(FinalInvalidStatue::getStatuteId)
                    .orderByAsc(FinalInvalidStatue::getClaimOrder);

        if (statusType != null) {
            if (statusType.equals(1)) {
                queryWrapper.in(FinalInvalidStatue::getStatuteId, inStatueIds);
            } else {
                queryWrapper.notIn(FinalInvalidStatue::getStatuteId, inStatueIds);

            }
        }
        List<FinalInvalidStatue> finalInvalidStatues = this.list(queryWrapper);
        if (finalInvalidStatues.size() == 0) {
            return finalProfGroupVOS;
        }
        List<Integer> ids = finalInvalidStatues.stream().map(FinalInvalidStatue::getId).collect(Collectors.toList());

        List<FinalProofGroup> finalProofGroups = new ArrayList<>();
        LambdaQueryWrapper<FinalProofGroup> queryWrapper1 = new LambdaQueryWrapper<>();
        queryWrapper1.in(FinalProofGroup::getFinalInvalidStatueId, ids);
        finalProofGroups = finalProofGroupService.list(queryWrapper1);

        for(FinalInvalidStatue finalInvalidStatue:finalInvalidStatues)
        {
            Integer id =finalInvalidStatue.getId();
 List<FinalProofGroup> statueGroups =finalProofGroups.stream().filter(item->item.getFinalInvalidStatueId().equals(id)).collect(Collectors.toList());
 statueGroups.forEach(item->{
     FinalProfGroupVO finalProfGroupVO = new FinalProfGroupVO();
     if (finalInvalidStatue != null) {
         finalProfGroupVO.setInvalidStatue(finalInvalidStatue);
     }
     finalProfGroupVO.setId(item.getId());
     finalProfGroupVO.setPresentOpinions(item.getPresentOpinions());
     finalProfGroupVO.setInvalidReason(item.getInvalidReason());
     finalProfGroupVO.setRbDecision(item.getRbDecision());
     finalProfGroupVOS.add(finalProfGroupVO);
 });
        }
        return finalProfGroupVOS;
    }


    public void editProofGroup(FinalProfGroupEditDTO finalProfGroupEditDTO) {
        Integer invalidStatueId = finalProfGroupEditDTO.getInvalidStatueId();
        Integer proofGroupId = finalProfGroupEditDTO.getProofGroupId();
        String editField = finalProfGroupEditDTO.getEditField();
        String fieldContent = finalProfGroupEditDTO.getFieldContent();
        switch (editField) {
            case "invalidReason":
                FinalProofGroup finalProofGroup1 = finalProofGroupService.getById(proofGroupId);
                finalProofGroup1.setInvalidReason(fieldContent);
                finalProofGroup1.updateById();
                break;
            case "presentOpinions":
                FinalProofGroup finalProofGroup2 = finalProofGroupService.getById(proofGroupId);
                finalProofGroup2.setPresentOpinions(fieldContent);
                finalProofGroup2.updateById();
                break;
            case "rbDecision":
                FinalProofGroup finalProofGroup3 = finalProofGroupService.getById(proofGroupId);
                finalProofGroup3.setRbDecision(fieldContent);
                finalProofGroup3.updateById();
                break;
            case "courtOpinions1":
                FinalInvalidStatue finalInvalidStatue1 = this.getById(invalidStatueId);
                Integer claimOrder = finalInvalidStatue1.getClaimOrder();
                UpdateWrapper<FinalInvalidStatue> updateWrapper = new UpdateWrapper<>();

                // Lambda表达式
                updateWrapper.lambda().set(FinalInvalidStatue::getCourtOpinions1, fieldContent)
                        .eq(FinalInvalidStatue::getClaimOrder, claimOrder)
                        .eq(FinalInvalidStatue::getProjectId, finalInvalidStatue1.getProjectId());
                this.update(updateWrapper);
                break;
            case "courtOpinions2":
                FinalInvalidStatue finalInvalidStatue2 = this.getById(invalidStatueId);
                Integer claimOrder2 = finalInvalidStatue2.getClaimOrder();
                UpdateWrapper<FinalInvalidStatue> updateWrapper2 = new UpdateWrapper<>();

                // Lambda表达式
                updateWrapper2.lambda().set(FinalInvalidStatue::getCourtOpinions2, fieldContent)
                        .eq(FinalInvalidStatue::getClaimOrder, claimOrder2)
                        .eq(FinalInvalidStatue::getProjectId, finalInvalidStatue2.getProjectId());
                this.update(updateWrapper2);
                break;
            case "claimText":
                FinalInvalidStatue finalInvalidStatue3 = this.getById(invalidStatueId);
                Integer claimOrder3 = finalInvalidStatue3.getClaimOrder();
                UpdateWrapper<FinalInvalidStatue> updateWrapper3 = new UpdateWrapper<>();

                // Lambda表达式
                updateWrapper3.lambda().set(FinalInvalidStatue::getClaimText, fieldContent)
                        .eq(FinalInvalidStatue::getClaimOrder, claimOrder3)
                        .eq(FinalInvalidStatue::getProjectId, finalInvalidStatue3.getProjectId());
                this.update(updateWrapper3);
                break;
            case "statuteId":
                FinalInvalidStatue finalInvalidStatue4 = this.getById(invalidStatueId);
                finalInvalidStatue4.setStatuteId(Integer.parseInt(fieldContent));
                finalInvalidStatue4.updateById();
        }
    }


    public void removeFinalInvalidStatus(Integer projectId) {
        LambdaQueryWrapper<FinalInvalidStatue> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(FinalInvalidStatue::getProjectId, projectId);
        LambdaQueryWrapper<FinalProofGroup> queryWrapper1 = new LambdaQueryWrapper<>();
        queryWrapper1.eq(FinalProofGroup::getProjectId, projectId);
        this.remove(queryWrapper);
        finalProofGroupService.remove(queryWrapper1);

    }
}