Files
WMSlite/WmsLite.Api/Repositories/OrderRepositories.cs
T
2026-06-01 23:30:36 +08:00

233 lines
9.0 KiB
C#

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Threading.Tasks;
using SqlSugar;
using WmsLite.Api.Common;
using WmsLite.Api.Dtos.Orders;
using WmsLite.Api.Enums;
using WmsLite.Api.Infrastructure.Auth;
using WmsLite.Api.Models;
using WmsLite.Api.Repositories.Interfaces;
namespace WmsLite.Api.Repositories;
public abstract class OrderRepositoryBase<TEntity, TQuery> : BaseRepository<TEntity>
where TEntity : BaseEntity, new()
where TQuery : OrderPagedQueryBase
{
protected OrderRepositoryBase(ISqlSugarClient db, ICurrentUserContext userContext) : base(db, userContext)
{
}
protected async Task<TEntity?> GetByOrderNoCoreAsync(string tenantId, string ownerCode, string orderNo)
{
if (string.IsNullOrWhiteSpace(orderNo))
{
return null;
}
var tenant = tenantId.Trim();
var owner = ownerCode.Trim();
var order = orderNo.Trim();
return await Db.Queryable<TEntity>()
.Where(x => !x.IsDeleted && x.TenantId == tenant && x.OwnerCode == owner)
.Where("order_no = @orderNo", new { orderNo = order })
.FirstAsync();
}
protected async Task<PagedResult<TEntity>> GetPagedListCoreAsync(TQuery query)
{
ArgumentNullException.ThrowIfNull(query);
var pageIndex = query.PageIndex <= 0 ? 1 : query.PageIndex;
var pageSize = query.PageSize <= 0 ? 20 : query.PageSize;
var tenant = ScopeTenantId;
var owner = ScopeOwnerCode;
// 注意:WhereIF(condition, sql, anonymousObject) 会在 condition 为 false 时仍对参数表达式求值,
// 因此不能在匿名对象里对可能为 null 的 query.OrderNo / query.BizType 直接调用 Trim()。
var dbQuery = Db.Queryable<TEntity>()
.Where(x => !x.IsDeleted && x.TenantId == tenant && x.OwnerCode == owner);
if (!string.IsNullOrWhiteSpace(query.OrderNo))
{
var pattern = $"%{query.OrderNo.Trim()}%";
dbQuery = dbQuery.Where("order_no LIKE @orderNo", new { orderNo = pattern });
}
if (!string.IsNullOrWhiteSpace(query.BizType))
{
var bizType = query.BizType!.Trim();
dbQuery = dbQuery.Where("biz_type = @bizType", new { bizType });
}
if (query.OrderStatus.HasValue)
{
var orderStatus = (int)query.OrderStatus.Value;
dbQuery = dbQuery.Where("order_status = @orderStatus", new { orderStatus });
}
RefAsync<int> total = 0;
var items = await dbQuery
.OrderByDescending(x => x.UpdateTime)
.OrderByDescending(x => x.CreateTime)
.ToPageListAsync(pageIndex, pageSize, total);
return new PagedResult<TEntity>
{
PageIndex = pageIndex,
PageSize = pageSize,
TotalCount = total,
Items = items
};
}
}
public abstract class OrderLineRepositoryBase<TEntity> : BaseRepository<TEntity>
where TEntity : BaseEntity, new()
{
protected OrderLineRepositoryBase(ISqlSugarClient db, ICurrentUserContext userContext) : base(db, userContext)
{
}
protected async Task<List<TEntity>> GetByOrderIdCoreAsync(long orderId)
{
return await Db.Queryable<TEntity>()
.Where(x => !x.IsDeleted)
.Where("order_id = @orderId", new { orderId })
.OrderBy("line_no")
.ToListAsync();
}
}
public class InboundOrderRepository : OrderRepositoryBase<InboundOrder, InboundOrderPagedQuery>, IInboundOrderRepository
{
public InboundOrderRepository(ISqlSugarClient db, ICurrentUserContext userContext) : base(db, userContext) { }
public Task<InboundOrder?> GetByOrderNoAsync(string tenantId, string ownerCode, string orderNo) => GetByOrderNoCoreAsync(tenantId, ownerCode, orderNo);
public Task<PagedResult<InboundOrder>> GetPagedListAsync(InboundOrderPagedQuery query) => GetPagedListCoreAsync(query);
public async Task<int> GetMaxDailySequenceInboundAsync(
string tenantId,
string ownerCode,
string orderPrefix,
string dateYyyyMmDd)
{
var tenant = tenantId.Trim();
var owner = ownerCode.Trim();
var prefix = orderPrefix.Trim();
var datePart = dateYyyyMmDd.Trim();
if (datePart.Length != 8 || prefix.Length == 0)
{
return 0;
}
var fullPrefix = $"{prefix}{datePart}";
var expectedLength = fullPrefix.Length + 5;
var nos = await Db.Queryable<InboundOrder>()
.Where(o => !o.IsDeleted && o.TenantId == tenant && o.OwnerCode == owner)
.Where(o => o.OrderNo.StartsWith(fullPrefix))
.Select(o => o.OrderNo)
.ToListAsync();
var max = 0;
foreach (var n in nos)
{
if (string.IsNullOrEmpty(n)
|| n.Length != expectedLength
|| !n.StartsWith(fullPrefix, StringComparison.Ordinal))
{
continue;
}
var tail = n.AsSpan(fullPrefix.Length);
if (tail.Length == 5
&& int.TryParse(tail, NumberStyles.None, CultureInfo.InvariantCulture, out var seq)
&& seq > max)
{
max = seq;
}
}
return max;
}
}
public class InboundOrderLineRepository : OrderLineRepositoryBase<InboundOrderLine>, IInboundOrderLineRepository
{
public InboundOrderLineRepository(ISqlSugarClient db, ICurrentUserContext userContext) : base(db, userContext) { }
public Task<List<InboundOrderLine>> GetByOrderIdAsync(long orderId) => GetByOrderIdCoreAsync(orderId);
}
public class OutboundOrderRepository : OrderRepositoryBase<OutboundOrder, OutboundOrderPagedQuery>, IOutboundOrderRepository
{
public OutboundOrderRepository(ISqlSugarClient db, ICurrentUserContext userContext) : base(db, userContext) { }
public Task<OutboundOrder?> GetByOrderNoAsync(string tenantId, string ownerCode, string orderNo) => GetByOrderNoCoreAsync(tenantId, ownerCode, orderNo);
public Task<PagedResult<OutboundOrder>> GetPagedListAsync(OutboundOrderPagedQuery query) => GetPagedListCoreAsync(query);
}
public class OutboundOrderLineRepository : OrderLineRepositoryBase<OutboundOrderLine>, IOutboundOrderLineRepository
{
public OutboundOrderLineRepository(ISqlSugarClient db, ICurrentUserContext userContext) : base(db, userContext) { }
public Task<List<OutboundOrderLine>> GetByOrderIdAsync(long orderId) => GetByOrderIdCoreAsync(orderId);
}
public class OutboundPickTaskRepository : OrderLineRepositoryBase<OutboundPickTask>, IOutboundPickTaskRepository
{
public OutboundPickTaskRepository(ISqlSugarClient db, ICurrentUserContext userContext) : base(db, userContext) { }
public async Task<List<OutboundPickTask>> GetByOrderIdAsync(long orderId)
{
return await Db.Queryable<OutboundPickTask>()
.Where(x => !x.IsDeleted && x.OrderId == orderId)
.OrderBy(x => x.TaskNo)
.ToListAsync();
}
public async Task<List<OutboundPickTask>> GetByOrderLineIdAsync(long orderLineId)
{
return await Db.Queryable<OutboundPickTask>()
.Where(x => !x.IsDeleted && x.OrderLineId == orderLineId)
.OrderBy(x => x.TaskNo)
.ToListAsync();
}
}
public class TransferOrderRepository : OrderRepositoryBase<TransferOrder, TransferOrderPagedQuery>, ITransferOrderRepository
{
public TransferOrderRepository(ISqlSugarClient db, ICurrentUserContext userContext) : base(db, userContext) { }
public Task<TransferOrder?> GetByOrderNoAsync(string tenantId, string ownerCode, string orderNo) => GetByOrderNoCoreAsync(tenantId, ownerCode, orderNo);
public Task<PagedResult<TransferOrder>> GetPagedListAsync(TransferOrderPagedQuery query) => GetPagedListCoreAsync(query);
}
public class TransferOrderLineRepository : OrderLineRepositoryBase<TransferOrderLine>, ITransferOrderLineRepository
{
public TransferOrderLineRepository(ISqlSugarClient db, ICurrentUserContext userContext) : base(db, userContext) { }
public Task<List<TransferOrderLine>> GetByOrderIdAsync(long orderId) => GetByOrderIdCoreAsync(orderId);
}
public class StocktakeOrderRepository : OrderRepositoryBase<StocktakeOrder, StocktakeOrderPagedQuery>, IStocktakeOrderRepository
{
public StocktakeOrderRepository(ISqlSugarClient db, ICurrentUserContext userContext) : base(db, userContext) { }
public Task<StocktakeOrder?> GetByOrderNoAsync(string tenantId, string ownerCode, string orderNo) => GetByOrderNoCoreAsync(tenantId, ownerCode, orderNo);
public Task<PagedResult<StocktakeOrder>> GetPagedListAsync(StocktakeOrderPagedQuery query) => GetPagedListCoreAsync(query);
}
public class StocktakeOrderLineRepository : OrderLineRepositoryBase<StocktakeOrderLine>, IStocktakeOrderLineRepository
{
public StocktakeOrderLineRepository(ISqlSugarClient db, ICurrentUserContext userContext) : base(db, userContext) { }
public Task<List<StocktakeOrderLine>> GetByOrderIdAsync(long orderId) => GetByOrderIdCoreAsync(orderId);
}