"git@gitlab.ruzhoukj.com:wujipeng/relation.git" did not exist on "dfa973fc6f73cfa1e2c09e683d5ebc84c5843a9e"
Commit 6e5dd7ca authored by zhuxiang's avatar zhuxiang
Browse files

增加公共账户逻辑

parent a7ae1554
package com.platform.controller;
import com.platform.model.entity.PublicAccountEntity;
import com.platform.model.resp.Result;
import com.platform.service.PublicAccountService;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
@RestController
@RequestMapping("/public/account")
public class PublicAccountController extends BaseController {
@Resource
private PublicAccountService publicAccountService;
@PostMapping("/set")
public Result set(@RequestBody PublicAccountEntity publicAccountEntity) {
try {
return toAjax(publicAccountService.save(publicAccountEntity));
} catch (DuplicateKeyException e) {
return Result.fail("该账户已是公共账户");
}
}
}
package com.platform.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.platform.model.entity.PublicAccountEntity;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface PublicAccountMapper extends BaseMapper<PublicAccountEntity> {
}
package com.platform.model.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
@Data
@TableName("public_account")
public class PublicAccountEntity {
@TableId(value = "id", type = IdType.AUTO)
private int id;
private int caseId;
private String accountName;
}
package com.platform.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.platform.model.entity.PublicAccountEntity;
import java.util.List;
public interface PublicAccountService extends IService<PublicAccountEntity> {
List<PublicAccountEntity> queryByCaseId(int caseId);
}
...@@ -18,6 +18,7 @@ import javax.annotation.Resource; ...@@ -18,6 +18,7 @@ import javax.annotation.Resource;
import java.math.BigDecimal; import java.math.BigDecimal;
import java.math.RoundingMode; import java.math.RoundingMode;
import java.util.*; import java.util.*;
import java.util.stream.Collectors;
@Service @Service
public class CaseServiceImpl extends ServiceImpl<CaseMapper, CasesEntity> implements CasesService { public class CaseServiceImpl extends ServiceImpl<CaseMapper, CasesEntity> implements CasesService {
...@@ -38,6 +39,8 @@ public class CaseServiceImpl extends ServiceImpl<CaseMapper, CasesEntity> implem ...@@ -38,6 +39,8 @@ public class CaseServiceImpl extends ServiceImpl<CaseMapper, CasesEntity> implem
private CaseRuleConfigService caseRuleConfigService; private CaseRuleConfigService caseRuleConfigService;
@Resource @Resource
private UserRelationService userRelationService; private UserRelationService userRelationService;
@Resource
private PublicAccountService publicAccountService;
@Override @Override
public List<CaseVO> queryDataList(CaseDTO caseDTO) { public List<CaseVO> queryDataList(CaseDTO caseDTO) {
...@@ -119,301 +122,347 @@ public class CaseServiceImpl extends ServiceImpl<CaseMapper, CasesEntity> implem ...@@ -119,301 +122,347 @@ public class CaseServiceImpl extends ServiceImpl<CaseMapper, CasesEntity> implem
@Override @Override
public GraphVO draw(CaseDTO caseDTO) { public GraphVO draw(CaseDTO caseDTO) {
// 初始化画布对象
GraphVO graph = new GraphVO(); GraphVO graph = new GraphVO();
CasesEntity caseEntity = baseMapper.getInfoById(caseDTO.getId()); CasesEntity caseEntity = baseMapper.getInfoById(caseDTO.getId());
if (caseEntity == null) { if (caseEntity == null) {
return graph; return graph;
} }
if (Boolean.TRUE.equals(caseEntity.getDrawFlag())) { if (Boolean.TRUE.equals(caseEntity.getDrawFlag())) {
//查询数据库数据 return loadExistingGraphData(caseDTO.getId());
List<NodeVO> nodeVOList = nodeService.queryByCaseId(caseDTO.getId());
List<EdgeVO> edgeVOList = edgeService.queryByCaseId(caseDTO.getId());
List<GroupVO> groupVOList = groupService.queryByCaseId(caseDTO.getId());
graph.setNodes(nodeVOList);
graph.setEdges(edgeVOList);
graph.setGroups(groupVOList);
} else { } else {
// 使用并查集管理团体关系 return processNewGraphData(caseDTO, graph);
UnionFindVO uf = new UnionFindVO(); }
}
Set<String> uniqueUserName = new HashSet<>();
// 存储边信息,键为payer-payee组合
Map<String, EdgeVO> edgeMap = new HashMap<>();
//查看案件是否有配置的规则
CaseRuleConfigEntity caseRuleConfigEntity = caseRuleConfigService.getByCaseId(caseDTO.getId());
if (caseRuleConfigEntity != null) {
caseDTO.setMinTransaction(caseRuleConfigEntity.getMinTransaction());
caseDTO.setMaxTransaction(caseRuleConfigEntity.getMaxTransaction());
caseDTO.setMinAmount(caseRuleConfigEntity.getMinAmount());
caseDTO.setMaxAmount(caseRuleConfigEntity.getMaxAmount());
caseDTO.setStartTime(caseRuleConfigEntity.getStartTime());
caseDTO.setEndTime(caseRuleConfigEntity.getEndTime());
caseDTO.setPrincipal(caseRuleConfigEntity.getPrincipal());
caseDTO.setWhiteFlag(caseRuleConfigEntity.isWhiteFlag());
}
// 查询案件数据 private GraphVO loadExistingGraphData(int caseId) {
List<ExcelDataEntity> excelDataEntityList = excelDataService.queryList(caseDTO); GraphVO graph = new GraphVO();
graph.setNodes(nodeService.queryByCaseId(caseId));
Iterator<ExcelDataEntity> iterator = excelDataEntityList.iterator(); graph.setEdges(edgeService.queryByCaseId(caseId));
while (iterator.hasNext()) { graph.setGroups(groupService.queryByCaseId(caseId));
ExcelDataEntity excelDataEntity = iterator.next(); return graph;
if (caseDTO.getPrincipal() != null) { }
if (caseDTO.getPrincipal() == 1 && excelDataEntity.getPayeeName().contains("公司")) {
//移除被付款人是公司
iterator.remove(); // 安全移除元素
continue;
}
if (caseDTO.getPrincipal() == 2 && !excelDataEntity.getPayeeName().contains("公司")) {
//移除被付款人是公司
iterator.remove(); // 安全移除元素
continue;
}
}
// 检查金额过滤条件 private GraphVO processNewGraphData(CaseDTO caseDTO, GraphVO graph) {
if (caseDTO.getMinAmount() != null && caseDTO.getMaxAmount() != null) { // 初始化数据结构
if (excelDataEntity.getAmount() < caseDTO.getMinAmount() || UnionFindVO uf = new UnionFindVO();
excelDataEntity.getAmount() > caseDTO.getMaxAmount()) { Set<String> uniqueUserName = new HashSet<>();
iterator.remove(); Map<String, EdgeVO> edgeMap = new HashMap<>();
continue;
}
} else if (caseDTO.getMinAmount() != null) {
if (excelDataEntity.getAmount() < caseDTO.getMinAmount()) {
iterator.remove();
continue;
}
} else if (caseDTO.getMaxAmount() != null && excelDataEntity.getAmount() > caseDTO.getMaxAmount()) {
iterator.remove();
continue;
}
// 配置规则
applyCaseRules(caseDTO);
// 检查交易次数过滤条件 // 查询并过滤数据
if (caseDTO.getMinTransaction() != null && caseDTO.getMaxTransaction() != null) { List<ExcelDataEntity> excelDataEntityList = filterExcelData(caseDTO);
if (excelDataEntity.getTransactionCount() < caseDTO.getMinTransaction() || if (CollUtil.isEmpty(excelDataEntityList)) {
excelDataEntity.getTransactionCount() > caseDTO.getMaxTransaction()) { return graph;
iterator.remove(); }
}
} else if (caseDTO.getMinTransaction() != null) { // 处理原始数据
if (excelDataEntity.getTransactionCount() < caseDTO.getMinTransaction()) { processRawData(excelDataEntityList, uf, uniqueUserName, edgeMap, caseDTO.getId());
iterator.remove();
} // 获取用户标签
} else if (caseDTO.getMaxTransaction() != null && excelDataEntity.getTransactionCount() > caseDTO.getMaxTransaction()) { Map<String, String> userAndLabel = getUserLabels(uniqueUserName, caseDTO.getId());
iterator.remove();
} // 添加节点
addNodesToGraph(graph, uniqueUserName, userAndLabel);
// 过滤有效边
List<EdgeVO> validEdges = filterValidEdges(edgeMap, uf);
graph.setEdges(validEdges);
// 计算成员明细
Map<String, GroupDetailEntity> memberDetailMap = calculateMemberDetails(validEdges);
// 生成团体
generateGroups(graph, uf, memberDetailMap);
// 保存数据
saveGraphData(caseDTO.getId(), graph);
return graph;
}
private void applyCaseRules(CaseDTO caseDTO) {
CaseRuleConfigEntity caseRuleConfigEntity = caseRuleConfigService.getByCaseId(caseDTO.getId());
if (caseRuleConfigEntity != null) {
caseDTO.setMinTransaction(caseRuleConfigEntity.getMinTransaction());
caseDTO.setMaxTransaction(caseRuleConfigEntity.getMaxTransaction());
caseDTO.setMinAmount(caseRuleConfigEntity.getMinAmount());
caseDTO.setMaxAmount(caseRuleConfigEntity.getMaxAmount());
caseDTO.setStartTime(caseRuleConfigEntity.getStartTime());
caseDTO.setEndTime(caseRuleConfigEntity.getEndTime());
caseDTO.setPrincipal(caseRuleConfigEntity.getPrincipal());
caseDTO.setWhiteFlag(caseRuleConfigEntity.isWhiteFlag());
}
}
private List<ExcelDataEntity> filterExcelData(CaseDTO caseDTO) {
List<ExcelDataEntity> excelDataEntityList = excelDataService.queryList(caseDTO);
if (CollUtil.isEmpty(excelDataEntityList)) {
return excelDataEntityList;
}
// 使用迭代器安全删除
Iterator<ExcelDataEntity> iterator = excelDataEntityList.iterator();
while (iterator.hasNext()) {
ExcelDataEntity excelDataEntity = iterator.next();
// 过滤付款人类型
if (caseDTO.getPrincipal() != null) {
if (caseDTO.getPrincipal() == 1 && excelDataEntity.getPayeeName().contains("公司")) {
iterator.remove();
continue;
}
if (caseDTO.getPrincipal() == 2 && !excelDataEntity.getPayeeName().contains("公司")) {
iterator.remove();
continue;
}
} }
if (caseDTO.getWhiteFlag() != null && caseDTO.getWhiteFlag()) { // 过滤金额范围
//过滤白名单 if (!isWithinAmountRange(excelDataEntity, caseDTO.getMinAmount(), caseDTO.getMaxAmount())) {
filterWhite(excelDataEntityList); iterator.remove();
continue;
} }
if (CollUtil.isEmpty(excelDataEntityList)) { // 过滤交易次数
return graph; // 无数据直接返回空图 if (!isWithinTransactionRange(excelDataEntity, caseDTO.getMinTransaction(), caseDTO.getMaxTransaction())) {
iterator.remove();
} }
}
// 第一步:处理原始数据 // 白名单过滤
for (ExcelDataEntity excelDataEntity : excelDataEntityList) { if (caseDTO.getWhiteFlag() != null && caseDTO.getWhiteFlag()) {
if (StringUtils.isEmpty(excelDataEntity.getPayUserName()) || filterWhite(excelDataEntityList);
StringUtils.isEmpty(excelDataEntity.getPayeeName())) { }
continue; // 跳过无效记录
} return excelDataEntityList;
}
private boolean isWithinAmountRange(ExcelDataEntity entity, Double min, Double max) {
double amount = entity.getAmount();
if (min != null && amount < min) return false;
if (max != null && amount > max) return false;
return true;
}
private boolean isWithinTransactionRange(ExcelDataEntity entity, Integer min, Integer max) {
int count = entity.getTransactionCount();
if (min != null && count < min) return false;
if (max != null && count > max) return false;
return true;
}
String payer = excelDataEntity.getPayUserName(); private void processRawData(List<ExcelDataEntity> dataList,
String payee = excelDataEntity.getPayeeName(); UnionFindVO uf,
double amount = excelDataEntity.getAmount(); Set<String> uniqueUserName,
Map<String, EdgeVO> edgeMap,
int caseId) {
//查看公共账号的数据
List<PublicAccountEntity> publicAccountEntityList = publicAccountService.queryByCaseId(caseId);
for (ExcelDataEntity excelDataEntity : dataList) {
if (StringUtils.isEmpty(excelDataEntity.getPayUserName()) ||
StringUtils.isEmpty(excelDataEntity.getPayeeName())) {
continue;
}
BigDecimal bd = BigDecimal.valueOf(amount); String payer = excelDataEntity.getPayUserName();
bd = bd.setScale(2, RoundingMode.HALF_UP); // 保留两位小数,四舍五入 String payee = excelDataEntity.getPayeeName();
double formattedAmount = bd.doubleValue();
// 跳过公共账户中的中号
if (isPublicAccount(payer, publicAccountEntityList) || isPublicAccount(payee, publicAccountEntityList)) {
continue;
}
String ip = excelDataEntity.getIp(); double amount = formatAmount(excelDataEntity.getAmount());
String mac = excelDataEntity.getMac(); uniqueUserName.add(payer);
String account = excelDataEntity.getPaymentBankName(); uniqueUserName.add(payee);
uniqueUserName.add(payee); // 使用UnionFindVO的接口正确添加节点
uniqueUserName.add(payer); if (!uf.getParent().containsKey(payer)) {
// 添加到并查集
uf.makeSet(payer); uf.makeSet(payer);
}
if (!uf.getParent().containsKey(payee)) {
uf.makeSet(payee); uf.makeSet(payee);
uf.union(payer, payee);
// 处理边信息
String edgeKey = payer + "-" + payee;
EdgeVO existingEdge = edgeMap.get(edgeKey);
if (existingEdge != null) {
// 更新现有边
existingEdge.setTotalTransactions(existingEdge.getTotalTransactions() + 1);
existingEdge.setTotalAmount(existingEdge.getTotalAmount() + formattedAmount);
} else {
// 创建新边
EdgeVO newEdge = new EdgeVO(payer, payee, 1, formattedAmount, uf.find(payer), ip, mac, account);
edgeMap.put(edgeKey, newEdge);
}
} }
List<String> userNameList = new ArrayList<>(uniqueUserName); // 执行并查集合并
List<ExcelDataVO> excelDataEntityListNew = userService.queryUserLabel(userNameList, caseDTO.getId()); uf.union(payer, payee);
Map<String, String> userAndLabel = new HashMap<>();
excelDataEntityListNew.forEach(excelDataVO -> userAndLabel.put(excelDataVO.getPayUserName(), excelDataVO.getLabel()));
// 第二步:过滤节点 // 处理边信息
Set<String> validNodes = new HashSet<>(); updateEdgeMap(edgeMap, payer, payee, amount, excelDataEntity, uf);
}
}
for (String node : uf.getParent().keySet()) { private boolean isPublicAccount(String accountName, List<PublicAccountEntity> publicAccountEntityList) {
validNodes.add(node); boolean result = false;
String label = userAndLabel.get(node); // 实现您的公共账户识别逻辑
graph.addNode(new NodeVO(node, label)); for (PublicAccountEntity publicAccountEntity : publicAccountEntityList) {
if (publicAccountEntity.getAccountName().equals(accountName)) {
result = true;
} }
}
return result;
}
// 第三步:过滤边 private double formatAmount(double amount) {
List<EdgeVO> validEdges = new ArrayList<>(); return BigDecimal.valueOf(amount)
for (EdgeVO edge : edgeMap.values()) { .setScale(2, RoundingMode.HALF_UP)
// 检查两端节点是否有效 .doubleValue();
if (!validNodes.contains(edge.getSource()) || }
!validNodes.contains(edge.getTarget())) {
continue;
}
// 添加到有效边集合
validEdges.add(edge);
graph.addEdge(edge);
}
// 第四步:重建过滤后的团体关系 private void updateEdgeMap(Map<String, EdgeVO> edgeMap,
// 创建新的并查集用于过滤后的数据 String payer, String payee,
UnionFindVO filteredUf = new UnionFindVO(); double amount, ExcelDataEntity entity,
validNodes.forEach(filteredUf::makeSet); UnionFindVO uf) {
String edgeKey = payer + "-" + payee;
EdgeVO existingEdge = edgeMap.get(edgeKey);
// 用于按团体分组统计 // 使用uf.find()获取根节点
Map<String, Set<String>> groupMembers = new HashMap<>(); String root = uf.find(payer);
Map<String, Double> groupTotalAmount = new HashMap<>();
Map<String, Integer> groupTotalTransactions = new HashMap<>();
// 初始化每个节点的团体 if (existingEdge != null) {
for (String node : validNodes) { existingEdge.setTotalTransactions(existingEdge.getTotalTransactions() + 1);
String root = uf.find(node); existingEdge.setTotalAmount(existingEdge.getTotalAmount() + amount);
groupMembers.computeIfAbsent(root, k -> new HashSet<>()).add(node); } else {
} EdgeVO newEdge = new EdgeVO(
payer, payee, 1, amount, root,
entity.getIp(), entity.getMac(), entity.getPaymentBankName()
);
edgeMap.put(edgeKey, newEdge);
}
}
// 处理有效边,更新团体关系 private Map<String, String> getUserLabels(Set<String> userNameList, int caseId) {
for (EdgeVO edge : validEdges) { List<ExcelDataVO> excelDataVOList = userService.queryUserLabel(new ArrayList<>(userNameList), caseId);
// 更新过滤后的并查集 Map<String, String> userAndLabel = new HashMap<>();
filteredUf.union(edge.getSource(), edge.getTarget()); for (ExcelDataVO vo : excelDataVOList) {
userAndLabel.put(vo.getPayUserName(), vo.getLabel());
}
return userAndLabel;
}
// 更新团体统计 private void addNodesToGraph(GraphVO graph, Set<String> uniqueUserName, Map<String, String> userAndLabel) {
String originalRoot = uf.find(edge.getSource()); for (String userName : uniqueUserName) {
groupTotalAmount.merge(originalRoot, edge.getTotalAmount(), Double::sum); String label = userAndLabel.getOrDefault(userName, "");
groupTotalTransactions.merge(originalRoot, edge.getTotalTransactions(), Integer::sum); graph.addNode(new NodeVO(userName, label));
} }
}
// 第五步:计算成员明细 private List<EdgeVO> filterValidEdges(Map<String, EdgeVO> edgeMap, UnionFindVO uf) {
Map<String, GroupDetailEntity> memberDetailMap = new HashMap<>(); List<EdgeVO> validEdges = new ArrayList<>();
Map<String, String> parent = uf.getParent();
// 初始化所有有效节点的成员明细 for (EdgeVO edge : edgeMap.values()) {
for (String node : validNodes) { // 检查节点是否在并查集中
memberDetailMap.put(node, new GroupDetailEntity(node)); if (parent.containsKey(edge.getSource()) && parent.containsKey(edge.getTarget())) {
validEdges.add(edge);
} }
}
return validEdges;
}
// 更新成员明细 private Map<String, GroupDetailEntity> calculateMemberDetails(List<EdgeVO> edges) {
for (EdgeVO edge : validEdges) { Map<String, GroupDetailEntity> memberDetailMap = new HashMap<>();
String payer = edge.getSource();
String payee = edge.getTarget(); for (EdgeVO edge : edges) {
double amount = edge.getTotalAmount(); String payer = edge.getSource();
String ip = edge.getIp(); String payee = edge.getTarget();
String mac = edge.getMac(); double amount = edge.getTotalAmount();
String account = edge.getAccount(); int transactions = edge.getTotalTransactions();
String ip = edge.getIp();
// 更新付款人(转出) String mac = edge.getMac();
GroupDetailEntity payerDetail = memberDetailMap.get(payer); String account = edge.getAccount();
if (payerDetail != null) {
payerDetail.setIp(ip); // 更新付款人明细
payerDetail.setMac(mac); GroupDetailEntity payerDetail = memberDetailMap.computeIfAbsent(payer, k -> new GroupDetailEntity(payer));
payerDetail.setAccount(account); payerDetail.setIp(ip);
payerDetail.addOutgoingTransaction(amount); payerDetail.setMac(mac);
payerDetail.incrementTransactionCount(edge.getTotalTransactions()); payerDetail.setAccount(account);
} payerDetail.addOutgoingTransaction(amount);
payerDetail.incrementTransactionCount(transactions);
// 更新收款人明细
GroupDetailEntity payeeDetail = memberDetailMap.computeIfAbsent(payee, k -> new GroupDetailEntity(payee));
payeeDetail.setIp(ip);
payeeDetail.setMac(mac);
payeeDetail.setAccount(account);
payeeDetail.addIncomingTransaction(amount);
payeeDetail.incrementTransactionCount(transactions);
}
// 更新收款人(转入) return memberDetailMap;
GroupDetailEntity payeeDetail = memberDetailMap.get(payee); }
if (payeeDetail != null) {
payeeDetail.setIp(ip);
payeeDetail.setMac(mac);
payeeDetail.setAccount(account);
payeeDetail.addIncomingTransaction(amount);
payeeDetail.incrementTransactionCount(edge.getTotalTransactions());
}
}
// 第六步:处理团体合并(因过滤可能改变团体结构) private void generateGroups(GraphVO graph, UnionFindVO uf, Map<String, GroupDetailEntity> memberDetailMap) {
for (String node : validNodes) { // 收集团体成员
String originalRoot = uf.find(node); Map<String, Set<String>> groupMembers = new HashMap<>();
String newRoot = filteredUf.find(node); Map<String, String> parent = uf.getParent();
if (!originalRoot.equals(newRoot)) { // 遍历所有节点
// 合并团体 for (String node : parent.keySet()) {
Set<String> members = groupMembers.remove(originalRoot); String root = uf.find(node);
if (members != null) { groupMembers.computeIfAbsent(root, k -> new HashSet<>()).add(node);
groupMembers.computeIfAbsent(newRoot, k -> new HashSet<>()).addAll(members); }
// 合并统计信息 // 计算团体统计数据
if (groupTotalAmount.containsKey(originalRoot)) { Map<String, Double> groupTotalAmount = new HashMap<>();
groupTotalAmount.merge(newRoot, groupTotalAmount.get(originalRoot), Double::sum); Map<String, Integer> groupTotalTransactions = new HashMap<>();
groupTotalAmount.remove(originalRoot);
} for (Map.Entry<String, Set<String>> entry : groupMembers.entrySet()) {
if (groupTotalTransactions.containsKey(originalRoot)) { String groupId = entry.getKey();
groupTotalTransactions.merge(newRoot, groupTotalTransactions.get(originalRoot), Integer::sum); for (String member : entry.getValue()) {
groupTotalTransactions.remove(originalRoot); GroupDetailEntity detail = memberDetailMap.get(member);
} if (detail != null) {
} groupTotalAmount.merge(groupId, detail.getTotalAmount(), Double::sum);
groupTotalTransactions.merge(groupId, detail.getTransactionCount(), Integer::sum);
} }
} }
}
// 第七步:生成团体对象 // 生成团体对象
for (Map.Entry<String, Set<String>> entry : groupMembers.entrySet()) { for (Map.Entry<String, Set<String>> entry : groupMembers.entrySet()) {
String groupId = entry.getKey(); String groupId = entry.getKey();
Set<String> members = entry.getValue(); Set<String> members = entry.getValue();
// 跳过孤立节点 // 团体人数小于3不生成团体
if (members.size() == 1 && !hasConnections(members, graph)) { if (members.size() < 3) {
continue; continue;
} }
// 收集成员明细 // 收集成员明细
List<GroupDetailEntity> memberDetails = new ArrayList<>(); List<GroupDetailEntity> memberDetails = new ArrayList<>();
for (String member : members) { for (String member : members) {
GroupDetailEntity detail = memberDetailMap.get(member); GroupDetailEntity detail = memberDetailMap.get(member);
if (detail != null) { if (detail != null) {
memberDetails.add(detail); memberDetails.add(detail);
}
} }
// 按用户名排序
memberDetails.sort(Comparator.comparing(GroupDetailEntity::getUserName));
// 添加团体对象
graph.addGroup(new GroupVO(
groupId,
members.size(),
groupTotalAmount.getOrDefault(groupId, 0.0),
groupTotalTransactions.getOrDefault(groupId, 0),
memberDetails
));
} }
//处理付款人与收款人的关系
disposeUserRelation(caseDTO.getId(), validNodes, graph.getEdges()); // 按用户名排序
//保存节点、边数据 memberDetails.sort(Comparator.comparing(GroupDetailEntity::getUserName));
nodeService.saveData(caseDTO.getId(), graph.getNodes());
edgeService.saveData(caseDTO.getId(), graph.getEdges()); // 添加团体对象
//保存团体数据 graph.addGroup(new GroupVO(
groupService.saveGroup(caseDTO.getId(), graph.getGroups()); groupId,
members.size(),
groupTotalAmount.getOrDefault(groupId, 0.0),
groupTotalTransactions.getOrDefault(groupId, 0),
memberDetails
));
} }
return graph; }
private void saveGraphData(int caseId, GraphVO graph) {
disposeUserRelation(caseId, graph.getNodes().stream()
.map(NodeVO::getNode)
.collect(Collectors.toSet()), graph.getEdges());
nodeService.saveData(caseId, graph.getNodes());
edgeService.saveData(caseId, graph.getEdges());
groupService.saveGroup(caseId, graph.getGroups());
} }
private void disposeUserRelation(int caseId, Set<String> validNodes, List<EdgeVO> edges) { private void disposeUserRelation(int caseId, Set<String> validNodes, List<EdgeVO> edges) {
......
package com.platform.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.platform.mapper.PublicAccountMapper;
import com.platform.model.entity.PublicAccountEntity;
import com.platform.service.PublicAccountService;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @author wujipeng
* @version 1.0
* @create 2025-08-05 20:16
*/
@Service
public class PublicAccountServiceImpl extends ServiceImpl<PublicAccountMapper, PublicAccountEntity> implements PublicAccountService {
@Override
public List<PublicAccountEntity> queryByCaseId(int caseId) {
return baseMapper.selectList(new LambdaQueryWrapper<PublicAccountEntity>()
.eq(PublicAccountEntity::getCaseId, caseId));
}
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment