use of ddf.catalog.operation.UpdateResponse in project ddf by codice.
the class CatalogComponentFrameworkTest method testUpdateWithListOfMetacards.
@Test
public /**
* Operation: UPDATE
* Body contains: List<Metacard>
*/
void testUpdateWithListOfMetacards() throws Exception {
resetMocks();
// Setup expectations to verify
final MockEndpoint mockVerifierEndpoint = getMockEndpoint("mock:result");
mockVerifierEndpoint.expectedMessageCount(1);
final List<Metacard> metacards = new ArrayList<Metacard>();
metacards.add(metacard1);
// setup mock catalog framework
final Update update = new UpdateImpl(metacard1, metacard2);
List<Update> updates = new ArrayList<Update>();
updates.add(update);
final String[] metacardIds = new String[metacards.size()];
for (int i = 0; i < metacards.size(); i++) {
metacardIds[i] = metacards.get(i).getId();
}
UpdateRequest updateRequest = new UpdateRequestImpl(metacardIds, metacards);
UpdateResponse updateResponse = new UpdateResponseImpl(updateRequest, new HashMap(), updates);
when(catalogFramework.update(any(UpdateRequest.class))).thenReturn(updateResponse);
// Exercise the route with a UPDATE operation
template.sendBodyAndHeader("direct:sampleInput", metacards, "Operation", "UPDATE");
// Verify that the number of metacards in the exchange after the records
// is identical to the input
assertListSize(mockVerifierEndpoint.getExchanges(), 1);
final Exchange exchange = mockVerifierEndpoint.getExchanges().get(0);
final List<Update> cardsUpdated = (List<Update>) exchange.getIn().getBody();
assertListSize(cardsUpdated, 1);
mockVerifierEndpoint.assertIsSatisfied();
}
use of ddf.catalog.operation.UpdateResponse in project ddf by codice.
the class UpdateOperations method update.
public UpdateResponse update(UpdateStorageRequest streamUpdateRequest) throws IngestException, SourceUnavailableException {
Map<String, Metacard> metacardMap = new HashMap<>();
List<ContentItem> contentItems = new ArrayList<>(streamUpdateRequest.getContentItems().size());
HashMap<String, Map<String, Path>> tmpContentPaths = new HashMap<>();
UpdateResponse updateResponse = null;
UpdateStorageRequest updateStorageRequest = null;
UpdateStorageResponse updateStorageResponse = null;
streamUpdateRequest = opsStorageSupport.prepareStorageRequest(streamUpdateRequest, streamUpdateRequest::getContentItems);
// Operation populates the metacardMap, contentItems, and tmpContentPaths
opsMetacardSupport.generateMetacardAndContentItems(streamUpdateRequest.getContentItems(), metacardMap, contentItems, tmpContentPaths);
streamUpdateRequest.getProperties().put(CONTENT_PATHS, tmpContentPaths);
streamUpdateRequest = applyAttributeOverrides(streamUpdateRequest, metacardMap);
try {
if (!contentItems.isEmpty()) {
updateStorageRequest = new UpdateStorageRequestImpl(contentItems, streamUpdateRequest.getId(), streamUpdateRequest.getProperties());
updateStorageRequest = processPreUpdateStoragePlugins(updateStorageRequest);
try {
updateStorageResponse = sourceOperations.getStorage().update(updateStorageRequest);
updateStorageResponse.getProperties().put(CONTENT_PATHS, tmpContentPaths);
} catch (StorageException e) {
throw new IngestException("Could not store content items. Removed created metacards.", e);
}
updateStorageResponse = processPostUpdateStoragePlugins(updateStorageResponse);
for (ContentItem contentItem : updateStorageResponse.getUpdatedContentItems()) {
if (StringUtils.isBlank(contentItem.getQualifier())) {
Metacard metacard = metacardMap.get(contentItem.getId());
Metacard overrideMetacard = contentItem.getMetacard();
Metacard updatedMetacard = OverrideAttributesSupport.overrideMetacard(metacard, overrideMetacard, true, true);
updatedMetacard.setAttribute(new AttributeImpl(Metacard.RESOURCE_SIZE, String.valueOf(contentItem.getSize())));
metacardMap.put(contentItem.getId(), updatedMetacard);
}
}
}
UpdateRequestImpl updateRequest = new UpdateRequestImpl(Iterables.toArray(metacardMap.values().stream().map(Metacard::getId).collect(Collectors.toList()), String.class), new ArrayList<>(metacardMap.values()));
updateRequest.setProperties(streamUpdateRequest.getProperties());
historian.setSkipFlag(updateRequest);
updateResponse = doUpdate(updateRequest);
historian.version(streamUpdateRequest, updateStorageResponse, updateResponse);
} catch (Exception e) {
if (updateStorageRequest != null) {
try {
sourceOperations.getStorage().rollback(updateStorageRequest);
} catch (StorageException e1) {
LOGGER.info("Unable to remove temporary content for id: {}", updateStorageRequest.getId(), e1);
}
}
throw new IngestException("Unable to store products for request: " + streamUpdateRequest.getId(), e);
} finally {
opsStorageSupport.commitAndCleanup(updateStorageRequest, tmpContentPaths);
}
updateResponse = doPostIngest(updateResponse);
return updateResponse;
}
use of ddf.catalog.operation.UpdateResponse in project ddf by codice.
the class TestCswEndpoint method testUpdateTransactionWithNewRecord.
@Test
public void testUpdateTransactionWithNewRecord() throws CswException, FederationException, IngestException, SourceUnavailableException, UnsupportedQueryException {
List<Update> updatedMetacards = new ArrayList<>();
updatedMetacards.add(new UpdateImpl(new MetacardImpl(), new MetacardImpl()));
UpdateResponse updateResponse = new UpdateResponseImpl(null, null, updatedMetacards);
doReturn(updateResponse).when(catalogFramework).update(any(UpdateRequest.class));
MetacardImpl updatedMetacard = new MetacardImpl();
updatedMetacard.setId("123");
UpdateAction updateAction = new UpdateAction(updatedMetacard, CswConstants.CSW_RECORD, "");
CswTransactionRequest transactionRequest = new CswTransactionRequest();
transactionRequest.getUpdateActions().add(updateAction);
transactionRequest.setVersion(CswConstants.VERSION_2_0_2);
transactionRequest.setService(CswConstants.CSW);
transactionRequest.setVerbose(false);
TransactionResponseType response = csw.transaction(transactionRequest);
assertThat(response, notNullValue());
TransactionSummaryType summary = response.getTransactionSummary();
assertThat(summary, notNullValue());
assertThat(summary.getTotalDeleted().intValue(), is(0));
assertThat(summary.getTotalInserted().intValue(), is(0));
assertThat(summary.getTotalUpdated().intValue(), is(1));
verifyMarshalResponse(response, "net.opengis.cat.csw.v_2_0_2:net.opengis.filter.v_1_1_0:net.opengis.gml.v_3_1_1", cswQnameOutPutSchema);
ArgumentCaptor<UpdateRequest> updateRequestArgumentCaptor = ArgumentCaptor.forClass(UpdateRequest.class);
verify(catalogFramework, times(1)).update(updateRequestArgumentCaptor.capture());
UpdateRequest actualUpdateRequest = updateRequestArgumentCaptor.getValue();
assertThat(actualUpdateRequest.getUpdates().size(), is(1));
assertThat(actualUpdateRequest.getUpdates().get(0).getValue().getId(), is("123"));
}
use of ddf.catalog.operation.UpdateResponse 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 ddf.catalog.operation.UpdateResponse in project ddf by codice.
the class MetacardApplication method patchMetacards.
protected UpdateResponse patchMetacards(List<MetacardChanges> metacardChanges) throws SourceUnavailableException, IngestException, FederationException, UnsupportedQueryException {
Set<String> changedIds = metacardChanges.stream().flatMap(mc -> mc.getIds().stream()).collect(Collectors.toSet());
Map<String, Result> results = util.getMetacards(changedIds, "*");
for (MetacardChanges changeset : metacardChanges) {
for (AttributeChange attributeChange : changeset.getAttributes()) {
for (String id : changeset.getIds()) {
List<String> values = attributeChange.getValues();
Metacard result = results.get(id).getMetacard();
Function<Serializable, Serializable> mapFunc = Function.identity();
if (isChangeTypeDate(attributeChange, result)) {
mapFunc = mapFunc.andThen(util::parseDate);
}
result.setAttribute(new AttributeImpl(attributeChange.getAttribute(), values.stream().filter(Objects::nonNull).map(mapFunc).collect(Collectors.toList())));
}
}
}
List<Metacard> changedMetacards = results.values().stream().map(Result::getMetacard).collect(Collectors.toList());
return catalogFramework.update(new UpdateRequestImpl(changedMetacards.stream().map(Metacard::getId).collect(Collectors.toList()).toArray(new String[0]), changedMetacards));
}
Aggregations