prs/prs.mobile/comal.timesheets/Main/MainPage.xaml.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Xamarin.Forms;
using InABox.Core;
using InABox.Configuration;
using InABox.Clients;
using InABox.Mobile;
using Comal.Classes;
using XF.Material.Forms.UI.Dialogs;
using comal.timesheets.CustomControls;
using comal.timesheets.StoreRequis;
using PRSSecurity = InABox.Core.Security;
using Plugin.LocalNotification;
using comal.timesheets.Tasks;
using System.IO;

namespace comal.timesheets
{
    public partial class MainPage : ContentPage
    {
        #region Fields
        List<ToolEntry> toolEntries = new List<ToolEntry>();
        public bool SettingsChanged { get; private set; }
        bool bUpdatingTimesheet = false;
        public static ConnectionSettings connectionSettings = null;
        bool midnightTimerOn = false;
        DateTime oneSecondBeforeMidnight = DateTime.Today.AddSeconds(864399);
        bool clockedOffInLast5Seconds = false;
        bool bRecentlyUpdatedTiles = false;
        bool bSharedDeviceFirstLoad = true;
        bool bSharedDevice = false;
        int NumberOfNotfications = 0;
        string matchedDeviceName = "";
        int notCount = 1;
        #endregion

        #region Constructor
        public MainPage()
        {
            InitializeComponent();
            try
            {
                InitItems();

                LoadCacheLists();

                RunCustomScript();
            }
            catch (Exception e) { }
        }
        private void RunCustomScript()
        {

        }

        private void InitItems()
        {
            NavigationPage.SetHasBackButton(this, false);

            MainPageUtils.Init();

            InitNotificationCentre();

            MainPageUtils.OnRefreshScreen += () =>
            {
                Device.BeginInvokeOnMainThread(() =>
                {
                    RefreshScreen();
                });
            };

            MessagingCenter.Subscribe<App>(this, App.MessageOnResume,
            (o) =>
            {
                if (!App.GPS.RecentlyLocated)
                    App.GPS.GetLocation();
                RefreshScreen();
            }
            );

            InitToolEntryList();

            CheckCurrentAssignment();

            NotifyChanges();
        }


        private void CheckCurrentAssignment()
        {
            Task.Run(() =>
            {
                try
                {
                    var assgn = MainPageUtils.CheckCurrentAssignment();

                    MainPageUtils.OnRequestUserInput += (taskID) => { RequestUserInput(taskID); };
                    MainPageUtils.OnTaskTitleChanged += (title) => { taskBtn.Text = title; };
                    MainPageUtils.Job.OnJobIDChanged += MainPageUtils.OnJobIDChanged;
                    MainPageUtils.Job.OnJobNumberChanged += Job_OnJobNumberChanged;

                    if (assgn == null)
                        return;

                    MainPageUtils.UseCurrentAssignment(assgn);
                    RefreshJobBtn();
                }
                catch (Exception ex)
                {
                    var log = new MobileLogging(LogType.Query, typeof(Assignment).ToString(), ex.Message, this.GetType().Name);
                }
            });
        }


        private void NotifyChanges()
        {
            Task.Run(() =>
            {
                string changes = NotifyMobileChanges.Notifiy();
                if (!string.IsNullOrWhiteSpace(changes))
                    Device.BeginInvokeOnMainThread(() =>
                    {
                        DisplayAlert("Latest changes", changes, "OK");
                    });
            });
        }
        #endregion

        #region OnAppearing and Display
        protected override void OnAppearing()
        {
            if (!App.IsUserLoggedIn)
            {
                Navigation.PopAsync();
                return;
            }

            if (!MainPageUtils.firstLoad)
                RefreshScreen();

            Task.Run(async () =>
            {
                bool isLatest = true;

                try
                {
                    isLatest = await MobileUtils.AppVersion.IsUsingLatestVersion();
                }
                catch (Exception eLatest)
                {
                    if (!MainPageUtils.recentlyAskedToUpdate)
                    {
                        Device.BeginInvokeOnMainThread(() =>
                        {

                        });

                        MainPageUtils.recentlyAskedToUpdate = true;
                    }
                    string s = eLatest.Message;
                }

                if (!isLatest)
                {
                    try
                    {
                        if (!MainPageUtils.recentlyAskedToUpdate)
                        {
                            string latestVersionNumber = await MobileUtils.AppVersion.GetLatestVersionNumber();
                            if (MainPageUtils.updateCounter < 3)
                            {
                                Device.BeginInvokeOnMainThread(async () =>
                                {
                                    string chosenOption = await DisplayActionSheet(String.Format("Version {0} Available. Update now?", latestVersionNumber), "You will be reminded again in 10 minutes.", null, "Yes", "No");
                                    switch (chosenOption)
                                    {
                                        case "No":
                                            break;
                                        case "Cancel":
                                            break;
                                        case "Yes":
                                            Dispatcher.BeginInvokeOnMainThread(() => { MobileUtils.AppVersion.OpenAppInStore(); });
                                            break;
                                        default:
                                            break;
                                    }

                                });
                            }
                            else if (MainPageUtils.updateCounter >= 3)
                            {
                                Device.BeginInvokeOnMainThread(() =>
                                {
                                    DisplayAlert(String.Format("Version {0} Available", latestVersionNumber), "Please update your software to the latest version.", "OK")
                                .ContinueWith((Task task) =>
                                {
                                    Dispatcher.BeginInvokeOnMainThread(() => { MobileUtils.AppVersion.OpenAppInStore(); });
                                });
                                });
                            }
                            MainPageUtils.recentlyAskedToUpdate = true;
                            MainPageUtils.updateCounter++;
                        }
                    }
                    catch { }
                }

            });

            base.OnAppearing();
        }

        private void AutoLogoutUser(object o)
        {
            App.LogoutUser();
            Navigation.PopToRootAsync();
        }

        private void RefreshScreen()
        {
            try
            {
                Device.BeginInvokeOnMainThread(() =>
                {
                    homeScreenGrid.RaiseChild(CurrentLocation);

                    CheckClockOnRequired();

                    bBusy = true;

                    if (GlobalVariables.EmpID == Guid.Empty)
                    {
                        GlobalVariables.EmpID = GlobalVariables.GetEmployeeID();
                        GlobalVariables.EmpName = GlobalVariables.GetEmployeeName();
                    }

                    clockOnButton.IsEnabled = false;

                    bool PRSReady = (App.Data.Employee != null) && (App.Data.TimeSheets != null) && (GlobalVariables.EmpID != Guid.Empty);
                    if (!PRSReady)
                        App.Data.Refresh();

                    bool GateReady = CheckLocation();

                    CurrentLocation.Text = DisplayAddress();

                    if (CurrentLocation.Text.ToUpper().Contains("ERROR"))
                        CurrentLocation.Text = "Unknown Address";

                    Title = null;
                    Title = App.Data.Employee != null ? App.Data.Employee.Name : "";

                    CoreRow timesheet = App.Data.TimeSheets?.Rows.FirstOrDefault();

                    clockOnButton.Text = PRSReady && GateReady ? timesheet == null ? "CLOCK ON" : "CLOCK OFF" : "PLEASE WAIT";
                    clockOnButton.IsEnabled = PRSReady && GateReady;
                    clockOnButton.BackgroundColor = PRSReady && GateReady ? timesheet == null ? Color.FromHex("#e6e6fa") : Color.FromHex("#15C7C1") : Color.Gainsboro;
                    clockOnButton.BorderColor = PRSReady && GateReady ? timesheet == null ? Color.Black : Color.FromHex("#15C7C1") : Color.Gainsboro;
                    if (clockOnButton.Text == "CLOCK OFF")
                    {
                        addNoteBtn.IsEnabled = true;
                        taskBtn.IsEnabled = true;
                        if (GlobalVariables.JobsLoaded)
                            jobBtn.IsEnabled = true;
                    }
                    else
                    {
                        addNoteBtn.IsEnabled = false;
                        jobBtn.IsEnabled = false;
                        taskBtn.IsEnabled = false;
                    }

                    RefreshJobBtn();

                    homeScreenGrid.RaiseChild(CurrentLocation);

                    MainPageUtils.firstLoad = false;
                    bBusy = false;
                });
            }
            catch (Exception ex)
            {
                var log = new MobileLogging(LogType.UIUpdate, "Main page refresh screen", ex.Message + ex.StackTrace, this.GetType().Name);
            }
        }

        private void CheckClockOnRequired()
        {
            try
            {
                if (GlobalVariables.IsJobOnlyEmployee)
                {
                    clockOnButton.IsVisible = false;
                    CurrentLocation.IsVisible = false;
                    buttonsGrid.IsVisible = false;
                    taskBtn.IsVisible = false;
                    row0.Height = 0;
                    row1.Height = 0;
                    row2.Height = 150;
                    Image img = new Image { Source = "logo.png" };
                    img.Margin = 15;
                    Grid.SetRow(img, 2);
                    homeScreenGrid.Children.Add(img);
                }
                else
                {
                    clockOnButton.IsVisible = true;
                    CurrentLocation.IsVisible = true;
                    buttonsGrid.IsVisible = true;
                    taskBtn.IsVisible = true;
                }
            }
            catch { }
        }

        private void Job_OnJobNumberChanged(string jobnumber)
        {
            jobBtn.Text = "Job: " + jobnumber;
        }

        private void RefreshJobBtn()
        {
            if (MainPageUtils.Job.ID == Guid.Empty)
                jobBtn.Text = "No Job Selected";
            else if (!string.IsNullOrWhiteSpace(MainPageUtils.Job.JobNumber))
                jobBtn.Text = MainPageUtils.Job.JobNumber;
        }

        private void RefreshJobFromTimeSheet(CoreRow timesheet)
        {
            Guid jobid = timesheet == null ? Guid.Empty : timesheet.Get<TimeSheet, Guid>(x => x.JobLink.ID);
            if (!jobid.Equals(Guid.Empty))
            {
                jobBtn.Text = String.Format("{0}: {1}", timesheet.Get<TimeSheet, String>(x => x.JobLink.JobNumber), timesheet.Get<TimeSheet, String>(x => x.JobLink.Name));
                MainPageUtils.Job.ID = timesheet == null ? Guid.Empty : timesheet.Get<TimeSheet, Guid>(x => x.JobLink.ID);
                MainPageUtils.Job.JobNumber = timesheet == null ? String.Empty : timesheet.Get<TimeSheet, String>(x => x.JobLink.JobNumber);
                MainPageUtils.Job.Name = timesheet == null ? String.Empty : timesheet.Get<TimeSheet, String>(x => x.JobLink.Name);
            }
            else
            {
                jobBtn.Text = "No Job Selected";
                MainPageUtils.Job = new JobShell();
            }
        }

        #endregion

        #region Clock on/off
        bool bBusy = false;

        async void ClockOnOff_Clicked(object sender, System.EventArgs e)
        {
            if (bBusy)
                return;
            bBusy = true;

            string chosenOption = "Continue";
            if (clockOnButton.Text == "CLOCK OFF")
            {
                chosenOption = await DisplayActionSheet("Clock off?", "Cancel", null, "Continue", "Cancel");
            }
            switch (chosenOption)
            {
                case "Continue":
                    break;
                case "Cancel":
                    bBusy = false;
                    return;
                    break;
                default:
                    bBusy = false;
                    return;
                    break;
            }
            if (clockOnButton.Text == "CLOCK ON" && clockedOffInLast5Seconds)
            {
                bBusy = false;
                return;
            }

            try
            {
                using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Loading"))
                {
                    InABox.Core.Location here = new InABox.Core.Location()
                    {
                        Latitude = App.GPS.Latitude,
                        Longitude = App.GPS.Longitude,
                        Timestamp = DateTime.Now
                    };

                    TimeSheet timesheet = App.Data.TimeSheets?.Rows.FirstOrDefault()?.ToObject<TimeSheet>();

                    if (timesheet != null)
                    {
                        if (timesheet.ID != Guid.Empty)
                        {
                            if (ZeroLengthTimesheet())
                            {
                                bUpdatingTimesheet = true;
                                new Client<TimeSheet>().Delete(timesheet, "Deleted due to zero duration timesheet");
                                App.Data.TimeSheets.Rows.Clear();
                            }
                            else
                            {
                                FinishTimeSheet(timesheet, here);
                            }
                        }
                    }
                    else
                    {
                        Guid jobid = Guid.Empty;
                        String jobnumber = "";
                        String jobname = "";

                        if (!App.Data.CanBypassGates)
                        {
                            CoreRow row = App.Data.Gates.Rows.FirstOrDefault(r => App.Bluetooth.Devices.Contains(r.Get<JobTracker, String>(c => c.TrackerLink.DeviceID)));
                            if (row != null)
                            {
                                jobid = row.Get<JobTracker, Guid>(x => x.JobLink.ID);
                                jobnumber = row.Get<JobTracker, String>(x => x.JobLink.JobNumber);
                                jobname = row.Get<JobTracker, String>(x => x.JobLink.Name);
                            }
                            CreateTimeSheet(jobid, jobnumber, jobname, here, App.GPS.Address, "Clocking On");
                        }
                        else
                        {
                            if ((!App.GPS.Latitude.Equals(0.0F)) && (!App.GPS.Longitude.Equals(0.0F)))
                            {
                                ChooseNearbyJob(here);
                            }
                        }


                    }
                    RefreshScreen();
                }
            }
            catch (Exception ex)
            {
                var log = new MobileLogging(LogType.UIUpdate, "Clock on/off", ex.Message + ex.StackTrace, this.GetType().Name);
            }
            bBusy = false;
        }


        #endregion

        #region Bluetooth

        private async void UploadTiles()
        {
            try
            {
                if (App.GPS.Latitude.Equals(0.0F) && App.GPS.Longitude.Equals(0.0F))
                    return;
                if (App.Bluetooth.DetectedBlueToothMACAddresses.Count == 0)
                    return;
                if (bRecentlyUpdatedTiles)
                    return;
                bRecentlyUpdatedTiles = true;
                await Task.Run(() =>
                {
                    InABox.Core.Location curlocation = new InABox.Core.Location() { Latitude = App.GPS.Latitude, Longitude = App.GPS.Longitude };
                    curlocation.Timestamp = DateTime.Now;
                    List<GPSTrackerLocation> trackersToUpdate = new List<GPSTrackerLocation>();

                    foreach (String id in App.Bluetooth.DetectedBlueToothMACAddresses)
                    {
                        GPSTracker tracker = GlobalVariables.GPSTrackerCache.Find(x => x.DeviceID.Equals(id));
                        bool stale = tracker.Location.Timestamp < DateTime.Now.Subtract(new TimeSpan(0, 5, 0));
                        bool moved = tracker.Location.DistanceTo(curlocation, UnitOfLength.Kilometers) > 0.1;
                        if (stale || moved)
                        {
                            GlobalVariables.GPSTrackerCache.Remove(tracker);
                            tracker.Location = curlocation;
                            GlobalVariables.GPSTrackerCache.Add(tracker);
                            //cache is updated

                            GPSTrackerLocation gpsTrackerLocation = new GPSTrackerLocation();
                            gpsTrackerLocation.DeviceID = tracker.DeviceID;
                            gpsTrackerLocation.Location.Timestamp = tracker.Location.Timestamp;
                            gpsTrackerLocation.Location = curlocation;
                            trackersToUpdate.Add(gpsTrackerLocation);
                        }
                    }
                    if (trackersToUpdate.Any())
                    {
                        if (ClientFactory.UserGuid != Guid.Empty)
                            new Client<GPSTrackerLocation>().Save(trackersToUpdate, "Updating Bluetooth Device Locations");
                    }
                    App.Bluetooth.DetectedBlueToothMACAddresses.Clear();
                }
                );
            }
            catch (Exception ex)
            {
                var log = new MobileLogging(LogType.BackgroundProcess, "Upload Tiles", ex.Message + ex.StackTrace, this.GetType().Name);
            }


            //if ((master != null) && (master.Location.Timestamp < DateTime.Now.Subtract(new TimeSpan(0, 15, 0))))
            //{
            //    GPSTrackerLocation device = new GPSTrackerLocation();
            //    device.DeviceID = MobileUtils.GetDeviceID();
            //    device.Location.Latitude = App.GPS.Latitude;
            //    device.Location.Longitude = App.GPS.Longitude;
            //    device.Location.Timestamp = DateTime.Now;
            //    locations.Add(device);
            //    //device.BatteryLevel = ((double)CrossBattery.Current.RemainingChargePercent);
            //    //new Client<GPSTrackerLocation>().Save(device, "Updating Device Location"); //, SaveTrackerCallback);
            //}

            #region OLD
            //for (int i = 0; i < App.Bluetooth.Devices.Length; i++)
            //{
            //    String id = App.Bluetooth.Devices[i];
            //    int level = App.Bluetooth.BatteryLevels[i];
            //    var btmaster = trackers.FirstOrDefault(x => x.DeviceID.Equals(id));

            //    if ((btmaster != null) && (!locations.Any(x => x.DeviceID.Equals(btmaster.DeviceID))))
            //    {
            //        bool stale = btmaster.Location.Timestamp < DateTime.Now.Subtract(new TimeSpan(0, 15, 0));
            //        bool moved = btmaster.Location.DistanceTo(curlocation, UnitOfLength.Kilometers) > 0.1;
            //        if (stale || moved)
            //        {
            //            GPSTrackerLocation location = new GPSTrackerLocation();
            //            location.DeviceID = id;
            //            location.Location.Latitude = App.GPS.Latitude;
            //            location.Location.Longitude = App.GPS.Longitude;
            //            location.Location.Timestamp = DateTime.Now;
            //            location.BatteryLevel = level;
            //            locations.Add(location);
            //        }
            //    }
            //    //new Client<GPSTrackerLocation>().Save(location, "Found Kontakt Device"); //, SaveTrackerCallback);
            //}

            //if (locations.Any())
            //    new Client<GPSTrackerLocation>().Save(locations, "Updating Bluetooth Device Locations", (o, e) => { });
            #endregion

        }


        #endregion

        #region Utilities
        private void InitNotificationCentre()
        {
            LocalNotificationCenter.Current.NotificationActionTapped += (Plugin.LocalNotification.EventArgs.NotificationActionEventArgs e) =>
            {
                if (MainPageUtils.DetermineCorrectPage(e) != null)
                {
                    Device.BeginInvokeOnMainThread(() =>
                    {
                        Navigation.PushAsync(MainPageUtils.DetermineCorrectPage(e));
                    });
                }
            };

            MainPageUtils.OnMainPageNotificationsChanged += RefreshOnNotificationsChange;
        }

        private void RefreshOnNotificationsChange()
        {
            try
            {
                int index = toolEntries.FindIndex(x => x.Text.Equals("Notifications"));
                toolEntries.RemoveAt(index);

                string notificationsString = "";
                if (NumberOfNotfications != 0)
                {
                    notificationsString = NumberOfNotfications.ToString();
                }
                ToolEntry Notifications = new ToolEntry(notificationsString)
                {
                    Text = "Notifications",
                    Image = "notifications"
                };
                Notifications.OnTapped += (async (object sender, EventArgs e) =>
                {
                    using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Loading"))
                    {
                        NotificationList notificationList = new NotificationList();
                        notificationList.NotificationsClosed += (n) =>
                        {
                            NumberOfNotfications = n;
                            RefreshOnNotificationsChange();
                        };
                        Navigation.PushAsync(notificationList);
                    }
                });
                toolEntries.Insert(index, Notifications);
                Device.BeginInvokeOnMainThread(() =>
                {
                    flexLayout.Children.RemoveAt(index);
                    flexLayout.Children.Insert(index, toolEntries[index]);
                });
            }
            catch (Exception ex)
            {
                var log = new MobileLogging(LogType.UIUpdate, "Refresh on Notifications change", ex.Message + ex.StackTrace, this.GetType().Name);
            }
        }

        private void CheckNotificationsPushed(CoreTable table)
        {
            try
            {
                if (!Application.Current.Properties.ContainsKey("LastPushedNotifications"))
                {
                    Application.Current.Properties.Add("LastPushedNotifications", DateTime.Now);
                }
                DateTime lastPushed = DateTime.Parse(Application.Current.Properties["LastPushedNotifications"].ToString());
                List<NotificationShell> toNotify = new List<NotificationShell>();
                foreach (CoreRow row in table.Rows)
                {
                    List<object> list = row.Values;
                    DateTime created = DateTime.Parse(list[3].ToString());
                    if (created > new DateTime(2022, 8, 22)) // prevent spam from buildup of old notifications before this is released
                    {
                        if (created > lastPushed)
                        {
                            if (list[1] == null) list[1] = "";
                            if (list[2] == null) list[2] = "";
                            if (list[3] == null) list[3] = DateTime.MinValue;
                            if (list[4] == null) list[4] = "";
                            if (list[5] == null) list[5] = "";
                            if (list[6] == null) list[6] = Guid.Empty;

                            NotificationShell shell = new NotificationShell
                            {
                                ID = Guid.Parse(list[0].ToString()),
                                Sender = list[1].ToString(),
                                Title = list[2].ToString(),
                                Created = DateTime.Parse(list[3].ToString()),
                                EntityType = list[5].ToString(),
                                EntityID = Guid.Parse(list[6].ToString())
                            };
                            toNotify.Add(shell); //add notification to be pushed
                        }
                    }
                }
                if (toNotify.Count > 0)
                    PushNotificationsAsync(toNotify);
            }
            catch { }
        }

        private async Task PushNotificationsAsync(List<NotificationShell> shells)
        {
            try
            {
                int count = 1;

                foreach (NotificationShell shell in shells)
                {
                    var notification = new NotificationRequest
                    {
                        BadgeNumber = 1,
                        Description = shell.Title,
                        Title = "New PRS Notification: ",
                        ReturningData = shell.EntityID.ToString() + "$" + shell.EntityType,
                        NotificationId = count,
                    };
                    count++;
                    NotificationImage img = new NotificationImage();
                    img.ResourceName = "icon16.png";
                    notification.Image = img;

                    await LocalNotificationCenter.Current.Show(notification);
                }
                Application.Current.Properties["LastPushedNotifications"] = DateTime.Now;
            }
            catch { }
        }

        private void StartMidnightTimeSheetTimer()
        {
            midnightTimerOn = true;
            int msUntilMidnight = (int)(oneSecondBeforeMidnight - DateTime.Now).TotalMilliseconds;
            Timer midnightTimer = new Timer(MidnightTimerCallback, null, msUntilMidnight, Timeout.Infinite);
        }

        private void MidnightTimerCallback(object o)
        {
            try
            {
                //if (bSharedDevice)
                //    return;
                if (midnightTimerOn)
                {
                    if (clockOnButton.Text == "CLOCK OFF")
                    {
                        InABox.Core.Location here = new InABox.Core.Location()
                        {
                            Latitude = App.GPS.Latitude,
                            Longitude = App.GPS.Longitude,
                            Timestamp = DateTime.Now
                        };
                        TimeSheet timesheet = App.Data.TimeSheets?.Rows.FirstOrDefault()?.ToObject<TimeSheet>();
                        if (timesheet != null)
                        {
                            if (timesheet.ID != Guid.Empty)
                            {
                                if (ZeroLengthTimesheet())
                                {
                                    bUpdatingTimesheet = true;
                                    new Client<TimeSheet>().Delete(timesheet, "Deleted due to zero duration timesheet");
                                    App.Data.TimeSheets.Rows.Clear();
                                }
                                else
                                {
                                    timesheet.Finish = new TimeSpan(23, 59, 59);
                                    timesheet.FinishLocation = here;
                                    bUpdatingTimesheet = true;
                                    new Client<TimeSheet>().Save(timesheet, "Auto Close timesheet at Midnight");
                                    App.Data.TimeSheets.Rows.Clear();

                                    Guid jobid = Guid.Empty;
                                    String jobnumber = "";
                                    String jobname = "";

                                    if (!App.Data.CanBypassGates)
                                    {
                                        CoreRow row = App.Data.Gates.Rows.FirstOrDefault(r => App.Bluetooth.Devices.Contains(r.Get<JobTracker, String>(c => c.TrackerLink.DeviceID)));
                                        if (row != null)
                                        {
                                            jobid = row.Get<JobTracker, Guid>(x => x.JobLink.ID);
                                            jobnumber = row.Get<JobTracker, String>(x => x.JobLink.JobNumber);
                                            jobname = row.Get<JobTracker, String>(x => x.JobLink.Name);
                                        }
                                        CreateTimeSheet(jobid, jobnumber, jobname, here, App.GPS.Address, "Clocking On");
                                    }
                                    else
                                    {
                                        if ((!App.GPS.Latitude.Equals(0.0F)) && (!App.GPS.Longitude.Equals(0.0F)))
                                        {
                                            ChooseNearbyJob(here);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch { }
        }

        private void FinishTimeSheet(TimeSheet timesheet, InABox.Core.Location here)
        {
            try
            {
                TimeSpan tod = DateTime.Now - DateTime.Today;
                timesheet.Finish = new TimeSpan(tod.Hours, tod.Minutes, 0);
                timesheet.FinishLocation = here;
                bUpdatingTimesheet = true;
                new Client<TimeSheet>().Save(timesheet, "Clocking Off");
                App.Data.TimeSheets.Rows.Clear();
                midnightTimerOn = false;
                Timer last60Seconds = new Timer(Last60SecondsTimerCallBack, null, 5000, Timeout.Infinite);
                clockedOffInLast5Seconds = true;
                if (MainPageUtils.CurrentAssignment != null)
                {
                    MainPageUtils.SaveCurrentAssignment("PRS Mobile - clocking off", true);
                    MainPageUtils.CurrentAssignment = null;
                }

            }
            catch (Exception ex)
            {
                var log = new MobileLogging(LogType.Save, typeof(TimeSheet).ToString(), ex.Message, this.GetType().Name);
            }
        }

        private void Last60SecondsTimerCallBack(object o)
        {
            clockedOffInLast5Seconds = false;
        }

        private async void ChooseNearbyJob(InABox.Core.Location here)
        {
            try
            {
                JobShell selectedJob = new JobShell();
                Dictionary<string, JobShell> nearbyJobs = new Dictionary<string, JobShell>();
                foreach (CoreRow row in App.Data.Jobs.Rows)
                {
                    InABox.Core.Location jobLocation = new InABox.Core.Location() { Latitude = row.Get<Job, double>(X => X.SiteAddress.Location.Latitude), Longitude = row.Get<Job, double>(X => X.SiteAddress.Location.Longitude) };
                    double distance = here.DistanceTo(jobLocation, UnitOfLength.Kilometers);
                    if (distance < 1.0F)
                    {
                        JobShell jobShell = new JobShell();
                        jobShell.ID = row.Get<Job, Guid>(X => X.ID);
                        jobShell.JobNumber = row.Get<Job, String>(x => x.JobNumber);
                        jobShell.Name = row.Get<Job, String>(x => x.Name);
                        jobShell.DisplayName = jobShell.JobNumber + " " + jobShell.Name;
                        nearbyJobs.Add(jobShell.DisplayName, jobShell);
                    }
                }
                if (nearbyJobs.Count > 1)
                {
                    string[] array = nearbyJobs.Keys.ToArray();
                    string chosenOption = await DisplayActionSheet("Choose job site", "Cancel", null, array);
                    if (string.IsNullOrEmpty(chosenOption) || chosenOption.Equals("Cancel"))
                    {
                        CreateTimeSheet(selectedJob.ID, selectedJob.JobNumber, selectedJob.Name, here, App.GPS.Address, "Clocking On");
                        return;
                    }
                    else
                    {
                        selectedJob = nearbyJobs[chosenOption];
                    }
                }
                else if (nearbyJobs.Count == 1)
                {
                    selectedJob = nearbyJobs.Values.First();
                }
                CreateTimeSheet(selectedJob.ID, selectedJob.JobNumber, selectedJob.Name, here, App.GPS.Address, "Clocking On");
            }
            catch { }
        }

        void AddNote_Tapped(System.Object sender, System.EventArgs e)
        {
            try
            {
                TimeSheet timesheet = App.Data.TimeSheets?.Rows.FirstOrDefault()?.ToObject<TimeSheet>();
                if (timesheet == null)
                    return;
                var notepage = new NotePage(timesheet);
                Navigation.PushAsync(notepage);
            }
            catch { }
        }

        private void TaskBtn_Tapped(object sender, EventArgs e)
        {
            ListSelectionPage page = new ListSelectionPage(MainPageUtils.GetTasks());
            page.OnDictionaryItemTapped += (id, title) =>
            {
                MainPageUtils.OnTaskSelected(id, title);
            };
            Navigation.PushAsync(page);
        }

        private async void RequestUserInput(Guid taskID)
        {
            const string addtask = "Change current assignment task";
            const string newassignment = "Start a new assignment with this task";
            string chosenOption = await DisplayActionSheet("Choose an option", "Cancel", null, addtask, newassignment);
            switch (chosenOption)
            {
                case addtask:
                    MainPageUtils.ChangeAssignmentTask(taskID);
                    break;
                case newassignment:
                    MainPageUtils.SaveCurrentAssignment("PRS Mobile main screen - saving assignment on task change", true);
                    MainPageUtils.CreateNewAssignment(Guid.Empty, taskID);
                    break;
                default:
                    break;
            }
        }

        private void JobBtn_Tapped(object sender, EventArgs e)
        {
            try
            {
                JobSelectionPage jobSelectionPage = new JobSelectionPage();
                jobSelectionPage.OnItemSelected += (() =>
                {
                    MainPageUtils.Job.ID = jobSelectionPage.Job.ID;
                    MainPageUtils.Job.JobNumber = jobSelectionPage.Job.JobNumber;
                    MainPageUtils.Job.Name = jobSelectionPage.Job.Name;
                    RefreshScreen();
                    JobPage_OnItemSelected(jobSelectionPage.Job);
                });
                Navigation.PushAsync(jobSelectionPage);
            }
            catch { }
        }

        private void JobPage_OnItemSelected(JobShell job)
        {
            //try
            //{
            //    TimeSheet timesheet = App.Data.TimeSheets?.Rows.FirstOrDefault()?.ToObject<TimeSheet>();
            //    if (timesheet == null)
            //        return;



            //    String auditmessage = String.Format("Changed Selected Job to: {0}: {1}", timesheet.JobLink.JobNumber, timesheet.JobLink.Name);
            //    if (ZeroLengthTimesheet())
            //    {
            //        timesheet.JobLink.ID = job.ID;
            //        timesheet.JobLink.JobNumber = job.JobNumber;
            //        timesheet.JobLink.Name = job.Name;
            //        bUpdatingTimesheet = true;
            //        new Client<TimeSheet>().Save(timesheet, auditmessage);

            //        Device.BeginInvokeOnMainThread(() =>
            //        {
            //            if (timesheet.JobLink.ID != Guid.Empty)
            //            {
            //                jobBtn.Text = "(" + timesheet.JobLink.JobNumber + ") " + timesheet.JobLink.Name;
            //            }
            //            else
            //            {
            //                jobBtn.Text = "No Job Selected";
            //            }
            //        });
            //    }
            //    else
            //    {
            //        InABox.Core.Location here = new InABox.Core.Location()
            //        {
            //            Latitude = App.GPS.Latitude,
            //            Longitude = App.GPS.Longitude,
            //            Timestamp = DateTime.Now
            //        };
            //        TimeSpan tod = DateTime.Now - DateTime.Today;
            //        timesheet.Finish = new TimeSpan(tod.Hours, tod.Minutes, 0);
            //        timesheet.FinishLocation = here;
            //        new Client<TimeSheet>().Save(timesheet, "Changing Job");

            //        CreateTimeSheet(
            //            job.ID,
            //            job.JobNumber,
            //            job.Name,
            //            here,
            //            App.GPS.Address,
            //            auditmessage
            //        );
            //    }
            //    RefreshScreen();
            //}
            //catch { }
        }

        private bool CheckTimeSheetAgainstGates(TimeSheet timesheet)
        {
            DateTime now = DateTime.Now;

            //var timesheet = CurrentTimeSheet();

            //Can't confirm if there is no timesheet
            if (timesheet == null)
                return false;

            // Can't confirm if there are no devices
            if (App.Bluetooth.Devices.Length == 0)
                return false;

            if (App.Data.Gates == null)
                return false;

            long tsTicks = timesheet.Date.Add(timesheet.Start).Ticks;
            long btTicks = App.Bluetooth.TimeStamp.Ticks;

            if (Math.Abs(tsTicks - btTicks) > new TimeSpan(0, 2, 0).Ticks)
                return false;

            CoreRow firstgate = null;
            List<String> gates = new List<string>();
            // Scan every located d
            foreach (var device in App.Bluetooth.Devices)
            {
                CoreRow gate = App.Data.Gates?.Rows.FirstOrDefault(r => r.Get<JobTracker, String>(c => c.TrackerLink.DeviceID) == device);
                if (gate != null)
                {

                    if ((gate.Get<JobTracker, bool>(x => x.IsJobSite) == true) && (firstgate == null))
                        firstgate = gate;

                    gates.Add(gate.Get<JobTracker, String>(x => x.Gate));
                }
            }
            if (gates.Any())
            {
                timesheet.Gate = String.Join(", ", gates.OrderBy(x => x));
                if (firstgate != null)
                {
                    timesheet.JobLink.ID = firstgate.Get<JobTracker, Guid>(x => x.JobLink.ID);
                    timesheet.JobLink.JobNumber = firstgate.Get<JobTracker, String>(x => x.JobLink.JobNumber);
                    timesheet.JobLink.Name = firstgate.Get<JobTracker, String>(x => x.JobLink.Name);
                }
                return true;
                //new Client<TimeSheet>().Save(timesheet, "Confirmed Gate Entry by Bluetooth Tracker", (o, e) => { });
            }

            return false;

        }

        private bool ZeroLengthTimesheet()
        {
            try
            {
                if (App.Data.TimeSheets == null)
                    return true;

                CoreRow row = App.Data.TimeSheets.Rows.FirstOrDefault();

                if (row == null)
                    return true;

                String notes = row.Get<TimeSheet, String>(x => x.Notes);
                if (!String.IsNullOrWhiteSpace(notes))
                    return false;

                DateTime date = row.Get<TimeSheet, DateTime>(x => x.Date);
                TimeSpan start = row.Get<TimeSheet, TimeSpan>(x => x.Start);
                if (date.Equals(DateTime.Today))
                {
                    TimeSpan tod = DateTime.Now - DateTime.Today;
                    var diff = (tod - start).TotalSeconds;
                    if (Math.Abs(diff) < 120.0F)
                        return true;
                }
            }
            catch { }
            return false;
        }

        private async void CreateTimeSheet(Guid jobid, string jobnumber, String jobname, InABox.Core.Location location, String address, String auditmessage)
        {
            try
            {
                var timesheet = new TimeSheet();
                using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Loading"))
                {
                    timesheet.EmployeeLink.ID = GlobalVariables.EmpID;
                    timesheet.Date = DateTime.Today;
                    TimeSpan tod = DateTime.Now - DateTime.Today;
                    tod = new TimeSpan(tod.Hours, tod.Minutes, 0);
                    timesheet.Start = tod;
                    timesheet.StartLocation = location;
                    timesheet.JobLink.ID = jobid;
                    timesheet.JobLink.JobNumber = jobnumber;
                    timesheet.JobLink.Name = jobname;
                    timesheet.Address = address;
                    timesheet.SoftwareVersion = MobileUtils.AppVersion.InstalledVersionNumber + GlobalVariables.DeviceString;

                    //if (ClientFactory.IsAllowed<AllowTimeSheetRollover>()) CheckTimeSheetAgainstGates(timesheet);
                    bUpdatingTimesheet = true;
                    new Client<TimeSheet>().Save(timesheet, auditmessage);
                    if (timesheet.ID == Guid.Empty)
                    {
                        DisplayAlert("Error creating new timesheet", "Please check your connection and try again", "OK");
                        return;
                    }
                    StartMidnightTimeSheetTimer();
                    // Don't Save Completed Timesheets!
                    App.Data.TimeSheets.Rows.Clear();
                    if (timesheet.Finish.Ticks == 0L)
                    {
                        CoreRow row = App.Data.TimeSheets.NewRow();
                        App.Data.TimeSheets.LoadRow(row, timesheet);
                        App.Data.TimeSheets.Rows.Add(row);
                    }
                }
                Device.BeginInvokeOnMainThread(() =>
                {
                    if (timesheet.JobLink.ID != Guid.Empty)
                    {
                        jobBtn.Text = "(" + timesheet.JobLink.JobNumber + ") " + timesheet.JobLink.Name;
                    }
                    else
                    {
                        jobBtn.Text = "No Job Selected";
                    }
                });
            }
            catch (Exception ex)
            {
                var log = new MobileLogging(LogType.Save, typeof(TimeSheet).ToString(), ex.Message, this.GetType().Name);
            }
        }

        private bool CheckLocation()
        {
            try
            {
                if (App.Data.CanBypassGates)
                {
                    if (App.GPS.TimeStamp > DateTime.Now.Subtract(new TimeSpan(0, 15, 0)))
                        return true;
                    else
                    {
                        App.GPS.GetLocation(true);
                        return false;
                    }

                }
                if (App.Data.Gates == null)
                    return false;
                if (App.Bluetooth.TimeStamp < DateTime.Now.Subtract(new TimeSpan(0, 15, 0)))
                    return false;
                if (!App.Bluetooth.Devices.Any())
                    return false;
                return App.Data.Gates.Rows.Any(r => App.Bluetooth.Devices.Contains(r.Get<JobTracker, String>(c => c.TrackerLink.DeviceID)));
            }
            catch
            {
                return true;
            }
        }

        private String DisplayAddress()
        {
            try
            {
                bool PRSReady = App.Data.Employee != null; // && (TimeSheet != null); // && (Activities != null);
                if (!PRSReady)
                    return "Retrieving Data";

                if (App.Data.CanBypassGates)
                {
                    if (App.GPS.TimeStamp < DateTime.Now.Subtract(new TimeSpan(0, 5, 0)))
                    {
                        App.GPS.GetLocation(true);
                        return "Searching for GPS";
                    }
                    else
                        return App.GPS.Address;
                }
                else
                {

                    // Hmm.. this can/should be simplified
                    // if in range of a gate
                    //    Show Gate Description
                    // else
                    //    "Looking for Gate"

                    if ((App.Data.Gates != null) && (App.Bluetooth.TimeStamp > DateTime.Now.Subtract(new TimeSpan(0, 2, 0))))
                    {
                        CoreRow row = App.Data.Gates.Rows.FirstOrDefault(r => App.Bluetooth.Devices.Contains(r.Get<JobTracker, String>(c => c.TrackerLink.DeviceID)));
                        if (row != null)
                            return row.Get<JobTracker, String>(x => x.Gate);
                        //else if ((CurrentTimeSheet() != null) && (!GPS.TimeStamp.IsEmpty()))
                        //    return GPS.Address;
                        else
                            return "Looking for Gate";
                    }
                    //else if ((CurrentTimeSheet() != null) && (GPS.TimeStamp > DateTime.Now.Subtract(new TimeSpan(0, 2, 0))))
                    //    return GPS.Address;
                    else
                        return "Looking for Gate";
                }
            }
            catch
            {
                return "Address error";
            }
        }

        #region Background Loading
        private void LoadCacheLists()
        {
            GlobalVariables.ProductsLoaded = false;
            GlobalVariables.JobsLoaded = false;
            GlobalVariables.GetXamarinWidth();

            CacheLoader.LoadJobs();
            LoadEmployeeShells();
            LoadCompanyDevices();
            LoadBlueToothAddresses();
            LoadProducts();

            //LoadHRToDos(); to be uncommented when ready for roll out
        }

        private void LoadCompanyDevices()
        {
            Task.Run(() =>
            {
                if (!string.IsNullOrWhiteSpace(MainPageUtils.deviceName) && MainPageUtils.deviceName != "unknown")
                {
                    List<Equipment> companyDevices = new List<Equipment>();
                    CoreTable table = DoEquipmentQuery();
                    while (table == null)
                        table = DoEquipmentQuery();
                    if (table.Rows.Any())
                    {
                        foreach (CoreRow row in table.Rows)
                        {
                            List<object> list = row.Values;
                            if (list[0].ToString().Equals(MainPageUtils.deviceName))
                            {
                                matchedDeviceName = MainPageUtils.deviceName;
                            }
                        }
                    }
                }
            });
        }

        private CoreTable DoEquipmentQuery()
        {
            try
            {
                return new Client<Equipment>().Query
                        (
                            new Filter<Equipment>(x => x.GroupLink.Code).IsEqualTo("DEVICE"),
                            new Columns<Equipment>(
                                x => x.TrackerLink.DeviceID
                                )
                            );
            }
            catch (Exception ex)
            {
                var log = new MobileLogging(LogType.Query, "DoEquipmentQuery()", ex.Message + ex.StackTrace, "CacheLoader");
                return null;
            }
        }

        private void LoadEmployeeShells()
        {
            Task.Run(() =>
            {
                try
                {
                    AddEmployees();
                    AddTeams();
                    AddTeamEmployees();
                }
                catch (Exception ex)
                {
                    var log = new MobileLogging(LogType.Query, "LoadEmployeeShells()", ex.Message + ex.StackTrace, this.GetType().Name);
                }
            });
        }

        private void AddEmployees()
        {
            List<EmployeeShell> employeeShells = new List<EmployeeShell>();
            CoreTable emps = DoEmployeeQuery();
            while (emps == null)
                emps = DoEmployeeQuery();

            foreach (var row in emps.Rows)
            {
                employeeShells.Add(
                    new EmployeeShell()
                    {
                        ID = row.Get<Employee, Guid>(x => x.ID),
                        Code = row.Get<Employee, String>(x => x.Code),
                        Name = row.Get<Employee, String>(x => x.Name),
                        TeamName = "All Staff"
                    }
                );
            }
            GlobalVariables.EmployeeShells = employeeShells;
        }

        private void AddTeamEmployees()
        {
            List<EmployeeShell> teamEmployeeShells = new List<EmployeeShell>();
            CoreTable members = DoEmployeeTeamQuery();
            while (members == null)
                members = DoEmployeeTeamQuery();

            foreach (var row in members.Rows)
            {
                teamEmployeeShells.Add(
                    new EmployeeShell()
                    {
                        ID = row.Get<EmployeeTeam, Guid>(x => x.EmployeeLink.ID),
                        Code = row.Get<EmployeeTeam, String>(x => x.EmployeeLink.Code),
                        Name = row.Get<EmployeeTeam, String>(x => x.EmployeeLink.Name),
                        TeamName = row.Get<EmployeeTeam, String>(x => x.TeamLink.Name)
                    }
                );
            }
            GlobalVariables.TeamEmployeeShells = teamEmployeeShells;
        }

        private void AddTeams()
        {
            var teamsTable = DoTeamsQuery();
            while (teamsTable == null)
                teamsTable = DoTeamsQuery();

            GlobalVariables.TeamNames = teamsTable.Rows.Select(r => r.Get<Team, String>(c => c.Name)).ToList();
        }

        private CoreTable DoEmployeeQuery()
        {
            try
            {
                return new Client<Employee>().Query(
                    LookupFactory.DefineFilter<Employee>(),
                    new Columns<Employee>(x => x.ID, x => x.Code, x => x.Name),
                    LookupFactory.DefineSort<Employee>());
            }
            catch (Exception ex)
            {
                var log = new MobileLogging(LogType.Query, "DoEmployeeQuery()", ex.Message + ex.StackTrace, this.GetType().Name);
                return null;
            }
        }

        private CoreTable DoTeamsQuery()
        {
            try
            {
                return new Client<Team>().Query(LookupFactory.DefineFilter<Team>(),
                        new Columns<Team>(x => x.Name),
                        new SortOrder<Team>(x => x.Name));
            }
            catch (Exception ex)
            {
                var log = new MobileLogging(LogType.Query, "DoTeamsQuery()", ex.Message + ex.StackTrace, this.GetType().Name);
                return null;
            }
        }

        private CoreTable DoEmployeeTeamQuery()
        {
            try
            {
                return new Client<EmployeeTeam>().Query(LookupFactory.DefineFilter<EmployeeTeam>(),
                            new Columns<EmployeeTeam>(x => x.EmployeeLink.ID)
                                .Add(x => x.EmployeeLink.Code)
                                .Add(x => x.EmployeeLink.Name)
                                .Add(x => x.TeamLink.Name),
                            new SortOrder<EmployeeTeam>(x => x.EmployeeLink.Name));
            }
            catch (Exception ex)
            {
                var log = new MobileLogging(LogType.Query, "DoTeamsQuery()", ex.Message + ex.StackTrace, this.GetType().Name);
                return null;
            }
        }

        private async void LoadHRToDos()
        {
            try
            {
                await Task.Run(() =>
                {
                    Thread.Sleep(10000);
                    if (GlobalVariables.UpdateHRItemsNeedingAttention())
                    {
                        string message = "You have HR Items needing attention. Open My HR now?";
                        Device.BeginInvokeOnMainThread(async () =>
                        {
                            string chosenOption = await DisplayActionSheet(message, "Cancel", null, "Yes", "No");
                            switch (chosenOption)
                            {
                                case "Cancel":
                                    break;
                                case "No":
                                    break;
                                default:
                                    break;
                                case "Yes":
                                    MyHRHome myHRHome = new MyHRHome();
                                    Navigation.PushAsync(myHRHome);
                                    break;
                            }
                        });
                    }
                });
            }
            catch { }
        }

        private void LoadProducts()
        {
            Task.Run(() =>
            {
                ProductsLoader productsLoader = new ProductsLoader();
            });
        }

        private async void LoadBlueToothAddresses()
        {
            Task.Run(() =>
            {
                GlobalVariables.GPSTrackerCache = new List<GPSTracker>();
                CoreTable table = QueryGPSTrackers();
                while (table == null)
                    table = QueryGPSTrackers();
                foreach (CoreRow row in table.Rows)
                {
                    GPSTracker tracker = row.ToObject<GPSTracker>();
                    GlobalVariables.GPSTrackerCache.Add(tracker);
                    App.Bluetooth.KnownBlueToothMACAddresses.Add(tracker.DeviceID);
                }
            });
        }

        private CoreTable QueryGPSTrackers()
        {
            try
            {
                return new Client<GPSTracker>().Query(new Filter<GPSTracker>(x => x.Type.Description).Contains("Kontakt"));
            }
            catch (Exception ex)
            {
                var log = new MobileLogging(LogType.Query, "QueryGPSTrackers()", ex.Message + ex.StackTrace, this.GetType().Name);
                return null;
            }
        }
        #endregion
        #endregion

        #region Modules
        public async void InitToolEntryList()
        {
            try
            {
                await Task.Run(() =>
                {
                    //Assignments
                    ToolEntry Assignments = new ToolEntry
                    {
                        Text = "Assignments",
                        Image = "calendar"
                    };

                    Assignments.OnTapped += ((object sender, EventArgs e) =>
                    {
                        var assignment_form = new AssignmentList();
                        Navigation.PushAsync(assignment_form);
                    });
                    if (PRSSecurity.CanView<Assignment>())
                        toolEntries.Add(Assignments);

                    //Deliveries
                    ToolEntry Deliveries = new ToolEntry
                    {
                        Text = "Deliveries",
                        Image = "deliveries"
                    };
                    Deliveries.OnTapped += ((object sender, EventArgs e) =>
                    {
                        if (GlobalVariables.IsDeliveryDriver)
                        {
                            var delivery_form = new DeliveryList();
                            Navigation.PushAsync(delivery_form);
                        }

                        else
                        {
                            DataGridHost host = new DataGridHost(new DeliveryGrid());
                            host.SetActionButton("Add");
                            host.OnActionButtonClicked += ((list) =>
                            {
                                DeliveryDetails details = new DeliveryDetails(Guid.Empty);
                                details.OnDeliverySaved += () => { (host.DataGrid as DeliveryGrid).RefreshGrid(); };
                                Navigation.PushAsync(details);
                            });
                            Navigation.PushAsync(host);
                        }
                    });
                    if (PRSSecurity.CanView<Delivery>())
                        toolEntries.Add(Deliveries);

                    //Digital Forms
                    ToolEntry Forms = new ToolEntry
                    {
                        Text = "Forms",
                        Image = "forms"
                    };
                    Forms.OnTapped += ((object sender, EventArgs e) =>
                    {
                        var qaFormPicker = new DigitalFormsPicker();
                        Navigation.PushAsync(qaFormPicker);
                    });
                    if (PRSSecurity.CanView<DigitalForm>())
                        toolEntries.Add(Forms);

                    //Equipment
                    ToolEntry Equipment = new ToolEntry
                    {
                        Text = "Equipment",
                        Image = "digger"
                    };
                    Equipment.OnTapped += (async (object sender, EventArgs e) =>
                    {
                        using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Loading"))
                        {
                            var equipment = new EquipmentModule();
                            Navigation.PushAsync(equipment);
                        }
                    });
                    if (PRSSecurity.CanView<Equipment>())
                        toolEntries.Add(Equipment);

                    //InOut
                    ToolEntry InOut = new ToolEntry
                    {
                        Text = "In/Out",
                        Image = "inout"
                    };
                    InOut.OnTapped += ((object sender, EventArgs e) =>
                    {
                        var staff_form = new StaffStatusPage();
                        Navigation.PushAsync(staff_form);
                    });
                    if (PRSSecurity.IsAllowed<CanViewInOutBoard>())
                        toolEntries.Add(InOut);

                    //Manufacturing
                    ToolEntry Manufacturing = new ToolEntry
                    {
                        Text = "Manufacturing",
                        Image = "manufacturingg"
                    };
                    if (Device.RuntimePlatform.Equals(Device.iOS))
                    {
                        Manufacturing.Image = "Image";
                    }
                    Manufacturing.OnTapped += ((object sender, EventArgs e) =>
                    {
                        ManufacturingScreen manufacturingScreen = new ManufacturingScreen();
                        Navigation.PushAsync(manufacturingScreen);
                    });
                    if (PRSSecurity.IsAllowed<CanViewManufacturingOnMobile>())
                        toolEntries.Add(Manufacturing);

                    //My HR
                    ToolEntry MyHR = new ToolEntry
                    {
                        Text = "My HR",
                        Image = "myhr"
                    };
                    MyHR.OnTapped += ((object sender, EventArgs e) =>
                    {
                        MyHRHome myHRHome = new MyHRHome();
                        Navigation.PushAsync(myHRHome);
                    });
                    toolEntries.Add(MyHR);

                    //Notifications
                    ToolEntry Notifications = new ToolEntry()
                    {
                        Text = "Notifications",
                        Image = "notifications"
                    };
                    Notifications.OnTapped += (object sender, EventArgs e) =>
                    {
                        NotificationList notificationList = new NotificationList();
                        notificationList.NotificationsClosed += (n) =>
                        {
                            NumberOfNotfications = n;
                            RefreshOnNotificationsChange();
                        };
                        Navigation.PushAsync(notificationList);

                    };
                    toolEntries.Add(Notifications);

                    ToolEntry Products = new ToolEntry()
                    {
                        Text = "Products",
                        Image = "products"
                    };
                    Products.OnTapped += (object sender, EventArgs e) =>
                    {
                        var page = new DataGridHost(new ProductsGrid());

                        Navigation.PushAsync(page);
                    };
                    if (PRSSecurity.CanView(typeof(Product)))
                        toolEntries.Add(Products);

                    //Purchase Orders
                    ToolEntry PurchaseOrders = new ToolEntry()
                    {
                        Text = "Purchase Orders",
                        Image = "shoppingcart"
                    };
                    PurchaseOrders.OnTapped += ((object sender, EventArgs e) =>
                    {
                        PurchaseOrderModule page = new PurchaseOrderModule();
                        Navigation.PushAsync(page);
                    });
                    if (PRSSecurity.CanView<PurchaseOrder>())
                        toolEntries.Add(PurchaseOrders);

                    //Scanner
                    ToolEntry Scanner = new ToolEntry
                    {
                        Text = "Scanner",
                        Image = "scanner"
                    };
                    Scanner.OnTapped += ((object sender, EventArgs e) =>
                    {
                        ScannerPage scannerPage = new ScannerPage();
                        Navigation.PushAsync(scannerPage);
                    });
                    toolEntries.Add(Scanner);

                    //Site
                    ToolEntry Site = new ToolEntry
                    {
                        Text = "Site",
                        Image = "construction"
                    };
                    Site.OnTapped += ((object sender, EventArgs e) =>
                    {
                        Site site = new Site(new Job { ID = MainPageUtils.Job.ID, Name = MainPageUtils.Job.Name, JobNumber = MainPageUtils.Job.JobNumber });
                        Navigation.PushAsync(site);
                    });
                    toolEntries.Add(Site);

                    //Store Requis
                    ToolEntry StoreRequis = new ToolEntry
                    {
                        Text = "Store Requis",
                        Image = "storerequis"
                    };
                    StoreRequis.OnTapped += ((object sender, EventArgs e) =>
                    {
                        var storeRequisList = new StoreRequiList();
                        Navigation.PushAsync(storeRequisList);
                    });
                    if (PRSSecurity.CanView<Requisition>())
                        toolEntries.Add(StoreRequis);

                    //Tasks
                    ToolEntry Tasks = new ToolEntry
                    {
                        Text = "My Tasks",
                        Image = "tasks"
                    };
                    Tasks.OnTapped += ((object sender, EventArgs e) =>
                    {
                        var tasksForm = new TasksList();
                        Navigation.PushAsync(tasksForm);
                    });
                    if (PRSSecurity.IsAllowed<CanViewTasks>())
                        toolEntries.Add(Tasks);

                    //Warehousing
                    ToolEntry Warehousing = new ToolEntry
                    {
                        Text = "Warehousing",
                        Image = "newwarehousing"
                    };
                    Warehousing.OnTapped += ((object sender, EventArgs e) =>
                    {
                        Warehousing2 locations = new Warehousing2();
                        Navigation.PushAsync(locations);
                    });
                    if (PRSSecurity.CanView<StockWarehouse>())
                        toolEntries.Add(Warehousing);

                    AddChildren();
                });
            }
            catch { }
        }

        private void AddChildren()
        {
            Device.BeginInvokeOnMainThread(() =>
            {
                foreach (ToolEntry toolEntry in toolEntries)
                {
                    toolEntry.Margin = new Thickness(5, 0, 5, 0);
                    flexLayout.Children.Add(toolEntry);
                }
                MainPageUtils.SearchForNewNotifications();
                AddBlanks();
            });
        }

        private void AddBlanks()
        {
            for (int x = 0; x < 6; x++)
            {
                ToolEntry toolEntry = new ToolEntry(true);
                toolEntry.Margin = new Thickness(5, 0, 5, 0);
                flexLayout.Children.Add(toolEntry);
            }
        }

        private void Settings_Tapped(object sender, EventArgs e)
        {
            try
            {
                var page = new SettingsPage();
                Navigation.PushAsync(page);
            }
            catch { }
        }
        #endregion
    }
}