@Controller
 @Api(name="Space API",
     description="Methods for interacting with space")
public class SpaceAPIController
extends Object
| Constructor and Description | 
|---|
| SpaceAPIController() | 
@Value(value="${spaceName}")
public void setSpaceName(String spaceName)
@Value(value="${lookupGroups}")
public void setLookupGroups(String lookupGroups)
@Value(value="${lookupLocators}")
public void setLookupLocators(String lookupLocators)
@Value(value="${datetime_format}")
public void setDatetimeFormat(String datetimeFormat)
@Deprecated @RequestMapping(value="/{type}/_introduce_type", method=GET, produces="application/json") @ResponseBody public Map<String,Object> introduceType(@PathVariable String type, @RequestParam(value="spaceid",defaultValue="id") String spaceID)
introduceTypeAdvanced(String, String) insteadtype - type namepublic String getString(com.fasterxml.jackson.databind.JsonNode node)
public Boolean getBoolean(com.fasterxml.jackson.databind.JsonNode node)
@ApiMethod(path="{type}/_introduce_type",
           verb=PUT,
           description="Introduces the specified type to the space with the provided description in the body",
           consumes="application/json",
           produces="application/json")
 @RequestMapping(value="/{type}/_introduce_type",
                method=PUT,
                consumes="application/json",
                produces="application/json")
 @ResponseBody
public Map<String,Object> introduceTypeAdvanced(@PathVariable @ApiPathParam(name="type",description="The type name")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     String type,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     @RequestBody(required=false) @ApiBodyObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     String requestBody)
@ApiMethod(path="{type}/",
           verb=GET,
           description="Read multiple entries from space that matches the query.",
           produces="application/json")
 @RequestMapping(value="/{type}",
                method=GET,
                produces="application/json")
 @ResponseBody
public Map<String,Object> getByQuery(@PathVariable @ApiPathParam(name="type",description="The type name")
                                                                                                                                                                                                                                                                                                                                          String type,
                                                                                                                                                                                                                                                                                                                                          @RequestParam(value="query",required=false) @ApiQueryParam(name="query",description="a SQLQuery that is a SQL-like syntax")
                                                                                                                                                                                                                                                                                                                                          String query,
                                                                                                                                                                                                                                                                                                                                          @RequestParam(value="max",required=false) @ApiQueryParam(name="size",description="")
                                                                                                                                                                                                                                                                                                                                          Integer size)
                                                                                                                                                                                                                                                                                                                                   throws ObjectNotFoundException
ObjectNotFoundException@ApiMethod(path="{type}/{id}",
           verb=GET,
           description="Read entry from space with the provided id",
           produces="application/json")
 @RequestMapping(value="/{type}/{id}",
                method=GET,
                produces="application/json")
 @ResponseBody
public Map<String,Object> getById(@PathVariable @ApiPathParam(name="type",description="The type name")
                                                                                                                                                                                                                                                                                                                                  String type,
                                                                                                                                                                                                                                                                                                                                  @PathVariable @ApiPathParam(name="id")
                                                                                                                                                                                                                                                                                                                                  String id)
                                                                                                                                                                                                                                                                                                                           throws ObjectNotFoundException
ObjectNotFoundException@ApiMethod(path="{type}/count",
           verb=GET,
           description="Returns the number of entries in space of the specified type\n",
           produces="application/json")
 @RequestMapping(value="/{type}/count",
                method=GET,
                produces="application/json")
 @ResponseBody
public Map<String,Object> count(@ApiPathParam(name="type",description="The type name") @PathVariable
                                                                                                                                                                                                                                                                                                                                                      String type)
                                                                                                                                                                                                                                                                                                                                               throws ObjectNotFoundException
ObjectNotFoundException@ApiMethod(path="{type}/{id}",
           verb=DELETE,
           description="Gets and deletes the entry from space with the provided id.",
           produces="application/json")
 @RequestMapping(value="/{type}/{id}",
                method=DELETE,
                produces="application/json")
 @ResponseBody
public Map<String,Object> deleteById(@ApiPathParam(name="type",description="The type name") @PathVariable
                                                                                                                                                                                                                                                                                                                                                            String type,
                                                                                                                                                                                                                                                                                                                                                            @ApiPathParam(name="id") @PathVariable
                                                                                                                                                                                                                                                                                                                                                            String id)
                                                                                                                                                                                                                                                                                                                                                     throws ObjectNotFoundException
ObjectNotFoundException@ApiMethod(path="{type}/",
           verb=DELETE,
           description="Gets and deletes entries from space that matches the query.",
           produces="application/json")
 @RequestMapping(value="/{type}",
                method=DELETE,
                produces="application/json")
 @ResponseBody
public Map<String,Object> deleteByQuery(@ApiPathParam(name="type",description="The type name") @PathVariable
                                                                                                                                                                                                                                                                                                                                                      String type,
                                                                                                                                                                                                                                                                                                                                                      @ApiQueryParam(name="query") @RequestParam(value="query")
                                                                                                                                                                                                                                                                                                                                                      String query,
                                                                                                                                                                                                                                                                                                                                                      @ApiQueryParam(name="max",description="The maximum number of entries to return. Default is Integer.MAX_VALUE") @RequestParam(value="max",required=false)
                                                                                                                                                                                                                                                                                                                                                      Integer max)
@ApiMethod(path="{type}/",
           verb=POST,
           description="Write one or more entries to the space.",
           consumes="application/json",
           produces="application/json")
 @RequestMapping(value="/{type}",
                method=POST,
                consumes="application/json",
                produces="application/json")
 @ResponseBody
public Map<String,Object> post(@ApiPathParam(name="type",description="The type name") @PathVariable
                                                                                                                                                                                                                                                                                                                                                                                                          String type,
                                                                                                                                                                                                                                                                                                                                                                                                          @RequestBody(required=false) @ApiBodyObject(clazz=ErrorMessage.class)
                                                                                                                                                                                                                                                                                                                                                                                                          String requestBody)
                                                                                                                                                                                                                                                                                                                                                                                                   throws TypeNotFoundException
TypeNotFoundException@ExceptionHandler(value=TypeNotFoundException.class) @ResponseStatus(value=NOT_FOUND) @ResponseBody public ErrorResponse resolveTypeDescriptorNotFoundException(TypeNotFoundException e) throws IOException
IOException@ExceptionHandler(value=ObjectNotFoundException.class) @ResponseStatus(value=NOT_FOUND) @ResponseBody public ErrorResponse resolveDocumentNotFoundException(ObjectNotFoundException e) throws IOException
IOException@ExceptionHandler(value=org.springframework.dao.DataAccessException.class) @ResponseStatus(value=INTERNAL_SERVER_ERROR) @ResponseBody public ErrorResponse resolveDataAccessException(org.springframework.dao.DataAccessException e) throws IOException
IOException@ExceptionHandler(value=CannotFindSpaceException.class) @ResponseStatus(value=INTERNAL_SERVER_ERROR) @ResponseBody public ErrorResponse resolveCannotFindSpaceException(CannotFindSpaceException e) throws IOException
IOException@ExceptionHandler(value=TypeAlreadyRegisteredException.class) @ResponseStatus(value=INTERNAL_SERVER_ERROR) @ResponseBody public ErrorResponse resoleTypeAlreadyRegisteredException(TypeAlreadyRegisteredException e) throws IOException
IOException@ExceptionHandler(value=RestException.class) @ResponseStatus(value=INTERNAL_SERVER_ERROR) @ResponseBody public ErrorResponse resolveRestIntroduceTypeException(RestException e) throws IOException
IOException@ExceptionHandler(value=java.lang.RuntimeException.class) @ResponseStatus(value=INTERNAL_SERVER_ERROR) @ResponseBody public ErrorResponse resolveRuntimeException(RuntimeException e) throws IOException
IOException@ExceptionHandler(value=UnsupportedTypeException.class) @ResponseStatus(value=INTERNAL_SERVER_ERROR) @ResponseBody public ErrorResponse resolveUnsupportedTypeException(UnsupportedTypeException e) throws IOException
IOExceptionCopyright © GigaSpaces.