prs/prs.classes/Entities/PurchaseOrder/PurchaseOrder.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Runtime.InteropServices;
using System.Xml.Linq;
using AutoProperties;
using InABox.Clients;
using InABox.Core;

namespace Comal.Classes
{
    
    // public class PurchaseOrderDueDate : CoreAggregate<PurchaseOrder, PurchaseOrderItem, DateTime>
    // {
    //     public override Expression<Func<PurchaseOrderItem, DateTime>> Aggregate => x => x.DueDate;
    //
    //     public override AggregateCalculation Calculation => AggregateCalculation.Minimum;
    //
    //     public override Filter<PurchaseOrderItem>? Filter => new Filter<PurchaseOrderItem>(c => c.DueDate).IsNotEqualTo(DateTime.MinValue);
    //
    //     public override Dictionary<Expression<Func<PurchaseOrderItem, object?>>, Expression<Func<PurchaseOrder, object?>>> Links =>
    //         new Dictionary<Expression<Func<PurchaseOrderItem, object?>>, Expression<Func<PurchaseOrder, object?>>>()
    //         {
    //             { PurchaseOrderItem => PurchaseOrderItem.PurchaseOrderLink.ID, PurchaseOrder => PurchaseOrder.ID }
    //         };
    // }
    public class PurchaseOrderUnreceivedQtyAggregate : CoreAggregate<PurchaseOrder, PurchaseOrderItem, double>
    {
        public override Expression<Func<PurchaseOrderItem, double>> Aggregate => x => x.Qty;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<PurchaseOrderItem, object?>>, Expression<Func<PurchaseOrder, object?>>> Links =>
            new Dictionary<Expression<Func<PurchaseOrderItem, object?>>, Expression<Func<PurchaseOrder, object?>>>()
            {
                { PurchaseOrderItem => PurchaseOrderItem.PurchaseOrder.ID, PurchaseOrder => PurchaseOrder.ID }
            };

        public override Filter<PurchaseOrderItem>? Filter => Filter<PurchaseOrderItem>.Where(x => x.ReceivedDate).IsEqualTo(DateTime.MinValue);
    }
    
    public class PurchaseOrderReceivedQtyAggregate : CoreAggregate<PurchaseOrder, PurchaseOrderItem, double>
    {
        public override Expression<Func<PurchaseOrderItem, double>> Aggregate => x => x.Qty;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<PurchaseOrderItem, object?>>, Expression<Func<PurchaseOrder, object?>>> Links =>
            new Dictionary<Expression<Func<PurchaseOrderItem, object?>>, Expression<Func<PurchaseOrder, object?>>>()
            {
                { PurchaseOrderItem => PurchaseOrderItem.PurchaseOrder.ID, PurchaseOrder => PurchaseOrder.ID }
            };
        
        public override Filter<PurchaseOrderItem>? Filter => Filter<PurchaseOrderItem>.Where(x => x.ReceivedDate).IsNotEqualTo(DateTime.MinValue);
    }  
    
    public class PurchaseOrderExTax : CoreAggregate<PurchaseOrder, PurchaseOrderItem, double>
    {
        public override Expression<Func<PurchaseOrderItem, double>> Aggregate => x => x.ExTax;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<PurchaseOrderItem, object?>>, Expression<Func<PurchaseOrder, object?>>> Links =>
            new Dictionary<Expression<Func<PurchaseOrderItem, object?>>, Expression<Func<PurchaseOrder, object?>>>()
            {
                { PurchaseOrderItem => PurchaseOrderItem.PurchaseOrder.ID, PurchaseOrder => PurchaseOrder.ID }
            };
    }    
    
    public class PurchaseOrderTax : CoreAggregate<PurchaseOrder, PurchaseOrderItem, double>
    {
        public override Expression<Func<PurchaseOrderItem, double>> Aggregate => x => x.Tax;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<PurchaseOrderItem, object?>>, Expression<Func<PurchaseOrder, object?>>> Links =>
            new Dictionary<Expression<Func<PurchaseOrderItem, object?>>, Expression<Func<PurchaseOrder, object?>>>()
            {
                { PurchaseOrderItem => PurchaseOrderItem.PurchaseOrder.ID, PurchaseOrder => PurchaseOrder.ID }
            };
    }

    public class PurchaseOrderIncTax : CoreAggregate<PurchaseOrder, PurchaseOrderItem, double>
    {
        public override Expression<Func<PurchaseOrderItem, double>> Aggregate => x => x.IncTax;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<PurchaseOrderItem, object?>>, Expression<Func<PurchaseOrder, object?>>> Links =>
            new Dictionary<Expression<Func<PurchaseOrderItem, object?>>, Expression<Func<PurchaseOrder, object?>>>()
            {
                { PurchaseOrderItem => PurchaseOrderItem.PurchaseOrder.ID, PurchaseOrder => PurchaseOrder.ID }
            };
    }

    public class PurchaseOrderBalance : CoreAggregate<PurchaseOrder, PurchaseOrderItem, double>
    {
        public override Expression<Func<PurchaseOrderItem, double>> Aggregate => x => x.Balance;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<PurchaseOrderItem, object?>>, Expression<Func<PurchaseOrder, object?>>> Links =>
            new Dictionary<Expression<Func<PurchaseOrderItem, object?>>, Expression<Func<PurchaseOrder, object?>>>()
            {
                { PurchaseOrderItem => PurchaseOrderItem.PurchaseOrder.ID, PurchaseOrder => PurchaseOrder.ID }
            };
    }

    [UserTracking(typeof(Bill))]
    public class PurchaseOrder : Entity, IRemotable, IPersistent, IStringAutoIncrement<PurchaseOrder>, IOneToMany<Supplier>,
        ILicense<AccountsPayableLicense>, IDataEntryInstance, IPostable, IMergeable
    {
        private bool bChanging;

        [UniqueCodeEditor(Visible = Visible.Default, Editable = Editable.Enabled)]
        [EditorSequence(0)]
        public string PONumber { get; set; }

        [RequiredColumn]
        [EntityRelationship(DeleteAction.SetNull)]
        [EditorSequence(1)]
        public SupplierLink Supplier { get; set; }

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

        [MemoEditor]
        [EditorSequence(2)]
        public string Description { get; set; }
        
        [EditorSequence(3)]
        public PurchaseOrderCategoryLink Category { get; set; }

        [EditorSequence(4)]
        public EmployeeLink RaisedBy { get; set; }

        [DateEditor]
        [EditorSequence(5)]
        public DateTime DueDate { get; set; }
        
        private class IssuedDateInformation : EditorInformation<PurchaseOrder>
        {
            public override string GetInfo(PurchaseOrder item) => item.IssuedBy.Name;
        }
        
        [DateTimeEditor(Information = typeof(IssuedDateInformation))]
        [RequiredColumn,LoggableProperty]
        [EditorSequence(6)]
        public DateTime IssuedDate { get; set; }
        
        private class EmployeeLookup : LookupDefinitionGenerator<Employee, PurchaseOrder>
        {
            public override Columns<Employee> DefineColumns()
            {
                return base.DefineColumns().Add(x => x.Name);
            }
        }
        // This information might be printed out on the PO report, so we store this in the database
        // Other properties uch as Closed/Cancelled/Checked etc are simply logged in the Audit Trail
        [NullEditor]
        [LookupDefinition(typeof(EmployeeLookup))]
        public EmployeeLink IssuedBy { get; set; }
        
        [CurrencyEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(PurchaseOrderExTax))]
        public double ExTax { get; set; }
        
        [CurrencyEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(PurchaseOrderTax))]
        public double Tax { get; set; }
        
        [CurrencyEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(PurchaseOrderIncTax))]
        public double IncTax { get; set; }
        
        [CurrencyEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(PurchaseOrderBalance))]
        public double Balance { get; set; }
        
        [EditorSequence("Additional",2)]
        [LoggableProperty]
        [TimestampEditor]
        public DateTime DataEntered { get; set; }
        
        [EditorSequence("Additional",3)]
        [TimestampEditor]
        [LoggableProperty]
        public DateTime CheckedDate { get; set; }
        
        [RequiredColumn, LoggableProperty]
        [TimestampEditor]
        [EditorSequence("Additional",4)]
        public DateTime ClosedDate { get; set; }
        
        [TimestampEditor]
        [LoggableProperty]
        [EditorSequence("Additional",5)]
        public DateTime CancelledDate { get; set; }
        
        [NotesEditor]
        [EditorSequence("Notes",1)]
        public string[] Notes { get; set; }
        
        
        [DoubleEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(PurchaseOrderUnreceivedQtyAggregate))]
        public double Unreceived { get; set; }
        
        [DoubleEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(PurchaseOrderReceivedQtyAggregate))]
        public double Received { get; set; }


        
        //[CodeEditor(Visible = Visible.Default, Editable = Editable.Hidden)]
        [NullEditor]
        public string SupplierCode { get; set; }

        //[TextBoxEditor]
        [NullEditor]
        public string SupplierName { get; set; }

        [DoNotPersist]
        [DoNotSerialize]
        [InterceptIgnore]
        public static string PONumberPrefix { get; set; }

        [NullEditor]
        [LoggableProperty]
        public DateTime Posted { get; set; }

        [NullEditor]
        [LoggableProperty]
        [RequiredColumn]
        public PostedStatus PostedStatus { get; set; }

        [NullEditor]
        public string PostedNote { get; set; }

        [NullEditor]
        public string PostedReference { get; set; }
        
        [Obsolete("Replaced by multiple Datetime stamps", true)]
        [NullEditor]
        public PurchaseOrderStatus Status { get; set; }
        
        public Expression<Func<PurchaseOrder, string>> AutoIncrementField() => x => x.PONumber;
        public Filter<PurchaseOrder> AutoIncrementFilter() => null;
        public string AutoIncrementPrefix() => PONumberPrefix;
        public string AutoIncrementFormat() => "{0:D6}";
        public int AutoIncrementDefault() => 1;

        protected override void DoPropertyChanged(string name, object? before, object? after)
        {
            base.DoPropertyChanged(name, before, after);
            if (bChanging)
                return;
            bChanging = true;
            if (name.Equals(nameof(IssuedDate)) && before is DateTime _old && after is DateTime _new && _new.IsEmpty() != _old.IsEmpty())
            {
                Employee? _emp = _new.IsEmpty()
                    ? new Employee()
                    : Client.Query<Employee>(
                        Filter<Employee>.Where(x => x.User.ID).IsEqualTo(ClientFactory.UserGuid),
                        Columns.None<Employee>().Add(x => x.ID).Add(x => x.Name)
                    ).Rows.FirstOrDefault()?.ToObject<Employee>();
                IssuedBy.ID = _emp.ID;
                IssuedBy.Synchronise(_emp);
            }
            bChanging = false;
        }

        static PurchaseOrder()
        {
            LinkedProperties.Register<PurchaseOrder, SupplierLink, String>(x => x.Supplier, x => x.Code, x => x.SupplierCode);
            LinkedProperties.Register<PurchaseOrder, SupplierLink, String>(x => x.Supplier, x => x.Name, x => x.SupplierName);
        }

        private static Column<PurchaseOrderItem> POProductIDColumn = new Column<PurchaseOrderItem>(x => x.Product.ID);
        
        /// <summary>
        /// Recalculate the cost of each PurchaseOrderItem in <paramref name="items"/>, by finding a <see cref="SupplierProduct"/> that matches.
        /// </summary>
        /// <param name="items"></param>
        /// <param name="supplierid"></param>
        /// <param name="changes"></param>
        public static void UpdateCosts(IEnumerable<PurchaseOrderItem> items, Guid supplierid, Dictionary<String,object?> changes, string columnName)
        {
            void UpdateValue<TType>(PurchaseOrderItem item,Expression<Func<PurchaseOrderItem, TType>> property, TType value)
            {
                CoreUtils.MonitorChanges(
                    item, 
                    () => CoreUtils.SetPropertyValue(item, CoreUtils.GetFullPropertyName(property, "."), value),
                    changes
                );
            }
            
            var _items =  items as PurchaseOrderItem[] ?? items.ToArray();
            var productids = _items.Where(x => x.Product.ID != Guid.Empty).Select(x => x.Product.ID).ToArray();
            var jobids = _items.Where(x => x.Product.ID != Guid.Empty).Select(x => x.Job.ID).ToList().Append(Guid.Empty).Distinct().ToArray();

            if(productids.Length == 0)
                return;
            
            MultiQuery query = new MultiQuery();
            
            query.Add(
                Filter<SupplierProduct>.Where(x =>x.Supplier.ID).IsEqualTo(supplierid)
                    .And(x=>x.Product.ID).InList(productids),
                Columns.None<SupplierProduct>().Add(x=>x.Product.ID)
                    .Add(x=>x.Style.ID)
                    .AddDimensionsColumns(x => x.Dimensions, Dimensions.ColumnsType.Local)
                    .Add(x=>x.Job.ID)
                    .Add(x=>x.SupplierCode)
                    .Add(x=>x.SupplierDescription)
                    .Add(x=>x.Supplier.ID)
                    .Add(x=>x.ForeignCurrencyPrice)
                    .Add(x=>x.TradePrice)
                    .Add(x=>x.CostPrice)
                    .Add(x=>x.DiscountGroup.ID)
            );
            
            query.Add(
                Filter<SupplierDiscount>.Where(x =>x.Job.ID).InList(jobids)
                    .And(x => x.Group.ID).InQuery(
                        Filter<SupplierProduct>.Where(x => x.Product.ID).InList(productids), 
                        x => x.DiscountGroup.ID
                    ),
                Columns.None<SupplierDiscount>()
                    .Add(x=>x.Group.ID)
                    .Add(x=>x.Job.ID)
                    .Add(x=>x.Group.Type)
                    .Add(x=>x.Value)
            );
            
            query.Add(
                Filter<ProductInstance>.Where(x =>x.Product.ID).InList(productids),
                Columns.None<ProductInstance>().Add(x=>x.Product.ID)
                    .Add(x => x.Style.ID)
                    .AddDimensionsColumns(x => x.Dimensions, Dimensions.ColumnsType.Local)
                    .Add(x => x.NettCost)
            );
            
            query.Query();

            var supplierProducts = query.Get<SupplierProduct>().ToArray<SupplierProduct>();
            var supplierDiscounts = query.Get<SupplierDiscount>().ToArray<SupplierDiscount>();
            var productInstances = query.Get<ProductInstance>().ToArray<ProductInstance>();
            
            foreach (var item in _items)
            {
                //Check Supplier / Job Specific Pricing
                var supplierProduct = supplierProducts.FirstOrDefault(x =>
                    x.Supplier.ID == item.PurchaseOrder.Supplier.ID
                    && x.Product.ID == item.Product.ID
                    && x.Style.ID == item.Style.ID
                    && x.Dimensions.Equals(item.Dimensions)
                    && x.Job.ID == item.Job.ID);
                if (supplierProduct != null)
                {
                    if(POProductIDColumn.IsEqualTo(columnName))
                    {
                        if (!supplierProduct.SupplierCode.IsNullOrWhiteSpace())
                        {
                            UpdateValue<string>(item, x => x.SupplierCode, supplierProduct.SupplierCode);
                        }
                        if (!supplierProduct.SupplierDescription.IsNullOrWhiteSpace())
                        {
                            UpdateValue<string>(item, x => x.Description, supplierProduct.SupplierDescription);
                        }
                    }
                    UpdateValue<double>(item, x => x.ForeignCurrencyCost, supplierProduct.ForeignCurrencyPrice);
                    UpdateValue<double>(item, x => x.Cost, supplierProduct.CostPrice);
                    continue;
                }
                
                
                // Check Supplier Pricing
                supplierProduct = supplierProducts.FirstOrDefault(x =>
                    x.Supplier.ID == item.PurchaseOrder.Supplier.ID
                    && x.Product.ID == item.Product.ID
                    && x.Style.ID == item.Style.ID
                    && x.Dimensions.Equals(item.Dimensions)
                    && x.Job.ID == Guid.Empty);
                if (supplierProduct != null)
                {
                    if(POProductIDColumn.IsEqualTo(columnName))
                    {
                        if (!supplierProduct.SupplierCode.IsNullOrWhiteSpace())
                        {
                            UpdateValue<string>(item, x => x.SupplierCode, supplierProduct.SupplierCode);
                        }
                        if (!supplierProduct.SupplierDescription.IsNullOrWhiteSpace())
                        {
                            UpdateValue<string>(item, x => x.Description, supplierProduct.SupplierDescription);
                        }
                    }
                    
                    var discount = supplierDiscounts.FirstOrDefault(x=>x.Job.ID == item.Job.ID && x.Group.ID == supplierProduct.DiscountGroup.ID);
                    if (discount == null)
                        discount = supplierDiscounts.FirstOrDefault(x=>x.Job.ID == Guid.Empty && x.Group.ID == supplierProduct.DiscountGroup.ID);
                    if (discount != null)
                    {
                        if (discount.Group.Type == SupplierDiscountGroupType.Discount)
                        {
                            var disc = (100.0 - discount?.Value ?? 0.00) / 100.0;
                            UpdateValue<double>(item, x => x.ForeignCurrencyCost,
                                supplierProduct.ForeignCurrencyPrice * disc);
                            UpdateValue<double>(item, x => x.Cost, supplierProduct.TradePrice * disc);
                        }
                        else
                        {
                            // Don't actually know what to do with the Foreign Currency here
                            //UpdateValue<double>(item, x => x.ForeignCurrencyCost, supplierProduct.ForeignCurrencyPrice);
                            UpdateValue<double>(item, x => x.Cost, discount.Value);
                        }
                    }
                    else
                        UpdateValue<double>(item, x => x.Cost, supplierProduct.CostPrice);

                    continue;
                }
                
                // Check Specific Product Instance
                var productInstance = productInstances.FirstOrDefault(x =>
                    x.Product.ID == item.Product.ID
                    && x.Style.ID == item.Style.ID
                    && x.Dimensions.Equals(item.Dimensions));
                if (productInstance != null)
                    UpdateValue<double>(item, x => x.Cost, productInstance.NettCost);
                else
                    UpdateValue<double>(item, x => x.Cost, 0.0F);
                UpdateValue<double>(item, x => x.ForeignCurrencyCost, 0.0F);
                
            }
        }
    }
}