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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
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.PurchaseOrderLink.ID, PurchaseOrder => PurchaseOrder.ID }
            };

        public override Filter<PurchaseOrderItem>? Filter => new Filter<PurchaseOrderItem>(x => x.ReceivedDate).IsEqualTo(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.PurchaseOrderLink.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.PurchaseOrderLink.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.PurchaseOrderLink.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.PurchaseOrderLink.ID, PurchaseOrder => PurchaseOrder.ID }
            };
    }

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

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

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

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

        [NotesEditor]
        [EditorSequence("Notes",1)]
        public string[] Notes { get; set; }
        
        [EditorSequence(3)]
        public PurchaseOrderCategoryLink Category { get; set; }
        
        [DateTimeEditor]
        [EditorSequence(4)]
        public DateTime IssuedDate { get; set; }

        [DateEditor]
        [EditorSequence(5)]
        public DateTime DueDate { get; set; }
        
        [EditorSequence("Additional",1)]
        public EmployeeLink RaisedBy { get; set; }
        
        [EditorSequence("Additional",2)]
        [TimestampEditor]
        public DateTime DataEntered { get; set; }
        
        [EditorSequence("Additional",3)]
        public EmployeeLink IssuedBy { get; set; }
        
        [TimestampEditor]
        [EditorSequence("Additional",4)]
        public DateTime ClosedDate { get; set; }
        
        [TimestampEditor]
        [EditorSequence("Additional",5)]
        public DateTime CancelledDate { get; set; }

        [EditorSequence(10)]
        [DoubleEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(PurchaseOrderExTax))]
        public double ExTax { get; set; }

        [EditorSequence(11)]
        [DoubleEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(PurchaseOrderTax))]
        public double Tax { get; set; }

        [EditorSequence(12)]
        [DoubleEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(PurchaseOrderIncTax))]
        public double IncTax { get; set; }

        [EditorSequence(13)]
        [DoubleEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(PurchaseOrderBalance))]
        public double Balance { get; set; }

        [EditorSequence(13)]
        [DoubleEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(PurchaseOrderUnreceivedQtyAggregate))]
        public double Unreceived { get; set; }

        [EditorSequence(14)]
        [EnumLookupEditor(typeof(PurchaseOrderStatus), Editable = Editable.Hidden)]
        public PurchaseOrderStatus Status { get; set; }
        
        //[CodeEditor(Visible = Visible.Default, Editable = Editable.Hidden)]
        [NullEditor]
        public string SupplierCode { get; set; }

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

        [DoNotPersist]
        [DoNotSerialize]
        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; }

        public Expression<Func<PurchaseOrder, string>> AutoIncrementField() => x => x.PONumber;
        public Filter<PurchaseOrder> AutoIncrementFilter() => null;
        public string AutoIncrementPrefix() => PONumberPrefix;
        public string AutoIncrementFormat() => "{0:D6}";

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

            if (name.Equals("Status"))
            {
                var status = (PurchaseOrderStatus)after;
                if (status.Equals(PurchaseOrderStatus.Closed))
                {
                    if (ClosedDate == DateTime.MinValue)
                        ClosedDate = DateTime.Now;
                    if (IssuedDate == DateTime.MinValue)
                        IssuedDate = DateTime.Now;
                }
                else if (status == PurchaseOrderStatus.Issued)
                {
                    if (ClosedDate != DateTime.MinValue)
                        ClosedDate = DateTime.MinValue;
                    if (IssuedDate == DateTime.MinValue)
                        IssuedDate = DateTime.Now;
                }
                else if(status == PurchaseOrderStatus.Cancelled)
                {
                    CancelledDate = DateTime.Now;
                }
                else
                {
                    if (ClosedDate != DateTime.MinValue)
                        ClosedDate = DateTime.MinValue;
                    if (IssuedDate != DateTime.MinValue)
                        IssuedDate = DateTime.MinValue;
                }
            }
            else
            {
                var status = PurchaseOrderStatus.Closed;
                if (CancelledDate != DateTime.MinValue)
                    status = PurchaseOrderStatus.Cancelled;
                else if (ClosedDate != DateTime.MinValue)
                    status = PurchaseOrderStatus.Closed;
                else if (IssuedDate != DateTime.MinValue)
                    status = PurchaseOrderStatus.Issued;
                else
                    status = PurchaseOrderStatus.Draft;
                if (Status != status)
                    Status = status;
            }

            bChanging = false;
        }

        static PurchaseOrder()
        {
            LinkedProperties.Register<PurchaseOrder, SupplierLink, String>(x => x.SupplierLink, x => x.Code, x => x.SupplierCode);
            LinkedProperties.Register<PurchaseOrder, SupplierLink, String>(x => x.SupplierLink, x => x.Name, x => x.SupplierName);
        }
        
        public static void UpdateCosts(IEnumerable<PurchaseOrderItem> items, Guid supplierid, Dictionary<String,object?> changes)
        {

            void UpdateValue<TType>(PurchaseOrderItem item,Expression<Func<PurchaseOrderItem, TType>> property, TType value)
            {
                CoreUtils.MonitorChanges(
                    item, 
                    () => CoreUtils.SetPropertyValue(item, CoreUtils.GetFullPropertyName(property, "."), value),
                    changes
                );
            }
            
            var productids = items.Where(x => x.Product.ID != Guid.Empty).Select(x => x.Product.ID).ToArray();
            MultiQuery query = new MultiQuery();
            query.Add(
                new Filter<SupplierProduct>(x=>x.SupplierLink.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.SupplierLink.ID)
                    .Add(x=>x.ForeignCurrencyPrice)
                    .Add(x=>x.CostPrice)
            );
            query.Add(
                new Filter<ProductInstance>(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 productInstances = query.Get<ProductInstance>().ToArray<ProductInstance>();
                
            foreach (var item in items)
            {
                //Check Supplier / Job Specific Pricing
                var supplierProduct = supplierProducts.FirstOrDefault(x =>
                    x.SupplierLink.ID == item.PurchaseOrderLink.SupplierLink.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)
                {
                    UpdateValue<string>(item, x => x.SupplierCode, supplierProduct.SupplierCode);
                    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.SupplierLink.ID == item.PurchaseOrderLink.SupplierLink.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)
                {
                    UpdateValue<string>(item, x => x.SupplierCode, supplierProduct.SupplierCode);
                    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 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);
                
            }
        }
    }
}