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

package cn.cslg.pas.service;

import cn.cslg.pas.common.core.base.Constants;
import cn.cslg.pas.common.utils.StringUtils;
import cn.cslg.pas.domain.Patent;
import cn.cslg.pas.domain.PatentAffair;
import cn.cslg.pas.domain.SystemDict;
import cn.cslg.pas.common.utils.DateUtils;
import cn.cslg.pas.mapper.PatentAffairMapper;
import cn.cslg.pas.common.model.params.PatentAffairParams;
import cn.cslg.pas.common.utils.PatentUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

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

/**
 * <p>
 * 专利信息事务信息表 服务类
 * </p>
 *
 * @author 王岩
 * @since 2022-02-24
 */
@Service
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class PatentAffairService extends ServiceImpl<PatentAffairMapper, PatentAffair> {

    private final SystemDictService systemDictService;
    private final PatentService patentService;

    public List<PatentAffair> getPatentAffairByPatentId(Integer patentId) {
        LambdaQueryWrapper<PatentAffair> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PatentAffair::getPatentId, patentId);
        queryWrapper.orderByDesc(PatentAffair::getDateTime);
        List<PatentAffair> dataList = this.list(queryWrapper);
        List<SystemDict> systemDictList = systemDictService.getSystemDictListByType(Arrays.asList(Constants.PATENT_STATUS, Constants.PATENT_SIMPLE_STATUS));
        dataList.forEach(item -> {
            List<String> splitStr = StringUtils.changeStringToString(item.getContent(), "\\|");
            List<Map<String, Object>> lst = new ArrayList<>();

            for (int i = 0; i < splitStr.size(); i += 3) {
                PatentAffair.INPADOC inpadoc = new PatentAffair.INPADOC();
                Map<String, Object> map = new HashMap<>();
                map.put("发生日期", splitStr.get(i).trim());
                map.put("国家", splitStr.get(i + 2).trim());
                map.put("内容", splitStr.get(i + 1).trim());

                lst.add(map);
            }
            item.setInpadoc(lst);
            item.setCreateTime(DateUtils.formatDate(item.getDateTime(), DateUtils.YYYY_MM_DD));
            item.setCreateSimpleStatus(systemDictList.stream().filter(systemDict -> systemDict.getType().equals(Constants.PATENT_SIMPLE_STATUS) && systemDict.getValue().equals(String.valueOf(item.getSimpleStatus()))).findFirst().orElse(new SystemDict()).getLabel());
            item.setCreateStatus(systemDictList.stream().filter(systemDict -> systemDict.getType().equals(Constants.PATENT_STATUS) && systemDict.getValue().equals(String.valueOf(item.getStatus()))).findFirst().orElse(new SystemDict()).getLabel());
        });
        return dataList;
    }

    public List<PatentAffair> getPatentAffairListByPatentIds(List<Integer> patentIds) {
        if (patentIds == null || patentIds.size() == 0) {
            return new ArrayList<>();
        }
        LambdaQueryWrapper<PatentAffair> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(PatentAffair::getPatentId, patentIds);
        return this.list(queryWrapper);
    }

    public void importPatentAffair(Patent localPatent, List<Patent> importPatentList, List<PatentAffair> importPatentAffairList) {
        this.deleteByPatentId(localPatent.getId());
        Patent importPatent = importPatentList.stream().filter(item -> item.getPatentNo().equals(localPatent.getPatentNo())).findFirst().orElse(new Patent());
        List<PatentAffair> importPatentAffairs = importPatentAffairList.stream().filter(item -> item.getPatentId().equals(importPatent.getId())).collect(Collectors.toList());
        for (PatentAffair patentAffair : importPatentAffairs) {
            patentAffair.setId(null);
            patentAffair.setPatentId(localPatent.getId());
        }
        this.saveOrUpdateBatch(importPatentAffairs);
    }

    public void updatePatientAffair(PatentAffairParams params) {
        if (params.getStatusList() != null) {
            this.deleteByPatentId(params.getPatentId());
            PatentAffair patentAffair = new PatentAffair();
            patentAffair.setPatentId(params.getPatentId());
            patentAffair.setStatus(params.getStatusList());
            patentAffair.setContent(params.getContent());
            patentAffair.setDateTime(params.getDateTime());
            patentAffair.setSimpleStatus(params.getSimpleStatus());
            this.saveOrUpdate(patentAffair);
        }
    }

    public void deleteByPatentId(Integer patentId) {
        this.remove(Wrappers.<PatentAffair>lambdaQuery().eq(PatentAffair::getPatentId, patentId));
    }
}