public async Task <IActionResult> Add(CreateTenantCommand command)
{
command.TenantId = Guid.NewGuid().ToString();
await Mediator.Send(command);
return(RedirectToAction("List"));
}
public async Task <IActionResult> UpdateTenantAsync(
Guid id,
[FromBody] CreateTenantCommand command)
{
try
{
Enum.TryParse <TenantTypes>(command.Type, true, out TenantTypes tenantType);
await tenantService.Update(
id,
command.Name,
command.Email,
command.PrimaryAddress,
command.PhoneNumber,
command.TaxCode,
command.RegistrationCode,
command.Certificates,
tenantType);
return(Ok());
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex));
}
}
public async Task <IActionResult> Create(CreateTenantCommand command)
{
if (!ModelState.IsValid)
{
return(View(command));
}
await Mediator.Send(command);
return(RedirectToAction(nameof(Index)));
}
/// <summary>
/// insert tk root của chi nhánh
/// gán quyền tenant_Admin
/// </summary>
/// <param name="model"></param>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <param name="idCurrentUser"></param>
/// <param name="tenantCode"></param>
private async Task <User> InsertRootTenantUserAsync(CreateTenantCommand model, string userName, string password, Guid idCurrentUser, Guid tenantCode)
{
//tk root của chi nhánh
var rootUser = new User
{
Id = Guid.NewGuid(),
CreatedAt = DateTime.Now,
CreatedAtUtc = DateTime.UtcNow,
CreatedBy = idCurrentUser,
UserName = userName,
NormalizedUserName = userName.ToUpper(),
SecurityStamp = Guid.NewGuid().ToString().ToUpper().Replace("-", ""),
LockoutEnabled = true,
TenantCode = tenantCode,
Email = model.User.Email,
NormalizedEmail = string.IsNullOrEmpty(model.User.Email) ? null : model.User.Email.ToUpper()
};
var validateResultAdmin = await _passwordValidator.ValidateAsync(_userManager, rootUser, password);
if (!validateResultAdmin.Succeeded)
{
throw new Exception(validateResultAdmin.ToMessage());
}
var passwordRootHashed = _passwordHasher.HashPassword(rootUser, password);
rootUser.PasswordHash = passwordRootHashed;
var repoUser = _uow.GetRepository <IUserRepository>();
await repoUser.InsertUserAsync(rootUser);
await repoUser.InsertUserInfoAsync(new UserInfo
{
Id = rootUser.Id,
FullName = model.User.FullName
});
//Authorization
var repoPermission = _uow.GetRepository <IPermissionRepository>();
await repoPermission.InsertUserClaimsAsync(
new List <IdentityUserClaim <Guid> > {
new IdentityUserClaim <Guid>
{
UserId = rootUser.Id,
ClaimType = nameof(SpecialPolicy.Special_TenantAdmin),
ClaimValue = $"{ClaimOfResource.Tenant}|{ClaimOfChildResource.Tenant}"
}
}
);
return(rootUser);
}
/// <summary>
/// thêm tk admin của chi nhánh và gán với 1 nhóm quyền mặc định
/// </summary>
/// <param name="model"></param>
/// <param name="idCurrentUser"></param>
/// <param name="tenantCode"></param>
/// <param name="idRole"></param>
/// <returns></returns>
private async Task <User> InsertAdminTenantUserAsync(CreateTenantCommand model, Guid idCurrentUser, Guid tenantCode, Guid idRole)
{
var repoUser = _uow.GetRepository <IUserRepository>();
//tk admin
var user = new User
{
Id = Guid.NewGuid(),
CreatedAt = DateTime.Now,
CreatedAtUtc = DateTime.UtcNow,
CreatedBy = idCurrentUser,
UserName = model.User.UserName,
NormalizedUserName = model.User.UserName.ToUpper(),
SecurityStamp = Guid.NewGuid().ToString().ToUpper().Replace("-", ""),
LockoutEnabled = true,
TenantCode = tenantCode,
Email = model.User.Email,
NormalizedEmail = string.IsNullOrEmpty(model.User.Email) ? null : model.User.Email.ToUpper()
};
var validateResult = await _passwordValidator.ValidateAsync(_userManager, user, model.User.Password);
if (!validateResult.Succeeded)
{
throw new Exception(validateResult.ToMessage());
}
//Insert user admin
var passwordHashed = _passwordHasher.HashPassword(user, model.User.Password);
user.PasswordHash = passwordHashed;
await repoUser.InsertUserAsync(user);
await repoUser.InsertUserInfoAsync(new UserInfo
{
Id = user.Id,
FullName = model.User.FullName
});
//gán tk admin đc tạo có quyền admin
var repoPermission = _uow.GetRepository <IPermissionRepository>();
await repoPermission.InsertUserRolesAsync(
new List <IdentityUserRole <Guid> > {
new IdentityUserRole <Guid>
{
UserId = user.Id,
RoleId = idRole
}
});
return(user);
}
/// <summary>
/// thêm mới tenant, tenantInfo
/// </summary>
/// <param name="model"></param>
/// <param name="idCurrentUser"></param>
/// <param name="parent"></param>
/// <returns></returns>
private async Task <TenantInfo> InsertTenant(CreateTenantCommand model, Guid idCurrentUser, Tenant parent)
{
//Insert tenant
var code = Guid.NewGuid();
var repoTenant = _uow.GetRepository <ITenantRepository>();
var tenant = new Tenant
{
Code = code,
Name = model.Info.TaxCode,
CreatedAt = DateTime.Now,
CreatedAtUtc = DateTime.UtcNow,
CreatedBy = idCurrentUser,
IdParent = parent.Code,
Path = $"{parent.Path}|{code}",
IsEnable = false
};
await repoTenant.InsertAsync(tenant);
var tenantInfo = new TenantInfo
{
Code = code,
IsCurrent = true,
TaxCode = model.Info.TaxCode,
Address = model.Info.Address,
FullNameVi = model.Info.FullNameVi,
City = "#",
Country = "#",
District = "#",
// FullNameEn = model.FullNameEn,
// LegalName = model.LegalName,
// Fax = model.Fax,
// BusinessType = model.BusinessType,
// Emails = model.Emails,
// Phones = model.Phones,
// Metadata = model.Metadata.Count == 0 ? null : JsonConvert.SerializeObject(model.Metadata)
};
await repoTenant.InsertInfoAsync(tenantInfo);
var splited = model.HostName.Split(';');
foreach (var item in splited)
{
await repoTenant.InsertHostAsync(new TenantHost
{
Code = code,
HostName = item
});
}
return(tenantInfo);
}
//[Authorize("roles:admin")]
public async Task <IActionResult> CreateTenantAsync(
[FromBody] CreateTenantCommand command)
{
try
{
if (String.IsNullOrEmpty(command.Email))
{
return(BadRequest("Email cannot be null or empty."));
}
if (!string.IsNullOrEmpty(command.Certificates))
{
// Ensure each certificate provided in the command
List <string> certificateList = command.Certificates.Split(',').ToList();
foreach (var cert in certificateList)
{
if (string.IsNullOrEmpty(uploadService.GetFileUri(cert)))
{
return(BadRequest("At least one certificate name provided is not valid."));
}
}
}
if (command.PhoneNumber == null)
{
command.PhoneNumber = String.Empty;
}
if (command.Certificates == null)
{
command.Certificates = String.Empty;
}
Enum.TryParse <TenantTypes>(command.Type, true, out TenantTypes tenantType);
var result = await tenantService.Create(
command.Name,
command.Email,
command.PrimaryAddress,
command.PhoneNumber,
command.TaxCode,
command.RegistrationCode,
command.Certificates,
tenantType);
return(Ok(new { CompanyId = result }));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex));
}
}
public async Task ShouldThrowErrorWhenInvalidInformation()
{
var command = new CreateTenantCommand
{
Name = "TestTenant#01",
HostName = "localhost",
Description = "test desc",
CreatedBy = 1,
Logo = new byte[] { 1 }
};
await Assert.ThrowsAsync <ObjectAlreadyExistsException>(async() =>
await _commandHandler.Handle(command, CancellationToken.None));
}
public async Task <IActionResult> Post([FromBody] CreateTenantCommand command)
{
var userAuthorize = await _authorizationService.AuthorizeAsync(User, "tenants:write");
var applicationAuthorize = await _authorizationService.AuthorizeAsync(User, "application(tenants:write)");
if (userAuthorize.Succeeded || applicationAuthorize.Succeeded)
{
var tenant = await _mediator.Send(command);
return(Ok(tenant));
}
return(StatusCode(401));
}
public async Task ShouldGetModelForValidInformation()
{
var command = new CreateTenantCommand
{
Name = "testtom",
HostName = "localhost1",
Description = "test desc",
CreatedBy = 1,
Logo = new byte[] { 1 }
};
var tenantModel = await _commandHandler.Handle(command, CancellationToken.None);
Assert.Null(tenantModel.Errors);
Assert.Equal(command.Name, tenantModel.Items.Single().Name, ignoreCase: true);
}
public async Task <IActionResult> Post([FromBody] CreateTenantCommand command)
{
try
{
var tenant = await _mediator.Send(command);
return(Ok(tenant));
}
catch (KeyNotFoundException ex)
{
return(NotFound());
}
catch (ArgumentException argumentException)
{
return(BadRequest(argumentException.Message));
}
}
public async Task <ActionResult <ResponseModel <CreateTenantModel> > > Post([FromBody] CreateTenantCommand command)
{
try
{
var userId = Claims[ClaimTypes.Sid].ToInt();
command.CreatedBy = userId;
var createTenantModel = await Mediator.Send(command);
return(Created($"api/tenant/{createTenantModel.Items.Single().Id}", createTenantModel));
}
catch (ObjectAlreadyExistsException ex)
{
return(Conflict(new ResponseModel <CreateTenantModel>(new Error(HttpStatusCode.Conflict, ex))));
}
catch
{
return(StatusCode(HttpStatusCode.InternalServerError.ToInt()));
}
}
private async Task <Guid> CreateTenant(IAdminTenantConfiguration config, RequestContext requestContext)
{
var createTenantCommand = new CreateTenantCommand(
config.TenantName,
config.TenantCode,
config.AllowedOrigin,
config.TokenSecret,
config.TokenExpirationInMinutes,
true,
false,
false,
config.DefaultLanguage,
true)
.WithRequestContext(requestContext);
var createTenantResult = await _mediator.Send(createTenantCommand);
if (!createTenantResult.IsSuccess)
{
throw new DomainException(createTenantResult);
}
return(createTenantCommand.CorrelationId);
}
public async Task CanCreateTenant()
{
var client = SystemTestExtension.GetTokenAuthorizeHttpClient(_factory);
// The endpoint or route of the controller action.
var command = new CreateTenantCommand
{
Name = "tenaasdasd1",
HostName = "qd1e12qwd",
Description = "desasc",
CreatedBy = 1
};
var json = JsonConvert.SerializeObject(command);
var httpResponse = await client.PostAsync("/Tenant", new StringContent(json, Encoding.UTF8, StringConstants.ApplicationJson));
// Must be successful.
httpResponse.EnsureSuccessStatusCode();
Assert.True(httpResponse.IsSuccessStatusCode);
Assert.Equal(HttpStatusCode.Created, httpResponse.StatusCode);
}
public async Task <IActionResult> PostAsync([FromBody] CreateTenantCommand model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var currentUser = _workContext.GetUserCode();
var currentTenant = await _workContext.GetCurrentTenantAsync();
var repoTenant = _uow.GetRepository <ITenantRepository>();
if (await repoTenant.AnyByNameAsync(model.Info.TaxCode))
{
throw new Exception("Mã số thuế đã bị trùng");
}
if (await repoTenant.AnyByHostNameAsync(model.HostName))
{
throw new Exception("Tên miền đã bị trùng");
}
//check tên tk có bị trùng với tk root của chi nhánh không
//(tk này đặc biệt không được gán nhóm quyền nào mà chỉ có quyền là adminTenant)
var userRootTenant = "root";
if (model.User.UserName.ToUpper() == userRootTenant.ToUpper())
{
throw new Exception("Tên đăng nhập không hợp lệ. Vui lòng nhập tên đăng nhập không phải là admin!");
}
//Nếu ko nhập pasword sẽ tự động random
var isRandomPassword = false;
if (string.IsNullOrEmpty(model.User.Password))
{
model.User.Password = RandomExtension.Random(10);
isRandomPassword = true;
}
//insert tenant, tenantInfo
var tenantInfo = await InsertTenant(model, currentUser, currentTenant);
//Insert user root của tenant
var passwordRoot = RandomExtension.Random(10);
var rootUser = await InsertRootTenantUserAsync(model, userRootTenant, passwordRoot, currentUser, tenantInfo.Code);
//insert quyền mặc định
var adminRole = await AddDefaultRolesAsync(tenantInfo, currentUser);
//Insert user của chi nhánh mà nsd nhập và gán quyền admin mặc định
var adminUser = await InsertAdminTenantUserAsync(model, currentUser, tenantInfo.Code, adminRole.Id);
await _uow.CommitAsync();
////gửi mail thông báo tài khoản root mật khẩu
//var db = _redis.GetDatabase();
//await db.ListLeftPushAsync(KeyQueueBackground.SendMail, JsonConvert.SerializeObject(new
//{
// Action = "SendAccountTenant",
// Datas = JsonConvert.SerializeObject(new
// {
// TenantCode = currentTenant.Code,
// IdUser = rootUser.Id,
// Password = passwordRoot,
// })
//}));
////gửi mail thông báo tài khoản admin mật khẩu nếu là password tự động
if (isRandomPassword)
{
// await db.ListLeftPushAsync(KeyQueueBackground.SendMail, JsonConvert.SerializeObject(new
// {
// Action = "SendAccountTenant",
// Datas = JsonConvert.SerializeObject(new
// {
// TenantCode = currentTenant.Code,
// IdUser = adminUser.Id,
// Password = model.User.Password,
// })
// }));
}
return(Ok(new
{
TenantCode = tenantInfo.Code,
}));
}
public async Task <ActionResult <TenantDetailsResponse> > CreateTenant([FromBody] CreateTenantCommand command, CancellationToken cancellationToken)
{
var response = await mediator.Send(command, cancellationToken);
return(CreatedAtAction(nameof(GetTenant), new { id = response.Id }, response));
}
