prs/prs.desktop/Panels/Manufacturing/ManufacturingPanelColumn.xaml.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Input;
using System.Windows.Media.Imaging;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.Reports;
using InABox.Core.Reports;
using InABox.Wpf.Reports;
using InABox.WPF;
using InABox.Scripting;
using System.Threading;

namespace PRSDesktop
{
    [ValueConversion(typeof(DateTime), typeof(Visibility))]
    public class DateTimeToVisibilityConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            var dateTime = (DateTime)value;
            if (dateTime.IsEmpty())
                return Visibility.Collapsed;
            return Visibility.Visible;
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }

    public class TemplateViewModel
    {
        public Guid TemplateID { get; set; }
        public string Name { get; set; }
        public string Time { get; set; }
        public TemplateViewModel()
        {
            TemplateID = Guid.Empty;
            Name = "";
            Time = "";
        }
    }

    public delegate void CollapsingEventHandler(object sender, bool collapsed);

    /// <summary>
    ///     Interaction logic for ManufacturingPanelColumn.xaml
    /// </summary>
    public partial class ManufacturingPanelColumn : UserControl, IManufacturingPanelColumn
    {
        private static readonly BitmapImage barcode = PRSDesktop.Resources.barcode.AsBitmapImage();
        private static readonly BitmapImage disabled = PRSDesktop.Resources.disabled.AsBitmapImage();
        private static readonly BitmapImage speechbubble = PRSDesktop.Resources.speechbubble.AsBitmapImage();

        private bool _collapsed;

        private bool _compactview;

        private DynamicDataGrid<ManufacturingPacket>? pg;

        //public List<String> CheckedKanbans = new List<string>();

        public ManufacturingPanelColumn()
        {
            InitializeComponent();
            LoadTemplates();
        }

        private void LoadTemplates()
        {
            Task.Run(() =>
            {
                CoreTable table = new Client<ManufacturingTemplateStage>().Query(null,
                    new Columns<ManufacturingTemplateStage>
                    (
                        x => x.Template.ID,
                        x => x.Section.Name,
                        x => x.Time
                    )
                );
                foreach (CoreRow row in table.Rows)
                {
                    TemplateViewModel model = new TemplateViewModel
                    {
                        TemplateID = row.Get<ManufacturingTemplateStage, Guid>(x => x.Template.ID),
                        Name = row.Get<ManufacturingTemplateStage, string>(x => x.Section.Name),
                        Time = row.Get<ManufacturingTemplateStage, TimeSpan>(x => x.Time).ToString()
                    };
                    templateStages.Add(model);
                }
            });
        }

        public string Title
        {
            get => (string)ColumnTitle.Content;
            set
            {
                ColumnTitle.Content = value;
                HiddenTitle.Content = value;
            }
        }

        public bool CompactView
        {
            get => _compactview;
            set
            {
                _compactview = value;
                Items.ItemTemplate = _compactview
                    ? Resources["CompactManufacturingPanel"] as DataTemplate
                    : Resources["FullManufacturingPanel"] as DataTemplate;
            }
        }

        public bool Collapsed
        {
            get => _collapsed;
            set
            {
                _collapsed = value;
                ColumnGrid.ColumnDefinitions[0].Width = value ? new GridLength(0, GridUnitType.Pixel) : new GridLength(1, GridUnitType.Star);
                ColumnGrid.ColumnDefinitions[1].Width = value ? new GridLength(1, GridUnitType.Auto) : new GridLength(0, GridUnitType.Pixel);
                MinWidth = _collapsed ? 35.0F : 300.0F;
                OnCollapsed?.Invoke(this, value);
            }
        }

        public Guid Category { get; set; }


        public ManufacturingKanban[] Kanbans
        {
            get => (ManufacturingKanban[])Items.ItemsSource;
            set
            {
                Items.ItemsSource = value;
                ItemCount.Content = string.Format("{0} Items", value.Length);
                HiddenCount.Content = string.Format(" ({0} items)", value.Length);
                Task.Run(() =>
                {
                    try
                    {
                        var time = CalcTime(value);
                        Dispatcher.Invoke(() => { TimeRequired.Content = string.Format("Time Required: {0:F2} hrs", time); });
                    }
                    catch (Exception e)
                    {
                        Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
                    }
                });
                Collapsed = value.Length == 0;
            }
        }

        public ManufacturingPanelData Data { get; set; }

        public List<ManufacturingPacket> Packets { get; set; }

        private List<TemplateViewModel> templateStages = new List<TemplateViewModel>();

        private ManufacturingTemplateStage[] TemplateStages { get; set; }

        private double CalcTime(IEnumerable<ManufacturingKanban> kanbans)
        {
            return Kanbans.Sum(x => x.Time.TotalHours * ((100.0F - x.PercentageComplete) / 100.0F));
        }

        public event EventHandler OnChanged;
        public event CollapsingEventHandler OnCollapsed;

        private static string GetColor(DateTime duedate, DateTime estdate)
        {
            var color = "LightGreen";
            if (duedate < estdate)
                color = "Salmon";
            else if (duedate < estdate.AddDays(7))
                color = "LightYellow";
            return color;
        }

        public void SetPackets(IEnumerable<ManufacturingPacket> packets)
        {
            var checkedKanbans = GetSelectedKanbans("").Select(x => x.ID).ToList();

            var kanbans = new List<ManufacturingKanban>();
            Packets = packets.ToList();
            foreach (var packet in Packets)
            {
                var bOK = true;

                var completed = packet.Completed;

                var onhold = packet.OnHold;
                var issues = packet.Issues;

                var orderitemid = packet.OrderItem.ID;
                var orderitem = orderitemid != Guid.Empty ? Data.OrderItems.FirstOrDefault(x => x.Item1.Equals(orderitemid)) : null;

                var itp = packet.ITP.ID;

                var jobid = packet.SetoutLink.JobLink.ID;

                var sectionid = packet.StageLink.SectionID;

                var title = packet.Title;
                var serial = packet.Serial;
                var watermark = packet.WaterMark;
                var location = packet.Location;

                var setoutlocation = packet.SetoutLink.Location;
                var setoutnumber = packet.SetoutLink.Number;
                var setoutdescription = packet.SetoutLink.Description;

                var templateid = packet.ManufacturingTemplateLink.ID;
                var templatecode = Data.Templates.FirstOrDefault(x => x.ID.Equals(templateid))?.Code;

                var groupid = packet.SetoutLink.Group.ID;
                var groupname = packet.SetoutLink.Group.Name;
                groupname = !string.IsNullOrWhiteSpace(groupname) ? packet.SetoutLink.Group.Job.JobNumber + ": " + groupname
                    : "";

                if (bOK)
                {
                    var id = packet.ID;
                    var priority = packet.Priority;
                    var distributed = packet.Distributed;

                    var barcodeqty = packet.BarcodeQty;
                    var quantity = packet.Quantity;
                    var estimateddate = packet.EstimatedDate;
                    var created = packet.Created;
                    var duedate = packet.DueDate;
                    var barcodeprinted = packet.BarcodePrinted;
                    var barcodetype = packet.BarcodeType;

                    var stageid = packet.StageLink.ID;
                    var stageValid = packet.StageLink.IsValid();
                    var station = packet.StageLink.Station;
                    var time = packet.StageLink.Time;
                    var percentagecomplete = packet.StageLink.PercentageComplete;

                    var jobrow = Data.Jobs.Rows.FirstOrDefault(r => r.Get<Job, Guid>(c => c.ID).Equals(jobid));
                    var jobname = jobrow?.Get<Job, string>(c => c.Name);
                    var jobnumber = jobrow?.Get<Job, string>(c => c.JobNumber);

                    var model = new ManufacturingKanban();

                    var flags = new List<string>();
                    if (onhold)
                        flags.Add("HOLD");
                    if (priority)
                        flags.Add("PRIORITY");
                    if (distributed)
                        flags.Add("DISTRIB");


                    model.ID = id.ToString();

                    var sTitle = string.Format("{0}{1}", quantity != barcodeqty ? string.Format("{0} x ", quantity) : "",
                        packet.Title);

                    model.Title = CompactView
                        ? string.Format("{0} x {1} / {2} {3}",
                            barcodeqty,
                            setoutnumber,
                            serial,
                            sTitle
                        )
                        : string.Format("{0}: {1}",
                            serial,
                            sTitle
                        );

                    if (!string.IsNullOrWhiteSpace(watermark))
                        model.Title = "[" + watermark + "] " + model.Title;

                    model.Quantity = barcodeqty;

                    model.JobName = string.Format("{0}: {1}", setoutnumber, jobname);

                    model.CreatedDate = created;

                    model.DueDate = duedate;

                    model.Time = time;
                    model.PercentageComplete = percentagecomplete;

                    if (string.IsNullOrEmpty(location))
                        location = setoutlocation;

                    var descrip = new List<string>
                    {
                        location
                    };

                    if (orderitem != null)
                        descrip.Add(orderitem.Item3);

                    model.Description = string.Join("\n", descrip);

                    model.TemplateID = packet.ManufacturingTemplateLink.ID;

                    model.Image = !barcodeprinted.IsEmpty() ? barcode : barcodetype == BarcodeType.None ? disabled : null;
                    model.Tags = Array.Empty<string>();
                    model.Category = completed != DateTime.MinValue ? CoreUtils.FullGuid : sectionid;

                    if (priority)
                        model.ColorKey = "Red";
                    else if (onhold)
                        model.ColorKey = "Silver";
                    else
                        model.ColorKey = GetColor(
                            duedate.IsEmpty() ? DateTime.Today : duedate,
                            estimateddate.IsEmpty() ? DateTime.Today : estimateddate
                        );
                    model.IssuesImage = string.IsNullOrWhiteSpace(issues)
                        ? null
                        : speechbubble;
                    model.Issues = issues;

                    if (orderitem != null)
                    {
                        var bOnOrder = orderitem.Item2.IsEmpty();
                        model.OrderColor = bOnOrder ? "Plum" : "DarkOrchid";
                        model.OrderStatus = bOnOrder ? "ON ORDER" : "RECEIVED";
                    }
                    else
                    {
                        model.OrderColor = model.ColorKey;
                        model.OrderStatus = "";
                    }

                    model.Checked = checkedKanbans.Contains(id.ToString());

                    model.Flags = string.Join("\n", flags);

                    model.Template = templatecode;

                    model.GroupID = groupid;
                    model.GroupName = groupname;


                    if (!stageValid || stageid.Equals(Guid.Empty) || stageid.Equals(CoreUtils.FullGuid))
                    {
                        model.Status = "";
                    }
                    else
                    {
                        if (station == 0)
                            model.Status = "Not Started";
                        else
                            model.Status = string.Format("{0} ({1:F0}%)", station == -1 ? "Shared" : "Stn " + station, percentagecomplete);
                    }

                    kanbans.Add(model);
                }
            }

            Kanbans = kanbans.ToArray();
        }

        public void ClearSelectedKanbans()
        {
            var kanbans = GetSelectedKanbans(Guid.Empty.ToString());
            foreach (var kanban in kanbans)
                kanban.Checked = false;
            var tmp = Kanbans;
            Items.ItemsSource = null;
            Items.ItemsSource = tmp;
        }

        public ManufacturingKanban[] GetSelectedKanbans(string currentid)
        {
            return Kanbans != null ? Kanbans.Where(x => x.Checked || x.ID.Equals(currentid)).ToArray() : new ManufacturingKanban[] { };
        }

        public IEnumerable<ManufacturingPacket> GetPackets() => Packets;

        public IEnumerable<ManufacturingPacket> GetSelectedPackets() => GetSelectedPackets(Guid.Empty.ToString());

        public IEnumerable<ManufacturingPacket> GetSelectedPackets(string currentid)
        {
            var selectedkanbans = GetSelectedKanbans(currentid);
            return Packets.Where(pkt => selectedkanbans.Any(x => x.ID.Equals(pkt.ID.ToString())));
        }

        private void Border_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            if (e.ClickCount == 2)
            {
                var model = ((Border)sender).Tag as ManufacturingKanban;
                var packet = Packets.Where(r => r.ID.ToString().Equals(model.ID)).FirstOrDefault();

                var setoutid = packet.SetoutLink.ID;
                var table = new Client<SetoutDocument>().Query(
                    new Filter<SetoutDocument>(x => x.EntityLink.ID).IsEqualTo(setoutid)
                );
                SetoutDocument[] docs = table.Rows.Select(r => r.ToObject<SetoutDocument>()).ToArray();

                // If this document is actually the cutting group document, 
                // redirect any annotations to the cutting group id rather than the setout
                var sgdoc = docs.FirstOrDefault(x => x.EntityLink.Group.ID == packet.SetoutLink.Group.ID);
                if (sgdoc != null)
                    sgdoc.ID = packet.SetoutLink.Group.ID;
                
                var viewer = new DocumentEditor(docs);
                viewer.ButtonsVisible = true;
                //viewer.PrintAllowed = Security.IsAllowed<CanPrintFactoryFloorDrawings>();
                viewer.SaveAllowed = Security.IsAllowed<CanSaveFactoryFloorDrawings>();
                viewer.Watermark = packet.WaterMark;
                viewer.ShowDialog();

                e.Handled = true;
            }
        }

        private void CheckBox_Checked(object sender, RoutedEventArgs e)
        {
            //ManufacturingKanban task = ((CheckBox)sender).Tag as ManufacturingKanban;
            //if (CheckedKanbans.Contains(task.ID))
            //    CheckedKanbans.Remove(task.ID);
            //else
            //    CheckedKanbans.Add(task.ID);
        }

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

            var createPickingList = menu.Items[2] as MenuItem;
            var issue = menu.Items[3] as MenuItem;
            var issuegroup = menu.Items[4] as MenuItem;
            var progress = menu.Items[5] as MenuItem;
            var split = menu.Items[6] as MenuItem;
            var revert = menu.Items[7] as MenuItem;
            var progress_separator = menu.Items[8] as Separator;

            var cancel = menu.Items[9] as MenuItem;
            var cancel_separator = menu.Items[10] as Separator;
            var bHasCancel = false;

            var complete = menu.Items[11] as MenuItem;
            var complete_separator = menu.Items[12] as Separator;
            var bHasComplete = false;

            var template = menu.Items[13] as MenuItem;
            var template_separator = menu.Items[14] as Separator;
            var bHasTemplate = true;

            var changedate = menu.Items[15] as MenuItem;
            var changedate_separator = menu.Items[16] as Separator;

            var setpriority = menu.Items[17] as MenuItem;
            var clearpriority = menu.Items[18] as MenuItem;
            var priority_separator = menu.Items[19] as Separator;

            var editissues = menu.Items[20] as MenuItem;
            var sethold = menu.Items[21] as MenuItem;
            var clearhold = menu.Items[22] as MenuItem;
            var hold_separator = menu.Items[23] as Separator;

            var generate = menu.Items[24] as MenuItem;
            var reprint = menu.Items[25] as MenuItem;
            var revoke = menu.Items[26] as MenuItem;
            var barcode_separator = menu.Items[27] as Separator;
            var bHasBarcode = false;

            var archive = menu.Items[28] as MenuItem;
            var bHasArchive = false;

            var model = menu.Tag as ManufacturingKanban;

            var packets = GetSelectedPackets(model.ID).ToList();
            var current = packets.FirstOrDefault(x => x.ID.Equals(Guid.Parse(model.ID)));

            //CoreRow row = packets.Rows.Where(r => r.Get<ManufacturingPacket, Guid>(c => c.ID).ToString().Equals(model.ID)).FirstOrDefault();

            var OnlyOne = packets.Count == 1; // (!CheckedKanbans.Any()) || (CheckedKanbans.Count == 1) && (CheckedKanbans.Contains(model.ID));

            var pktid = current != null ? current.ID : Guid.Empty; // row.Get<ManufacturingPacket, Guid>(x => x.ID);
            var stageid = current != null ? current.StageLink.ID : Guid.Empty; // row.Get<ManufacturingPacket, Guid>(x => x.StageLink.ID);
            var stageValid = current?.StageLink.IsValid() ?? false;
            var completed = current != null ? current.Completed : DateTime.MinValue; //row.Get<ManufacturingPacket, DateTime>(x => x.Completed);
            var printed = current != null
                ? current.BarcodePrinted
                : DateTime.MinValue; // row.Get<ManufacturingPacket, DateTime>(x => x.BarcodePrinted);
            var priority = current != null ? current.Priority : false; // row.Get<ManufacturingPacket, bool>(x => x.Priority);
            //bool onhold = current != null ? current.OnHold : false; // row.Get<ManufacturingPacket, bool>(x => x.OnHold);
            var onhold = current?.OnHold == true; // row.Get<ManufacturingPacket, bool>(x => x.OnHold);
            var qty = current != null ? current.Quantity : 0; //row.Get<ManufacturingPacket, int>(x => x.Quantity);
            var barcodetype =
                current != null ? current.BarcodeType : BarcodeType.None; // row.Get<ManufacturingPacket, BarcodeType>(x => x.BarcodeType);

            issue.Visibility = !stageValid && Security.IsAllowed<CanIssuePackets>() ? Visibility.Visible : Visibility.Collapsed;
            createPickingList.Visibility = !stageValid && Security.IsAllowed<CanIssuePackets>() ? Visibility.Visible : Visibility.Collapsed;
            issuegroup.Visibility = !stageValid && Security.IsAllowed<CanIssuePackets>() ? Visibility.Visible : Visibility.Collapsed;
            progress.Visibility = stageid.Equals(CoreUtils.FullGuid) || !stageValid ? Visibility.Collapsed : Visibility.Visible;
            split.Visibility = !stageValid && qty > 1 && printed.IsEmpty() && OnlyOne ? Visibility.Visible : Visibility.Collapsed;
            revert.Visibility = !stageValid && completed.Equals(DateTime.MinValue) ? Visibility.Collapsed : Visibility.Visible;

            cancel.Visibility = !stageValid ? Visibility.Visible : Visibility.Collapsed;
            bHasCancel = cancel.Visibility == Visibility.Visible;

            complete.Visibility = stageid.Equals(CoreUtils.FullGuid) ? Visibility.Collapsed : Visibility.Visible;
            bHasComplete = complete.Visibility == Visibility.Visible;

            template.Visibility = !stageValid ? Visibility.Visible : Visibility.Collapsed;
            template.Items.Clear();
            var menus = new Dictionary<string, MenuItem>();
            foreach (var Factory in Data.Factories)
            {
                if (!menus.ContainsKey(Factory.Name))
                {
                    menus[Factory.Name] = new MenuItem { Header = Factory.Name };
                    template.Items.Add(menus[Factory.Name]);
                }

                var group = menus[Factory.Name];
                foreach (var temp in Data.Templates.Where(x => x.Factory.ID == Factory.ID).OrderBy(x => x.Code))
                {
                    var item = new MenuItem
                    {
                        Header = string.Format("{0}: {1}", temp.Code, temp.Name),
                        Tag = new Tuple<Guid, ManufacturingTemplate>(pktid, temp)
                    };
                    item.Click += ChangeTemplateClick;
                    group.Items.Add(item);
                }
            }

            bHasTemplate = template.Visibility == Visibility.Visible;

            changedate.Visibility = stageid.Equals(CoreUtils.FullGuid) || !stageValid ? Visibility.Collapsed : Visibility.Visible;
            changedate_separator.Visibility = changedate.Visibility;

            setpriority.Visibility = priority ? Visibility.Collapsed : Visibility.Visible;
            clearpriority.Visibility = priority ? Visibility.Visible : Visibility.Collapsed;

            editissues.Visibility = Visibility.Visible;
            sethold.Visibility = Security.IsAllowed<CanManagePacketHolds>() && !onhold ? Visibility.Visible : Visibility.Collapsed;
            clearhold.Visibility = Security.IsAllowed<CanManagePacketHolds>() && onhold ? Visibility.Visible : Visibility.Collapsed;

            generate.Visibility = printed.IsEmpty() && barcodetype != BarcodeType.None ? Visibility.Visible : Visibility.Collapsed;
            reprint.Visibility = !printed.IsEmpty() ? Visibility.Visible : Visibility.Collapsed;
            revoke.Visibility = !printed.IsEmpty() ? Visibility.Visible : Visibility.Collapsed;
            bHasBarcode = generate.Visibility == Visibility.Visible || reprint.Visibility == Visibility.Visible ||
                          revoke.Visibility == Visibility.Visible;

            archive.Visibility = !printed.IsEmpty() ? Visibility.Visible : Visibility.Collapsed;
            bHasArchive = archive.Visibility == Visibility.Visible;

            progress_separator.Visibility = bHasCancel || bHasTemplate || bHasBarcode || bHasArchive ? Visibility.Visible : Visibility.Collapsed;
            cancel_separator.Visibility = bHasCancel && (bHasComplete || bHasTemplate || bHasBarcode || bHasArchive)
                ? Visibility.Visible
                : Visibility.Collapsed;
            complete_separator.Visibility = bHasComplete && (bHasTemplate || bHasBarcode || bHasArchive) ? Visibility.Visible : Visibility.Collapsed;
            template_separator.Visibility = bHasTemplate && (bHasBarcode || bHasArchive) ? Visibility.Visible : Visibility.Collapsed;
            hold_separator.Visibility = bHasBarcode || bHasArchive ? Visibility.Visible : Visibility.Collapsed;
            barcode_separator.Visibility = bHasBarcode && bHasArchive ? Visibility.Visible : Visibility.Collapsed;
        }

        private void ChangeTemplateClick(object sender, RoutedEventArgs e)
        {
            var menu = (MenuItem)sender;

            var binding = (Tuple<Guid, ManufacturingTemplate>)menu.Tag;
            var template = binding.Item2;

            if (TemplateStages == null)
                TemplateStages = new Client<ManufacturingTemplateStage>().Load(null, new SortOrder<ManufacturingTemplateStage>(x => x.Sequence));

            var templatestages = TemplateStages.Where(x => x.Template.ID.Equals(template.ID));

            var packets = GetSelectedPackets(binding.Item1.ToString());

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

            Progress.Show("Loading Packet Stages");


            Filter<ManufacturingPacketStage> stgflt = null;
            Filter<ManufacturingPacket> pktflt = null;

            foreach (var packet in packets)
            {
                stgflt = stgflt == null
                    ? new Filter<ManufacturingPacketStage>(x => x.Parent.ID).IsEqualTo(packet.ID)
                    : stgflt.Or(x => x.Parent.ID).IsEqualTo(packet.ID);
                pktflt = pktflt == null ? new Filter<ManufacturingPacket>(x => x.ID).IsEqualTo(packet.ID) : pktflt.Or(x => x.ID).IsEqualTo(packet.ID);
            }

            var packetstages = new Client<ManufacturingPacketStage>().Load(stgflt).ToList();
            foreach (var packetstage in packetstages)
                new Client<ManufacturingPacketStage>().Delete(packetstage, "");

            packetstages.Clear();

            var pkts = new Client<ManufacturingPacket>().Load(pktflt);
            foreach (var packet in pkts)
            {
                packet.ManufacturingTemplateLink.ID = template.ID;
                packet.ManufacturingTemplateLink.Code = template.Code;
                packet.Group = template.Factory.Name;

                var attributes = new Dictionary<string, string>();

                //if (packet.CustomAttributes == null)
                //    packet.CustomAttributes = new PackableList<CoreAttribute>();

                //foreach (var attribute in packet.CustomAttributes)
                //    attributes[attribute.Name] = attribute.Value;
                //packet.CustomAttributes.Clear();

                //if (template.CustomAttributes != null)
                //    packet.CustomAttributes.AddRange(template.CustomAttributes);

                //foreach (var attribute in packet.CustomAttributes)
                //{
                //    if (attributes.ContainsKey(attribute.Name))
                //        attribute.Value = attributes[attribute.Name];
                //}

                packet.StageLink.ID = Guid.Empty;


                foreach (var templatestage in templatestages)
                {
                    var packetstage = new ManufacturingPacketStage
                    {
                        Time = templatestage.Time,
                        Sequence = templatestage.Sequence,
                        SequenceType = templatestage.SequenceType,
                        Started = DateTime.MinValue,
                        PercentageComplete = 0.0F,
                        Completed = DateTime.MinValue,
                        QualityChecks = templatestage.QualityChecks,
                        QualityStatus = QualityStatus.NotChecked,
                        QualityNotes = ""
                    };

                    packetstage.ManufacturingSectionLink.ID = templatestage.Section.ID;
                    packetstage.ManufacturingSectionLink.Name = templatestage.Section.Name;
                    packetstage.Parent.ID = packet.ID;
                    packetstages.Add(packetstage);
                }
            }

            if (packetstages.Any())
            {
                Progress.SetMessage("Updating Packets");
                new Client<ManufacturingPacket>().Save(pkts, "Packet Template changed by User");
                new Client<ManufacturingPacketStage>().Save(packetstages, "Packet Template changed by User");
                OnChanged?.Invoke(this, new EventArgs());
            }

            Progress.Close();
        }

        private void ViewSetout_Click(object sender, RoutedEventArgs e)
        {
            var item = (MenuItem)sender;
            var model = (ManufacturingKanban)item.Tag;
            var pkt = Packets.Where(r => r.ID.ToString().Equals(model.ID)).FirstOrDefault();

            if (pkt == null)
            {
                MessageBox.Show("Cannot find selected Manufacturing Packet!");
                return;
            }

            var id = pkt.ID;

            pg ??= new DynamicDataGrid<ManufacturingPacket>();

            ManufacturingPacket? editPacket = null;
            using (new WaitCursor())
            {
                var columns = pg.LoadEditorColumns();

                editPacket = new Client<ManufacturingPacket>()
                    .Query(
                        new Filter<ManufacturingPacket>(x => x.ID).IsEqualTo(id),
                        columns)
                    .Rows.FirstOrDefault()?.ToObject<ManufacturingPacket>();
            }

            if (editPacket == null)
            {
                MessageBox.Show("Unable to load packet from database");
                return;
            }

            if (pg.EditItems(new[] { editPacket }))
                OnChanged?.Invoke(this, new EventArgs());
        }

        private void IssueSetout_Click(object sender, RoutedEventArgs e)
        {
            var item = (MenuItem)sender;
            var model = (ManufacturingKanban)item.Tag;

            var date = model.DueDate.IsEmpty() ? DateTime.Today.AddDays(14) : model.DueDate;
            if (DateEdit.Execute("Required Completion Date", ref date))
                ProgressPacket(model, date, Guid.Empty);
        }

        private List<RequisitionItem>? CustomisePickingList(Requisition requisition, List<RequisitionItem> items)
        {
            var script = Data.Properties.PickingListOptimisationScript;
            if (!script.IsNullOrWhiteSpace())
            {
                var scriptDocument = new ScriptDocument(script);
                if (!scriptDocument.Compile())
                {
                    throw new Exception("Script failed to compile!");
                }

                var method = scriptDocument.GetMethod(methodName: ManufacturingPanelProperties.PickingListOptimisationMethodName())
                    ?? throw new Exception($"Script has no method {ManufacturingPanelProperties.PickingListOptimisationMethodName()}()!");
                var result = (method.Invoke(scriptDocument.GetObject(), new object?[] { requisition, items }) as List<RequisitionItem>)!;
                return result;
            }
            return items;
        }

        private void CreatePickingList_Click(object sender, RoutedEventArgs e)
        {
            var item = (MenuItem)sender;
            var model = (ManufacturingKanban)item.Tag;

            var pkts = GetSelectedPackets(model.ID).ToList();
            if(pkts.Count == 0)
            {
                MessageBox.Show("Cannot create picking list: no packets selected.");
                return;
            }

            var jobs = pkts.Select(x => x.SetoutLink.JobLink.ID).Distinct().ToArray();
            if(jobs.Length > 1)
            {
                MessageBox.Show("Cannot create picking list: packets from more than one job are selected.");
                return;
            }
            var jobID = jobs.First();

            var components =
                Client.Query(
                    new Filter<ManufacturingPacketComponent>(x => x.Packet.ID).InList(pkts.Select(x => x.ID).ToArray())
                        .And(x => x.Requisition.ID).IsEqualTo(Guid.Empty),
                    new Columns<ManufacturingPacketComponent>()
                        .Add(x => x.ID)
                        .Add(x => x.Description)
                        .Add(x => x.Packet.ID)
                        .Add(x => x.Product.ID)
                        .Add(x => x.Product.Code)
                        .Add(x => x.Product.DefaultStyle.ID)
                        .Add(x => x.Product.DefaultStyle.Code)
                        .Add(x => x.Product.DefaultStyle.Description)
                        .Add(x => x.Product.DefaultLocation.ID)
                        .Add(x => x.Product.DefaultLocation.Code)
                        .Add(x => x.Product.DefaultLocation.Description)
                        .Add(x => x.Quantity)
                        .Add(x => x.Dimensions.Unit.ID)
                        .Add(x => x.Dimensions.Quantity)
                        .Add(x => x.Dimensions.Length)
                        .Add(x => x.Dimensions.Width)
                        .Add(x => x.Dimensions.Height)
                        .Add(x => x.Dimensions.Weight)
                        .Add(x => x.Dimensions.UnitSize))
                .ToObjects<ManufacturingPacketComponent>().ToList();
            if (components.Count == 0)
            {
                MessageBox.Show("No items to create picking list; all selected components already have requisitions.");
                return;
            }

            var requisitionItems = new List<RequisitionItem>();
            foreach(var component in components)
            {
                var packet = pkts.Find(x => x.ID == component.Packet.ID);
                if(packet is null)
                {
                    continue;
                }
                var requisitionItem = new RequisitionItem
                {
                    Quantity = component.Quantity,
                    Description = component.Description
                };
                requisitionItem.Job.ID = jobID;
                requisitionItem.Product.ID = component.Product.ID;
                requisitionItem.Product.Synchronise(component.Product);
                requisitionItem.Style.Synchronise(component.Product.DefaultStyle);
                requisitionItem.Location.Synchronise(component.Product.DefaultLocation);
                requisitionItem.Dimensions.CopyFrom(component.Dimensions);

                requisitionItems.Add(requisitionItem);
            }

            var requisition = new Requisition
            {
                Title = $"Materials for {string.Join(',', pkts.Select(x => x.Serial))}"
            };
            requisition.Notes = new[] { requisition.Title };
            requisition.RequestedBy.ID = App.EmployeeID;
            requisition.JobLink.ID = jobID;
            requisition.Due = DateTime.Now;

            try
            {
                requisitionItems = CustomisePickingList(requisition, requisitionItems);
                if (requisitionItems is null)
                {
                    MessageBox.Show("Creating picking list cancelled.");
                    return;
                }

                var grid = DynamicGridUtils.CreateDynamicGrid(typeof(DynamicGrid<>), typeof(Requisition));
                if (grid.EditItems(new Requisition[] { requisition }, t =>
                {
                    if (t == typeof(RequisitionItem))
                    {
                        var table = new CoreTable();
                        table.LoadColumns(typeof(RequisitionItem));
                        table.LoadRows(requisitionItems);
                        return table;
                    }
                    return null;
                }))
                {
                    foreach (var component in components)
                    {
                        component.Requisition.ID = requisition.ID;
                    }
                    new Client<ManufacturingPacketComponent>().Save(components, $"Created picking list for requisition {requisition.Number}.");
                    MessageBox.Show($"Created requisition {requisition.Number}");
                }
            }
            catch(Exception err)
            {
                MessageBox.Show($"Error: {err.Message}");
            }
        }

        private void IssueGroup_Click(object sender, RoutedEventArgs e)
        {
            var item = (MenuItem)sender;
            var model = (ManufacturingKanban)item.Tag;

            var date = model.DueDate.IsEmpty() ? DateTime.Today.AddDays(14) : model.DueDate;
            if (DateEdit.Execute("Required Completion Date", ref date))
                ProgressPacket(model, date, model.GroupID);
        }

        private void ProgressSetout_Click(object sender, RoutedEventArgs e)
        {
            var item = (MenuItem)sender;
            var model = (ManufacturingKanban)item.Tag;
            ProgressPacket(model, null, Guid.Empty);
        }

        private void ProgressPacket(ManufacturingKanban model, DateTime? date, Guid groupID)
        {
            Progress.Show("");
            var pkts = groupID == Guid.Empty ? 
                GetSelectedPackets(model.ID).ToList() 
                : GetPacketsOfGroup(groupID);

            if (pkts.Count == 0)
                return;

            Progress.SetMessage("Loading Stages");
            Filter<ManufacturingPacketStage>? stgflt = null;
            foreach (var pkt in pkts)
                stgflt = stgflt == null
                    ? new Filter<ManufacturingPacketStage>(x => x.Parent.ID).IsEqualTo(pkt.ID)
                    : stgflt.Or(x => x.Parent.ID).IsEqualTo(pkt.ID);
            var stgs = new Client<ManufacturingPacketStage>().Load(stgflt, new SortOrder<ManufacturingPacketStage>(x => x.Sequence));

            ManufacturingPacket.Progress(pkts, stgs);

            Progress.SetMessage("Progressing Items");
            var stgupdate = stgs.Where(x => x.IsChanged()).ToArray();
            Logger.Send(LogType.Information, ClientFactory.UserID,
                string.Format("ManufacturingPanelColumn.ProgressPacket() - Updating [{0}] stages", stgupdate.Length));

            new Client<ManufacturingPacketStage>().Save(stgupdate, "ManufacturingPacket Progressed by Menu Click");

            var pktupdate = pkts; //.Where(x => x.IsChanged()).ToArray();
            if (date.HasValue)
                foreach (var pkt in pktupdate)
                    pkt.DueDate = date.Value;
            Logger.Send(LogType.Information, ClientFactory.UserID,
                string.Format("ManufacturingPanelColumn.ProgressPacket() - Updating [{0}] packets: {1}", pktupdate.Count,
                    string.Join(", ", pktupdate.Select(x => x.Serial))));
            new Client<ManufacturingPacket>().Save(pktupdate, "ManufacturingPacket Progressed by Menu Click");

            Progress.Close();

            ClearSelectedKanbans();
            //CheckedKanbans.Clear();

            OnChanged?.Invoke(this, new EventArgs());
        }

        private List<ManufacturingPacket> GetPacketsOfGroup(Guid groupID)
        {
            return Packets.Where(x => x.SetoutLink.Group.ID == groupID).ToList();
        }

        private void SplitSetout_Click(object sender, RoutedEventArgs e)
        {
            var item = (MenuItem)sender;
            var model = (ManufacturingKanban)item.Tag;

            var pkts = GetSelectedPackets(model.ID).ToList();
            if (pkts.Count != 1)
            {
                MessageBox.Show("You can only split one Packet at a time!");
                return;
            }
            var pkt = pkts.First();


            var packets = new List<ManufacturingPacket> { pkt };
            var Quantity = 1;
            if (NumberEdit.Execute("Quantity to Issue", 1, pkt.Quantity, ref Quantity))
            {
                if (Quantity != pkt.Quantity)
                {
                    var packet2 = CoreUtils.Clone(pkt, null);
                    packet2.ID = Guid.Empty;
                    packet2.Quantity = Quantity;
                    pkt.Quantity -= Quantity;
                    packets.Add(packet2);
                }

                new Client<ManufacturingPacket>().Save(packets, "Split Manufacturing Packet");

                var stages = new Client<ManufacturingPacketStage>().Load(
                    new Filter<ManufacturingPacketStage>(x => x.Parent.ID).IsEqualTo(pkt.ID));
                foreach (var stage in stages)
                {
                    stage.ID = Guid.Empty;
                    stage.Parent.ID = pkt.ID;
                }

                new Client<ManufacturingPacketStage>().Save(stages, "");

                OnChanged?.Invoke(this, new EventArgs());
            }
        }

        private void RevertSetout_Click(object sender, RoutedEventArgs e)
        {
            var item = (MenuItem)sender;
            var model = (ManufacturingKanban)item.Tag;
            Progress.Show("");
            var pkts = GetSelectedPackets(model.ID).ToList();

            Filter<ManufacturingPacketStage>? stgflt = null;
            foreach (var pkt in pkts)
                stgflt = stgflt == null
                    ? new Filter<ManufacturingPacketStage>(x => x.Parent.ID).IsEqualTo(pkt.ID)
                    : stgflt.Or(x => x.Parent.ID).IsEqualTo(pkt.ID);
            var stgs = new Client<ManufacturingPacketStage>().Load(stgflt, new SortOrder<ManufacturingPacketStage>(x => x.Sequence));

            ManufacturingPacket.Regress(pkts, stgs);

            Progress.SetMessage("Regressing Items");
            new Client<ManufacturingPacketStage>().Save(stgs.Where(x => x.IsChanged()), "ManufacturingPacket Regressed by Menu Click");
            new Client<ManufacturingPacket>().Save(pkts.Where(x => x.IsChanged()), "ManufacturingPacket Regressed by Menu Click");

            ClearSelectedKanbans();
            //CheckedKanbans.Clear();

            Progress.Close();
            OnChanged?.Invoke(this, new EventArgs());
        }

        private void CancelSetout_Click(object sender, RoutedEventArgs e)
        {
            if (MessageBox.Show(
                    "This will cancel the selected packet (and any associated barcodes) and remove it from view.\n\nAre you sure you wish to continue?",
                    "Confirm packet cancellation", MessageBoxButton.YesNo).Equals(MessageBoxResult.Yes))
            {
                var item = (MenuItem)sender;
                var model = (ManufacturingKanban)item.Tag;
                Progress.Show("");
                var pkts = GetSelectedPackets(model.ID);
                var updates = new List<ManufacturingPacket>();
                foreach (var packet in pkts)
                {
                    packet.BarcodePrinted = DateTime.MinValue;
                    packet.Archived = DateTime.Now;
                    updates.Add(packet);
                }

                Progress.SetMessage("Archiving Packets");
                new Client<ManufacturingPacket>().Save(updates, "ManufacturingPacket Cancelled by Menu Click");
                ClearSelectedKanbans();
                //CheckedKanbans.Clear();

                Progress.Close();
                OnChanged?.Invoke(this, new EventArgs());
            }
        }

        private void CompeteItem_Click(object sender, RoutedEventArgs e)
        {
            var item = (MenuItem)sender;
            var model = (ManufacturingKanban)item.Tag;
            Progress.Show("");
            var pkts = GetSelectedPackets(model.ID);

            Progress.SetMessage("Loading Stages");
            Filter<ManufacturingPacketStage>? stgflt = null;
            foreach (var pkt in pkts)
                stgflt = stgflt == null
                    ? new Filter<ManufacturingPacketStage>(x => x.Parent.ID).IsEqualTo(pkt.ID)
                    : stgflt.Or(x => x.Parent.ID).IsEqualTo(pkt.ID);
            var stgs = new Client<ManufacturingPacketStage>().Query(
                stgflt,
                new Columns<ManufacturingPacketStage>(x => x.ID)
                    .Add(x => x.Parent.ID)
                    .Add(x => x.Sequence),
                new SortOrder<ManufacturingPacketStage>(x => x.Sequence)
            ).Rows.Select(x => x.ToObject<ManufacturingPacketStage>()).ToArray();

            while (pkts.Any(x => x.Completed.IsEmpty())) ManufacturingPacket.Progress(pkts, stgs);

            Progress.SetMessage("Progressing Items");
            new Client<ManufacturingPacketStage>().Save(stgs.Where(x => x.IsChanged()), "ManufacturingPacket Marked as Complete");
            new Client<ManufacturingPacket>().Save(pkts.Where(x => x.IsChanged()), "ManufacturingPacket Marked as Complete");
            Progress.Close();

            ClearSelectedKanbans();
            //CheckedKanbans.Clear();
            OnChanged?.Invoke(this, new EventArgs());
        }

        private void ChangeDate_Click(object sender, RoutedEventArgs e)
        {
            var item = (MenuItem)sender;
            var model = (ManufacturingKanban)item.Tag;
            var pkts = GetSelectedPackets(model.ID);

            DateTime? date = null;
            foreach (var pkt in pkts)
                if (!date.HasValue)
                    date = pkt.DueDate;
                else if (!date.Value.Equals(pkt.DueDate))
                    date = date > pkt.DueDate ? date : pkt.DueDate;
            var date2 = date ?? DateTime.Today.AddDays(14) ;
            if (DateEdit.Execute("Required Completion Date", ref date2))
            {
                Progress.SetMessage("Updating Packets");
                foreach (var pkt in pkts)
                    pkt.DueDate = date2;
                new Client<ManufacturingPacket>().Save(pkts, string.Format("Changed Due Date To {0:dd MMM yy}", date2));
                ClearSelectedKanbans();
                //CheckedKanbans.Clear();

                Progress.Close();
                OnChanged?.Invoke(this, new EventArgs());
            }
        }

        private void UpdatePriority(object sender, bool priority)
        {
            var item = (MenuItem)sender;
            var model = (ManufacturingKanban)item.Tag;
            Progress.Show("");
            var pkts = GetSelectedPackets(model.ID).ToList();
            foreach(var packet in pkts)
            {
                packet.Priority = priority;
            }

            Logger.Send(LogType.Information, ClientFactory.UserID,
                string.Format("ManufacturingPanelColumn.UpdatePriority() - Updating [{0}] packets: {1}", pkts.Count,
                    string.Join(", ", pkts.Select(x => x.Serial))));

            Progress.SetMessage("Updating Packets");
            new Client<ManufacturingPacket>().Save(pkts, "Priority Flag " + (priority ? "Set" : "Cleared"));

            ClearSelectedKanbans();
            //CheckedKanbans.Clear();

            Progress.Close();
            OnChanged?.Invoke(this, new EventArgs());
        }

        private void SetPriority_Click(object sender, RoutedEventArgs e)
        {
            UpdatePriority(sender, true);
        }

        private void ClearPriority_Click(object sender, RoutedEventArgs e)
        {
            UpdatePriority(sender, false);
        }

        private void UpdateHold(object sender, bool hold)
        {
            var item = (MenuItem)sender;
            var model = (ManufacturingKanban)item.Tag;

            if (MessageBox.Show(
                    hold
                        ? "Are you sure you want to place a hold on this packet?"
                        : "Are you sure you want to release this packet from hold?",
                    hold
                        ? "Confirm Hold"
                        : "Confirm Release",
                    MessageBoxButton.YesNo,
                    MessageBoxImage.Question
                ) != MessageBoxResult.Yes
               )
                return;

            Progress.ShowModal("Updating Hold Flags", (Action<IProgress<string>>)(progress =>
            {
                var pkts = GetSelectedPackets(model.ID).Select(x =>
                {
                    x.OnHold = hold;
                    return x;
                });
                progress.Report("Updating Packets");
                new Client<ManufacturingPacket>().Save(pkts, "Hold Flag " + (hold ? "Set" : "Cleared"));
            }));

            ClearSelectedKanbans();

            OnChanged?.Invoke(this, new EventArgs());
        }

        private void EditIssues_Click(object sender, RoutedEventArgs e)
        {
            var item = (MenuItem)sender;
            var model = (ManufacturingKanban)item.Tag;
            var pkts = GetSelectedPackets(model.ID).ToArray();
            if (new DynamicIssuesEditor(pkts, true).ShowDialog() == true)
            {
                Progress.ShowModal("Updating Issues", progress => { new Client<ManufacturingPacket>().Save(pkts, "Updated Issues"); });
                ClearSelectedKanbans();
                OnChanged?.Invoke(this, new EventArgs());
            }
        }


        private void SetHold_Click(object sender, RoutedEventArgs e)
        {
            UpdateHold(sender, true);
        }


        private void ClearHold_Click(object sender, RoutedEventArgs e)
        {
            UpdateHold(sender, false);
        }

        private void PrintBarcodes(IEnumerable<ManufacturingPacket> pkts)
        {
            //Filter<DeliveryItem> filter = null;
            //foreach (var pkt in pkts)
            //{
            //    if (filter == null)
            //        filter = new Filter<DeliveryItem>(x => x.ManufacturingPacketLink.ID).IsEqualTo(pkt.ID);
            //    else
            //        filter.Ors.Add(new Filter<DeliveryItem>(x => x.ManufacturingPacketLink.ID).IsEqualTo(pkt.ID));
            //}

            //Dictionary<Type, CoreTable> dataenvironment = new Dictionary<Type, CoreTable>();
            //Client<DeliveryItem> delclient = new Client<DeliveryItem>();
            //CoreTable items = delclient.Query(
            //    filter,
            //    null,
            //    //new Columns<DeliveryItem>(
            //    //    x => x.ID,
            //    //    x => x.Barcode,
            //    //    x => x.SetoutLink.Reference,
            //    //    x => x.SetoutLink.Location,
            //    //    x => x.SetoutLink.JobLink.JobNumber,
            //    //    x => x.SetoutLink.JobLink.Name,
            //    //    x => x.ManufacturingPacketLink.Serial,
            //    //    x => x.Description,
            //    //    x => x.Attributes
            //    //),
            //    new SortOrder<DeliveryItem>(x => x.Sequence)
            //);
            //dataenvironment[typeof(DeliveryItem)] = items;


            var ids = pkts.Select(x => x.ID).ToArray();
            var datamodel = new DeliveryItemDataModel(new Filter<DeliveryItem>(x => x.ManufacturingPacketLink.ID).InList(ids));


            var repclient = new Client<ReportTemplate>();
            var ReportName = "Print Bar Codes" + (!string.IsNullOrWhiteSpace(pkts.First().Group) ? " - " + pkts.First().Group : "");
            var report = repclient.Load(new Filter<ReportTemplate>(x => x.DataModel).IsEqualTo(datamodel.Name).And(x => x.Name).IsEqualTo(ReportName))
                .FirstOrDefault();
            if (report == null)
            {
                ReportName = "Print Bar Codes";
                report = repclient.Load(new Filter<ReportTemplate>(x => x.DataModel).IsEqualTo(datamodel.Name).And(x => x.Name).IsEqualTo(ReportName))
                    .FirstOrDefault();
            }

            if (report == null)
            {
                MessageBox.Show(string.Format("{0} -> [{1}] report does not exist!", datamodel.Name, ReportName));
                return;
            }

            ReportUtils.PreviewReport(report, datamodel, false, Security.IsAllowed<CanDesignReports>());
        }

        private void GenerateBarcodes_Click(object sender, RoutedEventArgs e)
        {
            var item = (MenuItem)sender;
            var model = (ManufacturingKanban)item.Tag;
            Progress.Show("");

            var pkts = GetSelectedPackets(model.ID).Where(x => x.BarcodePrinted.IsEmpty() && x.BarcodeType != BarcodeType.None).ToArray();

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


            Filter<ManufacturingPacket> pktflt = null;
            foreach (var packet in pkts)
                pktflt = pktflt == null ? new Filter<ManufacturingPacket>(x => x.ID).IsEqualTo(packet.ID) : pktflt.Or(x => x.ID).IsEqualTo(packet.ID);

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

            for (var i = 0; i < pkts.Length; i++)
            {
                var packet = pkts[i];
                packet.BarcodePrinted = DateTime.Now;
            }

            Progress.SetMessage("Creating Barcodes");
            Logger.Send(LogType.Information, ClientFactory.UserID,
                string.Format("ManufacturingPanelColumn.GenerateBarcodes() - Updating [{0}] packets: {1}", pkts.Length,
                    string.Join(", ", pkts.Select(x => x.Serial))));

            new Client<ManufacturingPacket>().Save(pkts, "Delivery Barcodes created");
            ClearSelectedKanbans();
            //CheckedKanbans.Clear();

            Progress.Close();
            PrintBarcodes(pkts);
            OnChanged?.Invoke(this, new EventArgs());
        }

        private void ReprintBarcodes_Click(object sender, RoutedEventArgs e)
        {
            var item = (MenuItem)sender;
            var model = (ManufacturingKanban)item.Tag;
            var pkts = GetSelectedPackets(model.ID);
            PrintBarcodes(pkts.Where(x => !x.BarcodePrinted.IsEmpty()));
        }

        private void RevokeBarcodes_Click(object sender, RoutedEventArgs e)
        {
            if (MessageBox.Show("This will clear out any delivery items already assigned to racks!\n\nAre you sure you wish to continue?",
                    "Confirm revocation", MessageBoxButton.YesNo).Equals(MessageBoxResult.Yes))
            {
                var item = (MenuItem)sender;
                var model = (ManufacturingKanban)item.Tag;
                Progress.Show("");
                var pkts = GetSelectedPackets(model.ID).Where(x => !x.BarcodePrinted.IsEmpty()).ToArray();
                for (var i = 0; i < pkts.Length; i++)
                {
                    Progress.SetMessage(string.Format("Revoking: {0:F2}% complete", (double)i * 100.0F / pkts.Length));
                    var packet = pkts[i];
                    packet.BarcodePrinted = DateTime.MinValue;
                }

                Progress.SetMessage("Revoking Barcodes");
                new Client<ManufacturingPacket>().Save(pkts, "Delivery Barcodes revoked");
                ClearSelectedKanbans();
                //CheckedKanbans.Clear();

                Progress.Close();
                OnChanged?.Invoke(this, new EventArgs());
            }
        }

        private void ArchiveSetout_Click(object sender, RoutedEventArgs e)
        {
            if (MessageBox.Show("This will remove the selected packet from view.\n\nAre you sure you wish to continue?", "Confirm item completion",
                    MessageBoxButton.YesNo).Equals(MessageBoxResult.Yes))
            {
                var item = (MenuItem)sender;
                var model = (ManufacturingKanban)item.Tag;
                Progress.Show("");

                var updates = new List<ManufacturingPacket>();
                foreach(var packet in GetSelectedPackets(model.ID))
                {
                    if (!packet.BarcodePrinted.IsEmpty())
                    {
                        //while (packet.Completed.IsEmpty())
                        //    packet.MoveNext();
                        packet.Archived = DateTime.Now;
                        updates.Add(packet);
                    }
                }

                Progress.SetMessage("Archiving Items");
                new Client<ManufacturingPacket>().Save(updates, "ManufacturingPacket Archived by Menu Click");
                ClearSelectedKanbans();
                //CheckedKanbans.Clear();

                Progress.Close();
                OnChanged?.Invoke(this, new EventArgs());
            }
        }

        private void SelectAll_Click(object sender, RoutedEventArgs e)
        {
            //CheckedKanbans.Clear();
            foreach (var kanban in Kanbans)
                kanban.Checked = true;
            var tmp = Kanbans;
            Items.ItemsSource = null;
            Items.ItemsSource = tmp;
        }

        private void ClearAll_Click(object sender, RoutedEventArgs e)
        {
            ClearSelectedKanbans();
            //CheckedKanbans.Clear();
            //foreach (var kanban in Kanbans)
            //{
            //    kanban.Checked = false;
            //    CheckedKanbans.Add(kanban.ID);
            //}
            var tmp = Kanbans;
            Items.ItemsSource = null;
            Items.ItemsSource = tmp;
        }

        private void ExpandColumn_Click(object sender, MouseButtonEventArgs e)
        {
            Collapsed = false;
        }

        private void CollapseColumn_Click(object sender, MouseButtonEventArgs e)
        {
            Collapsed = true;
        }
        private void Template_MouseEnter(object sender, MouseEventArgs e)
        {

        }
        private void Template_MouseLeave(object sender, MouseEventArgs e)
        {

        }

        private void ToolTip_Opened(object sender, RoutedEventArgs e)
        {
            if (sender.GetType().FullName.Equals(
                             "System.Windows.Controls.ToolTip"))
            {
                ToolTip t = (ToolTip)sender;
                Dispatcher.Invoke(() =>
                {
                    t.Content = new TextBlock { Text = "Loading..." };
                });

                ManufacturingKanban kanban = t.DataContext as ManufacturingKanban;
                Task.Run(() =>
                {
                    string s = "";
                    int count = 1;
                    var list = templateStages.Where(x => x.TemplateID == kanban.TemplateID);
                    foreach (var stage in list)
                    {
                        if (count > 1)
                            s = s + System.Environment.NewLine;
                        s = s + count + ". " + stage.Name + " (" + stage.Time + ")";
                        count++;
                    }

                    Dispatcher.Invoke(() =>
                    {
                        t.Content = new TextBlock { Text = s };
                    });
                });

            }
        }
    }
}