prs/prs.desktop/Panels/Delivery/DeliveryPanel.xaml.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
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 DeliveryPanel.xaml
    /// </summary>
    public partial class DeliveryPanel : UserControl, IPanel<Delivery>, IMasterDetailControl<Job>
    {

        private Delivery _delivery = new Delivery();
        private DeliveryScreenSettings settings;

        public DeliveryPanel()
        {
            InitializeComponent();
            Deliveries.OnSelectItem += Deliveries_OnSelectItem;
            Requis.OnChanged += OnChanged;
            Racks.OnChanged += OnChanged;
            Equipment.OnChanged += OnChanged;
            Bookings.LoadSettings += (sender) => new UserConfiguration<CalendarSettings>("Deliveries").Load();
            Bookings.SaveSettings += (sender, properties) => new UserConfiguration<CalendarSettings>("Deliveries").Save(properties);
            Bookings.HeaderVisibility = Visibility.Visible;
        }
        
        public Job? Master
        {
            get => Deliveries.Master;
            set => Deliveries.Master = value;
        }
        
        public bool IsReady { get; set; }

        public event DataModelUpdateEvent? OnUpdateDataModel;
        
        private CalendarSettings Bookings_OnLoadSettings(object sender) => 
            new UserConfiguration<CalendarSettings>("Deliveries").Load();
        
        private void Bookings_OnSaveSettings(object sender, CalendarSettings properties) =>
            new UserConfiguration<CalendarSettings>("Deliveries").Save(properties);
        
        public void Setup()
        {
            settings = new UserConfiguration<DeliveryScreenSettings>().Load();
            SplitPanel.View = settings.ViewType == ScreenViewType.Register ? DynamicSplitPanelView.Master :
                settings.ViewType == ScreenViewType.Details ? DynamicSplitPanelView.Detail : DynamicSplitPanelView.Combined;
            SplitPanel.AnchorWidth = settings.AnchorWidth;

            Bookings.Setup();
            
            Deliveries.ColumnsTag = settings.ViewType == ScreenViewType.Register ? settings.ViewType.ToString() : "";
            Deliveries.Refresh(true, false);
            Items.Refresh(true, false);
            Racks.Refresh(true, false);
            Requis.Refresh(true, false);
            Equipment.Refresh(true, false);
        }

        public void Shutdown(CancelEventArgs? cancel)
        {
        }

        public void CreateToolbarButtons(IPanelHost host)
        {
            if (Security.CanView<DeliveryType>())
            {
                host.CreateSetupAction(new PanelAction
                {
                    Caption = "Delivery Types",
                    Image = PRSDesktop.Resources.truck,
                    OnExecute = (action) =>
                    {
                        var list = new MasterList(typeof(DeliveryType));
                        list.ShowDialog();
                    }
                });
            }
            
            if (Security.IsAllowed<CanCompleteDeliveries>())
                host.CreatePanelAction(new PanelAction
                    { Caption = "Mark As Delivered", Image = PRSDesktop.Resources.barcode, OnExecute = MarkAsDelivered });

            if (Security.IsAllowed<CanArchiveDeliveries>())
                host.CreatePanelAction(
                    new PanelAction { Caption = "Archive Delivery", Image = PRSDesktop.Resources.archive, OnExecute = ArchiveDelivery });
        }

        public string SectionName => "Deliveries";

        public DataModel DataModel(Selection selection)
        {
            var ids = Deliveries.ExtractValues(x => x.ID, selection).ToArray();
            return new DeliveryDataModel(new Filter<Delivery>(x => x.ID).InList(ids));
        }

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

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

        public void Heartbeat(TimeSpan time)
        {
        }

        private void OnChanged(object? sender, EventArgs args)
        {
            Deliveries.Refresh(false, false);
        }

        private void ArchiveDelivery(PanelAction obj)
        {
            if (!Deliveries.SelectedRows.Any())
            {
                MessageBox.Show("Please select a Delivery first!");
                return;
            }

            var completed = Deliveries.SelectedRows.First().Get<Delivery, DateTime>(x => x.Completed);
            if (!completed.IsEmpty())
            {
                MessageBox.Show("Delivery has already been completed!");
                return;
            }

            var delivered = Deliveries.SelectedRows.First().Get<Delivery, DateTime>(x => x.Delivered);
            if (delivered.IsEmpty())
            {
                MessageBox.Show("This Delivery must be marked as delivered before it can be Archived.");
                return;
            }

            if (MessageBox.Show("This will archive this delivery, and remove it from the active deliveries list.\n\nDo you wish to continue?",
                    "Confirmation", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.No)
                return;

            Progress.Show("Archiving Delivery");
            try
            {
                var notification = new DeliveryNotification();
                notification.Delivery.ID = Deliveries.SelectedRows.First().Get<Delivery, Guid>(x => x.ID);
                new Client<DeliveryNotification>().Save(notification, "Manual Delivery Notification");

                var delivery = new Delivery
                {
                    Number = Deliveries.SelectedRows.First().Get<Delivery, int>(x => x.Number),
                    Completed = DateTime.Now
                }.SetID(Deliveries.SelectedRows.First().Get<Delivery, Guid>(x => x.ID));
                new Client<Delivery>().Save(delivery, "Marked as Completed");
            }
            finally
            {
                Progress.Close();
            }

            MessageBox.Show("Delivery Archived");

            Deliveries.Refresh(false, true);
        }

        private void MarkAsDelivered(PanelAction obj)
        {
            if (!Deliveries.SelectedRows.Any())
            {
                MessageBox.Show("Please select a Delivery first!");
                return;
            }

            var completed = Deliveries.SelectedRows.First().Get<Delivery, DateTime>(x => x.Completed);
            if (!completed.IsEmpty())
            {
                MessageBox.Show("Delivery has already been completed!");
                return;
            }

            var docs = Deliveries.SelectedRows.First().Get<Delivery, int>(x => x.Documents);
            if (docs == 0 && !Security.IsAllowed<CanSkipDeliveryPhotos>())
            {
                MessageBox.Show("Please photograph these items before completing this delivery");
                return;
            }

            if (MessageBox.Show("Are you sure you wish to mark this Delivery as delivered?", "Confirmation", MessageBoxButton.YesNo) !=
                MessageBoxResult.Yes)
                return;

            Progress.Show("Completing Delivery");
            try
            {
                var delivery = new Delivery
                {
                    Number = Deliveries.SelectedRows.First().Get<Delivery, int>(x => x.Number),
                    Delivered = DateTime.Now
                }.SetID(Deliveries.SelectedRows.First().Get<Delivery, Guid>(x => x.ID));
                delivery.Job.ID = Deliveries.SelectedRows.First().Get<Delivery, Guid>(x => x.Job.ID);
                new Client<Delivery>().Save(delivery, "Marked as Delivered");
            }
            finally
            {
                Progress.Close();
            }

            MessageBox.Show("Delivery Completed");

            Deliveries.Refresh(false, true);
        }

        private void Deliveries_OnSelectItem(object sender, DynamicGridSelectionEventArgs e)
        {
            _delivery = e.Rows?.FirstOrDefault()?.ToObject<Delivery>() ?? new Delivery();
            
            Notes.Text = _delivery.Notes;
            
            Items.Master = _delivery;
            Items.Refresh(false, true);

            Racks.Master = _delivery;
            Racks.Refresh(false, true);

            Requis.Master = _delivery;
            Requis.Refresh(false, true);

            Equipment.Master = _delivery;
            Equipment.Refresh(false, true);
            
            Bookings.Refresh();
        }
        
        private void Deliveries_DeliveryChanged(object sender)
        {
            Bookings.Refresh();
        }

        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 (Deliveries.ColumnsTag != newTag)
            {
                Deliveries.ColumnsTag = newTag;
                Deliveries.Refresh(true, true);
            }

            new UserConfiguration<DeliveryScreenSettings>().Save(settings);
        }
        
        private void Bookings_OnCustomiseContextMenu(object sender, ICalendarDataEventArgs args)
        {
        
            if (sender is not ContextMenu menu)
                return;
            
            if (args is CalendarDataEventArgs<CalendarTimeSlot> slot)
            {
                menu.Items.Insert(0, new Separator());
                bool bDeliveries = false;
                var CreateBooking = new MenuItem { Header = "Book Delivery" };
                foreach (var row in Deliveries.Data.Rows)
                {
                    if (row.Get<Delivery, DateTime>(x => x.Assignment.Date).IsEmpty())
                    {
                        bDeliveries = true;
                        MenuItem item = new MenuItem();
                        String description = String.Format("{0}: ", row.Get<Delivery, int>(x => x.Number));
                        if (row.IsEntityLinkValid<Delivery, JobLink>(x => x.Job))
                        {
                            description = String.Format("{0} {1} ({2})",
                                description,
                                row.Get<Delivery, String>(x => x.Job.Name),
                                row.Get<Delivery, String>(x => x.Job.JobNumber)
                            );
                        }
                        else if (row.IsEntityLinkValid<Delivery, ContactLink>(x => x.Contact))
                        {
                            description = String.Format("{0} {1}",
                                description,
                                row.Get<Delivery, String>(x => x.Contact.Name)
                            );
                        }

                        item.Header = description;
                        item.Click += (o,e) =>
                        {
                            if (Deliveries.CreateBooking(row, slot.Item.EmployeeID, slot.Item.Time))
                                Refresh();
                        };
                        CreateBooking.Items.Add(item);
                    }
                }
                menu.Items.Insert(0,CreateBooking);
                
            }
        }

    }
}