prs/prs.desktop/Panels/Factory/FactoryPanel.xaml.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using Comal.Classes;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.Core.Reports;
using InABox.Wpf.Reports;
using InABox.WPF;
using Motorola.Snapi;
using Motorola.Snapi.Constants.Enums;
using Motorola.Snapi.EventArguments;
using BarcodeType = Comal.Classes.BarcodeType;
using Color = System.Drawing.Color;
using Image = System.Windows.Controls.Image;
using InABox.Wpf;
using System.ComponentModel;

namespace PRSDesktop
{
    /// <summary>
    ///     Interaction logic for FactoryPanel.xaml
    /// </summary>
    public partial class FactoryPanel : IPanel<ManufacturingPacket>
    {

        private readonly BitmapImage barcode = PRSDesktop.Resources.barcode.AsBitmapImage();
        private readonly BitmapImage disabled = PRSDesktop.Resources.disabled.AsBitmapImage();
        private readonly BitmapImage speechbubble = PRSDesktop.Resources.speechbubble.AsBitmapImage();
        private readonly BitmapImage starred = PRSDesktop.Resources.report.AsBitmapImage(48, 48);
        private readonly BitmapImage grouped = PRSDesktop.Resources.grouped.AsBitmapImage();
        
        private SetoutDocument[] documents = Array.Empty<SetoutDocument>();
        private readonly List<IMotorolaBarcodeScanner> _scanners = new List<IMotorolaBarcodeScanner>();

        private readonly string NEARLYDUE_COLOR = "Orange";
        private readonly string NOTYETDUE_COLOR = "PaleGreen";
        private readonly string OVERDUE_COLOR = "Salmon";
        private readonly string PRIORITY_COLOR = "Red";
        private readonly string QA_COLOR = "Silver";
        private readonly string SELECTED_COLOR = "Yellow";
        private readonly string SHARED_COLOR = "Lime";
        private readonly string TREATED_COLOR = "DarkOrchid";

        private Button? _currentButton;
        private PDFEditorControl? PDFEditor;
        private QAGrid? QAGrid;
        
        private readonly FactoryFloorLocalSettings _settings;

        private readonly PanelAction _togglePackPanel;
        
        public FactoryPanel()
        {
            
            _settings = new LocalConfiguration<FactoryFloorLocalSettings>().Load();
            if (_settings.Section.Equals(CoreUtils.FullGuid) && _settings.Station.Equals(-1))
            {
                var user = new UserConfiguration<FactoryFloorSettings>().Load();
                _settings.Section = user.Section;
                _settings.Station = user.Station;
                new LocalConfiguration<FactoryFloorLocalSettings>().Save(_settings);
            }
            
            InitializeComponent();

            var CanConfigure = Security.IsAllowed<CanConfigureFactoryFloor>();
            Section.IsEnabled = CanConfigure;
            Station.IsEnabled = CanConfigure;

            PendingVisible = Security.IsAllowed<CanManagePendingPackets>();

            Kanbans = new ObservableCollection<ManufacturingKanban>();
            RackContents.ItemsSource = rackcontents;

            RackPanel.Visibility = _settings.SidePanel == FactorySidePanel.Racks
                ? Visibility.Visible
                : Visibility.Collapsed;
            
            PackPanel.Visibility = _settings.SidePanel == FactorySidePanel.Packs
                ? Visibility.Visible
                : Visibility.Collapsed;
            

        }

        public bool IsReady { get; set; }

        public void Setup()
        {

            var setups = new MultiQuery();
            
            setups.Add<ManufacturingFactory>();
            
            setups.Add(
                new Filter<ManufacturingSection>(x => x.Hidden).IsEqualTo(false),
                null,
                new SortOrder<ManufacturingSection>(x => x.Factory.Sequence).ThenBy(x => x.Sequence)
            );

            setups.Add<ManufacturingTrolley>();
            
            setups.Add(
                LookupFactory.DefineFilter<Employee>(),
                new Columns<Employee>(x => x.ID, x => x.Name, x => x.UserLink.ID),
                new SortOrder<Employee>(x => x.Name)
            );
            
            setups.Add(
                LookupFactory.DefineFilter<Shipment>(),
                new Columns<Shipment>(x => x.ID, x => x.Code, x => x.Description, x => x.BarCode)
                );
            
            if (_settings.AreaID != Guid.Empty)
                setups.Add(
                    new Filter<StockArea>(x=>x.ID).IsEqualTo(_settings.AreaID),
                    new Columns<StockArea>(x=>x.ID).Add(x=>x.Code).Add(x=>x.Description)
                );
            
            setups.Query();

            Factories = setups.Get<ManufacturingFactory>().Rows.Select(x => x.ToObject<ManufacturingFactory>()).ToArray();
            Sections = setups.Get<ManufacturingSection>().Rows.Select(x => x.ToObject<ManufacturingSection>()).ToArray();
            Trolleys = setups.Get<ManufacturingTrolley>().Rows.Select(x => x.ToObject<ManufacturingTrolley>()).ToArray();

            Shipments = setups.Get<Shipment>();

            CurrentSection = Sections.FirstOrDefault(x => x.ID.Equals(_settings.Section))
                ?? Sections.FirstOrDefault();
            var iSection = 0;
            var iCount = 0;
            foreach (var section in Sections)
            {
                if (section == CurrentSection)
                {
                    iSection = Section.Items.Count;
                    iCount = section.Stations; //Sections[id].Item2;
                }

                Section.Items.Add($"{section.Factory.Name}: {section.Name}");
            }

            Section.SelectedIndex = iSection;

            Station.Items.Clear();
            for (var i = 1; i <= (CurrentSection?.Stations ?? 0); i++)
                Station.Items.Add($"Station #{i}");

            CurrentStation = _settings.Station + 1;

            if (CurrentStation < 1)
                CurrentStation = 1;

            if (CurrentStation > iCount)
                CurrentStation = iCount;

            Station.SelectedIndex = CurrentStation - 1;

            if (_settings.AreaID != Guid.Empty)
            {
                var area = setups.Get<StockArea>().ToObjects<StockArea>().FirstOrDefault();
                if (area != null)
                {
                    _packGrid.Area = area;
                    _areaDescription.Text = $"{area.Code}";
                    _addPack.IsEnabled = true;
                }
                else
                {
                    _packGrid.Area = null;
                    _areaDescription.Text = "Set\r\nArea";
                    _settings.AreaID = Guid.Empty;
                    new LocalConfiguration<FactoryFloorLocalSettings>().Save(_settings);
                    _addPack.IsEnabled = false;
                }
            }
            else
            {
                _packGrid.Area = null;
                _areaDescription.Text = "Set\r\nArea";
            }

            _packGrid.Refresh(true,true);

            SetupScanner();
        }

        public void Shutdown(CancelEventArgs? cancel)
        {
            ShutdownScanner();
            //UpdateTimeTracking(true);
            LoadDrawing(null);
        }


        public void CreateToolbarButtons(IPanelHost host)
        {
            ManufacturingSetupActions.Standard(host);

            //if (Security.IsAllowed<CanViewManufacturingSelfAssessment>())
            //    host.CreatePanelAction(new PanelAction() { Caption = "Self Assessment", Image = PRSDesktop.Resources.star, OnExecute = DoSelfAssessment });

            host.CreatePanelAction(new PanelAction { Caption = "Lost Time", Image = PRSDesktop.Resources.smiley, OnExecute = DoSelectLostTime });

            host.CreatePanelAction(new PanelAction
            { Caption = "Treament PO", Image = PRSDesktop.Resources.purchase, OnExecute = DoCreatePurchaseOrder });
            host.CreatePanelAction(new PanelAction
            { Caption = "Treatment Delivery", Image = PRSDesktop.Resources.barcode, OnExecute = DoScanDeliveryItems });

            host.CreatePanelAction(new PanelAction { Caption = "Select Rack", Image = PRSDesktop.Resources.forklift, OnExecute = DoSelectRack });
            host.CreatePanelAction(new PanelAction { Caption = "Close Rack", Image = PRSDesktop.Resources.forklift, OnExecute = DoCloseRack });
            host.CreatePanelAction(new PanelAction { Caption = "Scan Barcode", Image = PRSDesktop.Resources.product, OnExecute = DoScanBarcode });
            
            host.CreatePanelAction(new PanelAction { Caption = _settings.SidePanel == FactorySidePanel.Packs ? "Hide Stock" : "Show Stock", Image = PRSDesktop.Resources.trolley, OnExecute = TogglePackPanel});
        }

        private void TogglePackPanel(PanelAction pa)
        {
            RackPanel.Visibility = Visibility.Collapsed;
            PackPanel.Visibility = _settings.SidePanel == FactorySidePanel.Packs
                ? Visibility.Collapsed
                : Visibility.Visible;
            _settings.SidePanel = PackPanel.Visibility == Visibility.Visible
                ? FactorySidePanel.Packs
                : FactorySidePanel.None;
            new LocalConfiguration<FactoryFloorLocalSettings>().Save(_settings);
            pa.Caption = _settings.SidePanel == FactorySidePanel.Packs
                ? "Hide Stock"
                : "Show Stock";
            _addPack.IsEnabled = _settings.AreaID != Guid.Empty;
        }

        public Dictionary<string, object[]> Selected()
        {
            var rows = Packets.Rows.Where(p => Kanbans.Any(k => k.Checked && p.Get<ManufacturingPacket, Guid>(c => c.ID).ToString().Equals(k.ID)));
            var pkts = rows.ToArray().Select(r => r.ToObject<ManufacturingPacket>());
            return new Dictionary<string, object[]> { { typeof(ManufacturingPacket).EntityName(), pkts.ToArray() } };
        }

        public string SectionName => "Factory";

        public DataModel DataModel(Selection selection)
        {
            var rows = (Packets == null) || (selection == Selection.None)
                ? new CoreRow[] { }
                : selection == Selection.Selected
                    ? Packets.Rows.Where(p => Kanbans.Any(k => k.Checked && p.Get<ManufacturingPacket, Guid>(c => c.ID).ToString().Equals(k.ID)))
                    : Packets.Rows;
            var ids = rows.Any() ? rows.Select(r => r.Get<ManufacturingPacket, Guid>(x => x.ID)).ToArray() : new[] { CoreUtils.FullGuid };
            return new ManufacturingPacketDataModel(new Filter<ManufacturingPacket>(x => x.ID).InList(ids));
        }

        public event DataModelUpdateEvent? OnUpdateDataModel;

        public void Heartbeat(TimeSpan time)
        {
            // Security Descriptor should be disabled for non-manufacturing staff
            if (!Security.IsAllowed<CanTrackManufacturingHistory>() || CurrentSection == null)
                return;

            // If Lost Time is Active, let's record that
            if (LostTime != null)
            {
                var history = new ManufacturingHistory();
                history.Date = DateTime.Today;
                history.Employee.ID = App.EmployeeID;
                history.Packet.ID = Guid.Empty;
                history.LostTime.ID = LostTime.ID;
                history.Description = LostTime.Description;
                //history.Setout.ID = CheckedPackets[id].Item3;
                //history.Job.ID = CheckedPackets[id].Item4;
                history.Section.ID = CurrentSection.ID;
                history.Station = CurrentStation;
                history.Activity.ID = LostTime.Activity.ID;
                history.WorkDuration = new TimeSpan(time.Ticks);
                history.QACompleted = 0;
                history.WorkCompleted = 0;
                history.Window = time;
                new Client<ManufacturingHistory>().Save(history, "", (o, e) => { });
            }
            else
            {
                var CheckedPackets = new Dictionary<Guid, Tuple<DateTime, DateTime, Guid, Guid, string>>();

                foreach (var kanban in Kanbans.Where(x => x.Checked))
                {
                    var packet = KanbanToPacket(kanban);
                    if (packet != null)
                    {
                        var stagerow = Stages.Rows.FirstOrDefault(r => r.Get<ManufacturingPacketStage, Guid>(c => c.Parent.ID).Equals(packet.ID)
                                                                       && r.Get<ManufacturingPacketStage, Guid>(c => c.ManufacturingSectionLink.ID)
                                                                           .Equals(_settings.Section));
                        if (stagerow != null)
                        {
                            var stage = stagerow.ToObject<ManufacturingPacketStage>();
                            if (stage.Station != 0)
                                CheckedPackets[packet.ID] = new Tuple<DateTime, DateTime, Guid, Guid, string>(stage.Started, stage.Completed,
                                    packet.SetoutLink.ID, packet.SetoutLink.JobLink.ID, packet.Serial);
                        }
                    }
                }

                if (!CheckedPackets.Any())
                    CheckedPackets[Guid.Empty] =
                        new Tuple<DateTime, DateTime, Guid, Guid, string>(DateTime.MinValue, DateTime.MinValue, Guid.Empty, Guid.Empty, "No Packet");

                var updates = new List<ManufacturingHistory>();

                var slice = time.Ticks / CheckedPackets.Count;
                foreach (var id in CheckedPackets.Keys)
                {
                    var history = new ManufacturingHistory();
                    history.Date = DateTime.Today;
                    history.Employee.ID = App.EmployeeID;
                    history.Packet.ID = id;
                    history.Description = CheckedPackets[id].Item5;
                    //history.Setout.ID = CheckedPackets[id].Item3;
                    //history.Job.ID = CheckedPackets[id].Item4;
                    history.Section.ID = CurrentSection.ID;
                    history.Activity.ID = CurrentSection.Activity.ID;
                    history.Station = CurrentStation;
                    if (CheckedPackets[id].Item1.Equals(DateTime.MinValue))
                        history.QADuration = new TimeSpan(slice);
                    else
                        history.WorkDuration = new TimeSpan(slice);
                    history.QACompleted = CheckedPackets[id].Item1.Equals(DateTime.MinValue) ? 0 : 0;
                    history.WorkCompleted = CheckedPackets[id].Item2.Equals(DateTime.MinValue) ? 0 : 1;
                    history.Window = time;

                    updates.Add(history);
                }

                if (updates.Any())
                    new Client<ManufacturingHistory>().Save(updates, "", (o, e) => { });
            }
        }

        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 isGuid = Guid.TryParse(code, out var guid);
                if (isGuid)
                {
                    if (Sections.Any(x => x.ID.Equals(guid)))
                    {
                        IsReady = false;
                        CurrentSection = Sections.First(x => x.ID.Equals(guid));
                        Section.SelectedIndex = Array.IndexOf(Sections, CurrentSection);
                        IsReady = true;
                        Progress.Show("Changing Sections");
                        DoRefresh(true);
                        Progress.Close();

                        scanner?.Actions.SoundBeeper(BeepPattern.FastWarble);
                    }
                    else if (Trolleys.Any(x => x.ID.Equals(guid)))
                    {
                        var trolley = Trolleys.First().Code;
                        var updates = new List<ManufacturingPacket>();
                        foreach (var kanban in Kanbans.Where(x => x.Checked))
                        {
                            var packet = KanbanToPacket(kanban);
                            packet.Trolleys = trolley;
                            updates.Add(packet);

                            var pktrow = Packets.Rows.FirstOrDefault(r => r.Get<ManufacturingPacket, Guid>(c => c.ID).Equals(Guid.Parse(kanban.ID)));
                            var stagerow = Stages.Rows.FirstOrDefault(r => r.Get<ManufacturingPacketStage, Guid>(c => c.Parent.ID).Equals(packet.ID)
                                                                           && r.Get<ManufacturingPacketStage, Guid>(
                                                                                   c => c.ManufacturingSectionLink.ID)
                                                                               .Equals(_settings.Section));
                            pktrow.Set<ManufacturingPacket, string>(x => x.Trolleys, packet.Trolleys);

                            LoadModel(kanban, pktrow, stagerow, true);
                            UpdateSelectedKanban(false);
                        }

                        if (updates.Any())
                            new Client<ManufacturingPacket>().Save(updates, "Set Trolley to " + trolley, (o, e) => { });

                        scanner?.Actions.SoundBeeper(BeepPattern.LowHigh);
                    }
                    else
                    {
                        scanner?.Actions.SoundBeeper(BeepPattern.FourLowShort);
                    }
                }
                else
                {
                    var shiprow = Shipments.Rows.FirstOrDefault(r => r.Get<Shipment, string>(c => c.BarCode).Equals(code));
                    if (shiprow != null)
                    {
                        if (string.Equals(code, rackbarcode))
                        {
                            RackPanel.Visibility = Visibility.Collapsed;
                            _settings.SidePanel = FactorySidePanel.None;
                            new LocalConfiguration<FactoryFloorLocalSettings>().Save(_settings);
                            
                            RackContents.ItemsSource = null;
                            rackid = Guid.Empty;
                            rackbarcode = "";
                            scanner?.Actions.SoundBeeper(BeepPattern.ThreeLowShort);
                        }
                        else
                        {
                            RackContents.ItemsSource = null;

                            rackid = shiprow.Get<Shipment, Guid>(c => c.ID);
                            rackbarcode = code;
                            var rows = DeliveryItems.Rows.Where(r => r.Get<DeliveryItem, Guid>(c => c.ShipmentLink.ID).Equals(rackid)).ToArray();
                            rackcontents.Clear();
                            rackcontents.AddRange(rows.Select(x => x.ToObject<DeliveryItem>()));

                            RackContents.ItemsSource = rackcontents;
                            RackName.Content = $"Rack {shiprow.Get<Shipment, string>(c => c.Code)}";
                            RackCount.Content = rows.Length.ToString();

                            PackPanel.Visibility = Visibility.Collapsed;
                            RackPanel.Visibility = Visibility.Visible;
                            _settings.SidePanel = FactorySidePanel.Racks;
                            new LocalConfiguration<FactoryFloorLocalSettings>().Save(_settings);
                            scanner?.Actions.SoundBeeper(BeepPattern.ThreeHighShort);
                        }
                    }
                    else
                    {
                        if (RackPanel.Visibility == Visibility.Visible)
                        {
                            var row = DeliveryItems.Rows.FirstOrDefault(r => r.Get<DeliveryItem, string>(c => c.Barcode).Equals(code));
                            if (row != null)
                            {
                                var delitem = rackcontents.FirstOrDefault(x => string.Equals(x.Barcode, code));
                                if (delitem != null)
                                {
                                    rackcontents.Remove(delitem);
                                    delitem.ShipmentLink.ID = Guid.Empty;
                                    new Client<DeliveryItem>().Save(delitem, "Item Removed From Rack", (o, e) => { });
                                    row.Set<DeliveryItem, Guid>(x => x.ShipmentLink.ID, Guid.Empty);
                                    scanner?.Actions.SoundBeeper(BeepPattern.HighLow);
                                }
                                else
                                {
                                    delitem = row.ToObject<DeliveryItem>();
                                    delitem.ShipmentLink.ID = rackid;
                                    rackcontents.Add(delitem);
                                    new Client<DeliveryItem>().Save(delitem, "Item Added to " + RackName.Content, (o, e) => { });
                                    row.Set<DeliveryItem, Guid>(x => x.ShipmentLink.ID, rackid);
                                    if (Kanbans.Any(x => string.Equals(x.ID, delitem.ManufacturingPacketLink.ID.ToString())))
                                        ReloadPackets(true);
                                    scanner?.Actions.SoundBeeper(BeepPattern.LowHigh);
                                }

                                RackContents.ItemsSource = null;
                                RackContents.ItemsSource = rackcontents;
                                RackCount.Content = rackcontents.Count.ToString();
                            }
                        }
                        else
                        {
                            var id = new Client<DeliveryItem>().Query(
                                new Filter<DeliveryItem>(x => x.Barcode).IsEqualTo(code),
                                new Columns<DeliveryItem>(x => x.ManufacturingPacketLink.ID)
                            ).Rows.FirstOrDefault()?.Get<DeliveryItem, Guid>(x => x.ManufacturingPacketLink.ID);

                            if (!id.HasValue)
                            {
                                scanner?.Actions.SoundBeeper(BeepPattern.FourLowShort);
                                return;
                            }

                            var kanban = Kanbans.FirstOrDefault(x => string.Equals(x.ID, id.Value.ToString()));
                            if (kanban == null)
                            {
                                // Error - packet not visible from this station
                                scanner?.Actions.SoundBeeper(BeepPattern.FourLowShort);
                                return;
                            }

                            var stage = Stages.Rows.FirstOrDefault(r => r.Get<ManufacturingPacketStage, Guid>(c => c.Parent.ID).Equals(id)
                                                                        && r.Get<ManufacturingPacketStage, Guid>(c => c.ManufacturingSectionLink.ID)
                                                                            .Equals(_settings.Section))?.ToObject<ManufacturingPacketStage>();

                            if (stage == null)
                                scanner?.Actions.SoundBeeper(BeepPattern.FourHighShort);

                            if (stage.Station == 0) AddPacketToCurrentWorkload(stage);

                            if (kanban != CurrentKanban)
                            {
                                CurrentKanban = kanban;
                                UpdateSelectedKanban(false);
                            }

                            scanner?.Actions.SoundBeeper(BeepPattern.LowHigh);
                        }
                    }
                }
            }
            catch (Exception)
            {
                scanner?.Actions.SoundBeeper(BeepPattern.FourLowShort);
            }
        }


        private void LoadDrawing(Guid? id)
        {
            if (PDFEditor != null)
            {
                PDFEditor.Document = null;
                // Unload PDF Annotations
                PDFEditor = null;
            }
            else if (QAGrid != null)
            {
                Editor.Content = null;
                // Unload QA Answers
                QAGrid = null;
            }

            if (id.HasValue)
            {
                var pktid = CurrentKanban != null ? Guid.Parse(CurrentKanban.ID) : Guid.Empty;

                var row = Packets.Rows.FirstOrDefault(r => r.Get<ManufacturingPacket, Guid>(c => c.ID).Equals(pktid));
                var stagerow = Stages.Rows.FirstOrDefault(r => r.Get<ManufacturingPacketStage, Guid>(c => c.Parent.ID).Equals(pktid)
                                                               && r.Get<ManufacturingPacketStage, Guid>(c => c.ManufacturingSectionLink.ID)
                                                                   .Equals(_settings.Section));
                var packet = row.ToObject<ManufacturingPacket>();

                if (id.Value == Guid.Empty)
                {
                    QAGrid = new QAGrid();


                    var qadata = stagerow != null ? stagerow.Get<ManufacturingPacketStage, string>(c => c.FormData) : "";

                    var values = string.IsNullOrWhiteSpace(qadata)
                        ? new Dictionary<Guid, object>()
                        : Serialization.Deserialize<Dictionary<Guid, object>>(qadata);

                    if (CurrentSection != null && row != null)
                    {
                        var genquestions = LoadQAQuestions(packet, true, false);
                        QAGrid.LoadChecks("Global Checks for " + CurrentSection.Name, genquestions, values);

                        //var specquestions = LoadQAQuestions(packet, false, true);
                        //QAGrid.LoadChecks(String.Format("Specific Checks for {0} [{1}] template", packet.ManufacturingTemplateLink.Name, packet.ManufacturingTemplateLink.Code), specquestions, values);
                    }


                    QAGrid.OnChanged += QAGridChanged;
                    Editor.Content = QAGrid;
                }
                else
                {
                    PDFEditor = new PDFEditorControl();
                    PDFEditor.LineColor = _settings.LineColor;
                    PDFEditor.TextSize = _settings.FontSize;
                    //PDFEditor.PrintAllowed = Security.IsAllowed<CanPrintFactoryFloorDrawings>();
                    PDFEditor.SaveAllowed = Security.IsAllowed<CanSaveFactoryFloorDrawings>();
                    var document = documents.FirstOrDefault(x => x.DocumentLink.ID.Equals(id));
                    PDFEditor.Watermark = packet.WaterMark;
                    PDFEditor.Document = document;

                    PDFEditor.PDFSettingsChanged += PDFEditorSettingsChanged;
                    Editor.Content = PDFEditor;
                }
            }
        }

        private void DoSelectRack(PanelAction obj)
        {
            var dlg = new MultiSelectDialog<Shipment>(
                null,
                new Columns<Shipment>(x => x.ID, x => x.Code, x => x.Description, x => x.BarCode),
                false
            );
            if (dlg.ShowDialog())
            {
                var id = dlg.IDs().FirstOrDefault();
                var barcode = dlg.Data().Rows.FirstOrDefault(r => r.Get<Shipment, Guid>(c => c.ID).Equals(id))?.Get<Shipment, string>(x => x.BarCode);
                ProcessCode(_scanners.FirstOrDefault(), barcode);
            }
        }

        private void DoCloseRack(PanelAction obj)
        {
            if (!string.IsNullOrWhiteSpace(rackbarcode))
                ProcessCode(_scanners.FirstOrDefault(), rackbarcode);
        }


        private void DoScanBarcode(PanelAction obj)
        {
            var dlg = new MultiSelectDialog<DeliveryItem>(
                new Filter<DeliveryItem>(x => x.DeliveredDate).IsEqualTo(DateTime.MinValue)
                    .And(x => x.ManufacturingPacketLink).LinkValid(),
                new Columns<DeliveryItem>(x => x.ID, x => x.Barcode, x => x.Description),
                false
            );
            if (dlg.ShowDialog())
            {
                var id = dlg.IDs().FirstOrDefault();
                var barcode = dlg.Data().Rows.FirstOrDefault(r => r.Get<DeliveryItem, Guid>(c => c.ID).Equals(id))
                    ?.Get<DeliveryItem, string>(x => x.Barcode);
                ProcessCode(_scanners.FirstOrDefault(), barcode);
            }
        }

        private void DoScanDeliveryItems(PanelAction obj)
        {
            new DeliveryBuilder(Guid.Empty, Guid.Empty).ShowDialog();
        }

        private void DoCreatePurchaseOrder(PanelAction obj)
        {
            //Guid section = CurrentSection != null ? CurrentSection.ID : CoreUtils.FullGuid;
            //var stages = Stages.Rows.Where(row => row.Get<ManufacturingPacketStage, Guid>(col => col.ManufacturingSectionLink.ID).Equals(section) && row.Get<ManufacturingPacketStage, int>(col => col.Station).Equals(CurrentStation));
            //var ids = stages.Select(row => row.Get<ManufacturingPacketStage, Guid>(col => col.ManufacturingPacketLink.ID)).ToArray();

            var ids = Kanbans.Where(x => !x.ColorKey.Equals(QA_COLOR)).Select(x => Guid.Parse(x.ID)).ToArray();

            var treatments = new Client<ManufacturingTreatment>().Query(new Filter<ManufacturingTreatment>(x => x.Packet.ID).InList(ids));
            var window = new ManufacturingTreatmentWindow(treatments);
            if (window.ShowDialog() != true)
                return;

            Progress.Show("Creating Purchase Order");
            var order = new PurchaseOrder();
            //Supplier supplier = new Client<Supplier>().Query(
            //    new Filter<Supplier>(x => x.ID).IsEqualTo(window.SupplierID),
            //    new Columns<Supplier>(x=>x.ID

            //).Rows.FirstOrDefault()?.ToObject<Supplier>());
            order.SupplierLink.ID = window.SupplierID;
            order.SupplierLink.Name = window.SupplierName; //supplier != null ? supplier.Name : "Unknown Supplier";
            order.Description = string.Format("Materials Processing Request raised by {0} from Factory Floor", App.EmployeeName);
            order.RaisedBy.ID = App.EmployeeID;
            order.IssuedBy.ID = App.EmployeeID;
            order.IssuedDate = DateTime.Today;
            order.DueDate = DateTime.Today.AddDays(7);
            new Client<PurchaseOrder>().Save(order, "Created Treatment Purchase Order");

            Progress.SetMessage("Processing Order");
            var orderitems = new List<PurchaseOrderItem>();
            var packetupdates = new List<ManufacturingPacket>();

            var query = new MultiQuery();
            query.Add(
                new Filter<SupplierProduct>(x => x.Product.ID).IsEqualTo(window.ProductID).And(x => x.SupplierLink.ID)
                    .IsEqualTo(window.SupplierID),
                new Columns<SupplierProduct>(x => x.Job.ID).Add(x => x.CostPrice).Add(x => x.Product.NettCost)
            );

            query.Add(
                new Filter<Product>(x => x.ID).IsEqualTo(window.ProductID),
                LookupFactory.DefineLookupColumns<PurchaseOrderItem, Product, ProductLink>(x => x.Product).Add(x => x.NettCost)
            );

            query.Query();
            var supprods = query.Get<SupplierProduct>().Rows.Select(x => x.ToObject<SupplierProduct>()).ToArray();
            var supprice = supprods.FirstOrDefault(x => Equals(x.Job.ID, Guid.Empty));
            var product = query.Get<Product>().Rows.FirstOrDefault()?.ToObject<Product>();

            var stdcost = supprice != null
                ? supprice.CostPrice
                : product != null
                    ? product.NettCost
                    : 0.0F;

            foreach (var row in window.Selected)
            {
                var treatment = row.ToObject<ManufacturingTreatment>();

                var packet = Packets.Rows.First(p => p.Get<ManufacturingPacket, Guid>(c => c.ID).Equals(treatment.Packet.ID))
                    .ToObject<ManufacturingPacket>();
                packetupdates.Add(packet);

                var item = new PurchaseOrderItem();
                item.PurchaseOrderLink.ID = order.ID;
                item.Job.ID = treatment.Packet.SetoutLink.JobLink.ID;
                item.Packet.ID = packet.ID;
                item.Product.ID = window.ProductID;
                if(product is not null)
                {
                    item.Product.Synchronise(product);
                }

                item.Qty = packet.BarcodeQty;

                item.Dimensions.Length = treatment.Parameter == 0.0F ? 1.0F : treatment.Parameter;

                var jobprice = supprods.FirstOrDefault(x => x.Job.ID.Equals(item.Job.ID));
                item.Cost = (jobprice != null ? jobprice.CostPrice : stdcost) * treatment.Parameter;

                var description = new List<string>();
                description.Add(string.Format("{0} x {1} - {2}", packet.BarcodeQty, packet.Serial, packet.Title));
                var dimensions = new List<string>();
                if (packet.Height > 0.0F)
                    dimensions.Add(string.Format("H:{0:F2}mm", packet.Height));
                if (packet.Width > 0.0F)
                    dimensions.Add(string.Format("W:{0:F2}mm", packet.Width));
                if (packet.Length > 0.0F)
                    dimensions.Add(string.Format("L:{0:F2}mm", packet.Length));
                dimensions.Add(string.Format("Param:{0:F4}", treatment.Parameter));
                if (dimensions.Any())
                    description.Add(string.Format("Dimensions: {0}", string.Join(" ", dimensions)));
                item.Description = string.Join("\n", description);

                orderitems.Add(item);
            }

            new Client<PurchaseOrderItem>().Save(orderitems, "Created by Factory Floor Purchase");

            Progress.SetMessage("Updating Packets");
            foreach (var orderitem in orderitems)
            {
                var packet = packetupdates.FirstOrDefault(x => x.ID.Equals(orderitem.Packet.ID));
                if (packet != null)
                    packet.OrderItem.ID = orderitem.ID;
            }

            new Client<ManufacturingPacket>().Save(packetupdates.Where(x => x.IsChanged()), "");


            Progress.SetMessage("Creating Delivery");
            var delivery = new Delivery();
            delivery.Date = DateTime.Today;
            delivery.Due = DateTime.Today;
            delivery.Employee.ID = App.EmployeeID;

            var sb = new StringBuilder();
            sb.Append("Serial # ");
            sb.AppendLine();
            sb.AppendLine();

            delivery.Notes = string.Format("Delivery of Items for processing to {0}\nOrder #{1} (raised on {2:dd MMM yy} by {3})\nItems: {4}",
                order.SupplierLink.Name,
                order.PONumber,
                delivery.Date,
                App.EmployeeName,
                string.Join(", ",
                    orderitems.Select(x =>
                        string.Format("{0}{1}", x.Description.Split('\n').FirstOrDefault(), x.Qty > 1 ? " (x" + x.Qty.ToString("F0") + ")" : "")))
            );
            new Client<Delivery>().Save(delivery, "Created by Factory Floor Purchase");
            Progress.Close();

            PrintDeliveryBarcode(delivery, order);

            PrintOrderItemBarcodes(delivery, order);

            SendPurchaseNotification(order.PONumber);

            MessageBox.Show("All Done");
            new DeliveryBuilder(delivery.ID, order.ID).ShowDialog();
            Refresh();
        }

        private void SendPurchaseNotification(string PONumber)
        {
            var updates = new List<Notification>();
            var roles = new Client<EmployeeRole>().Query(new Filter<EmployeeRole>(x => x.RoleLink.Code).IsEqualTo("PURCHASES"));
            foreach (var role in roles.Rows)
            {
                var notification = new Notification
                {
                    Title = string.Format("Treatment PO #{0} has been raised", PONumber),
                    Description = "The above Purchase Order has been created, and is ready to be checked and issued to the relevant supplier."
                };
                notification.Sender.ID = App.EmployeeID;
                notification.Employee.ID = role.Get<EmployeeRole, Guid>(x => x.EmployeeLink.ID);
                updates.Add(notification);
            }

            new Client<Notification>().Save(updates, "Sent Notification");
        }

        private void PrintDeliveryBarcode(Delivery delivery, PurchaseOrder order)
        {
            var model = new ManufacturingTreatmentDataModel(order, delivery);

            var templatename = "Print Treatment Delivery Bar Code";
            var sectionName = "Treatment Delivery Bar Code";

            var template = new Client<ReportTemplate>()
                .Load(
                    new Filter<ReportTemplate>(x => x.Name).IsEqualTo(templatename)
                        .And(x => x.DataModel).IsEqualTo(model.Name)
                        .And(x => x.Section).IsEqualTo(sectionName)
                ).FirstOrDefault();
            if (template == null)
            {
                template = new ReportTemplate
                {
                    DataModel = model.Name,
                    Section = sectionName,
                    Name = templatename
                };
                new Client<ReportTemplate>().Save(template, "Auto Created Report Template");
            }

            ReportUtils.PreviewReport(template, model, !Security.IsAllowed<CanDesignReports>(), Security.IsAllowed<CanDesignReports>());
        }


        private void PrintOrderItemBarcodes(Delivery delivery, PurchaseOrder order)
        {
            var model = new ManufacturingTreatmentDataModel(order, delivery);

            var templatename = "Print Treatment Item Bar Codes";
            var sectionName = "Treatment Item Bar Code";

            var template = new Client<ReportTemplate>()
                .Load(
                    new Filter<ReportTemplate>(x => x.Name).IsEqualTo(templatename)
                        .And(x => x.DataModel).IsEqualTo(model.Name)
                        .And(x => x.Section).IsEqualTo(sectionName)
                ).FirstOrDefault();
            if (template == null)
            {
                template = new ReportTemplate
                {
                    DataModel = model.Name,
                    Section = sectionName,
                    Name = templatename
                };
                new Client<ReportTemplate>().Save(template, "Auto Created Report Template");
            }

            ReportUtils.PreviewReport(template, model, !Security.IsAllowed<CanDesignReports>(), Security.IsAllowed<CanDesignReports>());
        }


        private CoreTable POItemTable(IEnumerable<PurchaseOrderItem> items)
        {
            var result = new CoreTable();
            result.LoadColumns(typeof(PurchaseOrderItem));
            result.LoadRows(items);
            return result;
        }

        private void DoSelectLostTime(PanelAction obj)
        {
            var chooser = new FactoryLostTimeChooser();
            if (chooser.ShowDialog() == true)
            {
                LostTime = chooser.SelectedLostTime;
                LostTimeDescription.Content = LostTime.Description;
                LostTimeActive.Visibility = Visibility.Visible;
            }
        }

        private void CancelLostTime_Click(object sender, RoutedEventArgs e)
        {
            LostTime = null;
            LostTimeActive.Visibility = Visibility.Collapsed;
        }

        //private void Current_DispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
        //{
        //    MessageBox.Show("Exception!\n\n" + e.Exception.Message + "\n\n" + e.Exception.StackTrace);
        //    e.Handled = true;
        //}

        private void Section_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (!IsReady)
                return;

            CurrentSection = Sections[Section.SelectedIndex];

            //Kanban.Columns.Clear();
            //Kanban.Columns.Add(new KanbanColumn() { Title = CurrentSection, Categories = CurrentSection.ID.ToString() });
            //Kanban.Columns[0].AllowDrag = false;
            //Kanban.Columns[0].PreviewMouseWheel += CardBorder_PreviewMouseWheel;

            IsReady = false;
            Station.Items.Clear();
            for (var i = 1; i <= CurrentSection.Stations; i++)
                Station.Items.Add(string.Format("Station #{0}", i));
            IsReady = true;
            Station.SelectedIndex = 0;
        }

        private void Station_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (!IsReady)
                return;
            SelectSectionAndStation(CurrentSection.ID, Station.SelectedIndex + 1);
        }

        private void SelectSectionAndStation(Guid section, int station)
        {
            CurrentKanban = null;
            CurrentStation = station;
            _settings.Section = section;
            _settings.Station = CurrentStation - 1;
            new LocalConfiguration<FactoryFloorLocalSettings>().Save(_settings);
            DoRefresh(true);
        }

        private void LoadKanban()
        {
            using (new WaitCursor())
            {
                if (CurrentKanban == null)
                {
                    ButtonStack.Children.Clear();
                    LoadDrawing(null);
                    _packGrid.CurrentPacket = null;
                }
                else if (true) // Kanban has changed - how do we figure this out 
                {
                    var packet = KanbanToPacket(CurrentKanban);
                    _packGrid.CurrentPacket = packet;
                    
                    //SetoutStage stage = packet.GetCurrentStage();
                    var row = Stages.Rows.FirstOrDefault(r => r.Get<ManufacturingPacketStage, Guid>(c => c.Parent.ID).Equals(packet.ID)
                                                              && r.Get<ManufacturingPacketStage, Guid>(c => c.ManufacturingSectionLink.ID)
                                                                  .Equals(_settings.Section));
                    var station = row != null ? row.Get<ManufacturingPacketStage, int>(c => c.Station) : 0;
                    var quality = row != null ? row.Get<ManufacturingPacketStage, QualityStatus>(c => c.QualityStatus) : QualityStatus.NotChecked;
                    var percentage = row != null ? row.Get<ManufacturingPacketStage, double>(c => c.PercentageComplete) : 0.00F;

                    var Pending = station == 0; //packet.StageLink.Station == 0;

                    // Set the Proper Button Set for this type of Packet
                    MfgRow.Height = Pending ? new GridLength(00) : new GridLength(50);

                    foreach (var btn in ButtonGrid.FindVisualChildren<Button>())
                        btn.IsEnabled = CurrentKanban != null;

                    var idle = CompleteButton.Background;
                    var current = new SolidColorBrush(Colors.SteelBlue);

                    Update100Button.Background = percentage >= 100.0F ? current : idle;
                    Update075Button.Background = percentage >= 75.0F ? current : idle;
                    Update050Button.Background = percentage >= 50.0F ? current : idle;
                    Update025Button.Background = percentage >= 25.0F ? current : idle;
                    Update000Button.Background = percentage >= 00.0F ? current : idle;

                    Button firstbutton = null;
                    //LoadDrawing(Guid.Empty);
                    ButtonStack.Children.Clear();

                    // If we are quality checking, add the QA Check button
                    if (!Pending)
                    {
                        var qabtn = new Button();
                        qabtn.Content = "Quality Checks";
                        qabtn.Tag = null;
                        qabtn.Style = Resources["UnselectedButton"] as Style;
                        qabtn.Click += ViewQualityChecks;
                        ButtonStack.Children.Add(qabtn);

                        if (packet.Drawing.IsValid())
                        {
                            var pdfbtn = new Button();
                            pdfbtn.Content = packet.Drawing.FileName.ToLower();
                            pdfbtn.Tag = packet.Drawing;
                            pdfbtn.Style = Resources["UnselectedButton"] as Style;
                            pdfbtn.Click += ViewDrawing;
                            ButtonStack.Children.Add(pdfbtn);
                            firstbutton = pdfbtn;
                        }

                        // List all available PDFs for this Setout
                        documents = new Client<SetoutDocument>().Load(
                            new Filter<SetoutDocument>(x => x.EntityLink.ID).IsEqualTo(CurrentKanban.SetoutID));
                        foreach (var document in documents)
                        {
                            // If this document is actually the cutting group document, 
                            // redirect any annotations to the cutting group id rather than the setout
                            if (document.DocumentLink.ID == packet.SetoutLink.Group.OptimizationDocument.ID)
                                document.ID = packet.SetoutLink.Group.ID;
                            
                            if (document.DocumentLink != null && document.DocumentLink.FileName != null)
                                if (document.DocumentLink.FileName.ToLower().EndsWith(".pdf") ||
                                    document.DocumentLink.FileName.ToLower().EndsWith(".png") ||
                                    document.DocumentLink.FileName.ToLower().EndsWith(".bmp") ||
                                    document.DocumentLink.FileName.ToLower().EndsWith(".jpg"))
                                {
                                    var pdfbtn = new Button();
                                    pdfbtn.Content = document.DocumentLink.FileName.ToLower() +
                                                     (!document.Superceded.IsEmpty() ? " (SUPERCEDED)" : "");
                                    pdfbtn.Tag = document.DocumentLink;
                                    pdfbtn.Style = Resources["UnselectedButton"] as Style;
                                    pdfbtn.Click += ViewDrawing;
                                    ButtonStack.Children.Add(pdfbtn);
                                    if (document.Superceded.IsEmpty())
                                        if ((PDFEditor != null && PDFEditor.Document.ID.Equals(document.ID)) ||
                                            firstbutton == null)
                                            firstbutton = pdfbtn;
                                }
                        }

                        if (firstbutton == null)
                            firstbutton = qabtn;
                    }

                    if (firstbutton != null)
                        //SetCurrentButton(firstbutton);
                        firstbutton.RaiseEvent(new RoutedEventArgs(ButtonBase.ClickEvent));
                    else
                        LoadDrawing(null);
                } // Kanban has not changed - do nothing
                if (_packLinked.IsChecked == true)
                    _packGrid.Refresh(false,false);
            }
        }

        private void SetCurrentButton(Button button)
        {
            if (_currentButton != null)
                _currentButton.Style = Resources["UnselectedButton"] as Style;
            _currentButton = button;
            button.Style = Resources["SelectedButton"] as Style;
        }

        private void SwimLaneSelected(object sender, MouseButtonEventArgs e)
        {
        }

        private void CardSelected(object sender, MouseButtonEventArgs e)
        {
            var border = (Border)sender;
            CurrentKanban = (ManufacturingKanban)border.Tag;

            UpdateSelectedKanban();
        }

        private bool CheckedPacketsChanged(Dictionary<Guid, Tuple<DateTime, DateTime>> lastCheckedPackets,
            Dictionary<Guid, Tuple<DateTime, DateTime>> newCheckedPackets)
        {
            if (lastCheckedPackets.Count != newCheckedPackets.Count)
                return true;
            foreach (var key in lastCheckedPackets.Keys)
            {
                if (!newCheckedPackets.ContainsKey(key))
                    return true;
                if (!newCheckedPackets[key].Item1.Equals(lastCheckedPackets[key].Item1))
                    return true;
                if (!newCheckedPackets[key].Item2.Equals(lastCheckedPackets[key].Item2))
                    return true;
            }

            return false;
        }

        private void UpdateSelectedKanban(bool uncheckothers = true)
        {
            if (CurrentKanban != null)
            {
                var others = Kanbans.Where(x => x.Checked && x.Assignee != CurrentKanban.Assignee).ToArray();
                foreach (var other in others)
                    other.Checked = false;

                others = Kanbans.Where(x => x.Checked).ToArray();
                if (others.Length == 1)
                    others[0].Checked = false;

                others = Kanbans.Where(x => x.IsSelected).ToArray();
                foreach (var other in others)
                {
                    other.IsSelected = false;
                    var pkt = KanbanToPacket(other);
                    if (pkt != null)
                        //var stg = Stages.FirstOrDefault(x => x.ManufacturingPacketLink.ID.Equals(pkt.ID));
                        other.SelectedColor = other.ColorKey;
                    else
                        other.SelectedColor = other.ColorKey;
                }

                CurrentKanban.Checked = true;
                CurrentKanban.IsSelected = true;
                CurrentKanban.SelectedColor = SELECTED_COLOR;
            }

            //UpdateTimeTracking();

            Kanban.ItemsSource = null;
            Kanban.ItemsSource = Kanbans.OrderBy(x => x.Assignee).ThenByDescending(x => x.Tags.Length).ThenBy(x => x.DueDate).ThenBy(x => x.JobName);

            LoadKanban();
        }

        private void CardChecked(object sender, RoutedEventArgs e)
        {
            //UpdateTimeTracking();
            try
            {
                var chk = sender as CheckBox;

                var border = (chk.Parent as Grid).Parent as Border;
                var kanban = border.Tag as ManufacturingKanban;
                kanban.Checked = chk.IsChecked == true;

                if (kanban.Checked)
                    foreach (var other in Kanbans.Where(x => x.Assignee != kanban.Assignee))
                        other.Checked = false;
            }
            catch (Exception err)
            {
                Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", err.Message, err.StackTrace));
            }

            //Kanban.ItemsSource = null;
            //Kanban.ItemsSource = Kanbans.OrderBy(x => x.Assignee).ThenByDescending(x => x.Tags.Length).ThenBy(x => x.DueDate).ThenBy(x => x.JobName);
        }

        private void CompleteButton_Click(object sender, RoutedEventArgs e)
        {
            var packets = new List<ManufacturingPacket>();
            foreach (var kanban in Kanbans.Where(x => x.Checked || x.IsSelected))
            {
                var packet = KanbanToPacket(kanban);

                if (packet.StageLink.SectionID != CurrentSection.ID)
                {
                    MessageBox.Show("You cannot complete a distributed packet that is not yet progressed to your station!");
                    return;
                }

                var qacomplete = true;
                var stage = Stages.Rows.FirstOrDefault(r => r.Get<ManufacturingPacketStage, Guid>(c => c.Parent.ID).Equals(packet.ID)
                                                            && r.Get<ManufacturingPacketStage, Guid>(c => c.ManufacturingSectionLink.ID)
                                                                .Equals(_settings.Section));
                if (stage != null)
                {
                    var qadata = stage.Get<ManufacturingPacketStage, string>(c => c.FormData);
                    var questions = LoadQAQuestions(packet, true, true);

                    if (questions != null)
                    {

                        var answers = string.IsNullOrWhiteSpace(qadata)
                            ? new Dictionary<Guid, object>()
                            : Serialization.Deserialize<Dictionary<Guid, object>>(qadata);

                        foreach (var question in questions)
                        {
                            var parameters = question.ParseParameters();
                            var bAnswerRequired = question.Answer != QAAnswer.Comment &&
                                                  (!parameters.ContainsKey("Default") || string.IsNullOrWhiteSpace(parameters["Default"]));
                            if (bAnswerRequired && (!answers.ContainsKey(question.ID) || answers[question.ID] == null))
                            {
                                qacomplete = false;
                                break;
                            }
                        }
                    }
                }

                if (!qacomplete)
                {
                    MessageBox.Show("You must complete the required QA checks before completing these items!");
                    return;
                }

                packets.Add(packet);
            }

            Progress.Show("Scanning Packets");

            //Filter<ManufacturingPacketStage> stgflt = new Filter<ManufacturingPacketStage>(x => x.ID).IsEqualTo(CoreUtils.FullGuid);
            //foreach (var pkt in packets)
            //    stgflt = stgflt.Or(x => x.ManufacturingPacketLink.ID).IsEqualTo(pkt.ID);
            //ManufacturingPacketStage[] stgs = new Client<ManufacturingPacketStage>().Load(stgflt, new SortOrder<ManufacturingPacketStage>(x => x.Sequence));

            var stage_updates = new List<ManufacturingPacketStage>();
            for (var i = 0; i < packets.Count; i++)
            {
                var packet = packets[i];

                var stagerows = Stages.Rows.Where(r => r.Get<ManufacturingPacketStage, Guid>(c => c.Parent.ID).Equals(packet.ID));
                var stages = stagerows.Select(r => r.ToObject<ManufacturingPacketStage>());

                //var stages = stgs.Where(x => x.ManufacturingPacketLink.ID.Equals(packet.ID));

                long sequence = 0;

                // Send the update to the server
                var stage = stages.FirstOrDefault(x => x.ID.Equals(packet.StageLink.ID));
                if (stage != null)
                {
                    stage.Completed = DateTime.Now;
                    if(stage.Form.ID == Guid.Empty)
                    {
                        stage.Form.ID = CurrentSection.QAForm.ID;
                    }
                    if(stage.Form.ID != Guid.Empty)
                    {
                        stage.FormCompleted = DateTime.Now;
                        stage.FormCompletedBy.ID = ClientFactory.UserGuid;
                    }
                    stage.PercentageComplete = 100.0F;
                    if (!stage_updates.Contains(stage))
                        stage_updates.Add(stage);
                    sequence = stage.Sequence;
                }

                // Also update the local copy (hacky hacky)
                var stagerow = Stages.Rows.FirstOrDefault(r => r.Get<ManufacturingPacketStage, Guid>(c => c.ID).Equals(packet.StageLink.ID));
                if (stagerow != null)
                {
                    stagerow.Set<ManufacturingPacketStage, DateTime>(x => x.Completed, DateTime.Now);
                    stagerow.Set<ManufacturingPacketStage, DateTime>(x => x.FormCompleted, DateTime.Now);
                    stagerow.Set<ManufacturingPacketStage, Guid>(x => x.FormCompletedBy.ID, ClientFactory.UserGuid);
                    stagerow.Set<ManufacturingPacketStage, double>(x => x.PercentageComplete, 100.0F);
                }

                // Update the pointer to the next stage
                // But only if it's at your  station already 
                // This takes into account distributed packets that may not be completed elsewhere
                if (packet.StageLink.SectionID == CurrentSection.ID)
                {
                    stage = stages.Where(x => x.Sequence > sequence).FirstOrDefault();

                    // If this is a distributed packet, then it may already have data allocated to it
                    // We on;y want to reset the next stage if it's not distributed
                    if (!packet.Distributed)
                        if (stage != null)
                        {
                            stage.QualityStatus = QualityStatus.NotChecked;
                            stage.QualityNotes = "";
                            stage.Station = 0;
                            stage.Started = DateTime.MinValue;
                            stage.Completed = DateTime.MinValue;
                            stage.PercentageComplete = 0.0F;
                            if (!stage_updates.Contains(stage))
                                stage_updates.Add(stage);
                        }
                }

                packet.StageLink.ID = stage == null ? CoreUtils.FullGuid : stage.ID;
                packet.Issued = !packet.StageLink.IsValid() ? DateTime.MinValue : packet.Issued.IsEmpty() ? DateTime.Now : packet.Issued;
                packet.Completed = packet.StageLink.ID.Equals(CoreUtils.FullGuid)
                    ? packet.Completed.IsEmpty() ? DateTime.Now : packet.Completed
                    : DateTime.MinValue;
            }

            Progress.SetMessage("Progressing Items");
            new Client<ManufacturingPacketStage>().Save(stage_updates, "ManufacturingPacket Progressed from Factory Floor");
            new Client<ManufacturingPacket>().Save(packets, "ManufacturingPacket Progressed From Factory Floor");

            //UpdateTimeTracking();

            Heartbeat(new TimeSpan(0L));

            CurrentKanban = null;

            Refresh();
            Progress.Close();
        }

        private void UpdateButtonClick(object sender, RoutedEventArgs e)
        {
            Progress.Show("");
            double percent = 0.0F;
            if (double.TryParse(((Button)sender).Tag.ToString(), out percent))
            {
                var selected = new List<ManufacturingPacket>();
                var stages = new List<ManufacturingPacketStage>();
                foreach (var kanban in Kanbans.Where(x => x.Checked || x.IsSelected))
                {
                    selected.Add(KanbanToPacket(kanban));
                    var pktid = Guid.Parse(kanban.ID);
                    var stagerows = Stages.Rows.Where(r =>
                        r.Get<ManufacturingPacketStage, Guid>(c => c.SectionID).Equals(CurrentSection.ID) &&
                        r.Get<ManufacturingPacketStage, Guid>(c => c.Parent.ID).Equals(pktid));
                    stages.AddRange(stagerows.Select(r => r.ToObject<ManufacturingPacketStage>()));
                }

                var updates = new List<ManufacturingPacketStage>();
                foreach (var stage in stages)
                {
                    var bChanged = false;
                    if (stage.Started == DateTime.MinValue)
                    {
                        stage.Started = DateTime.Now;
                        bChanged = true;
                    }

                    if (stage.PercentageComplete != percent)
                    {
                        stage.PercentageComplete = percent;
                        bChanged = true;
                    }

                    if (stage.Station != -1 && stage.Station != CurrentStation)
                    {
                        stage.Station = CurrentStation;
                        bChanged = true;
                    }

                    if (bChanged)
                        updates.Add(stage);
                }

                new Client<ManufacturingPacketStage>().Save(updates, "Progress Updated from Factory Floor");
                DoRefresh(true);
            }

            Progress.Close();
        }

        private void TearOffButton_Click(object sender, RoutedEventArgs e)
        {
            var doc = PDFEditor.Document;
            var window = new ThemableWindow();
            var editor = new PDFEditorControl();
            editor.SaveAllowed = Security.IsAllowed<CanSaveFactoryFloorDrawings>();
            editor.Document = doc;
            window.Content = editor;
            window.Show();
        }

        private void BarcodesButton_Click(object sender, RoutedEventArgs e)
        {
            //List<ManufacturingPacket> updates = new List<ManufacturingPacket>();

            var checkedpackets =
                Packets.Rows.Where(p => Kanbans.Any(k => k.Checked && p.Get<ManufacturingPacket, Guid>(c => c.ID).ToString().Equals(k.ID)));

            if (!checkedpackets.Any())
            {
                MessageBox.Show("Please select a packet before continuing");
                return;
            }

            Progress.Show("");

            Filter<ManufacturingPacket> pktflt = null;
            foreach (var row in checkedpackets)
                pktflt = pktflt == null
                    ? new Filter<ManufacturingPacket>(x => x.ID).IsEqualTo(row.Get<ManufacturingPacket, Guid>(c => c.ID))
                    : pktflt.Or(x => x.ID).IsEqualTo(row.Get<ManufacturingPacket, Guid>(c => c.ID));

            var pkts = new Client<ManufacturingPacket>().Load(pktflt);

            foreach (var pkt in pkts)
                //var pkt = row.ToObject<ManufacturingPacket>();
                if (pkt.BarcodePrinted == DateTime.MinValue)
                    pkt.BarcodePrinted = DateTime.Now;
            //updates.Add(pkt);
            //if (updates.Any())
            //{
            Progress.SetMessage("Creating Barcodes");
            new Client<ManufacturingPacket>().Save(pkts, "Delivery Barcodes created");
            //}


            Filter<DeliveryItem> filter = null;
            foreach (var row in checkedpackets)
            {
                var pktid = row.Get<ManufacturingPacket, Guid>(c => c.ID);
                if (filter == null)
                    filter = new Filter<DeliveryItem>(x => x.ManufacturingPacketLink.ID).IsEqualTo(pktid);
                else
                    filter = filter.Or(x => x.ManufacturingPacketLink.ID).IsEqualTo(pktid);
            }

            var dataenvironment = new Dictionary<Type, CoreTable>();

            var model = new DeliveryItemDataModel(filter);

            var Group = Packets.Rows.Select(r => r.Get<ManufacturingPacket, string>(c => c.Group)).FirstOrDefault();
            var BaseReportName = "Print Bar Codes";
            var sectionName = "Delivery Items";
            var repflt = new Filter<ReportTemplate>(x => x.Name).IsEqualTo(BaseReportName);
            var DesiredReportName = BaseReportName + (!string.IsNullOrWhiteSpace(Group) ? " - " + Group : "");
            if (DesiredReportName != BaseReportName)
                repflt = repflt.Or(x => x.Name).IsEqualTo(DesiredReportName);
            var repflt2 = new Filter<ReportTemplate>(x => x.DataModel).IsEqualTo(model.Name).And(x => x.Section).IsEqualTo(sectionName);
            repflt2.Ands.Add(repflt);

            var templates = new Client<ReportTemplate>().Load(repflt2);
            var report = templates.FirstOrDefault(x => x.Name == DesiredReportName);
            if (report == null)
                report = templates.FirstOrDefault(x => x.Name == BaseReportName);

            if (report == null)
            {
                Progress.Close();
                MessageBox.Show("Ready To Go -> [Print Bar Codes] report does not exist!");
                Refresh();
            }


            Progress.Close();
            ReportUtils.PreviewReport(report, model, false, Security.IsAllowed<CanDesignReports>());

            Refresh();
        }

        private void ViewDrawing(object sender, RoutedEventArgs e)
        {
            var button = (Button)sender;
            SetCurrentButton(button);
            var doc = button.Tag as IEntityLink;
            LoadDrawing(doc.ID);
        }

        private void Search_KeyUp(object sender, KeyEventArgs e)
        {
            SearchFilter = Search.Text;
            if (e.Key == Key.Enter || string.IsNullOrEmpty(Search.Text))
            {
                ClearAllSelections();
                ReloadPackets(true);
            }
        }

        //private void SwimlaneCheckBox_Checked(object sender, RoutedEventArgs e)
        //{
        //    CheckBox chk = sender as CheckBox;
        //    String tag = chk.Tag as String;
        //    foreach (var packet in Kanbans)
        //        packet.Checked = (packet.Assignee == tag) ? !packet.Checked : false;
        //    Kanban.ItemsSource = null;
        //    Kanban.ItemsSource = Kanbans.OrderBy(x => x.Assignee).ThenByDescending(x => x.Tags.Length).ThenBy(x => x.DueDate).ThenBy(x => x.JobName);
        //}

        //private void CardBorder_PreviewMouseWheel(object sender, MouseWheelEventArgs e)
        //{

        //    e.Handled = true;
        //    var eventArg = new MouseWheelEventArgs(e.MouseDevice, e.Timestamp, e.Delta);
        //    eventArg.RoutedEvent = UIElement.MouseWheelEvent;
        //    eventArg.Source = sender;
        //    var tgts = FindVisualChildren<UIElement>(Kanban.Columns[0]);
        //    foreach (var tgt in tgts)
        //        tgt.RaiseEvent(eventArg);

        //}

        private void PacketMenu_Opened(object sender, RoutedEventArgs e)
        {
            var menu = sender as ContextMenu;

            var setcurrent = menu.Items[0] as MenuItem;
            var setpending = menu.Items[1] as MenuItem;

            var actionseparator = menu.Items[2] as Separator;

            var settrolley = menu.Items[3] as MenuItem;
            var cleartrolley = menu.Items[4] as MenuItem;

            var trolleyseparator = menu.Items[5] as Separator;

            var setpriority = menu.Items[6] as MenuItem;
            var clearpriority = menu.Items[7] as MenuItem;

            var editissues = menu.Items[8] as MenuItem;
            var sethold = menu.Items[9] as MenuItem;
            var clearhold = menu.Items[10] as MenuItem;

            var setdistributed = menu.Items[11] as MenuItem;
            var cleardistributed = menu.Items[12] as MenuItem;

            var distseparator = menu.Items[13] as Separator;

            var setshared = menu.Items[14] as MenuItem;
            var clearshared = menu.Items[15] as MenuItem;
            var movepacket = menu.Items[16] as MenuItem;
            var requestMaterials = menu.Items[18] as MenuItem;

            var model = menu.Tag as ManufacturingKanban;

            if (!model.Checked)
            {
                foreach (var kanban in Kanbans.Where(x => x.Checked).ToArray())
                    kanban.Checked = false;
                model.Checked = true;
                //Kanban.ItemsSource = null;
                //Kanban.ItemsSource = Kanbans.OrderBy(x => x.Assignee).ThenByDescending(x => x.Tags.Length).ThenBy(x => x.DueDate).ThenBy(x => x.JobName);
            }


            var checkedkanbans = Kanbans.Where(k => k.Checked).Select(x => Guid.Parse(x.ID));
            var checkedpackets = Packets.Rows.Where(r => checkedkanbans.Contains(r.Get<ManufacturingPacket, Guid>(c => c.ID)));
            var checkedstages = Stages.Rows.Where(r => checkedkanbans.Contains(r.Get<ManufacturingPacketStage, Guid>(c => c.Parent.ID))
                                                       && r.Get<ManufacturingPacketStage, Guid>(c => c.ManufacturingSectionLink.ID)
                                                           .Equals(_settings.Section));


            // Only if we right-click on a checked packet??
            if (checkedpackets.Any() && checkedstages.Any())
            {
                var iStation = checkedstages.First().Get<ManufacturingPacketStage, int>(c => c.Station);

                setcurrent.Visibility = iStation == 0 ? Visibility.Visible : Visibility.Collapsed;
                setpending.Visibility = iStation > 0 ? Visibility.Visible : Visibility.Collapsed;
                actionseparator.Visibility = Visibility.Collapsed;

                settrolley.Visibility = Visibility.Visible;

                cleartrolley.Visibility =
                    checkedpackets.Select(r => r.Get<ManufacturingPacket, string>(x => x.Trolleys)).Any(x => !string.IsNullOrWhiteSpace(x))
                        ? Visibility.Visible
                        : Visibility.Collapsed;

                setpriority.Visibility = Visibility.Collapsed; // (packet != null) && packet.Priority ? Visibility.Collapsed : Visibility.Visible;
                clearpriority.Visibility = Visibility.Collapsed; // (packet != null) && packet.Priority ? Visibility.Visible : Visibility.Collapsed;

                editissues.Visibility = Visibility.Visible;

                sethold.Visibility =
                    false //Security.IsAllowed<CanManagePacketHolds>() && checkedpackets.Any(r => !r.Get<ManufacturingPacket, bool>(c => c.OnHold))
                        ? Visibility.Visible
                        : Visibility.Collapsed;

                clearhold.Visibility =
                    false //Security.IsAllowed<CanManagePacketHolds>() && checkedpackets.Any(r => r.Get<ManufacturingPacket, bool>(c => c.OnHold))
                        ? Visibility.Visible
                        : Visibility.Collapsed;

                setdistributed.Visibility = Security.IsAllowed<CanDistributePackets>() &&
                                            checkedpackets.Any(r => r.Get<ManufacturingPacket, bool>(c => c.Distributed) == false)
                    ? Visibility.Visible
                    : Visibility.Collapsed;

                cleardistributed.Visibility = Security.IsAllowed<CanDistributePackets>() &&
                                              checkedpackets.Any(r => r.Get<ManufacturingPacket, bool>(c => c.Distributed))
                    ? Visibility.Visible
                    : Visibility.Collapsed;

                distseparator.Visibility = setdistributed.Visibility == Visibility.Visible || cleardistributed.Visibility == Visibility.Visible
                    ? Visibility.Visible
                    : Visibility.Collapsed;

                setshared.Visibility = iStation > 0 ? Visibility.Visible : Visibility.Collapsed;
                clearshared.Visibility = iStation < 0 ? Visibility.Visible : Visibility.Collapsed;
                movepacket.Visibility = iStation > 0 ? Visibility.Visible : Visibility.Collapsed;

                setcurrent.Tag = checkedstages;
                setpending.Tag = checkedstages;

                setpriority.Tag = checkedpackets;
                clearpriority.Tag = checkedpackets;
                editissues.Tag = checkedpackets;
                sethold.Tag = checkedpackets;
                clearhold.Tag = checkedpackets;
                setdistributed.Tag = checkedpackets;
                cleardistributed.Tag = checkedpackets;

                setshared.Tag = checkedstages;
                clearshared.Tag = checkedstages;
                movepacket.Tag = checkedstages;
                requestMaterials.Tag = checkedpackets;

                if (movepacket.Visibility == Visibility.Visible)
                {
                    movepacket.Items.Clear();
                    foreach (var station in Station.Items)
                    {
                        var sub = new MenuItem { Header = station, Tag = checkedstages };
                        sub.Click += MovePacketClick;
                        movepacket.Items.Add(sub);
                        sub.Visibility = movepacket.Items.Count == CurrentStation ? Visibility.Collapsed : Visibility.Visible;
                    }
                }

                settrolley.Tag = Kanbans.Where(k => k.Checked);
                cleartrolley.Tag = Kanbans.Where(k => k.Checked);

                //if (Trolleys == null)
                //{
                //    Trolleys = new Client<ManufacturingTrolley>().Query(
                //        LookupFactory.DefineFilter<ManufacturingTrolley>(),
                //        LookupFactory.DefineColumns<ManufacturingTrolley>(),
                //        LookupFactory.DefineSort<ManufacturingTrolley>()
                //        );
                //}
                //if (Trolleys.Rows.Any())
                //{
                //    settrolley.Visibility = Visibility.Visible;
                //    settrolley.Items.Clear();
                //    foreach (var row in Trolleys.Rows)
                //    {
                //        MenuItem sub = new MenuItem() { Header = row.Get<ManufacturingTrolley,String>(x=>x.Code) + ": "+ row.Get<ManufacturingTrolley, String>(x => x.Description), Tag = row.Get<ManufacturingTrolley,Guid>(x=>x.ID) };
                //        sub.Click += SetTrolleyClick;
                //        settrolley.Items.Add(sub);

                //    }
                //}
                //else
                //    settrolley.Visibility = Visibility.Collapsed;
            }
            // Disable everything
        }

        private void SetPacketToTrolley(string trolley, params ManufacturingPacket[] packets)
        {
            var updates = new List<ManufacturingPacket>();
            foreach (var packet in packets)
                if (string.Equals(packet.Trolleys, trolley))
                {
                    packet.Trolleys = trolley;
                    updates.Add(packet);
                }

            if (updates.Any())
                using (new WaitCursor())
                {
                    new Client<ManufacturingPacket>().Save(updates, string.Format("Moved Packet to Trolley {0}", trolley), (o, e) => { });
                    foreach (var update in updates)
                    {
                        var pktrow = Packets.Rows.FirstOrDefault(r => r.Get<ManufacturingPacket, Guid>(c => c.ID).Equals(update.ID));
                        var stagerow = Stages.Rows.FirstOrDefault(r => r.Get<ManufacturingPacketStage, Guid>(c => c.Parent.ID).Equals(update.ID)
                                                                       && r.Get<ManufacturingPacketStage, Guid>(c => c.ManufacturingSectionLink.ID)
                                                                           .Equals(_settings.Section));

                        //ManufacturingPacketStage stage = Stages.Rows.FirstOrDefault(r => r.Get<ManufacturingPacketStage, Guid>(x => x.Parent.ID).Equals(update.ID))?.ToObject<ManufacturingPacketStage>();
                        var kanban = Kanbans.FirstOrDefault(x => x.ID.Equals(update.ID.ToString()));
                        LoadModel(kanban, pktrow, stagerow, true);
                    }
                }
        }

        private void SetTrolleyClick(object sender, RoutedEventArgs e)
        {
            var kanbans = (sender as MenuItem).Tag as IEnumerable<ManufacturingKanban>;
            List<string> trolleyPrePopulate = new List<string>();
            foreach (ManufacturingKanban kanban in kanbans)
            {
                if (!string.IsNullOrWhiteSpace(kanban.Trolleys))
                {
                    if (kanban.Trolleys.Contains(','))
                    {
                        var splitTrolleys = kanban.Trolleys.Split(',');
                        foreach (string s in splitTrolleys)
                        {
                            if (!trolleyPrePopulate.Contains(s))
                            {
                                trolleyPrePopulate.Add(s);
                            }
                        }
                    }
                    else
                    {
                        if (!trolleyPrePopulate.Contains(kanban.Trolleys))
                        {
                            trolleyPrePopulate.Add(kanban.Trolleys);
                        }
                    }
                }
            }
            var dlg = new MultiSelectWindow(typeof(ManufacturingTrolley), new Guid[] { }, trolleyPrePopulate);
            if (dlg.ShowDialog() == true)
                using (new WaitCursor())
                {
                    var trolleys = new List<string>();
                    foreach (ManufacturingTrolley value in dlg.Values)
                        trolleys.Add(value.Code);
                    var updates = new List<ManufacturingPacket>();
                    foreach (var kanban in kanbans)
                    {
                        var pktrow = Packets.Rows.FirstOrDefault(r => r.Get<ManufacturingPacket, Guid>(c => c.ID).Equals(Guid.Parse(kanban.ID)));
                        var stagerow = Stages.Rows.FirstOrDefault(r =>
                            r.Get<ManufacturingPacketStage, Guid>(c => c.Parent.ID).Equals(Guid.Parse(kanban.ID))
                            && r.Get<ManufacturingPacketStage, Guid>(c => c.ManufacturingSectionLink.ID).Equals(_settings.Section));

                        var packet = pktrow.ToObject<ManufacturingPacket>();

                        packet.Trolleys = string.Join(",", trolleys);
                        updates.Add(packet);

                        pktrow.Set<ManufacturingPacket, string>(x => x.Trolleys, packet.Trolleys);

                        LoadModel(kanban, pktrow, stagerow, true);
                    }

                    if (updates.Any())
                    {
                        new Client<ManufacturingPacket>().Save(updates, "Set Trolley to " + (sender as MenuItem).Header, (objects, error) => { });
                        var src = Kanban.ItemsSource;
                        Kanban.ItemsSource = null;
                        Kanban.ItemsSource = src;
                    }
                }
            //Refresh();
        }

        private void ClearTrolleyClick(object sender, RoutedEventArgs e)
        {
            var kanbans = (sender as MenuItem).Tag as IEnumerable<ManufacturingKanban>;
            using (new WaitCursor())
            {
                var updates = new List<ManufacturingPacket>();
                foreach (var kanban in kanbans)
                {
                    var pktrow = Packets.Rows.FirstOrDefault(r => r.Get<ManufacturingPacket, Guid>(c => c.ID).Equals(Guid.Parse(kanban.ID)));
                    var stagerow = Stages.Rows.FirstOrDefault(r =>
                        r.Get<ManufacturingPacketStage, Guid>(c => c.Parent.ID).Equals(Guid.Parse(kanban.ID))
                        && r.Get<ManufacturingPacketStage, Guid>(c => c.ManufacturingSectionLink.ID)
                            .Equals(_settings.Section));

                    var packet = pktrow.ToObject<ManufacturingPacket>();

                    packet.Trolleys = "";
                    updates.Add(packet);

                    pktrow.Set<ManufacturingPacket, string>(x => x.Trolleys, packet.Trolleys);

                    LoadModel(kanban, pktrow, stagerow, true);
                }

                if (updates.Any())
                {
                    new Client<ManufacturingPacket>().Save(updates, "Removed From Trolley", (objects, error) => { });
                    var src = Kanban.ItemsSource;
                    Kanban.ItemsSource = null;
                    Kanban.ItemsSource = src;
                }
            }
        }

        private void SetCurrent_Click(object sender, RoutedEventArgs e)
        {
            var rows = (sender as MenuItem).Tag as IEnumerable<CoreRow>;
            var stages = rows.Select(x => x.ToObject<ManufacturingPacketStage>()).ToArray();
            AddPacketToCurrentWorkload(stages);
            CurrentKanban = Kanbans.FirstOrDefault(x => x.ID.Equals(stages.First().Parent.ID.ToString()));
            UpdateSelectedKanban(false);
        }

        private void AddPacketToCurrentWorkload(params ManufacturingPacketStage[] stages)
        {
            var updates = new List<ManufacturingPacketStage>();
            foreach (var stage in stages)
                if (stage.Station == 0)
                {
                    stage.Station = CurrentStation;
                    stage.Started = DateTime.Now;
                    updates.Add(stage);
                }

            if (updates.Any())
                using (new WaitCursor())
                {
                    new Client<ManufacturingPacketStage>().Save(updates, string.Format("Moved Packet to Station {0}", CurrentStation), (o, e) => { });
                    foreach (var update in updates)
                    {
                        var pktrow = Packets.Rows.FirstOrDefault(r => r.Get<ManufacturingPacket, Guid>(c => c.ID).Equals(update.Parent.ID));
                        var stagerow = Stages.Rows.FirstOrDefault(r => r.Get<ManufacturingPacketStage, Guid>(x => x.ID).Equals(update.ID));
                        Stages.FillRow(stagerow, update);
                        var kanban = Kanbans.FirstOrDefault(x => x.ID.Equals(update.Parent.ID.ToString()));
                        LoadModel(kanban, pktrow, stagerow, true);
                    }
                }
        }

        private void SetPending_Click(object sender, RoutedEventArgs e)
        {
            var updates = new List<ManufacturingPacketStage>();
            var rows = (sender as MenuItem).Tag as IEnumerable<CoreRow>;
            foreach (var row in rows)
            {
                var stage = row.ToObject<ManufacturingPacketStage>();
                if (stage.Station != 0)
                {
                    stage.Station = 0;
                    stage.Started = DateTime.MinValue;
                    updates.Add(stage);
                }
            }

            if (updates.Any())
                using (new WaitCursor())
                {
                    new Client<ManufacturingPacketStage>().Save(updates, string.Format("Removed Packet from Station {0}", CurrentStation));
                    foreach (var update in updates)
                    {
                        var pktrow = Packets.Rows.FirstOrDefault(r => r.Get<ManufacturingPacket, Guid>(c => c.ID).Equals(update.Parent.ID));
                        var stagerow = Stages.Rows.FirstOrDefault(r => r.Get<ManufacturingPacketStage, Guid>(x => x.ID).Equals(update.ID));
                        Stages.FillRow(stagerow, update);
                        var kanban = Kanbans.FirstOrDefault(x => x.ID.Equals(update.Parent.ID.ToString()));
                        LoadModel(kanban, pktrow, stagerow, true);
                    }

                    CurrentKanban = Kanbans.FirstOrDefault(x => x.ID.Equals(updates.First().Parent.ID.ToString()));
                    UpdateSelectedKanban();
                }
        }

        private void UpdateFlag(object sender, string property, bool value)
        {
            var updates = new List<ManufacturingPacket>();
            var rows = (sender as MenuItem)!.Tag as IEnumerable<CoreRow>;
            foreach (var row in rows)
            {
                var packet = row.ToObject<ManufacturingPacket>();
                CoreUtils.SetPropertyValue(packet, property, value);
                updates.Add(packet);
            }

            if (updates.Any())
                using (new WaitCursor())
                {
                    new Client<ManufacturingPacket>().Save(updates, property + " Flag " + (value ? "Set" : "Cleared"));
                    Refresh();
                }
        }

        private void SetPriority_Click(object sender, RoutedEventArgs e)
        {
            UpdateFlag(sender, "Priority", true);
        }

        private void ClearPriority_Click(object sender, RoutedEventArgs e)
        {
            UpdateFlag(sender, "Priority", false);
        }

        private void EditIssues_Click(object sender, RoutedEventArgs e)
        {
            var updates = new List<ManufacturingPacket>();
            var rows = (sender as MenuItem).Tag as IEnumerable<CoreRow>;
            var pkts = rows.Select(x => x.ToObject<ManufacturingPacket>()).ToArray();
            if (new DynamicIssuesEditor(pkts, true).ShowDialog() == true)
            {
                Progress.ShowModal("Updating Issues", progress => { new Client<ManufacturingPacket>().Save(pkts, "Updated Issues"); });
                Refresh();
            }

            // String[] issues = rows.Select(r => r.Get<ManufacturingPacket, String>(c => c.Issues)).Distinct().ToArray();
            // if (issues.Length > 1)
            // {
            //     if (MessageBox.Show(
            //             "Multiple Issues found! If you continue, these may be lost.\n\nAre you sure you wish to continue?",
            //             "Multiple Issues",
            //             MessageBoxButton.YesNo) != MessageBoxResult.Yes)
            //         return;
            // }
            //
            // string issue = issues.Length > 0 ? issues.First() : "";
            // if (!TextBoxDialog.Execute("Edit Issues", ref issue))
            //     return;
            //
            // foreach (var row in rows)
            // {
            //     ManufacturingPacket packet = row.ToObject<ManufacturingPacket>();
            //     packet.Issues = issue;
            //     updates.Add(packet);
            // }
            // if (updates.Any())
            // {
            //     using (new WaitCursor())
            //     {
            //         new Client<ManufacturingPacket>().Save(updates, "Updated Issues");
            //         Refresh();
            //     }
            // }
        }

        private void SetHold_Click(object sender, RoutedEventArgs e)
        {
            if (MessageBox.Show(
                    "Are you sure you wish to set this packet on hold?",
                    "Set Hold",
                    MessageBoxButton.YesNo) != MessageBoxResult.Yes)
                return;
            UpdateFlag(sender, "OnHold", true);
        }

        private void ClearHold_Click(object sender, RoutedEventArgs e)
        {
            if (MessageBox.Show(
                    "Are you sure you wish to release this packet from hold?",
                    "Set Hold",
                    MessageBoxButton.YesNo) != MessageBoxResult.Yes)
                return;
            UpdateFlag(sender, "OnHold", false);
        }

        private void SetDistributed_Click(object sender, RoutedEventArgs e)
        {
            UpdateFlag(sender, "Distributed", true);
        }

        private void ClearDistributed_Click(object sender, RoutedEventArgs e)
        {
            UpdateFlag(sender, "Distributed", false);
        }

        private void SetShared_Click(object sender, RoutedEventArgs e)
        {
            var updates = new List<ManufacturingPacketStage>();
            var rows = (sender as MenuItem).Tag as IEnumerable<CoreRow>;
            foreach (var row in rows)
            {
                var stage = row.ToObject<ManufacturingPacketStage>();
                if (stage.Station > 0)
                {
                    stage.Station = -1;
                    updates.Add(stage);
                }
            }

            if (updates.Any())
                using (new WaitCursor())
                {
                    new Client<ManufacturingPacketStage>().Save(updates, "Set Packet as Shared");
                    Refresh();
                }
        }

        private void ClearShared_Click(object sender, RoutedEventArgs e)
        {
            var updates = new List<ManufacturingPacketStage>();
            var rows = (sender as MenuItem).Tag as IEnumerable<CoreRow>;
            foreach (var row in rows)
            {
                var stage = row.ToObject<ManufacturingPacketStage>();
                if (stage.Station == -1)
                {
                    stage.Station = CurrentStation;
                    updates.Add(stage);
                }
            }

            if (updates.Any())
                using (new WaitCursor())
                {
                    new Client<ManufacturingPacketStage>().Save(updates, "Cleared Shared flag from Packet");
                    Refresh();
                }
        }

        private void MovePacketClick(object sender, RoutedEventArgs e)
        {
            var item = sender as MenuItem;
            var station = (item.Parent as MenuItem).Items.IndexOf(item) + 1;


            var updates = new List<ManufacturingPacketStage>();
            var rows = (sender as MenuItem).Tag as IEnumerable<CoreRow>;
            foreach (var row in rows)
            {
                var stage = row.ToObject<ManufacturingPacketStage>();
                stage.Station = station;
                updates.Add(stage);
            }

            if (updates.Any())
                using (new WaitCursor())
                {
                    new Client<ManufacturingPacketStage>().Save(updates, "Moved Packet to " + item.Header);
                    Refresh();
                }
        }

        public void PDFEditorSettingsChanged(object sender, string linecolor, int fontsize)
        {
            _settings.LineColor = linecolor;
            _settings.FontSize = fontsize;
            new LocalConfiguration<FactoryFloorLocalSettings>().Save(_settings);
        }

        #region ManufacturingPacket Stuff

        //FactorySetup settings = new GlobalConfiguration<FactorySetup>().Load();
        //private Dictionary<Guid, Tuple<String,int>> Sections = new Dictionary<Guid, Tuple<String,int>>();
        private ManufacturingFactory[] Factories; // new ManufacturingFactory[] { };
        private ManufacturingSection[] Sections; // new ManufacturingSection[] { };
        private ManufacturingTrolley[] Trolleys; // new ManufacturingTrolley[] { };

        private CoreTable TemplateStages;

        //private ManufacturingTemplateStage[] TemplateStages = null;

        private CoreTable Questions;

        //private IList<CoreRow> AllStages = new CoreRow[] { };
        private CoreTable Packets;
        private CoreTable Stages;

        /// <remarks>
        /// <see langword="null"/> if there are no <see cref="ManufacturingSection"/>s in the system.
        /// </remarks>
        private ManufacturingSection? CurrentSection;
        private int CurrentStation;
        private readonly bool PendingVisible = true;

        private ManufacturingLostTime LostTime;

        #endregion

        #region Stuff to Do with Kanbans

        public ObservableCollection<ManufacturingKanban> Kanbans { get; set; }

        private string CurrentKanbanID = "";

        private ManufacturingKanban CurrentKanban
        {
            get { return Kanbans.FirstOrDefault(x => x.ID == CurrentKanbanID); }
            set => CurrentKanbanID = value != null ? value.ID : "";
        }


        private string SearchFilter = "";

        //Border LastCard = null;

        //Border[] CheckedPackets
        //{
        //     get {
        //        List<Border> packets = new List<Border>();
        //        var cards = Kanban.Columns[0].Cards.Where(x => ((ManufacturingKanban)x.Content).Checked == true);
        //        foreach (var card in cards)
        //        {
        //            var prop = card.GetType().GetProperty("TemplateChild", BindingFlags.NonPublic | BindingFlags.Instance);
        //            var val = prop.GetValue(card) as DependencyObject;
        //            var border = FindVisualChildren<Border>(val).FirstOrDefault();
        //            packets.Add(border);
        //        }
        //        return packets.ToArray();                
        //    }
        //}

        private void ClearAllSelections()
        {
            foreach (var kanban in Kanbans.Where(x => x.Checked))
                kanban.Checked = false;
            CurrentKanban = null;

            //var cards = Kanban.Columns[0].Cards.Where(x => ((ManufacturingKanban)x.Content).Checked == true).ToArray();
            //foreach (var card in cards)
            //    ((ManufacturingKanban)card.Content).Checked = false;
            //CurrentKanban = null;
            UpdateSelectedKanban();
        }

        private ManufacturingKanban GetKanban(Border border)
        {
            return border.Tag as ManufacturingKanban;
        }

        //private Border GetBorder(ManufacturingKanban kanban)
        //{
        //    var card = Kanban.Columns[0].Cards.FirstOrDefault(x => ((ManufacturingKanban)x.Content) == kanban);
        //    var prop = card.GetType().GetProperty("TemplateChild", BindingFlags.NonPublic | BindingFlags.Instance);
        //    var val = prop.GetValue(card) as DependencyObject;
        //    return FindVisualChildren<Border>(val).FirstOrDefault();
        //}

        //private void CheckKanban(Border card, bool ischecked)
        //{
        //    var chk = card.FindName("IsChecked") as CheckBox;
        //    chk.IsChecked = ischecked;
        //    card.ApplyTemplate();
        //}

        private void SelectKanban(Border card, bool isselected)
        {
            var img = card.FindName("IsCurrent") as Image;
            img.Source = isselected ? starred : null;
        }

        private ManufacturingPacket KanbanToPacket(ManufacturingKanban kanban)
        {
            if (Packets == null)
                return null;

            var row = Packets.Rows.FirstOrDefault(r => r.Get<ManufacturingPacket, Guid>(c => c.ID).Equals(Guid.Parse(kanban.ID)));
            if (row == null)
                return null;

            return row.ToObject<ManufacturingPacket>();
        }

        #endregion

        #region Shipping Rack Stuff

        private CoreTable Shipments;
        private CoreTable DeliveryItems;
        private readonly ObservableList<DeliveryItem> rackcontents = new();
        private Guid rackid = Guid.Empty;
        private string rackbarcode = "";

        #endregion

        #region Refresh / Reload

        private string GetQualityStatus(QualityStatus status)
        {
            if (status == QualityStatus.Passed)
                return "PASSED";
            if (status == QualityStatus.Skipped)
                return "SKIPPED";
            if (status == QualityStatus.PassedWithIssues)
                return "ISSUES";
            if (status == QualityStatus.Failed)
                return "FAILED";
            return "QA";
        }

        private BitmapImage GetBarCode(CoreRow row)
        {
            var type = row.Get<ManufacturingPacket, BarcodeType>(c => c.BarcodeType);
            if (!row.Get<ManufacturingPacket, DateTime>(c => c.BarcodePrinted).IsEmpty())
                return type == BarcodeType.Grouped ? grouped : barcode;
            if (type == BarcodeType.None)
                return disabled;
            return null;
        }

        private void CreateKanban(CoreRow pktrow, CoreRow stagerow, bool IsChecked)
        {
            var id = pktrow.Get<ManufacturingPacket, Guid>(c => c.ID);

            //var stagerow = Stages.Rows.FirstOrDefault(r=>r.Get<ManufacturingPacketStage,Guid>(c=>c.Parent.ID).Equals(id));
            if (stagerow == null)
                return;

            var station = stagerow.Get<ManufacturingPacketStage, int>(c => c.Station);
            //var stage = stagerow.ToObject<ManufacturingPacketStage>();

            if ((PendingVisible && station.Equals(0)) || station.Equals(-1) || station.Equals(CurrentStation))
            {
                var model = new ManufacturingKanban();
                LoadModel(model, pktrow, stagerow, IsChecked);
                Kanbans.Add(model);
            }
        }

        private void LoadModel(ManufacturingKanban model, CoreRow packet, CoreRow stage, bool IsChecked)
        {
            var station = stage.Get<ManufacturingPacketStage, int>(c => c.Station);
            var Pending = station == 0;
            var quality = stage.Get<ManufacturingPacketStage, QualityStatus>(c => c.QualityStatus);
            var percentage = stage.Get<ManufacturingPacketStage, double>(c => c.PercentageComplete);

            var packetid = packet.Get<ManufacturingPacket, Guid>(c => c.ID);
            var title = packet.Get<ManufacturingPacket, string>(c => c.Title);
            var watermark = packet.Get<ManufacturingPacket, string>(c => c.WaterMark);
            var issues = packet.Get<ManufacturingPacket, string>(c => c.Issues);
            var trolleys = packet.Get<ManufacturingPacket, string>(c => c.Trolleys);
            var serial = packet.Get<ManufacturingPacket, string>(c => c.Serial);
            var quantity = packet.Get<ManufacturingPacket, int>(c => c.Quantity);
            var barcodes = packet.Get<ManufacturingPacket, int>(c => c.BarcodeQty);
            var setoutnumber = packet.Get<ManufacturingPacket, string>(c => c.SetoutLink.Number);
            var jobname = packet.Get<ManufacturingPacket, string>(c => c.SetoutLink.JobLink.Name);
            var duedate = packet.Get<ManufacturingPacket, DateTime>(c => c.DueDate);
            var location = packet.Get<ManufacturingPacket, string>(c => c.Location);
            var setoutlocation = packet.Get<ManufacturingPacket, string>(c => c.SetoutLink.Location);
            var suppliercode = packet.Get<ManufacturingPacket, string>(c => c.OrderItem.PurchaseOrderLink.SupplierLink.Code);
            var ponumber = packet.Get<ManufacturingPacket, string>(c => c.OrderItem.PurchaseOrderLink.PONumber);
            var receiveddate = packet.Get<ManufacturingPacket, DateTime>(c => c.OrderItem.ReceivedDate);
            var receivedreference = packet.Get<ManufacturingPacket, string>(c => c.OrderItem.ReceivedReference);
            var priority = packet.Get<ManufacturingPacket, bool>(c => c.Priority);
            var estimateddate = packet.Get<ManufacturingPacket, DateTime>(c => c.EstimatedDate);
            var distributed = packet.Get<ManufacturingPacket, bool>(c => c.Distributed);
            var packetsection = packet.Get<ManufacturingPacket, string>(c => c.StageLink.Section);
            var groupid = packet.Get<ManufacturingPacket, Guid>(c => c.SetoutLink.Group.ID);
            var groupname = packet.Get<ManufacturingPacket, string>(c => c.SetoutLink.Group.Name);

            model.TemplateID = packet.Get<ManufacturingPacket, Guid>(c => c.ManufacturingTemplateLink.ID);

            model.ID = packetid.ToString();
            model.Title = string.Format(
                "{0}: {1}{2}",
                serial,
                quantity != barcodes ? string.Format("{0} x ", quantity) : "",
                title
            );
            if (!string.IsNullOrWhiteSpace(watermark))
                model.Title = "[" + watermark + "] " + model.Title;
            model.Quantity = barcodes;
            model.JobName = string.Format("{0}: {1}", setoutnumber, jobname);
            model.DueDate = duedate;
            model.GroupID = groupid;

            var descrip = new List<string>
            {
                string.IsNullOrEmpty(location) ? setoutlocation : location
            };

            if (packet.IsEntityLinkValid<ManufacturingPacket, PurchaseOrderItemLink>(x => x.OrderItem))
                descrip.Add(string.Format("{0} ({1}) RCVD {2:dd MMM yy} {3}",
                    suppliercode,
                    ponumber,
                    receiveddate,
                    string.IsNullOrWhiteSpace(receivedreference) ? "" : ": " + receivedreference
                ));
            model.Description = string.Join("\n", descrip);

            model.Image = GetBarCode(packet);
            //model.IsCurrent = packet.ID.ToString() == CurrentKanbanID ? starred : null;
            model.IsSelected = packet.Get<ManufacturingPacket, Guid>(c => c.ID).ToString() == CurrentKanbanID;
            model.Tags = priority
                ? new[] { "PRIORITY" }
                : new string[] { };
            model.Category = CurrentSection != null
                ? CurrentSection.ID.ToString()
                : ""; // packet.StageLink.SectionID.ToString();

            model.ColorKey = packet.IsEntityLinkValid<ManufacturingPacket, PurchaseOrderItemLink>(x => x.OrderItem)
                ? TREATED_COLOR
                : priority
                    ? PRIORITY_COLOR
                    : !Pending
                        ? GetColor(duedate.IsEmpty()
                            ? DateTime.Today
                            : duedate, estimateddate.IsEmpty()
                            ? DateTime.Today
                            : estimateddate)
                        : QA_COLOR;

            model.SelectedColor = packet.Get<ManufacturingPacket, Guid>(c => c.ID).ToString() == CurrentKanbanID
                ? SELECTED_COLOR
                : model.ColorKey;
            model.SharedColor = station.Equals(-1)
                ? SHARED_COLOR
                : model.ColorKey;
            model.Checked = IsChecked;
            model.SetoutID = packet.Get<ManufacturingPacket, Guid>(c => c.SetoutLink.ID);
            model.Assignee = Pending
                ? "Not Yet Started"
                : "Current Workload";
            model.Status = !Entity.IsEntityLinkValid<ManufacturingPacket, ManufacturingPacketStageLink>(x => x.StageLink, packet)
                ? " "
                : Pending
                    ? "PENDING"
                    : string.Format("{0:F0}%", percentage);
            try
            {
                model.Flags = distributed
                    ? !packet.Get<ManufacturingPacket, Guid>(c => c.StageLink.SectionID).Equals(CurrentSection.ID)
                        ? string.IsNullOrEmpty(packetsection)
                            ? ""
                            : packetsection.ToUpper().Trim()
                        : "DISTRIB"
                    : "";
            }
            catch (Exception e)
            {
                Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
            }

            model.Issues = issues;
            model.IssuesImage = string.IsNullOrWhiteSpace(issues)
                ? null
                : speechbubble;

            model.Trolleys = trolleys;

            
        }

        private string GetColor(DateTime duedate, DateTime estdate)
        {
            var color = NOTYETDUE_COLOR;
            if (duedate < estdate)
                color = OVERDUE_COLOR;
            else if (duedate < estdate.AddDays(7))
                color = NEARLYDUE_COLOR;
            return color;
        }

        private void ReloadPackets(bool reloaddata)
        {
            using var profiler = new Profiler(true);
            using (new WaitCursor())
            {
                if (reloaddata)
                {
                    var sectionid = CurrentSection != null ? CurrentSection.ID : CoreUtils.FullGuid;

                    var stageflt = new Filter<ManufacturingPacketStage>(x => x.Completed).IsEqualTo(DateTime.MinValue)
                        .Or(x => x.ManufacturingSectionLink.ID).IsEqualTo(CurrentSection.ID);
                    stageflt.Ands.Add(
                        new Filter<ManufacturingPacketStage>(x => x.Parent.StageLink.SectionID).IsEqualTo(sectionid)
                            .Or(x => x.Parent.Distributed).IsEqualTo(true)
                    );

                    var stageQuery = new KeyedQueryDef<ManufacturingPacketStage>(
                        stageflt,
                        new Columns<ManufacturingPacketStage>(x => x.ID)
                            .Add(x => x.Parent.ID)
                            .Add(x => x.Station)
                            .Add(x => x.QualityStatus)
                            .Add(x => x.PercentageComplete)
                            .Add(x => x.Time)
                            .Add(x => x.Started)
                            .Add(x => x.FormData)
                            .Add(x => x.Completed)
                            .Add(x => x.FormCompleted)
                            .Add(x => x.FormCompletedBy.ID)
                            .Add(x => x.Sequence)
                            .Add(x => x.QualityNotes)
                            .Add(x => x.SectionID)
                            .Add(x => x.ManufacturingSectionLink.ID));

                    var pktfilter = new Filter<ManufacturingPacket>(x => x.Completed).IsEqualTo(DateTime.MinValue)
                        .And(x => x.Archived).IsEqualTo(DateTime.MinValue)
                        .And(x => x.OnHold).IsEqualTo(false)
                        .And(new Filter<ManufacturingPacket>(x => x.OrderItem).NotLinkValid().Or(x => x.OrderItem.ReceivedDate)
                            .IsNotEqualTo(DateTime.MinValue))
                        .And(new Filter<ManufacturingPacket>(x => x.StageLink.SectionID).IsEqualTo(sectionid).Or(x => x.Distributed).IsEqualTo(true));

                    if (!string.IsNullOrWhiteSpace(SearchFilter))
                        pktfilter = pktfilter.TextSearch(
                            SearchFilter,
                            x => x.SetoutLink.JobLink.JobNumber,
                            x => x.SetoutLink.JobLink.Name,
                            x => x.SetoutLink.Number,
                            x => x.SetoutLink.Location,
                            //x => x.SetoutLink.Reference,
                            x => x.Title,
                            x => x.Serial,
                            x => x.Trolleys,
                            x => x.Location
                        );

                    var pktcolumns = new Columns<ManufacturingPacket>(x => x.ID)
                        .Add(x => x.Serial)
                        .Add(x => x.Title)
                        .Add(x => x.Quantity)
                        .Add(x => x.BarcodeQty)
                        .Add(x => x.SetoutLink.ID)
                        .Add(x => x.SetoutLink.Number)
                        .Add(x => x.SetoutLink.JobLink.ID)
                        .Add(x => x.SetoutLink.JobLink.JobNumber)
                        .Add(x => x.SetoutLink.JobLink.Name)
                        .Add(x => x.SetoutLink.Group.ID)
                        .Add(x => x.SetoutLink.Group.Name)
                        .Add(x => x.SetoutLink.Group.Job.JobNumber)
                        .Add(x => x.SetoutLink.Group.OptimizationDocument.ID)
                        .Add(x => x.DueDate)
                        .Add(x => x.SetoutLink.Location)
                        //.Add(x => x.SetoutLink.Reference)
                        .Add(x => x.Priority)
                        .Add(x => x.EstimatedDate)
                        .Add(x => x.Distributed)
                        .Add(x => x.StageLink.ID)
                        .Add(x => x.StageLink.SectionID)
                        .Add(x => x.StageLink.Section)
                        .Add(x => x.StageLink.Deleted)
                        .Add(x => x.BarcodePrinted)
                        .Add(x => x.BarcodeType)
                        .Add(x => x.ManufacturingTemplateLink.ID)
                        .Add(x => x.ManufacturingTemplateLink.Name)
                        .Add(x => x.ManufacturingTemplateLink.Code)
                        //.Add(x => x.CustomAttributes)
                        .Add(x => x.Trolleys)
                        .Add(x => x.Location)
                        .Add(x => x.Group)
                        .Add(x => x.Height)
                        .Add(x => x.Width)
                        .Add(x => x.Length)
                        .Add(x => x.OrderItem.ID)
                        .Add(x => x.OrderItem.Deleted)
                        .Add(x => x.OrderItem.PurchaseOrderLink.SupplierLink.Code)
                        .Add(x => x.OrderItem.PurchaseOrderLink.PONumber)
                        .Add(x => x.OrderItem.Consignment.EstimatedWarehouseArrival)
                        .Add(x => x.OrderItem.ReceivedReference)
                        //.Add(x => x.Zone.Code)
                        //.Add(x => x.Level.Code)
                        .Add(x => x.OrderItem.ReceivedDate)
                        .Add(x => x.WaterMark)
                        .Add(x => x.Issues)
                        .Add(x => x.OnHold)
                        .Add(DatabaseSchema.Properties(typeof(ManufacturingPacket))
                            .Where(x => x is CustomProperty)
                            .Select(x => x.Name).ToArray()
                        );

                    var pktQuery = new KeyedQueryDef<ManufacturingPacket>(
                        pktfilter,
                        pktcolumns,
                        new SortOrder<ManufacturingPacket>(x => x.Priority, SortDirection.Descending)
                            .ThenBy(x => x.SetoutLink.Number));

                    var results = Client.QueryMultiple(
                        stageQuery,
                        pktQuery,
                        new KeyedQueryDef<DeliveryItem>(
                            new Filter<DeliveryItem>(x => x.DeliveredDate).IsEqualTo(DateTime.MinValue)
                                .And(x => x.ManufacturingPacketLink).LinkValid(),
                            new Columns<DeliveryItem>(
                                x => x.ID,
                                x => x.Barcode,
                                x => x.ManufacturingPacketLink.ID,
                                x => x.ManufacturingPacketLink.Serial,
                                x => x.Description,
                                x => x.ShipmentLink.ID)));

                    Stages = results.Get<ManufacturingPacketStage>();
                    Packets = results.Get<ManufacturingPacket>();
                    DeliveryItems = results.Get<DeliveryItem>();
                }

                var checks = Kanbans.Where(x => x.Checked).Select(x => x.ID).ToArray();
                Kanbans.Clear();

                var stages = Stages.Rows
                    .Select(x => new Tuple<Guid, Guid>(
                        x.Get<ManufacturingPacketStage, Guid>(x => x.Parent.ID),
                        x.Get<ManufacturingPacketStage, Guid>(x => x.ManufacturingSectionLink.ID)
                        )).ToList();
                foreach (var pktrow in Packets.Rows)
                {
                    var id = pktrow.Get<ManufacturingPacket, Guid>(c => c.ID);
                    var distributed = pktrow.Get<ManufacturingPacket, bool>(c => c.Distributed);

                    var stageIndex = stages.FindIndex(x => x.Item1 == id && x.Item2 == _settings.Section);
                    var stageRow = stageIndex >= 0 ? Stages.Rows[stageIndex] : null;

                    //this was commented out previously - leading to the distributed packet issue. Uncommented and tested to work by Nick. Was there a reason for commenting this out?
                    bool bOK = true;
                    if (distributed)
                        bOK = stageRow?.Get<ManufacturingPacketStage, DateTime>(c => c.Completed).IsEmpty() == true;

                    if (bOK)
                    {
                        CreateKanban(pktrow, stageRow!, checks.Contains(id.ToString()));
                    }
                }

                var sorted = Kanbans.OrderBy(x => x.Assignee).ThenByDescending(x => x.Tags.Length).ThenBy(x => x.DueDate).ThenBy(x => x.JobName);

                if (CurrentKanban != null && !Kanbans.Contains(CurrentKanban))
                    CurrentKanban = sorted.FirstOrDefault();

                Kanban.ItemsSource = null;
                Kanban.ItemsSource =
                    sorted; //Kanbans.OrderBy(x => x.Assignee).ThenByDescending(x => x.Tags.Length).ThenBy(x => x.DueDate).ThenBy(x => x.JobName);

                UpdateSelectedKanban();
            }
        }

        private void DoRefresh(bool reloaddata)
        {
            if (!IsReady || Sections == null || !Sections.Any())
                return;

            ReloadPackets(reloaddata);

            //LoadKanban();
        }

        public void Refresh()
        {
            DoRefresh(true);
        }

        #endregion


        #region QAChecks

        private IEnumerable<QAQuestion> LoadQAQuestions(ManufacturingPacket packet, bool section, bool template)
        {
            if (Questions == null)
                Questions = new Client<QAQuestion>().Query();

            if (TemplateStages == null)
                TemplateStages = new Client<ManufacturingTemplateStage>().Query();
            var tstage = TemplateStages.Rows.FirstOrDefault(r =>
                r.Get<ManufacturingTemplateStage, Guid>(c => c.Template.ID).Equals(packet.ManufacturingTemplateLink.ID) &&
                r.Get<ManufacturingTemplateStage, Guid>(c => c.Section.ID).Equals(CurrentSection.ID));

            if (tstage == null)
                return null;

            IEnumerable<CoreRow> rows = null;
            if (section && !template)
                rows = Questions.Rows.Where(r => r.Get<QAQuestion, Guid>(c => c.QAForm.ID).Equals(CurrentSection.QAForm.ID));
            if (!section && template)
                rows = Questions.Rows.Where(r =>
                    r.Get<QAQuestion, Guid>(c => c.QAForm.ID).Equals(tstage.Get<ManufacturingTemplateStage, Guid>(x => x.QAForm.ID)));
            if (section && template)
                rows = Questions.Rows.Where(r =>
                    r.Get<QAQuestion, Guid>(c => c.QAForm.ID).Equals(CurrentSection.QAForm.ID) || r.Get<QAQuestion, Guid>(c => c.QAForm.ID)
                        .Equals(tstage.Get<ManufacturingTemplateStage, Guid>(x => x.QAForm.ID)));
            var result = rows.Where(r => r.Get<QAQuestion, bool>(c => c.QAForm.Active).Equals(true)).Select(r => r.ToObject<QAQuestion>());
            return result;
        }

        private void ViewQualityChecks(object sender, RoutedEventArgs e)
        {
            SetCurrentButton(sender as Button);
            LoadDrawing(Guid.Empty);
        }

        private void QAGridChanged(object sender, Dictionary<Guid, object> values)
        {
            SaveQAData(values);
        }

        private void SaveQAData(Dictionary<Guid, object> values)
        {
            var updates = new List<ManufacturingPacketStage>();
            var cks = Kanbans.Where(x => x.Checked);
            foreach (var ck in cks)
            {
                //var row = Packets.Rows.FirstOrDefault(r => r.Get<ManufacturingPacket, Guid>(c => c.ID).Equals(ck.ID));
                var stagerow = Stages.Rows.FirstOrDefault(r => r.Get<ManufacturingPacketStage, Guid>(c => c.Parent.ID).Equals(Guid.Parse(ck.ID))
                                                               && r.Get<ManufacturingPacketStage, Guid>(c => c.ManufacturingSectionLink.ID)
                                                                   .Equals(_settings.Section));
                if (stagerow != null)
                {
                    var stage = stagerow.ToObject<ManufacturingPacketStage>();
                    stage.Form.ID = CurrentSection.QAForm.ID;
                    stage.FormData = Serialization.Serialize(values);
                    stagerow.Set<ManufacturingPacketStage, string>(x => x.FormData, stage.FormData);
                    updates.Add(stage);
                }
            }

            if (updates.Any())
                Task.Run(() => { new Client<ManufacturingPacketStage>().Save(updates, "", (o, e) => { }); });
        }

        #endregion

        private void RequestMaterials_Click(object sender, RoutedEventArgs e)
        {
            var updates = new List<ManufacturingPacket>();
            var rows = (sender as MenuItem)!.Tag as IEnumerable<CoreRow>;
            ManufacturingPanelColumn.CreatePickingList(rows!.Select(x => x.ToObject<ManufacturingPacket>()).ToList(), true,
                () => new GlobalConfiguration<ManufacturingPanelProperties>().Load());
        }

        private void _selectPackArea_OnClick(object sender, RoutedEventArgs e)
        {
            var dlg = new MultiSelectDialog<StockArea>(
                new Filter<StockArea>(x => x.Active).IsEqualTo(true),
                new Columns<StockArea>(x => x.ID).Add(x => x.Warehouse.Code).Add(x => x.Code).Add(x => x.Description),
                false);
            if (dlg.ShowDialog("Select Area"))
            {
                _settings.AreaID = dlg.IDs().First();
                var area = dlg.Items().First();
                new LocalConfiguration<FactoryFloorLocalSettings>().Save(_settings);
                _areaDescription.Text = $"{area.Code}";
                _packGrid.Area = area;
                _packGrid.Refresh(false,true);
            }
        }

        private void _addPack_OnClick(object sender, RoutedEventArgs e)
        {
            var dlg = new MultiSelectDialog<StockLocation>(
                new Filter<StockLocation>(x => x.Area.ID).IsNotEqualTo(_settings.AreaID),
                new Columns<StockLocation>(x => x.ID).Add(x => x.Warehouse.Code).Add(x => x.Area.Code).Add(x => x.Code).Add(x => x.Description),
                false);
            if (dlg.ShowDialog("Select Location"))
            {
                var location = dlg.Items().FirstOrDefault();
                if (location != null)
                {
                    location.Area.ID = _settings.AreaID;
                    new Client<StockLocation>().Save(location,$"Moved To Manufacturing ({_packGrid.Area?.Code})");
                    _packGrid.Refresh(false,true);
                }
            }
        }

        private string _packFilter = "";

        private void _packSearch_OnTextChanged(object sender, TextChangedEventArgs e)
        {
            _packGrid.Refresh(false, false);
        }

        private bool _packGrid_OnOnFilterRecord(CoreRow row)
        {
            var result = true;
            
            if (_packLinked.IsChecked == true)
            {
                Guid jobid = row.Get<StockHolding, Guid>(x => x.Job.ID);
                if (_packGrid.CurrentPacket != null)
                    result = jobid == Guid.Empty || jobid == _packGrid.CurrentPacket.SetoutLink.JobLink.ID;
            }

            result = result && (String.IsNullOrWhiteSpace(_packSearch.Text)
                 || row.Get<StockHolding, String>(x => x.Product.Code).ToUpper().Contains(_packSearch.Text.ToUpper())
                 || row.Get<StockHolding, String>(x => x.Product.Name).ToUpper().Contains(_packSearch.Text.ToUpper())
                 || row.Get<StockHolding, String>(x => x.Location.Code).ToUpper().Contains(_packSearch.Text.ToUpper())
                 || row.Get<StockHolding, String>(x => x.Style.Code).ToUpper().Contains(_packSearch.Text.ToUpper())
                 || row.Get<StockHolding, String>(x => x.Style.Description).ToUpper()
                     .Contains(_packSearch.Text.ToUpper())
                 || row.Get<StockHolding, String>(x => x.Dimensions.UnitSize).ToUpper()
                     .Contains(_packSearch.Text.ToUpper())
                 || row.Get<StockHolding, String>(x => x.Job.JobNumber).ToUpper().Contains(_packSearch.Text.ToUpper())
                 || row.Get<StockHolding, String>(x => x.Job.Name).ToUpper().Contains(_packSearch.Text.ToUpper()));
            
            return result;

        }

        private void _packLinked_OnChecked(object sender, RoutedEventArgs e)
        {
            _packGrid?.Refresh(false, false);
        }


        private void _returnPack_OnClick(object sender, RoutedEventArgs e)
        {
            ContextMenu _menu = new ContextMenu();
            var dict = _packGrid.Data
                .ToDictionary<StockHolding, Guid, String>(
                    x => x.Location.ID,
                    (row) =>
                        $"{row.Get<StockHolding, String>(c => c.Location.Code)}: {row.Get<StockHolding, String>(c => c.Location.Description)}"
                );
            if (!dict.Any())
                return;
            foreach (var key in dict.Keys)
            {
                MenuItem item = new MenuItem() { Header = dict[key], DataContext = key };
                item.Click += (o, args) =>
                {
                    var dlg = new MultiSelectDialog<StockArea>(
                        new Filter<StockArea>(x => x.Active).IsEqualTo(true).And(x => x.ID).IsNotEqualTo(_settings.AreaID),
                        new Columns<StockArea>(x => x.ID).Add(x => x.Warehouse.Code).Add(x => x.Code)
                            .Add(x => x.Description),
                        false);
                    if (dlg.ShowDialog("Select Area"))
                    {
                        var location = new StockLocation() { ID = key };
                        location.CommitChanges();
                        location.Area.ID = dlg.IDs().First();
                        new Client<StockLocation>().Save(location,
                            $"Returned From Manufacturing ({_packGrid.Area?.Code})");
                        _packGrid.Refresh(false, true);
                    }
                };
                _menu.Items.Add(item);
            }
            _menu.IsOpen = true;
        }

        private void _replaceStock_OnClick(object sender, RoutedEventArgs e)
        {
            _packGrid.ReplaceStock();
        }

        private void _packGrid_OnOnSelectItem(object sender, DynamicGridSelectionEventArgs e)
        {
            _replaceStock.IsEnabled = e.Rows?.Any() == true;
        }
    }
}