prs/prs.shared/Posters/Timberline/BillTimberlinePoster.cs

using Comal.Classes;
using CsvHelper;
using CsvHelper.Configuration;
using CsvHelper.Configuration.Attributes;
using FastReport.Utils;
using InABox.Core;
using InABox.Core.Postable;
using InABox.Poster.Timberline;
using InABox.Scripting;
using Microsoft.Win32;
using NPOI.SS.Formula.Functions;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;
using Columns = InABox.Core.Columns;

namespace PRS.Shared;

public class BillTimberlineHeader
{
    [Ignore]
    public List<BillTimberlineDistribution> Distributions { get; set; } = new();

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

    [Index(1)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 10)]
    public string Vendor { get; set; } = "";

    [Ignore]
    private string _invoice = "";

    [Index(2)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 15)]
    public string Invoice
    {
        get => _invoice;
        set => _invoice = TimberlinePosterStringConverter.ConvertString(value, 15);
    }

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

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

    [Index(5)]
    public double Tax { get; set; }

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

    [Index(7)]
    public double MiscDeduction { get; set; }

    [Index(8)]
    [TypeConverter(typeof(TimberlinePosterDateConverter))]
    public DateTime InvoiceDate { get; set; }

    [Index(9)]
    [TypeConverter(typeof(TimberlinePosterDateConverter))]
    public DateTime DateReceived { get; set; }

    [Index(10)]
    [TypeConverter(typeof(TimberlinePosterDateConverter))]
    public DateTime DiscountDate { get; set; }

    [Index(11)]
    [TypeConverter(typeof(TimberlinePosterDateConverter))]
    public DateTime PaymentDate { get; set; }

    [Index(12)]
    [TypeConverter(typeof(TimberlinePosterDateConverter))]
    public DateTime AccountingDate { get; set; }

    [Index(13)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 10)]
    public string InvoiceCode1 { get; set; } = "";

    [Index(14)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 10)]
    public string InvoiceCode2 { get; set; } = "";

    [Index(15)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 30)]
    public string SmryPayeeName { get; set; } = "";

    [Index(16)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 33)]
    public string SmryPayeeAddress1 { get; set; } = "";

    [Index(17)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 33)]
    public string SmryPayeeAddress2 { get; set; } = "";

    [Index(18)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 15)]
    public string SmryPayeeCity { get; set; } = "";

    [Index(19)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 4)]
    public string SmryPayeeState { get; set; } = "";

    [Index(20)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 10)]
    public string SmryPayeeZip { get; set; } = "";
}

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

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

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

    [Index(3)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 7)]
    public string Equipment { get; set; } = "";

    [Index(4)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 6)]
    public string EQCostCode { get; set; } = "";

    [Index(5)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 6)]
    public string Job { get; set; } = "";

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

    [Index(7)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 7)]
    public string CostCode { get; set; } = "";

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

    [Index(9)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 10)]
    public string BLStdItem { get; set; } = "";

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

    [Index(11)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), int.MaxValue)] // int.MaxValue because it was chopping the accounts in PRS
    public string ExpenseAccount { get; set; } = "";

    [Index(12)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), int.MaxValue)] // int.MaxValue because it was chopping the accounts in PRS
    public string APAccount { get; set; } = "";

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

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

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

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

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

    [Index(18)]
    public double Tax { get; set; }

    [Index(19)]
    public double TaxLiability { get; set; }

    [Index(20)]
    public double DiscountOffered { get; set; }

    [Index(21)]
    public double Retainage { get; set; }

    [Index(22)]
    public double MiscDeduction { get; set; }

    [Index(23)]
    [BooleanTrueValues("t", "T", "1", "Y", "y")]
    [BooleanFalseValues("f", "F", "0", "N", "n")]
    public bool TaxablePaymentsExempt { get; set; }

    [Index(24)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 10)]
    public string DistCode { get; set; } = "";

    [Index(25)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 10)]
    public string Draw { get; set; } = "";

    [Index(26)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 10)]
    public string MiscEntry1 { get; set; } = "";

    [Index(27)]
    public double MiscEntryUnits1 { get; set; }

    [Index(28)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 10)]
    public string MiscEntry2 { get; set; } = "";

    [Index(29)]
    public double MiscEntryUnits2 { get; set; }

    [Index(30)]
    public double MeterOdometer { get; set; }

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

    [Index(32)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 10)]
    public string Authorization { get; set; } = "";

    [Index(33)]
    [TypeConverter(typeof(TimberlinePosterStringConverter), 30)]
    public string JointPayee { get; set; } = "";
}

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

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

    public bool ProcessHeader(IDataModel<Bill> model, Bill bill, BillTimberlineHeader header)
    {
        // Do extra processing for a header line; return false to fail this header
        return true;
    }

    public bool ProcessLine(IDataModel<Bill> model, BillLine bill, BillTimberlineDistribution distribution)
    {
        // Do extra processing for a distribution line; return false to fail this header
        return true;
    }

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

public class BillTimberlineResult : TimberlinePostResult<BillTimberlineHeader, Bill>
{
}

public class BillTimberlinePoster : ITimberlinePoster<Bill, BillTimberlineSettings>
{
    public ScriptDocument? Script { get; set; }
    public BillTimberlineSettings Settings { get; set; }

    public bool BeforePost(IDataModel<Bill> model)
    {
        foreach(var (name, table) in model.ModelTables)
        {
            table.IsDefault = false;
        }
        model.SetIsDefault<Bill>(true);
        model.SetIsDefault<BillLine>(true, "Bill_BillLine");

        model.SetColumns(Columns.None<Bill>().Add(x => x.ID)
            .Add(x => x.SupplierLink.Code)
            .Add(x => x.Description)
            .Add(x => x.Number)
            .Add(x => x.IncTax)
            .Add(x => x.Tax)
            .Add(x => x.BillDate)
            .Add(x => x.AccountingDate)
            .Add(x => x.PaymentDate)
            .Add(x => x.Approved));

        model.SetColumns(Columns.None<BillLine>().Add(x => x.ID)
            .Add(x => x.BillLink.ID)
            .Add(x => x.TaxCode.Code)
            .Add(x => x.IncTax)
            .Add(x => x.Tax)
            .Add(x => x.Description)
            .Add(x => x.PurchaseGL.Code)
            .Add(x => x.OrderItem.ID)
            .Add(x => x.Job.JobNumber),
            alias: "Bill_BillLine");

        model.AddChildTable<BillLine, PurchaseOrderItem>(x => x.OrderItem.ID, x => x.ID, isdefault: true,
            parentalias: "Bill_BillLine", childalias: "POItem",
            columns: Columns.None<PurchaseOrderItem>().Add(x => x.ID)
                .Add(x => x.PurchaseOrderLink.PONumber)
                .Add(x => x.Qty)
                .Add(x => x.Description)
                .Add(x => x.Cost)
                .Add(x => x.PostedReference)
                .Add(x => x.NominatedJob.Job.JobNumber)
                );

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

    private bool ProcessHeader(IDataModel<Bill> model, Bill bill, BillTimberlineHeader header)
    {
        return Script?.Execute(methodname: "ProcessHeader", parameters: new object[] { model, bill, header }) != false;
    }
    private bool ProcessLine(IDataModel<Bill> model, BillLine bill, BillTimberlineDistribution distribution)
    {
        return Script?.Execute(methodname: "ProcessLine", parameters: new object[] { model, bill, distribution }) != false;
    }

    private BillTimberlineResult DoProcess(IDataModel<Bill> model)
    {
        var result = new BillTimberlineResult();

        var lines = model.GetTable<BillLine>("Bill_BillLine").ToObjects<BillLine>()
            .GroupBy(x => x.BillLink.ID).ToDictionary(x => x.Key, x => x.ToList());
        var purchaseOrderItems = model.GetTable<PurchaseOrderItem>("POItem").ToObjects<PurchaseOrderItem>()
            .ToDictionary(x => x.ID, x => x);

        var bills = model.GetTable<Bill>().ToObjects<Bill>();
        if(bills.Any(x => x.Approved.IsEmpty()))
        {
            throw new PostFailedMessageException("We can't process unapproved bills; please approve all bills before processing.");
        }

        foreach (var bill in bills)
        {
            if(bill.Number.Length > 15)
            {
                result.AddFailed(bill, "Bill Number cannot be more than 15 digits in length.");
                continue;
            }

            var apif = new BillTimberlineHeader
            {
                Vendor = bill.SupplierLink.Code,
                Invoice = bill.Number,
                Description = bill.Description,
                Amount = Math.Round(bill.IncTax, 4),
                Tax = Math.Round(bill.Tax, 4),
                // DiscountOffered
                // Misc. Deduction
                InvoiceDate = bill.BillDate,
                // DateReceived doesn't exist
                DiscountDate = bill.BillDate,
                PaymentDate = bill.PaymentDate,
                AccountingDate = bill.AccountingDate,
                // InvoiceCode1
                // InvoiceCode2
                // SmryPayeeName
                // SmryPayeeAddress1
                // SmryPayeeAddress2
                // SmryPayeeCity
                // SmryPayeeState
                // SmryPayeeZip
            };
            if (!ProcessHeader(model, bill, apif))
            {
                result.AddFailed(bill, "Failed by script.");
                continue;
            }

            var success = true;
            var billLines = lines.GetValueOrDefault(bill.ID) ?? new List<BillLine>();
            foreach (var billLine in billLines)
            {
                var apdf = new BillTimberlineDistribution
                {
                    // Equipment
                    // EQ Cost Code
                    // Extra
                    // Cost Code
                    // Category
                    /// BL STd Item
                    // Reserved
                    ExpenseAccount = billLine.PurchaseGL.Code,
                    // AP Account
                    // Taxable Payments
                    TaxGroup = billLine.TaxCode.Code,
                    Amount = Math.Round(billLine.IncTax, 4),
                    Tax = Math.Round(billLine.Tax, 4),
                    // Tax Liability
                    // Discount OFfered
                    // Retainage
                    // MIsc Deduction
                    // Tax Payments Exempt
                    // Dist Code
                    // Misc Entry 1
                    // Misc Units 1
                    // Misc Entry 2
                    // Misc Units 2
                    // Meter
                    Description = billLine.Description,
                    // Authorization
                    // Joint Payee
                };
                if (purchaseOrderItems.TryGetValue(billLine.OrderItem.ID, out var poItem))
                {
                    apdf.Commitment = poItem.PurchaseOrderLink.PONumber;
                    apdf.Job = poItem.NominatedJob.Job.JobNumber;
                    if (int.TryParse(poItem.PostedReference, out var itemNumber))
                    {
                        apdf.CommitmentLineItem = itemNumber;
                        billLine.PostedReference = poItem.PostedReference;
                    }
                    apdf.Units = Math.Round(poItem.Qty, 4);
                    apdf.UnitCost = Math.Round(poItem.Cost, 4);
                    apdf.Description = poItem.Description.NotWhiteSpaceOr(apdf.Description);
                }
                else
                {
                    apdf.Job = billLine.Job.JobNumber;
                }

                if (!ProcessLine(model, billLine, apdf))
                {
                    success = false;
                    break;
                }
                apif.Distributions.Add(apdf);
            }
            if (success)
            {
                foreach(var billLine in billLines)
                {
                    result.AddFragment(billLine);
                }
                result.AddSuccess(bill, apif);
            }
            else
            {
                result.AddFailed(bill, "Failed by script.");
            }
        }
        return result;
    }

    public IPostResult<Bill> Process(IDataModel<Bill> model)
    {
        var result = 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 apif in result.Exports)
                {
                    csv.WriteRecord(apif);
                    csv.NextRecord();
                    foreach (var apdf in apif.Distributions)
                    {
                        csv.WriteRecord(apdf);
                        csv.NextRecord();
                    }
                }
            }

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

                        var i = 1;
                        while (csv.Read())
                        {
                            var id = csv.GetField(0);
                            if (id == "APIF")
                            {
                                var header = csv.GetRecord<BillTimberlineHeader>();
                                if (header is not null)
                                {
                                    var entry = result.Items.FirstOrDefault(x => x.Item2?.Invoice.Equals(header.Invoice) == true);
                                    if (entry is not null)
                                    {
                                        (entry.Item1 as IPostable).FailPost("");
                                    }
                                }
                                else
                                {
                                    Logger.Send(LogType.Error, "", "Bill Timberline export: Unable to parse header from CSV line in rejection file.");
                                    MessageBox.Show($"Invalid line {i} in file; skipping.");
                                }
                            }
                            else if (id == "APDF")
                            {
                                // Ignoring these because the reject file contains the header as well, and we don't need to fail BillLines, because
                                // they aren't postable.

                                /*var line = csv.GetRecord<BillTimberlineDistribution>();
                                if (line is not null)
                                {
                                    var entry = result.Items.FirstOrDefault(x => x.Item2?.Invoice.Equals(line.Invoice) == true);
                                    if (entry is not null)
                                    {
                                        (entry.Item1 as IPostable).FailPost("");
                                    }
                                }
                                else
                                {
                                    Logger.Send(LogType.Error, "", "Bill Timberline export: Unable to parse line from CSV line in rejection file.");
                                    MessageBox.Show("Invalid line in file; skipping.");
                                }*/
                            }
                            ++i;
                        }
                    }
                    return result;
                }
                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 result;
                    }
                }
            }
        }
        else
        {
            throw new PostCancelledException();
        }
    }
    public void AfterPost(IDataModel<Bill> model, IPostResult<Bill> result)
    {
        Script?.Execute(methodname: "AfterPost", parameters: new object[] { model });
    }
}

public class BillTimberlinePosterEngine<T> : TimberlinePosterEngine<Bill, BillTimberlineSettings>
{
}