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;
|
import com.vincent.rsf.server.manager.entity.WkOrderItem;
|
import com.vincent.rsf.server.manager.entity.AsnOrderItemLog;
|
import com.vincent.rsf.server.manager.enums.AsnExceStatus;
|
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;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
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
|
private AsnOrderItemService asnOrderItemService;
|
@Autowired
|
private AsnOrderMapper asnOrderMapper;
|
/**
|
* @author Ryan
|
* @description 继续收货
|
* @param
|
* @return
|
* @time 2025/4/17 15:08
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R continueRecipt(Long id) {
|
AsnOrderLog orderLog = this.getById(id);
|
if (Objects.isNull(orderLog)) {
|
throw new CoolException("单据不存在！！");
|
}
|
WkOrder order = new WkOrder();
|
BeanUtils.copyProperties(orderLog, order);
|
order.setId(orderLog.getAsnId())
|
.setDeleted(0)
|
.setExceStatus(AsnExceStatus.ASN_EXCE_STATUS_EXCE_ING.val);
|
|
WkOrder wkOrder = asnOrderMapper.selectOne(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getCode, orderLog.getCode()));
|
if (!Objects.isNull(wkOrder)) {
|
throw new CoolException("收货单据已添加，刷新后再操作！！");
|
}
|
|
if (asnOrderMapper.insert(order) <= 0) {
|
throw new CoolException("单据保存失败！！");
|
}
|
List<AsnOrderItemLog> itemLogs = asnOrderItemLogService
|
.list(new LambdaQueryWrapper<AsnOrderItemLog>()
|
.eq(AsnOrderItemLog::getLogId, id));
|
List<WkOrderItem> orderItems = new ArrayList<>();
|
if (!Objects.isNull(itemLogs) && !itemLogs.isEmpty()) {
|
for (AsnOrderItemLog itemLog : itemLogs) {
|
WkOrderItem item = new WkOrderItem();
|
BeanUtils.copyProperties(itemLog, item);
|
item.setId(itemLog.getAsnItemId())
|
.setOrderId(order.getId())
|
.setMatnrId(itemLog.getMatnrId())
|
.setDeleted(0);
|
orderItems.add(item);
|
}
|
if (!asnOrderItemService.saveOrUpdateBatch(orderItems)) {
|
throw new CoolException("明细保存失败");
|
}
|
}
|
if (!this.removeById(orderLog.getId())) {
|
throw new CoolException("历史单据删除失败！！");
|
}
|
if (!asnOrderItemLogService.remove(new LambdaQueryWrapper<AsnOrderItemLog>()
|
.eq(AsnOrderItemLog::getLogId, orderLog.getId()))) {
|
throw new CoolException("历史单据明细删除失败！！");
|
}
|
|
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;
|
}
|
}
|
