/// <summary>
/// Сохранить сообщение
/// </summary>
/// <param name="mailBox"></param>
/// <param name="message"></param>
/// <returns></returns>
public async Task SaveMessageAsync(IMailBox mailBox, MimeMessage message)
{
var messageHash = message.MessageHash();
_logger.Info($"Сообщение от {message.Date} хэш {messageHash}");
var emailMessage = //await GetMessageByHashAsync(mailBox, messageHash) ??
await CreateMessageAsync(mailBox, message, messageHash);
}
public TcpWriter(ActorId id, ActorsSystem system, IMailBox mailBox) : base(id, system, mailBox)
{
var serverEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 3000);
_client = new TcpClient();
_client.Connect(serverEndPoint);
_clientStream = _client.GetStream();
}
public async Task <EmailLoadingStatus> LoadFromEmailAsync(IMailBox mailBox)
{
foreach (var emailLoader in _emailLoaders.Where(c => c.ConnectionType == mailBox.Server.ConnectionType))
{
return(await emailLoader.LoadFromEmailAsync(mailBox));
}
return(EmailLoadingStatus.Active);
}
/// <summary>
/// Initializes a new instance of the <see cref="Scheduler"/> class.
/// </summary>
/// <param name="mailBox">the mailbox.</param>
public Scheduler(IMailBox mailBox)
{
this.mailBox = mailBox;
this.cancellation = new CancellationTokenSource();
this.consumer = new Thread(this.Consume)
{
IsBackground = true
};
}
public EmailMessageHandler(
ILogger <EmailMessageHandler> logger,
IMailBox mailBox,
IRabbitMQService rabbitMQService)
{
MailBox = mailBox;
_logger = logger;
_rabbitMQService = rabbitMQService;
}
public ChequeController(
IChequeRepository chequeRepository,
IReportRenderer reportRenderer,
IMailBox mailBox,
IIoTHub hub, ICopterRepository copterRepository)
{
_chequeRepository = chequeRepository;
_reportRenderer = reportRenderer;
_copterRepository = copterRepository;
_mailBox = mailBox;
_hub = hub;
}
public DefaultEmailMessageHandler(
ILogger <DefaultEmailMessageHandler> logger,
IMailBox mailBox,
IMailAnalyzeService mailAnalyzeService,
IContactService contactService,
IHtmlConverterService htmlConverterService)
{
_logger = logger;
_mailAnalyzeService = mailAnalyzeService;
_contactService = contactService;
_htmlConverterService = htmlConverterService;
MailBox = mailBox;
}
public override async Task <EmailLoadingStatus> LoadFromEmailAsync(IMailBox mailBox)
{
using (var client = new Pop3Client())
{
await ConnectAsync(client, mailBox.Server);
await AuthorizeAsync(client, mailBox);
Logger.Info($"Подключены к {mailBox.Login} c помощью {nameof(ImapLoader)}");
await LoadMessagesAsync(mailBox, client);
await client.DisconnectAsync(true, CancellationToken.None);
}
return(EmailLoadingStatus.Active);
}
protected async Task AuthorizeAsync(IMailService client, IMailBox mailBox)
{
try
{
//TODO
// Note: since we don't have an OAuth2 token, disable
// the XOAUTH2 authentication mechanism.
client.AuthenticationMechanisms.Remove("XOAUTH2");
var password = StringCipher.Decrypt(mailBox.Password, mailBox.Login);
await client.AuthenticateAsync(mailBox.Login, password);
}
catch (Exception ex)
{
throw new Exception($"Не удалось авторизоваться {mailBox.Login} - {ex.Message}", ex);
}
}
public override async Task <EmailLoadingStatus> LoadFromEmailAsync(IMailBox mailBox)
{
using (var client = new ImapClient())
{
await ConnectAsync(client, mailBox.Server);
await AuthorizeAsync(client, mailBox);
Logger.Info($"Подключены к {mailBox.Login} c помощью {nameof(ImapLoader)}");
// The Inbox folder is always available on all IMAP servers...
await LoadFromFolderAsync(mailBox, client.Inbox.ParentFolder);
await client.DisconnectAsync(true);
}
return(EmailLoadingStatus.Active);
}
/// <summary>
/// Загрузим сообщения
/// </summary>
/// <param name="mailBox"></param>
/// <param name="client"></param>
/// <returns></returns>
private async Task LoadMessagesAsync(IMailBox mailBox, Pop3Client client)
{
var count = client.Count;
for (var i = count - 1; i > 0; i--)
{
var message = await client.GetMessageAsync(i);
// только такая проверка т.к. в POP3 без вариантов
if (await MustBeSavedAsync(mailBox, message))
{
await SaveMessageAsync(mailBox, message);
continue;
}
//если письмо сохранять не нужно то сразу выходим
break;
}
}
/*
* /// <summary>
* /// Получить сообщение по Хэш
* /// </summary>
* /// <param name="messageHash"></param>
* /// <returns></returns>
* private async Task<EmailMessage> GetMessageByHashAsync(IMailBox mailBox, string messageHash)
* {
* if (string.IsNullOrWhiteSpace(messageHash)) throw new ArgumentNullException(nameof(messageHash));
* var formattableString = MessageKey(mailBox, messageHash);
* return await _cacheService.GetAsync<EmailMessage>(formattableString, EmailMesageRegion);
* }*/
/// <summary>
/// создать сообщения (без сохранения в бд)
/// </summary>
/// <param name="mailBox"></param>
/// <param name="message"></param>
/// <param name="messageHash"></param>
/// <returns></returns>
private async Task <EmailMessage> CreateMessageAsync(IMailBox mailBox, MimeMessage message, string messageHash)
{
//заполним основные поля
var emailMessage = new EmailMessage
{
Subject = message.Subject,
DateUtc = message.Date.UtcDateTime,
Hash = messageHash
};
_logger.Info($"Создано сообщение {messageHash}");
using (var scope = _lifetimeScope.BeginLifetimeScope((builder) =>
{
builder.Register(c => mailBox).As <IMailBox>();
}))
{
try
{
var messageHandlers = scope.Resolve <IEnumerable <IEmailMessageHandler> >();
var emailMessageHandlers = messageHandlers as IEmailMessageHandler[] ?? messageHandlers.ToArray();
foreach (var emailMessageHandler in emailMessageHandlers)
{
await emailMessageHandler.OnCreate(message, emailMessage);
}
foreach (var emailMessageHandler in emailMessageHandlers)
{
await emailMessageHandler.OnSaveAsync(emailMessage);
}
}
catch (EmailLoaderException exception)
{
_logger.Log(LogLevel.Error, exception, $"Ошибка при обработке письма {messageHash}");
}
}
// var formattableString = MessageKey(mailBox, messageHash);
// await _cacheService.InsertAsync(formattableString, emailMessage, EmailMesageRegion, TimeSpan.FromDays(1));
return(emailMessage);
}
private async Task LoadFromFolderAsync(IMailBox mailBox, IMailFolder parentFolder)
{
var folders = await parentFolder.GetSubfoldersAsync();
using (var folderEnumerator = folders.GetEnumerator())
{
while (folderEnumerator.MoveNext())
{
if (MustBeOpen(folderEnumerator.Current))
{
var folder = folderEnumerator.Current;
await folder.OpenAsync(FolderAccess.ReadOnly);
if (folder.Count > 0)
{
for (var i = folder.Count - 1; i > 0; i--)
{
var message = await folder.GetMessageAsync(i);
// только такая проверка т.к. в POP3 без вариантов
if (await MustBeSavedAsync(mailBox, message))
{
await SaveMessageAsync(mailBox, message);
continue;
}
//если письмо сохранять не нужно то сразу выходим
break;
}
}
if ((folderEnumerator.Current.Attributes & FolderAttributes.HasChildren) != 0)
{
await LoadFromFolderAsync(mailBox, folderEnumerator.Current);
}
}
}
}
}
public abstract Task <EmailLoadingStatus> LoadFromEmailAsync(IMailBox mailBox);
/// <summary>
/// Initializes a new instance of the <see cref="Address"/> class.
/// </summary>
/// <param name="mailBox">the mail box.</param>
public Address(IMailBox mailBox)
{
this.mailBox = mailBox;
}
/// <summary>
/// Полное сохранение письма
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public async Task SaveMessageAsync(IMailBox mailBox, MimeMessage message)
{
await _emailMesageService.SaveMessageAsync(mailBox, message);
}
/// <summary>
/// Initializes a new instance of the <see cref="Address"/> class.
/// </summary>
/// <param name="mailBox">the mail box.</param>
/// <param name="collector">the actor collector.</param>
public Address(IMailBox mailBox, ICollector collector)
{
this.mailBox = mailBox;
this.collector = collector;
}
protected Actor(ActorId id, ActorsSystem system, IMailBox mailBox)
{
Id = id;
System = system;
MailBox = mailBox;
}
/// <summary>
/// Проверка нужно ли сохранять сообщение из почты
/// (проверяет нет ли такого же письма в бд и даты что подходят под рамки)
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
protected async Task <bool> MustBeSavedAsync(IMailBox mailBox, MimeMessage message)
{
return(await _emailMesageService.MustBeSavedAsync(mailBox, message));
}
public ClientConnectionWorker(ActorsSystem system, IMailBox mailBox)
: base(ActorId.GenerateNew(), system, mailBox)
{
}
public MigrationService(ILogWriter logger, IMailBox sourceMailAccount, IMailBox destinationMailAccount)
{
_logger = logger;
_sourceMailAccount = sourceMailAccount;
_destinationMailAccount = destinationMailAccount;
}
public Test()
{
mail = new ProcessMailBox("TMProcessTest", 1024);
}
public Test()
{
mail = new ProcessMailBox("TMProcessTest",1024);
}
/// <summary>
/// можно ли сохранить
/// </summary>
/// <param name="mailBox"></param>
/// <param name="message"></param>
/// <returns></returns>
public Task <bool> MustBeSavedAsync(IMailBox mailBox, MimeMessage message)
{
return(Task.FromResult(message.Date.UtcDateTime > mailBox.LastStartTimeUtc));
}
private static string MessageKey(IMailBox mailBox, string messageHash)
{
var formattableString = $"{mailBox.Login}:{messageHash}";
return(formattableString);
}
public RoundRobinActor(ActorId id, Func <Actor> workerFactory, int degreeOfParallelism, ActorsSystem system, IMailBox mailBox)
: base(id, system, mailBox)
{
_workers = new Actor[degreeOfParallelism];
for (int i = 0; i < degreeOfParallelism; i++)
{
_workers[i] = workerFactory();
}
}
