private IList <MemberSubscription> GetNewSubscriptionList(int groupId, long vkMemberId, IEnumerable <responseGroup> responseGroups)
{
IList <MemberSubscription> newSubscriptions = new List <MemberSubscription>();
foreach (var responseGroup in responseGroups)
{
var memberSubscription = new MemberSubscription
{
VkGroupId = groupId,
SubscribedVkGroupId = int.Parse(responseGroup.gid),
VkMemberId = vkMemberId,
SubscribedVkGroup = new VkGroupReference()
{
VkGroupId = int.Parse(responseGroup.gid),
NameGroup = responseGroup.name,
Photo = responseGroup.photo_medium,
ScreenName = responseGroup.screen_name
}
};
newSubscriptions.Add(memberSubscription);
}
return(newSubscriptions);
}
public async Task <MemberSubscription> PurchaseSubscription(Guid memberId, Guid chapterSubscriptionId, string cardToken)
{
ChapterSubscription chapterSubscription = await _chapterRepository.GetChapterSubscription(chapterSubscriptionId);
if (chapterSubscription == null)
{
throw new OdkServiceException("Subscription not found");
}
Member member = await GetMember(memberId);
await _authorizationService.AssertMemberIsChapterMember(member, chapterSubscription.ChapterId);
await _paymentService.MakePayment(member, chapterSubscription.Amount, cardToken, chapterSubscription.Title);
MemberSubscription memberSubscription = await _memberRepository.GetMemberSubscription(member.Id);
DateTime expiryDate = (memberSubscription?.ExpiryDate ?? DateTime.UtcNow).AddMonths(chapterSubscription.Months);
memberSubscription = new MemberSubscription(member.Id, chapterSubscription.Type, expiryDate);
await _memberRepository.UpdateMemberSubscription(memberSubscription);
MemberSubscriptionRecord record = new MemberSubscriptionRecord(memberId, chapterSubscription.Type, DateTime.UtcNow,
chapterSubscription.Amount, chapterSubscription.Months);
await _memberRepository.AddMemberSubscriptionRecord(record);
_cacheService.UpdatedVersionedItem(memberSubscription, memberId);
_cacheService.RemoveVersionedCollection <Member>(member.ChapterId);
return(memberSubscription);
}
public async Task <bool> MembershipIsActive(MemberSubscription subscription, Guid chapterId)
{
ChapterMembershipSettings membershipSettings = await _cacheService.GetOrSetItem(
() => _chapterRepository.GetChapterMembershipSettings(chapterId),
chapterId);
return(MembershipIsActive(subscription, membershipSettings));
}
/// <summary>
///
/// </summary>
/// <param name="subscriptionDateTimeRange"></param>
/// <param name="subscriptionPlanId">Defaults to Monthly (1)</param>
public void AddSubscription(DateTimeRange subscriptionDateTimeRange, int subscriptionPlanId)
{
var subscription = new MemberSubscription(this.Id, subscriptionPlanId, subscriptionDateTimeRange);
MemberSubscriptions.Add(subscription);
CreateOrUpdateUpdateEvent("Subscription Added");
}
public async Task UpdateMemberSubscription(MemberSubscription memberSubscription)
{
await Context
.Update <MemberSubscription>()
.Set(x => x.Type, memberSubscription.Type)
.Set(x => x.ExpiryDate, memberSubscription.ExpiryDate)
.Where(x => x.MemberId).EqualTo(memberSubscription.MemberId)
.ExecuteAsync();
}
public void Delete(MemberSubscription subscription)
{
Contract.Requires(subscription != null);
using (IDataGateway dataGateway = this.dataGatewayProvider.GetDataGateway())
{
dataGateway.Connection.Execute(@"delete from membersubscriptions where id = @Id", new { subscription.Id });
}
}
public async Task AssertMembershipIsActive(Guid memberId, Guid chapterId)
{
MemberSubscription subscription = await GetMemberSubscription(memberId);
if (!await MembershipIsActive(subscription, chapterId))
{
throw new OdkNotAuthorizedException();
}
}
public async Task <SubscriptionApiResponse> UpdateMemberSubscription(Guid id,
[FromForm] UpdateMemberSubscriptionApiRequest request)
{
UpdateMemberSubscription update = _mapper.Map <UpdateMemberSubscription>(request);
MemberSubscription updated = await _memberAdminService.UpdateMemberSubscription(GetMemberId(), id, update);
return(_mapper.Map <SubscriptionApiResponse>(updated));
}
public async Task ImportMembers(Guid currentMemberId, Guid chapterId, CsvFile file)
{
await AssertMemberIsChapterAdmin(currentMemberId, chapterId);
IReadOnlyCollection <ChapterProperty> chapterProperties = await ChapterRepository.GetChapterProperties(chapterId);
MemberCsvFileHeaders headers = new MemberCsvFileHeaders(chapterProperties);
IDictionary <string, int> headerIndexes = file.GetColumnIndexes();
IDictionary <int, Member> members = new Dictionary <int, Member>();
IDictionary <int, MemberSubscription> membersSubscriptions = new Dictionary <int, MemberSubscription>();
IDictionary <int, IReadOnlyCollection <MemberProperty> > membersProperties =
new Dictionary <int, IReadOnlyCollection <MemberProperty> >();
for (int i = 0; i < file.Rows.Count; i++)
{
CsvRow row = file.Rows.ElementAt(i);
members.Add(i, new Member(Guid.Empty, chapterId,
row.Value(headerIndexes[MemberCsvFileHeaders.Email]),
true,
row.Value(headerIndexes[MemberCsvFileHeaders.FirstName]),
row.Value(headerIndexes[MemberCsvFileHeaders.LastName]),
DateTime.UtcNow,
true,
false,
0));
if (DateTime.TryParse(row.Value(headerIndexes[MemberCsvFileHeaders.SubscriptionExpiry]), out DateTime subscriptionExpiry))
{
membersSubscriptions.Add(i, new MemberSubscription(Guid.Empty, SubscriptionType.Full, subscriptionExpiry));
}
membersProperties.Add(i, chapterProperties
.Select(x => new MemberProperty(Guid.Empty, Guid.Empty, x.Id, row.Value(headerIndexes[x.Label])))
.ToArray());
}
// TODO: validate members
for (int i = 0; i < file.Rows.Count; i++)
{
Guid memberId = await _memberRepository.CreateMember(members[i]);
await _memberRepository.UpdateMemberProperties(memberId, membersProperties[i]);
if (membersSubscriptions.ContainsKey(i))
{
MemberSubscription subscription = new MemberSubscription(memberId, membersSubscriptions[i].Type, membersSubscriptions[i].ExpiryDate);
await _memberRepository.UpdateMemberSubscription(subscription);
}
}
}
private Member GetNonGraduatingMember()
{
var nonGraduatingMember = new Member();
var dates = new DateTimeRange(DateTime.Now.AddYears(-1), DateTime.Now.AddYears(1));
var nonGraduationSubscription = new MemberSubscription(nonGraduatingMember.Id, SubscriptionHelpers.TEST_MEMBER_PLAN_ID, dates);
nonGraduatingMember.MemberSubscriptions.Add(nonGraduationSubscription);
return(nonGraduatingMember);
}
private Member GetGraduatingMember()
{
var graduatingMember = new Member();
var graduationSubscription = new MemberSubscription();
graduationSubscription.Dates = new DateTimeRange(DateTime.Now.AddYears(-2).AddDays(-1), DateTime.Now);
graduatingMember.MemberSubscriptions.Add(graduationSubscription);
return(graduatingMember);
}
public void ReturnsDaysSubscribedToDate()
{
var member = MemberHelpers.CreateWithDefaultConstructor();
MemberSubscription subscription = SubscriptionHelpers.GetSubscriptionWithGivenSubscribedDaysToDateAndTotalSubscribedDays(50);
member.AddSubscription(subscription.Dates);
int days = member.TotalSubscribedDays();
Assert.Equal(50, days);
}
private Member GetNonGraduatingMember()
{
var nonGraduatingMember = new Member();
var nonGraduationSubscription = new MemberSubscription();
nonGraduationSubscription.Dates = new DateTimeRange(DateTime.Now.AddYears(-1), DateTime.Now.AddYears(1));
nonGraduatingMember.MemberSubscriptions.Add(nonGraduationSubscription);
return(nonGraduatingMember);
}
public void AddsSubscriptionWithGivenDateTimeRange()
{
Member member = MemberHelpers.CreateWithDefaultConstructor();
MemberSubscription subscription = SubscriptionHelpers.GetDefaultTestSubscription();
member.AddSubscription(subscription.Dates, 1);
var subscriptionAdded = member.MemberSubscriptions.Any(s => s.Dates.Equals(subscription.Dates));
Assert.True(subscriptionAdded);
}
public void Delete(MemberSubscription subscription)
{
try
{
this.subscriptionRepository.Delete(subscription);
}
catch (DbException exc)
{
ExceptionHandler.HandleSaveException(exc, subscription, "subscription");
}
}
public bool AddSubscription(MemberSubscription subscription)
{
try
{
memberSubscriptions.Add(subscription);
return(true);
}
catch
{
return(false);
}
}
public void ExtendCurrentSubscription(DateTime newEndDate)
{
for (int i = 0; i < MemberSubscriptions.Count; i++)
{
MemberSubscription s = MemberSubscriptions[i];
if (s.Dates.Contains(DateTime.Today))
{
s.Dates = new DateTimeRange(s.Dates.StartDate, newEndDate);
CreateOrUpdateUpdateEvent("Subscription Updated");
}
}
}
public bool RemoveSubscription(int subscriptionId)
{
MemberSubscription subscription = memberSubscriptions.Where(s => s.SubscriptionId == subscriptionId).FirstOrDefault();
if (subscription != null)
{
subscription.SubscriptionStatus = false;
return(true);
}
else
{
return(false);
}
}
public async Task CreateMember(Guid chapterId, CreateMemberProfile profile)
{
await ValidateMemberProfile(chapterId, profile);
ValidateMemberImage(profile.Image.MimeType, profile.Image.ImageData);
Member existing = await _memberRepository.FindMemberByEmailAddress(profile.EmailAddress);
if (existing != null)
{
return;
}
Member create = new Member(Guid.Empty, chapterId, profile.EmailAddress, profile.EmailOptIn, profile.FirstName, profile.LastName,
DateTime.UtcNow, false, false, 0);
Guid id = await _memberRepository.CreateMember(create);
ChapterMembershipSettings membershipSettings = await _chapterRepository.GetChapterMembershipSettings(chapterId);
MemberSubscription subscription = new MemberSubscription(id, SubscriptionType.Trial, create.CreatedDate.AddMonths(membershipSettings.TrialPeriodMonths));
await _memberRepository.UpdateMemberSubscription(subscription);
MemberImage image = CreateMemberImage(id, profile.Image.MimeType, profile.Image.ImageData);
await _memberRepository.AddMemberImage(image);
IEnumerable <MemberProperty> memberProperties = profile.Properties
.Select(x => new MemberProperty(Guid.Empty, id, x.ChapterPropertyId, x.Value));
await _memberRepository.UpdateMemberProperties(id, memberProperties);
string activationToken = RandomStringGenerator.Generate(64);
await _memberRepository.AddActivationToken(new MemberActivationToken(id, activationToken));
Chapter chapter = await _chapterRepository.GetChapter(chapterId);
string url = _settings.ActivateAccountUrl.Interpolate(new Dictionary <string, string>
{
{ "chapter.name", chapter.Name },
{ "token", HttpUtility.UrlEncode(activationToken) }
});
await _emailService.SendEmail(chapter, create.EmailAddress, EmailType.ActivateAccount, new Dictionary <string, string>
{
{ "chapter.name", chapter.Name },
{ "url", url }
});
}
private async Task <AuthenticationToken> GenerateAccessToken(Member member, DateTime?refreshTokenExpires = null)
{
IReadOnlyCollection <ChapterAdminMember> adminChapterMembers = await _chapterRepository.GetChapterAdminMembersByMember(member.Id);
MemberSubscription subscription = await _memberRepository.GetMemberSubscription(member.Id);
string accessToken = _authenticationTokenFactory.Create(member, _settings.AccessTokenLifetimeMinutes);
string refreshToken = await GenerateRefreshToken(member.Id, refreshTokenExpires);
return(new AuthenticationToken(member.Id, member.ChapterId, accessToken, refreshToken,
adminChapterMembers.Select(x => x.ChapterId),
adminChapterMembers.Any(x => x.SuperAdmin),
subscription.ExpiryDate,
await _authorizationService.MembershipIsActive(subscription, member.ChapterId)));
}
public void DoesNothingGivenNoCurrentSubscription()
{
Member member = MemberHelpers.CreateWithDefaultConstructor();
MemberSubscription starterSubscription = SubscriptionHelpers.GetSubscriptionWithPastEndDate();
DateTime newEndDate = DateTime.Now.AddDays(30);
var originalEndDate = starterSubscription.Dates.EndDate;
member.AddSubscription(starterSubscription.Dates);
member.ExtendCurrentSubscription(newEndDate);
Assert.Equal(originalEndDate, member.MemberSubscriptions[0].Dates.EndDate);
Assert.Single(member.MemberSubscriptions);
}
public async Task ReturnsEmptyListGivenListWithMemberOneDayFromGraduation()
{
var testlist = new List <Member>();
var member = new Member();
var dates = new DateTimeRange(DateTime.Today.AddDays(DAYS_IN_TWO_YEARS * -1).AddDays(1), DateTime.Today.AddDays(1));
var nearGraduationSubscription = new MemberSubscription(member.Id, SubscriptionHelpers.TEST_MEMBER_PLAN_ID, dates);
member.MemberSubscriptions.Add(nearGraduationSubscription);
testlist.Add(member);
userLookupService.Setup(u => u.FindUserIsAlumniByUserIdAsync(member.UserId)).ReturnsAsync(false);
var list = await service.CheckIfAnyMemberGraduating(testlist);
Assert.Empty(list);
}
private void ValidateMemberSubscription(MemberSubscription subscription)
{
if (!Enum.IsDefined(typeof(SubscriptionType), subscription.Type) || subscription.Type == SubscriptionType.None)
{
throw new OdkServiceException("Invalid type");
}
if (subscription.Type == SubscriptionType.Alum && subscription.ExpiryDate != null)
{
throw new OdkServiceException("Alum should not have expiry date");
}
else if (subscription.Type != SubscriptionType.Alum && subscription.ExpiryDate < DateTime.UtcNow.Date)
{
throw new OdkServiceException("Expiry date should not be in the past");
}
}
public async Task <Unit> Handle(ChangeSubscriptionExpirationDateForMemberCommand command, CancellationToken cancellationToken)
{
MemberSubscription memberSubscription = await _memberSubscriptionRepository.GetByIdOptionalAsync(new MemberSubscriptionId(command.MemberId.Value));
if (memberSubscription == null)
{
memberSubscription = MemberSubscription.CreateForMember(command.MemberId, command.ExpirationDate);
await _memberSubscriptionRepository.AddAsync(memberSubscription);
}
else
{
memberSubscription.ChangeExpirationDate(command.ExpirationDate);
}
return(Unit.Value);
}
public UserBillingViewModel(List <BillingActivity> billingActivities,
int totalSubscribedDays,
string subscriptionPlanName,
BillingPeriod billingPeriod,
DateTime currentSubscriptionEndDate,
DateTime graduationDate,
MemberSubscription currentSubscription)
{
BillingActivities = billingActivities;
TotalSubscribedDays = totalSubscribedDays;
SubscriptionPlanName = subscriptionPlanName;
BillingPeriod = billingPeriod;
CurrentSubscriptionEndDate = currentSubscriptionEndDate;
GraduationDate = graduationDate;
CurrentSubscription = currentSubscription;
}
public void ExtendsSubscription()
{
Member member = MemberHelpers.CreateWithDefaultConstructor();
MemberSubscription starterSubscription = SubscriptionHelpers.GetDefaultTestSubscription();
DateTime newEndDate = DateTime.Now.AddDays(30);
DateTime originalStartDate = starterSubscription.Dates.StartDate;
member.AddSubscription(starterSubscription.Dates);
member.ExtendCurrentSubscription(newEndDate);
Assert.Equal(newEndDate, member.MemberSubscriptions[0].Dates.EndDate);
Assert.Equal(originalStartDate, member.MemberSubscriptions[0].Dates.StartDate);
Assert.Single(member.MemberSubscriptions);
}
public async Task <MemberSubscription> UpdateMemberSubscription(Guid currentMemberId, Guid memberId,
UpdateMemberSubscription subscription)
{
Member member = await GetMember(currentMemberId, memberId);
DateTime?expiryDate = subscription.Type == SubscriptionType.Alum ? new DateTime?() : subscription.ExpiryDate;
MemberSubscription update = new MemberSubscription(member.Id, subscription.Type, expiryDate);
ValidateMemberSubscription(update);
await _memberRepository.UpdateMemberSubscription(update);
_cacheService.RemoveVersionedItem <MemberSubscription>(memberId);
_cacheService.RemoveVersionedCollection <Member>(member.ChapterId);
return(update);
}
public bool MembershipIsActive(MemberSubscription subscription, ChapterMembershipSettings membershipSettings)
{
if (subscription.Type == SubscriptionType.Alum)
{
return(false);
}
if (subscription.ExpiryDate == null || subscription.ExpiryDate >= DateTime.UtcNow)
{
return(true);
}
if (membershipSettings.MembershipDisabledAfterDaysExpired <= 0)
{
return(true);
}
return(subscription.ExpiryDate >= DateTime.UtcNow.AddDays(-1 * membershipSettings.MembershipDisabledAfterDaysExpired));
}
public void Save(MemberSubscription subscription)
{
if (!subscription.IsTransient())
{
return;
}
using (IDataGateway dataGateway = this.dataGatewayProvider.GetDataGateway())
{
try
{
subscription.Id = dataGateway.Connection.Query <int>(@"insert into membersubscriptions(vkmemberid, vkgroupid, subscribedvkgroupid) values (@VkMemberId, @VkGroupId, @SubscribedVkGroupId) RETURNING id", subscription).First();
}
catch (Exception exc)
{
this.log.ErrorFormat("Unable to save subscription {0} due to: {1}", subscription.ToString(), exc.ToString());
throw;
}
}
}
public static PaymentInformationBO Map(MemberSubscription memberSubscription, MemberAddress memberAddress,
MemberDetail memberDetail, MemberPaymentDetail paymentDetail)
{
return(new PaymentInformationBO
{
PaymentMethodType = memberSubscription != null && memberSubscription.PaymentType != null ?
((PaymentType)memberSubscription.PaymentType).ToString() : null,
Last4Digits = memberSubscription.CardOrAccountNumber,
LastTransactionDate = paymentDetail != null
? (paymentDetail.PaidDate != null ? paymentDetail.PaidDate.ToString() : "")
: "",
PremiumAmount = Convert.ToDecimal(paymentDetail != null ? paymentDetail.PaidAmount : 0),
//Field for auto populate
FirstName = memberDetail.FirstName,
LastName = memberDetail.LastName,
Address = memberAddress.AddressLine1 + (memberAddress.AddressLine2 ?? ""),
City = memberAddress.City,
State = memberAddress.StateCode,
ZipCode = memberAddress.ZipCode
});
}
