prs/prs.stores/StockMovementStore.cs

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

namespace PRSStores;

using HoldingDictionary = Dictionary<(Guid product, Guid style, Guid location, Guid job, StockDimensions dimensions), StockHolding>;

public class StockMovementStore : BaseStore<StockMovement>
{
    // These will be initialised in BeforeSave
    //HoldingDictionary holdingData = null!;
    //StockMovement[] mvtData = null!;
    //HashSet<Guid> currentIDs = new();

    protected override void BeforeSave(IEnumerable<StockMovement> entities)
    {
        foreach(var entity in entities)
        {
            // Calling base BeforeSave so that it doesn't call our other BeforeSave method.
            base.BeforeSave(entity);
        }

        //currentIDs = entities.Select(x => x.ID).Where(x => x != Guid.Empty).ToHashSet();

        // // We load the movements according to the data currently in the database (i.e, before we've saved). This is to decrease the old holdings.
        // mvtData = StockHoldingStore.LoadMovementData(this, currentIDs.ToArray());
        // holdingData = StockHoldingStore.LoadStockHoldings(this, mvtData);
        //
        // StockHoldingStore.ModifyHoldings(mvtData, holdingData, StockHoldingStore.Action.Decrease);

        foreach(var sm in entities)
        {
            if(sm.Job.HasOriginalValue(x => x.ID) && sm.Job.ID != Guid.Empty && sm.JobScope.ID == Guid.Empty)
            {
                // If we have updated the Job.ID to a non-empty value, we should
                // update the JobScope to the default job scope for that job.

                var scopeID = Guid.Empty;
                if(sm.ID != Guid.Empty)
                {
                    // It's possible that the JobScope ID just wasn't passed up, if
                    // this entity already exists; hence, we shall load the scopeID
                    // from the database just in case.
                    scopeID = Provider.Query(
                        new Filter<StockMovement>(x => x.ID).IsEqualTo(sm.ID),
                        Columns.None<StockMovement>().Add(x => x.JobScope.ID))
                        .Rows.FirstOrDefault()?.Get<StockMovement, Guid>(x => x.JobScope.ID) ?? Guid.Empty;
                }
                if(scopeID == Guid.Empty)
                {
                    // No scope has been assigned; however, we have a job, so we
                    // load the default scope for the job.
                    sm.JobScope.ID = Provider.Query(
                        new Filter<Job>(x => x.ID).IsEqualTo(sm.Job.ID),
                        Columns.None<Job>().Add(x => x.DefaultScope.ID))
                        .Rows.FirstOrDefault()?.Get<Job, Guid>(x => x.DefaultScope.ID) ?? Guid.Empty;
                }
            }
        }
    }

    protected override void BeforeSave(StockMovement sm)
    {
        BeforeSave(CoreUtils.One(sm));
    }

    protected override void AfterSave(IEnumerable<StockMovement> entities)
    {
        // // Update the old movement data with the changes we've made.
        // foreach(var mvt in entities)
        // {
        //     var dataMvt = mvtData.FirstOrDefault(x => x.ID == mvt.ID);
        //     if (dataMvt is null) continue;
        //
        //     // Need to stop observing, because otherwise the order of property setting could and would break things.
        //     dataMvt.SetObserving(false);
        //     foreach(var (key, value) in mvt.OriginalValueList)
        //     {
        //         if(DatabaseSchema.Property(typeof(StockMovement), key) is IProperty prop)
        //         {
        //             prop.Setter()(dataMvt, prop.Getter()(mvt));
        //         }
        //     }
        //     dataMvt.SetObserving(true);
        // }

        // // Find all movements that weren't loaded in BeforeSave - i.e., they are new stock movements.
        // var newIDs = entities.Select(x => x.ID).Where(x => !currentIDs.Contains(x)).ToArray();
        // // Grab the data for these movements.
        // var newMvts = StockHoldingStore.LoadMovementData(this, newIDs);
        // // Load all the stock holdings for these movements, but only if we haven't loaded them already.
        // StockHoldingStore.LoadStockHoldings(this, newMvts, holdingData);
        //
        // // Add the new movement data to our data. Note that the above line does the same for holdings.
        // mvtData = mvtData.Concatenate(newMvts);
        //
        // // Update the Relevant StockHolding with the details of this movement
        // StockHoldingStore.ModifyHoldings(mvtData, holdingData, StockHoldingStore.Action.Increase);
        // StockHoldingStore.SaveHoldings(this, holdingData);
        
        foreach(var entity in entities)
        {
            // Calling base AfterSave so that it doesn't call our other AfterSave method.
            base.AfterSave(entity);
        }
    }

    protected override void AfterSave(StockMovement sm)
    {
        AfterSave(CoreUtils.One(sm));
    }

    protected override void BeforeDelete(StockMovement entity)
    {
        base.BeforeDelete(entity);
        
        // // We need to do this in before delete, because otherwise we wont have
        // // the data that we need to pull to properly update the stockholdings
        // StockHoldingStore.UpdateStockHolding(this, entity.ID,StockHoldingStore.Action.Decrease);
        
        // Now let's pull the requisition ID, so that we can clean this up
        // properly in AfterDelete()
        entity.JobRequisitionItem.ID = Provider.Query(
                new Filter<StockMovement>(x => x.ID).IsEqualTo(entity.ID),
                Columns.None<StockMovement>().Add(x => x.JobRequisitionItem.ID)
            ).Rows
            .FirstOrDefault()?
            .Get<StockMovement, Guid>(x => x.JobRequisitionItem.ID) ?? Guid.Empty;
    }
    
}