Java AuthenticationFailureException类代码示例

import org.biokoframework.system.services.authentication.AuthenticationFailureException; //导入依赖的package包/类
@Override
public Fields executeCommand(Fields input) throws SystemException, ValidationException {
       AuthResponse authResponse = null;
	try {
		authResponse = fAuthService.authenticate(input, fRequiredRoles);
		input.putAll(authResponse.getMergeFields());
	} catch (AuthenticationFailureException exception) {
		if (fRequireValidAuthentication) {
			throw exception;
		}
	}
       Fields output = fWrappedHandler.executeCommand(input);
       if (authResponse != null && authResponse.getOverrideFields() != null) {
           output.putAll(authResponse.getOverrideFields());
       }
	return output;
}
 

import org.biokoframework.system.services.authentication.AuthenticationFailureException; //导入依赖的package包/类
@Override
public Fields httpAuthenticate(Fields input) throws AuthenticationFailureException {
	String encodedAuth = getHeader(AUTHORIZATION);
	String decodedAuth = new String(Base64.decodeBase64(encodedAuth.substring(BASIC_AUTH_START.length())));
	
	String userName = decodedAuth.replaceFirst(":.*", "");
	String password = decodedAuth.replaceFirst(".*:", "");
	
	Login login = fLoginRepository.retrieveByForeignKey(GenericFieldNames.USER_EMAIL, userName);
	if (login == null) {
		throw CommandExceptionsFactory.createInvalidLoginException();
	} else if (!login.get(GenericFieldNames.PASSWORD).equals(password)) {
		throw CommandExceptionsFactory.createInvalidLoginException();
	}
	
	return new Fields(Login.class.getSimpleName(), login);
}
 

import org.biokoframework.system.services.authentication.AuthenticationFailureException; //导入依赖的package包/类
@Override
public AuthResponse authenticate(Fields fields, List<String> requiredRoles) throws AuthenticationFailureException {
	for (IAuthenticationService anAuthService : fAuthServices) {
		if (!(anAuthService instanceof AllAuthenticationService)) {
               try {
                   AuthResponse authResponse = anAuthService.authenticate(fields, requiredRoles);
                   if (authResponse != null) {
                       return authResponse;
                   }
               } catch (AuthenticationFailureException exception) {
                   Long errorCode = exception.getErrors().get(0).get(ErrorEntity.ERROR_CODE);
                   if (FieldNames.AUTHENTICATION_REQUIRED_CODE != errorCode) {
                       throw exception;
                   }
               }
		}
	}
	
	throw CommandExceptionsFactory.createUnauthorisedAccessException();
}
 

import org.biokoframework.system.services.authentication.AuthenticationFailureException; //导入依赖的package包/类
@Test
public void testSuccessfulAuthenticationUsingToken() throws ValidationException, RepositoryException, AuthenticationFailureException {
    TestCurrentTimeService.setCalendar("2014-01-22T18:00:05Z");

    Login login = fLoginBuilder.loadDefaultExample().build(false);
    login = fLoginRepo.save(login);

    fAuthService = fInjector.getInstance(TokenAuthenticationServiceImpl.class);

    Authentication auth = fAuthBuilder.loadDefaultExample()
            .set(Authentication.LOGIN_ID, login.getId()).build(false);
    fAuthRepo.save(auth);

    Fields fields = new Fields("authToken", auth.get(Authentication.TOKEN));
    AuthResponse authResponse = fAuthService.authenticate(fields, Collections.<String>emptyList());

    assertThat(authResponse.getMergeFields(), contains(GenericFieldNames.AUTH_LOGIN_ID, login.getId()));

    DateTime authTokenExpire = ISODateTimeFormat.dateTimeNoMillis().parseDateTime((String) authResponse.getOverrideFields().get(Authentication.TOKEN_EXPIRE));
    assertThat(authTokenExpire, is(equalTo(fTimeService.getCurrentTimeAsDateTime().plus(fTokenValiditySecs * 1000))));
}
 

import org.biokoframework.system.services.authentication.AuthenticationFailureException; //导入依赖的package包/类
@Test
public void testFailedAuthenticationBecauseTokenExpired() throws ValidationException, RepositoryException, AuthenticationFailureException {
       TestCurrentTimeService.setCalendar("2014-01-24T18:00:05Z");

       Login login = fLoginBuilder.loadDefaultExample().build(false);
       login = fLoginRepo.save(login);

       fAuthService = fInjector.getInstance(TokenAuthenticationServiceImpl.class);

       Authentication auth = fAuthBuilder.loadDefaultExample()
               .set(Authentication.LOGIN_ID, login.getId())
               .build(false);
       auth = fAuthRepo.save(auth);

       Fields fields = new Fields("authToken", auth.get(Authentication.TOKEN));

       try {
           fAuthService.authenticate(fields, Collections.<String>emptyList());
           fail(AuthenticationFailureException.class + " not thrown");
       } catch (AuthenticationFailureException exception) {
           assertThat(exception.getErrors(), is(equalTo(CommandExceptionsFactory.createTokenExpiredException().getErrors())));
       }

       assertThat(fAuthRepo.retrieve(auth.getId()), is(nullValue()));
   }
 

import org.biokoframework.system.services.authentication.AuthenticationFailureException; //导入依赖的package包/类
@Test
public void testFailedBecauseRoleExpected() throws ValidationException, RepositoryException, AuthenticationFailureException {
    TestCurrentTimeService.setCalendar("2014-01-22T18:00:05Z");

    Login login = fLoginBuilder.loadDefaultExample().build(false);
    login = fLoginRepo.save(login);

    fAuthService = fInjector.getInstance(TokenAuthenticationServiceImpl.class);

    Authentication auth = fAuthBuilder.loadDefaultExample()
            .set(Authentication.LOGIN_ID, login.getId())
            .build(false);
    auth = fAuthRepo.save(auth);

    Fields fields = new Fields("authToken", auth.get(Authentication.TOKEN));

    expected.expect(AuthenticationFailureException.class);
    expected.expectMessage(containsString("\"errorCode\":113"));
    fAuthService.authenticate(fields, Collections.singletonList("aRole"));
}
 

import org.biokoframework.system.services.authentication.AuthenticationFailureException; //导入依赖的package包/类
@Test
public void simpleAuthenticationTest() throws AuthenticationFailureException, ValidationException, RepositoryException {
    Login login = fLoginBuilder.loadDefaultExample().build(false);
    login = fLoginRepo.save(login);

    SimpleAuthenticationService authenticationService = fInjector.getInstance(SimpleAuthenticationService.class);

    Fields fields = new Fields(
            Login.USER_EMAIL, login.get(Login.USER_EMAIL),
            Login.PASSWORD, login.get(Login.PASSWORD));

    AuthResponse response = authenticationService.authenticate(fields, Collections.<String>emptyList());

    assertThat(response, is(notNullValue()));
    assertThat((String) response.getMergeFields().get("authLoginId"), is(equalTo(login.getId())));
}
 

import org.biokoframework.system.services.authentication.AuthenticationFailureException; //导入依赖的package包/类
public static HashMap<Class<? extends BiokoException>, HttpError> create() {
	HashMap<Class<? extends BiokoException>, HttpError> exceptionMap = new HashMap<Class<? extends BiokoException>, HttpError>();
	exceptionMap.put(BadCommandInvocationException.class, new HttpError(400));
	exceptionMap.put(AuthenticationFailureException.class, new HttpError(401));
	exceptionMap.put(EntityNotFoundException.class, new HttpError(404));
	exceptionMap.put(CommandNotFoundException.class, new HttpError(404));
	
	exceptionMap.put(ValidationException.class, new HttpError(400));
	exceptionMap.put(CommandException.class, new HttpError(500));
	
	exceptionMap.put(EasterEggException.class, new HttpError(418));
	return exceptionMap;
}
 

import org.biokoframework.system.services.authentication.AuthenticationFailureException; //导入依赖的package包/类
public static AuthenticationFailureException createInvalidLoginException() {
	String[] message = sErrorMap.get(FieldNames.INVALID_LOGIN_CODE);
	Fields fields = new Fields(
			ErrorEntity.ERROR_CODE, FieldNames.INVALID_LOGIN_CODE,
			ErrorEntity.ERROR_MESSAGE, new StringBuilder()
				.append(message[0])
				.toString());
	
	ErrorEntity entity = new ErrorEntity();
	entity.setAll(fields);
	return new AuthenticationFailureException(entity);
}
 

import org.biokoframework.system.services.authentication.AuthenticationFailureException; //导入依赖的package包/类
public static AuthenticationFailureException createTokenNotFoundException() {
	String[] message = sErrorMap.get(FieldNames.AUTHENTICATION_REQUIRED_CODE);
	Fields fields = new Fields(
			ErrorEntity.ERROR_CODE, FieldNames.AUTHENTICATION_REQUIRED_CODE,
			ErrorEntity.ERROR_MESSAGE, new StringBuilder()
				.append(message[0])
				.toString());

	ErrorEntity entity = new ErrorEntity();
	entity.setAll(fields);
	return new AuthenticationFailureException(entity);
}
 

import org.biokoframework.system.services.authentication.AuthenticationFailureException; //导入依赖的package包/类
public static AuthenticationFailureException createUnauthorisedAccessException() {
	String[] message = sErrorMap.get(FieldNames.AUTHENTICATION_REQUIRED_CODE);
	Fields fields = new Fields(
			ErrorEntity.ERROR_CODE, FieldNames.AUTHENTICATION_REQUIRED_CODE,
			ErrorEntity.ERROR_MESSAGE, new StringBuilder()
				.append(message[0])
				.toString());
	
	ErrorEntity entity = new ErrorEntity();
	entity.setAll(fields);
	return new AuthenticationFailureException(entity);
}
 

import org.biokoframework.system.services.authentication.AuthenticationFailureException; //导入依赖的package包/类
public static AuthenticationFailureException createInsufficientPrivilegesException() {
	String[] message = sErrorMap.get(FieldNames.INSUFFICIENT_PRIVILEGES_CODE);
	Fields fields = new Fields(
			ErrorEntity.ERROR_CODE, FieldNames.INSUFFICIENT_PRIVILEGES_CODE,
			ErrorEntity.ERROR_MESSAGE, new StringBuilder()
				.append(message[0])
				.toString());
	
	ErrorEntity entity = new ErrorEntity();
	entity.setAll(fields);
	return new AuthenticationFailureException(entity);
}
 

import org.biokoframework.system.services.authentication.AuthenticationFailureException; //导入依赖的package包/类
public static AuthenticationFailureException createTokenExpiredException() {
	String[] message = sErrorMap.get(FieldNames.TOKEN_EXPIRED_CODE);
	Fields fields = new Fields(
			ErrorEntity.ERROR_CODE, FieldNames.TOKEN_EXPIRED_CODE,
			ErrorEntity.ERROR_MESSAGE, new StringBuilder()
				.append(message[0])
				.toString());
	
	ErrorEntity entity = new ErrorEntity();
	entity.setAll(fields);
	return new AuthenticationFailureException(entity);
}
 

import org.biokoframework.system.services.authentication.AuthenticationFailureException; //导入依赖的package包/类
public static AuthenticationFailureException createFacebookAuthenticationFailure(String facebookErrorType) {
	String[] message = sErrorMap.get(FieldNames.FACEBOOK_AUTH_FAILURE_CODE);
	Fields fields = new Fields(
			ErrorEntity.ERROR_CODE, FieldNames.FACEBOOK_AUTH_FAILURE_CODE,
			ErrorEntity.ERROR_MESSAGE, new StringBuilder()
				.append(message[0])
				.append(facebookErrorType).toString());
	
	ErrorEntity entity = new ErrorEntity();
	entity.setAll(fields);
	return new AuthenticationFailureException(entity);
}
 

import org.biokoframework.system.services.authentication.AuthenticationFailureException; //导入依赖的package包/类
@Override
public AuthResponse authenticate(Fields fields, List<String> requiredRoles) throws AuthenticationFailureException {
       String token = (String) fields.get(AUTH_TOKEN);
       if (token == null) {
           throw CommandExceptionsFactory.createUnauthorisedAccessException();
       }
       Authentication auth = fAuthRepo.retrieveByForeignKey(Authentication.TOKEN, token);
       if (auth == null) {
		throw CommandExceptionsFactory.createUnauthorisedAccessException();
       } else if (isExpired(auth)) {
           fAuthRepo.delete(auth.getId());
           throw CommandExceptionsFactory.createTokenExpiredException();
	} else if (!requiredRoles.isEmpty()) {
		String userRoles = auth.get(Authentication.ROLES);
		ensureRoles(requiredRoles, userRoles);
	}

       auth.set(Authentication.TOKEN_EXPIRE, renewAuthentication());
       try {
           fAuthRepo.save(auth);
       } catch (ValidationException|RepositoryException exception) {
           LOGGER.error("Unexpected error while updating authentication", exception);
           throw new AuthenticationFailureException(exception);
       }
	
	return new AuthResponse(
               new Fields(GenericFieldNames.AUTH_LOGIN_ID, auth.get(Authentication.LOGIN_ID)),
               new Fields(AUTH_TOKEN, token,
                       AUTH_TOKEN_EXPIRE, auth.get(Authentication.TOKEN_EXPIRE)));
}