prs/prs.classes/Entities/Invoice/Invoice.cs

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

namespace Comal.Classes
{
    // public class InvoiceChargeableHours : CoreAggregate<Invoice, Assignment, TimeSpan>
    // {
    //     public override Expression<Func<Assignment, TimeSpan>> Aggregate => x => x.ChargeableHours;
    //
    //     public override AggregateCalculation Calculation => AggregateCalculation.Sum;
    //
    //     public override Dictionary<Expression<Func<Assignment, object>>, Expression<Func<Invoice, object>>> Links =>
    //         new Dictionary<Expression<Func<Assignment, object>>, Expression<Func<Invoice, object>>>()
    //         {
    //             { Assignment => Assignment.Invoice.ID, Invoice => Invoice.ID }
    //         };
    //
    //     public override Filter<Assignment>? Filter => new Filter<Assignment>(x => x.Chargeable).IsEqualTo(true);
    // }

    public class InvoiceTax : CoreAggregate<Invoice, InvoiceLine, double>
    {
        public override Expression<Func<InvoiceLine, double>> Aggregate => x => x.Tax;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<InvoiceLine, object>>, Expression<Func<Invoice, object>>> Links =>
            new Dictionary<Expression<Func<InvoiceLine, object>>, Expression<Func<Invoice, object>>>()
            {
                { InvoiceLine => InvoiceLine.InvoiceLink.ID, Invoice => Invoice.ID }
            };
    }

    public class InvoiceIncTax : CoreAggregate<Invoice, InvoiceLine, double>
    {
        public override Expression<Func<InvoiceLine, double>> Aggregate => x => x.IncTax;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<InvoiceLine, object>>, Expression<Func<Invoice, object>>> Links =>
            new Dictionary<Expression<Func<InvoiceLine, object>>, Expression<Func<Invoice, object>>>()
            {
                { InvoiceLine => InvoiceLine.InvoiceLink.ID, Invoice => Invoice.ID }
            };
    }

    public class InvoiceAmountPaid : CoreAggregate<Invoice, InvoiceReceipt, double>
    {
        public override Expression<Func<InvoiceReceipt, double>> Aggregate => x => x.Amount;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<InvoiceReceipt, object>>, Expression<Func<Invoice, object>>> Links =>
            new Dictionary<Expression<Func<InvoiceReceipt, object>>, Expression<Func<Invoice, object>>>()
            {
                { InvoiceReceipt => InvoiceReceipt.InvoiceLink.ID, Invoice => Invoice.ID }
            };
    }

    public class InvoiceBalance : IFormula<Invoice, double>
    {
        public Expression<Func<Invoice, double>> Value => x => x.IncTax;
        public Expression<Func<Invoice, double>>[] Modifiers => new Expression<Func<Invoice, double>>[] { x => x.AmountPaid };
        public FormulaOperator Operator => FormulaOperator.Subtract;
        public FormulaType Type => FormulaType.Virtual;
    }

    public enum InvoiceType
    {
        Standard,
        ProgressClaim
    }

    [UserTracking("Accounts Receivable")]
    public class Invoice : Entity, IPersistent, IRemotable, INumericAutoIncrement<Invoice>, ILicense<AccountsReceivableLicense>, IExportable, IPostable
    {
        [EditorSequence(1)]
        [IntegerEditor(Visible = Visible.Default, Editable = Editable.Enabled)]
        public int Number { get; set; }

        [EditorSequence(2)]
        [DateEditor(Visible = Visible.Default, TodayVisible = true)]
        public DateTime Date { get; set; } = DateTime.Today;

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

        [EditorSequence(4)]
        public JobLink JobLink { get; set; }

        [EditorSequence(5)]
        public CustomerLink CustomerLink { get; set; }

        private class ClaimedFormula : ComplexFormulaGenerator<Invoice, double>
        {
            public override IComplexFormulaNode<Invoice, double> GetFormula() =>
                Aggregate<InvoiceLine>(AggregateCalculation.Sum, x => x.Property(x => x.ExTax))
                    .WithLink(x => x.InvoiceLink.ID, x => x.ID);
        }
        [EditorSequence(6)]
        [CurrencyEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [ComplexFormula(typeof(ClaimedFormula))]
        public double Claimed { get; set; }
        
        [EditorSequence(7)]
        [CurrencyEditor(Summary = Summary.Sum)]
        public double Retained { get; set; }
        
        private class ExTaxFormula : ComplexFormulaGenerator<Invoice, double>
        {
            public override IComplexFormulaNode<Invoice, double> GetFormula() =>
                Formula(FormulaOperator.Subtract, Property(x => x.Claimed), Property(x => x.Retained));
        }
        [EditorSequence(8)]
        [CurrencyEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [ComplexFormula(typeof(ExTaxFormula))]
        public double ExTax { get; set; }

        [EditorSequence(9)]
        [CurrencyEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(InvoiceTax))]
        public double Tax { get; set; }

        [EditorSequence(10)]
        [CurrencyEditor(Visible = Visible.Default, Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(InvoiceIncTax))]
        public double IncTax { get; set; }

        [EditorSequence(11)]
        [CurrencyEditor(Editable = Editable.Hidden)]
        [Aggregate(typeof(InvoiceAmountPaid))]
        public double AmountPaid { get; set; }

        /// <summary>
        /// Balance = <see cref="IncTax"/> - <see cref="AmountPaid"/>.
        /// </summary>
        [EditorSequence(12)]
        [CurrencyEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Formula(typeof(InvoiceBalance))]
        public double Balance { get; set; }
        
        [NullEditor]
        [LoggableProperty]
        [RequiredColumn]
        public PostedStatus PostedStatus { get; set; } = PostedStatus.NeverPosted;

        [NullEditor]
        [LoggableProperty]
        public DateTime Posted { get; set; }

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

        [NullEditor]
        public string PostedReference { get; set; }
        
        [NullEditor]
        public InvoiceType Type { get; set; }

        public Expression<Func<Invoice, int>> AutoIncrementField()
        {
            return x => x.Number;
        }

        public Filter<Invoice>? AutoIncrementFilter()
        {
            return null;
        }

        public override string ToString()
        {
            return string.Format("{0}: {1}", Number, Description);
        }

        protected override void DoPropertyChanged(string name, object? before, object? after)
        {
            base.DoPropertyChanged(name, before, after);
            if (name.Equals("IncTax"))
                Balance = (double)after - AmountPaid;
            else if (name.Equals("AmountPaid"))
                Balance = IncTax - (double)after;
        }
        
    }
}