public async Task SendBulkEmail(Guid currentMemberId, Chapter chapter, IEnumerable <Member> to, EmailType type, IDictionary <string, string> parameters)
{
ChapterAdminMember from = await GetSender(chapter.Id, currentMemberId);
Email email = await GetEmail(type, chapter.Id, parameters);
await _mailProvider.SendBulkEmail(chapter, to.Select(x => x.EmailAddress), email.Subject, email.HtmlContent, from);
}
protected async Task AssertMemberIsChapterSuperAdmin(Guid memberId, Guid chapterId)
{
ChapterAdminMember chapterAdminMember = await ChapterRepository.GetChapterAdminMember(chapterId, memberId);
if (chapterAdminMember == null || !chapterAdminMember.SuperAdmin)
{
throw new OdkNotAuthorizedException();
}
}
private async Task <ChapterAdminMember> GetSender(Guid chapterId, Guid memberId)
{
ChapterAdminMember from = await _chapterRepository.GetChapterAdminMember(chapterId, memberId);
if (from == null)
{
throw new OdkNotAuthorizedException();
}
return(from);
}
public async Task UpdateChapterAdminMember(ChapterAdminMember adminMember)
{
await Context
.Update <ChapterAdminMember>()
.Set(x => x.AdminEmailAddress, adminMember.AdminEmailAddress)
.Set(x => x.ReceiveContactEmails, adminMember.ReceiveContactEmails)
.Set(x => x.ReceiveNewMemberEmails, adminMember.ReceiveNewMemberEmails)
.Set(x => x.SendNewMemberEmails, adminMember.SendNewMemberEmails)
.Where(x => x.MemberId).EqualTo(adminMember.MemberId)
.ExecuteAsync();
}
public async Task DeleteChapterAdminMember(Guid currentMemberId, Guid chapterId, Guid memberId)
{
ChapterAdminMember adminMember = await GetChapterAdminMember(currentMemberId, chapterId, memberId);
if (adminMember.SuperAdmin)
{
return;
}
await _chapterRepository.DeleteChapterAdminMember(chapterId, memberId);
}
public async Task <ChapterAdminMember> GetChapterAdminMember(Guid currentMemberId, Guid chapterId, Guid memberId)
{
await AssertMemberIsChapterAdmin(currentMemberId, chapterId);
ChapterAdminMember adminMember = await _chapterRepository.GetChapterAdminMember(chapterId, memberId);
if (adminMember == null)
{
throw new OdkNotFoundException();
}
return(adminMember);
}
public async Task SendMemberEmail(Guid currentMemberId, Guid memberId, string subject, string body)
{
Member to = await _memberRepository.GetMember(memberId);
if (to == null)
{
throw new OdkNotFoundException();
}
ChapterAdminMember from = await GetSender(to.ChapterId, currentMemberId);
Chapter chapter = await _chapterRepository.GetChapter(from.ChapterId);
await _mailProvider.SendEmail(chapter, to.EmailAddress, subject, body, from);
}
public async Task AssertMemberIsChapterMember(Member member, Guid chapterId)
{
AssertMemberIsCurrent(member);
if (member.ChapterId == chapterId)
{
return;
}
ChapterAdminMember chapterAdminMember = await _chapterRepository.GetChapterAdminMember(chapterId, member.Id);
if (chapterAdminMember != null)
{
return;
}
throw new OdkNotAuthorizedException();
}
public async Task UpdateChapterAdminMember(Guid currentMemberId, Guid chapterId, Guid memberId,
UpdateChapterAdminMember adminMember)
{
await AssertMemberIsChapterAdmin(currentMemberId, chapterId);
ChapterAdminMember existing = await _chapterRepository.GetChapterAdminMember(chapterId, memberId);
if (existing == null)
{
throw new OdkNotFoundException();
}
existing.AdminEmailAddress = adminMember.AdminEmailAddress;
existing.ReceiveContactEmails = adminMember.ReceiveContactEmails;
existing.ReceiveNewMemberEmails = adminMember.ReceiveNewMemberEmails;
existing.SendNewMemberEmails = adminMember.SendNewMemberEmails;
await _chapterRepository.UpdateChapterAdminMember(existing);
}
public async Task AddChapterAdminMember(Guid currentMemberId, Guid chapterId, Guid memberId)
{
await AssertMemberIsChapterAdmin(currentMemberId, chapterId);
Member member = await _memberRepository.GetMember(memberId);
if (member == null)
{
throw new OdkNotFoundException();
}
ChapterAdminMember existing = await _chapterRepository.GetChapterAdminMember(chapterId, memberId);
if (existing != null)
{
return;
}
ChapterAdminMember adminMember = new ChapterAdminMember(chapterId, memberId);
await _chapterRepository.AddChapterAdminMember(adminMember);
}
public async Task <ChapterAdminMemberApiResponse> GetChapterAdminMember(Guid id, Guid memberId)
{
ChapterAdminMember adminMember = await _chapterAdminService.GetChapterAdminMember(GetMemberId(), id, memberId);
return(_mapper.Map <ChapterAdminMemberApiResponse>(adminMember));
}
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));
}
}
public async Task SendBulkEmail(Guid currentMemberId, Chapter chapter, IEnumerable <Member> to, string subject, string body)
{
ChapterAdminMember from = await GetSender(chapter.Id, currentMemberId);
await _mailProvider.SendBulkEmail(chapter, to.Select(x => x.EmailAddress), subject, body, from);
}
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 SendBulkEmail(Chapter chapter, IEnumerable <string> to, string subject, string body, ChapterAdminMember from, bool bcc = true)
{
body = await GetLayoutBody(chapter, body);
int i = 0;
List <string> toList = to.ToList();
while (i < toList.Count)
{
(ChapterEmailProvider provider, int remaining) = await GetProvider(chapter.Id);
int batchSize = provider.BatchSize ?? (toList.Count - i);
if (batchSize > remaining)
{
batchSize = remaining;
}
IEnumerable <string> batch = toList.Skip(i).Take(batchSize);
MimeMessage message = await CreateMessage(provider, from, subject, body);
if (bcc)
{
AddBulkEmailBccRecipients(message, message.From.First(), batch);
}
else
{
AddBulkEmailRecipients(message, batch);
}
await SendEmail(provider, message);
i += batchSize;
}
}
public async Task SendEmail(Chapter chapter, string to, string subject, string body, ChapterAdminMember from)
{
body = await GetLayoutBody(chapter, body);
(ChapterEmailProvider provider, int _) = await GetProvider(chapter.Id);
MimeMessage message = await CreateMessage(provider, from, subject, body);
AddEmailRecipient(message, new MailboxAddress(to));
await SendEmail(provider, message);
}
public async Task AddChapterAdminMember(ChapterAdminMember adminMember)
{
await Context
.Insert(adminMember)
.ExecuteAsync();
}
