public async Task SendContactMessage(Guid chapterId, string fromAddress, string message)
{
if (string.IsNullOrWhiteSpace(fromAddress) || string.IsNullOrWhiteSpace(message))
{
throw new OdkServiceException("Email address and message must be provided");
}
if (!MailUtils.ValidEmailAddress(fromAddress))
{
throw new OdkServiceException("Invalid email address format");
}
VersionedServiceResult <Chapter> chapter = await GetChapter(null, chapterId);
ContactRequest contactRequest = new ContactRequest(Guid.Empty, chapter.Value.Id, DateTime.UtcNow, fromAddress, message, false);
await _chapterRepository.AddContactRequest(contactRequest);
IDictionary <string, string> parameters = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
{
{ "from", fromAddress },
{ "message", HttpUtility.HtmlEncode(message) }
};
await _emailService.SendContactEmail(chapter.Value, fromAddress, message, parameters);
}
private async Task <MemberSubscription> GetMemberSubscription(Guid memberId)
{
VersionedServiceResult <MemberSubscription> subscription = await _cacheService.GetOrSetVersionedItem(
() => _memberRepository.GetMemberSubscription(memberId), memberId, null);
return(subscription.Value);
}
private async Task <Member> GetMember(Guid id)
{
VersionedServiceResult <Member> member = await _cacheService.GetOrSetVersionedItem(
() => _memberRepository.GetMember(id, true), id, null);
AssertMemberIsCurrent(member.Value);
return(member.Value);
}
private async Task <Member> GetMember(Guid currentMemberId, Guid memberId)
{
VersionedServiceResult <Member> member = await _cacheService.GetOrSetVersionedItem(() => _memberRepository.GetMember(memberId), memberId, null);
await _authorizationService.AssertMemberIsChapterMember(currentMemberId, member.Value.ChapterId);
return(member.Value);
}
public async Task <IReadOnlyCollection <Chapter> > GetChapters(Guid currentMemberId)
{
IReadOnlyCollection <ChapterAdminMember> chapterAdminMembers = await _chapterRepository.GetChapterAdminMembersByMember(currentMemberId);
if (chapterAdminMembers.Count == 0)
{
throw new OdkNotAuthorizedException();
}
VersionedServiceResult <IReadOnlyCollection <Chapter> > chapters = await _chapterService.GetChapters(null);
return(chapterAdminMembers
.Select(x => chapters.Value.Single(chapter => chapter.Id == x.ChapterId))
.ToArray());
}
protected async Task <ActionResult <TResponse> > HandleVersionedRequest <T, TResponse>(Func <long?, Task <VersionedServiceResult <T> > > getter, Func <T, TResponse> map)
{
int?version = GetRequestVersion();
VersionedServiceResult <T> result = await getter(version);
AddVersionHeader(result.Version);
if (version == result.Version)
{
return(NotModified());
}
return(Ok(map(result.Value)));
}
public async Task <VersionedServiceResult <Chapter> > GetChapter(long?currentVersion, Guid id)
{
VersionedServiceResult <IReadOnlyCollection <Chapter> > chapters = await GetChapters(currentVersion);
if (chapters.Version == currentVersion)
{
return(new VersionedServiceResult <Chapter>(chapters.Version));
}
Chapter chapter = chapters.Value.SingleOrDefault(x => x.Id == id);
if (chapter == null)
{
throw new OdkNotFoundException();
}
return(new VersionedServiceResult <Chapter>(chapters.Version, chapter));
}
public async Task <ActionResult <GoogleMapsApiKeyApiResponse> > GoogleMapsApiKey(Guid?venueId)
{
if (TryGetMemberId() == null)
{
VersionedServiceResult <Venue> venue = venueId != null
? await _venueService.GetVenue(null, null, venueId.Value)
: new VersionedServiceResult <Venue>(0, null);
if (venue.Value == null)
{
throw new OdkNotAuthorizedException();
}
}
return(await HandleVersionedRequest(
_settingsService.GetSiteSettings,
_mapper.Map <GoogleMapsApiKeyApiResponse>));
}
public async Task <VersionedServiceResult <IReadOnlyCollection <Member> > > GetLatestMembers(long?currentVersion,
Guid currentMemberId, Guid chapterId)
{
await _authorizationService.AssertMemberIsChapterMember(currentMemberId, chapterId);
VersionedServiceResult <IReadOnlyCollection <Member> > members = await GetMembers(currentVersion, currentMemberId, chapterId);
if (members.Value == null)
{
return(members);
}
IReadOnlyCollection <Member> latestMembers = members
.Value
.OrderByDescending(x => x.CreatedDate)
.Take(8)
.ToArray();
return(new VersionedServiceResult <IReadOnlyCollection <Member> >(members.Version, latestMembers));
}
public async Task <VersionedServiceResult <MemberImage> > GetMemberImage(long?currentVersion, Guid memberId, int?size)
{
VersionedServiceResult <MemberImage> result = await _cacheService.GetOrSetVersionedItem(
() => _memberRepository.GetMemberImage(memberId),
memberId,
currentVersion);
if (currentVersion == result.Version)
{
return(result);
}
MemberImage image = result.Value;
if (size != null)
{
byte[] imageData = _imageService.Crop(image.ImageData, size.Value, size.Value);
image = new MemberImage(image.MemberId, imageData, image.MimeType, image.Version);
}
return(new VersionedServiceResult <MemberImage>(image.Version, image));
}
