prs/prs.classes/Entities/Stock/StockMovement.cs

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

namespace Comal.Classes
{
    public class StockMovementDocumentCount : CoreAggregate<StockMovement, StockMovementBatchDocument, Guid>
    {
        public override Expression<Func<StockMovementBatchDocument, Guid>> Aggregate => x => x.ID;

        public override AggregateCalculation Calculation => AggregateCalculation.Count;

        public override Dictionary<Expression<Func<StockMovementBatchDocument, object>>, Expression<Func<StockMovement, object>>> Links =>
            new Dictionary<Expression<Func<StockMovementBatchDocument, object>>, Expression<Func<StockMovement, object>>>()
            {
                { StockMovementBatchDocument => StockMovementBatchDocument.EntityLink.ID, StockMovement => StockMovement.Batch.ID }
            };
    }

    public class StockMovementLink : EntityLink<StockMovement>
    {
        [NullEditor]
        public override Guid ID { get; set; }
    }

    
    public class StockMovementUnitsFormula : IFormula<StockMovement, double>
    {
        public Expression<Func<StockMovement, double>> Value => x => x.Received;

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

        public FormulaOperator Operator => FormulaOperator.Subtract;
        
        public FormulaType Type => FormulaType.Virtual;
    }
    
    public class StockMovementValueFormula : IFormula<StockMovement, double>
    {
        public Expression<Func<StockMovement, double>> Value => x => x.Units;

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

        public FormulaOperator Operator => FormulaOperator.Multiply;
        
        public FormulaType Type => FormulaType.Virtual;
    }
    
    public class StockMovementQuantityFormula : IFormula<StockMovement, double>
    {
        public Expression<Func<StockMovement, double>> Value => x => x.Units;

        public Expression<Func<StockMovement, double>>[] Modifiers => new Expression<Func<StockMovement, double>>[] { x => x.Dimensions.Value };

        public FormulaOperator Operator => FormulaOperator.Multiply;
        
        public FormulaType Type => FormulaType.Virtual;
    }

    public class StockMovementIsRemnantCondition : ICondition<StockHolding, double, object>
    {
        public Expression<Func<StockHolding, double>> Left => x => x.Dimensions.Value;

        public Condition Condition => Condition.LessThan;

        public Expression<Func<StockHolding, double>> Right => x => x.Product.DefaultInstance.Dimensions.Value;

        public Expression<Func<StockHolding, object>> True => x => true;

        public Expression<Func<StockHolding, object>> False => x => null;
        
        public ConditionType Type => ConditionType.Virtual;
    }

    [UserTracking("Warehousing")]
    public class StockMovement : StockEntity, IRemotable, IPersistent, IOneToMany<StockLocation>, IOneToMany<Product>, 
        ILicense<WarehouseLicense>, IStockHolding, IJobMaterial, IExportable, IImportable, IPostable
    {
        [DateTimeEditor]
        [EditorSequence(0)]
        public DateTime Date { get; set; }

        [EditorSequence(1)]
        [EntityRelationship(DeleteAction.Cascade)]
        [RequiredColumn]
        public override ProductLink Product { get; set; }

        [EditorSequence(2)]
        [EntityRelationship(DeleteAction.SetNull)]
        public ProductStyleLink Style { get; set; }

        [EntityRelationship(DeleteAction.SetNull)]
        public StockLocationLink Location { get; set; }

        [DoubleEditor(Summary = Summary.Sum)]
        [EditorSequence(3)]
        public double Received { get; set; }

        [DoubleEditor(Summary = Summary.Sum)]
        [EditorSequence(3)]
        public double Issued { get; set; }

        [DoubleEditor]
        [EditorSequence(4)]
        public double Balance { get; set; }
        
        // Units = Received - Issued
        [Formula(typeof(StockMovementUnitsFormula))]
        [EditorSequence(5)]
        [DoubleEditor(Visible=Visible.Optional, Editable = Editable.Hidden, Summary= Summary.Sum)]
        public double Units { get; set; }
        
        [EditorSequence(6)]
        [RequiredColumn]
        [DimensionsEditor(typeof(StockDimensions), AllowEditingUnit = false)]
        public override StockDimensions Dimensions { get; set; }
        
        // IsRemnant = Dimensions.Value < Product.Dimensions.Value
        [CheckBoxEditor(Editable = Editable.Hidden)]
        [Condition(typeof(StockMovementIsRemnantCondition))]
        [EditorSequence(7)]
        public bool IsRemnant { get; set; }
        
        // Qty = Units * Dimensions.Value
        [EditorSequence(8)]
        [Formula(typeof(StockMovementQuantityFormula))]
        [DoubleEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        public double Qty { get; set; }
        
        [EditorSequence(9)]
        [EntityRelationship(DeleteAction.SetNull)]
        public JobLink Job { get; set; }

        [EditorSequence(10)]
        [EntityRelationship(DeleteAction.SetNull)]
        public EmployeeLink Employee { get; set; }

        [MemoEditor]
        [EditorSequence(11)]
        public string Notes { get; set; }

        [EnumLookupEditor(typeof(StockMovementType))]
        public StockMovementType Type { get; set; }
        
        [NullEditor]
        public Guid Transaction { get; set; } = Guid.NewGuid();

        [NullEditor]
        public bool System { get; set; }

        [NullEditor]
        public bool IsTransfer { get; set; } = false;

        [NullEditor]
        public PurchaseOrderItemLink OrderItem { get; set; }

        [NullEditor]
        [RequiredColumn]
        public JobRequisitionItemLink JobRequisitionItem { get; set; }

        [Aggregate(typeof(StockMovementDocumentCount))]
        [NullEditor]
        public int Documents { get; set; }

        /// <summary>
        ///     Used to Group together movements (particularly images)
        ///     when transactions are uploaded from Mobile Devices
        /// </summary>
        [EntityRelationship(DeleteAction.Cascade)]
        public StockMovementBatchLink Batch { get; set; }
        
        [NullEditor]
        [Obsolete("Replaced with Dimensions", true)]
        public double UnitSize { get; set; }
        
        [CurrencyEditor(Visible = Visible.Default)]
        [EditorSequence(12)]
        public double Cost { get; set; } = 0.0;
        
        [CurrencyEditor(Visible = Visible.Optional, Editable = Editable.Hidden, Summary=Summary.Sum)]
        [Formula(typeof(StockMovementValueFormula))]
        public double Value { get; set; } = 0.0;

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

        static StockMovement()
        {
            StockEntity.LinkStockDimensions<StockMovement>();
            LinkedProperties.Register<StockMovement, ProductStyleLink, Guid>(x=>x.Product.DefaultInstance.Style, x => x.ID, x => x.Style.ID);
            //LinkedProperties.Register<StockMovement, ProductLink, double>(x => x.Product, x => x.AverageCost, x => x.Cost);
        }

        private static Column<StockMovement> unitsize = new Column<StockMovement>(x => x.Dimensions.Value);
        private static Column<StockMovement> issued = new Column<StockMovement>(x => x.Issued);
        private static Column<StockMovement> received = new Column<StockMovement>(x => x.Received);

        private bool bChanging;

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

            if (unitsize.IsEqualTo(name))
            {
                bChanging = true;
                Qty = (Received - Issued) * (double)after;
                bChanging = false;
            }

            else if (issued.IsEqualTo(name))
            {
                bChanging = true;
                Units = Received - (double)after;
                Qty = Units * Dimensions.Value;
                bChanging = false;
            }

            else if (received.IsEqualTo(name))
            {
                bChanging = true;
                Units = ((double)after - Issued);
                Qty = Units * Dimensions.Value;
                bChanging = false;
            }

            else
                base.DoPropertyChanged(name, before, after);
        }
    }
}