prs/prs.shared/Posters/Timberline/PurchaseOrderTimberlinePoster.cs

using Comal.Classes;
using CsvHelper.Configuration.Attributes;
using CsvHelper;
using InABox.Core.Postable;
using InABox.Core;
using InABox.Poster.Timberline;
using InABox.Scripting;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Win32;
using CsvHelper.TypeConversion;
using CsvHelper.Configuration;
using System.Reflection;
using System.Windows;
using PRSDimensionUtils;
using InABox.Clients;
using InABox.Wpf;

namespace PRS.Shared
{
    public enum PurchaseOrderTimberlineCommitmentType
    {
        Subcontract = 1,
        PO = 2
    }

    public class POTimberlineCommitmentTypeConverter : DefaultTypeConverter
    {
        public override object? ConvertFromString(string? text, IReaderRow row, MemberMapData memberMapData)
        {
            if(Enum.TryParse<PurchaseOrderTimberlineCommitmentType>(text, out var type))
            {
                return type;
            }
            return base.ConvertFromString(text, row, memberMapData);
        }

        public override string? ConvertToString(object? value, IWriterRow row, MemberMapData memberMapData)
        {
            if(value is PurchaseOrderTimberlineCommitmentType type)
            {
                return ((int)type).ToString();
            }
            return "";
        }
    }

    public class PurchaseOrderTimberlineHeader
    {
        [Ignore]
        public List<PurchaseOrderTimberlineLine> Lines { get; set; } = new();

        [Index(0)]
        public string RecordID { get; set; } = "C";

        [Index(1)]
        [TypeConverter(typeof(TimberlinePosterStringConverter), 12)]
        public string CommitmentID { get; set; }

        [Index(2)]
        [TypeConverter(typeof(POTimberlineCommitmentTypeConverter))]
        public PurchaseOrderTimberlineCommitmentType CommitmentType { get; set; }

        [Index(3)]
        [TypeConverter(typeof(TimberlinePosterStringConverter), 30)]
        public string Description { get; set; }

        [Index(4)]
        [TypeConverter(typeof(TimberlinePosterStringConverter), 10)]
        public string VendorID { get; set; }

        [Index(5)]
        [TypeConverter(typeof(TimberlinePosterDateConverter))]
        public DateTime Date { get; set; }

        [Index(6)]
        public double RetainagePercent { get; set; }

        [Index(7)]
        public bool CommittedToJC { get; set; }

        [Index(8)]
        public bool Closed { get; set; }

        [Index(9)]
        public bool Printed { get; set; }

        /// <summary>
        /// Dictionary of extra fields to write; the key is the 0-based index of the column in which we are writing.
        /// If the index is that of any of the explicit fields of this class, nothing happens.
        /// </summary>
        [Ignore]
        public Dictionary<int, string> AdditionalFields { get; set; } = new();
    }

    public class PurchaseOrderTimberlineLine
    {
        [Index(0)]
        public string RecordID { get; set; } = "CI";

        [Index(1)]
        [TypeConverter(typeof(TimberlinePosterStringConverter), 12)]
        public string CommitmentID { get; set; }

        [Index(2)]
        public int ItemNumber { get; set; }

        [Index(3)]
        [TypeConverter(typeof(TimberlinePosterStringConverter), 30)]
        public string Description { get; set; }

        [Index(4)]
        public double RetainagePercent { get; set; }

        [Index(5)]
        [TypeConverter(typeof(TimberlinePosterDateConverter))]
        public DateTime DeliveryDate { get; set; }

        [Index(6)]
        [TypeConverter(typeof(TimberlinePosterStringConverter), 1000)]
        public string ScopeOfWork { get; set; }

        [Index(7)]
        [TypeConverter(typeof(TimberlinePosterStringConverter), 10)]
        public string Job { get; set; }

        [Index(8)]
        [TypeConverter(typeof(TimberlinePosterStringConverter), 10)]
        public string Extra { get; set; }

        [Index(9)]
        [TypeConverter(typeof(TimberlinePosterStringConverter), 12)]
        public string CostCode { get; set; }

        [Index(10)]
        [TypeConverter(typeof(TimberlinePosterStringConverter), 3)]
        public string Category { get; set; }

        [Index(11)]
        [TypeConverter(typeof(TimberlinePosterStringConverter), 6)]
        public string TaxGroup { get; set; }

        [Index(12)]
        public string Tax { get; set; }

        [Index(13)]
        public double Units { get; set; }

        [Index(14)]
        public double UnitCost { get; set; }

        [Index(15)]
        [TypeConverter(typeof(TimberlinePosterStringConverter), 6)]
        public string UnitDescription { get; set; }

        [Index(16)]
        public double Amount { get; set; }

        [Index(17)]
        public bool BoughtOut { get; set; }

        /// <summary>
        /// Dictionary of extra fields to write; the key is the 0-based index of the column in which we are writing.
        /// If the index is that of any of the explicit fields of this class, nothing happens.
        /// </summary>
        [Ignore]
        public Dictionary<int, string> AdditionalFields { get; set; } = new();
    }

    public class PurchaseOrderTimberlineSettings : TimberlinePosterSettings<PurchaseOrder>
    {
        protected override string DefaultScript()
        {
            return @"
using PRS.Shared;
using InABox.Core;
using System.Collections.Generic;

public class Module
{
    public void BeforePost(IDataModel<PurchaseOrder> model)
    {
        // Perform pre-processing
    }

    public void ProcessHeader(IDataModel<PurchaseOrder> model, PurchaseOrder purchaseOrder, PurchaseOrderTimberlineHeader header)
    {
        // Do extra processing for a purchase order; return false to fail this purchase order
        return true;
    }

    public void ProcessLine(IDataModel<PurchaseOrder> model, PurchaseOrderItem purchaseOrderItem, PurchaseOrderItemAllocation? allocation, PurchaseOrderTimberlineLine line)
    {
        // Do extra processing for a purchase order line; return false to fail this purchase order
        return true;
    }

    public void AfterPost(IDataModel<PurchaseOrder> model)
    {
        // Perform post-processing
    }
}";
        }
    }

    public class PurchaseOrderTimberlineResult : TimberlinePostResult<PurchaseOrderTimberlineHeader, PurchaseOrder>
    {
    }

    public class PurchaseOrderTimberlinePoster : ITimberlinePoster<PurchaseOrder, PurchaseOrderTimberlineSettings>
    {
        public ScriptDocument? Script { get; set; }
        public PurchaseOrderTimberlineSettings Settings { get; set; }

        public bool BeforePost(IDataModel<PurchaseOrder> model)
        {
            model.SetIsDefault<Document>(false, alias: "CompanyLogo");
            model.SetIsDefault<CoreTable>(false, alias: "CompanyInformation");
            model.SetIsDefault<Employee>(false);

            model.SetIsDefault<PurchaseOrderItem>(true, alias: "PurchaseOrder_PurchaseOrderItem");

            model.SetColumns(Columns.None<PurchaseOrder>().Add(x => x.ID)
                .Add(x => x.PONumber)
                .Add(x => x.Description)
                .Add(x => x.SupplierLink.Code)
                .Add(x => x.IssuedDate)
                .Add(x => x.ClosedDate));
            model.SetColumns(Columns.None<PurchaseOrderItem>().Add(x => x.ID)
                .Add(x => x.PurchaseOrderLink.ID)
                .Add(x => x.PostedReference)
                .Add(x => x.Description)
                .Add(x => x.ReceivedDate)
                .Add(x => x.CostCentre.Code)
                .Add(x => x.TaxCode.Code)
                .Add(x => x.Qty)
                .Add(x => x.Cost)
                .Add(x => x.IncTax)
                .Add(x => x.Job.JobNumber)
                .AddDimensionsColumns(x => x.Dimensions, Dimensions.ColumnsType.Data),
                alias: "PurchaseOrder_PurchaseOrderItem");

            model.AddChildTable<PurchaseOrderItem, PurchaseOrderItemAllocation>(x => x.ID, x => x.Item.ID,
                isdefault: true,
                columns: Columns.None<PurchaseOrderItemAllocation>()
                    .Add(x => x.ID)
                    .Add(x => x.PostedReference)
                    .Add(x => x.Item.ID)
                    .Add(x => x.Quantity)
                    .Add(x => x.Job.JobNumber),
                parentalias: "PurchaseOrder_PurchaseOrderItem", childalias: "Allocations");

            Script?.Execute(methodname: "BeforePost", parameters: new object[] { model });
            return true;
        }

        private bool ProcessHeader(IDataModel<PurchaseOrder> model, PurchaseOrder purchaseOrder, PurchaseOrderTimberlineHeader header)
        {
            return Script?.Execute(methodname: "ProcessHeader", parameters: new object[] { model, purchaseOrder, header }) != false;
        }
        private bool ProcessLine(IDataModel<PurchaseOrder> model, PurchaseOrderItem purchaseOrderItem, PurchaseOrderItemAllocation? allocation, PurchaseOrderTimberlineLine line)
        {
            return Script?.Execute(methodname: "ProcessLine", parameters: new object?[] { model, purchaseOrderItem, allocation, line }) != false;
        }

        private class LineData(PurchaseOrderItem poItem, double poCost, double poQty, StockDimensions poDim, IPostableFragment<PurchaseOrder> item, double qty)
        {
            public PurchaseOrderItem POItem { get; set; } = poItem;

            public double POCost { get; set; } = poCost;

            public double POQty { get; set; } = poQty;

            public StockDimensions PODimensions { get; set; } = poDim;

            public IPostableFragment<PurchaseOrder> Item { get; set; } = item;

            public double Qty { get; set; } = qty;
        }

        private PurchaseOrderTimberlineResult DoProcess(IDataModel<PurchaseOrder> model)
        {
            var cs = new PurchaseOrderTimberlineResult();

            var lines = model.GetTable<PurchaseOrderItem>("PurchaseOrder_PurchaseOrderItem").ToObjects<PurchaseOrderItem>()
                .GroupBy(x => x.PurchaseOrderLink.ID).ToDictionary(x => x.Key, x => x.ToList());
            var allocations = model.GetTable<PurchaseOrderItemAllocation>("Allocations")
                .ToObjects<PurchaseOrderItemAllocation>()
                .GroupBy(x => x.Item.ID).ToDictionary(x => x.Key, x => x.ToList());
            foreach (var purchaseOrder in model.GetTable<PurchaseOrder>().ToObjects<PurchaseOrder>())
            {
                var c = new PurchaseOrderTimberlineHeader
                {
                    CommitmentID = purchaseOrder.PONumber,
                    CommitmentType = PurchaseOrderTimberlineCommitmentType.PO,
                    Description = purchaseOrder.Description,
                    VendorID = purchaseOrder.SupplierLink.Code,
                    Date = purchaseOrder.IssuedDate,
                    // RetainagePercent
                    // Committed to JC
                    Closed = purchaseOrder.ClosedDate != DateTime.MinValue,
                    // Printed
                };
                if(!ProcessHeader(model, purchaseOrder, c))
                {
                    cs.AddFailed(purchaseOrder, "Failed by script.");
                }
                else
                {
                    // Hashset of line numbers.
                    var items = new HashSet<int>();
                    var POItems = lines.GetValueOrDefault(purchaseOrder.ID)?.ToList() ?? new List<PurchaseOrderItem>();

                    var lineData = new List<LineData>();

                    // Get the data for all the lines.
                    foreach(var poItem in POItems)
                    {
                        // First, we must convert the dimensions and qty on the POItem to match the "exploded" allocations. Note we need to make copies,
                        // because we will be saving this poItem later on.
                        var dimensions = poItem.Dimensions.Copy();
                        var qty = DimensionUtils.ConvertDimensions(dimensions, poItem.Qty, Client<ProductDimensionUnit>.Provider);
                        var poCost = poItem.Cost;
                        var poQty = poItem.Qty;
                        if (!qty.IsEffectivelyEqual(poItem.Qty))
                        {
                            poCost = poItem.Cost * poItem.Qty / (qty.IsEffectivelyEqual(0.0) ? 1.0 : qty);
                            poQty = qty;
                        }

                        if(!allocations.TryGetValue(poItem.ID, out var poias))
                        {
                            poias = new();
                        }
                        var remQty = poItem.Qty - poias.Sum(x => x.Quantity);

                        if(remQty != 0)
                        {
                            lineData.Add(new(poItem, poCost, poQty, dimensions, poItem, remQty));
                        }
                        foreach(var poia in poias)
                        {
                            lineData.Add(new(poItem, poCost, poQty, dimensions, poia, poia.Quantity));
                        }
                    }

                    // Check line numbers.
                    foreach(var data in lineData)
                    {
                        if (int.TryParse(data.Item.PostedReference, out var itemNumber))
                        {
                            if (!items.Add(itemNumber))
                            {
                                // Theoretically shouldn't happen, but just in case.
                                MessageWindow.Warn(
                                    $"Warning: Multiple PurchaseOrder Items have the same line number for export; the line number for '{data.POItem.Description}' will be changed in the export.");
                                Logger.Send(LogType.Error, "", $"Purchase Order Post: Multiple POItems with the same Line Number; changing line number of POItem {(data.Item as Entity)!.ID}");

                                data.Item.PostedReference = "";
                            }
                        }
                    }

                    // Do post.
                    var success = true;
                    foreach(var data in lineData)
                    {
                        if (!int.TryParse(data.Item.PostedReference, out var itemNumber))
                        {
                            itemNumber = 1;
                            while (items.Contains(itemNumber))
                            {
                                ++itemNumber;
                            }

                            items.Add(itemNumber);
                            data.Item.PostedReference = itemNumber.ToString();
                        }
                        var ci = new PurchaseOrderTimberlineLine
                        {
                            CommitmentID = purchaseOrder.PONumber,
                            ItemNumber = itemNumber,
                            Description = data.POItem.Description,
                            // RetainagePercent = ,
                            DeliveryDate = data.POItem.ReceivedDate,
                            //ScopeOfWork
                            //Extra = poItem.Job
                            //Category = poItem.cat
                            TaxGroup = data.POItem.TaxCode.Code,
                            Units = Math.Round(data.Qty, 4),
                            UnitCost = Math.Round(data.POCost, 4),
                            UnitDescription = data.PODimensions.UnitSize,
                            Amount = Math.Round(data.POItem.IncTax * data.Qty / data.POQty, 4),
                            // BoughtOut
                        };

                        var alloc = data.Item as PurchaseOrderItemAllocation;
                        if(alloc is not null)
                        {
                            ci.Job = alloc.Job.JobNumber;
                        }
                        else
                        {
                            ci.Job = data.POItem.Job.JobNumber;
                        }
                        if (!ci.Job.IsNullOrWhiteSpace())
                        {
                            ci.CostCode = data.POItem.CostCentre.Code;
                        }

                        if(!ProcessLine(model, data.POItem, alloc, ci))
                        {
                            success = false;
                            break;
                        }
                        c.Lines.Add(ci);
                    }

                    if (success)
                    {
                        foreach(var data in lineData)
                        {
                            cs.AddFragment(data.Item);
                        }
                        cs.AddSuccess(purchaseOrder, c);
                    }
                    else
                    {
                        cs.AddFailed(purchaseOrder, "Failed by script.");
                    }
                }
            }
            return cs;
        }

        public IPostResult<PurchaseOrder> Process(IDataModel<PurchaseOrder> model)
        {
            var POs = DoProcess(model);

            var dlg = new SaveFileDialog()
            {
                Filter = "CSV Files (*.csv)|*.csv"
            };

            if (dlg.ShowDialog() == true)
            {
                using (var writer = new StreamWriter(dlg.FileName))
                {
                    using var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
                    foreach (var header in POs.Exports)
                    {
                        // Write the record.
                        csv.WriteRecord(header);

                        // Current 0-based index that the writer is at.
                        int i = csv.Index;
                        foreach (var (index, field) in header.AdditionalFields.OrderBy(x => x.Key))
                        {
                            while (i < index)
                            {
                                csv.WriteField("");
                                ++i;
                            }
                            csv.WriteField(field);
                            ++i;
                        }
                        csv.NextRecord();
                        foreach (var poi in header.Lines)
                        {
                            csv.WriteRecord(poi);

                            // Current 0-based index that the writer is at.
                            i = csv.Index;
                            foreach (var (index, field) in poi.AdditionalFields.OrderBy(x => x.Key))
                            {
                                while (i < index)
                                {
                                    csv.WriteField("");
                                    ++i;
                                }
                                csv.WriteField(field);
                                ++i;
                            }
                            csv.NextRecord();
                        }
                    }
                }

                while (true)
                {
                    var logDlg = new OpenFileDialog
                    {
                        InitialDirectory = Path.GetDirectoryName(dlg.FileName),
                        FileName = "JCREJECT.JCC",
                        Filter = "Rejected Item Files (*.jcc) | *.jcc;*.JCC | All Files (*.*) | *.*",
                        Title = "Please select JCREJECT.JCC"
                    };
                    if (logDlg.ShowDialog() == true)
                    {
                        var rejectedHeaders = new List<PurchaseOrderTimberlineHeader?>();
                        var rejectedLines = new List<PurchaseOrderTimberlineLine?>();
                        using (var reader = new StreamReader(logDlg.FileName))
                        {
                            using var csv = new CsvReader(reader, new CsvConfiguration(CultureInfo.InvariantCulture)
                            {
                                HasHeaderRecord = false
                            });

                            while (csv.Read())
                            {
                                var id = csv.GetField(0);
                                if (id == "C")
                                {
                                    var header = csv.GetRecord<PurchaseOrderTimberlineHeader>();
                                    if (header is not null)
                                    {
                                        var entry = POs.Items.FirstOrDefault(x => x.Item2?.CommitmentID.Equals(header.CommitmentID) == true);
                                        if (entry is not null)
                                        {
                                            (entry.Item1 as IPostable).FailPost("");
                                        }
                                    }
                                    else
                                    {
                                        Logger.Send(LogType.Error, "", "PO Timberline export: Unable to parse header from CSV line in rejection file.");
                                        MessageBox.Show("Invalid line in file; skipping.");
                                    }
                                }
                                else if (id == "CI")
                                {
                                    var line = csv.GetRecord<PurchaseOrderTimberlineLine>();
                                    if (line is not null)
                                    {
                                        var entry = POs.Items.FirstOrDefault(x => x.Item2?.CommitmentID.Equals(line.CommitmentID) == true);
                                        if (entry is not null)
                                        {
                                            (entry.Item1 as IPostable).FailPost("");
                                        }
                                    }
                                    else
                                    {
                                        Logger.Send(LogType.Error, "", "PO Timberline export: Unable to parse line from CSV line in rejection file.");
                                        MessageBox.Show("Invalid line in file; skipping.");
                                    }
                                }
                            }
                        }
                        return POs;
                    }
                    else
                    {
                        if (MessageBox.Show("Do you wish to cancel the export?", "Cancel Export?", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                        {
                            throw new PostCancelledException();
                        }
                        else if (MessageBox.Show("Did everything post successfully?", "Successful?", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                        {
                            return POs;
                        }
                    }
                }
            }
            else
            {
                throw new PostCancelledException();
            }
        }
        public void AfterPost(IDataModel<PurchaseOrder> model, IPostResult<PurchaseOrder> result)
        {
            Script?.Execute(methodname: "AfterPost", parameters: new object[] { model });
        }
    }

    public class PurchaseOrderTimberlinePosterEngine<T> : TimberlinePosterEngine<PurchaseOrder, PurchaseOrderTimberlineSettings>
    {
    }
}