prs/prs.mobile.new/PRS.Mobile/Components/DigitalForms/Editor/DigitalFormHost.xaml.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Xamarin.Forms;
using Xamarin.Forms.Xaml;
using InABox.Mobile;
using XF.Material.Forms.UI.Dialogs;

namespace PRS.Mobile
{

    public class DigitalFormsHostClosingArgs : EventArgs
    {
        public bool Changed { get; }

        public DigitalFormsHostClosingArgs(bool changed)
        {
            Changed = changed;
        }
    }

    public delegate void DigitalFormsHostClosingDelegate(object sender, DigitalFormsHostClosingArgs args);

    [XamlCompilation(XamlCompilationOptions.Compile)]
    public partial class DigitalFormHost 
    {

        public event DigitalFormsHostClosingDelegate OnClosing;

        public IDigitalFormHostModel Model { get; private set; }
        QAFormViewer viewer;
        bool readOnly = false;

        public IList<IDocumentShell> _documents = null;
        //Dictionary<String, Guid> fileNameDocIDs = new Dictionary<string, Guid>();

        public DigitalFormHost(IDigitalFormHostModel model, Guid jobid = default(Guid))
        {
            
            
            InitializeComponent();
            ProgressVisible = true;
            
            NavigationPage.SetHasBackButton(this, false);
            
            Model = model;
            //titleLbl.Text = Model.DigitalFormDataModel.Instance.Form.Description;
            Model.OnDigitalFormHostModelBeforeSave += () =>
            {
                Model.SetPropertyValues(viewer);
            };

            Model.OnDigitalFormHostModelSaved += async (responseRequest) =>
            {
                DisplayAlert("Success", "Form saved " + Model.DigitalFormDataModel.Instance.Form.Description, "OK");
                if (responseRequest == DigitalFormHostResponseRequest.CloseKanban)
                {
                    string chosenOption = await DisplayActionSheet("Input Required", "All forms for this task are complete. Complete this task as well?", null, "Yes", "No");
                    switch (chosenOption)
                    {
                        case "Yes":
                            return DigitalFormHostUserResponse.Yes;
                    }
                }
                return DigitalFormHostUserResponse.No;
            };

            _saveButton.IsVisible = !Model.ReadOnly;
            //_saveProgress.IsEnabled = !Model.ReadOnly;

            viewer = new QAFormViewer(Model.DigitalFormDataModel, Model.DFLayout, Model.NewForm, Model.ReadOnly, jobid);

            LoadDocs();

            formViewerScroller.Content = viewer;
        }

        protected override void OnAppearing()
        {
            base.OnAppearing();
            ProgressVisible = false;
        }

        private void ExitBtn_Clicked(object sender, EventArgs e)
        {
            RetainedResults.IsFormRetained = false;
            OnClosing?.Invoke(this, new DigitalFormsHostClosingArgs(false));
            Navigation.PopAsync();
        }

        private async void SaveProgressBtn_Clicked(object sender, EventArgs e)
        {
            if (!readOnly)
            {
                using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Saving Progress"))
                {
                    viewer.SaveData(true);
                }
            }
            Navigation.PopAsync();
        }

        private void SaveBtn_Clicked(object sender, EventArgs e)
        {
            SaveOptions();
        }

        private async void DocumentBtn_Clicked(object sender, EventArgs e)
        {
            PDFList pdfList = new PDFList() { Documents = _documents, AllowUpload = true };
            Navigation.PushAsync(pdfList);
        }

        private void LoadDocs()
        {
            App.Data.DigitalForms.Refresh(false);
            _documents = App.Data.DigitalForms.Documents.Where(x => x.EntityID == Model.DigitalFormLayout.Form.ID).ToList();
            documentBtn.IsVisible = true;
            documentBtn.Text = "View Attached Document(s) (" + _documents.Count + ")";
        }

        private async void SaveOptions()
        {
            try
            {
                string chosenOption = "";
                if (Model.DigitalFormLayout.Form.AppliesTo.Equals("Kanban"))
                    chosenOption = await DisplayActionSheet("Select Option", "Cancel", null, "Save Progress", "Complete Form", "Complete and Duplicate");
                else if (Model.DigitalFormLayout.Form.AppliesTo.Equals("Kanban") || Model.DigitalFormLayout.Form.AppliesTo.Equals("Job"))
                    chosenOption = await DisplayActionSheet("Select Option", "Cancel", null, "Save Progress", "Complete Form", "Complete and Duplicate");
                else if (Model.DigitalFormLayout.Form.AppliesTo.Equals("Product"))
                    chosenOption = await DisplayActionSheet("Select Option", "Cancel", null, "Save Progress", "Complete Form");
                else
                    chosenOption = await DisplayActionSheet("Select Option", "Cancel", null, "Save Progress", "Complete Form");

                if (!string.IsNullOrEmpty(chosenOption))
                {
                    if (!chosenOption.Equals("Cancel"))
                    {
                        bool saveForLater = false;
                        if (chosenOption.Equals("Save Progress"))
                        {
                            saveForLater = true;
                            ClearRetainedStatusAndResults();
                        }
                        else if (chosenOption.Equals("Complete Form"))
                        {
                            ClearRetainedStatusAndResults();
                        }
                        else if (chosenOption.Equals("Complete and Duplicate"))
                        {
                            RetainedResults.IsFormRetained = true;
                            RetainedResults.RetainedFormName = Model.DigitalFormLayout.Description;
                            RetainedResults.Results = new Dictionary<string, string>();
                        }
                        
                        using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Saving"))
                        {
                            viewer.SaveData(saveForLater);
                            if (viewer.isRequiredEmpty)
                            {
                                Device.BeginInvokeOnMainThread(async () =>
                                {
                                    await DisplayAlert("Alert", "Please fill in compulsory field \"" + viewer.isRequiredMessage
                                        + "\" in order to submit form. (Compulsory fields are highlighted in orange)."
                                        , "OK");
                                });
                                return;
                            }
                            if (viewer.errors.Count > 0)
                            {
                                string message = "";
                                int count = 1;
                                foreach (string s in viewer.errors)
                                {
                                    if (s.Contains("same key"))
                                    {
                                        string[] arrary = s.Split("Key");
                                        message = message + count + ". " + "Please check with the person that designs your forms - a duplicate variable property is present (" + (arrary[arrary.Length - 1]).Remove(0, 1) + ")"
                                            + System.Environment.NewLine;
                                    }
                                    else
                                    {
                                        message = message + count + ". " + s + System.Environment.NewLine;
                                        count++;
                                    }
                                }
                                Device.BeginInvokeOnMainThread(() =>
                                {
                                    DisplayAlert("Form saved but errors may be present", message, "OK");
                                });

                                InABox.Mobile.MobileLogging.Log(message);
                            }
                        }
                        OnClosing?.Invoke(this, new DigitalFormsHostClosingArgs(true));
                        Navigation.PopAsync();
                    }
                }
            }
            catch (Exception ex)
            {
                DisplayAlert("Alert", "Unable to save. Issues: " + Environment.NewLine + ex.Message, "OK");

                InABox.Mobile.MobileLogging.Log(ex);

            }
        }

        private void ClearRetainedStatusAndResults()
        {
            try
            {
                RetainedResults.IsFormRetained = false;
                if (RetainedResults.Results != null)
                    RetainedResults.Results.Clear();
            }
            catch
            {
                return;
            }
        }
    }
}