public bool IsValid(OrganizationSponsorship sponsorship, string currentUserEmail) => sponsorship != null && sponsorship.PlanSponsorshipType.HasValue && SponsorshipType == sponsorship.PlanSponsorshipType.Value && Id == sponsorship.Id && !string.IsNullOrWhiteSpace(sponsorship.OfferedToEmail) && Email.Equals(currentUserEmail, StringComparison.InvariantCultureIgnoreCase) && Email.Equals(sponsorship.OfferedToEmail, StringComparison.InvariantCultureIgnoreCase);
public async Task RevokeSponsorship_SponsorshipRedeemed_MarksForDelete(OrganizationSponsorship sponsorship, SutProvider <CloudRevokeSponsorshipCommand> sutProvider) { await sutProvider.Sut.RevokeSponsorshipAsync(sponsorship); Assert.True(sponsorship.ToDelete); await AssertUpdatedSponsorshipAsync(sponsorship, sutProvider); await AssertDidNotDeleteSponsorshipAsync(sutProvider); }
public async Task RemoveSponsorshipAsync(OrganizationSponsorship sponsorship) { if (sponsorship == null || sponsorship.SponsoredOrganizationId == null) { throw new BadRequestException("The requested organization is not currently being sponsored."); } await MarkToDeleteSponsorshipAsync(sponsorship); }
public async Task SendSponsorshipOfferAsync(OrganizationSponsorship sponsorship, string sponsoringOrgName) { var user = await _userRepository.GetByEmailAsync(sponsorship.OfferedToEmail); var isExistingAccount = user != null; await _mailService.SendFamiliesForEnterpriseOfferEmailAsync(sponsoringOrgName, sponsorship.OfferedToEmail, isExistingAccount, _tokenFactory.Protect(new OrganizationSponsorshipOfferTokenable(sponsorship))); }
public async Task RevokeSponsorship_SponsorshipNotSynced_DeletesSponsorship(OrganizationSponsorship sponsorship, SutProvider <SelfHostedRevokeSponsorshipCommand> sutProvider) { sponsorship.LastSyncDate = null; await sutProvider.Sut.RevokeSponsorshipAsync(sponsorship); await AssertDeletedSponsorshipAsync(sponsorship, sutProvider); }
protected virtual async Task DeleteSponsorshipAsync(OrganizationSponsorship sponsorship = null) { if (sponsorship == null) { return; } await _organizationSponsorshipRepository.DeleteAsync(sponsorship); }
protected async Task MarkToDeleteSponsorshipAsync(OrganizationSponsorship sponsorship) { if (sponsorship == null) { throw new BadRequestException("The sponsorship you are trying to cancel does not exist"); } sponsorship.ToDelete = true; await _organizationSponsorshipRepository.UpsertAsync(sponsorship); }
public OrganizationSponsorshipRequestModel(OrganizationSponsorship sponsorship) { SponsoringOrganizationUserId = sponsorship.SponsoringOrganizationUserId; FriendlyName = sponsorship.FriendlyName; OfferedToEmail = sponsorship.OfferedToEmail; PlanSponsorshipType = sponsorship.PlanSponsorshipType.GetValueOrDefault(); LastSyncDate = sponsorship.LastSyncDate; ValidUntil = sponsorship.ValidUntil; ToDelete = sponsorship.ToDelete; }
public async Task UpdateExpirationDate_UpdatesValidUntil(OrganizationSponsorship sponsorship, DateTime expireDate, SutProvider <OrganizationSponsorshipRenewCommand> sutProvider) { sutProvider.GetDependency <IOrganizationSponsorshipRepository>().GetBySponsoredOrganizationIdAsync(sponsorship.SponsoredOrganizationId.Value).Returns(sponsorship); await sutProvider.Sut.UpdateExpirationDateAsync(sponsorship.SponsoredOrganizationId.Value, expireDate); await sutProvider.GetDependency <IOrganizationSponsorshipRepository>().Received(1) .UpsertAsync(sponsorship); }
public async Task RevokeSponsorship_SponsorshipSynced_MarksForDeletion(OrganizationSponsorship sponsorship, SutProvider <SelfHostedRevokeSponsorshipCommand> sutProvider) { sponsorship.LastSyncDate = DateTime.UtcNow; await sutProvider.Sut.RevokeSponsorshipAsync(sponsorship); Assert.True(sponsorship.ToDelete); await AssertUpdatedSponsorshipAsync(sponsorship, sutProvider); await AssertDidNotDeleteSponsorshipAsync(sutProvider); }
public async Task ResendSponsorshipOffer_SponsoringOrgNotFound_ThrowsBadRequest( OrganizationUser orgUser, OrganizationSponsorship sponsorship, SutProvider <SendSponsorshipOfferCommand> sutProvider) { var exception = await Assert.ThrowsAsync <BadRequestException>(() => sutProvider.Sut.SendSponsorshipOfferAsync(null, orgUser, sponsorship)); Assert.Contains("Cannot find the requested sponsoring organization.", exception.Message); await sutProvider.GetDependency <IMailService>() .DidNotReceiveWithAnyArgs() .SendFamiliesForEnterpriseOfferEmailAsync(default, default, default, default);
private bool SponsorshipValidator(OrganizationSponsorship sponsorship, OrganizationSponsorship expectedSponsorship) { try { AssertHelper.AssertPropertyEqual(sponsorship, expectedSponsorship, nameof(OrganizationSponsorship.Id)); return(true); } catch { return(false); } }
public async Task SetUpSponsorship_OrgAlreadySponsored_ThrowsBadRequest(Organization org, OrganizationSponsorship sponsorship, OrganizationSponsorship existingSponsorship, SutProvider <SetUpSponsorshipCommand> sutProvider) { sutProvider.GetDependency <IOrganizationSponsorshipRepository>() .GetBySponsoredOrganizationIdAsync(org.Id).Returns(existingSponsorship); var exception = await Assert.ThrowsAsync <BadRequestException>(() => sutProvider.Sut.SetUpSponsorshipAsync(sponsorship, org)); Assert.Contains("Cannot redeem a sponsorship offer for an organization that is already sponsored. Revoke existing sponsorship first.", exception.Message); await AssertDidNotSetUpAsync(sutProvider); }
public async Task SetUpSponsorship_OrgNotFamiles_ThrowsBadRequest(PlanType planType, OrganizationSponsorship sponsorship, Organization org, SutProvider <SetUpSponsorshipCommand> sutProvider) { org.PlanType = planType; sponsorship.LastSyncDate = DateTime.UtcNow; var exception = await Assert.ThrowsAsync <BadRequestException>(() => sutProvider.Sut.SetUpSponsorshipAsync(sponsorship, org)); Assert.Contains("Can only redeem sponsorship offer on families organizations.", exception.Message); await AssertDidNotSetUpAsync(sutProvider); }
public async Task RemoveSponsorship_SponsoredOrgNull_ThrowsBadRequest(OrganizationSponsorship sponsorship, SutProvider <RemoveSponsorshipCommand> sutProvider) { sponsorship.SponsoredOrganizationId = null; var exception = await Assert.ThrowsAsync <BadRequestException>(() => sutProvider.Sut.RemoveSponsorshipAsync(sponsorship)); Assert.Contains("The requested organization is not currently being sponsored.", exception.Message); Assert.False(sponsorship.ToDelete); await AssertDidNotDeleteSponsorshipAsync(sutProvider); await AssertDidNotUpdateSponsorshipAsync(sutProvider); }
public async void ReplaceAsync_Works_DataMatches(OrganizationSponsorship postOrganizationSponsorship, OrganizationSponsorship replaceOrganizationSponsorship, Organization sponsoringOrg, List <EfRepo.OrganizationRepository> efOrgRepos, SqlRepo.OrganizationRepository sqlOrganizationRepo, SqlRepo.OrganizationSponsorshipRepository sqlOrganizationSponsorshipRepo, OrganizationSponsorshipCompare equalityComparer, List <EfRepo.OrganizationSponsorshipRepository> suts) { postOrganizationSponsorship.InstallationId = null; postOrganizationSponsorship.SponsoredOrganizationId = null; replaceOrganizationSponsorship.InstallationId = null; replaceOrganizationSponsorship.SponsoredOrganizationId = null; var savedOrganizationSponsorships = new List <OrganizationSponsorship>(); foreach (var(sut, orgRepo) in suts.Zip(efOrgRepos)) { var efSponsoringOrg = await orgRepo.CreateAsync(sponsoringOrg); sut.ClearChangeTracking(); postOrganizationSponsorship.SponsoringOrganizationId = efSponsoringOrg.Id; replaceOrganizationSponsorship.SponsoringOrganizationId = efSponsoringOrg.Id; var postEfOrganizationSponsorship = await sut.CreateAsync(postOrganizationSponsorship); sut.ClearChangeTracking(); replaceOrganizationSponsorship.Id = postEfOrganizationSponsorship.Id; await sut.ReplaceAsync(replaceOrganizationSponsorship); sut.ClearChangeTracking(); var replacedOrganizationSponsorship = await sut.GetByIdAsync(replaceOrganizationSponsorship.Id); savedOrganizationSponsorships.Add(replacedOrganizationSponsorship); } var sqlSponsoringOrg = await sqlOrganizationRepo.CreateAsync(sponsoringOrg); postOrganizationSponsorship.SponsoringOrganizationId = sqlSponsoringOrg.Id; var postSqlOrganization = await sqlOrganizationSponsorshipRepo.CreateAsync(postOrganizationSponsorship); replaceOrganizationSponsorship.Id = postSqlOrganization.Id; await sqlOrganizationSponsorshipRepo.ReplaceAsync(replaceOrganizationSponsorship); savedOrganizationSponsorships.Add(await sqlOrganizationSponsorshipRepo.GetByIdAsync(replaceOrganizationSponsorship.Id)); var distinctItems = savedOrganizationSponsorships.Distinct(equalityComparer); Assert.True(!distinctItems.Skip(1).Any()); }
public async void DeleteAsync_Works_DataMatches(OrganizationSponsorship organizationSponsorship, Organization sponsoringOrg, List <EfRepo.OrganizationRepository> efOrgRepos, SqlRepo.OrganizationRepository sqlOrganizationRepo, SqlRepo.OrganizationSponsorshipRepository sqlOrganizationSponsorshipRepo, List <EfRepo.OrganizationSponsorshipRepository> suts) { organizationSponsorship.InstallationId = null; organizationSponsorship.SponsoredOrganizationId = null; foreach (var(sut, orgRepo) in suts.Zip(efOrgRepos)) { var efSponsoringOrg = await orgRepo.CreateAsync(sponsoringOrg); sut.ClearChangeTracking(); organizationSponsorship.SponsoringOrganizationId = efSponsoringOrg.Id; var postEfOrganizationSponsorship = await sut.CreateAsync(organizationSponsorship); sut.ClearChangeTracking(); var savedEfOrganizationSponsorship = await sut.GetByIdAsync(postEfOrganizationSponsorship.Id); sut.ClearChangeTracking(); Assert.True(savedEfOrganizationSponsorship != null); await sut.DeleteAsync(savedEfOrganizationSponsorship); sut.ClearChangeTracking(); savedEfOrganizationSponsorship = await sut.GetByIdAsync(savedEfOrganizationSponsorship.Id); Assert.True(savedEfOrganizationSponsorship == null); } var sqlSponsoringOrg = await sqlOrganizationRepo.CreateAsync(sponsoringOrg); organizationSponsorship.SponsoringOrganizationId = sqlSponsoringOrg.Id; var postSqlOrganizationSponsorship = await sqlOrganizationSponsorshipRepo.CreateAsync(organizationSponsorship); var savedSqlOrganizationSponsorship = await sqlOrganizationSponsorshipRepo.GetByIdAsync(postSqlOrganizationSponsorship.Id); Assert.True(savedSqlOrganizationSponsorship != null); await sqlOrganizationSponsorshipRepo.DeleteAsync(postSqlOrganizationSponsorship); savedSqlOrganizationSponsorship = await sqlOrganizationSponsorshipRepo.GetByIdAsync(postSqlOrganizationSponsorship.Id); Assert.True(savedSqlOrganizationSponsorship == null); }
protected async Task AssertRemovedSponsoredPaymentAsync <T>(Organization sponsoredOrg, OrganizationSponsorship sponsorship, SutProvider <T> sutProvider) { await sutProvider.GetDependency <IPaymentService>().Received(1) .RemoveOrganizationSponsorshipAsync(sponsoredOrg, sponsorship); await sutProvider.GetDependency <IOrganizationRepository>().Received(1).UpsertAsync(sponsoredOrg); if (sponsorship != null) { await sutProvider.GetDependency <IMailService>().Received(1) .SendFamiliesForEnterpriseSponsorshipRevertingEmailAsync(sponsoredOrg.BillingEmailAddress(), sponsorship.ValidUntil.GetValueOrDefault()); } }
public async Task RevokeSponsorshipAsync(OrganizationSponsorship sponsorship) { if (sponsorship == null) { throw new BadRequestException("You are not currently sponsoring an organization."); } if (sponsorship.LastSyncDate == null) { await base.DeleteSponsorshipAsync(sponsorship); } else { await MarkToDeleteSponsorshipAsync(sponsorship); } }
public async Task SetUpSponsorshipAsync(OrganizationSponsorship sponsorship, Organization sponsoredOrganization) { if (sponsorship == null) { throw new BadRequestException("No unredeemed sponsorship offer exists for you."); } var existingOrgSponsorship = await _organizationSponsorshipRepository .GetBySponsoredOrganizationIdAsync(sponsoredOrganization.Id); if (existingOrgSponsorship != null) { throw new BadRequestException("Cannot redeem a sponsorship offer for an organization that is already sponsored. Revoke existing sponsorship first."); } if (sponsorship.PlanSponsorshipType == null) { throw new BadRequestException("Cannot set up sponsorship without a known sponsorship type."); } // Do not allow self-hosted sponsorships that haven't been synced for > 0.5 year if (sponsorship.LastSyncDate != null && DateTime.UtcNow.Subtract(sponsorship.LastSyncDate.Value).TotalDays > 182.5) { await _organizationSponsorshipRepository.DeleteAsync(sponsorship); throw new BadRequestException("This sponsorship offer is more than 6 months old and has expired."); } // Check org to sponsor's product type var requiredSponsoredProductType = StaticStore.GetSponsoredPlan(sponsorship.PlanSponsorshipType.Value)?.SponsoredProductType; if (requiredSponsoredProductType == null || sponsoredOrganization == null || StaticStore.GetPlan(sponsoredOrganization.PlanType).Product != requiredSponsoredProductType.Value) { throw new BadRequestException("Can only redeem sponsorship offer on families organizations."); } await _paymentService.SponsorOrganizationAsync(sponsoredOrganization, sponsorship); await _organizationRepository.UpsertAsync(sponsoredOrganization); sponsorship.SponsoredOrganizationId = sponsoredOrganization.Id; sponsorship.OfferedToEmail = null; await _organizationSponsorshipRepository.UpsertAsync(sponsorship); }
public async Task SetUpSponsorship_TooLongSinceLastSync_ThrowsBadRequest(PlanType planType, Organization org, OrganizationSponsorship sponsorship, SutProvider <SetUpSponsorshipCommand> sutProvider) { org.PlanType = planType; sponsorship.LastSyncDate = DateTime.UtcNow.AddDays(-365); var exception = await Assert.ThrowsAsync <BadRequestException>(() => sutProvider.Sut.SetUpSponsorshipAsync(sponsorship, org)); Assert.Contains("This sponsorship offer is more than 6 months old and has expired.", exception.Message); await sutProvider.GetDependency <IOrganizationSponsorshipRepository>() .Received(1) .DeleteAsync(sponsorship); await AssertDidNotSetUpAsync(sutProvider); }
public OrganizationSponsorshipOfferTokenable(OrganizationSponsorship sponsorship) { if (string.IsNullOrWhiteSpace(sponsorship.OfferedToEmail)) { throw new ArgumentException("Invalid OrganizationSponsorship to create a token, OfferedToEmail is required", nameof(sponsorship)); } Email = sponsorship.OfferedToEmail; if (!sponsorship.PlanSponsorshipType.HasValue) { throw new ArgumentException("Invalid OrganizationSponsorship to create a token, PlanSponsorshipType is required", nameof(sponsorship)); } SponsorshipType = sponsorship.PlanSponsorshipType.Value; if (sponsorship.Id == default) { throw new ArgumentException("Invalid OrganizationSponsorship to create a token, Id is required", nameof(sponsorship)); } Id = sponsorship.Id; }
public async Task SendSponsorshipOfferAsync(Organization sponsoringOrg, OrganizationUser sponsoringOrgUser, OrganizationSponsorship sponsorship) { if (sponsoringOrg == null) { throw new BadRequestException("Cannot find the requested sponsoring organization."); } if (sponsoringOrgUser == null || sponsoringOrgUser.Status != OrganizationUserStatusType.Confirmed) { throw new BadRequestException("Only confirmed users can sponsor other organizations."); } if (sponsorship == null || sponsorship.OfferedToEmail == null) { throw new BadRequestException("Cannot find an outstanding sponsorship offer for this organization."); } await SendSponsorshipOfferAsync(sponsorship, sponsoringOrg.Name); }
public async Task ValidateSponsorshipAsync_Valid(PlanType planType, Organization sponsoredOrg, OrganizationSponsorship existingSponsorship, Organization sponsoringOrg, SutProvider <ValidateSponsorshipCommand> sutProvider) { sponsoringOrg.PlanType = planType; sponsoringOrg.Enabled = true; existingSponsorship.SponsoringOrganizationId = sponsoringOrg.Id; sutProvider.GetDependency <IOrganizationSponsorshipRepository>() .GetBySponsoredOrganizationIdAsync(sponsoredOrg.Id).Returns(existingSponsorship); sutProvider.GetDependency <IOrganizationRepository>().GetByIdAsync(sponsoredOrg.Id).Returns(sponsoredOrg); sutProvider.GetDependency <IOrganizationRepository>().GetByIdAsync(sponsoringOrg.Id).Returns(sponsoringOrg); var result = await sutProvider.Sut.ValidateSponsorshipAsync(sponsoredOrg.Id); Assert.True(result); await AssertDidNotRemoveSponsoredPaymentAsync(sutProvider); await AssertDidNotDeleteSponsorshipAsync(sutProvider); }
public async Task SyncOrganization(Guid organizationId, Guid cloudOrganizationId, OrganizationConnection billingSyncConnection) { if (!_globalSettings.EnableCloudCommunication) { throw new BadRequestException("Failed to sync instance with cloud - Cloud communication is disabled in global settings"); } if (!billingSyncConnection.Enabled) { throw new BadRequestException($"Billing Sync Key disabled for organization {organizationId}"); } if (string.IsNullOrWhiteSpace(billingSyncConnection.Config)) { throw new BadRequestException($"No Billing Sync Key known for organization {organizationId}"); } var billingSyncConfig = billingSyncConnection.GetConfig <BillingSyncConfig>(); if (billingSyncConfig == null || string.IsNullOrWhiteSpace(billingSyncConfig.BillingSyncKey)) { throw new BadRequestException($"Failed to get Billing Sync Key for organization {organizationId}"); } var organizationSponsorshipsDict = (await _organizationSponsorshipRepository.GetManyBySponsoringOrganizationAsync(organizationId)) .ToDictionary(i => i.SponsoringOrganizationUserId); if (!organizationSponsorshipsDict.Any()) { _logger.LogInformation($"No existing sponsorships to sync for organization {organizationId}"); return; } var syncedSponsorships = new List <OrganizationSponsorshipData>(); foreach (var orgSponsorshipsBatch in CoreHelpers.Batch(organizationSponsorshipsDict.Values, 1000)) { var response = await SendAsync <OrganizationSponsorshipSyncRequestModel, OrganizationSponsorshipSyncResponseModel>(HttpMethod.Post, "organization/sponsorship/sync", new OrganizationSponsorshipSyncRequestModel { BillingSyncKey = billingSyncConfig.BillingSyncKey, SponsoringOrganizationCloudId = cloudOrganizationId, SponsorshipsBatch = orgSponsorshipsBatch.Select(s => new OrganizationSponsorshipRequestModel(s)) }); if (response == null) { _logger.LogDebug("Organization sync failed for '{OrgId}'", organizationId); throw new BadRequestException("Organization sync failed"); } syncedSponsorships.AddRange(response.ToOrganizationSponsorshipSync().SponsorshipsBatch); } var sponsorshipsToDelete = syncedSponsorships.Where(s => s.CloudSponsorshipRemoved).Select(i => organizationSponsorshipsDict[i.SponsoringOrganizationUserId].Id); var sponsorshipsToUpsert = syncedSponsorships.Where(s => !s.CloudSponsorshipRemoved).Select(i => { var existingSponsorship = organizationSponsorshipsDict[i.SponsoringOrganizationUserId]; if (existingSponsorship != null) { existingSponsorship.LastSyncDate = i.LastSyncDate; existingSponsorship.ValidUntil = i.ValidUntil; existingSponsorship.ToDelete = i.ToDelete; } else { // shouldn't occur, added in case self hosted loses a sponsorship existingSponsorship = new OrganizationSponsorship { SponsoringOrganizationId = organizationId, SponsoringOrganizationUserId = i.SponsoringOrganizationUserId, FriendlyName = i.FriendlyName, OfferedToEmail = i.OfferedToEmail, PlanSponsorshipType = i.PlanSponsorshipType, LastSyncDate = i.LastSyncDate, ValidUntil = i.ValidUntil, ToDelete = i.ToDelete }; } return(existingSponsorship); }); if (sponsorshipsToDelete.Any()) { await _organizationSponsorshipRepository.DeleteManyAsync(sponsorshipsToDelete); } if (sponsorshipsToUpsert.Any()) { await _organizationSponsorshipRepository.UpsertManyAsync(sponsorshipsToUpsert); } }
private async Task <(IEnumerable <OrganizationSponsorshipData> data, IEnumerable <OrganizationSponsorship> toOffer)> DoSyncAsync(Organization sponsoringOrg, IEnumerable <OrganizationSponsorshipData> sponsorshipsData) { var existingSponsorshipsDict = (await _organizationSponsorshipRepository.GetManyBySponsoringOrganizationAsync(sponsoringOrg.Id)) .ToDictionary(i => i.SponsoringOrganizationUserId); var sponsorshipsToUpsert = new List <OrganizationSponsorship>(); var sponsorshipIdsToDelete = new List <Guid>(); var sponsorshipsToReturn = new List <OrganizationSponsorshipData>(); foreach (var selfHostedSponsorship in sponsorshipsData) { var requiredSponsoringProductType = StaticStore.GetSponsoredPlan(selfHostedSponsorship.PlanSponsorshipType)?.SponsoringProductType; if (requiredSponsoringProductType == null || StaticStore.GetPlan(sponsoringOrg.PlanType).Product != requiredSponsoringProductType.Value) { continue; // prevent unsupported sponsorships } if (!existingSponsorshipsDict.TryGetValue(selfHostedSponsorship.SponsoringOrganizationUserId, out var cloudSponsorship)) { if (selfHostedSponsorship.ToDelete && selfHostedSponsorship.LastSyncDate == null) { continue; // prevent invalid sponsorships in cloud. These should have been deleted by self hosted } if (OrgDisabledForMoreThanGracePeriod(sponsoringOrg)) { continue; // prevent new sponsorships from disabled orgs } cloudSponsorship = new OrganizationSponsorship { SponsoringOrganizationId = sponsoringOrg.Id, SponsoringOrganizationUserId = selfHostedSponsorship.SponsoringOrganizationUserId, FriendlyName = selfHostedSponsorship.FriendlyName, OfferedToEmail = selfHostedSponsorship.OfferedToEmail, PlanSponsorshipType = selfHostedSponsorship.PlanSponsorshipType, LastSyncDate = DateTime.UtcNow, }; } else { cloudSponsorship.LastSyncDate = DateTime.UtcNow; } if (selfHostedSponsorship.ToDelete) { if (cloudSponsorship.SponsoredOrganizationId == null) { sponsorshipIdsToDelete.Add(cloudSponsorship.Id); selfHostedSponsorship.CloudSponsorshipRemoved = true; } else { cloudSponsorship.ToDelete = true; } } sponsorshipsToUpsert.Add(cloudSponsorship); selfHostedSponsorship.ValidUntil = cloudSponsorship.ValidUntil; selfHostedSponsorship.LastSyncDate = DateTime.UtcNow; sponsorshipsToReturn.Add(selfHostedSponsorship); } var sponsorshipsToEmailOffer = sponsorshipsToUpsert.Where(s => s.Id == default).ToArray(); if (sponsorshipsToUpsert.Any()) { await _organizationSponsorshipRepository.UpsertManyAsync(sponsorshipsToUpsert); } if (sponsorshipIdsToDelete.Any()) { await _organizationSponsorshipRepository.DeleteManyAsync(sponsorshipIdsToDelete); } return(sponsorshipsToReturn, sponsorshipsToEmailOffer); }
protected async Task AssertDeletedSponsorshipAsync <T>(OrganizationSponsorship sponsorship, SutProvider <T> sutProvider) { await sutProvider.GetDependency <IOrganizationSponsorshipRepository>().Received(1) .DeleteAsync(sponsorship); }
public async Task <OrganizationSponsorship> CreateSponsorshipAsync(Organization sponsoringOrg, OrganizationUser sponsoringOrgUser, PlanSponsorshipType sponsorshipType, string sponsoredEmail, string friendlyName) { var sponsoringUser = await _userService.GetUserByIdAsync(sponsoringOrgUser.UserId.Value); if (sponsoringUser == null || string.Equals(sponsoringUser.Email, sponsoredEmail, System.StringComparison.InvariantCultureIgnoreCase)) { throw new BadRequestException("Cannot offer a Families Organization Sponsorship to yourself. Choose a different email."); } var requiredSponsoringProductType = StaticStore.GetSponsoredPlan(sponsorshipType)?.SponsoringProductType; if (requiredSponsoringProductType == null || sponsoringOrg == null || StaticStore.GetPlan(sponsoringOrg.PlanType).Product != requiredSponsoringProductType.Value) { throw new BadRequestException("Specified Organization cannot sponsor other organizations."); } if (sponsoringOrgUser == null || sponsoringOrgUser.Status != OrganizationUserStatusType.Confirmed) { throw new BadRequestException("Only confirmed users can sponsor other organizations."); } var existingOrgSponsorship = await _organizationSponsorshipRepository .GetBySponsoringOrganizationUserIdAsync(sponsoringOrgUser.Id); if (existingOrgSponsorship?.SponsoredOrganizationId != null) { throw new BadRequestException("Can only sponsor one organization per Organization User."); } var sponsorship = new OrganizationSponsorship { SponsoringOrganizationId = sponsoringOrg.Id, SponsoringOrganizationUserId = sponsoringOrgUser.Id, FriendlyName = friendlyName, OfferedToEmail = sponsoredEmail, PlanSponsorshipType = sponsorshipType, }; if (existingOrgSponsorship != null) { // Replace existing invalid offer with our new sponsorship offer sponsorship.Id = existingOrgSponsorship.Id; } try { await _organizationSponsorshipRepository.UpsertAsync(sponsorship); return(sponsorship); } catch { if (sponsorship.Id != default) { await _organizationSponsorshipRepository.DeleteAsync(sponsorship); } throw; } }
protected async Task CancelSponsorshipAsync(Organization sponsoredOrganization, OrganizationSponsorship sponsorship = null) { if (sponsoredOrganization != null) { await _paymentService.RemoveOrganizationSponsorshipAsync(sponsoredOrganization, sponsorship); await _organizationRepository.UpsertAsync(sponsoredOrganization); try { if (sponsorship != null) { await _mailService.SendFamiliesForEnterpriseSponsorshipRevertingEmailAsync( sponsoredOrganization.BillingEmailAddress(), sponsorship.ValidUntil ?? DateTime.UtcNow.AddDays(15)); } } catch (Exception e) { _logger.LogError("Error sending Family sponsorship removed email.", e); } } await base.DeleteSponsorshipAsync(sponsorship); }
public async Task RevokeSponsorship_SponsorshipNotRedeemed_DeletesSponsorship(OrganizationSponsorship sponsorship, SutProvider <CloudRevokeSponsorshipCommand> sutProvider) { sponsorship.SponsoredOrganizationId = null; await sutProvider.Sut.RevokeSponsorshipAsync(sponsorship); await AssertDeletedSponsorshipAsync(sponsorship, sutProvider); }