public async Task <IActionResult> Register(RegisterModel model) { var existing = await _context.Users .FirstOrDefaultAsync(u => u.EmailAddress == model.EmailAddress); if (existing != null) { return(Generate(HttpStatusCode.BadRequest, $"User name \"{model.EmailAddress}\" is already taken.")); } var user = new User { EmailAddress = model.EmailAddress, Password = _hashService.GenerateHash(model.Password), FirstName = model.FirstName, LastName = model.LastName, DateOfBirth = model.DateOfBirth.Value.ToUniversalTime() }; _context.Users.Add(user); await _context.SaveChangesAsync(); var result = new UserCreatedResponse { UserId = user.Id }; return(Generate(HttpStatusCode.OK, result, "User successfully registered.")); }
public override void Seed() { if (_userRepository.Any()) { return; } _userRepository.Add(new User { Username = "******", Password = _hashService.GenerateHash("admin"), Email = "*****@*****.**", ConfirmationPhrase = Guid.NewGuid().ToString(), IsActive = true }); _userRepository.Add(new User { Username = "******", Password = _hashService.GenerateHash("ciri"), Email = "*****@*****.**", ConfirmationPhrase = Guid.NewGuid().ToString(), IsActive = true }); _userRepository.Add(new User { Username = "******", Password = _hashService.GenerateHash("geralt"), Email = "*****@*****.**", ConfirmationPhrase = Guid.NewGuid().ToString(), IsActive = true }); }
public async Task Consume(ConsumeContext <ToolBox.Contracts.Auth.UpdateAuthUser> context) { _logger.LogInformation("UpdateAuthUserConsumer Called"); var userToUpdate = await _dbContext.Users.FirstOrDefaultAsync(u => u.Id == context.Message.Id); var salt = _hashService.GenerateSalt(); if (context.Message.Username != null) { userToUpdate.UserName = context.Message.Username; } if (context.Message.Email != null) { userToUpdate.Email = context.Message.Email; } if (context.Message.Password != null) { userToUpdate.PasswordSalt = salt; userToUpdate.PasswordHash = _hashService.GenerateHash(context.Message.Password, salt); } await _dbContext.SaveChangesAsync(CancellationToken.None); await context.Publish <AuthUserUpdated>(new { userToUpdate.Id }); }
private async Task <int> AddSystemUserAsync(List <int> roleIds) { var user = await _context.Users .Include(u => u.UserRoles) .FirstOrDefaultAsync(u => u.EmailAddress == _seedSettings.EmailAddress); if (user == null) { user = new User(); _context.Users.Add(user); } user.EmailAddress = _seedSettings.EmailAddress; user.Password = _hashService.GenerateHash(_seedSettings.Password); user.FirstName = "System"; user.LastName = "Administrator"; user.DateOfBirth = new DateTime(1970, 1, 1).ToUniversalTime(); user.UserRoles.Clear(); foreach (var roleId in roleIds) { user.UserRoles.Add(new UserRole { RoleId = roleId }); } await _context.SaveChangesAsync(); return(user.Id); }
public virtual string Generate(IDbQuery query) { Ensure.That(query, "query").IsNotNull(); if (query.IsEmpty) { return(null); } var sb = new StringBuilder(); sb.AppendLine(query.Sql); foreach (var parameter in query.Parameters) { if (parameter is ArrayDacParameter) { OnVisitParam((ArrayDacParameter)parameter, sb); continue; } if (parameter is DacParameter) { OnVisitParam(parameter, sb); continue; } throw new SisoDbNotSupportedException(ExceptionMessages.DbQueryChecksumGenerator_UnsupportedDacParam); } return(HashService.GenerateHash(sb.ToString())); }
public virtual string Generate(IStructureIndex structureIndex) { if (structureIndex.DataTypeCode == DataTypeCode.Text) { throw new SisoDbNotSupportedException(ExceptionMessages.DefaultUniquesChecksumGenerator_UnsupportedDataType.Inject(structureIndex.Path)); } return(HashService.GenerateHash(SisoEnvironment.StringConverter.AsString(structureIndex.Value))); }
public void Register(RegisterRequest command) { var confirmationPhrase = Guid.NewGuid().ToString(); var user = new Models.User { Id = Guid.NewGuid(), Username = command.Username, Password = _hashService.GenerateHash(command.Password), Email = command.Email, IsActive = false, ConfirmationPhrase = confirmationPhrase }; _userRepository.Add(user); var confimationUrl = $"{command.RedirectUrl}?confirmationPhrase={confirmationPhrase}"; _mailService.SendMail( command.Email, "CallGate registration", $"In order to finish registration click {confimationUrl}." ); }
public async Task Consume(ConsumeContext <ToolBox.Contracts.Auth.CreateAuthUser> context) { _logger.LogInformation("CreateAuthUserConsumer Called"); #if DEBUG //Only add roles to debug seeded data var rolesList = new List <UserRole>(); switch (context.Message.Username) { case "Admin": rolesList.Add(new UserRole { UserId = context.Message.Id, Role = await _dbContext.Roles.FirstOrDefaultAsync(r => r.RoleName == "Admin") }); break; case "CustomerService": rolesList.Add(new UserRole { UserId = context.Message.Id, Role = await _dbContext.Roles.FirstOrDefaultAsync(r => r.RoleName == "CustomerService") }); break; } #endif var salt = _hashService.GenerateSalt(); var authUserToCreate = new Auth.Domain.Entities.AuthUser { Id = context.Message.Id, UserName = context.Message.Username, Email = context.Message.Email, PasswordSalt = salt, PasswordHash = _hashService.GenerateHash(context.Message.Password, salt), UserRoles = rolesList }; await _dbContext.Users.AddAsync(authUserToCreate); await _dbContext.SaveChangesAsync(CancellationToken.None); await context.Publish <AuthUserCreated>(new { authUserToCreate.Id }); }
public async Task <IActionResult> CreateUser(CreateUserModel model) { var existing = await _context.Users .FirstOrDefaultAsync(u => u.EmailAddress == model.EmailAddress); if (existing != null) { return(Generate(HttpStatusCode.BadRequest, $"User name \"{model.EmailAddress}\" is already taken.")); } var user = new User { EmailAddress = model.EmailAddress, Password = _hashService.GenerateHash(model.Password), FirstName = model.FirstName, LastName = model.LastName, DateOfBirth = model.DateOfBirth.Value.ToUniversalTime() }; user.UserRoles.Clear(); var roles = await _context.Roles .Where(r => model.Roles.Contains(r.Name)) .ToListAsync(); foreach (var role in roles) { user.UserRoles.Add(new UserRole { RoleId = role.Id }); } _context.Users.Add(user); await _context.SaveChangesAsync(); var result = new UserCreatedResponse { UserId = user.Id }; return(Generate(HttpStatusCode.OK, result, "User successfully created.")); }
public async Task <Link> AddRandomUrl(Link url) { string hash; while (true) { hash = await hashService.GenerateHash(url.LongURL); var isExist = await IsShortUrlExist(hash); if (!isExist) { break; } } url.ShortURL = hash; await context.Links.AddAsync(url); await context.SaveChangesAsync(); return(url); }
public async Task <IActionResult> ChangePassword(ChangePasswordModel model) { var user = await _context.Users .FirstOrDefaultAsync(u => u.Id == CurrentUserId); if (user == null || user.IsLockedOut) { return(Generate(HttpStatusCode.NotFound, "User not found.")); } var verified = _hashService.VerifyHash(model.CurrentPassword, user.Password); if (!verified) { return(Generate(HttpStatusCode.BadRequest, "Incorrect password.")); } user.Password = _hashService.GenerateHash(model.NewPassword); user.PasswordResetToken = null; await _context.SaveChangesAsync(); return(Generate(HttpStatusCode.OK, "Your password has been changed.")); }
public void GenerateHash_WhenNullInput_ThrowsArgumentNullException() { Assert.Throws <ArgumentNullException>(() => _hasher.GenerateHash(null)); }