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/AsnOrderItemLogServiceImpl.java | 246 +++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 246 insertions(+), 0 deletions(-)
diff --git a/rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/AsnOrderItemLogServiceImpl.java b/rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/AsnOrderItemLogServiceImpl.java
index 2c0038d..6d77c77 100644
--- a/rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/AsnOrderItemLogServiceImpl.java
+++ b/rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/AsnOrderItemLogServiceImpl.java
@@ -1,12 +1,258 @@
package com.vincent.rsf.server.manager.service.impl;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
+import com.vincent.rsf.server.manager.partition.AsnLogPartitionSupport;
import com.vincent.rsf.server.manager.mapper.AsnOrderItemLogMapper;
import com.vincent.rsf.server.manager.entity.AsnOrderItemLog;
import com.vincent.rsf.server.manager.service.AsnOrderItemLogService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
@Service("asnOrderItemLogService")
public class AsnOrderItemLogServiceImpl extends ServiceImpl<AsnOrderItemLogMapper, AsnOrderItemLog> implements AsnOrderItemLogService {
+ @Autowired
+ private AsnLogPartitionSupport partitionSupport;
+
+ @Override
+ public boolean save(AsnOrderItemLog entity) {
+ if (entity == null) {
+ return false;
+ }
+ String tableName = partitionSupport.resolveOrderItemLogTable(entity.getCreateTime());
+ partitionSupport.ensureTableExists(AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE, tableName);
+ return partitionSupport.executeOnTable(AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE, tableName, () -> super.save(entity));
+ }
+
+ @Override
+ public boolean saveBatch(Collection<AsnOrderItemLog> entityList) {
+ return saveBatch(entityList, DEFAULT_BATCH_SIZE);
+ }
+
+ @Override
+ public boolean saveBatch(Collection<AsnOrderItemLog> entityList, int batchSize) {
+ if (entityList == null || entityList.isEmpty()) {
+ return false;
+ }
+ Map<String, List<AsnOrderItemLog>> grouped = new LinkedHashMap<>();
+ for (AsnOrderItemLog entity : entityList) {
+ String tableName = partitionSupport.resolveOrderItemLogTable(entity == null ? null : entity.getCreateTime());
+ grouped.computeIfAbsent(tableName, key -> new ArrayList<>()).add(entity);
+ }
+ boolean success = true;
+ for (Map.Entry<String, List<AsnOrderItemLog>> entry : grouped.entrySet()) {
+ partitionSupport.ensureTableExists(AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE, entry.getKey());
+ Boolean saved = partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
+ entry.getKey(),
+ () -> super.saveBatch(entry.getValue(), batchSize)
+ );
+ success = success && Boolean.TRUE.equals(saved);
+ }
+ return success;
+ }
+
+ @Override
+ public boolean saveBatchToDate(Collection<AsnOrderItemLog> entityList, Date partitionDate) {
+ if (entityList == null || entityList.isEmpty()) {
+ return false;
+ }
+ String tableName = partitionSupport.resolveOrderItemLogTable(partitionDate);
+ partitionSupport.ensureTableExists(AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE, tableName);
+ return partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
+ tableName,
+ () -> super.saveBatch(entityList, DEFAULT_BATCH_SIZE)
+ );
+ }
+
+ @Override
+ public AsnOrderItemLog getById(Serializable id) {
+ if (id == null) {
+ return null;
+ }
+ for (String tableName : partitionSupport.listOrderItemLogTables()) {
+ AsnOrderItemLog record = partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
+ tableName,
+ () -> baseMapper.selectById(id)
+ );
+ if (record != null) {
+ return record;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public List<AsnOrderItemLog> listByIds(Collection<? extends Serializable> idList) {
+ if (idList == null || idList.isEmpty()) {
+ return Collections.emptyList();
+ }
+ Map<Long, AsnOrderItemLog> merged = new LinkedHashMap<>();
+ for (String tableName : partitionSupport.listOrderItemLogTables()) {
+ List<AsnOrderItemLog> part = partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
+ tableName,
+ () -> baseMapper.selectBatchIds(idList)
+ );
+ mergeRecords(merged, part);
+ }
+ return sortRecords(new ArrayList<>(merged.values()));
+ }
+
+ @Override
+ public List<AsnOrderItemLog> list() {
+ return list((Wrapper<AsnOrderItemLog>) null);
+ }
+
+ @Override
+ public List<AsnOrderItemLog> list(Wrapper<AsnOrderItemLog> queryWrapper) {
+ Map<Long, AsnOrderItemLog> merged = new LinkedHashMap<>();
+ for (String tableName : partitionSupport.listOrderItemLogTables()) {
+ List<AsnOrderItemLog> part = partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
+ tableName,
+ () -> baseMapper.selectList(queryWrapper)
+ );
+ mergeRecords(merged, part);
+ }
+ return sortRecords(new ArrayList<>(merged.values()));
+ }
+
+ @Override
+ public AsnOrderItemLog getOne(Wrapper<AsnOrderItemLog> queryWrapper) {
+ List<AsnOrderItemLog> records = list(queryWrapper);
+ return records.isEmpty() ? null : records.get(0);
+ }
+
+ @Override
+ public <E extends IPage<AsnOrderItemLog>> E page(E page, Wrapper<AsnOrderItemLog> queryWrapper) {
+ List<AsnOrderItemLog> 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(AsnOrderItemLog entity) {
+ if (entity == null || entity.getId() == null) {
+ return false;
+ }
+ String tableName = locateTableById(entity.getId());
+ if (tableName == null) {
+ return false;
+ }
+ return partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_ITEM_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_ITEM_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_ITEM_LOG_TABLE,
+ entry.getKey(),
+ () -> super.removeByIds(entry.getValue())
+ );
+ removed = removed || Boolean.TRUE.equals(partRemoved);
+ }
+ return removed;
+ }
+
+ @Override
+ public boolean remove(Wrapper<AsnOrderItemLog> queryWrapper) {
+ int affected = 0;
+ for (String tableName : partitionSupport.listOrderItemLogTables()) {
+ Integer count = partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
+ tableName,
+ () -> baseMapper.delete(queryWrapper)
+ );
+ affected += count == null ? 0 : count;
+ }
+ return SqlHelper.retBool(affected);
+ }
+
+ private String locateTableById(Serializable id) {
+ for (String tableName : partitionSupport.listOrderItemLogTables()) {
+ AsnOrderItemLog record = partitionSupport.executeOnTable(
+ AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
+ tableName,
+ () -> baseMapper.selectById(id)
+ );
+ if (record != null) {
+ return tableName;
+ }
+ }
+ return null;
+ }
+
+ private void mergeRecords(Map<Long, AsnOrderItemLog> merged, List<AsnOrderItemLog> records) {
+ if (records == null || records.isEmpty()) {
+ return;
+ }
+ for (AsnOrderItemLog record : records) {
+ if (record == null || record.getId() == null) {
+ continue;
+ }
+ merged.putIfAbsent(record.getId(), record);
+ }
+ }
+
+ private List<AsnOrderItemLog> sortRecords(List<AsnOrderItemLog> records) {
+ records.sort(Comparator.comparing(AsnOrderItemLog::getId, Comparator.nullsLast(Long::compareTo)).reversed());
+ return records;
+ }
}
--
Gitblit v1.9.1