/// <summary>
/// Creates a new tenant on the server. Check the server documentation for the required permissions.
/// </summary>
/// <param name="tenant"></param>
/// <returns></returns>
public async Task <Guid> PostTenantAsync(TenantCreateDto tenant)
{
var newId = await PostGuidEntityAsync(tenantsEndpoint, tenant);
tenant.TenantDetails.Id = newId.ToString();
return(newId);
}
public void Post_Should_Return_Created_Response_And_Call_Add()
{
// Given
var newId = Guid.NewGuid();
var tenantService = Substitute.For <IService <Tenant> >();
var tenantCreator = Substitute.For <ITenantCreator>();
var logger = Substitute.For <ILogger <TenantController> >();
var accountService = Substitute.For <IAccountService>();
var inspectionService = Substitute.For <IInspectionService>();
var employeeService = Substitute.For <IEmployeeService>();
var branchOfficeService = Substitute.For <IService <BranchOffice> >();
var departmentService = Substitute.For <IService <Department> >();
var tenantController = new TenantController(
tenantService,
tenantCreator,
accountService,
inspectionService,
employeeService,
branchOfficeService,
departmentService,
logger);
var createTenantDto = new TenantCreateDto {
TenantDetails = new TenantDto
{
Name = "Demo tenant 1",
PrimaryContact = new ContactInfoDto
{
FullName = "John Doe"
},
ServiceDetails = new ServiceDetailsDto
{
ServiceExpireDate = DateTime.Now.Date + TimeSpan.FromDays(366)
}
},
AdminUserDetails = new TenantCreateAdminDto
{
FirstName = "Ivanov",
LastName = "Konstantin",
Patronymic = "Mikhaylovich",
UserName = "******",
Email = "*****@*****.**",
NewPassword = "******"
}
};
// When
var response = tenantController.Post(createTenantDto);
// Then
tenantCreator.Received().CreateNewTenant(
Arg.Is <Tenant>(v => v.Name == createTenantDto.TenantDetails.Name),
Arg.Is <UserDto>(v => v.FirstName == createTenantDto.AdminUserDetails.FirstName),
Arg.Is <string>(v => v == createTenantDto.AdminUserDetails.NewPassword)
);
var createdResponse = (CreatedResult)response.Result;
Assert.That(createdResponse.Location, Is.EqualTo(nameof(TenantController.GetTenant)));
}
public void TenantAdminModel_ToAppUser()
{
var createTenantDto = new TenantCreateDto
{
TenantDetails = new TenantDto
{
Name = "Demo tenant 1",
PrimaryContact = new ContactInfoDto
{
FullName = "John Doe"
},
ServiceDetails = new ServiceDetailsDto
{
ServiceExpireDate = DateTime.Now.Date + TimeSpan.FromDays(366)
}
},
AdminUserDetails = new TenantCreateAdminDto
{
FirstName = "Ivanov",
LastName = "Konstantin",
Patronymic = "Mikhaylovich",
UserName = "******",
Email = "*****@*****.**",
NewPassword = "******"
}
};
var user = Mapper.Map <UserDto>(createTenantDto.AdminUserDetails);
}
public virtual async Task <TenantDto> CreateAsync(TenantCreateDto input)
{
return(await RequestAsync <TenantDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
{
{ typeof(TenantCreateDto), input }
}));
}
public virtual async Task <TenantDto> CreateAsync(TenantCreateDto input)
{
var tenant = await TenantManager.CreateAsync(input.Name);
input.MapExtraPropertiesTo(tenant);
await TenantRepository.InsertAsync(tenant);
await CurrentUnitOfWork.SaveChangesAsync();
await DistributedEventBus.PublishAsync(
new TenantCreatedEto
{
Id = tenant.Id,
Name = tenant.Name,
Properties =
{
{ "AdminEmail", input.AdminEmailAddress },
{ "AdminPassword", input.AdminPassword }
}
});
using (CurrentTenant.Change(tenant.Id, tenant.Name))
{
//TODO: Handle database creation?
// TODO: Seeder might be triggered via event handler.
await DataSeeder.SeedAsync(
new DataSeedContext(tenant.Id)
.WithProperty("AdminEmail", input.AdminEmailAddress)
.WithProperty("AdminPassword", input.AdminPassword)
);
}
return(ObjectMapper.Map <Tenant, TenantDto>(tenant));
}
public void Post_ShouldFail_WithoutContact()
{
// Given
// an instance of TenantDto without PrimaryContact value
var tenant = new TenantCreateDto
{
TenantDetails = new TenantDto
{
Id = Guid.NewGuid().ToString(),
Name = "AAA",
Slug = "aaa",
ServiceDetails = new ServiceDetailsDto
{
ServiceMaxUsers = 10
}
},
AdminUserDetails = new TenantCreateAdminDto
{
Email = "*****@*****.**",
UserName = "******",
NewPassword = "******",
FirstName = "John",
Patronymic = "Alfredovich",
LastName = "Lennon",
PhoneNumber = "+79991234567"
}
};
// When
// a request is made to create a new tenant with the specified attributes
var response = _httpClient.PostAsJsonAsync(_url, tenant);
// Then
// the request fails with BadRequest status code
Assert.That(response.Result.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
}
public void Post_ShouldFail_WithoutAdminData()
{
// Given
// an instance of TenantDto without PrimaryContact value
var tenant = new TenantCreateDto
{
TenantDetails = new TenantDto
{
Id = Guid.NewGuid().ToString(),
Name = "AAA-4",
Slug = "aaa-4",
PrimaryContact = new ContactInfoDto
{
FullName = "Neville Longbottom",
Email = "*****@*****.**"
},
ServiceDetails = new ServiceDetailsDto
{
ServiceMaxUsers = 10
}
}
};
// When
// a request is made to create a new tenant with the specified attributes
var response = _httpClient.PostAsJsonAsync(_url, tenant);
// Then
// the request fails with BadRequest status code
Assert.That(response.Result.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
}
public async Task <IActionResult> Post([FromBody] TenantCreateDto newTenantDto)
{
if (newTenantDto == null)
{
return(InvalidRequestBodyJson(nameof(TenantCreateDto)));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (newTenantDto.TenantDetails.PrimaryContact == null)
{
AddErrors(new[] { "TenantDetails model must have contact information defined" });
return(BadRequest(ModelState));
}
if (newTenantDto.TenantDetails.ServiceDetails == null)
{
AddErrors(new[] { "TenantDetails model must have service information defined" });
return(BadRequest(ModelState));
}
var newTenant = Mapper.Map <Tenant>(newTenantDto.TenantDetails);
var newUser = Mapper.Map <UserDto>(newTenantDto.AdminUserDetails);
var creationResult = await _tenantCreator.CreateNewTenant(
newTenant, newUser, newTenantDto.AdminUserDetails.NewPassword);
return(Created(nameof(GetTenant), new CreatedWithGuidDto {
Id = newTenant.Id
}));
}
public async Task <TenantDto> CreateAsync(TenantCreateDto input)
{
var tenant = await _tenantManager.CreateAsync(input.Name);
await _tenantRepository.InsertAsync(tenant);
return(ObjectMapper.Map <Tenant, TenantDto>(tenant));
}
public void Login_Should_Succeed_With_Slug_Case_Mismatch()
{
var lowerCaseSlug = "lower-case-slug";
// Given
// an instance of TenantDto with a Slug value in upper case
var tenant = new TenantCreateDto
{
TenantDetails = new TenantDto
{
Id = Guid.NewGuid().ToString(),
Name = "Bad slug",
Slug = lowerCaseSlug,
PrimaryContact = new ContactInfoDto
{
FullName = "Neville Longbottom",
Email = "*****@*****.**"
},
ServiceDetails = new ServiceDetailsDto
{
ServiceMaxUsers = 10
}
},
AdminUserDetails = new TenantCreateAdminDto
{
Email = "*****@*****.**",
UserName = "******",
NewPassword = "******",
FirstName = "John",
Patronymic = "Alfredovich",
LastName = "Lennon",
PhoneNumber = "+79991234567"
}
};
var response = _httpClient.PostAsJsonAsync(_url, tenant);
response.Result.EnsureSuccessStatusCode();
// When
// an authentication request is made with upper-case slug
var upperCaseSlug = lowerCaseSlug.ToUpper();
_apiClient.SignInWithUserPassword_WithSlug_Async(
tenant.AdminUserDetails.UserName, tenant.AdminUserDetails.NewPassword,
_httpClient, upperCaseSlug
).Wait();
// Then
// the request should succeed
}
public void Post_And_Sign_In_As_Tenant_Admin_Should_Succeed()
{
var tenant = new TenantCreateDto
{
TenantDetails = new TenantDto
{
Id = Guid.NewGuid().ToString(),
Name = "ZZZ",
Slug = "zzz",
PrimaryContact = new ContactInfoDto
{
FullName = "Neville Longbottom",
Email = "*****@*****.**"
},
ServiceDetails = new ServiceDetailsDto
{
ServiceMaxUsers = 10
}
},
AdminUserDetails = new TenantCreateAdminDto
{
Email = "*****@*****.**",
UserName = "******",
NewPassword = "******",
FirstName = "John",
Patronymic = "Alfredovich",
LastName = "Lennon",
PhoneNumber = "+79993456789"
}
};
// When
var response = _httpClient.PostAsJsonAsync(_url, tenant);
// Then
// 1.
response.Result.EnsureSuccessStatusCode();
Assert.That(response.Result.StatusCode, Is.EqualTo(HttpStatusCode.Created));
// 2.
var createdEntityInfo = response.Result.Content
.ReadAsJsonAsync <CreatedWithGuidDto>().Result;
// 3.
var createdEntityResponse = _httpClient.GetAsync(_url + createdEntityInfo.Id.ToString());
createdEntityResponse.Result.EnsureSuccessStatusCode();
// 4.
_apiClient.SignInWithUserPassword_WithSlug_Async(
tenant.AdminUserDetails.UserName, tenant.AdminUserDetails.NewPassword,
_httpClient, tenant.TenantDetails.Slug).Wait();
}
public void Post_ShouldSucceed_WithDuplicateAdminUsername()
{
// Given
var tenant = new TenantCreateDto
{
TenantDetails = new TenantDto
{
Id = Guid.NewGuid().ToString(),
Name = "CCC123456789",
Slug = "abcdefghijklmnopqrstuvwxyz-0123456789_",
PrimaryContact = new ContactInfoDto
{
FullName = "Neville Longbottom",
Email = "*****@*****.**"
},
ServiceDetails = new ServiceDetailsDto
{
ServiceMaxUsers = 10
}
},
AdminUserDetails = new TenantCreateAdminDto
{
Email = "*****@*****.**",
UserName = "******",
NewPassword = "******",
FirstName = "John",
Patronymic = "Alfredovich",
LastName = "Lennon",
PhoneNumber = "+79992345678"
}
};
var response1 = _httpClient.PostAsJsonAsync(_url, tenant);
Console.WriteLine(response1.Result.Content.ReadAsStringAsync().Result);
response1.Result.EnsureSuccessStatusCode();
// When
tenant.TenantDetails.Name += "___";
tenant.TenantDetails.Slug += "___";
tenant.TenantDetails.Id = Guid.NewGuid().ToString();
var response = _httpClient.PostAsJsonAsync(_url, tenant);
Console.WriteLine(response.Result.Content.ReadAsStringAsync().Result);
// Then
response.Result.EnsureSuccessStatusCode();
}
public void Post_Should_Fail_With_Duplicate_Slug_Nocase()
{
// Given
// a tenant with the specified slug value
var tenant = new TenantCreateDto
{
TenantDetails = new TenantDto
{
Id = Guid.NewGuid().ToString(),
Name = "AAA222",
Slug = "aaa222",
PrimaryContact = new ContactInfoDto
{
FullName = "Neville Longbottom",
Email = "*****@*****.**"
},
ServiceDetails = new ServiceDetailsDto
{
ServiceMaxUsers = 10
}
},
AdminUserDetails = new TenantCreateAdminDto
{
Email = "*****@*****.**",
UserName = "******",
NewPassword = "******",
FirstName = "John",
Patronymic = "Alfredovich",
LastName = "Lennon",
PhoneNumber = "+79991234567"
}
};
var response1 = _httpClient.PostAsJsonAsync(_url, tenant);
response1.Result.EnsureSuccessStatusCode();
// When
// a request is made to create a new tenant with the specified attributes
tenant.TenantDetails.Name += "__nocase";
tenant.TenantDetails.Slug = tenant.TenantDetails.Slug.ToUpper();
var response2 = _httpClient.PostAsJsonAsync(_url, tenant);
// Then
// the request fails with BadRequest status code
Assert.That(response2.Result.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
}
public void Post_ShouldFail_GivenPasswordIsTooSimple()
{
var tenant = new TenantCreateDto
{
TenantDetails = new TenantDto
{
Id = Guid.NewGuid().ToString(),
Name = "AAA-44",
Slug = "aaa-4a",
PrimaryContact = new ContactInfoDto
{
FullName = "Neville Longbottom",
Email = "*****@*****.**"
},
ServiceDetails = new ServiceDetailsDto
{
ServiceMaxUsers = 10
}
},
AdminUserDetails = new TenantCreateAdminDto
{
Email = "*****@*****.**",
UserName = "******",
NewPassword = "******",
FirstName = "John",
Patronymic = "Alfredovich",
LastName = "Lennon",
PhoneNumber = "+79991234567"
}
};
// When
var response = _httpClient.PostAsJsonAsync(_url, tenant);
// Then
// 1.
Assert.That(response.Result.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
// 2.
var errorInfo = response.Result.Content.ReadAsJsonAsync <ApiErrorDto>().Result;
Assert.That(!string.IsNullOrEmpty(errorInfo.Error));
// should contain 'assword' (simple match for 'Password' and 'password')
Assert.That(errorInfo.Error, Contains.Substring("assword"));
}
public void Post_ShouldFail_WithDuplicateTenantName()
{
// Given
var tenant = new TenantCreateDto
{
TenantDetails = new TenantDto {
Id = Guid.NewGuid().ToString(),
Name = "post_shouldfail_withduplicatetenantname",
Slug = "post_shouldfail_withduplicatetenantname",
PrimaryContact = new ContactInfoDto
{
FullName = "Neville Longbottom",
Email = "*****@*****.**"
},
ServiceDetails = new ServiceDetailsDto
{
ServiceMaxUsers = 10
}
},
AdminUserDetails = new TenantCreateAdminDto {
Email = "*****@*****.**",
UserName = "******",
NewPassword = "******",
FirstName = "John",
Patronymic = "Alfredovich",
LastName = "Lennon",
PhoneNumber = "+79991234567"
}
};
var response = _httpClient.PostAsJsonAsync(_url, tenant);
Console.WriteLine(response.Result.Content.ReadAsStringAsync().Result);
response.Result.EnsureSuccessStatusCode();
// When
tenant.TenantDetails.Id = Guid.NewGuid().ToString();
tenant.TenantDetails.Slug += "_duplicatename";
var response2 = _httpClient.PostAsJsonAsync(_url, tenant);
Console.WriteLine(response2.Result.Content.ReadAsStringAsync().Result);
// Then
Assert.That(response2.Result.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
}
public void PostTenant_ShouldFail_Given_Tenant_User()
{
// Given
// _client authenticated as a Gryffindor user
// When
// the user tries to post a new tenant
var newTenant = new TenantCreateDto
{
TenantDetails = new TenantDto
{
Id = Guid.NewGuid().ToString(),
Name = "AAA",
Slug = "aaa",
PrimaryContact = new ContactInfoDto
{
FullName = "Neville Longbottom",
Email = "*****@*****.**"
},
ServiceDetails = new ServiceDetailsDto
{
ServiceMaxUsers = 10
}
},
AdminUserDetails = new TenantCreateAdminDto
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Neville",
Patronymic = "Frankovich",
LastName = "Longbottom",
PhoneNumber = "+79990987654",
NewPassword = "******"
}
};
var response = _httpClient.PostAsJsonAsync(_url, newTenant);
// Then
// Server returns 'Forbidden' status code
Assert.That(response.Result.StatusCode, Is.EqualTo(HttpStatusCode.Forbidden));
}
public void Post_ShouldSucceed_WithSecondTenant()
{
var tenant = new TenantCreateDto
{
TenantDetails = new TenantDto
{
Id = Guid.NewGuid().ToString(),
Name = "BBB",
Slug = "bbb",
PrimaryContact = new ContactInfoDto
{
FullName = "Neville Longbottom",
Email = "*****@*****.**"
},
ServiceDetails = new ServiceDetailsDto
{
ServiceMaxUsers = 10
}
},
AdminUserDetails = new TenantCreateAdminDto
{
Email = "*****@*****.**",
UserName = "******",
NewPassword = "******",
FirstName = "John",
Patronymic = "Alfredovich",
LastName = "Lennon",
PhoneNumber = "+79992345678"
}
};
var response = _httpClient.PostAsJsonAsync(_url, tenant);
response.Result.EnsureSuccessStatusCode();
Assert.That(response.Result.StatusCode, Is.EqualTo(HttpStatusCode.Created));
var createdEntityInfo = response.Result.Content.ReadAsJsonAsync <PskOnline.Client.Api.Models.CreatedWithGuidDto>().Result;
var createdEntityResponse = _httpClient.GetAsync(_url + createdEntityInfo.Id.ToString());
createdEntityResponse.Result.EnsureSuccessStatusCode();
}
public virtual async Task <TenantDto> CreateAsync(TenantCreateDto input)
{
var tenant = await TenantManager.CreateAsync(input.Name);
input.MapExtraPropertiesTo(tenant);
await TenantRepository.InsertAsync(tenant);
await CurrentUnitOfWork.SaveChangesAsync();
using (CurrentTenant.Change(tenant.Id, tenant.Name))
{
//TODO: Handle database creation?
await DataSeeder.SeedAsync(
new DataSeedContext(tenant.Id)
.WithProperty("AdminEmail", input.AdminEmailAddress)
.WithProperty("AdminPassword", input.AdminPassword)
);
}
return(ObjectMapper.Map <Tenant, TenantDto>(tenant));
}
public Task <TenantDto> CreateAsync(TenantCreateDto input)
{
return(_service.CreateAsync(input));
}
public virtual Task <TenantDto> CreateAsync(TenantCreateDto input)
{
ValidateModel();
return(TenantAppService.CreateAsync(input));
}
public static async Task <TenantContainer> CreateTenantWithRolesAndUsers(IApiClient client, HttpClient httpClient, TenantDto t)
{
IMapper mapper = new AutoMapperConfig().CreateMapper();
// pretend we are the site user...
var tenantSpecification = new TenantContainer(t);
var newT = new TenantCreateDto
{
TenantDetails = new TenantDto
{
Name = t.Name,
Slug = t.Slug,
Comment = t.Comment,
PrimaryContact = new ContactInfoDto
{
FullName = "John Smith",
MobilePhoneNumber = "+79998887766",
StreetAddress = "931 Baker street",
Email = "*****@*****.**"
},
ServiceDetails = new ServiceDetailsDto
{
ServiceMaxEmployees = 1000,
ServiceMaxUsers = 10,
ServiceExpireDate = DateTime.Now + TimeSpan.FromDays(730),
ServiceMaxStorageMegabytes = 40960
}
},
AdminUserDetails = new TenantCreateAdminDto
{
UserName = tenantSpecification.AdminName,
FirstName = "John",
LastName = "Doe",
Email = tenantSpecification.AdminName + "@somedomain.com",
NewPassword = tenantSpecification.AdminPassword
}
};
var newTenantId = client.PostTenantAsync(newT).Result;
tenantSpecification.Tenant.Id = newTenantId.ToString();
tenantSpecification.TenantId = newTenantId;
// now read any details of the Tenant
await client.SignInWithUserPassword_WithSlug_Async(newT.AdminUserDetails.UserName, newT.AdminUserDetails.NewPassword,
httpClient, newT.TenantDetails.Slug);
var tenantRoles = await client.GetRolesAsync();
tenantSpecification.TenantAdminRole = tenantRoles.First(r => r.Name.Contains("admin", StringComparison.InvariantCultureIgnoreCase));
tenantSpecification.TenantAdminRoleId = Guid.Parse(tenantSpecification.TenantAdminRole.Id);
var tenantUsers = await client.GetUsersAsync();
var tenantAdminUser = tenantUsers.First(
u => !string.IsNullOrEmpty(u.UserName) && u.UserName.Contains("admin", StringComparison.InvariantCultureIgnoreCase));
tenantSpecification.AdminUser = mapper.Map <UserEditDto>(tenantAdminUser);
tenantSpecification.AdminUser.CurrentPassword = newT.AdminUserDetails.NewPassword;
newT.AdminUserDetails.NewPassword = null;
return(tenantSpecification);
}
public async Task Post_ShouldSucceed()
{
var tenant = new TenantCreateDto
{
TenantDetails = new TenantDto
{
Id = Guid.NewGuid().ToString(),
Name = "AAA",
Slug = "aaa",
PrimaryContact = new ContactInfoDto
{
FullName = "Neville Longbottom",
Email = "*****@*****.**"
},
ServiceDetails = new ServiceDetailsDto
{
ServiceMaxUsers = 10
}
},
AdminUserDetails = new TenantCreateAdminDto
{
Email = "*****@*****.**",
UserName = "******",
NewPassword = "******",
FirstName = "John",
Patronymic = "Alfredovich",
LastName = "Lennon",
PhoneNumber = "+79991234567"
}
};
// When
var response = _httpClient.PostAsJsonAsync(_url, tenant);
// Then
// 1.
response.Result.EnsureSuccessStatusCode();
Assert.That(response.Result.StatusCode, Is.EqualTo(HttpStatusCode.Created));
// 2.
var createdEntityInfo = response.Result.Content
.ReadAsJsonAsync <CreatedWithGuidDto>().Result;
// remember the ID -- it will be used in next tests
_createdTenantGuid = createdEntityInfo.Id;
Console.WriteLine("Tenant created: " + _createdTenantGuid);
// 3.
var createdEntityResponse = _httpClient.GetAsync(_url + createdEntityInfo.Id.ToString());
createdEntityResponse.Result.EnsureSuccessStatusCode();
// 4. there is a user created in the new tenant
var allUsersResponse = _httpClient.GetAsync("/api/account/users/").Result;
allUsersResponse.EnsureSuccessStatusCode();
var allUsers = allUsersResponse.Content.ReadAsJsonAsync <UserDto[]>().Result;
Assert.That(allUsers.Any(
u => 0 == string.Compare(u.TenantId, createdEntityInfo.Id.ToString(), true)));
// 5. and the user can authenticate with the credentials
await _apiClient.SignInWithUserPassword_WithSlug_Async(
tenant.AdminUserDetails.UserName, tenant.AdminUserDetails.NewPassword,
_httpClient, tenant.TenantDetails.Slug);
var id_token = _apiClient.GetIdToken();
// 6. and the id_token contains proper TenantId claim
Console.WriteLine(JObject.FromObject(id_token).ToString());
var tenantIdClaimValue = id_token.Claims.First(claim => claim.Type == CustomClaimTypes.TenantId).Value;
Console.WriteLine("Token contains tenant ID = " + tenantIdClaimValue);
Assert.That(tenantIdClaimValue, Is.EqualTo(createdEntityInfo.Id.ToString()));
// 7. and there are only standard roles created for the tenant
var rolesResponse = _httpClient.GetAsync("/api/account/roles/").Result;
rolesResponse.EnsureSuccessStatusCode();
Console.WriteLine(rolesResponse.Content.ReadAsStringAsync().Result);
var roles = rolesResponse.Content.ReadAsJsonAsync <RoleDto[]>().Result;
Assert.That(roles.Length, Is.EqualTo(4));
}
