public void UserDetails_ShouldReturn_ViewAndDetailInfo() { // Arrange string userId = "asd1"; var userDto = new AppUserDto { Id = userId }; mockAdminService.Setup(u => u.GetUserById(userId)).Returns(userDto); AdminController controller = new AdminController(new DeliveryMessage(), mockAdminService.Object, mockInvoicesService.Object); AppUserViewModel userViewModel = null; try { // Act result = controller.UserDetails(userId) as ViewResult; userViewModel = (AppUserViewModel)result.Model; } catch (Exception ex) { errorMessage = ex.Message + " | " + ex.StackTrace; } // Assert Assert.IsTrue(result.ViewName == "UserDetails", errorMessage); Assert.IsNotNull(userViewModel, errorMessage); }
private void LoginBtn_Click(object sender, RoutedEventArgs e) { string user = LoginBox.Text; string pswd = PasswordBox.Password; if (MyAes.EncryptStringToString(pswd).Length <= 255) { userDto = AppUserOperations.SelectAppUser(user, pswd); } if (userDto != null) { AuthBox.Visibility = Visibility.Visible; AuthBtn.Visibility = Visibility.Visible; AuthBox.IsEnabled = true; AuthBtn.IsEnabled = true; LoginBtn.IsEnabled = false; RegisterBtn.IsEnabled = false; timer.Start(); stopwatch.Start(); try { Task.Run(() => { SendAuthCode(user); }); } catch (SmtpException exc) { Debug.WriteLine(exc); } } else { MessageBox.Show("Nieprawidłowe dane logowania."); } }
public async Task <IActionResult> SignIn(AppUserLoginDto loginDto) { if (ModelState.IsValid) { AppUser appUser = await appUserService.FindByUserName(loginDto.UserName); if (appUserService.CheckPassword(loginDto, appUser) && appUser != null) { ICollection <AppRole> roles = await appUserService.GetRolesByUserName(loginDto.UserName); AppUserDto appUserDto = accountHelper.GenerateAppUserDto(appUser, roles); appUserSessionService.Set(appUserDto); logger.LogInformation($"{appUser.UserName} kullanıcısı giriş yaptı"); return(RedirectToAction("Index", "Home")); } else { logger.LogInformation($"{loginDto.UserName} Kullanici adi veya parola hatali "); ModelState.AddModelError("", "Kullanici adi veya parola hatali"); return(View(loginDto)); } } else { logger.LogInformation("AppUserLoginDto Not Valid"); ModelState.AddModelError("", "Lütfen gereken tüm alanları doldurunuz"); return(View(loginDto)); } }
public async Task <IActionResult> UpdateUser(int id, [FromBody] AppUserDto userDto) { if (id != userDto.Id) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = await _userService.GetByIdAsync(userDto.Id); if (user == null) { return(NotFound("User does not exist")); } _mapper.Map(userDto, user); try { _userService.Update(user); await _unitOfWork.SaveAsync(); } catch (Exception) { throw new Exception("An unexpected error occured. Could not update."); } return(Ok(_mapper.Map <AppUserDto>(user))); }
public async Task <IActionResult> RegisterEmployee([FromBody] AppUserDto model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, PhoneNumber = model.PhoneNumber, EmployeeNumber = model.EmployeeNumber, Address = model.Address }; var result = await _userManager.CreateAsync(user, $"{model.LastName}123!"); if (result.Succeeded) { // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713 // Send an email with this link //var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); //var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme); //await _emailSender.SendEmailAsync(model.Email, "Confirm your account", // "Please confirm your account by clicking this link: <a href=\"" + callbackUrl + "\">link</a>"); // await _signInManager.SignInAsync(user, isPersistent: false); _logger.LogInformation(3, "User created a new account with password."); var userViewModel = await GetUser(user.UserName); return(Ok(userViewModel)); } AddErrors(result); } // If we got this far, something failed return(BadRequest(this.ModelState)); }
public async Task <ActionResult> Login(LoginViewModel model) { try { if (ModelState.IsValid) { AppUserDto userDto = new AppUserDto { Email = model.Email, Password = model.Password }; ClaimsIdentity claim = await adminService.Authenticate(userDto); if (claim == null) { ModelState.AddModelError("", "Невірний логін або пароль."); } else { AuthenticationManager.SignOut(); AuthenticationManager.SignIn(new AuthenticationProperties { IsPersistent = true }, claim); return(RedirectToAction("Index", "Main")); } } return(View(model)); } catch (Exception ex) { deliveryMessage.Title = "Адміністрування"; deliveryMessage.Body = ex.Message; return(View("DeliveryMessage", deliveryMessage)); } }
public async Task <IActionResult> Index() { AppUserDto loginUser = appUserSessionService.Get(); ICollection <Website> userWebsites = await userWebsiteService.GetWebsitesByUserId(loginUser.Id); return(View(userWebsites)); }
// [Permission(Action = ActionName.CanUpdate)] public IHttpActionResult Edit(string id, [FromBody] AppUserDto user) { return(CreateResponse(() => { if (!ModelState.IsValid) { return BadRequest(ModelState); } var model = UserManager.FindById(id); Mapper.Map(user, model); UserManager.Update(model); if (user.Roles.Any()) { var userRoles = UserManager.GetRoles(model.Id); UserManager.RemoveFromRoles(model.Id, userRoles.ToArray()); UserManager.AddToRoles(model.Id, user.Roles.ToArray()); } return Ok(); })); }
public async void NewUserLogin() { string url = $"{TestDomain}/api/apps/login"; IList <string> mockUsers = CreateMockUsers(1000); // 模拟用户 bool testResult = true; foreach (var mockUser in mockUsers) { HttpClient httpClient = new HttpClient(); AppUserDto userDto = new AppUserDto { AppId = TestAppId, UserId = mockUser, Channel = "" }; var httpContent = new StringContent(JsonConvert.SerializeObject(userDto), Encoding.UTF8, "application/json"); var response = await httpClient.PostAsync(url, httpContent); testResult &= response.IsSuccessStatusCode; } Assert.True(testResult); }
public IActionResult Register([FromBody] AppUserDto userDto) { var userManager = _serviceProvider.GetRequiredService <UserManager <IdentityUser> >(); var user = userManager.FindByEmailAsync(userDto.UserName).Result; var requiredRole = (SiriusEnums.Roles)userDto.Role; if (user != null) { return(BadRequest($"User {userDto.UserName} already exists!")); } try { user = new IdentityUser { Id = Guid.NewGuid().ToString(), UserName = userDto.UserName, Email = userDto.UserName, SecurityStamp = Guid.NewGuid().ToString(), }; userManager.CreateAsync(user, userDto.Password + SiriusConfiguration.Salt).Wait(); userManager.AddToRoleAsync(user, requiredRole.ToString()).Wait(); return(Ok()); } catch (AppException ex) { // return error message if there was an exception return(BadRequest(new { message = ex.Message })); } }
public async Task <ServiceResult> CreateAsync(AppUserDto appUserDto, string password) { try { // Checking if user already exist var appUserExist = await _uow.AppUsers.AsQueryable() .AnyAsync(u => u.Email == appUserDto.Email && u.UserName == appUserDto.Name); if (appUserExist) { return(new ServiceResult($"User with name: {appUserDto.Name} or email: {appUserDto.Email} - already exist.")); } // User creating var appUser = _mapper.Map <AppUser>(appUserDto); var result = await _uow.AppUsers.CreateAsync(appUser, password); return(new ServiceResult { Succeeded = result.Succeeded }); } catch (Exception ex) { _logger.LogError($"{this.ToString()} - error message:{ex.Message}"); return(new ServiceResult(ex.Message)); } }
public async Task <IActionResult> GetOrAddAppUser([FromBody] AppUserDto appUserDto) { if (appUserDto.Id > 0) { return(Ok( _mapper.Map <AppUserDto>( _context.AppUser.Find(appUserDto.Id)) )); } if (appUserDto.Name != null) { var appUser = await _context.AppUser .SingleOrDefaultAsync(m => m.Name == appUserDto.Name); if (appUser == null) { appUser = new AppUser { Name = appUserDto.Name }; _context.AppUser.Add(appUser); _context.SaveChanges(); } return(Ok( _mapper.Map <AppUserDto>( appUser ) )); } return(BadRequest("user not found")); }
public IActionResult Authenticate([FromBody] AppUserDto userDto) { var user = _userService.Authenticate(userDto.UserName, userDto.Password); if (user == null) { return(BadRequest(new { message = "Username or password is incorrect" })); } var tokenHandler = new JwtSecurityTokenHandler(); var key = Encoding.ASCII.GetBytes(SiriusConfiguration.AppSecret); var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, user.Id) }), Expires = DateTime.UtcNow.AddDays(7), SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature) }; var token = tokenHandler.CreateToken(tokenDescriptor); var tokenString = tokenHandler.WriteToken(token); // return basic user info (without password) and token to store client side return(Ok(new { Id = user.Id, Username = user.UserName, Token = tokenString })); }
public async Task <AppUserDto> Register(AppUserDto userDto) { var accountRepository = DataContextManager.CreateRepository <IAccountRepository>(); var user = await accountRepository.GetByEmail(userDto.Email); if (user != null) { throw new ArgumentException(ErrorMessage.SAMENAME.ToString()); } user = new AppUser { FirstName = userDto.FirstName, LastName = userDto.LastName, Email = userDto.Email, Mobile = userDto.Mobile, Password = GetMD5Hash(userDto.Password), CreateDate = DateTime.Now, IsActive = true }; await accountRepository.Add(user); return(MapperFactory.CreateMapper <IAppUserMapper>().MapToModel(user)); }
public TokenUserResponse GenerateToken(AppUserDto appUserDto) { var claims = new List <Claim> { new Claim(ClaimTypes.Name, appUserDto.UserName), new Claim(ClaimTypes.NameIdentifier, appUserDto.AppUserId.ToString()), }; string accessToken = GenerateAccessToken(claims); string refreshToken = GenerateRefreshToken(); var token = new TokenUserResponse { UserId = appUserDto.AppUserId, UserName = appUserDto.UserName, CoverPhotoUrl = appUserDto.CoverPhotoUrl, ProfilePhotoUrl = appUserDto.ProfilePhotoUrl, RegisteredDate = appUserDto.RegisteredDate, UserPosts = appUserDto.UserPosts, AccessToken = accessToken, RefreshToken = refreshToken, Expires = JwtTokenDefinitions.TokenExpirationTime.Ticks }; return(token); }
public async Task <IViewComponentResult> InvokeAsync() { var user = await _userManager.GetUserAsync(HttpContext.User); AppUserDto appUserDto = _mapper.Map <AppUser, AppUserDto>(user); return(View(appUserDto)); }
public async Task <AppUserDto> CreateUserAsync(AppUserDto dto) { var userRecord = await _firebaseAuth.CreateUserAsync(new UserRecordArgs { Email = dto.Email, Password = dto.Password, }); dto.Uid = userRecord.Uid; return(dto); }
public async Task <ActionResult> Register([FromBody] UserRegisterModel model) { if (!ModelState.IsValid) { return(BadRequest()); } var userDto = new AppUserDto { FirstName = model.FirstName, LastName = model.LastName, Email = model.Email, Password = model.Password, Mobile = model.Mobile, }; try { var newUser = await _accountService.Register(userDto); var identity = await GetIdentity(model.Email, model.Password); var now = DateTime.UtcNow; var newToken = GenerateToken(identity.Claims); var refreshToken = GenerateRefreshToken(); await _accountService.SaveRefreshToken(model.Email, refreshToken); var response = new { access_token = newToken, refresh_token = refreshToken, expires_date = now.Add(TimeSpan.FromMinutes(AuthOptions.LIFETIME)) }; return(Ok(response)); } catch (ArgumentException aex) { _log.Error(aex); return(Unauthorized(aex.Message)); } catch (ObjectNotFoundException onfex) { _log.Error(onfex); } catch (UnauthorizedAccessException uaex) { _log.Error(uaex); } return(Unauthorized(ErrorMessage.INVALIDEMAILORPASSWORD.ToString())); }
public IActionResult Add([FromForm] AppUserDto rentalWithCreditCardDto) { var rental = _mapper.Map <Rental>(rentalWithCreditCardDto); var creditCard = _mapper.Map <CreditCard>(rentalWithCreditCardDto); var result = _rentalManager.AddRentalWithPayment(rental, creditCard, rentalWithCreditCardDto.willBeRecorded); if (!result.IsSuccess) { return(BadRequest(result)); } return(Ok(result)); }
private OrderViewModel CreateOrders(List <OrderItemViewModel> orderItems, AppUserDto owner) { var newOrder = new OrderViewModel() { OrderId = Guid.NewGuid().ToString(), CreatedDate = DateTime.UtcNow, Status = "InProcess", AppUserId = owner.AppUserId }; //Keeping history //var orderItemsToHistory = await _itemsHistoryComparer.GetOrderHistoryToRecordAsync(owner, orderItems); //var newOrderHistory = _mapper.Map<OrderHistoryDto>(newOrder); if (orderItems.Count() > 0) { foreach (var item in orderItems) { var orderItem = _mapper.Map <OrderItemViewModel>(item); orderItem.OrderId = newOrder.OrderId; orderItem.CreatedDate = DateTime.UtcNow; orderItem.Order = newOrder; //Keeping history //var newOrderItemHistory = new OrderItemHistoryDto(); //if (ItemsHistoryComparer.CompareTwoItems(item,)) //{ //} // _mapper.Map<OrderItemHistoryDto>(orderItem); var orderProduct = new OrderProductViewModel() { OrderId = newOrder.OrderId, ProductId = item.ProductId, }; newOrder.TotalPrice += orderItem.TotalQuantityPrice; newOrder.OrderItems.Add(orderItem); newOrder.OrderProducts.Add(orderProduct); //newOrderHistory.OrderItems.Add(newOrderItemHistory); //newOrderHistory.ProductIdDetail = item.ProductId; //newOrder.OrderHistory = newOrderHistory; //newOrder.AppUser.OrderHistoryCount += 1; } } return(newOrder); }
public async Task <IActionResult> ActiveUser() { var userName = User.Identity.Name; var user = await _appUserService.FindByUserNameAsync(userName); var model = new AppUserDto { Id = user.Id, Name = user.Name, Surname = user.Surname }; return(Ok(model)); }
/// <summary> /// User authentication /// </summary> /// <param name="userDto">Data transfer object from the login page</param> /// <returns>Об'єкт ClaimsIdentity</returns> public async Task <ClaimsIdentity> Authenticate(AppUserDto userDto) { ClaimsIdentity claim = null; // Знаходимо користувача IdentityUser user = await userManager.FindAsync(userDto.Email, userDto.Password); // авторизуємо його і повертаємо ClaimsIdentity if (user != null) { claim = await userManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); } return(claim); }
public async Task <IActionResult> ActiveUser() { var user = await this.appUserService.FindByUserNameAsync(User.Identity.Name); var roles = await this.appUserService.GetRolesByUserName(User.Identity.Name); AppUserDto appUserDto = new AppUserDto { Name = user.Name, Roles = roles.Select(x => x.Name).ToList(), UserName = user.UserName }; return(Ok(appUserDto)); }
public async Task <IActionResult> EditProfile() // Get current User data { var user = await _userManager.GetUserAsync(HttpContext.User); if (user == null) { return(NotFound()); } AppUserDto appUserDto = _mapper.Map <AppUser, AppUserDto>(user); var json = JsonConvert.SerializeObject(appUserDto); return(Json(json)); }
public async Task <IActionResult> ActiveUser() { var user = await _appUserService.FindByUserName(User.Identity.Name); var roles = await _appUserService.GetRolesByUserName(User.Identity.Name); AppUserDto appUserDto = new AppUserDto { FullName = user.FullName, UserName = user.UserName, Roles = roles.Select(I => I.Name).ToList() }; return(Ok(appUserDto)); }
public async Task <ActionResult <AppUserDto> > PostAppUser(AppUserDto appUser) { try { await _appUserRepository.AddAsync(_mapper.Map <AppUser>(appUser)); await _unitOfWorkAppUser.CommitAsync(_cancellationToken); return(CreatedAtAction("GetAppUser", new { id = appUser.AppUserId }, appUser)); } catch (Exception ex) { var eerorMsg = ex.Message; throw; } }
public void Insert(AppUserDto dto) { using (var ctx = DbContextManager <EfDbContext> .GetManager()) { var db = ctx.DbContext; var data = new AppUser(); SetData(data, dto); db.AppUsers.Add(data); db.SaveChanges(); dto.ConcurrencyStamp = data.ConcurrencyStamp; } }
public async Task <IActionResult> PutAppUser(AppUserDto appUser) { //if (id != appUser.AppUserId) //{ // return BadRequest(); //} try { if (ModelState.IsValid) { await _unitOfWorkAppUser.UpdateAsync(_cancellationToken, _mapper.Map <AppUser>(appUser)); return(Ok()); //return CreatedAtAction("GetAppUser", new { id = appUser.AppUserId }, appUser); } else { return(NotFound()); } } catch (Exception ex) { var errMsg = ex.Message; throw; } //_context.Entry(appUser).State = EntityState.Modified; //try //{ // await _context.SaveChangesAsync(); //} //catch (DbUpdateConcurrencyException) //{ // //if (!AppUserExists(id)) // //{ // // return NotFound(); // //} // //else // //{ // // throw; // //} //} return(NoContent()); }
public void OnAuthorization(AuthorizationFilterContext context) { AppUserDto user = context.HttpContext.RequestServices.GetService <IAppUserSessionService>().Get(); if (user.IsNull()) { context.Result = new RedirectToActionResult("SignIn", "Auth", null); } else if (Roles.Any()) { string foundRole = Roles.FirstOrDefault(role => user.Roles.Contains(role)); if (foundRole.EmptyCheck()) { context.Result = new RedirectToActionResult("AccessDenied", "Auth", null); } } }
private void SetData(AppUser data, AppUserDto dto) { data.Id = dto.Id; data.UserName = dto.UserName; data.NormalizedUserName = dto.NormalizedUserName; data.Email = dto.Email; data.NormalizedEmail = dto.NormalizedEmail; data.EmailConfirmed = dto.EmailConfirmed; data.PasswordHash = dto.PasswordHash; data.SecurityStamp = dto.SecurityStamp; data.PhoneNumber = dto.PhoneNumber; data.PhoneNumberConfirmed = dto.PhoneNumberConfirmed; data.TwoFactorEnabled = dto.TwoFactorEnabled; data.LockoutEnd = dto.LockoutEnd; data.LockoutEnabled = dto.LockoutEnabled; data.AccessFailedCount = dto.AccessFailedCount; }