public async Task <IHttpActionResult> CreateUser(CreateUserBindingModel createUserModel) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (createUserModel == null) { return(BadRequest("Error. Model is empty")); } var user = new ApplicationUserDto() { UserName = createUserModel.Username, Email = createUserModel.Email, FirstName = createUserModel.FirstName, LastName = createUserModel.LastName }; var addUserResult = await userService.CreateAsync(user, createUserModel.Password); if (!addUserResult.Succeeded) { return(GetErrorResult(addUserResult)); } await AssignRolesToUser(user.Id, new[] { "User" }); var locationHeader = new Uri(Url.Link("GetUserById", new { id = user.Id })); return(Created(locationHeader, user)); }
//POST : /api/ApplicationUser/Login public async Task <IActionResult> Login(ApplicationUserDto dto) { var user = await _userManager.FindByNameAsync(dto.UserName); if (user != null) { if (await _userManager.CheckPasswordAsync(user, dto.Password)) { var claims = await _userManager.GetClaimsAsync(user); var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(claims), Expires = DateTime.UtcNow.AddMinutes(30), SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_appSettings.Value.Secret)), SecurityAlgorithms.HmacSha256Signature) }; var tokenHandler = new JwtSecurityTokenHandler(); var securityToken = tokenHandler.CreateToken(tokenDescriptor); var token = tokenHandler.WriteToken(securityToken); return(Ok(new { token })); } else { return(BadRequest("Password is incorrect.")); } } else { return(BadRequest("Username does not exist.")); } }
public async Task <ApplicationUserDto> RegisterAsync(RegisterDto model) { var newUser = new ApplicationUser() { UserName = model.Username }; var result = await _userManager.CreateAsync(newUser, model.Password); if (result.Succeeded) { await _userManager.AddToRoleAsync(newUser, "User"); var role = await GetRoleAsync(newUser); // authentication successful so generate jwt token var token = GenerateJwtToken(newUser, role); var userDto = new ApplicationUserDto(newUser) { Token = token, Role = role }; return(userDto); } else { throw new RegistrationException(string.Join(" ", result.Errors.Select(e => e.Description))); } }
public IActionResult CreateUser([FromBody] ApplicationUserDto user, [FromQuery] string role) { _log.LogInformation("Called CreateUser"); try { ApplicationUser applicationUser = new ApplicationUser { UserName = user.UserName }; var result = _userManager.CreateAsync(applicationUser, user.Password).Result; if (result.Errors.Any()) { return(new ObjectResult(new ResponseModel <ApplicationUser>(null, result.Errors, "User Could Not Be Created."))); } var newUser = _service.GetUserByUserName(user.UserName); var roleresult = _userManager.AddToRoleAsync(newUser, role).Result; if (result.Errors.Any()) { return(new ObjectResult(new ResponseModel <ApplicationUser>(null, result.Errors, "User was created Successfully But Could Noit Add Role On It."))); } return(new ObjectResult(new ResponseModel <ApplicationUser>(null, message: "Successfully Created User."))); } catch (Exception ex) { _log.LogError(ex.Message); return(new ObjectResult(new ResponseModel <ApplicationUser>(null, ex, "Could not create User."))); } }
public async Task <List <ApplicationUserDto> > GetAllUsersCompany(string companyName) { var usersDto = new List <ApplicationUserDto>(); var users = await _userManager.Users.Where(user => user.UserName != "SuperAdmin" && user.Company.Name == companyName).Include(user => user.Company).ToListAsync(); foreach (var user in users) { var userDto = new ApplicationUserDto { Id = user.Id, UserName = user.UserName, Company = new CompanyDto { Id = user.Company.Id, Name = user.Company.Name }, Email = user.Email, PhoneNumber = user.PhoneNumber, }; //РОЛЬ var roleName = (await _userManager.GetRolesAsync(user)).FirstOrDefault(); userDto.RoleName = roleName; //КЛЕЙМЫ var userClaims = await _userManager.GetClaimsAsync(user); if (userClaims.Any()) { userDto.Claims = userClaims.ToDictionary(claim => claim.Type, claim => claim.Value); } usersDto.Add(userDto); } return(usersDto.ToList()); }
/// <summary> /// 获取 /// </summary> /// <param name="id"></param> public virtual ApplicationUserDto GetApplicationUserById(String id) { ApplicationUser applicationUser = this.ApplicationUserRepository.GetById(id); ApplicationUserDto model = new ApplicationUserDto(); model.Id = applicationUser.Id; model.CreatedAt = applicationUser.CreatedAt; model.UpdatedAt = applicationUser.UpdatedAt; model.UserName = applicationUser.UserName; model.PasswordHash = applicationUser.PasswordHash; model.PasswordSalt = applicationUser.PasswordSalt; model.NickName = applicationUser.NickName; model.FirstName = applicationUser.FirstName; model.LastName = applicationUser.LastName; model.Sex = applicationUser.Sex; model.Birthday = applicationUser.Birthday; model.Age = applicationUser.Age; model.Phone = applicationUser.Phone; model.Email = applicationUser.Email; model.HeadImageUrl = applicationUser.HeadImageUrl; model.LastLoginTime = applicationUser.LastLoginTime; model.LastLoginIP = applicationUser.LastLoginIP; model.Locked = applicationUser.Locked; model.LockedTime = applicationUser.LockedTime; model.Logined = applicationUser.Logined; return(model); }
public virtual void Update(String id, ApplicationUserDto model) { ApplicationUser applicationUser = this.ApplicationUserRepository.GetById(id); applicationUser.CreatedAt = model.CreatedAt; applicationUser.UpdatedAt = model.UpdatedAt; applicationUser.UserName = model.UserName; applicationUser.PasswordHash = model.PasswordHash; applicationUser.PasswordSalt = model.PasswordSalt; applicationUser.NickName = model.NickName; applicationUser.FirstName = model.FirstName; applicationUser.LastName = model.LastName; applicationUser.Sex = model.Sex; applicationUser.Birthday = model.Birthday; applicationUser.Age = model.Age; applicationUser.Phone = model.Phone; applicationUser.Email = model.Email; applicationUser.HeadImageUrl = model.HeadImageUrl; applicationUser.LastLoginTime = model.LastLoginTime; applicationUser.LastLoginIP = model.LastLoginIP; applicationUser.Locked = model.Locked; applicationUser.LockedTime = model.LockedTime; applicationUser.Logined = model.Logined; this.ApplicationUserRepository.Update(applicationUser); }
public async Task <bool> IsUserInRoleAsync(ApplicationUserDto userDto, string roleName) { var user = mapper.Map <ApplicationUser>(userDto); var isInRole = await userManager.IsInRoleAsync(user, roleName); return(isInRole); }
/// <summary> /// Simple implementation of user's leveling. /// </summary> /// <param name="user"></param> public UserLevelingResultDto LevelUser(ApplicationUserDto user, EventType eventType) { var result = new UserLevelingResultDto(); // Let's do levels as UserLevels 10, 100, 200, 500, 1000, 2000, // Collect all combines stats int totalStats = user.NumberOfAnswers + user.NumberOfDescriptions + user.NumberOfVotes + user.NumberOfFlags; // Check if user's stats are up to date. Would be crazy if they are not. if (!user.IsStatisticsCached) { throw new ServicesException("Can not level user without updated statistics"); } // Check if user's level corresponds to where he is at var levels = GetLevels(); int newLevel = 0; for (int i = 0; i < levels.Length - 1; i++) { if (totalStats < levels[i]) { newLevel = i; break; } } if (newLevel > user.Level) { // User's level changed. user.Level = newLevel; result.GainedLevel = true; result.Level = newLevel; UpdateUserLevel(user); } return(result); }
public async Task <Object> PostApllication(ApplicationUserDto applicationUserDto) { var data = _applicationUserBusiness.CreateAppUser(applicationUserDto); var result = data.Result.Data; return(Ok(result)); }
public async Task <object> PostApplicationUser(ApplicationUserDto model) { var userDto = new ApplicationUserDto() { FirstName = model.FirstName, LastName = model.LastName, PhoneNumber = model.PhoneNumber, UserName = model.Email, Email = model.Email }; var user = _mapper.Map <ApplicationUser>(userDto); try { var result = await _userManager.CreateAsync(user, model.Password); return(Ok(result)); } catch (Exception e) { Console.WriteLine(e); throw; } }
public async Task <IActionResult> Create(ApplicationUserDto model) { try { var user = await _userService.Create(model); if (user == null) { return(Ok(new ResultModel { Success = false, Message = Constants.Users.CreateAccountFail })); } return(Ok(new ResultModel { Success = true, Message = Constants.Users.CreateAccountSuccess })); } catch (Exception ex) { return(Ok(new ResultModel { Success = false, Message = ex.Message })); } }
public async Task GetUserById_ExistingUser_Ok() { // Arrange var adminToRequest = MockApplicationUsers.Get(0); var userToFind = MockApplicationUsers.Get(1); var expectedDto = new ApplicationUserDto(userToFind); var path = $"{Routes.UserRoute}/{userToFind.Id}"; var token = await GetToken(adminToRequest); _endSystems.SetBearerToken(token); // Act var response = await _endSystems.Get(path); var dto = JsonStringSerializer.GetApplicationUserDto(response.Body); // Assert Assert.Equal(HttpStatusCode.OK, response.Code); Assert.Equal(expectedDto.Id, dto.Id); Assert.Equal(expectedDto.Email, dto.Email); Assert.Equal(expectedDto.Name, dto.Name); // Tear down _endSystems.Dispose(); }
public void CreatedUserCount(ApplicationUserDto creator, IQueryable <ApplicationUserDto> userDtos) { var query = from u in userDtos where u.CreatedBy.Equals(creator.Email) select u; foreach (var i in query) { if (i.Role.Equals("SuperAdmin")) { creator.TotalSuperAdminCreated += 1; } if (i.Role.Equals("Admin")) { creator.TotalAdminCreated += 1; } if (i.Role.Equals("Client")) { creator.TotalClientCreated += 1; } } creator.TotalUsersCreated = creator.TotalClientCreated + creator.TotalAdminCreated + creator.TotalSuperAdminCreated; }
public void UserServiceTests_FindByIds_FindsUsers() { // Setup var setup = new TestSetup(); var user = new ApplicationUserDto() { UserId = "A" }; setup.UserService.AddUserToCache(user); var result = setup.UserService.FindByIds(new List <string>() { "A", "1", "222" }); // Only two users should be returned because "222" is not there. Assert.Equal(result.Count, 2); Assert.Null(setup.UserService.FindByIds(null)); result = setup.UserService.FindByIds(new List <string>()); Assert.Equal(result.Count, 0); }
/// <summary> /// This method shows the information of the selected ticket /// <example>tickets/Details/1</example> /// <example>tickets/Details/4</example> /// </summary> /// <param name="id">ID of the selected ticket</param> /// <returns>Details of the ticket which ID is given</returns> public ActionResult Details(int id) { ShowTicket showTicket = new ShowTicket(); //Get the current ticket from the database string url = "TicketData/FindTicket/" + id; HttpResponseMessage response = client.GetAsync(url).Result; if (response.IsSuccessStatusCode) { TicketDto SelectedTicket = response.Content.ReadAsAsync <TicketDto>().Result; showTicket.Ticket = SelectedTicket; //Get the user/owner of the selected ticket url = "TicketData/GetTicketUser/" + id; response = client.GetAsync(url).Result; ApplicationUserDto SelectedUser = response.Content.ReadAsAsync <ApplicationUserDto>().Result; showTicket.User = SelectedUser; //Get the parking spot of the selected ticket url = "TicketData/GetTicketSpot/" + id; response = client.GetAsync(url).Result; ParkingSpotDto SelectedSpot = response.Content.ReadAsAsync <ParkingSpotDto>().Result; showTicket.Spot = SelectedSpot; return(View(showTicket)); } else { return(RedirectToAction("Error")); } }
public async Task <string> Handle(LoginUserExternalQuery request, CancellationToken cancellationToken) { var user = _mapper.Map <ApplicationUserDto>(_mediator.Send(new GetUserByEmailQuery(request.Email), cancellationToken).Result); if (user == null) { var newUser = new ApplicationUserDto() { Email = request.Email, UserName = request.Email, EmailConfirmed = true }; var result = await _mediator.Send(new CreateUserCommand(newUser, GenerateRandomPassword.SecurePassword()), cancellationToken); if (!result.Succeeded) { _logger.LogInformation($"LoginUserExternal: {request.Email}: Failed login: Failed to create a local user"); throw new InvalidRegisterException("Failed to register account with third party login provider"); } } else { if (user.AccountEnabled) { throw new AccountLockedException(); } } var claims = _mediator.Send(new GetUserClaimQuery(user), cancellationToken).Result; return(_mediator.Send(new GenerateLoginTokenQuery(claims), cancellationToken).Result);; }
public ActionResult Details(int id) { ShowApplication ModelView = new ShowApplication(); //Using the Show Application View Model //Find the application by Id from the database string url = "ApplicationData/FindApplication/" + id; HttpResponseMessage response = client.GetAsync(url).Result; //Response 200 code if it is ok if (response.IsSuccessStatusCode) { ApplicationDto SelectedApplication = response.Content.ReadAsAsync <ApplicationDto>().Result; ModelView.Application = SelectedApplication; //Errors n/a if it is null //Associated Application with User url = "ApplicationData/GetUserForApplication/" + id; response = client.GetAsync(url).Result; ApplicationUserDto SelectedUser = response.Content.ReadAsAsync <ApplicationUserDto>().Result; ModelView.ApplicationUser = SelectedUser; //Errors n/a if it is null //Associated application with Job url = "ApplicationData/GetJobForApplication/" + id; response = client.GetAsync(url).Result; JobDto SelectedJob = response.Content.ReadAsAsync <JobDto>().Result; ModelView.Job = SelectedJob; return(View(ModelView)); } else { return(RedirectToAction("Error")); } }
public virtual String Save(ApplicationUserDto model) { ApplicationUser applicationUser = new ApplicationUser(); applicationUser.Id = model.Id; applicationUser.CreatedAt = model.CreatedAt; applicationUser.UpdatedAt = model.UpdatedAt; applicationUser.UserName = model.UserName; applicationUser.PasswordHash = model.PasswordHash; applicationUser.PasswordSalt = model.PasswordSalt; applicationUser.NickName = model.NickName; applicationUser.FirstName = model.FirstName; applicationUser.LastName = model.LastName; applicationUser.Sex = model.Sex; applicationUser.Birthday = model.Birthday; applicationUser.Age = model.Age; applicationUser.Phone = model.Phone; applicationUser.Email = model.Email; applicationUser.HeadImageUrl = model.HeadImageUrl; applicationUser.LastLoginTime = model.LastLoginTime; applicationUser.LastLoginIP = model.LastLoginIP; applicationUser.Locked = model.Locked; applicationUser.LockedTime = model.LockedTime; applicationUser.Logined = model.Logined; return(this.ApplicationUserRepository.Save(applicationUser)); }
public async Task GetAllUsersOrderedByNameAsync_AllInMockAndInOrder() { // Arrange var allIds = MockApplicationUsers.GetAll().Select(w => w.Id).ToHashSet(); // Act var allUsers = (await _service.GetAllUsersOrderedByNameAsync()).ToArray(); var dtoIds = allUsers.Select(w => w.Id).ToHashSet(); // Assert Assert.Equal(allIds.Count, dtoIds.Count); foreach (var id in dtoIds) { Assert.Contains(id, allIds); } var first = true; ApplicationUserDto last = null; foreach (var dto in allUsers) { if (first) { first = false; } else { Assert.True(string.Compare(dto.Name, last.Name, StringComparison.Ordinal) >= 0); } last = dto; } }
public async Task <Result <object> > CreateApplicationUser(ApplicationUserDto model) { var applicationUser = new ApplicationUser() { UserName = model.UserName, Email = model.Email, FullName = model.FullName }; try { var result = await _userManager.CreateAsync(applicationUser, model.Password); if (result.Errors.Count() > 0) { return(new Result <object>(false, ResultConstant.RecordNotCreated, result)); } return(new Result <object>(true, ResultConstant.RecordCreated, result)); } catch (Exception) { return(new Result <object>(false, ResultConstant.RecordNotCreated)); } }
public async Task EditAsync(ApplicationUserDto dto) { var existingEntity = await _context.Users.FirstOrDefaultAsync(e => e.Id == dto.Id); MapDtoToExistingEntity(dto, existingEntity); await _context.SaveChangesAsync(); }
public IActionResult Get(string username) { ApplicationUser user = _userService.GetUser(username); ApplicationUserDto dto = _mapper.Map <ApplicationUserDto>(user); return(Ok(dto)); }
/// <summary> /// Registers new user with the given <see cref="ApplicationUserDto"/> model. /// </summary> /// <param name="newUserDto">Data transfer object of the application user.</param> /// <param name="password">Password that user typed.</param> public async Task <Result <ApplicationUserDto> > RegisterAsync(ApplicationUserDto newUserDto, string password) { ApplicationUser newUser = new ApplicationUser { Email = newUserDto.Email, UserName = newUserDto.Email }; var newUserResult = await _userManager.CreateAsync(newUser, password); if (newUserResult.Succeeded) { await _signInManager.SignInAsync(newUser, false); newUserDto.Id = newUser.Id; return(new Result <ApplicationUserDto>(newUserDto)); } else { var errorResult = new Result <ApplicationUserDto>(newUserDto); foreach (var error in newUserResult.Errors) { errorResult.Errors.Add(error.Description); } return(errorResult); } }
//POST : /api/ApplicationUser/Register public async Task <IActionResult> Register(ApplicationUserDto dto) { var applicationUser = new ApplicationUser() { UserName = dto.UserName, Email = dto.Email, }; try { var result = await _userManager.CreateAsync(applicationUser, dto.Password); await _userManager.AddClaimAsync(applicationUser, new Claim("UserID", applicationUser.Id.ToString())); if (dto.IsAdmin) { await _userManager.AddClaimAsync(applicationUser, new Claim(ClaimTypes.Role, "Administrator", ClaimValueTypes.String, _iSSUER)); } return(Ok(result)); } catch (Exception ex) { return(BadRequest(ex.ToString())); } }
/// <summary> /// Remove user from this application if it registered. /// </summary> /// <param name="id"></param> /// <returns></returns> public async Task <ApplicationUserDto> Delete(string id) { try { ApplicationUserDto applicationUser = await _userManager.FindByIdAsync(id); if (applicationUser != null) { AspNetUsers user = _aguilaContext.AspNetUsers.Where(x => x.Id == id).FirstOrDefault(); IdentityResult result = await _userManager.DeleteAsync(applicationUser); if (result.Succeeded) { return(_mapper.Map <AspNetUsers, ApplicationUserDto>(user)); } else { return(null); } } else { return(null); } } catch (Exception) { return(null); } }
public async Task <ApplicationUserDto> AuthenticateAsync(LoginDto model) { var appUser = await _userManager.FindByNameAsync(model.Username); if (appUser != null) { var result = await _signInManager.CheckPasswordSignInAsync(appUser, model.Password, false); if (result.Succeeded) { // get user roles var role = await GetRoleAsync(appUser); // authentication successful so generate jwt token var token = GenerateJwtToken(appUser, role); var userDto = new ApplicationUserDto(appUser) { Token = token, Role = role }; return(userDto); } } return(null); }
public async Task <ServiceResult <LoginResponse> > Handle(GetTokenQuery request, CancellationToken cancellationToken) { ApplicationUserDto user = await _identityService.CheckUserPassword(request.Email, request.Password); if (user == null) { return(ServiceResult.Failed <LoginResponse>(ServiceError.ForbiddenError)); } var authClaims = new List <Claim> { new Claim(ClaimTypes.NameIdentifier, user.Id), new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()), }; var authSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["JWT:Secret"])); var token = new JwtSecurityToken( issuer: _configuration["JWT:ValidIssuer"], audience: _configuration["JWT:ValidAudience"], expires: DateTime.Now.AddDays(90), claims: authClaims, signingCredentials: new SigningCredentials(authSigningKey, SecurityAlgorithms.HmacSha256) ); return(ServiceResult.Success(new LoginResponse { User = user, Token = new JwtSecurityTokenHandler().WriteToken(token) })); }
public async Task <AppNetUserEntity> CreateUser(ApplicationUserDto dto, string password) { var user = new AppNetUserEntity() { UserName = dto.UserName, NormalizedUserName = dto.NormalizedUserName, Email = dto.Email, EmailConfirmed = dto.EmailConfirmed, PhoneNumber = dto.PhoneNumber, PhoneNumberConfirmed = dto.PhoneNumberConfirmed }; try { var result = await _userManager.CreateAsync(user, password); if (result.Succeeded) { // Add user to new roles // var roleNames = await _roleManager.Roles.Where(x => model.Roles.Contains(x.Id)).Select(x => x.Name).ToArrayAsync(); //var res2 = await _userManager.AddToRolesAsync(user.Id, roleNames); return(user); } else { foreach (var error in result.Errors) { //ModelState.AddModelError(string.Empty, error.Description); } } } catch (Exception er) { System.Console.WriteLine(er.Message); } return(null); }
/// <summary> /// Generate Json Web Token Method /// </summary> /// <param name="userInfo"></param> /// <returns></returns> public string GenerateJSONWebToken(ApplicationUserDto user) { var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Jwt:Key"])); var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256); List <Claim> claims = new List <Claim>() { new Claim(ClaimTypes.NameIdentifier, user.UserName), new Claim(CinemaClaimTypes.UserId, user.Id.ToString()) }; foreach (var role in user.UserRoles) { claims.Add(new Claim(ClaimTypes.Role, role.Role.Name)); } ; ClaimsIdentity claimsIdentity = new ClaimsIdentity(claims); var token = new JwtSecurityToken(_config["Jwt:Issuer"], _config["Jwt:Issuer"], claims, expires: DateTime.Now.AddMinutes(120), signingCredentials: credentials); return(new JwtSecurityTokenHandler().WriteToken(token)); }