com.google.gwt.http.client.RequestBuilder Java Examples

@Override
protected RequestBuilder doCreate(String serviceEntryPoint) {
	int timeout = DEFAULT_TIMEOUT;
	if (Session.get().getConfig("gui.rpc.timeout") != null)
		timeout = Integer.parseInt(Session.get().getConfig("gui.rpc.timeout"));
	RequestBuilder builder = new RequestBuilder(RequestBuilder.POST, serviceEntryPoint);
	builder.setTimeoutMillis(timeout * 60 * 1000);
	return builder;
}
 

@Override
public PuzzleServiceProxy get() {
    return new RetryLocalStorageServiceProxy(service,  new CallStrategy(){

    @Override
    public Request makeRequest(RequestBuilder builder) {
         ShortyzGadget.makePostRequest(builder.getUrl(), builder.getRequestData(), builder.getCallback());
         return new FakeRequest();
    }

});
}
 

@Override
public Request makeRequest(RequestBuilder builder) {
    try{
        return builder.send();
    } catch(Exception e){
        throw new RuntimeException(e.toString(), e);
    }
}
 

@Override
public PuzzleServiceProxy get() {
    return new RetryLocalStorageServiceProxy(service,  new CallStrategy(){

    @Override
    public Request makeRequest(RequestBuilder builder) {
         ShortyzWave.makePostRequest(builder.getUrl(), builder.getRequestData(), builder.getCallback());
         return new FakeRequest();
    }

}){

        @Override
        public Request savePuzzle(Long listingId, Puzzle puzzle, final AsyncCallback callback) {
            DeferredCommand.add(new Command(){

                @Override
                public void execute() {
                    callback.onSuccess(null);
                }
                
            });
            return new FakeRequest();
        }

};
}
 

private RequestBuilder.Method toMethod(ServerOperation.Method method) {
  switch (method) {
  case DELETE:
    return RequestBuilder.DELETE;
  case GET:
    return RequestBuilder.GET;
  case POST:
    return RequestBuilder.POST;
  default:
    return RequestBuilder.GET;
  }
}
 

private void doStreamLogFile(final String fileName, final Dispatcher.Channel channel) {
    RequestBuilder requestBuilder = new RequestBuilder(RequestBuilder.GET, encode(streamUrl(fileName)));
    requestBuilder.setHeader("Accept", "text/plain");
    requestBuilder.setHeader("Content-Type", "text/plain");
    String bearerToken = DMRHandler.getBearerToken();
    if (bearerToken != null)
        requestBuilder.setHeader("Authorization", "Bearer " + bearerToken);
        
    requestBuilder.setIncludeCredentials(true);
    try {
        // store the request in order to cancel it later
        pendingStreamingRequest = new PendingStreamingRequest(fileName,
                requestBuilder.sendRequest(null, new RequestCallback() {
                    @Override
                    public void onResponseReceived(Request request, Response response) {
                        if (response.getStatusCode() >= 400) {
                            channel.nack(new IllegalStateException("Failed to stream log file " +
                                    fileName + ": " + response.getStatusCode() + " - " +
                                    response.getStatusText()));
                        } else {
                            LogFile newLogFile = new LogFile(fileName, response.getText());
                            newLogFile.setFollow(false);
                            states.put(fileName, newLogFile);
                            activate(newLogFile);
                            channel.ack();
                        }
                    }

                    @Override
                    public void onError(Request request, Throwable exception) {
                        channel.nack(exception);
                    }
                }), channel);
    } catch (RequestException e) {
        channel.nack(e);
    }
}
 

public Request findPuzzle(Long puzzleId, AsyncCallback<Puzzle> callback){
    RequestBuilder builder = service.findPuzzle(puzzleId, callback);
    return strat.makeRequest(builder);
}
 

public Request listPuzzles(AsyncCallback<PuzzleDescriptor[]> callback){
    RequestBuilder builder = service.listPuzzles(callback);
    return strat.makeRequest(builder);
}
 

public Request savePuzzle(Long listingId, Puzzle puzzle, AsyncCallback callback){
    RequestBuilder builder = service.savePuzzle(listingId, puzzle, callback);
    return strat.makeRequest(builder);
}
 

public void securize(RequestBuilder rb) {
	if (token != null) {
		rb.setHeader(header, token);
	}
}
 

private RequestBuilder createRequestBuilder(RequestBuilder.Method method) {
    return new RequestBuilder(method, BASE_URL);
}
 

public RequestBuilder findPuzzle(Long puzzleId, AsyncCallback<Puzzle> callback); 

public RequestBuilder listPuzzles(AsyncCallback<PuzzleDescriptor[]> callback); 

public RequestBuilder savePuzzle(Long listingId, Puzzle puzzle, AsyncCallback callback); 

public Request makeRequest(RequestBuilder builder);