public UserGroupList getUserGroups(Integer page, Integer entries, boolean all) {
   WebResource wr = getBaseWebResource("usergroups");
   wr = wr.queryParam("page", page.toString());
   wr = wr.queryParam("entries", entries.toString());
   wr = wr.queryParam("all", "" + all);
   return wr.header("Content-Type", MediaType.TEXT_XML)
       .accept(MediaType.TEXT_XML)
       .get(UserGroupList.class);
 }
 private ReviewableItemsStatistics execGet(
     final String mapId, final String reviewScoreThresholdMinimum, final String geospatialBounds)
     throws Exception {
   WebResource resource = resource().path("/review/statistics");
   if (mapId != null) {
     resource = resource.queryParam("mapId", mapId);
   }
   if (reviewScoreThresholdMinimum != null) {
     resource = resource.queryParam("reviewScoreThresholdMinimum", reviewScoreThresholdMinimum);
   }
   if (geospatialBounds != null) {
     resource = resource.queryParam("geospatialBounds", geospatialBounds);
   }
   return resource.accept(MediaType.APPLICATION_JSON).get(ReviewableItemsStatistics.class);
 }
 public static WebResource addOptionalQueryParam(
     WebResource webResource, String key, int value, int defaultValue) {
   if (value != defaultValue) {
     webResource = webResource.queryParam(key, Integer.toString(value));
   }
   return webResource;
 }
  /** Reproducer test for JERSEY-1893. */
  @Test
  public void testGet() {
    WebResource r = resource().path("/");

    String s;

    // check that the regular filter gets involved
    s = r.path("direct").get(String.class);
    Assert.assertEquals("[DIRECT]", s);

    // the regular filter should work for directly requested forward resource as well.
    s = r.path("forward").get(String.class);
    Assert.assertEquals("[FORWARD]", s);

    // forward action should enforce forward filter to be invoked
    s = r.queryParam("action", "forward").get(String.class);
    Assert.assertEquals(">>FORWARD", s);

    // direct call to the include resource
    s = r.path("included").get(String.class);
    Assert.assertEquals("[INCLUDED]", s);

    // include call should involve both regular and include filter
    s = r.path("included").queryParam("action", "include").get(String.class);
    Assert.assertEquals("[SOMETHING INCLUDED]", s);
  }
  /**
   * Lists workflows according to the provided tag or with not tag restriction if null is provided.
   *
   * @param tag the tag to filter or null
   * @return a list of workflows
   */
  public List<WorkflowInfo> listWorkflows(String tag) {
    GenericType<JAXBElement<SearchResult>> searchResultType =
        new GenericType<JAXBElement<SearchResult>>() {};

    WebResource workflows = myExperiment.path(WORKFLOWS_PATH);
    if (tag != null) {
      workflows = workflows.queryParam("tag", tag);
    }
    LOG.debug("Querying myExperiments for workflows with tag [{}]", tag);
    return workflows
        .queryParam("elements", QUERY_ELEMENTS)
        .accept(MediaType.APPLICATION_XML_TYPE)
        .get(searchResultType)
        .getValue()
        .getWorkflows();
  }
 public static WebResource addOptionalQueryParam(
     WebResource webResource, String key, Object value) {
   if (value != null) {
     webResource = webResource.queryParam(key, value.toString());
   }
   return webResource;
 }
예제 #7
0
  /**
   * Retrieves from Keystone server a list of tenants from the given optional marker and limit
   * values. The marker and limit values are appended to the actual HTTP request to Keystone as
   * query string parameters. The return object of {@link KeystoneTenantList} represents the
   * response body from the Keystone API containing the tenant list.
   *
   * @param marker The ID of the tenant fetched in the previous request. The returned list will
   *     start from the tenant after the tenant with this ID. A null and empty values are ignored.
   * @param limit The number of tenants to fetch. Must be greater than 0. This field is ignored if
   *     the value is less than 1.
   * @return {@link KeystoneTenantList} object, representing the response from the Keystone API.
   * @throws KeystoneServerException
   * @throws KeystoneConnectionException
   */
  public KeystoneTenantList getTenants(String marker, int limit)
      throws KeystoneServerException, KeystoneConnectionException {
    log.debug("KeystoneClient.getTenants: entered marker=" + marker + ", limit=" + limit);

    Client client = Client.create(clientConfig);
    WebResource resource = client.resource(getTenantsUrl());

    if (!StringUtils.isEmpty(marker)) {
      resource = resource.queryParam(MARKER_QUERY, marker);
    }

    if (limit > 0) {
      resource = resource.queryParam(LIMIT_QUERY, Integer.toString(limit));
    }

    return sendGetRequest(resource, KeystoneTenantList.class);
  }
 public UserList getUsers(Integer page, Integer entries) {
   WebResource wr = getBaseWebResource("users");
   return wr.queryParam("page", page.toString())
       .queryParam("entries", entries.toString())
       .header("Content-Type", MediaType.TEXT_XML)
       .accept(MediaType.TEXT_XML)
       .get(UserList.class);
 }
예제 #9
0
  public <T> T getRawData(Class<T> clazz, Long id, RawFormat decodeFrom) {
    WebResource wr = getBaseWebResource("data", id, "raw");
    if (decodeFrom != null) {
      wr = wr.queryParam("decode", decodeFrom.name());
    }

    return wr.get(clazz);
  }
예제 #10
0
  public Resource getResource(Long id, boolean full) {
    WebResource resource = getBaseWebResource("resources", "resource", id);
    if (full) resource = resource.queryParam("full", Boolean.toString(full));

    return resource
        .header("Content-Type", MediaType.TEXT_XML)
        .accept(MediaType.TEXT_XML)
        .get(Resource.class);
  }
예제 #11
0
 @Test
 public void testQueryEndpointMultipleColumns() throws Exception {
   Node andres = createNode("name", "Andres");
   cypherRsPath.put(ClientResponse.class, MULTI_COLUMN_QUERY);
   ClientResponse response =
       cypherRsPath.queryParam("ids", String.valueOf(andres.getId())).get(ClientResponse.class);
   String result = response.getEntity(String.class);
   assertEquals(result, 200, response.getStatus());
   assertEquals("{\"l\":6,\"name\":\"Andres\"}", result);
 }
  private ClientResponse addProperty(String guid, String property, String value) {
    WebResource resource = service.path(ENTITIES).path(guid);

    return resource
        .queryParam("property", property)
        .queryParam("value", value)
        .accept(Servlets.JSON_MEDIA_TYPE)
        .type(Servlets.JSON_MEDIA_TYPE)
        .method(HttpMethod.PUT, ClientResponse.class);
  }
예제 #13
0
 @Test
 public void testQueryEndpoint() throws Exception {
   Node node = createNode("foo", "bar");
   cypherRsPath.put(ClientResponse.class, QUERY);
   ClientResponse response =
       cypherRsPath.queryParam("id", String.valueOf(node.getId())).get(ClientResponse.class);
   String result = response.getEntity(String.class);
   assertEquals(result, 200, response.getStatus());
   assertEquals("{\"foo\":\"bar\"}", result);
 }
예제 #14
0
  @Test
  public void testQueryEndpointNoResults() throws Exception {
    cypherRsPath.put(ClientResponse.class, MULTI_COLUMN_QUERY);
    ClientResponse response =
        cypherRsPath
            .queryParam("ids", String.valueOf(-234))
            .queryParam("ids", String.valueOf(-567))
            .get(ClientResponse.class);

    assertEquals(204, response.getStatus());
  }
예제 #15
0
  public ExtGroupList searchUserGroup(Integer start, Integer limit, String nameLike, boolean all) {
    WebResource wr = getBaseWebResource("extjs", "search", "groups", nameLike);

    wr =
        wr.queryParam("start", start.toString())
            .queryParam("limit", limit.toString())
            .queryParam("all", Boolean.toString(all));

    return wr.header("Content-Type", MediaType.TEXT_XML)
        .accept(MediaType.TEXT_XML)
        .get(ExtGroupList.class);
  }
예제 #16
0
  private <T, F, R> List<T> getContactsCommon(
      WebResource resource,
      ProfileField<F, R> key,
      F value,
      Integer limit,
      Integer offset,
      final ProfileType<T> type,
      ContactOrder order,
      ContactType contactType) {
    if (key != null && value != null) {
      resource =
          resource
              .queryParam("key", key.getName().toLowerCase())
              .queryParam("value", key.format(value).toString());
    }
    if (limit != null) {
      resource = resource.queryParam("limit", limit.toString());
    }
    if (offset != null) {
      resource = resource.queryParam("offset", offset.toString());
    }
    resource = resource.queryParam("type", type.getName());
    if (order != null) {
      resource = resource.queryParam("order", order.name().toLowerCase());
    }
    if (contactType != null) {
      resource = resource.queryParam("contact_type", contactType.name().toLowerCase());
    }

    return resource.get(getGenericType(type));
  }
예제 #17
0
 @Test
 public void testQueryEndpointMultipleResults() throws Exception {
   Node andres = createNode("name", "Andres");
   Node peter = createNode("name", "Peter");
   cypherRsPath.put(ClientResponse.class, "match n where id(n) in {ids} return n");
   ClientResponse response =
       cypherRsPath
           .queryParam("ids", String.valueOf(andres.getId()))
           .queryParam("ids", String.valueOf(peter.getId()))
           .get(ClientResponse.class);
   String result = response.getEntity(String.class);
   assertEquals(result, 200, response.getStatus());
   assertEquals("[{\"name\":\"Andres\"},{\"name\":\"Peter\"}]", result);
 }
  /*
   * https://www.twilio.com/docs/api/rest/available-phone-numbers#local-get-basic-example-1
   * available local phone numbers in the United States in the 510 area code.
   */
  @Test
  public void testSearchUSLocalPhoneNumbersWith501AreaCode() {
    stubFor(
        put(urlEqualTo("/test/configuration/voiceuri"))
            .willReturn(
                aResponse()
                    .withStatus(200)
                    .withHeader("Content-Type", "application/json")
                    .withBody(VoxboneAvailablePhoneNumbersEndpointTestUtils.VoiceURIJSonResponse)));
    stubFor(
        get(urlEqualTo(
                "/test/inventory/didgroup?countryCodeA3=USA&areaCode=501&pageNumber=0&pageSize=50"))
            .willReturn(
                aResponse()
                    .withStatus(200)
                    .withHeader("Content-Type", "application/json")
                    .withBody(VoxboneAvailablePhoneNumbersEndpointTestUtils.body501AreaCode)));
    // Get Account using admin email address and user email address
    Client jerseyClient = Client.create();
    jerseyClient.addFilter(new HTTPBasicAuthFilter(adminUsername, adminAuthToken));

    String provisioningURL = deploymentUrl + baseURL + "US/Local.json";
    WebResource webResource = jerseyClient.resource(provisioningURL);

    ClientResponse clientResponse =
        webResource
            .queryParam("areaCode", "501")
            .accept("application/json")
            .get(ClientResponse.class);
    assertTrue(clientResponse.getStatus() == 200);
    String response = clientResponse.getEntity(String.class);
    System.out.println(response);
    assertTrue(!response.trim().equalsIgnoreCase("[]"));
    JsonParser parser = new JsonParser();
    JsonArray jsonResponse = parser.parse(response).getAsJsonArray();

    System.out.println(jsonResponse);

    assertTrue(jsonResponse.size() == 15);
    System.out.println((jsonResponse.get(0).getAsJsonObject().toString()));
    assertTrue(
        jsonResponse
            .get(0)
            .getAsJsonObject()
            .toString()
            .equalsIgnoreCase(
                VoxboneAvailablePhoneNumbersEndpointTestUtils.firstJSonResult501AreaCode));
  }
예제 #19
0
    /** Finishes the query for execution. */
    public void finishQuery() {
      finishMigrationPathFilter();
      finishDependencyLabelFilter();
      finishMigrationPathSource();
      finishHandlesMimetypes();

      IndentedLineBuffer formatBuffer = new IndentedLineBuffer();
      FormatterElement.format(formatBuffer, new SerializationContext(prefixMapping), query);

      try {
        String encqs = URLEncoder.encode(formatBuffer.toString(), "UTF-8");
        String encpf = URLEncoder.encode(prefixes, "UTF-8");
        resource = resource.queryParam(PREFIX_NAME, encpf).queryParam(QUERY_NAME, encqs);
      } catch (UnsupportedEncodingException e) {
        LOG.error("Error encoding query", e);
      }
    }
  @Test
  public void testGetTraitNames() throws Exception {
    String[] traitsAdded = addTraits();

    WebResource resource = service.path("api/atlas/types");

    ClientResponse clientResponse =
        resource
            .queryParam("type", DataTypes.TypeCategory.TRAIT.name())
            .accept(Servlets.JSON_MEDIA_TYPE)
            .type(Servlets.JSON_MEDIA_TYPE)
            .method(HttpMethod.GET, ClientResponse.class);
    assertEquals(clientResponse.getStatus(), Response.Status.OK.getStatusCode());

    String responseAsString = clientResponse.getEntity(String.class);
    Assert.assertNotNull(responseAsString);

    JSONObject response = new JSONObject(responseAsString);
    Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID));

    final JSONArray list = response.getJSONArray(AtlasClient.RESULTS);
    Assert.assertNotNull(list);
    Assert.assertTrue(list.length() >= traitsAdded.length);
  }
예제 #21
0
 protected WebResource addQParam(WebResource wb, String key, Object value) {
   if (value != null) return wb.queryParam(key, value.toString());
   else return wb;
 }
예제 #22
0
 @Test
 public void testGetQueryWriteQueryShouldReturnInvalidMethod() throws Exception {
   cypherRsPath.put(ClientResponse.class, WRITE_QUERY);
   ClientResponse response = cypherRsPath.queryParam("name", "foobar").get(ClientResponse.class);
   assertEquals(Response.Status.NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
 }
예제 #23
0
 @Test
 public void testQueryNonExistingEndpoint() throws Exception {
   ClientResponse response = cypherRsPath.queryParam("id", "123").get(ClientResponse.class);
   assertEquals(404, response.getStatus());
 }