prs/prs.mobile/comal.timesheets/DigitalForms/DigitalFormHost.xaml.cs

using InABox.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using PRSClasses;
using Xamarin.Forms;
using Xamarin.Forms.Xaml;
using comal.timesheets.QAForms;
using InABox.Clients;
using Comal.Classes;
using XF.Material.Forms.UI.Dialogs;

namespace comal.timesheets
{
    [XamlCompilation(XamlCompilationOptions.Compile)]
    public partial class DigitalFormHost : ContentPage
    {
        IDigitalFormHostModel model;
        QAFormViewer viewer;
        bool readOnly = false;
        Dictionary<String, Guid> fileNameDocIDs = new Dictionary<string, Guid>();

        public DigitalFormHost(IDigitalFormHostModel DFHostModel, Guid jobid = default(Guid))
        {
            InitializeComponent();
            NavigationPage.SetHasBackButton(this, false);
            model = DFHostModel;
            titleLbl.Text = model.DigitalFormLayout.Description;
            model.OnDigitalFormHostModelBeforeSave += () =>
            {
                model.SetPropertyValues(viewer);
            };

            model.OnDigitalFormHostModelSaved += () =>
            {
                DisplayAlert("Success", "Form completed: " + model.DigitalFormLayout.Description, "OK");
            };

            completeBtn.IsEnabled = !model.ReadOnly;
            saveProgressBtn.IsEnabled = !model.ReadOnly;

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

            LoadDocs();

            formViewerScroller.Content = viewer;
        }

        private void ExitBtn_Clicked(object sender, EventArgs e)
        {
            RetainedResults.IsFormRetained = 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 CompleteBtn_Clicked(object sender, EventArgs e)
        {
            SaveOptions();
        }

        private async void DocumentBtn_Clicked(object sender, EventArgs e)
        {
            if (fileNameDocIDs.Count > 1)
            {
                PDFList pdfList = new PDFList(fileNameDocIDs, true);
                Navigation.PushAsync(pdfList);
            }
            else if (fileNameDocIDs.Count == 1)
            {
                PDFViewer pDFViewer = new PDFViewer(fileNameDocIDs.Values.First(), true);
                Device.BeginInvokeOnMainThread(() =>
                {
                    Navigation.PushAsync(pDFViewer);
                });
            }
        }

        private void LoadDocs()
        {
            try
            {
                Task.Run(() =>
                {
                    CoreTable table = new Client<DigitalFormDocument>().Query
                    (
                        new Filter<DigitalFormDocument>(x => x.EntityLink.ID).IsEqualTo(model.DigitalFormLayout.Form.ID),
                        new Columns<DigitalFormDocument>(x => x.DocumentLink.ID, x => x.DocumentLink.FileName)
                    );
                    if (table.Rows.Any())
                    {
                        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] = "";

                            fileNameDocIDs.Add(list[1].ToString(), Guid.Parse(list[0].ToString()));
                        }
                        Device.BeginInvokeOnMainThread(() =>
                        {
                            documentBtn.IsVisible = true;
                            documentBtn.Text = "View Attached Document(s) (" + table.Rows.Count + ")";
                        });
                    }
                });
            }
            catch { }
        }

        private async void SaveOptions()
        {
            try
            {
                string chosenOption = "";
                if (model.DigitalFormLayout.Form.AppliesTo.Equals("Kanban"))
                {
                    chosenOption = await DisplayActionSheet("Select Save Type", "Cancel", null, "Complete", "Complete and Duplicate");
                }
                else if (model.DigitalFormLayout.Form.AppliesTo.Equals("Kanban") || model.DigitalFormLayout.Form.AppliesTo.Equals("Job"))
                {
                    chosenOption = await DisplayActionSheet("Select Save Type", "Cancel", null, "Complete", "Complete and Duplicate");
                }
                else if (model.DigitalFormLayout.Form.AppliesTo.Equals("Product"))
                {
                    chosenOption = await DisplayActionSheet("Save", "Cancel", null, "Complete Product Form", "Cancel");
                }
                else
                {
                    chosenOption = await DisplayActionSheet("Save", "Cancel", null, "Complete", "Cancel");
                }
                if (!string.IsNullOrEmpty(chosenOption))
                {
                    if (chosenOption != "Cancel")
                    {
                        bool saveForLater = false;
                        if (chosenOption.Equals("Save for later"))
                        {
                            saveForLater = true;
                            ClearRetainedStatusAndResults();
                        }
                        else if (chosenOption.Equals("Complete"))
                        {
                            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");
                                });
                            }
                        }
                        Navigation.PopAsync();
                    }
                }
            }
            catch (Exception ex)
            {
                DisplayAlert("Alert", "Unable to save. Issues: " + Environment.NewLine + ex.Message, "OK");
            }
        }

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