RestMethodHandler (Waarp Common 3.3.4 API Reference)

java.lang.Object
- org.waarp.gateway.kernel.rest.RestMethodHandler

Direct Known Subclasses:

DataModelRestMethodHandler, HttpRestAbstractR66Handler, RootOptionsRestMethodHandler
```
public abstract class RestMethodHandler
extends Object
```
Rest Method handler (used by Http Rest Handler)

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`isBodyJsonDecode`
`protected Set<HttpRestHandler.METHOD>`	`methods`
`protected String`	`name`
`protected String`	`path`
`protected RestConfiguration`	`restConfiguration`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`RestMethodHandler(String name, String path, boolean isBodyJsonDecode, RestConfiguration config, HttpRestHandler.METHOD... method)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`abstract void`	`checkHandlerSessionCorrectness(HttpRestHandler handler, RestArgument arguments, RestArgument result)` Check the session (arguments, result) vs handler correctness, called before any BODY elements but after URI and HEADER.
`abstract void`	`endParsingRequest(HttpRestHandler handler, RestArgument arguments, RestArgument result, Object body)` Called when all Data were passed to the handler
`abstract Object`	`getBody(HttpRestHandler handler, io.netty.buffer.ByteBuf body, RestArgument arguments, RestArgument result)` Get data from BODY (supposedly a Json)
`protected abstract com.fasterxml.jackson.databind.node.ArrayNode`	`getDetailedAllow()`
`abstract void`	`getFileUpload(HttpRestHandler handler, io.netty.handler.codec.http.multipart.FileUpload data, RestArgument arguments, RestArgument result)` Get a new Http Uploaded File from BODY
`String`	`getName()`
`String`	`getPath()`
`io.netty.handler.codec.http.HttpResponseStatus`	`handleException(HttpRestHandler handler, RestArgument arguments, RestArgument result, Object body, Exception exception)` Called when an exception occurs
`boolean`	`isBodyJsonDecoded()`
`boolean`	`isMethodIncluded(HttpRestHandler.METHOD method)`
`protected void`	`optionsCommand(HttpRestHandler handler, RestArgument arguments, RestArgument result)` Options command that all handler should implement
`protected io.netty.channel.ChannelFuture`	`sendOptionsResponse(HttpRestHandler handler, io.netty.channel.ChannelHandlerContext ctx, RestArgument result, io.netty.handler.codec.http.HttpResponseStatus status)`
`abstract io.netty.channel.ChannelFuture`	`sendResponse(HttpRestHandler handler, io.netty.channel.ChannelHandlerContext ctx, RestArgument arguments, RestArgument result, Object body, io.netty.handler.codec.http.HttpResponseStatus status)` Send a response (correct or not)
`protected void`	`setIntersectionMethods(HttpRestHandler.METHOD[] selectedMethods, HttpRestHandler.METHOD... validMethod)` Will assign the intersection of both set of Methods
`protected void`	`setMethods(HttpRestHandler.METHOD... method)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

name
```
protected final String name
```

path
```
protected final String path
```

methods

protected final Set<HttpRestHandler.METHOD> methods

isBodyJsonDecode

protected final boolean isBodyJsonDecode

restConfiguration

protected final RestConfiguration restConfiguration

Constructor Detail

RestMethodHandler

protected RestMethodHandler(String name,
                            String path,
                            boolean isBodyJsonDecode,
                            RestConfiguration config,
                            HttpRestHandler.METHOD... method)

Parameters:: name - name associated with this Method Handler (to enable some HashMap or Enum classification); path - associated base Path; isBodyJsonDecode - Is this method Handler using a Json as Body; config - the associated configuration; method - the associated methods

Method Detail

setMethods

protected void setMethods(HttpRestHandler.METHOD... method)

setIntersectionMethods

protected void setIntersectionMethods(HttpRestHandler.METHOD[] selectedMethods,
                                      HttpRestHandler.METHOD... validMethod)

Will assign the intersection of both set of Methods

Parameters:: selectedMethods - the selected Methods among available; validMethod - the validMethod for this handler

getName
```
public String getName()
```

getPath
```
public String getPath()
```

isMethodIncluded
```
public boolean isMethodIncluded(HttpRestHandler.METHOD method)
```
Parameters:

method -

Returns:

True if the Method is valid for this Handler

checkHandlerSessionCorrectness

public abstract void checkHandlerSessionCorrectness(HttpRestHandler handler,
                                                    RestArgument arguments,
                                                    RestArgument result)
                                             throws HttpForbiddenRequestException

Check the session (arguments, result) vs handler correctness, called before any BODY elements but after URI and HEADER.

Parameters:: handler -; arguments -; result -
Throws:: HttpForbiddenRequestException

getFileUpload

public abstract void getFileUpload(HttpRestHandler handler,
                                   io.netty.handler.codec.http.multipart.FileUpload data,
                                   RestArgument arguments,
                                   RestArgument result)
                            throws HttpIncorrectRequestException

Get a new Http Uploaded File from BODY

Parameters:: handler -; data -; arguments -; result -
Throws:: HttpIncorrectRequestException

getBody

public abstract Object getBody(HttpRestHandler handler,
                               io.netty.buffer.ByteBuf body,
                               RestArgument arguments,
                               RestArgument result)
                        throws HttpIncorrectRequestException

Get data from BODY (supposedly a Json)

Parameters:: handler -; body -; arguments -; result -
Returns:: the object related to BODY decoding
Throws:: HttpIncorrectRequestException

endParsingRequest

public abstract void endParsingRequest(HttpRestHandler handler,
                                       RestArgument arguments,
                                       RestArgument result,
                                       Object body)
                                throws HttpIncorrectRequestException,
                                       HttpInvalidAuthenticationException,
                                       HttpNotFoundRequestException

Called when all Data were passed to the handler

Parameters:: handler -; arguments -; result -; body -
Throws:: HttpIncorrectRequestException; HttpNotFoundRequestException; HttpInvalidAuthenticationException

handleException

public io.netty.handler.codec.http.HttpResponseStatus handleException(HttpRestHandler handler,
                                                                      RestArgument arguments,
                                                                      RestArgument result,
                                                                      Object body,
                                                                      Exception exception)

Called when an exception occurs

Parameters:: handler -; arguments -; result -; body -; exception -
Returns:: the status to used in sendReponse

sendResponse

public abstract io.netty.channel.ChannelFuture sendResponse(HttpRestHandler handler,
                                                            io.netty.channel.ChannelHandlerContext ctx,
                                                            RestArgument arguments,
                                                            RestArgument result,
                                                            Object body,
                                                            io.netty.handler.codec.http.HttpResponseStatus status)

Send a response (correct or not)

Parameters:: handler -; ctx -; arguments -; result -; body -; status -
Returns:: The ChannelFuture if this response will need the channel to be closed, else null

sendOptionsResponse

protected io.netty.channel.ChannelFuture sendOptionsResponse(HttpRestHandler handler,
                                                             io.netty.channel.ChannelHandlerContext ctx,
                                                             RestArgument result,
                                                             io.netty.handler.codec.http.HttpResponseStatus status)

optionsCommand

protected void optionsCommand(HttpRestHandler handler,
                              RestArgument arguments,
                              RestArgument result)

Options command that all handler should implement

Parameters:: handler -; arguments -; result -

getDetailedAllow

protected abstract com.fasterxml.jackson.databind.node.ArrayNode getDetailedAllow()

Returns:: the detail of the method handler

isBodyJsonDecoded
```
public boolean isBodyJsonDecoded()
```
Returns:

the isBodyJson

Class RestMethodHandler