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