prs/prs.mobile/comal.timesheets/StoreRequis/StoreRequiScannerPage.xaml.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Xamarin.Essentials;
using Xamarin.Forms;
using ZXing;
using ZXing;
using Xamarin.Forms;
using Xamarin.Forms.Xaml;
using comal.timesheets.CustomControls;
using Comal.Classes;
using InABox.Core;
using InABox.Clients;
using System.Threading;
using static comal.timesheets.RequiItems;
using XF.Material.Forms.UI.Dialogs;
using Plugin.SimpleAudioPlayer;
using comal.timesheets.StoreRequis;

namespace comal.timesheets
{
    [XamlCompilation(XamlCompilationOptions.Compile)]
    public partial class StoreRequiScannerPage : ContentPage
    {
        #region Fields / Constructor
        public delegate bool OnScanEvent(object sender, String barcode);
        public event OnScanEvent OnScan;
        List<StoreRequiItemShell> shells = new List<StoreRequiItemShell>();
        List<StoreRequiItemShell> oldShells = new List<StoreRequiItemShell>();
        Requisition requisition = new Requisition();
        bool loading = false;
        Dictionary<StoreRequiItemShell, string> itemRowScannerRawResultPairs = new Dictionary<StoreRequiItemShell, string>();
        Dictionary<StoreRequiItemShell, string> itemRowScannerProcessedResultPairs = new Dictionary<StoreRequiItemShell, string>();
        bool firstLoad = true;
        bool containsNotes = false;

        public StoreRequiScannerPage(Guid requiID)
        {
            InitializeComponent();
            ConfigAll(requiID);
        }
        #endregion

        #region Config
        void ConfigAll(Guid requiID)
        {
            NavigationPage.SetHasBackButton(this, false);
            SetScannerOptions();
            if (requiID != Guid.Empty)
            {
                requisition.ID = requiID;
                LoadExistingRequi();
            }
            if (!HoldingsLoaded)
            {
                Timer t = null;
                t = new Timer(new TimerCallback((object o) =>
                {
                    if (HoldingsLoaded)
                    {
                        Device.BeginInvokeOnMainThread(() =>
                        {
                            ConfigDisplay();
                        });
                        t.Dispose();

                    }
                }), null, 0, 500);
            }
            else
            {
                loadingLbl.IsVisible = false;
                addBtn.IsEnabled = true;
                Task.Run(() =>
                {
                    Thread.Sleep(1500);
                    Device.BeginInvokeOnMainThread(() => { ConfigDisplay(); });
                });
            }
        }
        void SetScannerOptions()
        {
            var options = new ZXing.Mobile.MobileBarcodeScanningOptions()
            {
                PossibleFormats = new List<ZXing.BarcodeFormat>() { ZXing.BarcodeFormat.QR_CODE },
                AutoRotate = false,
                TryInverted = true,
                TryHarder = true,
            };
            _scanView.Options = options;
            _scanView.IsAnalyzing = true;
            _scanView.IsScanning = true;
            _scanView.AutoFocus();
            _scanView.OnScanResult += ScanView_OnScanResult;
        }

        protected override void OnAppearing()
        {
            base.OnAppearing();
            if (!firstLoad)
                _scanView.IsAnalyzing = true;
        }

        protected override void OnDisappearing()
        {
            _scanView.IsAnalyzing = false;
            base.OnDisappearing();
        }

        async void LoadExistingRequi()
        {
            await Task.Run(() =>
            {
                requisition = new Client<Requisition>().Query(
                       new Filter<Requisition>(x => x.ID).IsEqualTo(requisition.ID)
                       ).Rows.FirstOrDefault().ToObject<Requisition>();
                if (!string.IsNullOrWhiteSpace(requisition.Request))
                {
                    StoreRequiItemShell shell1 = new StoreRequiItemShell()
                    {
                        IsNotes = true,
                        IsNotNotes = false,
                        Summary = requisition.Request,
                        BorderColor = Color.FromHex("#9f4576")
                    };
                    shells.Insert(0, shell1);
                    containsNotes = true;
                }
            });

            await Task.Run(() =>
            {
                CoreTable table = new Client<RequisitionItem>().Query
                   (
                   new Filter<RequisitionItem>(x => x.RequisitionLink.ID).IsEqualTo(requisition.ID),
                   new Columns<RequisitionItem>(
                       x => x.ID, //0
                       x => x.Product.ID, //1 
                       x => x.Product.Name, //2
                       x => x.Product.Code, //3
                       x => x.Quantity, //4
                       x => x.Holding.ID, //5
                       x => x.Holding.Location.Description //6
                       )
                   );
                if (table.Rows.Any())
                {
                    Device.BeginInvokeOnMainThread(() =>{ saveBtn.IsVisible = true; });
                        foreach (CoreRow row in table.Rows)
                    {
                        List<object> list = row.Values;
                        if (list[0] == null) { list[0] = Guid.Empty; }
                        if (list[1] == null) { list[1] = Guid.Empty; }
                        if (list[2] == null) { list[2] = ""; }
                        if (list[3] == null) { list[3] = ""; }
                        if (list[4] == null) { list[4] = 0.0; }
                        if (list[5] == null) { list[5] = Guid.Empty; }
                        if (list[6] == null) { list[6] = ""; }

                        StoreRequiItemShell shell = new StoreRequiItemShell()
                        {
                            ID = Guid.Parse(list[0].ToString()),
                            ProductID = Guid.Parse(list[1].ToString()),
                            ProductName = list[2].ToString(),
                            ProductCode = list[3].ToString(),
                            Quantity = double.Parse(list[4].ToString()),
                            HoldingID = Guid.Parse(list[5].ToString()),
                            LocationName = list[6].ToString(),
                        };
                        shells.Add(shell);
                        oldShells.Add(shell);
                    }
                }
                Device.BeginInvokeOnMainThread(() =>
                {
                    requiItemListView.ItemsSource = shells;
                    if (containsNotes)
                    {
                        countLbl.Text = "Number of items: " + (shells.Count - 1);
                    }
                    else
                    {
                        countLbl.Text = "Number of items: " + shells.Count;
                    }
                });
            });
        }

        void ConfigDisplay()
        {
            loadingLbl.IsVisible = false;
            addBtn.IsEnabled = true;
            double width = scannerGrid.Width / 6;
            double height = scannerGrid.Height / 6;
            lblv1.WidthRequest = height / 2;
            lblh1.IsVisible = true;
            lblv1.IsVisible = true;
            lblv2.WidthRequest = height / 2;
            lblh2.IsVisible = true;
            lblv2.IsVisible = true;
            lblv3.WidthRequest = height / 2;
            lblh3.IsVisible = true;
            lblv3.IsVisible = true;
            lblv4.WidthRequest = height / 2;
            lblh4.IsVisible = true;
            lblv4.IsVisible = true;
            scannerGrid.RaiseChild(lblv1);
            scannerGrid.RaiseChild(lblh1);
            scannerGrid.RaiseChild(lblv2);
            scannerGrid.RaiseChild(lblh2);
            scannerGrid.RaiseChild(lblv3);
            scannerGrid.RaiseChild(lblh3);
            scannerGrid.RaiseChild(lblv4);
            scannerGrid.RaiseChild(lblh4);
            firstLoad = false;
        }
        #endregion

        #region Scanning
        private void ScanView_OnScanResult(ZXing.Result result)
        {
            Device.BeginInvokeOnMainThread(async () =>
            {
                if (!loading)
                {
                    loading = true;
                    if (RequiItems.HoldingsLoaded)
                    {
                        bool bOK = true;
                        if (OnScan != null)
                            bOK = OnScan(this, result.Text);
                        if (bOK)
                        {
                            if (!itemRowScannerRawResultPairs.Values.Contains(result.Text))
                            {
                                if (!itemRowScannerProcessedResultPairs.Values.Contains(result.Text))
                                {
                                    Vibration.Vibrate();
                                    var player = Plugin.SimpleAudioPlayer.CrossSimpleAudioPlayer.Current;
                                    player.Load("requiitemadded.mp3");
                                    player.Play();
                                    using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Adding"))
                                    {
                                        string rawResult = result.Text;
                                        Tuple<string, double> tuple = ProcessResult(result.Text);
                                        LoadProduct(tuple, rawResult);
                                    }
                                }
                                else
                                {
                                    loading = false;
                                }
                            }
                            else
                            {
                                loading = false;
                            }
                        }
                        else
                        {
                            loading = false;
                        }
                    }
                    else
                    {
                        loading = false;
                    }
                }
            });
        }
        private Tuple<string, double> ProcessResult(string result)
        {
            double qty = 1;
            if (result.Contains("*"))
            {
                try
                {
                    int i = result.IndexOf("*");
                    string remainder = result.Substring(i);
                    result = result.Remove(i);
                    string s1 = remainder.Substring(1);
                    qty = Convert.ToDouble(s1);
                }
                catch
                {
                    loading = false;
                }
            }
            Tuple<string, double> tuple = new Tuple<string, double>(result, qty);
            return tuple;
        }

        private async void LoadProduct(Tuple<string, double> processedResultQtyTuple, string rawResult)
        {
            Device.BeginInvokeOnMainThread(async () =>
            {
                //lookup product in productshells cache
                ProductShell product = GlobalVariables.ProductShells.Find(x => x.Code.Equals(processedResultQtyTuple.Item1));

                string itemLocation = "";
                Guid holdingID = Guid.Empty;

                //lookup holding for product in holdings cache
                try
                {
                    List<HoldingsCacheShell> list = holdingsCache.Where(x => x.ProductID.Equals(product.ID)).ToList();
                    if (list.Count == 1) //one stockholding - auto choose shelf
                    {
                        HoldingsCacheShell holding = list.First();
                        itemLocation = holding.LocationName;
                        holdingID = holding.ID;
                    }
                    else if (list.Count > 1)  //more than one stockholding - choose shelf
                    {
                        loading = true;
                        Dictionary<string, Guid> holdingIDLocations = new Dictionary<string, Guid>();
                        foreach (HoldingsCacheShell holding in list)
                        {
                            if (!holdingIDLocations.ContainsKey(holding.LocationName + " (Units: " + holding.Units + ")"))
                            {
                                holdingIDLocations.Add(holding.LocationName + " (Units: " + holding.Units + ")" + 
                                    Environment.NewLine + "Style: " + holding.StyleDescription
                                    + Environment.NewLine + "Job: " + holding.JobNumber
                                    + Environment.NewLine + "Size: " + holding.DimensionsUnitSize, holding.ID);
                            }
                        }
                        List<string> options = holdingIDLocations.Keys.ToList();
                        ListSelectionPage page = new ListSelectionPage(options);
                        page.OnSimpleListTapped += (s) => 
                        {
                            itemLocation = s;
                            holdingID = holdingIDLocations[s];
                        };
                        Navigation.PushAsync(page);
                    }
                    else if (list.Count == 0)
                    {
                        DisplayAlert("No Holdings Found for Product", "", "OK");
                        loading = false;
                        return;
                    }
                }
                catch (Exception e)
                {
                    DisplayAlert("Error", e.Message, "OK");
                    loading = false;
                    return;
                }

                StoreRequiItemShell shell = new StoreRequiItemShell
                {
                    ProductID = product.ID,
                    ProductName = product.Name,
                    ProductCode = product.Code,
                    Quantity = 1,
                    HoldingID = holdingID,
                    LocationName = itemLocation,
                };
                shells.Add(shell);

                itemRowScannerRawResultPairs.Add(shell, rawResult);
                itemRowScannerProcessedResultPairs.Add(shell, processedResultQtyTuple.Item1);

                requiItemListView.ItemsSource = null;
                requiItemListView.ItemsSource = shells;

                countLbl.IsVisible = true;

                if (containsNotes)
                {
                    countLbl.Text = "Number of items: " + (shells.Count - 1);
                }
                else
                {
                    countLbl.Text = "Number of items: " + shells.Count;
                }

                saveBtn.IsVisible = true;
                loading = false;
            });
        }
        #endregion

        #region Button Presses
        private async void ExitBtn_Clicked(object sender, EventArgs e)
        {
            if (shells.Count > 0)
            {
                if (containsNotes && shells.Count > 1)
                {
                    string chosenOption = await DisplayActionSheet("Leave without saving?", "Cancel", null, "Yes", "No");
                    switch (chosenOption)
                    {
                        case "Cancel":
                            return;
                        case "Yes":
                            Navigation.PopAsync();
                            break;
                        case "No":
                            return;
                        default:
                            return;
                    }
                }
                else if (containsNotes && shells.Count == 1)
                {
                    Navigation.PopAsync();
                }
                else
                {
                    string chosenOption = await DisplayActionSheet("Leave without saving?", "Cancel", null, "Yes", "No");
                    switch (chosenOption)
                    {
                        case "Cancel":
                            return;
                        case "Yes":
                            Navigation.PopAsync();
                            break;
                        case "No":
                            return;
                        default:
                            return;
                    }
                }               
            }
            else
                Navigation.PopAsync();

        }

        void SaveBtn_Clicked(object sender, EventArgs e)
        {
            StoreRequiConfirmationPage page = new StoreRequiConfirmationPage(requisition, shells, oldShells);
            page.OnSaveSelected += () => { Navigation.PopAsync(); };
            Navigation.PushAsync(page);
        }

        void ReduceQtyBtn_Clicked(object sender, EventArgs e)
        {
            var shell = ((TappedEventArgs)e).Parameter as StoreRequiItemShell;
            if (shell == null) return;

            if (shell.Quantity <= 1)
            {
                shells.Remove(shell);
                itemRowScannerRawResultPairs.Remove(shell);
                itemRowScannerProcessedResultPairs.Remove(shell);
                if (containsNotes)
                {
                    countLbl.Text = "Number of items: " + (shells.Count - 1);
                    if (shells.Count == 1)
                    {
                        saveBtn.IsVisible = false;
                    }
                }
                else
                {
                    countLbl.Text = "Number of items: " + shells.Count;
                    if (shells.Count == 0)
                    {
                        saveBtn.IsVisible = false;
                    }
                }
            }
            else
            {
                shell.Quantity--;
            }
            requiItemListView.ItemsSource = null;
            requiItemListView.ItemsSource = shells;
        }

        void IncreaseQtyBtn_Clicked(object sender, EventArgs e)
        {
            var shell = ((TappedEventArgs)e).Parameter as StoreRequiItemShell;
            if (shell == null) return;

            shell.Quantity++;
            requiItemListView.ItemsSource = null;
            requiItemListView.ItemsSource = shells;
        }

        void AddItem_Clicked(object sender, EventArgs e)
        {
            if (GlobalVariables.ProductsLoaded)
            {
                if (loading)
                    return;
                loading = true;
                ProductList products = new ProductList(GlobalVariables.ProductShells, true);
                products.OnProductSelected += () =>
                {
                    Tuple<string, double> tuple = new Tuple<string, double>(products.SelectedProduct.Code, 1);

                    LoadProduct(new Tuple<string, double>(products.SelectedProduct.Code, 1), products.SelectedProduct.Code);
                };
                Navigation.PushAsync(products);
            }
        }

        void Qty_Changed(object sender, EventArgs e)
        {

        }
        #endregion
    }

    public class StoreRequiItemShell
    {
        public Guid ID { get; set; }
        public Guid ProductID { get; set; }
        public string ProductCode { get; set; }
        public string ProductName { get; set; }
        public string LocationName { get; set; }
        public double Quantity { get; set; }
        public Guid HoldingID { get; set; }
        public Color BorderColor { get; set; }
        public bool IsNotes { get; set; }
        public bool IsNotNotes { get; set; }
        public string Summary { get; set; }
        public StoreRequiItemShell()
        {
            ProductID = Guid.Empty;
            ProductCode = "";
            ProductName = "";
            LocationName = "";
            Quantity = 0;
            ID = Guid.Empty;
            HoldingID = Guid.Empty;
            BorderColor = Color.FromHex("#15C7C1");
            IsNotes = false;
            IsNotNotes = true;
        }
    }
}