/** * Generates a 201 Created response with the specified content. * * @param uri The URI * @param entity entity * @return The response to be built */ protected ResponseBuilder generateCreatedResponse(final URI uri, final Object entity) { // generate the response builder return Response.created(uri).entity(entity); }
@Path("start") @POST public Response post(@DefaultValue("0") @QueryParam("testSources") int testSources, @Context Sse sse) { final Process process = new Process(testSources, sse); processes.put(process.getId(), process); Executors.newSingleThreadExecutor().execute(process); final URI processIdUri = UriBuilder.fromResource(DomainResource.class).path("process/{id}").build(process.getId()); return Response.created(processIdUri).build(); }
@POST @Consumes({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON}) public Response createQueue(Queue queue ) throws Exception { Preconditions.checkArgument(queue != null, "Queue configuration is required"); Preconditions.checkArgument(!QakkaUtils.isNullOrEmpty(queue.getName()), "Queue name is required"); queueManager.createQueue(queue); ApiResponse apiResponse = new ApiResponse(); apiResponse.setQueues( Collections.singletonList(queue) ); return Response.created( uriStrategy.queueURI( queue.getName() )).entity(apiResponse).build(); }
/** * Creates a new instance with the given parameters * * @param id the node id * @return Response (201) if the instance was created */ @POST public Response createInstance( @QueryParam("id") int id, @QueryParam("instanceID") String instanceID, @QueryParam("hostname") String hostname, @QueryParam("ip") String ip, @QueryParam("rack") String rack, @QueryParam("token") String token) { log.info( "Creating instance [id={}, instanceId={}, hostname={}, ip={}, rack={}, token={}", id, instanceID, hostname, ip, rack, token); PriamInstance instance = factory.create( config.getAppName(), id, instanceID, hostname, ip, rack, null, token); URI uri = UriBuilder.fromPath("/{id}").build(instance.getId()); return Response.created(uri).build(); }
@PUT @Timed @Path("/{inputId}") @ApiOperation( value = "Update input on this node", response = InputCreated.class ) @ApiResponses(value = { @ApiResponse(code = 404, message = "No such input on this node."), @ApiResponse(code = 400, message = "Missing or invalid input configuration.") }) @AuditEvent(type = AuditEventTypes.MESSAGE_INPUT_UPDATE) public Response update(@ApiParam(name = "JSON body", required = true) @Valid @NotNull InputCreateRequest lr, @ApiParam(name = "inputId", required = true) @PathParam("inputId") String inputId) throws org.graylog2.database.NotFoundException, NoSuchInputTypeException, ConfigurationException, ValidationException { checkPermission(RestPermissions.INPUTS_EDIT, inputId); final Input input = inputService.find(inputId); final Map<String, Object> mergedInput = input.getFields(); final MessageInput messageInput = messageInputFactory.create(lr, getCurrentUser().getName(), lr.node()); messageInput.checkConfiguration(); mergedInput.putAll(messageInput.asMap()); final Input newInput = inputService.create(input.getId(), mergedInput); inputService.update(newInput); final URI inputUri = getUriBuilderToSelf().path(InputsResource.class) .path("{inputId}") .build(input.getId()); return Response.created(inputUri).entity(InputCreated.create(input.getId())).build(); }
/** * Save a new resource owner. */ @PUT public Response put(@Context HttpServletRequest request, @Valid ResourceOwner newOne) { Response validateScopeResponse = validateScope(request, Collections.singletonList(AbstractResource.SCOPE_WRITE)); if (validateScopeResponse != null) { return validateScopeResponse; } ResourceOwner resourceOwnerSaved; try { //we run transactional modus, so any constraint violations only occur after the commit of the transaction (to late...) validate(newOne); resourceOwnerSaved = resourceOwnerRepository.save(newOne); } catch (Exception e) { return buildErrorResponse(e); } LOG.debug("New resourceOwner has been saved: {}. ", resourceOwnerSaved); final URI uri = UriBuilder.fromPath("{resourceServerId}.json").build(resourceOwnerSaved.getId()); return Response.created(uri).entity(resourceOwnerSaved).build(); }
@Path("start") @POST public Response post(@DefaultValue("0") @QueryParam("testSources") int testSources) { final Process process = new Process(testSources); processes.put(process.getId(), process); Executors.newSingleThreadExecutor().execute(process); final URI processIdUri = UriBuilder.fromResource(DomainResource.class).path("process/{id}").build(process.getId()); return Response.created(processIdUri).build(); }
@POST @Produces(MediaType.TEXT_PLAIN) @ApiOperation(value = "postTx: starts a new user Transaction in the current session") public Response postTx(String isolation) { TransactionManagement txMgr = getTxManager(); try { long txId = txMgr.beginTransaction(TransactionIsolation.valueOf(isolation)); return Response.created(UriBuilder.fromPath("/tx/" + txId).build()).entity(txId).build(); } catch (Exception ex) { logger.error("postTx.error", ex); throw new WebApplicationException(ex, Status.INTERNAL_SERVER_ERROR); } }
@POST @ApiOperation(value = "Adds a new session to the conference") @ApiResponses(value = { @ApiResponse(code = 201, message = "The session is created"), @ApiResponse(code = 400, message = "Invalid input")} ) public Response add(@ApiParam(value = "Session to be created", required = true) @NotNull Session session) { Session created = sessionRepository.create(session); return Response.created(getURIForSelf(session)).entity(created).build(); }
if (servlet.isReadOnly()) { return Response.status(Response.Status.FORBIDDEN) .type(MIMETYPE_TEXT).entity("Forbidden" + CRLF) .build(); URI uri = builder.path(id).build(); servlet.getMetrics().incrementSucessfulPutRequests(1); return Response.created(uri).build(); } catch (Exception e) { LOG.error("Exception occured while processing " + uriInfo.getAbsolutePath() + " : ", e); if (e instanceof TableNotFoundException) { return Response.status(Response.Status.NOT_FOUND) .type(MIMETYPE_TEXT).entity("Not found" + CRLF) .build(); } else if (e instanceof RuntimeException || e instanceof JsonMappingException | e instanceof JsonParseException) { return Response.status(Response.Status.BAD_REQUEST) .type(MIMETYPE_TEXT).entity("Bad request" + CRLF) .build();
/** * Save a new client. */ @PUT public Response put(@Context HttpServletRequest request, @PathParam("resourceServerId") Long resourceServerId, Client client) { Response validateScopeResponse = validateScope(request, Collections.singletonList(AbstractResource.SCOPE_WRITE)); if (validateScopeResponse != null) { return validateScopeResponse; } ResourceServer resourceServer = getResourceServer(request, resourceServerId); client.setResourceServer(resourceServer); client.setClientId(generateClientId(client)); client.setSecret(client.isAllowedImplicitGrant() ? null : generateSecret()); Client clientSaved; try { clientSaved = clientRepository.save(client); } catch (RuntimeException e) { return buildErrorResponse(e); } if (LOG.isDebugEnabled()) { LOG.debug("Saved client: {}", clientSaved); } final URI uri = UriBuilder.fromPath("{clientId}.json").build(clientSaved.getId()); return Response.created(uri).entity(clientSaved).build(); }
@POST @Timed @ApiOperation(value = "Add a new named pattern", response = GrokPattern.class) @AuditEvent(type = AuditEventTypes.GROK_PATTERN_CREATE) public Response createPattern(@ApiParam(name = "pattern", required = true) @Valid @NotNull GrokPattern pattern) throws ValidationException { checkPermission(RestPermissions.INPUTS_CREATE); // remove the ID from the pattern, this is only used to create new patterns final GrokPattern newPattern = grokPatternService.save(pattern.toBuilder().id(null).build()); final URI patternUri = getUriBuilderToSelf().path(GrokResource.class, "listPattern").build(newPattern.id()); return Response.created(patternUri).entity(newPattern).build(); }
@POST @Consumes("application/json") public Response create(CreateBuildingJsonPayload payload) { final AtomicReference<String> id = new AtomicReference<>(); createBuilding.execute(new CreateBuildingRequest(payload.getName()), id::set); return Response.created(UriBuilder.fromPath(GET_SINGLE_BUILDING_URI_TEMPLATE).resolveTemplate("buildingId", id.get()).build()) .header("X-Created-Id", id.get()) .build(); }
@POST @ApiOperation(value = "Adds a new attendee to the conference") @ApiResponses(value = { @ApiResponse(code = 201, message = "The attendee is created"), @ApiResponse(code = 400, message = "Invalid input")} ) public Response add(@ApiParam(value = "Room to be created", required = true) @NotNull Attendee attendee) { Attendee created = attendeeRepository.create(attendee); return Response.created(getURIForSelf(attendee)).entity(created).build(); }
@Override public Response addClaim(UriInfo ui, Claim claim) { LOG.info("add Claim config"); Claim createdClaim = claimDAO.addClaim(claim); UriBuilder uriBuilder = UriBuilder.fromUri(ui.getRequestUri()); uriBuilder.path("{index}"); URI location = uriBuilder.build(createdClaim.getClaimType().toString()); return Response.created(location).entity(claim).build(); }
/** * Save a new resource server. */ @PUT public Response put(@Context HttpServletRequest request, @Valid ResourceServer newOne) { Response validateScopeResponse = validateScope(request, Collections.singletonList(AbstractResource.SCOPE_WRITE)); if (validateScopeResponse != null) { return validateScopeResponse; } String owner = getUserId(request); // Read only fields newOne.setKey(generateKey()); newOne.setSecret(generateSecret()); newOne.setOwner(owner); ResourceServer resourceServerSaved; try { //we run transactional modus, so any constraint violations only occur after the commit of the transaction (to late...) validate(newOne); resourceServerSaved = resourceServerRepository.save(newOne); } catch (Exception e) { return buildErrorResponse(e); } LOG.debug("New resourceServer has been saved: {}. ", resourceServerSaved); final URI uri = UriBuilder.fromPath("{resourceServerId}.json").build(resourceServerSaved.getId()); return Response.created(uri).entity(resourceServerSaved).build(); }
@POST @Timed @ApiOperation(value = "Create a stream rule") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) @AuditEvent(type = AuditEventTypes.STREAM_RULE_CREATE) public Response create(@ApiParam(name = "streamid", value = "The stream id this new rule belongs to.", required = true) @PathParam("streamid") String streamId, @ApiParam(name = "JSON body", required = true) @Valid @NotNull CreateStreamRuleRequest cr) throws NotFoundException, ValidationException { checkPermission(RestPermissions.STREAMS_EDIT, streamId); checkNotDefaultStream(streamId, "Cannot add stream rules to the default stream."); // Check if stream exists streamService.load(streamId); final StreamRule streamRule = streamRuleService.create(streamId, cr); final String id = streamRuleService.save(streamRule); final SingleStreamRuleSummaryResponse response = SingleStreamRuleSummaryResponse.create(id); final URI streamRuleUri = getUriBuilderToSelf().path(StreamRuleResource.class) .path("{streamRuleId}") .build(streamId, id); return Response.created(streamRuleUri).entity(response).build(); }
@POST @Consumes("application/json") @Path("{buildingId}/tenant") public Response addTenant(@PathParam("buildingId") String buildingId, AddTenantToBuildingJsonPayload payload) { final AtomicReference<String> id = new AtomicReference<>(); addTenantToBuilding.execute(new AddTenantToBuildingRequest(buildingId, payload.getName()), id::set); return Response.created(UriBuilder.fromPath(GET_BUILDING_TENANT_URI_TEMPLATE).resolveTemplate("buildingId", buildingId).resolveTemplate("tenantId", id.get()).build()).build(); }