Java Code Examples for play.mvc.Http#Context

@Override
public List<FilterExpression<ProductProjection>> buildFilterExpressions(final Http.Context httpContext) {
    final List<SpecialCategorySettings> specialCategories = categoriesSettings.specialCategories();
    if (!specialCategories.isEmpty()) {
        final Optional<Category> selectedCategory = getSelectedValue(httpContext);
        if (selectedCategory.isPresent()) {
            return specialCategories.stream()
                    .filter(config -> config.externalId().equals(selectedCategory.get().getExternalId()))
                    .findAny()
                    .map(config -> config.productFilterExpressions().stream()
                            .map(expression -> SearchUtils.replaceCategoryExternalId(expression, categoryTree))
                            .map(FilterExpression::<ProductProjection>of)
                            .collect(toList()))
                    .orElseGet(() -> CategoryTreeFacetedSearchFormSettings.super.buildFilterExpressions(httpContext));
        }
    }
    return CategoryTreeFacetedSearchFormSettings.super.buildFilterExpressions(httpContext);
}
 

@Override
public Promise<Result> beforeAuthCheck(final Http.Context context) {
	if (PlayAuthenticate.isLoggedIn(context.session())) {
		// user is logged in
		return F.Promise.pure(null);
	} else {
		// user is not logged in

		// call this if you want to redirect your visitor to the page that
		// was requested before sending him to the login page
		// if you don't call this, the user will get redirected to the page
		// defined by your resolver
		final String originalUrl = PlayAuthenticate.storeOriginalUrl(context);
		
		System.out.println("-----------------"+originalUrl);

		context.flash().put("error",
				"You need to log in first, to view '" + originalUrl + "'");
           return F.Promise.promise(new F.Function0<Result>()
           {
               @Override
               public Result apply() throws Throwable
               {
                   return redirect(PlayAuthenticate.getResolver().login());
               }
           });
	}
}
 

/**
 * Finds all selected valid options for this form in the HTTP request.
 * @param httpContext current HTTP context
 * @return a list of valid selected options for this form
 */
default List<T> getAllSelectedOptions(final Http.Context httpContext) {
    final List<String> selectedValues = getSelectedValuesAsRawList(httpContext);
    return getOptions().stream()
            .filter(option -> selectedValues.contains(option.getFieldValue()))
            .collect(toList());
}
 

public static Http.Response setRequest(String body) {
    Http.Request mockRequest = mock(Http.Request.class);
    when(mockRequest.body()).thenReturn(new Http.RequestBody(Json.parse(body)));
    Http.Response mockResponse = mock(Http.Response.class);
    doNothing().when(mockResponse).setHeader(
            any(String.class), any(String.class));
    Http.Context mockContext = mock(Http.Context.class);
    when(mockContext.request()).thenReturn(mockRequest);
    when(mockContext.response()).thenReturn(mockResponse);
    Http.Context.current.set(mockContext);
    return mockResponse;
}
 

@Override
public F.Promise<Result> onAuthFailure(final Http.Context context,
		final String content) {
	// if the user has a cookie with a valid user and the local user has
	// been deactivated/deleted in between, it is possible that this gets
	// shown. You might want to consider to sign the user out in this case.
       return F.Promise.promise(new F.Function0<Result>()
       {
           @Override
           public Result apply() throws Throwable
           {
               return forbidden("Forbidden");
           }
       });
}
 

public CompletionStage<Result> call(Http.Context ctx) {
    try {
        //TODO: Do stuff you want to handle with each API call (metrics, logging, etc..)
        return delegate.call(ctx);
    } catch (Throwable t) {
        //TODO: log the error in your metric

        //We rethrow this error so it will be caught in the ErrorHandler
        throw t;
    }
}
 

@Override
public Promise<Result> onAuthFailure(final Http.Context context, final String content) {
       if (context.session().get("username") != null && !context.session().get("username").isEmpty()) {
           return Promise.promise(() -> forbidden("Forbidden"));
       } else {
           return Promise.promise(() -> redirect(routes.Authentication.login()));
       }
}
 

@Override
public CompletionStage<Result> call(final Http.Context ctx) {
    if (LOGGER.isDebugEnabled()) {
        if (sphereClient instanceof SimpleMetricsSphereClient) {
            return callWithMetrics((SimpleMetricsSphereClient) sphereClient, ctx);
        } else {
            LOGGER.warn(ctx.request() + " enabled logging via @LogMetrics annotation without a SimpleMetricsSphereClient");
        }
    }
    return delegate.call(ctx);
}
 

public static void setRequest(String body) {
    Http.Request mockRequest = mock(Http.Request.class);
    when(mockRequest.body()).thenReturn(new Http.RequestBody(Json.parse(body)));
    Http.Response mockResponse = mock(Http.Response.class);
    doNothing().when(mockResponse).setHeader(
            any(String.class), any(String.class));
    Http.Context mockContext = mock(Http.Context.class);
    when(mockContext.request()).thenReturn(mockRequest);
    when(mockContext.response()).thenReturn(mockResponse);
    Http.Context.current.set(mockContext);
}
 

@Override
public CompletionStage<Result> call(final Http.Context ctx) {
    if (configuration.value().length > 0) {
        // On creation of this action there isn't any HTTP context, necessary to initialize the ComponentRegistry
        final ComponentRegistry componentRegistry = injector.instanceOf(ComponentRegistry.class);
        Arrays.stream(configuration.value())
                .forEach(componentClass -> registerComponent(componentRegistry, componentClass));
    }
    return delegate.call(ctx);
}
 

private static void logRequestData(final List<ObservedTotalDuration> metrics, final Http.Context ctx, final long totalDuration) {
    if (LOGGER.isTraceEnabled()) {
        logTraceRequestData(metrics);
    } else {
        logDebugRequestData(metrics, ctx, totalDuration);
    }
}
 

private T provideFromContext(final Http.Context currentContext) {
    final boolean providerTypeIsHttpContext = key.getTypeLiteral().equals(CONTEXT_TYPE_LITERAL);
    if (providerTypeIsHttpContext) {
        return castToProviderType(currentContext);
    } else {
        final Cache cache = new HttpContextCache(currentContext);
        return provideFromCache(cache);
    }
}
 

default long getLimit(final Http.Context httpContext) {
    return getSelectedOption(httpContext)
            .map(FormOption::getValue)
            .orElse(DEFAULT_LIMIT);
}
 

@Override
default RangeFacetedSearchExpression<T> buildFacetedSearchExpression(final Http.Context httpContext) {
    final RangeFacetExpression<T> facetExpression = buildFacetExpression();
    final List<FilterExpression<T>> filterExpressions = buildFilterExpressions(httpContext);
    return RangeFacetedSearchExpression.of(facetExpression, filterExpressions);
}
 

default long getOffset(final Http.Context httpContext, final long limit) {
    return (getSelectedValueOrDefault(httpContext) - 1) * limit;
}
 

/**
 * Retrieves user allowed actions
 *
 * @param ctx the current request context
 * @return a list of allowed actions
 */
public List<String> getAllowedActions(Http.Context ctx) {
    return ctx.request().attrs().get(ALLOWED_ACTIONS_TYPED_KEY);
}
 

/**
 * Retrieves the configuration of auth
 *
 * @param ctx the current request context
 * @return a list of allowed actions
 */
public Boolean isAuthRequired(Http.Context ctx) {
    return ctx.request().attrs().get(AUTH_REQUIRED_TYPED_KEY);
}
 

/**
 * Retrieves the configuration of auth
 *
 * @param ctx the current request context
 * @return a list of allowed actions
 */
public Boolean isAuthRequired(Http.Context ctx) {
    return ctx.request().attrs().get(AUTH_REQUIRED_TYPED_KEY);
}
 

/**
 * Returns the current HTTP context.
 *
 * @return Context instance
 */
protected Http.Context getContext() {
    return Http.Context.current();
}
 

FacetedSearchExpression<T> buildFacetedSearchExpression(Http.Context httpContext);