prs/prs.classes/Entities/LeaveRequest/LeaveRequest.cs

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

namespace Comal.Classes
{
    public enum LeaveRequestStatus
    {
        InProgress,
        Approved,
        Rejected
    }


    public class LeaveRequestOpenFormCount : CoreAggregate<LeaveRequest, LeaveRequestForm, Guid>
    {
        public override Expression<Func<LeaveRequestForm, Guid>> Aggregate => x => x.ID;

        public override AggregateCalculation Calculation => AggregateCalculation.Count;

        public override Filter<LeaveRequestForm>? Filter =>
            new Filter<LeaveRequestForm>(x => x.FormCompleted).IsEqualTo(DateTime.MinValue);

        public override Dictionary<Expression<Func<LeaveRequestForm, object>>, Expression<Func<LeaveRequest, object>>> Links =>
            new Dictionary<Expression<Func<LeaveRequestForm, object>>, Expression<Func<LeaveRequest, object>>>()
            {
                { LeaveRequestForm => LeaveRequestForm.Parent.ID, LeaveRequest => LeaveRequest.ID }
            };
    }

    [UserTracking("Holiday Calendar")]
    [Caption("Leave Requests")]
    public class LeaveRequest : Entity, IRemotable, IPersistent, ILicense<LeaveManagementLicense>, IDataEntryInstance
    {
        [EditorSequence(1)]
        public EmployeeLink EmployeeLink { get; set; }

        [EditorSequence(2)]
        public LeaveRequestActivityLink LeaveType { get; set; }

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

        [TimeOfDayEditor]
        [EditorSequence(4)]
        public TimeSpan FromTime { get; set; }

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

        [TimeOfDayEditor]
        [EditorSequence(6)]
        public TimeSpan ToTime { get; set; }

        [EditorSequence(7)]
        public DocumentLink Request { get; set; }

        [MemoEditor]
        [EditorSequence(8)]
        public string Notes { get; set; }

        [LoggableProperty]
        [EditorSequence(9)]
        [RequiredColumn]
        [EnumLookupEditor(typeof(LeaveRequestStatus))]
        public LeaveRequestStatus Status { get; set; }

        [Caption("Response")]
        [MemoEditor]
        [EditorSequence(10)]
        public string StatusNotes { get; set; }
        
        [EditorSequence("Internal Notes", 1)]
        [TimestampEditor]
        public DateTime DataEntered { get; set; }

        [MemoEditor]
        [EditorSequence("Internal Notes", 2)]
        public string InternalNotes { get; set; }
        
        [TimestampEditor(Editable = Editable.Disabled)]
        [EditorSequence("Internal Notes", 3)]
        public DateTime Processed { get; set; }

        [Obsolete("Replaced By Status", true)]
        [NullEditor]
        public DateTime Approved { get; set; }

        [Obsolete("Replaced By StatusNotes", true)]
        [NullEditor]
        public string ApprovalNotes { get; set; }

        [NullEditor]
        [EntityRelationship(DeleteAction.Cascade)]
        public StandardLeaveLink PublicHoliday { get; set; }
        
        [IntegerEditor(Visible = Visible.Optional,Editable = Editable.Hidden)]
        [Aggregate(typeof(LeaveRequestOpenFormCount))]
        public int OpenForms { get; set; }

        protected override void Init()
        {
            base.Init();
            EmployeeLink = new EmployeeLink();
            LeaveType = new LeaveRequestActivityLink();
            Request = new DocumentLink();
            PublicHoliday = new StandardLeaveLink();
            ToTime = new TimeSpan(23, 59, 59);
            Status = LeaveRequestStatus.InProgress;
        }

        //protected override void DoPropertyChanged(string name, object? before, object? after)
        //{
        //    base.DoPropertyChanged(name, before, after);
        //    if (String.Equals(name,"Status"))
        //    {
        //        var status = (LeaveRequestStatus)after;
        //        if (status == LeaveRequestStatus.Approved)
        //            Approved = Approved.IsEmpty() ? DateTime.Now : Approved;
        //        else
        //            Approved = DateTime.MinValue;
        //    }
        //}


        public LeaveRequest LoadFrom(StandardLeave standardleave)
        {
            PublicHoliday.ID = standardleave.ID;
            From = standardleave.From;
            FromTime = standardleave.FromTime;
            To = standardleave.To;
            ToTime = standardleave.ToTime;
            LeaveType.ID = standardleave.LeaveType.ID;
            Notes = standardleave.Name;
            return this;
        }

        //protected override string ToSort()
        //{
        //    if (Approved == DateTime.MinValue)
        //        return String.Format("0{0:yyyyMMdd}{1}",From,EmployeeLink.Name);
        //    else
        //        return String.Format("1{0:yyyyMMdd}{1}", DateTime.MinValue.Add(DateTime.MaxValue.Subtract(From)), EmployeeLink.Name);
        //}

        public static SortOrder<LeaveRequest> SortOrder()
        {
            return new SortOrder<LeaveRequest>(x => x.From, SortDirection.Descending).ThenBy(x => x.EmployeeLink.Name);
        }

        public override string ToString()
        {
            return string.Format("{0}: {1} {2:dd MMM yy} - {3:dd MMM yy} {4}", EmployeeLink.Name, LeaveType.Description, From, To, Status);
        }
    }
}