prs/prs.classes/Entities/Stock/StockHolding/StockHoldingSummaryGenerator.cs

using System;
using InABox.Core;

namespace Comal.Classes
{
    public class StockHoldingSummaryGenerator : AutoEntitySummaryGenerator<StockHolding, StockMovement>
    {
        public override void Configure()
        {
            GroupBy(x=>x.Location.ID, x=>x.Location.ID);
            GroupBy(x=>x.Product.ID, x=>x.Product.ID);
            GroupBy(x=>x.Style.ID, x=>x.Style.ID);
            GroupBy(x=>x.Job.ID, x=>x.Job.ID);
            GroupBy(x=>x.Dimensions.Unit.ID, x=>x.Dimensions.Unit.ID);
            GroupBy(x=>x.Dimensions.Length, x=>x.Dimensions.Length);
            GroupBy(x=>x.Dimensions.Width, x=>x.Dimensions.Width);
            GroupBy(x=>x.Dimensions.Height, x=>x.Dimensions.Height);
            GroupBy(x=>x.Dimensions.Weight, x=>x.Dimensions.Weight);
            GroupBy(x=>x.Dimensions.Quantity,x=>x.Dimensions.Quantity);
            GroupBy(x=>x.Dimensions.Value, x=>x.Dimensions.Value);
            GroupBy(x=>x.Dimensions.UnitSize, x=>x.Dimensions.UnitSize);
            
            Aggregate(x => x.Units, AutoEntitySummaryAggregate.Sum, new UnitsFormula());
            Aggregate(x => x.Qty, AutoEntitySummaryAggregate.Sum, new QtyFormula());
            Aggregate(x=>x.Weight, AutoEntitySummaryAggregate.Sum, new WeightFormula());
            Aggregate(x=>x.Available, AutoEntitySummaryAggregate.Sum, new AvailableStockFomula());
            Aggregate(x=>x.Allocated, AutoEntitySummaryAggregate.Sum, new AllocatedStockFomula());
            Aggregate(x=>x.Value, AutoEntitySummaryAggregate.Sum, new TotalCostFomula());
            Aggregate(x =>x.LastStockTake, AutoEntitySummaryAggregate.Maximum, new StockTakeFormula());

            Having(new Filter<StockHolding>(x => x.Units).IsNotEqualTo(FilterConstant.Zero)
                .Or(x => x.Available).IsNotEqualTo(FilterConstant.Zero)
                .Or(x => x.Allocated).IsNotEqualTo(FilterConstant.Zero)
            );
        }


        
        
        private class UnitsFormula : ComplexFormulaGenerator<StockMovement, object?> 
        {
            public override IComplexFormulaNode<StockMovement, object?> GetFormula() => Formula(
                FormulaOperator.Subtract,
                Property(x => x.Received),
                Property(x => x.Issued)
            );
        }
        
        private class QtyFormula : ComplexFormulaGenerator<StockMovement, object?> 
        {
            public override IComplexFormulaNode<StockMovement, object?> GetFormula() => Formula(
                FormulaOperator.Multiply,
                Formula(
                    FormulaOperator.Subtract,
                        Property(x => x.Received),
                        Property(x => x.Issued)
                    ),
                Property(x=>x.Dimensions.Value)
            );
        }
        
        private class WeightFormula : ComplexFormulaGenerator<StockMovement, object?> 
        {
            public override IComplexFormulaNode<StockMovement, object?> GetFormula() => Formula(
                FormulaOperator.Multiply,
                Formula(
                    FormulaOperator.Subtract,
                    Property(x => x.Received),
                    Property(x => x.Issued)
                ),
                Property(x=>x.Dimensions.Weight)
            );
        }
        
        private class StockTakeFormula : ComplexFormulaGenerator<StockMovement, object?> 
        {
            public override IComplexFormulaNode<StockMovement, object?> GetFormula() => 
                If<StockMovement,StockMovementType,object?>(
                    Property<StockMovement,StockMovementType>(x=>x.Type),
                    Condition.Equals,
                    Constant<StockMovement,StockMovementType>(StockMovementType.StockTake)
                ).Then(
                    Property(x=>x.Date)
                ).Else(
                    Constant(DateTime.MinValue)
                );
            
        }
        
        private class AvailableStockFomula : ComplexFormulaGenerator<StockMovement, object?>
        {
            public override IComplexFormulaNode<StockMovement, object?> GetFormula() =>
                If<StockMovement,Guid,object?>(
                    Property<StockMovement, Guid>(x => x.JobRequisitionItem.ID),
                    Condition.Equals,
                    Constant<StockMovement, Guid>(Guid.Empty)
                ).Then(
                    Formula<StockMovement, object?>(
                        FormulaOperator.Subtract,
                        Property(x => x.Received),
                        Property(x => x.Issued)
                    )
                ).Else(
                    Constant(0.0)
                );
        }
        
        private class AllocatedStockFomula : ComplexFormulaGenerator<StockMovement, object?>
        {
            public override IComplexFormulaNode<StockMovement, object?> GetFormula() =>
                If<StockMovement,Guid,object?>(
                    Property<StockMovement, Guid>(x => x.JobRequisitionItem.ID),
                    Condition.NotEqual,
                    Constant<StockMovement, Guid>(Guid.Empty)
                ).Then(
                    Formula<StockMovement, object?>(
                        FormulaOperator.Subtract,
                        Property(x => x.Received),
                        Property(x => x.Issued)
                    )
                ).Else(
                    Constant(0.0)
                );
        }
        
        private class TotalCostFomula : ComplexFormulaGenerator<StockMovement, object?>
        {
            public override IComplexFormulaNode<StockMovement, object?> GetFormula() =>
                Formula(FormulaOperator.Multiply,
                    Formula<StockMovement, object?>(
                        FormulaOperator.Subtract,
                        Property(x => x.Received),
                        Property(x => x.Issued)
                    ),
                    Property(x => x.Cost)
                );
        }
        
    }
}