/**
* TODO: Description.
*
* @param source
* @param target
* @param syncOperation the parent {@link ObjectMapping.SyncOperation} instance
* @return TODO.
* @throws SynchronizationException TODO.
*/
public Action getAction(
LazyObjectAccessor source,
LazyObjectAccessor target,
final ObjectMapping.SyncOperation syncOperation)
throws SynchronizationException {
Action result = null;
if (action != null) { // static action specified
result = action;
} else if (script != null) { // action is dynamically determine
Map<String, Object> scope = new HashMap<String, Object>();
if (null != scriptScope) {
// Make a thread safe copy and put the variables into the scope
for (Map.Entry<String, Object> entry : Utils.deepCopy(scriptScope).entrySet()) {
if (scope.containsKey(entry.getKey())) {
continue;
}
scope.put(entry.getKey(), entry.getValue());
}
}
Map<String, Object> recon = new HashMap<String, Object>();
scope.put("recon", recon);
JsonValue actionParam = null;
if (syncOperation instanceof ObjectMapping.TargetSyncOperation) {
actionParam = ((ObjectMapping.TargetSyncOperation) syncOperation).toJsonValue();
} else if (syncOperation instanceof ObjectMapping.SourceSyncOperation) {
actionParam = ((ObjectMapping.SourceSyncOperation) syncOperation).toJsonValue();
}
if (null != actionParam) {
// FIXME Decide if leading underscore should be used here or not
actionParam.put("_" + ActionRequest.FIELD_ACTION, "performAction");
recon.put("actionParam", actionParam.getObject());
}
scope.put("sourceAction", (syncOperation instanceof ObjectMapping.SourceSyncOperation));
if (source != null) {
scope.put("source", source.asMap());
}
if (target != null) {
scope.put("target", target.asMap());
}
try {
result = Enum.valueOf(Action.class, script.exec(scope).toString());
} catch (NullPointerException npe) {
throw new SynchronizationException("action script returned null value");
} catch (IllegalArgumentException iae) {
throw new SynchronizationException("action script returned invalid action");
} catch (ScriptException se) {
LOGGER.debug("action script encountered exception", se);
throw new SynchronizationException(se);
}
}
return result;
}
/**
* Returns the exception in a JSON object structure, suitable for inclusion in the entity of an
* HTTP error response. The JSON representation looks like this:
*
* <pre>
* {
* "code" : 404,
* "reason" : "...", // optional
* "message" : "...", // required
* "detail" : { ... } // optional
* "cause" : { ... } // optional iff includeCause is set to true
* }
* </pre>
*
* @return The exception in a JSON object structure, suitable for inclusion in the entity of an
* HTTP error response.
*/
public final JsonValue toJsonValue() {
final Map<String, Object> result = new LinkedHashMap<String, Object>(4);
result.put(FIELD_CODE, code); // required
if (reason != null) { // optional
result.put(FIELD_REASON, reason);
}
final String message = getMessage();
if (message != null) { // should always be present
result.put(FIELD_MESSAGE, message);
}
if (!detail.isNull()) {
result.put(FIELD_DETAIL, detail.getObject());
}
if (includeCause && getCause() != null && getCause().getMessage() != null) {
final Map<String, Object> cause = new LinkedHashMap<String, Object>(2);
cause.put("message", getCause().getMessage());
result.put(FIELD_CAUSE, cause);
}
return new JsonValue(result);
}
/**
* Returns a JSON object containing only the specified fields from the provided JSON value. If the
* list of fields is empty then the value is returned unchanged.
*
* <p><b>NOTE:</b> this method only performs a shallow copy of extracted fields, so changes to the
* filtered JSON value may impact the original JSON value, and vice-versa.
*
* @param resource The JSON value whose fields are to be filtered.
* @param fields The list of fields to be extracted.
* @return The filtered JSON value.
*/
public static JsonValue filterResource(
final JsonValue resource, final Collection<JsonPointer> fields) {
if (fields.isEmpty() || resource.isNull() || resource.size() == 0) {
return resource;
} else {
final Map<String, Object> filtered = new LinkedHashMap<String, Object>(fields.size());
for (JsonPointer field : fields) {
if (field.isEmpty()) {
// Special case - copy resource fields (assumes Map).
filtered.putAll(resource.asMap());
} else {
// FIXME: what should we do if the field refers to an array element?
final JsonValue value = resource.get(field);
if (value != null) {
final String key = field.leaf();
filtered.put(key, value.getObject());
}
}
}
return new JsonValue(filtered);
}
}
@Test(dataProvider = "testFilterData")
public void testFilter(List<JsonPointer> filter, JsonValue content, JsonValue expected) {
Assertions.assertThat(Resources.filterResource(content, filter).getObject())
.isEqualTo(expected.getObject());
}