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 InABox.Wpf;
using Syncfusion.UI.Xaml.Kanban;
using System.ComponentModel;

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

        #region Settings Fields

        private bool bIncludeCompleted;
        private bool bIncludeHeld;
        private ManufacturingSettings.FilterOrdersOptions filterOrders;

        private ManufacturingViewType ViewType;
        private Guid CurrentFactory = Guid.Empty;

        private bool SortByDueDate = true;

        private ManufacturingSettings settings = new();

        public ManufacturingPanelProperties Properties { get; set; }

        #endregion

        private readonly DispatcherTimer columnsizer = new();

        private Document[] FactoryImages = Array.Empty<Document>();

        private int iCombo;
        private bool JobChanging;

        private readonly ManufacturingPanelData Data = new();

        private CoreTable packets;

        private Guid SelectedJob;

        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 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
                )
            );
            Data.Factories = tables[0].Rows.Select(x => x.ToObject<ManufacturingFactory>())
                .ToArray(); //new Client<ManufacturingFactory>().Load(null, new SortOrder<ManufacturingFactory>(x=>x.Sequence));
            Data.Sections = tables[1].Rows.Select(x => x.ToObject<ManufacturingSection>())
                .ToArray(); //new Client<ManufacturingSection>().Load(null, new SortOrder<ManufacturingSection>(x=>x.Sequence));
            Data.Templates = tables[2].Rows.Select(x => x.ToObject<ManufacturingTemplate>())
                .ToArray(); //new Client<ManufacturingTemplate>().Load(null, new SortOrder<ManufacturingTemplate>(x=>x.Code));
            Data.Jobs = tables[3]; //.Rows.Select(x => x.ToObject<Job>()).ToArray();
            Data.ITPs = tables[4]; //.Rows.Select(x => x.ToObject<JobITP>()).ToArray();

            Data.Properties = Properties;

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

                Data.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(); 

            if (Data.Factories.Any())
            {
                Filter<Document>? imageFilter = null;
                foreach (var Factory in Data.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);
            }
            else
                FactoryImages = Array.Empty<Document>();

            var iFact = 1;
            foreach (var Factory in Data.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));

                    var img = ImageUtils.LoadImage(image?.Data) ?? 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 = (int)ViewType;

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

            filterOrders = settings.FilterOrders;
            FilterOrders.SelectedIndex = (int)filterOrders;

            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 Data.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;
            SelectedJob = CoreUtils.FullGuid;
            ITP.IsEnabled = false;
            JobChanging = false;
        }

        public void Shutdown(CancelEventArgs? cancel)
        {
        }

        public void CreateToolbarButtons(IPanelHost host)
        {
            ManufacturingSetupActions.Standard(host);
            host.CreateSetupAction(
                new PanelAction() 
                { 
                    Caption = "Template Groups", 
                    Image = PRSDesktop.Resources.specifications,
                    OnExecute =
                    action =>
                    {
                        var list = new MasterList(typeof(ManufacturingTemplateGroup));
                        list.ShowDialog();
                    }  
                }
            );
        }

        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
                    ? Enumerable.Empty<ManufacturingPacket>()
                    : selection == Selection.Selected
                        ? column.GetSelectedPackets()
                        : column.GetPackets();

                ids.AddRange(rows.Select(r => r.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)
        {
            var oldID = SelectedJob;
            var newID = Job.SelectedValue != null ? (Guid)Job.SelectedValue : Guid.Empty;
            SelectedJob = newID;

            //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 (SelectedJob == Guid.Empty || SelectedJob == 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;
            }
            else
            {
                iCombo = 1;

                foreach (var row in Data.ITPs.Rows.Where(r => r.Get<JobITP, Guid>(c => c.Job.ID).Equals(SelectedJob)))
                    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 (newID != CoreUtils.FullGuid && ViewType == ManufacturingViewType.Job)
            {
                View.SelectedIndex = (int)ManufacturingViewType.Full;
            }
            else
            {
                if (!JobChanging && iCombo == 0)
                {
                    ReloadPackets();
                }
            }
        }

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

        private void AddColumn<TColumn>(string title, Guid category, TColumn column)
            where TColumn : FrameworkElement, IManufacturingPanelColumn
        {
            column.Margin = new Thickness(_columns.Any() ? 2 : 0, 0, 0, 0);
            column.Title = title;
            column.Data = Data;
            column.Category = category;

            column.SetValue(Grid.ColumnProperty, _columns.Count);
            column.OnCollapsed += Column_OnCollapsed;

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

        private void CreateColumn(string title, Guid category)
        {
            var job = SelectedJob;
            if (ViewType == ManufacturingViewType.Job)
            {
                var column = new ManufacturingPanelJobColumn();
                column.OnSelectJob += Column_OnSelectJob;
                AddColumn(title, category, column);
            }
            else
            {
                var column = new ManufacturingPanelColumn();

                column.CompactView = ViewType == ManufacturingViewType.Compact;
                column.OnChanged += Column_OnChanged;

                AddColumn(title, category, column);
            }

        }

        private void Column_OnSelectJob(Guid jobID)
        {
            Job.SelectedValue = jobID;
        }

        private void Column_OnCollapsed(object sender, bool collapsed)
        {
            var index = _columns.IndexOf((IManufacturingPanelColumn)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 Data.Factories)
                if (CurrentFactory.Equals(Guid.Empty) || CurrentFactory.Equals(factory.ID))
                    foreach (var section in Data.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 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()
        {
            var filter = GenerateFilter();
            var columns = GenerateColumns();

            using var profiler = new Profiler(false);
            packets = new Client<ManufacturingPacket>().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));

            Logger.Send(LogType.Information, ClientFactory.UserID,
                string.Format("Retrieved {0} packets in {1}ms", packets.Rows.Count, profiler.Restart()));

            var objects = packets.ToObjects<ManufacturingPacket>();
            var groups =  objects.GroupBy(x => !x.Completed.IsEmpty() ? CoreUtils.FullGuid : x.StageLink.SectionID);
            var results = groups.ToDictionary(x => x.Key, x => x);

            Logger.Send(LogType.Information, ClientFactory.UserID, string.Format("Processed Kanbans in {0}ms", profiler.Restart()));

            foreach (var column in _columns)
            {
                column.SetPackets(results.GetValueOrDefault(column.Category) ?? Enumerable.Empty<ManufacturingPacket>());
            }

            Logger.Send(LogType.Information, ClientFactory.UserID, string.Format("Loaded Columns in {0}ms", profiler.Restart()));
        }

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

            switch (filterOrders)
            {
                case ManufacturingSettings.FilterOrdersOptions.IncludeOrders:
                    break;
                case ManufacturingSettings.FilterOrdersOptions.OrdersOnly:
                    var orderfilter = new Filter<ManufacturingPacket>(x => x.OrderItem).LinkValid()
                        .And(x => x.OrderItem.ReceivedDate).IsEqualTo(DateTime.MinValue);
                    filter = filter.And(orderfilter);
                    break;
                case ManufacturingSettings.FilterOrdersOptions.ExcludeOrders:
                    orderfilter = new Filter<ManufacturingPacket>(x => x.OrderItem).NotLinkValid()
                        .Or(x => x.OrderItem.ReceivedDate).IsNotEqualTo(DateTime.MinValue);
                    filter = filter.And(orderfilter);
                    break;
            }

            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 sections = Data.Sections.Where(x => CurrentFactory.Equals(Guid.Empty) || x.Factory.ID.Equals(CurrentFactory)).Select(x => x.ID)
                .ToList();
            var sctflt = new Filter<ManufacturingPacket>(x => x.StageLink.SectionID).IsEqualTo(Guid.Empty)
                    .Or(x => x.StageLink.SectionID).InList(sections.ToArray());
            /*
             var sctflt = new Filter<ManufacturingPacket>(x => x.StageLink).NotLinkValid();
             foreach (var section in Data.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.SetoutLink.Group.ID);
            columns.Add(x => x.SetoutLink.Group.Name);
            columns.Add(x => x.SetoutLink.Group.Job.JobNumber);
            columns.Add(x => x.SetoutLink.Group.OptimizationDocument.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 || e.AddedItems[0] is not Tuple<string, BitmapImage, Guid> selected)
                return;

            CurrentFactory = selected.Item3;

            if (IsReady)
                SaveSettings();

            if (IsReady)
                Refresh();
        }

        private void SortBy_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (e.AddedItems.Count == 0 || e.AddedItems[0] is not ComboBoxItem selected)
                return;

            SortByDueDate = selected.Content.Equals("Due Date");

            if (IsReady)
                SaveSettings();

            if (IsReady)
                Refresh();
        }

        private void View_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (e.AddedItems.Count == 0 || e.AddedItems[0] is not ComboBoxItem selected)
                return;

            ViewType = (ManufacturingViewType)View.SelectedIndex;

            if (IsReady)
                SaveSettings();

            if (ViewType == ManufacturingViewType.Job && SelectedJob != CoreUtils.FullGuid)
            {
                SelectedJob = CoreUtils.FullGuid;
                JobChanging = true;
                Job.SelectedValue = SelectedJob;
                JobChanging = false;
            }

            if (IsReady)
                Refresh();
        }

        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 FilterOrders_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (e.AddedItems.Count == 0 || e.AddedItems[0] is not ComboBoxItem selected)
                return;

            filterOrders = (ManufacturingSettings.FilterOrdersOptions)FilterOrders.SelectedIndex;

            if (IsReady)
            {
                SaveSettings();
                Refresh();
            }
        }

        private void SaveSettings()
        {
            var user = new ManufacturingSettings
            {
                FactoryID = CurrentFactory,
                SortByDueDate = SortByDueDate,
                ViewType = ViewType,
                IncludeHeld = bIncludeHeld,
                FilterOrders = filterOrders,
                IncludeCompleted = bIncludeCompleted
            };
            new UserConfiguration<ManufacturingSettings>().Save(user);
        }

        private void Export_Click(object sender, RoutedEventArgs e)
        {
            IEnumerable<string> columns = string.IsNullOrWhiteSpace(settings.ExportColumns) ? Array.Empty<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));
        }
    }
}