Examples with MultipartEntity org.apache.http.entity.mime.MultipartEntity used on opensource projects

Example 11 with MultipartEntity

use of org.apache.http.entity.mime.MultipartEntity in project tmdm-studio-se by Talend.

the class HttpClientUtil method createUploadFileToServerRequest.

private static HttpUriRequest createUploadFileToServerRequest(String URL, String userName, final String fileName) {
    HttpPost request = new HttpPost(URL);
    String path = fileName;
    if (URL.indexOf("deletefile") == -1) {
        // $NON-NLS-1$
        if (URL.indexOf("deployjob") != -1) {
            // $NON-NLS-1$
            // $NON-NLS-1$
            path = URL.substring(URL.indexOf("=") + 1);
        }
        MultipartEntity entity = new MultipartEntity();
        entity.addPart(path, new FileBody(new File(fileName)));
        request.setEntity(entity);
    }
    addStudioToken(request, userName);
    return request;
}

Example 12 with MultipartEntity

use of org.apache.http.entity.mime.MultipartEntity in project liferay-ide by liferay.

the class ServerManagerConnection method updateApplication.

public Object updateApplication(String appName, String absolutePath, IProgressMonitor monitor) throws APIException {
    try {
        final File file = new File(absolutePath);
        final FileBody fileBody = new FileBody(file);
        final MultipartEntity entity = new MultipartEntity();
        entity.addPart(file.getName(), fileBody);
        final HttpPut httpPut = new HttpPut();
        httpPut.setEntity(entity);
        Object response = httpJSONAPI(httpPut, getUpdateURI(appName));
        if (response instanceof JSONObject) {
            JSONObject json = (JSONObject) response;
            if (isSuccess(json)) {
                // $NON-NLS-1$
                System.out.println("updateApplication: success.\n\n");
            } else {
                if (isError(json)) {
                    // $NON-NLS-1$
                    return json.getString("error");
                } else {
                    // $NON-NLS-1$
                    return "updateApplication error " + getDeployURI(appName);
                }
            }
        }
        httpPut.releaseConnection();
    } catch (Exception e) {
        e.printStackTrace();
        return e.getMessage();
    }
    return null;
}

Example 13 with MultipartEntity

use of org.apache.http.entity.mime.MultipartEntity in project opencast by opencast.

the class WorkingFileRepositoryRemoteImpl method putInCollection.

/**
 * {@inheritDoc}
 *
 * @see org.opencastproject.workingfilerepository.api.WorkingFileRepository#putInCollection(java.lang.String,
 *      java.lang.String, java.io.InputStream)
 */
@Override
public URI putInCollection(String collectionId, String fileName, InputStream in) {
    String url = UrlSupport.concat(new String[] { COLLECTION_PATH_PREFIX, collectionId });
    HttpPost post = new HttpPost(url);
    MultipartEntity entity = new MultipartEntity();
    ContentBody body = new InputStreamBody(in, fileName);
    entity.addPart("file", body);
    post.setEntity(entity);
    HttpResponse response = getResponse(post);
    try {
        if (response != null) {
            String content = EntityUtils.toString(response.getEntity());
            return new URI(content);
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    } finally {
        closeConnection(response);
    }
    throw new RuntimeException("Unable to put file in collection");
}

Example 14 with MultipartEntity

use of org.apache.http.entity.mime.MultipartEntity in project opencast by opencast.

the class WorkingFileRepositoryRemoteImpl method put.

/**
 * {@inheritDoc}
 *
 * @see org.opencastproject.workingfilerepository.api.WorkingFileRepository#put(java.lang.String, java.lang.String,
 *      java.lang.String, java.io.InputStream)
 */
@Override
public URI put(String mediaPackageID, String mediaPackageElementID, String filename, InputStream in) {
    String url = UrlSupport.concat(new String[] { MEDIAPACKAGE_PATH_PREFIX, mediaPackageID, mediaPackageElementID });
    HttpPost post = new HttpPost(url);
    MultipartEntity entity = new MultipartEntity();
    ContentBody body = new InputStreamBody(in, filename);
    entity.addPart("file", body);
    post.setEntity(entity);
    HttpResponse response = getResponse(post);
    try {
        if (response != null) {
            String content = EntityUtils.toString(response.getEntity());
            return new URI(content);
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    } finally {
        closeConnection(response);
    }
    throw new RuntimeException("Unable to put file");
}

Example 15 with MultipartEntity

use of org.apache.http.entity.mime.MultipartEntity in project iNaturalistAndroid by inaturalist.

the class INaturalistService method request.

private JSONArray request(String url, String method, ArrayList<NameValuePair> params, JSONObject jsonContent, boolean authenticated, boolean useJWTToken, boolean allowAnonymousJWTToken) throws AuthenticationException {
    DefaultHttpClient client = new DefaultHttpClient();
    // Handle redirects (301/302) for all HTTP methods (including POST)
    client.setRedirectHandler(new DefaultRedirectHandler() {

        @Override
        public boolean isRedirectRequested(HttpResponse response, HttpContext context) {
            boolean isRedirect = super.isRedirectRequested(response, context);
            if (!isRedirect) {
                int responseCode = response.getStatusLine().getStatusCode();
                if (responseCode == 301 || responseCode == 302) {
                    return true;
                }
            }
            return isRedirect;
        }
    });
    client.getParams().setParameter(CoreProtocolPNames.USER_AGENT, getUserAgent(mApp));
    // Log.d(TAG, String.format("%s (%b - %s): %s", method, authenticated,
    // authenticated ? mCredentials : "<null>",
    // url));
    HttpRequestBase request;
    Log.d(TAG, String.format("URL: %s - %s (%s)", method, url, (params != null ? params.toString() : "null")));
    if (method.equalsIgnoreCase("post")) {
        request = new HttpPost(url);
    } else if (method.equalsIgnoreCase("delete")) {
        request = new HttpDelete(url);
    } else if (method.equalsIgnoreCase("put")) {
        request = new HttpPut(url);
    } else {
        request = new HttpGet(url);
    }
    // POST params
    if (jsonContent != null) {
        // JSON body content
        request.setHeader("Content-type", "application/json");
        StringEntity entity = null;
        try {
            entity = new StringEntity(jsonContent.toString(), HTTP.UTF_8);
        } catch (UnsupportedEncodingException exc) {
            exc.printStackTrace();
        }
        if (method.equalsIgnoreCase("put")) {
            ((HttpPut) request).setEntity(entity);
        } else {
            ((HttpPost) request).setEntity(entity);
        }
    } else if (params != null) {
        // "Standard" multipart encoding
        Charset utf8Charset = Charset.forName("UTF-8");
        MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
        for (int i = 0; i < params.size(); i++) {
            if (params.get(i).getName().equalsIgnoreCase("image") || params.get(i).getName().equalsIgnoreCase("file") || params.get(i).getName().equalsIgnoreCase("user[icon]")) {
                // If the key equals to "image", we use FileBody to transfer the data
                String value = params.get(i).getValue();
                if (value != null)
                    entity.addPart(params.get(i).getName(), new FileBody(new File(value)));
            } else {
                // Normal string data
                try {
                    entity.addPart(params.get(i).getName(), new StringBody(params.get(i).getValue(), utf8Charset));
                } catch (UnsupportedEncodingException e) {
                    Log.e(TAG, "failed to add " + params.get(i).getName() + " to entity for a " + method + " request: " + e);
                }
            }
        }
        if (method.equalsIgnoreCase("put")) {
            ((HttpPut) request).setEntity(entity);
        } else {
            ((HttpPost) request).setEntity(entity);
        }
    }
    if (url.startsWith(API_HOST) && (mCredentials != null)) {
        // For the node API, if we're logged in, *always* use JWT authentication
        authenticated = true;
        useJWTToken = true;
    }
    if (authenticated) {
        if (useJWTToken && allowAnonymousJWTToken && (mCredentials == null)) {
            // User not logged in, but allow using anonymous JWT
            request.setHeader("Authorization", getAnonymousJWTToken());
        } else {
            ensureCredentials();
            if (useJWTToken) {
                // Use JSON Web Token for this request
                request.setHeader("Authorization", getJWTToken());
            } else if (mLoginType == LoginType.PASSWORD) {
                // Old-style password authentication
                request.setHeader("Authorization", "Basic " + mCredentials);
            } else {
                // OAuth2 token (Facebook/G+/etc)
                request.setHeader("Authorization", "Bearer " + mCredentials);
            }
        }
    }
    try {
        mResponseErrors = null;
        HttpResponse response = client.execute(request);
        HttpEntity entity = response.getEntity();
        String content = entity != null ? EntityUtils.toString(entity) : null;
        Log.d(TAG, String.format("RESP: %s", content));
        JSONArray json = null;
        mLastStatusCode = response.getStatusLine().getStatusCode();
        switch(response.getStatusLine().getStatusCode()) {
            // switch (response.getStatusCode()) {
            case HttpStatus.SC_UNPROCESSABLE_ENTITY:
                // Validation error - still need to return response
                Log.e(TAG, response.getStatusLine().toString());
            case HttpStatus.SC_OK:
                try {
                    json = new JSONArray(content);
                } catch (JSONException e) {
                    Log.d(TAG, "Failed to create JSONArray, JSONException: " + e.toString());
                    try {
                        JSONObject jo = new JSONObject(content);
                        json = new JSONArray();
                        json.put(jo);
                    } catch (JSONException e2) {
                        Log.d(TAG, "Failed to create JSONObject, JSONException: " + e2.toString());
                    }
                }
                mResponseHeaders = response.getAllHeaders();
                try {
                    if ((json != null) && (json.length() > 0)) {
                        JSONObject result = json.getJSONObject(0);
                        if (result.has("errors")) {
                            // Error response
                            Log.e(TAG, "Got an error response: " + result.get("errors").toString());
                            mResponseErrors = result.getJSONArray("errors");
                            return null;
                        }
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }
                if ((content != null) && (content.length() == 0)) {
                    // In case it's just non content (but OK HTTP status code) - so there's no error
                    json = new JSONArray();
                }
                return json;
            case HttpStatus.SC_UNAUTHORIZED:
                throw new AuthenticationException();
            case HttpStatus.SC_GONE:
                Log.e(TAG, "GONE: " + response.getStatusLine().toString());
            // or post them as new observations
            default:
                Log.e(TAG, response.getStatusLine().toString());
        }
    } catch (IOException e) {
        // request.abort();
        Log.w(TAG, "Error for URL " + url, e);
    }
    return null;
}