using System.Net;

using biblioteksentralen.Constants;

using biblioteksentralen.Extensions;

using biblioteksentralen.Handlers;

using biblioteksentralen.Helpers;

using biblioteksentralen.Interfaces;

using biblioteksentralen.Models.Netsuite.Inbound;

using biblioteksentralen.Models.Omnium.CustomProperties;

using Microsoft.Azure.Functions.Worker;

using Microsoft.Azure.Functions.Worker.Http;

using Microsoft.Extensions.Logging;

using Microsoft.Kiota.Abstractions;

using Omnium.Public.Contacts.Models;

using Omnium.Public.Customers.Models;

using Omnium.Public.Models;

using Omnium.Public.Orders.Models;

using Omnium.Public.Orders.Models.Patch;

using Omnium.Public.Payments.Models;

using Omnium.Public.Payments.Models.Patch;

using Omnium.Public.Shipments.Models;

using Omnium.Public.Shipments.Models.Patch;

​

namespace biblioteksentralen.Functions.NetsuiteFunctions;

​

public class UpsertOrder(ILogger<UpsertOrder> logger, IOmniumService omniumService, IMarcPostHandler marcPostHandler)

{

    [Function(nameof(UpsertOrder))]

    public async Task<HttpResponseData> Run(

        [HttpTrigger(AuthorizationLevel.Function, "post", Route = "api/UpsertOrder")] HttpRequestData req

    )

    {

        NetsuiteUpsertOrderDto? netsuiteUpsertOrderDto;

        try

        {

            string? message = await req.ReadAsStringAsync();

            if (message == null)

            {

                logger.LogError("Invalid format on request: {message}", message);

                return await req.CreateMessageResponseAsync(

                    HttpStatusCode.BadRequest,

                    "Error reading order upsert message"

                );

            }

​

            netsuiteUpsertOrderDto = JsonHelper.DeserializeWithOptions<NetsuiteUpsertOrderDto>(message);

        }

        catch (Exception ex)

        {

            logger.LogError(ex, "Error deserializing order upsert: {message}", ex.Message);

            return await req.CreateMessageResponseAsync(

                HttpStatusCode.BadRequest,

                "Error deserializing order upsert: " + ex.Message

            );

        }

​

        try

        {

            await HandleOmniumOrderUpsert(netsuiteUpsertOrderDto!);

        }

        catch (Exception ex)

        {

            logger.LogError(ex, "Error handling order upsert: {message}", ex.Message);

            return await req.CreateMessageResponseAsync(

                HttpStatusCode.InternalServerError,

                "Error handling order upsert: " + ex.Message

            );

        }

​

        return req.CreateResponse(HttpStatusCode.OK);

    }

    private async Task HandleOmniumOrderUpsert(NetsuiteUpsertOrderDto netsuiteUpsertOrderDto)

    {

        if (!ValidateOrder(netsuiteUpsertOrderDto, out var errorMessage))

        {

            throw new ArgumentException(errorMessage);

        }

​

        var customer = await omniumService.GetBusinessCustomer(netsuiteUpsertOrderDto.Body.CustomerId.ToString());

        if (customer == null)

        {

            throw new ApiException(

                $"Customer not found: {netsuiteUpsertOrderDto.Body.CustomerId} on order: {netsuiteUpsertOrderDto}"

            );

        }

​

        var newAddress = customer.Addresses.Find(a =>

            a.ExternalId.Equals(netsuiteUpsertOrderDto.Body.ShippingAddressId.ToString())

        );

        if (newAddress == null)

        {

            throw new ApiException(

                $"Shipping address not found: {netsuiteUpsertOrderDto.Body.ShippingAddressId} on order: {netsuiteUpsertOrderDto}"

            );

        }

​

        var freightLine = netsuiteUpsertOrderDto.Lines.Find(l => l.IsFreightCharge);

​

        if (netsuiteUpsertOrderDto is {  Source: OmniumConstants.OrderSource })

        {

            var (convertedOrderPatch, currentOrderStatus) = await ConvertToOmniumPatchOrder(

                netsuiteUpsertOrderDto,

                newAddress,

                freightLine,

                customer, 

                netsuiteUpsertOrderDto.OmniumOrderId);

            var patchedOrder = await omniumService.PatchOrder(convertedOrderPatch.Id, convertedOrderPatch);

            if (!convertedOrderPatch.Status.Equals(currentOrderStatus))

            {

                await omniumService.UpdateOrderStatus(convertedOrderPatch.Id, convertedOrderPatch.Status);

            }

        }

        // Order source is either NetSuite/Migrated/ehf and we need to check on transactionname if order is already created in Omnium

        else

        {

            if (await omniumService.OrderExists(netsuiteUpsertOrderDto.TransactionName))

            {

                var (convertedOrderPatch, currentOrderStatus) = await ConvertToOmniumPatchOrder(

                    netsuiteUpsertOrderDto,

                    newAddress, 

                    freightLine,

                    customer,

                    netsuiteUpsertOrderDto.TransactionName);

                var patchedOrder = await omniumService.PatchOrder(convertedOrderPatch.Id, convertedOrderPatch);

                if (!convertedOrderPatch.Status.Equals(currentOrderStatus))

                {

                    await omniumService.UpdateOrderStatus(convertedOrderPatch.Id, convertedOrderPatch.Status);

                }

            }

            else

            {

                var convertedOrder = ConvertToOmniumOrder(netsuiteUpsertOrderDto, newAddress, freightLine, netsuiteUpsertOrderDto.Source, customer);

                await omniumService.CreateOrder(convertedOrder);

                await marcPostHandler.Handle(convertedOrder, customer);

            }

        }

    }

​

​

    private OmniumOrderPatch ConvertToOmniumOrder(

        NetsuiteUpsertOrderDto netsuiteUpsertOrderDto,

        OmniumAddress? newAddress,

        NetsuiteUpsertOrderLineDto? netsuiteFreightLine,

        string orderSource,

        OmniumBusinessCustomer customer

    )

    {

        List<string> tags;

        if (netsuiteUpsertOrderDto.Source == "Ehf")

        {

            tags = [NetsuiteConstants.Tags.OrderOriginNetsuite, OmniumConstants.OrderIsEhf];

​

        }

        else

        {

            tags = [NetsuiteConstants.Tags.OrderOriginNetsuite];

        }

​

        var order = new OmniumOrderPatch();

        AddCommonProperties(order, customer, netsuiteUpsertOrderDto, orderSource, true);

        order.OrderForm = new OmniumOrderFormPatch()

        {

            Payments =

            [

                new OmniumPaymentPatch()

                {

                    Amount = netsuiteUpsertOrderDto

                        .Lines.Sum(l => l.Amount),

                    PaymentMethodName = "Invoice",

                    Status = "Processed",

                    TransactionType = "Invoiced",

                    TransactionId = Guid.NewGuid().ToString()

                }

            ],

        };

        var orderLines = new List<OmniumOrderLinePatch>();

        foreach (var netsuiteOrderLine in netsuiteUpsertOrderDto

                     .Lines.Where(l => !l.IsFreightCharge))

        {

            CreateNewOrderLineWithServices(netsuiteOrderLine, orderLines);

        }

        order.OrderForm.LineItems = orderLines;

        order.Tags = tags;

        order.Properties =

        [

            new OmniumPropertyItem { Key = "DepartmentName", Value = netsuiteUpsertOrderDto.Body.DepartmentName },

        ];

        AddShipment(order, netsuiteUpsertOrderDto, newAddress, netsuiteFreightLine, true, null);

        return order;

    }

​

    private async Task<(OmniumOrderPatch, string)> ConvertToOmniumPatchOrder(

        NetsuiteUpsertOrderDto netsuiteUpsertOrderDto,

        OmniumAddress? newAddress,

        NetsuiteUpsertOrderLineDto? netsuiteFreightLine,

        OmniumBusinessCustomer customer,

        string orderId

    )

    {

        var currentOrder = await omniumService.GetOmniumOrder(orderId);

        if (currentOrder == null)

        {

            throw new ApiException($"Order not found: {orderId}");

        }

​

        var currentOrderStatus = currentOrder.Status;

        var shipmentId = currentOrder.OrderForm.Shipments.FirstOrDefault()?.ShipmentId ?? Guid.NewGuid().ToString();

        AddCommonProperties(currentOrder, customer, netsuiteUpsertOrderDto, currentOrder.OrderOrigin, false);

        currentOrder.OrderForm.LineItems = await GetPatchOrderLines(currentOrder, netsuiteUpsertOrderDto, shipmentId);

        AddShipment(currentOrder, netsuiteUpsertOrderDto, newAddress, netsuiteFreightLine, false, shipmentId);

        if (currentOrder.OrderForm.Payments != null && currentOrder.OrderForm.Payments.Count > 0)

        {

            currentOrder.OrderForm.Payments[0].Amount = netsuiteUpsertOrderDto

                .Lines.Sum(l => l.Amount);

        }

        currentOrder.Properties =

        [

            new OmniumPropertyItem { Key = "DepartmentName", Value = netsuiteUpsertOrderDto.Body.DepartmentName },

        ];

​

        return (currentOrder, currentOrderStatus);

    }

​

    private void CreateNewOrderLineWithServices(NetsuiteUpsertOrderLineDto netsuiteOrderLine, IList<OmniumOrderLinePatch> orderLines)

    {

        decimal amountToSubtract = 0;

        if (netsuiteOrderLine.Lamination != null && netsuiteOrderLine.Lamination.Value)

        {

            amountToSubtract += netsuiteOrderLine.LaminationFeeNetPrice!.Value;

            orderLines.Add(new OmniumOrderLinePatch

            {

                ProductId = OmniumConstants.LaminationId,

                Code = OmniumConstants.LaminationId,

                Quantity = netsuiteOrderLine.OrderQuantity,

                DeliveredQuantity = netsuiteOrderLine.FulfilledQuantity,

                PlacedPrice = netsuiteOrderLine.LaminationFeeListPrice,

                Discounted = netsuiteOrderLine.LaminationFeeDiscounted,

                TaxRate = netsuiteOrderLine.TaxRate,

                LineItemId = Guid.NewGuid().ToString(),

                Comment = netsuiteOrderLine.Memo,

                Properties = GetOmniumLineItemProperties(netsuiteOrderLine),

                PackageLineItemId = netsuiteOrderLine.UniqueLineId

            });

        }

        if (netsuiteOrderLine.FiksFerdig != null && netsuiteOrderLine.FiksFerdig.Value)

        {

            amountToSubtract += netsuiteOrderLine.FiksFerdigFeeNetPrice!.Value;

            orderLines.Add(new OmniumOrderLinePatch

            {

                ProductId = OmniumConstants.FiksFerdigId,

                Code = OmniumConstants.FiksFerdigId,

                Quantity = netsuiteOrderLine.OrderQuantity,

                DeliveredQuantity = netsuiteOrderLine.FulfilledQuantity,

                PlacedPrice = netsuiteOrderLine.FiksFerdigFeeListPrice,

                Discounted = netsuiteOrderLine.FiksFerdigFeeDiscounted,

                TaxRate = netsuiteOrderLine.TaxRate,

                LineItemId = Guid.NewGuid().ToString(),

                Comment = netsuiteOrderLine.Memo,

                Properties = GetOmniumLineItemProperties(netsuiteOrderLine),

                PackageLineItemId = netsuiteOrderLine.UniqueLineId

            });

        }

        if (netsuiteOrderLine.NumberPrint != null && netsuiteOrderLine.NumberPrint.Value)

        {

            amountToSubtract += netsuiteOrderLine.NumberPrintFeeNetPrice!.Value;

            orderLines.Add(new OmniumOrderLinePatch

            {

                ProductId = OmniumConstants.NumberPrintId,

                Code = OmniumConstants.NumberPrintId,

                Quantity = netsuiteOrderLine.OrderQuantity,

                DeliveredQuantity = netsuiteOrderLine.FulfilledQuantity,

                PlacedPrice = netsuiteOrderLine.NumberPrintFeeListPrice,

                Discounted = netsuiteOrderLine.NumberPrintFeeDiscounted,

                TaxRate = netsuiteOrderLine.TaxRate,

                LineItemId = Guid.NewGuid().ToString(),

                Comment = netsuiteOrderLine.Memo,

                Properties = GetOmniumLineItemProperties(netsuiteOrderLine),

                PackageLineItemId = netsuiteOrderLine.UniqueLineId

            });

        }

        var orderLine = new OmniumOrderLinePatch

        {

            ProductId = netsuiteOrderLine.ExternalItemId,

            Code = netsuiteOrderLine.ExternalItemId,

            Quantity = netsuiteOrderLine.OrderQuantity,

            DeliveredQuantity = netsuiteOrderLine.FulfilledQuantity,

            PlacedPrice = netsuiteOrderLine.ListPrice,

            // Netsuite Price is a compound price so we need to subtract

            // the fees from the total amount when calculating discount

            Discounted = netsuiteOrderLine.OriginalAmount - amountToSubtract - netsuiteOrderLine.Amount,

            TaxRate = netsuiteOrderLine.TaxRate,

            LineItemId = netsuiteOrderLine.UniqueLineId,

            Comment = netsuiteOrderLine.Memo,

            Properties = GetOmniumLineItemProperties(netsuiteOrderLine)

        };

        orderLines.Add(orderLine);

    }

​

    private void AddCommonProperties(OmniumOrderPatch order, OmniumBusinessCustomer customer, NetsuiteUpsertOrderDto netsuiteUpsertOrderDto, string orderSource, bool isNewOrder)

    {

        if (!isNewOrder)

        {

            order.Id = netsuiteUpsertOrderDto.TransactionName;

            if (netsuiteUpsertOrderDto.Body.CreatedDate != null)

                order.Created = DateTime.Parse(netsuiteUpsertOrderDto.Body.CreatedDate);

        }

        order.IsReadOnly = true;

        order.OrderOrigin = orderSource;

        order.Status = netsuiteUpsertOrderDto.Status;

        order.BillingCurrency = "NOK";

        order.BillingAddress = GetBillingAddressFromCustomer(customer);

        order.CustomerId = netsuiteUpsertOrderDto.Body.CustomerId;

        order.CustomerName = customer.Name;

        order.CustomerEmail = customer.Email;

        order.ContactPerson = new OmniumContactPerson

        {

            Id = netsuiteUpsertOrderDto.Body.CustomerId,

            FirstName = netsuiteUpsertOrderDto.Body.CustomerContactNameFirst,

            LastName = netsuiteUpsertOrderDto.Body.CustomerContactNameLast,

            Email = netsuiteUpsertOrderDto.Body.CustomerContactEmail,

        };

        order.MarketId = GeneralHelper.GetMarketFromSubsidiaryId(netsuiteUpsertOrderDto.Body.NsSubsidiaryId);

        order.StoreId = GeneralHelper.GetStoreIdFromSubsidiary(netsuiteUpsertOrderDto.Body.NsSubsidiaryId);

        order.CustomerReference = netsuiteUpsertOrderDto.Body.Reference;

        order.CustomerRequisition = netsuiteUpsertOrderDto.Body.RequisitionNumber;

        order.OrderNotes = !string.IsNullOrWhiteSpace(netsuiteUpsertOrderDto.Body.Memo)

            ?

            [

                new OmniumComment

                {

                    Detail = netsuiteUpsertOrderDto.Body.Memo,

                    Creator = netsuiteUpsertOrderDto.Body.CustomerContactNameFirst + " " +

                              netsuiteUpsertOrderDto.Body.CustomerContactNameLast,

                },

            ]

            : null;

    }

​

    private void AddShipment(

        OmniumOrderPatch order,        

        NetsuiteUpsertOrderDto netsuiteUpsertOrderDto,

        OmniumAddress? address,

        NetsuiteUpsertOrderLineDto? netsuiteFreightLine,

        bool isNewOrder,

        string? shipmentId)

    {

        order.OrderForm.Shipments =

        [

            new OmniumShipmentPatch()

            {

                ShipmentId = isNewOrder &&  shipmentId != null ? shipmentId : Guid.NewGuid().ToString(),

                ShippingMethodId = "1",

                ShippingSubTotal = netsuiteFreightLine?.Amount ?? 0,

                ShippingMethodName = "Frakt",

                WarehouseCode = GeneralHelper.GetStoreIdFromSubsidiary(netsuiteUpsertOrderDto.Body.NsSubsidiaryId),

                Address = new OmniumOrderAddress()

                {

                    Name = address?.Name,

                    Line1 = address?.Line1,

                    Line2 = address?.Line2,

                    PostalCode = address?.PostalCode,

                    City = address?.City,

                    CountryCode = address?.CountryCode,

                    RegionName = address?.RegionName,

                    RegionCode = address?.RegionCode,

                    Email = address?.Email,

                    ExternalId = address?.ExternalId,

                },

                LineItems = order.OrderForm.LineItems,

            },

        ];

    }

​

    private async Task<List<OmniumOrderLinePatch>> GetPatchOrderLines(

        OmniumOrderPatch currentOrder,

        NetsuiteUpsertOrderDto updatedOrder,

        string shipmentId

    )

    {

        var changedLines = new List<OmniumOrderLinePatch>();

        foreach (var netsuiteOrderLine in updatedOrder.Lines)

        {

            if (netsuiteOrderLine.IsFreightCharge)

            {

                continue;

            }

            var currentLine = currentOrder.OrderForm.LineItems

                .Find(l => l.LineItemId == netsuiteOrderLine.UniqueLineId 

                           || l.LineItemId == netsuiteOrderLine.ExternalLineId);

            //Netsuite added new line

            if (currentLine == null)

            {

                var orderLinesToAdd = new List<OmniumOrderLinePatch>();

                CreateNewOrderLineWithServices(netsuiteOrderLine, orderLinesToAdd);

                await omniumService.AddOrderLines(

                    currentOrder.Id,

                    orderLinesToAdd,

                    shipmentId

                );

                continue;

            }

​

            // Line was cancelled earlier

            if (currentLine.CanceledDate != null)

            {

                continue;

            }

​

            // Line was cancelled now

            if (currentLine.CanceledDate == null && netsuiteOrderLine.OrderQuantity == 0)

            {

                var orderLinesToCancel = new List<OmniumOrderLinePatch>();

                CreateCancelledOrderLinesWithServices(currentOrder, currentLine, netsuiteOrderLine, changedLines, orderLinesToCancel);

                // Cancelling via api end point to trigger notification to customer

                await omniumService.CancelOrderLines(new OmniumOrderLineIdRequest

                {

                    OrderId = currentOrder.Id,

                    LineItemIds = orderLinesToCancel.Select(ol => ol.LineItemId).ToList(),

                });

                continue;

            }

​

            //Line updated or not

            if (currentLine != null)

            {

                var orderLinesToAdd = new List<OmniumOrderLinePatch>();

                CreateUpdatedLinesWithServices(currentOrder, netsuiteOrderLine, currentLine, changedLines, orderLinesToAdd);

                if (orderLinesToAdd.Count != 0)

                {

                    await omniumService.AddOrderLines(

                        currentOrder.Id,

                        orderLinesToAdd,

                        shipmentId

                    );

                }

            }

        }

​

        return changedLines;

    }

​

    private void CreateUpdatedLinesWithServices(

        OmniumOrderPatch currentOrder,

        NetsuiteUpsertOrderLineDto netsuiteOrderLine,

        OmniumOrderLinePatch currentLine,

        List<OmniumOrderLinePatch> changedLines,

        List<OmniumOrderLinePatch> orderLinesToAdd)

    {

        decimal amountToSubtract = 0;

        if (netsuiteOrderLine.Lamination != null && netsuiteOrderLine.Lamination.Value)

        {

            amountToSubtract += netsuiteOrderLine.LaminationFeeNetPrice!.Value;

            var laminationServiceLine = currentOrder.OrderForm.LineItems

                .FirstOrDefault(ol => 

                    ol.PackageLineItemId != null 

                    && ol.PackageLineItemId.Equals(currentLine.LineItemId)

                    && ol.ProductId.Equals(OmniumConstants.LaminationId));

            if (laminationServiceLine != null)

            {

                changedLines.Add(new OmniumOrderLinePatch

                {

                    ProductId = laminationServiceLine.ProductId,

                    Code = laminationServiceLine.Code,

                    Quantity = netsuiteOrderLine.OrderQuantity,

                    DeliveredQuantity = netsuiteOrderLine.FulfilledQuantity,

                    PlacedPrice = netsuiteOrderLine.LaminationFeeListPrice,

                    Discounted = netsuiteOrderLine.LaminationFeeDiscounted,

                    TaxRate = netsuiteOrderLine.TaxRate,

                    LineItemId = laminationServiceLine.LineItemId,

                    Comment = netsuiteOrderLine.Memo,

                    Properties = GetOmniumLineItemProperties(netsuiteOrderLine),

                    PackageLineItemId = currentLine.LineItemId

                });

            }

            else

            {

                orderLinesToAdd.Add(new OmniumOrderLinePatch

                {

                    ProductId = OmniumConstants.LaminationId,

                    Code = OmniumConstants.LaminationId,

                    Quantity = netsuiteOrderLine.OrderQuantity,

                    DeliveredQuantity = netsuiteOrderLine.FulfilledQuantity,

                    PlacedPrice = netsuiteOrderLine.LaminationFeeListPrice,

                    Discounted = netsuiteOrderLine.LaminationFeeDiscounted,

                    TaxRate = netsuiteOrderLine.TaxRate,

                    LineItemId = Guid.NewGuid().ToString(),

                    Comment = netsuiteOrderLine.Memo,

                    Properties = GetOmniumLineItemProperties(netsuiteOrderLine),

                    PackageLineItemId = currentLine.LineItemId

                });

            }

        }

        if (netsuiteOrderLine.FiksFerdig != null && netsuiteOrderLine.FiksFerdig.Value)

        {

            amountToSubtract += netsuiteOrderLine.FiksFerdigFeeNetPrice!.Value;

            var fiksFerdigServiceLine = currentOrder.OrderForm.LineItems

                .FirstOrDefault(ol => 

                    ol.PackageLineItemId != null 

                    && ol.PackageLineItemId.Equals(currentLine.LineItemId)

                    && ol.ProductId.Equals(OmniumConstants.FiksFerdigId));

            if (fiksFerdigServiceLine != null)

            {

                changedLines.Add(new OmniumOrderLinePatch

                {

                    ProductId = fiksFerdigServiceLine.ProductId,

                    Code = fiksFerdigServiceLine.Code,

                    Quantity = netsuiteOrderLine.OrderQuantity,

                    DeliveredQuantity = netsuiteOrderLine.FulfilledQuantity,

                    PlacedPrice = netsuiteOrderLine.FiksFerdigFeeListPrice,

                    Discounted = netsuiteOrderLine.FiksFerdigFeeDiscounted,

                    TaxRate = netsuiteOrderLine.TaxRate,

                    LineItemId = fiksFerdigServiceLine.LineItemId,

                    Comment = netsuiteOrderLine.Memo,

                    Properties = GetOmniumLineItemProperties(netsuiteOrderLine),

                    PackageLineItemId = currentLine.LineItemId

                });

            }

            else

            {

                orderLinesToAdd.Add(new OmniumOrderLinePatch

                {

                    ProductId = OmniumConstants.FiksFerdigId,

                    Code = OmniumConstants.FiksFerdigId,

                    Quantity = netsuiteOrderLine.OrderQuantity,

                    DeliveredQuantity = netsuiteOrderLine.FulfilledQuantity,

                    PlacedPrice = netsuiteOrderLine.FiksFerdigFeeListPrice,

                    Discounted = netsuiteOrderLine.FiksFerdigFeeDiscounted,

                    TaxRate = netsuiteOrderLine.TaxRate,

                    LineItemId = Guid.NewGuid().ToString(),

                    Comment = netsuiteOrderLine.Memo,

                    Properties = GetOmniumLineItemProperties(netsuiteOrderLine),

                    PackageLineItemId = currentLine.LineItemId

                });

            }

        }

        if (netsuiteOrderLine.NumberPrint != null && netsuiteOrderLine.NumberPrint.Value)

        {

            amountToSubtract += netsuiteOrderLine.NumberPrintFeeNetPrice!.Value;

            var fiksFerdigServiceLine = currentOrder.OrderForm.LineItems

                .FirstOrDefault(ol => 

                    ol.PackageLineItemId != null 

                    && ol.PackageLineItemId.Equals(currentLine.LineItemId)

                    && ol.ProductId.Equals(OmniumConstants.NumberPrintId));

            if (fiksFerdigServiceLine != null)

            {

                changedLines.Add(new OmniumOrderLinePatch

                {

                    ProductId = fiksFerdigServiceLine.ProductId,

                    Code = fiksFerdigServiceLine.Code,

                    Quantity = netsuiteOrderLine.OrderQuantity,

                    DeliveredQuantity = netsuiteOrderLine.FulfilledQuantity,

                    PlacedPrice = netsuiteOrderLine.NumberPrintFeeListPrice,

                    Discounted = netsuiteOrderLine.NumberPrintFeeDiscounted,

                    TaxRate = netsuiteOrderLine.TaxRate,

                    LineItemId = fiksFerdigServiceLine.LineItemId,

                    Comment = netsuiteOrderLine.Memo,

                    Properties = GetOmniumLineItemProperties(netsuiteOrderLine),

                    PackageLineItemId = currentLine.LineItemId

                });

            }

            else

            {

                orderLinesToAdd.Add(new OmniumOrderLinePatch

                {

                    ProductId = OmniumConstants.NumberPrintId,

                    Code = OmniumConstants.NumberPrintId,

                    Quantity = netsuiteOrderLine.OrderQuantity,

                    DeliveredQuantity = netsuiteOrderLine.FulfilledQuantity,

                    PlacedPrice = netsuiteOrderLine.NumberPrintFeeListPrice,

                    Discounted = netsuiteOrderLine.NumberPrintFeeDiscounted,

                    TaxRate = netsuiteOrderLine.TaxRate,

                    LineItemId = Guid.NewGuid().ToString(),

                    Comment = netsuiteOrderLine.Memo,

                    Properties = GetOmniumLineItemProperties(netsuiteOrderLine),

                    PackageLineItemId = currentLine.LineItemId

                });

            }

        }

        var orderLine = new OmniumOrderLinePatch

        {

            ProductId = currentLine.ProductId,

            Code = currentLine.Code,

            Quantity = netsuiteOrderLine.OrderQuantity,

            DeliveredQuantity = netsuiteOrderLine.FulfilledQuantity,

            PlacedPrice = netsuiteOrderLine.ListPrice,

            // Removing service fees from amount

            Discounted = netsuiteOrderLine.OriginalAmount - amountToSubtract - netsuiteOrderLine.Amount,

            TaxRate = netsuiteOrderLine.TaxRate,

            LineItemId = currentLine.LineItemId,

            Comment = netsuiteOrderLine.Memo,

            Properties = GetOmniumLineItemProperties(netsuiteOrderLine),

        };

        changedLines.Add(orderLine);

    }

​

    private void CreateCancelledOrderLinesWithServices(

        OmniumOrderPatch currentOrder,

        OmniumOrderLinePatch currentLine, 

        NetsuiteUpsertOrderLineDto netsuiteOrderLine, 

        List<OmniumOrderLinePatch> changedLines,

        List<OmniumOrderLinePatch> orderLinesToCancel)

    {

        var serviceLines  =

            currentOrder.OrderForm.LineItems.FindAll(ol => ol.PackageLineItemId != null && ol.PackageLineItemId.Equals(currentLine.LineItemId));

        decimal amountToSubract = 0;

        foreach (var serviceLine in serviceLines)

        {

            if (serviceLine.ProductId.Equals(OmniumConstants.LaminationId))

            {

                amountToSubract += netsuiteOrderLine.LaminationFeeNetPrice!.Value;

                changedLines.Add(new OmniumOrderLinePatch

                {

                    PlacedPrice = netsuiteOrderLine.LaminationFeeListPrice,

                    Discounted = netsuiteOrderLine.LaminationFeeDiscounted,

                    TaxRate = serviceLine.TaxRate,

                    ProductId = serviceLine.ProductId,

                    LineItemId = serviceLine.LineItemId,

                    Comment = serviceLine.Comment,

                    CanceledQuantity = serviceLine.Quantity,

                    CanceledDate = DateTime.UtcNow,

                    Properties = GetOmniumLineItemProperties(netsuiteOrderLine),

                });

            }

            if (serviceLine.ProductId.Equals(OmniumConstants.FiksFerdigId))

            {

                amountToSubract += netsuiteOrderLine.FiksFerdigFeeNetPrice!.Value;

                changedLines.Add(new OmniumOrderLinePatch

                {

                    PlacedPrice = netsuiteOrderLine.FiksFerdigFeeListPrice,

                    Discounted = netsuiteOrderLine.FiksFerdigFeeDiscounted,

                    TaxRate = serviceLine.TaxRate,

                    ProductId = serviceLine.ProductId,

                    LineItemId = serviceLine.LineItemId,

                    Comment = serviceLine.Comment,

                    CanceledQuantity = serviceLine.Quantity,

                    CanceledDate = DateTime.UtcNow,

                    Properties = GetOmniumLineItemProperties(netsuiteOrderLine),

                });

            }

            if (serviceLine.ProductId.Equals(OmniumConstants.NumberPrintId))

            {

                amountToSubract += netsuiteOrderLine.NumberPrintFeeNetPrice!.Value;

                changedLines.Add(new OmniumOrderLinePatch

                {

                    PlacedPrice = netsuiteOrderLine.NumberPrintFeeListPrice,

                    Discounted = netsuiteOrderLine.NumberPrintFeeDiscounted,

                    TaxRate = serviceLine.TaxRate,

                    ProductId = serviceLine.ProductId,

                    LineItemId = serviceLine.LineItemId,

                    Comment = serviceLine.Comment,

                    CanceledQuantity = serviceLine.Quantity,

                    CanceledDate = DateTime.UtcNow,

                    Properties = GetOmniumLineItemProperties(netsuiteOrderLine),

                });

            }

        }

​

        var orderLine = new OmniumOrderLinePatch

        {

            PlacedPrice = netsuiteOrderLine.ListPrice,

            Discounted = netsuiteOrderLine.OriginalAmount - amountToSubract - netsuiteOrderLine.Amount, // Removing service fees from amount

            TaxRate = currentLine.TaxRate,

            ProductId = currentLine.ProductId,

            LineItemId = currentLine.LineItemId,

            Comment = currentLine.Comment,

            CanceledQuantity = currentLine.Quantity,

            CanceledDate = DateTime.UtcNow,

            Properties = GetOmniumLineItemProperties(netsuiteOrderLine),

        };

        orderLinesToCancel.AddRange(serviceLines);

        orderLinesToCancel.Add(currentLine);

        changedLines.Add(orderLine);

    }

​

    private List<OmniumPropertyItem> GetOmniumLineItemProperties(NetsuiteUpsertOrderLineDto netsuiteUpsertOrderLineDto)

    {

        var list = new List<OmniumPropertyItem>();

        list.SetProperty(OrderLinePropertyKey.Location, netsuiteUpsertOrderLineDto.AllocationInfo?.Location);

        list.SetProperty(OrderLinePropertyKey.SupplierCode, netsuiteUpsertOrderLineDto.AllocationInfo?.SupplierCode);

        list.SetProperty(OrderLinePropertyKey.DepartmentName, netsuiteUpsertOrderLineDto.AllocationInfo?.DepartmentName);

        list.SetProperty(OrderLinePropertyKey.DepartmentCode, netsuiteUpsertOrderLineDto.AllocationInfo?.DepartmentCode);

        list.SetProperty(OrderLinePropertyKey.BudgetCode, netsuiteUpsertOrderLineDto.AllocationInfo?.BudgetCode);

        list.SetProperty(OrderLinePropertyKey.Shelf, netsuiteUpsertOrderLineDto.AllocationInfo?.ShelfLocation);

        list.SetProperty(OrderLinePropertyKey.LocalTitleId, netsuiteUpsertOrderLineDto.AllocationInfo?.LocalTitleId);

        list.SetProperty(OrderLinePropertyKey.BackorderQuantity, netsuiteUpsertOrderLineDto.BackorderQuantity.ToString());

        list.SetProperty(OrderLinePropertyKey.PickedQuantity, netsuiteUpsertOrderLineDto.PickedQuantity.ToString());

        list.SetProperty(OrderLinePropertyKey.PackedQuantity, netsuiteUpsertOrderLineDto.PackedQuantity.ToString());

        list.SetProperty(OrderLinePropertyKey.InvoicedQuantity, netsuiteUpsertOrderLineDto.InvoicedQuantity.ToString());

        return list;

​

    }

​

    private bool ValidateOrder(NetsuiteUpsertOrderDto netsuiteUpsertOrderDto, out string errorMessage)

    {

        if (netsuiteUpsertOrderDto.NsOrderId < 1)

        {

            errorMessage = "NsOrderId is required.";

            logger.LogError("NsOrderId is required: {order}", netsuiteUpsertOrderDto.ToString());

            return false;

        }

​

        if (string.IsNullOrWhiteSpace(netsuiteUpsertOrderDto.Body.CustomerId))

        {

            errorMessage = "CustomerId is required.";

            logger.LogError("CustomerId is required: {order}", netsuiteUpsertOrderDto.ToString());

            return false;

        }

​

        if (netsuiteUpsertOrderDto.Body.ShippingAddressId < 1)

        {

            errorMessage = "ShippingAddressId is required.";

            logger.LogError("ShippingAddressId is required: {order}", netsuiteUpsertOrderDto.ToString());

            return false;

        }

​

        if (string.IsNullOrWhiteSpace(netsuiteUpsertOrderDto.Context))

        {

            errorMessage = "Context is required.";

            logger.LogError("Context is required: {order}", netsuiteUpsertOrderDto.ToString());

            return false;

        }

​

        if (netsuiteUpsertOrderDto.Body.NsSubsidiaryId < 1)

        {

            errorMessage = "NsSubsidiaryId is required.";

            logger.LogError("NsSubsidiaryId is required: {order}", netsuiteUpsertOrderDto.ToString());

            return false;

        }

​

        if (netsuiteUpsertOrderDto.Lines.Count == 0)

        {

            errorMessage = "Order must have at least one line.";

            logger.LogError("Order must have at least one line: {order}", netsuiteUpsertOrderDto.ToString());

            return false;

        }

​

        if (netsuiteUpsertOrderDto.Lines.Exists(l => string.IsNullOrWhiteSpace(l.UniqueLineId)))

        {

            errorMessage = "UniqueLineId is required for all lines.";

            logger.LogError("UniqueLineId is required for all lines: {order}", netsuiteUpsertOrderDto.ToString());

            return false;

        }

​

        errorMessage = "";

​

        return true;

    }

    private static OmniumOrderAddress GetBillingAddressFromCustomer(OmniumBusinessCustomer customer)

    {

        var billingAddress = customer.Addresses.FirstOrDefault(a => a.Purposes.Contains(OmniumConstants.BillingAddressType));

        if (billingAddress == null)

        {

            throw new Exception("Billing address not found for customer: " + customer.CustomerId);

        }

​

        var convertedBillingAddress = new OmniumOrderAddress

        {

            Name = billingAddress.Name,

            Line1 = billingAddress.Line1,

            City = billingAddress.City,

            PostalCode = billingAddress.PostalCode,

            ExternalId = billingAddress.ExternalId,

            RegionName = billingAddress.RegionName,

        };

        return convertedBillingAddress;

    }

}

​