admin/src/Oms.SqlSugarCore/Orders/OrderRepository.cs

using Fake.DependencyInjection;
using Oms.Domain.OrdersAggregate.Entities;
using Oms.Domain.OrdersAggregate.Repositories;
using Oms.SqlSugarCore.Repositories;

namespace Oms.SqlSugarCore.Orders;

public class OrderRepository : OmsSqlSugarRepository<Order>, IOrderRepository, IScopedDependency
{
    public Task<Order?> GetByServiceNoAsync(string serviceNo, CancellationToken cancellationToken = default)
    {
        return FirstOrDefaultAsync(x => x.ServiceNo == serviceNo, cancellationToken);
    }

    public Task<bool> HasServiceNoAsync(string serviceNo, CancellationToken cancellationToken = default)
    {
        return AnyAsync(x => x.ServiceNo == serviceNo, cancellationToken);
    }

    public Task<Order?> GetByTrackNoAsync(string trackNo, CancellationToken cancellationToken = default)
    {
        return FirstOrDefaultAsync(x => x.TrackNo == trackNo, cancellationToken);
    }

    public Task<Order?> GetByCustomerAndClientNoAsync(int customerId, string clientNo, CancellationToken cancellationToken = default)
    {
        return FirstOrDefaultAsync(x => x.CustomerId == customerId && x.ClientNo == clientNo, cancellationToken);
    }

    public Task<Order?> GetByRequestIdAsync(string requestId, CancellationToken cancellationToken = default)
    {
        return FirstOrDefaultAsync(x => x.RequestId == requestId, cancellationToken);
    }

    public async Task<List<OrderSender>> GetSendersByOrderIdsAsync(IEnumerable<int> orderIds, CancellationToken cancellationToken = default)
    {
        var ids = orderIds.Distinct().ToArray();
        if (ids.Length == 0)
        {
            return [];
        }

        var db = await GetDbContextAsync(cancellationToken);
        return await db.Queryable<OrderSender>()
            .Where(x => ids.Contains(x.OrderId))
            .ToListAsync(cancellationToken);
    }

    public async Task<List<OrderRecipient>> GetRecipientsByOrderIdsAsync(IEnumerable<int> orderIds, CancellationToken cancellationToken = default)
    {
        var ids = orderIds.Distinct().ToArray();
        if (ids.Length == 0)
        {
            return [];
        }

        var db = await GetDbContextAsync(cancellationToken);
        return await db.Queryable<OrderRecipient>()
            .Where(x => ids.Contains(x.OrderId))
            .ToListAsync(cancellationToken);
    }

    public async Task<List<OrderDeclaration>> GetDeclarationsByOrderIdsAsync(IEnumerable<int> orderIds, CancellationToken cancellationToken = default)
    {
        var ids = orderIds.Distinct().ToArray();
        if (ids.Length == 0)
        {
            return [];
        }

        var db = await GetDbContextAsync(cancellationToken);
        return await db.Queryable<OrderDeclaration>()
            .Where(x => ids.Contains(x.OrderId))
            .ToListAsync(cancellationToken);
    }

    public async Task<List<OrderWeight>> GetWeightsByOrderIdsAsync(IEnumerable<int> orderIds, CancellationToken cancellationToken = default)
    {
        var ids = orderIds.Distinct().ToArray();
        if (ids.Length == 0)
        {
            return [];
        }

        var db = await GetDbContextAsync(cancellationToken);
        return await db.Queryable<OrderWeight>()
            .Where(x => ids.Contains(x.OrderId))
            .ToListAsync(cancellationToken);
    }

    public async Task<OrderSender> InsertSenderAsync(OrderSender sender, CancellationToken cancellationToken = default)
    {
        var db = await GetDbContextAsync(cancellationToken);
        return await db.Insertable(sender).ExecuteReturnEntityAsync();
    }

    public async Task<OrderRecipient> InsertRecipientAsync(OrderRecipient recipient, CancellationToken cancellationToken = default)
    {
        var db = await GetDbContextAsync(cancellationToken);
        return await db.Insertable(recipient).ExecuteReturnEntityAsync();
    }

    public async Task InsertDeclarationsAsync(IEnumerable<OrderDeclaration> declarations, CancellationToken cancellationToken = default)
    {
        var items = declarations.ToArray();
        if (items.Length == 0)
        {
            return;
        }

        var db = await GetDbContextAsync(cancellationToken);
        await db.Insertable(items).ExecuteCommandAsync(cancellationToken);
    }

    public async Task InsertWeightsAsync(IEnumerable<OrderWeight> weights, CancellationToken cancellationToken = default)
    {
        var items = weights.ToArray();
        if (items.Length == 0)
        {
            return;
        }

        var db = await GetDbContextAsync(cancellationToken);
        await db.Insertable(items).ExecuteCommandAsync(cancellationToken);
    }
}