prs/prs.classes/Entities/Stock/StockSummary.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Runtime.CompilerServices;
using InABox.Core;

namespace Comal.Classes
{
    public class StockSummaryBOMAggregate : CoreAggregate<StockSummary, JobBillOfMaterialsItem, double>
    {
        public override Expression<Func<JobBillOfMaterialsItem, double>> Aggregate => x => x.Quantity;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<JobBillOfMaterialsItem, object>>, Expression<Func<StockSummary, object>>> Links =>
            new Dictionary<Expression<Func<JobBillOfMaterialsItem, object>>, Expression<Func<StockSummary, object>>>()
            {
                { JobBillOfMaterialsItem => JobBillOfMaterialsItem.Job.ID, summary => summary.Job.ID },
                { JobBillOfMaterialsItem => JobBillOfMaterialsItem.Product.ID, summary => summary.Product.ID },
                { JobBillOfMaterialsItem => JobBillOfMaterialsItem.Style.ID, summary => summary.Style.ID },
                { JobBillOfMaterialsItem => JobBillOfMaterialsItem.Dimensions.UnitSize, summary => summary.Dimensions.UnitSize }
            };

        public override Filter<JobBillOfMaterialsItem> Filter =>
            new Filter<JobBillOfMaterialsItem>(x => x.BillOfMaterials.Approved).IsNotEqualTo(DateTime.MinValue);
    }
    public class StockSummaryMinimumStockAggregate : CoreAggregate<StockSummary, ProductInstance, int>
    {
        public override Expression<Func<ProductInstance, int>> Aggregate => x => x.MinimumStockLevel;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<ProductInstance, object>>, Expression<Func<StockSummary, object>>> Links =>
            new Dictionary<Expression<Func<ProductInstance, object>>, Expression<Func<StockSummary, object>>>()
            {
                { JobBillOfMaterialsItem => JobBillOfMaterialsItem.Product.ID, summary => summary.Product.ID },
                { JobBillOfMaterialsItem => JobBillOfMaterialsItem.Style.ID, summary => summary.Style.ID },
                { JobBillOfMaterialsItem => JobBillOfMaterialsItem.Dimensions.UnitSize, summary => summary.Dimensions.UnitSize }
            };

    }

    public class StockSummaryIssuedAggregate : CoreAggregate<StockSummary, StockMovement, double>
    {
        public override Expression<Func<StockMovement, double>> Aggregate => x => x.Issued;

        public override Filter<StockMovement> Filter => new Filter<StockMovement>(x => x.IsTransfer).IsEqualTo(false)
            .And(x => x.Job.ID).IsNotEqualTo(Guid.Empty);

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<StockMovement, object>>, Expression<Func<StockSummary, object>>> Links =>
            new Dictionary<Expression<Func<StockMovement, object>>, Expression<Func<StockSummary, object>>>()
            {
                { StockMovement => StockMovement.Job.ID, summary => summary.Job.ID },
                { StockMovement => StockMovement.Product.ID, summary => summary.Product.ID },
                { StockMovement => StockMovement.Style.ID, summary => summary.Style.ID },
                { StockMovement => StockMovement.Dimensions.UnitSize, summary => summary.Dimensions.UnitSize }
            };
    }
    
    public class StockSummaryTotalRequiredFormula : IFormula<StockSummary, double>
    {
        public Expression<Func<StockSummary, double>> Value => x => x.BillOfMaterials;

        public Expression<Func<StockSummary, double>>[] Modifiers => new Expression<Func<StockSummary, double>>[]
        {
            x => x.Issued
        };

        public FormulaOperator Operator => FormulaOperator.Subtract;

        public FormulaType Type => FormulaType.Virtual;
    }
    
    public class StockSummaryNettRequiredFormula : IFormula<StockSummary, double>
    {
        public Expression<Func<StockSummary, double>> Value => x => x.TotalRequired;

        public Expression<Func<StockSummary, double>>[] Modifiers => new Expression<Func<StockSummary, double>>[]
        {
            x => 0.0
        };

        public FormulaOperator Operator => FormulaOperator.Maximum;

        public FormulaType Type => FormulaType.Virtual;
    }
    
    public class StockSummaryAllStockAggregate : CoreAggregate<StockSummary, StockMovement, double>
    {
        public override Expression<Func<StockMovement, double>> Aggregate => x => x.Units;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<StockMovement, object>>, Expression<Func<StockSummary, object>>> Links =>
            new Dictionary<Expression<Func<StockMovement, object>>, Expression<Func<StockSummary, object>>>()
            {
                { StockMovement => StockMovement.Product.ID, summary => summary.Product.ID },
                { StockMovement => StockMovement.Style.ID, summary => summary.Style.ID },
                { StockMovement => StockMovement.Dimensions.UnitSize, summary => summary.Dimensions.UnitSize }
            };
    }

    public class StockSummaryOrderAggregate : CoreAggregate<StockSummary, 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<StockSummary, object>>> Links =>
            new Dictionary<Expression<Func<PurchaseOrderItem, object>>, Expression<Func<StockSummary, object>>>()
            {
                { PurchaseOrderItem => PurchaseOrderItem.Product.ID, summary => summary.Product.ID },
                { PurchaseOrderItem => PurchaseOrderItem.Style.ID, summary => summary.Style.ID },
                { PurchaseOrderItem => PurchaseOrderItem.Dimensions.UnitSize, summary => summary.Dimensions.UnitSize }
            };

        public override Filter<PurchaseOrderItem> Filter => new Filter<PurchaseOrderItem>(x => x.ReceivedDate).IsEqualTo(DateTime.MinValue);
    }

    public class StockSummaryTotalStockFormula : IFormula<StockSummary, double>
    {
        public Expression<Func<StockSummary, double>> Value => x => x.AllStock;

        public Expression<Func<StockSummary, double>>[] Modifiers => new Expression<Func<StockSummary, double>>[]
        {
            x => x.OnOrder
        };

        public FormulaOperator Operator => FormulaOperator.Add;

        public FormulaType Type => FormulaType.Virtual;
    }

    public class StockSummaryBalanceAvailableFormula : IFormula<StockSummary, double>
    {
        public Expression<Func<StockSummary, double>> Value => x => x.TotalStock;

        public Expression<Func<StockSummary, double>>[] Modifiers => new Expression<Func<StockSummary, double>>[]
        {
            x => x.MinimumStockLevel,
            x => x.NettRequired
        };

        public FormulaOperator Operator => FormulaOperator.Subtract;

        public FormulaType Type => FormulaType.Virtual;
    }

    public class StockSummaryUnionGenerator : AutoEntityUnionGenerator<IJobMaterial>
    {
        protected override void Configure()
        {
            // 
            AddTable<ProductInstance>()
                .AddConstant<object?>(x => x.Job.ID, null);

            // BOM
            AddTable<JobBillOfMaterialsItem>(new Filter<JobBillOfMaterialsItem>(x => x.Job.ID).IsNotEqualTo(Guid.Empty));
            // Stock Holdings
            AddTable<StockMovement>(new Filter<StockMovement>(x => x.Job.ID).IsNotEqualTo(Guid.Empty));
            // On Order
            AddTable<PurchaseOrderItem>(new Filter<PurchaseOrderItem>(x => x.ReceivedDate).IsEqualTo(DateTime.MinValue));
        }

        public override bool Distinct => true;

        public override Column<IJobMaterial>[] IDColumns => new Column<IJobMaterial>[]
        {
            new Column<IJobMaterial>(x => x.Job.ID),
            new Column<IJobMaterial>(x => x.Product.ID),
            new Column<IJobMaterial>(x => x.Style.ID),
            new Column<IJobMaterial>(x => x.Dimensions.Unit.ID),
            new Column<IJobMaterial>(x => x.Dimensions.Quantity),
            new Column<IJobMaterial>(x => x.Dimensions.Length),
            new Column<IJobMaterial>(x => x.Dimensions.Width),
            new Column<IJobMaterial>(x => x.Dimensions.Height),
            new Column<IJobMaterial>(x => x.Dimensions.Weight)
        };
    }

    public class StockSummaryCalculatedField : IFormula<StockSummary, double>
    {
        public Expression<Func<StockSummary, double>> Value => x => 0.0;
        public Expression<Func<StockSummary, double>>[] Modifiers => new Expression<Func<StockSummary, double>>[] { };
        public FormulaOperator Operator => FormulaOperator.Constant;
        public FormulaType Type => FormulaType.Virtual;
    }


    [UserTracking(typeof(Product))]
    [AutoEntity(typeof(StockSummaryUnionGenerator))]
    public class StockSummary : StockEntity, IJobMaterial, IRemotable, IPersistent, ILicense<WarehouseLicense>
    {

        [NullEditor]
        public JobLink Job { get; set; }

        [EditorSequence(1)]
        public override ProductLink Product { get; set; }

        [EditorSequence(2)]
        public ProductStyleLink Style { get; set; }

        [EditorSequence(3)]
        [RequiredColumn]
        [DimensionsEditor(typeof(StockDimensions), AllowEditingUnit = false)]
        public override StockDimensions Dimensions { get; set; }

        [EditorSequence(4)]
        [DoubleEditor]
        [Aggregate(typeof(StockSummaryBOMAggregate))]
        public double BillOfMaterials { get; set; }

        [EditorSequence(5)]
        [IntegerEditor]
        [Aggregate(typeof(StockSummaryMinimumStockAggregate))]
        public int MinimumStockLevel { get; set; }

        [EditorSequence(6)]
        [Aggregate(typeof(StockSummaryIssuedAggregate))]
        [DoubleEditor]
        public double Issued { get; set; }
        
        [EditorSequence(7)]
        [Formula(typeof(StockSummaryTotalRequiredFormula))]
        public double TotalRequired { get; set; }
        
        [EditorSequence(8)]
        [Formula(typeof(StockSummaryNettRequiredFormula))]
        public double NettRequired { get; set; }

        [EditorSequence(9)]
        [Aggregate(typeof(StockSummaryAllStockAggregate))]
        [DoubleEditor]
        public double AllStock { get; set; }

        [EditorSequence(10)]
        [DoubleEditor]
        [Aggregate(typeof(StockSummaryOrderAggregate))]
        public double OnOrder { get; set; }
        
        [EditorSequence(11)]
        [Formula(typeof(StockSummaryTotalStockFormula))]
        [DoubleEditor]
        public double TotalStock { get; set; }

        [EditorSequence(12)]
        [DoubleEditor]
        [Formula(typeof(StockSummaryCalculatedField))]
        public double BalanceAvailable { get; set; }
    }
}