prs/prs.mobile/comal.timesheets/DigitalForms/DigitalFormPickerScreen/DigitalFormsPicker.xaml.cs

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

namespace comal.timesheets
{
    [XamlCompilation(XamlCompilationOptions.Compile)]
    public partial class DigitalFormsPicker : ContentPage
    {
        #region Fields
        bool _searching = false;
        Kanban addToTaskKanban = new Kanban();
        List<DigitalFormLayoutShell> layouts = new List<DigitalFormLayoutShell>();
        List<String> types = new List<String>();
        private bool firstLoad = true;
        private bool incompleteVisible = true;
        private bool addingToTask = false;
        Guid JobID = Guid.Empty;
        List<ExistingFormShell> incompleteForms = new List<ExistingFormShell>();
        List<ExistingFormShell> completeForms = new List<ExistingFormShell>();
        #endregion
        public DigitalFormsPicker(string appliesTo = "Kanban", Guid _jobid = new Guid()) //normal Forms Library - default is kanban type
        {
            InitializeComponent();
            JobID = _jobid;
            NavigationPage.SetHasBackButton(this, false);
            LoadScreen(appliesTo);
        }

        public DigitalFormsPicker(Kanban _kanban) //used for adding forms to a task
        {
            InitializeComponent();
            addingToTask = true;
            addToTaskKanban = _kanban;
            NavigationPage.SetHasBackButton(this, false);
            LoadScreen("Kanban");
        }

        private void ExitBtn_Clicked(object sender, EventArgs e)
        {
            Navigation.PopAsync();
        }

        #region OnAppearing and Loading Screen
        protected override void OnAppearing()
        {
            try
            {
                _searching = false;
                if (RetainedResults.IsFormRetained)
                {
                    DigitalFormHost host = new DigitalFormHost(DigitalFormsHelper.LoadModel(RetainedResults.LastDigitalFormLayout, CheckType(), addToTaskKanban, JobID, null, addingToTask), JobID);
                    Navigation.PushAsync(host);
                }
                LoadExistingForms();
            }
            catch { }

            base.OnAppearing();
        }

        private void LoadScreen(string appliesTo)
        {
            try
            {
                Task.Run(() =>
                {
                    types.Add("All");

                    CoreTable table = LoadEmployeeRoleForms(appliesTo);

                    foreach (CoreRow row in table.Rows)
                        CreateAndAddShell(row);

                    GetAverages();

                    Device.BeginInvokeOnMainThread(() =>
                    {
                        layoutsList.ItemsSource = layouts;
                        filterOptionsControl.Options = types;
                        filterOptionsControl.CreateRadioButtonsAndSetDefault(types.First());
                    });
                    filterOptionsControl.OnFilterOptionChanged += FilterOptionsControl_OnFilterOptionChanged;

                    firstLoad = false;
                });
            }
            catch (Exception e)
            {
                DisplayAlert("Error", e.Message, "OK");
            }
        }

        private void CreateAndAddShell(CoreRow row)
        {
            DigitalFormLayoutShell layout = new DigitalFormLayoutShell();
            layout.ID = row.Get<DigitalFormLayout, Guid>(x => x.ID);
            layout.Description = row.Get<DigitalFormLayout, string>(x => x.Description);
            layout.Code = row.Get<DigitalFormLayout, string>(x => x.Code);
            layout.AppliesTo = row.Get<DigitalFormLayout, string>(x => x.Form.AppliesTo);
            layout.FormID = row.Get<DigitalFormLayout, Guid>(x => x.Form.ID);
            layout.Layout = row.Get<DigitalFormLayout, string>(x => x.Layout);
            layout.FormGroupDescription = row.Get<DigitalFormLayout, string>(x => x.Form.Group.Description);
            if (string.IsNullOrWhiteSpace(layout.FormGroupDescription))
                layout.FormGroupDescription = "All";
            layouts.Add(layout);

            if (!types.Contains(layout.FormGroupDescription) && !string.IsNullOrWhiteSpace(layout.FormGroupDescription))
            {
                types.Add(layout.FormGroupDescription);
            }
        }

        private CoreTable LoadEmployeeRoleForms(string appliesTo)
        {
            CoreTable table = new Client<EmployeeRole>().Query(
                new Filter<EmployeeRole>(x => x.EmployeeLink.ID).IsEqualTo(GlobalVariables.EmpID)
                , new Columns<EmployeeRole>(x => x.RoleLink.ID));
            if (!table.Rows.Any())
            {
                Device.BeginInvokeOnMainThread(() =>
                {
                    DisplayAlert("Alert", "No Roles found for your employee profile. Please check with your administrator.", "OK");
                });

                return table;
            }

            CoreTable roleForms = QueryRoleForms(table);

            if (!roleForms.Rows.Any())
            {
                Device.BeginInvokeOnMainThread(() =>
                {
                    DisplayAlert("Alert", "No Forms found for your employee role. Please check with your administrator.", "OK");
                });

                return table;
            }

            return QueryFormLayouts(roleForms, appliesTo);
        }
        private CoreTable QueryRoleForms(CoreTable table)
        {
            List<Guid> roleIDS = new List<Guid>();
            foreach (CoreRow row in table.Rows)
            {
                roleIDS.Add(row.Get<EmployeeRole, Guid>(x => x.RoleLink.ID));
            }
            return new Client<RoleForm>().Query(
                new Filter<RoleForm>(x => x.Role.ID).InList(roleIDS.ToArray()),
                new Columns<RoleForm>(x => x.Form.ID));
        }

        private CoreTable QueryFormLayouts(CoreTable roleForms, string appliesTo)
        {
            List<Guid> formIDs = new List<Guid>();
            foreach (CoreRow row in roleForms.Rows)
            {
                formIDs.Add(row.Get<RoleForm, Guid>(x => x.Form.ID));
            }
            return new Client<DigitalFormLayout>().Query
                (
                new Filter<DigitalFormLayout>(x => x.Form.ID).InList(formIDs.ToArray())
                .And(x => x.Type).IsEqualTo(DFLayoutType.Mobile)
                .And(x => x.Active).IsEqualTo(true)
                .And(x => x.Form.Secure).IsEqualTo(false)
                .And(x => x.Form.Active).IsEqualTo(true)
                .And(x => x.Form.AppliesTo).IsEqualTo(appliesTo),

                new Columns<DigitalFormLayout>(
                x => x.Description,
                x => x.ID,
                x => x.Code,
                x => x.Form.AppliesTo,
                x => x.Form.ID,
                x => x.Layout,
                x => x.Form.Group.Description),

                new SortOrder<DigitalFormLayout>(x => x.Description)
                );
        }



        private void GetAverages()
        {
            try
            {
                Task.Run(() =>
                {
                    foreach (var layout in layouts)
                    {
                        TimeSpan span = new TimeSpan();
                        CoreTable table = new Client<KanbanForm>().Query
                            (
                            new Filter<KanbanForm>(x => x.Form.ID).IsEqualTo(layout.FormID).And(x => x.FormOpen).IsNotEqualTo(null),
                            new Columns<KanbanForm>(x => x.FormOpen)
                            );
                        if (table.Rows.Any())
                        {
                            foreach (CoreRow row in table.Rows)
                            {
                                List<object> list = row.Values;
                                TimeSpan timespan = TimeSpan.Parse(list[0].ToString());
                                span = span + timespan;
                            }
                            TimeSpan average = span / table.Rows.Count();
                            layout.AverageTime = "Average time to complete: " + average.Minutes.ToString() + "m " + average.Seconds.ToString() + "s";
                            layout.AverageTimeRow = 30;
                            layout.ImageRowSpan = 2;
                        }
                    }
                    Device.BeginInvokeOnMainThread(() =>
                    {
                        layoutsList.ItemsSource = null;
                        if (filterOptionsControl.CurrentOption == "All")
                        {
                            layoutsList.ItemsSource = layouts;
                        }
                        else
                        {
                            layoutsList.ItemsSource = layouts.Where(x => x.FormGroupDescription.Equals(filterOptionsControl.CurrentOption));
                        }
                    });
                });
            }
            catch { }
        }

        private void LoadExistingForms()
        {
            //Task.Run(() =>
            //{
            try
            {
                List<IFormPickerQueryLoader> loaderList = new List<IFormPickerQueryLoader>()
                {
                new FormPickerQueryLoader<Kanban, KanbanLink, KanbanForm>(),
                new FormPickerQueryLoader<Job, JobLink, JobForm>()
                 };
                incompleteForms.Clear();
                completeForms.Clear();
                foreach (var loader in loaderList)
                {
                    List<ExistingFormShell> incomplete = loader.QueryIncomplete();
                    foreach (var v in incomplete)
                    {
                        incompleteForms.Add(v);
                    }
                    List<ExistingFormShell> complete = loader.QueryComplete();
                    foreach (var v in complete)
                    {
                        completeForms.Add(v);
                    }
                }
                SortForms(completeForms, FormCompletion.Complete);
                SortForms(incompleteForms, FormCompletion.Incomplete);
                Device.BeginInvokeOnMainThread(() =>
                {
                    ShowOrHideIncompleteFormsNotifications();
                    RefreshMyForms();
                });
            }
            catch { }
            //});
        }

        enum FormCompletion
        {
            Incomplete,
            Complete
        }

        private void SortForms(List<ExistingFormShell> shells, FormCompletion completion)
        {
            if (completion == FormCompletion.Complete && shells.Count > 0)
                shells.Sort((x, y) => y.DateCompleted.CompareTo(x.DateCompleted)); //descending
            else if (completion == FormCompletion.Incomplete && shells.Count > 0)
                shells.Sort((x, y) => x.DateStarted.CompareTo(y.DateStarted)); //ascending
        }

        private void ShowOrHideIncompleteFormsNotifications()
        {
            if (incompleteForms.Count > 0)
            {
                notificationFrame.IsVisible = true;
                notificationColumn.Width = 40;
                numberOfIncompleteFormsLbl.Text = incompleteForms.Count.ToString();
            }
            else
            {
                notificationFrame.IsVisible = false;
                notificationColumn.Width = 0;
            }
        }

        private void RefreshMyForms()
        {
            incompleteFormsList.ItemsSource = null;
            completeFormsList.ItemsSource = null;
            incompleteFormsList.ItemsSource = incompleteForms;
            completeFormsList.ItemsSource = completeForms;
            incompleteBtn.Text = "Incomplete (" + incompleteForms.Count + ")";
            completeBtn.Text = "Complete (" + completeForms.Count + ")";
        }

        #endregion

        #region User Interaction

        #region New Forms Section
        private void NewButton_Clicked(object sender, EventArgs e)
        {
            templatesColumn.Width = GridLength.Star;
            formsColumn.Width = 0;

            existingFormsGrid.IsVisible = false;
            templatesGrid.IsVisible = true;

            newButton.BackgroundColor = Color.FromHex("#15C7C1");
            myFormsButton.BackgroundColor = Color.Default;
        }

        private void MyFormsButton_Clicked(object sender, EventArgs e)
        {
            templatesColumn.Width = 0;
            formsColumn.Width = GridLength.Star;

            existingFormsGrid.IsVisible = true;
            templatesGrid.IsVisible = false;

            newButton.BackgroundColor = Color.Default;
            myFormsButton.BackgroundColor = Color.FromHex("#15C7C1");
        }

        private void FilterOptionsControl_OnFilterOptionChanged(string filterOption)
        {
            try
            {
                if (filterOption == filterOptionsControl.CurrentOption)
                    return;

                filterOptionsControl.CurrentOption = filterOption;
                if (filterOption == "All")
                {
                    layoutsList.ItemsSource = layouts;
                }
                else
                {
                    layoutsList.ItemsSource = layouts.Where(x => x.FormGroupDescription.Equals(filterOption));
                }
            }
            catch { }
        }
        #endregion

        #region My Forms Section
        private async void IncompleteFormsList_Tapped(object sender, EventArgs e)
        {
            using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Loading"))
            {
                var form = incompleteFormsList.SelectedItem as ExistingFormShell;
                DigitalFormLayout layout = new Client<DigitalFormLayout>().Query(
                    new Filter<DigitalFormLayout>(x => x.Form.ID).IsEqualTo(form.FormID)
                    ).Rows.FirstOrDefault().ToObject<DigitalFormLayout>();

                if (form.Type == typeof(JobForm))
                    JobID = form.ParentID;
                else
                    JobID = Guid.Empty;

                DigitalFormHost host = new DigitalFormHost(DigitalFormsHelper.LoadModel(layout, form.Type, addToTaskKanban, JobID, form, addingToTask), JobID);
                Navigation.PushAsync(host);
            }
        }

        private async void CompleteFormsList_Tapped(object sender, EventArgs e)
        {
            using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Loading"))
            {
                var form = completeFormsList.SelectedItem as ExistingFormShell;
                DigitalFormLayout layout = new Client<DigitalFormLayout>().Query(
                    new Filter<DigitalFormLayout>(x => x.Form.ID).IsEqualTo(form.FormID)
                    ).Rows.FirstOrDefault().ToObject<DigitalFormLayout>();

                if (form.Type == typeof(JobForm))
                    JobID = form.ParentID;
                else
                    JobID = Guid.Empty;

                DigitalFormHost host = new DigitalFormHost(DigitalFormsHelper.LoadModel(layout, form.Type, addToTaskKanban, JobID, form, addingToTask), JobID);
                Navigation.PushAsync(host);
            }
        }

        private void Incomplete_Tapped(object sender, EventArgs e)
        {
            incompleteFormsColumn.Width = GridLength.Star;
            completeFormsColumn.Width = 0;

            incompleteFormsList.IsVisible = true;
            completeFormsList.IsVisible = false;

            incompleteBtn.BackgroundColor = Color.FromHex("#15C7C1");
            completeBtn.BackgroundColor = Color.Default;

            incompleteVisible = true;
            searchEnt.Text = "";
        }

        private void Complete_Tapped(object sender, EventArgs e)
        {
            completeFormsColumn.Width = GridLength.Star;
            incompleteFormsColumn.Width = 0;

            completeFormsList.IsVisible = true;
            incompleteFormsList.IsVisible = false;

            incompleteBtn.BackgroundColor = Color.Default;
            completeBtn.BackgroundColor = Color.FromHex("#15C7C1");

            incompleteVisible = false;
            searchEnt.Text = "";
        }

        private async void Delete_Tapped(object sender, EventArgs e)
        {
            var item = ((TappedEventArgs)e).Parameter as ExistingFormShell;
            if (item == null) return;

            string chosenOption = await DisplayActionSheet("Delete Form?", "Cancel", null, "Yes", "No");
            switch (chosenOption)
            {
                case "Yes":
                    break;
                default:
                    return;
            }

            DeleteForm(item);
            LoadExistingForms();
        }

        private void DeleteForm(ExistingFormShell item)
        {
            if (item.Type == typeof(KanbanForm))
                DeleteKanbanForm(item.ID);
            if (item.Type == typeof(JobForm))
                DeleteJobForm(item.ID);
        }

        private void DeleteJobForm(Guid id)
        {
            JobForm form = new JobForm { ID = id };
            new Client<JobForm>().Delete(form, "Deleted from Mobile App - My Forms section");
        }

        private void DeleteKanbanForm(Guid id)
        {
            KanbanForm form = new KanbanForm { ID = id };
            new Client<KanbanForm>().Delete(form, "Deleted from Mobile App - My Forms section");
        }

        #region Loading From History Section
        private void LayoutsList_Tapped(object sender, EventArgs e)
        {
            if (_searching)
                return;
            else
                LoadHost();
        }

        private async void LoadHost()
        {
            try
            {
                var digitalFormLayoutShell = layoutsList.SelectedItem as DigitalFormLayoutShell;
                DigitalFormLayout digitalFormLayout = new DigitalFormLayout();
                using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Loading"))
                {
                    _searching = true;

                    digitalFormLayout.ID = digitalFormLayoutShell.ID;
                    digitalFormLayout.Description = digitalFormLayoutShell.Description;
                    digitalFormLayout.Code = digitalFormLayoutShell.Code;
                    digitalFormLayout.Form.AppliesTo = digitalFormLayoutShell.AppliesTo;
                    digitalFormLayout.Form.ID = digitalFormLayoutShell.FormID;
                    digitalFormLayout.Layout = digitalFormLayoutShell.Layout;
                    digitalFormLayout.Form.Group.Description = digitalFormLayoutShell.FormGroupDescription;

                    RetainedResults.LastDigitalFormLayout = digitalFormLayout;
                }
                DigitalFormHost host = new DigitalFormHost(DigitalFormsHelper.LoadModel(digitalFormLayout, CheckType(), addToTaskKanban, JobID, null, addingToTask), JobID);
                Navigation.PushAsync(host);
            }
            catch { }
        }

        private Type CheckType()
        {
            if (JobID != Guid.Empty)
                return typeof(JobForm);
            else
                return typeof(KanbanForm);
        }

        private IDigitalFormHostModel LoadModel(DigitalFormLayout layout, Type type, ExistingFormShell form = null)
        {
            if (type == typeof(JobForm))
            {
                var model = new DigitalFormHostModel<Job, JobLink, JobForm>();
                var job = new Job();

                var jobForm = new JobForm();
                jobForm.Form.ID = layout.Form.ID;

                if (form == null)
                {
                    job.ID = JobID;
                }
                else
                {
                    jobForm.ID = form.ID;
                    job.ID = form.ParentID;
                }

                model.LoadItems(job, jobForm, layout);
                return model;
            }
            else
            {
                var model = new DigitalFormHostModel<Kanban, KanbanLink, KanbanForm>();
                var kanban = new Kanban();

                var kanbanForm = new KanbanForm();

                kanbanForm.Form.ID = layout.Form.ID;
                if (form != null)
                {
                    kanbanForm.ID = form.ID;
                    kanban.ID = form.ParentID;
                }

                if (addingToTask)
                {
                    kanbanForm.Parent.ID = addToTaskKanban.ID;
                    kanban.ID = addToTaskKanban.ID;
                }

                model.LoadItems(kanban, kanbanForm, layout);
                return model;
            }
        }

        #endregion

        #region Searching
        private void SearchEnt_Changed(object sender, EventArgs e)
        {
            if (CheckEmptySearch())
                return;
            else
            {
                RunSearch();
            }
        }

        private bool CheckEmptySearch()
        {
            if (string.IsNullOrWhiteSpace(searchEnt.Text))
            {
                incompleteFormsList.ItemsSource = incompleteForms;
                completeFormsList.ItemsSource = completeForms;
                return true;
            }
            else
                return false;
        }

        private void RunSearch()
        {
            try
            {
                if (incompleteVisible)
                    RunSearchOnIncomplete();
                else
                    RunSearchOnHistory();
            }
            catch (Exception ex)
            {
                string message = ex.Message;
            }
        }
        private void RunSearchOnIncomplete()
        {
            incompleteFormsList.ItemsSource = incompleteForms.Where(x =>
            x.Description.Contains(searchEnt.Text) || x.Description.Contains(searchEnt.Text.ToUpper())
            || x.Description.Contains(searchEnt.Text.ToLower()) || x.Description.Contains(SearchUtils.UpperCaseFirst(searchEnt.Text))
            );
        }
        private void RunSearchOnHistory()
        {
            completeFormsList.ItemsSource = completeForms.Where(x =>
            x.Description.Contains(searchEnt.Text) || x.Description.Contains(searchEnt.Text.ToUpper())
            || x.Description.Contains(searchEnt.Text.ToLower()) || x.Description.Contains(SearchUtils.UpperCaseFirst(searchEnt.Text))
            );
        }
        #endregion
        #endregion

        #endregion

    }
}