FA_WEB/SytelineSaAppEfDataModel/Services/EdiCustomerOrderService.cs

using AutoMapper;
using Microsoft.Data.SqlClient;
using Microsoft.EntityFrameworkCore;
using System.Data;
using SytelineSaAppEfDataModel.Dtos;
using SytelineSaAppEfDataModel.Entities;

namespace SytelineSaAppEfDataModel.Services
{
    public class EdiCustomerOrderService(SytelineSaAppDbContext context, IMapper mapper) : IEdiCustomerOrderService
    {
        public async Task<int> GetLastOrderNumber()
        {
            var lastOrderNumber =
                (await context.EdiCustomerOrders.OrderByDescending(x => x.CustomerOrderNumber).FirstOrDefaultAsync())
                ?.CustomerOrderNumber[3..] ?? "0";

            return int.Parse(lastOrderNumber);
        }

        public async Task<IEnumerable<EdiCustomerOrderDto>> GetAll()
        {
            IList<EdiCustomerOrderTranslateDto> ediCustomerOrderTranslates = await context.EdiCustomerOrderTranslates
                .Select(x => mapper.Map<EdiCustomerOrderTranslateDto>(x)).ToListAsync();

            IList<EdiCustomerOrderDto> ediCustomerOrders =
                await context.EdiCustomerOrders.Select(x => mapper.Map<EdiCustomerOrderDto>(x)).ToListAsync();

            IDictionary<string, List<EdiCustomerOrderTranslateDto>> ediTranslatesByCoNumber = ediCustomerOrderTranslates
                .GroupBy(x => x.EdiCoCoNum).ToDictionary(x => x.Key, y => y.ToList());

            foreach (EdiCustomerOrderDto ediCustomerOrder in ediCustomerOrders)
            {
                if (!ediTranslatesByCoNumber.TryGetValue(ediCustomerOrder.CustomerOrderNumber,
                        out List<EdiCustomerOrderTranslateDto>? customerOrderTranslates)) continue;

                customerOrderTranslates = customerOrderTranslates.OrderByDescending(x => x.CreatedDate).ToList();
                ediCustomerOrder.EdiCustomerOrderTranslates = customerOrderTranslates;
            }

            return ediCustomerOrders;
        }

        public async Task<IEnumerable<EdiCustomerOrderDto?>> GetByDate(DateTime date)
        {
            IList<EdiCustomerOrderDto?> customerOrders = new List<EdiCustomerOrderDto?>();

            IList<Guid> orderNumbers = await context.EdiCustomerOrders.Where(x => x.CreateDate > date)
                .Select(x => x.RowPointer).ToListAsync();

            foreach (Guid orderNumber in orderNumbers)
            {
                customerOrders.Add(await GetByOrderNumber(orderNumber));
            }

            return customerOrders;
        }

        public async Task<EdiCustomerOrderDto?> GetByOrderNumber(Guid customerOrderNumber)
        {
            EdiCustomerOrderDto ediCustomerOrder = mapper.Map<EdiCustomerOrderDto>(
                await context.EdiCustomerOrders.FirstOrDefaultAsync(x => x.RowPointer == customerOrderNumber));

            if (ediCustomerOrder == null)
            {
                return null;
            }

            IList<EdiCustomerOrderLineDto> ediCustomerOrderLines = await context.EdiCustomerOrderLines
                .Where(x => x.CustomerOrderNumber == ediCustomerOrder.CustomerOrderNumber)
                .Select(x => mapper.Map<EdiCustomerOrderLineDto>(x)).ToListAsync();

            foreach (EdiCustomerOrderLineDto ediCustomerOrderLine in ediCustomerOrderLines)
            {
                ediCustomerOrderLine.EdiCustomerOrderLineItems = await context.EdiCustomerOrderLineItems
                    .Where(x => x.CustomerOrderNumber == ediCustomerOrder.CustomerOrderNumber &&
                                x.CustomerOrderLine == ediCustomerOrderLine.CustomerOrderLine)
                    .Select(x => mapper.Map<EdiCustomerOrderLineItemDto>(x)).ToListAsync();
            }

            IList<EdiCustomerOrderTranslateDto> ediCustomerOrderTranslates = await context.EdiCustomerOrderTranslates
                .Where(x => x.EdiCoCoNum == ediCustomerOrder.CustomerOrderNumber)
                .Select(x => mapper.Map<EdiCustomerOrderTranslateDto>(x)).ToListAsync();

            ediCustomerOrder.EdiCustomerOrderLines = ediCustomerOrderLines;
            ediCustomerOrder.EdiCustomerOrderTranslates = ediCustomerOrderTranslates;

            return ediCustomerOrder;
        }

        public async Task<IEnumerable<EdiCustomerOrderTranslateDto>> FindMissingOrders(DateTime startDate)
        {
            IList<EdiCustomerOrderTranslate> ediCustomerOrderTranslates = await context.EdiCustomerOrderTranslates
                .Where(x => x.CreatedDate >= startDate).ToListAsync();

            var ediOrderNumbers = ediCustomerOrderTranslates.Select(x => x.EdiCoCoNum).ToList();
            var ediOrderNumbersFromEdiCo = (await context.EdiCustomerOrders.ToListAsync())
                .Where(x => ediOrderNumbers.Contains(x.CustomerOrderNumber)).Select(x => x.CustomerOrderNumber)
                .ToList();

            ISet<string> missingNumbers = ediOrderNumbers.Except(ediOrderNumbersFromEdiCo).ToHashSet();

            IEnumerable<EdiCustomerOrderTranslateDto> missingOrders =
                (await context.EdiCustomerOrderTranslates.ToListAsync())
                .Where(x => missingNumbers.Contains(x.EdiCoCoNum)).Select(mapper.Map<EdiCustomerOrderTranslateDto>);

            return missingOrders;
        }

        public async Task<int> SendOrderToSyteline(Guid customerOrderNumber)
        {
            EdiCustomerOrder? ediCustomerOrder =
                await context.EdiCustomerOrders.FirstOrDefaultAsync(x => x.RowPointer == customerOrderNumber);

            if (ediCustomerOrder == null) return 0;

            var ediCoNum = new SqlParameter("@PEdiCoNum", SqlDbType.NVarChar, 50)
                { Value = ediCustomerOrder.CustomerOrderNumber };
            var ediCoCount = new SqlParameter("@PEdiCoCount", SqlDbType.Int)
                { Value = 0, Direction = ParameterDirection.Output };
            var postedCount = new SqlParameter("@PPostedCount", SqlDbType.Int)
                { Value = 0, Direction = ParameterDirection.Output };
            var infoBar = new SqlParameter("@Infobar", SqlDbType.NVarChar, 2800)
                { Value = "", Direction = ParameterDirection.Output };
            var autoPost = new SqlParameter("@AutoPost", SqlDbType.Int) { Value = 0 };
            var processId = new SqlParameter("@ProcessId", SqlDbType.Int) { Value = 423456 };

            await context.Database.ExecuteSqlRawAsync(
                "EXEC [dbo].[FKR_EDI_EXTGEN_EdiInOrderPSp] @PEdiCoNum, @PEdiCoCount OUT, @PPostedCount OUT, @Infobar OUT, @AutoPost, @ProcessId",
                ediCoNum, ediCoCount, postedCount, infoBar, autoPost, processId);

            string? infoBarResult = infoBar.Value?.ToString();
            int ediCoCountResult = Convert.ToInt32(ediCoCount.Value);
            int postedCountResult = Convert.ToInt32(postedCount.Value);

            Console.WriteLine($"EDI Co Num: {infoBarResult}");
            Console.WriteLine($"EDI Co Count: {ediCoCountResult}");
            Console.WriteLine($"Posted Count: {postedCountResult}");

            return postedCountResult;
        }

        public async Task<(bool, string)> SaveOrdersWithDetails(List<EdiCustomerOrderDto> ediCustomerOrders)
        {
            if (ediCustomerOrders.Count == 0)
            {
                return (false, string.Empty);
            }

            try
            {
                await context.EdiCustomerOrders.AddRangeAsync(ediCustomerOrders.Select(mapper.Map<EdiCustomerOrder>));
                await context.EdiCustomerOrderLines.AddRangeAsync(ediCustomerOrders
                    .SelectMany(x => x.EdiCustomerOrderLines)
                    .Select(mapper.Map<EdiCustomerOrderLine>));
                await context.EdiCustomerOrderLineItems.AddRangeAsync(ediCustomerOrders
                    .SelectMany(x => x.EdiCustomerOrderLines)
                    .SelectMany(y => y.EdiCustomerOrderLineItems).Select(mapper.Map<EdiCustomerOrderLineItem>));
                await context.EdiCustomerOrderTranslates.AddRangeAsync(ediCustomerOrders
                    .SelectMany(x => x.EdiCustomerOrderTranslates)
                    .Select(mapper.Map<EdiCustomerOrderTranslate>));
                await context.SaveChangesAsync();
                return (true, string.Empty);
            }
            catch (Exception ex)
            {
                return (false, ex.Message);
            }
        }
    }
}