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

using System.Linq;
using InABox.Core;

namespace Comal.Classes
{
    [UserTracking(typeof(Quote))]
    public class QuoteContractProposal : Entity, IRemotable, IPersistent, IQuoteContractProposal, IManyToMany<QuoteContract, QuoteProposal>,
        ILicense<QuotesManagementLicense>
    {
        [NullEditor]
        [EntityRelationship(DeleteAction.Cascade)]
        public QuoteContractLink Contract { get; set; }
        private class QuoteContractProposalLookup : LookupDefinitionGenerator<QuoteProposal, QuoteContractProposal>
        {
            public override Filter<QuoteProposal> DefineFilter(QuoteContractProposal[] items)
            {
                if (items?.Any() != true)
                    return LookupFactory.DefineFilter<QuoteProposal>();
                return new Filter<QuoteProposal>(x => x.Quote.ID).IsEqualTo(items.First().Contract.Quote.ID);
            }

            public override Columns<QuoteProposal> DefineColumns()
            {
                return base.DefineColumns()
                    .Add(x=>x.ExTax)
                    .Add(x=>x.Tax)
                    .Add(x=>x.IncTax);
            }

            public override Columns<QuoteContractProposal> DefineFilterColumns()
                => new Columns<QuoteContractProposal>(ColumnTypeFlags.Required);
            
        }
        [LookupDefinition(typeof(QuoteContractProposalLookup))]
        [EntityRelationship(DeleteAction.Cascade)]
        [EditorSequence(1)]
        public QuoteProposalLink Proposal { get; set; }

        [NullEditor]
        public long Sequence { get; set; }
        
        [EditorSequence(2)]
        public double Price { get; set; }
        
        private class ExTaxFormula : ComplexFormulaGenerator<QuoteContractProposal, double>
        {
            public override IComplexFormulaNode<QuoteContractProposal, double> GetFormula() => If<double>(
                    x => Property(x => x.Price),
                    Condition.Equals,
                    x => Constant(0.0))
                .Then(Property(x=>x.Proposal.ExTax))
                .Else(Property(x=>x.Price));
        }
        
        [CurrencyEditor(Visible = Visible.Optional, Editable = Editable.Hidden, Summary = Summary.Sum)]
        [ComplexFormula(typeof(ExTaxFormula))]
        [EditorSequence(3)]
        public double ExTax { get; set; }
        
        private class TaxFormula : ComplexFormulaGenerator<QuoteContractProposal, double>
        {
            public override IComplexFormulaNode<QuoteContractProposal, double> GetFormula() => If<double>(
                    x => Property(x => x.Price),
                    Condition.Equals,
                    x => Constant(0.0))
                .Then(Property(x=>x.Proposal.Tax))
                .Else(Formula(FormulaOperator.Multiply, Property(x=>x.Price), Property(x=>x.Proposal.TaxCode.Rate), Constant(0.01)));
        }
        
        [CurrencyEditor(Visible = Visible.Optional, Editable = Editable.Hidden, Summary = Summary.Sum)]
        [ComplexFormula(typeof(TaxFormula))]
        [EditorSequence(5)]
        public double Tax { get; set; }

        
        private class IncTaxFormula : ComplexFormulaGenerator<QuoteContractProposal, double>
        {
            public override IComplexFormulaNode<QuoteContractProposal, double> GetFormula() => If<double>(
                    x => Property(x => x.Price),
                    Condition.Equals,
                    x => Constant(0.0))
                .Then(Property(x=>x.Proposal.IncTax))
                .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))]
        [EditorSequence(6)]
        public double IncTax { get; set; }
        
    }
}