prs/prs.desktop/Panels/Consignments/ConsignmentsPanel.xaml.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Linq.Expressions;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using Comal.Classes;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using InABox.Wpf;

namespace PRSDesktop
{
    /// <summary>
    ///     Interaction logic for ConsignmentsPanel.xaml
    /// </summary>
    public partial class ConsignmentsPanel : UserControl, IPanel<Consignment>
    {
        private readonly List<Tuple<Guid, string>> _categories = new();

        private readonly List<Tuple<Guid, string>> _types = new();

        private ConsignmentScreenSettings settings;

        public ConsignmentsPanel()
        {
            InitializeComponent();
            
            ConsignmentItems.GetParcels = () => ConsignmentParcels.Data;
            
            Consignments.HiddenColumns.Add(x => x.Supplier.Code);
            Consignments.HiddenColumns.Add(x => x.Supplier.Name);
            Consignments.HiddenColumns.Add(x => x.Number);
            Consignments.HiddenColumns.Add(x => x.Type.Description);
            Consignments.HiddenColumns.Add(x => x.Origin);
            Consignments.HiddenColumns.Add(x => x.Description);
            Consignments.HiddenColumns.Add(x => x.EstimatedDispatchDate);
            Consignments.HiddenColumns.Add(x => x.EstimatedPortArrival);
            Consignments.HiddenColumns.Add(x => x.EstimatedWarehouseArrival);
            Consignments.HiddenColumns.Add(x => x.ActualDispatchDate);
            Consignments.HiddenColumns.Add(x => x.ActualPortArrival);
            Consignments.HiddenColumns.Add(x => x.ActualWarehouseArrival);
            //Consignments.HiddenColumns.Add(x => x.Status);
            Consignments.HiddenColumns.Add(x => x.Closed);

            Consignments.OnSelectItem += (o, e) =>
            {
                var row = e.Rows?.FirstOrDefault();
                
                Guid consignmentid = row != null ? row.Get<Consignment, Guid>(x => x.ID) : CoreUtils.FullGuid;
                bool completed = row == null || !row.Get<Consignment, DateTime>(x => x.Closed).IsEmpty();
                
                
                LoadConsigmment(row);
                ConsignmentParcels.ConsignmentID = consignmentid;
                ConsignmentParcels.Completed = completed;
                ConsignmentParcels.Refresh(false, true);

                ConsignmentItems.ConsignmentID = consignmentid;
                ConsignmentItems.ParcelID = CoreUtils.FullGuid;
                ConsignmentItems.Completed = completed;
                
                ConsignmentItems.Refresh(false, true);
            };

            ConsignmentItems.OnChanged += ConsignmentItemsChanged;
        }

        public bool IsReady { get; set; }

        public event DataModelUpdateEvent? OnUpdateDataModel;

        public void CreateToolbarButtons(IPanelHost host)
        {
            if (Security.CanView<ConsignmentType>())
            {
                host.CreateSetupAction(new PanelAction("Consignment Types",PRSDesktop.Resources.service,
                    (action) =>
                    {
                        var list = new MasterList(typeof(ConsignmentType));
                        list.ShowDialog();
                    }
                ));
            }
        }

        public string SectionName => "Consignments";

        public DataModel DataModel(Selection selection)
        {
            var ids = Consignments.ExtractValues(c => c.ID, selection).ToArray();
            return new BaseDataModel<Consignment>(new Filter<Consignment>(x => x.ID).InList(ids));
        }

        public void Heartbeat(TimeSpan time)
        {
            // Nothing to Do Here
        }

        public void Refresh()
        {
            Consignments.Refresh(false, true);
        }

        public Dictionary<string, object[]> Selected()
        {
            return new Dictionary<string, object[]>();
        }

        public void Setup()
        {
            settings = new UserConfiguration<ConsignmentScreenSettings>().Load();
            SplitPanel.View = settings.ViewType == ScreenViewType.Register ? DynamicSplitPanelView.Master :
                settings.ViewType == ScreenViewType.Details ? DynamicSplitPanelView.Detail : DynamicSplitPanelView.Combined;
            SplitPanel.AnchorWidth = settings.AnchorWidth;

            StatusList.SelectedIndex = settings.ShowAll ? 1 : 0;
            StatusList.SelectionChanged += StatusList_SelectionChanged;

            _types.Add(new Tuple<Guid, string>(CoreUtils.FullGuid, "All Types"));
            _categories.Add(new Tuple<Guid, string>(CoreUtils.FullGuid, "All Categories"));

            var query = new MultiQuery();
            query.Add(
                LookupFactory.DefineFilter<ConsignmentType>(),
                LookupFactory.DefineColumns<ConsignmentType>(),
                LookupFactory.DefineSort<ConsignmentType>()
            );
            query.Add(
                LookupFactory.DefineFilter<PurchaseOrderCategory>(),
                LookupFactory.DefineColumns<PurchaseOrderCategory>(),
                LookupFactory.DefineSort<PurchaseOrderCategory>()
            );
            query.Query();

            LoadLookups<ConsignmentType>(query, _types, x => x.Description);
            TypeList.ItemsSource = _types;
            TypeList.SelectedValue = _types.Any(x => x.Item1 == settings.SelectedType) ? settings.SelectedType : CoreUtils.FullGuid;
            Consignments.SelectedType = (Guid)TypeList.SelectedValue;
            TypeList.SelectionChanged += TypeList_SelectionChanged;

            LoadLookups<PurchaseOrderCategory>(query, _categories, x => x.Description);
            CategoryList.ItemsSource = _categories;
            CategoryList.SelectedValue =
                _categories.Any(x => x.Item1 == settings.SelectedCategory) ? settings.SelectedCategory : CoreUtils.FullGuid;
            Consignments.SelectedCategory = (Guid)CategoryList.SelectedValue;
            CategoryList.SelectionChanged += CategoryList_SelectionChanged;

            Consignments.ShowAll = settings.ShowAll;
            Consignments.ColumnsTag = settings.ViewType == ScreenViewType.Register ? settings.ViewType.ToString() : "";
            Consignments.Refresh(true, false);
            ConsignmentParcels.Refresh(true, false);
            ConsignmentItems.Refresh(true, false);
        }

        public void Shutdown(CancelEventArgs? cancel)
        {
        }

        private void ConsignmentItemsChanged(object? sender, EventArgs args)
        {
            var consrow = Consignments.Data.Rows.FirstOrDefault(r => r.Get<Consignment, Guid>(c => c.ID).Equals(ConsignmentItems.ConsignmentID));
            if (consrow is null)
            {
                MessageBox.Show("Cannot find Consignment");
                return;
            }

            var consignment = consrow.ToObject<Consignment>();
            var allreceived = !ConsignmentItems.Data.Rows.Any(r => r.Get<PurchaseOrderItem, DateTime>(c => c.ReceivedDate).IsEmpty());
            var anyreceived = ConsignmentItems.Data.Rows.Any(r => !r.Get<PurchaseOrderItem, DateTime>(c => c.ReceivedDate).IsEmpty());

            if (anyreceived)
            {
                if (consignment.ActualWarehouseArrival.IsEmpty())
                    consignment.ActualWarehouseArrival = DateTime.Now;
            }
            else
            {
                if (!consignment.ActualWarehouseArrival.IsEmpty())
                    consignment.ActualWarehouseArrival = DateTime.MinValue;
            }

            if (allreceived)
            {
                if (consignment.Closed.IsEmpty())
                    consignment.Closed = DateTime.Now;
            }
            else
            {
                if (!consignment.Closed.IsEmpty())
                    consignment.Closed = DateTime.MinValue;
            }

            if (consignment.IsChanged())
                using (new WaitCursor())
                {
                    new Client<Consignment>().Save(consignment, "Consignment Closed Date Updated");
                }
        }

        private string CheckDate(DateTime date)
        {
            return date.IsEmpty() ? "" : date.ToShortDateString();
        }

        private void LoadConsigmment(CoreRow? row)
        {
            SupplierCode.Text = row == null ? "" : row.Get<Consignment, string>(x => x.Supplier.Code);
            SupplierName.Text = row == null ? "" : row.Get<Consignment, string>(x => x.Supplier.Name);

            Number.Text = row == null ? "" : row.Get<Consignment, string>(x => x.Number);
            Type.Text = row == null ? "" : row.Get<Consignment, string>(x => x.Type.Description);

            Origin.Text = row == null ? "" : row.Get<Consignment, string>(x => x.Origin);

            Description.Text = row == null ? "" : row.Get<Consignment, string>(x => x.Description);

            EstShip.Text = row == null ? "" : CheckDate(row.Get<Consignment, DateTime>(x => x.EstimatedDispatchDate));
            EstPort.Text = row == null ? "" : CheckDate(row.Get<Consignment, DateTime>(x => x.EstimatedPortArrival));
            EstArrival.Text = row == null ? "" : CheckDate(row.Get<Consignment, DateTime>(x => x.EstimatedWarehouseArrival));

            ActShip.Text = row == null ? "" : CheckDate(row.Get<Consignment, DateTime>(x => x.ActualDispatchDate));
            ActPort.Text = row == null ? "" : CheckDate(row.Get<Consignment, DateTime>(x => x.ActualPortArrival));
            ActArrival.Text = row == null ? "" : CheckDate(row.Get<Consignment, DateTime>(x => x.ActualWarehouseArrival));

            //Status.Text = row == null ? "" : row.Get<Consignment, string>(x => x.Status);
        }

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

            Consignments.SelectedCategory = (Guid)CategoryList.SelectedValue;

            settings.SelectedCategory = Consignments.SelectedCategory;
            new UserConfiguration<ConsignmentScreenSettings>().Save(settings);

            Refresh();
        }

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

            Consignments.SelectedType = (Guid)TypeList.SelectedValue;

            settings.SelectedType = Consignments.SelectedType;
            new UserConfiguration<ConsignmentScreenSettings>().Save(settings);

            Refresh();
        }

        private void LoadLookups<T>(MultiQuery query, List<Tuple<Guid, string>> lookups, Expression<Func<T, string>> display) where T : Entity
        {
            var table = query.Get<T>();
            foreach (var row in table.Rows)
                lookups.Add(new Tuple<Guid, string>(row.Get<T, Guid>(c => c.ID), row.Get(display)));
        }

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

            Consignments.ShowAll = StatusList.SelectedIndex == 1;

            settings.ShowAll = Consignments.ShowAll;
            new UserConfiguration<ConsignmentScreenSettings>().Save(settings);

            Refresh();
        }

        private void Search_KeyUp(object sender, KeyEventArgs e)
        {
        }

        private void SplitPanel_OnChanged(object sender, DynamicSplitPanelSettings e)
        {
            settings.ViewType = SplitPanel.View == DynamicSplitPanelView.Master ? ScreenViewType.Register :
                SplitPanel.View == DynamicSplitPanelView.Detail ? ScreenViewType.Details : ScreenViewType.Combined;
            settings.AnchorWidth = SplitPanel.AnchorWidth;

            var newTag = settings.ViewType == ScreenViewType.Register ? settings.ViewType.ToString() : "";
            if (Consignments.ColumnsTag != newTag)
            {
                Consignments.ColumnsTag = newTag;
                Consignments.Refresh(true, true);
            }

            new UserConfiguration<ConsignmentScreenSettings>().Save(settings);
        }

        private void ConsignmentParcels_OnOnSelectItem(object sender, DynamicGridSelectionEventArgs e)
        {
            ConsignmentItems.ParcelID = 
                ConsignmentParcels.SelectedRows.FirstOrDefault()?.Get<ConsignmentParcel, Guid>(x => x.ID) ??
                CoreUtils.FullGuid;
            ConsignmentItems.Refresh(false,true);
        }
    }
}