prs/prs.classes/Entities/Job/JobScopes/JobScope.cs

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

namespace Comal.Classes
{
    
    public class JobScopeInvoiceExTax : CoreAggregate<JobScope, InvoiceLine, double>
    {
        public override Expression<Func<InvoiceLine, double>> Aggregate => x => x.ExTax;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

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

    public class JobScopeInvoiceTax : CoreAggregate<JobScope, 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<JobScope, object>>> Links =>
            new Dictionary<Expression<Func<InvoiceLine, object>>, Expression<Func<JobScope, object>>>()
            {
                { InvoiceLine => InvoiceLine.Scope.ID, JobPrice => JobPrice.ID }
            };
    }

    public class JobScopeInvoiceIncTax : CoreAggregate<JobScope, 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<JobScope, object>>> Links =>
            new Dictionary<Expression<Func<InvoiceLine, object>>, Expression<Func<JobScope, object>>>()
            {
                { InvoiceLine => InvoiceLine.Scope.ID, JobPrice => JobPrice.ID }
            };
    }

    public class JobScopeUninvoicedExTax : IFormula<JobScope, double>
    {
        public Expression<Func<JobScope, double>> Value => x => x.ExTax;
        public Expression<Func<JobScope, double>>[] Modifiers => new Expression<Func<JobScope, double>>[] { x => x.InvoiceExTax };
        public FormulaOperator Operator => FormulaOperator.Subtract;
        public FormulaType Type => FormulaType.Virtual;
    }

    public class JobScopeActivityCost : CoreAggregate<JobScope, JobScopeActivity, double>
    {
        public override Expression<Func<JobScopeActivity, double>> Aggregate => x => x.Cost;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<JobScopeActivity, object?>>, Expression<Func<JobScope, object?>>> Links =>
            new Dictionary<Expression<Func<JobScopeActivity, object>>, Expression<Func<JobScope, object>>>()
            {
                { JobScopeActivity => JobScopeActivity.Scope.ID, JobScope => JobScope.ID }
            };
    }
    
    public class JobScopeActivitySell : CoreAggregate<JobScope, JobScopeActivity, double>
    {
        public override Expression<Func<JobScopeActivity, double>> Aggregate => x => x.Sell;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<JobScopeActivity, object?>>, Expression<Func<JobScope, object?>>> Links =>
            new Dictionary<Expression<Func<JobScopeActivity, object>>, Expression<Func<JobScope, object>>>()
            {
                { JobScopeActivity => JobScopeActivity.Scope.ID, JobScope => JobScope.ID }
            };
    }
    
    public class JobScopeCostCentreCost : CoreAggregate<JobScope, JobScopeCostCentre, double>
    {
        public override Expression<Func<JobScopeCostCentre, double>> Aggregate => x => x.Cost;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<JobScopeCostCentre, object?>>, Expression<Func<JobScope, object?>>> Links =>
            new Dictionary<Expression<Func<JobScopeCostCentre, object>>, Expression<Func<JobScope, object>>>()
            {
                { JobScopeCostCentre => JobScopeCostCentre.Scope.ID, JobScope => JobScope.ID }
            };
    }
    
    public class JobScopeCostCentreSell : CoreAggregate<JobScope, JobScopeCostCentre, double>
    {
        public override Expression<Func<JobScopeCostCentre, double>> Aggregate => x => x.Sell;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<JobScopeCostCentre, object?>>, Expression<Func<JobScope, object?>>> Links =>
            new Dictionary<Expression<Func<JobScopeCostCentre, object>>, Expression<Func<JobScope, object>>>()
            {
                { JobScopeCostCentre => JobScopeCostCentre.Scope.ID, JobScope => JobScope.ID }
            };
    }

    
    public interface IJobScopedItem
    {
        JobLink JobLink { get; set; }
        JobScopeLink JobScope { get; set; }
    }

    [UserTracking(typeof(Job))]
    public class JobScope : Entity, IRemotable, IPersistent, ITaxable, IStringAutoIncrement<JobScope>, ILicense<ProjectManagementLicense>
    {
        [NullEditor]
        public InternalJobLink Job { get; set; }

        [EnumLookupEditor(typeof(JobScopeType), Visible = Visible.Default)]
        [EditorSequence(1)]
        public JobScopeType Type { get; set; } = JobScopeType.Variation;

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

        [MemoEditor(Visible = Visible.Default)]
        [EditorSequence(3)]
        public string Description { get; set; }
        
        [EditorSequence(4)]
        [TextBoxEditor]
        public string SourceRef{ get; set; } 
        
        private class JobScopeLookup : LookupDefinitionGenerator<JobScope, JobScope>
        {
            public override Filter<JobScope> DefineFilter(JobScope[] items)
            {
                if (items?.Any() != true)
                    return Filter.None<JobScope>();

                var data = Client.Query(
                    Filter<JobScope>.Where(x =>x.Job.ID).IsEqualTo(items.First().Job.ID),
                    Columns.None<JobScope>().Add(x => x.ID).Add(x => x.Parent.ID));

                var nodes = new CoreTreeNodes<Guid>(Guid.Empty);
                nodes.Load<JobScope>(data, x => x.ID, x => x.Parent.ID);

                var exclusions = items.SelectMany(x => nodes.GetChildren(x.ID)).ToArray();
                var ids = exclusions.Select(x => x.ID).ToArray();
                return Filter<JobScope>.Where(x =>x.Job.ID).IsEqualTo(items.First().Job.ID).And(x => x.ID).NotInList(ids);
            }

            public override Columns<JobScope> DefineFilterColumns()
                => Columns.None<JobScope>().Add(x => x.ID).Add(x => x.Parent.ID).Add(x => x.Number);
        }
        
        [LookupDefinition(typeof(JobScopeLookup))]
        [EditorSequence(4)]
        public JobScopeLink Parent { get; set; }

        private class MaterialsCostAggregate : ComplexFormulaGenerator<JobScope, double>
        {
            public override IComplexFormulaNode<JobScope, double> GetFormula()
                => Aggregate<JobScopeCostCentre>(AggregateCalculation.Sum, x => x.Property(p => p.Cost))
                    .WithLink(x => x.Scope.ID, x => x.ID);
        }
        
        [ComplexFormula(typeof(MaterialsCostAggregate))]
        [EditorSequence(5)]
        [CurrencyEditor(Summary = Summary.Sum, Visible = Visible.Optional, Editable =  Editable.Hidden)]
        public double MaterialsCost { get; set; }
        
        private class MaterialsSellAggregate : ComplexFormulaGenerator<JobScope, double>
        {
            public override IComplexFormulaNode<JobScope, double> GetFormula()
                => Aggregate<JobScopeCostCentre>(AggregateCalculation.Sum, x => x.Property(p => p.Sell))
                    .WithLink(x => x.Scope.ID, x => x.ID);
        }
        
        [ComplexFormula(typeof(MaterialsSellAggregate))]
        [EditorSequence(6)]
        [CurrencyEditor(Summary = Summary.Sum, Visible = Visible.Optional, Editable =  Editable.Hidden)]
        public double MaterialsSell { get; set; }
        
        private class MaterialsMarginFormula : ComplexFormulaGenerator<JobScope, double>
        {
            public override IComplexFormulaNode<JobScope, double> GetFormula() => 
                Formula(
                    FormulaOperator.Divide, 
                    Formula(
                        FormulaOperator.Multiply, 
                        Formula(
                            FormulaOperator.Subtract, 
                            Property(x=>x.MaterialsSell), 
                            Property(c => c.MaterialsCost)
                        ), 
                        Constant(100.0F)
                    ),  
                    Property(c=>c.MaterialsSell)
                );
        }
        
        [ComplexFormula(typeof(MaterialsMarginFormula))]
        [EditorSequence(7)]
        [DoubleEditor(Visible = Visible.Optional, Editable =  Editable.Hidden)]
        public double MaterialMargin { get; set; }
        
        private class MaterialsMarkupFormula : ComplexFormulaGenerator<JobScope, double>
        {
            public override IComplexFormulaNode<JobScope, double> GetFormula() => 
                Formula(
                    FormulaOperator.Divide, 
                    Formula(
                        FormulaOperator.Multiply, 
                        Formula(
                            FormulaOperator.Subtract, 
                            Property(x=>x.MaterialsSell), 
                            Property(c => c.MaterialsCost)
                        ), 
                        Constant(100.0F)
                    ),  
                    Property(c=>c.MaterialsCost)
                );
        }
        
        [ComplexFormula(typeof(MaterialsMarkupFormula))]
        [EditorSequence(8)]
        [DoubleEditor(Visible = Visible.Optional, Editable =  Editable.Hidden)]
        public double MaterialMarkup { get; set; }
        
        private class LabourCostAggregate : ComplexFormulaGenerator<JobScope, double>
        {
            public override IComplexFormulaNode<JobScope, double> GetFormula()
                => Aggregate<JobScopeActivity>(AggregateCalculation.Sum, x => x.Property(p => p.Cost))
                    .WithLink(x => x.Scope.ID, x => x.ID);
        }
        
        [ComplexFormula(typeof(LabourCostAggregate))]
        [EditorSequence(9)]
        [CurrencyEditor(Summary = Summary.Sum, Visible = Visible.Optional, Editable =  Editable.Hidden)]
        public double LabourCost { get; set; }
        
        private class LabourSellAggregate : ComplexFormulaGenerator<JobScope, double>
        {
            public override IComplexFormulaNode<JobScope, double> GetFormula()
                => Aggregate<JobScopeActivity>(AggregateCalculation.Sum, x => x.Property(p => p.Sell))
                    .WithLink(x => x.Scope.ID, x => x.ID);
        }
        
        [ComplexFormula(typeof(LabourSellAggregate))]
        [EditorSequence(10)]
        [CurrencyEditor(Summary = Summary.Sum, Visible = Visible.Optional, Editable =  Editable.Hidden)]
        public double LabourSell { get; set; }
        
        private class LabourMarginFormula : ComplexFormulaGenerator<JobScope, double>
        {
            public override IComplexFormulaNode<JobScope, double> GetFormula() => 
                Formula(
                    FormulaOperator.Divide, 
                    Formula(
                        FormulaOperator.Multiply, 
                        Formula(
                            FormulaOperator.Subtract, 
                            Property(x=>x.LabourSell), 
                            Property(c => c.LabourCost)
                        ), 
                        Constant(100.0F)
                    ),  
                    Property(c=>c.LabourSell)
                );
        }
        
        [ComplexFormula(typeof(LabourMarginFormula))]
        [EditorSequence(11)]
        [DoubleEditor(Visible = Visible.Optional, Editable =  Editable.Hidden)]
        public double LabourMargin { get; set; }
        
        private class LabourMarkupFormula : ComplexFormulaGenerator<JobScope, double>
        {
            public override IComplexFormulaNode<JobScope, double> GetFormula() => 
                Formula(
                    FormulaOperator.Divide, 
                    Formula(
                        FormulaOperator.Multiply, 
                        Formula(
                            FormulaOperator.Subtract, 
                            Property(x=>x.LabourSell), 
                            Property(c => c.LabourCost)
                        ), 
                        Constant(100.0F)
                    ),  
                    Property(c=>c.LabourCost)
                );
        }
        
        [ComplexFormula(typeof(LabourMarkupFormula))]
        [EditorSequence(12)]
        [DoubleEditor(Visible = Visible.Optional, Editable =  Editable.Hidden)]
        public double LabourMarkup { get; set; }
        
        
        [CurrencyEditor(Summary = Summary.Sum, Visible = Visible.Default)]
        [EditorSequence(13)]
        public double ExTax { get; set; }

        [EditorSequence(14)]
        public TaxCodeLink TaxCode { get; set; }
        
        [CurrencyEditor(Summary = Summary.Sum, Visible = Visible.Optional)]
        [EditorSequence(15)]
        public double IncTax { get; set; }

        [EditorSequence(16)]
        public JobScopeStatusLink Status { get; set; }
        
        private class InvoiceExTaxAggregate : ComplexFormulaGenerator<JobScope, double>
        {
            public override IComplexFormulaNode<JobScope, double> GetFormula()
                => Aggregate<InvoiceLine>(AggregateCalculation.Sum, x => x.Property(p => p.ExTax))
                    .WithLink(x => x.Scope.ID, x => x.ID);
        }
        
        [ComplexFormula(typeof(LabourSellAggregate))]
        
        [Aggregate(typeof(JobScopeInvoiceExTax))]
        [EditorSequence(17)]
        [CurrencyEditor(Visible = Visible.Default, Editable = Editable.Hidden, Summary = Summary.Sum)]
        public double InvoiceExTax { get; set; }

        [Aggregate(typeof(JobScopeInvoiceTax))]
        [EditorSequence(18)]
        [CurrencyEditor(Visible = Visible.Optional, Editable = Editable.Hidden, Summary = Summary.Sum)]
        public double InvoiceTax { get; set; }

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

        [Formula(typeof(JobScopeUninvoicedExTax))]
        [EditorSequence(20)]
        [CurrencyEditor(Visible = Visible.Optional, Editable = Editable.Hidden, Summary = Summary.Sum)]
        public double UninvoiceIncTax { get; set; }

        private class MaterialsExTaxFormula : ComplexFormulaGenerator<JobScope, double>
        {
            public override IComplexFormulaNode<JobScope, double> GetFormula() =>
                Formula(FormulaOperator.Subtract,
                    Aggregate<StockMovement>(AggregateCalculation.Sum, x => x.Property(x => x.Value))
                        .WithFilter(
                            Filter<StockMovement>.Where(x => x.Type).IsEqualTo(StockMovementType.Issue))
                        .WithLink(x => x.JobScope.ID, x => x.ID));
        }
        [CurrencyEditor(Visible = Visible.Optional, Editable = Editable.Hidden, Summary = Summary.Sum)]
        [ComplexFormula(typeof(MaterialsExTaxFormula))]
        public double MaterialsExTax { get; set; }
        
        private class UninvoicedMaterial : ComplexFormulaGenerator<JobScope, double>
        {
            public override IComplexFormulaNode<JobScope, double> GetFormula() =>
                Formula(FormulaOperator.Subtract,
                    Aggregate<StockMovement>(AggregateCalculation.Sum, x => x.Property(x => x.Value))
                        .WithFilter(
                            Filter<StockMovement>.Where(x => x.Invoice.ID).IsEqualTo(Guid.Empty)
                                .And(x => x.Type).IsEqualTo(StockMovementType.Issue))
                        .WithLink(x => x.JobScope.ID, x => x.ID));
        }
        [CurrencyEditor(Visible = Visible.Optional, Editable = Editable.Hidden, Summary = Summary.Sum)]
        [ComplexFormula(typeof(UninvoicedMaterial))]
        public double UninvoicedMaterialsExTax { get; set; }

        public Expression<Func<JobScope, string>> AutoIncrementField() => x => x.Number;
        public Filter<JobScope> AutoIncrementFilter() =>  Filter<JobScope>.Where(x => x.Job.ID).IsEqualTo(Job.ID);
        public String AutoIncrementPrefix() => "";
        public string AutoIncrementFormat() => "{0:D3}";
        public int AutoIncrementDefault() => 0;
        
        [NullEditor]
        public double TaxRate { get; set; }

        [NullEditor(Summary = Summary.Sum, Visible = Visible.Optional)]
        public double Tax { get; set; }
        
        static JobScope()
        {
            LinkedProperties.Register<JobScope, TaxCodeLink, double>(x=>x.TaxCode, x => x.Rate, x => x.TaxRate);
        }

        public static void LinkScopeProperties<TScoped>() where TScoped : class, IJobScopedItem
        {
            LinkedProperties.Register<TScoped, JobScopeLink, Guid>(ass => ass.JobLink.DefaultScope, scope => scope.ID, ass => ass.JobScope.ID);
            LinkedProperties.Register<TScoped, JobScopeLink, String>(ass => ass.JobLink.DefaultScope, scope => scope.Number, ass => ass.JobScope.Number);
            LinkedProperties.Register<TScoped, JobScopeLink, String>(ass => ass.JobLink.DefaultScope, scope => scope.Description, ass => ass.JobScope.Description);
        }
    }
}