feat: 处理重复基础数据

src/main/java/com/docus/demo/controller/SyncBasicDataController.java

@@ -130,4 +130,22 @@ public class SyncBasicDataController {
             return CommonResult.failed("保存失败！异常处理" + e.getMessage());
         }
     }
+
+
+
+
+    @ApiOperation("根据 病案号、姓名、出院日期、住院次数 进行筛选数据保留一条")
+    @GetMapping("/choose")
+    public CommonResult<?> choose(){
+        log.info("根据 病案号、姓名、出院日期、住院次数 进行筛选数据保留一条");
+        try {
+            syncBasicDataService.choose();
+            log.info("根据 病案号、姓名、出院日期、住院次数 进行筛选数据保留一条,已完成！");
+            return CommonResult.success("筛选完成！");
+        } catch (Exception ex) {
+            log.error("根据 病案号、姓名、出院日期、住院次数 进行筛选数据保留一条,出现异常！" + ex.getMessage(), ex);
+            return CommonResult.failed("筛选异常！");
+        }
+    }
+
 }

src/main/java/com/docus/demo/dto/BasicChooseDto.java

@@ -0,0 +1,32 @@
+package com.docus.demo.dto;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+/**
+ * @author YongBin Wen
+ * @date 2024/9/6 16:05
+ */
+@Data
+@ApiModel("基础数据选择处理对象")
+public class BasicChooseDto {
+    @ApiModelProperty("病案主键")
+    private String patientId;
+
+    @ApiModelProperty("病案号")
+    private String inpatientNo;
+
+    @ApiModelProperty("患者出院日期 yyyy-MM-dd")
+    private String disDate;
+
+    @ApiModelProperty("患者姓名")
+    private String name;
+
+    @ApiModelProperty("患者姓名")
+    private Integer admissTimes;
+
+    @ApiModelProperty("优先级")
+    private int priority;
+
+}

src/main/java/com/docus/demo/entity/ScanAssort.java

@@ -49,6 +49,9 @@ public class ScanAssort {
     @ApiModelProperty(value = "页数")
     private Integer filePages;
 
+    @ApiModelProperty(value = "是否作废，0未作废")
+    private Integer isDel;
+
     private String creater;
 
     private String createrName;

src/main/java/com/docus/demo/facade/ISyncBasicDataService.java

@@ -15,4 +15,6 @@ public interface ISyncBasicDataService {
     CommonResult<?> syncLzBasicData(SyncBasicDataDto syncBasicDataDto);
 
     void scanBasicCorrect(List<BasicCorrectDto> basicCorrectDtos);
+
+    void choose();
 }

src/main/java/com/docus/demo/mapper/mysql/BasicMapper.java

@@ -44,4 +44,10 @@ public interface BasicMapper {
     Boolean delTbasicByAdmissId(@Param("admissId")String admissId);
 
     int updateScanBasicCorrect(@Param("oldPatId") String oldBasicPatientId, @Param("newPatId") String newPatientId,@Param("ph")  String ph);
+
+    int delTbasic(@Param("pidList") List<String> patientIds);
+
+    List<Tbasic> getTbasicByInpatientNo(@Param("inpatientNo") String inpatientNo);
+
+    List<String> getInpatientNos();
 }

src/main/java/com/docus/demo/mapper/mysql/ScanAssortMapper.java

@@ -33,5 +33,9 @@ public interface ScanAssortMapper  {
 
     int updatePatientId(@Param("oldPatId") String oldBasicPatientId, @Param("newPatId") String newPatientId);
 
+    int updatePatientIdById(@Param("ids") List<Long> ids, @Param("newPatId") String newPatientId);
+
     int delScanAssortById(@Param("id") Long id);
+
+    List<ScanAssort> getListByPids(@Param("pidList") List<String> patientIds);
 }

src/main/java/com/docus/demo/service/SyncBasicDataImpl.java

@@ -2,11 +2,14 @@ package com.docus.demo.service;
 
 
 import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
+import com.docus.demo.dto.BasicChooseDto;
 import com.docus.demo.dto.BasicCorrectDto;
 import com.docus.demo.dto.SyncBasicDataDto;
 import com.docus.demo.entity.CommonResult;
+import com.docus.demo.entity.ScanAssort;
 import com.docus.demo.entity.Tbasic;
 import com.docus.demo.entity.TbasicSub;
 import com.docus.demo.entity.sqlserver.CardInfo;
@@ -158,10 +161,278 @@ public class SyncBasicDataImpl implements ISyncBasicDataService {
         }
     }
 
+
+    @Override
+    public void choose() {
+        int count = 0;
+        List<String> inpatientNos = basicMapper.getInpatientNos();
+        log.info("本次筛选病案号数量为：{}", inpatientNos.size());
+        for (String inpatientNo : inpatientNos) {
+            choose(inpatientNo);
+            count++;
+            log.info("已经筛选病案号：{} 个", count);
+        }
+        log.info("本次筛选完成！");
+    }
+
+    /**
+     * 根据 病案号、姓名、出院日期、住院次数  判断是同一个人，进行数据筛选。
+     * 有盘号/箱号 优先级 +10
+     * 如果有现场扫描文件数据 优先级 +4。
+     * 如果有联众文件数据 优先级 +3。
+     * 文件数量更多的,判断现场和联众 现场多优先级 +2 ，联众多优先级 +1。
+     * 根据最后优先级选择最高的，如果有相同选择，随机挑选一条。
+     * 文件数据合并到选择的患者（选择的患者没有的文件来源随机挑选一个患者）。
+     * 未被选择的删除基础信息。
+     */
+    private void choose(String inpatientNo) {
+        List<Tbasic> basicList = basicMapper.getTbasicByInpatientNo(inpatientNo);
+        if (basicList.size() == 1) {
+            return;
+        }
+        Map<String, List<Tbasic>> group = new HashMap<>();
+        for (Tbasic tbasic : basicList) {
+            String groupKey = tbasic.getInpatientNo() + "_" + tbasic.getName() + "_" + DateUtil.formatDate(tbasic.getDisDate()) + "_" + tbasic.getAdmissTimes();
+            List<Tbasic> groupOrDefault = group.getOrDefault(groupKey, new ArrayList<>());
+            groupOrDefault.add(tbasic);
+            group.put(groupKey, groupOrDefault);
+        }
+
+        Set<Map.Entry<String, List<Tbasic>>> entries = group.entrySet();
+        for (Map.Entry<String, List<Tbasic>> entry : entries) {
+            List<Tbasic> value = entry.getValue();
+            if (value.size() <= 1) {
+                continue;
+            }
+            groupChoose(value);
+        }
+    }
+
+    /**
+     * 根据重复数据已经分组进行处理
+     */
+    private void groupChoose(List<Tbasic> basicList) {
+        if (basicList.size() <= 1) {
+            return;
+        }
+
+        List<BasicChooseDto> chooseDtoList = new ArrayList<>();
+        for (Tbasic basic : basicList) {
+            BasicChooseDto chooseDto = new BasicChooseDto();
+            chooseDto.setPatientId(basic.getPatientId());
+            chooseDto.setName(basic.getName());
+            chooseDto.setInpatientNo(basic.getInpatientNo());
+            chooseDto.setAdmissTimes(basic.getAdmissTimes());
+            chooseDto.setDisDate(DateUtil.formatDate(basic.getDisDate()));
+            if (StrUtil.isBlank(basic.getPh())) {
+                chooseDto.setPriority(0);
+            } else {
+                chooseDto.setPriority(10);
+            }
+            chooseDtoList.add(chooseDto);
+        }
+        if (judgeAndProcess(chooseDtoList)) {
+            return;
+        }
+
+        Map<String, Map<String, List<ScanAssort>>> groupByPatientGroupBySource = new HashMap<>(10);
+        for (BasicChooseDto basicChooseDto : chooseDtoList) {
+            List<ScanAssort> assorts = scanAssortMapper.getListByPid(basicChooseDto.getPatientId());
+            assorts = assorts.stream().filter(f -> {
+                if (f.getSource() == null) {
+                    f.setSource("unknow");
+                }
+                Integer del = 1;
+                return ObjectUtil.notEqual(del, f.getIsDel());
+            }).collect(Collectors.toList());
+            if (CollUtil.isEmpty(assorts)) {
+                continue;
+            }
+            Map<String, List<ScanAssort>> groupBySource = assorts.stream().collect(Collectors.groupingBy(ScanAssort::getSource));
+            if (groupBySource.containsKey("-1")) {
+                basicChooseDto.setPriority(basicChooseDto.getPriority() + 4);
+            }
+            if (groupBySource.containsKey("lianzhong")) {
+                basicChooseDto.setPriority(basicChooseDto.getPriority() + 3);
+            }
+            groupByPatientGroupBySource.put(basicChooseDto.getPatientId(), groupBySource);
+        }
+        if (judgeAndProcess(chooseDtoList)) {
+            return;
+        }
+
+        int siteMaxSize = 0;
+        int lianzhongMaxSize = 0;
+        HashMap<Integer, List<BasicChooseDto>> siteFileCountMap = new HashMap<>();
+        HashMap<Integer, List<BasicChooseDto>> lianzhongFileCountMap = new HashMap<>();
+        for (BasicChooseDto chooseDto : chooseDtoList) {
+            Map<String, List<ScanAssort>> groupBySource = groupByPatientGroupBySource.getOrDefault(chooseDto.getPatientId(), new HashMap<>());
+
+            List<ScanAssort> siteScan = groupBySource.getOrDefault("-1", new ArrayList<>());
+            int siteSize = siteScan.size();
+            List<ScanAssort> lianzhong = groupBySource.getOrDefault("lianzhong", new ArrayList<>());
+            int lianzhongSize = lianzhong.size();
+
+            List<BasicChooseDto> siteGroup = siteFileCountMap.getOrDefault(siteSize, new ArrayList<>());
+            siteGroup.add(chooseDto);
+            List<BasicChooseDto> lianzhongGroup = lianzhongFileCountMap.getOrDefault(lianzhongSize, new ArrayList<>());
+            lianzhongGroup.add(chooseDto);
+
+            siteFileCountMap.put(siteSize, siteGroup);
+            lianzhongFileCountMap.put(lianzhongSize, lianzhongGroup);
+
+            siteMaxSize = Math.max(siteMaxSize, siteSize);
+            lianzhongMaxSize = Math.max(lianzhongMaxSize, lianzhongSize);
+        }
+        List<BasicChooseDto> siteCountChoose = siteFileCountMap.get(siteMaxSize);
+        List<BasicChooseDto> lianzhongCountChoose = lianzhongFileCountMap.get(lianzhongMaxSize);
+        for (BasicChooseDto dto : siteCountChoose) {
+            dto.setPriority(dto.getPriority() + 2);
+        }
+        for (BasicChooseDto dto : lianzhongCountChoose) {
+            dto.setPriority(dto.getPriority() + 1);
+        }
+        // 最后无需再判定，直接取最大优先权中的一条
+        processSelection(chooseDtoList, electedOneData(chooseDtoList));
+    }
+
+    /**
+     * 判定选择并且处理
+     *
+     * @return 如果已经选择且处理 返回true
+     */
+    private boolean judgeAndProcess(List<BasicChooseDto> chooseDtoList) {
+        if (elected(chooseDtoList) && electedOne(chooseDtoList)) {
+            processSelection(chooseDtoList, electedOneData(chooseDtoList));
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 处理选择后的逻辑，
+     * 文件数据合并到选择的患者（选择的患者没有的文件来源随机挑选一个患者）。
+     * 未被选择的删除基础信息。
+     *
+     * @param chooseDtoList 选择的集合
+     * @param finalElected  最终的选择数据
+     */
+    private void processSelection(List<BasicChooseDto> chooseDtoList, BasicChooseDto finalElected) {
+        String selectPatientId = finalElected.getPatientId();
+        List<String> allPatientIds = chooseDtoList.stream().map(BasicChooseDto::getPatientId).collect(Collectors.toList());
+        List<ScanAssort> allScanAssorts = scanAssortMapper.getListByPids(allPatientIds);
+        allScanAssorts = allScanAssorts.stream().filter(f -> {
+            if (f.getSource() == null) {
+                f.setSource("unknow");
+            }
+            Integer del = 1;
+            return ObjectUtil.notEqual(del, f.getIsDel());
+        }).collect(Collectors.toList());
+
+        if (CollUtil.isEmpty(allScanAssorts)) {
+            return;
+        }
+
+        Set<String> allSources = allScanAssorts.stream().map(ScanAssort::getSource).collect(Collectors.toSet());
+        Set<String> selectPatientSources = allScanAssorts.stream()
+                .filter(e -> ObjectUtil.equals(selectPatientId, e.getPatientId()))
+                .map(ScanAssort::getSource)
+                .collect(Collectors.toSet());
+
+        for (String source : allSources) {
+            if (selectPatientSources.contains(source)) {
+                continue;
+            }
+            transferScanAssortBySource(allScanAssorts, selectPatientId, source);
+            selectPatientSources.add(source);
+        }
+
+        List<String> notSelectedPids = allPatientIds.stream().filter(e -> !e.equals(selectPatientId)).collect(Collectors.toList());
+        basicMapper.delTbasic(notSelectedPids);
+        for (String notSelectedPid : notSelectedPids) {
+            basicMapper.delTbasicSub(notSelectedPid);
+        }
+
+    }
+
+    /**
+     * 文件数据合并到选择的患者（选择的患者没有的文件来源随机挑选一个患者）。
+     *
+     * @param allScanAssorts  所有的文件数据
+     * @param selectPatientId 选择的患者主键
+     * @param source          来源
+     */
+    private void transferScanAssortBySource(List<ScanAssort> allScanAssorts, String selectPatientId, String source) {
+        // 选择该来源的其他患者中这个来源数量最多的
+        Map<String, List<ScanAssort>> groupByPatient = allScanAssorts.stream()
+                .filter(e -> !ObjectUtil.equals(selectPatientId, e.getPatientId()) && ObjectUtil.equals(source, e.getSource()))
+                .collect(Collectors.groupingBy(ScanAssort::getPatientId));
+        int maxSize = 0;
+        String maxSizePatient = null;
+        Set<Map.Entry<String, List<ScanAssort>>> entries = groupByPatient.entrySet();
+        for (Map.Entry<String, List<ScanAssort>> entry : entries) {
+            List<ScanAssort> assorts = entry.getValue();
+            int size = assorts.size();
+            if (size > maxSize) {
+                maxSize = size;
+                maxSizePatient = assorts.get(0).getPatientId();
+            }
+        }
+        List<ScanAssort> updateScanAssort = groupByPatient.get(maxSizePatient);
+        List<Long> updateScanAssortIds = updateScanAssort.stream()
+                .map(ScanAssort::getId)
+                .collect(Collectors.toList());
+        scanAssortMapper.updatePatientIdById(updateScanAssortIds, selectPatientId);
+    }
+
+    /**
+     * 是否已经有选举,判定集合中是否已经有优先级大于0的数据
+     */
+    private boolean elected(List<BasicChooseDto> chooseDtoList) {
+        for (BasicChooseDto dto : chooseDtoList) {
+            if (dto.getPriority() > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 只存在一条选举，判定集合中优先级最大的只有一条
+     */
+    private boolean electedOne(List<BasicChooseDto> chooseDtoList) {
+        List<BasicChooseDto> list = electedMaxPriorityData(chooseDtoList);
+        return list.size() == 1;
+    }
+
+    /**
+     * 从最大选举权的数据选择一条
+     */
+    private BasicChooseDto electedOneData(List<BasicChooseDto> chooseDtoList) {
+        List<BasicChooseDto> list = electedMaxPriorityData(chooseDtoList);
+        return list.get(0);
+    }
+
+    /**
+     * 取得最大选举权的集合
+     */
+    private List<BasicChooseDto> electedMaxPriorityData(List<BasicChooseDto> chooseDtoList) {
+        Map<Integer, List<BasicChooseDto>> groupByPriority = chooseDtoList.stream()
+                .collect(Collectors.groupingBy(BasicChooseDto::getPriority));
+        int maxPriority = 0;
+        for (BasicChooseDto chooseDto : chooseDtoList) {
+            int priority = chooseDto.getPriority();
+            maxPriority = Math.max(priority, maxPriority);
+        }
+        return groupByPriority.get(maxPriority);
+    }
+
+
     public static void main(String[] args) {
         LocalDate startDate = LocalDate.parse("2024-05-06");
         System.out.println(startDate);
     }
+
     private List<TbasicSub> getTbasicSubList(List<Tbasic> tbasicList) {
         return tbasicList.stream().map(m -> {
             TbasicSub tbasicSub = new TbasicSub();
@@ -307,7 +578,6 @@ public class SyncBasicDataImpl implements ISyncBasicDataService {
     }
 
 
-
     private List<Tbasic> getInsertTbasic(List<Tbasic> oldBasicList, List<CardInfo> cardInfoList) {
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         List<CardInfo> cardInfos = cardInfoList.stream().filter(f -> {

src/main/resources/mapper/mysql/BasicMapper.xml

@@ -80,6 +80,13 @@
     <delete id="delTbasicSub">
         delete from docus_medicalrecord.t_basic_sub where patient_id=#{patientId}
     </delete>
+    <delete id="delTbasic">
+        delete from docus_medicalrecord.t_basic
+        where patient_id in
+        <foreach collection="pidList" item="pid" separator="," open="(" close=")">
+            #{pid}
+        </foreach>
+    </delete>
 
 
     <select id="getBasicVoList" resultType="com.docus.demo.vo.BasicVo">
@@ -189,6 +196,27 @@
         from docus_medicalrecord.t_basic
         where patient_id = #{patientId}
     </select>
+    <select id="getTbasicByInpatientNo" resultType="com.docus.demo.entity.Tbasic">
+        SELECT
+        patient_id,
+        admiss_times,
+        inpatient_no,
+        admiss_date,
+        `name`,
+        dis_date,
+        ph
+        FROM
+        docus_medicalrecord.t_basic
+        where
+             inpatient_no = #{inpatientNo}
+    </select>
+    <select id="getInpatientNos" resultType="java.lang.String">
+        SELECT
+            inpatient_no
+        FROM
+            docus_medicalrecord.t_basic
+        group by inpatient_no
+    </select>
 
 
 </mapper>

src/main/resources/mapper/mysql/ScanAssortMapper.xml

@@ -47,6 +47,13 @@
     <update id="updatePatientId">
         update docus_archivefile.t_scan_assort set patient_id=#{newPatId} where patient_id=#{oldPatId}
     </update>
+    <update id="updatePatientIdById">
+        update docus_archivefile.t_scan_assort set patient_id=#{newPatId}
+        where id in
+        <foreach collection="ids" item="id" separator="," open="(" close=")">
+            #{id}
+        </foreach>
+    </update>
     <delete id="deleteByPid">
         delete   FROM docus_archivefile.t_scan_assort
         where patient_id in
@@ -74,7 +81,9 @@
                file_pages,
                creater,
                create_time,
-               sort
+               sort,
+               is_del,
+               source
         FROM docus_archivefile.t_scan_assort
         WHERE patient_id = #{pid}
     </select>
@@ -90,7 +99,9 @@
                file_pages,
                creater,
                create_time,
-               sort
+               sort,
+               is_del,
+               source
         FROM docus_archivefile.t_scan_assort
         WHERE assort_id = #{assortId} and patient_id = #{pid} and source='jy'
 
@@ -98,5 +109,26 @@
     <select id="getScanAssort" resultType="com.docus.demo.entity.ScanAssort">
         SELECT *  FROM docus_archivefile.t_scan_assort WHERE patient_id=#{patientId} and source=#{source}
     </select>
+    <select id="getListByPids" resultType="com.docus.demo.entity.ScanAssort">
+        SELECT id,
+               patient_id,
+               assort_id,
+               file_title,
+               image_path,
+               scan_page,
+               file_source,
+               file_storage_type,
+               file_pages,
+               creater,
+               create_time,
+               sort,
+               is_del,
+               source
+        FROM docus_archivefile.t_scan_assort
+        where patient_id in
+        <foreach collection="pidList" item="pid" separator="," open="(" close=")">
+            #{pid}
+        </foreach>
+    </select>
 
 </mapper>