private void MarkAsRoutingEmail(PXGraph graph, CRSMEmail message) { var cache = graph.Caches[message.GetType()]; message.ClassID = CRActivityClass.EmailRouting; message.RefNoteID = null; message.BAccountID = null; message.ContactID = null; cache.Update(message); }
private void PersistAM() { var cached = _graph.Caches[_activityMessage.GetType()].Locate(_activityMessage); _graph.Persist(); _graph.SelectTimeStamp(); var cache = _graph.Caches[_activityMessage.GetType()]; _activityMessage = (CRSMEmail)cache.CreateCopy(cached); }
protected override bool Process(Package package) { PXGraph graph = package.Graph; EMailAccount account = package.Account; CRSMEmail message = package.Message; if (account != null && ( (account.ForbidRouting ?? false) || !(account.RouteEmployeeEmails ?? false) )) { return(false); } bool?isFromInternalUser = IsFromInternalUser(graph, message); var recipients = new MailAddressList(); if (isFromInternalUser == true) { recipients.AddRange(GetExternalRecipient(graph, message)); } else if (isFromInternalUser == false) { recipients.AddRange(GetInternalRecipient(graph, message)); } else { return(false); // for those users and employees which are disabled or RouteEmails switched off } RemoveAddress(recipients, message.MailFrom); RemoveAddress(recipients, message.MailTo); RemoveAddress(recipients, message.MailCc); RemoveAddress(recipients, message.MailBcc); if (recipients.Count == 0) { return(false); } if (isFromInternalUser == true) { SendCopyMessageToOutside(graph, package.Account, message, recipients); MarkAsRoutingEmail(graph, message); MarkAsRead(graph, message); } else { SendCopyMessageToInside(graph, package.Account, message, recipients); } graph.EnsureCachePersistence(message.GetType()); return(true); }
private void SendCopyMessageToInside(PXGraph graph, EMailAccount account, CRSMEmail message, IEnumerable <Mailbox> email) { var cache = graph.Caches[message.GetType()]; var copy = (CRSMEmail)cache.CreateCopy(message); copy.NoteID = null; copy.EmailNoteID = null; copy.IsIncome = false; copy.ParentNoteID = message.NoteID; copy.MailTo = ConcatAddresses(email); //TODO: need add address description copy.MailCc = null; copy.MailBcc = null; Mailbox mailFrom; copy.MailFrom = Mailbox.TryParse(message.MailFrom, out mailFrom) ? new Mailbox(mailFrom.DisplayName, account.Address).ToString() : account.Address; copy.MPStatus = MailStatusListAttribute.PreProcess; copy.ClassID = CRActivityClass.EmailRouting; new AddInfoEmailProcessor().Process(new EmailProcessEventArgs(graph, account, copy)); copy.RefNoteID = null; copy.BAccountID = null; copy.ContactID = null; var imcUid = Guid.NewGuid(); copy.ImcUID = imcUid; copy.MessageId = GetType().Name + "_" + imcUid.ToString().Replace("-", string.Empty); copy.OwnerID = null; copy.WorkgroupID = null; copy = (CRSMEmail)cache.CreateCopy(cache.Insert(copy)); //Update owner and reset owner if employee not found copy.OwnerID = message.OwnerID; try { copy = (CRSMEmail)cache.Update(copy); } catch (PXSetPropertyException) { copy.OwnerID = null; copy = (CRSMEmail)cache.Update(copy); } copy.IsPrivate = message.IsPrivate; copy.WorkgroupID = message.WorkgroupID; var noteFiles = PXNoteAttribute.GetFileNotes(cache, message); if (noteFiles != null) { PXNoteAttribute.SetFileNotes(cache, copy, noteFiles); } }
//TODO: need optimizae DB requests internal static bool?IsFromInternalUser(PXGraph graph, CRSMEmail message) { var @from = EmailParser.ParseAddresses(message.MailFrom).FirstOrDefault().With(_ => _?.Address).With(_ => _?.Trim()); PXSelect <Users, Where2 < Where <Users.guest, Equal <False>, Or <Users.guest, IsNull> >, And <Users.email, Equal <Required <Users.email> > > > > .Clear(graph); var users = PXSelect <Users, Where2 < Where <Users.guest, Equal <False>, Or <Users.guest, IsNull> >, And <Users.email, Equal <Required <Users.email> > > > > .Select(graph, @from); bool disabledUser = users.Count > 0 && users.RowCast <Users>().All(_ => _.State == Users.state.Disabled); if (disabledUser) { return(null); } PXSelectJoin <EPEmployee, LeftJoin <Contact, On <Contact.contactID, Equal <EPEmployee.defContactID> > >, Where < EPEmployee.userID, IsNotNull, And <Contact.eMail, Equal <Required <Contact.eMail> > > > > .Clear(graph); var employees = PXSelectJoin <EPEmployee, LeftJoin <Contact, On <Contact.contactID, Equal <EPEmployee.defContactID> > >, Where < EPEmployee.userID, IsNotNull, And <Contact.eMail, Equal <Required <Contact.eMail> > > > > .Select(graph, @from); bool disabledEmployee = employees.Count > 0 && employees.RowCast <EPEmployee>().All(_ => _.Status == BAccount.status.Inactive || !(_.RouteEmails ?? false)); if (disabledEmployee) { return(null); } if (users.Count > 0 || employees.Count > 0) { return(true); } return(false); }
private static void FillMailCC(PXGraph graph, CRSMEmail message, Guid?refNoteId) { if (refNoteId != null && refNoteId.HasValue && refNoteId != null) { foreach (Mailbox email in CRRelationsList <CRRelation.refNoteID> .GetEmailsForCC(graph, refNoteId.Value)) { if (email != null) { message.MailCc += email.ToString() + "; "; } } } }
private void SendCopyMessage(PXGraph graph, EMailAccount account, CRSMEmail message, string email) { var cache = graph.Caches[message.GetType()]; var copy = (CRSMEmail)cache.CreateCopy(message); copy.NoteID = null; copy.EmailNoteID = null; copy.IsIncome = false; copy.ParentNoteID = message.NoteID; copy.MailTo = email; //TODO: need add address description copy.MailCc = null; copy.MailBcc = null; copy.MPStatus = MailStatusListAttribute.PreProcess; copy.ClassID = CRActivityClass.EmailRouting; new AddInfoEmailProcessor().Process(new EmailProcessEventArgs(graph, account, copy)); copy.RefNoteID = null; copy.BAccountID = null; copy.ContactID = null; copy.Pop3UID = null; copy.ImapUID = null; var imcUid = Guid.NewGuid(); copy.ImcUID = imcUid; copy.MessageId = this.GetType().Name + "_" + imcUid.ToString().Replace("-", string.Empty); copy.OwnerID = null; copy.WorkgroupID = null; copy = (CRSMEmail)cache.CreateCopy(cache.Insert(copy)); //Update owner and reset owner if employee not found copy.OwnerID = message.OwnerID; try { cache.Update(copy); } catch (PXSetPropertyException) { copy.OwnerID = null; copy = (CRSMEmail)cache.CreateCopy(cache.Update(copy)); } copy.WorkgroupID = message.WorkgroupID; var noteFiles = PXNoteAttribute.GetFileNotes(cache, message); if (noteFiles != null) { PXNoteAttribute.SetFileNotes(cache, copy, noteFiles); } graph.EnsureCachePersistence(copy.GetType()); }
private void SendCopyMessageToOutside(PXGraph graph, EMailAccount account, CRSMEmail message, IEnumerable <MailAddress> addresses) { var cache = graph.Caches[message.GetType()]; var copy = (CRSMEmail)cache.CreateCopy(message); copy.NoteID = null; copy.EmailNoteID = null; copy.IsIncome = false; copy.ParentNoteID = message.NoteID; MailAddress address; copy.MailFrom = EmailParser.TryParse(message.MailFrom, out address) ? new MailAddress(account.Address, address.DisplayName).ToString() : account.Address; copy.MailTo = PXDBEmailAttribute.ToString(addresses); //TODO: need add address description copy.MailCc = null; copy.MailBcc = null; copy.MPStatus = MailStatusListAttribute.PreProcess; copy.ClassID = CRActivityClass.Email; var imcUid = Guid.NewGuid(); copy.ImcUID = imcUid; copy.MessageId = GetType().Name + "_" + imcUid.ToString().Replace("-", string.Empty); copy.IsPrivate = message.IsPrivate; copy.OwnerID = null; copy.ParentNoteID = null; copy = (CRSMEmail)cache.CreateCopy(cache.Insert(copy)); //Update owner and reset owner if employee not found copy.OwnerID = message.OwnerID; try { copy = (CRSMEmail)cache.Update(copy); } catch (PXSetPropertyException) { copy.OwnerID = null; copy = (CRSMEmail)cache.Update(copy); } copy.ParentNoteID = message.NoteID; var noteFiles = PXNoteAttribute.GetFileNotes(cache, message); if (noteFiles != null) { PXNoteAttribute.SetFileNotes(cache, copy, noteFiles); } }
internal static bool IsOwnerEqualUser(PXGraph graph, CRSMEmail message, Guid?owner) { var @from = EmailParser.ParseAddresses(message.MailFrom).FirstOrDefault().With(_ => _.Address).With(_ => _.Trim()); PXSelect <Users, Where <Users.email, Equal <Required <Users.email> > > > .Clear(graph); var usersEmail = (Users)PXSelect <Users, Where <Users.email, Equal <Required <Users.email> > > > .Select(graph, @from); if (usersEmail != null) { return(usersEmail.PKID == owner); } return(false); }
protected override bool Process(Package package) { PXGraph graph = package.Graph; EMailAccount account = package.Account; CRSMEmail message = package.Message; if (account != null && (account.ForbidRouting ?? false)) { return(false); } var isFromInternalUser = IsFromInternalUser(graph, message); var recipients = new MailAddressList(); if (isFromInternalUser) { recipients.AddRange(GetExternalRecipient(graph, message)); } else { recipients.AddRange(GetInternalRecipient(graph, message)); } RemoveAddress(recipients, message.MailFrom); RemoveAddress(recipients, message.MailTo); RemoveAddress(recipients, message.MailCc); RemoveAddress(recipients, message.MailBcc); if (recipients.Count == 0) { return(false); } if (isFromInternalUser) { SendCopyMessageToOutside(graph, package.Account, message, recipients); MarkAsRoutingEmail(graph, message); MarkAsRead(graph, message); } else { SendCopyMessageToInside(graph, package.Account, message, recipients); } graph.EnsureCachePersistence(message.GetType()); return(true); }
private static CRSMEmail GetPreviousExternalMessage(PXGraph graph, CRSMEmail message) { if (message.Ticket == null) { return(null); } CRSMEmail prevActivity = SelectActivity(graph, message.Ticket); while (prevActivity != null && prevActivity.ClassID == CRActivityClass.EmailRouting) { prevActivity = SelectParentActivity(graph, prevActivity.ParentNoteID); } return(prevActivity); }
private bool CreateMessage() { if (_message != null) { _activityMessage = PXSelect <CRSMEmail, Where <CRSMEmail.noteID, Equal <Required <SMEmail.refNoteID> > > > .Select(_graph, _message.RefNoteID); return(true); } try { if (_email.Message.From == null || _email.Message.From.Count() == 0) { return(false); } using (PXTransactionScope ts = new PXTransactionScope()) { // Only two functions in scope so as not to create activity without email, // but also to prevent repetition of processing messages with bad attachments CreateActivity(); CreateEmail(); ts.Complete(); } if (_message == null) { return(false); } _activityMessage = PXSelect <CRSMEmail, Where <CRSMEmail.noteID, Equal <Required <SMEmail.refNoteID> > > > .Select(_graph, _message.RefNoteID); AppendAttachments(); PersistAM(); return(true); } catch (Exception ex) { PXTrace.WriteError(ex); PersistException(ex); return(false); } }
protected override bool Process(Package package) { CRSMEmail activity = package.Message; EMailAccount account = package.Account; PXGraph graph = package.Graph; if (activity.Ticket != null || activity.ParentNoteID != null || account.EmailAccountType != EmailAccountTypesAttribute.Exchange || !(account.IncomingProcessing ?? false)) { return(false); } if (String.IsNullOrEmpty(activity.MessageId) || String.IsNullOrEmpty(activity.MessageReference)) { return(false); } foreach (String id in activity.MessageReference.Split(new string[] { "> <", ">,<" }, StringSplitOptions.RemoveEmptyEntries)) { string refId = id; if (refId.IndexOf('<') != 0) { refId = refId.Insert(0, "<"); } if (refId.LastIndexOf('>') != refId.Length - 1) { refId = refId.Insert(refId.Length, ">"); } Boolean found = false; foreach (CRSMEmail parent in PXSelect <CRSMEmail, Where <CRSMEmail.messageId, Like <Required <CRSMEmail.messageId> > > > .SelectSingleBound(graph, null, refId)) { activity.Ticket = parent.ID; found = true; break; } if (found) { return(true); } } return(false); }
private void InsertInformationIntoMessage(CRSMEmail message, IEnumerable <string> briefInfo) { if (briefInfo == null) { return; } var content = message.Body ?? string.Empty; var match = _HTML_REGEX.Match(content); if (match.Success) { var bodyGroup = match.Groups["body"]; var orgBody = bodyGroup.Value; var sb = new StringBuilder(); foreach (string info in briefInfo) { sb.AppendFormat("<i>{0}</i><br/>", info); } sb.AppendFormat("<br/>"); var htmlText = sb.ToString(); if (!orgBody.StartsWith(htmlText)) { var newBody = orgBody.Insert(0, htmlText); content = content.Substring(0, bodyGroup.Index) + newBody + content.Substring(bodyGroup.Index + bodyGroup.Length); } } else { var sb = new StringBuilder(); sb.AppendLine("***"); foreach (string info in briefInfo) { sb.AppendLine(info); } sb.AppendLine("***"); sb.AppendLine(); var plainText = sb.ToString(); if (!content.StartsWith(plainText)) { content = content.Insert(0, plainText); } } message.Body = PX.Web.UI.PXRichTextConverter.NormalizeHtml(content); }
private MailAddressList GetFromExternal(PXGraph graph, CRSMEmail message) { var recipients = new MailAddressList(); recipients.AddRange(GetOwnerAddressByNote(graph, message.RefNoteID, message.OwnerID)); var routingMessage = GetRoutingMessage(graph, message); if (routingMessage != null) { RemoveAddress(recipients, routingMessage.MailFrom); RemoveAddress(recipients, routingMessage.MailTo); RemoveAddress(recipients, routingMessage.MailCc); RemoveAddress(recipients, routingMessage.MailBcc); } return(recipients); }
private IEnumerable <Mailbox> GetInternalRecipient(PXGraph graph, CRSMEmail message) { var previousMessage = GetPreviousInternalMessage(graph, message); if (previousMessage != null) { return(GetInternalMailOutside(previousMessage)); } var result = new List <Mailbox>(); var initialMessage = GetParentMessage(graph, message); if (message.OwnerID != null) { var ownerAddress = GetOwnerAddress(graph, message.OwnerID); if (ownerAddress != null) { result.Add(ownerAddress); } } if (initialMessage != null && initialMessage.OwnerID != message.OwnerID) { var ownerAddress = GetOwnerAddress(graph, initialMessage.OwnerID); if (ownerAddress != null) { result.Add(ownerAddress); } } if (result.Count == 0) { var ownerAddress = GetOwnerAddressByNote(graph, message.RefNoteID); if (ownerAddress != null) { result.Add(ownerAddress); } var parentOwnerAddress = GetOwnerAddress(graph, message.BAccountID); if (parentOwnerAddress != null) { result.Add(parentOwnerAddress); } } return(result); }
public EmailProcessEventArgs(PXGraph graph, EMailAccount account, CRSMEmail message) { if (graph == null) { throw new ArgumentNullException("graph"); } if (account == null) { throw new ArgumentNullException("account"); } if (message == null) { throw new ArgumentNullException("message"); } _graph = graph; _account = account; _message = message; }
private List <MailAddress> GetExternalRecipient(PXGraph graph, CRSMEmail message) { var previousMessage = GetPreviousExternalMessage(graph, message); var result = new List <MailAddress>(); if (previousMessage != null) { result = GetExternalMailOutside(previousMessage); if (previousMessage.OwnerID != null) { result.Add(GetOwnerAddress(graph, previousMessage.OwnerID)); } } return(result); //TODO: need implementation //var source = FindSource(graph, (long)message.RefNoteID); }
private Package(PXGraph graph, EMailAccount account, CRSMEmail message) { if (graph == null) { throw new ArgumentNullException("graph"); } if (account == null) { throw new ArgumentNullException("account"); } if (message == null) { throw new ArgumentNullException("message"); } _graph = graph; _account = account; _message = message; }
private void PersistException(Exception ex) { this._graph.Clear(); if (_activityMessage == null || _graph.Caches[_activityMessage.GetType()].GetStatus(_activityMessage) == PXEntryStatus.Inserted) { return; } _activityMessage = PXSelect <CRSMEmail, Where <CRSMEmail.noteID, Equal <Required <CRSMEmail.noteID> > > > .SelectWindowed(_graph, 0, 1, _activityMessage.NoteID); if (_activityMessage != null) { _activityMessage = (CRSMEmail)_graph.Caches[_activityMessage.GetType()].CreateCopy(_activityMessage); _activityMessage.Exception = ex.Message; _activityMessage.MPStatus = MailStatusListAttribute.Failed; UpdateAM(); PersistAM(); } }
public static void SendMessage(CRSMEmail message) { if (message == null || message.MailAccountID == null) { throw new PXException(ErrorMessages.EmailNotConfigured); } Tuple <EMailSyncServer, EMailSyncPolicy, PXSyncMailbox> tuple = GetConfig(message.MailAccountID.Value); IEmailSyncProvider prov = GetExchanger(tuple.Item1, tuple.Item2); try { prov.SendMessage(tuple.Item3, new[] { message }); message.Exception = null; } catch (Exception ex) { message.Exception = ex.Message; } }
private IEnumerable <Mailbox> GetExternalRecipient(PXGraph graph, CRSMEmail message) { var previousMessage = GetPreviousExternalMessage(graph, message); if (previousMessage != null) { foreach (Mailbox box in GetExternalMailOutside(previousMessage)) { yield return(box); } if (previousMessage.OwnerID != null) { yield return(GetOwnerAddress(graph, previousMessage.OwnerID)); } } //TODO: need implementation //var source = FindSource(graph, (long)message.RefNoteID); }
protected static string MergeAddressList(CRSMEmail email, string addressList, string sourceList) { if (string.IsNullOrEmpty(addressList)) { return(sourceList); } AddressList result = new AddressList(); var index = new HashSet <string>(); foreach (Mailbox box in AddressList.Parse(addressList)) { if (index.Contains(box.Address)) { continue; } if (email.MailTo != null && email.MailTo.Contains(box.Address)) { continue; } if (email.MailCc != null && email.MailCc.Contains(box.Address)) { continue; } if (email.MailBcc != null && email.MailBcc.Contains(box.Address)) { continue; } index.Add(box.Address); result.Add(box); } return(result.Count == 0 ? sourceList : (string.IsNullOrEmpty(sourceList) ? result.ToString() : sourceList + "; " + result)); }
protected override bool Process(Package package) { PXGraph graph = package.Graph; CRSMEmail message = package.Message; if (message.IsIncome != true) { return(false); } var isFromInternalUser = message.ClassID == CRActivityClass.EmailRouting; var recipients = new MailAddressList(); if (isFromInternalUser) { recipients.AddRange(GetFromInternal(graph, message)); } else { recipients.AddRange(GetFromExternal(graph, message)); } RemoveAddress(recipients, message.MailFrom); RemoveAddress(recipients, message.MailTo); RemoveAddress(recipients, message.MailCc); RemoveAddress(recipients, message.MailBcc); if (recipients.Count == 0) { return(false); } SendCopyMessageToInside(package.Graph, package.Account, message, recipients); graph.EnsureCachePersistence(message.GetType()); return(true); }
protected static string MergeAddressList(CRSMEmail email, string addressList, string sourceList) { if (string.IsNullOrEmpty(addressList)) { return(sourceList); } List <MailAddress> result = new List <MailAddress>(); var index = new HashSet <string>(); foreach (MailAddress address in EmailParser.ParseAddresses(addressList)) { if (index.Contains(address.Address)) { continue; } if (email.MailTo != null && email.MailTo.Contains(address.Address, StringComparison.InvariantCultureIgnoreCase)) { continue; } if (email.MailCc != null && email.MailCc.Contains(address.Address, StringComparison.InvariantCultureIgnoreCase)) { continue; } if (email.MailBcc != null && email.MailBcc.Contains(address.Address, StringComparison.InvariantCultureIgnoreCase)) { continue; } index.Add(address.Address); result.Add(address); } return(result.Count == 0 ? sourceList : string.IsNullOrEmpty(sourceList) ? PXDBEmailAttribute.ToString(result) : PXDBEmailAttribute.AppendAddresses(sourceList, PXDBEmailAttribute.ToString(result))); }
private Guid?GetKnownSender(PXGraph graph, CRSMEmail message) { var @from = Mailbox.Parse(message.MailFrom).With(_ => _.Address).With(_ => _.Trim()); PXSelectJoin <EPEmployee, InnerJoin <Contact, On <Contact.contactID, Equal <EPEmployee.defContactID> >, InnerJoin <Users, On <Users.pKID, Equal <EPEmployee.userID> > > >, Where <Contact.eMail, Equal <Required <Contact.eMail> > > > . Clear(graph); var employeeEmail = (EPEmployee)PXSelectJoin <EPEmployee, InnerJoin <Contact, On <Contact.contactID, Equal <EPEmployee.defContactID> >, InnerJoin <Users, On <Users.pKID, Equal <EPEmployee.userID> > > >, Where <Contact.eMail, Equal <Required <Contact.eMail> > > > . Select(graph, @from); if (employeeEmail != null) { return(employeeEmail.UserID); } return(null); }
private bool CreateMessage() { if (_message != null) { _activityMessage = PXSelect <CRSMEmail, Where <CRSMEmail.noteID, Equal <Required <SMEmail.refNoteID> > > > .Select(_graph, _message.RefNoteID); return(true); } try { if (_email.Message.From == null || _email.Message.From.Count() == 0) { return(false); } CreateActivity(); CreateEmail(); if (_message == null) { return(false); } _activityMessage = PXSelect <CRSMEmail, Where <CRSMEmail.noteID, Equal <Required <SMEmail.refNoteID> > > > .Select(_graph, _message.RefNoteID); AppendAttachments(); PersistAM(); return(true); } catch (Exception ex) { PersistException(ex); return(false); } }
protected override bool Process(Package package) { CRSMEmail activity = package.Message; EMailAccount account = package.Account; PXGraph graph = package.Graph; if (activity.Ticket != null || activity.ParentNoteID != null || account.EmailAccountType != EmailAccountTypesAttribute.Exchange || !(account.IncomingProcessing ?? false)) { return(false); } if (String.IsNullOrEmpty(activity.MessageId) || String.IsNullOrEmpty(activity.MessageReference)) { return(false); } foreach (String id in activity.MessageReference.Split(' ')) { Boolean found = false; foreach (CRSMEmail parent in PXSelect <CRSMEmail, Where <CRSMEmail.messageId, Like <Required <CRSMEmail.messageId> > > > .SelectSingleBound(graph, null, id)) { activity.Ticket = parent.ID; found = true; break; } if (found) { return(true); } } return(false); }
private void ProcessEvent(EmailEventProcess graph, SendGridEvent e) { if (!String.IsNullOrEmpty(e.MessageID) && !String.IsNullOrEmpty(e.SendGridMessageID)) { //Create link between internal Message ID and SendGrid MessageID for future events that will not include our own Message ID. VXEmailID association = graph.RemoteMessageIds.Select(e.SendGridMessageID); if (association == null) { association = new VXEmailID(); association.RemoteMessageID = e.SendGridMessageID; association.InternalMessageID = e.MessageID; graph.RemoteMessageIds.Insert(association); graph.Actions.PressSave(); } } //Locate Acumatica e-mail CRSMEmail email = (CRSMEmail)graph.EmailByRemoteId.Select(e.SendGridMessageID); if (email == null) { PXTrace.WriteError("VX.MailTrack No e-mail message found in Acumatica for SendGrid MessageID " + e.SendGridMessageID); return; } //Insert event; duplicates are possible as per the SendGrid documentation, but since EventID is a key we will simply discard it when inserting var emailEvent = new VXEMailEvent(); emailEvent.EventID = e.EventID; emailEvent.EventDate = UnixTimeStampToDateTime(e.Timestamp); emailEvent.NoteID = email.NoteID; emailEvent.EMail = e.Email; var pushMessage = new PushHelper.PushMessage(); pushMessage.NoteID = email.NoteID; pushMessage.RefNoteID = email.RefNoteID; pushMessage.Body = email.Subject; switch (e.EventType.ToLower()) { case "dropped": pushMessage.Title = $"Message Dropped {e.Email}"; emailEvent.EventType = MailEventType.Dropped; emailEvent.Description = e.Reason; break; case "delivered": pushMessage.Title = $"Message Delivered to {e.Email}"; emailEvent.EventType = MailEventType.Delivered; break; case "bounce": pushMessage.Title = $"Message Bounced {e.Email}"; emailEvent.EventType = MailEventType.Bounce; emailEvent.Description = e.Reason; break; case "open": pushMessage.Title = $"Message Opened by {e.Email}"; emailEvent.EventType = MailEventType.Open; emailEvent.Description = e.UserAgent; break; case "click": pushMessage.Title = $"Link Clicked by {e.Email}"; pushMessage.Body += $" ({ e.Url})"; emailEvent.EventType = MailEventType.Click; emailEvent.Description = e.Url; break; default: emailEvent.EventType = MailEventType.Unknown; emailEvent.Description = "Unhandled event type: " + e.EventType; break; } graph.Events.Insert(emailEvent); graph.Actions.PressSave(); //Notifications are sent to the user who created e-mail message or who is the current owner (OwnerID will be setup for e-mails that are generated by e-mail processing) foreach (VXUserPushNotification pushNotification in graph.PushNotifications.Select(email.CreatedByID, email.OwnerID)) { //Just fire and forget var task = PushHelper.SendPushNotificationAsync(pushNotification, pushMessage); } }
private static void FillMailAccount(CRSMEmail message, int MailAccountID) { message.MailAccountID = MailAccountID; }