Java 类play.mvc.Http.Request 实例源码

/**
 * This method will create common response for all controller method
 * 
 * @param response Object
 * @param key String
 * @param request play.mvc.Http.Request
 * @return Result
 */
public Result createCommonResponse(Object response, String key, play.mvc.Http.Request request) {

  if (response instanceof Response) {
    Response courseResponse = (Response) response;
    if (!ProjectUtil.isStringNullOREmpty(key)) {
      Object value = courseResponse.getResult().get(JsonKey.RESPONSE);
      courseResponse.getResult().remove(JsonKey.RESPONSE);
      courseResponse.getResult().put(key, value);
    }
    return Results.ok(
        Json.toJson(BaseController.createSuccessResponse(request, (Response) courseResponse)));
  } else {
    ProjectCommonException exception = (ProjectCommonException) response;
    return Results.status(exception.getResponseCode(),
        Json.toJson(BaseController.createResponseOnException(request, exception)));
  }
}

@Override
public Action<Void> createAction(Request request, Method actionMethod) {

    return new Action.Simple() {
        @Override
        public Promise<Result> call(Context ctx) throws Throwable {
            // Inject the required services into the context
            injectCommonServicesIncontext(ctx);
            final Language language = new Language(request.getQueryString("lang"));

            if (messagesPlugin.isLanguageValid(language.getCode())) {
                Logger.debug("change language to: " + language.getCode());
                ctx.changeLang(language.getCode());
                // Update the CAS language cookie which is relying on Spring
                // framework (not really solid yet works)
                Utilities.setSsoLanguage(ctx, language.getCode());
            }

            return delegate.call(ctx);

        }
    };

}

@Override
public void writeInterface(JsonGenerator generator, PlayHttpRequestInterface playHttpInterface) throws IOException {
    Request request = playHttpInterface.getRequest();

    generator.writeStartObject();
    generator.writeStringField(URL, buildUrl(request));
    generator.writeStringField(METHOD, request.method());

    generator.writeFieldName(DATA);
    writeData(generator, request);

    generator.writeStringField(QUERY_STRING, extractQueryString(request));

    generator.writeFieldName(COOKIES);
    writeCookies(generator, request.cookies());

    generator.writeFieldName(HEADERS);
    writeHeaders(generator, request.headers());

    generator.writeFieldName(ENVIRONMENT);
    writeEnvironment(generator, request);

    generator.writeEndObject();
}

private static ClientConf.Configuration loadConfiguration(Request request) {
    ClientConf.Configuration configuration = new ClientConf.Configuration();

    configuration.set(
        ClientConf.Setting.INDEX_URL,
        routes.Application.index().url());

    configuration.set(
        ClientConf.Setting.ASSETS_URL,
        controllers.routes.Assets.at("").url());

    configuration.set(
        ClientConf.Setting.RPC_SERVICE_HTTP_URL,
        controllers.rpc.routes.HTTPController.call().url());

    configuration.set(
        ClientConf.Setting.RPC_SERVICE_WS_URL,
        controllers.rpc.routes.WebSocketController.socket().webSocketURL(
            request));

    return configuration;
}

@Test
public void renderTemplate() throws InstantiationException, IllegalAccessException {
    Request requestMock = mock(Request.class);

    Context.current.set(new Context(1l, mock(RequestHeader.class), requestMock, //
            Collections.<String, String>emptyMap(), // sessionData
            Collections.<String, String>emptyMap(), // flashData
            Collections.<String, Object>emptyMap()));

    when(requestMock.username()).thenReturn("nom_de_test");

    Html html = views.html.index.render("Your new application is ready.");
    assertThat(contentType(html)).isEqualTo("text/html");
    assertThat(contentAsString(html)).contains("Your new application is ready.");
    assertThat(contentAsString(html)).contains("Bonjour nom_de_test!");
}

@Test
public void renderTemplate() throws InstantiationException, IllegalAccessException {
    Request requestMock = mock(Request.class);

    Context.current.set(new Context(1l, mock(RequestHeader.class), requestMock, //
            Collections.<String, String>emptyMap(), // sessionData
            Collections.<String, String>emptyMap(), // flashData
            Collections.<String, Object>emptyMap()));

    when(requestMock.username()).thenReturn("nom_de_test");

    Html html = views.html.index.render("Your new application is ready.");
    assertThat(contentType(html)).isEqualTo("text/html");
    assertThat(contentAsString(html)).contains("Your new application is ready.");
    assertThat(contentAsString(html)).contains("Bonjour nom_de_test!");
}

public PlayServerWebSocket(Request request, In<String> in, Out<String> out) {
    this.request = request;
    this.out = out;
    // TODO https://github.com/vibe-project/vibe-java-platform/issues/4
    // Supports text frame only for now
    in.onMessage(new Callback<String>() {
        @Override
        public void invoke(String message) throws Throwable {
            textActions.fire(message);
        }
    });
    in.onClose(new Callback0() {
        @Override
        public void invoke() throws Throwable {
            closeActions.fire();
        }
    });
}

private void displayGae(String name)
{
    Request request = Request.current();
    if (request != null)
    {
        Header header = request.headers.get("X-TraceUrl");
        if (header != null)
        {
            String value = header.value();
            if (StringUtils.isNotEmpty(value))
            {
                // Logger.info("profiler: " + name + " " + value);
            }
        }

    }
}

@Override
public void beforeActionInvocation(Method actionMethod) {
    super.beforeActionInvocation(actionMethod);
    // displayGae("beforeActionInvocation");
    // RenderArgs.current().put("profiler", profilerUtil);
    boolean shouldProfile = ProfilerEnhancer.shouldProfile();
    if (shouldProfile)
    {
        ProfilerEnhancer.addHeader(Request.current(), ProfilerEnhancer.REQUEST_ID_ATTRIBUTE, requestId);
        profilerUtil.setRequestId(requestId);

        RenderArgs.current().put("profiler", profilerUtil);
    }
    // Logger.info("beforeInvocation: " + actionMethod.getName() +
    // " requestId:" + ProfilerEnhancer.currentRequestId());
}

@Override
public void routeRequest(Request request) {
    boolean shouldProfile = ProfilerEnhancer.shouldProfile();
    if (shouldProfile)
    {
        profilerUtil = ProfilerEnhancer.addIncludes();
        requestId = String.valueOf(counter.incrementAndGet());
        ProfilerEnhancer.before(requestId);
        // Logger.info("routeRequest:" + request.path + " requestId:" +
        // ProfilerEnhancer.currentRequestId());
        startTime = System.currentTimeMillis();
        // displayGae("routeRequest");
        MiniProfiler.start();
    }
    super.routeRequest(request);
}

@SuppressWarnings("unchecked")
public Object bind(String name, Annotation[] annotations, String value, Class actualClass, Type genericType) {
    if (value == null || value.trim().length() == 0) {
        return null;
    }
    try {
        List<Upload> uploads = (List<Upload>) Request.current().args.get("__UPLOADS");
        for (Upload upload : uploads) {
            if (upload.getFieldName().equals(value) && upload.getSize() > 0) {
                return upload;
            }
        }
        if (Params.current().get(value + "_delete_") != null) {
            return null;
        }
        return Binder.MISSING;
    } catch (Exception e) {
        Logger.error("", e);
        throw new UnexpectedException(e);
    }
}

@SuppressWarnings("unchecked")
public File[] bind(String name, Annotation[] annotations, String value, Class actualClass, Type genericType) {
    if (value == null || value.trim().length() == 0) {
        return null;
    }
    List<Upload> uploads = (List<Upload>) Request.current().args.get("__UPLOADS");
    List<File> fileArray = new ArrayList<File>();
    for (Upload upload : uploads) {
        if (upload.getFieldName().equals(value)) {
            File file = upload.asFile();
            if (file.length() > 0) {
                fileArray.add(file);
            }
        }
    }
    return fileArray.toArray(new File[fileArray.size()]);
}

@SuppressWarnings("unchecked")
public File bind(String name, Annotation[] annotations, String value, Class actualClass, Type genericType) {
    if (value == null || value.trim().length() == 0) {
        return null;
    }
    List<Upload> uploads = (List<Upload>) Request.current().args.get("__UPLOADS");
    for (Upload upload : uploads) {
        if (upload.getFieldName().equals(value)) {
            File file = upload.asFile();
            if (file.length() > 0) {
                return file;
            }
            return null;
        }
    }
    return null;
}

@SuppressWarnings("unchecked")
public Object bind(String name, Annotation[] annotations, String value, Class actualClass, Type genericType) {
    if (value == null || value.trim().length() == 0) {
        return null;
    }
    try {
        Model.BinaryField b = (Model.BinaryField) actualClass.newInstance();
        List<Upload> uploads = (List<Upload>) Request.current().args.get("__UPLOADS");
        for (Upload upload : uploads) {
            if (upload.getFieldName().equals(value) && upload.getSize() > 0) {
                b.set(upload.asStream(), upload.getContentType());
                return b;
            }
        }
        if (Params.current().get(value + "_delete_") != null) {
            return null;
        }
        return Binder.MISSING;
    } catch (Exception e) {
        throw new UnexpectedException(e);
    }
}

/**
 * Render a specific template.
 *
 * @param templateName The template name.
 * @param args The template data.
 */
protected static void renderTemplate(String templateName, Map<String,Object> args) {
    // Template datas
    Scope.RenderArgs templateBinding = Scope.RenderArgs.current();
    templateBinding.data.putAll(args);
    templateBinding.put("session", Scope.Session.current());
    templateBinding.put("request", Http.Request.current());
    templateBinding.put("flash", Scope.Flash.current());
    templateBinding.put("params", Scope.Params.current());
    templateBinding.put("errors", Validation.errors());
    try {
        Template template = TemplateLoader.load(template(templateName));
        throw new RenderTemplate(template, templateBinding.data);
    } catch (TemplateNotFoundException ex) {
        if (ex.isSourceAvailable()) {
            throw ex;
        }
        StackTraceElement element = PlayException.getInterestingStrackTraceElement(ex);
        if (element != null) {
            throw new TemplateNotFoundException(templateName, Play.classes.getApplicationClass(element.getClassName()), element.getLineNumber());
        } else {
            throw ex;
        }
    }
}

public static Object invokeControllerMethod(Method method, Object[] forceArgs) throws Exception {
    if (Modifier.isStatic(method.getModifiers()) && !method.getDeclaringClass().getName().matches("^controllers\\..*\\$class$")) {
        return invoke(method, null, forceArgs == null ? getActionMethodArgs(method, null) : forceArgs);
    } else if (Modifier.isStatic(method.getModifiers())) {
        Object[] args = getActionMethodArgs(method, null);
        args[0] = Http.Request.current().controllerClass.getDeclaredField("MODULE$").get(null);
        return invoke(method, null, args);
    } else {
        Object instance = null;
        try {
            instance = method.getDeclaringClass().getDeclaredField("MODULE$").get(null);
        } catch (Exception e) {
            Annotation[] annotations = method.getDeclaredAnnotations();
            String annotation = Utils.getSimpleNames(annotations);
            if (!StringUtils.isEmpty(annotation)) {
                throw new UnexpectedException("Method public static void " + method.getName() + "() annotated with " + annotation + " in class " + method.getDeclaringClass().getName() + " is not static.");
            }
            // TODO: Find a better error report
            throw new ActionNotFoundException(Http.Request.current().action, e);
        }
        return invoke(method, instance, forceArgs == null ? getActionMethodArgs(method, instance) : forceArgs);
    }
}

protected static Map<String, Object> getBindingForErrors(Exception e, boolean isError) {

        Map<String, Object> binding = new HashMap<String, Object>();
        if (!isError) {
            binding.put("result", e);
        } else {
            binding.put("exception", e);
        }
        binding.put("session", Scope.Session.current());
        binding.put("request", Http.Request.current());
        binding.put("flash", Scope.Flash.current());
        binding.put("params", Scope.Params.current());
        binding.put("play", new Play());
        try {
            binding.put("errors", Validation.errors());
        } catch (Exception ex) {
            //Logger.error(ex, "Error when getting Validation errors");
        }

        return binding;
    }

@Override
public boolean rawInvocation(Request request, Response response) throws Exception {
    if (Play.mode.isDev() && request.path.equals("/@db")) {
        response.status = Http.StatusCode.MOVED;

        // For H2 embeded database, we'll also start the Web console
        if (h2Server != null) {
            h2Server.stop();
        }
        h2Server = org.h2.tools.Server.createWebServer();
        h2Server.start();

        response.setHeader("Location", "http://localhost:8082/");
        return true;
    }
    return false;
}

@Override
public boolean rawInvocation(Request request, Response response) throws Exception {

    // Mark an evolution as resolved
    if (Play.mode.isDev() && request.method.equals("POST") && request.url.matches("^/@evolutions/force/[0-9]+$")) {
        int revision = Integer.parseInt(request.url.substring(request.url.lastIndexOf("/") + 1));
        resolve(revision);
        new Redirect("/").apply(request, response);
        return true;
    }

    // Apply the current evolution script
    if (Play.mode.isDev() && request.method.equals("POST") && request.url.equals("/@evolutions/apply")) {
        applyScript(true);
        new Redirect("/").apply(request, response);
        return true;
    }
    return super.rawInvocation(request, response);
}

/**
 * sends a GET request to the application under tests.
 * @param request
 * @param url relative url such as <em>"/products/1234"</em>
 * @return the response
 */
public static Response GET(Request request, Object url) {
    String path = "";
    String queryString = "";
    String turl = url.toString();
    if (turl.contains("?")) {
        path = turl.substring(0, turl.indexOf("?"));
        queryString = turl.substring(turl.indexOf("?") + 1);
    } else {
        path = turl;
    }
    request.method = "GET";
    request.url = turl;
    request.path = path;
    request.querystring = queryString;
    request.body = new ByteArrayInputStream(new byte[0]);
    if (savedCookies != null) request.cookies = savedCookies;
    return makeRequest(request);
}

/**
 * Sends a POST request to the application under tests.
 * @param request
 * @param url relative url such as <em>"/products/1234"</em>
 * @param contenttype content-type of the request
 * @param body posted data
 * @return the response
 */
public static Response POST(Request request, Object url, String contenttype, InputStream body) {
    String path = "";
    String queryString = "";
    String turl = url.toString();
    if (turl.contains("?")) {
        path = turl.substring(0, turl.indexOf("?"));
        queryString = turl.substring(turl.indexOf("?") + 1);
    } else {
        path = turl;
    }
    request.method = "POST";
    request.contentType = contenttype;
    request.url = turl;
    request.path = path;
    request.querystring = queryString;
    request.body = body;
    if (savedCookies != null) request.cookies = savedCookies;
    return makeRequest(request);
}

/**
 * Sends a PUT request to the application under tests.
 * @param request
 * @param url relative url such as <em>"/products/1234"</em>
 * @param contenttype content-type of the request
 * @param body data to send
 * @return the response
 */
public static Response PUT(Request request, Object url, String contenttype, String body) {
    String path = "";
    String queryString = "";
    String turl = url.toString();
    if (turl.contains("?")) {
        path = turl.substring(0, turl.indexOf("?"));
        queryString = turl.substring(turl.indexOf("?") + 1);
    } else {
        path = turl;
    }
    request.method = "PUT";
    request.contentType = contenttype;
    request.url = turl;
    request.path = path;
    request.querystring = queryString;
    request.body = new ByteArrayInputStream(body.getBytes());
    return makeRequest(request);
}

/**
 * Sends a DELETE request to the application under tests.
 * @param request
 * @param url relative url eg. <em>"/products/1234"</em>
 * @return the response
 */
public static Response DELETE(Request request, Object url) {
    String path = "";
    String queryString = "";
    String turl = url.toString();
    if (turl.contains("?")) {
        path = turl.substring(0, turl.indexOf("?"));
        queryString = turl.substring(turl.indexOf("?") + 1);
    } else {
        path = turl;
    }
    request.method = "DELETE";
    request.url = turl;
    request.path = path;
    request.querystring = queryString;
    if (savedCookies != null) request.cookies = savedCookies;
    request.body = new ByteArrayInputStream(new byte[0]);
    return makeRequest(request);
}

public static Response makeRequest(final Request request) {
    Response response = newResponse();
    makeRequest(request, response);

    if (response.status == 302) { // redirect
        // if Location-header is pressent, fix it to "look like" a functional-test-url
        Http.Header locationHeader = response.headers.get("Location");
        if (locationHeader != null) {
            String locationUrl = locationHeader.value();
            if (locationUrl.startsWith("http://localhost/")) {
                locationHeader.values.clear();
                locationHeader.values.add( locationUrl.substring(16));//skip 'http://localhost'
            }
        }
    }
    return response;
}

public static Request newRequest() {
    Request request = Request.createRequest(
            null,
            "GET",
            "/",
            "",
            null,
            null,
            null,
            null,
            false,
            80,
            "localhost",
            false,
            null,
            null
    );
    return request;
}

/**
 * Retrieve the current language or null
 * @return The current language (fr, ja, it ...) or null
 */
public static String get() {
    String locale = current.get();
    if (locale == null) {
        // don't have current locale for this request - must try to resolve it
        Http.Request currentRequest = Http.Request.current();
        if (currentRequest!=null) {
            // we have a current request - lets try to resolve language from it
            resolvefrom( currentRequest );
        } else {
            // don't have current request - just use default
            setDefaultLocale();
        }
        // get the picked locale
        locale = current.get();
    }
    return locale;
}

@Override
public Promise<Result> apply(Request request, Method method, Context context, Action<?> action)
    throws Throwable {
  String token = getAuthorizationToken(request);
  if (token == null) {
    token = request.getQueryString(OAuth2AccessToken.ACCESS_TOKEN);
  }
  if (token == null) {
    logger.info("Authentication skipped");
  } else {
    Authentication authRequest = new PreAuthenticatedAuthenticationToken(token, "");
    Authentication authResult = oauth2AuthenticationManager.authenticate(authRequest);
    SecurityContextHolder.getContext().setAuthentication(authResult);
    logger.info("Authenticated successfully");
  }
  return action.call(context);
}

/**
 * This method will create failure response
 * 
 * @param request Request
 * @param code ResponseCode
 * @param headerCode ResponseCode
 * @return Response
 */
public static Response createFailureResponse(Request request, ResponseCode code,
    ResponseCode headerCode) {

  Response response = new Response();
  response.setVer(getApiVersion(request.path()));
  response.setId(getApiResponseId(request));
  response.setTs(ProjectUtil.getFormattedDate());
  response.setResponseCode(headerCode);
  response.setParams(createResponseParamObj(code));
  return response;
}

/**
 * This method will create data for success response.
 * 
 * @param request play.mvc.Http.Request
 * @param response Response
 * @return Response
 */
public static Response createSuccessResponse(play.mvc.Http.Request request, Response response) {

  if (request != null) {
    response.setVer(getApiVersion(request.path()));
  } else {
    response.setVer("");
  }
  response.setId(getApiResponseId(request));
  response.setTs(ProjectUtil.getFormattedDate());
  ResponseCode code = ResponseCode.getResponse(ResponseCode.success.getErrorCode());
  code.setResponseCode(ResponseCode.OK.getResponseCode());
  response.setParams(createResponseParamObj(code));
  return response;
}

/**
 * This method will handle response in case of exception
 * 
 * @param request play.mvc.Http.Request
 * @param exception ProjectCommonException
 * @return Response
 */
public static Response createResponseOnException(play.mvc.Http.Request request,
    ProjectCommonException exception) {
  ProjectLogger.log(exception != null ? exception.getMessage() : "Message is not coming",
      exception);
  Response response = new Response();
  if (request != null) {
    response.setVer(getApiVersion(request.path()));
  } else {
    response.setVer("");
  }
  response.setId(getApiResponseId(request));
  response.setTs(ProjectUtil.getFormattedDate());
  response.setResponseCode(ResponseCode.getHeaderResponseCode(exception.getResponseCode()));
  ResponseCode code = ResponseCode.getResponse(exception.getCode());
  if (code == null) {
    code = ResponseCode.SERVER_ERROR;
  }
  response.setParams(createResponseParamObj(code));
  if (response.getParams() != null && response.getParams().getStatus() != null) {
    response.getParams().setStatus(
        exception.getCode() != null ? exception.getCode() : response.getParams().getStatus());
  }
  if (response.getParams() != null
      && !ProjectUtil.isStringNullOREmpty(response.getParams().getErrmsg())
      && response.getParams().getErrmsg().contains("{0}")) {
    response.getParams().setErrmsg(exception.getMessage());
  }
  return response;
}

/**
 * This method will be called on each request.
 * 
 * @param request Request
 * @param actionMethod Method
 * @return Action
 */
@SuppressWarnings("rawtypes")
public Action onRequest(Request request, Method actionMethod) {

  String messageId = request.getHeader(JsonKey.MESSAGE_ID);
  ProjectLogger.log("method call start.." + request.path() + " " + actionMethod + " " + messageId,
      LoggerEnum.INFO.name());
  if (ProjectUtil.isStringNullOREmpty(messageId)) {
    UUID uuid = UUID.randomUUID();
    messageId = uuid.toString();
    ProjectLogger.log("message id is not provided by client.." + messageId);
  }
  ExecutionContext.setRequestId(messageId);
  return new ActionWrapper(super.onRequest(request, actionMethod));
}

private void fillAndSave(Event event, Request request){
    if(request != null){
        event.setIpAddress(request.remoteAddress());
        event.setUserAgent(request.header("User-Agent").orElse(null));
    }
    this.save(event);
}

public static Result handleException(Throwable e, Request request) {
  if (e.getCause().getCause() instanceof GroundException) {
    return badRequest(GroundUtils.getClientError(request, e.getCause().getCause(), ExceptionType.ITEM_NOT_FOUND));
  } else {
    return internalServerError(GroundUtils.getServerError(request, e.getCause().getCause()));
  }
}

private static ObjectNode getServerError(final Request request, final Throwable e) {
  Logger.error("Error! Request Path: {}\nError Message: {}\n Stack Trace: {}", request.path(), e.getMessage(), e.getStackTrace());

  ObjectNode result = Json.newObject();
  result.put("Error", "Unexpected error while processing request.");
  result.put("Request Path", request.path());

  StringWriter sw = new StringWriter();
  e.printStackTrace(new PrintWriter(sw));
  result.put("Stack Trace", sw.toString());
  return result;
}

/**
 * Constructor RequestHeader
 * @param request
 * @return new RequestHeader Object
 * @throws Exception
 */
public RequestHeader (Request request) throws Exception {

  this.remoteAddress = request.remoteAddress();
  this.requestType = RequestType.valueOf(request.method().toUpperCase() );
  this.userAgent = request.getHeader("User-Agent");
  this.httpAccept = request.getHeader("Accept");
  this.headers = request.headers();
}

/**
 * Check the identity of the user from the current request, that should be the callback from the OpenID server
 */
public static F.Promise<UserInfo> verifiedId() {
    Request request = Http.Context.current().request();
    scala.concurrent.Future<UserInfo> scalaPromise = play.api.libs.openid.OpenID.verifiedId(request.queryString()).map(
            new AbstractFunction1<play.api.libs.openid.UserInfo, UserInfo>() {
                @Override
                public UserInfo apply(play.api.libs.openid.UserInfo scalaUserInfo) {
                    return new UserInfo(scalaUserInfo.id(), JavaConversions.mapAsJavaMap(scalaUserInfo.attributes()));
                }
            },Invoker.executionContext());
    return new F.Promise<UserInfo>(scalaPromise);
}

private Integer extractPort(Request request) {
    String host = request.host();
    String[] hparts = host.split(":");

    Integer port;

    if(hparts.length == 2)
        port = Integer.parseInt(hparts[1]);
    else
        port = 80;

    return port;
}

private String extractQueryString(Request request) {
    int index = request.uri().indexOf("?");
    if(index == -1)
        return "";

    return request.uri().substring(index + 1);
}

private void writeEnvironment(JsonGenerator generator, Request request) throws IOException {
    InetAddress localhost = InetAddress.getLocalHost();

    generator.writeStartObject();
       generator.writeStringField(ENV_REMOTE_ADDR, request.remoteAddress());
       generator.writeStringField(ENV_SERVER_NAME, request.host());
       generator.writeNumberField(ENV_SERVER_PORT, extractPort(request));
       generator.writeStringField(ENV_LOCAL_ADDR, localhost.getHostAddress());
       generator.writeStringField(ENV_LOCAL_NAME, localhost.getHostName());
       generator.writeStringField(ENV_SERVER_PROTOCOL, request.version());
       generator.writeBooleanField(ENV_REQUEST_SECURE, request.secure());
       generator.writeStringField(ENV_REMOTE_USER, request.username());
       generator.writeEndObject();
}

/**
 * Helper to get the selected rows (ids) from the request (depending of the
 * row action type: ajax or link).
 * 
 * @param request
 *            the HTTP request
 */
public static List<String> getIdsFromRequest(Request request) {

    try {

        List<String> ids = new ArrayList<>();
        JsonNode selectedRows = null;

        // ajax case
        JsonNode json = request.body().asJson();
        if (json != null && json.get(JSON_SELECTED_ROWS_FIELD) != null) {
            selectedRows = json.get(JSON_SELECTED_ROWS_FIELD);
        }

        // link case
        Map<String, String[]> formUrlEncoded = request.body().asFormUrlEncoded();
        if (formUrlEncoded != null && formUrlEncoded.get(JSON_SELECTED_ROWS_FIELD) != null && formUrlEncoded.get(JSON_SELECTED_ROWS_FIELD).length > 0) {
            String[] selectedRowsString = formUrlEncoded.get(JSON_SELECTED_ROWS_FIELD);
            ObjectMapper mapper = new ObjectMapper();
            selectedRows = mapper.readTree(selectedRowsString[0]);
        }

        if (selectedRows != null) {
            for (JsonNode elem : selectedRows) {
                ids.add(elem.asText());
            }
            return ids;
        }

    } catch (Exception e) {
        Logger.error("impossible to get the ids", e);
    }

    return null;
}