import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Override
public void validate(final UsernamePasswordCredentials credentials, final WebContext context) throws HttpAction {
    if (credentials == null) {
        throwsException("No credential");
    }
    String username = credentials.getUsername();
    String password = credentials.getPassword();
    if (CommonHelper.isBlank(username)) {
        throwsException("Username cannot be blank");
    }
    if (CommonHelper.isBlank(password)) {
        throwsException("Password cannot be blank");
    }
    if (CommonHelper.areNotEquals(username, password)) {
        throwsException("Username : '" + username + "' does not match password");
    }
    final CommonProfile profile = new CommonProfile();
    profile.setId(username);
    profile.addAttribute(Pac4jConstants.USERNAME, username);
    credentials.setUserProfile(profile);
}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Override
public CompletableFuture<Boolean> matches(AsyncWebContext context, String matcherNames, Map<String, AsyncMatcher> matchersMap) {

    // if we have a matcher name (which may be a list of matchers names)
    if (CommonHelper.isNotBlank(matcherNames)) {

        // we must have matchers
        CommonHelper.assertNotNull("matchersMap", matchersMap);
        final String[] names = matcherNames.split(Pac4jConstants.ELEMENT_SEPRATOR);

        final List<AsyncMatcher> matchers = Arrays.stream(names)
                .map(n -> matchersMap.entrySet().stream()
                        .filter(e -> CommonHelper.areEqualsIgnoreCaseAndTrim(e.getKey(), n))
                        .peek(e -> CommonHelper.assertNotNull("matchersMap['" + n + "']", e))
                        .findFirst().map(e -> e.getValue()).orElse(null))
                .collect(Collectors.toList());

        return shortCircuitedFuture(matchers.stream()
                    .map(m -> () -> m.matches(context)), false);
    }

    return CompletableFuture.completedFuture(true);
}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
public DefaultAsyncLogoutLogic(final AsyncConfig<R, U, WC> config,
                               final HttpActionAdapter<R, WC> httpActionAdapter,
                               final String defaultUrl,
                               final String logoutUrlPattern,
                               boolean localLogout,
                               boolean destroySession,
                               boolean centralLogout) {

    assertNotNull("config", config);
    assertNotNull("clients", config.getClients());
    assertNotNull("httpActionAdapter", httpActionAdapter);
    this.logoutUrlPattern = Optional.ofNullable(logoutUrlPattern).orElse(DEFAULT_LOGOUT_URL_PATTERN_VALUE);
    assertNotBlank(Pac4jConstants.LOGOUT_URL_PATTERN, this.logoutUrlPattern);

    this.config = config;
    this.httpActionAdapter = httpActionAdapter;
    this.defaultUrl = defaultUrl;
    sessionDestructionStrategy = getSessionDestructionStrategy(destroySession);
    this.localLogoutStrategy = getLocalLogoutStrategy(localLogout);
    this.centralLogoutStrategy = getCentralLogoutStrategy(centralLogout);

}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Override
public CompletableFuture<R> perform(WC context) {
    assertNotNull("context", context);

    // compute redirection URL
    final String url = context.getRequestParameter(Pac4jConstants.URL);
    final String redirectUrl = (url != null && Pattern.matches(logoutUrlPattern, url)) ? url : defaultUrl;

    logger.debug("redirectUrl: {}", redirectUrl);

    final AsyncProfileManager manager = getProfileManager(context, config);

    final CompletableFuture<List<? extends U>> loggedOutProfilesFuture = localLogoutStrategy.logout(manager, sessionDestructionStrategy, context);

    return loggedOutProfilesFuture.thenApply(profiles -> centralLogoutStrategy.getCentralLogoutAction(config.getClients(),
            profiles,
            redirectUrl,
            context))
            .thenApply(o -> o.map(s -> s.get())
                    .orElseGet(() -> redirectUrl == null ? ok("ok", context) : redirect("redirect", context, redirectUrl)))
            .thenApply(action -> httpActionAdapter.adapt(action.getCode(), context));

}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Test
public void testCallback(final TestContext testContext) throws Exception {
    final TestProfile expectedProfile = TestProfile.from(TEST_CREDENTIALS);
    when(webContext.getRequestParameter(Clients.DEFAULT_CLIENT_NAME_PARAMETER)).thenReturn(NAME);
    final Clients<AsyncClient<? extends Credentials, ? extends TestProfile>, AsyncAuthorizationGenerator<TestProfile>> clients = clientsWithOneIndirectClient();
    when(config.getClients()).thenReturn(clients);
    asyncCallbackLogic = new DefaultAsyncCallbackLogic<>(false, false, config, httpActionAdapter);
    final Async async = testContext.async();
    final CompletableFuture<Object> future = asyncCallbackLogic.perform(webContext, null);
    final CompletableFuture<Map<String, TestProfile>> profilesFuture = future.thenAccept(o -> {
        assertThat(o, is(nullValue()));
        assertThat(status.get(), is(302));
        assertThat(responseHeaders.get(LOCATION_HEADER), is(Pac4jConstants.DEFAULT_URL_VALUE));
        verify(sessionStore, never()).renewSession(any(AsyncWebContext.class));
    }).thenCompose((Void v) ->  webContext.getSessionStore().get(webContext, Pac4jConstants.USER_PROFILES));

    assertSuccessfulEvaluation(profilesFuture, profiles -> {
        assertThat(profiles.containsValue(expectedProfile), is(true));
        assertThat(profiles.size(), is(1));
    }, async);

}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
private CompletableFuture<Void> assertSuccessfulLoginWithProfiles(final CompletableFuture<Object> future,
                                                                  final Async async,
                                                                  final TestProfile ... expectedProfiles) {
    return assertSuccessfulEvaluation(future, ExceptionSoftener.softenConsumer(o -> {
        assertThat(o, is(nullValue()));
        assertThat(status.get(), is(-1));

        verify(accessGrantedAdapter, times(1)).adapt(webContext);
        final LinkedHashMap<String, TestProfile> profiles = (LinkedHashMap<String, TestProfile>) webContext.getRequestAttribute(Pac4jConstants.USER_PROFILES);
        assertThat(profiles.size(), is(profiles.size()));
        Arrays.stream(expectedProfiles).forEach(profile -> {
            assertThat(profiles.values(), hasItem(profile));
        });

    }), async);

}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Test(timeout = 2000)
public void indirectClientAvailable(final TestContext testContext) {

    final Map<String, String> responseHeaders = new HashMap<>();
    final AsyncWebContext context = MockAsyncWebContextBuilder.from(rule.vertx(), asynchronousComputationAdapter)
            .withRecordedResponseHeaders(responseHeaders)
            .build();
    final List<AsyncClient<? extends Credentials, CommonProfile>> clients = Arrays.asList(getIndirectClient());
    final Async async = testContext.async();
    authInitiator.initiateIndirectFlow(context, clients)
            .whenComplete((a, t) -> {
                assertThat(t, is(nullValue()));
                assertThat(a, is(notNullValue()));
                assertThat(a.getCode(), is(HttpConstants.TEMP_REDIRECT));
                assertThat(responseHeaders.get(HttpConstants.LOCATION_HEADER), is(AUTH_REDIRECT_URL));
            })
            // Now validate session is as we expect
            .thenCompose(v -> context.getSessionStore().get(context, Pac4jConstants.REQUESTED_URL))
            .whenComplete((v, t) -> {
                assertThat(t, is(nullValue()));
                assertThat(v, is(MockAsyncWebContextBuilder.DEFAULT_FULL_REQUEST_URL));
                async.complete();
            });

}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Test
public void testCentralLogout(final TestContext testContext) {
    final Map<String, TestProfile> profiles = new HashMap<>();
    final TestProfile profile = TestProfile.from(TEST_CREDENTIALS);
    profile.setClientName(NAME);
    profiles.put(NAME, profile);
    final AsyncClient<TestCredentials, TestProfile> client = indirectClient(NAME, CALLBACK_URL,
            targetUrl -> RedirectAction.redirect(CALLBACK_URL + "?p=" + targetUrl));

    final Clients<AsyncClient<? extends Credentials, ? extends TestProfile>, AsyncAuthorizationGenerator<TestProfile>> clients = new Clients<>(client);
    when(config.getClients()).thenReturn(clients);
    asyncLogoutLogic = new DefaultAsyncLogoutLogic<>(config, httpActionAdapter, null, ".*", true, false, true);
    when(webContext.getRequestParameter(eq(Pac4jConstants.URL))).thenReturn(CALLBACK_URL);
    final Async async = testContext.async();
    final CompletableFuture<Object> resultFuture = addProfilesToContext(profiles)
            .thenCompose(v -> asyncLogoutLogic.perform(webContext));

    assertSuccessfulEvaluation(assertProfilesCount(resultFuture, 0), o -> {
        assertThat(buffer.toString(), is(""));
        assertThat(status.get(), is(302));
        assertThat(responseHeaders.get(HttpConstants.LOCATION_HEADER), is(CALLBACK_URL + "?p=" + CALLBACK_URL));
    }, async);
}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Test
public void testCentralLogoutWithRelativeUrl(final TestContext testContext) {
    final Map<String, TestProfile> profiles = new HashMap<>();
    final TestProfile profile = TestProfile.from(TEST_CREDENTIALS);
    profile.setClientName(NAME);
    profiles.put(NAME, profile);
    final AsyncClient<TestCredentials, TestProfile> client = indirectClient(NAME, PAC4J_BASE_URL, targetUrl -> RedirectAction.redirect(CALLBACK_URL + "?p=" + targetUrl));

    final Clients<AsyncClient<? extends Credentials, ? extends TestProfile>, AsyncAuthorizationGenerator<TestProfile>> clients = new Clients<>(client);
    when(config.getClients()).thenReturn(clients);
    asyncLogoutLogic = new DefaultAsyncLogoutLogic<>(config, httpActionAdapter, null, ".*", true, false, true);
    when(webContext.getRequestParameter(eq(Pac4jConstants.URL))).thenReturn(PATH);
    final Async async = testContext.async();
    final CompletableFuture<Object> resultFuture = addProfilesToContext(profiles)
            .thenCompose(v -> asyncLogoutLogic.perform(webContext));

    assertSuccessfulEvaluation(assertProfilesCount(resultFuture, 0), o -> {
        assertThat(buffer.toString(), is(""));
        assertThat(status.get(), is(302));
        assertThat(responseHeaders.get(HttpConstants.LOCATION_HEADER), is(CALLBACK_URL + "?p=null"));
    }, async);

}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Test
public void testLogoutWithGoodUrl(final TestContext testContext) {
    final Map<String, TestProfile> profiles = new HashMap<>();
    profiles.put(NAME, TestProfile.from(TEST_CREDENTIALS));
    final Clients<AsyncClient<? extends Credentials, ? extends TestProfile>, AsyncAuthorizationGenerator<TestProfile>> clients = new Clients<>();
    when(config.getClients()).thenReturn(clients);
    when(webContext.getRequestParameter(eq(Pac4jConstants.URL))).thenReturn(PATH);

    final Async async = testContext.async();
    asyncLogoutLogic = new DefaultAsyncLogoutLogic<>(config, httpActionAdapter, CALLBACK_URL, null, true, false, false);
    final CompletableFuture<Object> resultFuture = addProfilesToContext(profiles)
            .thenCompose(v -> asyncLogoutLogic.perform(webContext));

    assertSuccessfulEvaluation(assertProfilesCount(resultFuture, 0), o -> {
        assertThat(buffer.toString(), is(""));
        assertThat(status.get(), is(302));
        assertThat(responseHeaders.get(HttpConstants.LOCATION_HEADER), is(PATH));
    }, async);
}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Test
public void testLogoutWithBadUrlNoDefaultUrl(final TestContext testContext) {
    final Map<String, TestProfile> profiles = new HashMap<>();
    profiles.put(NAME, TestProfile.from(TEST_CREDENTIALS));
    final Clients<AsyncClient<? extends Credentials, ? extends TestProfile>, AsyncAuthorizationGenerator<TestProfile>> clients = new Clients<>();
    when(config.getClients()).thenReturn(clients);
    when(webContext.getRequestParameter(eq(Pac4jConstants.URL))).thenReturn(PATH);

    final Async async = testContext.async();
    asyncLogoutLogic = new DefaultAsyncLogoutLogic<>(config, httpActionAdapter, null, VALUE, true, false, false);
    final CompletableFuture<Object> resultFuture = addProfilesToContext(profiles)
            .thenCompose(v -> asyncLogoutLogic.perform(webContext));

    assertSuccessfulEvaluation(assertProfilesCount(resultFuture, 0), o -> {
        assertThat(buffer.toString(), is(""));
        assertThat(status.get(), is(200));
    }, async);

}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Test
public void testLogoutWithBadUrlButDefaultUrl(final TestContext testContext) {
    final Map<String, TestProfile> profiles = new HashMap<>();
    profiles.put(NAME, TestProfile.from(TEST_CREDENTIALS));
    final Clients<AsyncClient<? extends Credentials, ? extends TestProfile>, AsyncAuthorizationGenerator<TestProfile>> clients = new Clients<>();
    when(config.getClients()).thenReturn(clients);
    when(webContext.getRequestParameter(eq(Pac4jConstants.URL))).thenReturn(PATH);

    final Async async = testContext.async();
    asyncLogoutLogic = new DefaultAsyncLogoutLogic<>(config, httpActionAdapter, CALLBACK_URL, VALUE, true, false, false);
    final CompletableFuture<Object> resultFuture = addProfilesToContext(profiles)
            .thenCompose(v -> asyncLogoutLogic.perform(webContext));

    assertSuccessfulEvaluation(assertProfilesCount(resultFuture, 0), o -> {
        assertThat(buffer.toString(), is(""));
        assertThat(status.get(), is(302));
        assertThat(responseHeaders.get(HttpConstants.LOCATION_HEADER), is(CALLBACK_URL));
    }, async);

}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
/**
 * Retrieve the map of profiles from the session or the request.
 *
 * @param readFromSession if the user profiles must be read from session
 * @return the map of profiles
 */
protected LinkedHashMap<String, U> retrieveAll(final boolean readFromSession) {
    final LinkedHashMap<String, U> profiles = new LinkedHashMap<>();
    final Object request = this.context.getRequestAttribute(Pac4jConstants.USER_PROFILES);
    if (request != null) {
        if  (request instanceof LinkedHashMap) {
            profiles.putAll((LinkedHashMap<String, U>) request);
        }
        if (request instanceof CommonProfile) {
            profiles.put(retrieveClientName((U) request), (U) request);
        }
    }
    if (readFromSession) {
        final Object sessionAttribute = this.context.getSessionAttribute(Pac4jConstants.USER_PROFILES);
        if  (sessionAttribute instanceof LinkedHashMap) {
            profiles.putAll((LinkedHashMap<String, U>) sessionAttribute);
        }
        if (sessionAttribute instanceof CommonProfile) {
            profiles.put(retrieveClientName((U) sessionAttribute), (U) sessionAttribute);
        }
    }
    return profiles;
}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
/**
 * Save the given user profile (replace the current one if multi profiles are not supported, add it otherwise).
 *
 * @param saveInSession if the user profile must be saved in session
 * @param profile a given user profile
 * @param multiProfile whether multiple profiles are supported
 */
public void save(final boolean saveInSession, final U profile, final boolean multiProfile) {
    final LinkedHashMap<String, U> profiles;

    final String clientName = retrieveClientName(profile);
    if (multiProfile) {
        profiles = retrieveAll(saveInSession);
        profiles.remove(clientName);
    } else {
        profiles = new LinkedHashMap<>();
    }
    profiles.put(clientName, profile);

    if (saveInSession) {
        this.context.setSessionAttribute(Pac4jConstants.USER_PROFILES, profiles);
    }
    this.context.setRequestAttribute(Pac4jConstants.USER_PROFILES, profiles);
}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Override
public boolean isAuthorized(final WebContext context, final List<CommonProfile> profiles) throws HttpAction {
    CommonHelper.assertNotNull("csrfTokenGenerator", csrfTokenGenerator);
    final String token = csrfTokenGenerator.get(context);
    context.setRequestAttribute(Pac4jConstants.CSRF_TOKEN, token);
    final Cookie cookie = new Cookie(Pac4jConstants.CSRF_TOKEN, token);
    if (domain != null) {
        cookie.setDomain(domain);
    } else {
        cookie.setDomain(context.getServerName());
    }
    if (path != null) {
        cookie.setPath(path);
    }
    if (httpOnly != null) {
        cookie.setHttpOnly(httpOnly.booleanValue());
    }
    if (secure != null) {
        cookie.setSecure(secure.booleanValue());
    }
    context.addResponseCookie(cookie);
    return true;
}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Test
public void testDoubleDirectClient() throws Exception {
    final CommonProfile profile = new CommonProfile();
    profile.setId(NAME);
    final CommonProfile profile2 = new CommonProfile();
    profile2.setId(VALUE);
    final DirectClient directClient = new MockDirectClient(NAME, new MockCredentials(), profile);
    final DirectClient directClient2 = new MockDirectClient(VALUE, new MockCredentials(), profile2);
    config.setClients(new Clients(CALLBACK_URL, directClient, directClient2));
    clients = NAME + "," + VALUE;
    call();
    assertEquals(-1, context.getResponseStatus());
    assertEquals(1, nbCall);
    final LinkedHashMap<String, CommonProfile> profiles = (LinkedHashMap<String, CommonProfile>) context.getRequestAttribute(Pac4jConstants.USER_PROFILES);
    assertEquals(1, profiles.size());
    assertTrue(profiles.containsValue(profile));
}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Test
public void testDoubleDirectClientSupportingMultiProfile() throws Exception {
    final CommonProfile profile = new CommonProfile();
    profile.setId(NAME);
    final CommonProfile profile2 = new CommonProfile();
    profile2.setId(VALUE);
    final DirectClient directClient = new MockDirectClient(NAME, new MockCredentials(), profile);
    final DirectClient directClient2 = new MockDirectClient(VALUE, new MockCredentials(), profile2);
    config.setClients(new Clients(CALLBACK_URL, directClient, directClient2));
    clients = NAME + "," + VALUE;
    multiProfile = true;
    call();
    assertEquals(-1, context.getResponseStatus());
    assertEquals(1, nbCall);
    final LinkedHashMap<String, CommonProfile> profiles = (LinkedHashMap<String, CommonProfile>) context.getRequestAttribute(Pac4jConstants.USER_PROFILES);
    assertEquals(2, profiles.size());
    assertTrue(profiles.containsValue(profile));
    assertTrue(profiles.containsValue(profile2));
}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Test
public void testDoubleDirectClientChooseDirectClient() throws Exception {
    final CommonProfile profile = new CommonProfile();
    profile.setId(NAME);
    final CommonProfile profile2 = new CommonProfile();
    profile2.setId(VALUE);
    final DirectClient directClient = new MockDirectClient(NAME, new MockCredentials(), profile);
    final DirectClient directClient2 = new MockDirectClient(VALUE, new MockCredentials(), profile2);
    config.setClients(new Clients(CALLBACK_URL, directClient, directClient2));
    clients = NAME + "," + VALUE;
    context.addRequestParameter(Clients.DEFAULT_CLIENT_NAME_PARAMETER, VALUE);
    multiProfile = true;
    call();
    assertEquals(-1, context.getResponseStatus());
    assertEquals(1, nbCall);
    final LinkedHashMap<String, CommonProfile> profiles = (LinkedHashMap<String, CommonProfile>) context.getRequestAttribute(Pac4jConstants.USER_PROFILES);
    assertEquals(1, profiles.size());
    assertTrue(profiles.containsValue(profile2));
}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Test
public void testCallback() throws Exception {
    final String originalSessionId = request.getSession().getId();
    request.setParameter(Clients.DEFAULT_CLIENT_NAME_PARAMETER, NAME);
    final CommonProfile profile = new CommonProfile();
    final IndirectClient indirectClient = new MockIndirectClient(NAME, null, new MockCredentials(), profile);
    config.setClients(new Clients(CALLBACK_URL, indirectClient));
    call();
    final HttpSession session = request.getSession();
    final String newSessionId = session.getId();
    final LinkedHashMap<String, CommonProfile> profiles = (LinkedHashMap<String, CommonProfile>) session.getAttribute(Pac4jConstants.USER_PROFILES);
    assertTrue(profiles.containsValue(profile));
    assertEquals(1, profiles.size());
    assertNotEquals(newSessionId, originalSessionId);
    assertEquals(302, response.getStatus());
    assertEquals(Pac4jConstants.DEFAULT_URL_VALUE, response.getRedirectedUrl());
}
 

import org.pac4j.core.context.Pac4jConstants; //导入依赖的package包/类
@Test
public void testCallbackWithOriginallyRequestedUrl() throws Exception {
    HttpSession session = request.getSession();
    final String originalSessionId = session.getId();
    session.setAttribute(Pac4jConstants.REQUESTED_URL, PAC4J_URL);
    request.setParameter(Clients.DEFAULT_CLIENT_NAME_PARAMETER, NAME);
    final CommonProfile profile = new CommonProfile();
    final IndirectClient indirectClient = new MockIndirectClient(NAME, null, new MockCredentials(), profile);
    config.setClients(new Clients(CALLBACK_URL, indirectClient));
    call();
    session = request.getSession();
    final String newSessionId = session.getId();
    final LinkedHashMap<String, CommonProfile> profiles = (LinkedHashMap<String, CommonProfile>) session.getAttribute(Pac4jConstants.USER_PROFILES);
    assertTrue(profiles.containsValue(profile));
    assertEquals(1, profiles.size());
    assertNotEquals(newSessionId, originalSessionId);
    assertEquals(302, response.getStatus());
    assertEquals(PAC4J_URL, response.getRedirectedUrl());
}