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

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
using Comal.Classes;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using Syncfusion.UI.Xaml.Kanban;

namespace PRSDesktop
{
    public partial class ManufacturingPanel : UserControl, IPanel<ManufacturingPacket>
    {
        private readonly List<ManufacturingPanelColumn> _columns = new();

        private readonly BitmapImage barcode = PRSDesktop.Resources.barcode.AsBitmapImage();

        private bool bIncludeCompleted;
        private bool bIncludeHeld;
        private bool bIncludeOrders;

        private readonly DispatcherTimer columnsizer = new();

        private bool CompactView;
        private bool ConsolidatedView;
        private Guid CurrentFactory = Guid.Empty;
        public KanbanModel CurrentKanban = null;
        private readonly BitmapImage disabled = PRSDesktop.Resources.disabled.AsBitmapImage();

        private ManufacturingFactory[] Factories = { };
        private Document[] FactoryImages = { };

        private int iCombo;
        private CoreTable ITPs;


        private bool JobChanging;
        private CoreTable Jobs;
        private readonly List<Tuple<Guid, DateTime, string>> OrderItems = new();
        private CoreTable packets;
        private ManufacturingSection[] Sections = { };

        private ManufacturingSettings settings = new();

        //ManufacturingTemplateStage[] TemplateStages = null; 

        private bool SortByDueDate = true;
        private readonly BitmapImage speechbubble = PRSDesktop.Resources.speechbubble.AsBitmapImage();
        private ManufacturingTemplate[] Templates = { };

        public ManufacturingPanel()
        {
            InitializeComponent();
            //columnsizer.Interval = new TimeSpan(0, 0, 0, 0, 500);
            //columnsizer.Tick += Columnsizer_Tick;
            //columnsizer.IsEnabled = true;
            IncludeCompleted.IsChecked = false;
        }

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

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

        public bool IsReady { get; set; }

        public Dictionary<string, object[]> Selected()
        {
            return new Dictionary<string, object[]> { { typeof(ManufacturingPacket).EntityName(), new CoreRow[] { } } };
        }

        public void Setup()
        {
            settings = new UserConfiguration<ManufacturingSettings>().Load();

            var FactorySource = new ObservableCollection<Tuple<string, BitmapImage, Guid>>();
            FactorySource.Add(new Tuple<string, BitmapImage, Guid>("All Sections", PRSDesktop.Resources.factory.AsBitmapImage(), Guid.Empty));

            var tables = ClientFactory.MultiQuery(
                new QueryDef<ManufacturingFactory>(null, null, null),
                new QueryDef<ManufacturingSection>(null, null, null),
                new QueryDef<ManufacturingTemplate>(null, null, null),
                new QueryDef<Job>(
                    LookupFactory.DefineFilter<Job>(),
                    new Columns<Job>(
                        x => x.ID,
                        x => x.JobNumber,
                        x => x.Name
                    ),
                    LookupFactory.DefineSort<Job>()
                ),
                new QueryDef<JobITP>(null, null, null),
                new QueryDef<PurchaseOrderItem>(
                    new Filter<PurchaseOrderItem>(x => x.Packet).LinkValid()
                        .And(x => x.Packet.Completed).IsEqualTo(DateTime.MinValue),
                    new Columns<PurchaseOrderItem>(
                        x => x.ID,
                        x => x.ReceivedDate,
                        x => x.Consignment.EstimatedWarehouseArrival,
                        x => x.DueDate,
                        x => x.PurchaseOrderLink.SupplierLink.Code,
                        x => x.PurchaseOrderLink.PONumber,
                        x => x.ReceivedReference
                    ),
                    null
                )
            );
            Factories = tables[0].Rows.Select(x => x.ToObject<ManufacturingFactory>())
                .ToArray(); //new Client<ManufacturingFactory>().Load(null, new SortOrder<ManufacturingFactory>(x=>x.Sequence));
            Sections = tables[1].Rows.Select(x => x.ToObject<ManufacturingSection>())
                .ToArray(); //new Client<ManufacturingSection>().Load(null, new SortOrder<ManufacturingSection>(x=>x.Sequence));
            Templates = tables[2].Rows.Select(x => x.ToObject<ManufacturingTemplate>())
                .ToArray(); //new Client<ManufacturingTemplate>().Load(null, new SortOrder<ManufacturingTemplate>(x=>x.Code));
            Jobs = tables[3]; //.Rows.Select(x => x.ToObject<Job>()).ToArray();
            ITPs = tables[4]; //.Rows.Select(x => x.ToObject<JobITP>()).ToArray();
            foreach (var orderrow in tables[5].Rows)
            {
                var id = orderrow.Get<PurchaseOrderItem, Guid>(x => x.ID);
                var receiveddate = orderrow.Get<PurchaseOrderItem, DateTime>(c => c.ReceivedDate);

                var estimatedwarehousearrival = orderrow.Get<PurchaseOrderItem, DateTime>(c => c.Consignment.EstimatedWarehouseArrival);
                if (estimatedwarehousearrival.IsEmpty())
                    estimatedwarehousearrival = orderrow.Get<PurchaseOrderItem, DateTime>(c => c.DueDate);

                var suppliercode = orderrow.Get<PurchaseOrderItem, string>(c => c.PurchaseOrderLink.SupplierLink.Code);
                var ponumber = orderrow.Get<PurchaseOrderItem, string>(c => c.PurchaseOrderLink.PONumber);
                var poreference = orderrow.Get<PurchaseOrderItem, string>(c => c.ReceivedReference);

                var tag = receiveddate.IsEmpty() ? "ETA" : "RCVD";

                OrderItems.Add(new Tuple<Guid, DateTime, string>(
                    id,
                    receiveddate,
                    string.Format("{0} ({1}) {2} {3:dd MMM yy} {4}",
                        suppliercode,
                        ponumber,
                        tag,
                        receiveddate.IsEmpty() ? estimatedwarehousearrival : receiveddate,
                        string.IsNullOrWhiteSpace(poreference) ? "" : ": " + poreference
                    )
                ));
            }
            //OrderItems = tables[5]; //.Rows.Select(x => x.ToObject<PurchaseOrderItem>()).ToArray(); 

            Filter<Document> imageFilter = null;
            foreach (var Factory in Factories)
                if (Factory.Thumbnail.IsValid())
                    imageFilter = imageFilter == null
                        ? new Filter<Document>(x => x.ID).IsEqualTo(Factory.Thumbnail.ID)
                        : imageFilter.Or(x => x.ID).IsEqualTo(Factory.Thumbnail.ID);
            FactoryImages = new Client<Document>().Load(imageFilter);

            var iFact = 1;
            foreach (var Factory in Factories)
            {
                var groups = new List<string>();
                if (!FactorySource.Any(x => x.Item1.Equals(Factory.Name)))
                {
                    var image = FactoryImages.FirstOrDefault(x => x.ID.Equals(Factory.Thumbnail.ID));
                    BitmapImage img = null;
                    if (image != null && image.Data != null && image.Data.Length > 0)
                    {
                        img = new BitmapImage();
                        img.LoadImage(image.Data);
                    }
                    else
                    {
                        img = PRSDesktop.Resources.factory.AsBitmapImage();
                    }

                    FactorySource.Add(new Tuple<string, BitmapImage, Guid>(Factory.Name, img, Factory.ID));
                    if (settings.FactoryID == Factory.ID)
                        iFact = FactorySource.Count - 1;
                }
            }

            FactoryListBox.ItemsSource = FactorySource;

            FactoryListBox.SelectedIndex = iFact < FactorySource.Count ? iFact : 0;

            SortBy.SelectedIndex = settings.SortByDueDate ? 1 : 0;
            View.SelectedIndex = settings.CompactView ? 1 : 0;

            bIncludeHeld = settings.IncludeHeld;
            IncludeHeld.IsChecked = bIncludeHeld;

            bIncludeOrders = settings.IncludeOrders;
            IncludeOrders.IsChecked = bIncludeOrders;

            bIncludeCompleted = settings.IncludeCompleted;
            IncludeCompleted.IsChecked = bIncludeCompleted;

            //new Client<Job>().Query(
            //    LookupFactory.DefineFilter<Job>(),
            //    LookupFactory.DefineColumns<Job>(),
            //    LookupFactory.DefineSort<Job>(),
            //    (table, error) =>
            //    {
            //        Dictionary<Guid, String> jobs = new Dictionary<Guid, string>() { { CoreUtils.FullGuid, "All Jobs" } };
            //        foreach (var row in table.Rows)
            //            jobs[row.Get<Job, Guid>(x => x.ID)] = String.Format("{0}: {1}", row.Get<Job, String>(x => x.JobNumber), row.Get<Job, String>(x => x.Name));
            //        Dispatcher.Invoke(() =>
            //        {
            //            JobChanging = true;
            //            Job.ItemsSource = jobs;
            //            Job.SelectedValue = CoreUtils.FullGuid;
            //            //Level.IsEnabled = false;
            //            //Zone.IsEnabled = false;
            //            ITP.IsEnabled = false;
            //            JobChanging = false;
            //        });
            //    });

            var jobs = new Dictionary<Guid, string> { { CoreUtils.FullGuid, "All Jobs" } };
            foreach (var row in Jobs.Rows)
                jobs[row.Get<Job, Guid>(c => c.ID)] =
                    string.Format("{0}: {1}", row.Get<Job, string>(c => c.JobNumber), row.Get<Job, string>(c => c.Name));
            JobChanging = true;
            Job.ItemsSource = jobs;
            Job.SelectedValue = CoreUtils.FullGuid;
            ITP.IsEnabled = false;
            JobChanging = false;
        }

        public void Shutdown()
        {
        }

        public void CreateToolbarButtons(IPanelHost host)
        {
        }

        public string SectionName => "Manufacturing Packets";

        public DataModel DataModel(Selection selection)
        {
            var ids = new List<Guid>();
            foreach (var column in _columns)
            {
                var rows = selection == Selection.None
                    ? new CoreRow[] { }
                    : selection == Selection.Selected
                        ? column.GetSelectedRows(Guid.Empty.ToString())
                        : column.packets.Rows;

                ids.AddRange(rows.Select(r => r.Get<ManufacturingPacket, Guid>(c => c.ID)));
            }

            return new ManufacturingPacketDataModel(new Filter<ManufacturingPacket>(x => x.ID).InList(ids.ToArray()));
        }


        public void Refresh()
        {
            Application.Current.Dispatcher.Invoke(() => { Mouse.OverrideCursor = Cursors.Wait; });

            var now = DateTime.Now;
            ReloadFactories();
            var elapsed = DateTime.Now - now;
            Logger.Send(LogType.Information, ClientFactory.UserID, string.Format("Refreshed Factories in {0}ms", elapsed.TotalMilliseconds));
            now = DateTime.Now;
            ReloadPackets();
            elapsed = DateTime.Now - now;
            Logger.Send(LogType.Information, ClientFactory.UserID, string.Format("Refreshed Packets in {0}ms", elapsed.TotalMilliseconds));


            Application.Current.Dispatcher.Invoke(() => { Mouse.OverrideCursor = null; });
        }

        public event DataModelUpdateEvent OnUpdateDataModel;

        //private void ChangeDate_Click(object sender, RoutedEventArgs e)
        //{
        //    MenuItem item = (MenuItem)sender;
        //    KanbanModel model = (KanbanModel)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;
        //    }
        //    DateTime date2 = !date.HasValue ? DateTime.Today.AddDays(14) : date.Value;
        //    if (InABox.WPF.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));
        //        CheckedKanbans.Clear();

        //        Progress.Close();
        //        Refresh();
        //    }
        //}

        //private void UpdatePriority(object sender, bool priority)
        //{
        //    MenuItem item = (MenuItem)sender;
        //    KanbanModel model = (KanbanModel)item.Tag;
        //    Progress.Show("");
        //    var pkts = GetSelectedPackets(model.ID);
        //    for (int i = 0; i < pkts.Length; i++)
        //    {
        //        var packet = pkts[i];
        //        packet.Priority = priority;
        //    }
        //    Progress.SetMessage("Updating Packets");
        //    new Client<ManufacturingPacket>().Save(pkts, "Priority Flag "+ (priority ? "Set" : "Cleared"));
        //    CheckedKanbans.Clear();

        //    Progress.Close();
        //    Refresh();
        //}

        //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)
        //{
        //    MenuItem item = (MenuItem)sender;
        //    KanbanModel model = (KanbanModel)item.Tag;
        //    Progress.Show("");
        //    var pkts = GetSelectedPackets(model.ID);
        //    for (int i = 0; i < pkts.Length; i++)
        //    {
        //        var packet = pkts[i];
        //        packet.OnHold = hold;
        //    }
        //    Progress.SetMessage("Updating Packets");
        //    new Client<ManufacturingPacket>().Save(pkts, "Hold Flag " + (hold ? "Set" : "Cleared"));
        //    CheckedKanbans.Clear();

        //    Progress.Close();
        //    Refresh();
        //}

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

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

        //private void CompeteItem_Click(object sender, RoutedEventArgs e)
        //{
        //    MenuItem item = (MenuItem)sender;
        //    KanbanModel model = (KanbanModel)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.ManufacturingPacketLink.ID).IsEqualTo(pkt.ID) : stgflt.Or(x => x.ManufacturingPacketLink.ID).IsEqualTo(pkt.ID);
        //    ManufacturingPacketStage[] stgs = new Client<ManufacturingPacketStage>().Load(stgflt, new SortOrder<ManufacturingPacketStage>(x => x.Sequence));

        //    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();

        //    CheckedKanbans.Clear();


        //    Refresh();
        //}

        public void Heartbeat(TimeSpan time)
        {
        }

        private void Job_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            //Dictionary<Guid, String> Levels = new Dictionary<Guid, string>() { { CoreUtils.FullGuid, "All Levels" } };
            //Dictionary<Guid, String> Zones = new Dictionary<Guid, string>() { { CoreUtils.FullGuid, "All Zones" } };
            var itps = new Dictionary<Guid, string> { { CoreUtils.FullGuid, "All ITPs" } };
            if (Job.SelectedValue == null || (Guid)Job.SelectedValue == CoreUtils.FullGuid)
            {
                iCombo = 1;
                //Level.ItemsSource = Levels;
                //Level.SelectedValue = CoreUtils.FullGuid;
                //Level.IsEnabled = false;

                //Zone.ItemsSource = Zones;
                //Zone.SelectedValue = CoreUtils.FullGuid;
                //Zone.IsEnabled = false;

                ITP.ItemsSource = itps;
                ITP.SelectedValue = CoreUtils.FullGuid;
                ITP.IsEnabled = false;

                iCombo = 0;
                if (!JobChanging)
                    ReloadPackets();
                return;
            }

            iCombo = 1;

            foreach (var row in ITPs.Rows.Where(r => r.Get<JobITP, Guid>(c => c.Job.ID).Equals(Job.SelectedValue)))
                itps[row.Get<JobITP, Guid>(c => c.Job.ID)] =
                    string.Format("{0}: {1}", row.Get<JobITP, string>(c => c.Code), row.Get<JobITP, string>(c => c.Description));

            ITP.ItemsSource = itps;
            ITP.SelectedValue = CoreUtils.FullGuid;
            ITP.IsEnabled = true;
            iCombo--;
            if (iCombo == 0)
                ReloadPackets();

            //new Client<JobLevel>().Query(
            //    new Filter<JobLevel>(x=>x.Job.ID).IsEqualTo((Guid)Job.SelectedValue),
            //    LookupFactory.DefineColumns<JobLevel>(),
            //    LookupFactory.DefineSort<JobLevel>(),
            //    (table, error) =>
            //    {
            //        foreach (var row in table.Rows)
            //            Levels[row.Get<JobLevel, Guid>(x => x.ID)] = String.Format("{0}: {1}", row.Get<JobLevel,String>(x=>x.Code), row.Get<JobLevel,String>(x=>x.Description));
            //        Dispatcher.Invoke(() =>
            //        {
            //            Level.ItemsSource = Levels;
            //            Level.SelectedValue = CoreUtils.FullGuid;
            //            Level.IsEnabled = true;

            //            iCombo--;
            //            if (iCombo == 0)
            //                ReloadPackets();
            //        });
            //    });

            // new Client<JobZone>().Query(
            //    new Filter<JobZone>(x => x.Job.ID).IsEqualTo((Guid)Job.SelectedValue),
            //    LookupFactory.DefineColumns<JobZone>(),
            //    LookupFactory.DefineSort<JobZone>(),
            //    (table, error) =>
            //    {
            //        foreach (var row in table.Rows)
            //            Zones[row.Get<JobZone, Guid>(x => x.ID)] = String.Format("{0}: {1}", row.Get<JobZone, String>(x => x.Code), row.Get<JobZone, String>(x => x.Description));
            //        Dispatcher.Invoke(() =>
            //        {
            //            Zone.ItemsSource = Zones;
            //            Zone.SelectedValue = CoreUtils.FullGuid;
            //            Zone.IsEnabled = true;
            //            iCombo--;
            //            if (iCombo == 0)
            //                ReloadPackets();
            //        });
            //    });

            //new Client<JobITP>().Query(
            //   new Filter<JobITP>(x => x.Job.ID).IsEqualTo((Guid)Job.SelectedValue),
            //   LookupFactory.DefineColumns<JobITP>(),
            //   LookupFactory.DefineSort<JobITP>(),
            //   (table, error) =>
            //   {
            //       foreach (var row in table.Rows)
            //           ITPs[row.Get<JobITP, Guid>(x => x.ID)] = String.Format("{0}: {1}", row.Get<JobITP, String>(x => x.Code), row.Get<JobITP, String>(x => x.Description));
            //       Dispatcher.Invoke(() =>
            //       {
            //           ITP.ItemsSource = ITPs;
            //           ITP.SelectedValue = CoreUtils.FullGuid;
            //           ITP.IsEnabled = true;
            //           iCombo--;
            //           if (iCombo == 0)
            //               ReloadPackets();
            //       });
            //   });
        }

        private void Unit_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (JobChanging || iCombo > 0)
                return;
            ReloadPackets();
        }

        private void CreateColumn(string title, Guid category)
        {
            var column = new ManufacturingPanelColumn();
            column.Margin = new Thickness(_columns.Any() ? 2 : 0, 0, 0, 0);
            column.Title = title;
            column.CompactView = CompactView;
            column.Category = category;
            column.SetValue(Grid.ColumnProperty, _columns.Count);
            column.Templates = Templates;
            column.Factories = Factories;
            column.OnChanged += Column_OnChanged;
            column.OnCollapsed += Column_OnCollapsed;

            Columns.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
            Columns.Children.Add(column);
            _columns.Add(column);
        }

        private void Column_OnCollapsed(object sender, bool collapsed)
        {
            var index = _columns.IndexOf((ManufacturingPanelColumn)sender);
            Columns.ColumnDefinitions[index].Width = new GridLength(1, collapsed ? GridUnitType.Auto : GridUnitType.Star);
        }

        private void Column_OnChanged(object sender, EventArgs e)
        {
            Refresh();
        }

        private void ReloadFactories()
        {
            columnsizer.IsEnabled = false;
            Columns.Children.Clear();

            _columns.Clear();
            Columns.ColumnDefinitions.Clear();
            CreateColumn("To Be Issued", Guid.Empty);

            //Kanban.Columns.Clear();
            //Kanban.Columns.Add(new KanbanColumn() { Title = "To be Issued", Categories = Guid.Empty.ToString() });

            foreach (var Factory in Factories)
                if (CurrentFactory.Equals(Guid.Empty) || CurrentFactory.Equals(Factory.ID))
                    foreach (var Section in Sections)
                        if (Section.Factory.ID.Equals(Factory.ID) && !Section.Hidden)
                            CreateColumn(Section.Factory.Name + ":" + Section.Name, Section.ID);
            //Kanban.Columns.Add(new KanbanColumn() { Title = Section.Factory.Name + ":" + Section.Name, Categories = Section.ID.ToString() });
            if (bIncludeCompleted)
                CreateColumn("Completed", CoreUtils.FullGuid);
            //Kanban.Columns.Add(new KanbanColumn() { Title = "Completed", Categories = CoreUtils.FullGuid.ToString() });

            //foreach (KanbanColumn column in Kanban.Columns)
            //{
            //    ContextMenu menu = new ContextMenu();
            //    menu.Tag = column;
            //    MenuItem item = new MenuItem() { Header = "Select All " + column.Title + " Tasks", Tag = column };
            //    item.Click += SelectAll_Click;
            //    menu.Items.Add(item);
            //    item = new MenuItem() { Header = "Unselect All " + column.Title + " Tasks", Tag = column };
            //    item.Click += UnSelectAll_Click;
            //    menu.Items.Add(item);
            //    column.ContextMenu = menu;
            //    column.AllowDrag = false;
            //    column.AllowDrop = false;
            //}

            //ResizeColumns();
            //columnsizer.IsEnabled = true;
        }

        //private void SetSelectedItems(KanbanColumn column, bool selected)
        //{

        //    foreach (ManufacturingKanban model in Kanbans)
        //    {
        //        if ((string)model.Category == column.Categories)
        //        {
        //            if (!CheckedKanbans.Contains(model.ID))
        //                CheckedKanbans.Add(model.ID);
        //            model.Checked = selected;
        //        }
        //    }

        //    Kanban.ItemsSource = null;
        //    Kanban.ItemsSource = Kanbans;
        //}

        //private void UnSelectAll_Click(object sender, RoutedEventArgs e)
        //{
        //    KanbanColumn column = ((MenuItem)sender).Tag as KanbanColumn;
        //    SetSelectedItems(column, false);
        //}

        //private void SelectAll_Click(object sender, RoutedEventArgs e)
        //{
        //    KanbanColumn column = ((MenuItem)sender).Tag as KanbanColumn;
        //    SetSelectedItems(column, 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 string GetColor(DateTime duedate, DateTime estdate)
        {
            var color = "LightGreen";
            if (duedate < estdate)
                color = "Salmon";
            else if (duedate < estdate.AddDays(7))
                color = "LightYellow";
            return color;
        }

        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 " ";
        }

        private void ReloadPackets()
        {
            Kanbans = new ObservableCollection<ManufacturingKanban>();
            var now = DateTime.Now;
            var elapsed = new TimeSpan(0);

            var CheckedKanbans = new List<string>();
            foreach (var column in _columns)
                CheckedKanbans.AddRange(column.GetSelectedKanbans("").Select(x => x.ID));

            var client = new Client<ManufacturingPacket>();

            var filter = GenerateFilter();

            //new CoreTable().LoadColumns(typeof(ManufacturingPacket));

            var columns = GenerateColumns();

            //var iprops = InABox.Core.DatabaseSchema.Properties(typeof(ManufacturingPacket)).Where(x => !x.Name.Equals("CustomAttributes") && !x.Name.Equals("Stages") && !x.Name.Equals("Time") && !x.Name.Equals("ActualTime") /* && !x.Name.Equals("TimeRemaining") */);

            //foreach (var iprop in iprops)
            //    columns.Add(iprop.Name);

            now = DateTime.Now;
            packets = client.Query(
                filter,
                columns,
                SortBy.SelectedIndex == 0
                    ? new SortOrder<ManufacturingPacket>(x => x.SetoutLink.Number)
                    : new SortOrder<ManufacturingPacket>(x => x.DueDate).ThenBy(x => x.Priority, SortDirection.Descending)
                        .ThenBy(x => x.SetoutLink.Number));

            elapsed = DateTime.Now - now;
            Logger.Send(LogType.Information, ClientFactory.UserID,
                string.Format("Retrieved {0} packets in {1}ms", packets.Rows.Count, elapsed.TotalMilliseconds));
            now = DateTime.Now;

            foreach (var row in packets.Rows)
            {
                var bOK = true;

                var completed = row.Get<ManufacturingPacket, DateTime>(x => x.Completed);

                var onhold = row.Get<ManufacturingPacket, bool>(x => x.OnHold);
                var issues = row.Get<ManufacturingPacket, string>(x => x.Issues);

                var orderitemid = row.EntityLinkID<ManufacturingPacket, PurchaseOrderItemLink>(x => x.OrderItem) ?? Guid.Empty;
                var orderitem = orderitemid != Guid.Empty ? OrderItems.FirstOrDefault(x => x.Item1.Equals(orderitemid)) : null;
                //if (bOK && !bIncludeOrders)
                //    bOK = (orderitem == null) || !orderitem.Item2.IsEmpty();

                //bool bSkipJobCheck = false;
                var itp = row.Get<ManufacturingPacket, Guid>(x => x.ITP.ID);
                //if (bOK && (ITP.SelectedValue != null) && !ITP.SelectedValue.Equals(CoreUtils.FullGuid))
                //{
                //    bOK = itp == (Guid)ITP.SelectedValue;
                //    bSkipJobCheck = true;
                //}

                var jobid = row.Get<ManufacturingPacket, Guid>(x => x.SetoutLink.JobLink.ID);
                //if (bOK && !bSkipJobCheck && (Job.SelectedValue != null) && !Job.SelectedValue.Equals(CoreUtils.FullGuid))
                //    bOK = jobid ==(Guid)Job.SelectedValue;

                var sectionid = row.Get<ManufacturingPacket, Guid>(x => x.StageLink.SectionID);
                //if (bOK && !CurrentFactory.Equals(Guid.Empty))
                //    bOK = Sections.Any(x => x.Factory.ID.Equals(CurrentFactory) && x.ID.Equals(sectionid));

                //if (CurrentFactory != Guid.Empty)
                //{
                //    var templatefilter = new Filter<ManufacturingPacket>(x => x.ManufacturingTemplateLink.Factory.ID).IsEqualTo(CurrentFactory).Or(x => x.StageLink.ID).IsNotEqualTo(Guid.Empty);
                //    filter.Ands.Add(templatefilter);
                //}

                var title = row.Get<ManufacturingPacket, string>(x => x.Title);
                var serial = row.Get<ManufacturingPacket, string>(x => x.Serial);
                var watermark = row.Get<ManufacturingPacket, string>(x => x.WaterMark);
                var location = row.Get<ManufacturingPacket, string>(x => x.Location);

                var setoutlocation = row.Get<ManufacturingPacket, string>(x => x.SetoutLink.Location);
                var setoutnumber = row.Get<ManufacturingPacket, string>(x => x.SetoutLink.Number);
                var setoutdescription = row.Get<ManufacturingPacket, string>(x => x.SetoutLink.Description);

                var templateid = row.Get<ManufacturingPacket, Guid>(x => x.ManufacturingTemplateLink.ID);
                var templatecode = Templates.FirstOrDefault(x => x.ID.Equals(templateid))?.Code;

                //if (bOK && !String.IsNullOrWhiteSpace(SearchBox.Text))
                //{
                //    var search = SearchBox.Text.ToUpper();
                //    bOK = title.ToUpper().Contains(search)
                //        || serial.ToUpper().Contains(search)
                //        || watermark.ToUpper().Contains(search)
                //        || location.ToUpper().Contains(search)
                //        || setoutlocation.ToUpper().Contains(search)
                //        || setoutnumber.ToUpper().Contains(search)
                //        || templatecode.ToUpper().Contains(search);
                //}

                if (bOK)
                {
                    var id = row.Get<ManufacturingPacket, Guid>(x => x.ID);
                    var priority = row.Get<ManufacturingPacket, bool>(x => x.Priority);
                    var distributed = row.Get<ManufacturingPacket, bool>(x => x.Distributed);

                    var barcodeqty = row.Get<ManufacturingPacket, int>(x => x.BarcodeQty);
                    var quantity = row.Get<ManufacturingPacket, int>(x => x.Quantity);
                    var estimateddate = row.Get<ManufacturingPacket, DateTime>(x => x.EstimatedDate);
                    var created = row.Get<ManufacturingPacket, DateTime>(x => x.Created);
                    var duedate = row.Get<ManufacturingPacket, DateTime>(x => x.DueDate);
                    var barcodeprinted = row.Get<ManufacturingPacket, DateTime>(x => x.BarcodePrinted);
                    var barcodetype = row.Get<ManufacturingPacket, BarcodeType>(x => x.BarcodeType);

                    var stageid = row.Get<ManufacturingPacket, Guid>(x => x.StageLink.ID);
                    var stageValid = Entity.IsEntityLinkValid<ManufacturingPacket, ManufacturingPacketStageLink>(x => x.StageLink, row);
                    var station = row.Get<ManufacturingPacket, int>(x => x.StageLink.Station);
                    var time = row.Get<ManufacturingPacket, TimeSpan>(x => x.StageLink.Time);
                    var percentagecomplete = row.Get<ManufacturingPacket, double>(x => x.StageLink.PercentageComplete);

                    var jobrow = 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) : "",
                        row.Get<ManufacturingPacket, string>(x => x.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>();

                    //List<String> locdesc = new List<string>()
                    //{
                    //    row.Get<ManufacturingPacket,String>(x=>x.Level.Code),
                    //    row.Get<ManufacturingPacket,String>(x=>x.Zone.Code),
                    //    location
                    //};
                    //descrip.Add(String.Join(" / ", locdesc.Where(x => !String.IsNullOrWhiteSpace(x))));
                    descrip.Add(location);

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

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

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

                    model.Image = !barcodeprinted.IsEmpty() ? barcode : barcodetype == BarcodeType.None ? disabled : null;
                    model.Tags = new 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;


                    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);
                }
            }

            elapsed = DateTime.Now - now;
            Logger.Send(LogType.Information, ClientFactory.UserID, string.Format("Processed Kanbans in {0}ms", elapsed.TotalMilliseconds));
            now = DateTime.Now;

            foreach (var column in _columns)
            {
                column.packets = packets;
                column.Kanbans = Kanbans.Where(x => x.Category.Equals(column.Category)).ToArray();
            }
            //foreach (var col in Kanban.Columns)
            //    col.IsExpanded = Kanbans.Where(x => col.Categories.Contains(x.Category.ToString())).Count() > 0;

            //bResizeRequired = true;

            //Kanban.ItemsSource = null;
            //Kanban.ItemsSource = Kanbans;

            elapsed = DateTime.Now - now;
            Logger.Send(LogType.Information, ClientFactory.UserID, string.Format("Loaded Columns in {0}ms", elapsed.TotalMilliseconds));
        }

        private Filter<ManufacturingPacket> GenerateFilter()
        {
            var filter = new Filter<ManufacturingPacket>(x => x.Archived).IsEqualTo(DateTime.MinValue);

            if (!bIncludeCompleted)
                filter = filter.And(x => x.Completed).IsEqualTo(DateTime.MinValue);

            if (!bIncludeHeld)
                //    filter = filter.And(x => x.OnHold).IsEqualTo(false);
                filter = filter.And(x => x.OnHold).IsEqualTo(false);

            if (!bIncludeOrders)
            {
                var orderfilter = new Filter<ManufacturingPacket>(x => x.OrderItem).NotLinkValid().Or(x => x.OrderItem.ReceivedDate)
                    .IsNotEqualTo(DateTime.MinValue);
                filter = filter.And(orderfilter);
            }

            var bSkipJobCheck = false;

            if (ITP.SelectedValue != null && !ITP.SelectedValue.Equals(CoreUtils.FullGuid))
            {
                filter = filter.And(x => x.ITP.ID).IsEqualTo((Guid)ITP.SelectedValue);
                bSkipJobCheck = true;
            }

            if (!bSkipJobCheck && Job.SelectedValue != null && !Job.SelectedValue.Equals(CoreUtils.FullGuid))
                filter = filter.And(x => x.SetoutLink.JobLink.ID).IsEqualTo((Guid)Job.SelectedValue);

            var sctflt = new Filter<ManufacturingPacket>(x => x.StageLink).NotLinkValid();

            foreach (var Section in Sections.Where(x => CurrentFactory.Equals(Guid.Empty) || x.Factory.ID.Equals(CurrentFactory)))
                sctflt = sctflt.Or(x => x.StageLink.SectionID).IsEqualTo(Section.ID);
            filter.Ands.Add(sctflt);

            if (CurrentFactory != Guid.Empty)
            {
                var templatefilter = new Filter<ManufacturingPacket>(x => x.ManufacturingTemplateLink.Factory.ID).IsEqualTo(CurrentFactory)
                    .Or(x => x.StageLink).LinkValid();
                filter.Ands.Add(templatefilter);
            }

            if (!string.IsNullOrWhiteSpace(SearchBox.Text))
                filter = filter.TextSearch(
                    SearchBox.Text,
                    x => x.SetoutLink.JobLink.JobNumber,
                    x => x.SetoutLink.JobLink.Name,
                    x => x.SetoutLink.Number,
                    x => x.SetoutLink.Description,
                    //x => x.SetoutLink.Reference,
                    x => x.SetoutLink.Location,
                    //x => x.Unit.Code,
                    //x => x.Unit.Description,
                    x => x.ITP.Code,
                    x => x.ITP.Description,
                    x => x.Title,
                    x => x.Serial,
                    x => x.Location,
                    x => x.WaterMark,
                    x => x.ManufacturingTemplateLink.Code
                );

            return filter;
        }

        private static Columns<ManufacturingPacket> GenerateColumns()
        {
            var columns = new Columns<ManufacturingPacket>();
            columns.Add(x => x.ID);
            //columns.Add(x => x.OnHold);
            columns.Add(x => x.OnHold);
            columns.Add(x => x.Issues);
            columns.Add(x => x.Priority);
            columns.Add(x => x.Distributed);
            columns.Add(x => x.BarcodeQty);
            columns.Add(x => x.Quantity);
            columns.Add(x => x.Title);
            columns.Add(x => x.Serial);
            columns.Add(x => x.WaterMark);
            columns.Add(x => x.EstimatedDate);
            columns.Add(x => x.Created);
            columns.Add(x => x.DueDate);
            columns.Add(x => x.Location);
            columns.Add(x => x.BarcodePrinted);
            columns.Add(x => x.BarcodeType);
            columns.Add(x => x.Completed);
            //columns.Add(x => x.TimeRemaining);
            columns.Add(x => x.Group);

            columns.Add(x => x.SetoutLink.ID);
            columns.Add(x => x.SetoutLink.Number);
            columns.Add(x => x.SetoutLink.Description);
            columns.Add(x => x.SetoutLink.Location);
            columns.Add(x => x.SetoutLink.JobLink.ID);

            columns.Add(x => x.OrderItem.ID);
            //columns.Add(x => x.OrderItem.ReceivedDate);
            //columns.Add(x => x.OrderItem.Consignment.EstimatedWarehouseArrival);
            //columns.Add(x => x.OrderItem.PurchaseOrderLink.SupplierLink.Code);
            //columns.Add(x => x.OrderItem.PurchaseOrderLink.PONumber);

            columns.Add(x => x.ManufacturingTemplateLink.ID);

            columns.Add(x => x.ITP.ID);

            columns.Add(x => x.StageLink.ID);
            columns.Add(x => x.StageLink.SectionID);
            columns.Add(x => x.StageLink.Station);
            columns.Add(x => x.StageLink.Time);
            columns.Add(x => x.StageLink.PercentageComplete);
            columns.Add(x => x.StageLink.Deleted);
            return columns;
        }

        private void Factories_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (e.AddedItems.Count == 0)
                return;

            var selected = (Tuple<string, BitmapImage, Guid>)e.AddedItems[0];
            CurrentFactory = selected.Item3;


            if (IsReady)
                SaveSettings();

            foreach (var column in _columns)
                column.ClearSelectedKanbans();
            //column.CheckedKanbans.Clear();
            //CheckedKanbans.Clear();
            if (IsReady)
                Refresh();
        }

        private void SortBy_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (e.AddedItems.Count == 0)
                return;

            var selected = (ComboBoxItem)e.AddedItems[0];
            SortByDueDate = selected.Content.Equals("Due Date");


            if (IsReady)
                SaveSettings();

            foreach (var column in _columns)
                column.ClearSelectedKanbans();
            //column.CheckedKanbans.Clear();
            //CheckedKanbans.Clear();
            if (IsReady)
                Refresh();
        }

        private void View_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (e.AddedItems.Count == 0)
                return;

            var selected = (ComboBoxItem)e.AddedItems[0];
            CompactView = selected.Content.Equals("Compact");
            ConsolidatedView = selected.Content.Equals("Consolidated");

            if (IsReady)
                SaveSettings();

            foreach (var column in _columns)
                column.ClearSelectedKanbans();
            //column.CheckedKanbans.Clear();
            //CheckedKanbans.Clear();

            if (IsReady)
                Refresh();
        }

        private ManufacturingPacket[] GetSelectedPackets(string currentid)
        {
            var rows = packets.Rows.Where(r => r.Get<ManufacturingPacket, Guid>(c => c.ID).Equals(Guid.Parse(currentid)));
            return rows.Select(r => r.ToObject<ManufacturingPacket>()).ToArray();
        }

        private void SearchBox_KeyUp(object sender, KeyEventArgs e)
        {
            if (string.IsNullOrWhiteSpace(SearchBox.Text) || e.Key == Key.Return)
                Refresh();
        }

        private void IncludeCompleted_Click(object sender, RoutedEventArgs e)
        {
            bIncludeCompleted = IncludeCompleted.IsChecked == true;
            if (IsReady)
            {
                SaveSettings();
                Refresh();
            }
        }

        private void IncludeHeld_Click(object sender, RoutedEventArgs e)
        {
            bIncludeHeld = IncludeHeld.IsChecked == true;
            if (IsReady)
            {
                SaveSettings();
                Refresh();
            }
        }

        private void IncludeOrders_Click(object sender, RoutedEventArgs e)
        {
            bIncludeOrders = IncludeOrders.IsChecked == true;
            if (IsReady)
            {
                SaveSettings();
                Refresh();
            }
        }

        private void SaveSettings()
        {
            var user = new ManufacturingSettings
            {
                FactoryID = CurrentFactory,
                SortByDueDate = SortByDueDate,
                CompactView = CompactView,
                ConsolidatedView = ConsolidatedView,
                IncludeHeld = bIncludeHeld,
                IncludeOrders = bIncludeOrders,
                IncludeCompleted = bIncludeCompleted
            };
            new UserConfiguration<ManufacturingSettings>().Save(user);
        }

        private void Export_Click(object sender, RoutedEventArgs e)
        {
            IEnumerable<string> columns = string.IsNullOrWhiteSpace(settings.ExportColumns) ? new string[] { } : settings.ExportColumns.Split(',');
            if (!columns.Any())
                columns = packets.Columns.Select(x => x.ColumnName);

            var form = new DynamicExportForm(typeof(ManufacturingPacket), columns);
            if (form.ShowDialog() != true)
                return;

            settings.ExportColumns = string.Join(",", form.Fields);
            new UserConfiguration<ManufacturingSettings>().Save(settings);

            var export = new Client<ManufacturingPacket>().Query(
                GenerateFilter(),
                new Columns<ManufacturingPacket>(form.Fields),
                LookupFactory.DefineSort<ManufacturingPacket>()
            );
            ExcelExporter.DoExport<ManufacturingPacket>(export, string.Format("Manufacturing {0:dd-MMM-yy}", DateTime.Today));
        }
    }
}