prs/prs.shared/Database Update Scripts/Update_7_52.cs

using Comal.Classes;
using Comal.Stores;
using InABox.Core;
using InABox.Database;
using PRS.Shared.Database_Update_Scripts.Utils;
using PRSStores;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static ICSharpCode.AvalonEdit.Document.TextDocumentWeakEventManager;

namespace PRS.Shared;

public class Update_7_52 : DatabaseUpdateScript
{
    
    private Type jripoiType = null;
    
    public Update_7_52()
    {
        jripoiType = CoreUtils.GetEntity("Comal.Classes.JobRequisitionItemPurchaseOrderItem");
    } 

    
    public override VersionNumber Version => new VersionNumber(7, 52);

    private IStore<JobRequisitionItem>? _store;

    private IStore<JobRequisitionItem> Store
    {
        get
        {
            _store ??= DbFactory.FindStore<JobRequisitionItem>(Guid.Empty, "", Platform.Server, CoreUtils.GetVersion(), Logger.New());
            return _store;
        }
    }

    private void UpdateStockMovements()
    {
        var jobRequiItems = DbFactory.NewProvider(Logger.Main).Query(
            new Filter<JobRequisitionItem>(x => x.PurchaseOrderItem.ID).IsNotEqualTo(null),
            Columns.None<JobRequisitionItem>().Add(x => x.ID)
                .Add(x => x.PurchaseOrderItem.ID))
            .ToObjects<JobRequisitionItem>()
            .ToList();

        var _poiIDs = DbFactory.NewProvider(Logger.Main).GetTable(jripoiType).ExtractValues<Guid>("PurchaseOrderItem.ID").Distinct().ToArray();
        
        var mvts = DbFactory.NewProvider(Logger.Main).Query(
            new Filter<StockMovement>(x => x.JobRequisitionItem.ID).IsEqualTo(null)
                .And(x => x.OrderItem.ID).IsNotEqualTo(null)
                .And(new Filter<StockMovement>(x => x.OrderItem.ID).InList(_poiIDs) //<JobRequisitionItemPurchaseOrderItem>(null, x => x.PurchaseOrderItem.ID)
                    .Or(x => x.OrderItem.ID).InQuery<JobRequisitionItem>(null, x => x.PurchaseOrderItem.ID)),
            Columns.None<StockMovement>().Add(x => x.ID)
                .Add(x => x.OrderItem.ID))
            .ToObjects<StockMovement>()
            .ToList();

        Logger.Send(LogType.Information, "", $"Updating JobRequisitionItem.ID for {mvts.Count} StockMovements");

        var orderItemIDs = mvts.Select(x => x.OrderItem.ID).ToArray();

        var jriPois = DbFactory.NewProvider(Logger.Main).Query(
            jripoiType, Filter.Create(jripoiType,"PurchaseOrderItem.ID",Operator.InList, orderItemIDs),
            Columns.None(jripoiType).Add("JobRequisitionItem.ID").Add("PurchaseOrderItem.ID")
        );

        var _jris = DbFactory.NewProvider(Logger.Main).Query(
            new Filter<JobRequisitionItem>(x => x.PurchaseOrderItem.ID).InList(orderItemIDs),
            Columns.None<JobRequisitionItem>().Add(x => x.ID).Add(x => x.PurchaseOrderItem.ID))
            .ToObjects<JobRequisitionItem>();

        var requiIDs = new Dictionary<Guid, Guid>();
        foreach(var _row in jriPois.Rows)
        {
            requiIDs.TryAdd(_row.Get<Guid>("PurchaseOrderItem.ID"), _row.Get<Guid>("JobRequisitionItem.ID"));
        }
        foreach (var _jri in _jris)
        {
            requiIDs.TryAdd(_jri.PurchaseOrderItem.ID, _jri.ID);
        }

        foreach(var mvt in mvts)
        {
            if(requiIDs.TryGetValue(mvt.OrderItem.ID, out var requiItemID))
            {
                mvt.JobRequisitionItem.ID = requiItemID;
            }
            else
            {
                Logger.Send(LogType.Error, "", $"StockMovement which didn't have an associated JobRequisitionItem: {mvt.ID}");
            }
        }

        var changed = mvts.Where(x => x.IsChanged()).ToList();

        // Not going through the store otherwise the JobRequisitionItem Status will be updated incorrectly.
        DbFactory.NewProvider(Logger.Main).Save(changed);

        Logger.Send(LogType.Information, "", $"Updated {changed.Count} StockMovements");
    }

    private void UpdateOrderStatus()
    {
        var jobRequiItems = DbFactory.NewProvider(Logger.Main).Query(
            new Filter<JobRequisitionItem>(x => x.OrderRequired).IsEqualTo(DateTime.MinValue)
                .And(new Filter<JobRequisitionItem>(x => x.Status).IsEqualTo(JobRequisitionItemStatus.OrderRequired)
                    .Or(x => x.Status).IsEqualTo(JobRequisitionItemStatus.OnOrder)
                    .Or(x => x.Status).IsEqualTo(JobRequisitionItemStatus.Received)),
            Columns.None<JobRequisitionItem>().Add(x => x.ID)
                .Add(x => x.LastUpdate))
            .ToObjects<JobRequisitionItem>()
            .ToList();

        foreach (var jri in jobRequiItems)
        {
            jri.OrderRequired = jri.LastUpdate;
        }

        DbFactory.NewProvider(Logger.Main).Save(jobRequiItems);
    }

    private void CreateJobRequisitionItemPurchaseOrderItems()
    {
        
        var _poiIDs = DbFactory.NewProvider(Logger.Main).GetTable(jripoiType).ExtractValues<Guid>("PurchaseOrderItem.ID").Distinct().ToArray();

        var jobRequiItems = DbFactory.NewProvider(Logger.Main).Query(
            new Filter<JobRequisitionItem>(x => x.PurchaseOrderItem.ID).IsNotEqualTo(null)
                .And(x => x.ID).NotInList(_poiIDs),
            Columns.None<JobRequisitionItem>().Add(x => x.ID)
                .Add(x => x.PurchaseOrderItem.ID)
                .Add(x => x.Status))
            .ToObjects<JobRequisitionItem>()
            .ToList();
        Logger.Send(LogType.Information, "", $"Creating JobRequisitionPurchaseOrderItems for {jobRequiItems.Count} JobRequisitionItems");

        var newJRIPois = new List<Entity>();
        foreach (var jri in jobRequiItems)
        {
            var jriPoi = Activator.CreateInstance(jripoiType) as Entity;
            CoreUtils.SetPropertyValue(jriPoi,"JobRequisitionItem.ID",jri.ID);
            CoreUtils.SetPropertyValue(jriPoi,"PurchaseOrderItem.ID",jri.PurchaseOrderItem.ID);
            newJRIPois.Add(jriPoi);
        }
        DbFactory.NewProvider(Logger.Main).Save(jripoiType,newJRIPois);
        DbFactory.NewProvider(Logger.Main).Save(jobRequiItems);
    }

    public override bool Update()
    {
        UpdateStockMovements();
        UpdateOrderStatus();
        CreateJobRequisitionItemPurchaseOrderItems();
        //JobRequisitionItemUtils.RefreshStatuses(Store);

        return true;
    }
}