public async Task ReinstateSubscriptionAsync(Guid organizationId) { var organization = await _organizationRepository.GetByIdAsync(organizationId); if (organization == null) { throw new NotFoundException(); } if (string.IsNullOrWhiteSpace(organization.StripeSubscriptionId)) { throw new BadRequestException("Organization has no subscription."); } var subscriptionService = new StripeSubscriptionService(); var sub = await subscriptionService.GetAsync(organization.StripeSubscriptionId); if (sub == null) { throw new BadRequestException("Organization subscription was not found."); } if (sub.Status != "active" || !sub.CanceledAt.HasValue) { throw new BadRequestException("Organization subscription is not marked for cancellation."); } // Just touch the subscription. var updatedSub = await subscriptionService.UpdateAsync(sub.Id, new StripeSubscriptionUpdateOptions { }); if (updatedSub.CanceledAt.HasValue) { throw new BadRequestException("Unable to reinstate subscription."); } }
public StripeSubscription CreateSubscription(PurchaseInformation info, string customerIdOfStripe) { try { var customer = new StripeCustomerUpdateOptions(); customer.SourceCard = new SourceCard() { Number = info.CC_number, ExpirationYear = Convert.ToInt32(info.ExpireYear), ExpirationMonth = Convert.ToInt32(info.ExpireMonth), Cvc = info.CCVCode, Name = info.NameOnCard }; if (!string.IsNullOrEmpty(info.Coupon)) { customer.Coupon = info.Coupon; } var customerService = new StripeCustomerService(); StripeCustomer stripeCustomer = customerService.Update(customerIdOfStripe, customer); var subscriptionService = new StripeSubscriptionService(); StripeSubscription stripeSubscription = subscriptionService.Create(customerIdOfStripe, info.PlanId); // optional StripeSubscriptionCreateOptions return(stripeSubscription); } catch (Exception ex) { throw ex; } }
public StripeSubscriptionServiceTest() { this.service = new StripeSubscriptionService(); this.createOptions = new StripeSubscriptionCreateOptions() { Items = new List <StripeSubscriptionItemOption> { new StripeSubscriptionItemOption { PlanId = "plan_123", Quantity = 2 }, new StripeSubscriptionItemOption { PlanId = "plan_124", Quantity = 3 }, }, }; this.updateOptions = new StripeSubscriptionUpdateOptions() { Metadata = new Dictionary <string, string>() { { "key", "value" }, }, }; this.listOptions = new StripeSubscriptionListOptions() { Limit = 1, }; }
public async Task ReinstateSubscriptionAsync(ISubscriber subscriber) { if (subscriber == null) { throw new ArgumentNullException(nameof(subscriber)); } if (string.IsNullOrWhiteSpace(subscriber.GatewaySubscriptionId)) { throw new GatewayException("No subscription."); } var subscriptionService = new StripeSubscriptionService(); var sub = await subscriptionService.GetAsync(subscriber.GatewaySubscriptionId); if (sub == null) { throw new GatewayException("Subscription was not found."); } if ((sub.Status != "active" && sub.Status != "trialing") || !sub.CanceledAt.HasValue) { throw new GatewayException("Subscription is not marked for cancellation."); } // Just touch the subscription. var updatedSub = await subscriptionService.UpdateAsync(sub.Id, new StripeSubscriptionUpdateOptions { }); if (updatedSub.CanceledAt.HasValue) { throw new GatewayException("Unable to reinstate subscription."); } }
public creating_and_updating_subscriptions_with_manual_invoicing() { var customerService = new StripeCustomerService(Cache.ApiKey); var subscriptionService = new StripeSubscriptionService(Cache.ApiKey); var CustomerCreateOptions = new StripeCustomerCreateOptions { Email = "*****@*****.**", }; var Customer = customerService.Create(CustomerCreateOptions); var SubscriptionCreateOptions = new StripeSubscriptionCreateOptions { Billing = StripeBilling.SendInvoice, DaysUntilDue = 7, PlanId = Cache.GetPlan("silver").Id }; SubscriptionCreated = subscriptionService.Create(Customer.Id, SubscriptionCreateOptions); var SubscriptionUpdateOptions = new StripeSubscriptionUpdateOptions { DaysUntilDue = 2, }; SubscriptionUpdated = subscriptionService.Update(SubscriptionCreated.Id, SubscriptionUpdateOptions); }
public async Task <BillingInfo.BillingInvoice> GetUpcomingInvoiceAsync(ISubscriber subscriber) { if (!string.IsNullOrWhiteSpace(subscriber.GatewaySubscriptionId)) { var subscriptionService = new StripeSubscriptionService(); var invoiceService = new StripeInvoiceService(); var sub = await subscriptionService.GetAsync(subscriber.GatewaySubscriptionId); if (sub != null) { if (!sub.CanceledAt.HasValue && !string.IsNullOrWhiteSpace(subscriber.GatewayCustomerId)) { try { var upcomingInvoice = await invoiceService.UpcomingAsync(subscriber.GatewayCustomerId); if (upcomingInvoice != null) { return(new BillingInfo.BillingInvoice(upcomingInvoice)); } } catch (StripeException) { } } } } return(null); }
public void CancelSubscription() { Helpers.SslSecurity.Callback(); var customerDetails = GetSavedCustomerStripeDetails(); if (customerDetails != null) { var subscriptionService = new StripeSubscriptionService(Helpers.SiteInfo.StripeAPISecretKey); subscriptionService.Cancel(customerDetails.Item1, customerDetails.Item2); } using (var db = InitializeSettings.DbFactory) { var data = db.Get <Majorsilence.Vpn.Poco.Users>(_userId); data.StripeSubscriptionId = ""; db.Update(data); this.email.SendMail_BackgroundThread("Your vpn account subscription has been cancelled. " + "You will not be billed again. You will continue to have access until your current payment expires.", "VPN Account Subscription Cancelled", data.Email, true, null, Majorsilence.Vpn.Logic.Email.EmailTemplates.Generic); } if (customerDetails == null) { throw new Exceptions.InvalidDataException("Attempting to cancel an account but the customer does not have any stripe details. Only removed from database. Nothing removed from stripe."); } }
public StripeSubscription SubscribeToPlan(ApplicationUser dbUser, string stripeToken, string planToSubscribeTo) { StripeCustomer customer = CreateStripeCustomer(dbUser, stripeToken); var currentSubscriptionId = String.Empty; if (customer.Subscriptions != null && customer.Subscriptions.TotalCount > 0) { currentSubscriptionId = customer.Subscriptions.Data[0].Id; } var service = new StripeSubscriptionService(); StripeSubscription subscription = null; if (String.IsNullOrEmpty(currentSubscriptionId)) { subscription = AddNewUserSubscription(customer.Id, planToSubscribeTo, service, dbUser); } else if (!planToSubscribeTo.Contains("Free")) { subscription = UpdateUserSubscription(customer.Id, currentSubscriptionId, planToSubscribeTo, service, dbUser); } else { CancleCustomerSubscription(dbUser); } return(subscription); }
public void CancelSubscription() { var user = AuthHelper.GetCurrentUser(); var usermanager = AuthHelper.GetUserManager(); try { var cust = new StripeCustomerService().Get(user.StripeCustomerId); if (cust != null) { var sub_svc = new StripeSubscriptionService(); var sub = sub_svc.Get(cust.Id, cust.StripeSubscriptionList.Data[0].Id); sub_svc.Cancel(cust.Id, sub.Id, true); } else { throw new ApplicationException("Could not find the customer in stripe to change the plan"); } } catch (Exception ex) { throw ex; } }
public IViewComponentResult Invoke(int numberOfItems) { var user = GetCurrentUserAsync(); if (!string.IsNullOrEmpty(user.StripeCustomerId)) { var customerService = new StripeSubscriptionService(_stripeSettings.Value.SecretKey); var subscriptions = customerService.List(user.StripeCustomerId); var customerSubscription = new CustomerPaymentViewModel { UserName = user.Email, Subscriptions = subscriptions.Select(s => new CustomerSubscriptionViewModel { Id = s.Id, Name = s.StripePlan.Name, Amount = s.StripePlan.Amount, Currency = s.StripePlan.Currency, Status = s.Status }).ToList() }; return(View("View", customerSubscription)); } var subscription = new CustomerPaymentViewModel { UserName = user.Email, Subscriptions = new List <CustomerSubscriptionViewModel>() }; return(View(subscription)); }
public usage_record_fixture() { var subOptions = new StripeSubscriptionCreateOptions { Items = new List <StripeSubscriptionItemOption> { new StripeSubscriptionItemOption { PlanId = Cache.GetPlan("Metered Plan", "metered").Id } } }; var service = new StripeSubscriptionService(Cache.ApiKey); var customer_id = Cache.GetCustomer().Id; var subscription = service.Create(customer_id, subOptions); var subscription_item_id = subscription.Items.Data[0].Id; UsageRecordCreateOptions = new StripeUsageRecordCreateOptions() { Action = "increment", SubscriptionItem = subscription_item_id, Timestamp = DateTime.Now, Quantity = 2000 }; var usageRecordService = new StripeUsageRecordService(Cache.ApiKey); UsageRecord = usageRecordService.Create(UsageRecordCreateOptions); }
public async Task CancelAndRecoverChargesAsync(ISubscriber subscriber) { if (!string.IsNullOrWhiteSpace(subscriber.GatewaySubscriptionId)) { var subscriptionService = new StripeSubscriptionService(); await subscriptionService.CancelAsync(subscriber.GatewaySubscriptionId, false); } if (string.IsNullOrWhiteSpace(subscriber.GatewayCustomerId)) { return; } var chargeService = new StripeChargeService(); var charges = await chargeService.ListAsync(new StripeChargeListOptions { CustomerId = subscriber.GatewayCustomerId }); if (charges?.Data != null) { var refundService = new StripeRefundService(); foreach (var charge in charges.Data.Where(c => !c.Refunded)) { await refundService.CreateAsync(charge.Id); } } var customerService = new StripeCustomerService(); await customerService.DeleteAsync(subscriber.GatewayCustomerId); }
private static bool ChangeSubscription(StripeSubscription subscription, string option) { try { var subscriptionService = new StripeSubscriptionService(); var subscriptionToChange = (Subscriptions)(int.Parse(option)); var actualSubscription = (Subscriptions)Enum.Parse(typeof(Subscriptions), subscription.Items.Data.First().Plan.Id); var isUpgrade = subscriptionToChange > actualSubscription ? true : false; var updateSubscription = new StripeSubscriptionUpdateOptions() { Items = new List <StripeSubscriptionItemUpdateOption>() { new StripeSubscriptionItemUpdateOption() { Id = subscription.Items.Data.First().Id, PlanId = subscriptionToChange.ToString() } }, Prorate = isUpgrade }; StripeSubscription updatedSubscription = subscriptionService.Update(subscription.Id, updateSubscription); return(true); } catch (Exception ex) { Console.WriteLine($"An error ocurred while updating your subscription.\nError: { ex.Message }"); return(false); } }
public subscription_fixture() { SubscriptionCreateOptions = new StripeSubscriptionCreateOptions { Items = new List <StripeSubscriptionItemOption> { new StripeSubscriptionItemOption { PlanId = Cache.GetPlan().Id, Quantity = 1 }, new StripeSubscriptionItemOption { PlanId = Cache.GetPlan2().Id, Quantity = 2 } } }; var service = new StripeSubscriptionService(Cache.ApiKey); Subscription = service.Create(Cache.GetCustomer().Id, SubscriptionCreateOptions); SubscriptionUpdateOptions = new StripeSubscriptionUpdateOptions { Items = new List <StripeSubscriptionItemUpdateOption> { new StripeSubscriptionItemUpdateOption { Id = Subscription.Items.Data[0].Id, Deleted = true }, new StripeSubscriptionItemUpdateOption { Id = Subscription.Items.Data[1].Id, Quantity = 5 } } }; SubscriptionUpdated = service.Update(Subscription.Id, SubscriptionUpdateOptions); }
public async Task CancelSubscriptionAsync(Guid organizationId, bool endOfPeriod = false) { var organization = await _organizationRepository.GetByIdAsync(organizationId); if (organization == null) { throw new NotFoundException(); } if (string.IsNullOrWhiteSpace(organization.StripeSubscriptionId)) { throw new BadRequestException("Organization has no subscription."); } var subscriptionService = new StripeSubscriptionService(); var sub = await subscriptionService.GetAsync(organization.StripeSubscriptionId); if (sub == null) { throw new BadRequestException("Organization subscription was not found."); } if (sub.CanceledAt.HasValue) { throw new BadRequestException("Organization subscription is already canceled."); } var canceledSub = await subscriptionService.CancelAsync(sub.Id, endOfPeriod); if (!canceledSub.CanceledAt.HasValue) { throw new BadRequestException("Unable to cancel subscription."); } }
public static bool UnSubscribe(string CustId) { var subsService = new StripeSubscriptionService(); StripeList <StripeSubscription> activeSub = subsService.List(new StripeSubscriptionListOptions() { CustomerId = CustId, Limit = 10 }); try { if (activeSub.Count() > 0) { foreach (var sub in activeSub) { StripeSubscription subs = subsService.Cancel(sub.Id); } } return(true); } catch (Exception ex) { return(false); } }
static void Main(string[] args) { // Set Stripe Api Key StripeConfiguration.SetApiKey(AppConfiguration.StripeApiKey); using (var subscriptionBookingRepository = new SubscriptionBookingRepository()) { var subscriptionBookingList = subscriptionBookingRepository.SubscriptionBookingsList.Where(sb => ids.Contains(sb.Id)).ToList(); // Each Subscription Bookings subscriptionBookingList.ForEach(subscriptionBookings => { var customerInfos = subscriptionBookingRepository.CustomerInfoList .FirstOrDefault(ci => ci.CustomerId == subscriptionBookings.CustomerId); // Customer Infos if (customerInfos != null) { var subscriptionService = new StripeSubscriptionService(); StripeSubscription subscription = subscriptionService.Get(subscriptionBookings.StripeSubscriptionId); DateTime?canceledDate = subscription.CanceledAt; if (canceledDate.HasValue) { subscriptionBookings.CancelDate = canceledDate; } } }); subscriptionBookingRepository.UpdateSubscriptionBookingCanceledDate(subscriptionBookingList); Console.WriteLine("Done!!!"); Console.ReadLine(); } }
public int CancelSubscription(string userMail, string plansId) { StripeConfiguration.SetApiKey("sk_test_YskwifolV97dD2Iu0v8YgDt5"); var customerService = new StripeCustomerService(); StripeList <StripeCustomer> customerItems = customerService.List( new StripeCustomerListOptions() { Limit = 300 } ); bool found = false; var customer = new StripeCustomer(); foreach (StripeCustomer cus in customerItems) { if (cus.Email == userMail) { found = true; customer = cus; break; } } if (found) { var subscriptionService = new StripeSubscriptionService(); StripeList <StripeSubscription> response = subscriptionService.List(new StripeSubscriptionListOptions { Limit = 3333 }); found = false; var subscript = new StripeSubscription(); foreach (StripeSubscription subs in response) { if (subs.CustomerId == customer.Id && subs.StripePlan.Id == plansId) { found = true; subscript = subs; break; } } if (found) { StripeSubscription subscription = subscriptionService.Cancel(subscript.Id, new StripeSubscriptionCancelOptions()); } } return(0); }
public ActionResult ManageSubscription() { var model = new ManageSubscriptionViewModel(); try { //GetUptodate plan prices from stripe var planService = new StripePlanService(SensativeInformation.StripeKeys.SecretKey); var ordPlan = planService.Get(StaticIdentifiers.OrdinaryMemberPlanId); var socialPlan = planService.Get(StaticIdentifiers.SocialMemberPlanId); var patronPlan = planService.Get(StaticIdentifiers.PatronPlanId); if (ordPlan != null) { model.OrdinaryPrice = (ordPlan.Amount / 100m).ToString("N"); } if (socialPlan != null) { model.SocialPrice = (socialPlan.Amount / 100m).ToString("N"); } if (patronPlan != null) { model.PatronPrice = (patronPlan.Amount / 100m).ToString("N"); } } catch (StripeException e) { _log.Error($"There was a stripe error whilst trying to load the current subscriptions prices for the manage membership page. The error was {e.Message}."); } try { var stripeAccountId = new Member(Members.GetCurrentMember()).StripeUserId; var dm = new DataManager(); if (stripeAccountId.IsNotNullOrEmpty()) { model.IsStripeUser = true; model.HasExistingSubscription = false; //Get plan status var subscriptionService = new StripeSubscriptionService(SensativeInformation.StripeKeys.SecretKey); var listOption = new StripeSubscriptionListOptions { CustomerId = stripeAccountId }; var stripeSubscriptions = subscriptionService.List(listOption); if (stripeSubscriptions != null && stripeSubscriptions.Any()) { model.IsOrdinaryMember = stripeSubscriptions.Any(m => m.StripePlan.Id == StaticIdentifiers.OrdinaryMemberPlanId && m.Status == StripeSubscriptionStatuses.Active); model.IsSocialMember = stripeSubscriptions.Any(m => m.StripePlan.Id == StaticIdentifiers.SocialMemberPlanId && m.Status == StripeSubscriptionStatuses.Active); model.IsPatron = stripeSubscriptions.Any(m => m.StripePlan.Id == StaticIdentifiers.PatronPlanId && m.Status == StripeSubscriptionStatuses.Active); model.HasExistingSubscription = stripeSubscriptions.Any(m => m.Status == StripeSubscriptionStatuses.Active); } } } catch (StripeException e) { _log.Error($"There was a stripe error whilst trying to load the current subscriptions for the managemembership page for user {Members.GetCurrentMember().Name} and id {Members.GetCurrentMember().Id}. The error was {e.Message}."); } return(PartialView("ManageSubscription", model)); }
public void CreateSubscription(CustomerInfo customerInfo, string planId) { string customerId = GetCustomerId(customerInfo); StripeSubscriptionService subscriptionService = new StripeSubscriptionService(); StripeSubscription stripeSubscription = subscriptionService.Create(customerId, planId); PaymentId = stripeSubscription.Id; }
public StripeSubscriptionServiceFacade() { #if DEBUG _stripeSubscriptionService = new StripeSubscriptionService(Config.PaymentProviderConfig.TestKey); #else _stripeSubscriptionService = new StripeSubscriptionService(Config.PaymentProviderConfig.ProductionKey); #endif }
public IActionResult Delete(string subscriptionId) { var subscriptionService = new StripeSubscriptionService(_stripeSettings.Value.SecretKey); var result = subscriptionService.Cancel(subscriptionId); SetTempMessage($"You have successfully deleted '{result.StripePlan.Name}' subscription"); return(RedirectToAction("Index", "Manage")); }
public string SubscribeAccountPlan(string planId, string customerId) { var subscriptionService = new StripeSubscriptionService(); StripeSubscription stripeSubscription = subscriptionService.Create(customerId, planId); return(null); // optional StripeSubscriptionUpdateOptions return null; }
public Subscription CancelSubscription(int companyId) { var subscription = GetSubscription(companyId); var subscriptionService = new StripeSubscriptionService(); subscriptionService.Cancel(subscription.StripeCustomerId, subscription.StripeSubscriptionId); // optional cancelAtPeriodEnd flag return(subscription); }
public void RemoveCustomerFromSubscription(string customerId) { var customerService = new StripeCustomerService(Constants.StripeSecretKey); var stripeCustomer = customerService.Get(customerId); var subscriptionId = stripeCustomer.StripeSubscriptionList.Data.Select(s => s.Id).Distinct().FirstOrDefault(); var subscriptionService = new StripeSubscriptionService(Constants.StripeSecretKey); subscriptionService.Cancel(customerId, subscriptionId); }
public void UnsubscribePlan(string customerId) { var customerService = new StripeCustomerService(); StripeCustomer stripeCustomer = customerService.Get(customerId); var subscriptionId = stripeCustomer.Subscriptions.First().Id; var subscriptionService = new StripeSubscriptionService(); subscriptionService.Cancel(subscriptionId); }
public void CancelPayment(string email) { StripeCustomerService customerService = new StripeCustomerService(); IEnumerable <StripeCustomer> response = customerService.List(); string customerId = response.FirstOrDefault(m => m.Email == email).Id; StripeSubscriptionService subscriptionService = new StripeSubscriptionService(); subscriptionService.Cancel(customerId, PaymentId); customerService.Delete(customerId); }
public async Task PurchasePremiumAsync(User user, string paymentToken, short additionalStorageGb) { var customerService = new StripeCustomerService(); var customer = await customerService.CreateAsync(new StripeCustomerCreateOptions { Description = user.Name, Email = user.Email, SourceToken = paymentToken }); var subCreateOptions = new StripeSubscriptionCreateOptions { CustomerId = customer.Id, Items = new List <StripeSubscriptionItemOption>(), Metadata = new Dictionary <string, string> { ["userId"] = user.Id.ToString() } }; subCreateOptions.Items.Add(new StripeSubscriptionItemOption { PlanId = PremiumPlanId, Quantity = 1 }); if (additionalStorageGb > 0) { subCreateOptions.Items.Add(new StripeSubscriptionItemOption { PlanId = StoragePlanId, Quantity = additionalStorageGb }); } StripeSubscription subscription = null; try { var subscriptionService = new StripeSubscriptionService(); subscription = await subscriptionService.CreateAsync(subCreateOptions); } catch (StripeException) { await customerService.DeleteAsync(customer.Id); throw; } user.Gateway = Enums.GatewayType.Stripe; user.GatewayCustomerId = customer.Id; user.GatewaySubscriptionId = subscription.Id; user.Premium = true; user.PremiumExpirationDate = subscription.CurrentPeriodEnd; }
static void Main(string[] args) { // Set Stripe Api Key StripeConfiguration.SetApiKey(AppConfiguration.StripeApiKey); using (var subscriptionBookingRepository = new SubscriptionBookingRepository()) { var subscriptionBookingList = subscriptionBookingRepository.SubscriptionBookingsList.Where(sb => ids.Contains(sb.Id)).ToList(); // Each Subscription Bookings subscriptionBookingList.ForEach(subscriptionBookings => { var customerInfos = subscriptionBookingRepository.CustomerInfoList .FirstOrDefault(ci => ci.CustomerId == subscriptionBookings.CustomerId); // Customer Infos if (customerInfos != null) { var subscriptionService = new StripeSubscriptionService(); StripeSubscription subscription = subscriptionService.Get(subscriptionBookings.StripeSubscriptionId); DateTime?canceledDate = subscription.CanceledAt; if (canceledDate.HasValue) { subscriptionBookings.CancelDate = canceledDate; } switch (subscription.Status) { case "past_due": case "unpaid": subscriptionBookings.Status = (int)Enums.SubscriptionBookingStatus.Suspended; break; case "active": // Set Date of Discounts //subscriptionBookings.Status = (int)Enums.SubscriptionBookingStatus.Active; break; case "canceled": //subscriptionBookings.Status = (int)Enums.SubscriptionBookingStatus.End; break; default: //trialing break; } } }); subscriptionBookingRepository.UpdateSubscriptionBookingCanceledDate(subscriptionBookingList); Console.WriteLine("Done!!!"); Console.ReadLine(); } }
protected override void DeleteModels(ICollection <Organization> organizations) { var currentUser = ExceptionlessUser; foreach (var organization in organizations) { Log.Info().Message("User {0} deleting organization {1} with {2} total events.", currentUser.Id, organization.Id, organization.TotalEventCount).Write(); if (!String.IsNullOrEmpty(organization.StripeCustomerId)) { Log.Info().Message("Canceling stripe subscription for the organization '{0}' with Id: '{1}'.", organization.Name, organization.Id).Write(); var subscriptionService = new StripeSubscriptionService(); var subs = subscriptionService.List(organization.StripeCustomerId).Where(s => !s.CanceledAt.HasValue); foreach (var sub in subs) { subscriptionService.Cancel(organization.StripeCustomerId, sub.Id); } } List <User> users = _userRepository.GetByOrganizationId(organization.Id).ToList(); foreach (User user in users) { // delete the user if they are not associated to any other organizations and they are not the current user if (user.OrganizationIds.All(oid => String.Equals(oid, organization.Id)) && !String.Equals(user.Id, currentUser.Id)) { Log.Info().Message("Removing user '{0}' as they do not belong to any other organizations.", user.Id, organization.Name, organization.Id).Write(); _userRepository.Remove(user.Id); } else { Log.Info().Message("Removing user '{0}' from organization '{1}' with Id: '{2}'", user.Id, organization.Name, organization.Id).Write(); user.OrganizationIds.Remove(organization.Id); _userRepository.Save(user); } } List <Project> projects = _projectRepository.GetByOrganizationId(organization.Id).ToList(); if (User.IsInRole(AuthorizationRoles.GlobalAdmin) && projects.Count > 0) { foreach (Project project in projects) { Log.Info().Message("Resetting all project data for project '{0}' with Id: '{1}'.", project.Name, project.Id).Write(); _projectController.ResetDataAsync(project.Id).Wait(); } Log.Info().Message("Deleting all projects for organization '{0}' with Id: '{1}'.", organization.Name, organization.Id).Write(); _projectRepository.Save(projects); } Log.Info().Message("Deleting organization '{0}' with Id: '{1}'.", organization.Name, organization.Id).Write(); base.DeleteModels(new[] { organization }); } }