Java ApprovalStatus类代码示例

import org.springframework.security.oauth2.provider.approval.Approval.ApprovalStatus; //导入依赖的package包/类
@Test
public void testAddApprovals() {
	assertThatThrownBy(() -> {
		approvalStore.addApprovals(null);
	}).isInstanceOf(NullPointerException.class);
	when(approvalRepository.findByUserUsernameAndClientIdAndScope(anyString(), anyString(), eq("read")))
			.thenReturn(new UserOAuth2ClientApprovalEntity()
					.setUser(new UserEntity().setId("1"))
					.setClient(new OAuth2ClientEntity().setId("2"))
					.setScope("read")
					.setApprovalStatus(ApprovalStatus.APPROVED));
	approvalStore.addApprovals(Arrays.asList(new Approval("1", "2", "read", new Date(), ApprovalStatus.APPROVED)));
	verify(approvalRepository).findByUserUsernameAndClientIdAndScope(anyString(), anyString(), eq("read"));
	when(approvalRepository.findByUserUsernameAndClientIdAndScope(anyString(), anyString(), eq("write")))
			.thenReturn(null);
	approvalStore.addApprovals(Arrays.asList(new Approval("1", "2", "write", new Date(), ApprovalStatus.APPROVED)));
	verify(approvalRepository).findByUserUsernameAndClientIdAndScope(anyString(), anyString(), eq("write"));
	verify(approvalRepository, times(2)).save(any(UserOAuth2ClientApprovalEntity.class));
}
 

import org.springframework.security.oauth2.provider.approval.Approval.ApprovalStatus; //导入依赖的package包/类
@Test
public void testRevokeApprovals() {
	assertThatThrownBy(() -> {
		approvalStore.revokeApprovals(null);
	}).isInstanceOf(NullPointerException.class);
	when(approvalRepository.findByUserUsernameAndClientIdAndScope(anyString(), anyString(), eq("read")))
			.thenReturn(new UserOAuth2ClientApprovalEntity()
					.setUser(new UserEntity().setId("1"))
					.setClient(new OAuth2ClientEntity().setId("2"))
					.setScope("read")
					.setApprovalStatus(ApprovalStatus.APPROVED));
	when(approvalRepository.findByUserUsernameAndClientIdAndScope(anyString(), anyString(), eq("write"))).thenReturn(null);
	List<Approval> approvals = new ArrayList<>();
	approvals.add(new Approval("", "", "write", new Date(), ApprovalStatus.APPROVED));
	for (int i = 0; i < 3; i++) {
		approvals.add(new Approval("", "", "read", new Date(), ApprovalStatus.APPROVED));
	}
	approvalStore.revokeApprovals(approvals);
	verify(approvalRepository, times(1)).findByUserUsernameAndClientIdAndScope(anyString(), anyString(), eq("write"));
	verify(approvalRepository, times(3)).findByUserUsernameAndClientIdAndScope(anyString(), anyString(), eq("read"));
	verify(approvalRepository, times(3)).delete(any(UserOAuth2ClientApprovalEntity.class));
}
 

import org.springframework.security.oauth2.provider.approval.Approval.ApprovalStatus; //导入依赖的package包/类
@Test
@SuppressWarnings("serial")
public void testGetApprovals() {
	when(approvalRepository.findByUserUsernameAndClientId(anyString(), anyString()))
			.thenReturn(Arrays.asList(new UserOAuth2ClientApprovalEntity() {{ setCreatedDate(new Date()); }}
							.setApprovalStatus(ApprovalStatus.APPROVED)
							.setUser(new UserEntity())
							.setClient(new OAuth2ClientEntity()),
					new UserOAuth2ClientApprovalEntity() {{ setCreatedDate(new Date()); }}
							.setApprovalStatus(ApprovalStatus.DENIED)
							.setUser(new UserEntity())
							.setClient(new OAuth2ClientEntity())));
	List<Approval> approvals = new ArrayList<>(approvalStore.getApprovals("1", "2"));
	assertThat(approvals.size()).isEqualTo(2);
	assertThat(approvals.get(0).getStatus()).isEqualTo(ApprovalStatus.APPROVED);
	assertThat(approvals.get(1).getStatus()).isEqualTo(ApprovalStatus.DENIED);
	verify(approvalRepository).findByUserUsernameAndClientId(anyString(), anyString());
}
 

import org.springframework.security.oauth2.provider.approval.Approval.ApprovalStatus; //导入依赖的package包/类
@RequestMapping("/oauth/confirm_access")
public ModelAndView getAccessConfirmation(Map<String, Object> model, Principal principal) throws Exception {
	AuthorizationRequest clientAuth = (AuthorizationRequest) model.remove("authorizationRequest");
	ClientDetails client = clientDetailsService.loadClientByClientId(clientAuth.getClientId());
	model.put("auth_request", clientAuth);
	model.put("client", client);
	Map<String, String> scopes = new LinkedHashMap<String, String>();
	for (String scope : clientAuth.getScope()) {
		scopes.put(OAuth2Utils.SCOPE_PREFIX + scope, "false");
	}
	for (Approval approval : approvalStore.getApprovals(principal.getName(), client.getClientId())) {
		if (clientAuth.getScope().contains(approval.getScope())) {
			scopes.put(OAuth2Utils.SCOPE_PREFIX + approval.getScope(),
					approval.getStatus() == ApprovalStatus.APPROVED ? "true" : "false");
		}
	}
	model.put("scopes", scopes);
	return new ModelAndView("authorize", model);
}
 

import org.springframework.security.oauth2.provider.approval.Approval.ApprovalStatus; //导入依赖的package包/类
@PersistenceConstructor
public MongoApproval(final String id,
                     final String userId,
                     final String clientId,
                     final String scope,
                     final ApprovalStatus status,
                     final LocalDate expiresAt,
                     final LocalDate lastUpdatedAt) {
    this.id = id;
    this.userId = userId;
    this.clientId = clientId;
    this.scope = scope;
    this.status = status;
    this.expiresAt = expiresAt;
    this.lastUpdatedAt = lastUpdatedAt;
}
 

import org.springframework.security.oauth2.provider.approval.Approval.ApprovalStatus; //导入依赖的package包/类
/**
 * Extract the implied approvals from any tokens associated with the user and client id supplied.
 * 
 * @see org.springframework.security.oauth2.provider.approval.ApprovalStore#getApprovals(java.lang.String,
 * java.lang.String)
 */
@Override
public Collection<Approval> getApprovals(String userId, String clientId) {
	Collection<Approval> result = new HashSet<Approval>();
	Collection<OAuth2AccessToken> tokens = store.findTokensByUserName(userId);
	for (OAuth2AccessToken token : tokens) {
		OAuth2Authentication authentication = store.readAuthentication(token);
		if (authentication != null && clientId.equals(authentication.getOAuth2Request().getClientId())) {
			Date expiresAt = token.getExpiration();
			for (String scope : token.getScope()) {
				result.add(new Approval(userId, clientId, scope, expiresAt, ApprovalStatus.APPROVED));
			}
		}
	}
	return result;
}
 

import org.springframework.security.oauth2.provider.approval.Approval.ApprovalStatus; //导入依赖的package包/类
@Test
public void testRevokeByExpiry() {
	store.setHandleRevocationsAsExpiry(true);
	Approval approval1 = new Approval("user", "client", "read", 10000,
			ApprovalStatus.APPROVED);
	Approval approval2 = new Approval("user", "client", "write", 10000,
			ApprovalStatus.APPROVED);
	assertTrue(store.addApprovals(Arrays.<Approval> asList(approval1,
			approval2)));
	store.revokeApprovals(Arrays.asList(approval1));
	assertEquals(2, store.getApprovals("user", "client").size());
	assertEquals(
			new Integer(1),
			new JdbcTemplate(db)
					.queryForObject(
							"SELECT COUNT(*) from oauth_approvals where userId='user' AND expiresAt < ?",
							Integer.class,
							new Date(System.currentTimeMillis() + 1000)));
}
 

import org.springframework.security.oauth2.provider.approval.Approval.ApprovalStatus; //导入依赖的package包/类
@RequestMapping("/oauth/confirm_access")
public ModelAndView getAccessConfirmation(Map<String, Object> model, Principal principal) throws Exception {
	AuthorizationRequest clientAuth = (AuthorizationRequest) model.remove("authorizationRequest");
	ClientDetails client = clientDetailsService.loadClientByClientId(clientAuth.getClientId());
	model.put("auth_request", clientAuth);
	model.put("client", client);
	Map<String, String> scopes = new LinkedHashMap<String, String>();
	for (String scope : clientAuth.getScope()) {
		scopes.put(OAuth2Utils.SCOPE_PREFIX + scope, "false");
	}
	for (Approval approval : approvalStore.getApprovals(principal.getName(), client.getClientId())) {
		if (clientAuth.getScope().contains(approval.getScope())) {
			scopes.put(OAuth2Utils.SCOPE_PREFIX + approval.getScope(),
					approval.getStatus() == ApprovalStatus.APPROVED ? "true" : "false");
		}
	}
	model.put("scopes", scopes);
	return new ModelAndView("access_confirmation", model);
}
 

import org.springframework.security.oauth2.provider.approval.Approval.ApprovalStatus; //导入依赖的package包/类
public MongoApproval(final String id,
                     final String userId,
                     final String clientId,
                     final String scope,
                     final ApprovalStatus status,
                     final LocalDate expiresAt,
                     final LocalDate lastUpdatedAt) {
    this.id = id;
    this.userId = userId;
    this.clientId = clientId;
    this.scope = scope;
    this.status = status;
    this.expiresAt = expiresAt;
    this.lastUpdatedAt = lastUpdatedAt;
}
 

import org.springframework.security.oauth2.provider.approval.Approval.ApprovalStatus; //导入依赖的package包/类
@Test
public void testAddDifferentScopes() {
    assertTrue(addApprovals(
            Arrays.<Approval>asList(new Approval("user", "client", "read", 1000, ApprovalStatus.APPROVED),
                    new Approval("user", "client", "write", 1000, ApprovalStatus.APPROVED))));
    assertEquals(2, getApprovalStore().getApprovals("user", "client").size());
}
 

import org.springframework.security.oauth2.provider.approval.Approval.ApprovalStatus; //导入依赖的package包/类
@Test
public void testIdempotentAdd() {
    assertTrue(addApprovals(
            Arrays.<Approval>asList(new Approval("user", "client", "read", 1000, ApprovalStatus.APPROVED),
                    new Approval("user", "client", "write", 1000, ApprovalStatus.APPROVED))));
    assertTrue(addApprovals(
            Arrays.<Approval>asList(new Approval("user", "client", "read", 1000, ApprovalStatus.APPROVED),
                    new Approval("user", "client", "write", 1000, ApprovalStatus.APPROVED))));
    assertEquals(2, getApprovalStore().getApprovals("user", "client").size());
}
 

import org.springframework.security.oauth2.provider.approval.Approval.ApprovalStatus; //导入依赖的package包/类
@Test
public void testAddDifferentClients() {
    assertTrue(addApprovals(
            Arrays.<Approval>asList(new Approval("user", "client", "read", 1000, ApprovalStatus.APPROVED),
                    new Approval("user", "other", "write", 1000, ApprovalStatus.APPROVED))));
    assertEquals(1, getApprovalStore().getApprovals("user", "client").size());
    assertEquals(1, getApprovalStore().getApprovals("user", "other").size());
}
 

import org.springframework.security.oauth2.provider.approval.Approval.ApprovalStatus; //导入依赖的package包/类
@Test
public void testVanillaRevoke() {
    Approval approval1 = new Approval("user", "client", "read", 1000, ApprovalStatus.APPROVED);
    Approval approval2 = new Approval("user", "client", "write", 1000, ApprovalStatus.APPROVED);
    assertTrue(addApprovals(Arrays.<Approval>asList(approval1, approval2)));
    getApprovalStore().revokeApprovals(Arrays.asList(approval1));
    assertEquals(getExpectedNumberOfApprovalsAfterRevoke(), getApprovalStore().getApprovals("user", "client").size());
}
 

import org.springframework.security.oauth2.provider.approval.Approval.ApprovalStatus; //导入依赖的package包/类
/**
 * Requires the authorization request to be explicitly approved, including all individual scopes, and the user to be
 * authenticated. A scope that was requested in the authorization request can be approved by sending a request
 * parameter <code>scope.&lt;scopename&gt;</code> equal to "true" or "approved" (otherwise it will be assumed to
 * have been denied). The {@link ApprovalStore} will be updated to reflect the inputs.
 * 
 * @param authorizationRequest The authorization request.
 * @param userAuthentication the current user authentication
 * 
 * @return An approved request if all scopes have been approved by the current user.
 */
public AuthorizationRequest updateAfterApproval(AuthorizationRequest authorizationRequest,
		Authentication userAuthentication) {
	// Get the approved scopes
	Set<String> requestedScopes = authorizationRequest.getScope();
	Set<String> approvedScopes = new HashSet<String>();
	Set<Approval> approvals = new HashSet<Approval>();

	Date expiry = computeExpiry();

	// Store the scopes that have been approved / denied
	Map<String, String> approvalParameters = authorizationRequest.getApprovalParameters();
	for (String requestedScope : requestedScopes) {
		String approvalParameter = scopePrefix + requestedScope;
		String value = approvalParameters.get(approvalParameter);
		value = value == null ? "" : value.toLowerCase();
		if ("true".equals(value) || value.startsWith("approve")) {
			approvedScopes.add(requestedScope);
			approvals.add(new Approval(userAuthentication.getName(), authorizationRequest.getClientId(),
					requestedScope, expiry, ApprovalStatus.APPROVED));
		}
		else {
			approvals.add(new Approval(userAuthentication.getName(), authorizationRequest.getClientId(),
					requestedScope, expiry, ApprovalStatus.DENIED));
		}
	}
	approvalStore.addApprovals(approvals);

	boolean approved;
	authorizationRequest.setScope(approvedScopes);
	if (approvedScopes.isEmpty() && !requestedScopes.isEmpty()) {
		approved = false;
	}
	else {
		approved = true;
	}
	authorizationRequest.setApproved(approved);
	return authorizationRequest;
}
 

import org.springframework.security.oauth2.provider.approval.Approval.ApprovalStatus; //导入依赖的package包/类
@Override
public Approval mapRow(ResultSet rs, int rowNum) throws SQLException {
	String userName = rs.getString(4);
	String clientId = rs.getString(5);
	String scope = rs.getString(6);
	Date expiresAt = rs.getTimestamp(1);
	String status = rs.getString(2);
	Date lastUpdatedAt = rs.getTimestamp(3);

	return new Approval(userName, clientId, scope, expiresAt, ApprovalStatus.valueOf(status), lastUpdatedAt);
}