prs/prs.desktop/JobRequisitionReviewGrid.cs

using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace PRSDesktop
{
    public delegate void JobRequiItemSelect(JobRequisitionItem item);
    public delegate void GridRefresh();
    public class JobRequisitionReviewGrid : DynamicDataGrid<JobRequisitionItem>
    {
        public event JobRequiItemSelect OnJobRequiItemSelected;
        public event GridRefresh OnGridRefresh;
        List<Guid> filterProductIDs = new List<Guid>();
        public Guid empID = new Guid();
        string empName = "";
        bool bIncludeArchived = false;
        bool bViewCancelled = false;

        public JobRequisitionReviewGrid()
        {
            Options.AddRange(
            DynamicGridOption.FilterRows,
            DynamicGridOption.SelectColumns,
            DynamicGridOption.RecordCount,
            DynamicGridOption.MultiSelect
            );
            HiddenColumns.Add(x => x.ID);
            HiddenColumns.Add(x => x.Product.ID);
            HiddenColumns.Add(x => x.Product.Code);
            HiddenColumns.Add(x => x.Product.Group.ID);
            HiddenColumns.Add(x => x.Product.Group.Code);
            HiddenColumns.Add(x => x.Product.Group.Description);
            HiddenColumns.Add(x => x.Style.ID);
            HiddenColumns.Add(x => x.Style.Code);
            HiddenColumns.Add(x => x.Style.Description);
            HiddenColumns.Add(x => x.Requisition.ID);
            HiddenColumns.Add(x => x.Requisition.Job.ID);
            HiddenColumns.Add(x => x.Requisition.Job.JobNumber);
            HiddenColumns.Add(x => x.Requisition.Job.Name);
            HiddenColumns.Add(x => x.Requisition.Number);
            HiddenColumns.Add(x => x.PurchaseOrderItem.PurchaseOrderLink.ID);
            HiddenColumns.Add(x => x.PurchaseOrderItem.PurchaseOrderLink.PONumber);
            HiddenColumns.Add(x => x.PurchaseOrderItem.DueDate);
            HiddenColumns.Add(x => x.Job.ID);
            HiddenColumns.Add(x => x.Dimensions.UnitSize);
            HiddenColumns.Add(x => x.Dimensions.Length);
            HiddenColumns.Add(x => x.Dimensions.Width);
            HiddenColumns.Add(x => x.Dimensions.Height);
            HiddenColumns.Add(x => x.Dimensions.Weight);
            HiddenColumns.Add(x => x.Dimensions.Quantity);
            HiddenColumns.Add(x => x.Dimensions.Value);
            HiddenColumns.Add(x => x.Dimensions.Unit.ID);
            HiddenColumns.Add(x => x.Dimensions.Unit.HasLength);
            HiddenColumns.Add(x => x.Dimensions.Unit.HasHeight);
            HiddenColumns.Add(x => x.Dimensions.Unit.HasWidth);
            HiddenColumns.Add(x => x.Dimensions.Unit.HasWeight);
            HiddenColumns.Add(x => x.Dimensions.Unit.HasQuantity);
            HiddenColumns.Add(x => x.Dimensions.Unit.Formula);
            HiddenColumns.Add(x => x.Dimensions.Unit.Format);
            HiddenColumns.Add(x => x.Dimensions.Unit.Code);
            HiddenColumns.Add(x => x.Dimensions.Unit.Description);

            if (Security.CanEdit<JobRequisitionItem>())
                ActionColumns.Add(new DynamicMenuColumn(BuildMenu, EmptyReturnFunction));
            if (Security.CanEdit<PurchaseOrder>())
                AddButton("Create Purchase Order", null, CreatePurchaseOrder);
            if (Security.CanEdit<PurchaseOrder>())
                AddButton("Create Treatment PO", null, CreateTreatmentPO);

            AddButton("Include Archived", null, ViewArchived);
            AddButton("Include Cancelled", null, ViewCancelled);
            
            OnSelectItem += JobRequisitionReviewGrid_OnSelectItem;

            ColumnsTag = "JobRequisitionReview";

            CoreTable table = new Client<Employee>().Query(new Filter<Employee>(x => x.UserLink.UserID).IsEqualTo(ClientFactory.UserID), new Columns<Employee>(x => x.ID, x => x.Name));
            if (table.Rows.Any())
            {
                empID = Guid.Parse(table.Rows.FirstOrDefault().Values[0].ToString());
                empName = table.Rows.FirstOrDefault().Values[1].ToString();
            }
        }

        private void JobRequisitionReviewGrid_OnSelectItem(object sender, DynamicGridSelectionEventArgs e)
        {
            OnJobRequiItemSelected?.Invoke(SelectedRows[0].ToObject<JobRequisitionItem>());
        }

        private bool ViewCancelled(Button button, CoreRow[] rows)
        {
            if (bViewCancelled)
            {
                bViewCancelled = false;
                button.Content = "Include Cancelled";
            }
            else
            {
                bViewCancelled = true;
                button.Content = "Exclude Cancelled";
            }

            OnGridRefresh?.Invoke();

            return true;
        }

        private bool ViewArchived(Button button, CoreRow[] rows)
        {
            if (bIncludeArchived)
            {
                bIncludeArchived = false;
                button.Content = "Include Archived";
            }
            else
            {
                bIncludeArchived = true;
                button.Content = "Exclude Archived";
            }

            OnGridRefresh?.Invoke();

            return true;
        }

        private bool CreateTreatmentPO(Button button, CoreRow[] rows)
        {
            return true;
        }

        protected override void GenerateColumns(DynamicGridColumns columns)
        {
            columns.Add<JobRequisitionItem, DateTime>(x => x.Created, 80, "Date", "", Alignment.MiddleLeft);
            columns.Add<JobRequisitionItem, string>(x => x.Requisition.Job.JobNumber, 70, "Job", "", Alignment.MiddleLeft);
            columns.Add<JobRequisitionItem, int>(x => x.Requisition.Number, 50, "NO.", "", Alignment.MiddleLeft);
            columns.Add<JobRequisitionItem, string>(x => x.Product.Code, 70, "Code", "", Alignment.MiddleLeft);
            columns.Add<JobRequisitionItem, string>(x => x.Product.Name, 200, "Product Name", "", Alignment.MiddleLeft);
            columns.Add<JobRequisitionItem, string>(x => x.Style.Description, 150, "Style", "", Alignment.MiddleLeft);
            columns.Add<JobRequisitionItem, double>(x => x.Qty, 50, "Qty", "", Alignment.MiddleLeft);
            columns.Add<JobRequisitionItem, string>(x => x.Dimensions.UnitSize, 50, "Size", "", Alignment.MiddleLeft);
            columns.Add<JobRequisitionItem, string>(x => x.PurchaseOrderItem.PurchaseOrderLink.PONumber, 80, "PO Number", "", Alignment.MiddleLeft);
            columns.Add<JobRequisitionItem, string>(x => x.PurchaseOrderItem.PONumber, 80, "PO Number", "", Alignment.MiddleLeft);
            columns.Add<JobRequisitionItem, DateTime>(x => x.PurchaseOrderItem.DueDate, 80, "Due", "", Alignment.MiddleLeft);
            columns.Add<JobRequisitionItem, DateTime>(x => x.PurchaseOrderItem.ReceivedDate, 80, "Received", "", Alignment.MiddleLeft);
            columns.Add<JobRequisitionItem, JobRequisitionItemStatus>(x => x.Status, 80, "Status", "", Alignment.MiddleLeft);
            columns.Add<JobRequisitionItem, string>(x => x.Notes, 300, "Notes", "", Alignment.MiddleLeft);
        }

        private DynamicMenuStatus EmptyReturnFunction(CoreRow row)
        {
            return DynamicMenuStatus.Enabled;
        }

        #region Action Column Buttons
        private bool CheckValidAction(JobRequisitionItem item, bool bypassReserved)
        {
            bool valid = true;
            if (item.Status == JobRequisitionItemStatus.Reserved && !bypassReserved)
            {
                MessageBox.Show("Error. Item has already been reserved!");
                return false;
            }
            else if (item.Status == JobRequisitionItemStatus.OnOrder)
            {
                MessageBox.Show("Error. Item is already on order!");
                return false;
            }
            if (item.Status == JobRequisitionItemStatus.Received)
            {
                MessageBox.Show("Error. Item has already been recieved!");
                return false;
            }
            return valid;
        }

        private void SplitLine(JobRequisitionItem item, double oldItemQty, double newItemQty, string notes)
        {
            List<JobRequisitionItem> items = new List<JobRequisitionItem>();
            JobRequisitionItem newItem = new JobRequisitionItem();
            newItem.Requisition.ID = item.Requisition.ID;
            newItem.Requisition.Job.ID = item.Requisition.Job.ID;
            newItem.Requisition.Job.JobNumber = item.Requisition.Job.JobNumber;
            newItem.Requisition.Job.Name = item.Requisition.Job.Name;
            newItem.Product.ID = item.Product.ID;
            newItem.Product.Name = item.Product.Name;
            newItem.Product.Code = item.Product.Code;
            newItem.Product.Group.ID = item.Product.Group.ID;
            newItem.Product.Group.Description = item.Product.Group.Description;
            newItem.Dimensions.CopyFrom(item.Dimensions);
            newItem.Style.ID = item.Style.ID;
            newItem.Style.Description = item.Style.Description;
            newItem.Style.Code = item.Style.Code;
            newItem.Notes = item.Notes + Environment.NewLine + notes;
            item.Notes = newItem.Notes;

            item.Qty = oldItemQty;
            newItem.Qty = newItemQty;

            items.Add(newItem);
            items.Add(item);
            new Client<JobRequisitionItem>().Save(items, "Split lines from Job Requi Item Review Dashboard");
            MessageBox.Show("Line split - original line Qty is now " + item.Qty + ". New line Qty is " + newItem.Qty, "Success");
            OnGridRefresh?.Invoke();
        }

        private void SplitLine_Clicked(CoreRow row)
        {
            JobRequisitionItem item = row.ToObject<JobRequisitionItem>();
            if (CheckValidAction(item, false))
            {
                int units = Convert.ToInt32(item.Qty);
                if (NumberEdit.Execute("Enter amount to split", 1, units, ref units))
                {
                    SplitLine(item, item.Qty - units, units, "Line split");
                }
            }
        }

        private void Archive_Clicked(CoreRow row)
        {
            JobRequisitionItem item = row.ToObject<JobRequisitionItem>();

            SaveRow(row, JobRequisitionItemStatus.Archived, "Line marked as Archived by " + empName + " on " + DateTime.Now.ToString("dd MMM yy"));
        }

        private void OrderRequired_Clicked(CoreRow row)
        {
            JobRequisitionItem item = row.ToObject<JobRequisitionItem>();
            if (CheckValidAction(item, false))
                SaveRow(row, JobRequisitionItemStatus.OrderRequired, "Line marked as Order Required by " + empName + " on " + DateTime.Now.ToString("dd MMM yy"));
        }

        private void TreatmentRequired_Clicked(CoreRow row)
        {
            JobRequisitionItem item = row.ToObject<JobRequisitionItem>();
            if (item.Status != JobRequisitionItemStatus.Reserved)
            {
                MessageBox.Show("Stock must first be reserved for this item");
                return;
            }
            SaveRow(row, JobRequisitionItemStatus.TreatmentRequired, "Line marked as Treatment Required by " + empName + " on " + DateTime.Now.ToString("dd MMM yy"));
        }

        private void Uncheck_Clicked(CoreRow row)
        {
            string extraMessage = "";
            JobRequisitionItem item = row.ToObject<JobRequisitionItem>();
            if (!CheckValidAction(item, true))
                return;
            CoreTable table = new Client<StockMovement>().Query
                (
                new Filter<StockMovement>(x => x.JobRequisitionItem.ID).IsEqualTo(item.ID),
                new Columns<StockMovement>(x => x.ID)
                );
            if (table.Rows.Any())
            {
                var result = MessageBox.Show("This will reverse stock movements already created for this Requisition Item. Proceed?", "Alert", MessageBoxButton.YesNo);
                switch (result)
                {
                    case MessageBoxResult.Yes:
                        break;
                    case MessageBoxResult.No:
                        return;
                    default:
                        return;
                }
                List<StockMovement> movements = new List<StockMovement>();
                foreach (CoreRow stockmovementRow in table.Rows)
                {
                    StockMovement movement = new StockMovement();
                    movement.ID = Guid.Parse(stockmovementRow.Values[0].ToString());
                    movements.Add(movement);
                }
                new Client<StockMovement>().Delete(movements, "Stock movements reversed from Job Requisition Item Review Dashboard");
                extraMessage = " and Stock Movements Reversed ";
            }
            SaveRow(row, JobRequisitionItemStatus.NotChecked, "Line marked as Not Checked by " + empName + extraMessage + " on " + DateTime.Now.ToString("dd MMM yy"));
        }

        private bool CreatePurchaseOrder(Button btn, CoreRow[] rows)
        {
            if (!rows.Any())
            {
                MessageBox.Show("Please select at least one row to add to Purchase Order!");
                return false;
            }

            PurchaseOrder purchaseOrder = new PurchaseOrder();
            purchaseOrder.Notes = "Created from Job Requi Item Review Screen" + System.Environment.NewLine;
            purchaseOrder.RaisedBy.ID = empID;
            var page = new SupplierPurchaseOrders();
            page.OnAfterSave += (form, items) =>
            {
                PurchaseOrderOnSave(form, items.Cast<PurchaseOrder>().ToArray());
            };
            return page.EditItems(new[] { purchaseOrder }, LoadPurchaseOrderItems, true);
        }

        private void PurchaseOrderOnSave(IDynamicEditorForm form, PurchaseOrder[] items)
        {
            Progress.Show("Working");

            Guid POID = items[0].ID;

            CoreTable table = new Client<PurchaseOrderItem>().Query(new Filter<PurchaseOrderItem>(x => x.PurchaseOrderLink.ID).IsEqualTo(POID),
                new Columns<PurchaseOrderItem>(x => x.ID, x => x.Product.ID, x => x.Qty, x => x.Dimensions.UnitSize, x => x.DueDate, x => x.Job.ID));
            if (table.Rows.Any())
            {
                var poItems = AddPOItems(table, new List<PurchaseOrderItem>());

                var requiItems = MatchRequiItems(poItems, new List<JobRequisitionItem>());

                if (requiItems.Count > 0)
                    SaveAndRefreshScreen(requiItems);
            }
            Progress.Close();
        }

        private void SaveAndRefreshScreen(List<JobRequisitionItem> requiItems)
        {
            new Client<JobRequisitionItem>().Save(requiItems, "Updated on Create Purchase Order from Job Requi Dashboard");
            OnGridRefresh?.Invoke();
        }

        private List<PurchaseOrderItem> AddPOItems(CoreTable table, List<PurchaseOrderItem> poItems)
        {
            foreach (CoreRow row in table.Rows)
            {
                PurchaseOrderItem poItem = row.ToObject<PurchaseOrderItem>();
                poItems.Add(poItem);
            }
            return poItems;
        }

        private List<JobRequisitionItem> MatchRequiItems(List<PurchaseOrderItem> poItems, List<JobRequisitionItem> requiItems)
        {
            foreach (CoreRow row in SelectedRows)
            {
                JobRequisitionItem JobReqItem = row.ToObject<JobRequisitionItem>();
                foreach (var item in poItems)
                {
                    if (string.IsNullOrWhiteSpace(JobReqItem.Dimensions.UnitSize))
                        JobReqItem.Dimensions.UnitSize = QueryUnitSize(JobReqItem.Product.ID);

                    if (string.IsNullOrWhiteSpace(item.Dimensions.UnitSize))
                        item.Dimensions.UnitSize = QueryUnitSize(item.Product.ID);

                    if (JobReqItem.Job.ID == Guid.Empty)
                        JobReqItem.Job.ID = QueryJobID(JobReqItem.Requisition.ID);

                    if (item.Job.ID == Guid.Empty)
                        item.Job.ID = QueryJobID(JobReqItem.Requisition.ID);

                    if (MatchReqItemToPOItem(JobReqItem, item))
                        requiItems.Add(UpdateJobReqItemWithPODetails(JobReqItem, item));
                }
            }
            return requiItems;
        }



        private JobRequisitionItem UpdateJobReqItemWithPODetails(JobRequisitionItem JobReqItem, PurchaseOrderItem item)
        {
            JobReqItem.PurchaseOrderItem.ID = item.ID;
            JobReqItem.PurchaseOrderItem.DueDate = item.DueDate;
            if (JobReqItem.Status != JobRequisitionItemStatus.OnOrder)
            {
                JobReqItem.Notes = JobReqItem.Notes + Environment.NewLine + "Line marked as On Order by " + empName + " on " + DateTime.Now.ToString("dd MMM yy");
                JobReqItem.Status = JobRequisitionItemStatus.OnOrder;
            }
            return JobReqItem;
        }

        private bool MatchReqItemToPOItem(JobRequisitionItem JobReqItem, PurchaseOrderItem item)
        {
            if (JobReqItem.Product.ID == item.Product.ID &&
                                JobReqItem.Dimensions.UnitSize == item.Dimensions.UnitSize &&
                                JobReqItem.Job.ID == item.Job.ID)
                return true;
            else
                return false;
        }

        private string QueryUnitSize(Guid productID)
        {
            CoreTable table = new Client<Product>().Query(new Filter<Product>(x => x.ID).IsEqualTo(productID),
                new Columns<Product>(x => x.Dimensions.UnitSize));
            return table.Rows.FirstOrDefault().Get<string>("Dimensions.UnitSize");
        }

        private Guid QueryJobID(Guid iD)
        {
            CoreTable table = new Client<JobRequisition>().Query(new Filter<JobRequisition>(x => x.ID).IsEqualTo(iD),
                new Columns<JobRequisition>(x => x.Job.ID));
            return table.Rows.FirstOrDefault().Get<Guid>("Job.ID");
        }

        private CoreTable LoadPurchaseOrderItems(Type arg)
        {
            Progress.Show("Working");
            var result = new CoreTable();
            result.LoadColumns(typeof(PurchaseOrderItem));
            List<PurchaseOrderItem> items = new List<PurchaseOrderItem>();
            foreach (CoreRow row in SelectedRows)
            {
                JobRequisitionItem JobReqItem = row.ToObject<JobRequisitionItem>();
                PurchaseOrderItem POItem = new PurchaseOrderItem();
                POItem.Product.ID = JobReqItem.Product.ID;
                POItem.Product.Code = JobReqItem.Product.Code;
                POItem.Product.Name = JobReqItem.Product.Name;
                POItem.Description = JobReqItem.Product.Name;
                POItem.Qty = JobReqItem.Qty;
                POItem.Dimensions.CopyFrom(JobReqItem.Dimensions);
                POItem.Style.ID = JobReqItem.Style.ID;
                POItem.Style.Code = JobReqItem.Style.Code;
                POItem.Style.Description = JobReqItem.Style.Description;
                POItem.Job.ID = JobReqItem.Requisition.Job.ID;
                POItem.Dimensions.UnitSize = JobReqItem.Dimensions.UnitSize;
                items.Add(POItem);
            }
            result.LoadRows(items);
            Progress.Close();
            return result;
        }
        #endregion

        #region Utils
        private void SaveRow(CoreRow row, JobRequisitionItemStatus status, string note)
        {
            if (row == null)
                return;
            var id = row.Get<JobRequisitionItem, Guid>(c => c.ID);
            JobRequisitionItem item = Data.Rows.Where(r => r.Get<JobRequisitionItem, Guid>(c => c.ID).Equals(id)).FirstOrDefault().ToObject<JobRequisitionItem>();
            item.Status = status;
            item.Notes = item.Notes + Environment.NewLine + note;
            new Client<JobRequisitionItem>().Save(item, "Updated From Job Requisition Review Dashboard");

            OnGridRefresh?.Invoke();

        }

        private void SaveItem(JobRequisitionItem item, JobRequisitionItemStatus status, string note)
        {
            item.Status = status;
            item.Notes = item.Notes + Environment.NewLine + note;
            new Client<JobRequisitionItem>().Save(item, "Updated From Job Requisition Review Dashboard");
            OnGridRefresh?.Invoke();
        }

        private void MultiSaveRows(CoreRow[] rows, JobRequisitionItemStatus status, string note)
        {
            List<JobRequisitionItem> items = new List<JobRequisitionItem>();
            foreach (CoreRow row in rows)
            {
                var id = row.Get<JobRequisitionItem, Guid>(c => c.ID);
                JobRequisitionItem item = Data.Rows.Where(r => r.Get<JobRequisitionItem, Guid>(c => c.ID).Equals(id)).FirstOrDefault().ToObject<JobRequisitionItem>();
                item.Status = status;
                item.Notes = item.Notes + Environment.NewLine + note;
                items.Add(item);
            }
            new Client<JobRequisitionItem>().Save(items, "Updated From Job Requisition Review Dashboard");
            OnGridRefresh?.Invoke();
        }


        protected override void Reload(Filters<JobRequisitionItem> criteria, Columns<JobRequisitionItem> columns, ref SortOrder<JobRequisitionItem> sort,
            Action<CoreTable, Exception> action)
        {
            criteria.Add(new Filter<JobRequisitionItem>(x => x.Requisition.Approved).IsNotEqualTo(DateTime.MinValue));

            if (!bViewCancelled)
                criteria.Add(new Filter<JobRequisitionItem>(x => x.Status).IsNotEqualTo(JobRequisitionItemStatus.Cancelled));

            if (!bIncludeArchived)
                criteria.Add(new Filter<JobRequisitionItem>(x => x.Status).IsNotEqualTo(JobRequisitionItemStatus.Archived));

            if (filterProductIDs.Count > 0)
            {
                Filter<JobRequisitionItem> filter = new Filter<JobRequisitionItem>(x => x.Product.ID).IsEqualTo(filterProductIDs.FirstOrDefault());
                foreach (Guid id in filterProductIDs)
                {
                    if (id != filterProductIDs[0])
                        filter = filter.Or(x => x.Product.ID).IsEqualTo(id);
                }
                criteria.Add(filter);
            }
            sort = new SortOrder<JobRequisitionItem>(x => x.Requisition.Number, SortDirection.Descending);
            base.Reload(criteria, columns, ref sort, action);
        }

        public void RefreshOnFilterChanged(Guid id)
        {
            filterProductIDs.Clear();
            if (id != Guid.Empty)
            {
                CoreTable table = new Client<SupplierProduct>().Query(
                    new Filter<SupplierProduct>(x => x.SupplierLink.ID).IsEqualTo(id)
                        .And(x => x.Product).LinkValid(),
                    new Columns<SupplierProduct>(x => x.Product.ID));
                if (table.Rows.Any())
                {
                    foreach (CoreRow row in table.Rows)
                    {
                        filterProductIDs.Add(Guid.Parse(row.Values[0].ToString()));
                    }
                }
            }
            OnGridRefresh?.Invoke();
        }

        private void BuildMenu(DynamicMenuColumn column, CoreRow row)
        {
            column.AddItem("Treatment Required", PRSDesktop.Resources.palette, TreatmentRequired_Clicked);
            column.AddItem("Order Required", PRSDesktop.Resources.purchase, OrderRequired_Clicked);
            column.AddItem("Mark as Not Checked", PRSDesktop.Resources.disabled, Uncheck_Clicked);
            column.AddItem("Split Line", PRSDesktop.Resources.split, SplitLine_Clicked);
            column.AddItem("Archive", PRSDesktop.Resources.archive, Archive_Clicked);
        }
        #endregion
    }

    public class JobRequiReviewDashboardFilterItem
    {
        public Guid SupplierID { get; set; }
        public Guid ProductID { get; set; }
        public string Text { get; set; }

        public JobRequiReviewDashboardFilterItem()
        {
            SupplierID = Guid.Empty;
            ProductID = Guid.Empty;
            Text = "";
        }
    }
}