use of javax.ws.rs.core.MediaType.APPLICATION_JSON in project keywhiz by square.
the class ClientResource method modifyClientGroups.
/**
* Modify groups a client has membership in
*
* @excludeParams automationClient
* @param name Client name
* @param request JSON request specifying which groups to add or remove
* @return Listing of groups client has membership in
*
* @responseMessage 201 Client modified successfully
* @responseMessage 404 Client not found
*/
@Timed
@ExceptionMetered
@PUT
@Path("{name}/groups")
@Produces(APPLICATION_JSON)
public Iterable<String> modifyClientGroups(@Auth AutomationClient automationClient, @PathParam("name") String name, @Valid ModifyGroupsRequestV2 request) {
Client client = clientDAOReadWrite.getClient(name).orElseThrow(NotFoundException::new);
String user = automationClient.getName();
long clientId = client.getId();
Set<String> oldGroups = aclDAOReadWrite.getGroupsFor(client).stream().map(Group::getName).collect(toSet());
Set<String> groupsToAdd = Sets.difference(request.addGroups(), oldGroups);
Set<String> groupsToRemove = Sets.intersection(request.removeGroups(), oldGroups);
// TODO: should optimize AclDAO to use names and return only name column
groupsToGroupIds(groupsToAdd).forEach((maybeGroupId) -> maybeGroupId.ifPresent((groupId) -> aclDAOReadWrite.findAndEnrollClient(clientId, groupId, auditLog, user, new HashMap<>())));
groupsToGroupIds(groupsToRemove).forEach((maybeGroupId) -> maybeGroupId.ifPresent((groupId) -> aclDAOReadWrite.findAndEvictClient(clientId, groupId, auditLog, user, new HashMap<>())));
return aclDAOReadWrite.getGroupsFor(client).stream().map(Group::getName).collect(toSet());
}
use of javax.ws.rs.core.MediaType.APPLICATION_JSON in project ddf by codice.
the class MetacardApplication method init.
@Override
public void init() {
get("/metacardtype", (req, res) -> {
return util.getJson(util.getMetacardTypeMap());
});
get("/metacard/:id", (req, res) -> {
String id = req.params(":id");
return util.metacardToJson(id);
});
get("/metacard/:id/attribute/validation", (req, res) -> {
String id = req.params(":id");
return util.getJson(validator.getValidation(util.getMetacard(id)));
});
get("/metacard/:id/validation", (req, res) -> {
String id = req.params(":id");
return util.getJson(validator.getFullValidation(util.getMetacard(id)));
});
post("/metacards", APPLICATION_JSON, (req, res) -> {
List<String> ids = JsonFactory.create().parser().parseList(String.class, req.body());
List<Metacard> metacards = util.getMetacards(ids, "*").entrySet().stream().map(Map.Entry::getValue).map(Result::getMetacard).collect(Collectors.toList());
return util.metacardsToJson(metacards);
});
delete("/metacards", APPLICATION_JSON, (req, res) -> {
List<String> ids = JsonFactory.create().parser().parseList(String.class, req.body());
DeleteResponse deleteResponse = catalogFramework.delete(new DeleteRequestImpl(new ArrayList<>(ids), Metacard.ID, null));
if (deleteResponse.getProcessingErrors() != null && !deleteResponse.getProcessingErrors().isEmpty()) {
res.status(500);
return ImmutableMap.of("message", "Unable to archive metacards.");
}
return ImmutableMap.of("message", "Successfully archived metacards.");
}, util::getJson);
patch("/metacards", APPLICATION_JSON, (req, res) -> {
List<MetacardChanges> metacardChanges = JsonFactory.createUseJSONDates().parser().parseList(MetacardChanges.class, req.body());
UpdateResponse updateResponse = patchMetacards(metacardChanges);
if (updateResponse.getProcessingErrors() != null && !updateResponse.getProcessingErrors().isEmpty()) {
res.status(500);
return updateResponse.getProcessingErrors();
}
return req.body();
});
put("/validate/attribute/:attribute", TEXT_PLAIN, (req, res) -> {
String attribute = req.params(":attribute");
String value = req.body();
return util.getJson(validator.validateAttribute(attribute, value));
});
get("/history/:id", (req, res) -> {
String id = req.params(":id");
List<Result> queryResponse = getMetacardHistory(id);
if (queryResponse.isEmpty()) {
res.status(204);
return "[]";
}
List<HistoryResponse> response = queryResponse.stream().map(Result::getMetacard).map(mc -> new HistoryResponse(mc.getId(), (String) mc.getAttribute(MetacardVersion.EDITED_BY).getValue(), (Date) mc.getAttribute(MetacardVersion.VERSIONED_ON).getValue())).sorted(Comparator.comparing(HistoryResponse::getVersioned)).collect(Collectors.toList());
return util.getJson(response);
});
get("/history/revert/:id/:revertid", (req, res) -> {
String id = req.params(":id");
String revertId = req.params(":revertid");
Metacard versionMetacard = util.getMetacard(revertId);
List<Result> queryResponse = getMetacardHistory(id);
if (queryResponse == null || queryResponse.isEmpty()) {
throw new NotFoundException("Could not find metacard with id: " + id);
}
Optional<Metacard> contentVersion = queryResponse.stream().map(Result::getMetacard).filter(mc -> getVersionedOnDate(mc).isAfter(getVersionedOnDate(versionMetacard)) || getVersionedOnDate(mc).equals(getVersionedOnDate(versionMetacard))).filter(mc -> CONTENT_ACTIONS.contains(Action.ofMetacard(mc))).filter(mc -> mc.getResourceURI() != null).filter(mc -> ContentItem.CONTENT_SCHEME.equals(mc.getResourceURI().getScheme())).sorted(Comparator.comparing((Metacard mc) -> util.parseToDate(mc.getAttribute(MetacardVersion.VERSIONED_ON).getValue()))).findFirst();
if (!contentVersion.isPresent()) {
/* no content versions, just restore metacard */
revertMetacard(versionMetacard, id, false);
} else {
revertContentandMetacard(contentVersion.get(), versionMetacard, id);
}
return util.metacardToJson(MetacardVersionImpl.toMetacard(versionMetacard, types));
});
get("/associations/:id", (req, res) -> {
String id = req.params(":id");
return util.getJson(associated.getAssociations(id));
});
put("/associations/:id", (req, res) -> {
String id = req.params(":id");
List<Associated.Edge> edges = JsonFactory.create().parser().parseList(Associated.Edge.class, req.body());
associated.putAssociations(id, edges);
return req.body();
});
post("/subscribe/:id", (req, res) -> {
String email = getSubjectEmail();
if (isEmpty(email)) {
throw new NotFoundException("Login to subscribe to workspace.");
}
String id = req.params(":id");
subscriptions.addEmail(id, email);
return ImmutableMap.of("message", String.format("Successfully subscribed to id = %s.", id));
}, util::getJson);
post("/unsubscribe/:id", (req, res) -> {
String email = getSubjectEmail();
if (isEmpty(email)) {
throw new NotFoundException("Login to un-subscribe from workspace.");
}
String id = req.params(":id");
subscriptions.removeEmail(id, email);
return ImmutableMap.of("message", String.format("Successfully un-subscribed to id = %s.", id));
}, util::getJson);
get("/workspaces/:id", (req, res) -> {
String id = req.params(":id");
String email = getSubjectEmail();
Metacard metacard = util.getMetacard(id);
// NOTE: the isEmpty is to guard against users with no email (such as guest).
boolean isSubscribed = !isEmpty(email) && subscriptions.getEmails(metacard.getId()).contains(email);
return ImmutableMap.builder().putAll(transformer.transform(metacard)).put("subscribed", isSubscribed).build();
}, util::getJson);
get("/workspaces", (req, res) -> {
String email = getSubjectEmail();
Map<String, Result> workspaceMetacards = util.getMetacardsByFilter(WorkspaceAttributes.WORKSPACE_TAG);
// NOTE: the isEmpty is to guard against users with no email (such as guest).
Set<String> ids = isEmpty(email) ? Collections.emptySet() : subscriptions.getSubscriptions(email);
return workspaceMetacards.entrySet().stream().map(Map.Entry::getValue).map(Result::getMetacard).map(metacard -> {
boolean isSubscribed = ids.contains(metacard.getId());
try {
return ImmutableMap.builder().putAll(transformer.transform(metacard)).put("subscribed", isSubscribed).build();
} catch (RuntimeException e) {
LOGGER.debug("Could not transform metacard. WARNING: This indicates there is invalid data in the system. Metacard title: '{}', id:'{}'", metacard.getTitle(), metacard.getId(), e);
}
return null;
}).filter(Objects::nonNull).collect(Collectors.toList());
}, util::getJson);
post("/workspaces", APPLICATION_JSON, (req, res) -> {
Map<String, Object> incoming = JsonFactory.create().parser().parseMap(req.body());
Metacard saved = saveMetacard(transformer.transform(incoming));
Map<String, Object> response = transformer.transform(saved);
res.status(201);
return util.getJson(response);
});
put("/workspaces/:id", APPLICATION_JSON, (req, res) -> {
String id = req.params(":id");
Map<String, Object> workspace = JsonFactory.create().parser().parseMap(req.body());
Metacard metacard = transformer.transform(workspace);
metacard.setAttribute(new AttributeImpl(Metacard.ID, id));
Metacard updated = updateMetacard(id, metacard);
return util.getJson(transformer.transform(updated));
});
delete("/workspaces/:id", APPLICATION_JSON, (req, res) -> {
String id = req.params(":id");
catalogFramework.delete(new DeleteRequestImpl(id));
return ImmutableMap.of("message", "Successfully deleted.");
}, util::getJson);
get("/enumerations/metacardtype/:type", APPLICATION_JSON, (req, res) -> {
return util.getJson(enumExtractor.getEnumerations(req.params(":type")));
});
get("/enumerations/attribute/:attribute", APPLICATION_JSON, (req, res) -> {
return util.getJson(enumExtractor.getAttributeEnumerations(req.params(":attribute")));
});
get("/localcatalogid", (req, res) -> {
return String.format("{\"%s\":\"%s\"}", "local-catalog-id", catalogFramework.getId());
});
after((req, res) -> {
res.type(APPLICATION_JSON);
});
exception(IngestException.class, (ex, req, res) -> {
res.status(404);
res.header(CONTENT_TYPE, APPLICATION_JSON);
LOGGER.debug("Failed to ingest metacard", ex);
res.body(util.getJson(ImmutableMap.of("message", UPDATE_ERROR_MESSAGE)));
});
exception(NotFoundException.class, (ex, req, res) -> {
res.status(404);
res.header(CONTENT_TYPE, APPLICATION_JSON);
LOGGER.debug("Failed to find metacard.", ex);
res.body(util.getJson(ImmutableMap.of("message", ex.getMessage())));
});
exception(NumberFormatException.class, (ex, req, res) -> {
res.status(400);
res.header(CONTENT_TYPE, APPLICATION_JSON);
res.body(util.getJson(ImmutableMap.of("message", "Invalid values for numbers")));
});
exception(RuntimeException.class, (ex, req, res) -> {
LOGGER.debug("Exception occured.", ex);
res.status(404);
res.header(CONTENT_TYPE, APPLICATION_JSON);
res.body(util.getJson(ImmutableMap.of("message", "Could not find what you were looking for")));
});
}
use of javax.ws.rs.core.MediaType.APPLICATION_JSON in project che by eclipse.
the class WorkspaceService method updateProject.
@PUT
@Path("/{id}/project/{path:.*}")
@Consumes(APPLICATION_JSON)
@Produces(APPLICATION_JSON)
@ApiOperation(value = "Update the workspace project by replacing it with a new one", notes = "This operation can be performed only by the workspace owner")
@ApiResponses({ @ApiResponse(code = 200, message = "The project successfully updated"), @ApiResponse(code = 400, message = "Missed required parameters, parameters are not valid"), @ApiResponse(code = 403, message = "The user does not have access to update the project"), @ApiResponse(code = 404, message = "The workspace or the project not found"), @ApiResponse(code = 500, message = "Internal server error occurred") })
public WorkspaceDto updateProject(@ApiParam("The workspace id") @PathParam("id") String id, @ApiParam("The path to the project") @PathParam("path") String path, @ApiParam(value = "The project update", required = true) ProjectConfigDto update) throws ServerException, BadRequestException, NotFoundException, ConflictException, ForbiddenException {
requiredNotNull(update, "Project config");
final WorkspaceImpl workspace = workspaceManager.getWorkspace(id);
final List<ProjectConfigImpl> projects = workspace.getConfig().getProjects();
final String normalizedPath = path.startsWith("/") ? path : '/' + path;
if (!projects.removeIf(project -> project.getPath().equals(normalizedPath))) {
throw new NotFoundException(format("Workspace '%s' doesn't contain project with path '%s'", id, normalizedPath));
}
projects.add(new ProjectConfigImpl(update));
validator.validateConfig(workspace.getConfig());
return linksInjector.injectLinks(asDto(workspaceManager.updateWorkspace(id, workspace)), getServiceContext());
}
use of javax.ws.rs.core.MediaType.APPLICATION_JSON in project keywhiz by square.
the class ClientResource method createClient.
/**
* Creates a client and assigns to given groups
*
* @excludeParams automationClient
* @param request JSON request to create a client
*
* @responseMessage 201 Created client and assigned to given groups
* @responseMessage 409 Client already exists
*/
@Timed
@ExceptionMetered
@POST
@Consumes(APPLICATION_JSON)
public Response createClient(@Auth AutomationClient automationClient, @Valid CreateClientRequestV2 request) {
String creator = automationClient.getName();
String client = request.name();
clientDAOReadWrite.getClient(client).ifPresent((c) -> {
logger.info("Automation ({}) - Client {} already exists", creator, client);
throw new ConflictException("Client name already exists.");
});
// Creates new client record
long clientId = clientDAOReadWrite.createClient(client, creator, request.description());
auditLog.recordEvent(new Event(Instant.now(), EventTag.CLIENT_CREATE, creator, client));
// Enrolls client in any requested groups
groupsToGroupIds(request.groups()).forEach((maybeGroupId) -> maybeGroupId.ifPresent((groupId) -> aclDAOReadWrite.findAndEnrollClient(clientId, groupId, auditLog, creator, new HashMap<>())));
URI uri = UriBuilder.fromResource(ClientResource.class).path(client).build();
return Response.created(uri).build();
}
use of javax.ws.rs.core.MediaType.APPLICATION_JSON in project keywhiz by square.
the class SecretResource method modifySecretGroups.
/**
* Modify the groups a secret is assigned to
*
* @excludeParams automationClient
* @param name Secret series name
* @param request JSON request to modify groups
*
* @responseMessage 201 Group membership changed
* @responseMessage 404 Secret series not found
*/
@Timed
@ExceptionMetered
@PUT
@Path("{name}/groups")
@Consumes(APPLICATION_JSON)
@Produces(APPLICATION_JSON)
public Iterable<String> modifySecretGroups(@Auth AutomationClient automationClient, @PathParam("name") String name, @Valid ModifyGroupsRequestV2 request) {
// TODO: Use latest version instead of non-versioned
Secret secret = secretController.getSecretByName(name).orElseThrow(NotFoundException::new);
String user = automationClient.getName();
long secretId = secret.getId();
Set<String> oldGroups = aclDAO.getGroupsFor(secret).stream().map(Group::getName).collect(toSet());
Set<String> groupsToAdd = Sets.difference(request.addGroups(), oldGroups);
Set<String> groupsToRemove = Sets.intersection(request.removeGroups(), oldGroups);
// TODO: should optimize AclDAO to use names and return only name column
groupsToGroupIds(groupsToAdd).forEach((maybeGroupId) -> maybeGroupId.ifPresent((groupId) -> aclDAO.findAndAllowAccess(secretId, groupId, auditLog, user, new HashMap<>())));
groupsToGroupIds(groupsToRemove).forEach((maybeGroupId) -> maybeGroupId.ifPresent((groupId) -> aclDAO.findAndRevokeAccess(secretId, groupId, auditLog, user, new HashMap<>())));
return aclDAO.getGroupsFor(secret).stream().map(Group::getName).collect(toSet());
}
Aggregations