public async Task <(string, bool)> IsHealthy(HttpContext context, LivenessExecutionContext livenessContext, CancellationToken cancellationToken = default)
{
try
{
_imapConnection = new ImapConnection(_options);
if (await _imapConnection.ConnectAsync())
{
if (_options.AccountOptions.login)
{
return(await ExecuteAuthenticatedUserActions());
}
}
else
{
return($"Connection to server {_options.Host} has failed - SSL Enabled : {_options.ConnectionType}", false);
}
return(BeatPulseKeys.BEATPULSE_HEALTHCHECK_DEFAULT_OK_MESSAGE, true);
}
catch (Exception ex)
{
var message = !livenessContext.IsDevelopment ? string.Format(BeatPulseKeys.BEATPULSE_HEALTHCHECK_DEFAULT_ERROR_MESSAGE, livenessContext.Name)
: $"Exception {ex.GetType().Name} with message ('{ex.Message}')";
return(message, false);
}
finally
{
_imapConnection.Dispose();
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
_imapConnection = new ImapConnection(_options);
if (await _imapConnection.ConnectAsync())
{
if (_options.AccountOptions.Login)
{
return(await ExecuteAuthenticatedUserActions(context));
}
}
else
{
return(new HealthCheckResult(context.Registration.FailureStatus, description: $"Connection to server {_options.Host} has failed - SSL Enabled : {_options.ConnectionType}"));
}
return(HealthCheckResult.Healthy());
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
finally
{
_imapConnection.Dispose();
}
}
/// <summary>
/// Moves messages from the trash mailbox back to the inbox.
/// </summary>
/// <param name="messages">The messages to move.</param>
internal async Task RestoreMessagesAsync(MailMessageContext[] messages)
{
try {
if (messages.Length < 1)
{
return;
}
var inbox = messages.First().Mailbox.Account.GetInbox();
using (var connection = new ImapConnection {
Security = _account.ImapSecurity
}) {
using (var auth = await connection.ConnectAsync(_account.ImapHost, _account.ImapPort)) {
using (var session = await auth.LoginAsync(_account.ImapUsername, _account.ImapPassword)) {
var mailbox = await session.SelectAsync(Name);
if (IsTrash)
{
await mailbox.MoveMailsAsync(messages.Select(x => x.Uid).ToArray(), inbox.Name);
}
}
}
}
await DeleteMessagesAsync(messages, _account.GetTrashMailbox().Name);
App.Context.NotifyMessagesRemoved(messages);
} catch (Exception ex) {
Logger.Error(ex);
}
}
internal async Task MarkAsSeenAsync(MailMessageContext[] messages)
{
Application.Current.AssertBackgroundThread();
try {
messages.ForEach(x => x.IsSeen = true);
var uids = messages.Select(x => x.Uid).ToArray();
using (var connection = new ImapConnection {
Security = _account.ImapSecurity
}) {
connection.RemoteCertificateValidationFailed += (sender, e) => e.IsCanceled = false;
using (var auth = await connection.ConnectAsync(_account.ImapHost, _account.ImapPort)) {
using (var session = await auth.LoginAsync(_account.ImapUsername, _account.ImapPassword)) {
var folder = await session.SelectAsync(Name);
await folder.MarkAsSeenAsync(uids);
}
}
}
await CountNotSeenAsync();
} catch (Exception ex) {
messages.ForEach(x => x.IsSeen = false);
Logger.Error(ex);
}
}
internal async Task IdleAsync()
{
try {
using (var connection = new ImapConnection {
Security = _account.ImapSecurity
}) {
connection.RemoteCertificateValidationFailed += (sender, e) => e.IsCanceled = false;
using (var auth = await connection.ConnectAsync(_account.ImapHost, _account.ImapPort)) {
using (var session = await auth.LoginAsync(_account.ImapUsername, _account.ImapPassword)) {
if (!connection.CanIdle)
{
return;
}
var mailbox = await session.SelectAsync(Name);
try {
IsIdling = true;
mailbox.ChangeNotificationReceived += OnChangeNotificationReceived;
await mailbox.IdleAsync();
} finally {
mailbox.ChangeNotificationReceived -= OnChangeNotificationReceived;
IsIdling = false;
}
}
}
}
} catch (Exception ex) {
Logger.Error(ex);
}
}
internal async Task DeleteMessagesAsync(MailMessageContext[] messages, string trashFolder)
{
var uids = messages.Select(x => x.Uid).ToArray();
using (var connection = new ImapConnection {
Security = _account.ImapSecurity
}) {
using (var auth = await connection.ConnectAsync(_account.ImapHost, _account.ImapPort)) {
using (var session = await auth.LoginAsync(_account.ImapUsername, _account.ImapPassword)) {
var mailbox = await session.SelectAsync(Name);
if (IsTrash)
{
await mailbox.DeleteMailsAsync(uids);
}
else
{
await mailbox.MoveMailsAsync(uids, trashFolder);
}
}
}
}
using (var context = new DatabaseContext()) {
await context.Database.Connection.OpenAsync();
foreach (var message in messages)
{
var id = message.Id;
using (var transaction = context.Database.BeginTransaction()) {
try {
var mime = await context.MimeMessages
.FirstOrDefaultAsync(x => x.MessageId == id);
context.MimeMessages.Remove(mime);
await context.SaveChangesAsync();
var model = new MailMessageModel {
Id = message.Id,
MailboxId = Id
};
context.MailMessages.Attach(model);
context.MailMessages.Remove(model);
await context.SaveChangesAsync();
transaction.Commit();
App.Context.NotifyMessageRemoved(message);
} catch (Exception) {
transaction.Rollback();
}
}
}
}
}
internal async Task <List <ImapMailboxInfo> > ListSubscribedMailboxesAsync(string pattern = "")
{
using (var connection = new ImapConnection {
Security = ImapSecurity
}) {
connection.RemoteCertificateValidationFailed += (sender, e) => e.IsCanceled = false;
using (var auth = await connection.ConnectAsync(ImapHost, ImapPort)) {
using (var session = await auth.LoginAsync(ImapUsername, ImapPassword)) {
var wildcard = string.IsNullOrEmpty(pattern) ? "%" : pattern;
return(await session.LSubAsync("", ImapMailbox.EncodeName(wildcard)));
}
}
}
}
private async Task DeleteAsync()
{
using (var connection = new ImapConnection {
Security = _account.ImapSecurity
}) {
using (var auth = await connection.ConnectAsync(_account.ImapHost, _account.ImapPort)) {
using (var session = await auth.LoginAsync(_account.ImapUsername, _account.ImapPassword)) {
await session.DeleteMailboxAsync(Name);
}
}
}
await DeleteLocalAsync();
_account.NotifyMailboxRemoved(this);
}
private async Task UnsubscribeAsync()
{
using (var connection = new ImapConnection {
Security = _account.ImapSecurity
}) {
using (var auth = await connection.ConnectAsync(_account.ImapHost, _account.ImapPort)) {
using (var session = await auth.LoginAsync(_account.ImapUsername, _account.ImapPassword)) {
await session.UnsubscribeAsync(Name);
}
}
}
using (var database = new DatabaseContext()) {
var mailbox = await database.Mailboxes.FindAsync(_mailbox.Id);
mailbox.IsSubscribed = false;
await database.SaveChangesAsync();
}
}
public async Task CreateMailboxAsync(string mailbox)
{
using (var connection = new ImapConnection {
Security = _account.ImapSecurity
}) {
using (var auth = await connection.ConnectAsync(_account.ImapHost, _account.ImapPort)) {
using (var session = await auth.LoginAsync(_account.ImapUsername, _account.ImapPassword)) {
var name = string.Format("{0}{1}{2}", Name, Delimiter, mailbox);
await session.CreateMailboxAsync(name);
}
}
}
// Reset to allow new mailboxes to be discovered.
_isSyncedInitially = false;
await Task.Run(() => SyncMailboxesAsync());
IsExpanded = true;
}
internal async Task RestoreMessagesAsync(ICollection <MailMessageContext> messages)
{
try {
var inbox = GetInbox();
var trash = GetTrashMailbox();
using (var connection = new ImapConnection {
Security = _account.ImapSecurity
}) {
using (var auth = await connection.ConnectAsync(_account.ImapHost, _account.ImapPort)) {
using (var session = await auth.LoginAsync(_account.ImapUsername, _account.ImapPassword)) {
var mailbox = await session.SelectAsync(trash.Name);
await mailbox.MoveMailsAsync(messages.Select(x => x.Uid).ToArray(), inbox.Name);
}
}
}
using (var database = new DatabaseContext()) {
foreach (var message in messages)
{
try {
var model = new MailMessageModel {
Id = message.Id,
MailboxId = Id
};
database.MailMessages.Attach(model);
database.MailMessages.Remove(model);
} catch (Exception ex) {
Logger.Error(ex);
throw;
}
}
await database.SaveChangesAsync();
}
App.Context.NotifyMessagesRemoved(messages);
} catch (Exception ex) {
Logger.Error(ex);
}
}
private async Task TestImapSettingsAsync()
{
Testing = new TestingContext {
Message = Resources.TestingImapStatus
};
try {
using (var connection = new ImapConnection {
Security = ImapSecurity
}) {
using (var auth = await connection.ConnectAsync(ImapHost, ImapPort)) {
await auth.LoginAsync(ImapUsername, ImapPassword);
}
}
} catch (Exception ex) {
Testing = new TestingContext {
IsFaulted = true,
Message = ex.Message
};
Logger.Error(ex);
}
}
public async Task <LivenessResult> IsHealthy(LivenessExecutionContext context, CancellationToken cancellationToken = default)
{
try
{
_logger?.LogInformation($"{nameof(ImapLiveness)} is checking IMAP entries.");
_imapConnection = new ImapConnection(_options);
if (await _imapConnection.ConnectAsync())
{
if (_options.AccountOptions.Login)
{
return(await ExecuteAuthenticatedUserActions());
}
}
else
{
_logger?.LogWarning($"{nameof(ImapLiveness)} fail connect to server {_options.Host}- SSL Enabled : {_options.ConnectionType}.");
return(LivenessResult.UnHealthy($"Connection to server {_options.Host} has failed - SSL Enabled : {_options.ConnectionType}"));
}
_logger?.LogInformation($"The {nameof(ImapLiveness)} check success.");
return(LivenessResult.Healthy());
}
catch (Exception ex)
{
_logger?.LogWarning($"The {nameof(ImapLiveness)} check fail with the exception {ex.ToString()}.");
return(LivenessResult.UnHealthy(ex));
}
finally
{
_imapConnection.Dispose();
}
}
private async Task <byte[]> FetchMimeAsync()
{
var mailbox = await GetMailboxAsync();
var account = await GetAccountAsync(mailbox);
using (var connection = new ImapConnection {
Security = account.ImapSecurity
}) {
connection.RemoteCertificateValidationFailed += (sender, e) => e.IsCanceled = false;
using (var auth = await connection.ConnectAsync(account.ImapHost, account.ImapPort)) {
using (var session = await auth.LoginAsync(account.ImapUsername, account.ImapPassword)) {
var folder = await session.SelectAsync(mailbox.Name);
folder.ByteCountChanged += OnByteCountChanged;
var mime = await folder.FetchMessageBodyAsync(Uid);
folder.ByteCountChanged -= OnByteCountChanged;
return(mime);
}
}
}
}
internal async Task <ICollection <MailMessageContext> > SyncMessagesAsync()
{
ICollection <MailMessageContext> contexts;
lock (_syncMessagesMutex) {
if (IsSyncingMessages)
{
return(new MailMessageContext[0]);
}
IsSyncingMessages = true;
}
try {
var name = _mailbox.Name;
var maxUid = await GetMaxUidAsync();
var account = await GetAccountAsync();
var messages = new List <MailMessageModel>();
using (var connection = new ImapConnection {
Security = account.ImapSecurity
}) {
using (var auth = await connection.ConnectAsync(account.ImapHost, account.ImapPort)) {
using (var session = await auth.LoginAsync(account.ImapUsername, account.ImapPassword)) {
var mailbox = await session.SelectAsync(name);
messages.AddRange(await SyncChallengesAsync(mailbox, maxUid));
messages.AddRange(await SyncNonChallengesAsync(mailbox, maxUid));
}
}
}
if (messages.Count == 0)
{
FetchedEnvelopeCount = 0;
lock (_syncMessagesMutex) {
IsSyncingMessages = false;
}
return(new MailMessageContext[0]);
}
await SaveContactsAsync(messages);
await SaveMessagesAsync(messages);
contexts = messages.Where(x => x.Type == MailType.Message)
.Select(x => new MailMessageContext(this, x)).ToArray();
FetchedEnvelopeCount = 0;
await Application.Current.Dispatcher
.InvokeAsync(() => App.Context.NotifyMessagesAdded(contexts));
await CountNotSeenAsync();
} finally {
lock (_syncMessagesMutex) {
IsSyncingMessages = false;
}
}
return(contexts);
}