public CourseBO Get(int id) { using (var uow = _facade.UnitOfWork) { CourseBO course = null; var courseFromDb = uow.CourseRepo.Get(id); if (courseFromDb != null) { var convCat = _catConv.Convert(courseFromDb.Category); var creatorConverted = _userConv.Convert(courseFromDb.Creator); //var convSecs = courseFromDb.Sections?.Select(s => _secConverter.Convert(s)).ToList(); course = ConvertCourseWithSectionsAndLessons(courseFromDb); course.Category = convCat; course.Creator = creatorConverted; // we cant use orderby in query via entity framework since we get lessons via include // so we gotta sort after the query is done foreach (var section in course.Sections) { var sortedLessons = section.Lessons.OrderBy(l => l.ListIndex).ToList(); section.Lessons = sortedLessons; } var sortedUndistributedLessons = course.Lessons.OrderBy(l => l.ListIndex).ToList(); course.Lessons = sortedUndistributedLessons; } return(course); } }
public UserBO Create(UserBO user) { using (var uow = facade.UnitOfWork) { newUser = uow.UserRepository.Create(userConv.Convert(user)); uow.Complete(); return(userConv.Convert(newUser)); } }
public UserBO Create(UserBO user) { using (var uow = _facade.UnitOfWork) { var userEntity = uow.UserRepository.Create(conv.Convert(user)); uow.Complete(); return(conv.Convert(userEntity)); } }
public ApplicationBO Get(int id) { using (var uow = _facade.UnitOfWork) { var applFromDb = uow.ApplicationRepo.Get(id); var convUser = _userConv.Convert(applFromDb.User); var application = _applicationConv.Convert(applFromDb); application.User = convUser; return(application); } }
public UserBO Create(UserBO user) { if (user == null) { return(null); } using (var uow = _facade.UnitOfWork) { var createdUser = uow.UserRepository.Create(_conv.ConvertBO(user)); uow.Complete(); return(_conv.Convert(createdUser)); } }
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 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 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 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 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 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 <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); }
/// <inheritdoc/> public UserPublic UpdateUser(UserPublic user) { UserLogic logic = new UserLogic(mDBContext); UserConverter converter = new UserConverter(mDBContext); try { UserPublic updatedUser = converter.Convert(logic.Update(converter.Convert(user))); mDBContext.SaveChangesAsync(CancellationToken.None); return(updatedUser); } catch { return(null); } }
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 <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 async Task <bool> UpdateAsync(UserDto item) { User user = UserConverter.Convert(item); var result = await _userManager.UpdateAsync(user); return(result.Succeeded); }
public override IList <DatabaseUser> Users() { var dt = _schemaReader.Users(); var list = UserConverter.Convert(dt); return(list); }
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 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 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 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 ConvertUserPassTest() { foreach (var entity in users) { var userBO = _conv.Convert(entity); Assert.NotNull(userBO); Assert.Equal(entity.FirstName, userBO.FirstName); Assert.Equal(entity.LastName, userBO.LastName); Assert.Equal(entity.UserName, userBO.UserName); Assert.Equal(entity.HomePhoneNumber, userBO.HomePhoneNumber); Assert.Equal(entity.WorkPhoneNumber, userBO.WorkPhoneNumber); Assert.Equal(entity.WorkEmail, userBO.WorkEmail); Assert.Equal(entity.Password, userBO.Password); Assert.Equal(entity.WorkTitle, userBO.WorkTitle); Assert.Equal(entity.Id, userBO.Id); } }
public async Task <UserViewModel> GetUserByIdAsync(int id, CancellationToken ct = default(CancellationToken)) { var userViewModel = UserConverter.Convert(await _userRepository.GetByIdAsync(id, ct)); userViewModel.Addresses = await GetAddressesByUserIdAsync(userViewModel.Id, ct); return(userViewModel); }
async public Task <UserDto> GetById(Guid id) { var user = UserConverter.Convert(await _um.FindByIdAsync(id.ToString())); user.IsAdmin = await _um.IsInRoleAsync(UserConverter.Convert(user), "admin"); return(user); }
async public Task <UserDto> GetByEmail(string email) { var user = UserConverter.Convert(await _um.FindByEmailAsync(email)); user.IsAdmin = await _um.IsInRoleAsync(UserConverter.Convert(user), "admin"); return(user); }
public async Task <UserDto> GetUserByIdAsync(Guid id) { UserDto user = UserConverter.Convert(await _userRepo.GetByIdAsync(id)); user.Administration = AdministrationConverter.Convert(await _adminRepo.GetByUserIdAsync(id)); user.Participant = ParticipantConverter.Convert(await _participantRepo.GetByUserIdAsync(id)); return(user); }
public async Task <ActionResult <Response <Token> > > Register([FromBody] UserDto item) { try { try { User user1 = UserConverter.Convert(item); if (user1 == null) { return(StatusCode(400, "Invalid email or password")); } User user = new User { Email = item.Email, UserName = item.Email, Name = item.Name }; var result = await _userManager.CreateAsync(user, item.Password); if (result.Succeeded) { await _userManager.AddToRoleAsync(user, "user"); await _signInManager.SignInAsync(user, false); var res = await _jwt.GenerateJwt(user); try { var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); var callbackUrl = Url.Action( "ConfirmEmail", "Auth", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme); EmailService emailService = new EmailService(_configuration); await emailService.SendEmailAsync(item.Email, "Confirm your account", $"Подтвердите регистрацию, перейдя по ссылке: <a href='{callbackUrl}'>сюда</a>"); } catch (Exception e) { return(StatusCode(400, e.ToString())); } //return res; return(StatusCode(res.Code, new Ack <Token>(res))); } return(StatusCode(400, "Invalid data")); } catch (Exception) { return(StatusCode(520, "Unknown error!")); } } catch (Exception) { return(StatusCode(520, new Ack <Token>(null, "Unknown error"))); } }
public async Task <IActionResult> GenerateToken([FromBody] Client.Models.Users.UserRegistrationInfo userInfo, [FromServices] IJwtSigningEncodingKey signingEncodingKey, CancellationToken cancellationToken) { if (userInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("UserInfo"); return(BadRequest(error)); } if (userInfo.Login == null || userInfo.Password == null) { var error = ServiceErrorResponses.NotEnoughUserData(); return(BadRequest(error)); } User user; try { user = await users.GetAsync(userInfo.Login, cancellationToken); } catch (UserNotFoundException) { var error = ServiceErrorResponses.UserNotFound(userInfo.Login); return(BadRequest(error)); } if (user.PasswordHash != Auth.AuthHash.GetHashPassword(userInfo.Password)) { var error = ServiceErrorResponses.IncorrectPassword(); return(BadRequest(error)); } var clientUser = UserConverter.Convert(user); var claims = new Claim[] { new Claim(ClaimTypes.Name, clientUser.Login), new Claim(ClaimTypes.NameIdentifier, clientUser.Id), }; var token = new JwtSecurityToken( //issuer: "ToDoTasksApp", //audience: "ToDoTasksClient", claims: claims, expires: DateTime.Now.AddMinutes(AuthOptions.LIFETIME), signingCredentials: new SigningCredentials(signingEncodingKey.GetKey(), signingEncodingKey.SigningAlgorithm) ); var encodedJwt = new JwtSecurityTokenHandler().WriteToken(token); return(Ok(new AuthTokenAnswer { Login = userInfo.Login, AccessToken = encodedJwt })); }
/// <inheritdoc/> public UserPublic CreateUser(UserPublic user) { UserLogic logic = new UserLogic(mDBContext); UserConverter converter = new UserConverter(mDBContext); try { User createdUser = logic.Create(converter.Convert(user)); mDBContext.SaveChanges(); return(converter.Convert(createdUser)); } catch { return(null); } }