javax.ws.rs.DELETE Java Examples

@DELETE
@Path("/{namespace}/{set}/{entry}")
@Produces(MediaType.APPLICATION_JSON)
@Operation(summary = "Delete a specific entry by name")
@ApiResponses(value = {
    @ApiResponse(responseCode = "200",
                 description = "Provides single property json with a boolean which is only true if the key was found and the entry was deleted",
                 content = @Content(schema = @Schema(implementation = HttpModels.DeleteResponse.class))),
    @ApiResponse(responseCode = "500", description = serverErrorMessage)
})
public Response delete(@Parameter(description = "Namespace identifier") @PathParam("namespace") final String namespace,
                       @Parameter(description = "Name of the set") @PathParam("set") final String set,
                       @Parameter(description = "Name of the entry") @PathParam("entry") final String entry) throws IOException {
    logger.info("received request to delete entry {} in set/namespace {}/{}", entry, set, namespace);
    final Map<String, Boolean> completed = new HashMap<>();
    completed.put(jsonFieldResults, this.cantor.sets().delete(namespace, set, entry));
    return Response.ok(parser.toJson(completed)).build();
}
 

@DELETE
@Path("/{namespace}/{key}")
@Produces(MediaType.APPLICATION_JSON)
@Operation(summary = "Delete an object by its key")
@ApiResponses(value = {
    @ApiResponse(responseCode = "200",
                 description = "Provides single property json with a boolean which is only true if the key was found and the object was deleted",
                 content = @Content(schema = @Schema(implementation = HttpModels.DeleteResponse.class))),
    @ApiResponse(responseCode = "500", description = serverErrorMessage)
})
public Response deleteByKey(@Parameter(description = "Namespace identifier") @PathParam("namespace") final String namespace,
                            @Parameter(description = "Key of the object") @PathParam("key") final String key) throws IOException {
    logger.info("received request to delete object '{}' in namespace {}", key, namespace);
    final Map<String, Boolean> completed = new HashMap<>();
    completed.put(jsonFieldResults, this.cantor.objects().delete(namespace, key));
    return Response.ok(parser.toJson(completed)).build();
}
 

@DELETE
@Path("/delete/{namespace}")
@Operation(summary = "Delete events")
@ApiResponses(value = {
        @ApiResponse(responseCode = "200",
                     description = "All specified events were deleted",
                     content = @Content(schema = @Schema(implementation = HttpModels.CountResponse.class))),
        @ApiResponse(responseCode = "500", description = serverErrorMessage)
})
public Response dropEvents(@Parameter(description = "Namespace identifier") @PathParam("namespace") final String namespace,
                           @BeanParam final EventsDataSourceBean bean) throws IOException {
    logger.info("received request to drop namespace {}", namespace);
    final int eventsDeleted = this.cantor.events().delete(
            namespace,
            bean.getStart(),
            bean.getEnd(),
            bean.getMetadataQuery(),
            bean.getDimensionQuery());
    final Map<String, Integer> countResponse = new HashMap<>();
    countResponse.put(jsonFieldCount, eventsDeleted);
    return Response.ok(parser.toJson(countResponse)).build();
}
 

@DELETE()
@Path("/{id}")
@Produces(MediaType.APPLICATION_JSON)
public $Type$Output deleteResource_$name$(@PathParam("id") final String id) {
    return org.kie.kogito.services.uow.UnitOfWorkExecutor.executeInUnitOfWork(application.unitOfWorkManager(), () -> {
        ProcessInstance<$Type$> pi = process.instances()
                .findById(id)
                .orElse(null);
        if (pi == null) {
            return null;
        } else {
            pi.abort();
            return getModel(pi);
        }
    });
}
 

@DELETE()
@Path("/{id}")
@Produces(MediaType.APPLICATION_JSON)
public CompletionStage<$Type$Output> deleteResource_$name$(@PathParam("id") final String id) {
    return CompletableFuture.supplyAsync(() -> {
        return org.kie.kogito.services.uow.UnitOfWorkExecutor.executeInUnitOfWork(application.unitOfWorkManager(), () -> {
            ProcessInstance<$Type$> pi = process.instances()
                    .findById(id)
                    .orElse(null);
            if (pi == null) {
                return null;
            } else {
                pi.abort();
                return getModel(pi);
            }
        });
    });
}
 

@DELETE
@Path("/pop/{namespace}/{set}")
@Produces(MediaType.APPLICATION_JSON)
@Operation(summary = "Pop entries from a set")
@ApiResponses(value = {
    @ApiResponse(responseCode = "200",
                 description = "Entries and weights of elements popped matching query parameters",
                 content = @Content(schema = @Schema(implementation = Map.class))),
    @ApiResponse(responseCode = "400", description = "One of the query parameters has a bad value"),
    @ApiResponse(responseCode = "500", description = serverErrorMessage)
})
public Response pop(@Parameter(description = "Namespace identifier") @PathParam("namespace") final String namespace,
                    @Parameter(description = "Name of the set") @PathParam("set") final String set,
                    @BeanParam final SetsDataSourceBean bean) throws IOException {
    logger.info("received request to pop off set/namespace {}/{}", set, namespace);
    logger.debug("request parameters: {}", bean);
    final Map<String, Long> entries = this.cantor.sets().pop(
            namespace,
            set,
            bean.getMin(),
            bean.getMax(),
            bean.getStart(),
            bean.getCount(),
            bean.isAscending());
    return Response.ok(parser.toJson(entries)).build();
}
 

/**
 * Returns the experiment that deleted
 * @param id experiment id
 * @return the detailed info about deleted experiment
 */
@DELETE
@Path("/{id}")
@Operation(summary = "Delete the experiment",
        tags = {"experiment"},
        responses = {
                @ApiResponse(description = "successful operation", content = @Content(
                        schema = @Schema(implementation = JsonResponse.class))),
                @ApiResponse(responseCode = "404", description = "Experiment not found")})
public Response deleteExperiment(@PathParam(RestConstants.ID) String id) {
  try {
    Experiment experiment = experimentManager.deleteExperiment(id);
    return new JsonResponse.Builder<Experiment>(Response.Status.OK).success(true)
        .result(experiment).build();
  } catch (SubmarineRuntimeException e) {
    return parseExperimentServiceException(e);
  }
}
 

@DELETE
@Path("/{namespace}/{set}")
@Operation(summary = "Delete entries in a set between provided weights")
@ApiResponses(value = {
    @ApiResponse(responseCode = "200", description = "Successfully deleted entries between and including provided weights"),
    @ApiResponse(responseCode = "400", description = "One of the query parameters has a bad value"),
    @ApiResponse(responseCode = "500", description = serverErrorMessage)
})
public Response delete(@Parameter(description = "Namespace identifier") @PathParam("namespace") final String namespace,
                       @Parameter(description = "Name of the set") @PathParam("set") final String set,
                       @Parameter(description = "Minimum weight for an entry", example = "0") @QueryParam("min") final long min,
                       @Parameter(description = "Maximum weight for an entry", example = "0") @QueryParam("max") final long max) throws IOException {
    logger.info("received request to delete entries in set/namespace {}/{} between weights {}-{}", set, namespace, min, max);
    this.cantor.sets().delete(namespace, set, min, max);
    return Response.ok().build();
}
 

@DELETE
@Path("/deleteBatch")
@SubmarineApi
public Response deleteBatch(@QueryParam("ids") String ids) {
  LOG.info("deleteBatch({})", ids.toString());
  try (SqlSession sqlSession = MyBatisUtil.getSqlSession()) {
    SysDeptMapper sysDeptMapper = sqlSession.getMapper(SysDeptMapper.class);
    sysDeptMapper.deleteBatch(Arrays.asList(ids.split(",")));
    sqlSession.commit();
  } catch (Exception e) {
    LOG.error(e.getMessage(), e);
    return new JsonResponse.Builder<>(Response.Status.OK)
        .message("Batch delete department failed!").success(false).build();
  }

  return new JsonResponse.Builder<>(Response.Status.OK)
      .message("Batch delete department successfully!").success(true).build();
}
 

@DELETE
@Path("/remove")
@SubmarineApi
public Response remove(String id) {
  LOG.info("remove({})", id);

  try (SqlSession sqlSession = MyBatisUtil.getSqlSession()) {
    SysDeptMapper sysDeptMapper = sqlSession.getMapper(SysDeptMapper.class);
    sysDeptMapper.deleteById(id);
    sqlSession.commit();
  } catch (Exception e) {
    LOG.error(e.getMessage(), e);
    return new JsonResponse.Builder<>(Response.Status.OK)
        .message("Delete department failed!").success(false).build();
  }

  return new JsonResponse.Builder<>(Response.Status.OK)
      .message("Delete department successfully!").success(true).build();
}
 

@DELETE
@Path("/delete")
@SubmarineApi
public Response delete(@QueryParam("id") String id) {
  // TODO(zhulinhao): At the front desk need to id
  LOG.info("delete team:{}", id);

  // Delete data in a team and team_member table
  // TODO(zhulinhao):delete sys_message's invite messages
  try {
    teamService.delete(id);
  } catch (Exception e) {
    LOG.error(e.getMessage(), e);
    return new JsonResponse.Builder<>(Response.Status.OK).success(false)
        .message("delete team failed!").build();
  }

  return new JsonResponse.Builder<>(Response.Status.OK)
      .message("Delete team successfully!").success(true).build();
}
 

@DELETE
@Path("/delete")
@SubmarineApi
public Response delete(@QueryParam("id") String id) {
  // TODO(zhulinhao): At the front desk need to id
  LOG.info("delete project:{}", id);

  try {
    projectService.delete(id);
  } catch (Exception e) {
    LOG.error(e.getMessage(), e);
    return new JsonResponse.Builder<>(Response.Status.OK).success(false)
        .message("Delete project failed!").build();
  }

  return new JsonResponse.Builder<>(Response.Status.OK)
      .message("Delete project successfully!").success(true).build();
}
 

@DELETE
@Path("/delete")
@SubmarineApi
public Response delete(@QueryParam("id") String id) {
  LOG.info("delete({})", id);

  try {
    userService.delete(id);
  } catch (Exception e) {
    LOG.error(e.getMessage(), e);
    return new JsonResponse.Builder<>(Response.Status.OK).success(false)
        .message("delete user failed!").build();
  }
  return new JsonResponse.Builder<>(Response.Status.OK)
      .success(true).message("delete  user successfully!").build();
}
 

/**
 * Rest endpoint to delete specific bucket.
 * <p>
 * See: https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketDELETE.html
 * for more details.
 */
@DELETE
public Response delete(@PathParam("bucket") String bucketName)
    throws IOException, OS3Exception {

  try {
    deleteS3Bucket(bucketName);
  } catch (OMException ex) {
    if (ex.getResult() == ResultCodes.BUCKET_NOT_EMPTY) {
      throw S3ErrorTable.newError(S3ErrorTable
          .BUCKET_NOT_EMPTY, bucketName);
    } else if (ex.getResult() == ResultCodes.BUCKET_NOT_FOUND) {
      throw S3ErrorTable.newError(S3ErrorTable
          .NO_SUCH_BUCKET, bucketName);
    } else {
      throw ex;
    }
  }

  return Response
      .status(HttpStatus.SC_NO_CONTENT)
      .build();

}
 

@DELETE
@Path("/v1/proxy")
@Produces(APPLICATION_JSON)
public void cancelQuery(
        @QueryParam("uri") String uri,
        @QueryParam("hmac") String hash,
        @Context HttpServletRequest servletRequest,
        @Suspended AsyncResponse asyncResponse)
{
    if (!hmac.hashString(uri, UTF_8).equals(HashCode.fromString(hash))) {
        throw badRequest(FORBIDDEN, "Failed to validate HMAC of URI");
    }

    Request.Builder request = prepareDelete().setUri(URI.create(uri));

    performRequest(servletRequest, asyncResponse, request, response -> responseWithHeaders(noContent(), response));
}
 

@DELETE
@Path("{uuid}")
public synchronized Response deleteRequest(
        @HeaderParam(PRESTO_ENVIRONMENT) String environment,
        @PathParam("uuid") UUID uuid)
{
    checkEnvironment(environment);
    if (!shards.containsKey(uuid)) {
        return Response.status(NOT_FOUND).build();
    }
    if (shards.get(uuid) == null) {
        return Response.status(GONE).build();
    }
    shards.put(uuid, null);
    return Response.noContent().build();
}
 

@ApiOperation(
        value = "Delete device",
        notes = "Delete an existing device"
)
@DELETE
@Path("/{id}")
@Produces(MediaType.APPLICATION_JSON)
public Response removeDevice(@PathParam("id") @ApiParam("Device ID") Integer id) {
    final boolean canEditDevices = SecurityContext.get().hasPermission("edit_devices");

    if (!(canEditDevices)) {
        log.error("Unauthorized attempt to delete device",
                SecurityException.onCustomerDataAccessViolation(id, "device"));
        return Response.PERMISSION_DENIED();
    }

    this.deviceDAO.removeDeviceById(id);
    return Response.OK();
}
 

@DELETE
@Path("/customers/{id}/")
public Response deleteCustomer(@PathParam("id") String id) {
    System.out.println("----invoking deleteCustomer, Customer id is: " + id);
    long idNumber = Long.parseLong(id);
    Customer c = customers.get(idNumber);

    Response r;
    if (c != null) {
        r = Response.ok().build();
        customers.remove(idNumber);
    } else {
        r = Response.notModified().build();
    }

    return r;
}
 

@ResourceSecurity(AUTHENTICATED_USER)
@DELETE
@Path("{queryId}")
public void cancelQuery(@PathParam("queryId") QueryId queryId, @Context HttpServletRequest servletRequest, @Context HttpHeaders httpHeaders)
{
    requireNonNull(queryId, "queryId is null");

    try {
        BasicQueryInfo queryInfo = dispatchManager.getQueryInfo(queryId);
        checkCanKillQueryOwnedBy(extractAuthorizedIdentity(servletRequest, httpHeaders, accessControl, groupProvider), queryInfo.getSession().getUser(), accessControl);
        dispatchManager.cancelQuery(queryId);
    }
    catch (AccessDeniedException e) {
        throw new ForbiddenException();
    }
    catch (NoSuchElementException ignored) {
    }
}
 

@ApiOperation(
        value = "Delete user",
        notes = "Deletes a user account referenced by the specified ID"
)
@DELETE
@Path("/other/{id}")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public Response deleteUser(@PathParam("id") @ApiParam("User ID") int id) {
    try {
        userDAO.deleteUser(id);
        return Response.OK();
    } catch (Exception e) {
        return Response.ERROR(e.getMessage());
    }
}
 

@ResourceSecurity(INTERNAL_ONLY)
@DELETE
@Path("{taskId}")
@Produces(MediaType.APPLICATION_JSON)
public TaskInfo deleteTask(
        @PathParam("taskId") TaskId taskId,
        @QueryParam("abort") @DefaultValue("true") boolean abort,
        @Context UriInfo uriInfo)
{
    requireNonNull(taskId, "taskId is null");
    TaskInfo taskInfo;

    if (abort) {
        taskInfo = taskManager.abortTask(taskId);
    }
    else {
        taskInfo = taskManager.cancelTask(taskId);
    }

    if (shouldSummarize(uriInfo)) {
        taskInfo = taskInfo.summarize();
    }
    return taskInfo;
}
 

@DELETE
@Path("{id}")
@Operation(
        operationId = "DeleteLegume",
        summary = "Delete a Legume"
)
@APIResponse(
        responseCode = "204",
        description = "Empty response"
)
@APIResponse(
        name = "notFound",
        responseCode = "404",
        description = "Legume not found"
)
@APIResponse(
        name = "internalError",
        responseCode = "500",
        description = "Internal Server Error"
)
Response delete(
        @Parameter(name = "id",
                description = "Id of the Legume to delete",
                required = true,
                example = "81471222-5798-11e9-ae24-57fa13b361e1",
                schema = @Schema(description = "uuid", required = true))
        @PathParam("id")
        @NotEmpty final String legumeId);
 

@DELETE
@Path("{id}")
public void deleteCoffee(@PathParam("id") Long coffeeId) {
	try {
		this.cafeRepository.removeCoffeeById(coffeeId);
	} catch (IllegalArgumentException ex) {
		logger.log(Level.SEVERE, "Error calling deleteCoffee() for coffeeId {0}: {1}.",
				new Object[] { coffeeId, ex });
		throw new WebApplicationException(Response.Status.NOT_FOUND);
	}
}
 

@DELETE
  @Path("/{personId}")
  public void removePerson(@PathParam("personId") long id) {
      try (Connection conn = defaultDataSource.getConnection();
	 PreparedStatement ps = conn.prepareStatement("DELETE FROM people WHERE id = ?")){
	ps.setLong(1,id);
	if (ps.executeUpdate() > 0) {
		return;
	};	
	throw new NotFoundException("Person with id " + id + " not found.");
} catch (SQLException e) {
	e.printStackTrace(System.out);
}
throw new InternalServerErrorException("Could not delete person"); 
  }
 

@DELETE
@Path("{id}")
public void deleteCoffee(@PathParam("id") Long coffeeId) {
	try {
		this.cafeRepository.removeCoffeeById(coffeeId);
	} catch (IllegalArgumentException ex) {
		logger.log(Level.SEVERE, "Error calling deleteCoffee() for coffeeId {0}: {1}.",
				new Object[] { coffeeId, ex });
		throw new WebApplicationException(Response.Status.NOT_FOUND);
	}
}
 

@DELETE
@Path("{id}")
public void deleteCoffee(@PathParam("id") Long coffeeId) {
	try {
		this.cafeRepository.removeCoffeeById(coffeeId);
	} catch (IllegalArgumentException ex) {
		logger.log(Level.SEVERE, "Error calling deleteCoffee() for coffeeId {0}: {1}.",
				new Object[] { coffeeId, ex });
		throw new WebApplicationException(Response.Status.NOT_FOUND);
	}
}
 

@Path("/delete")
@DELETE
@Produces(MediaType.TEXT_PLAIN)
public Response deleteData(@QueryParam("indexId") String indexId) throws Exception {
    producerTemplate.requestBody("elasticsearch-rest://elasticsearch?operation=Delete&indexName=test", indexId);
    return Response.noContent().build();
}
 

@DELETE
@Path("/{id}")
@Produces(MediaType.APPLICATION_JSON)
public Response removeCustomer(@PathParam("id") Integer id) {
    try {
        this.customerDAO.removeCustomerById(id);
        return Response.OK();
    } catch (Exception e) {
        log.error("Unexpected error when deleting customer account #{}", id, e);
        return Response.INTERNAL_ERROR();
    }
}
 

@Path("/delete/{fileName}")
@DELETE
public Response deleteFile(@PathParam("fileName") String fileName) {
    producerTemplate.requestBodyAndHeader("mongodb-gridfs:camelMongoClient?database=test&operation=remove", null,
            Exchange.FILE_NAME,
            fileName);
    return Response.noContent().build();
}
 

@DELETE
@Path("{id}")
public void deleteCoffee(@PathParam("id") Long coffeeId) {
	try {
		this.cafeRepository.removeCoffeeById(coffeeId);
	} catch (IllegalArgumentException ex) {
		logger.log(Level.SEVERE, "Error calling deleteCoffee() for coffeeId {0}: {1}.",
				new Object[] { coffeeId, ex });
		throw new WebApplicationException(Response.Status.NOT_FOUND);
	}
}