public async Task <UserViewModel> Authenticate(string email, string password, CancellationToken ct = default(CancellationToken)) { var userViewModel = UserConverter.Convert(await _userRepository.Authenticate(email, password, ct)); if (userViewModel == null) { return(null); } var tokenHandler = new JwtSecurityTokenHandler(); var key = Encoding.ASCII.GetBytes(_appSettings.Secret); var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.Name, userViewModel.Id.ToString()) }), Expires = DateTime.UtcNow.AddDays(7), SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature) }; var token = tokenHandler.CreateToken(tokenDescriptor); userViewModel.Token = tokenHandler.WriteToken(token); return(userViewModel); }
public List <UserModel> GetUsers(int usersPageNumber) { var entities = _iUserDAO.GetUsers(usersPageNumber); var models = UserConverter.EntitiesToModels(entities); return(models); }
public async Task <bool> SaveUser(DtoUser user) { try { using (var data = Context) { var u = await(from item in data.Users where user.Id == item.id select item).FirstOrDefaultAsync(); // Updating user if (u != null) { u.login = user.Login; u.cardId = user.CardId; u.password = AuthenticationLogic.HashPassword(user.Password, user.Login); //u.isAdmin = user.IsAdmin; u.averageScore = user.AverageScore; } // Adding new user else { data.Users.Add(UserConverter.DtoToDataAccess(user)); } await data.SaveChangesAsync(); } return(true); } catch (Exception) { return(false); } }
public UserModel GetUserById(int id) { var entity = _iUserDAO.GetUserById(id); var model = UserConverter.EntityToModel(entity); return(model); }
public async Task <Response <Token> > Register(UserDto item) { try { User user = UserConverter.Convert(item); if (user == null) { return(new Response <Token>(400, "Invalid email or password")); } user.RoleType = RoleType.User; var result = await _userManager.CreateAsync(user, item.Password); if (result.Succeeded) { await _signInManager.SignInAsync(user, false); return(await _jwt.GenerateJwt(user)); } return(new Response <Token>(400, "Invalid data")); } catch (Exception) { return(new Response <Token>(520, "Unknown error")); } }
public async Task <List <UserVm> > FindUsersByStringQueryAsync(string stringQuery, long?navigationUserId = 0, bool?direction = true) { using (MessengerDbContext context = contextFactory.Create()) { ExpressionsHelper helper = new ExpressionsHelper(); var query = context.Users .Include(opt => opt.Emails) .Include(opt => opt.Phones) .Include(opt => opt.BlackList) .Where(opt => opt.NodeId == NodeSettings.Configs.Node.Id && opt.Deleted == false && !opt.Deleted && opt.Confirmed == true); if (direction.GetValueOrDefault()) { query = query.OrderBy(opt => opt.Id) .Where(opt => opt.Id > navigationUserId.GetValueOrDefault()); } else { query = query.OrderByDescending(opt => opt.Id) .Where(opt => opt.Id < navigationUserId.GetValueOrDefault()); } List <User> users = await query.Where(helper.GetUserExpression(stringQuery)) .ToListAsync().ConfigureAwait(false); return(UserConverter.GetUsersVm(users)); } }
public async Task <bool> UpdateAsync(UserDto item) { User user = UserConverter.Convert(item); var result = await _userManager.UpdateAsync(user); return(result.Succeeded); }
public async Task <IActionResult> Register([FromBody] Client.Users.UserRegistrationInfo registrationInfo, CancellationToken cancellationToken) { if (registrationInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("UserRegistrationInfo"); return(this.BadRequest(error)); } User result; var creationInfo = new UserCreationInfo(registrationInfo.Login, Authenticator.HashPassword(registrationInfo.Password), registrationInfo.FirstName, registrationInfo.LastName, registrationInfo.Email, registrationInfo.Phone); try { result = await userRepository.CreateAsync(creationInfo, cancellationToken); } catch (UserDuplicationException) { var error = ServiceErrorResponses.ConflictLogin(creationInfo?.Login); return(this.Conflict(error)); } var clientUser = UserConverter.Convert(result); return(this.Ok(clientUser)); }
public override IList <DatabaseUser> Users() { var dt = _schemaReader.Users(); var list = UserConverter.Convert(dt); return(list); }
public async Task <IActionResult> UpdateAsync([FromBody] Client.Users.UserPatchInfo patchInfo, CancellationToken cancellationToken) { if (patchInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("UserPatchInfo"); return(this.BadRequest(error)); } var userId = User.FindFirstValue("userId"); if (userId == null) { var error = ServiceErrorResponses.InvalidClaims("userId"); return(this.BadRequest(error)); } User modelUser; try { modelUser = await userRepository.PatchAsync(patchInfo, userId, cancellationToken); } catch (UserNotFoundException e) { var error = ServiceErrorResponses.NoSuchObject("User", e.Message); return(this.NotFound(error)); } var clientUserInfo = UserConverter.ConvertToUserInfo(modelUser); return(Ok(clientUserInfo)); }
public async Task <List <ValuePair <UserDto, byte[]> > > GetPollVotedUsersAsync(Guid pollId, long conversationId, ConversationType conversationType, byte optionId, long?requestorId, int limit = 30, long navigationUserId = 0) { using (MessengerDbContext context = contextFactory.Create()) { var poll = await context.Polls.FirstOrDefaultAsync(opt => opt.PollId == pollId && opt.ConversationType == conversationType && opt.ConvertsationId == conversationId) .ConfigureAwait(false); if (requestorId.GetValueOrDefault() != poll.CreatorId && !poll.ResultsVisibility && !await conversationsService.IsUserInConversationAsync(conversationType, conversationId, requestorId.GetValueOrDefault()).ConfigureAwait(false)) { throw new PermissionDeniedException(); } List <PollOptionVote> votes = await context.PollsOptionsVotes .Include(opt => opt.User) .Include(opt => opt.User.Phones) .Include(opt => opt.User.Emails) .Include(opt => opt.User.BlackList) .Where(opt => opt.ConversationId == conversationId && opt.ConversationType == conversationType && opt.PollId == pollId && opt.OptionId == optionId && opt.UserId > navigationUserId) .OrderBy(opt => opt.UserId) .Take(limit) .ToListAsync() .ConfigureAwait(false); return(votes.Select(vote => new ValuePair <UserDto, byte[]>(UserConverter.GetUserDto(vote.User), vote.Sign)).ToList()); } }
public void Convert_ConvertsExistingServiceModelToEntity_ReturnsConvertedEntity() { // ARRANGE DbContextOptions <TestDatabaseContext> options = new DbContextOptionsBuilder <TestDatabaseContext>() .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) .Options; IDatabaseContext dbContext = new TestDatabaseContext(options); User user = new User() { ID = 1, FirstName = "Johhny", LastName = "Test", OAuthID = "12345" }; dbContext.Users.Add(user); dbContext.SaveChanges(); UserConverter converter = new UserConverter(dbContext); UserPublic userPublic = new UserPublic() { ID = 1, FirstName = "Johhny", LastName = "Test", OAuthID = "12345" }; // ACT User user2 = converter.Convert(userPublic); // ASSERT user2.Should().BeEquivalentTo <User>(user); }
public UserModel getUserInfo(string openId) { UserProvider provider = new UserProvider(); UserModel model = UserConverter.userEntityToModel(provider.getUserInfo(openId)); return(model); }
public VMFacade(IFactionPlayerService factionPlayerService, IFactionService factionService, IPlayerService playerService) { _factionPlayerService = factionPlayerService; _factionService = factionService; _playerService = playerService; _userConverter = new UserConverter(); }
public async Task <IActionResult> GetUserByLoginAsync([FromRoute] string userLogin, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (userLogin == null) { var error = ServiceErrorResponses.BodyIsMissing(userLogin); return(BadRequest(error)); } User modelUser = null; try { modelUser = await repository.GetAsync(userLogin, cancellationToken).ConfigureAwait(false); } catch (UserNotFoundException) { var error = ServiceErrorResponses.UserNotFound(userLogin); return(NotFound(error)); } var clientUser = UserConverter.Convert(modelUser); return(Ok(clientUser)); }
public UserService() { _accountConverter = new AccountDataConverter(); UserProvider = new UserProvider(); _userConverter = new UserConverter(); _chatConverter = new ChatConverter(); }
public async Task <IActionResult> CreateUserAsync([FromBody] Client.UserCreationInfo creationInfo, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (creationInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("UserCreationInfo"); return(BadRequest(error)); } var hashPassword = PasswordEncoder.Encode(creationInfo.Password); var modelCreationInfo = new UserCreationInfo(creationInfo.Login, hashPassword); User modelUser = null; try { modelUser = await repository.CreateAsync(modelCreationInfo, cancellationToken) .ConfigureAwait(false); } catch (UserDuplicationException) { var error = ServiceErrorResponses.UserDuplication(modelCreationInfo.Login); return(BadRequest(error)); } var clientUser = UserConverter.Convert(modelUser); return(Ok(clientUser)); }
public async Task <Response <string> > Register(UserDto item, string role) { try { User user = UserConverter.Convert(item); if (user == null) { return(new Response <string>(400, "Invalid email or password")); } var result = await _userManager.CreateAsync(user, item.Password); if (result.Succeeded) { await _userManager.AddToRoleAsync(user, role); await SendConfirmation(user); await _signInManager.SignInAsync(user, false); return(new Response <string>(200, "Get your token from message")); } return(new Response <string>(400, "Invalid data")); } catch (Exception) { return(new Response <string>(520, "Unknown error")); } }
public async Task <IActionResult> Update(string id, [FromBody] View.UserPatchInfo userToUpdate) { var user = UserConverter.ConvertPatchInfo(userToUpdate); var guidId = Guid.Parse(id); Guid.TryParse(HttpContext.User.Identity.Name, out var userId); if (userId != guidId) { return(BadRequest(new { message = "Запрещено для этого пользователя" })); } user.Id = guidId; try { await userService.UpdateAsync(user, userToUpdate.Password); return(Ok()); } catch (AppException ex) { return(BadRequest(new { message = ex.Message })); } }
public async Task <object> Register(UserDto item) { try { User user = UserConverter.Convert(item); if (user == null) { return(null); } var result = await _userManager.CreateAsync(user, item.Password); if (result.Succeeded) { await _userManager.AddToRoleAsync(user, "user"); await _signInManager.SignInAsync(user, false); return(await _jwt.GenerateJwt(user)); } return(null); } catch (Exception) { return(null); } }
public UserModel getCoverUser() { UserProvider provider = new UserProvider(); UserModel model = UserConverter.userEntityToModel(provider.getCoverPageUser()); return(model); }
public AuthenticationService(StockContext context, IDataProtectionProvider provider, IConfiguration configuration) { _context = context; converter = new UserConverter(); _protector = provider.CreateProtector("ConfigurationManager.ConnectionStrings['StockManagerConnectionString'].ConnectionString"); _configuration = configuration; }
public LoginBusinessImpl(IUserRepository repository, SigningConfigurations signingConfigurations, TokenConfiguration tokenConfiguration) { _repository = repository; _signingConfigurations = signingConfigurations; _tokenConfigurations = tokenConfiguration; _converter = new UserConverter(); }
public void GetUser_OnExistingUser_ReturnsUser() { // ARRANGE DbContextOptions <TestDatabaseContext> options = new DbContextOptionsBuilder <TestDatabaseContext>() .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) .Options; IDatabaseContext dbContext = new TestDatabaseContext(options); UserRepository repository = new UserRepository(dbContext); UserConverter converter = new UserConverter(dbContext); User user = new User() { FirstName = "Jan", LastName = "Kowalski", }; dbContext.Users.Add(user); dbContext.SaveChanges(); // ACT UserPublic userPublic = repository.GetUser(1); // ASSERT userPublic.Should().BeEquivalentTo <UserPublic>(converter.Convert(user)); }
public UserBusiness(IUserRepository repository, SignInConfiguration signInConfiguration, TokenConfiguration tokenConfiguration) { _repository = repository; _signInConfiguration = signInConfiguration; _tokenConfiguration = tokenConfiguration; _converter = new UserConverter(); }
public void Convert_ConvertsEntityToServiceModel_ReturnsConvertedModel() { // ARRANGE DbContextOptions <TestDatabaseContext> options = new DbContextOptionsBuilder <TestDatabaseContext>() .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) .Options; IDatabaseContext dbContext = new TestDatabaseContext(options); UserConverter converter = new UserConverter(dbContext); User user = new User() { ID = 1, FirstName = "Johhny", LastName = "Test", OAuthID = "12345" }; // ACT UserPublic userPublic = converter.Convert(user); // ASSERT userPublic.Should().BeEquivalentTo <UserPublic>(new UserPublic() { ID = 1, FirstName = "Johhny", LastName = "Test", OAuthID = "12345" }); }
public HttpResponseMessage Put(Guid id, UserDTO userDTO) { var post = UserApplication.Get(id); if (post == null) { return(Request.CreateResponse(HttpStatusCode.NotFound, new Note("Usuário não encontrado", Note.NoteType.Success))); } var converter = new UserConverter(); converter.Convert(userDTO, post); try { UserApplication.Save(post); return(Request.CreateResponse(HttpStatusCode.OK, new Note("Usuário criado com sucesso", Note.NoteType.Success))); } catch (InvalidModelState ex) { return(Request.CreateResponse(HttpStatusCode.BadRequest, new Note("Não foi possível criar o post", ex.Details, Note.NoteType.Warning))); } catch (Exception ex) { return(Request.CreateResponse(HttpStatusCode.BadRequest, new Note("Não foi possível criar o usuário", ex.Message, Note.NoteType.Error))); } }
public async Task <IActionResult> RegisterUser([FromBody] Client.Models.Users.UserRegistrationInfo registrationInfo, CancellationToken cancellationToken) { if (registrationInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("RegistrationInfo"); return(BadRequest(error)); } if (registrationInfo.Login == null || registrationInfo.Password == null) { var error = ServiceErrorResponses.NotEnoughUserData(); return(BadRequest(error)); } var creationInfo = new UserCreationInfo(registrationInfo.Login, Auth.AuthHash.GetHashPassword(registrationInfo.Password)); User user = null; try { user = await users.CreateAsync(creationInfo, cancellationToken); } catch (UserDuplicationException) { var error = ServiceErrorResponses.UserNameAlreadyExists(registrationInfo.Login); return(BadRequest(error)); } var clientUser = UserConverter.Convert(user); return(Ok(clientUser)); }
public async Task <ActionResult> Refresh() { var tokenJSON = Request.Cookies.SingleOrDefault(c => c.Key == "token").Value; var token = JsonConvert.DeserializeObject(tokenJSON, typeof(AccessToken)) as AccessToken; var refreshToken = token.refresh_token; var principal = _tokens.GetPrincipalFromExpiredToken(token.token); var username = principal.Identity.Name; var user = _userManager.Users.Include(u => u.RefreshToken).SingleOrDefault(u => u.UserName == username); if (user == null || user.RefreshToken.Token != refreshToken) { return(BadRequest()); } ClaimsIdentity identity = await _getIdentity.GenerateClaimsIdentity(user); if (identity == null) { return(BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid username or password.", ModelState))); } var userView = UserConverter.Convert(user); if (await _moviesPlaceSupervisor.ValidRefreshTokenAsync(userView, refreshToken)) { string refreshTokenNew = Tokens.GenerateRefreshToken(); if (!await _moviesPlaceSupervisor.DeleteRefreshTokenAsync(userView, refreshToken)) { return(BadRequest(Errors.AddErrorToModelState("token_failure", "The refresh token did not match", ModelState))); } await _moviesPlaceSupervisor.SaveRefreshTokenAsync(userView, refreshTokenNew); string newJwtToken = await Tokens.GenerateJwt(identity, _jwtFactory, userView.Username, _jwtOptions, refreshTokenNew, new JsonSerializerSettings { Formatting = Formatting.Indented }); Response.Cookies.Delete("token"); Response.Cookies.Append( "token", newJwtToken, new Microsoft.AspNetCore.Http.CookieOptions() { HttpOnly = true, SameSite = SameSiteMode.Strict, Expires = DateTime.Now.AddDays(5) }); return(new OkObjectResult(newJwtToken)); } return(BadRequest(Errors.AddErrorToModelState("token_failure", "Expired or invalid refresh token.", ModelState))); }
public async Task <ActionResult <UserDto> > GetUserWithData(Guid id) { var user = UserConverter.Convert(await _userManager.Users .Include(u => u.Settings) .ThenInclude(s => s.Notifications) .Include(u => u.Vip) .Include(u => u.Exercises) .ThenInclude(e => e.PullUps) .Include(u => u.Exercises) .ThenInclude(e => e.PushUps) .Include(u => u.Exercises) .ThenInclude(e => e.Abs) .Include(u => u.Exercises) .ThenInclude(e => e.Squats) .FirstOrDefaultAsync(u => u.Id == id)); user.Settings.User = null; user.Vip.User = null; user.Exercises.User = null; if (user == null) { return(NotFound()); } return(user); }
public void User_Should_Be_Converted_From_Xml_String() { string input = @"<?xml version=""1.0"" encoding=""UTF-8""?> <user> <id type=""integer"">1</id> <name>Sebastian Munz</name> <email>[email protected]</email> <note></note> <archived type=""boolean"">false</archived> <role>coworker</role> <language>de</language> <created-at type=""datetime"">2007-06-23T23:00:58+02:00</created-at> <updated-at type=""datetime"">2009-02-14T00:33:26+01:00</updated-at> </user> "; User user = new UserConverter().Convert(input); Assert.That(user.Role, Is.EqualTo(Role.coworker)); }