prs/prs.classes/Entities/Quote/QuoteContract/QuoteContract.cs

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

namespace Comal.Classes
{
    [UserTracking(typeof(Quote))]
    public class QuoteContract : Entity, IRemotable, IPersistent, IQuoteContract, ILicense<QuotesManagementLicense>, IOneToMany<Quote>
    {
        [NullEditor]
        [EntityRelationship(DeleteAction.Cascade)]
        public QuoteLink Quote { get; set; }

        [TextBoxEditor]
        [EditorSequence(1)]
        public string Description { get; set; }

        [CurrencyEditor]
        [EditorSequence(2)]
        public double Price { get; set; }
        
        [EditorSequence(3)]
        public TaxCodeLink TaxCode { get; set; }
        
        private class ExTaxFormula : ComplexFormulaGenerator<QuoteContract, double>
        {
            public override IComplexFormulaNode<QuoteContract, double> GetFormula() => If<double>(
                    x => x.Property(x => x.Price),
                    Condition.Equals,
                    x => Constant(0.0))
                .Then(Aggregate<QuoteContractProposal>(AggregateCalculation.Sum, x => x.Property(x => x.ExTax)).WithLink(x => x.Contract.ID, x => x.ID))
                .Else(Property(x => x.Price));
        }
        
        [CurrencyEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [ComplexFormula(typeof(ExTaxFormula))]
        public double ExTax { get; set; }

        private class TaxFormula : ComplexFormulaGenerator<QuoteContract, double>
        {
            public override IComplexFormulaNode<QuoteContract, double> GetFormula() => If<double>(
                    x => x.Property(x => x.Price),
                    Condition.Equals,
                    x => x.Constant(0.0))
                .Then(Aggregate<QuoteContractProposal>(AggregateCalculation.Sum, x => x.Property(x => x.Tax)).WithLink(x => x.Proposal.ID, x => x.ID))
                .Else(Formula(FormulaOperator.Multiply, Property(x => x.Price), Property(x => x.TaxCode.Rate), Constant(0.01)));
        }
        
        [CurrencyEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [ComplexFormula(typeof(TaxFormula))]
        public double Tax { get; set; }
        
        private class IncTaxFormula : ComplexFormulaGenerator<QuoteContract, double>
        {
            public override IComplexFormulaNode<QuoteContract, double> GetFormula() => If<double>(
                    x => x.Property(x => x.Price),
                    Condition.Equals,
                    x => x.Constant(0.0))
                .Then(Aggregate<QuoteContractProposal>(AggregateCalculation.Sum, x => x.Property(x => x.IncTax)).WithLink(x => x.Proposal.ID, x => x.ID))
                .Else(Formula(FormulaOperator.Add, Property(x => x.Price), Property(x => x.Tax)));
        }

        [CurrencyEditor(Visible = Visible.Default, Editable = Editable.Hidden, Summary = Summary.Sum)]
        [ComplexFormula(typeof(IncTaxFormula))]
        public double IncTax { get; set; }
        
        [DateTimeEditor]
        [EditorSequence(2)]
        public DateTime Confirmed { get; set; }
        
        
        private class QuoteContractJobScopeLookup : LookupDefinitionGenerator<JobScope, QuoteContract>
        {
            public override Filter<JobScope> DefineFilter(QuoteContract[] items)
            {
                if (items?.Any() != true)
                    return LookupFactory.DefineFilter<JobScope>();
                return new Filter<JobScope>(x => x.Job.ID).IsEqualTo(items.First().Quote.Job.ID);
            }

            public override Columns<QuoteContract> DefineFilterColumns()
                => new Columns<QuoteContract>(ColumnTypeFlags.Required);
        }
        [LookupDefinition(typeof(QuoteContractJobScopeLookup))]
        [EditorSequence(3)]
        public JobScopeLink JobScope { get; set; }
    }
}