From 25f0001a7e76d0565fa9de0651f1177b9f61472f Mon Sep 17 00:00:00 2001
From: zhou zhou <zozhouo3o@gmail.com>
Date: 星期四, 07 五月 2026 17:12:00 +0800
Subject: [PATCH] #order打印
---
rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/AsnOrderLogServiceImpl.java | 216 +++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 214 insertions(+), 2 deletions(-)
diff --git a/rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/AsnOrderLogServiceImpl.java b/rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/AsnOrderLogServiceImpl.java
index 9afaedf..232d2f6 100644
--- a/rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/AsnOrderLogServiceImpl.java
+++ b/rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/AsnOrderLogServiceImpl.java
@@ -1,6 +1,8 @@
package com.vincent.rsf.server.manager.service.impl;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.manager.entity.WkOrder;
@@ -10,6 +12,7 @@
import com.vincent.rsf.server.manager.mapper.AsnOrderMapper;
import com.vincent.rsf.server.manager.mapper.AsnOrderLogMapper;
import com.vincent.rsf.server.manager.entity.AsnOrderLog;
+import com.vincent.rsf.server.manager.partition.AsnLogPartitionSupport;
import com.vincent.rsf.server.manager.service.AsnOrderItemLogService;
import com.vincent.rsf.server.manager.service.AsnOrderItemService;
import com.vincent.rsf.server.manager.service.AsnOrderLogService;
@@ -19,13 +22,21 @@
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
+import java.io.Serializable;
import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
@Service("asnOrderLogService")
public class AsnOrderLogServiceImpl extends ServiceImpl<AsnOrderLogMapper, AsnOrderLog> implements AsnOrderLogService {
+ @Autowired
+ private AsnLogPartitionSupport partitionSupport;
@Autowired
private AsnOrderItemLogService asnOrderItemLogService;
@Autowired
@@ -42,7 +53,7 @@
@Override
@Transactional(rollbackFor = Exception.class)
public R continueRecipt(Long id) {
- AsnOrderLog orderLog = this.getOne(new LambdaQueryWrapper<AsnOrderLog>().eq(AsnOrderLog::getId, id));
+ AsnOrderLog orderLog = this.getById(id);
if (Objects.isNull(orderLog)) {
throw new CoolException("鍗曟嵁涓嶅瓨鍦紒锛�");
}
@@ -64,7 +75,7 @@
.list(new LambdaQueryWrapper<AsnOrderItemLog>()
.eq(AsnOrderItemLog::getLogId, id));
List<WkOrderItem> orderItems = new ArrayList<>();
- if (!Objects.isNull(itemLogs) || !itemLogs.isEmpty()) {
+ if (!Objects.isNull(itemLogs) && !itemLogs.isEmpty()) {
for (AsnOrderItemLog itemLog : itemLogs) {
WkOrderItem item = new WkOrderItem();
BeanUtils.copyProperties(itemLog, item);
@@ -88,4 +99,205 @@
return R.ok();
}
+
+ @Override
+ public boolean save(AsnOrderLog entity) {
+ if (entity == null) {
+ return false;
+ }
+ String tableName = partitionSupport.resolveOrderLogTable(entity.getCreateTime());
+ partitionSupport.ensureTableExists(AsnLogPartitionSupport.ORDER_LOG_TABLE, tableName);
+ return partitionSupport.executeOnTable(AsnLogPartitionSupport.ORDER_LOG_TABLE, tableName, () -> super.save(entity));
+ }
+
+ @Override
+ public boolean saveBatch(Collection<AsnOrderLog> entityList) {
+ return saveBatch(entityList, DEFAULT_BATCH_SIZE);
+ }
+
+ @Override
+ public boolean saveBatch(Collection<AsnOrderLog> entityList, int batchSize) {
+ if (entityList == null || entityList.isEmpty()) {
+ return false;
+ }
+ Map<String, List<AsnOrderLog>> grouped = new LinkedHashMap<>();
+ for (AsnOrderLog entity : entityList) {
+ String tableName = partitionSupport.resolveOrderLogTable(entity == null ? null : entity.getCreateTime());
+ grouped.computeIfAbsent(tableName, key -> new ArrayList<>()).add(entity);
+ }
+ boolean success = true;
+ for (Map.Entry<String, List<AsnOrderLog>> entry : grouped.entrySet()) {
+ partitionSupport.ensureTableExists(AsnLogPartitionSupport.ORDER_LOG_TABLE, entry.getKey());
+ Boolean saved = partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_LOG_TABLE,
+ entry.getKey(),
+ () -> super.saveBatch(entry.getValue(), batchSize)
+ );
+ success = success && Boolean.TRUE.equals(saved);
+ }
+ return success;
+ }
+
+ @Override
+ public AsnOrderLog getById(Serializable id) {
+ if (id == null) {
+ return null;
+ }
+ for (String tableName : partitionSupport.listOrderLogTables()) {
+ AsnOrderLog record = partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_LOG_TABLE,
+ tableName,
+ () -> baseMapper.selectById(id)
+ );
+ if (record != null) {
+ return record;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public List<AsnOrderLog> listByIds(Collection<? extends Serializable> idList) {
+ if (idList == null || idList.isEmpty()) {
+ return Collections.emptyList();
+ }
+ Map<Long, AsnOrderLog> merged = new LinkedHashMap<>();
+ for (String tableName : partitionSupport.listOrderLogTables()) {
+ List<AsnOrderLog> part = partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_LOG_TABLE,
+ tableName,
+ () -> baseMapper.selectBatchIds(idList)
+ );
+ mergeRecords(merged, part);
+ }
+ return sortRecords(new ArrayList<>(merged.values()));
+ }
+
+ @Override
+ public List<AsnOrderLog> list() {
+ return list((Wrapper<AsnOrderLog>) null);
+ }
+
+ @Override
+ public List<AsnOrderLog> list(Wrapper<AsnOrderLog> queryWrapper) {
+ Map<Long, AsnOrderLog> merged = new LinkedHashMap<>();
+ for (String tableName : partitionSupport.listOrderLogTables()) {
+ List<AsnOrderLog> part = partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_LOG_TABLE,
+ tableName,
+ () -> baseMapper.selectList(queryWrapper)
+ );
+ mergeRecords(merged, part);
+ }
+ return sortRecords(new ArrayList<>(merged.values()));
+ }
+
+ @Override
+ public AsnOrderLog getOne(Wrapper<AsnOrderLog> queryWrapper) {
+ List<AsnOrderLog> records = list(queryWrapper);
+ return records.isEmpty() ? null : records.get(0);
+ }
+
+ @Override
+ public <E extends IPage<AsnOrderLog>> E page(E page, Wrapper<AsnOrderLog> queryWrapper) {
+ List<AsnOrderLog> records = list(queryWrapper);
+ long current = page.getCurrent() <= 0 ? 1L : page.getCurrent();
+ long size = page.getSize() <= 0 ? records.size() : page.getSize();
+ int fromIndex = (int) Math.min((current - 1) * size, records.size());
+ int toIndex = (int) Math.min(fromIndex + size, records.size());
+ page.setTotal(records.size());
+ page.setRecords(fromIndex >= records.size() ? Collections.emptyList() : new ArrayList<>(records.subList(fromIndex, toIndex)));
+ return page;
+ }
+
+ @Override
+ public boolean updateById(AsnOrderLog entity) {
+ if (entity == null || entity.getId() == null) {
+ return false;
+ }
+ String tableName = locateTableById(entity.getId());
+ if (tableName == null) {
+ return false;
+ }
+ return partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_LOG_TABLE,
+ tableName,
+ () -> super.updateById(entity)
+ );
+ }
+
+ @Override
+ public boolean removeById(Serializable id) {
+ if (id == null) {
+ return false;
+ }
+ String tableName = locateTableById(id);
+ if (tableName == null) {
+ return false;
+ }
+ return partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_LOG_TABLE,
+ tableName,
+ () -> super.removeById(id)
+ );
+ }
+
+ @Override
+ public boolean removeByIds(Collection<?> list) {
+ if (list == null || list.isEmpty()) {
+ return false;
+ }
+ Map<String, List<Serializable>> groupedIds = new LinkedHashMap<>();
+ for (Object idObj : list) {
+ if (!(idObj instanceof Serializable)) {
+ continue;
+ }
+ Serializable id = (Serializable) idObj;
+ String tableName = locateTableById(id);
+ if (tableName != null) {
+ groupedIds.computeIfAbsent(tableName, key -> new ArrayList<>()).add(id);
+ }
+ }
+ boolean removed = false;
+ for (Map.Entry<String, List<Serializable>> entry : groupedIds.entrySet()) {
+ Boolean partRemoved = partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_LOG_TABLE,
+ entry.getKey(),
+ () -> super.removeByIds(entry.getValue())
+ );
+ removed = removed || Boolean.TRUE.equals(partRemoved);
+ }
+ return removed;
+ }
+
+ private String locateTableById(Serializable id) {
+ for (String tableName : partitionSupport.listOrderLogTables()) {
+ AsnOrderLog record = partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_LOG_TABLE,
+ tableName,
+ () -> baseMapper.selectById(id)
+ );
+ if (record != null) {
+ return tableName;
+ }
+ }
+ return null;
+ }
+
+ private void mergeRecords(Map<Long, AsnOrderLog> merged, List<AsnOrderLog> records) {
+ if (records == null || records.isEmpty()) {
+ return;
+ }
+ for (AsnOrderLog record : records) {
+ if (record == null || record.getId() == null) {
+ continue;
+ }
+ merged.putIfAbsent(record.getId(), record);
+ }
+ }
+
+ private List<AsnOrderLog> sortRecords(List<AsnOrderLog> records) {
+ records.sort(Comparator.comparing(AsnOrderLog::getId, Comparator.nullsLast(Long::compareTo)).reversed());
+ return records;
+ }
}
--
Gitblit v1.9.1