public async Task UpdateTenant_Test()
{
CreateTenantDto dto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var createResult = await _tenantAppService.CreateAsync(dto);
createResult.Name = "NewTenant";
createResult.Contact = "ContactName";
createResult.Address = "TestAddress";
createResult.Logo = "LogoUrl";
var updateResult = await _tenantAppService.UpdateAsync(createResult);
await UsingDbContextAsync(async context =>
{
var testTenant = await context.Tenants.FirstOrDefaultAsync(u => u.TenancyName == dto.TenancyName);
testTenant.Name.ShouldBe("NewTenant");
testTenant.Contact.ShouldBe("ContactName");
testTenant.Address.ShouldBe("TestAddress");
testTenant.Logo.ShouldBe("LogoUrl");
});
}
public async Task Create_Get_Update_Delete_Tenant_Test()
{
var dto = new CreateTenantDto
{
DisplayName = "Tenant_TEST",
IsActive = true,
TenancyName = "Tenant_TEST"
};
await _tenantAppService.CreateTenant(dto);
var dtoEdit = await _tenantAppService.GetTenant(dto.TenancyName);
dtoEdit.ShouldNotBe(null);
dtoEdit.TenancyName.ShouldBe("Tenant_TEST");
dtoEdit.TenancyName = "Tenant_TEST_UPDATE";
await _tenantAppService.UpdateTenant(dtoEdit);
var dtoGet = await _tenantAppService.GetTenant("Tenant_TEST_UPDATE");
dtoGet.ShouldNotBe(null);
dtoEdit.TenancyName.ShouldBe("Tenant_TEST_UPDATE");
await _tenantAppService.DeleteTenant(new Abp.Application.Services.Dto.EntityRequestInput <Guid>(dtoGet.Id));
var tenant = await _tenantAppService.GetTenant(new Abp.Application.Services.Dto.EntityRequestInput <Guid>(dtoGet.Id));
tenant.ShouldBe(null);
}
public async Task GetRoleInTenant_WrongTenantId_Test()
{
CreateTenantDto createTenantDto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(createTenantDto);
var createRoleDto1 = new CreateRoleDto()
{
Name = "Role1",
DisplayName = "Test role1",
Description = "Role1 for test",
GrantedPermissions = new List <string>()
{
PermissionNames.Pages_Roles
}
};
var role1Dto = await _omRoleAppService.CreateRoleInTenantAsync(tenantDto.Id, createRoleDto1);
try
{
var getRole1Dto = await _omRoleAppService.GetRoleInTenantAsync(1, new EntityDto <int>(role1Dto.Id));
}
catch (Exception exception)
{
exception.Message.ShouldBe("There is no role with id: 4");
}
}
public async Task UpdateUserInTenant_Test()
{
CreateTenantDto dto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(dto);
// Create user with role and orgunit (orgunit contain role)
CreateUserDto createUserDto = new CreateUserDto()
{
UserName = "******",
Password = User.DefaultPassword,
Name = "John",
Surname = "Smith",
PhoneNumber = "13851400001",
IsActive = true
};
var userDto = await _omUserAppService.CreateUserInTenantAsync(tenantDto.Id, createUserDto);
var getUserDto = await _omUserAppService.GetUserInTenantAsync(tenantDto.Id, new EntityDto <long>(userDto.Id));
getUserDto.Name = "Johnny";
var updatedUser = await _omUserAppService.UpdateUserInTenantAsync(tenantDto.Id, getUserDto);
updatedUser.FullName.ShouldBe("Johnny Smith");
}
public async Task CreateRoleInTenant_Test()
{
CreateTenantDto createTenantDto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(createTenantDto);
CreateRoleDto createRoleDto = new CreateRoleDto()
{
Name = "RoleTest",
DisplayName = "Test role",
Description = "Role for test",
GrantedPermissions = new List <string>()
{
PermissionNames.Pages_Roles
}
};
var roleDto = await _omRoleAppService.CreateRoleInTenantAsync(tenantDto.Id, createRoleDto);
roleDto.Id.ShouldNotBe(0);
roleDto.NormalizedName.ShouldBe("ROLETEST");
await UsingDbContextAsync(async context =>
{
var testTenant = await context.Roles.FirstOrDefaultAsync(r => r.Id == roleDto.Id);
testTenant.TenantId.ShouldBe(tenantDto.Id);
});
}
public async Task CreateTenant(CreateTenantDto input)
{
var hashedPassword = SecurePasswordHasherHelper.Hash(input.Password);
var user = new Tenant
{
TenantName = input.TenantName,
Address = input.Address,
IsPremium = input.IsPremium,
PhoneNumber = input.PhoneNumber,
PhoneNumber2 = input.PhoneNumber2,
Password = hashedPassword,
Email = input.Email,
AboutUs = input.AboutUs,
Title = input.Title,
LocationId = input.LocationId,
};
if (input.LogoFile != null)
{
var logoPath = await _blobService.InsertFile(input.LogoFile);
user.LogoPath = logoPath;
}
await _tenantRepository.AddAsync(user);
}
public async Task EnableFeatureForTenantAsync_Enable_Test()
{
CreateTenantDto createTenantDto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(createTenantDto);
EnableFeatureDto enableFeatureDto = new EnableFeatureDto()
{
TenantId = tenantDto.Id,
FeatureNames = new List <string>()
{
"SmartPassFeature"
}
};
bool result = await _featureAppService.EnableFeatureForTenantAsync(enableFeatureDto);
result.ShouldBeTrue();
var features = await _featureAppService.ListAllFeaturesInTenantAsync(tenantDto.Id);
features.Count.ShouldBe(1);
var permissions = await _featureAppService.GetTenantPermissionsAsync(tenantDto.Id);
permissions.Items.Count.ShouldBe(83);
}
public async Task CreateOrgUnitInTenant_Test()
{
CreateTenantDto createTenantDto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(createTenantDto);
CreateOrgUnitDto createOrgUnitDto = new CreateOrgUnitDto()
{
ParentId = null,
DisplayName = "Ou Test"
};
var orgUnitDto = await _omOrgUnitAppService.CreateOrgUnitInTenantAsync(tenantDto.Id, createOrgUnitDto);
await UsingDbContextAsync(async context =>
{
var testOu = await context.OrganizationUnits.FirstOrDefaultAsync(ou => ou.Id == orgUnitDto.Id);
testOu.TenantId = tenantDto.Id;
testOu.DisplayName.ShouldBe("Ou Test");
testOu.Code.ShouldBe("00002"); // AdminGroup is 00001
});
}
public async Task GetRoleInTenant_CorrectTenantId_Test()
{
CreateTenantDto createTenantDto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(createTenantDto);
var createRoleDto1 = new CreateRoleDto()
{
Name = "Role1",
DisplayName = "Test role1",
Description = "Role1 for test",
GrantedPermissions = new List <string>()
{
PermissionNames.Pages_Roles
}
};
var role1Dto = await _omRoleAppService.CreateRoleInTenantAsync(tenantDto.Id, createRoleDto1);
var getRole1Dto =
await _omRoleAppService.GetRoleInTenantAsync(tenantDto.Id, new EntityDto <int>(role1Dto.Id));
getRole1Dto.Name.ShouldBe(createRoleDto1.Name);
getRole1Dto.DisplayName.ShouldBe(createRoleDto1.DisplayName);
getRole1Dto.Description.ShouldBe(createRoleDto1.Description);
getRole1Dto.GrantedPermissions.Count.ShouldBe(1);
}
public async Task DeleteOrgUnitInTenant_Test()
{
CreateTenantDto createTenantDto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(createTenantDto);
CreateOrgUnitDto createOrgUnitDto = new CreateOrgUnitDto()
{
ParentId = null,
DisplayName = "Ou1"
};
var orgUnitDto = await _omOrgUnitAppService.CreateOrgUnitInTenantAsync(tenantDto.Id, createOrgUnitDto);
await _omOrgUnitAppService.DeleteOrgUnitInTenantAsync(tenantDto.Id, new EntityDto <long>(orgUnitDto.Id));
await UsingDbContextAsync(async context =>
{
var testOu = await context.OrganizationUnits.FirstOrDefaultAsync(ou => ou.Id == orgUnitDto.Id);
testOu.TenantId.ShouldBe(tenantDto.Id);
testOu.IsDeleted.ShouldBeTrue();
});
}
public async Task GetAllOrgUnitInTenant_Test()
{
CreateTenantDto createTenantDto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(createTenantDto);
CreateOrgUnitDto createOrgUnit1Dto = new CreateOrgUnitDto()
{
ParentId = null,
DisplayName = "Ou1"
};
var orgUnit1Dto = await _omOrgUnitAppService.CreateOrgUnitInTenantAsync(tenantDto.Id, createOrgUnit1Dto);
CreateOrgUnitDto createOrgUnit2Dto = new CreateOrgUnitDto()
{
ParentId = null,
DisplayName = "Ou2"
};
var orgUnit2Dto = await _omOrgUnitAppService.CreateOrgUnitInTenantAsync(tenantDto.Id, createOrgUnit2Dto);
GetOrgUnitsInput getOrgUnitsInput = new GetOrgUnitsInput()
{
Role = string.Empty
};
var orgUnits = await _omOrgUnitAppService.GetAllOrgUnitInTenantAsync(tenantDto.Id, getOrgUnitsInput);
orgUnits.Items.Count.ShouldBe(3); // 2 new created + 1 admin
}
public async Task EnableFeatureForTenantAsync_Disable_Test()
{
CreateTenantDto createTenantDto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(createTenantDto);
var permissions0 = await _featureAppService.GetTenantPermissionsAsync(tenantDto.Id);
permissions0.Items.Count.ShouldBe(2);
// Enable two features.
EnableFeatureDto enableFeature1Dto = new EnableFeatureDto()
{
TenantId = tenantDto.Id,
FeatureNames = new List <string>()
{
"SmartPassFeature", "SmartSecurityFeature"
}
};
bool result1 = await _featureAppService.EnableFeatureForTenantAsync(enableFeature1Dto);
result1.ShouldBeTrue();
var features1 = await _featureAppService.ListAllFeaturesInTenantAsync(tenantDto.Id);
features1.Count.ShouldBe(2);
var permissions1 = await _featureAppService.GetTenantPermissionsAsync(tenantDto.Id);
permissions1.Items.Count.ShouldBe(84);
// Reset feature to remain one left
EnableFeatureDto enableFeature2Dto = new EnableFeatureDto()
{
TenantId = tenantDto.Id,
FeatureNames = new List <string>()
{
"SmartSecurityFeature"
}
};
bool result2 = await _featureAppService.EnableFeatureForTenantAsync(enableFeature2Dto);
result2.ShouldBeTrue();
var features2 = await _featureAppService.ListAllFeaturesInTenantAsync(tenantDto.Id);
features2.Count.ShouldBe(1);
var permissions2 = await _featureAppService.GetTenantPermissionsAsync(tenantDto.Id);
permissions2.Items.Count.ShouldBe(3);
}
public async Task <Tenant> Create(CreateTenantDto createTenantDto)
{
var createTenantRequest = _mapper.Map <DataAccess.DTO.Tenants.CreateTenantDto>(createTenantDto);
var tenantDto = await _tenantsRepository.Create(createTenantRequest);
var tenant = _mapper.Map <Tenant>(tenantDto);
return(tenant);
}
public async Task GetUsersInRoleInTenant_Test()
{
CreateTenantDto createTenantDto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(createTenantDto);
var createRoleDto = new CreateRoleDto()
{
Name = "RoleTest",
DisplayName = "Test role",
Description = "Role for test",
GrantedPermissions = new List <string>()
{
PermissionNames.Pages_Roles
}
};
var roleDto = await _omRoleAppService.CreateRoleInTenantAsync(tenantDto.Id, createRoleDto);
CreateUserDto createUser1Dto = new CreateUserDto()
{
UserName = "******",
Password = User.DefaultPassword,
Name = "John",
Surname = "Smith",
PhoneNumber = "13851400001",
IsActive = true
};
var user1Dto = await _omUserAppService.CreateUserInTenantAsync(tenantDto.Id, createUser1Dto);
SetRoleUserDto setRoleUserDto = new SetRoleUserDto()
{
UserId = user1Dto.Id,
RoleId = roleDto.Id
};
await _omRoleAppService.AddUserToRoleInTenantAsync(tenantDto.Id, setRoleUserDto);
CreateUserDto createUser2Dto = new CreateUserDto()
{
UserName = "******",
Password = User.DefaultPassword,
Name = "Mike",
Surname = "Smith",
PhoneNumber = "13851400002",
IsActive = true,
RoleNames = new[] { "RoleTest" }
};
var user2Dto = await _omUserAppService.CreateUserInTenantAsync(tenantDto.Id, createUser2Dto);
var roleUsers = await _omRoleAppService.GetUsersInRoleInTenantAsync(tenantDto.Id, new EntityDto <int>(roleDto.Id));
roleUsers.Count.ShouldBe(2);
}
public async Task <CreateTenantDto> CreateTenantAsync(CreateTenantDto createTenantDto)
{
try
{
if (createTenantDto.FlatId != null && !CheckFlatExist(createTenantDto.FlatId))
{
return new CreateTenantDto {
Errors = new[] { $"Flat with Id: '{createTenantDto.FlatId}' not exist." }
}
}
;
if (createTenantDto.FlatId != null && !CheckHouseExistByFlatId(createTenantDto.FlatId))
{
return new CreateTenantDto {
Errors = new[] { $"House with (Flat Id: '{createTenantDto.FlatId}') not exist." }
}
}
;
if (CheckTenantExist(createTenantDto))
{
return new CreateTenantDto {
Errors = new[] { $"Tenant with provided details already exist." }
}
}
;
BBIT.Domain.Entities.Tenant.Tenant tenant = CreateNewTenant(createTenantDto);
var flat = GetFlatById(createTenantDto.FlatId);
flat.AmountOfTenants++;
tenant.Flat = flat;
_dbContext.Flats.Update(flat);
await _dbContext.Tenants.AddAsync(tenant);
await _dbContext.SaveChangesAsync();
var createTenantDtoToReturn = tenant.TenantDtoToCreateTenantDto();
createTenantDtoToReturn.Status = true;
return(createTenantDtoToReturn);
}
catch (Exception e)
{
_logger.LogError($"Error on creating Tenant in database. Exception message: {e.Message};\nInner message: {e.InnerException?.Message}");
return(new CreateTenantDto
{
Errors = new[] { "Error on creating Tenant in database." },
ServerError = true
});
}
}
public async Task RemoveRoleFromOrgUnitInTenant_Test()
{
CreateTenantDto createTenantDto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(createTenantDto);
var createRoleDto = new CreateRoleDto()
{
Name = "RoleTest",
DisplayName = "Test role",
Description = "Role for test",
GrantedPermissions = new List <string>()
{
PermissionNames.Pages_Roles
}
};
var roleDto = await _omRoleAppService.CreateRoleInTenantAsync(tenantDto.Id, createRoleDto);
CreateOrgUnitDto createOrgUnitDto = new CreateOrgUnitDto()
{
ParentId = null,
DisplayName = "Ou Test"
};
var orgUnitDto = await _omOrgUnitAppService.CreateOrgUnitInTenantAsync(tenantDto.Id, createOrgUnitDto);
SetOrgUnitRoleDto setOrgUnitRoleDto = new SetOrgUnitRoleDto()
{
OrgUnitId = orgUnitDto.Id,
RoleId = roleDto.Id
};
await _omOrgUnitAppService.AddRoleToOrgUnitInTenantAsync(tenantDto.Id, setOrgUnitRoleDto);
await UsingDbContextAsync(async context =>
{
var testOus = await context.OrganizationUnitRoles
.Where(our => our.OrganizationUnitId == orgUnitDto.Id).ToListAsync();
testOus.Count.ShouldBe(1);
testOus[0].RoleId.ShouldBe(roleDto.Id);
});
await _omOrgUnitAppService.RemoveRoleFromOrgUnitInTenantAsync(tenantDto.Id, setOrgUnitRoleDto);
await UsingDbContextAsync(async context =>
{
var testOus = await context.OrganizationUnitRoles
.Where(our => our.OrganizationUnitId == orgUnitDto.Id).ToListAsync();
testOus.Count.ShouldBe(1);
testOus[0].RoleId.ShouldBe(roleDto.Id);
testOus[0].IsDeleted.ShouldBeTrue();
});
}
public async Task UpdateOrgUnitInTenant_Test()
{
CreateTenantDto createTenantDto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(createTenantDto);
// Prepare roles
var createRoleDto1 = new CreateRoleDto()
{
Name = "Role1",
DisplayName = "Test role1",
Description = "Role1 for test",
GrantedPermissions = new List <string>()
{
PermissionNames.Pages_Roles
}
};
var role1Dto = await _omRoleAppService.CreateRoleInTenantAsync(tenantDto.Id, createRoleDto1);
var createRoleDto2 = new CreateRoleDto()
{
Name = "Role2",
DisplayName = "Test role2",
Description = "Role2 for test",
GrantedPermissions = new List <string>()
{
PermissionNames.Pages_Users
}
};
var role2Dto = await _omRoleAppService.CreateRoleInTenantAsync(tenantDto.Id, createRoleDto2);
// Prepare organization units
CreateOrgUnitDto createOrgUnit1Dto = new CreateOrgUnitDto()
{
ParentId = null,
DisplayName = "Ou1"
};
var orgUnitDto = await _omOrgUnitAppService.CreateOrgUnitInTenantAsync(tenantDto.Id, createOrgUnit1Dto);
await _omOrgUnitAppService.AddRoleToOrgUnitInTenantAsync(tenantDto.Id, new SetOrgUnitRoleDto()
{
OrgUnitId = orgUnitDto.Id,
RoleId = role1Dto.Id
});
// Update
orgUnitDto.DisplayName = "**Ou1**";
var updatedOrgUnitDto = await _omOrgUnitAppService.UpdateOrgUnitInTenantAsync(tenantDto.Id, orgUnitDto);
updatedOrgUnitDto.DisplayName.ShouldBe("**Ou1**");
}
public async Task <TenantDto> RegisterTenant(CreateTenantDto input)
{
// 创建租户
var tenant = new Tenant(input.TenancyName, input.TenancyName)
{
IsActive = true
};
tenant.ConnectionString = input.ConnectionString.IsNullOrEmpty()
? null
: SimpleStringCipher.Instance.Encrypt(input.ConnectionString);
var defaultEdition = await _editionManager.FindByNameAsync(EditionManager.DefaultEditionName);
if (defaultEdition != null)
{
tenant.EditionId = defaultEdition.Id;
}
await TenantManager.CreateAsync(tenant);
// 保存以获取新租户的Id
await CurrentUnitOfWork.SaveChangesAsync();
// 创建租户数据库
_abpZeroDbMigrator.CreateOrMigrateForTenant(tenant);
// 新的租户,所以设置工作单元当前所属的租户
using (CurrentUnitOfWork.SetTenantId(tenant.Id))
{
// 创建角色
CheckErrors(await _roleManager.CreateStaticRoles(tenant.Id));
// 保存，获取角色id
await CurrentUnitOfWork.SaveChangesAsync();
// 分配权限
var adminRole = _roleManager.Roles.Single(r => r.Name == StaticRoleNames.Tenants.Admin);
await _roleManager.GrantAllPermissionsAsync(adminRole);
// 创建此租户的管理员用户
var adminUser = User.CreateTenantAdminUser(tenant.Id, input.AdminEmailAddress);
// 如果没有提交密码,那么走的是默认密码 123qwe
adminUser.Password = _passwordHasher.HashPassword(adminUser, input.AdminPassword.IsNullOrWhiteSpace() ? User.DefaultPassword : input.AdminPassword);
CheckErrors(await UserManager.CreateAsync(adminUser));
// 保存，获取角色id
await CurrentUnitOfWork.SaveChangesAsync();
// 授权
CheckErrors(await UserManager.AddToRoleAsync(adminUser, adminRole.Name));
await CurrentUnitOfWork.SaveChangesAsync();
}
return(tenant.MapTo <TenantDto>());
}
public async Task <IActionResult> Add([FromBody] CreateTenantDto createTenantDto)
{
TenantDto createdTenantDto = await this.tenantService.Add(createTenantDto.ToTenantDto());
if (createdTenantDto.Id != Guid.Empty)
{
return(this.CreatedAtRoute("get-tenant", new { id = createdTenantDto.Id }, createdTenantDto));
}
return(this.BadRequest());
}
private bool CheckTenantExist(CreateTenantDto createTenantDto)
{
var tenant = _dbContext.Tenants
.ToList()
.FirstOrDefault(x =>
x.Name == createTenantDto.Tenant.Name &&
x.Surname == createTenantDto.Tenant.Surname &&
x.DateOfBirth.ToString("d") == Convert.ToDateTime(createTenantDto.Tenant.DateOfBirth).ToString("d") &&
x.PersonalCode == createTenantDto.Tenant.PersonalCode);
return(tenant != null);
}
public async Task <ActionResult <StringResult> > Create([FromBody] CreateTenantDto dto)
{
var createdId = await Task.Run(() =>
{
return(_tenantService.Create(dto));
});
return(Ok(new StringResult
{
Result = createdId.ToString()
}));
}
public int Create(CreateTenantDto dto)
{
var tenant = new Tenant
{
Name = dto.Name,
};
var parent = _context.Industries.Find(dto.IndustryId);
parent.Tenants.Add(tenant);
_context.SaveChanges();
return(tenant.Id);
}
public async Task GetUsersInOrgUnitInTenant_Test()
{
CreateTenantDto createTenantDto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(createTenantDto);
CreateOrgUnitDto createOrgUnitDto = new CreateOrgUnitDto()
{
ParentId = null,
DisplayName = "Ou Test"
};
var orgUnitDto = await _omOrgUnitAppService.CreateOrgUnitInTenantAsync(tenantDto.Id, createOrgUnitDto);
CreateUserDto createUser1Dto = new CreateUserDto()
{
UserName = "******",
Password = User.DefaultPassword,
Name = "John",
Surname = "Smith",
PhoneNumber = "13851400001",
IsActive = true
};
var user1Dto = await _omUserAppService.CreateUserInTenantAsync(tenantDto.Id, createUser1Dto);
SetOrgUnitUserDto setOrgUnitUserDto = new SetOrgUnitUserDto()
{
UserId = user1Dto.Id,
OrgUnitId = orgUnitDto.Id
};
await _omOrgUnitAppService.AddUserToOrgUnitInTenantAsync(tenantDto.Id, setOrgUnitUserDto);
CreateUserDto createUser2Dto = new CreateUserDto()
{
UserName = "******",
Password = User.DefaultPassword,
Name = "Mike",
Surname = "Smith",
PhoneNumber = "13851400002",
IsActive = true,
OrgUnitNames = new[] { "Ou Test" }
};
var user2Dto = await _omUserAppService.CreateUserInTenantAsync(tenantDto.Id, createUser2Dto);
var orgUnitUsers = await _omOrgUnitAppService.GetUsersInOrgUnitInTenantAsync(tenantDto.Id, new EntityDto <long>(orgUnitDto.Id));
orgUnitUsers.Count.ShouldBe(2);
}
public async Task <TenantDto> RegisterTenantAsync(CreateTenantDto input)
{
var tenant = new Tenant(input.TenancyName, input.Name)
{
IsActive = true
};
// 连接字串要加密
tenant.ConnectionString = input.ConnectionString.IsNullOrEmpty()
? null
: SimpleStringCipher.Instance.Encrypt(input.ConnectionString);
// 获得默认的版本信息 DefaultEditionName = "Standard"
var defaultEdition = await _editionManager.FindByNameAsync(EditionManager.DefaultEditionName);
if (defaultEdition != null)
{
tenant.EditionId = defaultEdition.Id;
}
// 创建租户信息
await TenantManager.CreateAsync(tenant);
await CurrentUnitOfWork.SaveChangesAsync();
// 初始化数据信息迁移，针对租户级
_abpZeroDbMigrator.CreateOrMigrateForTenant(tenant);
// 所以设置当前的工作单元为新注册登录的租户信息
using (CurrentUnitOfWork.SetTenantId(tenant.Id))
{
// 创建租户
CheckErrors(await _roleManager.CreateStaticRoles(tenant.Id));
// role =admin permission user
await CurrentUnitOfWork.SaveChangesAsync();
// 创建角色
var adminRole = _roleManager.Roles.Single(a => a.Name == StaticRoleNames.Tenants.Admin);
// 授权当前角色所有权限
await _roleManager.GrantAllPermissionsAsync(adminRole);
// 创建admin用户信息
var adminUser = User.CreateTenantAdminUser(tenant.Id, input.AdminEmailAddress);
// 密码为空时提供默认密码
adminUser.Password = _passwordHasher.HashPassword(adminUser, StringExtensions.IsNullOrWhiteSpace(input.PassWord)?User.DefaultPassword:input.PassWord);
CheckErrors(await UserManager.CreateAsync(adminUser));
await CurrentUnitOfWork.SaveChangesAsync();
// 角色授权给用户
CheckErrors(await UserManager.AddToRoleAsync(adminUser, adminRole.Name));
await CurrentUnitOfWork.SaveChangesAsync();
}
return(tenant.MapTo <TenantDto>());
}
public async Task <TenantDto> TenantCreateAsync(CreateTenantDto tenant)
{
try
{
var response = await api.Create <TenantDto>("/api/services/app/Tenant/Create", tenant);
return(response);
}
catch
{
}
return(null);
}
public async Task RemoveUserFromOrgUnitInTenant_Test()
{
CreateTenantDto createTenantDto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(createTenantDto);
CreateOrgUnitDto createOrgUnitDto = new CreateOrgUnitDto()
{
ParentId = null,
DisplayName = "Ou Test"
};
var orgUnitDto = await _omOrgUnitAppService.CreateOrgUnitInTenantAsync(tenantDto.Id, createOrgUnitDto);
CreateUserDto createUserDto = new CreateUserDto()
{
UserName = "******",
Password = User.DefaultPassword,
Name = "John",
Surname = "Smith",
PhoneNumber = "13851400001",
IsActive = true
};
var userDto = await _omUserAppService.CreateUserInTenantAsync(tenantDto.Id, createUserDto);
var getUser1Dto = await _omUserAppService.GetUserInTenantAsync(tenantDto.Id, new EntityDto <long>(userDto.Id));
getUser1Dto.OrgUnitNames.Length.ShouldBe(0);
SetOrgUnitUserDto setOrgUnitUserDto = new SetOrgUnitUserDto()
{
UserId = userDto.Id,
OrgUnitId = orgUnitDto.Id
};
await _omOrgUnitAppService.AddUserToOrgUnitInTenantAsync(tenantDto.Id, setOrgUnitUserDto);
var getUser2Dto = await _omUserAppService.GetUserInTenantAsync(tenantDto.Id, new EntityDto <long>(userDto.Id));
getUser2Dto.OrgUnitNames.Length.ShouldBe(1);
// Remove from organization unit
await _omOrgUnitAppService.RemoveUserFromOrgUnitInTenantAsync(tenantDto.Id, setOrgUnitUserDto);
var getUser3Dto = await _omUserAppService.GetUserInTenantAsync(tenantDto.Id, new EntityDto <long>(userDto.Id));
getUser3Dto.OrgUnitNames.Length.ShouldBe(0);
}
public async Task GetRolesByPermissionInTenant_Test()
{
CreateTenantDto createTenantDto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(createTenantDto);
var createRoleDto1 = new CreateRoleDto()
{
Name = "Role1",
DisplayName = "Test role1",
Description = "Role1 for test",
GrantedPermissions = new List <string>()
{
PermissionNames.Pages_Roles
}
};
var role1Dto = await _omRoleAppService.CreateRoleInTenantAsync(tenantDto.Id, createRoleDto1);
var createRoleDto2 = new CreateRoleDto()
{
Name = "Role2",
DisplayName = "Test role2",
Description = "Role2 for test",
GrantedPermissions = new List <string>()
{
PermissionNames.Pages_Users
}
};
var role2Dto = await _omRoleAppService.CreateRoleInTenantAsync(tenantDto.Id, createRoleDto2);
GetRolesInput input1 = new GetRolesInput()
{
Permission = string.Empty
};
var roles1 = await _omRoleAppService.GetRolesByPermissionInTenantAsync(tenantDto.Id, input1);
roles1.Items.Count.ShouldBe(3);
GetRolesInput input2 = new GetRolesInput()
{
Permission = PermissionNames.Pages_Users
};
var roles2 = await _omRoleAppService.GetRolesByPermissionInTenantAsync(tenantDto.Id, input2);
roles2.Items.Count.ShouldBe(2);
}
public async Task <IActionResult> CreateTenant([FromForm] CreateTenantDto input)
{
try
{
await _tenantAppService.CreateTenant(input);
return(Ok("Created Tenant"));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <JsonResult> MyCreate(CreateTenantDto input)
{
try
{
input.IsActive = true;
var output = await _tenantAppService.Create(input);
return(Json(new { result = "success", content = "记录修改成功" }));
}
catch (Exception ex)
{
throw new UserFriendlyException("表操作失败", ex.Message);
}
}
public async Task <TenantDto> RegisterTenant(CreateTenantDto input)
{
var tenant = new Tenant(input.TenancyName, input.Name)
{
IsActive = true
};
//连接字符串加密
tenant.ConnectionString = input.ConnectionString.IsNullOrEmpty()
? null
: SimpleStringCipher.Instance.Encrypt(input.ConnectionString);
var defaultEdition = await _editionManager.FindByNameAsync(EditionManager.DefaultEditionName);
if (defaultEdition != null)
{
tenant.EditionId = defaultEdition.Id;
}
//创建租户信息
await TenantManager.CreateAsync(tenant);
await CurrentUnitOfWork.SaveChangesAsync();
//初始化数据信息迁移
_abpZeroDbMigrator.CreateOrMigrateForTenant(tenant);
using (CurrentUnitOfWork.SetTenantId(tenant.Id))
{
CheckErrors(await _roleManager.CreateStaticRoles(tenant.Id));
await CurrentUnitOfWork.SaveChangesAsync();
var adminRole = _roleManager.Roles.Single(a => a.Name == StaticRoleNames.Tenants.Admin);
await _roleManager.GrantAllPermissionsAsync(adminRole);
var adminUser = User.CreateTenantAdminUser(tenant.Id, input.AdminEmailAddress);
adminUser.Password = _passwordHasher.HashPassword(adminUser,
input.Password.IsNullOrWhiteSpace() ? User.DefaultPassword : input.Password);
CheckErrors(await UserManager.CreateAsync(adminUser));
await CurrentUnitOfWork.SaveChangesAsync();
CheckErrors(await UserManager.AddToRoleAsync(adminUser, adminRole.Name));
await CurrentUnitOfWork.SaveChangesAsync();
}
return(tenant.MapTo <TenantDto>());
}
