public async Task ReturnProper_WhenValidSaleIdIsPassed()
{
int validSaleId = 1;
var callArgs = new List <int>();
InitMocks();
SaleService.Setup(x => x.GetSaleInfoAsync(It.IsAny <int>()))
.ReturnsAsync(new Sale())
.Callback((int s) => callArgs.Add(s));
SaleService.Setup(x => x.GetAllProductsInSaleAsync(It.IsAny <int>()))
.ReturnsAsync(new List <ProductSale>());
AddressService.Setup(x => x.GetAllAddressesAsync()).ReturnsAsync(new List <Address>());
CityService.Setup(x => x.GetAllCitiesAsync()).ReturnsAsync(new List <City>());
CountryService.Setup(x => x.GetAllCountriesAsync()).ReturnsAsync(new List <Country>());
ClientService.Setup(x => x.GetAllClientsAsync(It.IsAny <int>(), It.IsAny <int>(), "*")).ReturnsAsync(new List <Client>());
SaleCUMapper.Setup(x => x.MapFrom(It.IsAny <Sale>())).Returns(new SaleCUViewModel());
var user = new StoreUser()
{
Id = "validId", UserName = "******", Email = "*****@*****.**"
};
var context = CreateControllerContext(user, ROLES.Client, true);
var sut = CreateController();
sut.ControllerContext = context;
//Act
var result = await sut.Edit(validSaleId);
//Assert
Assert.IsInstanceOfType(result, typeof(ViewResult));
Assert.IsInstanceOfType((result as ViewResult).Model, typeof(SaleCUViewModel));
Assert.IsTrue(callArgs.All(x => x == validSaleId));
Assert.IsTrue(callArgs.Count == 1);
AddressService.Verify(mock => mock.GetAllAddressesAsync(), Times.Once());
}
public async Task <IActionResult> Register(RegisterUserViewModel vm)
{
if (ModelState.IsValid)
{
var user = new StoreUser {
Email = vm.Email, UserName = vm.Email
};
var result = await _userManager.CreateAsync(user, vm.Password);
if (result.Succeeded)
{
return(RedirectToAction("Login", "Auth"));
}
else
{
}
}
return(View());
}
public async Task <IActionResult> LoginStoreUser([FromBody] LoginUser user, CancellationToken ct)
{
if (!ModelState.IsValid)
{
return(BadRequest(new { error = "Model state is not valid" }));
}
var result = await _baseSignInManager.PasswordSignInAsync(user.Email, user.Password, false, false);
if (!result.Succeeded)
{
return(BadRequest(new { error = $"Unable to sign in user {user.Email}" }));
}
var storeUserEntity = await _baseUserManager.FindByEmailAsync(user.Email) as StoreUserEntity;
// Get Home Store Information
var storeUser = new StoreUser
{
Token = CreateToken(storeUserEntity),
FullName = $"{storeUserEntity.FirstName}, {storeUserEntity.LastName}",
Email = storeUserEntity.Email
};
if (storeUserEntity.HomeStoreId != 0)
{
StoreEntity storeEntity = await _storeRepository.GetEntityAsync(storeUserEntity.HomeStoreId, ct);
AddressEntity addressEntity = await _addressRepository.GetEntityAsync(storeEntity.AddressId, ct);
Store mappedStore = Mapper.Map <Store>(storeEntity);
Address address = Mapper.Map <Address>(addressEntity);
mappedStore.Address = address;
storeUser.Store = mappedStore;
}
else
{
storeUser.Store = null;
}
return(Ok(storeUser));
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
StoreUserManager storeUserMgr = context.OwinContext.Get <StoreUserManager>("AspNet.Identity.Owin:" + typeof(StoreUserManager).AssemblyQualifiedName);
StoreUser user = await storeUserMgr.FindAsync(context.UserName, context.Password);
if (user == null)
{
context.SetError("invalid_grant", "The username or password is incorrect");
}
else
{
ClaimsIdentity ident = await storeUserMgr.CreateIdentityAsync(user, "Custom");
AuthenticationTicket ticket = new AuthenticationTicket(ident, new AuthenticationProperties());
context.Validated(ticket);
context.Request.Context.Authentication.SignIn(ident);
}
}
public async Task <IActionResult> Register(Register model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
user = new StoreUser()
{
FirstName = model.FirstName,
LastName = model.LastName,
UserName = model.UserName,
Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result != IdentityResult.Success)
{
string ErrorString = "\n";
foreach (var error in result.Errors)
{
ErrorString += error.Description + "\n";
}
ViewBag.UserMessage = "Ошибка регистрации пользователя:" + ErrorString;
}
else
{
ViewBag.UserMessage = "Регистрация завершена.";
bool x = await _roleManager.RoleExistsAsync("Users");
if (x)
{
var result1 = await _userManager.AddToRoleAsync(user, "Users");
}
}
}
ModelState.Clear();
}
return(View());
}
public decimal CalculateFinalPrice(StoreUser user, BillItems items)
{
decimal percentageTotalDiscount = 0m, itemTotal = 0m;
decimal discountRate = GetDiscountRate(user);
if (discountRate > 0)
{
foreach (var item in items.Products)
{
if (item.ProductType != ProductType.Grocery)
{
itemTotal += (item.Quantity * item.Price);
}
}
percentageTotalDiscount = (itemTotal * discountRate);
}
decimal fixedDiscount = Math.Floor(items.BillTotal / 100) * 5m;
return(items.BillTotal - (percentageTotalDiscount + fixedDiscount));
}
public async Task <IActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new StoreUser {
UserName = model.Username, Email = model.Username
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Details", "Shop"));
}
ModelState.AddModelError("", "Registration Failed");
}
return(View(model));
}
public async Task ReturnProper_WhenUserIsNotInRoleClient()
{
var user = new StoreUser()
{
Id = "validId", UserName = "******", Email = "*****@*****.**", ClientId = null
};
var context = CreateControllerContext(user, ROLES.Admin, true);
var sut = CreateController();
sut.ControllerContext = context;
//Act
var result = await sut.Index();
//Assert
Assert.IsInstanceOfType(result, typeof(ViewResult));
Assert.IsInstanceOfType((result as ViewResult).Model, typeof(OfferIndexViewModel));
OfferService.Verify(mock => mock.GetOffersWithTotalAsync(null, null, null, null, null), Times.Once());
}
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 StoreUser {
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());
}
public async Task Seed()
{
//check if the database was created
_ctx.Database.EnsureCreated();
//this part is to create the first user
var user = await _userManager.FindByEmailAsync("*****@*****.**");
if (user == null)
{
user = new StoreUser()
{
FirstName = "Danny",
LastName = "Llanes",
UserName = "******",
Email = "*****@*****.**",
Person = new Persons()
{
AccessLevel = "System",
CreateDate = DateTime.UtcNow,
IsActive = true,
LastModifiedDate = DateTime.UtcNow,
Contact = new Contacts()
{
FirstName = "Danny",
LastName = "Llanes",
Email = "*****@*****.**"
}
}
};
var result = await _userManager.CreateAsync(user, "Dllanes1");
if (result != IdentityResult.Success)
{
throw new InvalidOperationException("Failed to create default user");
}
_ctx.SaveChanges();
}
}
public async Task <IActionResult> GetAllStoreUsers(CancellationToken ct)
{
var users = await _storeUserRepository.GetAllEntities(ct);
List <StoreUser> storeUsers = new List <StoreUser>();
foreach (var user in users)
{
if (user.HomeStoreId == 0)
{
return(Conflict(new { error = $"StoreEntity's Homestore is not set {user.Email}" }));
}
var storeUser = new StoreUser
{
Token = CreateToken(user),
FullName = $"{user.FirstName}, {user.LastName}",
Email = user.Email,
TimeOfCreation = user.TimeOfCreation
};
if (user.HomeStoreId != 0)
{
StoreEntity storeEntity = await _storeRepository.GetEntityAsync(user.HomeStoreId, ct);
AddressEntity addressEntity = await _addressRepository.GetEntityAsync(storeEntity.AddressId, ct);
Store mappedStore = Mapper.Map <Store>(storeEntity);
Address address = Mapper.Map <Address>(addressEntity);
mappedStore.Address = address;
storeUser.Store = mappedStore;
}
else
{
storeUser.Store = null;
}
storeUsers.Add(storeUser);
}
return(Ok(storeUsers));
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new IdentityUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
StoreUser storeUser = new StoreUser();
storeUser.UserId = user.Id;
storeUser.UserCatergoryId = _context.UserCategories.Where(x => x.Name == "Regular").Select(x => x.Id).FirstOrDefault();
_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 _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);
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <IActionResult> GetAddress(string id)
{
try
{
StoreUser user = null;
if (id != "null")
{
user = await _userManager.FindByIdAsync(id);
}
else
{
user = await _userManager.FindByNameAsync(HttpContext.User.Identity.Name);
}
return(Ok(user));
}
catch (Exception ex)
{
_logger.LogError($"Failed to get orders: {ex}");
return(BadRequest("Failed to get orders"));
}
}
public async Task seed()
{
var user = await _userManager.FindByEmailAsync("*****@*****.**");
if (user == null)
{
user = new StoreUser()
{
FirstName = "Jhonny",
LastName = "Bravo",
UserName = "******",
Email = "*****@*****.**"
};
var result = await _userManager.CreateAsync(user, "P@ssw0rd!");
if (result != IdentityResult.Success)
{
throw new InvalidOperationException("Failed to create user");
}
}
}
public async Task <IActionResult> Post([FromBody] RegisterModel model)
{
var newUser = new StoreUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(newUser, model.Password);
if (!result.Succeeded)
{
var errors = result.Errors.Select(x => x.Description);
return(BadRequest(new RegisterResult {
Successful = false, Errors = errors
}));
}
return(Ok(new RegisterResult {
Successful = true
}));
}
public async Task <ActionResult> Delete(string username)
{
StoreUser user = await userManager.FindByEmailAsync(username);
if (user == null)
{
return(BadRequest("User does not exists"));
}
var result = await userManager.DeleteAsync(user);
if (result != IdentityResult.Success)
{
throw new InvalidOperationException("Could not delete user");
}
else
{
logger.LogInformation("Deleting user");
return(Ok());
}
}
public async Task Seed()
{
ctx.Database.EnsureCreated();
var user = await userManager.FindByEmailAsync("*****@*****.**");
if (user == null)
{
user = new StoreUser()
{
FirstName = "Bau",
LastName = "Bau",
UserName = "******",
Email = "*****@*****.**"
};
var result = await userManager.CreateAsync(user, "P@ssw0rd!");
if (result != IdentityResult.Success)
{
throw new InvalidOperationException("Failed to create default user");
}
}
if (!ctx.Engineers.Any())
{
var filePath = Path.Combine(hosting.ContentRootPath, "../Bau.Data/engineers.json");
var json = File.ReadAllText(filePath);
var engineers = JsonConvert.DeserializeObject <IEnumerable <Engineer> >(json);
ctx.Engineers.AddRange(engineers);
ctx.SaveChanges();
planningService.GeneratePlanForDateRagne(
ctx,
new DateTime(2018, 2, 1),
new DateTime(2018, 2, 28));
}
}
public async Task SeedAsync()
{
_islandDbContext.Database.EnsureCreated();
StoreUser user = await _userManager.FindByEmailAsync("*****@*****.**");
if (user == null)
{
user = new StoreUser
{
FirstName = "Koen",
LastName = " Hos",
Email = "*****@*****.**",
UserName = "******"
};
var result = await _userManager.CreateAsync(user, "P@ssw0rd!");
if (result != IdentityResult.Success)
{
throw new InvalidOperationException("Could not create new user in seeder");
}
}
if (!_islandDbContext.Elements.Any())
{
//seed
var file = Path.Combine(_hostingEnvironment.ContentRootPath, "../Aruba.Data/Elements.json");
var json = File.ReadAllText("../Aruba.Data/Elements.json");
var elements = JsonConvert.DeserializeObject <IEnumerable <Element> >(json);
foreach (Element element in elements)
{
element.User = user;
}
_islandDbContext.Elements.AddRange(elements);
_islandDbContext.SaveChanges();
}
}
public void CreateOrder(Order order, StoreUser storeUser)
{
// var transaction = _bookstoreDbContext.Database.BeginTransaction();
// try
{
order.OrderDate = DateTime.Now;
order.OrderNumber = DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString()
+ DateTime.Now.Day.ToString() + DateTime.Now.Hour.ToString() + DateTime.Now.Minute.ToString()
+ DateTime.Now.Second.ToString() + DateTime.Now.Millisecond.ToString();
order.User = storeUser;
order.OrderTotal = _shoppingCart.GetShoppingCartTotal();
order.Condidtion = "Created";
_bookstoreDbContext.Add(order);
_bookstoreDbContext.SaveChanges();
var shoppingCartItems = _shoppingCart.ShoppingCartItems;
foreach (var item in shoppingCartItems)
{
var orderItem = new OrderItem()
{
BookId = item.Book.Id,
OrderId = order.Id,
Price = item.Book.Price * item.Amount,
Amount = item.Amount
};
//var itemStorage = _bookstoreDbContext.Storages.FirstOrDefault(s => s.BookId == item.Book.Id);
//itemStorage.Amount = itemStorage.Amount - orderItem.Amount;
// _bookstoreDbContext.Storages.Update(itemStorage);
_bookstoreDbContext.OrderItems.Add(orderItem);
}
_bookstoreDbContext.SaveChanges();
// transaction.Commit();
}
//catch (Exception e)
//{
// transaction.Rollback();
//}
}
public JsonResult UserLogin(StoreUser d)
{
if (!String.IsNullOrEmpty(d.StoreName) && !String.IsNullOrEmpty(d.Password))
{
int idUser = Convert.ToInt32(d.StoreName);
using (GiftCardEntities db = new GiftCardEntities())
{
var user = db.StoreUsers.Where(s => s.IDUser == idUser && s.Password.Equals(d.Password)).FirstOrDefault();
if (user != null && user.Password != null)
{
FormsAuthentication.SetAuthCookie(user.IDUser.ToString(), false);
return(Json(new { success = true }));
}
return(Json(new { success = false, errors = true }));
}
}
else
{
return(Json(new { success = false, errors = true }));
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (Request.QueryString["UserName"] == null)
{
this.labActivation.Text = "激活失败";
}
else
{
string lstrUserName = Request.QueryString["UserName"];
StoreUser lUser = new StoreUser();
lUser.UserName = lstrUserName;
lUser.IsConfim = '1';
if (lUser.Active(lUser))
{
this.labActivation.Text = "激活成功";
}
else
{
this.labActivation.Text = "激活失败";
}
}
}
//public async Task<IActionResult> Login(LoginViewModel model)
public async Task <IActionResult> Get(bool includeItems = true)
{
try
{
//var username = User.Identity.Name; //one way
//var username = _userManager.GetUserId(User); //other way
ClaimsPrincipal currentUser = this.User; //get current logged in user
var currentUserEmail = currentUser.FindFirst(ClaimTypes.NameIdentifier).Value;
StoreUser user = await _userManager.FindByEmailAsync(currentUserEmail);
var result = _mapper.Map <IEnumerable <Order>, IEnumerable <OrderViewModel> >(_repository.GetAllOrdersByUser(user.Id, includeItems));
return(Ok(result));
//return Ok(_mapper.Map<IEnumerable<Order>, IEnumerable<OrderViewModel>>(_repository.GetAllOrders(includeItems)));
}
catch (Exception ex)
{
_logger.LogError($"Failed to get orders:{ex}");
return(BadRequest("Bad request"));
}
}
private async Task CreateUser(string email, string firstName, string LastName, string userName)
{
var user = await userManager.FindByEmailAsync(email);
if (user == null)
{
user = new StoreUser
{
FirstName = firstName,
LastName = LastName,
Email = email,
UserName = userName
};
var result = await userManager.CreateAsync(user, "P4ssw0rd!");
if (result != IdentityResult.Success)
{
throw new InvalidOperationException("Failed to create default user");
}
}
}
public bool UpdateUserRole(StoreUser user, string role)
{
try
{
IdentityRole idNewRole = context.Roles.Where(i => i.Name == role).FirstOrDefault();
IdentityUserRole <string> userRoleCurrent = context.UserRoles.Where(u => u.UserId == user.Id).FirstOrDefault();
if (idNewRole != null && userRoleCurrent != null)
{
userRoleCurrent.RoleId = idNewRole.Id;
context.UserRoles.Update(userRoleCurrent);
return(true);
}
return(false);
}
catch (Exception)
{
logger.LogError("Could not create user role to database.");
return(false);
}
}
public async Task <ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Manage"));
}
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new StoreUser()
{
UserName = model.UserName
};
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
await SignInAsync(user, isPersistent : false);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}
public async Task <IActionResult> RegisterUser([FromBody] RegistrationViewModel model, string returnUrl = null)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new StoreUser()
{
UserName = model.Email,
Email = model.Email,
Titel = model.Titel,
FirstName = model.FirstName,
LastName = model.LastName,
Address1 = model.Address1,
Address2 = model.Address2,
PhoneNumber = model.PhoneNumber,
Zipcode = model.Zipcode,
City = model.City,
Country = model.Country,
AdditionalInformation = model.AdditionalInformation,
UserType = 0
};
try
{
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
}
catch (Exception e)
{ }
Uri locationHeader = new Uri(Url.Link("GetUserById", new { id = user.Id }));
return(Created(locationHeader, user));
}
public async Task SeedAsync()
{
_ctx.Database.EnsureCreated();
StoreUser storeUser = await userManager.FindByEmailAsync("*****@*****.**");
if (storeUser == null)
{
storeUser = new StoreUser()
{
FirstName = "Nikunj",
LastName = "Rathod",
Email = "*****@*****.**",
UserName = "******"
};
var result = await userManager.CreateAsync(storeUser, "P@ssw0rd!");
if (result != IdentityResult.Success)
{
throw new InvalidOperationException("Could not create new user");
}
}
if (!_ctx.GameLibraries.Any())
{
//create data
var filepath = Path.Combine(_hosting.ContentRootPath, "Data/file.json");
var json = File.ReadAllText(filepath);
//var games = JsonSerializer.DeserializeObject<IEnumerable<Games>>(json);
var GameSystem = new GameSystem {
CreationDate = DateTime.Today, GameLibrary = null, SystemName = "PS4",
GameSystemID = 1
/*new List<Games>() { new Games() { library = Games.First() }*/
/*new Library { GameSystemID=1, CreationDate=DateTime.Now, Description="abcd", DiscType="Digital", GameLibraryID=1, GameSystems=null, Name="Spiderman", Rating=4}*/
};
GameSystem.user = storeUser;
_ctx.GameSystems.AddRange(GameSystem);
_ctx.SaveChanges();
}
}
public bool RegisterUser(UserEL user)
{
bool isUserRegistered = false;
try
{
StoreUser storeUser = new StoreUser();
storeUser = MapperUtility.MapTo(user, storeUser);
using (uow = new UnitOfWork.UnitOfWork())
{
storeUser.Password = EncryptionHelper.Encrypt(storeUser.Password);
uow.StoreUserRepository.Insert(storeUser);
uow.Save();
isUserRegistered = true;
}
}
catch
{
isUserRegistered = false;
}
return(isUserRegistered);
}
private decimal CalculateDiscount(StoreUser user, BillItems items, IPriceDiscountRule rule)
{
decimal discount = 0m;
if (rule.IsFixed) // When discount is fixed
{
discount = rule.GetApplicableDiscount(user, items);
}
else // when discount is in percentage
{
decimal itemTotal = 0m;
decimal discountRate = rule.GetApplicableDiscount(user, items);
foreach (Product product in items.Products)
{
if (product.ProductType != ProductType.Grocery) //Percentage discount doesn't apply on grocery items
{
itemTotal += (product.Quantity * product.Price);
}
}
discount = itemTotal * discountRate;
}
return(discount);
}
public async Task <bool> RegisterUser(RegisterViewModel model)
{
if (model == null)
{
return(false);
}
var storeUser = new StoreUser
{
FirstName = model?.FirstName,
LastName = model?.LastName,
Email = model?.Email,
UserName = model?.Email,
PhoneNumber = model?.PhoneNumber
};
var isCreated = await _userManager.CreateAsync(storeUser, model.Password).ConfigureAwait(true);
if (isCreated.Succeeded)
{
return(true);
}
return(false);
}
