@Then("^the user should receive a specified JSON content$") public void jsonResponse() throws Exception { assertThat(response.getHeaders("Content-Type")) .extracting(Header::getValue) .containsExactly(org.apache.http.entity.ContentType.APPLICATION_JSON.toString()); DocumentContext jsonPath = JsonPath.parse(response.getEntity().getContent()); assertThat(jsonPath.<String>read("blobId")).isEqualTo(_1M_ZEROED_FILE_BLOB_ID); assertThat(jsonPath.<String>read("type")).isEqualTo("application/octet-stream"); assertThat(jsonPath.<Integer>read("size")).isEqualTo(_1M); }
@Test public void testGetLocation() throws Exception { LocationRepository repository = container.getInjector().getInstance(LocationRepository.class); String id = repository.create(new Location("foo", 0, 0)).getId(); HttpResponse httpResponse = container.execute(new HttpGet("/location/" + id)); assertEquals(HttpURLConnection.HTTP_OK, httpResponse.getStatusLine().getStatusCode()); HttpEntity entity = httpResponse.getEntity(); assertEquals(ContentType.APPLICATION_JSON.getMimeType(), ContentType.get(entity).getMimeType()); String content = EntityUtils.toString(entity); ObjectMapper om = new ObjectMapper(); Map<String, ?> response = om.readValue(content, new TypeReference<Map<String, ?>>() {}); assertEquals(id, response.get("id")); }
private JSONObject prepareRequestAndExtractResponse(HttpUriRequest request) throws HTTPError { if (key != null) { String encoding = ""; try { encoding = Base64.encodeBase64String((key + ":").getBytes("UTF-8")); } catch (UnsupportedEncodingException e) { throw new RuntimeException(e); } request.setHeader("Authorization", "Basic " + encoding + "="); } HttpResponse response; try { response = httpClient.execute(request); } catch (ClientProtocolException e) { throw new RuntimeException(e); } catch (IOException e) { throw new RuntimeException(e); } String body = null; HttpEntity entity = response.getEntity(); if (entity != null) { try { body = EntityUtils.toString(entity); } catch (IOException e) { throw new RuntimeException(e); } } StatusLine status = response.getStatusLine(); if (status.getStatusCode() >= 299 && !ContentType.APPLICATION_JSON .getMimeType() .equals( (entity.getContentType() != null ? entity.getContentType().getValue() : null))) { throw new HTTPError(response, body); } JSONObject result; try { result = new JSONObject(body); } catch (JSONException e) { throw new RuntimeException(e); } return result; }
private CloseableHttpClient createClientInstance() { final RequestConfig requestConfig = RequestConfig.copy(RequestConfig.DEFAULT) .setConnectionRequestTimeout((int) config.getConnectTimeout().toMillis()) .setSocketTimeout((int) config.getConnectTimeout().toMillis()) .build(); final List<Header> headers = new ArrayList<>(1); headers.add( new BasicHeader(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.getMimeType())); return HttpClients.custom() .setDefaultRequestConfig(requestConfig) .setDefaultHeaders(headers) .build(); }
@Test public void testGetContentType() throws Exception { String input = "0123456789"; BasicHttpEntity basic; PartiallyRepeatableHttpEntity replay; basic = new BasicHttpEntity(); basic.setContent(new ByteArrayInputStream(input.getBytes(UTF8))); replay = new PartiallyRepeatableHttpEntity(basic, 5); assertThat(replay.getContentType(), nullValue()); basic = new BasicHttpEntity(); basic.setContent(new ByteArrayInputStream(input.getBytes(UTF8))); basic.setContentType(ContentType.APPLICATION_JSON.getMimeType()); replay = new PartiallyRepeatableHttpEntity(basic, 5); assertThat(replay.getContentType().getValue(), is("application/json")); }
public void testInitialSearchEntity() throws IOException { String query = "{\"match_all\":{}}"; HttpEntity entity = initialSearchEntity(new BytesArray(query)); assertEquals(ContentType.APPLICATION_JSON.toString(), entity.getContentType().getValue()); assertEquals( "{\"query\":" + query + "}", Streams.copyToString(new InputStreamReader(entity.getContent(), StandardCharsets.UTF_8))); // Invalid XContent fails RuntimeException e = expectThrows( RuntimeException.class, () -> initialSearchEntity(new BytesArray("{}, \"trailing\": {}"))); assertThat(e.getCause().getMessage(), containsString("Unexpected character (',' (code 44))")); e = expectThrows(RuntimeException.class, () -> initialSearchEntity(new BytesArray("{"))); assertThat(e.getCause().getMessage(), containsString("Unexpected end-of-input")); }
public boolean banImpl(String userId, String serverId) { Map<String, String> headers = new HashMap<>(); headers.put(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.getMimeType()); headers.put(HttpHeaders.AUTHORIZATION, apiClient.getToken()); try { HttpResponse<JsonNode> response = Unirest.put( "https://discordapp.com/api/guilds/" + serverId + "/bans/" + userId + "?delete-message-days=1") .headers(headers) .asJson(); // Ignore return true; } catch (Exception e) { LOGGER.warn("Exception when trying to ban " + userId, e); return false; } }
private void vanish(MessageContext context, String args) { Message message = context.getMessage(); if (args.isEmpty()) { return; } try { final int cap = 100; final int capPages = 10; String[] vals = args.split(" "); String userId; int numMsgs; if (vals.length == 2) { User user = findUser(context, vals[0]); userId = user.getId(); if (user == NO_USER) { userId = vals[0]; } numMsgs = Math.max(1, Math.min(cap, Integer.parseInt(vals[1]))); } else if (vals.length == 1) { userId = ""; numMsgs = Math.max(1, Math.min(cap, Integer.parseInt(vals[0]))); } else { userId = ""; numMsgs = 10; } int limit = numMsgs; String before = message.getId(); // Limit search to 10 pages (500 msgs) // Instead of deleting them when we find them, we build a list instead List<String> messagesToDelete = new ArrayList<>(limit); for (int k = 0; k < capPages && limit > 0; k++) { Map<String, String> headers = new HashMap<>(); headers.put(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.getMimeType()); headers.put(HttpHeaders.AUTHORIZATION, apiClient.getToken()); Map<String, Object> queryParams = new HashMap<>(); queryParams.put("limit", 50); queryParams.put("before", before); HttpResponse<JsonNode> response = Unirest.get(ApiConst.CHANNELS_ENDPOINT + message.getChannelId() + "/messages") .headers(headers) .queryString(queryParams) .asJson(); JSONArray ret = response.getBody().getArray(); if (userId.isEmpty()) { for (int i = 0; i < ret.length() && limit > 0; i++) { JSONObject msg = ret.getJSONObject(i); String mid = msg.getString("id"); before = mid; messagesToDelete.add(mid); limit--; } } else { for (int i = 0; i < ret.length() && limit > 0; i++) { JSONObject msg = ret.getJSONObject(i); String mid = msg.getString("id"); JSONObject msgUsr = msg.getJSONObject("author"); String uid = msgUsr.getString("id"); before = mid; if (userId.equals(uid)) { messagesToDelete.add(mid); limit--; } } } } LOGGER.info("Deleting {} messages", messagesToDelete.size()); // Using bulk delete endpoint apiClient.bulkDeleteMessages( context.getChannel().getId(), messagesToDelete.toArray(new String[messagesToDelete.size()])); } catch (Exception e) { LOGGER.warn("Unable to get messages", e); } }
private void setNick(MessageContext context, String args) { if (context.getServer() == null || context.getServer() == NO_SERVER) { return; } String serverId = context.getServer().getId(); Channel channel = context.getChannel(); String[] split = args.split(" ", 2); String newNickname; if (split.length == 1) { // Clearing nickname, set to empty string newNickname = ""; } else { newNickname = split[1]; } User[] mentions = context.getMessage().getMentions(); if (mentions.length == 0) { apiClient.sendMessage(loc.localize("commands.mod.setnick.response.blank"), channel); } User target = mentions[0]; Map<String, String> headers = new HashMap<>(); headers.put(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.getMimeType()); headers.put(HttpHeaders.AUTHORIZATION, apiClient.getToken()); try { HttpResponse<JsonNode> response = Unirest.patch( "https://discordapp.com/api/guilds/" + serverId + "/members/" + target.getId()) .headers(headers) .body("{\"nick\":\"" + newNickname + "\"}") .asJson(); int status = response.getStatus(); if (status != 204) { if (status == 403) { apiClient.sendMessage( loc.localize("commands.mod.setnick.response.failed.no_perms"), channel); } else if (status == 404) { apiClient.sendMessage( loc.localize("commands.mod.setnick.response.failed.not_found"), channel); } else { apiClient.sendMessage( loc.localize( "commands.mod.setnick.response.unknown_error", status, response.getStatusText(), response.getBody().toString()), channel); } } else { if (newNickname.isEmpty()) { apiClient.sendMessage( loc.localize("commands.mod.setnick.response.removed", target.getUsername()), channel); } else { apiClient.sendMessage( loc.localize( "commands.mod.setnick.response.changed", target.getUsername(), newNickname), channel); } } } catch (UnirestException e) { LOGGER.warn( "Exception while setting nickname for {} {} in {} {}", target.getUsername(), target.getId(), context.getServer().getName(), serverId); LOGGER.warn("Nickname set exception", e); } }
private Res handlePOSTRequest(Req request, Class<Res> resClass) { L.d(TAG, "Request URL: " + request.getURL()); HttpPost httpPost = new HttpPost(request.getURL()); // 添加请求头 Map<String, String> headersMap = request.getHeaders(); if (headersMap != null) { Iterator<Map.Entry<String, String>> iterator = headersMap.entrySet().iterator(); while (iterator.hasNext()) { Map.Entry<String, String> entry = iterator.next(); httpPost.addHeader(entry.getKey(), entry.getValue()); } } L.d(TAG, "Request Header: " + new Gson().toJson(headersMap)); // 判断是否存在上传文件,以不同方式添加请求参数 if (request.existUploadFiles()) { Map<String, String> uploadFilesMap = request.getUploadFiles(); Map<String, Object> paramsMap = request.getParams(); /*MultipartEntityBuilder builder = MultipartEntityBuilder.create(); builder.setMode( HttpMultipartMode.BROWSER_COMPATIBLE ); // builder.setCharset( Charset.forName( "UTF-8" ) ); String data = new Gson().toJson( paramsMap ); // 设置中文编码 ContentType contentType = ContentType.create( "application/json" , HTTP.UTF_8 ); StringBody strBody = new StringBody( data , contentType ); builder.addPart( "data" , strBody ); // builder.addTextBody( "data" , data ); // builder.addTextBody( "data" , data , ContentType.APPLICATION_JSON.withCharset( "UTF-8" ) ); Log.d( "[File Data]" , data ); Iterator<Entry<String , String>> iterator = uploadFilesMap.entrySet().iterator(); while( iterator.hasNext() ) { Map.Entry<String , String> entry = iterator.next(); String key = entry.getKey(); String filePath = entry.getValue(); if( !TextUtils.isEmpty( filePath ) ) { byte[] fileByte = FileUtils.getBytesFromFile( new File( filePath ) ); builder.addBinaryBody( key , fileByte ); } } HttpEntity httpEntity = builder.build();*/ MultipartEntity httpEntity = new MultipartEntity(); StringBody sb = new StringBody( new Gson().toJson(paramsMap), ContentType.APPLICATION_JSON.withCharset("UTF-8")); httpEntity.addPart("data", sb); Iterator<Entry<String, String>> iterator = uploadFilesMap.entrySet().iterator(); while (iterator.hasNext()) { Map.Entry<String, String> entry = iterator.next(); String key = entry.getKey(); String filePath = entry.getValue(); if (!TextUtils.isEmpty(filePath)) { /*byte[] fileByte = FileUtils.getBytesFromFile( new File( filePath ) ); builder.addBinaryBody( key , fileByte );*/ ContentBody cbFile = new FileBody(new File(filePath)); httpEntity.addPart(key, cbFile); } } httpPost.setEntity(httpEntity); /*if( paramsMap != null ) { MultipartEntity httpEntity = new MultipartEntity(); Iterator<Map.Entry<String , Object>> iterator = paramsMap.entrySet().iterator(); while( iterator.hasNext() ) { Map.Entry<String , Object> entry = iterator.next(); L.d( TAG , "---- Params Key: " + entry.getKey() + " ----\n---- Params Value: " + entry.getValue() ); StringBody sb = new StringBody( new Gson().toJson( entry.getValue() ) , ContentType.APPLICATION_JSON.withCharset( "UTF-8" ) ); httpEntity.addPart( entry.getKey() , sb ); } httpPost.setEntity( httpEntity ); }*/ } else { Map<String, Object> paramsMap = request.getParams(); L.e(TAG, "[Request Params]: " + new Gson().toJson(paramsMap)); if (paramsMap != null) { String bodyJsonString = new Gson().toJson(paramsMap); StringEntity entity = null; try { entity = new StringEntity(bodyJsonString, HTTP.UTF_8); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } httpPost.setEntity(entity); } } Res response = null; try { HttpResponse httpResponse = httpClient.execute(httpPost); try { response = (Res) resClass.newInstance().parseResult(httpResponse); if (response != null && response.isTokenError()) { EventBus.getDefault().post(new ErrorTokenEvent()); } } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } } catch (ClientProtocolException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } return response; }
public static String doPostJson(String url, String json) { return doPostString(url, json, ContentType.APPLICATION_JSON.getMimeType()); }