prs/prs.classes/Entities/Assignment/Assignment.cs

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

namespace Comal.Classes
{
    /// <summary>
    ///     An assignment represents an anticipated booking for an employee, much like a diary entry
    ///     <exclude />
    /// </summary>
    [UserTracking("Assignments")]
    [Caption("Assignments")]
    public class Assignment : Entity, IPersistent, IRemotable, INumericAutoIncrement<Assignment>, IOneToMany<Employee>, IOneToMany<Job>,
        IOneToMany<Kanban>, ILicense<SchedulingControlLicense>, IJobActivity, IOneToMany<Invoice>, IJobScopedItem,
        IInvoiceable
    {
        [IntegerEditor(Editable = Editable.Hidden)]
        [EditorSequence(1)]
        public int Number { get; set; }

        [DateEditor]
        [EditorSequence(2)]
        [RequiredColumn]
        public DateTime Date { get; set; }

        [EntityRelationship(DeleteAction.Cascade)]
        [EditorSequence(3)]
        [RequiredColumn]
        public EmployeeLink Employee { get; set; }

        [Obsolete("Replaced by Employee")]
        public EmployeeLink EmployeeLink
        {
            get => Employee;
            set { }
        }

        // [EntityRelationship(DeleteAction.Cascade)]
        // [EditorSequence(4)]
        // public EquipmentLink Equipment { get; set; }

        [TextBoxEditor]
        [EditorSequence(5)]
        public string Title { get; set; }

        [MemoEditor]
        [EditorSequence(6)]
        public string Description { get; set; }

        [EditorSequence(7)]
        public AssignmentActivityLink Activity { get; set; }

        [Obsolete("Replaced by Activity")]
        public AssignmentActivityLink ActivityLink
        {
            get => Activity;
            set { }
        }

        private class KanbanLookup : LookupDefinitionGenerator<Kanban, Assignment>
        {
            public override Filter<Kanban> DefineFilter(Assignment[] items)
            {
                if (items == null || !items.Any())
                    return LookupFactory.DefineFilter<Kanban>();
                var employeeID = items.First().Employee.ID;
                
                // Open tasks which the employee of this assignment is an observer of.
                return Filter<Kanban>.Where(x => x.Closed).IsEqualTo(DateTime.MinValue)
                    .And(x => x.ID).InQuery(Filter<KanbanSubscriber>.Where(x => x.Employee.ID).IsEqualTo(employeeID), x => x.Kanban.ID);
            }

            public override Columns<Assignment> DefineFilterColumns()
                => Columns.None<Assignment>().Add(x => x.Employee.ID);
        }
        [LookupDefinition(typeof(KanbanLookup))]
        [EditorSequence(8)]
        [EntityRelationship(DeleteAction.SetNull)]
        public KanbanLink Task { get; set; }

        [EditorSequence(9)]
        public JobLink Job { get; set; }

        [NullEditor]
        [Obsolete("Replaced with Job")]
        public JobLink JobLink { get; set; }
        
        private class JobITPLookup : LookupDefinitionGenerator<JobITP, Assignment>
        {
            public override Filter<JobITP> DefineFilter(Assignment[] items)
            {
                if (items.Length == 1)
                    return Filter<JobITP>.Where(x => x.Job.ID).IsEqualTo(items.First().Job.ID);
                return LookupFactory.DefineFilter<JobITP>();
            }
            
            public override Columns<Assignment> DefineFilterColumns()
                => Columns.None<Assignment>().Add(x => x.Job.ID);
        }
        [LookupDefinition(typeof(JobITPLookup))]
        [EditorSequence(10)]
        public JobITPLink ITP { get; set; }

        [NullEditor]
        [Obsolete("Replaced with Actual.Start", true)]
        public TimeSpan Start { get; set; }

        [NullEditor]
        [Obsolete("Replaced with Actual.Duration", true)]
        public TimeSpan Duration { get; set; }

        [NullEditor]
        [Obsolete("Replaced with Actual.Finish", true)]
        public TimeSpan Finish { get; set; }

        [EditorSequence(11)]
        [CoreTimeEditor]
        public TimeBlock Booked { get; set; }

        [EditorSequence(12)]
        [CoreTimeEditor]
        public TimeBlock Actual { get; set; }
        
        [TimestampEditor]
        [RequiredColumn]
        [EditorSequence(13)]
        public DateTime Completed { get; set; }

        [Editable(Editable.Disabled)]
        [Comment("The duration this Assignment was treated as having for costing purposes")]
        [EditorSequence("Processing", 1)]
        public double CostedHours { get; set; }

        [CurrencyEditor]
        [Editable(Editable.Disabled)]
        [Comment("Cost of the Assignment; calculated from duration, overtime rules and the employee's hourly rate.")]
        [EditorSequence("Processing", 2)]
        public double Cost { get; set; }
        
        [EditorSequence("Processing", 3)]
        public ActualCharge Charge { get; set; }
        
        [TimestampEditor]
        [EditorSequence("Processing", 4)]
        public DateTime Processed { get; set; }
        
        [NullEditor]
        [EntityRelationship(DeleteAction.Cascade)]
        public LeaveRequestLink LeaveRequest { get; set; }

        [Obsolete("Replaced by LeaveRequest")]
        public LeaveRequestLink LeaveRequestLink
        {
            get => LeaveRequest;
            set { }
        }

        [NullEditor]
        [EntityRelationship(DeleteAction.Cascade)]
        public DeliveryLink Delivery { get; set; }
        
        [NullEditor]
        [EntityRelationship(DeleteAction.SetNull)]
        public InvoiceLink Invoice { get; set; }
        
        [NullEditor]
        public MeetingDetails Meeting { get; set; }
        
        private class JobScopeLookup : LookupDefinitionGenerator<JobScope, Assignment>
        {
            public override Filter<JobScope> DefineFilter(Assignment[] items)
            {
                var item = items?.Length == 1 ? items[0] : null;
                if (item != null)
                    return Filter<JobScope>.Where(x => x.Job.ID).IsEqualTo(item.Job.ID).And(x => x.Status.Approved).IsEqualTo(true);
                return Filter.None<JobScope>();
            }
            
            public override Columns<Assignment> DefineFilterColumns()
                => Columns.None<Assignment>().Add(x => x.Job.ID);
        }
        [LookupDefinition(typeof(JobScopeLookup))]
        public JobScopeLink JobScope { get; set; }
        
        public Expression<Func<Assignment, int>> AutoIncrementField()
        {
            return x => x.Number;
        }

        public Filter<Assignment> AutoIncrementFilter()
        {
            return null;
        }
        
        public int AutoIncrementDefault() => 1;
        

        public static TimeSpan EffectiveTime(TimeSpan actual, TimeSpan booked) => actual.Ticks != 0L ? actual : booked; 

        public TimeSpan EffectiveStartTime()
        {
            return EffectiveTime(Actual.Start, Booked.Start);
        }
        public DateTime EffectiveStart()
        {
            return Date.Add(EffectiveStartTime());
        }

        public TimeSpan EffectiveFinishTime()
        {
            // If we have an actual finish, always use that
            // otherwise use EffectiveStart() + booked.duration
            return EffectiveTime(
                    Actual.Finish,
                    EffectiveTime(Actual.Start, Booked.Start)
                        .Add(Booked.Duration)
                );
        }
        public DateTime EffectiveFinish()
        {
            return Date.Add(
                EffectiveFinishTime()
            );
        }
        
        static Assignment()
        {
            LinkedProperties.Register<Assignment, ActivityCharge, bool>(ass => ass.Activity.Charge, chg => chg.Chargeable, ass => ass.Charge.Chargeable);
            Classes.JobScope.LinkScopeProperties<Assignment>();
        }
        
    }
}