/** * Creates the query portion of a URI based on a list of NameValuePairs. * * @return The requested string. */ protected String getQueryString() { final List<NameValuePair> params = getUrlParameters(); String queryString = null; if (params != null && !params.isEmpty()) { final StringBuilder sb = new StringBuilder(params.size() * 10); for (NameValuePair param : params) { if (param == null) { continue; } sb.append(param.getName()); sb.append("="); sb.append(param.getValue() == null ? "" : param.getValue()); sb.append("&"); } String potentialQueryString = sb.toString(); if (potentialQueryString.length() == 0) { potentialQueryString = null; } else if (potentialQueryString.endsWith("&")) { potentialQueryString = potentialQueryString.substring(0, potentialQueryString.length() - 1); } // URLEncoder.encode cannot be used since it encodes things in a way the api does not expect, // particularly // dates. queryString = potentialQueryString; } return queryString; }
/** * Parses the access token for a given subscriber provided the subscriber has completed the * authentication process via SMS. * * @param requestURL The callback URL along with the query parameters as called by the system upon * SMS subscription by the user. Query parameters must include access_token and * subscription_number. * @return Access token and subscriber number * @throws GlobeApiException */ public AccessTokenResponse getAccessToken(String requestURL) throws GlobeApiException { try { URIBuilder builder = new URIBuilder(requestURL); List<NameValuePair> queryParams = builder.getQueryParams(); String accessToken = null; String subscriberNumber = null; for (NameValuePair pair : queryParams) { if ("access_token".equals(pair.getName())) { accessToken = pair.getValue(); } else if ("subscriber_number".equals(pair.getName())) { subscriberNumber = pair.getValue(); } } if (accessToken == null || subscriberNumber == null) { throw new GlobeApiException("Request URL cannot be parsed"); } else { return new AccessTokenResponse(accessToken, subscriberNumber); } } catch (URISyntaxException e) { throw new GlobeApiException("Request URL cannot be parsed", e); } }
public List<NameValuePair> addnew_crypt_K_param(List<NameValuePair> param, String url) { ArrayList<NameValuePair> localArrayList = new ArrayList<NameValuePair>(); generate_new_aes_key(); localArrayList.add(new BasicNameValuePair("K", get_K())); Iterator<NameValuePair> i = param.iterator(); boolean is_login = false; if (url.indexOf("login?") != -1 || url.indexOf("regist?") != -1) { is_login = true; ON = true; } while (i.hasNext()) { NameValuePair n = i.next(); // String val = Base64.encodeBase64String(new_encrypt_cn(E_CODE.AES,n.getValue())); String val = new String(Base64.encode(new_encrypt_cn(E_CODE.AES, n.getValue()), Base64.DEFAULT)); if (is_login == true) { // localArrayList.add(new BasicNameValuePair(n.getName(), // Base64.encodeBase64String(new_encrypt_cn(E_CODE.RSA_EP, val)))); localArrayList.add( new BasicNameValuePair( n.getName(), new String(Base64.encode(new_encrypt_cn(E_CODE.RSA_EP, val), Base64.DEFAULT)))); } else { localArrayList.add(new BasicNameValuePair(n.getName(), val)); } } return localArrayList; }
public static zzkq zza(zzae com_google_android_gms_analytics_internal_zzae, String str) { zzkq com_google_android_gms_internal_zzkq = null; zzv.zzr(com_google_android_gms_analytics_internal_zzae); if (TextUtils.isEmpty(str)) { return com_google_android_gms_internal_zzkq; } try { List<NameValuePair> parse = URLEncodedUtils.parse(new URI("?" + str), HttpRequest.CHARSET_UTF8); Map hashMap = new HashMap(parse.size()); for (NameValuePair nameValuePair : parse) { hashMap.put(nameValuePair.getName(), nameValuePair.getValue()); } zzkq com_google_android_gms_internal_zzkq2 = new zzkq(); com_google_android_gms_internal_zzkq2.zzcU((String) hashMap.get("utm_content")); com_google_android_gms_internal_zzkq2.zzcS((String) hashMap.get("utm_medium")); com_google_android_gms_internal_zzkq2.setName((String) hashMap.get("utm_campaign")); com_google_android_gms_internal_zzkq2.zzcR((String) hashMap.get("utm_source")); com_google_android_gms_internal_zzkq2.zzcT((String) hashMap.get("utm_term")); com_google_android_gms_internal_zzkq2.zzcV((String) hashMap.get("utm_id")); com_google_android_gms_internal_zzkq2.zzcW((String) hashMap.get("anid")); com_google_android_gms_internal_zzkq2.zzcX((String) hashMap.get("gclid")); com_google_android_gms_internal_zzkq2.zzcY((String) hashMap.get("dclid")); com_google_android_gms_internal_zzkq2.zzcZ((String) hashMap.get("aclid")); return com_google_android_gms_internal_zzkq2; } catch (URISyntaxException e) { com_google_android_gms_analytics_internal_zzae.zzd("No valid campaign data found", e); return com_google_android_gms_internal_zzkq; } }
public static zzol zza(zzaf com_google_android_gms_analytics_internal_zzaf, String str) { zzol com_google_android_gms_internal_zzol = null; zzx.zzv(com_google_android_gms_analytics_internal_zzaf); if (TextUtils.isEmpty(str)) { return com_google_android_gms_internal_zzol; } try { List<NameValuePair> parse = URLEncodedUtils.parse(new URI("?" + str), HTTP.UTF_8); Map hashMap = new HashMap(parse.size()); for (NameValuePair nameValuePair : parse) { hashMap.put(nameValuePair.getName(), nameValuePair.getValue()); } zzol com_google_android_gms_internal_zzol2 = new zzol(); com_google_android_gms_internal_zzol2.zzdL((String) hashMap.get("utm_content")); com_google_android_gms_internal_zzol2.zzdJ((String) hashMap.get("utm_medium")); com_google_android_gms_internal_zzol2.setName((String) hashMap.get("utm_campaign")); com_google_android_gms_internal_zzol2.zzdI((String) hashMap.get("utm_source")); com_google_android_gms_internal_zzol2.zzdK((String) hashMap.get("utm_term")); com_google_android_gms_internal_zzol2.zzdM((String) hashMap.get("utm_id")); com_google_android_gms_internal_zzol2.zzdN((String) hashMap.get("anid")); com_google_android_gms_internal_zzol2.zzdO((String) hashMap.get("gclid")); com_google_android_gms_internal_zzol2.zzdP((String) hashMap.get("dclid")); com_google_android_gms_internal_zzol2.zzdQ((String) hashMap.get("aclid")); return com_google_android_gms_internal_zzol2; } catch (URISyntaxException e) { com_google_android_gms_analytics_internal_zzaf.zzd("No valid campaign data found", e); return com_google_android_gms_internal_zzol; } }
/** * Sends a POST request with a file and returns the response. * * @param endpoint The endpoint to send the request to. * @param file The file to upload * @param responseClass The class to deserialise the Json response to. Can be null if no response * message is expected. * @param fields Any name-value pairs to serialise * @param <T> The type to deserialise the response to. * @return A {@link Response} containing the deserialised body, if any. * @throws IOException If an error occurs. * @see MultipartEntityBuilder */ public <T> Response<T> post( Endpoint endpoint, File file, Class<T> responseClass, NameValuePair... fields) throws IOException { if (file == null) { return post(endpoint, responseClass, fields); } // deal with null case // Create the request HttpPost post = new HttpPost(endpoint.url()); post.setHeaders(combineHeaders()); // Add fields as text pairs MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create(); for (NameValuePair field : fields) { multipartEntityBuilder.addTextBody(field.getName(), field.getValue()); } // Add file as binary FileBody bin = new FileBody(file); multipartEntityBuilder.addPart("file", bin); // Set the body post.setEntity(multipartEntityBuilder.build()); // Send the request and process the response try (CloseableHttpResponse response = httpClient().execute(post)) { T body = deserialiseResponseMessage(response, responseClass); return new Response<>(response.getStatusLine(), body); } }
public static String encodeParameters( List<NameValuePair> postParams, String splitter, boolean quot, boolean sort) { if (sort) Collections.sort( postParams, new Comparator<NameValuePair>() { @Override public int compare(NameValuePair o1, NameValuePair o2) { return o1.getName().compareTo(o2.getName()); } }); StringBuilder buf = new StringBuilder(); for (NameValuePair pair : postParams) { if (buf.length() != 0) { if (quot) { buf.append("\""); } buf.append(splitter); } buf.append(encode(pair.getName())).append("="); if (quot) { buf.append("\""); } buf.append(encode(pair.getValue())); } if (buf.length() != 0) { if (quot) { buf.append("\""); } } return buf.toString(); }
private static JsonNode encodeParamsAsJson(final List<NameValuePair> params) { final Map<String, String> map = new HashMap<String, String>(params.size()); for (final NameValuePair nameValuePair : params) { map.put(nameValuePair.getName(), nameValuePair.getValue()); } return new ObjectMapper().valueToTree(map); }
public static String post(String url, NameValuePair[] nameValuePair) throws ApiException { Map<String, String> paramsMap = new HashMap<String, String>(); for (NameValuePair t : nameValuePair) { paramsMap.put(t.getName(), t.getValue()); } return post(url, paramsMap); }
/** * Returns a list of {@link NameValuePair NameValuePairs} as parsed from an {@link HttpEntity}. * The encoding is taken from the entity's Content-Encoding header. * * <p>This is typically used while parsing an HTTP POST. * * @param entity The entity to parse * @throws IOException If there was an exception getting the entity's data. */ public static List<NameValuePair> parse(final HttpEntity entity) throws IOException { List<NameValuePair> result = Collections.emptyList(); String contentType = null; String charset = null; Header h = entity.getContentType(); if (h != null) { HeaderElement[] elems = h.getElements(); if (elems.length > 0) { HeaderElement elem = elems[0]; contentType = elem.getName(); NameValuePair param = elem.getParameterByName("charset"); if (param != null) { charset = param.getValue(); } } } if (contentType != null && contentType.equalsIgnoreCase(CONTENT_TYPE)) { final String content = EntityUtils.toString(entity, HTTP.ASCII); if (content != null && content.length() > 0) { result = new ArrayList<NameValuePair>(); parse(result, new Scanner(content), charset); } } return result; }
public BrowserMobHttpResponse execute() { // deal with PUT/POST requests if (method instanceof HttpEntityEnclosingRequestBase) { HttpEntityEnclosingRequestBase enclodingRequest = (HttpEntityEnclosingRequestBase) method; if (!nvps.isEmpty()) { try { if (!multiPart) { enclodingRequest.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8)); } else { for (NameValuePair nvp : nvps) { multipartEntity.addPart(nvp.getName(), new StringBody(nvp.getValue())); } enclodingRequest.setEntity(multipartEntity); } } catch (UnsupportedEncodingException e) { LOG.severe("Could not find UTF-8 encoding, something is really wrong", e); } } else if (multipartEntity != null) { enclodingRequest.setEntity(multipartEntity); } else if (byteArrayEntity != null) { enclodingRequest.setEntity(byteArrayEntity); } else if (stringEntity != null) { enclodingRequest.setEntity(stringEntity); } else if (inputStreamEntity != null) { enclodingRequest.setEntity(inputStreamEntity); } } return client.execute(this); }
/** Returns an HttpEntity containing all request parameters */ public HttpEntity getEntity() { if (bodyEntity != null) { return bodyEntity; } HttpEntity result = null; if (fileParams != null && !fileParams.isEmpty()) { MultipartEntity multipartEntity = new MultipartEntity(HttpMultipartMode.STRICT, boundary, Charset.forName(charset)); if (bodyParams != null && !bodyParams.isEmpty()) { for (NameValuePair param : bodyParams) { try { multipartEntity.addPart(param.getName(), new StringBody(param.getValue())); } catch (UnsupportedEncodingException e) { LogUtils.e(e.getMessage(), e); } } } for (ConcurrentHashMap.Entry<String, ContentBody> entry : fileParams.entrySet()) { multipartEntity.addPart(entry.getKey(), entry.getValue()); } result = multipartEntity; } else if (bodyParams != null && !bodyParams.isEmpty()) { result = new BodyParamsEntity(bodyParams, charset); } return result; }
/** * Constructs a BannerForm representing the given page on Banner. You must specify whether to * send a POST request or a GET request. If the URL contains a question mark followed by a * series of parameters (such as /somepage?x=y&a=1&foo=bar), this is a GET request. If the page * is accessed by filling out a form and clicking a submit button, and the URL of the result * page does not contain a question mark followed by the parameter list, this is a POST request; * you will need to get the parameter names and values from the HTML source. The parameters are * specified as NameValuePairs, a class provided by Apache for precisely this purpose. * * @param path the path (not including the protocol or domain) of the page on Banner * @param isPOST true if this page expects an HTTP POST request, false if it expects a GET * @param parms an array of parameter names mapped to default values */ public BannerForm(String path, boolean isPOST, NameValuePair... parms) { this.path = path; this.isPOST = isPOST; defaultParms = parms; currentParms = new HashMap<String, String>(); for (NameValuePair parm : parms) currentParms.put(parm.getName(), parm.getValue()); }
public HttpRequest addQueryStringParams(List<NameValuePair> nameValuePairs) { if (nameValuePairs != null) { for (NameValuePair nameValuePair : nameValuePairs) { uriBuilder.addParameter(nameValuePair.getName(), nameValuePair.getValue()); } } return this; }
public RequestParameters(final List<NameValuePair> pairs) { parameters = new LinkedHashMap<String, String>(); final Iterator<NameValuePair> it = pairs.iterator(); while (it.hasNext()) { final NameValuePair pair = it.next(); parameters.put(pair.getName(), pair.getValue()); } }
private String getQueryStringParam(String query, String key) { List<NameValuePair> params = URLEncodedUtils.parse(query, Charset.defaultCharset()); for (NameValuePair pair : params) { if (key.equals(pair.getName())) { return pair.getValue(); } } return null; }
public static List<NameValuePair> removeEntry(List<NameValuePair> params, String key) { List<NameValuePair> newList = new ArrayList<NameValuePair>(); for (NameValuePair nvp : params) { if (!nvp.getName().equals(key)) { newList.add(nvp); } } return newList; }
private List<NameValuePair> stripNulls(NameValuePair... nameValuePairs) { List<NameValuePair> params = new ArrayList<NameValuePair>(); for (int i = 0; i < nameValuePairs.length; i++) { NameValuePair param = nameValuePairs[i]; if (param.getValue() != null) { params.add(param); } } return params; }
public static Map<String, String> convert(List<NameValuePair> nv) { Map<String, String> map = new HashMap<String, String>(); for (NameValuePair nameValue : nv) { map.put(nameValue.getName(), nameValue.getValue()); } return map; }
public static String getString(List<NameValuePair> params, String key) { String retVal = ""; for (NameValuePair nvp : params) { if (nvp.getName().equals(key)) { retVal = nvp.getValue(); break; } } return retVal; }
public void addBodyParameter(List<NameValuePair> nameValuePairs) { if (bodyParams == null) { bodyParams = new LinkedHashMap<String, NameValuePair>(); } if (nameValuePairs != null && nameValuePairs.size() > 0) { for (NameValuePair pair : nameValuePairs) { bodyParams.put(pair.getName(), pair); } } }
private MultipartEntity createMultipartEntity( String filename, File file, List<NameValuePair> postParams) throws UnsupportedEncodingException { MultipartEntity entity = new MultipartEntity(); for (NameValuePair param : postParams) { entity.addPart(param.getName(), new StringBody(param.getValue(), Charset.defaultCharset())); } entity.addPart(filename, new FileBody(file)); return entity; }
public static long getLong(List<NameValuePair> params, String key) { long retVal = 0; for (NameValuePair nvp : params) { if (nvp.getName().equals(key)) { String value = nvp.getValue(); retVal = Long.parseLong(value); break; } } return retVal; }
public static int getInt(List<NameValuePair> params, String key) { int retVal = 0; for (NameValuePair nvp : params) { if (nvp.getName().equals(key)) { String value = nvp.getValue(); retVal = Integer.parseInt(value); break; } } return retVal; }
private static QueryHashMap<String, String> parseEventUrl(String url) throws Exception { QueryHashMap<String, String> values = new QueryHashMap<String, String>(); List<NameValuePair> params = URLEncodedUtils.parse(new URI("http://localhost/" + url), "UTF-8"); for (NameValuePair param : params) { values.put(param.getName(), param.getValue()); } return values; }
@Override protected List<NameValuePair> getProxyParameters(List<NameValuePair> requestParameters) { List<NameValuePair> proxyParameters = new ArrayList<NameValuePair>(); for (NameValuePair requestParameter : requestParameters) { if (!"apiKey".equalsIgnoreCase(requestParameter.getName())) { proxyParameters.add( new BasicNameValuePair(requestParameter.getName(), requestParameter.getValue())); } } proxyParameters.add(new BasicNameValuePair("key", UITBASE_APIKEY)); return proxyParameters; }
private List<NameValuePair> stripNulls(NameValuePair... nameValuePairs) { List<NameValuePair> params = new ArrayList<NameValuePair>(); for (int i = 0; i < nameValuePairs.length; i++) { NameValuePair param = nameValuePairs[i]; if (param.getValue() != null) { if (DEBUG) LOG.log(Level.FINE, "Param: " + param); System.out.println("Param: " + param); params.add(param); } } return params; }
private String joinAttributes(List<NameValuePair> attr) { StringBuilder builder = new StringBuilder(); int i = 1; for (NameValuePair pair : attr) { builder.append(pair.getName()).append(":").append(pair.getValue()); if (i < attr.size()) { builder.append(MiPushClient.ACCEPT_TIME_SEPARATOR); } i++; } return builder.toString(); }
/** {@inheritDoc} */ @Override public int send(List<Argument> arguments) { m_arguments = arguments; String url = getUrl(); if (url == null) { LOG.warn("send: url argument is null, HttpNotification requires a URL"); return 1; } DefaultHttpClient client = new DefaultHttpClient(); HttpUriRequest method = null; List<NameValuePair> posts = getPostArguments(); if (posts == null) { method = new HttpGet(url); LOG.info("send: No \"post-\" arguments..., continuing with an HTTP GET using URL: {}", url); } else { LOG.info( "send: Found \"post-\" arguments..., continuing with an HTTP POST using URL: {}", url); for (final NameValuePair post : posts) { LOG.debug("send: post argument: {} = {}", post.getValue(), post.getName()); } method = new HttpPost(url); try { UrlEncodedFormEntity entity = new UrlEncodedFormEntity(posts, "UTF-8"); ((HttpPost) method).setEntity(entity); } catch (UnsupportedEncodingException e) { // Should never happen } } String contents = null; int statusCode = -1; try { HttpResponse response = client.execute(method); statusCode = response.getStatusLine().getStatusCode(); contents = EntityUtils.toString(response.getEntity()); LOG.info("send: Contents is: {}", contents); } catch (IOException e) { LOG.error("send: IO problem with HTTP post/response: {}", e); throw new RuntimeException("Problem with HTTP post: " + e.getMessage()); } finally { // Do we need to do any cleanup? // method.releaseConnection(); } doSql(contents); return statusCode; }
@Override protected PocketAuthInfo buildInfo(final Response r) throws AccessTokenException { if (r.getStatus() >= 400) { throw new AccessTokenException(r.asJson().asText()); } else { final List<NameValuePair> list = URLEncodedUtils.parse(r.getBody(), Charset.forName("UTF-8")); final Map<String, String> map = new HashMap<String, String>(list.size()); for (final NameValuePair nameValuePair : list) { map.put(nameValuePair.getName(), nameValuePair.getValue()); } return new PocketAuthInfo(map); } }