Example usage for com.fasterxml.jackson.core JsonProcessingException getMessage

List of usage examples for com.fasterxml.jackson.core JsonProcessingException getMessage

Introduction

In this page you can find the example usage for com.fasterxml.jackson.core JsonProcessingException getMessage.

Prototype

@Override
public String getMessage() 

Source Link

Document

Default method overridden so that we can add location information

Usage

From source file:lti.LaunchRequest.java

@JsonIgnore
public String toJSON() {
    ObjectMapper om = new ObjectMapper();
    String rawJson = null;/*w w  w . j ava2  s .c om*/
    try {
        rawJson = om.writer().writeValueAsString(this);
    } catch (JsonProcessingException e) {
        log.error(e.getMessage(), e);
    }
    return rawJson;
}

From source file:org.eclipse.cft.server.core.internal.client.ClientRequestFactory.java

/** Log-in to server and store token as needed */
public BaseClientRequest<?> connect() throws CoreException {
    final CloudFoundryServer cloudServer = behaviour.getCloudFoundryServer();

    return new BehaviourRequest<Void>("Login to " + behaviour.getCloudFoundryServer().getUrl(), behaviour) { //$NON-NLS-1$
        @Override/*from   w w  w.  jav a  2 s  .  c o m*/
        protected Void doRun(CloudFoundryOperations client, SubMonitor progress) throws CoreException {
            OAuth2AccessToken token = client.login();
            try {
                String tokenValue = CloudUtil.getTokenAsJson(token);
                cloudServer.setAndSaveToken(tokenValue);
            } catch (JsonProcessingException e) {
                CloudFoundryPlugin.logWarning(e.getMessage());
            }

            return null;
        }
    };
}

From source file:com.auditbucket.engine.service.TrackService.java

public SearchChange prepareSearchDocument(MetaHeader metaHeader, LogInputBean logInput, ChangeEvent event,
        Boolean searchActive, DateTime fortressWhen, TrackLog trackLog) throws JsonProcessingException {

    if (!searchActive || metaHeader.isSearchSuppressed())
        return null;
    SearchChange searchDocument;// w  ww.jav a 2 s .co m
    searchDocument = new MetaSearchChange(metaHeader, logInput.getMapWhat(), event.getCode(), fortressWhen);
    searchDocument.setWho(trackLog.getChange().getWho().getCode());
    searchDocument.setTags(tagTrackService.findTrackTags(metaHeader.getFortress().getCompany(), metaHeader));
    searchDocument.setDescription(metaHeader.getName());
    try {
        logger.trace("JSON {}", om.writeValueAsString(searchDocument));
    } catch (JsonProcessingException e) {
        logger.error(e.getMessage());
        throw (e);
    }
    if (trackLog != null && trackLog.getSysWhen() != 0)
        searchDocument.setSysWhen(trackLog.getSysWhen());
    else
        searchDocument.setSysWhen(metaHeader.getWhenCreated());

    // Used to reconcile that the change was actually indexed
    logger.trace("Preparing Search Document [{}]", trackLog);
    searchDocument.setLogId(trackLog.getId());
    return searchDocument;
}

From source file:services.echannel.EchannelServiceImpl.java

/**
 * Perform a call.//  www. j a v  a2s  .  c o m
 * 
 * @param httpMethod
 *            the HTTP method (GET, POST...)
 * @param action
 *            the action name
 * @param queryParams
 *            the query parameters
 * @param content
 *            the request content (for POST)
 */
private JsonNode call(HttpMethod httpMethod, String action, List<NameValuePair> queryParams, JsonNode content)
        throws EchannelException {

    String url = this.getActionUrl(action);

    Logger.debug("URL: " + url);

    WSRequest request = WS.url(url).setHeader("Content-Type", "application/octet-stream");
    request.setHeader(HTTP_HEADER_API_KEY, this.getApiSecretKey());

    if (queryParams != null) {
        for (NameValuePair param : queryParams) {
            request.setQueryParameter(param.getName(), param.getValue());
        }
    }

    Promise<WSResponse> response = null;

    String contentString = null;
    if (content != null) {
        try {
            contentString = getMapper().writeValueAsString(content);
            Logger.info("contentString: " + contentString);
        } catch (JsonProcessingException e) {
            throw new EchannelException(e.getMessage());
        }
    }

    switch (httpMethod) {
    case GET:
        response = request.get();
        break;
    case POST:
        response = request.post(contentString);
        break;
    case PUT:
        response = request.put(contentString);
        break;
    }

    Promise<Pair<Integer, JsonNode>> jsonPromise = response
            .map(new Function<WSResponse, Pair<Integer, JsonNode>>() {
                public Pair<Integer, JsonNode> apply(WSResponse response) {
                    try {
                        return Pair.of(response.getStatus(), response.asJson());
                    } catch (Exception e) {
                        JsonNode error = JsonNodeFactory.instance.textNode(e.getMessage());
                        return Pair.of(response.getStatus(), error);
                    }
                }
            });

    Pair<Integer, JsonNode> responseContent = jsonPromise.get(WS_TIMEOUT);

    Logger.debug("STATUS CODE: " + responseContent.getLeft());

    if (responseContent.getLeft().equals(200) || responseContent.getLeft().equals(204)) {
        return responseContent.getRight();
    } else {
        String errorMessage = "eChannel service call error / url: " + url + " / status: "
                + responseContent.getLeft() + " / errors: " + responseContent.getRight().toString();
        throw new EchannelException(errorMessage);
    }

}

From source file:org.apache.streams.json.JsonPathFilter.java

@Override
public List<StreamsDatum> process(StreamsDatum entry) {

    List<StreamsDatum> result = Lists.newArrayList();

    String json = null;//ww w  .ja  va 2  s .co  m

    ObjectNode document = null;

    LOGGER.debug("{} processing {}", STREAMS_ID);

    if (entry.getDocument() instanceof ObjectNode) {
        document = (ObjectNode) entry.getDocument();
        try {
            json = mapper.writeValueAsString(document);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    } else if (entry.getDocument() instanceof String) {
        json = (String) entry.getDocument();
        try {
            document = mapper.readValue(json, ObjectNode.class);
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    Preconditions.checkNotNull(document);

    if (StringUtils.isNotEmpty(json)) {

        Object srcResult = null;
        try {
            srcResult = jsonPath.read(json);

        } catch (Exception e) {
            e.printStackTrace();
            LOGGER.warn(e.getMessage());
        }

        Preconditions.checkNotNull(srcResult);

        String[] path = StringUtils.split(pathExpression, '.');
        ObjectNode node = document;
        for (int i = 1; i < path.length - 1; i++) {
            node = (ObjectNode) document.get(path[i]);
        }

        Preconditions.checkNotNull(node);

        if (srcResult instanceof JSONArray) {
            try {
                ArrayNode jsonNode = mapper.convertValue(srcResult, ArrayNode.class);
                if (jsonNode.size() == 1) {
                    JsonNode item = jsonNode.get(0);
                    node.set(destNodeName, item);
                } else {
                    node.set(destNodeName, jsonNode);
                }
            } catch (Exception e) {
                LOGGER.warn(e.getMessage());
            }
        } else if (srcResult instanceof JSONObject) {
            try {
                ObjectNode jsonNode = mapper.convertValue(srcResult, ObjectNode.class);
                node.set(destNodeName, jsonNode);
            } catch (Exception e) {
                LOGGER.warn(e.getMessage());
            }
        } else if (srcResult instanceof String) {
            try {
                node.put(destNodeName, (String) srcResult);
            } catch (Exception e) {
                LOGGER.warn(e.getMessage());
            }
        }

    }

    result.add(new StreamsDatum(document));

    return result;

}

From source file:com.servioticy.api.commons.data.SO.java

/** Return the subscriptions in output format
 *
 * @param streamId/* ww w  .j a  v a 2  s.  co  m*/
 * @return subscriptions in output format
 */
public String responseSubscriptions(String streamId, boolean externalOnly) {

    JsonNode stream = getStream(streamId);

    // Check if exist this streamId in the Service Object
    if (stream == null)
        throw new ServIoTWebApplicationException(Response.Status.BAD_REQUEST,
                "There is no Stream: " + streamId + " in the Service Object");

    // Get the Subscriptions
    List<String> IDs = externalOnly ? SearchEngine.getExternalSubscriptionsByStream(soId, streamId)
            : SearchEngine.getAllSubscriptionsByStream(soId, streamId);

    ArrayList<JsonNode> subsArray = new ArrayList<JsonNode>();

    JsonNode root = mapper.createObjectNode();
    if (root == null) {
        LOG.error("Could not create JSON mapper...");
        throw new ServIoTWebApplicationException(Response.Status.INTERNAL_SERVER_ERROR,
                "Could not create JSON mapper...");
    }
    try {
        for (String id : IDs) {
            Subscription tmp = CouchBase.getSubscription(id);
            if (tmp != null)
                subsArray.add(mapper.readTree(CouchBase.getSubscription(id).getString()));
            else
                LOG.error("Subscription id: " + id
                        + ", reported by search engine but not found in CouchBase. Skipping...");
        }
        ((ObjectNode) root).put("subscriptions", mapper.readTree(mapper.writeValueAsString(subsArray)));
    } catch (JsonProcessingException e) {
        LOG.error(e);
        throw new ServIoTWebApplicationException(Response.Status.BAD_REQUEST,
                "Error parsing subscriptions array");
    } catch (IOException e) {
        LOG.error(e);
        throw new ServIoTWebApplicationException(Response.Status.BAD_REQUEST, "Error in subscriptions array");
    } catch (Exception e) {
        LOG.error("Error:", e);
        throw new ServIoTWebApplicationException(Response.Status.INTERNAL_SERVER_ERROR, e.getMessage());
    }

    return root.toString();

    // [TODO] No well formated - To check //
    // use mapper.writerWithDefaultPrettyPrinter().writeValueAsString(data)
    //  Map<String, Object> data = new LinkedHashMap<String, Object>();
    //    Map<String, Object> map = new HashMap<String, Object>();
    //    List<Object> list = new ArrayList<Object>();
    //    while (subs.hasNext()) {
    //      subscription = cb.getSO(user_id, subs.next().asText());
    //      list.add(subscription.getString());
    //    }
    //    map.put("subscriptions", list);
    //
    //    try {
    //      return mapper.writeValueAsString(map.toString());
    //    } catch (JsonProcessingException e) {
    //      e.printStackTrace();
    //    }
    //
    //    return null;
    ////    return map.toString();
}

From source file:com.vmware.photon.controller.apife.backends.TaskDcpBackend.java

private String convertStepOptionsToString(Map<String, String> stepOptions, TaskEntity taskEntity) {
    if (stepOptions != null && !stepOptions.isEmpty()) {
        try {/*  w ww.  j av a 2s .  c o m*/
            return objectMapper.writeValueAsString(stepOptions);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(
                    String.format("Error serializing step options: {%s} for task id {%s}", e.getMessage(),
                            taskEntity.getId()));
        }
    }

    return null;
}

From source file:com.unboundid.scim2.server.providers.JsonProcessingExceptionMapper.java

/**
 * {@inheritDoc}//from www. j  a v a 2s . c om
 */
public Response toResponse(final JsonProcessingException exception) {
    ErrorResponse errorResponse;
    if ((exception instanceof JsonParseException) || (exception instanceof JsonMappingException)) {
        StringBuilder builder = new StringBuilder();
        builder.append("Unable to parse request: ");
        builder.append(exception.getOriginalMessage());
        if (exception.getLocation() != null) {
            builder.append(" at line: ");
            builder.append(exception.getLocation().getLineNr());
            builder.append(", column: ");
            builder.append(exception.getLocation().getColumnNr());
        }
        errorResponse = BadRequestException.invalidSyntax(builder.toString()).getScimError();
    } else {
        if (exception.getCause() != null && exception.getCause() instanceof ScimException) {
            errorResponse = ((ScimException) exception.getCause()).getScimError();
        } else {
            errorResponse = new ServerErrorException(exception.getMessage()).getScimError();
        }
    }

    return ServerUtils.setAcceptableType(Response.status(errorResponse.getStatus()).entity(errorResponse),
            headers.getAcceptableMediaTypes()).build();
}