prs/prs.classes/Entities/PurchaseOrder/PurchaseOrderItem.cs

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

namespace Comal.Classes
{
    public class PurchaseOrderItemFormCount : CoreAggregate<PurchaseOrderItem, PurchaseOrderItemForm, Guid>
    {
        public override Expression<Func<PurchaseOrderItemForm, Guid>> Aggregate => x => x.ID;

        public override AggregateCalculation Calculation => AggregateCalculation.Count;

        public override Dictionary<Expression<Func<PurchaseOrderItemForm, object>>, Expression<Func<PurchaseOrderItem, object>>> Links =>
            new Dictionary<Expression<Func<PurchaseOrderItemForm, object>>, Expression<Func<PurchaseOrderItem, object>>>()
            {
                { PurchaseOrderItemForm => PurchaseOrderItemForm.Parent.ID, PurchaseOrderItem => PurchaseOrderItem.ID }
            };
    }

    public class PurchaseOrderItemOpenForms : CoreAggregate<PurchaseOrderItem, PurchaseOrderItemForm, Guid>
    {
        public override Expression<Func<PurchaseOrderItemForm, Guid>> Aggregate => x => x.ID;

        public override AggregateCalculation Calculation => AggregateCalculation.Count;

        public override Dictionary<Expression<Func<PurchaseOrderItemForm, object>>, Expression<Func<PurchaseOrderItem, object>>> Links =>
            new Dictionary<Expression<Func<PurchaseOrderItemForm, object>>, Expression<Func<PurchaseOrderItem, object>>>()
            {
                { PurchaseOrderItemForm => PurchaseOrderItemForm.Parent.ID, PurchaseOrderItem => PurchaseOrderItem.ID }
            };

        public override Filter<PurchaseOrderItemForm> Filter => new Filter<PurchaseOrderItemForm>(x => x.FormCompleted).IsEqualTo(DateTime.MinValue)
            .Or(x => x.FormData).IsEqualTo("");
    }

    [UserTracking(typeof(Bill))]
    [Caption("Purchase Order Items")]
    public class PurchaseOrderItem : StockEntity, IRemotable, IPersistent, IOneToMany<PurchaseOrder>, ITaxable, IOneToMany<Consignment>, IOneToMany<Job>,
        ILicense<AccountsPayableLicense>, IJobMaterial
    {
        [EntityRelationship(DeleteAction.SetNull)]
        [NullEditor]
        [Obsolete("Replaced with Product", true)]
        public ProductLink ProductLink
        {
            get { return Product; }
            set { Product = value; }
        }

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

        [EntityRelationship(DeleteAction.SetNull)]
        [NullEditor]
        [Obsolete("Replaced with Style", true)]
        public ProductStyleLink StyleLink
        {
            get { return Style; }
            set { Style = value; }
        }

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

        [EntityRelationship(DeleteAction.SetNull)]
        [EditorSequence(3)]
        public JobLink Job { get; set; }

        [MemoEditor(Visible = Visible.Default)]
        [EditorSequence(4)]
        public string Description { get; set; }

        [CodeEditor(Visible = Visible.Default, Editable = Editable.Enabled)]
        [EditorSequence(5)]
        public string SupplierCode { get; set; }

        [DoubleEditor(Visible = Visible.Default)]
        [EditorSequence(6)]
        public double Qty { get; set; }

        [NullEditor]
        [Obsolete("Replaced with Dimensions", true)]
        public double UnitSize { get; set; }

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

        [CurrencyEditor(Visible = Visible.Default)]
        [EditorSequence(8)]
        public double Cost { get; set; }

        [EditorSequence(10)]
        public TaxCodeLink TaxCode { get; set; }

        [EditorSequence(14)]
        [CurrencyEditor(Visible = Visible.Optional, Editable = Editable.Hidden, Summary = Summary.Sum)]
        public double Balance { get; set; }

        [EditorSequence(15)]
        [EntityRelationship(DeleteAction.SetNull)]
        public ConsignmentLink Consignment { get; set; }

        [DateTimeEditor(Visible = Visible.Default)]
        [EditorSequence(16)]
        public DateTime ReceivedDate { get; set; }

        [TextBoxEditor(Visible = Visible.Optional)]
        [EditorSequence(17)]
        public string ReceivedReference { get; set; }

        [EditorSequence(18)]
        [IntegerEditor(Visible = Visible.Optional)]
        public int PORevision { get; set; }

        [DateTimeEditor(Visible = Visible.Default)]
        [EditorSequence(19)]
        public DateTime DueDate { get; set; }

        [NullEditor]
        public StockMovementLink StockMovement { get; set; }

        [EntityRelationship(DeleteAction.Cascade)]
        public PurchaseOrderLink PurchaseOrderLink { get; set; }

        [NullEditor]
        public string PONumber { get; set; }

        [NullEditor]
        [EntityRelationship(DeleteAction.SetNull)]
        public BillLineLink BillLine { get; set; }

        [NullEditor]
        [EntityRelationship(DeleteAction.SetNull)]
        public ManufacturingPacketLink Packet { get; set; }

        [NullEditor]
        [Aggregate(typeof(PurchaseOrderItemFormCount))]
        public int FormCount { get; set; }

        [NullEditor]
        [Aggregate(typeof(PurchaseOrderItemOpenForms))]
        public int OpenForms { get; set; }


        public StockLocationLink StockLocation { get; set; }

        [CurrencyEditor(Visible = Visible.Default, Summary = Summary.Sum)]
        [EditorSequence(9)]
        public double ExTax { get; set; }

        [EditorSequence(11)]
        [DoubleEditor(Visible = Visible.Default, Editable = Editable.Hidden)]
        public double TaxRate { get; set; }

        [EditorSequence(12)]
        [CurrencyEditor(Visible = Visible.Default, Editable = Editable.Hidden, Summary = Summary.Sum)]
        public double Tax { get; set; }

        [EditorSequence(13)]
        [CurrencyEditor(Visible = Visible.Default, Summary = Summary.Sum)]
        public double IncTax { get; set; }

        protected override void Init()
        {
            base.Init();

            PurchaseOrderLink = new PurchaseOrderLink(() => this);
            Consignment = new ConsignmentLink();

            Style = new ProductStyleLink();

            TaxCode = new TaxCodeLink(() => this);

            Packet = new ManufacturingPacketLink();

            Job = new JobLink();

            Qty = 1;

            BillLine = new BillLineLink();

            StockMovement = new StockMovementLink();

            StockLocation = new StockLocationLink();
        }

        static PurchaseOrderItem()
        {
            LinkedProperties.Register<PurchaseOrderItem, ProductLink, String>(x => x.Product, x => x.Code, x => x.SupplierCode);
            LinkedProperties.Register<PurchaseOrderItem, ProductLink, String>(x => x.Product, x => x.Name, x => x.Description);

            LinkedProperties.Register<PurchaseOrderItem, TaxCodeLink, Guid>(x => x.Product.TaxCode, x => x.ID, x => x.TaxCode.ID);
            LinkedProperties.Register<PurchaseOrderItem, TaxCodeLink, double>(x => x.Product.TaxCode, x => x.Rate, x => x.TaxCode.Rate);
            LinkedProperties.Register<PurchaseOrderItem, ProductStyleLink, Guid>(x => x.Product.DefaultStyle, x => x.ID, x => x.Style.ID);

            StockEntity.LinkStockDimensions<PurchaseOrderItem>();

            LinkedProperties.Register<PurchaseOrderItem, TaxCodeLink, double>(x => x.TaxCode, x => x.Rate, x => x.TaxRate);
        }

        private static Column<PurchaseOrderItem> qty = new Column<PurchaseOrderItem>(x => x.Qty);
        private static Column<PurchaseOrderItem> cost = new Column<PurchaseOrderItem>(x => x.Cost);
        private static Column<PurchaseOrderItem> extax = new Column<PurchaseOrderItem>(x => x.ExTax);
        private static Column<PurchaseOrderItem> inctax = new Column<PurchaseOrderItem>(x => x.IncTax);
        private static Column<PurchaseOrderItem> balance = new Column<PurchaseOrderItem>(x => x.Balance);
        private static Column<PurchaseOrderItem> received = new Column<PurchaseOrderItem>(x => x.ReceivedDate);

        private bool bChanging;

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

            bChanging = true;

            if (qty.IsEqualTo(name))
                ExTax = (double)after /* * Dimensions.Value */ * Cost;

            else if (cost.IsEqualTo(name))
                ExTax = Qty /* * Dimensions.Value */ * (double)after;

            else if (inctax.IsEqualTo(name))
                Balance = ReceivedDate.IsEmpty() ? (double)after : 0.00F;

            else if (received.IsEqualTo(name))
                Balance = ((DateTime)after).IsEmpty() ? IncTax : 0.00F;

            bChanging = false;
            base.DoPropertyChanged(name, before, after);
        }
    }
}