prs/prs.desktop/Forms/DeliveryBuilder.xaml.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Media;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.Reports;
using InABox.Core.Reports;
using InABox.Wpf;
using InABox.Wpf.Reports;
using InABox.WPF;
using Motorola.Snapi;
using Motorola.Snapi.Constants.Enums;
using Motorola.Snapi.EventArguments;

namespace PRSDesktop
{
    /// <summary>
    ///     Interaction logic for DeliveryBuilder.xaml
    /// </summary>
    public partial class DeliveryBuilder : ThemableWindow
    {
        private Guid _deliveryid = Guid.Empty;
        private readonly Guid _me = Guid.Empty;
        private Guid _orderid = Guid.Empty;

        private readonly Dictionary<CodeStatus, BeepPattern> BeepList = new()
        {
            { CodeStatus.Initialized, BeepPattern.FastWarble },
            { CodeStatus.Opened, BeepPattern.ThreeHighShort },
            { CodeStatus.Closed, BeepPattern.ThreeLowShort },
            { CodeStatus.Added, BeepPattern.LowHigh },
            { CodeStatus.Removed, BeepPattern.HighLow },
            { CodeStatus.NotFound, BeepPattern.FourLowLong },
            { CodeStatus.Error, BeepPattern.FourLowShort }
        };


        private readonly CoreTable Deliveries;
        private CoreTable Order;
        private CoreTable OrderItems = null;

        public List<IMotorolaBarcodeScanner> Scanners = new();

        private DynamicGridRowStyle _rowStyle;

        public DeliveryBuilder(Guid deliveryid, Guid orderid)
        {
            InitializeComponent();

            var me = new Client<Employee>().Query(new Filter<Employee>(x => x.UserLink.ID).IsEqualTo(ClientFactory.UserGuid),
                new Columns<Employee>().Default(ColumnType.ExcludeVisible));
            _me = me.Rows.Any() ? me.Rows.First().Get<Employee, Guid>(x => x.ID) : Guid.Empty;

            Deliveries = new Client<Delivery>().Query(
                new Filter<Delivery>(x => x.Completed).IsEqualTo(DateTime.MinValue)
            );
            _deliveryid = deliveryid;
            _orderid = orderid;
            Items.OnChanged += ItemsChanged;
            Items.OnGetRowStyle += Items_GetStyle;
        }

        private DynamicGridStyle Items_GetStyle(CoreRow row, DynamicGridStyle defaultstyle)
        {
            if (_rowStyle == null)
                _rowStyle = new DynamicGridRowStyle(defaultstyle) { Background = new SolidColorBrush(Colors.LightYellow) };
            return _rowStyle;
        }

        private void ItemsChanged(IDynamicGrid sender)
        {
            PrintButton.IsEnabled = Items.DeliveryDocketReady();
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            BarcodeScannerManager.Instance.Open();

            BarcodeScannerManager.Instance.RegisterForEvents(EventType.Barcode, EventType.Pnp, EventType.Image, EventType.Other, EventType.Rmd);

            BarcodeScannerManager.Instance.GetDevices();
            foreach (var scanner in BarcodeScannerManager.Instance.GetDevices())
            {
                Scanners.Add(scanner);
                scanner.Actions.ToggleLed(LedMode.RedOn);
            }

            Beep(CodeStatus.Initialized);

            BarcodeScannerManager.Instance.DataReceived += Instance_DataReceived;

            if (_deliveryid != Guid.Empty && _orderid != Guid.Empty)
            {
                CheckCode(null, string.Format("Delivery{0}Order{1}", _deliveryid, _orderid));
                PrintButton.IsEnabled = Items.DeliveryDocketReady();
            }
        }

        private void Window_Unloaded(object sender, RoutedEventArgs e)
        {
            foreach (var scanner in Scanners) scanner.Actions.ToggleLed(LedMode.GreenOff);
            BarcodeScannerManager.Instance.DataReceived -= Instance_DataReceived;

            BarcodeScannerManager.Instance.Close();
        }

        private void Beep(CodeStatus status)
        {
            foreach (var scanner in BarcodeScannerManager.Instance.GetDevices())
            {
                if (status == CodeStatus.Opened)
                    scanner.Actions.ToggleLed(LedMode.GreenOn);
                else if (status == CodeStatus.Closed)
                    scanner.Actions.ToggleLed(LedMode.RedOn);
                scanner.Actions.SoundBeeper(BeepList[status]);
            }
        }

        private void WaitBeep()
        {
            foreach (var scanner in BarcodeScannerManager.Instance.GetDevices())
            {
                scanner.Actions.ToggleLed(LedMode.YellowOn);
                scanner.Actions.SoundBeeper(BeepPattern.OneHighShort);
            }
        }

        private void Instance_DataReceived(object sender, BarcodeScanEventArgs e)
        {
            Dispatcher.Invoke(() => { CheckCode(Scanners[(int)e.ScannerId], e.Data); });
        }

        private void CheckCode(IMotorolaBarcodeScanner scanner, string code)
        {
            if (code.Contains("Delivery") && code.Contains("Order"))
            {
                var barcodes = code.Split(new[] { "Delivery", "Order" }, StringSplitOptions.RemoveEmptyEntries);
                if (barcodes.Length != 2)
                {
                    MessageBox.Show(string.Format("Bad Delivery Barcode: {0} -> {1}", code, string.Join(" / ", barcodes)));
                    return;
                }

                if (!Guid.TryParse(barcodes[0], out var deliveryid))
                {
                    MessageBox.Show(string.Format("Bad Delivery Guid: {0}", barcodes[0]));
                    return;
                }

                _deliveryid = deliveryid;

                if (!Guid.TryParse(barcodes[1], out var orderid))
                {
                    MessageBox.Show(string.Format("Bad Order Guid: {0}", barcodes[1]));
                    return;
                }

                _orderid = orderid;

                var delrow = Deliveries.Rows.FirstOrDefault(row => row.Get<Delivery, Guid>(x => x.ID).Equals(deliveryid));
                if (delrow == null)
                {
                    MessageBox.Show(string.Format("Cannot Find Delivery: {0}", deliveryid));
                    return;
                }

                DeliveryNumber.Text = delrow.Get<Delivery, int>(x => x.Number).ToString();

                DeliveryNotes.Text = delrow.Get<Delivery, string>(x => x.Notes);

                Items.DeliveryID = delrow.Get<Delivery, Guid>(x => x.ID);
                Items.OrderID = orderid;

                new Client<PurchaseOrder>().Query(
                    new Filter<PurchaseOrder>(x => x.ID).IsEqualTo(orderid),
                    null,
                    null,
                    (o, e) =>
                    {
                        Dispatcher.Invoke(() =>
                        {
                            Order = o;
                            var ordrow = o.Rows.FirstOrDefault();
                            OrderNumber.Text = ordrow != null ? ordrow.Get<PurchaseOrder, string>(x => x.PONumber) : "";
                            Supplier.Text = ordrow != null ? ordrow.Get<PurchaseOrder, string>(x => x.SupplierLink.Name) : "";
                        });
                    }
                );

                PrintButton.IsEnabled = Items.DeliveryDocketReady();
            }
            else if (code.Contains("OrderItem"))
            {
                var barcodes = code.Split(new[] { "OrderItem" }, StringSplitOptions.RemoveEmptyEntries);
                try
                {
                    Items.CheckCode(Guid.Parse(barcodes.First()));
                    Items.Refresh(false, true);
                }
                catch (Exception e)
                {
                    MessageBox.Show(e.Message);
                }

                PrintButton.IsEnabled = Items.DeliveryDocketReady();
            }
            else
            {
                MessageBox.Show("Bad Code: " + code);
            }
        }

        private void PrintButton_Click(object sender, RoutedEventArgs e)
        {
            var model = new DeliveryDataModel(new Filter<Delivery>(x => x.ID).IsEqualTo(_deliveryid));
            var templatename = "Print Treatment Delivery Docket";
            var sectionName = "Factory Floor - Treatment PO";

            var template = new Client<ReportTemplate>()
                .Load(
                    new Filter<ReportTemplate>(x => x.Name).IsEqualTo(templatename)
                        .And(x => x.DataModel).IsEqualTo(model.Name)
                        .And(x => x.Section).IsEqualTo(sectionName)
                ).FirstOrDefault();
            if (template == null)
            {
                template = new ReportTemplate
                {
                    DataModel = model.Name,
                    Section = sectionName,
                    Name = templatename
                };
                new Client<ReportTemplate>().Save(template, "Auto Created Report Template");
            }

            var delrow = Deliveries.Rows.FirstOrDefault(r => r.Get<Delivery, Guid>(c => c.ID).Equals(_deliveryid));
            if (delrow == null)
            {
                Progress.Close();
                MessageBox.Show("Cannot Find Delivery!");
                return;
            }

            ReportUtils.PreviewReport(template, model, !Security.IsAllowed<CanDesignReports>(), Security.IsAllowed<CanDesignReports>());

            SendDeliveryNotification(delrow.Get<Delivery, int>(x => x.Number));
        }

        private void SendDeliveryNotification(int DeliveryNumber)
        {
            var updates = new List<Notification>();
            var roles = new Client<EmployeeRole>().Query(new Filter<EmployeeRole>(x => x.RoleLink.Code).IsEqualTo("DELIVERIES"));
            foreach (var role in roles.Rows)
            {
                var notification = new Notification
                {
                    Title = string.Format("Treatment Delivery #{0} has been raised", DeliveryNumber),
                    Description = "The above Delivery has been created, and is ready to be shipped to the relevant supplier."
                };
                notification.Sender.ID = _me;
                notification.Employee.ID = role.Get<EmployeeRole, Guid>(x => x.EmployeeLink.ID);
                updates.Add(notification);
            }

            new Client<Notification>().Save(updates, "Sent Notification");
        }

        private enum CodeStatus
        {
            Initialized,
            Opened,
            Closed,
            Added,
            Removed,
            Error,
            NotFound
        }
    }
}