public void SendMessage(object message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
if (!(message is SMEmail))
{
var error = string.Format("Can't process message '{0}'. Expected type is '{1}'",
message.GetType().Name, typeof(SMEmail).Name);
throw new ArgumentException(error, "message");
}
SMEmail email = message as SMEmail;
if (email.MailAccountID != null && PX.Objects.CS.Email.PXEmailSyncHelper.IsExchange(email.MailAccountID.Value))
{
CRSMEmail emailProjection =
PXSelect <CRSMEmail, Where <CRSMEmail.noteID, Equal <Required <SMEmail.refNoteID> > > > .Select(new PXGraph(), email.RefNoteID);
CS.Email.PXEmailSyncHelper.SendMessage(emailProjection);
}
else
{
new MessageProcessor(email.MailAccountID).Process(email);
}
}
public void SendMessage(object message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message), PXMessages.LocalizeNoPrefix(Messages.Message));
}
if (!(message is SMEmail))
{
string errorText = PXMessages.LocalizeFormatNoPrefixNLA(Messages.CanNotProcessMessage, message.GetType().Name,
typeof(SMEmail).Name);
throw new ArgumentException(errorText, PXMessages.LocalizeNoPrefix(Messages.Message));
}
SMEmail email = message as SMEmail;
if (email.MailAccountID != null && PX.Objects.CS.Email.PXEmailSyncHelper.IsExchange(email.MailAccountID.Value))
{
CRSMEmail emailProjection =
PXSelect <CRSMEmail, Where <CRSMEmail.noteID, Equal <Required <SMEmail.refNoteID> > > > .Select(new PXGraph(), email.RefNoteID);
CS.Email.PXEmailSyncHelper.SendMessage(emailProjection);
}
else
{
using (var processor = new MessageProcessor(email.MailAccountID))
{
processor.Process(email);
}
}
}
private string GenerateSubject(SMEmail message)
{
var subject = message.Subject;
if (message.Ticket == null)
{
message.Ticket = message.ID;
}
if (message.Ticket != null)
{
EMailAccount account =
PXSelect <EMailAccount, Where <EMailAccount.emailAccountID, Equal <Required <EMailAccount.emailAccountID> > > > .Select(_graph,
message.MailAccountID);
if (account != null && account.IncomingProcessing == true)
{
var ticket = EncodeTicket(message.ID.GetValueOrDefault());
subject = message.Subject.StartsWith("FW: ") || message.Subject.StartsWith("RE: ")
? message.Subject.Substring(0, 4) + message.Subject.Substring(4)
: message.Subject;
subject += " " + ticket;
}
}
return(subject);
}
private void Proccess()
{
using (new PXScreenIDScope("CR306015"))
{
try
{
if (CreateMessage())
{
ProcessMessage();
}
}
finally
{
_graph.Clear();
_activity = null;
if (_activityMessage != null)
{
_message.Exception = _activityMessage.Exception;
_message.MPStatus = _activityMessage.MPStatus;
}
_message = null;
_activityMessage = null;
}
}
}
private MailProcessor(PXGraph graph, EMailAccount account, SMEmail message)
: this(graph, account)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
_message = message;
}
private string ReadTemplateAttachments(SMEmail message)
{
if (message.Body != null && message.Body.IndexOf("embedded=\"true\"") > -1)
{
Regex _tempimagesRegex = new Regex("(<(img data-convert=\"view\")[^<>]*(src=\"([^\"]*)\" ([^<>]*)>))");
Regex _tempimagesRegex2 = new Regex("(<img[^<>]*src=(\"[^<>]*GetFile.*;file=([^\"]*)\") ([^<>]*)>)");
List <string> changeimage = new List <string>();
List <int> start = new List <int>();
List <int> length = new List <int>();
foreach (Match match in _tempimagesRegex.Matches(message.Body))
{
if (match.Groups[4].Value != null && match.Groups[1].Value.IndexOf("embedded=\"true\"") > -1)
{
foreach (var result in
PXSelectJoin <UploadFile,
InnerJoin <UploadFileRevision,
On <UploadFile.fileID, Equal <UploadFileRevision.fileID>,
And <UploadFile.lastRevisionID, Equal <UploadFileRevision.fileRevisionID> > > >,
Where <UploadFile.name, Equal <Required <UploadFile.name> > > > .
SelectWindowed(new PXGraph(), 0, 1, HttpUtility.UrlDecode(match.Groups[4].Value)))
{
UploadFileRevision filedata = result[typeof(UploadFileRevision)] as UploadFileRevision;
if (filedata != null)
{
string tempchangeimage = "<img title=\"\" src=\"data:image/jpeg;base64," + Convert.ToBase64String(filedata.Data) + "\">";
message.Body = message.Body.Replace(match.Groups[1].Value, tempchangeimage);
}
}
}
}
foreach (Match match in _tempimagesRegex2.Matches(message.Body))
{
if (match.Groups[3].Value != null && match.Groups[1].Value.IndexOf("embedded=\"true\"") > -1)
{
foreach (var result in
PXSelectJoin <UploadFile,
InnerJoin <UploadFileRevision,
On <UploadFile.fileID, Equal <UploadFileRevision.fileID>,
And <UploadFile.lastRevisionID, Equal <UploadFileRevision.fileRevisionID> > > >,
Where <UploadFile.name, Equal <Required <UploadFile.name> > > > .
SelectWindowed(new PXGraph(), 0, 1, HttpUtility.UrlDecode(match.Groups[3].Value)))
{
UploadFileRevision filedata = result[typeof(UploadFileRevision)] as UploadFileRevision;
if (filedata != null)
{
string tempchangeimage = "<img title=\"\" src=\"data:image/jpeg;base64," + Convert.ToBase64String(filedata.Data) + "\">";
message.Body = message.Body.Replace(match.Groups[1].Value, tempchangeimage);
}
}
}
}
}
return(null);
}
private void UpdateMessage(SMEmail message)
{
var emailType = message.GetType();
var cache = _graph.Caches[emailType];
message = (SMEmail)cache.Update(message);
_graph.EnsureCachePersistence(emailType);
var cached = _graph.Caches[message.GetType()].Locate(message);
_graph.Persist();
_graph.SelectTimeStamp();
message = (SMEmail)cache.CreateCopy(cached);
}
private void ProcessMessage(SMEmail message)
{
try
{
SendMail(CreateMail(message));
message.Exception = null;
}
catch (OutOfMemoryException) { throw; }
catch (StackOverflowException) { throw; }
catch (Exception e)
{
message.Exception = e.Message;
}
}
private void PreProcessMessage(SMEmail message)
{
var messageCopy = (SMEmail)_graph.Caches[message.GetType()].CreateCopy(message);
messageCopy.MPStatus = MailStatusListAttribute.InProcess;
messageCopy.Exception = null;
if (messageCopy.MessageId == null)
{
messageCopy.MessageId = "<" + Guid.NewGuid() + "_acumatica@" + _account.OutcomingHostName + ">";
}
UpdateMessage(messageCopy);
_graph.Caches[message.GetType()].RestoreCopy(message, messageCopy);
}
private AttachmentCollection ReadAttachments(SMEmail message)
{
var fs = new AttachmentCollection(_graph);
foreach (NoteDoc notes in
PXSelect <NoteDoc,
Where <NoteDoc.fileID, IsNotNull,
And <NoteDoc.noteID, Equal <Required <NoteDoc.noteID> > > > > .
Select(_graph, message.RefNoteID))
{
fs.Add((Guid)notes.FileID);
}
return(fs);
}
private string ExtractInlineImages(SMEmail message, AttachmentCollection fs)
{
string res;
ICollection <PX.Data.ImageExtractor.ImageInfo> files;
if (message.Body != null && new ImageExtractor().Extract(message.Body, out res, out files))
{
foreach (PX.Data.ImageExtractor.ImageInfo imageInfo in files)
{
fs.Add(imageInfo.ID, imageInfo.ID.ToString(), imageInfo.Bytes);
}
return(res);
}
return(message.Body);
}
private void PostProcessMessage(SMEmail message)
{
PXDatabase.Update <CRActivity>(
new PXDataFieldAssign <CRActivity.startDate>(PXTimeZoneInfo.UtcNow),
new PXDataFieldAssign <CRActivity.uistatus>(message.Exception == null
? ActivityStatusAttribute.Completed
: ActivityStatusAttribute.Open),
new PXDataFieldRestrict <CRActivity.noteID>(PXDbType.UniqueIdentifier, 16, message.RefNoteID, PXComp.EQ));
if (message.Exception == null)
{
PXUpdate <Set <PMTimeActivity.approvalStatus,
Switch <Case <Where <PMTimeActivity.approverID, IsNull>,
ActivityStatusAttribute.completed>,
ActivityStatusAttribute.pendingApproval> >,
PMTimeActivity,
Where <PMTimeActivity.refNoteID, Equal <Required <PMTimeActivity.refNoteID> >,
And <PMTimeActivity.isCorrected, Equal <Zero> > > >
.Update(_graph, message.RefNoteID);
}
if (message.Exception == null)
{
message.RetryCount = 0;
message.MPStatus = MailStatusListAttribute.Processed;
}
else
{
message.RetryCount += 1;
if (message.Exception.StartsWith("5") ||
message.RetryCount >= MailAccountManager.GetEmailPreferences().RepeatOnErrorSending)
{
message.RetryCount = 0;
message.MPStatus = MailStatusListAttribute.Failed;
}
else
{
message.MPStatus = MailStatusListAttribute.PreProcess;
}
}
UpdateMessage(message);
}
public void Process(SMEmail message)
{
using (PXTransactionScope sc = new PXTransactionScope())
{
try
{
PreProcessMessage(message);
}
catch (Exception)
{
//Unable to change status - leave message alone.
return;
}
try
{
ProcessMessage(message);
PostProcessMessage(message);
}
catch (Exception ex)
{
this._graph.Clear();
if (message == null || _graph.Caches[message.GetType()].GetStatus(message) == PXEntryStatus.Inserted)
{
return;
}
message = PXSelect <SMEmail, Where <SMEmail.noteID, Equal <Required <SMEmail.noteID> > > > .SelectWindowed(_graph, 0, 1, message.NoteID);
if (message != null)
{
var messageCopy = (SMEmail)_graph.Caches[message.GetType()].CreateCopy(message);
messageCopy.Exception = ex.Message;
messageCopy.MPStatus = MailStatusListAttribute.Failed;
UpdateMessage(messageCopy);
_graph.Caches[message.GetType()].RestoreCopy(message, messageCopy);
}
}
sc.Complete();
}
}
protected IEnumerable viewDetails(PXAdapter adapter)
{
SMEmail item = FilteredItems.Current;
if (item != null)
{
if (item.RefNoteID != null)
{
CREmailActivityMaint graph = CreateInstance <CREmailActivityMaint>();
graph.Message.Current = graph.Message.Search <CRSMEmail.noteID>(item.RefNoteID);
PXRedirectHelper.TryRedirect(graph, PXRedirectHelper.WindowMode.NewWindow);
}
else
{
CRSMEmailMaint graph = CreateInstance <CRSMEmailMaint>();
graph.Email.Current = graph.Email.Search <SMEmail.noteID>(item.NoteID);
PXRedirectHelper.TryRedirect(graph, PXRedirectHelper.WindowMode.NewWindow);
}
}
return(adapter.Get());
}
private Message CreateMail(SMEmail message)
{
var subject = GenerateSubject(message);
var fs = ReadAttachments(message);
ReadTemplateAttachments(message);
var content = ExtractInlineImages(message, fs);
Message mail = new Message(message.MailFrom, message.MailTo, subject)
{
Reply = message.MailReply,
Cc = message.MailCc,
Bcc = message.MailBcc,
Body = GenerateBody(content, fs),
Html = message.Format == null || message.Format == EmailFormatListAttribute.Html,
UID = message.MessageId,
Files = fs
};
return(mail);
}
public virtual void editRecord()
{
SMEmail item = Emails.Current;
if (item == null)
{
return;
}
if (item.RefNoteID != item.NoteID)
{
CREmailActivityMaint graph = CreateInstance <CREmailActivityMaint>();
graph.Message.Current = graph.Message.Search <CRSMEmail.noteID>(item.RefNoteID);
PXRedirectHelper.TryRedirect(graph, PXRedirectHelper.WindowMode.InlineWindow);
}
else
{
CRSMEmailMaint graph = CreateInstance <CRSMEmailMaint>();
graph.Email.Current = graph.Email.Search <SMEmail.noteID>(item.NoteID);
PXRedirectHelper.TryRedirect(graph, PXRedirectHelper.WindowMode.InlineWindow);
}
}
private AttachmentCollection ReadAttachments(SMEmail message)
{
var fs = new AttachmentCollection(_graph);
foreach (NoteDoc notes in
PXSelect <NoteDoc,
Where <NoteDoc.fileID, IsNotNull,
And <NoteDoc.noteID, Equal <Required <NoteDoc.noteID> > > > > .
Select(_graph, message.RefNoteID))
{
fs.Add((Guid)notes.FileID);
}
var addFiles = PXSelect <DynamicAttachment,
Where <DynamicAttachment.refNoteID, Equal <Required <DynamicAttachment.refNoteID> > > > .
Select(_graph, message.RefNoteID);
foreach (Guid fileId in DynamicAttachmentManager.Process(_graph, addFiles.Extract()))
{
fs.Add(fileId);
}
return(fs);
}
public static void Proccess(PXGraph graph, EMailAccount account, SMEmail email)
{
var obj = new MailProcessor(graph, account, email);
obj.Proccess();
}
private void CreateEmail()
{
PXCache cache = _graph.Caches[typeof(SMEmail)];
_message = (SMEmail)cache.CreateCopy(cache.Insert());
_message.RefNoteID = _activity.NoteID;
_message.MailAccountID = _account.EmailAccountID;
var mimeMessage = _email.Message;
_message.MailFrom = mimeMessage.From.With(_ => _.ToString()) ?? string.Empty;
_message.MailReply = mimeMessage.ReplyTo.With(_ => _.ToString()) ?? string.Empty;
_message.MailTo = mimeMessage.To.With(_ => _.ToString()) ?? string.Empty;
_message.MailCc = mimeMessage.Cc.With(_ => _.ToString()) ?? string.Empty;
_message.MailBcc = mimeMessage.Bcc.With(_ => _.ToString()) ?? string.Empty;
_message.Subject = mimeMessage.Subject.With(_ => _.ToString()) ?? " ";
if (!string.IsNullOrEmpty(_email.UID))
{
if (_account.IncomingHostProtocol == IncomingMailProtocolsAttribute._IMAP)
{
_message.ImapUID = int.Parse(_email.UID);
}
else
{
_message.Pop3UID = _email.UID;
}
}
_message.IsIncome = true;
_message.MessageId = mimeMessage.MessageID;
_message.MPStatus = MailStatusListAttribute.PreProcess; //TODO: need move into Automation steps
var body = mimeMessage.BodyHtmlText;
if (body == null)
{
if (mimeMessage.BodyText != null)
{
body = PX.Common.Tools.ConvertSimpleTextToHtml(mimeMessage.BodyText);
}
}
else
{
body = mimeMessage.BodyHtmlText.
Replace(Environment.NewLine, " ").
Replace("<spanstyle", "<span style"); //NOTE: ms outlook style conflicts with our system style
Regex baseTag = new Regex(@"<base(.|\n)*?>");
body = baseTag.Replace(body, String.Empty);
}
_message.Body = body ?? string.Empty;
string clearedSubject;
var ticket = DecodeTicket(_message.Subject, out clearedSubject);
if (ticket != null)
{
_message.Ticket = CorrectTicket(ticket);
}
_message.Subject = clearedSubject;
_message = (SMEmail)cache.CreateCopy(cache.Update(_message));
_graph.EnsureCachePersistence(_message.GetType());
var cached = _graph.Caches[_message.GetType()].Locate(_message);
_graph.Persist();
_graph.SelectTimeStamp();
_message = (SMEmail)cache.CreateCopy(cached);
}
