Example usage for com.google.gwt.http.client RequestBuilder setRequestData

List of usage examples for com.google.gwt.http.client RequestBuilder setRequestData

  1. HOME
  2. Java
  3. com.google.gwt
  4. com.google.gwt.http.client.*
  5. RequestBuilder
  6. setRequestData

Introduction

In this page you can find the example usage for com.google.gwt.http.client RequestBuilder setRequestData.

Prototype

public void setRequestData(String requestData)

Source Link

Document

Sets the data to send as part of this request.

Usage

From source file:com.gwtplatform.dispatch.client.rest.RestRequestBuilderFactory.java

License:Apache License

public <A extends RestAction<?>> RequestBuilder build(A action, String securityToken) throws ActionException {
    RequestBuilder.Method httpMethod = HTTP_METHODS.get(action.getHttpMethod());
    String url = buildUrl(action);

    RequestBuilder requestBuilder = new RequestBuilder(httpMethod, url);

    for (RestParameter param : action.getHeaderParams()) {
        requestBuilder.setHeader(param.getName(), encode(param));
    }/*from  w  w w .  j a  v a2  s  .  c  o  m*/

    requestBuilder.setHeader(CONTENT_TYPE, JSON_UTF8);
    requestBuilder.setHeader(MODULE_BASE_HEADER, baseUrl);

    if (action.hasFormParams()) {
        requestBuilder.setRequestData(buildQueryString(action.getFormParams()));
    } else if (action.hasBodyParam()) {
        requestBuilder.setRequestData(getSerializedValue(action, action.getBodyParam()));
    }

    if (securityToken != null && securityToken.length() > 0) {
        requestBuilder.setHeader(securityHeaderName, securityToken);
    }

    return requestBuilder;
}

From source file:com.gwtplatform.dispatch.rest.client.core.DefaultBodyFactory.java

License:Apache License

private void assignBodyFromForm(RequestBuilder requestBuilder, RestAction<?> action) {
    String queryString = uriFactory.buildQueryString(action, Type.FORM);

    requestBuilder.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_FORM_URLENCODED);
    requestBuilder.setRequestData(queryString);
}

From source file:com.gwtplatform.dispatch.rest.client.core.DefaultBodyFactory.java

License:Apache License

private void assignBodyFromSerialization(RequestBuilder requestBuilder, RestAction<?> action)
        throws ActionException {
    String data;/*from ww w  . j a va  2  s.com*/
    if (action.hasBodyParam()) {
        SerializedValue serializedValue = getSerializedValue(action, action.getBodyParam());
        ContentType contentType = serializedValue.getContentType();
        data = serializedValue.getData();

        requestBuilder.setHeader(HttpHeaders.CONTENT_TYPE, contentType.toString());
    } else {
        // Fixes an issue for all IE versions (IE 11 is the latest at this time). If request data is not
        // explicitly set to 'null', the JS 'undefined' will be sent as the request body on IE. Other
        // browsers don't send undefined bodies.
        data = null;
    }

    requestBuilder.setRequestData(data);
}

From source file:com.gwtplatform.dispatch.rest.client.DefaultRestRequestBuilderFactory.java

License:Apache License

private <A extends RestAction<?>> void buildBody(RequestBuilder requestBuilder, A action)
        throws ActionException {
    if (action.hasFormParams()) {
        requestBuilder.setRequestData(buildQueryString(action.getParameters(Type.FORM)));
    } else if (action.hasBodyParam()) {
        requestBuilder.setRequestData(getSerializedValue(action, action.getBodyParam()));
    } else {/*from  w w w. ja  v  a  2s.c  om*/
        // Fixes an issue for all IE versions (IE 11 is the latest at this time). If request data is not explicitly
        // set to 'null', the JS 'undefined' will be sent as the request body on IE. Other browsers don't send
        // undefined bodies.
        requestBuilder.setRequestData(null);
    }
}

From source file:com.smartgwt.mobile.client.data.DataSource.java

License:Open Source License

@SGWTInternal
protected void _sendGWTRequest(DSRequest dsRequest) {
    final int transactionNum = com.smartgwt.mobile.client.rpc.RPCManager._getNextTransactionNum();
    dsRequest._setTransactionNum(transactionNum);
    // For the time being, the request ID and transactionNum are the same.
    dsRequest.setRequestId(Integer.toString(transactionNum));

    final boolean strictJSON = Canvas._booleanValue(getStrictJSON(), false);
    final DSOperationType opType = dsRequest.getOperationType();
    final OperationBinding opBinding = getOperationBinding(dsRequest);

    final DSDataFormat dataFormat;
    if (opBinding == null)
        dataFormat = DSDataFormat.JSON;/*w w w. ja  v  a 2  s .  c om*/
    else if (opBinding.getDataFormat() != null)
        dataFormat = opBinding.getDataFormat();
    else
        dataFormat = DSDataFormat.JSON;
    assert dataFormat != null;

    DSProtocol protocol;
    if (opBinding != null && opBinding.getDataProtocol() != null) {
        protocol = opBinding.getDataProtocol();
    } else {
        protocol = getDataProtocol();
        if (protocol == null) {
            protocol = (opType == null || opType == DSOperationType.FETCH) ? null : DSProtocol.POSTMESSAGE;
        }
    }

    final Object originalData = dsRequest.getData();
    Object transformedData;
    switch (protocol == null ? DSProtocol.GETPARAMS : protocol) {
    case GETPARAMS:
    case POSTPARAMS:
        transformedData = transformRequest(dsRequest);
        if (transformedData == null)
            transformedData = Collections.EMPTY_MAP;
        else if (!(transformedData instanceof Map)) {
            // TODO Issue a warning.
            transformedData = Collections.EMPTY_MAP;
        }
        break;
    case POSTMESSAGE:
        transformedData = transformRequest(dsRequest);
        if (!(transformedData instanceof String)) {
            if (dataFormat != DSDataFormat.JSON) {
                throw new UnsupportedOperationException(
                        "Only serialization of DSRequests in JSON format is supported.");
            }
            transformedData = dsRequest._serialize(strictJSON);
            if (dsRequest.getContentType() == null) {
                // For best interoperability with ASP.NET AJAX services, send Content-Type:application/json.
                // http://weblogs.asp.net/scottgu/archive/2007/04/04/json-hijacking-and-how-asp-net-ajax-1-0-mitigates-these-attacks.aspx
                dsRequest.setContentType("application/json;charset=UTF-8");
            }
        }
        break;
    default:
        assert protocol != null;
        throw new UnsupportedOperationException(
                "In transforming the DSRequest, failed to handle case:  protocol:" + protocol.getValue());
    }
    if (transformedData != dsRequest) {
        dsRequest.setData(transformedData);
    }
    dsRequest.setOriginalData(originalData);
    if (dsRequest.getDataSource() == null)
        dsRequest.setDataSource(getID());
    final DSRequest finalDSRequest = dsRequest;
    assert finalDSRequest.getOperationType() == opType;

    if (protocol == null) {
        assert opType == DSOperationType.FETCH;
        if (transformedData == null
                || (transformedData instanceof Map && ((Map<?, ?>) transformedData).isEmpty())) {
            protocol = DSProtocol.GETPARAMS;
        } else {
            protocol = DSProtocol.POSTMESSAGE;
            transformedData = dsRequest._serialize(strictJSON);
            if (dsRequest.getContentType() == null) {
                dsRequest.setContentType("application/json;charset=UTF-8");
            }
        }
    }

    URIBuilder workBuilder;

    {
        String work = finalDSRequest.getDataURL();

        if (work == null) {
            if (opType != null) {
                switch (opType) {
                case FETCH:
                    work = getFetchDataURL();
                    break;
                case ADD:
                    work = getAddDataURL();
                    break;
                case UPDATE:
                    work = getUpdateDataURL();
                    break;
                case REMOVE:
                    work = getRemoveDataURL();
                    break;
                case VALIDATE:
                    work = getValidateDataURL();
                    break;
                case CUSTOM:
                    work = getCustomDataURL();
                    break;
                }
            }

            // common url
            if (work == null) {
                work = getDataURL();

                // construct default url
                if (work == null) {
                    work = RPCManager.getActionURL();
                    if (work.endsWith("/")) {
                        work = work.substring(0, work.length() - 1);
                    }
                }
            }
        }

        workBuilder = new URIBuilder(work);
    }

    // build up the query string
    final DateTimeFormat datetimeFormat = finalDSRequest._getDatetimeFormat();

    {
        Map<String, Object> params = finalDSRequest.getParams();

        if (protocol == DSProtocol.GETPARAMS || protocol == DSProtocol.POSTPARAMS) {
            if (params == null)
                params = new LinkedHashMap<String, Object>();

            if (protocol == DSProtocol.GETPARAMS) {
                assert transformedData instanceof Map;
                @SuppressWarnings("unchecked")
                final Map<String, Object> m = (Map<String, Object>) transformedData;
                params.putAll(m);
            }

            if (getSendMetaData()) {
                String metaDataPrefix = getMetaDataPrefix();
                if (metaDataPrefix == null)
                    metaDataPrefix = "_";

                params.put(metaDataPrefix + "operationType", opType);
                params.put(metaDataPrefix + "operationId", finalDSRequest.getOperationId());
                params.put(metaDataPrefix + "startRow", finalDSRequest.getStartRow());
                params.put(metaDataPrefix + "endRow", finalDSRequest.getEndRow());
                params.put(metaDataPrefix + "sortBy", finalDSRequest._getSortByString());
                params.put(metaDataPrefix + "useStrictJSON", Boolean.TRUE);
                params.put(metaDataPrefix + "textMatchStyle", finalDSRequest.getTextMatchStyle());
                params.put(metaDataPrefix + "oldValues", finalDSRequest.getOldValues());
                params.put(metaDataPrefix + "componentId", finalDSRequest.getComponentId());

                params.put(metaDataPrefix + "dataSource", dsRequest.getDataSource());
                params.put("isc_metaDataPrefix", metaDataPrefix);
            }

            params.put("isc_dataFormat", dataFormat.getValue());
        }

        if (params != null) {
            for (final Map.Entry<String, Object> e : params.entrySet()) {
                workBuilder.setQueryParam(e.getKey(), e.getValue(), strictJSON, false, datetimeFormat);
            }
        }
    }

    // automatically add the data format even to user-provided dataURLs unless they contain the param already
    if (!workBuilder.containsQueryParam("isc_dataFormat")) {
        workBuilder.appendQueryParam("isc_dataFormat", dataFormat.getValue());
    }

    if (protocol == DSProtocol.POSTPARAMS) {
        assert transformedData instanceof Map;
        @SuppressWarnings("unchecked")
        final Map<String, Object> m = (Map<String, Object>) transformedData;

        String requestContentType = finalDSRequest.getContentType();
        if (requestContentType != null)
            requestContentType = requestContentType.trim();

        if (requestContentType == null || requestContentType.startsWith("application/x-www-form-urlencoded")) {
            URIBuilder postBodyBuilder = new URIBuilder("");
            for (final Map.Entry<String, Object> e : m.entrySet()) {
                postBodyBuilder.setQueryParam(e.getKey(), e.getValue(), strictJSON, false, datetimeFormat);
            }
            // Exclude the '?'.
            transformedData = postBodyBuilder.toString().substring(1);
        } //else if (requestContentType.startsWith("multipart/form-data")) {} // TODO
        else {
            throw new IllegalArgumentException(
                    "Request content type '" + requestContentType + "' is not supported.");
        }
    }

    RequestBuilder.Method httpMethod = getHttpMethod(finalDSRequest.getHttpMethod());
    if (httpMethod == null) {
        if (protocol == DSProtocol.GETPARAMS)
            httpMethod = RequestBuilder.GET;
        else if (protocol == DSProtocol.POSTPARAMS || protocol == DSProtocol.POSTMESSAGE) {
            httpMethod = RequestBuilder.POST;
        } else {
            if (opType == null || opType == DSOperationType.FETCH) {
                httpMethod = RequestBuilder.GET;
            } else {
                httpMethod = RequestBuilder.POST;
            }
        }
    } else if (httpMethod == RequestBuilder.GET) {
        if (protocol == DSProtocol.POSTPARAMS ||
        //protocol == DSProtocol.POSTXML
                protocol == DSProtocol.POSTMESSAGE) {
            // TODO Warn that GET requests do not support bodies.
            httpMethod = RequestBuilder.POST;
        }
    }

    String requestContentType = finalDSRequest.getContentType();
    if (requestContentType != null) {
        if (httpMethod == RequestBuilder.GET) {
            // TODO Warn that GET requests do not support bodies.
            requestContentType = null;
        }
    } else {
        if (protocol == DSProtocol.POSTPARAMS)
            requestContentType = "application/x-www-form-urlencoded";
        //else if (protocol == DSProtocol.POSTXML) requestContentType = "text/xml";
    }

    final RequestBuilder rb = new RequestBuilder(httpMethod, workBuilder.toString());
    final Integer timeoutMillis = finalDSRequest.getTimeout();
    rb.setTimeoutMillis(timeoutMillis == null ? RPCManager._getDefaultTimeoutMillis()
            : Math.max(1, timeoutMillis.intValue()));

    final String authorization = finalDSRequest.getAuthorization();
    if (authorization != null)
        rb.setHeader("Authorization", authorization);

    final Map<String, String> httpHeaders = finalDSRequest.getHttpHeaders();
    if (httpHeaders != null) {
        for (Map.Entry<String, String> entry : httpHeaders.entrySet()) {
            rb.setHeader(entry.getKey(), entry.getValue());
        }
    }

    if (dataFormat == DSDataFormat.XML) {
        rb.setHeader("Accept", "application/xml,text/xml,*/*");
    } else if (dataFormat == DSDataFormat.JSON) {
        rb.setHeader("Accept", "application/json,*/*");
    }

    if (requestContentType != null) {
        rb.setHeader("Content-Type", requestContentType);
    }

    if (httpMethod != RequestBuilder.GET) {
        switch (protocol) {
        case POSTPARAMS: // `transformedData` has already been created and is now a String.
        case POSTMESSAGE:
            rb.setRequestData((String) transformedData);
            break;
        case GETPARAMS:
            // Already handled earlier when the query params were appended to `workBuilder'.
            break;
        default:
            throw new UnsupportedOperationException(
                    "In setting the request data, failed to handle case protocol:" + protocol);
        }
    }

    rb.setCallback(new RequestCallback() {
        @Override
        public void onError(Request request, Throwable exception) {
            final DSResponse dsResponse = new DSResponse(finalDSRequest);
            final int status;
            if (exception instanceof RequestTimeoutException)
                status = RPCResponse.STATUS_SERVER_TIMEOUT;
            else
                status = RPCResponse.STATUS_FAILURE;
            dsResponse.setStatus(status);
            onError(dsResponse);
        }

        private void onError(DSResponse dsResponse) {
            final DSRequest dsRequest = finalDSRequest;
            final boolean errorEventCancelled = ErrorEvent._fire(DataSource.this, dsRequest, dsResponse);
            if (!errorEventCancelled)
                RPCManager._handleError(dsResponse, dsRequest);
        }

        @Override
        public void onResponseReceived(Request request, Response response) {
            assert response != null;

            String responseText = response.getText();
            if (responseText == null)
                responseText = "";
            assert responseText != null;

            int httpResponseCode = response.getStatusCode();

            final HTTPHeadersMap responseHTTPHeaders = new HTTPHeadersMap();
            for (final Header h : response.getHeaders()) {
                if (h != null) {
                    responseHTTPHeaders.put(h.getName(), h.getValue());
                }
            }

            int status = 0;
            if (0 == httpResponseCode || // file:// requests (e.g. if Showcase is packaged with PhoneGap.)
            (200 <= httpResponseCode && httpResponseCode < 300) || httpResponseCode == 304) // 304 Not Modified
            {
                status = RPCResponse.STATUS_SUCCESS;
            } else {
                status = RPCResponse.STATUS_FAILURE;
                final DSResponse errorResponse = new DSResponse(finalDSRequest);
                errorResponse.setStatus(RPCResponse.STATUS_FAILURE);
                errorResponse.setHttpResponseCode(httpResponseCode);
                errorResponse._setHttpHeaders(responseHTTPHeaders);
                onError(errorResponse);
                return;
            }

            Object rawResponse;
            final DSResponse dsResponse;

            String origResponseContentType = responseHTTPHeaders.get("Content-Type");
            if (origResponseContentType == null
                    || (origResponseContentType = origResponseContentType.trim()).length() == 0) {
                origResponseContentType = "application/octet-stream";
            }

            String responseContentType = origResponseContentType;
            // remove the media type parameter if present
            // http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7
            final int semicolonPos = responseContentType.indexOf(';');
            if (semicolonPos != -1) {
                responseContentType = responseContentType.substring(0, semicolonPos).trim();
                if (responseContentType.length() == 0)
                    responseContentType = "application/octet-stream";
            }

            if (dataFormat == DSDataFormat.CUSTOM) {
                rawResponse = responseText;

                dsResponse = new DSResponse(finalDSRequest, status);
                dsResponse.setHttpResponseCode(httpResponseCode);
                dsResponse._setHttpHeaders(responseHTTPHeaders);
                dsResponse.setContentType(origResponseContentType);

                transformResponse(dsResponse, finalDSRequest, responseText);
            } else {
                if (dataFormat == DSDataFormat.XML) {
                    final Element rootEl;
                    if (responseText.isEmpty()) {
                        rawResponse = rootEl = null;
                        dsResponse = new DSResponse(finalDSRequest, status);
                    } else {
                        final Document document;
                        try {
                            document = XMLParser.parse(responseText);
                        } catch (DOMParseException ex) {
                            onError(request, ex);
                            return;
                        }

                        rootEl = document.getDocumentElement();
                        rawResponse = rootEl;

                        dsResponse = new DSResponse(finalDSRequest, status, rootEl);

                        String dataTagName, recordName;
                        if (opBinding == null) {
                            dataTagName = _getDataTagName();
                            recordName = null;
                        } else {
                            dataTagName = opBinding._getDataTagName(_getDataTagName());
                            recordName = opBinding.getRecordName();
                        }
                        if (recordName == null)
                            recordName = _getRecordName();

                        final Element dataEl = extractDataElement(rootEl, dataTagName);
                        final List<Element> recordNodes = extractRecordElements(dataEl, recordName);

                        if (recordNodes != null && !recordNodes.isEmpty()) {
                            final RecordList records = extractRecordList(recordNodes);
                            dsResponse.setData(records);
                        } else if (rootEl.equals(dataEl)) {
                            dsResponse._setData(XMLUtil.getTextContent(dataEl));
                        }
                    }
                    dsResponse.setHttpResponseCode(httpResponseCode);
                    dsResponse._setHttpHeaders(responseHTTPHeaders);

                    transformResponse(dsResponse, finalDSRequest, rootEl);
                } else {
                    String jsonPrefix = getJsonPrefix();
                    if (jsonPrefix == null)
                        jsonPrefix = "";
                    String jsonSuffix = getJsonSuffix();
                    if (jsonSuffix == null)
                        jsonSuffix = "";

                    // auto-detect default wrapper text returned by RestHandler
                    if (responseText.startsWith(jsonPrefix) && responseText.endsWith(jsonSuffix)) {
                        responseText = responseText.substring(jsonPrefix.length(),
                                responseText.length() - jsonSuffix.length());
                        responseContentType = "application/json";
                    }

                    if (dataFormat == DSDataFormat.JSON) {
                        if (responseText.isEmpty()) {
                            rawResponse = null;
                            dsResponse = new DSResponse(finalDSRequest, status);
                        } else {
                            JSONObject responseObj;
                            try {
                                responseObj = JSONParser.parseLenient(responseText).isObject();
                            } catch (JSONException ex) {
                                onError(request, ex);
                                return;
                            }
                            if (responseObj != null && responseObj.containsKey("response")) {
                                JSONValue val = responseObj.get("response");
                                responseObj = (val == null ? null : val.isObject());
                            }
                            rawResponse = responseObj;

                            dsResponse = new DSResponse(finalDSRequest, status, responseObj);

                            if (responseObj != null && responseObj.containsKey("data")) {
                                final JSONValue dataVal = responseObj.get("data");
                                assert dataVal != null;

                                final JSONString dataStr = dataVal.isString();
                                if (dataStr != null) {
                                    dsResponse._setData(dataStr.stringValue());
                                } else {
                                    JSONArray dataArr = dataVal.isArray();
                                    if (dataArr == null) {
                                        JSONObject datumObj = dataVal.isObject();
                                        if (datumObj != null) {
                                            dataArr = new JSONArray();
                                            dataArr.set(0, datumObj);
                                        }
                                    }
                                    if (dataArr != null) {
                                        final RecordList records = extractRecordList(dataArr);
                                        dsResponse.setData(records);
                                    }
                                }
                            }
                        }
                        dsResponse.setHttpResponseCode(httpResponseCode);
                        dsResponse._setHttpHeaders(responseHTTPHeaders);

                        transformResponse(dsResponse, finalDSRequest, rawResponse);
                    } else {
                        throw new UnsupportedOperationException("Unhandled dataFormat:" + dataFormat);
                    }
                }
            }

            if (dsResponse.getInvalidateCache()) {
                //invalidateDataSourceDataChangedHandlers(finalDSRequest, dsResponse);
            }

            status = dsResponse.getStatus();
            if (status >= 0) {
                DSDataChangedEvent.fire(DataSource.this, dsResponse, finalDSRequest);
            } else {
                // Unless it was a validation error, or the request specified willHandleError,
                // go through centralized error handling (if alerting the failure string
                // can be dignified with such a name!)
                if (status != -4 && !finalDSRequest._getWillHandleError()) {
                    onError(dsResponse);
                    return;
                }
            }

            // fireResponseCallbacks
            final DSCallback callback = finalDSRequest.getCallback(),
                    afterFlowCallback = finalDSRequest._getAfterFlowCallback();
            if (callback != null) {
                callback.execute(dsResponse, rawResponse, finalDSRequest);
            }
            if (afterFlowCallback != null && afterFlowCallback != callback) {
                afterFlowCallback.execute(dsResponse, rawResponse, finalDSRequest);
            }
        }
    });

    try {
        rb.send();
    } catch (RequestException re) {
        re.printStackTrace();
    }
    ++_numDSRequestsSent;
}

From source file:com.smartgwt.mobile.client.data.DataSource.java

License:Open Source License

private static void loadDataSource(String ID, LoadDSCallback callback, boolean loadParents) {
    String work = dsLoaderUrl;// w  w  w . j  a v a 2 s.  c o  m
    if (work.endsWith("/")) {
        work = work.substring(0, work.length() - 1);
    }
    work += "?dataSource=" + ID;
    if (loadParents) {
        work += "&loadParents=true";
    }
    RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, work);
    rb.setRequestData("");

    final LoadDSCallback finalCallback = callback;

    rb.setCallback(new RequestCallback() {

        public void onResponseReceived(Request request, Response response) {
            String creationText = null;

            if (response != null) {
                creationText = response.getText();
            }
            if (creationText == null || creationText.trim().length() == 0) {
                //Log.error("ERROR!  Null or empty response in DataSource loadDataSource");
                if (finalCallback != null)
                    finalCallback.execute(null);
                return;
            }

            assert response != null;
            int status = response.getStatusCode();
            if (status < 200 || status > 299) {
                //Log.error("DataSource loadDataSource returned HTTP status " + status);
                if (finalCallback != null)
                    finalCallback.execute(null);
                return;
            }

            ArrayList<DataSource> dataSources = createDataSourcesFromJSON(creationText, false);
            if (finalCallback != null) {
                DataSource[] dsList = dataSources.toArray(new DataSource[dataSources.size()]);
                finalCallback.execute(dsList);
            }
        }

        public void onError(Request request, Throwable exception) {
            //Log.error("loadDataSource error: ", exception);
            if (finalCallback != null)
                finalCallback.execute(null);
        }
    });

    try {
        rb.send();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

From source file:com.tdm.client.dispatch.AbstractRequestBuilderClientActionHandler.java

License:Apache License

protected RequestBuilder prepareRequestBuilder(Method method, String[] restResourcePath,
        Map<String, String> queryParams, JSONObject jsonObject) {

    UrlBuilder urlBuilder = new UrlBuilder().setModule("api").setVersion("v1");
    for (String path : restResourcePath) {
        urlBuilder.addResourcePath(path);
    }//from  w w w . j  a v a 2s.  c  o  m
    if (queryParams != null) {
        for (Entry<String, String> entry : queryParams.entrySet()) {
            urlBuilder.addQueryParameter(entry.getKey(), entry.getValue());
        }
    }
    RequestBuilder rb = new RequestBuilder(method, urlBuilder.toUrl());
    if (jsonObject != null) {
        jsonObject.put("$H", null);
        String string = jsonObject.toString();
        rb.setRequestData(string);
    }
    return rb;
}

From source file:com.totsp.gwittir.rest.client.transports.ProxyTransport.java

License:Open Source License

@Override
public RequestControl post(String mimeType, String url, String payload, final AsyncCallback callback) {
    RequestBuilder b = new RequestBuilder(RequestBuilder.POST, this.originProxyPath);
    b.setHeader(ACCEPT_HEADER, mimeType);
    b.setHeader(X_PROXY_LOCATION_HEADER, url);
    b.setHeader(CONTENT_TYPE_HEADER, mimeType);
    b.setRequestData(payload);
    return super.doRequest(b, new GenericRequestCallback(HTTPTransport.POST_RESPONSE_CODES, false, callback));
}

From source file:com.totsp.gwittir.rest.client.transports.ProxyTransport.java

License:Open Source License

@Override
public RequestControl put(String mimeType, String url, String payload, final AsyncCallback<String> callback) {
    RequestBuilder b = new RequestBuilder(RequestBuilder.POST, this.originProxyPath);
    b.setHeader(X_PROXY_LOCATION_HEADER, url);
    b.setHeader(X_REST_METHOD_HEADER, "PUT");
    b.setHeader(ACCEPT_HEADER, mimeType);
    b.setRequestData(payload);
    return super.doRequest(b, new GenericRequestCallback(HTTPTransport.PUT_RESPONSE_CODES, false, callback));
}

From source file:com.totsp.gwittir.rest.client.transports.XHRTransport.java

License:Open Source License

public RequestControl post(String mimeType, String url, String payload, final AsyncCallback<String> callback) {
    RequestBuilder b = new RequestBuilder(RequestBuilder.POST, url);
    b.setHeader(ACCEPT_HEADER, mimeType);
    b.setHeader(CONTENT_TYPE_HEADER, mimeType);
    b.setRequestData(payload);
    return super.doRequest(b, new GenericRequestCallback(HTTPTransport.POST_RESPONSE_CODES, false, callback));
}