public virtual OrganizationSignup ToOrganizationSignup(User user)
{
var orgSignup = new OrganizationSignup
{
Owner = user,
OwnerKey = Key,
Name = Name,
Plan = PlanType,
PaymentMethodType = PaymentMethodType,
PaymentToken = PaymentToken,
AdditionalSeats = AdditionalSeats,
MaxAutoscaleSeats = MaxAutoscaleSeats,
AdditionalStorageGb = AdditionalStorageGb.GetValueOrDefault(0),
PremiumAccessAddon = PremiumAccessAddon,
BillingEmail = BillingEmail,
BusinessName = BusinessName,
CollectionName = CollectionName,
TaxInfo = new TaxInfo
{
TaxIdNumber = TaxIdNumber,
BillingAddressLine1 = BillingAddressLine1,
BillingAddressLine2 = BillingAddressLine2,
BillingAddressCity = BillingAddressCity,
BillingAddressState = BillingAddressState,
BillingAddressPostalCode = BillingAddressPostalCode,
BillingAddressCountry = BillingAddressCountry,
},
};
Keys?.ToOrganizationSignup(orgSignup);
return(orgSignup);
}
public async Task <Tuple <Organization, OrganizationUser> > SignUpAsync(OrganizationSignup signup)
{
var plan = StaticStore.Plans.FirstOrDefault(p => p.Type == signup.Plan);
if (plan == null)
{
throw new BadRequestException("Plan not found.");
}
var organization = new Organization
{
Name = signup.Name,
UserId = signup.Owner.Id,
PlanType = plan.Type,
MaxUsers = plan.MaxUsers,
PlanTrial = plan.Trial.HasValue,
PlanPrice = plan.Trial.HasValue ? 0 : plan.Price,
PlanRenewalPrice = plan.Price,
Plan = plan.ToString(),
CreationDate = DateTime.UtcNow,
RevisionDate = DateTime.UtcNow
};
if (plan.Trial.HasValue)
{
organization.PlanRenewalDate = DateTime.UtcNow.Add(plan.Trial.Value);
}
else if (plan.Cycle != null)
{
organization.PlanRenewalDate = DateTime.UtcNow.Add(plan.Cycle(DateTime.UtcNow));
}
await _organizationRepository.CreateAsync(organization);
try
{
var orgUser = new OrganizationUser
{
OrganizationId = organization.Id,
UserId = signup.Owner.Id,
Email = signup.Owner.Email,
Key = signup.OwnerKey,
Type = Enums.OrganizationUserType.Owner,
Status = Enums.OrganizationUserStatusType.Confirmed,
CreationDate = DateTime.UtcNow,
RevisionDate = DateTime.UtcNow
};
await _organizationUserRepository.CreateAsync(orgUser);
return(new Tuple <Organization, OrganizationUser>(organization, orgUser));
}
catch
{
await _organizationRepository.DeleteAsync(organization);
throw;
}
}
public async Task <Tuple <Organization, OrganizationUser> > SignUpAsync(OrganizationSignup signup)
{
var organization = new Organization
{
Id = CoreHelpers.GenerateComb(),
Name = signup.Name,
BusinessName = signup.BusinessName,
ApiKey = CoreHelpers.SecureRandomString(30),
CreationDate = DateTime.UtcNow,
RevisionDate = DateTime.UtcNow
};
return(await SignUpAsync(organization, signup.Owner.Id, signup.OwnerKey, signup.CollectionName, true));
}
public OrganizationSignup ToOrganizationSignup(OrganizationSignup existingSignup)
{
if (string.IsNullOrWhiteSpace(existingSignup.PublicKey))
{
existingSignup.PublicKey = PublicKey;
}
if (string.IsNullOrWhiteSpace(existingSignup.PrivateKey))
{
existingSignup.PrivateKey = EncryptedPrivateKey;
}
return(existingSignup);
}
public Task <ProviderOrganization> CreateOrganizationAsync(Guid providerId, OrganizationSignup organizationSignup, User user) => throw new NotImplementedException();
public async Task <Tuple <Organization, OrganizationUser> > SignUpAsync(OrganizationSignup signup)
{
var plan = StaticStore.Plans.FirstOrDefault(p => p.Type == signup.Plan && !p.Disabled);
if (plan == null)
{
throw new BadRequestException("Plan not found.");
}
var customerService = new StripeCustomerService();
var subscriptionService = new StripeSubscriptionService();
StripeCustomer customer = null;
StripeSubscription subscription = null;
if (!plan.CanBuyAdditionalSeats && signup.AdditionalSeats > 0)
{
throw new BadRequestException("Plan does not allow additional users.");
}
if (plan.CanBuyAdditionalSeats && plan.MaxAdditionalSeats.HasValue &&
signup.AdditionalSeats > plan.MaxAdditionalSeats.Value)
{
throw new BadRequestException($"Selected plan allows a maximum of " +
$"{plan.MaxAdditionalSeats.GetValueOrDefault(0)} additional users.");
}
if (plan.Type == PlanType.Free)
{
var ownerExistingOrgCount =
await _organizationUserRepository.GetCountByFreeOrganizationAdminUserAsync(signup.Owner.Id);
if (ownerExistingOrgCount > 0)
{
throw new BadRequestException("You can only be an admin of one free organization.");
}
}
else
{
customer = await customerService.CreateAsync(new StripeCustomerCreateOptions
{
Description = signup.BusinessName,
Email = signup.BillingEmail,
SourceToken = signup.PaymentToken
});
var subCreateOptions = new StripeSubscriptionCreateOptions
{
Items = new List <StripeSubscriptionItemOption>
{
new StripeSubscriptionItemOption
{
PlanId = plan.StripePlanId,
Quantity = 1
}
}
};
if (signup.AdditionalSeats > 0)
{
subCreateOptions.Items.Add(new StripeSubscriptionItemOption
{
PlanId = plan.StripeSeatPlanId,
Quantity = signup.AdditionalSeats
});
}
try
{
subscription = await subscriptionService.CreateAsync(customer.Id, subCreateOptions);
}
catch (StripeException)
{
if (customer != null)
{
await customerService.DeleteAsync(customer.Id);
}
throw;
}
}
var organization = new Organization
{
Name = signup.Name,
BillingEmail = signup.BillingEmail,
BusinessName = signup.BusinessName,
PlanType = plan.Type,
Seats = (short)(plan.BaseSeats + signup.AdditionalSeats),
MaxSubvaults = plan.MaxSubvaults,
Plan = plan.Name,
StripeCustomerId = customer?.Id,
StripeSubscriptionId = subscription?.Id,
CreationDate = DateTime.UtcNow,
RevisionDate = DateTime.UtcNow
};
try
{
await _organizationRepository.CreateAsync(organization);
var orgUser = new OrganizationUser
{
OrganizationId = organization.Id,
UserId = signup.Owner.Id,
Key = signup.OwnerKey,
Type = OrganizationUserType.Owner,
Status = OrganizationUserStatusType.Confirmed,
AccessAllSubvaults = true,
CreationDate = DateTime.UtcNow,
RevisionDate = DateTime.UtcNow
};
await _organizationUserRepository.CreateAsync(orgUser);
// push
await _pushService.PushSyncOrgKeysAsync(signup.Owner.Id);
return(new Tuple <Organization, OrganizationUser>(organization, orgUser));
}
catch
{
if (subscription != null)
{
await subscriptionService.CancelAsync(subscription.Id, false);
}
if (customer != null)
{
var chargeService = new StripeChargeService();
var charges = await chargeService.ListAsync(new StripeChargeListOptions { CustomerId = customer.Id });
if (charges?.Data != null)
{
var refundService = new StripeRefundService();
foreach (var charge in charges.Data.Where(c => !c.Refunded))
{
await refundService.CreateAsync(charge.Id);
}
}
await customerService.DeleteAsync(customer.Id);
}
if (organization.Id != default(Guid))
{
await _organizationRepository.DeleteAsync(organization);
}
throw;
}
}
