How to use

getParameter

method

in

leap.web.Request

@Override
public String getParameter(String name) {
  return request.getParameter(name);
}

public RequestOAuth2Params(Request request) {
  this.request   = request;
  this.grantType = request.getParameter(GRANT_TYPE);
}

@Override
public String getParameter(String name) {
  return request.getParameter(name);
}

@Override
public String getParameter(String name) {
  return request.getParameter(name);
}

protected boolean isLogoutFromServer(Request request) {
  String v = request.getParameter(OAUTH2_LOGOUT);
  return "1".equals(v);
}

protected boolean isRedirectBackFromServer(Request request) {
  String v = request.getParameter(REDIRECT_BACK_PARAM);
  return "1".equals(v);
}

protected String generateToken(Request request, OAuth2Client client, int expires, boolean includeNonce) {
  Map<String, Object> claims = new LinkedHashMap<>();
  claims.put(JWT.CLAIM_AUDIENCE,        client.getId());
  claims.put(JWT.CLAIM_EXPIRATION_TIME, System.currentTimeMillis()/1000L + expires);
  if(includeNonce) {
    String nonce = request.getParameter("nonce");
    if (!Strings.isEmpty(nonce)) {
      claims.put("nonce", nonce);
    }
  }
  return signer.sign(claims, config.getExpires());
}

  protected void handleTokenEndpoint(Request request, Response response) throws Throwable {
    String grantType = request.getParameter("grant_type");

    boolean clientCredentials = CLIENT_CREDENTIALS.equals(grantType);
    if(clientCredentials) {
      handleClientCredentialsGrantType(request, response);
      return;
    }

//        boolean refreshToken = REFRESH_TOKEN.equals(grantType);
//        if(refreshToken) {
//            handleRefreshTokenGrantType(request, response);
//            return;
//        }

    error(response, 400, INVALID_REQUEST);
  }

@Override
public Token extractTokenFromRequest(Request request) {
  String v = request.getParameter(OAuth2Constants.ACCESS_TOKEN);
  if (Strings.isEmpty(v)) {
    v = request.getHeader(Headers.AUTHORIZATION);
    if (Strings.startsWithIgnoreCase(v, OAuth2Constants.BEARER_TYPE)) {
      v = v.substring(OAuth2Constants.BEARER_TYPE.length()).trim();
    } else {
      v = null;
    }
  }
  if (Strings.isEmpty(v)) {
    return null;
  }
  return new SimpleToken(v);
}

protected String[] extractClientCredentials(Request request, Response response) {
  String authorization = request.getHeader(Headers.AUTHORIZATION);
  if(!Strings.isEmpty(authorization)){
    if(!authorization.startsWith("Basic")){
      error(response, 400, INVALID_REQUEST, "invalid Authorization header");
      return null;
    }
    String base64Token = Strings.trim(authorization.substring("Basic".length()));
    String token = Base64.decode(base64Token);
    String[] idAndSecret = Strings.split(token,":");
    if(idAndSecret.length != 2){
      error(response, 400, INVALID_REQUEST, "invalid Authorization header");
      return null;
    }
    return new String[]{idAndSecret[0],idAndSecret[1]};
  }
  return new String[]{request.getParameter("client_id"), request.getParameter("client_secret")};
}

@Override
public State prePromoteLogin(Request request, Response response, LoginContext context) throws Throwable {
  if(config.isOAuth2LoginEnabled()) {
    //Check cyclic redirect.
    if(!Strings.isEmpty(request.getParameter("oauth2_redirect"))) {
      throw new IllegalStateException("Cannot promote login for oauth2 redirect request : " + request.getUri());
    }else{
      context.setLoginUrl(buildRemoteLoginUrl(request));
    }
  }
  return State.CONTINUE;
}

@Override
public State preLogout(Request request, Response response, LogoutContext context) throws Throwable {
  if(config.isEnabled() && config.isOAuth2LogoutEnabled()) {
    Boolean reqeustedLogout = (Boolean)request.getAttribute("oauth2_logout");
    if(null != reqeustedLogout) {
      return State.CONTINUE;
    }
    String remoteLogoutParam = request.getParameter("remote_logout");
    if("0".equals(remoteLogoutParam)) {
      return State.CONTINUE;
    }else{
      response.sendRedirect(buildRemoteLogoutUrl(request));
      return State.INTERCEPTED;
    }
  }
  return State.CONTINUE;
}

  protected String getCsrfTokenString(Request request) {
    String token = request.getHeader(securityConfig.getCsrfHeaderName());
    if(Strings.isEmpty(token)) {
      token = request.getParameter(securityConfig.getCsrfParameterName());
      if(Strings.isEmpty(token)) {
        token = CSRF.getRequestToken(request);
      }
    }
    return token;
  }
}

private boolean checkProfile(MApiOperation o) {
  if(null == o.getRoute()) {
    return false;
  }
  String[] profiles = tryGetProfiles(o);
  if(null != profiles) {
    Request request = Request.tryGetCurrent();
    if (null != request) {
      String requestProfile = request.getParameter("profile");
      if (Strings.isNotBlank(requestProfile)) {
        if(!Arrays2.containsAny(profiles, requestProfile)) {
          return true;
        }
      }
    }
  }
  return false;
}

@Override
public void onLoginSuccess(Request request, Response response, Authentication authentication) {
  UserPrincipal user = authentication.getUser();
  
  if(user instanceof UserDetails){
    String rememberMe = request.getParameter(securityConfig.getRememberMeParameterName());
  
    if(Converts.toBoolean(rememberMe, false)){
      setRememberMeCookie(request,response,user.getLoginName(),((UserDetails) user).getPassword());
    }else{
      removeCookie(request, response);
    }
  }
}

protected void handleAuthzServerLoginResponse(Request request, Response response) throws Throwable {
  String logoutParam = request.getParameter("oauth2_logout");
  if(!Strings.isEmpty(logoutParam)) {
    request.setAttribute("oauth2_logout", Boolean.TRUE);
    lom.logout(request, response);
  }else{
    OAuth2Params params = new RequestOAuth2Params(request);
    if(params.isError()) {
      handleOAuth2ServerError(request, response, params);
    }else{
      handleOAuth2ServerSuccess(request, response, params);
    }
  }
}

protected String getReturnUrl(LoginContext context, Request request, String loginUrl){
  String returnUrl = context.getReturnUrl() ;
  
  if(null == returnUrl){
    returnUrl = request.getParameter(config.getReturnUrlParameterName());
  }
  
  if(Strings.isEmpty(returnUrl)){
    if(null != loginUrl) {
      String loginPath = Urls.removeQueryString(urlHandler.removePrefix(loginUrl));
      if(!request.getPath().equals(loginPath)) {
        return request.getUriWithQueryString();
      }
    }
    if(config.isLoginRedirectRoot()) {
      return "/";
    }else {
      return request.getUri();
    }
  }
  
  return returnUrl;
}

  protected String getReturnUrl(LogoutContext context, Request request){
    String returnUrl = context.getReturnUrl() ;
    
    if(null == returnUrl){
      returnUrl = request.getParameter(context.getSecurityConfig().getReturnUrlParameterName());
    }
    
    if(Strings.isEmpty(returnUrl)){
      returnUrl = context.getSecurityConfig().getLogoutSuccessUrl();
    }
    
    if(Strings.isEmpty(returnUrl)){
      returnUrl = Strings.isEmpty(request.getContextPath()) ? "/" : request.getContextPath();
    }
    
    return returnUrl;
  }
}

@Override
public void handle(Request request, Response response) throws Throwable {
  String grantType = request.getParameter("grant_type");
  if(Strings.isEmpty(grantType)) {
    errorHandler.invalidRequest(response, "'grant_type' required");
    return;
  }
  GrantTypeHandler handler = grantTokenManager.getHandler(grantType);
  if(null == handler) {
    errorHandler.invalidRequest(response, "Unsupported grant type");
    return;
  }
  try{
    OAuth2Params params = new RequestOAuth2Params(request, grantType);
    AuthzAccessToken token = grantTokenManager.grantAccessToken(request,response,params,handler);
    if(token!=null){
      handleGrantedToken(request, response, params, handler, token);
    }
  }catch(OAuth2ResponseException e) {
    errorHandler.response(response, e.getStatus(), e.getError(), e.getMessage());
  }catch(ResponseException e) {
    throw e;
  }catch(Throwable e) {
    errorHandler.serverError(response, e.getMessage(), e);
  }
}

@Override
public Object apply(ActionParams params) {
  MApiModel am = api.getMetadata().getModel(model.getName());
  ModelExecutorContext context  = new SimpleModelExecutorContext(api, dao, am, em, params);
  ModelDeleteExecutor  executor = newDeleteExecutor(context);
  Object        id      = id(params);
  DeleteOptions options = cascadeDelete ? getWithId(params, 0) : null;
  if (!cascadeDelete) {
    Request request = Request.tryGetCurrent();
    String  param   = request.getParameter("cascade_delete");
    if (!Strings.isEmpty(param) && Converts.toBoolean(param)) {
      throw new BadRequestException("Cascade delete not supported by this operation, check parameter 'cascade_delete'!");
    }
  }
  DeleteOneResult result = executor.deleteOne(id, options);
  if (null != result.entity) {
    return ApiResponse.of(result.entity);
  } else {
    if (result.success) {
      return ApiResponse.NO_CONTENT;
    } else {
      throw new NotFoundException(am.getName() + " '" + id.toString() + "' not found");
    }
  }
}