prs/prs.desktop/Panels/Requisitions/RequisitionPanel.xaml.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using Comal.Classes;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using InABox.Wpf;
using Motorola.Snapi;
using Motorola.Snapi.Constants.Enums;
using Motorola.Snapi.EventArguments;

//using RestSharp;

namespace PRSDesktop;

public class RequisitionPanelSettings : IUserConfigurationSettings
{
    public ScreenViewType ViewType { get; set; } = ScreenViewType.Combined;

    public double RequisitionsWidth { get; set; } = 450;

    public double DetailsWidth { get; set; } = 450;
}

/// <summary>
///     Interaction logic for RequisitionPanel.xaml
/// </summary>
public partial class RequisitionPanel : UserControl, IPanel<Requisition>
{
    private Requisition? _requisition;
    private RequisitionPanelSettings Settings;

    public List<IMotorolaBarcodeScanner> Scanners = new();

    public RequisitionPanel()
    {
        InitializeComponent();
        PickImage.Source = PRSDesktop.Resources.tick.AsBitmapImage(Color.White);
        StockImage.Source = PRSDesktop.Resources.forklift.AsBitmapImage(Color.White);
        TruckImage.Source = PRSDesktop.Resources.truck.AsBitmapImage();
    }

    //DateTime lastselection = DateTime.MaxValue;
    //DispatcherTimer timer = new DispatcherTimer();

    public event DataModelUpdateEvent? OnUpdateDataModel;

    public bool IsReady { get; set; }

    public Dictionary<string, object[]> Selected()
    {
        return new Dictionary<string, object[]>
        {
            { typeof(Requisition).EntityName(), Requisitions.SelectedRows },
            { typeof(RequisitionItem).EntityName(), Items.SelectedRows }
        };
    }

    public void Setup()
    {
        //Requisitions.OnSelectItem += Requisitions_OnSelectItem;

        //Requisitions.OnRequisitionFillStateChanged += Requisitions_OnRequisitionFillStateChanged;
        //Requisitions.OnRequisitionBoxesChanged += Requisitions_OnRequisitionBoxesChanged;

        LoadSettings();

        SetupScanner();

        Items.Reconfigure(options =>
        {
            if (_requisition != null)
            {
                if (_requisition.Filled.IsEmpty())
                {
                    options.AddRows = true;
                    options.DeleteRows = true;
                }
                else
                {
                    options.AddRows = false;
                    options.DeleteRows = false;
                }
            }
        });

        Requisitions.Refresh(true, false);
        Items.Refresh(true, false);

        UpdateLayout();
    }

    private void LoadSettings()
    {
        Settings = new UserConfiguration<RequisitionPanelSettings>().Load();
        MainPanel.View = Settings.ViewType == ScreenViewType.Register ? DynamicSplitPanelView.Master :
            Settings.ViewType == ScreenViewType.Details ? DynamicSplitPanelView.Detail : DynamicSplitPanelView.Combined;
        MainPanel.AnchorWidth = Settings.RequisitionsWidth;

        DetailsPanel.AnchorWidth = Settings.DetailsWidth;
    }
    private void SaveSettings()
    {
        Settings.ViewType = MainPanel.View switch
        {
            DynamicSplitPanelView.Master => ScreenViewType.Register,
            DynamicSplitPanelView.Detail => ScreenViewType.Details,
            DynamicSplitPanelView.Combined or _ => ScreenViewType.Combined
        };
        Settings.RequisitionsWidth = MainPanel.AnchorWidth;
        Settings.DetailsWidth = DetailsPanel.AnchorWidth;
        new UserConfiguration<RequisitionPanelSettings>().Save(Settings);
    }

    private void MainPanel_OnChanged(object sender, DynamicSplitPanelSettings e)
    {
        SaveSettings();
    }

    public void Shutdown(CancelEventArgs? cancel)
    {
        ShutdownScanner();
    }

    public void CreateToolbarButtons(IPanelHost host)
    {
        if (Security.CanView<RequisitionDestination>())
        {
            host.CreateSetupAction(new PanelAction
            {
                Caption = "Requisition Destinations",
                Image = PRSDesktop.Resources.truck,
                OnExecute = (action) =>
                {
                    var list = new MasterList(typeof(RequisitionDestination));
                    list.ShowDialog();
                }
            });
        }
        //host.CreatePanelAction(new PanelAction() { Caption = "Archive Requisition", Image = InABox.Wpf.Resources.delete, OnExecute = ArchiveRequisition });
    }

    public string SectionName => "Requisitions";
    public DataModel DataModel(Selection selection)
    {
        var ids = Requisitions.ExtractValues(x => x.ID, selection).ToArray();
        return new BaseDataModel<Requisition>(new Filter<Requisition>(x => x.ID).InList(ids));
    }

    public void Refresh()
    {
        Requisitions.Refresh(false, true);
        //lastselection = DateTime.MinValue;
        //Items.Refresh(true, false);
    }

    public void Heartbeat(TimeSpan time)
    {
        // Nothing to do here
    }

    private void ShutdownScanner()
    {
        try
        {
            foreach (var scanner in Scanners) scanner.Actions.ToggleLed(LedMode.GreenOff);
            BarcodeScannerManager.Instance.DataReceived -= Instance_DataReceived;

            BarcodeScannerManager.Instance.Close();
        }
        catch (Exception e)
        {
            MessageBox.Show("Error Shutting down Scanner!\n\n" + e.Message);
        }
    }

    private void SetupScanner()
    {
        Scanners.Clear();
        BarcodeScannerManager.Instance.Open();

        BarcodeScannerManager.Instance.RegisterForEvents(EventType.Barcode, EventType.Pnp, EventType.Image, EventType.Other, EventType.Rmd);

        BarcodeScannerManager.Instance.GetDevices();
        foreach (var scanner in BarcodeScannerManager.Instance.GetDevices())
        {
            Scanners.Add(scanner);
            scanner.Actions.ToggleLed(LedMode.RedOn);
            scanner.Actions.SoundBeeper(BeepPattern.FastWarble);
        }

        BarcodeScannerManager.Instance.DataReceived += Instance_DataReceived;
    }

    private void Instance_DataReceived(object? sender, BarcodeScanEventArgs e)
    {
        Dispatcher.Invoke(() => { ProcessCode(Scanners[(int)e.ScannerId], e.Data); });
    }

    private void ProcessCode(IMotorolaBarcodeScanner scanner, string code)
    {
        try
        {
            var iRow = Requisitions.SelectedRows.First().Index;
            if (iRow == -1)
                throw new Exception("Please select a Requsition First");

            var row = Requisitions.Data.Rows[iRow];
            var filled = row.Get<Requisition, DateTime>(x => x.Filled);

            if (!filled.IsEmpty())
                throw new Exception("Cannot Add Items to a completed Requisition");

            var reqid = row.Get<Requisition, Guid>(x => x.ID);

            var boxes = row.Get<Requisition, int>(x => x.Boxes);

            var sCode = code;
            var iQty = 1;
            if (sCode.Contains('*'))
            {
                var comps = sCode.Split('*');
                sCode = comps[0];
                iQty = int.Parse(comps[1].Trim());
            }

            RequisitionItem? item = null;
            CoreRow? itemrow = null;
            try
            {
                itemrow = Items.Data.Rows.FirstOrDefault(r => /* r.Get<RequisitionItem, int>(x => x.BoxNumber).Equals(boxes) && */
                    r.Get<RequisitionItem, string>(x => x.BarCode).Equals(sCode));
                //itemrow = Items.Data.Rows.FirstOrDefault(r => r.Get<RequisitionItem, String>(x => x.BarCode).Equals(sCode));
            }
            catch (Exception e)
            {
                Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
            }

            if (itemrow != null)
                item = new Client<RequisitionItem>()
                    .Load(new Filter<RequisitionItem>(x => x.ID).IsEqualTo(itemrow.Get<RequisitionItem, Guid>(x => x.ID))).FirstOrDefault();
            if (item != null)
            {
                item.Quantity += iQty;
                new Client<RequisitionItem>().Save(item, "Quantity Updated by Barcode Scanner");
                scanner?.Actions.SoundBeeper(BeepPattern.LowHigh);
                Refresh();
            }
            else
            {
                var product = new Client<Product>().Load(new Filter<Product>(x => x.Code).IsEqualTo(sCode)).FirstOrDefault();
                if (product != null)
                {
                    item = new RequisitionItem
                    {
                        RequisitionLink = new RequisitionLink { ID = reqid },
                        //BoxNumber = boxes,
                        Code = product.Code,
                        Description = product.Name,
                        BarCode = sCode,
                        Quantity = iQty
                    };
                    new Client<RequisitionItem>().Save(item, "Scanned by Barcode Reader");

                    scanner?.Actions.SoundBeeper(BeepPattern.LowHigh);

                    Refresh();
                }
                else
                {
                    scanner?.Actions.SoundBeeper(BeepPattern.FourLowLong);
                }
            }
        }
        catch (Exception)
        {
            scanner?.Actions.SoundBeeper(BeepPattern.FourLowShort);
        }
    }

    /*private void ArchiveRequisition(PanelAction obj)
    {
        var bClosed = false;
        var iRow = Requisitions.SelectedRows.First().Index;
        if (iRow > -1)
        {
            var row = Requisitions.Data.Rows[iRow];
            var id = row.Get<Requisition, Guid>(x => x.ID);
            var filled = row.Get<Requisition, DateTime>(x => x.Filled);
            if (filled.IsEmpty())
            {
                MessageBox.Show("Please complete this requisition before Archiving it!");
            }
            else
            {
                var req = new Client<Requisition>().Load(new Filter<Requisition>(x => x.ID).IsEqualTo(id)).FirstOrDefault();
                if (req != null)
                {
                    req.Archived = DateTime.Now;
                    new Client<Requisition>().Save(req, "Requisition Archived");
                    bClosed = true;
                }
            }
        }
        else
        {
            MessageBox.Show("Please select a requisition first!");
        }

        if (bClosed)
            Refresh();
    }*/

    private void LoadRequisition()
    {
        foreach (var scanner in Scanners)
            scanner.Actions.ToggleLed(_requisition != null ? LedMode.GreenOn : LedMode.RedOn);


        Title.Text = _requisition != null ? _requisition.Title : "";

        RequestedBy.Content = _requisition != null ? _requisition.RequestedBy.Name : "";

        DueDate.Content = _requisition != null ? string.Format("{0:dddd, dd MMM yyyy}", _requisition.Due) : "";
        
        Destination.Content = _requisition != null ? _requisition.Destination.Description : "";

        var notes = _requisition != null ? _requisition.Notes : Array.Empty<string>();
        var request = _requisition != null ? CoreUtils.StripHTML(_requisition.Request) : "";
        Request.Text = string.Join("\n===============================\n", Utility.ProcessNotes(notes, request));

        MarkAsFilled.IsEnabled = _requisition != null && _requisition.Archived.IsEmpty() && _requisition.StockUpdated.IsEmpty();
        MarkAsFilledDescription.Content = _requisition == null || _requisition.Filled.IsEmpty() ? "Mark As Filled" : "Clear Filled Flag";

        UpdateStock.IsEnabled = Security.IsAllowed<CanUpdateRequisitionStockMovements>() && _requisition != null &&
                                !_requisition.Filled.IsEmpty();
        UpdateStockDescription.Content =
            _requisition == null || _requisition.StockUpdated.IsEmpty() ? "Update Stock Holdings" : "Clear Stock Movements";

        TakenBy.IsEnabled = _requisition != null && !_requisition.Filled.IsEmpty() && _requisition.Archived.IsEmpty() &&
                            !_requisition.Delivery.IsValid();

        TakenByDescription.Content = _requisition == null
            ? "Select Employee"
            : _requisition.Delivery.IsValid()
                ? _requisition.Delivery.Completed.IsEmpty()
                    ? string.Format("Booked On Delivery #{0}", _requisition.Delivery.Number)
                    : string.Format("Delivered on {0:dd MMM yy} (#{1})", _requisition.Delivery.Completed, _requisition.Delivery.Number)
                : _requisition.TakenBy.IsValid()
                    ? string.Format("{0} ({1:dd MMM yy})", _requisition.TakenBy.Name, _requisition.Archived)
                    : "Select Employee";
    }

    private void Requisitions_OnSelectItem(object sender, DynamicGridSelectionEventArgs e)
    {
        _requisition = e.Rows?.FirstOrDefault()?.ToObject<Requisition>();
        LoadRequisition();
        Items.Requisition = _requisition;
        Items.Refresh(false, true);
        //lastselection = DateTime.Now;
        //Dispatcher.Invoke(() => { LoadRequisition(); });
    }

    private void TakenBy_Click(object sender, RoutedEventArgs e)
    {
        if (_requisition == null || _requisition.ID == Guid.Empty)
            return;

        var dlg = new MultiSelectDialog<Employee>(
            LookupFactory.DefineFilter<Employee>(),
            LookupFactory.DefineColumns<Employee>(),
            false);

        if (!dlg.ShowDialog())
            return;

        if (!_requisition.Filled.IsEmpty() && !_requisition.StockUpdated.IsEmpty())
            if (!MessageWindow.ShowYesNo(
                "This will remove this requisition from this list.\nAre you sure you wish to continue?",
                "Close Requisition?",
                image: MessageWindow.QuestionImage))
                return;

        if (_requisition.Archived.IsEmpty())
            _requisition.Archived = DateTime.Now;

        var emp = dlg.Data()?.Rows.FirstOrDefault();
        _requisition.TakenBy.ID = emp != null ? emp.Get<Employee, Guid>(x => x.ID) : Guid.Empty;
        _requisition.TakenBy.Name = emp != null ? emp.Get<Employee, string>(x => x.Name) : "";

        Progress.Show("Updating Requisition Delivery Status");
        new Client<Requisition>().Save(_requisition, "Updated [TakenBy] Flag");
        if (!_requisition.Filled.IsEmpty() && !_requisition.StockUpdated.IsEmpty() && !_requisition.Archived.IsEmpty())
        {
            Refresh();
        }
        else
        {
            Requisitions.UpdateRow<Requisition, Guid>(Requisitions.SelectedRows.First(), x => x.TakenBy.ID, _requisition.TakenBy.ID, false);
            Requisitions.UpdateRow<Requisition, string>(Requisitions.SelectedRows.First(), x => x.TakenBy.Name, _requisition.TakenBy.Name, false);
            Requisitions.UpdateRow<Requisition, DateTime>(Requisitions.SelectedRows.First(), x => x.Archived, _requisition.Archived);
            LoadRequisition();
        }

        Progress.Close();
    }

    private void MarkAsFilled_Click(object sender, RoutedEventArgs e)
    {
        var _row = Requisitions.SelectedRows.FirstOrDefault();
        if (_row == null)
        {
            MessageWindow.ShowMessage("Please select a Picking List first!", "Select Picking List");
            return;
        }

        var _currentrequi = _row.ToObject<Requisition>();
        if (!_currentrequi.Filled.IsEmpty())
        {
            Progress.ShowModal("Updating Picking List Items", (p) =>
            {
                _currentrequi.Filled = DateTime.MinValue;
                Client.Save(_currentrequi, "Filled flag cleared");

            });
            Requisitions.UpdateRow<Requisition, DateTime>(Requisitions.SelectedRows.First(), x => x.Filled,
                DateTime.MinValue);
            _requisition.Filled = DateTime.MinValue;
            LoadRequisition();
            Items.Refresh(false, true);
            return;
        }

        DateTime _filltime = DateTime.Now;

        var _confirm = MessageWindowResult.Yes;
        var _unpickeditems = Items.Data.Rows.Where(r =>
            (r.Get<RequisitionItem, Guid>(x => x.Product.ID) != Guid.Empty)
            && (r.Get<RequisitionItem, bool>(x => x.Product.NonStock) != true)
            && (!r.Get<RequisitionItem, bool>(x => x.Done))
        ).ToArray();
        if (_unpickeditems.Any())
        {
            _confirm = new MessageWindow()
                .Message(
                    "There are items on this Picking List which are not done!\n\nDo you want to mark them as done, or move them to a New Picking List ?")
                .Title("Unpicked Items found")
                .AddYesButton("Mark as Done")
                .AddNoButton("New Picking List")
                .AddCancelButton()
                .Display()
                .Result;

            if (_confirm == MessageWindowResult.Cancel)
                return;
        }

        Progress.ShowModal("Updating Picking List Items", (p) =>
        {
            
            if (_confirm == MessageWindowResult.No)
            {
                Requisitions.SplitPickingList(_row, true, (_) => true, p);
                _currentrequi.Filled = _filltime;
                p.Report("Creating Delivery Items");
                Client.Save(_currentrequi,"Marked as Filled");
            }
            else if (_confirm == MessageWindowResult.Yes)
            {
                var updates = new List<RequisitionItem>();
                foreach (var row in _unpickeditems)
                {
                    var item = row.ToObject<RequisitionItem>();
                    item.Done = true;
                    updates.Add(item);
                }
                Client.Save(updates, "Marked as Done because Requisition was marked as filled");
                
                _currentrequi.Filled = _filltime;
                p.Report("Creating Delivery Items");
                Client.Save(_currentrequi,"Marked as Filled");
            }


        });
        Requisitions.UpdateRow<Requisition, DateTime>(Requisitions.SelectedRows.First(), x => x.Filled, _filltime);
        _requisition.Filled = _filltime;
        LoadRequisition();
        Items.Refresh(false, true);
    }

    private void UpdateStock_Click(object sender, RoutedEventArgs e)
    {
        if (_requisition == null)
        {
            MessageWindow.ShowMessage("Please select a Requisition first!", "Select Requisition");
            return;
        }

        if (_requisition.StockUpdated.IsEmpty())
        {
            var emptyrows = Items.Data.Rows.Where(r =>
                !r.Get<RequisitionItem,double>(x=>x.ActualQuantity).IsEffectivelyEqual(0.0)
                && !Entity.IsEntityLinkValid<RequisitionItem, StockLocationLink>(x => x.Location, r) 
                && r.Get<RequisitionItem, bool>(c => c.Product.NonStock).Equals(false));
            if (emptyrows.Any())
            {
                MessageWindow.ShowMessage(
                    "You must select a Holding for each non-stock Item on this Requisition!",
                    "Missing Holdings",
                    image: MessageWindow.WarningImage);
                return;
            }
            
            if (!MessageWindow.ShowYesNo("Update Stock Movements?", "Confirm"))
                return;
            

            _requisition.StockUpdated = DateTime.Now;
        }
        else
        {
            if (!MessageWindow.ShowYesNo("Clear Stock Movements?", "Confirm"))
                return;
            _requisition.StockUpdated = DateTime.MinValue;
        }

        Progress.Show("Updating Stock Holdings");
        Client.Save(_requisition, "Updated Stock Flag");
        if (!_requisition.Filled.IsEmpty() && !_requisition.StockUpdated.IsEmpty() && !_requisition.Archived.IsEmpty())
        {
            Refresh();
        }
        else
        {
            Requisitions.UpdateRow<Requisition, DateTime>(Requisitions.SelectedRows.First(), x => x.StockUpdated, _requisition.StockUpdated);
            LoadRequisition();
        }

        Progress.Close();
    }
}