prs/prs.mobile/comal.timesheets/Assignments/AssignmentDetails.xaml.cs

using System;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using Syncfusion.Drawing;
using Xamarin.Forms;
using Xamarin.Forms.Xaml;
using XF.Material.Forms.UI.Dialogs;
using PRSSecurity = InABox.Core.Security;

namespace comal.timesheets
{

    public class AssignmentDetailsChangedArgs : EventArgs
    {
        public string Property { get; }

        public AssignmentDetailsChangedArgs(String property)
        {
            Property = property;
        }
    }

    public delegate void AssignmentDetailsChangedDelegate(object sender, AssignmentDetailsChangedArgs args);

    [XamlCompilation(XamlCompilationOptions.Compile)]
    public partial class AssignmentDetails : ContentView, IAssignmentPage
    {

        public event AssignmentDetailsChangedDelegate OnDetailsChanged;

        public AssignmentEditDataModel DataModel => BindingContext as AssignmentEditDataModel;

        public AssignmentDetails()
        {
            InitializeComponent();
        }

        public void Load()
        {
            bool open = DataModel.Item.Completed.IsEmpty();

            Completed.Text = open
                ? "Complete"
                : InABox.Core.Security.CanEdit<Assignment>() ? "Re-Open" : $"Completed {DataModel.Item.Completed:dd/MM/yy}";

            Subject.IsEnabled = open && PRSSecurity.CanEdit<Assignment>();
            ActualStart.IsEnabled = open && PRSSecurity.IsAllowed<CanEditAssignmentActualTimes>();
            ActualFinish.IsEnabled = open && PRSSecurity.IsAllowed<CanEditAssignmentActualTimes>();
            BookedStart.IsEnabled = open && PRSSecurity.IsAllowed<CanEditAssignmentBookings>();
            BookedFinish.IsEnabled = open && PRSSecurity.IsAllowed<CanEditAssignmentBookings>();
            AsBookedBtn.IsEnabled = open && PRSSecurity.IsAllowed<CanEditAssignmentActualTimes>();
            Job.IsEnabled = open && PRSSecurity.CanEdit<Assignment>();
            Task.IsEnabled = open && PRSSecurity.CanEdit<Assignment>();
            Activity.IsEnabled = open && PRSSecurity.CanEdit<Assignment>();
            Description.IsEnabled = open && PRSSecurity.CanEdit<Assignment>();
            Completed.IsEnabled = open || PRSSecurity.CanEdit<Assignment>();
        }

        private async void Activity_Clicked(object sender, EventArgs e)
        {
            try
            {
                GenericSelectionPage page = new GenericSelectionPage(
                    "Select Activity",
                    new SelectionViewModel<EmployeeActivity>(
                        new Filter<EmployeeActivity>(x => x.Employee.ID).IsEqualTo(App.Data.Employee.ID),
                        new Expression<Func<EmployeeActivity, object>>[]
                            { x => x.Activity.Code, x => x.Activity.Description },
                        new Expression<Func<EmployeeActivity, object>>[] { x => x.Activity.ID },
                        new SortOrder<EmployeeActivity>(x => x.Activity.Code)
                    )
                );
                page.OnItemSelected += (row) =>
                {
                    Device.BeginInvokeOnMainThread(() =>
                    {
                        DataModel.Item.ActivityID = row.Get<EmployeeActivity, Guid>(c => c.Activity.ID);
                        DataModel.Item.ActivityCode = row.Get<EmployeeActivity, String>(c => c.Activity.Code);
                        DataModel.Item.ActivityDescription = row.Get<EmployeeActivity, String>(c => c.Activity.Description);
                        OnDetailsChanged?.Invoke(this, new AssignmentDetailsChangedArgs("Activity"));
                    });
                };
                Navigation.PushAsync(page);

            }
            catch
            {

            }
        }

        private void Job_Clicked(object sender, EventArgs e)
        {
            try
            {
                GenericSelectionPage page = new GenericSelectionPage(
                    "Select Job",
                    new SelectionViewModel<Job>(
                        new Filter<Job>(x => x.JobStatus.Active).IsEqualTo(true),
                        new Expression<Func<Job, object>>[]
                            { x => x.JobNumber, x => x.Name },
                        new Expression<Func<Job, object>>[] { x => x.ID, x => x.SiteAddress.Location.Latitude, x => x.SiteAddress.Location.Longitude },
                        new SortOrder<Job>(x => x.JobNumber, SortDirection.Descending)
                    )
                );
                page.OnItemSelected += (row) =>
                {
                    Device.BeginInvokeOnMainThread(() =>
                    {
                        DataModel.Item.JobID = row.Get<Job, Guid>(c => c.ID);
                        DataModel.Item.JobNumber = row.Get<Job, String>(c => c.JobNumber);
                        DataModel.Item.JobName = row.Get<Job, String>(c => c.Name);
                        DataModel.Coordinates = new PointF(
                            (float)row.Get<Job, double>(c => c.SiteAddress.Location.Longitude),
                            (float)row.Get<Job, double>(c => c.SiteAddress.Location.Latitude)
                        );
                        OnDetailsChanged?.Invoke(this, new AssignmentDetailsChangedArgs("Job"));
                    });
                };
                Navigation.PushAsync(page);

            }
            catch
            {

            }
        }

        private void Task_Clicked(object sender, EventArgs e)
        {
            try
            {
                GenericSelectionPage page = new GenericSelectionPage(
                    "Select Task",
                    new SelectionViewModel<Kanban>(
                        new Filter<Kanban>(x => x.Completed).IsEqualTo(DateTime.MinValue),
                        new Expression<Func<Kanban, object>>[]
                            { x => x.Number, x => x.Title },
                        new Expression<Func<Kanban, object>>[] { x => x.ID },
                        new SortOrder<Kanban>(x => x.Number, SortDirection.Descending)
                    )
                );
                page.OnItemSelected += (row) =>
                {
                    Device.BeginInvokeOnMainThread(() =>
                    {
                        DataModel.Item.TaskID = row.Get<Kanban, Guid>(c => c.ID);
                        DataModel.Item.TaskNumber = row.Get<Kanban, int>(c => c.Number);
                        DataModel.Item.TaskName = row.Get<Kanban, String>(c => c.Title);
                        OnDetailsChanged?.Invoke(this, new AssignmentDetailsChangedArgs("Task"));
                    });
                };
                Navigation.PushAsync(page);

            }
            catch
            {

            }
        }

        private async void Complete_Clicked(object sender, EventArgs e)
        {
            if (!DataModel.Item.Completed.IsEmpty())
            {
                DataModel.Item.Completed = DateTime.MinValue;
                DataModel.Save("Re-opened on Mobile Device");
                Load();
                return;
            }

            bool bOpenForms = DataModel.Forms.Any(x => !x.Completed);
            if (bOpenForms)
            {
                await MaterialDialog.Instance.AlertAsync("Please finish all open forms before completing this assignment", "Open Forms Found");
                return;
            }
            bool bConfirm = await MaterialDialog.Instance.ConfirmAsync(message: "Complete Assignment?",
                confirmingText: "Yes",
                dismissiveText: "No") == true;
            if (bConfirm)
            {
                DataModel.Item.Completed = DateTime.Now;
                DataModel.Save("Completed on Mobile Device");
                Navigation.PopAsync();
            }
        }

        private void ActualStartNowBtn_Clicked(object sender, EventArgs e)
        {
            ActualStart.Time = DateTime.Now.TimeOfDay;
            OnDetailsChanged?.Invoke(this, new AssignmentDetailsChangedArgs("ActualStart"));
        }

        private void ActualFinishNowBtn_Clicked(object sender, EventArgs e)
        {
            ActualFinish.Time = DateTime.Now.TimeOfDay;
            OnDetailsChanged?.Invoke(this, new AssignmentDetailsChangedArgs("ActualFinish"));
        }

        private void AsBookedBtn_Clicked(object sender, EventArgs e)
        {
            ActualStart.Time = BookedStart.Time;
            ActualFinish.Time = BookedFinish.Time;
            OnDetailsChanged?.Invoke(this, new AssignmentDetailsChangedArgs("ActualStart"));
            OnDetailsChanged?.Invoke(this, new AssignmentDetailsChangedArgs("ActualFinish"));
        }


        private void BookedStart_OnUnfocused(object sender, FocusEventArgs e)
        {
            OnDetailsChanged?.Invoke(this, new AssignmentDetailsChangedArgs("BookedStart"));
        }

        private void BookedFinish_OnUnfocused(object sender, FocusEventArgs e)
        {
            OnDetailsChanged?.Invoke(this, new AssignmentDetailsChangedArgs("BookedFinish"));
        }

        private void ActualStart_OnUnfocused(object sender, FocusEventArgs e)
        {
            OnDetailsChanged?.Invoke(this, new AssignmentDetailsChangedArgs("ActualStart"));
        }

        private void ActualFinish_OnUnfocused(object sender, FocusEventArgs e)
        {
            OnDetailsChanged?.Invoke(this, new AssignmentDetailsChangedArgs("ActualFinish"));
        }


        private void Description_OnTextChanged(object sender, TextChangedEventArgs e)
        {
            if (Description.IsFocused)
                OnDetailsChanged?.Invoke(this, new AssignmentDetailsChangedArgs("Description"));
        }

        private void Subject_OnTextChanged(object sender, TextChangedEventArgs e)
        {
            if (Subject.IsFocused)
                OnDetailsChanged?.Invoke(this, new AssignmentDetailsChangedArgs("Subject"));
        }
    }
}