prs/prs.classes/Entities/Employee/Employee.cs

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

namespace Comal.Classes
{

    [UserTracking("Human Resources")]
    public class Employee : Entity, IEmployee, ISchedulable, IPersistent, IRemotable, IOrgChart<EmployeeLink>, ILicense<CoreLicense>, IExportable,
        IImportable
    {

        [UniqueCodeEditor(Visible = Visible.Default, Editable = Editable.Enabled)]
        [EditorSequence(1)]
        public string Code { get; set; } = "";

        [EditorSequence(2)]
        public string Name { get; set; } = "";
                
        [EditorSequence("Payroll", 3)]
        public EmployeeType Type { get; set; }
        
        [EditorSequence(4)]
        [AddressEditor(true)]
        public Address Address { get; set; }
        
        [EditorSequence(5)]
        public string Email { get; set; }

        [EditorSequence(6)]
        [TextBoxEditor(Alignment = Alignment.MiddleCenter, Width = 120)]
        public string Mobile { get; set; }
        
        [DateEditor]
        [EditorSequence(7)]
        public DateTime DateOfBirth { get; set; }
        
        [EditorSequence(8)]
        public UserLink User { get; set; }

        [Obsolete("Replaced by User")]
        public UserLink UserLink
        {
            get => User;
            set { }
        }
        
        [CodeEditor(Editable = Editable.Enabled)]
        [EditorSequence(9)]
        [Obsolete("Replaced with EmployeeGroup", true)]
        public string Department { get; set; }

        [EditorSequence(10)]
        public EmployeeGroupLink Group { get; set; }
        
        [EditorSequence(11)]
        public ImageDocumentLink Thumbnail { get; set; }

        [SecondaryIndex]
        [CheckBoxEditor]
        [EditorSequence(12)]
        public bool CanAllocateTasks { get; set; }
        
        [CheckBoxEditor]
        [EditorSequence(13)]
        [Caption("Show In/Out Status?")]
        public bool ShowOnInOutBoard { get; set; }
        
        [SecondaryIndex]
        [DateEditor]
        [EditorSequence("Payroll", 1)]
        public DateTime StartDate { get; set; }

        [SecondaryIndex]
        [DateEditor]
        [EditorSequence("Payroll", 2)]
        public DateTime FinishDate { get; set; }

        public EmployeeRosterLink RosterTemplate { get; set; }
        
        [EditorSequence("Payroll", 3)]
        [EmbeddedListEditor(typeof(EmployeeRosterItem), DirectEdit = true)]
        [Obsolete("Use Template system instead")]
        public string Roster { get; set; }
        
        [EditorSequence("Payroll", 4)]
        [DateTimeEditor(Visible = Visible.Optional)]
        public DateTime RosterStart { get; set; }

        [EditorSequence("Payroll",5)]
        public OvertimeRuleLink OvertimeRule { get; set; }

        [Obsolete("Replaced by OvertimeRule")]
        public OvertimeRuleLink OvertimeRuleLink
        {
            get => OvertimeRule;
            set { }
        }
        
        [CodeEditor(Editable = Editable.Enabled)]
        [EditorSequence("Payroll",6)]
        public string PayrollID { get; set; }

        [CurrencyEditor]
        [Security(typeof(CanViewHourlyRates))]
        [EditorSequence("Payroll",7)]
        [Comment("Hourly rate of the employee; used for assignment costing")]
        public double HourlyRate { get; set; }
        
        [EditorSequence("Payroll",8)]
        [Caption("Leave Approval")]
        public LeaveRequestApprovalSetLink LeaveRequestApprovalSet { get; set; }
        
        [EditorSequence("Org Chart", 1)]
        public EmployeePositionLink Position { get; set; }

        private class EmployeeLookup : LookupDefinitionGenerator<Employee, Employee>
        {
            public override Filter<Employee> DefineFilter(Employee[] items)
            {
                var result = LookupFactory.DefineFilter<Employee>();
                result.Ands.Add(Filter<Employee>.Where(x => x.ID).NotInList(items.Select(x => x.ID).ToArray()));
                return result;
            }

            public override Columns<Employee> DefineFilterColumns()
                => Columns.None<Employee>().Add(x => x.ID);
        }
        [LookupDefinition(typeof(EmployeeLookup))]
        [EditorSequence("Org Chart", 2)]
        [EntityRelationship(DeleteAction.Cascade)]
        public EmployeeLink Manager { get; set; }

        [EditorSequence("Org Chart", 3)]
        public OrgChartSettings<EmployeeLink> OrgChart { get; set; }
        
        [NullEditor]
        [Obsolete("Replaced with UserLink.ID", true)]
        public Guid UserID { get; set; }
        
        [NullEditor]
        public int ActiveSchedules { get; set; }

        [NullEditor]
        public byte[]? Signature { get; set; }

        [NullEditor]
        [Obsolete("Replaced with EmployeeRoster class", true)]
        public TimeSpan UsualStart { get; set; }

        [NullEditor]
        [Obsolete("Replaced with EmployeeRoster class", true)]
        public TimeSpan UsualFinish { get; set; }

        static Employee()
        {
            DefaultColumns.Add<Employee>(x => x.Code);
            DefaultColumns.Add<Employee>(x => x.Name);
            DefaultColumns.Add<Employee>(x => x.User.UserID, caption: "User");
            DefaultColumns.Add<Employee>(x => x.Group.Code, caption: "Group");
            DefaultColumns.Add<Employee>(x => x.Email);
            DefaultColumns.Add<Employee>(x => x.Mobile);
            DefaultColumns.Add<Employee>(x => x.Type, width: 70);
            DefaultColumns.Add<Employee>(x => x.ShowOnInOutBoard, caption: "In/Out?");
        }

        protected override void DoPropertyChanged(string name, object? before, object? after)
        {
            base.DoPropertyChanged(name, before, after);
            if(name == $"{Type}")
            {
                ShowOnInOutBoard = Type == EmployeeType.Employee;
            }
        }

        public override string ToString()
        {
            return Name;
        }

        public static Filter<Employee> ActiveEmployees(DateTime date)
        {
            var start = Filter<Employee>.Where(x => x.StartDate).IsEqualTo(DateTime.MinValue).Or(x => x.StartDate).IsLessThanOrEqualTo(date);
            var finish = Filter<Employee>.Where(x => x.FinishDate).IsEqualTo(DateTime.MinValue).Or(x => x.FinishDate).IsGreaterThanOrEqualTo(date);
            return start.And(finish);
        }
    }
}