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 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; }

        [NullEditor]
        [Obsolete("Notes is dumb, because Description exists")]
        public string Notes { get; set; }
        
        [EditorSequence(3)]
        public PurchaseOrderCategoryLink Category { get; set; }
        
        [TimestampEditor]
        [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; }

        [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(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]
        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 (ClosedDate != DateTime.MinValue)
                        ClosedDate = DateTime.MinValue;
                    if (IssuedDate != DateTime.MinValue)
                        IssuedDate = DateTime.MinValue;
                }
            }
            else
            {
                var closed = name.Equals("ClosedDate") ? (DateTime)after : ClosedDate;
                var issued = name.Equals("IssuedDate") ? (DateTime)after : IssuedDate;
                var status = PurchaseOrderStatus.Closed;
                if (closed != DateTime.MinValue)
                    status = PurchaseOrderStatus.Closed;
                else if (issued != 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)
                    .And(x=>x.Dimensions.UnitSize).IsEqualTo(items.First().Dimensions.UnitSize),
                new Columns<SupplierProduct>(x=>x.Product.ID)
                    .Add(x=>x.Job.ID)
                    .Add(x=>x.CostPrice)
                    .Add(x=>x.SupplierCode)
                    .Add(x=>x.SupplierDescription)
                    .Add(x=>x.Dimensions.Value)
            );
            query.Add(
                new Filter<Product>(x=>x.ID).InList(productids),
                new Columns<Product>(x=>x.ID)
                    .Add(x=>x.NettCost)
                    .Add(x=>x.Code)
                    .Add(x=>x.Name)
                    .Add(x=>x.Dimensions.Value)
            );
            query.Query();
                
            foreach (var item in items)
            {
                CoreRow? row = query.Get<SupplierProduct>()?.Rows.FirstOrDefault(r =>
                    (r.Get<SupplierProduct, Guid>(c => c.Product.ID) == item.Product.ID)
                    && (r.Get<SupplierProduct, Guid>(c => c.Job.ID) == item.Job.ID)
                );
                if (row == null)
                    row = query.Get<SupplierProduct>()?.Rows.FirstOrDefault(r =>
                        (r.Get<SupplierProduct, Guid>(c => c.Product.ID) == item.Product.ID)
                        && (r.Get<SupplierProduct, Guid>(c => c.Job.ID) == Guid.Empty)
                    );
                if (row != null)
                {
                    UpdateValue<String>(item, x => x.SupplierCode, row.Get<SupplierProduct, String>(c => c.SupplierCode));
                    UpdateValue<String>(item, x => x.Description, row.Get<SupplierProduct, String>(c => c.SupplierDescription));
                    UpdateValue<double>(item, x => x.Cost, row.Get<SupplierProduct, double>(c => c.CostPrice));
                }
                else
                {
                    row = query.Get<Product>()?.Rows.FirstOrDefault(r =>
                        (r.Get<Product, Guid>(c => c.ID) == item.Product.ID)
                    );
                    if (row != null)
                    {
                        UpdateValue<String>(item, x => x.SupplierCode, row.Get<Product, String>(c => c.Code));
                        UpdateValue<String>(item, x => x.Description, row.Get<Product, String>(c => c.Name));
                        if (String.Equals(row.Get<Product,String>(c=>c.Dimensions.UnitSize),items.First().Dimensions.UnitSize))
                            UpdateValue<double>(item, x => x.Cost, row.Get<Product, double>(c => c.NettCost));
                        else
                            UpdateValue<double>(item, x => x.Cost, 0.0F);
                    }
                    else
                    {
                        UpdateValue<String>(item, x => x.SupplierCode, "");
                        UpdateValue<String>(item, x => x.Description, "");
                        UpdateValue<double>(item, x => x.Cost, 0.0F);
                    }
                }

            }
        }
    }
}