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>, ITaxable
    {
        [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.ProposalExTax)
                    .Add(x=>x.ProposalTax)
                    .Add(x=>x.ProposalIncTax);
            }

            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 bool OverridePrice { get; set; }
        
        [CurrencyEditor(Visible = Visible.Default, Summary = Summary.Sum)]
        [EditorSequence(3)]
        public double ExTax { get; set; }
        
        [EditorSequence(4)]
        public TaxCodeLink TaxCode { get; set; }
        
        [NullEditor]
        public double TaxRate { get; set; }

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

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

        static QuoteContractProposal()
        {
            LinkedProperties.Register<QuoteContractProposal, TaxCodeLink, double>(x => x.TaxCode, x => x.Rate, x => x.TaxRate);
            LinkedProperties.Register<QuoteContractProposal, QuoteProposalLink, double>(x => x.Proposal, x => x.ProposalExTax, x => x.ExTax, CheckProposalOverride);
            LinkedProperties.Register<QuoteContractProposal, QuoteProposalLink, double>(x => x.Proposal, x => x.ProposalTax, x => x.Tax, CheckProposalOverride);
            LinkedProperties.Register<QuoteContractProposal, QuoteProposalLink, double>(x => x.Proposal, x => x.ProposalIncTax, x => x.IncTax, CheckProposalOverride);

        }

        private static Result<double, string> CheckProposalOverride(QuoteContractProposal? proposal, double value)
        {
            if(proposal?.OverridePrice == true)
            {
                return Result.Error("");
            }
            else
            {
                return Result.Ok(value);
            }
        }
    }
}