public async Task <ChapterEmailProvider> GetChapterEmailProvider(Guid currentMemberId, Guid chapterEmailProviderId)
{
ChapterEmailProvider provider = await _chapterRepository.GetChapterEmailProvider(chapterEmailProviderId);
await AssertMemberIsChapterAdmin(currentMemberId, provider.ChapterId);
return(provider);
}
private async Task AddEmailFrom(MimeMessage message, ChapterEmailProvider provider, ChapterAdminMember from)
{
if (from != null)
{
Member member = await _memberRepository.GetMember(from.MemberId);
message.From.Add(new MailboxAddress($"{member.FirstName} {member.LastName}", from.AdminEmailAddress));
}
else
{
message.From.Add(new MailboxAddress(provider.FromName, provider.FromEmailAddress));
}
}
private static void ValidateChapterEmailProvider(ChapterEmailProvider provider)
{
if (string.IsNullOrWhiteSpace(provider.FromEmailAddress) ||
string.IsNullOrWhiteSpace(provider.FromName) ||
string.IsNullOrWhiteSpace(provider.SmtpLogin) ||
string.IsNullOrWhiteSpace(provider.SmtpPassword) ||
provider.SmtpPort == 0 ||
provider.DailyLimit <= 0 ||
provider.BatchSize <= 0)
{
throw new OdkServiceException("Some required fields are missing");
}
}
private async Task <MimeMessage> CreateMessage(ChapterEmailProvider provider, ChapterAdminMember from, string subject, string body)
{
MimeMessage message = new MimeMessage
{
Body = new TextPart(TextFormat.Html)
{
Text = body
},
Subject = subject
};
await AddEmailFrom(message, provider, from);
return(message);
}
public async Task AddChapterEmailProvider(Guid currentMemberId, Guid chapterId, UpdateChapterEmailProvider provider)
{
await AssertMemberIsChapterAdmin(currentMemberId, chapterId);
ChapterEmailProvider create = new ChapterEmailProvider(Guid.Empty, chapterId, provider.SmtpServer, provider.SmtpPort,
provider.SmtpLogin, provider.SmtpPassword, provider.FromEmailAddress, provider.FromName,
provider.BatchSize, provider.DailyLimit, 0);
IReadOnlyCollection <ChapterEmailProvider> existing = await _chapterRepository.GetChapterEmailProviders(chapterId);
create.Order = existing.Count + 1;
ValidateChapterEmailProvider(create);
await _chapterRepository.AddChapterEmailProvider(create);
}
public async Task UpdateChapterEmailProvider(ChapterEmailProvider provider)
{
await Context
.Update <ChapterEmailProvider>()
.Set(x => x.BatchSize, provider.BatchSize)
.Set(x => x.DailyLimit, provider.DailyLimit)
.Set(x => x.FromEmailAddress, provider.FromEmailAddress)
.Set(x => x.FromName, provider.FromName)
.Set(x => x.Order, provider.Order)
.Set(x => x.SmtpLogin, provider.SmtpLogin)
.Set(x => x.SmtpPassword, provider.SmtpPassword)
.Set(x => x.SmtpPort, provider.SmtpPort)
.Set(x => x.SmtpServer, provider.SmtpServer)
.Where(x => x.Id).EqualTo(provider.Id)
.ExecuteAsync();
}
public async Task UpdateChapterEmailProvider(Guid currentMemberId, Guid chapterEmailProviderId,
UpdateChapterEmailProvider provider)
{
ChapterEmailProvider update = await GetChapterEmailProvider(currentMemberId, chapterEmailProviderId);
update.BatchSize = provider.BatchSize;
update.DailyLimit = provider.DailyLimit;
update.FromEmailAddress = provider.FromEmailAddress;
update.FromName = provider.FromName;
update.SmtpLogin = provider.SmtpLogin;
update.SmtpPassword = provider.SmtpPassword;
update.SmtpPort = provider.SmtpPort;
update.SmtpServer = provider.SmtpServer;
ValidateChapterEmailProvider(update);
await _chapterRepository.UpdateChapterEmailProvider(update);
}
private async Task SendEmail(ChapterEmailProvider provider, MimeMessage message)
{
if (message.To.Count == 0)
{
await _loggingService.LogDebug("Not sending email, no recipients set");
return;
}
await _loggingService.LogDebug($"Sending email to {string.Join(", ", message.To)}");
try
{
using SmtpClient client = new SmtpClient
{
ServerCertificateValidationCallback = (s, c, h, e) => true
};
await client.ConnectAsync(provider.SmtpServer, provider.SmtpPort, SecureSocketOptions.StartTlsWhenAvailable);
client.Authenticate(provider.SmtpLogin, provider.SmtpPassword);
await client.SendAsync(message);
await client.DisconnectAsync(true);
foreach (InternetAddress to in message.To.Union(message.Cc).Union(message.Bcc))
{
SentEmail sentEmail = new SentEmail(provider.Id, DateTime.UtcNow, to.ToString(), message.Subject);
await _emailRepository.AddSentEmail(sentEmail);
}
await _loggingService.LogDebug($"Email sent to {string.Join(", ", message.To)}");
}
catch (Exception ex)
{
await _loggingService.LogError(ex, "Error sending email");
throw new OdkServiceException("Error sending email");
}
}
public async Task <ChapterEmailProviderApiResponse> GetChapterEmailProvider(Guid id, Guid chapterEmailProviderId)
{
ChapterEmailProvider provider = await _emailAdminService.GetChapterEmailProvider(GetMemberId(), chapterEmailProviderId);
return(_mapper.Map <ChapterEmailProviderApiResponse>(provider));
}
public async Task DeleteChapterEmailProvider(Guid currentMemberId, Guid chapterEmailProviderId)
{
ChapterEmailProvider provider = await GetChapterEmailProvider(currentMemberId, chapterEmailProviderId);
await _chapterRepository.DeleteChapterEmailProvider(provider.Id);
}
public async Task AddChapterEmailProvider(ChapterEmailProvider provider)
{
await Context
.Insert(provider)
.ExecuteAsync();
}
