public async Task GetMessage_ValidMime()
{
DateTime startDate = DateTime.Now;
DbModel.Message testMessage1 = await GetTestMessage1();
TestMessagesRepository messagesRepository = new TestMessagesRepository(testMessage1);
MessagesController messagesController = new MessagesController(messagesRepository);
ApiModel.Message result = messagesController.GetMessage(testMessage1.Id);
Assert.Null(result.MimeParseError);
Assert.Equal(testMessage1.Id, result.Id);
Assert.InRange(result.ReceivedDate, startDate, DateTime.Now);
Assert.Equal("*****@*****.**", result.From);
Assert.Equal("*****@*****.**", result.To);
Assert.Equal("*****@*****.**", result.Bcc);
Assert.Equal("*****@*****.**", result.Cc);
Assert.Equal("subject", result.Subject);
var allParts = result.Parts.Flatten(p => p.ChildParts).ToList();
Assert.Equal(6, allParts.Count);
Assert.All(allParts, p => {
Assert.Equal(testMessage1.Id, p.MessageId);
Assert.NotNull(p.Id);
Assert.NotEqual("", p.Id);
});
//All parts have a unique Id
Assert.Equal(allParts.Count, allParts.Select(p => p.Id).Distinct().Count());
}
public RelayResult TryRelayMessage(Message message, MailboxAddress[] overrideRecipients)
{
var result = new RelayResult(message);
if (!relayOptions.CurrentValue.IsEnabled)
{
return(result);
}
MailboxAddress[] recipients;
if (overrideRecipients == null)
{
recipients = message.To
.Split(",")
.Select(r => MailboxAddress.Parse(r))
.Where(r => relayOptions.CurrentValue.AutomaticEmails.Contains(r.Address, StringComparer.OrdinalIgnoreCase))
.ToArray();
}
else
{
recipients = overrideRecipients;
}
foreach (MailboxAddress recipient in recipients)
{
try
{
log.Information("Relaying message to {recipient}", recipient);
using SmtpClient relaySmtpClient = relaySmtpClientFactory(relayOptions.CurrentValue);
var apiMsg = new ApiModel.Message(message);
MimeMessage newEmail = apiMsg.MimeMessage;
MailboxAddress sender = MailboxAddress.Parse(
!string.IsNullOrEmpty(relayOptions.CurrentValue.SenderAddress)
? relayOptions.CurrentValue.SenderAddress
: apiMsg.From);
relaySmtpClient.Send(newEmail, sender, new[] { recipient });
result.RelayRecipients.Add(new RelayRecipientResult()
{
Email = recipient.Address, RelayDate = DateTime.UtcNow
});
}
catch (Exception e)
{
log.Error(e, "Can not relay message to {recipient}: {errorMessage}", recipient, e.ToString());
result.Exceptions[recipient] = e;
}
}
return(result);
}
public Dictionary <MailboxAddress, Exception> TryRelayMessage(Message message, MailboxAddress[] overrideRecipients)
{
Dictionary <MailboxAddress, Exception> result = new Dictionary <MailboxAddress, Exception>();
if (!relayOptions.CurrentValue.IsEnabled)
{
return(result);
}
MailboxAddress[] recipients;
if (overrideRecipients == null)
{
recipients = message.To
.Split(",")
.Select(r => MailboxAddress.Parse(r))
.Where(r => relayOptions.CurrentValue.AutomaticEmails.Contains(r.Address, StringComparer.OrdinalIgnoreCase))
.ToArray();
}
else
{
recipients = overrideRecipients;
}
foreach (MailboxAddress recipient in recipients)
{
try
{
Console.WriteLine($"Relaying message to {recipient}");
using (SmtpClient relaySmtpClient = relaySmtpClientFactory(relayOptions.CurrentValue))
{
var apiMsg = new ApiModel.Message(message);
MimeMessage newEmail = apiMsg.MimeMessage;
MailboxAddress sender = MailboxAddress.Parse(
!string.IsNullOrEmpty(relayOptions.CurrentValue.SenderAddress)
? relayOptions.CurrentValue.SenderAddress
: apiMsg.From);
relaySmtpClient.Send(newEmail, sender, new[] { recipient });
}
}
catch (Exception e)
{
Console.WriteLine($"Can not relay message to {recipient}: {e.ToString()}");
result[recipient] = e;
}
}
return(result);
}
private void Session_Fetch(object sender, IMAP_e_Fetch e)
{
foreach (var msgInfo in e.MessagesInfo)
{
var dbMessage = this.messagesRepository.GetMessages().FirstOrDefault(m => m.Id == new Guid(msgInfo.ID));
if (dbMessage != null)
{
ApiModel.Message apiMessage = new ApiModel.Message(dbMessage);
Mail_Message message = Mail_Message.ParseFromByte(apiMessage.Data);
e.AddData(msgInfo, message);
}
}
}
private void Session_Fetch(object sender, IMAP_e_Fetch e)
{
using (var scope = this.serviceScopeFactory.CreateScope())
{
var messagesRepository = scope.ServiceProvider.GetService <IMessagesRepository>();
foreach (var msgInfo in e.MessagesInfo)
{
var dbMessage = messagesRepository.GetMessages().SingleOrDefault(m => m.Id == new Guid(msgInfo.ID));
if (dbMessage != null)
{
ApiModel.Message apiMessage = new ApiModel.Message(dbMessage);
Mail_Message message = Mail_Message.ParseFromByte(apiMessage.Data);
e.AddData(msgInfo, message);
}
}
}
}
public async Task <DbModel.Message> ConvertAsync(Stream messageData, string envelopeFrom, string envelopeTo)
{
string subject = "";
string mimeParseError = null;
byte[] data = new byte[messageData.Length];
await messageData.ReadAsync(data, 0, data.Length);
bool foundHeaders = false;
bool foundSeparator = false;
using (StreamReader dataReader = new StreamReader(new MemoryStream(data)))
{
while (!dataReader.EndOfStream)
{
if (dataReader.ReadLine().Length != 0)
{
foundHeaders = true;
}
else
{
foundSeparator = true;
break;
}
}
}
if (!foundHeaders || !foundSeparator)
{
mimeParseError = "Malformed MIME message. No headers found";
}
else
{
messageData.Seek(0, SeekOrigin.Begin);
try
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(10));
MimeMessage mime = await MimeMessage.LoadAsync(messageData, true, cts.Token).ConfigureAwait(false);
subject = mime.Subject;
}
catch (OperationCanceledException e)
{
mimeParseError = e.Message;
}
catch (FormatException e)
{
mimeParseError = e.Message;
}
}
DbModel.Message message = new DbModel.Message()
{
Id = Guid.NewGuid(),
From = PunyCodeReplacer.DecodePunycode(envelopeFrom),
To = PunyCodeReplacer.DecodePunycode(envelopeTo),
ReceivedDate = DateTime.Now,
Subject = PunyCodeReplacer.DecodePunycode(subject),
Data = data,
MimeParseError = mimeParseError,
AttachmentCount = 0
};
var parts = new ApiModel.Message(message).Parts;
foreach (var part in parts)
{
message.AttachmentCount += CountAttachments(part);
}
return(message);
}
