private static ISubscriptionRequest CreateAuthorizeDotNetSubscriptionRequest(SubscriptionRegistration registrationInformation)
{
// Subscription information
SubscriptionType selectedSubscriptionType = registrationInformation.AvailableSubscriptionTypes.First(st => st.SubscriptionTypeId == registrationInformation.SelectedSubscriptionTypeId);
return(CreateAuthorizeDotNetSubscriptionRequest(registrationInformation.CreditCard, selectedSubscriptionType));
}
public async Task PublishSubscribe_Event_Success(SupportedDatabaseTypes databaseType)
{
var scope = OverrideConfig.GetServiceCollection(databaseType)
.BuildServiceProvider()
.CreateScope();
var mqttClient = scope.ServiceProvider.GetRequiredService <MqttClient>();
var bus = scope.ServiceProvider.GetRequiredService <IBus>();
var repository = scope.ServiceProvider.GetRequiredService <IEventRepository>();
var dbConnection = scope.ServiceProvider.GetRequiredService <IDbConnection>();
await SubscriptionRegistration.SetupSubscriptions(bus);
mqttClient.Setup(scope.ServiceProvider);
var eventContract = new EventContract();
eventContract.PingPongs = 5;
await bus.Advanced.Topics.Publish(EventContract.Topic, eventContract);
await Tools.WaitUntilSuccess(async() =>
{
var selectedEvent = await repository.SelectEvent(dbConnection, eventContract.Id); // At some point, the event should have been sent through the message broker and handled by the message handler.
selectedEvent.Id.Should().Be(eventContract.Id); // Verify that the message handler has received and handled the event for the first time. The message handler will publish the event again, but having set the Stop event property to true.
selectedEvent.Stop.Should().BeTrue(); // Verify that the message handler published and handled the event again by marking the event as stopped.
});
await repository.DeleteEvent(dbConnection, eventContract.Id); // Finished with the event, delete it.
}
public ActionResult Subscribe(SubscriptionRegistration registrationInformation)
{
registrationInformation.AvailableSubscriptionTypes = _database.SubscriptionTypes.Include(st => st.SubscriptionFrequency).Where(st => st.IsAvailableToUsers && !st.IsAddOn);
registrationInformation.Countries = _database.Countries.AsEnumerable();
if (registrationInformation.SelectedSubscriptionTypeId == 0)
{
ModelState.AddModelError(string.Empty, "Please choose a subscription to continue.");
}
// If all credit card information has been supplied, then try to validate the request with Authorize.NET
if (ModelState.IsValid)
{
ISubscriptionGateway gateway = GetSubscriptionGateway();
ISubscriptionRequest subscriptionRequest = MembersController.CreateAuthorizeDotNetSubscriptionRequest(registrationInformation);
ISubscriptionRequest subscriptionResponse = null;
try
{
subscriptionResponse = gateway.CreateSubscription(subscriptionRequest);
}
catch (InvalidOperationException exception)
{
ModelState.AddModelError(string.Empty, exception.Message);
return(View(registrationInformation));
}
// If we reach this part of the code, we have successfully scheduled a subscription, make a note of it in our system
WebSite.Models.User currentUser = Authentication.GetCurrentUser();
DatabaseContext db = _database;
// Encrypt the credit card information of the user
registrationInformation.CreditCard.Encrypt();
// Construct a subscription for the user
Subscription userSubscription = new Subscription()
{
ActivationDate = DateTime.UtcNow,
AuthorizeNETSubscriptionId = subscriptionResponse.SubscriptionID,
CancellationDate = null,
SubscriptionTypeId = registrationInformation.SelectedSubscriptionTypeId,
CreditCard = registrationInformation.CreditCard
};
// Associate the subscription with the user
currentUser.AddSubscription(userSubscription);
db.SaveChanges();
return(this.RedirectToAction("Index"));
}
return(View(registrationInformation));
}
public async Task SetSubscriptionRegistrationAsync(
string subscriptionId,
SubscriptionRegistration subscriptionRegistration)
{
using (var ctx = new ResourceProviderEntities(this.connectionString))
{
ctx.SubscriptionRegistrations.AddOrUpdate(subscriptionRegistration);
await ctx.SaveChangesAsync();
}
}
public ActionResult Subscribe(SubscriptionRegistration registrationInformation, int userId, int day, int month, int year)
{
ViewBag.UserId = userId;
registrationInformation.AvailableSubscriptionTypes = _db.SubscriptionTypes.Include(o => o.SubscriptionFrequency);
registrationInformation.Countries = _db.Countries.AsEnumerable();
if (registrationInformation.SelectedSubscriptionTypeId == 0)
{
ModelState.AddModelError(string.Empty, "Please choose a subscription to continue.");
}
// If all credit card information has been supplied, then try to validate the request with Authorize.NET
if (ModelState.IsValid)
{
WebSite.Models.User user = _db.Users.Find(userId);
ISubscriptionGateway gateway = this.GetSubscriptionGateway();
ISubscriptionRequest subscriptionRequest = this.CreateAuthorizeDotNetSubscriptionRequest(registrationInformation, user, new DateTime(year, month, day));
ISubscriptionRequest subscriptionResponse = null;
try
{
subscriptionResponse = gateway.CreateSubscription(subscriptionRequest);
}
catch (InvalidOperationException exception)
{
ModelState.AddModelError(string.Empty, exception.Message);
return(View(registrationInformation));
}
// Encrypt the credit card information of the user
registrationInformation.CreditCard.Encrypt();
// Construct a subscription for the user
Subscription userSubscription = new Subscription()
{
ActivationDate = DateTime.UtcNow,
AuthorizeNETSubscriptionId = subscriptionResponse.SubscriptionID,
CancellationDate = null,
SubscriptionTypeId = registrationInformation.SelectedSubscriptionTypeId,
CreditCard = registrationInformation.CreditCard
};
// Associate the subscription with the user
user.AddSubscription(userSubscription);
_db.SaveChanges();
return(this.RedirectToAction("Index"));
}
return(View(registrationInformation));
}
public ActionResult Subscribe()
{
// Calculate the set of subscriptions available to the user
SubscriptionRegistration registration = new SubscriptionRegistration()
{
AvailableSubscriptionTypes = _database.SubscriptionTypes.Include(st => st.SubscriptionFrequency).Where(st => st.IsAvailableToUsers && !st.IsAddOn),
Countries = _database.Countries.AsEnumerable()
};
return(View(registration));
}
static void Purchase(Client client)
{
Console.Clear();
ShowAssortimentsList();
Console.WriteLine("*********************************\n" +
"Добавьте желаемую подписку по её номеру: ");
int choice = 0;
Subscription market = new Subscription();
using (var context = new NomadsContext())
{
while (choice == 0)
{
int.TryParse(Console.ReadLine(), out choice);
if (choice < 0 || choice > context.Subscriptions.Count())
{
choice = 0;
}
else
{
market = context.Subscriptions.FirstOrDefault(m => m.Id == choice);
break;
}
}
SubscriptionRegistration basket = new SubscriptionRegistration
{
ClientId = client.Id,
Client = client,
SubscriptionId = market.Id,
Subscription = market
};
context.SubscriptionRegistrations.Add(basket);
context.SaveChanges();
List <SubscriptionRegistration> baskets = new List <SubscriptionRegistration>();
Console.WriteLine("Просмотр подписки: ");
foreach (var b in context.SubscriptionRegistrations.ToList())
{
Console.WriteLine($"Клиент: {b.Client.Email}," +
$" Журнал: {b.Subscription.Name}." +
$" Цена: {b.Subscription.Price}." +
$" Подписка на {b.Subscription.Period} месяцев.");
baskets.Add(b);
}
}
}
public ActionResult Subscribe(int userId)
{
// Calculate the set of subscriptions available to the user
SubscriptionRegistration registration = new SubscriptionRegistration()
{
AvailableSubscriptionTypes = _db.SubscriptionTypes.Include(o => o.SubscriptionFrequency),
Countries = _db.Countries.AsEnumerable()
};
ViewBag.UserId = userId;
return(View(registration));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public async void Configure(
IApplicationBuilder app,
IHostingEnvironment env,
IApplicationLifetime lifetime,
ILoggerFactory loggerFactory,
IBus bus,
MqttClient mqttClient)
{
StartupLogger = loggerFactory.CreateLogger <Startup>();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
StartupLogger.LogInformation("Begin Application_Start");
lifetime.ApplicationStarted.Register(() => StartupLogger.LogInformation("End Application_Start"));
lifetime.ApplicationStopping.Register(() => StartupLogger.LogInformation("Start Application_Stop"));
lifetime.ApplicationStopped.Register(() => StartupLogger.LogInformation("End Application_Stop"));
var configuration = app.ApplicationServices.GetRequiredService <IConfiguration>();
if (configuration.GetValue("host:migrateDbSchema", true))
{
app.ApplicationServices.MigrateUpSchema();
StartupLogger.LogInformation("Finished database migration");
}
await SubscriptionRegistration.SetupSubscriptions(bus);
mqttClient.Setup(app.ApplicationServices);
app.UseHealthChecks("/status/health", new Microsoft.AspNetCore.Diagnostics.HealthChecks.HealthCheckOptions()
{
ResponseWriter = HealthCheckResponseWriter
});
app.UseMvc();
}
public async Task <IEnumerable <string> > CreateOrUpdateSubscriptionAsync(
string requestId,
string subscriptionId,
SubscriptionDescription model)
{
// The racing condition will be handled by two-steps updating
// Step 1: Update the subscription registration
var subscriptionRegistration = new SubscriptionRegistration
{
SubscriptionId = subscriptionId,
State = model.State.ToString(),
TenantId = model.Properties.TenantId,
RegistrationDate = model.RegistrationDate,
LocationPlacementId = model.Properties.LocationPlacementId ?? "n/a",
QuotaId = model.Properties.QuotaId ?? "n/a",
RegisteredFeatures = JsonConvert.SerializeObject(model.Properties.RegisteredFeatures) ?? "n/a"
};
await this.store.SetSubscriptionRegistrationAsync(
subscriptionId,
subscriptionRegistration);
// Step 2: Update the per-account state
var tenants = await this.tenantCacheClient.ListTenantsAsync(
requestId,
subscriptionId);
switch (model.State)
{
case SubscriptionState.Registered:
{
foreach (var tenant in tenants)
{
tenant.IsDisabled = false;
try
{
await this.tenantCacheClient.UpdateTenantAsync(
requestId,
tenant);
}
catch
{
// The account may be removed by some other concurrent action
}
}
}
break;
case SubscriptionState.Warned:
case SubscriptionState.Suspended:
{
foreach (var tenant in tenants)
{
tenant.IsDisabled = true;
try
{
await this.tenantCacheClient.UpdateTenantAsync(
requestId,
tenant);
}
catch
{
// The account may be removed by some other concurrent action
}
}
}
break;
case SubscriptionState.Deleted:
case SubscriptionState.Unregistered:
{
foreach (var tenant in tenants)
{
try
{
await this.tenantCacheClient.DeleteTenantAsync(
requestId,
subscriptionId,
tenant.ResourceGroupName,
tenant.AccountName);
}
catch
{
// The account may be removed by some other concurrent action
}
}
}
break;
default:
break;
}
return(tenants.Select(t => t.AccountName));
}
private ISubscriptionRequest CreateAuthorizeDotNetSubscriptionRequest(SubscriptionRegistration registrationInformation, WebSite.Models.User user, DateTime startsOn)
{
ISubscriptionRequest subscriptionRequest = SubscriptionRequest.CreateNew();
// Billing address information
string countryName = _db.Countries.Find(registrationInformation.CreditCard.BillingAddress.CountryId).Name;
subscriptionRequest.BillingAddress = new AuthorizeNet.Address()
{
City = registrationInformation.CreditCard.BillingAddress.City,
Country = countryName,
First = registrationInformation.CreditCard.CardholderFirstName,
Last = registrationInformation.CreditCard.CardholderLastName,
Phone = registrationInformation.CreditCard.BillingAddress.PhoneNumber,
State = registrationInformation.CreditCard.BillingAddress.ProvinceOrState,
Street =
registrationInformation.CreditCard.BillingAddress.AddressLine1 +
(!string.IsNullOrEmpty(registrationInformation.CreditCard.BillingAddress.AddressLine2) ?
(Environment.NewLine + registrationInformation.CreditCard.BillingAddress.AddressLine2) :
string.Empty)
,
Zip = registrationInformation.CreditCard.BillingAddress.PostalCode
};
// Subscription information
SubscriptionType selectedSubscriptionType = registrationInformation.AvailableSubscriptionTypes.First(st => st.SubscriptionTypeId == registrationInformation.SelectedSubscriptionTypeId);
subscriptionRequest.StartsOn = startsOn;
subscriptionRequest.Amount = selectedSubscriptionType.Price;
subscriptionRequest.SubscriptionName = selectedSubscriptionType.SubscriptionFrequency.Name + " Membership";
// Subscription interval
if (selectedSubscriptionType.SubscriptionFrequency.Name == PredefinedSubscriptionFrequencies.Monthly)
{
subscriptionRequest.BillingInterval = 1;
subscriptionRequest.BillingIntervalUnits = BillingIntervalUnits.Months;
}
else if (selectedSubscriptionType.SubscriptionFrequency.Name == PredefinedSubscriptionFrequencies.Quarterly)
{
subscriptionRequest.BillingInterval = 365 / 4;
subscriptionRequest.BillingIntervalUnits = BillingIntervalUnits.Days;
}
else if (selectedSubscriptionType.SubscriptionFrequency.Name == PredefinedSubscriptionFrequencies.Yearly)
{
subscriptionRequest.BillingInterval = 365;
subscriptionRequest.BillingIntervalUnits = BillingIntervalUnits.Days;
}
else
{
// TODO: Log Error! We should never hit this case.
}
// Credit card information
subscriptionRequest.CardCode = registrationInformation.CreditCard.CVV;
subscriptionRequest.CardExpirationMonth = registrationInformation.CreditCard.ExpirationMonth;
subscriptionRequest.CardExpirationYear = registrationInformation.CreditCard.ExpirationYear;
subscriptionRequest.CardNumber = registrationInformation.CreditCard.Number;
// Customer information
subscriptionRequest.CustomerEmail = user.EmailAddress;
subscriptionRequest.CustomerID = user.UserId.ToString();
return(subscriptionRequest);
}