prs/prs.stores/AssignmentStore.cs

using System.Collections.Generic;
using System.Linq;
using Comal.Classes;
using InABox.Core;
using System;

namespace Comal.Stores
{
    internal class AssignmentStore : BaseStore<Assignment>
    {
        private void CheckActivityForms(Assignment assignment)
        {
            if (!assignment.ActivityLink.HasOriginalValue(x => x.ID))
            {
                return;
            }

            List<AssignmentForm> assignmentForms;
            if(assignment.ID != Guid.Empty)
            {
                assignmentForms = Provider.Query(
                    Filter<AssignmentForm>.Where(x => x.Parent.ID).IsEqualTo(assignment.ID),
                    Columns.None<AssignmentForm>().Add(x => x.ID, x => x.FormData)
                ).Rows.Select(x => x.ToObject<AssignmentForm>()).ToList();
            }
            else
            {
                assignmentForms = new();
            }

            var toDelete = assignmentForms.Where(x => string.IsNullOrWhiteSpace(x.FormData));
            Provider.Delete(toDelete, UserID);

            var activityForms = Provider.Query(
                Filter<ActivityForm>.Where(x => x.Activity.ID).IsEqualTo(assignment.ActivityLink.ID)
                    .And(x => x.Form.AppliesTo).IsEqualTo(nameof(Assignment)));

            var newForms = new List<AssignmentForm>();
            foreach (var row in activityForms.Rows)
            {
                var formID = row.Get<ActivityForm, Guid>(x => x.Form.ID);
                if (!(assignmentForms.Any(x => x.Form.ID == formID) && !toDelete.Any(x => x.Form.ID == formID)))
                {
                    var assignmentForm = new AssignmentForm();
                    assignmentForm.Form.ID = formID;
                    assignmentForm.Parent.ID = assignment.ID;
                    newForms.Add(assignmentForm);
                }
            }
            Provider.Save(newForms);
        }

        protected override void AfterSave(Assignment entity)
        {
            base.AfterSave(entity);

            CheckActivityForms(entity);

            CheckAssignmentCosts(entity);
        }

        private void CheckAssignmentCosts(Assignment entity)
        {
            var changedEmployee = entity.TryGetOriginalValue(x => x.EmployeeLink.ID, out var employeeID);
            if (!changedEmployee)
            {
                employeeID = entity.EmployeeLink.ID;
            }

            var changedDate = entity.TryGetOriginalValue(x => x.Date, out var date);
            if (!changedDate)
            {
                date = entity.Date;
            }
            if(changedEmployee || changedDate)
            {
                CheckAssignmentCosts(date, employeeID);
            }

            CheckAssignmentCosts(entity.Date, entity.EmployeeLink.ID);
        }
        
        private void CheckAssignmentCosts(DateTime date, Guid employeeID)
        {
            if (employeeID == Guid.Empty) return;

            var assignments = Provider.Query(
                Filter<Assignment>.Where(x => x.Date).IsEqualTo(date)
                    .And(x => x.EmployeeLink.ID).IsEqualTo(employeeID),
                Columns.None<Assignment>()
                    .Add(x => x.ID)
                    .Add(x => x.Actual.Start)
                    .Add(x => x.Actual.Finish)
                    .Add(x => x.Actual.Duration)
                    .Add(x => x.Booked.Start)
                    .Add(x => x.Booked.Finish)
                    .Add(x => x.Booked.Duration))
                .ToArray<Assignment>();
            var employee = Provider.Query(
                Filter<Employee>.Where(x => x.ID).IsEqualTo(employeeID),
                Columns.None<Employee>()
                    .Add(x => x.RosterStart)
                    .Add(x => x.HourlyRate))
                .ToObjects<Employee>().FirstOrDefault();
            if (employee is null) return;

            var rosterItems = Provider.Query(
                Filter<EmployeeRosterItem>.Where(x => x.Employee.ID).IsEqualTo(employeeID),
                Columns.None<EmployeeRosterItem>()
                    .Add(x => x.Overtime.ID),
                new SortOrder<EmployeeRosterItem>(x => x.Day))
                .ToArray<EmployeeRosterItem>();
            var overtimeID = RosterUtils.GetRoster(rosterItems, employee.RosterStart, date)?.Overtime.ID ?? Guid.Empty;
            if(overtimeID == Guid.Empty) return;

            var overtime = Provider.Query(
                Filter<OvertimeInterval>.Where(x => x.Overtime.ID).IsEqualTo(overtimeID),
                Columns.None<OvertimeInterval>()
                    .Add(x => x.Interval)
                    .Add(x => x.IntervalType)
                    .Add(x => x.Multiplier),
                new SortOrder<OvertimeInterval>(x => x.Sequence))
                .ToArray<OvertimeInterval>();

            assignments.SortBy(x => x.EffectiveStartTime());
            var totalHours = new Dictionary<Assignment, double>();
            OvertimeUtils.EvaluateOvertime(assignments, overtime, x => x.EffectiveFinishTime() - x.EffectiveStartTime(), (assignment, interval, duration) =>
            {
                totalHours[assignment] = totalHours.GetValueOrAdd(assignment)
                    + duration.TotalHours * (interval?.Multiplier ?? 1);
            });

            foreach(var assignment in assignments)
            {
                assignment.Cost = totalHours.GetValueOrDefault(assignment) * employee.HourlyRate;
            }

            Provider.Save(assignments.Where(x => x.IsChanged()));
        }
    }
}