prs/prs.classes/Entities/Bill/BillLine.cs

using System;
using System.Collections.Generic;
using System.Linq;
using InABox.Core;

namespace Comal.Classes
{
    public class BillLineLink : EntityLink<BillLine>
    {
        [PopupEditor(typeof(BillLine))]
        public override Guid ID { get; set; }
        
        [RequiredColumn]
        public BillLink Bill { get; set; }
    }

    internal class BillLineLookups : EntityLookup<BillLine>
    {
        public override Filter<BillLine>? DefineFilter() => null;

        public override SortOrder<BillLine>? DefineSortOrder() => null;

        public override Columns<BillLine> DefineColumns()
        {
            return base.DefineColumns().Add(x => x.Bill.Number).Add(x => x.Description);
        }

        public override string FormatLookup(Dictionary<string, object?> values, IEnumerable<string> exclude)
        {
            return base.FormatLookup(values, exclude);
        }
    }

    [UserTracking(typeof(Bill))]
    public class BillLine : Entity, IPersistent, IRemotable,
        IOneToMany<Bill>, ITaxable, ILicense<AccountsPayableLicense>, IPostableFragment<Bill>, IEntityLookup<BillLine, BillLineLookups>,
        IInvoiceable
    {
        [RequiredColumn]
        [EntityRelationship(DeleteAction.Cascade)]
        [NullEditor]
        public BillLink Bill { get; set; }

        [Obsolete("Replaced by Bill")]
        public BillLink BillLink
        {
            get => Bill;
            set { }
        }

        private class PurchaseOrderItemLookup : LookupDefinitionGenerator<PurchaseOrderItem, BillLine>
        {
            public override Filter<PurchaseOrderItem> DefineFilter(BillLine[] items)
            {
                if (!items.Any())
                    return new Filter<PurchaseOrderItem>().None();
                
                var supplierID = items.Select(x => x.Bill.Supplier.ID).Distinct().SingleOrDefault();
                if(supplierID == Guid.Empty)
                    return new Filter<PurchaseOrderItem>().None();
                
                return Filter<PurchaseOrderItem>.Where(x => x.PurchaseOrder.Supplier.ID).IsEqualTo(supplierID)
                    .And(x=>x.BillLine.ID).IsEqualTo(Guid.Empty);
            }

            public override Columns<BillLine> DefineFilterColumns()
            {
                return Columns.None<BillLine>().Add(x => x.Bill.Supplier.ID);
            }
        }
        
        [LookupDefinition(typeof(PurchaseOrderItemLookup))]
        [EntityRelationship(DeleteAction.SetNull)]
        [EditorSequence(1)]
        public PurchaseOrderItemLink OrderItem { get; set; }
        
        private class ConsignmentLookup : LookupDefinitionGenerator<Consignment, BillLine>
        {
            public override Filter<Consignment> DefineFilter(BillLine[] items)
            {
                if (!items.Any())
                    return new Filter<Consignment>().None();
                
                var supplierID = items.Select(x => x.Bill.Supplier.ID).Distinct().SingleOrDefault();
                if(supplierID == Guid.Empty)
                    return new Filter<Consignment>().None();
                
                return Filter<Consignment>.Where(x => x.Supplier.ID).IsEqualTo(supplierID)
                    .And(x=>x.BillLine.ID).IsEqualTo(Guid.Empty);
            }

            public override Columns<BillLine> DefineFilterColumns()
            {
                return Columns.None<BillLine>().Add(x => x.Bill.Supplier.ID);
            }
        }
        
        [LookupDefinition(typeof(ConsignmentLookup))]
        [EntityRelationship(DeleteAction.SetNull)]
        [EditorSequence(2)]
        public ConsignmentLink Consignment { get; set; }

        private class ProductLookupGenerator : LookupDefinitionGenerator<Product, BillLine>
        {
            public override Filter<Product>? DefineFilter(BillLine[] items)
                => Filter<Product>.Where(x => x.NonStock).IsEqualTo(true);
        }
        [EditorSequence(3)]
        [LookupDefinition(typeof(ProductLookupGenerator))]
        public ProductLink Product { get; set; }
        
        [EditorSequence(4)]
        public JobLink Job { get; set; }
        
        [MemoEditor]
        [EditorSequence(5)]
        public string Description { get; set; }
        
        [CurrencyEditor(Summary=Summary.Sum)]
        [EditorSequence(6)]
        public double ForeignCurrencyCost { get; set; }

        [CurrencyEditor(Summary = Summary.Sum)]
        [EditorSequence(7)]
        public double ExTax { get; set; }

        [RequiredColumn]
        [EditorSequence(8)]
        public TaxCodeLink TaxCode { get; set; }

        
        [CurrencyEditor(Summary = Summary.Sum)]
        [EditorSequence(9)]
        public double Tax { get; set; }

        [CurrencyEditor(Summary = Summary.Sum)]
        [EditorSequence(10)]
        public double IncTax { get; set; }

        [EditorSequence(11)]
        public PurchaseGLCodeLink PurchaseGL { get; set; }
        
        [EditorSequence(12)]
        public CostCentreLink CostCentre { get; set; }
        
        [EditorSequence(13)]
        [Editable(Editable.Disabled)]
        public InvoiceLink Invoice { get; set; }

        [EditorSequence(14)]
        public ActualCharge Charge { get; set; }
        
        [NullEditor]
        public double TaxRate { get; set; }
        
        [NullEditor]
        public string PostedReference { get; set; }

        static BillLine()
        {
            // If we select a product for this bill line
            LinkedProperties.Register<BillLine, ProductLink, String>(x => x.Product, x => x.Name, x => x.Description);
            
            LinkedProperties.Register<BillLine, PurchaseOrderItemLink, double>(x => x.OrderItem, x => x.ExTax,
                x => x.ExTax);
            LinkedProperties.Register<BillLine, PurchaseGLCodeLink, Guid>(x => x.OrderItem.PurchaseGL, x => x.ID,
                x => x.PurchaseGL.ID);
            LinkedProperties.Register<BillLine, CostCentreLink, Guid>(x => x.OrderItem.CostCentre, x => x.ID,
                x => x.CostCentre.ID);
            LinkedProperties.Register<BillLine, TaxCodeLink, Guid>(x => x.OrderItem.TaxCode, x => x.ID,
                x => x.TaxCode.ID);            
            LinkedProperties.Register<BillLine, TaxCodeLink, String>(x => x.OrderItem.TaxCode, x => x.Code,
                x => x.TaxCode.Code);            

            LinkedProperties.Register<BillLine, TaxCodeLink, String>(x => x.OrderItem.TaxCode, x => x.Description,
                x => x.TaxCode.Description);            

            LinkedProperties.Register<BillLine, TaxCodeLink, double>(x => x.OrderItem.TaxCode, x => x.Rate,
                x => x.TaxCode.Rate);            
            
            LinkedProperties.Register<BillLine, PurchaseOrderItemLink, double>(x => x.OrderItem, x => x.Tax,
                x => x.Tax);
            
            LinkedProperties.Register<BillLine, PurchaseOrderItemLink, double>(x => x.OrderItem, x => x.IncTax,
                x => x.IncTax);

            LinkedProperties.Register<BillLine, TaxCodeLink, double>(x => x.TaxCode, x => x.Rate, x => x.TaxRate);

            LinkedProperties.Register<BillLine, PurchaseGLCodeLink, Guid>(x => x.Product.PurchaseGL, x => x.ID, x => x.PurchaseGL.ID);
            LinkedProperties.Register<BillLine, CostCentreLink, Guid>(x => x.Product.CostCentre, x => x.ID, x => x.CostCentre.ID);
            LinkedProperties.Register<BillLine, TaxCodeLink, Guid>(x => x.Product.TaxCode, x => x.ID, x => x.TaxCode.ID);
            LinkedProperties.Register<BillLine, TaxCodeLink, string>(x => x.Product.TaxCode, x => x.Code, x => x.TaxCode.Code);
            LinkedProperties.Register<BillLine, TaxCodeLink, string>(x => x.Product.TaxCode, x => x.Description, x => x.TaxCode.Description);
            LinkedProperties.Register<BillLine, TaxCodeLink, double>(x => x.Product.TaxCode, x => x.Rate, x => x.TaxCode.Rate);
        }

        private static readonly Column<BillLine> OrderItemColumn = new Column<BillLine>(x => x.OrderItem.ID);
        private static readonly Column<BillLine> ProductColumn = new Column<BillLine>(x => x.Product.ID);
        private static readonly Column<BillLine> JobColumn = new Column<BillLine>(x => x.Job.ID);
        private static readonly Column<BillLine> ForeignCurrencyColumn = new Column<BillLine>(x => x.ForeignCurrencyCost);
        private static readonly Column<BillLine> ExTaxColumn = new Column<BillLine>(x => x.ExTax);
        private static readonly Column<BillLine> IncTaxColumn = new Column<BillLine>(x => x.ExTax);

        private bool bChanging = false;

        protected override void DoPropertyChanged(string name, object? before, object? after)
        {
            if (bChanging)
                return;
            bChanging = true;

            try
            {
                base.DoPropertyChanged(name, before, after);
                if (OrderItemColumn.IsEqualTo(name) && after is Guid orderItemID && orderItemID != Guid.Empty)
                {
                    Product.ID = Guid.Empty;
                    Product.Clear();
                    Job.ID = Guid.Empty;
                    Job.Clear();
                }
                else if((ProductColumn.IsEqualTo(name) && after is Guid productID && productID != Guid.Empty)
                        || (JobColumn.IsEqualTo(name) && after is Guid jobID && jobID != Guid.Empty))
                {
                    OrderItem.ID = Guid.Empty;
                    OrderItem.Clear();
                }
                else if (ForeignCurrencyColumn.IsEqualTo(name) && after is double fcc)
                {
                    ExTax = fcc / (Bill.Supplier.Currency.ExchangeRate.IsEffectivelyEqual(0.0) ? 1.0 : Bill.Supplier.Currency.ExchangeRate);
                    Tax = ExTax * TaxRate / 100.0;
                    IncTax = ExTax + Tax;
                }
                else if (ExTaxColumn.IsEqualTo(name) && after is double etc)
                {
                    ForeignCurrencyCost = etc * (Bill.Supplier.Currency.ExchangeRate.IsEffectivelyEqual(0.0) ? 1.0 : Bill.Supplier.Currency.ExchangeRate);
                }
                else if (IncTaxColumn.IsEqualTo(name) && after is double itc)
                {
                    ForeignCurrencyCost = ExTax * (Bill.Supplier.Currency.ExchangeRate.IsEffectivelyEqual(0.0) ? 1.0 : Bill.Supplier.Currency.ExchangeRate);
                }
                
            }
            finally
            {
                bChanging = false;
            }
            
        }
    }
}