//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void deleteTenantGroupMembership()
public virtual void deleteTenantGroupMembership()
{
Tenant tenant = identityService.newTenant(TENANT_ONE);
identityService.saveTenant(tenant);
Group group = identityService.newGroup(GROUP_ONE);
identityService.saveGroup(group);
identityService.createTenantGroupMembership(TENANT_ONE, GROUP_ONE);
TenantQuery query = identityService.createTenantQuery().groupMember(GROUP_ONE);
assertThat(query.count(), @is(1L));
identityService.deleteTenantGroupMembership("nonExisting", GROUP_ONE);
assertThat(query.count(), @is(1L));
identityService.deleteTenantGroupMembership(TENANT_ONE, "nonExisting");
assertThat(query.count(), @is(1L));
identityService.deleteTenantGroupMembership(TENANT_ONE, GROUP_ONE);
assertThat(query.count(), @is(0L));
}
public PaginationResult <TenantDto> Query(TenantQuery query)
{
using (var connection = GetConnection())
{
connection.Open();
var columnsCommand = @"
SELECT t.*";
var queryCommand = @"
FROM [_Tenants] t
WHERE (@IsValid is NULL or @IsValid=t.IsValid)
AND (@Name is NULL OR t.Name like @Name)";
var pagingCommand = query.Page == -1 ? "" : @"
ORDER BY t.Id DESC
OFFSET @Offset ROWS
FETCH NEXT @Size ROWS ONLY; ";
query.Name = string.IsNullOrWhiteSpace(query.Name) ?
null : $"%{query.Name.Trim()}%";
var data = connection.Query <TenantDto>($@"{columnsCommand} {queryCommand} {pagingCommand}", query);
var count = connection.ExecuteScalar <long>($@"SELECT COUNT(t.Id) {queryCommand}", query);
var result = CombinePaginationResult(query, data, count);
return(result);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void queryByUserIncludingGroups()
public virtual void queryByUserIncludingGroups()
{
TenantQuery query = identityService.createTenantQuery().userMember(USER);
assertThat(query.includingGroupsOfUser(false).count(), @is(1L));
assertThat(query.includingGroupsOfUser(true).count(), @is(2L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void queryByIdIn()
public virtual void queryByIdIn()
{
TenantQuery query = identityService.createTenantQuery();
assertThat(query.tenantIdIn("non", "existing").count(), @is(0L));
assertThat(query.tenantIdIn(TENANT_ONE, TENANT_TWO).count(), @is(2L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void deleteTenantUserMembership()
public virtual void deleteTenantUserMembership()
{
Tenant tenant = identityService.newTenant(TENANT_ONE);
identityService.saveTenant(tenant);
User user = identityService.newUser(USER_ONE);
identityService.saveUser(user);
identityService.createTenantUserMembership(TENANT_ONE, USER_ONE);
TenantQuery query = identityService.createTenantQuery().userMember(USER_ONE);
assertThat(query.count(), @is(1L));
identityService.deleteTenantUserMembership("nonExisting", USER_ONE);
assertThat(query.count(), @is(1L));
identityService.deleteTenantUserMembership(TENANT_ONE, "nonExisting");
assertThat(query.count(), @is(1L));
identityService.deleteTenantUserMembership(TENANT_ONE, USER_ONE);
assertThat(query.count(), @is(0L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void queryByName()
public virtual void queryByName()
{
TenantQuery query = identityService.createTenantQuery();
assertThat(query.tenantName("nonExisting").count(), @is(0L));
assertThat(query.tenantName("Tenant_1").count(), @is(1L));
assertThat(query.tenantName("Tenant_2").count(), @is(1L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void queryByNameLike()
public virtual void queryByNameLike()
{
TenantQuery query = identityService.createTenantQuery();
assertThat(query.tenantNameLike("%nonExisting%").count(), @is(0L));
assertThat(query.tenantNameLike("%Tenant\\_1%").count(), @is(1L));
assertThat(query.tenantNameLike("%Tenant%").count(), @is(2L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void queryByUser()
public virtual void queryByUser()
{
TenantQuery query = identityService.createTenantQuery();
assertThat(query.userMember("nonExisting").count(), @is(0L));
assertThat(query.userMember(USER).count(), @is(1L));
assertThat(query.userMember(USER).tenantId(TENANT_ONE).count(), @is(1L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void queryByGroup()
public virtual void queryByGroup()
{
TenantQuery query = identityService.createTenantQuery();
assertThat(query.groupMember("nonExisting").count(), @is(0L));
assertThat(query.groupMember(GROUP).count(), @is(1L));
assertThat(query.groupMember(GROUP).tenantId(TENANT_TWO).count(), @is(1L));
}
private IQueryable <Tenant> PagingRequired(IQueryable <Tenant> query, TenantQuery queryObject)
{
if (queryObject.Page != 0 || queryObject.PageSize != 0)
{
return(query.ApplyPaging(queryObject));
}
return(query);
}
public virtual CountResultDto getTenantCount(UriInfo uriInfo)
{
TenantQueryDto queryDto = new TenantQueryDto(ObjectMapper, uriInfo.QueryParameters);
TenantQuery query = queryDto.toQuery(ProcessEngine);
long count = query.count();
return(new CountResultDto(count));
}
public IActionResult Query([FromQuery] TenantQuery query)
{
var tenant = TenantId;
var results = _tr.Query(query);
var vmResults = MapPaginationModel <TenantDto, TenantApiViewModel>(results);
return(Ok(new ApiResultModel <PaginationResult <TenantApiViewModel> >
{
Data = vmResults
}));
}
private TenantQuery setUpMockQuery(IList <Tenant> tenants)
{
TenantQuery query = mock(typeof(TenantQuery));
when(query.list()).thenReturn(tenants);
when(query.count()).thenReturn((long)tenants.Count);
when(processEngine.IdentityService.createTenantQuery()).thenReturn(query);
return(query);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void queryById()
public virtual void queryById()
{
TenantQuery query = identityService.createTenantQuery().tenantId(TENANT_ONE);
assertThat(query.count(), @is(1L));
assertThat(query.list().size(), @is(1));
Tenant tenant = query.singleResult();
assertThat(tenant, @is(notNullValue()));
assertThat(tenant.Name, @is("Tenant_1"));
}
protected internal virtual IList <Tenant> executePaginatedQuery(TenantQuery query, int?firstResult, int?maxResults)
{
if (firstResult == null)
{
firstResult = 0;
}
if (maxResults == null)
{
maxResults = int.MaxValue;
}
return(query.listPage(firstResult, maxResults));
}
private IQueryable <Tenant> SortByRequired(IQueryable <Tenant> query, TenantQuery queryObject)
{
if (!String.IsNullOrWhiteSpace(queryObject.SortBy))
{
var columnsMap = new Dictionary <string, Expression <Func <Tenant, object> > >()
{
["name"] = tenant => tenant.Name,
["email"] = tenant => tenant.Email
};
return(query.ApplyOrdering(queryObject, columnsMap));
}
return(query);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void deleteTenant()
public virtual void deleteTenant()
{
// create
Tenant tenant = identityService.newTenant(TENANT_ONE);
identityService.saveTenant(tenant);
TenantQuery query = identityService.createTenantQuery();
assertThat(query.count(), @is(1L));
identityService.deleteTenant("nonExisting");
assertThat(query.count(), @is(1L));
identityService.deleteTenant(TENANT_ONE);
assertThat(query.count(), @is(0L));
}
protected internal virtual IList <string> setupTenantQueryMock(IList <Tenant> tenants)
{
TenantQuery mockTenantQuery = mock(typeof(TenantQuery));
when(identityServiceMock.createTenantQuery()).thenReturn(mockTenantQuery);
when(mockTenantQuery.userMember(anyString())).thenReturn(mockTenantQuery);
when(mockTenantQuery.includingGroupsOfUser(anyBoolean())).thenReturn(mockTenantQuery);
when(mockTenantQuery.list()).thenReturn(tenants);
IList <string> tenantIds = new List <string>();
foreach (Tenant tenant in tenants)
{
tenantIds.Add(tenant.Id);
}
return(tenantIds);
}
public virtual IList <TenantDto> queryTenants(UriInfo uriInfo, int?firstResult, int?maxResults)
{
TenantQueryDto queryDto = new TenantQueryDto(ObjectMapper, uriInfo.QueryParameters);
TenantQuery query = queryDto.toQuery(ProcessEngine);
IList <Tenant> tenants;
if (firstResult != null || maxResults != null)
{
tenants = executePaginatedQuery(query, firstResult, maxResults);
}
else
{
tenants = query.list();
}
return(TenantDto.fromTenantList(tenants));
}
public async Task <QueryResult <Tenant> > GetTenants(TenantQuery queryObject = null)
{
var queryResult = new QueryResult <Tenant>();
var query = context.Tenants.AsQueryable();
queryResult.TotalItems = await query.CountAsync();
if (queryObject != null)
{
query = await this.FilteredRequired(query, queryObject, this.context);
query = this.SortByRequired(query, queryObject);
queryResult.TotalItems = await query.CountAsync();
query = this.PagingRequired(query, queryObject);
}
queryResult.Items = await query.ToListAsync();
return(queryResult);
}
public QueryResource <TenantQuery, TenantInfo> Query(TenantQuery query = null) =>
new QueryResource <TenantQuery, TenantInfo>(
query,
(q, f, m) => _api.GetList(q, f, m),
q => _api.GetListCount(q));
public QueryResource <TenantQuery, TenantInfo> Query(TenantQuery query = null) => new QueryResource <TenantQuery, TenantInfo>(_api, query);
public async Task <IActionResult> Get(TenantQuery tenantQuery)
{
return(Success(await _tenantService.RetrieveAsync(tenantQuery)));
}
public async Task <IActionResult> Page(TenantQuery tenantQuery)
{
return(Success(await _tenantService.PageAsync(tenantQuery)));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setUpRuntimeData()
public virtual void setUpRuntimeData()
{
IList <Tenant> tenants = Collections.singletonList(MockProvider.createMockTenant());
mockQuery = setUpMockQuery(tenants);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void queryByNonExistingId()
public virtual void queryByNonExistingId()
{
TenantQuery query = identityService.createTenantQuery().tenantId("nonExisting");
assertThat(query.count(), @is(0L));
}
private async Task <IQueryable <Tenant> > FilteredRequired(IQueryable <Tenant> query, TenantQuery queryObject, PropertyRentalContext context)
{
if (queryObject.Available.HasValue && queryObject.Available == true)
{
var unavailableTenants = new List <int>();
var rentals = await context.Rentals.Include(rental => rental.Tenant).ToListAsync();
foreach (var rental in rentals)
{
unavailableTenants.Add(rental.Tenant.Id);
}
query = query.Where(tenant => !unavailableTenants.Any(unavailableTenantId => unavailableTenantId == tenant.Id));
}
return(query);
}
