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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using InABox.Clients;
using InABox.Core;
using PRSClasses;

namespace Comal.Classes
{

    
    public class StockHoldingLastStocktake : CoreAggregate<StockHolding, StockMovement, DateTime>
    {
        public override Expression<Func<StockMovement, DateTime>> Aggregate => x => x.Date;

        public override Filter<StockMovement> Filter => new Filter<StockMovement>(x => x.Type)
            .IsEqualTo(StockMovementType.StockTake);

        public override Dictionary<Expression<Func<StockMovement, object?>>, Expression<Func<StockHolding, object?>>> Links =>
            new Dictionary<Expression<Func<StockMovement, object?>>, Expression<Func<StockHolding, object?>>>()
            {
                { StockMovement => StockMovement.Product.ID, StockHolding => StockHolding.Product.ID },
                { StockMovement => StockMovement.Location.ID, StockHolding => StockHolding.Location.ID },
                { StockMovement => StockMovement.Style.ID, StockHolding => StockHolding.Style.ID },
                { StockMovement => StockMovement.Job.ID, StockHolding => StockHolding.Job.ID },
            }.AddRange(Dimensions.GetLinks<StockMovement, StockHolding>(x => x.Dimensions, x => x.Dimensions));

        public override AggregateCalculation Calculation => AggregateCalculation.Maximum;
    }
    
    [UserTracking(typeof(StockMovement))]
    [Unrecoverable]
    public class StockHolding : StockEntity, IRemotable, IPersistent, IOneToMany<StockLocation>, IOneToMany<Product>, 
        IStockHolding, ILicense<WarehouseLicense>
    {
        
        [Editable(Editable.Disabled)]
        [EditorSequence(1)]
        public StockLocationLink Location { get; set; }
        
        private class ProductLookupGenerator : LookupDefinitionGenerator<Product, StockHolding>
        {
            public override Filter<Product>? DefineFilter(StockHolding[] items)
                => LookupFactory.DefineFilter<Product>().And(x => x.NonStock).IsEqualTo(false);
        }
        [Editable(Editable.Disabled)]
        [EditorSequence(2)]
        [LookupDefinition(typeof(ProductLookupGenerator))]
        public override ProductLink Product { get; set; }
        
        [DimensionsEditor(typeof(StockDimensions))]
        [Editable(Editable.Disabled)]
        [EditorSequence(3)]
        public override StockDimensions Dimensions { get; set; }

        [Editable(Editable.Disabled)]
        [EditorSequence(4)]
        public ProductStyleLink Style { get; set; }
        
        [Editable(Editable.Disabled)]
        [EditorSequence(4)]
        public JobLink Job { get; set; }
        
        [DoubleEditor(Editable = Editable.Disabled, Summary = Summary.Sum)]
        [EditorSequence(5)]
        public double Units { get; set; }
        
        [DoubleEditor(Editable = Editable.Disabled, Summary = Summary.Sum)]
        [EditorSequence(6)]
        public double Qty { get; set; }
        
        [DoubleEditor(Editable = Editable.Disabled, Summary = Summary.Sum)]
        [EditorSequence(7)]
        public double Weight { get; set; }
        
        [DoubleEditor(Editable = Editable.Disabled, Summary = Summary.Sum)]
        [EditorSequence(8)]
        public double Value { get; set; }
        
        [DoubleEditor(Editable = Editable.Disabled)]
        [EditorSequence(9)]
        public double AverageValue { get; set; }
        
        [DoubleEditor(Editable = Editable.Disabled, Summary = Summary.Sum)]
        [EditorSequence(10)]
        public double Available { get; set; }

        [Formula(typeof(StockHoldingAllocatedFormula))]
        [DoubleEditor(Editable = Editable.Disabled, Summary = Summary.Sum)]
        [EditorSequence(11)]
        public double Allocated { get; set; }
        
        [Aggregate(typeof(StockHoldingLastStocktake))]
        [DateEditor(Editable = Editable.Disabled)]
        [EditorSequence(11)]
        public DateTime LastStockTake { get; set; }
        
        public static Column<IStockHolding>[] Columns => new Column<IStockHolding>[]
        {
            new Column<IStockHolding>(x => x.Job.ID),
            new Column<IStockHolding>(x => x.Location.ID),
            new Column<IStockHolding>(x => x.Product.ID),
            new Column<IStockHolding>(x => x.Style.ID),
            new Column<IStockHolding>(x => x.Dimensions.Unit.ID),
            new Column<IStockHolding>(x => x.Dimensions.Quantity),
            new Column<IStockHolding>(x => x.Dimensions.Length),
            new Column<IStockHolding>(x => x.Dimensions.Width),
            new Column<IStockHolding>(x => x.Dimensions.Height),
            new Column<IStockHolding>(x => x.Dimensions.Weight),
        };
        
        public static Filter<StockMovement>? GetFilter(IStockHolding holding)
        {
            var filter = new Filters<StockMovement>();
        
            foreach(var column in Columns)
            {
                filter.Add(new Filter<StockMovement>(column.Cast<StockMovement>()).IsEqualTo(CoreUtils.GetPropertyValue(holding, column.Property)));
            }
        
            return filter.Combine();
        }
    }

    internal class StockHoldingAllocatedFormula : IFormula<StockHolding, double>
    {
        public Expression<Func<StockHolding, double>> Value => x => x.Qty;

        public FormulaOperator Operator => FormulaOperator.Subtract;

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

        public FormulaType Type => FormulaType.Virtual;
    }

    public static class StockHoldingExtensions
    {
        /// <summary>
        /// Create a new stock movement from an <see cref="IStockHolding"/>, copying across the "key" properties;
        /// that is, the job, product, style, location and dimensions.
        /// </summary>
        /// <param name="holding"></param>
        /// <returns></returns>
        public static StockMovement CreateMovement(this IStockHolding holding)
        {
            var movement = new StockMovement();
            movement.Date = DateTime.Now;
            movement.Job.ID = holding.Job.ID;
            movement.Job.Synchronise(holding.Job);
            movement.Product.ID = holding.Product.ID;
            movement.Product.Synchronise(holding.Product);
            movement.Style.ID = holding.Style.ID;
            movement.Style.Synchronise(holding.Style);
            movement.Location.ID = holding.Location.ID;
            movement.Location.Synchronise(holding.Location);
            movement.Dimensions.CopyFrom(holding.Dimensions);
            return movement;
        }

        public static IEnumerable<StockHolding> GroupMovements(IEnumerable<StockMovement> movements)
        {
            var grouped = new List<StockHolding>();

            var toGroup = movements.AsList();
            while (toGroup.Count > 0)
            {
                var first = toGroup.First();
                var selected = toGroup.Where(x => x.IsEqualTo(first)).ToList();

                var holding = grouped.FirstOrDefault(x => x.IsEqualTo(first));
                if (holding == null)
                {
                    holding = new StockHolding();
                    holding.Location.ID = first.Location.ID;
                    holding.Product.ID = first.Product.ID;
                    holding.Style.ID = first.Style.ID;
                    holding.Job.ID = first.Job.ID;
                    holding.Dimensions.CopyFrom(first.Dimensions);
                }
                holding.Recalculate(selected);

                toGroup.RemoveAll(x => selected.Any(s => s.ID == x.ID));
            }
            return grouped;
        }

        public static bool IsEqualTo(this IStockHolding h1, IStockHolding h2)
        {
            return h1.Product.ID == h2.Product.ID
                && h1.Location.ID == h2.Location.ID
                && h1.Job.ID == h2.Job.ID
                && h1.Style.ID == h2.Style.ID
                && h1.Dimensions.Unit.ID == h2.Dimensions.Unit.ID
                && h1.Dimensions.Length.IsEffectivelyEqual(h2.Dimensions.Length)
                && h1.Dimensions.Width.IsEffectivelyEqual(h2.Dimensions.Width)
                && h1.Dimensions.Height.IsEffectivelyEqual(h2.Dimensions.Height)
                && h1.Dimensions.Quantity.IsEffectivelyEqual(h2.Dimensions.Quantity)
                && h1.Dimensions.Weight.IsEffectivelyEqual(h2.Dimensions.Weight);
        }

        public static void Recalculate(this StockHolding holding, IEnumerable<StockMovement> movements)
        {
            movements = movements.AsIList();
            var units = movements.Sum(x => x.Units);
            var cost = movements.Select(x => x.Units * x.Cost).Sum();
            var available = movements.Where(x => x.JobRequisitionItem.ID == Guid.Empty).Sum(x => x.Units);
            holding.Units = units;
            holding.Available = available;
            holding.Qty = movements.Sum(x => x.Units * x.Dimensions.Value);
            holding.Value = cost;

            holding.AverageValue = units.IsEffectivelyEqual(0.0F) ? 0.0d : cost / units;
            holding.Weight = holding.Qty * holding.Dimensions.Weight;
        }
        
        public static IEnumerable<JobRequisitionItem> LoadRequisitionItems(this StockHolding holding, bool alwaysshowunallocated = false)
        {
            var items = new Client<JobRequisitionItem>().Query(
                    new Filter<JobRequisitionItem>(x => x.ID).InQuery(StockHolding.GetFilter(holding), x => x.JobRequisitionItem.ID),
                    Columns.None<JobRequisitionItem>().Add(x => x.ID)
                        .Add(x => x.Job.ID)
                        .Add(x => x.Job.JobNumber)
                        .Add(x => x.Job.Name)
                        .Add(x => x.Requisition.Number)
                        .Add(x => x.Requisition.Description)
                        .Add(x => x.Qty))
                .ToObjects<JobRequisitionItem>();
            if (holding.Available > 0 || alwaysshowunallocated)
            {
                var requi = new JobRequisitionItem() { Qty = holding.Available };
                requi.Requisition.Description = "Unallocated Items";
                items = CoreUtils.One(requi).Concat(items);
            }

            return items;
        }

        public static IEnumerable<StockMovement> AdjustValue(this StockHolding holding, double unitvalue, StockMovementBatch batch)
        {
            List<StockMovement> _result = new List<StockMovement>();
            var movements = Client.Query(
                new Filter<StockMovement>(x => x.Location.ID).IsEqualTo(holding.Location.ID)
                    .And(x => x.Style.ID).IsEqualTo(holding.Style.ID)
                    .And(x => x.Dimensions).DimensionEquals(holding.Dimensions)
                    .And(x => x.Job.ID).IsEqualTo(holding.Job.ID),
                Columns.Required<StockMovement>().Add(x=>x.Units)
            ).Rows.ToObjects<StockMovement>().ToArray();
            var _allocations = movements.GroupBy(x => x.JobRequisitionItem.ID);
            foreach (var _allocation in _allocations)
            {
                var _units = _allocation.Sum(x => x.Units);
                if (!_units.IsEffectivelyEqual(0.0))
                {
                    var _transout = holding.CreateMovement();
                    _transout.Employee.ID = batch.Employee.ID;
                    _transout.Issued = _units;
                    _transout.Cost = holding.AverageValue;
                    _transout.Type = StockMovementType.TransferOut;
                    _transout.JobRequisitionItem.ID = _allocation.Key;
                    _transout.Batch.ID = batch.ID;
                    _transout.Notes = $"Adjusting Average Value from ${holding.AverageValue:F2} to ${unitvalue:F2}";
                    _result.Add(_transout);

                    var _transin = holding.CreateMovement();
                    _transin.Date = _transout.Date.AddTicks(1);
                    _transout.Employee.ID = batch.Employee.ID;
                    _transin.Received = _units;
                    _transin.Cost = unitvalue;
                    _transin.Type = StockMovementType.TransferIn;
                    _transin.Transaction = _transout.Transaction;
                    _transin.JobRequisitionItem.ID = _allocation.Key;
                    _transin.Batch.ID = batch.ID;
                    _transin.Notes = $"Adjusting Average Value from ${holding.AverageValue:F2} to ${unitvalue:F2}";
                    _result.Add(_transin);
                }
            }

            return _result;
        }
        
    //     public static IEnumerable<Tuple<Guid,double>> GetAllocations(this StockHolding holding, bool alwaysshowunallocated)
    //     {
    //         var table = new Client<StockMovement>().Query(
    //             StockHolding.GetFilter(holding),
    //             new Columns<StockMovement>(x => x.Units)
    //                 .Add(x => x.Location.ID)
    //                 .Add(x => x.Product.ID)
    //                 .Add(x => x.Style.ID)
    //                 .AddDimensionsColumns(x => x.Dimensions)
    //                 .Add(x => x.Cost)
    //                 .Add(x => x.OrderItem.ID)
    //                 .Add(x => x.JobRequisitionItem.ID)
    //             );
    //         
    //         var movements = table
    //             .ToObjects<StockMovement>();
    //         
    //         var groups = movements
    //             .GroupBy(x => new
    //             {
    //                 Location = x.Location.ID,
    //                 Product = x.Product.ID,
    //                 Style = x.Style.ID,
    //                 x.Dimensions,
    //                 x.Cost,
    //                 OrderItem = x.OrderItem.ID,
    //                 JobRequisitionItem = x.JobRequisitionItem.ID
    //             });
    //
    //         var result = groups
    //             .Select(x => new Tuple<Guid, double>(
    //                 x.Key.JobRequisitionItem,
    //                 x.Sum(x => x.Units))
    //             ).ToList();
    //         
    //         if (alwaysshowunallocated || !holding.Available.IsEffectivelyEqual(0))
    //             result.Add(new Tuple<Guid, double>(Guid.Empty,holding.Available));
    //         
    //         return result;
    //
    //     }
    
    }
    
}