prs/prs.mobile.new/PRS.Mobile/Modules/Warehousing/Transfer/RecTransCompletion.xaml.cs

using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using System.Transactions;
using Xamarin.Essentials;
using Xamarin.Forms;
using Xamarin.Forms.Xaml;
using XF.Material.Forms.UI.Dialogs;

namespace PRS.Mobile
{
    [XamlCompilation(XamlCompilationOptions.Compile)]
    public partial class RecTransCompletion 
    {
        public delegate void RecTransCompleted();
        public event RecTransCompleted OnRecTransCompleted;
        List<StockHoldingShell_Old> receivingShells = new List<StockHoldingShell_Old>();
        List<StockHoldingShell_Old> originalHoldings = new List<StockHoldingShell_Old>();
        StockLocation issuingLocation = new StockLocation();
        StockLocation receivingLocation = new StockLocation();
        Job receivingJob = new Job();
        Dictionary<Image, Document> imagesDocuments = new Dictionary<Image, Document>();
        List<string> favourites = new List<string>
        { "Issued to Cutting","Issued to Factory" , "Transferred For Painting", "Returned From Painting",
            "Received on PO", "Issued to Site" };
        public RecTransCompletion(List<StockHoldingShell_Old> _receivingShells, List<StockHoldingShell_Old> _originalHoldings, StockLocation _issuingLocation, StockLocation _receivingLocation, Job _receivingJob)
        {
            InitializeComponent();
            receivingShells = _receivingShells;
            issuingLocation = _issuingLocation;
            receivingLocation = _receivingLocation;
            originalHoldings = _originalHoldings;
            receivingJob = _receivingJob;
            AddFavButtons();
            if (receivingLocation.ID != Guid.Empty)
                DownloadIssuingLocation();
        }

        private void AddFavButtons()
        {
            foreach (string s in favourites)
            {
                Button button = new Button
                {
                    Text = s,
                    TextColor = Color.White,
                    BackgroundColor = Color.FromHex("#15C7C1"),
                    CornerRadius = 10,
                    Margin = 2,
                    FontAttributes = FontAttributes.Bold,
                    VerticalOptions = LayoutOptions.Center,
                    HorizontalOptions = LayoutOptions.Center,
                    Padding = new Thickness(6, 3, 6, 3)
                };
                button.Clicked += FavButton_Clicked;
                optionsFlexLayout.Children.Add(button);
            }
        }

        private void FavButton_Clicked(object sender, EventArgs e)
        {
            Button button = sender as Button;
            if (string.IsNullOrWhiteSpace(notesEdt.Text))
            {
                notesEdt.Text = button.Text;
            }
            else
            {
                notesEdt.Text = notesEdt.Text + " " + button.Text;
            }

        }

        private async void DownloadIssuingLocation()
        {
            await Task.Run(() =>
            {
                CoreTable table = new Client<StockLocation>().Query
                (
                new Filter<StockLocation>(x => x.ID).IsEqualTo(issuingLocation.ID),
                new Columns<StockLocation>(x => x.ID, x => x.Code, x => x.Description)
                 );
                issuingLocation = table.Rows.First().ToObject<StockLocation>();
            });
        }



        private async void SaveBatch_Clicked(object sender, EventArgs e)
        {
            using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Saving"))
            {
                // Create a Stock Movement Batch - save and wait for return
                StockMovementBatch batch = new StockMovementBatch()
                {
                    Notes = notesEdt.Text
                };
                if (receivingLocation.ID != Guid.Empty)
                {
                    batch.Type = StockMovementBatchType.Transfer;
                }
                else if (receivingJob.ID != Guid.Empty)
                {
                    batch.Type = StockMovementBatchType.Issue;
                }
                new Client<StockMovementBatch>().Save(batch, "Created on mobile");

                // Save photos - async, no wait needed
                SavePhotos(batch.ID);

                var movements = new List<StockMovement>();

                if (receivingLocation.ID != Guid.Empty)
                {
                    foreach (var shell in receivingShells)
                    {
                        var transaction = Guid.NewGuid();

                        var issue = IssueStockMovement(shell,
                            CreateStockMovement(shell, batch, transaction, StockMovementType.TransferOut, issuingLocation));
                        var receive = ReceiveStockMovement(shell,
                            CreateStockMovement(shell, batch, transaction, StockMovementType.TransferIn, receivingLocation));

                        movements.Add(issue);
                        movements.Add(receive);
                    }
                }
                else if (receivingJob.ID != Guid.Empty)
                {
                    foreach (StockHoldingShell_Old shell in receivingShells)
                    {
                        var transaction = Guid.NewGuid();

                        var originalShell = originalHoldings.First(x => x.ID == shell.ID);
                        if (receivingJob.ID != originalShell.JobID)
                        {
                            // Issue from original job
                            var issueToJob = IssueStockMovement(shell,
                                CreateStockMovement(shell, batch, transaction, StockMovementType.TransferOut, issuingLocation));

                            // to new job
                            var receiveToJob = ReceiveStockMovement(shell,
                                CreateStockMovement(shell, batch, transaction, StockMovementType.TransferIn, issuingLocation));
                            receiveToJob.Job.ID = receivingJob.ID;
                            receiveToJob.Style.ID = originalShell.StyleID;
                            receiveToJob.System = true;

                            // Issue from new job
                            var issueFromJob = IssueStockMovement(shell,
                                CreateStockMovement(shell, batch, transaction, StockMovementType.Issue, issuingLocation));
                            issueFromJob.Job.ID = receivingJob.ID;
                            issueFromJob.System = true;

                            movements.Add(issueToJob);
                            movements.Add(receiveToJob);
                            movements.Add(issueFromJob);
                        }
                        else
                        {
                            var issue = IssueStockMovement(shell,
                                CreateStockMovement(shell, batch, transaction, StockMovementType.Issue, issuingLocation));
                            movements.Add(issue);
                        }
                    }
                }

                Task.Run(() =>
                {
                    new Client<StockMovement>().Save(movements, "Updated from mobile device");
                });

                Device.BeginInvokeOnMainThread(async () =>
                {
                    saveBatchBtn.IsVisible = false;
                    await DisplayAlert("Success", "Batch Saved", "OK");
                    OnRecTransCompleted?.Invoke();
                    Navigation.PopAsync();
                });
            }
        }

        private StockHoldingShell_Old GetOriginalShell(StockHoldingShell_Old shell)
        {
            return originalHoldings.First(x => x.ID == shell.ID);
        }

        private StockMovement CreateStockMovement(StockHoldingShell_Old shell, StockMovementBatch batch, Guid transaction, StockMovementType type,
            StockLocation location)
        {
            var movement = new StockMovement();
            movement.Batch.ID = batch.ID;
            movement.Date = DateTime.Now;
            if (batch.Type == StockMovementBatchType.Transfer)
                movement.IsTransfer = true;
            movement.Type = type;
            movement.Transaction = transaction;
            movement.Notes = notesEdt.Text;
            movement.Dimensions.Unit.ID = shell.DimensionsUnitID;
            movement.Dimensions.Quantity = shell.DimensionsQuantity;
            movement.Dimensions.Length = shell.DimensionsLength;
            movement.Dimensions.Width = shell.DimensionsWidth;
            movement.Dimensions.Height = shell.DimensionsHeight;
            movement.Dimensions.Weight = shell.DimensionsWeight;
            movement.Dimensions.Unit.HasHeight = shell.DimensionsHasHeight;
            movement.Dimensions.Unit.HasLength = shell.DimensionsHasLength;
            movement.Dimensions.Unit.HasWidth = shell.DimensionsHasWidth;
            movement.Dimensions.Unit.HasWeight = shell.DimensionsHasWeight;
            movement.Dimensions.Unit.HasQuantity = shell.DimensionsHasQuantity;
            movement.Dimensions.Unit.Formula = shell.DimensionsUnitFormula;
            movement.Dimensions.Unit.Format = shell.DimensionsUnitFormat;
            movement.Dimensions.Unit.Code = shell.DimensionsUnitCode;
            movement.Dimensions.Unit.Description = shell.DimensionsUnitDescription;
            movement.Dimensions.UnitSize = shell.DimensionsUnitSize;
            movement.Dimensions.Value = shell.DimensionsValue;
            movement.Product.ID = shell.ProductID;
            movement.Product.Code = shell.Code;
            movement.Product.Name = shell.Name;
            movement.Employee.ID = App.Data.Me.ID;
            movement.Employee.Name = App.Data.Me.Name;

            movement.Location.ID = location.ID;
            movement.Location.Code = location.Code;
            movement.Location.Description = location.Description;

            return movement;
        }

        private StockMovement IssueStockMovement(StockHoldingShell_Old shell, StockMovement movement)
        {
            var originalShell = GetOriginalShell(shell);

            movement.Style.ID = originalShell.StyleID;
            movement.Style.Code = originalShell.StyleCode;
            movement.Style.Description = originalShell.Finish;

            movement.Job.ID = originalShell.JobID;
            movement.Job.JobNumber = originalShell.JobNumber;
            movement.Job.Name = originalShell.JobName;

            movement.Issued = shell.Units;

            return movement;
        }

        private StockMovement ReceiveStockMovement(StockHoldingShell_Old shell, StockMovement movement)
        {
            movement.Style.ID = shell.StyleID;
            movement.Style.Code = shell.StyleCode;
            movement.Style.Description = shell.Finish;

            movement.Job.ID = shell.JobID;
            movement.Job.JobNumber = shell.JobNumber;
            movement.Job.Name = shell.JobName;

            movement.Received = shell.Units;

            return movement;
        }

        #region Photos
        private async void SavePhotos(Guid batchID)
        {
            await Task.Run(() =>
            {
                new Client<Document>().Save(imagesDocuments.Values, "");

                // Link the photos to the batch
                List<StockMovementBatchDocument> stockMovementBatchDocuments = new List<StockMovementBatchDocument>();
                foreach (var doc in imagesDocuments.Values)
                {
                    var smd = new StockMovementBatchDocument();
                    smd.EntityLink.ID = batchID;
                    smd.DocumentLink.ID = doc.ID;
                    smd.DocumentLink.FileName = doc.FileName;
                    if (smd.EntityLink.ID != Guid.Empty)
                        stockMovementBatchDocuments.Add(smd);
                }
                new Client<StockMovementBatchDocument>().Save(stockMovementBatchDocuments, "");
            });
        }

        async void TakePhoto_Clicked(object sender, EventArgs e)
        {
            TakeAPhoto();
        }

        async void ChooseImage_Clicked(object sender, EventArgs e)
        {
            ChooseAPhoto();
        }

        private async void TakeAPhoto()
        {

            var file = await MediaPicker.CapturePhotoAsync();
            if (file == null)
                return;

            using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Adding Photo"))
            {
                Image img = null;
                var memoryStream = new MemoryStream();
                using (var stream = await file.OpenReadAsync())
                    await stream.CopyToAsync(memoryStream);
                var data = memoryStream.ToArray();

                Document doc = new Document()
                {
                    FileName = Path.GetFileName(file.FileName),
                    Data = data,
                    CRC = CoreUtils.CalculateCRC(data),
                    TimeStamp = DateTime.Now
                };

                ImageSource src = ImageSource.FromStream(() => new MemoryStream(data));
                img = new Image();
                img.HeightRequest = 150;
                img.WidthRequest = 150;
                img.Aspect = Aspect.AspectFit;
                img.Source = src;
                img.GestureRecognizers.Add(new TapGestureRecognizer
                {
                    Command = new Command(OnTap),
                    CommandParameter = src,
                    NumberOfTapsRequired = 1
                });

                imagesDocuments.Add(img, doc);
                
                if (img != null)
                {
                    Device.BeginInvokeOnMainThread(() =>
                    {
                        ImageScroller.IsVisible = true;
                        images.Children.Add(img);
                        UpdateColours();
                    });
                }
            }
        }

        private async void ChooseAPhoto()
        {
            var file = await MediaPicker.PickPhotoAsync();
            if (file == null)
                return;

            using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Adding Photo"))
            {
                Image img = null;
                var memoryStream = new MemoryStream();
                using (var stream = await file.OpenReadAsync())
                    await stream.CopyToAsync(memoryStream);
                var data = memoryStream.ToArray();

                Document doc = new Document()
                {
                    FileName = Path.GetFileName(file.FileName),
                    Data = data,
                    CRC = CoreUtils.CalculateCRC(data),
                    TimeStamp = DateTime.Now
                };

                ImageSource src = ImageSource.FromStream(() => new MemoryStream(data));
                img = new Image();
                img.HeightRequest = 150;
                img.WidthRequest = 150;
                img.Aspect = Aspect.AspectFit;
                img.Source = src;
                img.GestureRecognizers.Add(new TapGestureRecognizer
                {
                    Command = new Command(OnTap),
                    CommandParameter = src,
                    NumberOfTapsRequired = 1
                });

                imagesDocuments.Add(img, doc);
                
                if (img != null)
                {
                    Device.BeginInvokeOnMainThread(() =>
                    {
                        ImageScroller.IsVisible = true;
                        images.Children.Add(img);
                        UpdateColours();
                    });
                }
            }
        }

        private void OnTap(object obj)
        {
            ImageViewerPage viewer = new ImageViewerPage(obj as ImageSource, () => DeleteImage(obj));
            Navigation.PushAsync(viewer);
        }

        private void DeleteImage(object obj)
        {
            Image img = imagesDocuments.Keys.First(x => x.Source.Equals(obj as ImageSource));
            imagesDocuments.Remove(img);
            Device.BeginInvokeOnMainThread(() =>
            {
                images.Children.Clear();
                if (imagesDocuments.Count > 0)
                {
                    foreach (Image image in imagesDocuments.Keys)
                    {
                        images.Children.Add(image);
                    }
                }

                UpdateColours();
            });
        }

        #endregion

        #region Updating Screen
        private void NotesEdt_Changed(object sender, EventArgs e)
        {
            UpdateColours();
        }

        private void UpdateColours()
        {
            if (photosFrame.BorderColor == Color.Red)
            {
                if (imagesDocuments.Values.Count > 0)
                {
                    photosFrame.BorderColor = Color.Gray;
                }
            }
            if (!string.IsNullOrWhiteSpace(notesEdt.Text))
            {
                if (notesFrame.BorderColor == Color.Red)
                {
                    notesFrame.BorderColor = Color.Gray;
                }
            }
            else
            {
                notesFrame.BorderColor = Color.Red;
            }
            ShowSave();
        }

        private void ShowSave()
        {
            if (notesFrame.BorderColor == Color.Gray && photosFrame.BorderColor == Color.Gray)
            {
                saveBatchBtn.IsVisible = true;
            }
            else
            {
                saveBatchBtn.IsVisible = false;
            }
        }
        #endregion
    }
}