//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); }