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