public async Task <IdentityUtilsResult <TUserDto> > CreateUser(TUserDto user)
{
var userDb = mapper.Map <TUser>(user);
var result = ModelValidator.ValidateDataAnnotations(userDb).ToIdentityUtilsResult();
if (!result.Success)
{
return(result.ToTypedResult <TUserDto>());
}
var managerValidationResult = await new UserValidator <TUser>().ValidateAsync(userManager, userDb);
if (!managerValidationResult.Succeeded)
{
return(managerValidationResult.ToIdentityUtilsResult().ToTypedResult <TUserDto>());
}
result = (await userManager.CreateAsync(userDb, user.Password ?? "")).ToIdentityUtilsResult();
if (result.Success)
{
user.Password = null;
mapper.Map(userDb, user);
}
return(result.ToTypedResult(user));
}
public async Task <IdentityUtilsResult <TTenantDto> > AddTenant(TTenantDto tenantDto)
{
tenantDto.Hostnames ??= new List <string>();
var hostsAlreadyExist = await dbContext.TenantHosts
.Where(x => tenantDto.Hostnames.Contains(x.Hostname))
.AnyAsync();
if (hostsAlreadyExist)
{
return(IdentityUtilsResult <TTenantDto> .ErrorResult("Hostname already assigned to different tenant"));
}
var tenant = mapper.Map <TTenant>(tenantDto);
tenant.Hosts = tenantDto.Hostnames
.Select(x => new IdentityManagerTenantHost
{
Hostname = x.Trim()
})
.ToList();
var result = ModelValidator.ValidateDataAnnotations(tenant);
if (!result.isValid)
{
return(IdentityUtilsResult <TTenantDto> .ErrorResult(result.ToIdentityUtilsResult().ErrorMessages));
}
dbContext.Tenants.Add(tenant);
await dbContext.SaveChangesAsync();
return(IdentityUtilsResult <TTenantDto> .SuccessResult(ToDto(tenant)));
}
public async Task <IdentityUtilsResult <TRoleDto> > AddRole(TRoleDto roleDto)
{
roleDto.Name = roleDto.Name.Trim();
var role = mapper.Map <TRole>(roleDto);
var result = ModelValidator.ValidateDataAnnotations(role).ToIdentityUtilsResult();
if (!result.Success)
{
return(result.ToTypedResult <TRoleDto>());
}
var managerValidationResult = await new RoleValidator <TRole>().ValidateAsync(roleManager, role);
if (!managerValidationResult.Succeeded)
{
return(managerValidationResult.ToIdentityUtilsResult().ToTypedResult <TRoleDto>());
}
var roleResult = await roleManager.CreateAsync(role);
if (!roleResult.Succeeded)
{
return(roleResult.ToIdentityUtilsResult().ToTypedResult <TRoleDto>());
}
mapper.Map(role, roleDto);
return(IdentityUtilsResult <TRoleDto> .SuccessResult(roleDto));
}
public async Task <IdentityUtilsResult <TTenantDto> > UpdateTenant(TTenantDto tenantDto)
{
using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
var hostsAlreadyExist = await dbContext.TenantHosts
.Where(x => x.TenantId != tenantDto.TenantId)
.Where(x => tenantDto.Hostnames.Contains(x.Hostname))
.AnyAsync();
if (hostsAlreadyExist)
{
return(IdentityUtilsResult <TTenantDto> .ErrorResult("Hostname already assigned to different tenant"));
}
var currentHosts = dbContext.TenantHosts.Where(x => x.TenantId == tenantDto.TenantId);
dbContext.TenantHosts.RemoveRange(currentHosts);
await dbContext.SaveChangesAsync();
var tenantDbResult = await GetTenantDb(tenantDto.TenantId, false);
if (!tenantDbResult.Success)
{
return(IdentityUtilsResult <TTenantDto> .ErrorResult(tenantDbResult.ErrorMessages));
}
var tenant = tenantDbResult.Data.First();
mapper.Map(tenantDto, tenant);
var hosts = tenantDto.Hostnames
.Select(x => new IdentityManagerTenantHost
{
TenantId = tenantDto.TenantId,
Hostname = x
});
var result = ModelValidator.ValidateDataAnnotations(tenant);
if (!result.isValid)
{
return(IdentityUtilsResult <TTenantDto> .ErrorResult(result.ToIdentityUtilsResult().ErrorMessages));
}
dbContext.Tenants.Update(tenant);
dbContext.TenantHosts.AddRange(hosts);
await dbContext.SaveChangesAsync();
scope.Complete();
return(IdentityUtilsResult <TTenantDto> .SuccessResult(ToDto(tenant)));
}
public async Task <IdentityUtilsResult> UpdateUser(TUserDto user)
{
var userDbResult = await FindByIdAsync(user.Id);
if (!userDbResult.Success)
{
return(IdentityUtilsResult.ErrorResult(userDbResult.ErrorMessages));
}
var userDb = userDbResult.Data.First();
mapper.Map(user, userDb);
var result = ModelValidator.ValidateDataAnnotations(userDb).ToIdentityUtilsResult();
if (!result.Success)
{
return(result.ToTypedResult <TUserDto>());
}
var managerValidationResult = await new UserValidator <TUser>().ValidateAsync(userManager, userDb);
if (!managerValidationResult.Succeeded)
{
return(managerValidationResult.ToIdentityUtilsResult().ToTypedResult <TUserDto>());
}
var identityResult = await userManager.UpdateAsync(userDb);
if (!identityResult.Succeeded)
{
return(identityResult.ToIdentityUtilsResult());
}
mapper.Map(userDbResult.Data.Single(), user);
return(IdentityUtilsResult.SuccessResult);
}
