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); }