if(username == null) { Result unauthorized = authenticator.onUnauthorized(ctx); return F.Promise.pure(unauthorized); } else { try {
/** * Invoked when a handler or resource is not found. * * @param request The request that no handler was found to handle. * @param message A message. */ protected F.Promise<Result> onNotFound(RequestHeader request, String message){ if (environment.isProd()) { return F.Promise.<Result>pure(Results.notFound(views.html.defaultpages.notFound.render( request.method(), request.uri()))); } else { return F.Promise.<Result>pure(Results.notFound(views.html.defaultpages.devNotFound.render( request.method(), request.uri(), Some.apply(routes.get()) ))); } }
public F.Promise<Result> onError(Http.RequestHeader request, Throwable ex) { ErrorResponse resp; if (ex.getCause() instanceof HttpException) { resp = apply(((HttpException) ex.getCause()).responseCode(), ex.getMessage(), apply$default$3(), apply$default$4()); } else if (ex.getCause() instanceof Upstream4xxResponse) { resp = apply(((Upstream4xxResponse) ex).reportAs(), ex.getMessage(), apply$default$3(), apply$default$4()); } else if (ex.getCause() instanceof Upstream5xxResponse) { resp = apply(((Upstream5xxResponse) ex).reportAs(), ex.getMessage(), apply$default$3(), apply$default$4()); } else { resp = apply(INTERNAL_SERVER_ERROR, ex.getMessage(), apply$default$3(), apply$default$4()); } return F.Promise.pure(status(resp.statusCode(), toJson(resp))); }
@Override public Promise<Result> apply(UserProfile profile) throws Throwable { if (profile != null) { logger.debug("authorizerName: {}", authorizerName); if (authorizationChecker.isAuthorized(context, profile, authorizerName, config.getAuthorizers())) { logger.debug("authenticated and authorized -> grant access"); // when called from Scala if (delegate == null) { return Promise.pure(null); } else { return delegate.call(ctx); } } else { logger.debug("forbidden"); return forbidden(context, currentClients, profile); } } else { if (startAuthentication(context, currentClients)) { logger.debug("Starting authentication"); saveRequestedUrl(context, currentClients); return Promise.promise(() -> redirectToIdentityProvider(context, currentClients)); } else { logger.debug("unauthorized"); return unauthorized(context, currentClients); } } } });
@Override public F.Promise<SimpleResult> call(Http.Context context) throws Throwable { final String authHeader = context.request().getHeader(AUTHORIZATION); if (authHeader == null) { context.response().setHeader(WWW_AUTHENTICATE, REALM); return F.Promise.pure((SimpleResult) unauthorized()); } final String auth = authHeader.substring(6); final String[] credString = org.apache.commons.codec.binary.StringUtils.newStringUtf8(Base64.decodeBase64(auth)).split(":"); if (credString.length != 2) { return F.Promise.pure((SimpleResult) unauthorized()); } final String username = credString[0]; final String password = credString[1]; return (StringUtils.equals(username, play.Play.application().configuration().getString("rest.auth.user", "")) && StringUtils.equals(password, play.Play.application().configuration().getString("rest.auth.pass", ""))) ? delegate.call(context) : F.Promise.pure((SimpleResult) unauthorized()); } }
protected <T> F.Promise<Result> withJsonBody(Class<T> klass, ToPromiseResult<T> f) { JsonNode jsonNode = request().body().asJson(); if (jsonNode == null) { return pure(badRequest("could not parse body to JSON")); } else { try { T obj = play.libs.Json.fromJson(jsonNode, klass); F.Tuple<Integer, Object> r = f.apply(obj); return pure(Results.status(r._1, toJson(r._2))); } catch (ConstraintViolationException ex) { return pure((badRequest(createJsonResponse(ex)))); } catch (RuntimeException e) { if (e.getCause() instanceof JsonProcessingException) { return pure(badRequest(handleProcessingException((JsonProcessingException) e.getCause()))); } else { throw e; } } } }
protected Promise<Result> forbidden(final PlayWebContext context, final List<Client> currentClients, final UserProfile profile) { return Promise.pure((Result) config.getHttpActionAdapter().adapt(HttpConstants.FORBIDDEN, context)); }
protected Promise<Result> unauthorized(final PlayWebContext context, final List<Client> currentClients) { return Promise.pure((Result) config.getHttpActionAdapter().adapt(HttpConstants.UNAUTHORIZED, context)); } }
public F.Promise<Result> onHandlerNotFound(Http.RequestHeader request) { ErrorResponse er = apply(NOT_FOUND, "URI not found", apply$default$3(), Some.apply(request.path())); return F.Promise.pure(notFound(toJson(er))); }
public F.Promise<Result> onBadRequest(Http.RequestHeader request, String error) { ErrorResponse er = apply(BAD_REQUEST, error, apply$default$3(), apply$default$4()); return F.Promise.pure(badRequest(toJson(er))); } }
@Inject public JPAApiProvider(JPAConfig jpaConfig, DBApi dbApi, ApplicationLifecycle lifecycle) { // dependency on db api ensures that the databases are initialised jpaApi = new DefaultJPAApi(jpaConfig); lifecycle.addStopHook(() -> { jpaApi.shutdown(); return F.Promise.pure(null); }); jpaApi.start(); }
/** * Invoked when a server error occurs. * * By default, the implementation of this method delegates to [[onProdServerError()]] when in prod mode, and * [[onDevServerError()]] in dev mode. It is recommended, if you want Play's debug info on the error page in dev * mode, that you override [[onProdServerError()]] instead of this method. * * @param request The request that triggered the server error. * @param exception The server error. */ @Override public F.Promise<Result> onServerError(RequestHeader request, Throwable exception) { try { UsefulException usefulException = throwableToUsefulException(exception); logServerError(request, usefulException); switch (environment.mode()) { case PROD: return onProdServerError(request, usefulException); default: return onDevServerError(request, usefulException); } } catch (Exception e) { Logger.error("Error while handling error", e); return F.Promise.<Result>pure(Results.internalServerError()); } }
/** * Invoked in dev mode when a server error occurs. * * @param request The request that triggered the error. * @param exception The exception. */ protected F.Promise<Result> onDevServerError(RequestHeader request, UsefulException exception) { return F.Promise.<Result>pure(Results.internalServerError(views.html.defaultpages.devError.render(playEditor, exception))); }
/** * Invoked in prod mode when a server error occurs. * * Override this rather than [[onServerError()]] if you don't want to change Play's debug output when logging errors * in dev mode. * * @param request The request that triggered the error. * @param exception The exception. */ protected F.Promise<Result> onProdServerError(RequestHeader request, UsefulException exception) { return F.Promise.<Result>pure(Results.internalServerError(views.html.defaultpages.error.render(exception))); }
/** * Invoked when a client makes a request that was forbidden. * * @param request The forbidden request. * @param message The error message. */ protected F.Promise<Result> onForbidden(RequestHeader request, String message) { return F.Promise.<Result>pure(Results.forbidden(views.html.defaultpages.unauthorized.render())); }
/** * Invoked when a client error occurs, that is, an error in the 4xx series, which is not handled * by any of the other methods in this class already. * * @param request The request that caused the client error. * @param statusCode The error status code. Must be greater or equal to 400, and less than 500. * @param message The error message. */ protected F.Promise<Result> onOtherClientError(RequestHeader request, int statusCode, String message) { return F.Promise.<Result>pure(Results.status(statusCode, views.html.defaultpages.badRequest.render( request.method(), request.uri(), message ))); }
/** * Invoked when a client makes a bad request. * * @param request The request that was bad. * @param message The error message. */ protected F.Promise<Result> onBadRequest(RequestHeader request, String message) { return F.Promise.<Result>pure(Results.badRequest(views.html.defaultpages.badRequest.render( request.method(), request.uri(), message ))); }