prs/prs.desktop/Dashboards/HumanResources/TimesheetWidget.xaml.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using Comal.Classes;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using PRS.Shared;
using PRSDesktop.WidgetGroups;

namespace PRSDesktop
{
    public class TimesheetWidgetProperties : IUserConfigurationSettings, IDashboardProperties { }

    public class TimesheetWidgetElement : DashboardElement<TimesheetWidget, HumanResources, TimesheetWidgetProperties> { }

    /// <summary>
    ///     Interaction logic for TimesheetWidget.xaml
    /// </summary>
    public partial class TimesheetWidget : UserControl, IDashboardWidget<HumanResources, TimesheetWidgetProperties>
    {
        private DateTime _date = DateTime.Today;

        private Guid _groupid = CoreUtils.FullGuid;
        private CoreTable activities;

        private Dictionary<Guid, Tuple<Employee, List<EmployeeRosterItem>>> employeeData;

        private readonly DataTable report = new();
        private CoreTable timesheets;

        public TimesheetWidget()
        {
            InitializeComponent();
            report.Columns.Add("ID", typeof(Guid));
            report.Columns.Add("Name", typeof(string));
            report.Columns.Add("Leave", typeof(string));
            report.Columns.Add("LateStart", typeof(TimeSpan));
            report.Columns.Add("EarlyFinish", typeof(TimeSpan));
            report.Columns.Add("ClockIn", typeof(string));
            report.Columns.Add("ClockOut", typeof(string));
            report.PrimaryKey = new[] { report.Columns[0] };
        }

        public DateTime Date
        {
            get => _date;
            set
            {
                _date = value;
                LoadTimeSheets();
            }
        }

        public Guid GroupID
        {
            get => _groupid;
            set
            {
                _groupid = value;
                LoadEmployees(value);
            }
        }

        public TimesheetWidgetProperties Properties { get; set; }
        public event LoadSettings<TimesheetWidgetProperties>? LoadSettings;
        public event SaveSettings<TimesheetWidgetProperties>? SaveSettings;

        public void Setup()
        {
            LoadEmployees(GroupID);
            LoadActivities();
        }

        public void Refresh()
        {
            LoadTimeSheets();
        }

        public void Shutdown(CancelEventArgs? cancel)
        {
        }

        private void ClearReport()
        {
            Report.ItemsSource = null;
        }

        private void LoadEmployees(Guid id)
        {
            ClearReport();
            employeeData = null;

            var employeeFilter = id != CoreUtils.FullGuid ? new Filter<Employee>(x => x.Group.ID).IsEqualTo(id) : null;
            Client.QueryMultiple(
                (results, e) =>
                {
                    if(results != null)
                    {
                        var rosterItems = results.Get<EmployeeRosterItem>()
                            .ToObjects<EmployeeRosterItem>().GroupBy(x => x.Employee.ID)
                            .ToDictionary(x => x.Key, x => x);

                        employeeData = results.Get<Employee>().ToObjects<Employee>()
                            .ToDictionary(x => x.ID, x =>
                            {
                                return new Tuple<Employee, List<EmployeeRosterItem>>(x, rosterItems.GetValueOrDefault(x.ID)?.ToList() ?? new());
                            });

                        CheckData();
                    }
                    else if(e != null)
                    {
                        Logger.Send(LogType.Error, "", CoreUtils.FormatException(e));
                        Dispatcher.Invoke(() =>
                        {
                            MessageBox.Show($"Error loading data: {e.Message}");
                        });
                    }
                },
                new KeyedQueryDef<Employee>(
                    employeeFilter,
                    null,
                    null),
                new KeyedQueryDef<EmployeeRosterItem>(
                    new Filter<EmployeeRosterItem>(x => x.Employee).InQuery(employeeFilter, x => x.ID),
                    null));
        }

        private void LoadActivities()
        {
            ClearReport();
            activities = null;
            new Client<Activity>().Query(
                new Filter<Activity>(x => x.IsLeave).IsEqualTo(true),
                Columns.None<Activity>().Add(
                    x => x.ID,
                    x => x.Description
                ),
                null,
                CoreRange.All,
                (o, e) =>
                {
                    activities = o;
                    CheckData();
                }
            );
        }


        private void LoadTimeSheets()
        {
            ClearReport();
            timesheets = null;
            new Client<TimeSheet>().Query(
                new Filter<TimeSheet>(x => x.Date).IsEqualTo(_date),
                null,
                new SortOrder<TimeSheet>(x => x.EmployeeLink.Name),
                CoreRange.All,
                (o, e) =>
                {
                    timesheets = o;
                    CheckData();
                }
            );
        }

        private void CheckData()
        {
            if (employeeData != null && activities != null && timesheets != null)
                ProcessData();
        }

        private string Codify(string name)
        {
            var result = "";
            var comps = name.ToUpper().Split(' ');
            foreach (var comp in comps)
                if (comp.Any())
                    result += comp.First();
            return string.IsNullOrWhiteSpace(result) ? "??" : result;
        }

        private void ProcessData()
        {
            try
            {
                report.Rows.Clear();
                foreach (var time in timesheets.Rows)
                {
                    var empid = time.Get<TimeSheet, Guid>(x => x.EmployeeLink.ID);
                    var empname = time.Get<TimeSheet, string>(x => x.EmployeeLink.Name);

                    if (report.Rows.Find(empid) == null)
                    {
                        if (employeeData.TryGetValue(empid, out var data))
                        {
                            var (employee, rosters) = data;

                            var userid = employee.UserLink.UserID;
                            var date = time.Get<TimeSheet, DateTime>(c => c.Date);

                            var rosterday = RosterUtils.GetRoster(rosters, employee.RosterStart, date);

                            var shifts = RosterUtils.GetBlocks(rosterday, date, TimeSpan.Zero, TimeSpan.FromDays(1));
                            var shiftstart = shifts.Aggregate(TimeSpan.MaxValue, (time, block) => block.Start < time ? block.Start : time);
                            var shiftend = shifts.Aggregate(TimeSpan.Zero, (time, block) => block.Finish > time ? block.Finish : time);

                            var rows = timesheets.Rows.Where(r => r.Get<TimeSheet, Guid>(c => c.EmployeeLink.ID).Equals(empid));

                            var start = new TimeSpan(long.MaxValue);
                            TimeSpan? late = null;

                            var finish = new TimeSpan(long.MinValue);
                            TimeSpan? early = null;

                            var leave = "";

                            var clockin = "";
                            var clockout = "";

                            var leaves = new List<string>();
                            foreach (var row in rows)
                            {
                                var activity = row.Get<TimeSheet, Guid>(x => x.ActivityLink.ID);
                                var activityrow = activities.Rows.FirstOrDefault(r => r.Get<Activity, Guid>(c => c.ID).Equals(activity));
                                if (activityrow != null)
                                {
                                    var thisleave = Codify(activityrow.Get<Activity, string>(x => x.Description));
                                    if (!leaves.Contains(thisleave))
                                        leaves.Add(thisleave);
                                }

                                leave = string.Join(",", leaves);

                                var createdby = row.Get<TimeSheet, string>(x => x.CreatedBy);
                                if (createdby == null)
                                    createdby = "";


                                if (shiftstart.Ticks != 0)
                                {
                                    var thisstart = row.Get<TimeSheet, TimeSpan>(x => x.Start);
                                    if (thisstart < start)
                                    {
                                        start = thisstart;
                                        if (start > shiftstart)
                                            late = !late.HasValue || start < late.Value ? start : late;
                                        else
                                            late = null;
                                        clockin = createdby.Equals(userid) ? "" : createdby;
                                    }
                                }

                                if (shiftend.Ticks != 0)
                                {
                                    var thisfinish = row.Get<TimeSheet, TimeSpan>(x => x.Finish);
                                    if (thisfinish.Ticks == 0)
                                    {
                                        shiftend = new TimeSpan(0);
                                        early = null;
                                    }
                                    else
                                    {
                                        if (thisfinish > finish)
                                        {
                                            finish = thisfinish;
                                            if (finish < shiftend)
                                                early = !early.HasValue || finish > early.Value ? finish : early;
                                            else
                                                early = null;
                                            clockout = createdby.Equals(userid) ? "" : createdby;
                                        }
                                    }
                                }
                            }

                            leave = string.Join(",", leaves);

                            if (!string.IsNullOrEmpty(leave) || late.HasValue || early.HasValue || !string.IsNullOrEmpty(clockin) ||
                                !string.IsNullOrEmpty(clockout))
                                report.Rows.Add(empid, empname, leave, late, early, clockin, clockout);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
            }

            Dispatcher.Invoke(() => { Report.ItemsSource = report; });
        }
    }
}