org.xdi.oxauth.uma.service.UmaGatherer クラス

org.xdi.oxauth.uma.service.UmaGatherer 連携図

公開メンバ関数
boolean	gather ()
String	prepareForStep ()
String	result (String resultCode)
void	addMessage (FacesMessage.Severity severity, String summary)
Map< String, String >	getPageClaims ()

静的公開メンバ関数
static String	addQueryParameters (String url, String parameters)
static String	addQueryParameter (String url, String paramName, String paramValue)

限定公開メンバ関数
CustomScriptConfiguration	getScript (final SessionId session)

非公開メンバ関数
void	onSuccess (SessionId session, UmaGatherContext context)
String	constructRedirectUri (SessionId session, UmaGatherContext context, String newTicket)
void	errorPage (String errorKey)

非公開変数類
Logger	log
ExternalUmaClaimsGatheringService	external
AppConfiguration	appConfiguration
FacesContext	facesContext
ExternalContext	externalContext
FacesService	facesService
LanguageBean	languageBean
UmaSessionService	umaSessionService
UmaPermissionService	umaPermissionService
UmaPctService	umaPctService
UserService	userService
final Map< String, String >	pageClaims = new HashMap<String, String>()

詳解

著者

yuriyz

バージョン

August 9, 2017

関数詳解

addMessage()

void org.xdi.oxauth.uma.service.UmaGatherer.addMessage ( FacesMessage.Severity  severity, String  summary  )

inline

                                                                           {
        String msg = languageBean.getMessage(summary);
        FacesMessage message = new FacesMessage(severity, msg, null);
        facesContext.addMessage(null, message);
    }

addQueryParameter()

static String org.xdi.oxauth.uma.service.UmaGatherer.addQueryParameter ( String  url, String  paramName, String  paramValue  )

inlinestatic

                                                                                            {
        if (StringUtils.isBlank(url)) {
            return "";
        }
        if (StringUtils.isNotBlank(paramValue)) {
            if (url.contains("?")) {
                url += "&" + paramName + "=" + paramValue;
            } else {
                url += "?" + paramName + "=" + paramValue;
            }
        }
        return url;
    }

addQueryParameters()

static String org.xdi.oxauth.uma.service.UmaGatherer.addQueryParameters ( String  url, String  parameters  )

inlinestatic

                                                                           {
        if (StringUtils.isNotBlank(parameters)) {
            if (url.contains("?")) {
                url += "&" + parameters;
            } else {
                url += "?" + parameters;
            }
        }
        return url;
    }

constructRedirectUri()

String org.xdi.oxauth.uma.service.UmaGatherer.constructRedirectUri ( SessionId  session, UmaGatherContext  context, String  newTicket  )

inlineprivate

                                                                                                       {
        String claimsRedirectUri = umaSessionService.getClaimsRedirectUri(session);
        if (StringUtils.isBlank(claimsRedirectUri)) {
            log.debug("claims_redirect_uri is blank, session: " + session);
            return "";
        }

        claimsRedirectUri = addQueryParameters(claimsRedirectUri, context.getRedirectUserParameters().buildQueryString().trim());
        claimsRedirectUri = addQueryParameter(claimsRedirectUri, "state", umaSessionService.getState(session));
        claimsRedirectUri = addQueryParameter(claimsRedirectUri, "ticket", newTicket);
        return claimsRedirectUri;
    }

errorPage()

void org.xdi.oxauth.uma.service.UmaGatherer.errorPage ( String  errorKey )

inlineprivate

                                            {
        addMessage(FacesMessage.SEVERITY_ERROR, errorKey);
        facesService.redirect("/error.xhtml");
    }

gather()

boolean org.xdi.oxauth.uma.service.UmaGatherer.gather ( )

inline

                            {
        try {
            final HttpServletRequest httpRequest = (HttpServletRequest) externalContext.getRequest();
            final HttpServletResponse httpResponse = (HttpServletResponse) externalContext.getResponse();
            final SessionId session = umaSessionService.getSession(httpRequest, httpResponse);

            CustomScriptConfiguration script = getScript(session);
            UmaGatherContext context = new UmaGatherContext(script.getConfigurationAttributes(), httpRequest, session, umaSessionService, umaPermissionService,
                    umaPctService, pageClaims, userService, facesService, appConfiguration);

            int step = umaSessionService.getStep(session);
            if (!umaSessionService.isPassedPreviousSteps(session, step)) {
                log.error("There are claims-gathering steps not marked as passed. scriptName: '{}', step: '{}'", script.getName(), step);
                return false;
            }

            boolean gatheredResult = external.gather(script, step, context);
            log.debug("Claims-gathering result for script '{}', step: '{}', gatheredResult: '{}'", script.getName(), step, gatheredResult);

            int overridenNextStep = external.getNextStep(script, step, context);

            if (!gatheredResult && overridenNextStep == -1) {
                return false;
            }

            if (overridenNextStep != -1) {
                umaSessionService.resetToStep(session, overridenNextStep, step);
                step = overridenNextStep;
            }

            int stepsCount = external.getStepsCount(script, context);

            if (step < stepsCount || overridenNextStep != -1) {
                int nextStep;
                if (overridenNextStep != -1) {
                    nextStep = overridenNextStep;
                } else {
                    nextStep = step + 1;
                    umaSessionService.markStep(session, step, true);
                }

                umaSessionService.setStep(nextStep, session);
                context.persist();

                String page = external.getPageForStep(script, nextStep, context);

                log.trace("Redirecting to page: '{}'", page);
                facesService.redirect(page);
                return true;
            }

            if (step == stepsCount) {
                context.persist();
                onSuccess(session, context);
                return true;
            }
        } catch (Exception e) {
            log.error("Exception during gather() method call.", e);
        }

        log.error("Failed to perform gather() method successfully.");
        return false;
    }

getPageClaims()

Map<String, String> org.xdi.oxauth.uma.service.UmaGatherer.getPageClaims ( )

inline

                                               {
        return pageClaims;
    }

getScript()

CustomScriptConfiguration org.xdi.oxauth.uma.service.UmaGatherer.getScript ( final SessionId  session )

inlineprotected

                                                                           {
                String scriptName = umaSessionService.getScriptName(session);
                CustomScriptConfiguration script = external.getCustomScriptConfigurationByName(scriptName);

                return script;
        }

onSuccess()

void org.xdi.oxauth.uma.service.UmaGatherer.onSuccess ( SessionId  session, UmaGatherContext  context  )

inlineprivate

                                                                        {
        List<UmaPermission> permissions = context.getPermissions();
        String newTicket = umaPermissionService.changeTicket(permissions, permissions.get(0).getAttributes());

        String url = constructRedirectUri(session, context, newTicket);
        if (StringUtils.isNotBlank(url)) {
            facesService.redirectToExternalURL(url);
        } else {
            log.debug("Redirect to claims_redirect_uri is skipped because it was not provided during request.");
        }
    }

prepareForStep()

String org.xdi.oxauth.uma.service.UmaGatherer.prepareForStep ( )

inline

                                   {
        try {
            final HttpServletRequest httpRequest = (HttpServletRequest) externalContext.getRequest();
            final HttpServletResponse httpResponse = (HttpServletResponse) externalContext.getResponse();
            final SessionId session = umaSessionService.getSession(httpRequest, httpResponse);

            if (session == null || session.getSessionAttributes().isEmpty()) {
                log.error("Invalid session.");
                return result(Constants.RESULT_EXPIRED);
            }

            CustomScriptConfiguration script = getScript(session);
            UmaGatherContext context = new UmaGatherContext(script.getConfigurationAttributes(), httpRequest, session, umaSessionService, umaPermissionService,
                    umaPctService, pageClaims, userService, facesService, appConfiguration);

            int step = umaSessionService.getStep(session);
            if (step < 1) {
                log.error("Invalid step: {}", step);
                return result(Constants.RESULT_INVALID_STEP);
            }
            if (script == null) {
                log.error("Failed to load script, step: '{}'", step);
                return result(Constants.RESULT_FAILURE);
            }

            if (!umaSessionService.isPassedPreviousSteps(session, step)) {
                log.error("There are claims-gathering steps not marked as passed. scriptName: '{}', step: '{}'", script.getName(), step);
                return result(Constants.RESULT_FAILURE);
            }

            boolean result = external.prepareForStep(script, step, context);
            if (result) {
                context.persist();
                return result(Constants.RESULT_SUCCESS);
            } else {
                String redirectToExternalUrl = context.getRedirectToExternalUrl();
                if (StringUtils.isNotBlank(redirectToExternalUrl)) {
                    log.debug("Redirect to : " + redirectToExternalUrl);
                    facesService.redirectToExternalURL(redirectToExternalUrl);
                    return redirectToExternalUrl;
                }
            }
        } catch (Exception e) {
            log.error("Failed to prepareForStep()", e);
        }
        return result(Constants.RESULT_FAILURE);
    }

result()

String org.xdi.oxauth.uma.service.UmaGatherer.result ( String  resultCode )

inline

                                            {
        if (Constants.RESULT_FAILURE.equals(resultCode)) {
            addMessage(FacesMessage.SEVERITY_ERROR, "uma2.gather.failed");
        } else if (Constants.RESULT_INVALID_STEP.equals(resultCode)) {
            addMessage(FacesMessage.SEVERITY_ERROR, "uma2.invalid.step");
        } else if (Constants.RESULT_EXPIRED.equals(resultCode)) {
            addMessage(FacesMessage.SEVERITY_ERROR, "uma2.invalid.session");
        }
        return resultCode;
    }

メンバ詳解

appConfiguration

AppConfiguration org.xdi.oxauth.uma.service.UmaGatherer.appConfiguration

private

external

ExternalUmaClaimsGatheringService org.xdi.oxauth.uma.service.UmaGatherer.external

private

externalContext

ExternalContext org.xdi.oxauth.uma.service.UmaGatherer.externalContext

private

facesContext

FacesContext org.xdi.oxauth.uma.service.UmaGatherer.facesContext

private

facesService

FacesService org.xdi.oxauth.uma.service.UmaGatherer.facesService

private

languageBean

LanguageBean org.xdi.oxauth.uma.service.UmaGatherer.languageBean

private

log

Logger org.xdi.oxauth.uma.service.UmaGatherer.log

private

pageClaims

final Map<String, String> org.xdi.oxauth.uma.service.UmaGatherer.pageClaims = new HashMap<String, String>()

private

umaPctService

UmaPctService org.xdi.oxauth.uma.service.UmaGatherer.umaPctService

private

umaPermissionService

UmaPermissionService org.xdi.oxauth.uma.service.UmaGatherer.umaPermissionService

private

umaSessionService

UmaSessionService org.xdi.oxauth.uma.service.UmaGatherer.umaSessionService

private

userService

UserService org.xdi.oxauth.uma.service.UmaGatherer.userService

private

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/OpenId/gluu/src/oxAuth/Server/src/main/java/org/xdi/oxauth/uma/service/UmaGatherer.java