prs/prs.classes/Entities/Job/JobStage.cs

using System;
using System.ComponentModel;
using System.Linq;
using InABox.Core;

namespace Comal.Classes
{
    public class JobStageJobLookup : LookupDefinitionGenerator<JobStage, Job>
    {
        public override Filter<JobStage> DefineFilter(Job[] items)
        {
            if (items.Length == 1)
                return new Filter<JobStage>(x => x.Job.ID).IsEqualTo(items.First().ID).And(x => x.IsHeader).IsEqualTo(false);
            return new Filter<JobStage>(x => x.ID).IsEqualTo(Guid.Empty);
        }

        public override Columns<Job> DefineFilterColumns()
            => Columns.None<Job>().Add(x => x.ID);
    }

    [UserTracking("Gantt Charts")]
    public class JobStage : Entity, IRemotable, IPersistent, ISequenceable, INotifyPropertyChanged, ILicense<ProjectManagementLicense>, IOneToMany<Job>,
        IChildEntityLookup<Job, JobStage, JobStageJobLookup>
    {
        private bool bChanging;

        [EntityRelationship(DeleteAction.Cascade)]
        [EditorSequence(0)]
        public JobLink Job { get; set; }

        [NullEditor]
        public bool IsHeader { get; set; }

        private class JobStageLookup : LookupDefinitionGenerator<JobStage, JobStage>
        {
            public override Filter<JobStage> DefineFilter(JobStage[] items)
            {
                if (items.Length == 1)
                    return new Filter<JobStage>(x => x.Job.ID).IsEqualTo(items.First().Job.ID).And(x => x.IsHeader).IsEqualTo(false);
                return new Filter<JobStage>(x => x.ID).IsEqualTo(Guid.Empty);
            }

            public override Columns<JobStage> DefineFilterColumns()
                => Columns.None<JobStage>().Add(x => x.Job.ID);
        }
        [LookupDefinition(typeof(JobStageLookup))]
        [NullEditor]
        public JobStageLink Parent { get; set; }

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

        [EditorSequence(2)]
        [NullEditor]
        public JobStageCalendarLink Calendar { get; set; }

        [DateEditor]
        [EditorSequence(3)]
        public DateTime StartDate { get; set; }

        [IntegerEditor]
        [EditorSequence(4)]
        public int WorkDays { get; set; }

        [DateEditor]
        [EditorSequence(5)]
        public DateTime EndDate { get; set; }

        [DoubleEditor]
        [EditorSequence(9)]
        public double SupervisionHours { get; set; }

        [DoubleEditor]
        [EditorSequence(10)]
        public double TradesHours { get; set; }

        [DoubleEditor]
        [EditorSequence(11)]
        public double ApprenticeHours { get; set; }

        [DoubleEditor(Editable = Editable.Disabled)]
        [EditorSequence("Summary", 1)]
        public double TotalHours { get; set; }

        [DoubleEditor(Editable = Editable.Disabled)]
        [EditorSequence("Summary", 2)]
        public double Supervisors { get; set; }

        [DoubleEditor(Editable = Editable.Disabled)]
        [EditorSequence("Summary", 3)]
        public double Tradespersons { get; set; }

        [DoubleEditor(Editable = Editable.Disabled)]
        [EditorSequence("Summary", 4)]
        public double Apprentices { get; set; }

        [NullEditor]
        public long Sequence { get; set; }

        protected override void DoPropertyChanged(string name, object? before, object? after)
        {
            base.DoPropertyChanged(name, before, after);

            if (bChanging)
                return;
            bChanging = true;

            if (name.Equals("WorkDays"))
            {
                EndDate = Calendar.CalculateEndDate(StartDate, (int)after);
                Tradespersons = Calendar.CalculateWorkers(StartDate, EndDate, TradesHours);
                Supervisors = Calendar.CalculateWorkers(StartDate, EndDate, SupervisionHours);
                Apprentices = Calendar.CalculateWorkers(StartDate, EndDate, ApprenticeHours);
            }

            else if (name.Equals("EndDate"))
            {
                WorkDays = Calendar.CalculateWorkDays(StartDate, (DateTime)after);
                Tradespersons = Calendar.CalculateWorkers(StartDate, (DateTime)after, TradesHours);
                Supervisors = Calendar.CalculateWorkers(StartDate, (DateTime)after, SupervisionHours);
                Apprentices = Calendar.CalculateWorkers(StartDate, (DateTime)after, ApprenticeHours);
            }

            else if (name.Equals("TradesHours"))
            {
                Tradespersons = Calendar.CalculateWorkers(StartDate, EndDate, (double)after);
                TotalHours = SupervisionHours + (double)after + ApprenticeHours;
            }

            else if (name.Equals("SupervisionHours"))
            {
                Supervisors = Calendar.CalculateWorkers(StartDate, EndDate, (double)after);
                TotalHours = (double)after + TradesHours + ApprenticeHours;
            }

            else if (name.Equals("ApprenticeHours"))
            {
                Apprentices = Calendar.CalculateWorkers(StartDate, EndDate, (double)after);
                TotalHours = SupervisionHours + TradesHours + (double)after;
            }

            bChanging = false;
        }
    }
}