wkc/ccdi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

完成员工亲属实体关联改造并清理旧数据

Browse Source
This commit is contained in:
wkc
2026-04-24 08:55:05 +08:00
parent b7d020c0b2
commit b7db711906
25 changed files with 1298 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
ccdi-info-collection/src/main/java/com/ruoyi/info/collection/controller/CcdiStaffEnterpriseRelationController.java
View File

@@ -5,6 +5,7 @@ import com.ruoyi.info.collection.domain.dto.CcdiStaffEnterpriseRelationAddDTO;
import com.ruoyi.info.collection.domain.dto.CcdiStaffEnterpriseRelationEditDTO;
import com.ruoyi.info.collection.domain.dto.CcdiStaffEnterpriseRelationQueryDTO;
import com.ruoyi.info.collection.domain.excel.CcdiStaffEnterpriseRelationExcel;
import com.ruoyi.info.collection.domain.vo.CcdiStaffEnterpriseRelationOptionVO;
import com.ruoyi.info.collection.domain.vo.CcdiStaffEnterpriseRelationVO;
import com.ruoyi.info.collection.domain.vo.ImportResultVO;
import com.ruoyi.info.collection.domain.vo.ImportStatusVO;
@@ -33,12 +34,12 @@ import java.util.ArrayList;
import java.util.List;
/**
* 员工实体关系信息Controller
* 员工亲属实体关联Controller
*
* @author ruoyi
* @date 2026-02-09
*/
@Tag(name = "员工实体关系信息管理")
@Tag(name = "员工亲属实体关联管理")
@RestController
@RequestMapping("/ccdi/staffEnterpriseRelation")
public class CcdiStaffEnterpriseRelationController extends BaseController {
@@ -50,9 +51,9 @@ public class CcdiStaffEnterpriseRelationController extends BaseController {
private ICcdiStaffEnterpriseRelationImportService relationImportService;
/**
* 查询员工实体关系列表
* 查询员工亲属实体关联列表
*/
@Operation(summary = "查询员工实体关系列表")
@Operation(summary = "查询员工亲属实体关联列表")
@PreAuthorize("@ss.hasPermi('ccdi:staffEnterpriseRelation:list')")
@GetMapping("/list")
public TableDataInfo list(CcdiStaffEnterpriseRelationQueryDTO queryDTO) {
@@ -64,9 +65,20 @@ public class CcdiStaffEnterpriseRelationController extends BaseController {
}
/**
* 获取员工实体关系详细信息
* 查询有效员工亲属下拉列表
*/
@Operation(summary = "获取员工实体关系详细信息")
@Operation(summary = "查询有效员工亲属下拉列表")
@PreAuthorize("@ss.hasPermi('ccdi:staffEnterpriseRelation:list')")
@GetMapping("/familyOptions")
public AjaxResult familyOptions(@RequestParam(required = false) String query) {
List<CcdiStaffEnterpriseRelationOptionVO> list = relationService.selectFamilyOptions(query);
return success(list);
}
/**
* 获取员工亲属实体关联详细信息
*/
@Operation(summary = "获取员工亲属实体关联详细信息")
@Parameter(name = "id", description = "主键ID", required = true)
@PreAuthorize("@ss.hasPermi('ccdi:staffEnterpriseRelation:query')")
@GetMapping(value = "/{id}")
@@ -75,34 +87,34 @@ public class CcdiStaffEnterpriseRelationController extends BaseController {
}
/**
* 新增员工实体关系
* 新增员工亲属实体关联
*/
@Operation(summary = "新增员工实体关系")
@Operation(summary = "新增员工亲属实体关联")
@PreAuthorize("@ss.hasPermi('ccdi:staffEnterpriseRelation:add')")
@Log(title = "员工实体关系信息", businessType = BusinessType.INSERT)
@Log(title = "员工亲属实体关联", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody CcdiStaffEnterpriseRelationAddDTO addDTO) {
return toAjax(relationService.insertRelation(addDTO));
}
/**
* 修改员工实体关系
* 修改员工亲属实体关联
*/
@Operation(summary = "修改员工实体关系")
@Operation(summary = "修改员工亲属实体关联")
@PreAuthorize("@ss.hasPermi('ccdi:staffEnterpriseRelation:edit')")
@Log(title = "员工实体关系信息", businessType = BusinessType.UPDATE)
@Log(title = "员工亲属实体关联", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody CcdiStaffEnterpriseRelationEditDTO editDTO) {
return toAjax(relationService.updateRelation(editDTO));
}
/**
* 删除员工实体关系
* 删除员工亲属实体关联
*/
@Operation(summary = "删除员工实体关系")
@Operation(summary = "删除员工亲属实体关联")
@Parameter(name = "ids", description = "主键ID数组", required = true)
@PreAuthorize("@ss.hasPermi('ccdi:staffEnterpriseRelation:remove')")
@Log(title = "员工实体关系信息", businessType = BusinessType.DELETE)
@Log(title = "员工亲属实体关联", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids) {
return toAjax(relationService.deleteRelationByIds(ids));
@@ -115,16 +127,16 @@ public class CcdiStaffEnterpriseRelationController extends BaseController {
@Operation(summary = "下载导入模板")
@PostMapping("/importTemplate")
public void importTemplate(HttpServletResponse response) {
EasyExcelUtil.importTemplateWithDictDropdown(response, CcdiStaffEnterpriseRelationExcel.class, "员工实体关系信息");
EasyExcelUtil.importTemplateWithDictDropdown(response, CcdiStaffEnterpriseRelationExcel.class, "员工亲属实体关联");
}
/**
* 异步导入员工实体关系
* 异步导入员工亲属实体关联
*/
@Operation(summary = "异步导入员工实体关系")
@Operation(summary = "异步导入员工亲属实体关联")
@Parameter(name = "file", description = "导入文件", required = true)
@PreAuthorize("@ss.hasPermi('ccdi:staffEnterpriseRelation:import')")
@Log(title = "员工实体关系信息", businessType = BusinessType.IMPORT)
@Log(title = "员工亲属实体关联", businessType = BusinessType.IMPORT)
@PostMapping("/importData")
public AjaxResult importData(@Parameter(description = "导入文件") MultipartFile file) throws Exception {
List<CcdiStaffEnterpriseRelationExcel> list = EasyExcelUtil.importExcel(file.getInputStream(), CcdiStaffEnterpriseRelationExcel.class);
@@ -140,9 +152,9 @@ public class CcdiStaffEnterpriseRelationController extends BaseController {
ImportResultVO result = new ImportResultVO();
result.setTaskId(taskId);
result.setStatus("PROCESSING");
result.setMessage("导入任务已提交,正在后台处理");
result.setMessage("员工亲属实体关联导入任务已提交,正在后台处理");
return AjaxResult.success("导入任务已提交,正在后台处理", result);
return AjaxResult.success("员工亲属实体关联导入任务已提交,正在后台处理", result);
}
/**

12
ccdi-info-collection/src/main/java/com/ruoyi/info/collection/domain/dto/CcdiStaffEnterpriseRelationAddDTO.java
View File

@@ -10,22 +10,22 @@ import java.io.Serial;
import java.io.Serializable;
/**
* 员工实体关系信息新增DTO
* 员工亲属实体关联新增DTO
*
* @author ruoyi
* @date 2026-02-09
*/
@Data
@Schema(description = "员工实体关系信息新增")
@Schema(description = "员工亲属实体关联新增")
public class CcdiStaffEnterpriseRelationAddDTO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/** 身份证号 */
@NotBlank(message = "身份证号不能为空")
@Pattern(regexp = "^[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}[0-9Xx]$", message = "身份证号格式不正确")
@Schema(description = "身份证号")
/** 亲属身份证号 */
@NotBlank(message = "亲属身份证号不能为空")
@Pattern(regexp = "^[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}[0-9Xx]$", message = "亲属身份证号格式不正确")
@Schema(description = "亲属身份证号")
private String personId;
/** 关联人在企业的职务 */

8
ccdi-info-collection/src/main/java/com/ruoyi/info/collection/domain/dto/CcdiStaffEnterpriseRelationEditDTO.java
View File

@@ -10,13 +10,13 @@ import java.io.Serial;
import java.io.Serializable;
/**
* 员工实体关系信息编辑DTO
* 员工亲属实体关联编辑DTO
*
* @author ruoyi
* @date 2026-02-09
*/
@Data
@Schema(description = "员工实体关系信息编辑")
@Schema(description = "员工亲属实体关联编辑")
public class CcdiStaffEnterpriseRelationEditDTO implements Serializable {
@Serial
@@ -27,8 +27,8 @@ public class CcdiStaffEnterpriseRelationEditDTO implements Serializable {
@Schema(description = "主键ID")
private Long id;
/** 身份证号 */
@Schema(description = "身份证号（不可修改）")
/** 亲属身份证号 */
@Schema(description = "亲属身份证号（不可修改）")
private String personId;
/** 关联人在企业的职务 */

16
ccdi-info-collection/src/main/java/com/ruoyi/info/collection/domain/dto/CcdiStaffEnterpriseRelationQueryDTO.java
View File

@@ -7,22 +7,30 @@ import java.io.Serial;
import java.io.Serializable;
/**
* 员工实体关系信息查询DTO
* 员工亲属实体关联查询DTO
*
* @author ruoyi
* @date 2026-02-09
*/
@Data
@Schema(description = "员工实体关系信息查询条件")
@Schema(description = "员工亲属实体关联查询条件")
public class CcdiStaffEnterpriseRelationQueryDTO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/** 身份证号 */
@Schema(description = "身份证号")
/** 亲属身份证号 */
@Schema(description = "亲属身份证号")
private String personId;
/** 亲属姓名 */
@Schema(description = "亲属姓名")
private String relationName;
/** 关联员工 */
@Schema(description = "关联员工")
private String staffPersonName;
/** 统一社会信用代码 */
@Schema(description = "统一社会信用代码")
private String socialCreditCode;

10
ccdi-info-collection/src/main/java/com/ruoyi/info/collection/domain/excel/CcdiStaffEnterpriseRelationExcel.java
View File

@@ -10,23 +10,23 @@ import java.io.Serial;
import java.io.Serializable;
/**
* 员工实体关系信息Excel导入导出对象
* 员工亲属实体关联Excel导入导出对象
*
* @author ruoyi
* @date 2026-02-09
*/
@Data
@Schema(description = "员工实体关系信息Excel导入导出对象")
@Schema(description = "员工亲属实体关联Excel导入导出对象")
public class CcdiStaffEnterpriseRelationExcel implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/** 身份证号 */
@ExcelProperty(value = "身份证号", index = 0)
/** 亲属身份证号 */
@ExcelProperty(value = "亲属身份证号", index = 0)
@ColumnWidth(20)
@Required
@Schema(description = "身份证号")
@Schema(description = "亲属身份证号")
private String personId;
/** 统一社会信用代码 */

37
ccdi-info-collection/src/main/java/com/ruoyi/info/collection/domain/vo/CcdiStaffEnterpriseRelationOptionVO.java Normal file
View File

@@ -0,0 +1,37 @@
package com.ruoyi.info.collection.domain.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
/**
* 员工亲属实体关联下拉选项VO
*
* @author ruoyi
* @date 2026-04-23
*/
@Data
@Schema(description = "员工亲属实体关联下拉选项")
public class CcdiStaffEnterpriseRelationOptionVO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/** 亲属身份证号 */
@Schema(description = "亲属身份证号")
private String relationCertNo;
/** 亲属姓名 */
@Schema(description = "亲属姓名")
private String relationName;
/** 关联员工身份证号 */
@Schema(description = "关联员工身份证号")
private String staffPersonId;
/** 关联员工姓名 */
@Schema(description = "关联员工姓名")
private String staffPersonName;
}

22
ccdi-info-collection/src/main/java/com/ruoyi/info/collection/domain/vo/CcdiStaffEnterpriseRelationVO.java
View File

@@ -9,13 +9,13 @@ import java.io.Serializable;
import java.util.Date;
/**
* 员工实体关系信息VO
* 员工亲属实体关联VO
*
* @author ruoyi
* @date 2026-02-09
*/
@Data
@Schema(description = "员工实体关系信息")
@Schema(description = "员工亲属实体关联")
public class CcdiStaffEnterpriseRelationVO implements Serializable {
@Serial
@@ -25,13 +25,21 @@ public class CcdiStaffEnterpriseRelationVO implements Serializable {
@Schema(description = "主键ID")
private Long id;
/** 身份证号 */
@Schema(description = "身份证号")
/** 亲属身份证号 */
@Schema(description = "亲属身份证号")
private String personId;
/** 员工姓名 */
@Schema(description = "员工姓名")
private String personName;
/** 亲属姓名 */
@Schema(description = "亲属姓名")
private String relationName;
/** 关联员工身份证号 */
@Schema(description = "关联员工身份证号")
private String staffPersonId;
/** 关联员工姓名 */
@Schema(description = "关联员工姓名")
private String staffPersonName;
/** 关联人在企业的职务 */
@Schema(description = "关联人在企业的职务")

12
ccdi-info-collection/src/main/java/com/ruoyi/info/collection/domain/vo/StaffEnterpriseRelationImportFailureVO.java
View File

@@ -7,22 +7,26 @@ import java.io.Serial;
import java.io.Serializable;
/**
* 员工实体关系信息导入失败记录VO
* 员工亲属实体关联导入失败记录VO
*
* @author ruoyi
* @date 2026-02-09
*/
@Data
@Schema(description = "员工实体关系信息导入失败记录")
@Schema(description = "员工亲属实体关联导入失败记录")
public class StaffEnterpriseRelationImportFailureVO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/** 身份证号 */
@Schema(description = "身份证号")
/** 亲属身份证号 */
@Schema(description = "亲属身份证号")
private String personId;
/** 亲属姓名 */
@Schema(description = "亲属姓名")
private String relationName;
/** 统一社会信用代码 */
@Schema(description = "统一社会信用代码")
private String socialCreditCode;

17
ccdi-info-collection/src/main/java/com/ruoyi/info/collection/mapper/CcdiStaffEnterpriseRelationMapper.java
View File

@@ -4,6 +4,7 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.info.collection.domain.CcdiStaffEnterpriseRelation;
import com.ruoyi.info.collection.domain.dto.CcdiStaffEnterpriseRelationQueryDTO;
import com.ruoyi.info.collection.domain.vo.CcdiStaffEnterpriseRelationOptionVO;
import com.ruoyi.info.collection.domain.vo.CcdiStaffEnterpriseRelationVO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@@ -38,6 +39,14 @@ public interface CcdiStaffEnterpriseRelationMapper extends BaseMapper<CcdiStaffE
*/
CcdiStaffEnterpriseRelationVO selectRelationById(@Param("id") Long id);
/**
* 查询有效员工亲属下拉选项
*
* @param query 搜索关键词
* @return 下拉选项
*/
List<CcdiStaffEnterpriseRelationOptionVO> selectFamilyOptions(@Param("query") String query);
/**
* 判断身份证号和统一社会信用代码的组合是否已存在
*
@@ -57,6 +66,14 @@ public interface CcdiStaffEnterpriseRelationMapper extends BaseMapper<CcdiStaffE
*/
Set<String> batchExistsByCombinations(@Param("combinations") List<String> combinations);
/**
* 根据亲属身份证号批量置无效
*
* @param personId 亲属身份证号
* @return 影响行数
*/
int invalidateByFamilyCertNo(@Param("personId") String personId);
/**
* 批量插入员工实体关系数据
*

2
ccdi-info-collection/src/main/java/com/ruoyi/info/collection/service/ICcdiStaffEnterpriseRelationImportService.java
View File

@@ -7,7 +7,7 @@ import com.ruoyi.info.collection.domain.vo.StaffEnterpriseRelationImportFailureV
import java.util.List;
/**
* 员工实体关系信息异步导入服务层
* 员工亲属实体关联异步导入服务层
*
* @author ruoyi
* @date 2026-02-09

9
ccdi-info-collection/src/main/java/com/ruoyi/info/collection/service/ICcdiStaffEnterpriseRelationService.java
View File

@@ -5,6 +5,7 @@ import com.ruoyi.info.collection.domain.dto.CcdiStaffEnterpriseRelationAddDTO;
import com.ruoyi.info.collection.domain.dto.CcdiStaffEnterpriseRelationEditDTO;
import com.ruoyi.info.collection.domain.dto.CcdiStaffEnterpriseRelationQueryDTO;
import com.ruoyi.info.collection.domain.excel.CcdiStaffEnterpriseRelationExcel;
import com.ruoyi.info.collection.domain.vo.CcdiStaffEnterpriseRelationOptionVO;
import com.ruoyi.info.collection.domain.vo.CcdiStaffEnterpriseRelationVO;
import java.util.List;
@@ -42,6 +43,14 @@ public interface ICcdiStaffEnterpriseRelationService {
*/
List<CcdiStaffEnterpriseRelationExcel> selectRelationListForExport(CcdiStaffEnterpriseRelationQueryDTO queryDTO);
/**
* 查询有效员工亲属下拉选项
*
* @param query 搜索关键词
* @return 下拉选项
*/
List<CcdiStaffEnterpriseRelationOptionVO> selectFamilyOptions(String query);
/**
* 查询员工实体关系详情
*

145
ccdi-info-collection/src/main/java/com/ruoyi/info/collection/service/impl/CcdiStaffEnterpriseRelationImportServiceImpl.java
View File

@@ -2,14 +2,14 @@ package com.ruoyi.info.collection.service.impl;
import com.alibaba.fastjson2.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.info.collection.domain.CcdiBaseStaff;
import com.ruoyi.info.collection.domain.CcdiStaffEnterpriseRelation;
import com.ruoyi.info.collection.domain.CcdiStaffFmyRelation;
import com.ruoyi.info.collection.domain.dto.CcdiStaffEnterpriseRelationAddDTO;
import com.ruoyi.info.collection.domain.excel.CcdiStaffEnterpriseRelationExcel;
import com.ruoyi.info.collection.domain.vo.ImportResult;
import com.ruoyi.info.collection.domain.vo.ImportStatusVO;
import com.ruoyi.info.collection.domain.vo.StaffEnterpriseRelationImportFailureVO;
import com.ruoyi.info.collection.mapper.CcdiBaseStaffMapper;
import com.ruoyi.info.collection.mapper.CcdiStaffFmyRelationMapper;
import com.ruoyi.info.collection.mapper.CcdiStaffEnterpriseRelationMapper;
import com.ruoyi.info.collection.service.ICcdiStaffEnterpriseRelationImportService;
import com.ruoyi.info.collection.utils.ImportLogUtils;
@@ -29,7 +29,7 @@ import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
/**
* 员工实体关系信息异步导入服务层处理
* 员工亲属实体关联异步导入服务层处理
*
* @author ruoyi
* @date 2026-02-09
@@ -47,7 +47,7 @@ public class CcdiStaffEnterpriseRelationImportServiceImpl implements ICcdiStaffE
private RedisTemplate<String, Object> redisTemplate;
@Resource
private CcdiBaseStaffMapper baseStaffMapper;
private CcdiStaffFmyRelationMapper familyRelationMapper;
@Override
@Async
@@ -56,37 +56,48 @@ public class CcdiStaffEnterpriseRelationImportServiceImpl implements ICcdiStaffE
long startTime = System.currentTimeMillis();
// 记录导入开始
ImportLogUtils.logImportStart(log, taskId, "员工实体关系", excelList.size(), userName);
ImportLogUtils.logImportStart(log, taskId, "员工亲属实体关联", excelList.size(), userName);
List<CcdiStaffEnterpriseRelation> newRecords = new ArrayList<>();
List<StaffEnterpriseRelationImportFailureVO> failures = new ArrayList<>();
// 批量验证员工身份证号是否存在
Set<String> excelPersonIds = excelList.stream()
.map(CcdiStaffEnterpriseRelationExcel::getPersonId)
.filter(StringUtils::isNotEmpty)
.collect(Collectors.toSet());
Set<String> existingPersonIds = new HashSet<>();
Map<String, CcdiStaffFmyRelation> validFamilies = new HashMap<>();
Set<String> knownFamilyCertNos = new HashSet<>();
Map<String, String> familyNameMap = new HashMap<>();
if (!excelPersonIds.isEmpty()) {
ImportLogUtils.logBatchQueryStart(log, taskId, "员工身份证号", excelPersonIds.size());
ImportLogUtils.logBatchQueryStart(log, taskId, "员工亲属关系", excelPersonIds.size());
LambdaQueryWrapper<CcdiBaseStaff> wrapper = new LambdaQueryWrapper<>();
wrapper.select(CcdiBaseStaff::getIdCard)
.in(CcdiBaseStaff::getIdCard, excelPersonIds);
LambdaQueryWrapper<CcdiStaffFmyRelation> wrapper = new LambdaQueryWrapper<>();
wrapper.select(
CcdiStaffFmyRelation::getRelationCertNo,
CcdiStaffFmyRelation::getRelationName,
CcdiStaffFmyRelation::getPersonId,
CcdiStaffFmyRelation::getStatus,
CcdiStaffFmyRelation::getIsEmpFamily
)
.in(CcdiStaffFmyRelation::getRelationCertNo, excelPersonIds);
List<CcdiBaseStaff> existingStaff = baseStaffMapper.selectList(wrapper);
existingPersonIds = existingStaff.stream()
.map(CcdiBaseStaff::getIdCard)
.collect(Collectors.toSet());
List<CcdiStaffFmyRelation> familyRelations = familyRelationMapper.selectList(wrapper);
for (CcdiStaffFmyRelation familyRelation : familyRelations) {
knownFamilyCertNos.add(familyRelation.getRelationCertNo());
familyNameMap.putIfAbsent(familyRelation.getRelationCertNo(), familyRelation.getRelationName());
if (Boolean.TRUE.equals(familyRelation.getIsEmpFamily()) && Integer.valueOf(1).equals(familyRelation.getStatus())) {
validFamilies.putIfAbsent(familyRelation.getRelationCertNo(), familyRelation);
}
}
ImportLogUtils.logBatchQueryComplete(log, taskId, "员工身份证号", existingPersonIds.size());
ImportLogUtils.logBatchQueryComplete(log, taskId, "员工亲属关系", familyRelations.size());
}
// 批量查询已存在的person_id + social_credit_code组合
ImportLogUtils.logBatchQueryStart(log, taskId, "已存在的员工企业关系组合", excelList.size());
ImportLogUtils.logBatchQueryStart(log, taskId, "已存在的员工亲属实体关联组合", excelList.size());
Set<String> existingCombinations = getExistingCombinations(excelList);
ImportLogUtils.logBatchQueryComplete(log, taskId, "员工企业关系组合", existingCombinations.size());
ImportLogUtils.logBatchQueryComplete(log, taskId, "员工亲属实体关联组合", existingCombinations.size());
// 用于跟踪Excel文件内已处理的组合
Set<String> processedCombinations = new HashSet<>();
@@ -103,41 +114,18 @@ public class CcdiStaffEnterpriseRelationImportServiceImpl implements ICcdiStaffE
// 验证数据
validateRelationData(addDTO);
// 身份证号存在性检查（在基本验证之后）
if (!existingPersonIds.contains(excel.getPersonId())) {
throw new RuntimeException(String.format(
"第%d行: 身份证号[%s]不存在于员工信息表中，请先添加员工信息",
i + 1, excel.getPersonId()));
}
CcdiStaffFmyRelation familyRelation = validFamilies.get(excel.getPersonId());
CcdiStaffEnterpriseRelation relation = validateAndBuildEntity(
excel,
familyRelation,
knownFamilyCertNos,
existingCombinations,
processedCombinations,
userName
);
String combination = excel.getPersonId() + "|" + excel.getSocialCreditCode();
CcdiStaffEnterpriseRelation relation = new CcdiStaffEnterpriseRelation();
BeanUtils.copyProperties(excel, relation);
if (existingCombinations.contains(combination)) {
// 组合已存在，直接报错
throw new RuntimeException(String.format("身份证号[%s]和统一社会信用代码[%s]的组合已存在，请勿重复导入",
excel.getPersonId(), excel.getSocialCreditCode()));
} else if (processedCombinations.contains(combination)) {
// Excel文件内部重复
throw new RuntimeException(String.format("身份证号[%s]和统一社会信用代码[%s]的组合在导入文件中重复,已跳过此条记录",
excel.getPersonId(), excel.getSocialCreditCode()));
} else {
relation.setCreatedBy(userName);
relation.setUpdatedBy(userName);
// 设置默认值
relation.setStatus(1);
relation.setIsEmployee(0);
relation.setIsEmpFamily(1);
relation.setIsCustomer(0);
relation.setIsCustFamily(0);
relation.setDataSource("IMPORT");
newRecords.add(relation);
processedCombinations.add(combination); // 标记为已处理
}
newRecords.add(relation);
processedCombinations.add(excel.getPersonId() + "|" + excel.getSocialCreditCode());
// 记录进度
ImportLogUtils.logProgress(log, taskId, i + 1, excelList.size(),
@@ -146,11 +134,12 @@ public class CcdiStaffEnterpriseRelationImportServiceImpl implements ICcdiStaffE
} catch (Exception e) {
StaffEnterpriseRelationImportFailureVO failure = new StaffEnterpriseRelationImportFailureVO();
BeanUtils.copyProperties(excel, failure);
failure.setRelationName(familyNameMap.get(excel.getPersonId()));
failure.setErrorMessage(e.getMessage());
failures.add(failure);
// 记录验证失败日志
String keyData = String.format("身份证号=%s, 统一社会信用代码=%s, 企业名称=%s",
String keyData = String.format("亲属身份证号=%s, 统一社会信用代码=%s, 企业名称=%s",
excel.getPersonId(), excel.getSocialCreditCode(), excel.getEnterpriseName());
ImportLogUtils.logValidationError(log, taskId, i + 1, e.getMessage(), keyData);
}
@@ -166,7 +155,7 @@ public class CcdiStaffEnterpriseRelationImportServiceImpl implements ICcdiStaffE
// 保存失败记录到Redis
if (!failures.isEmpty()) {
try {
String failuresKey = "import:staffEnterpriseRelation:" + taskId + ":failures";
String failuresKey = "import:staffEnterpriseRelation:" + taskId + ":failures";
redisTemplate.opsForValue().set(failuresKey, failures, 7, TimeUnit.DAYS);
ImportLogUtils.logRedisOperation(log, taskId, "保存失败记录", failures.size());
} catch (Exception e) {
@@ -185,7 +174,7 @@ public class CcdiStaffEnterpriseRelationImportServiceImpl implements ICcdiStaffE
// 记录导入完成
long duration = System.currentTimeMillis() - startTime;
ImportLogUtils.logImportComplete(log, taskId, "员工实体关系",
ImportLogUtils.logImportComplete(log, taskId, "员工亲属实体关联",
excelList.size(), result.getSuccessCount(), result.getFailureCount(), duration);
}
@@ -251,9 +240,9 @@ public class CcdiStaffEnterpriseRelationImportServiceImpl implements ICcdiStaffE
statusData.put("endTime", System.currentTimeMillis());
if ("SUCCESS".equals(status)) {
statusData.put("message", "全部成功!共导入" + result.getTotalCount() + "条数据");
statusData.put("message", "员工亲属实体关联导入全部成功!共导入" + result.getTotalCount() + "条数据");
} else {
statusData.put("message", "成功" + result.getSuccessCount() + "条,失败" + result.getFailureCount() + "条");
statusData.put("message", "员工亲属实体关联导入成功" + result.getSuccessCount() + "条,失败" + result.getFailureCount() + "条");
}
redisTemplate.opsForHash().putAll(key, statusData);
@@ -297,14 +286,14 @@ public class CcdiStaffEnterpriseRelationImportServiceImpl implements ICcdiStaffE
}
/**
* 验证员工实体关系数据
* 验证员工亲属实体关联基础数据
*
* @param addDTO 新增DTO
*/
private void validateRelationData(CcdiStaffEnterpriseRelationAddDTO addDTO) {
// 验证必填字段
if (StringUtils.isEmpty(addDTO.getPersonId())) {
throw new RuntimeException("身份证号不能为空");
throw new RuntimeException("亲属身份证号不能为空");
}
if (StringUtils.isEmpty(addDTO.getSocialCreditCode())) {
throw new RuntimeException("统一社会信用代码不能为空");
@@ -313,9 +302,9 @@ public class CcdiStaffEnterpriseRelationImportServiceImpl implements ICcdiStaffE
throw new RuntimeException("企业名称不能为空");
}
// 验证身份证号格式（18位）
// 验证亲属身份证号格式（18位）
if (!addDTO.getPersonId().matches("^[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}[0-9Xx]$")) {
throw new RuntimeException("身份证号格式不正确，必须为18位有效身份证号");
throw new RuntimeException("亲属身份证号格式不正确，必须为18位有效身份证号");
}
// 验证统一社会信用代码格式（18位）
@@ -331,4 +320,38 @@ public class CcdiStaffEnterpriseRelationImportServiceImpl implements ICcdiStaffE
throw new RuntimeException("企业名称长度不能超过200个字符");
}
}
CcdiStaffEnterpriseRelation validateAndBuildEntity(CcdiStaffEnterpriseRelationExcel excel,
CcdiStaffFmyRelation familyRelation,
Set<String> knownFamilyCertNos,
Set<String> existingCombinations,
Set<String> processedCombinations,
String userName) {
String combination = excel.getPersonId() + "|" + excel.getSocialCreditCode();
if (familyRelation == null) {
if (knownFamilyCertNos.contains(excel.getPersonId())) {
throw new RuntimeException("亲属身份证号[" + excel.getPersonId() + "]不是有效员工亲属，请先维护有效的员工亲属关系");
}
throw new RuntimeException("亲属身份证号[" + excel.getPersonId() + "]不存在，请先维护员工亲属关系");
}
if (existingCombinations.contains(combination)) {
throw new RuntimeException("亲属身份证号[" + excel.getPersonId() + "]和统一社会信用代码[" + excel.getSocialCreditCode() + "]的组合已存在，请勿重复导入");
}
if (processedCombinations.contains(combination)) {
throw new RuntimeException("亲属身份证号[" + excel.getPersonId() + "]和统一社会信用代码[" + excel.getSocialCreditCode() + "]的组合在导入文件中重复,已跳过此条记录");
}
CcdiStaffEnterpriseRelation relation = new CcdiStaffEnterpriseRelation();
BeanUtils.copyProperties(excel, relation);
relation.setCreatedBy(userName);
relation.setUpdatedBy(userName);
relation.setStatus(1);
relation.setIsEmployee(0);
relation.setIsEmpFamily(1);
relation.setIsCustomer(0);
relation.setIsCustFamily(0);
relation.setDataSource("IMPORT");
return relation;
}
}

44
ccdi-info-collection/src/main/java/com/ruoyi/info/collection/service/impl/CcdiStaffEnterpriseRelationServiceImpl.java
View File

@@ -3,11 +3,14 @@ package com.ruoyi.info.collection.service.impl;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.info.collection.domain.CcdiStaffEnterpriseRelation;
import com.ruoyi.info.collection.domain.CcdiStaffFmyRelation;
import com.ruoyi.info.collection.domain.dto.CcdiStaffEnterpriseRelationAddDTO;
import com.ruoyi.info.collection.domain.dto.CcdiStaffEnterpriseRelationEditDTO;
import com.ruoyi.info.collection.domain.dto.CcdiStaffEnterpriseRelationQueryDTO;
import com.ruoyi.info.collection.domain.excel.CcdiStaffEnterpriseRelationExcel;
import com.ruoyi.info.collection.domain.vo.CcdiStaffEnterpriseRelationOptionVO;
import com.ruoyi.info.collection.domain.vo.CcdiStaffEnterpriseRelationVO;
import com.ruoyi.info.collection.mapper.CcdiStaffFmyRelationMapper;
import com.ruoyi.info.collection.mapper.CcdiStaffEnterpriseRelationMapper;
import com.ruoyi.info.collection.service.ICcdiStaffEnterpriseRelationImportService;
import com.ruoyi.info.collection.service.ICcdiStaffEnterpriseRelationService;
@@ -37,6 +40,9 @@ public class CcdiStaffEnterpriseRelationServiceImpl implements ICcdiStaffEnterpr
@Resource
private CcdiStaffEnterpriseRelationMapper relationMapper;
@Resource
private CcdiStaffFmyRelationMapper familyRelationMapper;
@Resource
private ICcdiStaffEnterpriseRelationImportService relationImportService;
@@ -86,6 +92,11 @@ public class CcdiStaffEnterpriseRelationServiceImpl implements ICcdiStaffEnterpr
}).collect(Collectors.toList());
}
@Override
public java.util.List<CcdiStaffEnterpriseRelationOptionVO> selectFamilyOptions(String query) {
return relationMapper.selectFamilyOptions(query);
}
/**
* 查询员工实体关系详情
*
@@ -106,16 +117,15 @@ public class CcdiStaffEnterpriseRelationServiceImpl implements ICcdiStaffEnterpr
@Override
@Transactional
public int insertRelation(CcdiStaffEnterpriseRelationAddDTO addDTO) {
// 检查身份证号+统一社会信用代码唯一性
validateEffectiveFamily(addDTO.getPersonId());
if (relationMapper.existsByPersonIdAndSocialCreditCode(addDTO.getPersonId(), addDTO.getSocialCreditCode())) {
throw new RuntimeException("该身份证号和统一社会信用代码组合已存在");
throw new RuntimeException("该亲属身份证号和统一社会信用代码组合已存在");
}
CcdiStaffEnterpriseRelation relation = new CcdiStaffEnterpriseRelation();
BeanUtils.copyProperties(addDTO, relation);
// 设置默认值
// 新增时强制设置状态为有效
relation.setStatus(1);
if (relation.getIsEmployee() == null) {
@@ -159,7 +169,7 @@ public class CcdiStaffEnterpriseRelationServiceImpl implements ICcdiStaffEnterpr
updateWrapper.set(editDTO.getRemark() != null, CcdiStaffEnterpriseRelation::getRemark, editDTO.getRemark());
// 注意：以下字段不可修改
// - personId（身份证号，业务主键）
// - personId（亲属身份证号，业务主键）
// - socialCreditCode（统一社会信用代码，业务主键）
// - dataSource（数据来源，系统字段）
// - isEmployee（是否为员工，系统字段）
@@ -224,4 +234,28 @@ public class CcdiStaffEnterpriseRelationServiceImpl implements ICcdiStaffEnterpr
return taskId;
}
private CcdiStaffFmyRelation validateEffectiveFamily(String familyCertNo) {
CcdiStaffFmyRelation validFamily = familyRelationMapper.selectOne(
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<CcdiStaffFmyRelation>()
.eq(CcdiStaffFmyRelation::getRelationCertNo, familyCertNo)
.eq(CcdiStaffFmyRelation::getIsEmpFamily, Boolean.TRUE)
.eq(CcdiStaffFmyRelation::getStatus, 1)
.last("LIMIT 1")
);
if (validFamily != null) {
return validFamily;
}
CcdiStaffFmyRelation existingFamily = familyRelationMapper.selectOne(
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<CcdiStaffFmyRelation>()
.select(CcdiStaffFmyRelation::getId)
.eq(CcdiStaffFmyRelation::getRelationCertNo, familyCertNo)
.last("LIMIT 1")
);
if (existingFamily == null) {
throw new RuntimeException("亲属身份证号[" + familyCertNo + "]不存在，请先维护员工亲属关系");
}
throw new RuntimeException("亲属身份证号[" + familyCertNo + "]不是有效员工亲属，请先维护有效的员工亲属关系");
}
}

9
ccdi-info-collection/src/main/java/com/ruoyi/info/collection/service/impl/CcdiStaffFmyRelationServiceImpl.java
View File

@@ -3,12 +3,13 @@ package com.ruoyi.info.collection.service.impl;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.info.collection.domain.CcdiAssetInfo;
import com.ruoyi.info.collection.domain.CcdiStaffFmyRelation;
import com.ruoyi.info.collection.domain.vo.CcdiAssetInfoVO;
import com.ruoyi.info.collection.domain.dto.CcdiStaffFmyRelationAddDTO;
import com.ruoyi.info.collection.domain.dto.CcdiStaffFmyRelationEditDTO;
import com.ruoyi.info.collection.domain.dto.CcdiStaffFmyRelationQueryDTO;
import com.ruoyi.info.collection.domain.excel.CcdiStaffFmyRelationExcel;
import com.ruoyi.info.collection.domain.vo.CcdiAssetInfoVO;
import com.ruoyi.info.collection.domain.vo.CcdiStaffFmyRelationVO;
import com.ruoyi.info.collection.mapper.CcdiStaffEnterpriseRelationMapper;
import com.ruoyi.info.collection.mapper.CcdiStaffFmyRelationMapper;
import com.ruoyi.info.collection.service.ICcdiAssetInfoService;
import com.ruoyi.info.collection.service.ICcdiStaffFmyRelationImportService;
@@ -50,6 +51,9 @@ public class CcdiStaffFmyRelationServiceImpl implements ICcdiStaffFmyRelationSer
@Resource
private ICcdiAssetInfoService assetInfoService;
@Resource
private CcdiStaffEnterpriseRelationMapper staffEnterpriseRelationMapper;
/**
* 查询员工亲属关系列表
*
@@ -161,6 +165,9 @@ public class CcdiStaffFmyRelationServiceImpl implements ICcdiStaffFmyRelationSer
CcdiStaffFmyRelation relation = new CcdiStaffFmyRelation();
BeanUtils.copyProperties(editDTO, relation);
int result = relationMapper.updateById(relation);
if (Integer.valueOf(1).equals(existing.getStatus()) && Integer.valueOf(0).equals(editDTO.getStatus())) {
staffEnterpriseRelationMapper.invalidateByFamilyCertNo(existing.getRelationCertNo());
}
assetInfoService.replaceByFamilyIdAndPersonId(editDTO.getPersonId(), editDTO.getRelationCertNo(), editDTO.getAssetInfoList());
return result;
}

55
ccdi-info-collection/src/main/resources/mapper/info/collection/CcdiStaffEnterpriseRelationMapper.xml
View File

@@ -8,7 +8,9 @@
<resultMap type="com.ruoyi.info.collection.domain.vo.CcdiStaffEnterpriseRelationVO" id="CcdiStaffEnterpriseRelationVOResult">
<id property="id" column="id"/>
<result property="personId" column="person_id"/>
<result property="personName" column="person_name"/>
<result property="relationName" column="relation_name"/>
<result property="staffPersonId" column="staff_person_id"/>
<result property="staffPersonName" column="staff_person_name"/>
<result property="relationPersonPost" column="relation_person_post"/>
<result property="socialCreditCode" column="social_credit_code"/>
<result property="enterpriseName" column="enterprise_name"/>
@@ -28,17 +30,28 @@
<!-- 分页查询员工实体关系列表 -->
<select id="selectRelationPage" resultMap="CcdiStaffEnterpriseRelationVOResult">
SELECT
ser.id, ser.person_id, bs.name as person_name, ser.relation_person_post,
ser.id, ser.person_id, sfr.relation_name, sfr.person_id AS staff_person_id, bs.name AS staff_person_name,
ser.relation_person_post,
ser.social_credit_code, ser.enterprise_name, ser.status, ser.remark,
ser.data_source, ser.is_employee, ser.is_emp_family, ser.is_customer,
ser.is_cust_family, ser.created_by, ser.create_time, ser.updated_by,
ser.update_time
FROM ccdi_staff_enterprise_relation ser
LEFT JOIN ccdi_base_staff bs ON ser.person_id = bs.id_card
LEFT JOIN ccdi_staff_fmy_relation sfr
ON ser.person_id = sfr.relation_cert_no
AND sfr.is_emp_family = 1
LEFT JOIN ccdi_base_staff bs ON sfr.person_id = bs.id_card
<where>
<if test="query.personId != null and query.personId != ''">
AND ser.person_id LIKE CONCAT('%', #{query.personId}, '%')
</if>
<if test="query.relationName != null and query.relationName != ''">
AND sfr.relation_name LIKE CONCAT('%', #{query.relationName}, '%')
</if>
<if test="query.staffPersonName != null and query.staffPersonName != ''">
AND (sfr.person_id LIKE CONCAT('%', #{query.staffPersonName}, '%')
OR bs.name LIKE CONCAT('%', #{query.staffPersonName}, '%'))
</if>
<if test="query.socialCreditCode != null and query.socialCreditCode != ''">
AND ser.social_credit_code LIKE CONCAT('%', #{query.socialCreditCode}, '%')
</if>
@@ -55,16 +68,40 @@
<!-- 查询员工实体关系详情 -->
<select id="selectRelationById" resultMap="CcdiStaffEnterpriseRelationVOResult">
SELECT
ser.id, ser.person_id, bs.name as person_name, ser.relation_person_post,
ser.id, ser.person_id, sfr.relation_name, sfr.person_id AS staff_person_id, bs.name AS staff_person_name,
ser.relation_person_post,
ser.social_credit_code, ser.enterprise_name, ser.status, ser.remark,
ser.data_source, ser.is_employee, ser.is_emp_family, ser.is_customer,
ser.is_cust_family, ser.created_by, ser.create_time, ser.updated_by,
ser.update_time
FROM ccdi_staff_enterprise_relation ser
LEFT JOIN ccdi_base_staff bs ON ser.person_id = bs.id_card
LEFT JOIN ccdi_staff_fmy_relation sfr
ON ser.person_id = sfr.relation_cert_no
AND sfr.is_emp_family = 1
LEFT JOIN ccdi_base_staff bs ON sfr.person_id = bs.id_card
WHERE ser.id = #{id}
</select>
<!-- 查询有效员工亲属下拉选项 -->
<select id="selectFamilyOptions" resultType="com.ruoyi.info.collection.domain.vo.CcdiStaffEnterpriseRelationOptionVO">
SELECT
sfr.relation_cert_no AS relationCertNo,
sfr.relation_name AS relationName,
sfr.person_id AS staffPersonId,
bs.name AS staffPersonName
FROM ccdi_staff_fmy_relation sfr
LEFT JOIN ccdi_base_staff bs ON sfr.person_id = bs.id_card
<where>
sfr.is_emp_family = 1
AND sfr.status = 1
<if test="query != null and query != ''">
AND sfr.relation_cert_no LIKE CONCAT('%', #{query}, '%')
</if>
</where>
ORDER BY sfr.create_time DESC
LIMIT 100
</select>
<!-- 判断身份证号和统一社会信用代码的组合是否已存在 -->
<select id="existsByPersonIdAndSocialCreditCode" resultType="boolean">
SELECT COUNT(1) > 0
@@ -84,6 +121,14 @@
</foreach>
</select>
<update id="invalidateByFamilyCertNo">
UPDATE ccdi_staff_enterprise_relation
SET status = 0,
update_time = NOW()
WHERE person_id = #{personId}
AND status != 0
</update>
<!-- 批量插入员工实体关系数据 -->
<insert id="insertBatch">
INSERT INTO ccdi_staff_enterprise_relation

148
ccdi-info-collection/src/test/java/com/ruoyi/info/collection/mapper/CcdiStaffEnterpriseRelationMapperTest.java Normal file
View File

@@ -0,0 +1,148 @@
package com.ruoyi.info.collection.mapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.pagehelper.parser.defaults.DefaultCountSqlParser;
import com.ruoyi.info.collection.domain.dto.CcdiStaffEnterpriseRelationQueryDTO;
import org.apache.ibatis.builder.xml.XMLMapperBuilder;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.scripting.xmltags.XMLLanguageDriver;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
import org.apache.ibatis.type.TypeAliasRegistry;
import org.junit.jupiter.api.Test;
import javax.sql.DataSource;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
class CcdiStaffEnterpriseRelationMapperTest {
private static final String RESOURCE = "mapper/info/collection/CcdiStaffEnterpriseRelationMapper.xml";
@Test
void selectRelationPage_shouldJoinFamilyRelationAndStaff() throws Exception {
MappedStatement mappedStatement = loadMappedStatement(
"com.ruoyi.info.collection.mapper.CcdiStaffEnterpriseRelationMapper.selectRelationPage");
CcdiStaffEnterpriseRelationQueryDTO queryDTO = new CcdiStaffEnterpriseRelationQueryDTO();
queryDTO.setRelationName("李");
queryDTO.setStaffPersonName("张");
String sql = renderSql(mappedStatement, Map.of(
"page", new Page<>(1, 10),
"query", queryDTO
));
String countSql = normalizeSql(new DefaultCountSqlParser().getSmartCountSql(sql, "0"));
assertTrue(sql.contains("LEFT JOIN ccdi_staff_fmy_relation sfr"), sql);
assertTrue(sql.contains("LEFT JOIN ccdi_base_staff bs ON sfr.person_id = bs.id_card"), sql);
assertTrue(sql.contains("sfr.relation_name"), sql);
assertTrue(sql.contains("staff_person_id"), sql);
assertTrue(sql.contains("bs.name AS staff_person_name"), sql);
assertTrue(sql.contains("sfr.relation_name LIKE CONCAT('%', ?, '%')"), sql);
assertTrue(sql.contains("bs.name LIKE CONCAT('%', ?, '%')"), sql);
assertFalse(countSql.contains("1AND"), countSql);
}
@Test
void selectFamilyOptions_shouldOnlyQueryEffectiveEmployeeFamilies() throws Exception {
MappedStatement mappedStatement = loadMappedStatement(
"com.ruoyi.info.collection.mapper.CcdiStaffEnterpriseRelationMapper.selectFamilyOptions");
String sql = renderSql(mappedStatement, Map.of("query", "320101"));
assertTrue(sql.contains("sfr.is_emp_family = 1"), sql);
assertTrue(sql.contains("sfr.status = 1"), sql);
assertTrue(sql.contains("sfr.relation_cert_no LIKE CONCAT('%', ?, '%')"), sql);
}
@Test
void mapperXml_shouldContainInvalidateByFamilyCertNo() throws Exception {
try (InputStream inputStream = getClass().getClassLoader().getResourceAsStream(RESOURCE)) {
String xml = new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
assertTrue(xml.contains("<update id=\"invalidateByFamilyCertNo\">"), xml);
assertTrue(xml.contains("WHERE person_id = #{personId}"), xml);
assertTrue(xml.contains("SET status = 0"), xml);
}
}
private MappedStatement loadMappedStatement(String statementId) throws Exception {
Configuration configuration = new Configuration();
configuration.setEnvironment(new Environment("test", new JdbcTransactionFactory(), new NoOpDataSource()));
registerTypeAliases(configuration.getTypeAliasRegistry());
configuration.getLanguageRegistry().register(XMLLanguageDriver.class);
configuration.addMapper(CcdiStaffEnterpriseRelationMapper.class);
try (InputStream inputStream = getClass().getClassLoader().getResourceAsStream(RESOURCE)) {
XMLMapperBuilder xmlMapperBuilder =
new XMLMapperBuilder(inputStream, configuration, RESOURCE, configuration.getSqlFragments());
xmlMapperBuilder.parse();
}
return configuration.getMappedStatement(statementId);
}
private String renderSql(MappedStatement mappedStatement, Map<String, Object> params) {
BoundSql boundSql = mappedStatement.getBoundSql(new HashMap<>(params));
return normalizeSql(boundSql.getSql());
}
private String normalizeSql(String sql) {
return sql.replaceAll("\\s+", " ").trim();
}
private void registerTypeAliases(TypeAliasRegistry typeAliasRegistry) {
typeAliasRegistry.registerAlias("map", Map.class);
}
private static class NoOpDataSource implements DataSource {
@Override
public java.sql.Connection getConnection() {
throw new UnsupportedOperationException("Not required for SQL rendering tests");
}
@Override
public java.sql.Connection getConnection(String username, String password) {
throw new UnsupportedOperationException("Not required for SQL rendering tests");
}
@Override
public java.io.PrintWriter getLogWriter() {
return null;
}
@Override
public void setLogWriter(java.io.PrintWriter out) {
}
@Override
public void setLoginTimeout(int seconds) {
}
@Override
public int getLoginTimeout() {
return 0;
}
@Override
public java.util.logging.Logger getParentLogger() {
return java.util.logging.Logger.getGlobal();
}
@Override
public <T> T unwrap(Class<T> iface) {
throw new UnsupportedOperationException("Not supported");
}
@Override
public boolean isWrapperFor(Class<?> iface) {
return false;
}
}
}

138
ccdi-info-collection/src/test/java/com/ruoyi/info/collection/service/CcdiStaffEnterpriseRelationImportServiceImplTest.java Normal file
View File

@@ -0,0 +1,138 @@
package com.ruoyi.info.collection.service;
import com.ruoyi.info.collection.domain.CcdiStaffEnterpriseRelation;
import com.ruoyi.info.collection.domain.CcdiStaffFmyRelation;
import com.ruoyi.info.collection.domain.excel.CcdiStaffEnterpriseRelationExcel;
import com.ruoyi.info.collection.service.impl.CcdiStaffEnterpriseRelationImportServiceImpl;
import org.junit.jupiter.api.Test;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
class CcdiStaffEnterpriseRelationImportServiceImplTest {
private final CcdiStaffEnterpriseRelationImportServiceImpl service = new CcdiStaffEnterpriseRelationImportServiceImpl();
@Test
void validateAndBuildEntity_shouldBuildImportEntityForValidFamily() throws Exception {
CcdiStaffEnterpriseRelationExcel excel = buildExcel();
CcdiStaffFmyRelation familyRelation = buildFamily();
CcdiStaffEnterpriseRelation entity = invokeValidateAndBuildEntity(
excel,
familyRelation,
Set.of(excel.getPersonId()),
Set.of(),
new HashSet<>(),
"admin"
);
assertEquals("IMPORT", entity.getDataSource());
assertEquals(1, entity.getStatus());
assertEquals(1, entity.getIsEmpFamily());
assertEquals("admin", entity.getCreatedBy());
}
@Test
void validateAndBuildEntity_shouldRejectWhenFamilyDoesNotExist() throws Exception {
CcdiStaffEnterpriseRelationExcel excel = buildExcel();
RuntimeException exception = assertThrows(RuntimeException.class,
() -> invokeValidateAndBuildEntity(excel, null, Set.of(), Set.of(), new HashSet<>(), "admin"));
assertEquals("亲属身份证号[" + excel.getPersonId() + "]不存在，请先维护员工亲属关系", exception.getMessage());
}
@Test
void validateAndBuildEntity_shouldRejectWhenFamilyIsInvalid() throws Exception {
CcdiStaffEnterpriseRelationExcel excel = buildExcel();
RuntimeException exception = assertThrows(RuntimeException.class,
() -> invokeValidateAndBuildEntity(excel, null, Set.of(excel.getPersonId()), Set.of(), new HashSet<>(), "admin"));
assertEquals("亲属身份证号[" + excel.getPersonId() + "]不是有效员工亲属，请先维护有效的员工亲属关系", exception.getMessage());
}
@Test
void validateAndBuildEntity_shouldRejectWhenCombinationAlreadyExistsInDatabase() throws Exception {
CcdiStaffEnterpriseRelationExcel excel = buildExcel();
CcdiStaffFmyRelation familyRelation = buildFamily();
String combination = excel.getPersonId() + "|" + excel.getSocialCreditCode();
RuntimeException exception = assertThrows(RuntimeException.class,
() -> invokeValidateAndBuildEntity(excel, familyRelation, Set.of(excel.getPersonId()), Set.of(combination), new HashSet<>(), "admin"));
assertEquals("亲属身份证号[" + excel.getPersonId() + "]和统一社会信用代码[" + excel.getSocialCreditCode() + "]的组合已存在，请勿重复导入", exception.getMessage());
}
@Test
void validateAndBuildEntity_shouldRejectWhenCombinationAlreadyExistsInExcel() throws Exception {
CcdiStaffEnterpriseRelationExcel excel = buildExcel();
CcdiStaffFmyRelation familyRelation = buildFamily();
String combination = excel.getPersonId() + "|" + excel.getSocialCreditCode();
RuntimeException exception = assertThrows(RuntimeException.class,
() -> invokeValidateAndBuildEntity(excel, familyRelation, Set.of(excel.getPersonId()), Set.of(), new HashSet<>(Set.of(combination)), "admin"));
assertEquals("亲属身份证号[" + excel.getPersonId() + "]和统一社会信用代码[" + excel.getSocialCreditCode() + "]的组合在导入文件中重复,已跳过此条记录", exception.getMessage());
}
private CcdiStaffEnterpriseRelation invokeValidateAndBuildEntity(CcdiStaffEnterpriseRelationExcel excel,
CcdiStaffFmyRelation familyRelation,
Set<String> knownFamilyCertNos,
Set<String> existingCombinations,
Set<String> processedCombinations,
String userName) throws Exception {
Method method = CcdiStaffEnterpriseRelationImportServiceImpl.class.getDeclaredMethod(
"validateAndBuildEntity",
CcdiStaffEnterpriseRelationExcel.class,
CcdiStaffFmyRelation.class,
Set.class,
Set.class,
Set.class,
String.class
);
method.setAccessible(true);
try {
return (CcdiStaffEnterpriseRelation) method.invoke(
service,
excel,
familyRelation,
knownFamilyCertNos,
existingCombinations,
processedCombinations,
userName
);
} catch (InvocationTargetException ex) {
Throwable targetException = ex.getTargetException();
if (targetException instanceof RuntimeException runtimeException) {
throw runtimeException;
}
throw ex;
}
}
private CcdiStaffEnterpriseRelationExcel buildExcel() {
CcdiStaffEnterpriseRelationExcel excel = new CcdiStaffEnterpriseRelationExcel();
excel.setPersonId("320101199001010022");
excel.setSocialCreditCode("91310000123456789A");
excel.setEnterpriseName("测试企业");
excel.setRelationPersonPost("董事");
return excel;
}
private CcdiStaffFmyRelation buildFamily() {
CcdiStaffFmyRelation familyRelation = new CcdiStaffFmyRelation();
familyRelation.setPersonId("320101199001010011");
familyRelation.setRelationCertNo("320101199001010022");
familyRelation.setRelationName("李四");
familyRelation.setStatus(1);
familyRelation.setIsEmpFamily(true);
return familyRelation;
}
}

156
ccdi-info-collection/src/test/java/com/ruoyi/info/collection/service/CcdiStaffEnterpriseRelationServiceImplTest.java Normal file
View File

@@ -0,0 +1,156 @@
package com.ruoyi.info.collection.service;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.ruoyi.info.collection.domain.CcdiStaffEnterpriseRelation;
import com.ruoyi.info.collection.domain.CcdiStaffFmyRelation;
import com.ruoyi.info.collection.domain.dto.CcdiStaffEnterpriseRelationAddDTO;
import com.ruoyi.info.collection.domain.dto.CcdiStaffEnterpriseRelationEditDTO;
import com.ruoyi.info.collection.domain.vo.CcdiStaffEnterpriseRelationOptionVO;
import com.ruoyi.info.collection.mapper.CcdiStaffEnterpriseRelationMapper;
import com.ruoyi.info.collection.mapper.CcdiStaffFmyRelationMapper;
import com.ruoyi.info.collection.service.impl.CcdiStaffEnterpriseRelationServiceImpl;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.apache.ibatis.session.Configuration;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.data.redis.core.RedisTemplate;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class CcdiStaffEnterpriseRelationServiceImplTest {
@BeforeAll
static void initTableInfo() {
registerTableInfo(CcdiStaffEnterpriseRelation.class, CcdiStaffEnterpriseRelationMapper.class.getName());
registerTableInfo(CcdiStaffFmyRelation.class, CcdiStaffFmyRelationMapper.class.getName());
}
@InjectMocks
private CcdiStaffEnterpriseRelationServiceImpl service;
@Mock
private CcdiStaffEnterpriseRelationMapper relationMapper;
@Mock
private CcdiStaffFmyRelationMapper familyRelationMapper;
@Mock
private ICcdiStaffEnterpriseRelationImportService relationImportService;
@Mock
private RedisTemplate<String, Object> redisTemplate;
@Test
void insertRelation_shouldAllowValidFamily() {
CcdiStaffEnterpriseRelationAddDTO addDTO = buildAddDto();
CcdiStaffFmyRelation familyRelation = new CcdiStaffFmyRelation();
familyRelation.setRelationCertNo(addDTO.getPersonId());
familyRelation.setRelationName("李四");
familyRelation.setPersonId("320101199001010011");
when(familyRelationMapper.selectOne(any())).thenReturn(familyRelation);
when(relationMapper.existsByPersonIdAndSocialCreditCode(addDTO.getPersonId(), addDTO.getSocialCreditCode())).thenReturn(false);
when(relationMapper.insert(any(CcdiStaffEnterpriseRelation.class))).thenReturn(1);
int result = service.insertRelation(addDTO);
assertEquals(1, result);
ArgumentCaptor<CcdiStaffEnterpriseRelation> captor = ArgumentCaptor.forClass(CcdiStaffEnterpriseRelation.class);
verify(relationMapper).insert(captor.capture());
assertEquals(1, captor.getValue().getStatus());
assertEquals("MANUAL", captor.getValue().getDataSource());
assertEquals(1, captor.getValue().getIsEmpFamily());
}
@Test
void insertRelation_shouldRejectInvalidFamily() {
CcdiStaffEnterpriseRelationAddDTO addDTO = buildAddDto();
when(familyRelationMapper.selectOne(any()))
.thenReturn(null)
.thenReturn(new CcdiStaffFmyRelation());
RuntimeException exception = assertThrows(RuntimeException.class, () -> service.insertRelation(addDTO));
assertEquals("亲属身份证号[" + addDTO.getPersonId() + "]不是有效员工亲属，请先维护有效的员工亲属关系", exception.getMessage());
}
@Test
void insertRelation_shouldRejectMissingFamily() {
CcdiStaffEnterpriseRelationAddDTO addDTO = buildAddDto();
when(familyRelationMapper.selectOne(any())).thenReturn(null);
RuntimeException exception = assertThrows(RuntimeException.class, () -> service.insertRelation(addDTO));
assertEquals("亲属身份证号[" + addDTO.getPersonId() + "]不存在，请先维护员工亲属关系", exception.getMessage());
}
@Test
void updateRelation_shouldExecuteEditFlow() {
CcdiStaffEnterpriseRelationEditDTO editDTO = new CcdiStaffEnterpriseRelationEditDTO();
editDTO.setId(1L);
editDTO.setPersonId("320101199001010022");
editDTO.setSocialCreditCode("91310000123456789A");
editDTO.setEnterpriseName("测试企业");
editDTO.setRelationPersonPost("董事");
editDTO.setStatus(0);
editDTO.setRemark("测试备注");
when(relationMapper.update(isNull(), any(LambdaUpdateWrapper.class))).thenReturn(1);
int result = service.updateRelation(editDTO);
assertEquals(1, result);
verify(relationMapper).update(isNull(), any(LambdaUpdateWrapper.class));
}
@Test
void selectFamilyOptions_shouldDelegateToMapper() {
CcdiStaffEnterpriseRelationOptionVO option = new CcdiStaffEnterpriseRelationOptionVO();
option.setRelationCertNo("320101199001010022");
option.setRelationName("李四");
option.setStaffPersonId("320101199001010011");
option.setStaffPersonName("张三");
List<CcdiStaffEnterpriseRelationOptionVO> expected = List.of(option);
when(relationMapper.selectFamilyOptions("320101")).thenReturn(expected);
List<CcdiStaffEnterpriseRelationOptionVO> result = service.selectFamilyOptions("320101");
assertSame(expected, result);
}
private CcdiStaffEnterpriseRelationAddDTO buildAddDto() {
CcdiStaffEnterpriseRelationAddDTO addDTO = new CcdiStaffEnterpriseRelationAddDTO();
addDTO.setPersonId("320101199001010022");
addDTO.setSocialCreditCode("91310000123456789A");
addDTO.setEnterpriseName("测试企业");
addDTO.setRelationPersonPost("董事");
return addDTO;
}
private static void registerTableInfo(Class<?> entityClass, String namespace) {
if (TableInfoHelper.getTableInfo(entityClass) != null) {
return;
}
MapperBuilderAssistant assistant = new MapperBuilderAssistant(new Configuration(), "");
assistant.setCurrentNamespace(namespace);
TableInfoHelper.initTableInfo(assistant, entityClass);
}
}

34
ccdi-info-collection/src/test/java/com/ruoyi/info/collection/service/CcdiStaffFmyRelationServiceImplTest.java
View File

@@ -6,6 +6,7 @@ import com.ruoyi.info.collection.domain.dto.CcdiAssetInfoDTO;
import com.ruoyi.info.collection.domain.dto.CcdiStaffFmyRelationAddDTO;
import com.ruoyi.info.collection.domain.dto.CcdiStaffFmyRelationEditDTO;
import com.ruoyi.info.collection.domain.vo.CcdiStaffFmyRelationVO;
import com.ruoyi.info.collection.mapper.CcdiStaffEnterpriseRelationMapper;
import com.ruoyi.info.collection.mapper.CcdiStaffFmyRelationMapper;
import com.ruoyi.info.collection.service.impl.CcdiStaffFmyRelationServiceImpl;
import org.junit.jupiter.api.Test;
@@ -46,6 +47,9 @@ class CcdiStaffFmyRelationServiceImplTest {
@Mock
private ICcdiAssetInfoService assetInfoService;
@Mock
private CcdiStaffEnterpriseRelationMapper staffEnterpriseRelationMapper;
@Test
void selectRelationById_shouldAggregateAssetInfoList() {
CcdiStaffFmyRelationVO relationVO = new CcdiStaffFmyRelationVO();
@@ -171,6 +175,36 @@ class CcdiStaffFmyRelationServiceImplTest {
verify(assetInfoService).replaceByFamilyIdAndPersonId("320101199001010011", "A123456789", editDTO.getAssetInfoList());
}
@Test
void updateRelation_shouldInvalidateEnterpriseRelationsWhenFamilyBecomesInvalid() {
CcdiStaffFmyRelation existing = new CcdiStaffFmyRelation();
existing.setId(10L);
existing.setRelationCertType("护照");
existing.setRelationCertNo("A123456789");
existing.setStatus(1);
CcdiStaffFmyRelationEditDTO editDTO = new CcdiStaffFmyRelationEditDTO();
editDTO.setId(10L);
editDTO.setPersonId("320101199001010011");
editDTO.setRelationType("配偶");
editDTO.setRelationName("李四");
editDTO.setRelationCertType("护照");
editDTO.setRelationCertNo("A123456789");
editDTO.setStatus(0);
editDTO.setAssetInfoList(List.of(buildAssetDto("车辆")));
when(relationMapper.selectById(10L)).thenReturn(existing);
when(relationMapper.updateById(any(CcdiStaffFmyRelation.class))).thenReturn(1);
int result = service.updateRelation(editDTO);
assertEquals(1, result);
var order = inOrder(relationMapper, staffEnterpriseRelationMapper, assetInfoService);
order.verify(relationMapper).updateById(any(CcdiStaffFmyRelation.class));
order.verify(staffEnterpriseRelationMapper).invalidateByFamilyCertNo("A123456789");
order.verify(assetInfoService).replaceByFamilyIdAndPersonId("320101199001010011", "A123456789", editDTO.getAssetInfoList());
}
@Test
void deleteRelationByIds_shouldDeleteRelativeAssetsBeforeDeletingRelations() {
CcdiStaffFmyRelation relation1 = new CcdiStaffFmyRelation();