prs/prs.desktop/Forms/EmailInterfaceForm.xaml.cs

using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using com.sun.org.apache.xpath.@internal;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.Mail;
using InABox.Wpf;
using InABox.WPF;

namespace PRSDesktop
{
    public enum EmailRootFolder
    {
        Inbox,
        Sent
    }

    public class EmailInterface : BaseObject
    {
        [EnumLookupEditor(typeof(EmailRootFolder), Editable = Editable.Disabled)]
        public EmailRootFolder Folder { get; set; }

        [TextBoxEditor(Editable = Editable.Disabled)]
        public string ID { get; set; }

        [DateTimeEditor(Editable = Editable.Disabled)]
        public DateTime Date { get; set; }

        [TextBoxEditor(Editable = Editable.Disabled)]
        public string Subject { get; set; }

        public CustomerLink Customer { get; set; }

        public JobLink Job { get; set; }

        public TimeSpan Time { get; set; }
    }

    public class EmailInterfaceGrid : DynamicGrid<EmailInterface>
    {
        public static readonly DependencyProperty RootFolderProperty =
            DependencyProperty.Register(nameof(RootFolder), typeof(EmailRootFolder), typeof(EmailInterfaceGrid));

        public static readonly DependencyProperty
            FolderProperty = DependencyProperty.Register(nameof(Folder), typeof(string), typeof(EmailInterfaceGrid));

        public static readonly DependencyProperty CountProperty = DependencyProperty.Register(nameof(Count), typeof(int), typeof(EmailInterfaceGrid));

        private static readonly ICoreMailer mailer = ClientFactory.CreateMailer();


        public EmailInterfaceGrid()
        {
            Folder = "";
            FromDate = DateTime.MinValue;
            ToDate = DateTime.MaxValue;

            if (Mailer != null)
                try
                {
                    Mailer.Connect();
                }
                catch (Exception)
                {
                    MessageBox.Show("Unable to connect to email system!\nPlease configure this in User Settings");
                }
            else
                MessageBox.Show("Please configure Email Settings before continuing.");
        }

        protected override void Init()
        {
            ActionColumns.Add(new DynamicImageColumn(PRSDesktop.Resources.delete.AsBitmapImage(), EmailActionIgnore)
            { Position = DynamicActionColumnPosition.Start });
            ActionColumns.Add(new DynamicImageColumn(PRSDesktop.Resources.minus.AsBitmapImage(), EmailLessTimeClick));
            ActionColumns.Add(new DynamicImageColumn(PRSDesktop.Resources.plus.AsBitmapImage(), EmailMoreTimeClick));
            ActionColumns.Add(new DynamicImageColumn(PRSDesktop.Resources.tick.AsBitmapImage(), EmailActionClick));
        }

        protected override void DoReconfigure(DynamicGridOptions options)
        {
            options.RecordCount = true;
            options.DirectEdit = true;
        }

        public EmailRootFolder RootFolder
        {
            get => (EmailRootFolder)GetValue(RootFolderProperty);
            set => SetValue(RootFolderProperty, value);
        }

        public string Folder
        {
            get => (string)GetValue(FolderProperty);
            set => SetValue(FolderProperty, value);
        }

        public int Count
        {
            get => (int)GetValue(CountProperty);
            set => SetValue(CountProperty, value);
        }

        public Guid EmployeeID { get; set; }

        public Guid ActivityID { get; set; }

        public DateTime FromDate { get; set; }

        public DateTime ToDate { get; set; }

        public ICoreMailer Mailer => mailer;

        //Dictionary<String, Guid> validemails = new Dictionary<String, Guid>();

        protected override DynamicGridColumns LoadColumns()
        {
            var result = new DynamicGridColumns();
            result.Add<EmailInterface, DateTime>(x => x.Date, 120, "Date", "dd MMM yy HH:mm", Alignment.MiddleCenter);
            result.Add<EmailInterface, EmailRootFolder>(x => x.Folder, 60, "Folder", "", Alignment.MiddleCenter);
            result.Add<EmailInterface, string>(x => x.ID, 60, "ID", "", Alignment.MiddleCenter);
            result.Add<EmailInterface, Guid>(x => x.Customer.ID, 200, "Customer", "", Alignment.MiddleLeft);
            result.Add<EmailInterface, string>(x => x.Subject, 0, "Subject", "", Alignment.MiddleLeft);
            result.Add<EmailInterface, Guid>(x => x.Job.ID, 200, "Job", "", Alignment.MiddleLeft);
            result.Add<EmailInterface, TimeSpan>(x => x.Time, 100, "Time", "", Alignment.MiddleCenter);
            //var cols = new Columns<EmailInterface>().Default(ColumnType.IncludeLinked);
            return result;
        }

        public override void DeleteItems(params CoreRow[] rows)
        {
        }

        public override EmailInterface LoadItem(CoreRow row)
        {
            return row.ToObject<EmailInterface>();
        }

        protected override void Reload(
        	Filters<EmailInterface> criteria, Columns<EmailInterface> columns, ref SortOrder<EmailInterface>? sort,
        	CancellationToken token, Action<CoreTable?, Exception?> action)
        {
            var result = new CoreTable();
            result.LoadColumns(typeof(EmailInterface));
            if (Mailer != null && Mailer.IsConnected)
            {
                var folder = Mailer.FindFolder(RootFolder.Equals(EmailRootFolder.Inbox) ? Mailer.Inbox : Mailer.SentItems, Folder);
                if (folder != null)
                {
                    var index = Math.Max(folder.Count - Count, 0);
                    var messages = Mailer.ListMessages(folder, index, index + (Count - 1));

                    var filtered = messages.Where(x => x.Date.Date >= FromDate && x.Date.Date <= ToDate).ToArray();
                    foreach (var message in filtered.Reverse())
                        if (message.Date.Date >= FromDate && message.Date.Date <= ToDate)
                        {
                            var email = "";
                            if (RootFolder.Equals(EmailRootFolder.Inbox))
                                email = message.From; // validemails.ContainsKey(message.From.ToUpper()) ? message.From.ToUpper() : "";
                            else
                                email = message.To.First();
                            //foreach (var to in message.To)
                            //{
                            //    if (validemails.ContainsKey(to.ToUpper()))
                            //    {
                            //        email = to.ToUpper();
                            //        break;
                            //    }
                            //}
                            var subject = message.Subject ?? "";

                            if (!string.IsNullOrWhiteSpace(email) && !subject.StartsWith("[PRS:"))
                            {
                                var intf = new EmailInterface();
                                intf.Folder = RootFolder;
                                intf.ID = message.ID;
                                intf.Date = message.Date;
                                intf.Customer.ID = Guid.Empty; // validemails[email];
                                intf.Subject = subject;
                                result.LoadRow(intf);
                            }
                        }
                }
            }

            action.Invoke(result, null);
        }

        public override void SaveItem(EmailInterface item)
        {
        }

        private bool EmailMoreTimeClick(CoreRow? arg)
        {
            if (arg == null)
                return false;

            var t = arg.Get<EmailInterface, TimeSpan>(x => x.Time);
            t = t.Floor(new TimeSpan(0, 15, 0)).Add(new TimeSpan(0, 15, 0));
            UpdateCell(arg.Index, "Time", t);
            return false;
        }

        private bool EmailLessTimeClick(CoreRow? arg)
        {
            if (arg == null)
                return false;

            var t = arg.Get<EmailInterface, TimeSpan>(x => x.Time);
            t = t.Ceiling(new TimeSpan(0, 15, 0)).Subtract(new TimeSpan(0, 15, 0));
            if (t.Ticks < 0L)
                t = new TimeSpan(0);
            UpdateCell(arg.Index, "Time", t);
            return false;
        }

        private bool EmailActionIgnore(CoreRow? row)
        {
            if (row == null)
                return false;

            var id = row.Get<EmailInterface, string>(x => x.ID);
            var fld = RootFolder == EmailRootFolder.Sent ? Mailer.SentItems : Mailer.Inbox;
            var msg = Mailer.GetMessage(fld, id);
            msg.Subject = string.Format("[PRS:Ignore] {0}", msg.Subject);
            msg.Save();
            return true;
        }

        private bool EmailActionClick(CoreRow? arg)
        {
            if (arg == null)
                return false;

            var t = arg.Get<EmailInterface, TimeSpan>(x => x.Time);
            if (t.Ticks == 0L)
            {
                MessageBox.Show("You must select a time");
                return false;
            }

            var bOK = true;

            var jobid = Entity.EntityLinkID<EmailInterface, JobLink>(x => x.Job, arg);
            var jobname = arg.Get<EmailInterface, string>(x => x.Subject);
            var jobnumber = "";

            if (jobid == null)
            {
                if (Security.IsAllowed<CanCreateJobsFromEmails>())
                    bOK = MessageBox.Show("Create new job?", "Confirm", MessageBoxButton.OKCancel) == MessageBoxResult.OK;
                jobid = Guid.Empty;
            }
            else
            {
                var job = new Client<Job>().Query(
                    new Filter<Job>(x => x.ID).IsEqualTo(jobid),
                    Columns.None<Job>().Add(x => x.JobNumber, x => x.Name)).Rows
                    .FirstOrDefault();
                jobname = job != null ? job.Get<Job, string>(x => x.Name) : "";
                jobnumber = job != null ? job.Get<Job, string>(x => x.JobNumber) : "";
            }

            if (bOK)
            {
                var ag = new AssignmentGrid();
                ag.OnBeforeSave += (editor, items) =>
                {
                    var ass = items.FirstOrDefault() as Assignment;
                    if (ass != null)
                    {
                        if (!ass.JobLink.IsValid() && Security.IsAllowed<CanCreateJobsFromEmails>())
                        {
                            var job = new Job();
                            job.Name = jobname;
                            job.Customer.ID = arg.Get<EmailInterface, Guid>(x => x.Customer.ID);

                            var defstatus = new Client<JobStatus>().Query(new Filter<JobStatus>(x => x.Default).IsEqualTo(true));
                            if (defstatus.Rows.Any())
                                job.JobStatus.ID = defstatus.Rows.First().Get<JobStatus, Guid>(x => x.ID);

                            job.JobType = JobType.Project;

                            job.SiteLead.ID = EmployeeID;
                            job.ProjectLead.ID = EmployeeID;
                            //job.JobStatus = defstatus.ID;

                            job.Notes = new[] { string.Format("As per email dated {0:dd MMM yy}", arg.Get<EmailInterface, DateTime>(x => x.Date)) };
                            new Client<Job>().Save(job, "Created from Email Interface");

                            foreach (var item in items)
                            {
                                ass.JobLink.ID = job.ID;
                                ass.JobLink.JobNumber = job.JobNumber;
                            }
                        }
                    }
                };

                var Time = arg.Get<EmailInterface, DateTime>(x => x.Date).TimeOfDay;
                var Duration = arg.Get<EmailInterface, TimeSpan>(x => x.Time);

                var ass = new Assignment();
                ass.Date = arg.Get<EmailInterface, DateTime>(x => x.Date).Date;
                ass.Actual.Start = RootFolder == EmailRootFolder.Inbox ? Time : Time.Subtract(Duration);
                ass.Actual.Duration = Duration;
                ass.Actual.Finish = ass.Actual.Start.Add(ass.Actual.Duration);
                ass.ActivityLink.ID = ActivityID;
                var id = arg.Get<EmailInterface, string>(x => x.ID);
                var fld = RootFolder == EmailRootFolder.Sent ? Mailer.SentItems : Mailer.Inbox;
                var msg = Mailer.GetMessage(fld, id);
                ass.Description = msg.Body != null ? CoreUtils.StripHTML(msg.Body) : "";
                //ass.Completed = DateTime.Now;
                ass.EmployeeLink.ID = EmployeeID;
                ass.JobLink.ID = jobid ?? Guid.Empty;
                if (ag.EditItems(new[] { ass }))
                {
                    msg.Subject = ass.JobLink.IsValid()
                        ? string.Format("[PRS:{0}] {1}", ass.JobLink.JobNumber, msg.Subject)
                        : string.Format("[PRS:No Job] {0}", msg.Subject);
                    msg.Save();
                    return true;
                }
            }

            return false;
        }
    }

    /// <summary>
    ///     Interaction logic for EmailInterfaceForm.xaml
    /// </summary>
    public partial class EmailInterfaceForm : ThemableWindow
    {
        public EmailInterfaceForm()
        {
            InitializeComponent();

            Preview.VisibleButtons = RichTextEditorButtons.None;

            Emails.OnSelectItem += Emails_OnSelectItem;

            var me = new Client<Employee>().Load(new Filter<Employee>(x => x.UserLink.ID).IsEqualTo(ClientFactory.UserGuid)).FirstOrDefault();
            Emails.EmployeeID = me?.ID ?? Guid.Empty;
            Emails.ActivityID = Guid.Empty;
            Employee.Content = me != null ? me.Name : "(No Employee Found)";
        }

        public DateTime FromDate
        {
            get => Emails.FromDate;
            set => Emails.FromDate = value;
        }

        public DateTime ToDate
        {
            get => Emails.ToDate;
            set => Emails.ToDate = value;
        }

        private void Emails_OnSelectItem(object sender, DynamicGridSelectionEventArgs e)
        {
            var row = e.Rows?.FirstOrDefault();
            if (!Emails.Mailer.IsConnected || row == null)
                return;

            var fld = Folder.SelectedIndex == 1 ? Emails.Mailer.SentItems : Emails.Mailer.Inbox;
            var mailer = Emails.Mailer;
            Task.Run(() =>
            {
                var id = row.Get<EmailInterface, string>(x => x.ID);

                var msg = mailer.GetMessage(fld, id);
                var text = CoreUtils.StripHTML(msg.Body);
                Dispatcher.BeginInvoke(new Action(() => { Preview.Text = text; }));
            });
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            Emails.Refresh(true, true);
        }

        private void Folder_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (Emails == null || !Emails.IsLoaded)
                return;
            Emails.RootFolder = Folder.SelectedIndex == 1 ? EmailRootFolder.Sent : EmailRootFolder.Inbox;
            Emails.Refresh(false, true);
        }

        private void Items_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (Emails == null || !Emails.IsLoaded)
                return;
            var value = ((ComboBoxItem)Items.SelectedValue).Content.ToString() ?? "";
            var count = value.Equals("All Items") ? int.MaxValue : int.Parse(value);
            Emails.Count = count;
            Emails.Refresh(false, true);
        }
    }
}