prs/prs.stores/JobRequisitionItemStore.cs

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

namespace PRSStores;

public class JobRequisitionItemStore : BaseStore<JobRequisitionItem>
{
    protected override void BeforeSave(JobRequisitionItem item)
    {
        if (item.ID != Guid.Empty)
        {
            var newStatus = CalculateStatus(this, item);
            if(newStatus != null)
            {
                item.Status = newStatus.Value;
            }
        }
        base.BeforeSave(item);
    }

    public static Columns<JobRequisitionItem> StatusRequiredColumns()
    {
        return new Columns<JobRequisitionItem>(
            x => x.ID,
            x => x.Archived,
            x => x.Cancelled,
            x => x.OrderRequired,
            x => x.Status,
            x => x.Style.ID,
            x => x.Product.ID,
            x => x.Qty);
    }

    /// <summary>
    /// Ensure that the columns of <paramref name="item"/> match <see cref="StatusRequiredColumns"/>.
    /// </summary>
    /// <param name="store"></param>
    /// <param name="item"></param>
    /// <returns></returns>
    public static JobRequisitionItemStatus? CalculateStatus(IStore store, JobRequisitionItem item)
    {
        if (item.Archived != DateTime.MinValue)
        {
            return JobRequisitionItemStatus.Archived;
        }
        else if (item.Cancelled != DateTime.MinValue)
        {
            return JobRequisitionItemStatus.Cancelled;
        }
        else
        {
            var stockMovements = store.Provider.Query(
                new Filter<StockMovement>(x => x.JobRequisitionItem.ID).IsEqualTo(item.ID),
                new Columns<StockMovement>(
                    x => x.Units,
                    x => x.Style.ID))
                .ToObjects<StockMovement>();
            var styleTotal = 0.0;
            var total = 0.0;
            foreach (var mvt in stockMovements)
            {
                if (mvt.Style.ID == item.Style.ID)
                {
                    styleTotal += mvt.Units;
                }
                total += mvt.Units;
            }

            var remStyle = item.Qty - styleTotal;
            var remTotal = item.Qty - total;

            if (remStyle <= 0)
            {
                return JobRequisitionItemStatus.Allocated;
            }
            else if (remTotal <= 0)
            {
                // Find all unreceived POItems for this guy that are treatments (i.e., wrong product ID).
                var jriPois = store.Provider.Query(
                    new Filter<JobRequisitionItemPurchaseOrderItem>(x => x.JobRequisitionItem.ID).IsEqualTo(item.ID)
                        .And(x => x.PurchaseOrderItem.ReceivedDate).IsEqualTo(DateTime.MinValue)
                        .And(x => x.PurchaseOrderItem.Product.ID).IsNotEqualTo(item.Product.ID),
                    new Columns<JobRequisitionItemPurchaseOrderItem>(x => x.ID));
                if (jriPois.Rows.Count > 0)
                {
                    return JobRequisitionItemStatus.TreatmentOnOrder;
                }
                else
                {
                    return JobRequisitionItemStatus.TreatmentRequired;
                }
            }
            else
            {
                // Find all unreceived POItems for this guy.
                var jriPois = store.Provider.Query(
                    new Filter<JobRequisitionItemPurchaseOrderItem>(x => x.JobRequisitionItem.ID).IsEqualTo(item.ID)
                        .And(x => x.PurchaseOrderItem.ReceivedDate).IsEqualTo(DateTime.MinValue),
                    new Columns<JobRequisitionItemPurchaseOrderItem>(x => x.PurchaseOrderItem.Product.ID)
                        .Add(x => x.PurchaseOrderItem.Qty))
                    .ToObjects<JobRequisitionItemPurchaseOrderItem>()
                    .ToList();
                var stockOrders = jriPois.Where(x => x.PurchaseOrderItem.Product.ID == item.Product.ID).ToList();
                var treatmentOrders = jriPois.Where(x => x.PurchaseOrderItem.Product.ID != item.Product.ID).ToList();

                remTotal -= stockOrders.Sum(x => x.PurchaseOrderItem.Qty);
                if (remTotal <= 0)
                {
                    if (stockOrders.Count > 0)
                    {
                        return JobRequisitionItemStatus.OnOrder;
                    }
                    else
                    {
                        // This should be impossible to reach. We are at this point because remTotal <= 0, but stockOrders was an empty list. Therefore
                        // remTotal is was <= 0 before checking PurchaseOrderItems, but then we should be TreatmentRequired, as above.
                        Logger.Send(LogType.Error, store.UserID, $"Internal assertion failed: there is enough stock, but we didn't reach the correct clause.");

                        if (treatmentOrders.Count > 0)
                        {
                            return JobRequisitionItemStatus.TreatmentOnOrder;
                        }
                        else
                        {
                            return JobRequisitionItemStatus.TreatmentRequired;
                        }
                    }
                }
                else if (item.OrderRequired != DateTime.MinValue)
                {
                    return JobRequisitionItemStatus.OrderRequired;
                }
                else
                {
                    // Even after all the orders have come through, we still don't have enough. We must order more.
                    return JobRequisitionItemStatus.NotChecked;
                }
            }
        }
    }

    public static JobRequisitionItemStatus? CalculateStatus(IStore store, Guid jobRequiItemID)
    {
        var item = store.Provider.Query(
            new Filter<JobRequisitionItem>(x => x.ID).IsEqualTo(jobRequiItemID),
            StatusRequiredColumns())
            .ToObjects<JobRequisitionItem>()
            .FirstOrDefault();
        if(item is null)
        {
            Logger.Send(LogType.Error, store.UserID, $"No {nameof(JobRequisitionItem)} with ID {jobRequiItemID}");
            return null;
        }
        return CalculateStatus(store, item);
    }

    public static void UpdateStatus(IStore store, Guid jobRequiItemID)
    {
        var item = store.Provider.Query(
            new Filter<JobRequisitionItem>(x => x.ID).IsEqualTo(jobRequiItemID),
            StatusRequiredColumns())
            .ToObjects<JobRequisitionItem>()
            .FirstOrDefault();
        if (item is null)
        {
            Logger.Send(LogType.Error, store.UserID, $"No {nameof(JobRequisitionItem)} with ID {jobRequiItemID}");
        }
        else
        {
            var newStatus = CalculateStatus(store, item);
            if (newStatus.HasValue)
            {
                item.Status = newStatus.Value;
                store.Provider.Save(item);
            }
        }
    }
}