/// <inheritdoc />
public async Task <Dto.GetDetailsAsync.ResponseDto> RegisterAsync(Dto.RegisterAsync.RequestDto dto)
{
if (string.IsNullOrWhiteSpace(dto.Password))
{
throw new InvalidPasswordException(_l["Password is required."]);
}
var existingUser = await _db.Users.FirstOrDefaultAsync(
x => x.Username == dto.Username || x.Email == dto.Email);
if (existingUser?.Username == dto.Username)
{
throw new UsernameTakenException(string.Format(_l["Username '{0}' is already taken."], dto.Username));
}
if (existingUser?.Email == dto.Email)
{
throw new EmailTakenException(string.Format(_l["Email '{0}' is already taken."], dto.Email));
}
var(passwordHash, passwordSalt) = _passwordHelper.CreateHash(dto.Password);
var user = new User
{
Id = Guid.NewGuid(),
GivenName = dto.GivenName,
FamilyName = dto.FamilyName,
Username = dto.Username,
IsActive = false
// Email must be confirmed first.
};
var emailSuccess = await ChangeEmailAsync(user, dto.Email);
user.CreatedAt = DateTime.UtcNow;
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
if (!emailSuccess)
{
throw new EmailNotSentException(_l["Sending of confirmation email failed."]);
}
await _db.Users.AddAsync(user);
await _db.SaveChangesAsync();
return(new Dto.GetDetailsAsync.ResponseDto
{
Id = user.Id,
Username = user.Username,
GivenName = user.GivenName,
FamilyName = user.FamilyName,
Email = user.Email,
CreatedAt = user.CreatedAt,
UpdatedAt = user.UpdatedAt,
LastLoginAt = user.LastLoginAt,
IsActive = user.IsActive
});
}
/// <summary>
/// Creates list of users.
/// </summary>
/// <param name="count">The number of users to create.</param>
/// <param name="password">The password that will be set for every user.</param>
/// <returns>The list of users.</returns>
public List <User> CreateUsers(int count, string password)
{
var users = new List <User>();
for (var i = 0; i < count; i++)
{
var(passwordHash, passwordSalt) = _passwordHelper.CreateHash(password);
users.Add(new User
{
Id = Guid.NewGuid(),
Username = "******" + i,
GivenName = "First name " + i,
FamilyName = "Last name " + i,
Email = $"email{i}@example.com",
CreatedAt = DateTime.UtcNow,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt,
IsActive = true
});
}
Context.Users.AddRange(users);
Context.SaveChanges();
return(users);
}
public void Create_WhenCalled_CreatesUser()
{
// Arrange
var (passwordHash, passwordSalt) = _passwordHelper.CreateHash("test_password");
var user = new User
{
FirstName = "test first name",
LastName = "test last name",
Username = "******",
PasswordHash = passwordHash,
PasswordSalt = passwordSalt
};
// Act
var response = _service.Create(user, "test_password");
// Assert
Assert.Equal(user.Username, response.Username);
Assert.Equal(user.FirstName, response.FirstName);
Assert.Equal(user.LastName, response.LastName);
var userFromDb = _db.Users.Single(x => x.Username == user.Username);
Assert.Equal(user.Username, userFromDb.Username);
Assert.Equal(user.FirstName, userFromDb.FirstName);
Assert.Equal(user.LastName, userFromDb.LastName);
Assert.True(_passwordHelper.VerifyHash("test_password", userFromDb.PasswordHash, userFromDb.PasswordSalt));
}
public User Register(User user)
{
var userExists = _uow.Users.Any(a => a.Email == user.Email);
if (userExists)
{
throw new ValidationException("Email currently exists.");
}
user.Password = _passHelper.CreateHash(user.Password);
user.Picture = "https://forum.mikrotik.com/styles/canvas/theme/images/no_avatar.jpg";
_uow.Users.Add(user, "");
_uow.Save();
return(user);
}
public List <User> CreateUsers(int count, string password)
{
var users = new List <User>();
for (var i = 0; i < count; i++)
{
var(passwordHash, passwordSalt) = _passwordHelper.CreateHash(password);
users.Add(new User
{
Id = i + 1,
Username = "******" + i,
FirstName = "First name " + i,
LastName = "Last name " + i,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt,
});
}
Context.Users.AddRange(users);
Context.SaveChanges();
return(users);
}
/// <summary>
/// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
/// </summary>
/// <param name="app">Provides the mechanisms to configure an application's request pipeline.</param>
/// <param name="env">Provides information about the web hosting environment an application is running in.
/// </param>
/// <param name="appDbContext">The database context.</param>
/// <param name="passwordHelper">The helper object for working with passwords.</param>
/// <param name="logger">The logger.</param>
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, AppDbContext appDbContext,
IPasswordHelper passwordHelper, ILogger <Startup> logger)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
// Handle all uncaught exceptions.
app.UseExceptionHandler(a => a.Run(
async context =>
{
var exceptionHandlerPathFeature = context.Features.Get <IExceptionHandlerPathFeature>();
var exception = exceptionHandlerPathFeature.Error;
logger.LogError(exception, $"Unhandled exception caught by middleware: {exception.Message}");
var result = JsonConvert.SerializeObject(new { error = exception.Message });
context.Response.ContentType = "application/json";
context.Response.StatusCode = 500;
await context.Response.WriteAsync(result);
}));
// Migrate any database changes on startup (includes initial database creation).
appDbContext.Database.Migrate();
// Seed admin user and role.
using (var serviceScope = app.ApplicationServices.GetService <IServiceScopeFactory>().CreateScope())
{
var db = serviceScope.ServiceProvider.GetService <AppDbContext>();
if (db.Users.FirstOrDefault(x => x.Username == _appSettings.AdminUsername) == null)
{
var(passwordHash, passwordSalt) = passwordHelper.CreateHash(_appSettings.AdminPassword);
var user = new User
{
Id = Guid.NewGuid(),
Username = _appSettings.AdminUsername,
Email = _appSettings.AdminEmail,
CreatedAt = DateTime.UtcNow,
IsActive = true,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt
};
db.Users.Add(user);
db.SaveChanges();
var role = new Role
{
Id = Guid.NewGuid(),
Name = Models.EnumerationTypes.Role.Admin.ToString(),
CreatedById = user.Id
};
db.Roles.Add(role);
user.RoleId = role.Id;
db.SaveChanges();
}
}
// The localization middleware must be configured before
// any middleware which might check the request culture.
var supportedCultures = new[]
{
new CultureInfo("en"),
new CultureInfo("bs")
};
app.UseRequestLocalization(new RequestLocalizationOptions
{
DefaultRequestCulture = new RequestCulture("en"),
// Formatting numbers, dates, etc.
SupportedCultures = supportedCultures,
// UI strings that we have localized.
SupportedUICultures = supportedCultures
});
app.UseRouting();
// Set global CORS policy.
app.UseCors(configuration => configuration.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
endpoints.MapHealthChecks("/health");
}
);
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "Web API V1");
c.DisplayRequestDuration();
});
}
