public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new TechAndToolsUser
{
UserName = Input.Username,
Email = Input.Email,
FirstName = Input.FirstName,
LastName = Input.LastName,
ShoppingCart = new ShoppingCart(),
CreatedOn = DateTime.UtcNow
};
var resultCreate = await userManager.CreateAsync(user, Input.Password);
if (resultCreate.Succeeded)
{
logger.LogInformation("User created a new account with password.");
var code = await userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await userManager.AddToRoleAsync(user, GlobalConstants.UserRole);
await emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
await signInManager.SignInAsync(user, isPersistent : false);
var cart = SessionHelper.GetObjectFromJson <List <ShoppingCartProductViewModel> >(HttpContext.Session, TechAndTools.Commons.Constants.GlobalConstants.SessionShoppingCartKey);
if (cart != null)
{
foreach (var product in cart)
{
await shoppingCartService.AddToShoppingCartAsync(product.Id, Input.Email, product.Quantity);
}
HttpContext.Session.Remove(GlobalConstants.SessionShoppingCartKey);
}
return(LocalRedirect(returnUrl));
}
foreach (var error in resultCreate.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async void GetAllByUserId_ShouldReturnAllUsersAddressesByUserId()
{
var options = new DbContextOptionsBuilder <TechAndToolsDbContext>()
.UseInMemoryDatabase(databaseName: "GetAllByUserId_ShouldReturnAllUsersAddressesByUserId")
.Options;
TechAndToolsDbContext context = new TechAndToolsDbContext(options);
await SeedData(context);
IUserService userService = new UserService(context);
IAddressService addressService = new AddressService(context, userService);
TechAndToolsUser testUser = new TechAndToolsUser
{
Id = "testId",
UserName = "******",
Email = "testEmail"
};
await context.AddAsync(testUser);
await context.SaveChangesAsync();
int expectedResult = context.Addresses.Where(x => x.TechAndToolsUserId == "testId").ToList().Count;
int actualResult = addressService.GetAllByUserId("testId").ToList().Count;
Assert.Equal(expectedResult, actualResult);
}
public async void CreateAsync_WithIncorrectUserShouldThrowException()
{
var options = new DbContextOptionsBuilder <TechAndToolsDbContext>()
.UseInMemoryDatabase(databaseName: "CreateAsync_WithIncorrectUserShouldThrowException")
.Options;
TechAndToolsDbContext context = new TechAndToolsDbContext(options);
IUserService userService = new UserService(context);
IAddressService addressService = new AddressService(context, userService);
TechAndToolsUser testUser = new TechAndToolsUser
{
UserName = "******",
Email = "testEmail"
};
await context.AddAsync(testUser);
await context.SaveChangesAsync();
AddressServiceModel serviceModel = new AddressServiceModel
{
Id = 1,
City = "CityTest1",
CityAddress = "CityAddressTest1",
PostCode = 9000,
TechAndToolsUserId = Guid.NewGuid().ToString()
};
await Assert.ThrowsAsync <ArgumentNullException>(() => addressService.CreateAsync(serviceModel, "wrongUsername"));
}
public async Task SeedAsync(TechAndToolsDbContext dbContext, IServiceProvider serviceProvider)
{
var userManager = serviceProvider.GetRequiredService <UserManager <TechAndToolsUser> >();
var hasAdmin = userManager.GetUsersInRoleAsync(GlobalConstants.AdminRole).Result.Any();
if (!hasAdmin)
{
TechAndToolsUser admin = new TechAndToolsUser
{
UserName = GlobalConstants.AdminUsername,
FirstName = GlobalConstants.AdminFirstName,
LastName = GlobalConstants.AdminLastName,
Email = GlobalConstants.AdminEmail,
CreatedOn = DateTime.UtcNow,
PhoneNumber = GlobalConstants.AdminPhoneNumber,
PhoneNumberConfirmed = true,
EmailConfirmed = true,
ShoppingCart = new ShoppingCart()
};
var password = GlobalConstants.AdminPassword;
await userManager.CreateAsync(admin, password);
await userManager.AddToRoleAsync(admin, GlobalConstants.AdminRole);
}
}
public IActionResult Create()
{
if (!this.shoppingCartService.AnyProducts(this.User.Identity.Name))
{
return(RedirectToAction("Index", "Home"));
}
TechAndToolsUser user = this.userService
.GetUserByUsername(this.User.Identity.Name);
IEnumerable <AddressViewModel> addressesViewModel = this.addressService
.GetAllByUserId(this.User.FindFirstValue(ClaimTypes.NameIdentifier))
.To <AddressViewModel>()
.ToList();
IEnumerable <SupplierViewModel> supplierViewModels = this.supplierService
.GetAllSuppliers()
.To <SupplierViewModel>()
.ToList();
IEnumerable <ShoppingCartProductServiceModel> shoppingCartProductsServiceModels = this.shoppingCartService
.GetAllShoppingCartProducts(this.User.Identity.Name)
.ToList();
IEnumerable <PaymentMethodViewModel> paymentMethodViewModels = this.paymentMethodService
.GetAllPaymentMethods()
.To <PaymentMethodViewModel>()
.ToList();
IEnumerable <ShoppingCartProductViewModel> shoppingCartProductsViewModels = shoppingCartProductsServiceModels
.Select(x => x.To <ShoppingCartProductViewModel>())
.ToList();
CreateOrderInputModel createOrderViewModel = new CreateOrderInputModel
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
PhoneNumber = user.PhoneNumber,
AddressesViewModels = addressesViewModel.ToList(),
SuppliersViewModel = supplierViewModels,
ShoppingCartProductViewModels = shoppingCartProductsViewModels,
PaymentMethodViewModels = paymentMethodViewModels
};
return(this.View(createOrderViewModel));
}
public async void CreateAsync_ShouldCreateAndAddAddressToDatabase()
{
var options = new DbContextOptionsBuilder <TechAndToolsDbContext>()
.UseInMemoryDatabase(databaseName: "CreateArticleAsync_ShouldCreateAndAddArticlesToDatabase")
.Options;
TechAndToolsDbContext context = new TechAndToolsDbContext(options);
IUserService userService = new UserService(context);
IAddressService addressService = new AddressService(context, userService);
TechAndToolsUser testUser = new TechAndToolsUser
{
UserName = "******",
Email = "testEmail"
};
await context.AddAsync(testUser);
await context.SaveChangesAsync();
await addressService.CreateAsync(
new AddressServiceModel
{
Id = 1,
City = "CityTest1",
CityAddress = "CityAddressTest1",
PostCode = 9000,
TechAndToolsUserId = Guid.NewGuid().ToString()
}, "testUsername");
await addressService.CreateAsync(
new AddressServiceModel
{
Id = 2,
City = "CityTest2",
CityAddress = "CityAddressTest2",
PostCode = 9000,
TechAndToolsUserId = Guid.NewGuid().ToString()
}, "testUsername");
int expectedCount = 2;
int actualCount = context.Addresses.ToList().Count;
Assert.Equal(expectedCount, actualCount);
}
public async Task <bool> EditLastName(TechAndToolsUser user, string lastName)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (lastName.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(user));
}
user.LastName = lastName;
int result = await this.context.SaveChangesAsync();
return(result > 0);
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
var user = new TechAndToolsUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginProvider = info.LoginProvider;
ReturnUrl = returnUrl;
return(Page());
}
