import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance)
		throws InterceptionException {
	if (this.session.isLogged()) {
		Permissioned ann = method.getMethod().getAnnotation(Permissioned.class);
		if (ann.value().getLevel() > session.getAccessLevel()) {
			if (ann.permissions().length <= 0) {
				this.unauthorized();
			} else {
				for (Class<? extends Permission> perm : ann.permissions()) {
					if (session.getPermissions().contains(perm.getCanonicalName())) {
						stack.next(method, controllerInstance);
						return;
					}
				}
				this.unauthorized();
			}
		} else {
			stack.next(method, controllerInstance);
		}
	} else {
		this.unauthorized();
	}
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void intercept(InterceptorStack stack, ControllerMethod method,
		Object obj) throws InterceptionException {
	ClassController<KarmaCalculator> mirrorOnKarma = new Mirror().on(KarmaCalculator.class);
	List<Field> karmaCalculatorFields = mirrorOnKarma.reflectAll().fields();
		
	for (Field field : karmaCalculatorFields) {
		result.include(field.getName(), mirrorOnKarma.get().field(field));
	}
	
	PermissionRules[] rules = PermissionRules.values();
	for (PermissionRules rule : rules) {
		long karma = environmentKarma.get(rule);
		result.include(rule.name(), karma);
	}

	stack.next(method, obj);
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@BeforeCall
public void intercept() throws InterceptionException {
	
	String origin = request.getHeader("origin") != null ? request.getHeader("origin") : "*";
	
	response.addHeader("Access-Control-Allow-Origin", origin);
	response.addHeader("Access-Control-Allow-Credentials", "true");
	response.addHeader("Access-Control-Expose-Headers", "Content-Type, Location");
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void intercept(InterceptorStack stack, ResourceMethod method, Object resourceInstance) throws InterceptionException {
	sessionManager.refreshSession(userSession);
	request.setAttribute("userSession", userSession);
	request.setAttribute("roleManager", userSession.getRoleManager());
	stack.next(method, resourceInstance);
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void intercept(InterceptorStack stack, ResourceMethod method, Object resourceInstance) throws InterceptionException {
	RoleManager roleManager = userSession.getRoleManager();

	if (!roleManager.isAdministrator() && !roleManager.isModerator() && !roleManager.getCanEditPosts()) {
		int postId = Integer.parseInt(request.getParameter("postId"));

		Post post = this.postRepository.get(postId);
		Forum forum = post.getForum();

		long time = this.repository.getLimitedTime(forum);

		if (time > 0) {
			long duration = (System.currentTimeMillis() - post.getDate().getTime()) / 1000;

			if (duration > time) {
				// TODO: Decide to where redirect the user
				throw new RuntimeException("duration > time");
			}
		}

		if (roleManager.getPostOnlyWithModeratorOnline() && !sessionManager.isModeratorOnline()) {
			// TODO
			throw new RuntimeException("Posting is only allowed when moderators are online");
		}
	}

	stack.next(method, resourceInstance);
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
public void intercept(InterceptorStack stack, ControllerMethod method,
		Object resourceInstance) throws InterceptionException {
	LOG.debug("request for: " + req.getRequestURI());
	viewObjects.include();
	
	stack.next(method, resourceInstance);
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void intercept(InterceptorStack stack, ControllerMethod method,
		Object instance) throws InterceptionException {
	try {
		stack.next(method, instance);
	}catch (Exception e) {
		
		StringWriter sw = new StringWriter();
		PrintWriter pw = new PrintWriter(sw);
		
		Throwable cause = e.getCause();
		if(cause != null){
			if (cause instanceof ConstraintViolationException) {
				Set<ConstraintViolation<?>> constraintViolations = ((ConstraintViolationException) cause).getConstraintViolations();
				pw.printf("\nConstraint Violations: \n");
				for (ConstraintViolation<?> constraintViolation : constraintViolations) {
					pw.printf("\t" +constraintViolation.getConstraintDescriptor().getAnnotation()+"\n");
				}
				pw.printf("\n");
				log.error(sw.toString());
			}
			cause.printStackTrace(pw);
		}else{
			e.printStackTrace(pw);
		}
		
		pw.close();
		result.include("stacktrace", sw.toString());
		throw e;
	}
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void intercept(InterceptorStack stack, ControllerMethod method,
		Object obj) throws InterceptionException {
	try {
		locals.reset().put(Result.class, result).put(MessageFactory.class, factory);
		stack.next(method, obj);
	} finally {
		locals.clear();
	}
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void intercept(InterceptorStack interceptorStack, ControllerMethod controllerMethod, Object o) throws InterceptionException {
	List<BlockedIp> ips = blockedIps.list();
	Collection<IpMatcher> matchers = Collections2.transform(ips, extractIp);
	boolean isBlocked = matches(matchers);
	if (isBlocked) {
		result.use(http()).sendError(503);
		return;
	}
	interceptorStack.next(controllerMethod, o);
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void intercept(InterceptorStack stack, 
		ResourceMethod method, Object resourceInstance) throws InterceptionException {

	result.include("errors", Arrays.asList(new ValidationMessage("Usuário não está logado", "Login")));
	result.redirectTo(LoginController.class).login();
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance)
	throws InterceptionException {
	try {
		stack.next(method, controllerInstance);
	} catch (InterceptionException e) {
		if (!(e.getCause() instanceof Exception) || !replay((Exception) e.getCause())) {
			throw e;
		}
	}
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
private Object invokeMethod(Object interceptor, Method stepMethod, Object... params) {
	try {
		return reflectionProvider.invoke(interceptor, stepMethod, params);
	} catch (Exception e) {
		// we dont wanna wrap it if it is a simple controller business logic
		// exception
		propagateIfInstanceOf(e.getCause(), ApplicationLogicException.class);
		throw new InterceptionException(e.getCause());
	}
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance)
		throws InterceptionException {
	Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS);
	
	if (parameters != null) {
		parameters = new HashMap<>(parameters);
		
		session.removeAttribute(FLASH_INCLUDED_PARAMETERS);
		for (Entry<String, Object> parameter : parameters.entrySet()) {
			result.include(parameter.getKey(), parameter.getValue());
		}
	}
	response.addRedirectListener(new RedirectListener() {
		@Override
		public void beforeRedirect() {
			Map<String, Object> included = result.included();
			if (!included.isEmpty()) {
				try {
					session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included));
				} catch (IllegalStateException e) {
					LOGGER.warn("HTTP Session was invalidated. It is not possible to include " +
							"Result parameters on Flash Scope", e);
				}
			}
		}
	});
	stack.next(method, controllerInstance);

}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void validate(Class<?> originalType, List<Method> methods) {
	Method accepts = invoker.findMethod(methods, Accepts.class, originalType);

	if (accepts != null && !isBooleanReturn(accepts.getReturnType())) {
		throw new InterceptionException(format("@%s method must return boolean", 
				Accepts.class.getSimpleName()));
	}
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void validate(Class<?> originalType, List<Method> methods) {

	boolean hasAfterMethod = hasAnnotatedMethod(AfterCall.class, originalType, methods);
	boolean hasAroundMethod = hasAnnotatedMethod(AroundCall.class, originalType, methods);
	boolean hasBeforeMethod = hasAnnotatedMethod(BeforeCall.class, originalType, methods);

	if (!hasAfterMethod && !hasAroundMethod && !hasBeforeMethod) {
		throw new InterceptionException(format("Interceptor %s must "
			+ "declare at least one method whith @AfterCall, @AroundCall "
			+ "or @BeforeCall annotation", originalType.getCanonicalName()));
	}
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void couldntFind(FilterChain chain, MutableRequest request, MutableResponse response) {
	event.fire(new ControllerNotFound());
	try {
		chain.doFilter(request, response);
	} catch (IOException | ServletException e) {
		throw new InterceptionException(e);
	}
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) {
	response.addHeader("Allow", Joiner.on(", ").join(allowedMethods));
	try {
		if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) {
			response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
		}
	} catch (IOException e) {
		throw new InterceptionException(e);
	}
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void next(ControllerMethod method, Object controllerInstance) throws InterceptionException {
	Iterator<InterceptorHandler> iterator = internalStack.peek();

	if (!iterator.hasNext()) {
		interceptorsExecutedEvent.fire(new InterceptorsExecuted(controllerMethod.get(), controllerInstance));
		logger.debug("All registered interceptors have been called. End of VRaptor Request Execution.");
		return;
	}
	InterceptorHandler handler = iterator.next();
	handler.execute(this, method, controllerInstance);

}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Override
public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance)
		throws InterceptionException {
	final Interceptor interceptor = (Interceptor) container.instanceFor(type);
	if (interceptor == null) {
		throw new InterceptionException("Unable to instantiate interceptor for " + type.getName()
				+ ": the container returned null.");
	}
	if (interceptor.accepts(method)) {
		logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName());
		executeSafely(stack, method, controllerInstance, interceptor);
	} else {
		stack.next(method, controllerInstance);
	}
}
 

import br.com.caelum.vraptor.InterceptionException; //导入依赖的package包/类
@Test
public void shouldVerifyIfAcceptsMethodReturnsVoid() {
	exception.expect(InterceptionException.class);
	exception.expectMessage("@Accepts method must return boolean");

	Class<VoidAcceptsInterceptor> type = VoidAcceptsInterceptor.class;
	List<Method> allMethods = stepInvoker.findAllMethods(type);
	validationRule.validate(type, allMethods);
}