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