Java HttpAction.redirect方法代码示例

import org.pac4j.core.exception.HttpAction; //导入方法依赖的package包/类
private void computeRedirectionToServerIfNecessary(final WebContext context) throws HttpAction {
    final String relayStateValue = context.getRequestParameter(CasConfiguration.RELAY_STATE_PARAMETER);
    // if we have a state value -> redirect to the CAS server to continue the logout process
    if (CommonUtils.isNotBlank(relayStateValue)) {
        final StringBuilder buffer = new StringBuilder();
        buffer.append(configuration.getPrefixUrl());
        if (!configuration.getPrefixUrl().endsWith("/")) {
            buffer.append("/");
        }
        buffer.append("logout?_eventId=next&");
        buffer.append(CasConfiguration.RELAY_STATE_PARAMETER);
        buffer.append("=");
        buffer.append(CommonUtils.urlEncode(relayStateValue));
        final String redirectUrl = buffer.toString();
        logger.debug("Redirection url to the CAS server: {}", redirectUrl);
        throw HttpAction.redirect("Force redirect to CAS server for front channel logout", context, redirectUrl);
    }
}
 

import org.pac4j.core.exception.HttpAction; //导入方法依赖的package包/类
/**
 * Perform a {@link RedirectAction} on the web context.
 *
 * @param context the web context
 * @return the performed {@link HttpAction}
 */
public HttpAction perform(final WebContext context) {
    if (type == RedirectType.REDIRECT) {
        return HttpAction.redirect("redirection via 302", context, location);
    } else {
        return HttpAction.ok("redirection via 200", context, content);
    }
}
 

import org.pac4j.core.exception.HttpAction; //导入方法依赖的package包/类
@Override
protected boolean handleError(final C context) throws HttpAction {
    if (this.redirectionUrl != null) {
        throw HttpAction.redirect(getErrorMessage(), context, this.redirectionUrl);
    } else {
        return false;
    }
}
 

import org.pac4j.core.exception.HttpAction; //导入方法依赖的package包/类
protected HttpAction redirectToOriginallyRequestedUrl(final C context, final String defaultUrl) {
    final String requestedUrl = (String) context.getSessionAttribute(Pac4jConstants.REQUESTED_URL);
    String redirectUrl = defaultUrl;
    if (isNotBlank(requestedUrl)) {
        context.setSessionAttribute(Pac4jConstants.REQUESTED_URL, null);
        redirectUrl = requestedUrl;
    }
    logger.debug("redirectUrl: {}", redirectUrl);
    return HttpAction.redirect("redirect", context, redirectUrl);
}
 

import org.pac4j.core.exception.HttpAction; //导入方法依赖的package包/类
@Override
public R perform(final C context, final Config config, final HttpActionAdapter<R, C> httpActionAdapter,
                   final String defaultUrl, final String inputLogoutUrlPattern) {

    logger.debug("=== APP LOGOUT ===");

    // default value
    final String logoutUrlPattern;
    if (inputLogoutUrlPattern == null) {
        logoutUrlPattern = Pac4jConstants.DEFAULT_LOGOUT_URL_PATTERN_VALUE;
    } else {
        logoutUrlPattern = inputLogoutUrlPattern;
    }

    // checks
    assertNotNull("context", context);
    assertNotNull("config", config);
    assertNotNull("httpActionAdapter", httpActionAdapter);
    assertNotBlank(Pac4jConstants.LOGOUT_URL_PATTERN, logoutUrlPattern);

    // logic
    final ProfileManager manager = getProfileManager(context);
    manager.logout();
    postLogout(context);

    final String url = context.getRequestParameter(Pac4jConstants.URL);
    String redirectUrl = defaultUrl;
    if (url != null && Pattern.matches(logoutUrlPattern, url)) {
        redirectUrl = url;
    }
    logger.debug("redirectUrl: {}", redirectUrl);
    final HttpAction action;
    if (redirectUrl != null) {
        action = HttpAction.redirect("redirect", context, redirectUrl);
    } else {
        action = HttpAction.ok("ok", context);
    }

    return httpActionAdapter.adapt(action.getCode(), context);
}
 

import org.pac4j.core.exception.HttpAction; //导入方法依赖的package包/类
@Override
protected boolean handleError(final WebContext context) throws HttpAction {
    if (this.redirectionUrl != null) {
        throw HttpAction.redirect(getErrorMessage(), context, this.redirectionUrl);
    } else {
        return false;
    }
}
 

import org.pac4j.core.exception.HttpAction; //导入方法依赖的package包/类
@Override
public final HttpAction redirect(final WebContext context) throws HttpAction {
    final RedirectAction action = getRedirectAction(context);
    if (action.getType() == RedirectType.REDIRECT) {
        return HttpAction.redirect("redirection via 302", context, action.getLocation());
    } else {
        return HttpAction.ok("redirection via 200", context, action.getContent());
    }
}
 

import org.pac4j.core.exception.HttpAction; //导入方法依赖的package包/类
private HttpAction handleInvalidCredentials(final WebContext context, final String username, String message, String errorMessage, int errorCode) throws HttpAction {
    // it's an AJAX request -> unauthorized (instead of a redirection)
    if (getAjaxRequestResolver().isAjax(context)) {
        logger.info("AJAX request detected -> returning " + errorCode);
        return HttpAction.status("AJAX request -> " + errorCode, errorCode, context);
    } else {
        String redirectionUrl = CommonHelper.addParameter(this.loginUrl, this.usernameParameter, username);
        redirectionUrl = CommonHelper.addParameter(redirectionUrl, ERROR_PARAMETER, errorMessage);
        logger.debug("redirectionUrl: {}", redirectionUrl);
        logger.debug(message);
        return HttpAction.redirect(message, context, redirectionUrl);
    }
}
 

import org.pac4j.core.exception.HttpAction; //导入方法依赖的package包/类
@Override
protected TokenCredentials retrieveCredentials(final WebContext context) throws HttpAction {
    init(context);
    try {
        String currentUrl = context.getFullRequestURL();
        String loginUrl = configuration.getLoginUrl();
        final CallbackUrlResolver callbackUrlResolver = configuration.getCallbackUrlResolver();
        if (callbackUrlResolver != null) {
            currentUrl = callbackUrlResolver.compute(currentUrl, context);
            loginUrl = callbackUrlResolver.compute(loginUrl, context);
        }

        final TokenCredentials credentials = getCredentialsExtractor().extract(context);
        if (credentials == null) {
            // redirect to the login page
            final String redirectionUrl = CommonUtils.constructRedirectUrl(loginUrl, CasConfiguration.SERVICE_PARAMETER,
                    currentUrl, configuration.isRenew(), false);
            logger.debug("redirectionUrl: {}", redirectionUrl);
            throw HttpAction.redirect("no ticket -> force redirect to login page", context, redirectionUrl);
        }

        // clean url from ticket parameter
        currentUrl = CommonHelper.substringBefore(currentUrl, "?" + CasConfiguration.TICKET_PARAMETER + "=");
        currentUrl = CommonHelper.substringBefore(currentUrl, "&" + CasConfiguration.TICKET_PARAMETER + "=");
        final CasAuthenticator casAuthenticator = new CasAuthenticator(configuration, currentUrl);
        casAuthenticator.init(context);
        casAuthenticator.validate(credentials, context);

        return credentials;
    } catch (CredentialsException e) {
        logger.error("Failed to retrieve or validate CAS credentials", e);
        return null;
    }
}
 

import org.pac4j.core.exception.HttpAction; //导入方法依赖的package包/类
@Override
protected HttpAction forbidden(final WebContext context, final List currentClients, final List list, final String authorizers) {
    return HttpAction.redirect("Authorization failed", context, "authorizationFailure");
}