/** regression test for a NPE exception */
@Test
public void testNPE() throws Exception {
final InputStream is =
getClass()
.getClassLoader()
.getResourceAsStream("com/zaubersoftware/gnip4j/payload/payload-twitter-entities.js");
final InputStream expectedIs =
getClass()
.getClassLoader()
.getResourceAsStream("com/zaubersoftware/gnip4j/payload/payload-twitter-entities.xml");
try {
final String json = IOUtils.toString(is);
final JsonParser parser = mapper.getJsonFactory().createJsonParser(json);
final Activity activity = parser.readValueAs(Activity.class);
final StringWriter w = new StringWriter();
mapper.getJsonFactory().createJsonGenerator(w).writeObject(activity);
final Marshaller o = ctx.createMarshaller();
o.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
StringWriter ww = new StringWriter();
o.marshal(activity, ww);
assertEquals(
removeTimeZoneFields(IOUtils.toString(expectedIs)), removeTimeZoneFields(ww.toString()));
} finally {
is.close();
}
}
@Override
public void onEvalStart() {
super.onEvalStart();
initalizeData();
try {
ObjectMapper mapper = new ObjectMapper();
mapper.setDateFormat(new SimpleDateFormat("MM/dd/yyyy hh:mm:ss a"));
mapper.configure(SerializationConfig.Feature.SORT_PROPERTIES_ALPHABETICALLY, true);
mapper.configure(SerializationConfig.Feature.WRAP_EXCEPTIONS, true);
mapper.configure(SerializationConfig.Feature.WRITE_EMPTY_JSON_ARRAYS, false);
mapper.configure(SerializationConfig.Feature.WRITE_NULL_MAP_VALUES, true);
SimpleModule module = new SimpleModule("DataProxy", new Version(1, 0, 0, null));
module.addSerializer(DataProxy.class, new DataProxySerializer(DataProxy.class));
mapper.registerModule(module);
JsonFactory jsonFactory = mapper.getJsonFactory();
writer = jsonFactory.createJsonGenerator(context.getWriter());
writer.setPrettyPrinter(new DefaultPrettyPrinter());
writer.writeStartObject();
} catch (IOException ex) {
throw new OseeCoreException(ex);
}
}
@SuppressWarnings("rawtypes")
private boolean retryFailedEntries(InputStream content, TrackingBytesArray data)
throws IOException {
ObjectReader r = mapper.reader(Map.class);
JsonParser parser = mapper.getJsonFactory().createJsonParser(content);
if (ParsingUtils.seek("items", new JacksonJsonParser(parser)) == null) {
return false;
}
int entryToDeletePosition = 0; // head of the list
for (Iterator<Map> iterator = r.readValues(parser); iterator.hasNext(); ) {
Map map = iterator.next();
Map values = (Map) map.values().iterator().next();
String error = (String) values.get("error");
if (error != null) {
// status - introduced in 1.0.RC1
Integer status = (Integer) values.get("status");
if (status != null && HttpStatus.canRetry(status)
|| error.contains("EsRejectedExecutionException")) {
entryToDeletePosition++;
} else {
String message =
(status != null
? String.format("%s(%s) - %s", HttpStatus.getText(status), status, error)
: error);
throw new IllegalStateException(
String.format("Found unrecoverable error [%s]; Bailing out..", message));
}
} else {
data.remove(entryToDeletePosition);
}
}
return entryToDeletePosition > 0;
}
@SuppressWarnings("unchecked")
private <T> T parseContent(InputStream content, String string) throws IOException {
// create parser manually to lower Jackson requirements
JsonParser jsonParser = mapper.getJsonFactory().createJsonParser(content);
Map<String, Object> map = mapper.readValue(jsonParser, Map.class);
return (T) (string != null ? map.get(string) : map);
}
private static String getChannelURL(String responseBody) {
try {
ObjectMapper mapper = new ObjectMapper();
JsonFactory f = mapper.getJsonFactory();
JsonParser jp = f.createJsonParser(responseBody);
JsonToken current = jp.nextToken();
if (current != JsonToken.START_OBJECT) {
throw new IllegalStateException("FAIL - Error: root should be an object: quiting.");
}
JsonNode node = mapper.readTree(jp);
if (node.has("notificationChannel")) {
node = node.get("notificationChannel");
if (node.has("channelData")) {
node = node.get("channelData");
if (node.has("channelURL")) {
return node.get("channelURL").getTextValue();
}
}
}
jp.close();
} catch (IOException e) {
throw new IllegalStateException("FAIL - Error parsing the body, is a JSON?");
}
return null;
}
/**
* Convenience method to convert the given object to a JSON string. Supports Maps, Lists, Strings,
* Boolean, Double
*
* @param object object to convert to json
* @return JSON string to be eval'd in javascript
*/
protected String toJSONString(Object object) {
ObjectMapper mapper = new ObjectMapper();
mapper.getJsonFactory().setCharacterEscapes(new OpenmrsCharacterEscapes());
try {
return mapper.writeValueAsString(object);
} catch (IOException e) {
log.error("Failed to convert object to JSON");
throw new APIException(e);
}
}
@Test
public void testJackson() throws Exception {
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.registerModule(new VKontakteModule());
objectMapper.getJsonFactory().setInputDecorator(new VKontakteDecoratorFilter());
ClassLoader loader = getClass().getClassLoader();
VKontakteNewsPosts resp =
objectMapper.readValue(loader.getResource("wall.get.json"), VKontakteNewsPosts.class);
System.out.println(resp);
}
public static String beanToJson(Object bean) {
StringWriter sw = new StringWriter();
try {
JsonGenerator jsongenerator = objmapper.getJsonFactory().createJsonGenerator(sw);
objmapper.writeValue(jsongenerator, bean);
jsongenerator.close();
} catch (IOException e) {
LOG.error("", e);
return "";
}
return sw.toString();
}
public static byte[] writeAsByte(Object obj) {
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
mapper.getJsonFactory().createJsonGenerator(bos, JsonEncoding.UTF8);
return mapper.writeValueAsBytes(obj);
} catch (JsonGenerationException e) {
throw new RuntimeException(e);
} catch (JsonMappingException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public void dump(OutputStream os, BaseResponse res) {
D2ResponseMessage d2Response = (D2ResponseMessage) res;
try {
OutputStreamWriter writer;
writer = new OutputStreamWriter(os, charset);
JsonGenerator generator = objectMapper.getJsonFactory().createJsonGenerator(writer);
if (pretty) {
JsonPrettyPrinter pp = new JsonPrettyPrinter();
generator.setPrettyPrinter(pp);
}
//
generator.writeStartArray();
{
List<D2ResponseMessageDoc> list = d2Response.getDocs();
for (D2ResponseMessageDoc doc : list) {
generator.writeStartObject();
{
generator.writeStringField("md5Lite", Md5Lite.toString(doc.getMd5Lite()));
generator.writeNumberField("weight", doc.getWeight());
generator.writeNumberField("indentValue", doc.getIndentValue());
generator.writeNumberField("indentCount", doc.getIndentCount());
generator.writeNumberField("indentPage", doc.getIndentPage());
generator.writeNumberField("po", doc.getPo());
generator.writeNumberField("ph", doc.getPh());
}
generator.writeEndObject();
}
}
generator.writeEndArray();
//
generator.flush();
writer.flush();
} catch (UnsupportedEncodingException e) {
logger.error("dump response failed.", e);
} catch (IOException e) {
logger.error("dump response failed.", e);
} finally {
}
}
public IVRResponse parse(HttpResponse httpResponse) {
String ivrResponseAsString = "not parsed yet";
try {
ivrResponseAsString = EntityUtils.toString(httpResponse.getEntity());
LOGGER.info(String.format("Attempting to parse IVR response %s", ivrResponseAsString));
ObjectMapper objectMapper = new ObjectMapper();
JsonFactory jsonFactory = objectMapper.getJsonFactory();
JsonParser jsonParser = jsonFactory.createJsonParser(ivrResponseAsString);
return jsonParser.readValueAs(IVRResponse.class);
} catch (IOException e) {
LOGGER.error(String.format("Response returned %s", ivrResponseAsString));
throw new MTrainingException("Could not parse httpResponse", e);
}
}
public void parseResult(InputStream json) throws JsonParseException, IOException {
JsonParser jp = mapper.getJsonFactory().createJsonParser(json);
if (jp.nextToken() != JsonToken.START_OBJECT) {
throw new RuntimeException("Expected data to start with an Object");
}
Map<String, String> fields = readHeaderFields(jp);
assertNoErrors(fields);
if (fields.containsKey(OFFSET_FIELD_NAME)) {
offset = Integer.parseInt(fields.get(OFFSET_FIELD_NAME));
}
if (fields.containsKey(TOTAL_ROWS_FIELD_NAME)) {
totalRows = Integer.parseInt(fields.get(TOTAL_ROWS_FIELD_NAME));
if (totalRows == 0) {
rows = Collections.emptyList();
return;
}
}
rows = new ArrayList<T>();
ParseState state = new ParseState();
T first = parseFirstRow(jp, state);
if (first == null) {
rows = Collections.emptyList();
} else {
rows.add(first);
}
while (jp.getCurrentToken() != null) {
skipToField(jp, state.docFieldName, state);
lastId = state.lastId;
lastKey = state.lastKey;
if (atEndOfRows(jp)) {
return;
}
if (!state.fieldIsNull) {
rows.add(jp.readValueAs(type));
}
endRow(jp, state);
}
}
/** test a complete unmarshal from the json */
@Test
public void testGeoCoordinates() throws Exception {
final InputStream is =
getClass()
.getClassLoader()
.getResourceAsStream("com/zaubersoftware/gnip4j/payload/payload-example-geo.json");
try {
final JsonParser parser = mapper.getJsonFactory().createJsonParser(is);
final Activity activity = parser.readValueAs(Activity.class);
assertNotNull(activity.getGeo());
assertNotNull(activity.getGeo().getCoordinates());
assertEquals(-34.58501869, activity.getGeo().getCoordinates()[0], 0.001);
assertEquals(-58.43946468, activity.getGeo().getCoordinates()[1], 0.001);
} finally {
is.close();
}
}
@Override
public void render(Map<String, ?> map, HttpServletRequest req, HttpServletResponse resp)
throws Exception {
AnnotationIntrospector introspector = new JaxbAnnotationIntrospector();
mapper.getDeserializationConfig().setAnnotationIntrospector(introspector);
mapper.getSerializationConfig().setAnnotationIntrospector(introspector);
// resp.setHeader("Content-Type", "text/html; charset=UTF-8"); // "application/json");
JsonGenerator generator =
mapper.getJsonFactory().createJsonGenerator(resp.getOutputStream(), JsonEncoding.UTF8);
ObjectNode json = mapper.valueToTree(map);
// json.put("success", true);
mapper.writeTree(generator, json);
// mapper.writeValue(generator, ret);
generator.flush();
}
@BeforeClass
public static void initBeforeClass() throws Exception {
ObjectMapper mapper = new ObjectMapper();
JsonFactory factory = mapper.getJsonFactory();
JsonParser jp =
factory.createJsonParser(TestTimedEventBuffer.class.getResourceAsStream("/event1.json"));
JsonNode sampleJsonNode = mapper.readTree(jp);
timedEvent1 = TimedEvent.fromJson(sampleJsonNode);
jp = factory.createJsonParser(TestTimedEventBuffer.class.getResourceAsStream("/event2.json"));
sampleJsonNode = mapper.readTree(jp);
timedEvent2 = TimedEvent.fromJson(sampleJsonNode);
EventQueryParser queryParser = new EventQueryParser();
queryModel =
queryParser.parseEventQuery(
"request1.within(\"1990/07/04 12:08:56 PST\", \"2012/07/04 12:08:56 PST\")");
// queryModel = queryParser.parseEventQuery("request.last(\"4hours\").eq(/\"service\"," +
// "#\"Cluster\").eq(/\"service\",#\"Cluster\")");
}
public class LastFM {
final ObjectMapper mapper = new ObjectMapper();
final JsonFactory factory = mapper.getJsonFactory();
List<String> getArtists(final CityCountry cc, final int limit)
throws JsonParseException, MalformedURLException, IOException {
// assemble lastFM URL (uses audioscrobbler)
final String method = "method=geo.getmetroartistchart";
final String country = String.format("country=%s", cc.getCountry());
final String metro = String.format("metro=%s", cc.getCity());
final String apiKey = "api_key=a7b5d6873ba983e70be73d5106a61ebc";
final String lim = String.format("limit=%s", limit);
final String format = "format=json";
final String url =
String.format(
"http://ws.audioscrobbler.com/2.0/?%s&%s&%s&%s&%s&%s",
method, country, metro, lim, apiKey, format);
// get json from URL, parse it
final JsonNode node = mapper.readTree(factory.createJsonParser(new URL(url)));
return parseJson(node);
}
// extract artist names from topartists json
private List<String> parseJson(final JsonNode node) {
JsonNode topartists = node.findValue("topartists");
JsonNode artist = topartists.findValue("artist");
return artist.findValuesAsText("name");
}
// allow json parsing to be unit tested from a local file
public List<String> parseJson(final String fullFile) throws JsonParseException, IOException {
final InputStream is = ClassLoader.getSystemResourceAsStream(fullFile);
final JsonParser jp = factory.createJsonParser(is);
final JsonNode node = mapper.readTree(jp);
return parseJson(node);
}
}
private Object success(Class<?> clazz, HttpInputMessage inputMessage)
throws JsonParseException, IOException {
// Note, parsing code used from ektorp project
JsonParser jp = objectMapper.getJsonFactory().createJsonParser(inputMessage.getBody());
if (jp.nextToken() != JsonToken.START_OBJECT) {
throw new RuntimeException("Expected data to start with an Object");
}
Map<String, Integer> fields = readHeaderFields(jp);
List result;
if (fields.containsKey(TOTAL_ROWS_FIELD_NAME)) {
int totalRows = fields.get(TOTAL_ROWS_FIELD_NAME);
if (totalRows == 0) {
return Collections.emptyList();
}
result = new ArrayList(totalRows);
} else {
result = new ArrayList();
}
ParseState state = new ParseState();
Object first = parseFirstRow(jp, state, clazz);
if (first == null) {
return Collections.emptyList();
} else {
result.add(first);
}
while (jp.getCurrentToken() != null) {
skipToField(jp, state.docFieldName, state);
if (atEndOfRows(jp)) {
return result;
}
result.add(jp.readValueAs(clazz));
endRow(jp, state);
}
return result;
}
/** test a complete unmarshal from the json */
@Test
public void testGetGnip() throws Exception {
final InputStream is =
getClass()
.getClassLoader()
.getResourceAsStream("com/zaubersoftware/gnip4j/payload/payload-example.js");
try {
final JsonParser parser = mapper.getJsonFactory().createJsonParser(is);
final Activity activity = parser.readValueAs(Activity.class);
assertNotNull(activity.getGnip());
assertNotNull(activity.getGnip().getLanguage());
assertEquals("en", activity.getGnip().getLanguage().getValue());
final List<MatchingRules> matchingRules = activity.getGnip().getMatchingRules();
assertNotNull(matchingRules);
assertEquals(1, matchingRules.size());
assertEquals("coke", matchingRules.get(0).getValue());
assertEquals(null, matchingRules.get(0).getTag());
} finally {
is.close();
}
}
public void start() {
ObjectMapper mapper = new ObjectMapper();
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm a z");
mapper.setDateFormat(df);
jsonFactory = mapper.getJsonFactory();
}
public void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.addHeader(CONTENT_TYPE, CONTENT_TYPE_JAVASCRIPT);
request.setCharacterEncoding(ENCODING);
String uri = request.getRequestURI();
String action = uri.substring(uri.lastIndexOf("/"), uri.lastIndexOf("."));
OutputStreamWriter out = new OutputStreamWriter(response.getOutputStream(), ENCODING);
ObjectMapper objectMapper = new ObjectMapper();
DeptService ds = new DeptService();
if (action.equals("/taskList")) {
try {
String name = request.getParameter("name");
List<Map<String, Object>> tasks = ts.getTasks(name);
objectMapper.writeValue(out, tasks); // 用objectMapper的方法
out.close();
} catch (Exception e) {
e.printStackTrace();
throw new ServletException(e);
}
} else if (action.equals("/taskDetail")) {
String taskId = request.getParameter("id");
Map<String, Object> map = new HashMap<String, Object>();
map.put("success", "true");
map.put("msg", "success");
map.put("data", ts.taskDetail(taskId));
objectMapper.writeValue(out, map); // 用objectMapper的方法
out.close();
} else if (action.equals("/addTask")) {
Map<String, Object> map = new HashMap<String, Object>();
map.put("name", request.getParameter("name"));
map.put("time", request.getParameter("time"));
map.put("leaveDay", request.getParameter("leaveDay"));
map.put("content", request.getParameter("content"));
String position = request.getParameter("position");
map.put("position", position);
// 判断是否是manager
if (position.trim().equals("manager")) {
// "manager"变量名与askFor.jpdl.xml中decision里面的变量一致，同时设置的值也要保持一致
map.put("manager", "yes");
} else {
map.put("manager", "no");
}
ts.addTask(map);
Map<String, Object> res = new HashMap<String, Object>();
res.put("success", "true");
res.put("msg", "success");
objectMapper.writeValue(out, res); // 用objectMapper的方法
out.close();
} else if (action.equals("/confirmTask")) {
String taskId = request.getParameter("id");
ts.confirmTask(taskId);
Map<String, Object> map = new HashMap<String, Object>();
map.put("success", "true");
map.put("msg", "success");
objectMapper.writeValue(out, map); // 用objectMapper的方法
out.close();
} else if (action.equals("/rejectTask")) {
String taskId = request.getParameter("id");
ts.rejectTask(taskId);
Map<String, Object> map = new HashMap<String, Object>();
map.put("success", "true");
map.put("msg", "success");
objectMapper.writeValue(out, map); // 用objectMapper的方法
out.close();
} else if (action.equals("/deptView")) {
OutputStreamWriter out1 = new OutputStreamWriter(response.getOutputStream(), ENCODING);
JsonGenerator jsonGenerator = null;
ObjectMapper objectMapper1 = new ObjectMapper();
jsonGenerator = objectMapper1.getJsonFactory().createJsonGenerator(out1);
JSONArray data = ds.deptTree();
jsonGenerator.writeObject(data); // 用jsonGenerator方法输出
out.close();
} else if (action.equals("/deptListView")) {
String deptId = request.getParameter("id");
List<Map<String, Object>> depts = ds.findDept(deptId);
Map<String, Object> map = new HashMap<String, Object>();
map.put("data", depts);
map.put("success", "true");
map.put("msg", "success");
objectMapper.writeValue(out, depts); // 用objectMapper的方法
out.close();
}
}
/** 保存记录 */
@SuppressWarnings("unchecked")
public Integer saveDetails(
String overFlowReason,
String userId,
String deptId,
String applyDate,
Double fee,
String presentType,
String json,
String isDevide)
throws Exception {
ObjectMapper objectMapper = new ObjectMapper();
JsonParser parser = objectMapper.getJsonFactory().createJsonParser(json);
JsonNode nodes = parser.readValueAsTree();
List<HashMap<String, String>> list = new ArrayList<HashMap<String, String>>(nodes.size());
for (JsonNode node : nodes) {
list.add(objectMapper.readValue(node, HashMap.class));
}
Integer result = 0;
DBUtil db = DBUtil.getInstance();
db.setConnectionAttr(false);
try {
// 创建工作流及主记录 DPA(department present apply)部门礼品申请
HashMap<String, String> map = new HashMap<String, String>();
Calendar calendar = Calendar.getInstance();
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
map.put("DeptId", deptId);
map.put("CreateTime", format.format(calendar.getTime()));
map.put("Status", "0");
map.put("OverFlowReason", overFlowReason);
map.put("TotalPrice", String.valueOf(fee));
map.put("ApplyUserID", userId);
map.put("PresentType", presentType);
// map.put("IsDevide", isDevide);
String orderCode = WorkFlowManager.saveNewWorkFlow(db, map, "PresentWorkFlow", "DPA", "32");
// 创建明细记录
for (HashMap<String, String> tempMap : list) {
String sql =
" insert into PresentDetail(OrderCode,PresentName,PresentPrice,Count,ApplyReason) values('"
+ orderCode
+ "','"
+ tempMap.get("presentName")
+ "',"
+ tempMap.get("presentPrice")
+ ","
+ tempMap.get("quantity")
+ ",'"
+ tempMap.get("reason")
+ "')";
db.execute(sql);
}
result = 1;
db.commitConn();
} catch (Throwable e) {
e.printStackTrace();
db.rollBackConn();
}
return result;
}
private JsonNode jsonNodeFromString(String json) throws Exception {
ObjectMapper objectMapper = new ObjectMapper();
JsonFactory factory = objectMapper.getJsonFactory();
JsonNode jsonNode = (JsonNode) objectMapper.readTree(factory.createJsonParser(json));
return jsonNode;
}
