Java Code Examples for com.fasterxml.jackson.core.JsonProcessingException#getMessage()

/**
 * Converts {@link AdUnitBid} to masterTagId. In case of any problem to retrieve or validate masterTagId, throws
 * {@link PreBidException}
 */
private AdformParams toAdformParams(AdUnitBid adUnitBid) {
    final ObjectNode params = adUnitBid.getParams();
    if (params == null) {
        throw new PreBidException("Adform params section is missing");
    }
    final AdformParams adformParams;
    try {
        adformParams = mapper.mapper().treeToValue(params, AdformParams.class);
    } catch (JsonProcessingException e) {
        throw new PreBidException(e.getMessage(), e.getCause());
    }
    final Long masterTagId = adformParams.getMid();
    if (masterTagId != null && masterTagId > 0) {
        return adformParams;
    } else {
        throw new PreBidException(String.format("master tag(placement) id is invalid=%s", masterTagId));
    }
}
 

default String getTolerations(AccountDeploymentDetails<KubernetesAccount> details) {
  List<Toleration> toleration =
      details
          .getDeploymentConfiguration()
          .getDeploymentEnvironment()
          .getTolerations()
          .getOrDefault(getService().getServiceName(), new ArrayList<>());

  if (toleration.isEmpty()) {
    toleration =
        details
            .getDeploymentConfiguration()
            .getDeploymentEnvironment()
            .getTolerations()
            .getOrDefault(getService().getBaseCanonicalName(), new ArrayList<>());
  }

  try {
    return getObjectMapper().writeValueAsString(toleration);
  } catch (JsonProcessingException e) {
    throw new HalException(
        Problem.Severity.FATAL, "Invalid tolerations format: " + e.getMessage(), e);
  }
}
 

public String render() {
  StringBuilder builder = new StringBuilder();
  JsonFormatterUtils newFormatter = new JsonFormatterUtils();
  JsonFormatterUtils oldFormatter = new JsonFormatterUtils();

  String topologyName = response.getTopology().getName();
  String packingClassName = Context.packingClass(response.getConfig());
  PackingPlan newPackingPlan = response.getPackingPlan();
  PackingPlan oldPackingPlan = response.getOldPackingPlan();

  try {
    String newPackingPlanJson = newFormatter.renderPackingPlan(topologyName, packingClassName,
        newPackingPlan);
    String oldPackingPlanJson = oldFormatter.renderPackingPlan(topologyName, packingClassName,
        oldPackingPlan);

    builder.append("New packing plan:\n");
    builder.append(newPackingPlanJson).append("\n");
    builder.append("Old packing plan:\n");
    builder.append(oldPackingPlanJson).append("\n");

    return builder.toString();
  } catch (JsonProcessingException e) {
    return "ERROR: " + e.getMessage();
  }
}
 

private AppnexusBidExt parseAppnexusBidExt(ObjectNode bidExt) {
    if (bidExt == null) {
        throw new PreBidException("bidResponse.bid.ext should be defined for appnexus");
    }

    final AppnexusBidExt appnexusBidExt;
    try {
        appnexusBidExt = mapper.mapper().treeToValue(bidExt, AppnexusBidExt.class);
    } catch (JsonProcessingException e) {
        throw new PreBidException(e.getMessage(), e);
    }
    return appnexusBidExt;
}
 

public ModifyKeyRelDeviceListApi(List<String> addDevIds, List<String> delDevIds, String apiKey, String masterKey) {
    this.apiKey = apiKey;
    this.addDevIds = addDevIds;
    this.delDevIds = delDevIds;
    this.key = masterKey;
    this.method = RequestInfo.Method.PUT;
    this.HttpMethod = new HttpPutMethod(method);
    this.url = Config.getString("test.url") + "/keys/"+apiKey+"/devices" ;
    Map<String, Object> headmap = new HashMap<String, Object>();
    Map<String, Object> body = new HashMap<String, Object>();
    if(addDevIds!=null&&!addDevIds.isEmpty()){
        body.put("add_dev_ids",addDevIds);
    }
    if(delDevIds!=null&&!delDevIds.isEmpty()){
        body.put("del_dev_ids",delDevIds);
    }
    String json = null;
    try {
        json = mapper.writeValueAsString(body);
    } catch (JsonProcessingException e) {
        logger.error("json error {}", e.getMessage());
        throw new OnenetApiException(e.getMessage());
    }
    headmap.put("api-key", masterKey);
    HttpMethod.setHeader(headmap);
    HttpMethod.setcompleteUrl(url,null);
    HttpMethod.setEntity(json);
}
 

public String toString() {
    ArrayNode array = mapper.createArrayNode();
    results.forEach((key, value) -> array.add(mapper.createObjectNode().
            put("model", key).
            set("tests", value)));
    try {
        return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(array);
    } catch (JsonProcessingException e) {
        return e.getMessage();
    }
}
 

private void postSeaCloudsDcConfiguration(SeaCloudsDcRequestDto requestBody) {
    try {
        String jsonBody = new ObjectMapper().writeValueAsString(requestBody);
        postSeaCloudsDcConfiguration(jsonBody);
    } catch (JsonProcessingException e) {
        throw new RuntimeException("Something went wrong creating Request body to " +
                "configure the SeaCloudsDc for type" + requestBody.getType() + " and " +
                "url " + requestBody.getUrl() + ". Message: " + e.getMessage());
    }
}
 

/**
 * Converts a {@link DataTagValueUpdate} to a JMS {@link Message}
 *
 * @param tag     the tag to convert
 * @param session the session in which the message must be created
 *
 * @return the resulting message
 * @throws JMSException if an error occurs in creating the message
 */
@Override
public Message toMessage(final Object tag, final Session session) throws JMSException {
  try {
    String json = mapper.writeValueAsString(tag);
    return session.createTextMessage(json);

  } catch (JsonProcessingException e) {
    log.error("Exception caught on update reception", e.getMessage());
    throw new MessageConversionException("Exception caught in converting dataTagValueUpdate to a json String:"
        + e.getMessage());
  }
}
 

private void validateSource(Source source) throws ValidationException {
    if (source != null && source.getExt() != null) {
        try {
            mapper.mapper().treeToValue(source.getExt(), ExtSource.class);
        } catch (JsonProcessingException e) {
            throw new ValidationException("request.source.ext is invalid: %s", e.getMessage());
        }
    }
}
 

public String request() {
    try {

        Builder<String, String> builder = ImmutableMap.<String, String>builder()
                .put("query", this.query);


        variables.ifPresent(variables -> builder.put("variables", variables));
        operationName.ifPresent(operationName -> builder.put("operationName", operationName));

        return toJsonString(builder.build());
    } catch (JsonProcessingException exception) {
        throw new RuntimeException(exception.getMessage(), exception);
    }
}
 

@Override
  public String objectToSQLString(final Object object) {
  	
  	if (object == null) {
  		return null;
  	}

  	try {
	return objectWriter.writeValueAsString(object);
} catch (JsonProcessingException e) {
	throw new HibernateException("Cannot serialize JSON object: " + e.getMessage(), e);
}
  }
 

public static String toJson(Object object, boolean indentedOutput) {
    try {
        return getObjectWriter(indentedOutput).writeValueAsString(object);
    } catch (JsonProcessingException e) {
        throw new IllegalArgumentException(e.getMessage(), e);
    }
}
 

private void validateApp(App app) throws ValidationException {
    if (app != null) {
        if (app.getExt() != null) {
            try {
                mapper.mapper().treeToValue(app.getExt(), ExtApp.class);
            } catch (JsonProcessingException e) {
                throw new ValidationException("request.app.ext object is not valid: %s", e.getMessage());
            }
        }
    }
}
 

public String asJson() {
  try {
    return new ObjectMapper().writeValueAsString(this);
  } catch (JsonProcessingException e) {
    throw new RuntimeException("Could not serialize context to JSON: " + e.getMessage(), e);
  }
}
 

private ExtBidRequest parseAndValidateExtBidRequest(BidRequest bidRequest) throws ValidationException {
    ExtBidRequest extBidRequest = null;
    if (bidRequest.getExt() != null) {
        try {
            extBidRequest = mapper.mapper().treeToValue(bidRequest.getExt(), ExtBidRequest.class);
        } catch (JsonProcessingException e) {
            throw new ValidationException("request.ext is invalid: %s", e.getMessage());
        }
    }
    return extBidRequest;
}
 

private AppnexusBidExt parseAppnexusBidExt(ObjectNode bidExt) {
    if (bidExt == null) {
        throw new PreBidException("bidResponse.bid.ext should be defined for appnexus");
    }

    final AppnexusBidExt appnexusBidExt;
    try {
        appnexusBidExt = mapper.mapper().treeToValue(bidExt, AppnexusBidExt.class);
    } catch (JsonProcessingException e) {
        throw new PreBidException(e.getMessage(), e);
    }
    return appnexusBidExt;
}
 

@Override
public Space fromMap(Map<String, Object> map) throws ModifyOpError, HttpException {
  try {
    return Json.mapper.readValue(Json.encode(map), Space.class);
  } catch (JsonProcessingException e) {
    throw new HttpException(BAD_REQUEST, "Invalid space definition: " + e.getMessage(), e);
  }
}
 

public static JsonReadException fromJackson(JsonProcessingException ex)
{
    String message = ex.getMessage();

    // Strip off location.
    int locPos = message.lastIndexOf(" at [Source");
    if (locPos >= 0) {
        message = message.substring(0, locPos);
    }

    return new JsonReadException(message, ex.getLocation());
}
 

public static SwaggerError newJsonError(JsonProcessingException exception) {
    int line = (exception.getLocation() != null) ? exception.getLocation().getLineNr() : 1;
    return new SwaggerError(line, IMarker.SEVERITY_ERROR, 0, exception.getMessage());
}
 

public String build() throws InternalInfrastructureException {
  List<VerifierProxyConfig> proxyConfigs = new ArrayList<>();
  Config config =
      new Config()
          .withJWTProxy(
              new JWTProxy()
                  .withSignerProxy(new SignerProxyConfig().withEnabled(false))
                  .withVerifiedProxyConfigs(proxyConfigs));

  for (VerifierProxy verifierProxy : verifierProxies) {
    VerifierConfig verifierConfig =
        new VerifierConfig()
            .withAudience(workspaceId)
            .withUpstream(verifierProxy.upstream)
            .withMaxSkew("1m")
            .withMaxTtl(ttl)
            .withKeyServer(
                new RegistrableComponentConfig()
                    .withType("preshared")
                    .withOptions(
                        ImmutableMap.of(
                            "issuer",
                            issuer,
                            "key_id",
                            workspaceId,
                            "public_key_path",
                            JWT_PROXY_CONFIG_FOLDER + '/' + JWT_PROXY_PUBLIC_KEY_FILE)))
            .withCookiesEnabled(verifierProxy.cookiesAuthEnabled)
            .withCookiePath(ensureStartsWithSlash(verifierProxy.cookiePath))
            .withClaimsVerifier(
                Collections.singleton(
                    new RegistrableComponentConfig()
                        .withType("static")
                        .withOptions(ImmutableMap.of("iss", issuer))))
            .withNonceStorage(new RegistrableComponentConfig().withType("void"));

    if (!verifierProxy.excludes.isEmpty()) {
      verifierConfig.setExcludes(verifierProxy.excludes);
    }

    if (verifierProxy.cookiesAuthEnabled && authPageUrl != null) {
      verifierConfig.setAuthUrl(authPageUrl.toString());
    }

    if (verifierProxy.publicBasePath != null) {
      verifierConfig.setPublicBasePath(verifierProxy.publicBasePath);
    }

    VerifierProxyConfig proxyConfig =
        new VerifierProxyConfig()
            .withListenAddr(":" + verifierProxy.listenPort)
            .withVerifierConfig(verifierConfig);

    proxyConfigs.add(proxyConfig);
  }

  try {
    return YAML_PARSER.writeValueAsString(config);
  } catch (JsonProcessingException e) {
    throw new InternalInfrastructureException(
        "Error during creation of JWTProxy config YAML: " + e.getMessage(), e);
  }
}