prs/prs.stores/PurchaseOrderItemStore.cs

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

namespace Comal.Stores
{
    internal class PurchaseOrderItemStore : BaseStore<PurchaseOrderItem>
    {

        private void UpdateStockMovements(PurchaseOrderItem entity)
        {
            if (!entity.Product.IsValid())
            {
                Logger.Send(LogType.Information, UserID, "PurchaseOrderItem.Product.ID is blank!");
                return;
            }

            var locationid = entity.StockLocation.ID;
            var locationValid = entity.StockLocation.IsValid();

            var movementtask = new Task<List<StockMovement>>(() =>
            {
                var result = Provider.Query(
                    new Filter<StockMovement>(x => x.OrderItem.ID).IsEqualTo(entity.ID),
                    new Columns<StockMovement>(
                        x => x.ID,
                        x => x.Date,
                        x => x.Product.ID,
                        x => x.Received,
                        x => x.Employee.ID,
                        x => x.OrderItem.ID,
                        x => x.Job.ID,
                        x => x.Location.ID,
                        x => x.Dimensions.Unit.ID,
                        x => x.Dimensions.Unit.Formula,
                        x => x.Dimensions.Unit.Format,
                        x => x.Dimensions.Quantity,
                        x => x.Dimensions.Length,
                        x => x.Dimensions.Width,
                        x => x.Dimensions.Height,
                        x => x.Dimensions.Weight,
                        x => x.Notes,
                        x => x.Cost,
                        x => x.Dimensions.Unit.HasHeight,
                        x => x.Dimensions.Unit.HasLength,
                        x => x.Dimensions.Unit.HasWidth,
                        x => x.Dimensions.Unit.HasWeight,
                        x => x.Dimensions.Unit.HasQuantity,
                        x => x.Dimensions.Unit.Formula,
                        x => x.Dimensions.Unit.Format,
                        x => x.Dimensions.Unit.Code,
                        x => x.Dimensions.Unit.Description
                    )
                ).Rows.Select(x => x.ToObject<StockMovement>()).ToList();
                if (!result.Any())
                    result.Add(new StockMovement());
                return result;
            });
            movementtask.Start();

            var producttask = new Task<CoreRow>(() =>
            {
                return Provider.Query(
                    new Filter<Product>(x => x.ID).IsEqualTo(entity.Product.ID),
                    new Columns<Product>(
                        x => x.ID,
                        x => x.DefaultLocation.ID,
                        x => x.Warehouse.ID,
                        x => x.Dimensions.Unit.ID,
                        x => x.Dimensions.Unit.Formula,
                        x => x.Dimensions.Unit.Format,
                        x => x.Dimensions.Quantity,
                        x => x.Dimensions.Length,
                        x => x.Dimensions.Width,
                        x => x.Dimensions.Height,
                        x => x.Dimensions.Weight,
                        x => x.NonStock,
                        x => x.Dimensions.Unit.HasHeight,
                        x => x.Dimensions.Unit.HasLength,
                        x => x.Dimensions.Unit.HasWidth,
                        x => x.Dimensions.Unit.HasWeight,
                        x => x.Dimensions.Unit.HasQuantity,
                        x => x.Dimensions.Unit.Formula,
                        x => x.Dimensions.Unit.Format,
                        x => x.Dimensions.Unit.Code,
                        x => x.Dimensions.Unit.Description
                    )
                ).Rows.FirstOrDefault();
            });
            producttask.Start();

            var locationtask = new Task<CoreTable>(() =>
            {
                return Provider.Query(
                    new Filter<StockLocation>(x => x.Default).IsEqualTo(true),
                    new Columns<StockLocation>(x => x.ID, x => x.Warehouse.ID, x => x.Warehouse.Default)
                );
            });
            locationtask.Start();

            Task.WaitAll(movementtask, producttask, locationtask);

            var movements = movementtask.Result;
            var productrow = producttask.Result;
            var defaultlocations = locationtask.Result;

            if (productrow == null)
            {
                Logger.Send(LogType.Information, UserID, "Cannot Find PurchaseOrderItem.Product.ID!");
                return;
            }

            if (productrow.Get<Product, bool>(x => x.NonStock))
            {
                Logger.Send(LogType.Information, UserID, "PurchaseOrderItem.Product is marked as Non Stock!");
                return;
            }

            if (!locationValid)
            {
                Logger.Send(LogType.Information, UserID, "PurchaseOrderItem.Location.ID is blank!");
                if (productrow != null)
                {
                    var productlocationid = productrow.EntityLinkID<Product, StockLocationLink>(x => x.DefaultLocation) ?? Guid.Empty;
                    if (productlocationid != Guid.Empty)
                    {
                        Logger.Send(LogType.Information, UserID, "- Using Product.DefaultLocation.ID as location");
                        locationid = productlocationid;
                    }
                    else
                    {
                        var productwarehouseid = productrow.Get<Product, Guid>(c => c.Warehouse.ID);
                        var row = defaultlocations.Rows.FirstOrDefault(r => r.Get<StockLocation, Guid>(c => c.Warehouse.ID) == productwarehouseid);
                        if (row != null)
                        {
                            Logger.Send(LogType.Information, UserID, "- Using Product.Warehouse -> Default as location");
                            locationid = row.Get<StockLocation, Guid>(x => x.ID);
                        }
                    }
                }

                if (locationid == Guid.Empty)
                {
                    var row = defaultlocations.Rows.FirstOrDefault(r => r.Get<StockLocation, bool>(c => c.Warehouse.Default));
                    if (row != null)
                    {
                        Logger.Send(LogType.Information, UserID, "- Using Default Warehouse -> Default Location as location");
                        locationid = row.Get<StockLocation, Guid>(x => x.ID);
                    }
                }

                if (locationid == Guid.Empty)
                {
                    Logger.Send(LogType.Information, UserID, "- Cannot find Location : Skipping Movement Creation");
                    return;
                }
            }


            if (
                (entity.Dimensions.Unit.ID == Guid.Empty)
                && (entity.Dimensions.Height == 0)
                && (entity.Dimensions.Width == 0)
                && (entity.Dimensions.Length == 0)
                && (entity.Dimensions.Weight == 0)
                )
            {
                Logger.Send(LogType.Information, UserID, "PurchaseOrderItem.Unit Size is zero!");
                entity.Dimensions.CopyFrom(productrow.ToObject<Product>().Dimensions);
            }

            var product = productrow.ToObject<Product>();

            foreach (var movement in movements)
            {
                movement.Batch.Type = StockMovementBatchType.Receipt;
                movement.Date = entity.ReceivedDate;
                movement.Product.ID = entity.Product.ID;
                movement.Received = entity.Qty;
                movement.Employee.ID = Guid.Empty;
                movement.OrderItem.ID = entity.ID;
                movement.Job.ID = entity.Job.ID;
                movement.Location.ID = locationid;
                movement.Style.ID = entity.Style.ID;
                movement.Style.Code = entity.Style.Code;
                movement.Style.Description = entity.Style.Description;
                movement.Notes = string.Format("Received on PO {0}", entity.PurchaseOrderLink.PONumber);
                movement.Cost = entity.Cost;
                movement.Dimensions.UnitSize = product.Dimensions.UnitSize;
                movement.Dimensions.Unit.ID = product.Dimensions.Unit.ID;
                movement.Dimensions.Height = product.Dimensions.Height;
                movement.Dimensions.Length = product.Dimensions.Length;
                movement.Dimensions.Width = product.Dimensions.Width;
                movement.Dimensions.Weight = product.Dimensions.Weight;
                movement.Dimensions.Quantity = product.Dimensions.Quantity;
                movement.Dimensions.Unit.HasHeight = product.Dimensions.Unit.HasHeight;
                movement.Dimensions.Unit.HasWidth = product.Dimensions.Unit.HasWidth;
                movement.Dimensions.Unit.HasLength = product.Dimensions.Unit.HasLength;
                movement.Dimensions.Unit.HasWeight = product.Dimensions.Unit.HasWeight;
                movement.Dimensions.Unit.HasQuantity = product.Dimensions.Unit.HasQuantity;
                movement.Dimensions.Unit.Formula = product.Dimensions.Unit.Formula;
                movement.Dimensions.Unit.Format = product.Dimensions.Unit.Format;
                movement.Dimensions.Unit.Code = product.Dimensions.Unit.Code;
                movement.Dimensions.Unit.Description = product.Dimensions.Unit.Description;
            }

            var updates = movements.Where(x => x.IsChanged());
            if (updates.Any())
                FindSubStore<StockMovement>().Save(updates, "Updated by Purchase Order Modification");
        }


        private void DeleteStockMovements(PurchaseOrderItem entity)
        {
            var movements = Provider.Query(
                new Filter<StockMovement>(x => x.OrderItem.ID).IsEqualTo(entity.ID),
                new Columns<StockMovement>(x => x.ID)
            ).Rows.Select(x => x.ToObject<StockMovement>());

            if (movements.Any())
                FindSubStore<StockMovement>().Delete(movements, "Purchase Order Item marked as Unreceived");
        }

        protected override void BeforeSave(PurchaseOrderItem entity)
        {
            base.BeforeSave(entity);
            EnsureJobMaterials(entity.Product, entity.Job, entity.Style, entity.Dimensions);
        }

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

            if (entity.ReceivedDate.IsEmpty())
                DeleteStockMovements(entity);
            else
            {
                UpdateStockMovements(entity);
                UpdateJobRequiItems(entity);
            }
            //}

            CleanupJobMaterials(entity.ID, entity.Product, entity.Job, entity.Style, entity.Dimensions, false);

        }

        private void UpdateJobRequiItems(PurchaseOrderItem entity)
        {
            var table = Provider.Query(
                new Filter<JobRequisitionItem>(x => x.PurchaseOrderItem.ID).IsEqualTo(entity.ID),
                new Columns<JobRequisitionItem>(x => x.ID, x => x.Status)
                );
            if (table.Rows.Any())
            {
                JobRequisitionItem item = table.Rows.FirstOrDefault().ToObject<JobRequisitionItem>();
                if (item.Status == JobRequisitionItemStatus.TreatmentOnOrder)
                    item.Status = JobRequisitionItemStatus.TreatmentReceived;
                else
                    item.Status = JobRequisitionItemStatus.Received;
            }
        }

        protected override void BeforeDelete(PurchaseOrderItem entity)
        {
            base.BeforeDelete(entity);
            DeleteStockMovements(entity);

            var delete = Provider.Query(
                new Filter<PurchaseOrderItem>(x => x.ID).IsEqualTo(entity.ID),
                new Columns<PurchaseOrderItem>(x => x.ID)
                    .Add(x => x.Product.ID)
                    .Add(x => x.Job.ID)
                    .Add(x => x.Style.ID)
                    .Add(x => x.Dimensions.Unit.ID)
                    .Add(x => x.Dimensions.Length)
                    .Add(x => x.Dimensions.Width)
                    .Add(x => x.Dimensions.Height)
                    .Add(x => x.Dimensions.Weight)
            ).Rows.FirstOrDefault()?.ToObject<PurchaseOrderItem>();
            CleanupJobMaterials(delete.ID, delete.Product, delete.Job, delete.Style, delete.Dimensions, true);
        }

        protected override void AfterDelete(PurchaseOrderItem entity)
        {
            base.AfterDelete(entity);
            RemoveJobRequisitionItemLink(entity);
        }

        private void RemoveJobRequisitionItemLink(PurchaseOrderItem entity)
        {
            CoreTable table = Provider.Query<JobRequisitionItem>
                (
                new Filter<JobRequisitionItem>(x => x.PurchaseOrderItem.ID).IsEqualTo(entity.ID),
                new Columns<JobRequisitionItem>(x => x.ID, x => x.PurchaseOrderItem.PurchaseOrderLink.PONumber, x => x.Status)
                );
            if (table.Rows.Any())
            {
                JobRequisitionItem item = table.Rows.FirstOrDefault().ToObject<JobRequisitionItem>();
                item.PurchaseOrderItem.PurchaseOrderLink.PONumber = "";
                item.Status = JobRequisitionItemStatus.NotChecked;
                Provider.Save<JobRequisitionItem>(item);
            }
        }
    }
}