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 }); }