@Override public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException { String thisUsersId = req.getParameter("userId"); if ("true".equals(req.getParameter("pingAlive"))) { updateLastAliveTime(thisUsersId); } else { ObjectMapper mapper = new ObjectMapper(); ArrayNode usersArray = mapper.createArrayNode(); for (Map.Entry<String, User> userEntry : users.entrySet()) { if (!thisUsersId.equals(userEntry.getKey())) { User user = userEntry.getValue(); Date now = new Date(); if ((now.getTime() - user.getLastAliveTime().getTime()) / 1000 <= 10) { ObjectNode userJson = mapper.createObjectNode(); userJson.put("user_id", userEntry.getKey()); userJson.put("user_name", user.getName()); usersArray.add(userJson); } } } ObjectNode usersJson = mapper.createObjectNode(); usersJson.put("opponents", usersArray); resp.setContentType("application/json; charset=UTF-8"); mapper.writeValue(resp.getWriter(), usersJson); } }
@Test public void testGroupByWithSum1() throws JsonGenerationException, JsonMappingException, IOException, InterruptedException { Object[][] rows1 = {{0}, {2}, {2}, {5}, {10}, {100}}; Block block = new ArrayBlock(Arrays.asList(rows1), new String[] {"a"}, 1); TupleOperator operator = new GroupByOperator(); Map<String, Block> input = new HashMap<String, Block>(); input.put("first", block); ObjectMapper mapper = new ObjectMapper(); ObjectNode json = mapper.createObjectNode(); json.put("input", "first"); ArrayNode anode = mapper.createArrayNode(); anode.add("a"); json.put("groupBy", anode); anode = mapper.createArrayNode(); ObjectNode onode = mapper.createObjectNode(); onode.put("type", "SUM"); onode.put("input", "a"); onode.put("output", "sum"); anode.add(onode); json.put("aggregates", anode); BlockProperties props = new BlockProperties(null, new BlockSchema("INT a, INT sum"), (BlockProperties) null); operator.setInput(input, json, props); Block output = new TupleOperatorBlock(operator, props); ArrayBlock.assertData( output, new Object[][] {{0, 0}, {2, 4}, {5, 5}, {10, 10}, {100, 100}}, new String[] {"a", "sum"}); }
/** * Convenience method for creating an error response * * @param jsonRpc the jsonrpc string * @param id the id * @param code the error code * @param message the error message * @param data the error data (if any) * @return the error response */ private ObjectNode createErrorResponse( String jsonRpc, String id, int code, String message, Object data) { ObjectNode response = mapper.createObjectNode(); ObjectNode error = mapper.createObjectNode(); error.put("code", code); error.put("message", message); if (data != null) { error.put("data", mapper.valueToTree(data)); } response.put("jsonrpc", jsonRpc); response.put("id", id); response.put("error", error); return response; }
@Test public void testMergeJoinFullOuterEmptyRight() throws JsonGenerationException, JsonMappingException, IOException, InterruptedException { Object[][] rows1 = {{0}, {2}, {2}, {5}, {10}, {100}}; Object[][] rows2 = {}; Object[][] expected = {{0, null}, {2, null}, {2, null}, {5, null}, {10, null}, {100, null}}; Block block1 = new ArrayBlock(Arrays.asList(rows1), new String[] {"a"}); Block block2 = new ArrayBlock(Arrays.asList(rows2), new String[] {"a"}); TupleOperator operator = new MergeJoinOperator(); Map<String, Block> input = new HashMap<String, Block>(); input.put("block1", block1); input.put("block2", block2); ObjectMapper mapper = new ObjectMapper(); ObjectNode node = mapper.createObjectNode(); node.put("leftCubeColumns", "a"); node.put("rightCubeColumns", "a"); node.put("leftBlock", "block1"); node.put("rightBlock", "block2"); node.put("joinType", "full outer"); BlockProperties props = new BlockProperties( null, new BlockSchema("INT block1___a, INT block2___a"), (BlockProperties) null); operator.setInput(input, node, props); Block output = new TupleOperatorBlock(operator, props); ArrayBlock.assertData(output, expected, new String[] {"block1.a", "block2.a"}); System.out.println("Successfully tested MERGE JOIN FULL OUTER empty block"); }
public String createChallangeNAClaims(String req, String claimDefs, int size) throws Exception { ObjectMapper mapper = new ObjectMapper(); ArrayNode claimDefNodes = (ArrayNode) mapper.readTree(claimDefs); req = req.replaceAll("\"", ""); byte[] reqElemBytes = Base64.decode(req); Element reqElem = null; ArrayList<IdentityClaimDefinition> icds = new ArrayList<IdentityClaimDefinition>(); for (int i = 0; i < size; i++) { String onVal = claimDefNodes.get(i).getTextValue(); ObjectNode claimDefOn = (ObjectNode) mapper.readTree(onVal); IdentityClaimDefinition idClaimDef = new IdentityClaimDefinition(claimDefOn); icds.add(idClaimDef); if (reqElem == null) { Pairing pairing = idClaimDef.getParams().getPairing(); reqElem = pairing.getG1().newElement(); reqElem.setFromBytes(reqElemBytes); // System.out.println(reqElem); } } Pairing pairing = icds.get(0).getParams().getPairing(); Field gt = pairing.getGT(); Element sessionKey = gt.newRandomElement().getImmutable(); Element sessionKeyOrig = sessionKey.getImmutable(); // System.out.println("Key: " + sessionKey); JsonNode rootNode = mapper.createObjectNode(); ObjectNode on = (ObjectNode) rootNode; Encrypt encrypt = new Encrypt(); for (int i = 0; i < size; i++) { IdentityClaimDefinition claimDef = icds.get(i); Element share = null; if (i < (size - 1)) { share = gt.newRandomElement().getImmutable(); sessionKey = sessionKey.sub(share).getImmutable(); } else { // Last one should be the remaining part of session key share = sessionKey; } encrypt.init(claimDef.getParams()); // System.out.println("Part : " + i + " : " + share); AECipherTextBlock ct = encrypt.doEncrypt(share, reqElem); on.put(claimDef.getName(), ct.serializeJSON()); } // System.out.println(sessionKeyOrig); String sk = new String(Base64.encode(sessionKeyOrig.toBytes())); sk = sk.replaceAll(" ", ""); on.put("SessionKey", sk); return on.toString(); }
/** * Create a session key, encrypt it with the given request and claimDef. Return a serialized JSON * node with the session key and challenge. * * @param request Request from user: Base64 encoded bytes of the request element. * @param claimDef Claim definition to use: JSON encoded * @return * @throws Exception */ public String createChallange(String request, String claimDef) throws Exception { ObjectMapper mapper = new ObjectMapper(); ObjectNode claimDefOn = (ObjectNode) mapper.readTree(claimDef); IdentityClaimDefinition idClaimDef = new IdentityClaimDefinition(claimDefOn); byte[] reqElemBytes = Base64.decode(request); Element reqElem = idClaimDef.getParams().getPairing().getG1().newElement(); reqElem.setFromBytes(reqElemBytes); Element sessionKey = idClaimDef.getParams().getPairing().getGT().newRandomElement().getImmutable(); // Encrypt session key Encrypt encrypt = new Encrypt(); encrypt.init(idClaimDef.getParams()); AECipherTextBlock ct = encrypt.doEncrypt(sessionKey, reqElem); JsonNode rootNode = mapper.createObjectNode(); ObjectNode on = (ObjectNode) rootNode; on.put(idClaimDef.getName(), ct.serializeJSON()); String sk = new String(Base64.encode(sessionKey.toBytes())); sk = sk.replaceAll(" ", ""); on.put("SessionKey", sk); return on.toString(); }
@Test public void testSortOperator() throws JsonGenerationException, JsonMappingException, IOException, InterruptedException { System.out.println("Testing SORT operator"); Object[][] rows1 = {{0, 10, 0}, {2, 5, 2}, {2, 8, 5}, {5, 9, 6}, {10, 11, 1}, {100, 6, 10}}; Block block = new ArrayBlock(Arrays.asList(rows1), new String[] {"a", "b", "c"}, 1); TupleOperator operator = new SortOperator(); Map<String, Block> input = new HashMap<String, Block>(); input.put("unsorted", block); ObjectMapper mapper = new ObjectMapper(); ObjectNode json = mapper.createObjectNode(); json.put("input", "unsorted"); ArrayNode anode = mapper.createArrayNode(); anode.add("b"); anode.add("c"); json.put("sortBy", anode); BlockProperties props = new BlockProperties(null, new BlockSchema("INT a, INT b, INT c"), (BlockProperties) null); operator.setInput(input, json, props); Block output = new TupleOperatorBlock(operator, props); System.out.println("output is " + output); ArrayBlock.assertData( output, new Object[][] {{2, 5, 2}, {100, 6, 10}, {2, 8, 5}, {5, 9, 6}, {0, 10, 0}, {10, 11, 1}}, new String[] {"a", "b", "c"}); }
/** * @param keyValues The map to turn into the string. * @return A string of format {"key":"value",...} */ String getMessagesFromMap(final Map<String, String> keyValues) { ObjectNode node = objectMapper.createObjectNode(); for (Map.Entry<String, String> entry : keyValues.entrySet()) { node.put(entry.getKey(), entry.getValue()); } return node.size() > 0 ? node.toString() : null; }
@Test // when there are multiple rows in one table public void testMergeJoin4() throws JsonGenerationException, JsonMappingException, IOException, InterruptedException { Object[][] rows1 = {{0}, {2}, {2}, {5}, {10}, {100}}; Object[][] rows2 = {{1}, {2}, {7}, {9}, {100}, {100}}; Object[][] expected = {{2, 2}, {2, 2}, {100, 100}, {100, 100}}; Block block1 = new ArrayBlock(Arrays.asList(rows1), new String[] {"a"}); Block block2 = new ArrayBlock(Arrays.asList(rows2), new String[] {"a"}); TupleOperator operator = new MergeJoinOperator(); Map<String, Block> input = new HashMap<String, Block>(); input.put("block1", block1); input.put("block2", block2); ObjectMapper mapper = new ObjectMapper(); ObjectNode node = mapper.createObjectNode(); node.put("leftCubeColumns", "a"); node.put("rightCubeColumns", "a"); node.put("leftBlock", "block1"); BlockProperties props = new BlockProperties( null, new BlockSchema("INT block1___a, INT block2___a"), (BlockProperties) null); operator.setInput(input, node, props); Block output = new TupleOperatorBlock(operator, props); ArrayBlock.assertData(output, expected, new String[] {"block1.a", "block2.a"}); }
@Test public void testCombinedBlockLeftRunsout() throws JsonGenerationException, JsonMappingException, IOException, InterruptedException { Object[][] rows1 = {{2}, {7}, {9}}; Object[][] rows2 = {{3}, {5}, {10}}; Block block1 = new ArrayBlock(Arrays.asList(rows1), new String[] {"a"}, 1); Block block2 = new ArrayBlock(Arrays.asList(rows2), new String[] {"a"}, 1); TupleOperator operator = new CombineOperator(); Map<String, Block> input = new HashMap<String, Block>(); input.put("cube1", block1); input.put("cube2", block2); ObjectMapper mapper = new ObjectMapper(); ObjectNode node = mapper.createObjectNode(); JsonNode ct = mapper.readValue("[\"a\"]", JsonNode.class); node.put("pivotBy", ct); BlockProperties props = new BlockProperties(null, new BlockSchema("INT a"), (BlockProperties) null); operator.setInput(input, node, props); Block output = new TupleOperatorBlock(operator, props); ArrayBlock.assertData( output, new Object[][] {{2}, {3}, {5}, {7}, {9}, {10}}, new String[] {"a"}); }
public void testDictionaryEncoding() throws IOException, InterruptedException { // create dictionary block Object[][] dictRows = {{1000, 100, 1}, {1000, 101, 2}}; Block dictionary = new ArrayBlock(Arrays.asList(dictRows), new String[] {"colname", "colvalue", "code"}); // create data block Object[][] dataRows = {{100, 10}, {100, 11}, {101, 10}}; Block dataBlock = new ArrayBlock(Arrays.asList(dataRows), new String[] {"1000", "a"}); // create operator Map<String, Block> input = new HashMap<String, Block>(); input.put("block1", dictionary); input.put("block2", dataBlock); ObjectMapper mapper = new ObjectMapper(); ObjectNode node = mapper.createObjectNode(); node.put("dictionary", "block1"); TupleOperator operator = new DictionaryEncodeOperator(); BlockProperties props = new BlockProperties(null, new BlockSchema("INT 1000, INT a"), (BlockProperties) null); operator.setInput(input, node, props); Block output = new TupleOperatorBlock(operator, props); Object[][] expected = {{1, 10}, {1, 11}, {2, 10}}; ArrayBlock.assertData(output, expected, new String[] {"1000", "a"}); }
public ObjectNode processMutHm(long entrezGeneId, ArrayList<Integer> sampleList, HashMap mutHm) { ObjectNode _datum = mapper.createObjectNode(); // create map to pair sample and value HashMap<Integer, String> mapSampleValue = new HashMap<>(); for (Integer sampleId : sampleList) { // Assign every sample (included non mutated ones) values -- mutated -> // Mutation Type, non-mutated -> "Non" String mutationStatus = "Non"; String tmpStr = new StringBuilder() .append(Integer.toString(sampleId)) .append(Long.toString(entrezGeneId)) .toString(); if (mutHm.containsKey(tmpStr)) mutationStatus = "Mutated"; mapSampleValue.put(sampleId, mutationStatus); } // remove empty entry Iterator it = mapSampleValue.entrySet().iterator(); while (it.hasNext()) { Map.Entry pair = (Map.Entry) it.next(); if (pair.getValue().equals("NA") || pair.getValue().equals("NaN") || pair.getValue().equals("null")) { it.remove(); } } // get Gene Name and Cytoband DaoGeneOptimized daoGeneOptimized = DaoGeneOptimized.getInstance(); String geneName = daoGeneOptimized.getGene(entrezGeneId).getHugoGeneSymbolAllCaps(); String cytoband = daoGeneOptimized.getGene(entrezGeneId).getCytoband(); // statistics analysis if (!(Arrays.asList(queriedGenes)).contains(geneName)) { // remove queried genes from result _datum.put(COL_NAME_GENE, geneName); _datum.put(COL_NAME_CYTOBAND, cytoband); _datum.put(COL_NAME_PCT_ALTERED, calcPct(mapSampleValue, profileType, "altered")); _datum.put(COL_NAME_PCT_UNALTERED, calcPct(mapSampleValue, profileType, "unaltered")); _datum.put( COL_NAME_RATIO, calcRatio( calcPct(mapSampleValue, profileType, "altered"), calcPct(mapSampleValue, profileType, "unaltered"))); _datum.put(COL_NAME_DIRECTION, "place holder"); // calculation is done by the front-end _datum.put(COL_NAME_P_VALUE, calcPval(mapSampleValue, profileType, geneticProfileStableId)); if (!(calcPct(mapSampleValue, profileType, "altered") == 0.0 && calcPct(mapSampleValue, profileType, "unaltered") == 0.0) && !Double.isNaN(calcPval(mapSampleValue, profileType, geneticProfileStableId))) { return _datum; } } return null; }
public JsonNode serialize(Locale locale, ObjectMapper mapper) { final ObjectNode jsonOverview = mapper.createObjectNode(); if (this.getLastResult() != null) { jsonOverview.put("text_result", this.getLastResult().getTextResult()); jsonOverview.put("content_type", this.getLastResult().getContentType()); } else { jsonOverview.put("text_result", (String) null); jsonOverview.put("content_type", (String) null); } return jsonOverview; }
@Test public void showRoles() { ObjectMapper m = new ObjectMapper(); ObjectNode body = m.createObjectNode(); body.put("domain_object", "system"); body.put("user", "datenbereitstellera"); JsonNode node = client.showRoles(body); log.info("roles: {}", node.toString()); }
@Test public void showUser() { ObjectMapper m = new ObjectMapper(); ObjectNode body = m.createObjectNode(); ClientResponse<JsonNode> response = client.showUser( (String) properties.getProperty(PROPERTY_NAME_CKAN_AUTHORIZATION_KEY), body); if (response.getStatus() == Response.Status.OK.getStatusCode()) { log.info(response.getEntity().toString()); } }
public String toJson(ObjectMapper mapper) { ObjectNode rootNode = mapper.createObjectNode(); ArrayNode keysNode = rootNode.putArray("keys"); for (Object key : keys) { keysNode.addPOJO(key); } try { return mapper.writeValueAsString(rootNode); } catch (Exception e) { throw Exceptions.propagate(e); } }
/** * Calculate the results graph data. The graph includes final rank graph and final vs provisional * score graph. * * @param resultInfos the results */ private void calculateResultsGraphData(List<ResultInfo> resultInfos) { // Sort the results info by final score. Collections.sort( resultInfos, new Comparator<ResultInfo>() { public int compare(ResultInfo resultInfo, ResultInfo resultInfo2) { if (resultInfo.getFinalRank() < resultInfo2.getFinalRank()) { return 0; } if (resultInfo.getFinalRank() == resultInfo2.getFinalRank()) { return String.CASE_INSENSITIVE_ORDER.compare( resultInfo.getHandle(), resultInfo2.getHandle()); } return 1; } }); ObjectMapper objectMapper = new ObjectMapper(); ObjectNode finalScoreRankingData = objectMapper.createObjectNode(); ObjectNode finalVsProvisionalScoreData = objectMapper.createObjectNode(); ArrayNode rating = objectMapper.createArrayNode(); ArrayNode score = objectMapper.createArrayNode(); for (ResultInfo result : resultInfos) { ObjectNode finalScoreNode = objectMapper.createObjectNode(); finalScoreNode.put("handle", result.getHandle()); finalScoreNode.put("number", result.getFinalScore()); finalScoreNode.put("rank", result.getFinalRank()); rating.add(finalScoreNode); ObjectNode finalProvisionalScoreNode = objectMapper.createObjectNode(); finalProvisionalScoreNode.put("handle", result.getHandle()); finalProvisionalScoreNode.put("finalScore", result.getFinalScore()); finalProvisionalScoreNode.put("provisionalScore", result.getProvisionalScore()); score.add(finalProvisionalScoreNode); } finalScoreRankingData.put("rating", rating); finalVsProvisionalScoreData.put("score", score); viewData.setFinalScoreRankingData(finalScoreRankingData.toString()); viewData.setFinalVsProvisionalScoreData(finalVsProvisionalScoreData.toString()); }
public static void main(String args[]) { JacksonTester tester = new JacksonTester(); try { ObjectMapper mapper = new ObjectMapper(); JsonNode rootNode = mapper.createObjectNode(); JsonNode marksNode = mapper.createArrayNode(); ((ArrayNode) marksNode).add(100); ((ArrayNode) marksNode).add(90); ((ArrayNode) marksNode).add(85); ((ObjectNode) rootNode).put("name", "Mahesh Kumar"); ((ObjectNode) rootNode).put("age", 21); ((ObjectNode) rootNode).put("verified", false); ((ObjectNode) rootNode).put("marks", marksNode); mapper.writeValue(new File("student.json"), rootNode); rootNode = mapper.readTree(new File("student.json")); JsonNode nameNode = rootNode.path("name"); System.out.println("Name: " + nameNode.getTextValue()); JsonNode ageNode = rootNode.path("age"); System.out.println("Age: " + ageNode.getIntValue()); JsonNode verifiedNode = rootNode.path("verified"); System.out.println("Verified: " + (verifiedNode.getBooleanValue() ? "Yes" : "No")); JsonNode marksNode1 = rootNode.path("marks"); Iterator<JsonNode> iterator = marksNode1.getElements(); System.out.print("Marks: [ "); while (iterator.hasNext()) { JsonNode marks = iterator.next(); System.out.print(marks.getIntValue() + " "); } System.out.println("]"); } catch (JsonParseException e) { e.printStackTrace(); } catch (JsonMappingException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }
public List<String> map(String metrics, Map<String, String> tags) { try { ObjectMapper objectMapper = new ObjectMapper(); JsonNode jsonNode = objectMapper.readTree(metrics); ObjectNode objectNode = objectMapper.createObjectNode(); objectNode.put("@timestamp", System.currentTimeMillis()); objectNode.put("metrics", jsonNode); for (Map.Entry<String, String> tag : tags.entrySet()) { objectNode.put(tag.getKey(), tag.getValue()); } return ImmutableList.of(objectMapper.writeValueAsString(objectNode)); } catch (IOException e) { throw new RuntimeException("Failed to create metrics", e); } }
public JsonNode getTask( FramedGraph<OrientBaseGraph> orientGraph, ObjectMapper objectMapper, String taskJid) { final ORID taskRid = RidConverter.convertToRID(taskJid); final XTask task = orientGraph.getVertex(taskRid, XTask.class); if (task == null) throw new ObjectNotFoundException("Task with jid " + taskJid + " does not exist."); ObjectNode result = objectMapper.createObjectNode(); result.put("status", task.getStatus()); DateFormat dateFormat = DateFormat.getDateTimeInstance(); result.put("startTime", dateFormat.format(task.getStartTime())); result.put("jid", RidConverter.convertFromRID((ORID) task.asVertex().getId())); return result; }
@Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { String lastUserIdStr = null; String userName = req.getParameter("user_name"); synchronized (this) { lastUserIdStr = Integer.toString(++lastUserId); User user = new User(lastUserIdStr, userName, new Date()); users.put(lastUserIdStr, user); } ObjectMapper mapper = new ObjectMapper(); ObjectNode userJson = mapper.createObjectNode(); userJson.put("user_id", lastUserIdStr); userJson.put("user_name", userName); resp.setContentType("application/json; charset=UTF-8"); mapper.writeValue(resp.getWriter(), userJson); }
public static void submit(String submissionIdentifier, String pipeline, int startingProcessIndex) throws IOException { setup(); ObjectNode userOb = objectMapper.createObjectNode(); userOb.put("priority", properties.getProperty("biosamples.conan.priority")); userOb.put("pipelineName", pipeline); userOb.put("startingProcessIndex", startingProcessIndex); userOb.put("restApiKey", properties.getProperty("biosamples.conan.apikey")); ObjectNode inputParameters = userOb.putObject("inputParameters"); inputParameters.put("SampleTab Accession", submissionIdentifier); log.trace(userOb.toString()); // Send data HttpPost postRequest = new HttpPost(properties.getProperty("biosamples.conan.url") + "/api/submissions/"); postRequest.setConfig( RequestConfig.custom() .setSocketTimeout(0) .setConnectTimeout(0) .setConnectionRequestTimeout(0) .build()); StringEntity input = new StringEntity(userOb.toString()); input.setContentType("application/json"); postRequest.setEntity(input); // get response try (CloseableHttpResponse response = httpClient.execute(postRequest)) { try (BufferedReader br = new BufferedReader(new InputStreamReader((response.getEntity().getContent())))) { // TODO parse response and raise exception if submit failed String line; while ((line = br.readLine()) != null) { log.info(line); } } EntityUtils.consume(response.getEntity()); } }
public boolean writeInfoToResourceFile(String resourceFileName) { ObjectMapper objMapper = new ObjectMapper(); ObjectNode infoObj = objMapper.createObjectNode(); infoObj.put("loginId", loginId); infoObj.put("mainSummoner", mainSummoner); infoObj.put("client version", clientVersion); infoObj.put("mainServer", mainServer.getServerCode()); int i = 0; for (String summonerName : summonerList) { infoObj.put("summoner" + i, summonerName); i++; } try { objMapper.writeValue(new File(resourceFileName), infoObj); } catch (IOException e) { e.printStackTrace(); } return true; }
@Test // testing multiple join keys public void testMergeJoinMultipleJoinKeys() throws JsonGenerationException, JsonMappingException, IOException, InterruptedException { Object[][] rows1 = {{0, 1}, {2, 1}, {2, 2}, {5, 1}, {10, 1}, {100, 1}}; Object[][] rows2 = {{1, 1}, {2, 0}, {2, 1}, {5, 1}, {100, 2}, {100, 3}}; Object[][] expected = {{2, 1, 2, 1}, {5, 1, 5, 1}}; Block block1 = new ArrayBlock(Arrays.asList(rows1), new String[] {"a", "b"}); Block block2 = new ArrayBlock(Arrays.asList(rows2), new String[] {"c", "a"}); TupleOperator operator = new MergeJoinOperator(); Map<String, Block> input = new HashMap<String, Block>(); input.put("block1", block1); input.put("block2", block2); ObjectMapper mapper = new ObjectMapper(); ObjectNode node = mapper.createObjectNode(); ArrayNode lkeys = mapper.createArrayNode(); lkeys.add("a"); lkeys.add("b"); node.put("leftCubeColumns", lkeys); ArrayNode rkeys = mapper.createArrayNode(); rkeys.add("c"); rkeys.add("a"); node.put("rightCubeColumns", rkeys); node.put("leftBlock", "block1"); BlockProperties props = new BlockProperties( null, new BlockSchema("INT block1___a, INT block1___b, INT block2___c, INT block2___a"), (BlockProperties) null); operator.setInput(input, node, props); Block output = new TupleOperatorBlock(operator, props); ArrayBlock.assertData(output, expected, new String[] {"block1.a", "block2.a"}); }
@Get public ObjectNode getById() { ObjectNode modelNode = null; ObjectMapper objectMapper = new ObjectMapper(); modelNode = objectMapper.createObjectNode(); String output = (String) getRequest().getAttributes().get("output"); String id = (String) getRequest().getAttributes().get("userId"); TSUser tsUser = userService.get(TSUser.class, id); Map<String, String> excludeProperty = new HashMap<String, String>(); excludeProperty.put("TSDepart", "TSDepart"); if (output != null && output.equals("json")) { modelNode.put("result", Utils.toSingleJson(tsUser, TSUser.class, excludeProperty).toString()); } if (output != null && output.equals("xml")) { try { modelNode.put("result", Utils.toSingleXml(tsUser, TSUser.class, excludeProperty).getText()); } catch (IOException e) { e.printStackTrace(); } } return modelNode; }
/** * Handles the given {@link ObjectNode} and writes the responses to the given {@link * OutputStream}. * * @param node the {@link JsonNode} * @param ops the {@link OutputStream} * @throws JsonGenerationException * @throws JsonMappingException * @throws IOException */ private void handleObject(ObjectNode node, OutputStream ops) throws JsonGenerationException, JsonMappingException, IOException { // validate request if (!node.has("jsonrpc") || !node.has("method")) { mapper.writeValue( ops, createErrorResponse("jsonrpc", "null", -32600, "Invalid Request", null)); return; } // parse request String jsonRpc = node.get("jsonrpc").getValueAsText(); String methodName = node.get("method").getValueAsText(); String id = node.get("id").getValueAsText(); JsonNode params = node.get("params"); int paramCount = (params != null) ? params.size() : 0; // find methods Set<Method> methods = new HashSet<Method>(); methods.addAll(ReflectionUtil.findMethods(getHandlerClass(), methodName)); // method not found if (methods.isEmpty()) { mapper.writeValue(ops, createErrorResponse(jsonRpc, id, -32601, "Method not found", null)); return; } // iterate through the methods and remove // the one's who's parameter count's don't // match the request Iterator<Method> itr = methods.iterator(); while (itr.hasNext()) { Method method = itr.next(); if (method.getParameterTypes().length != paramCount) { itr.remove(); } } // choose a method Method method = null; List<JsonNode> paramNodes = new ArrayList<JsonNode>(); // handle param arrays, no params, and single methods if (paramCount == 0 || params.isArray() || (methods.size() == 1)) { method = methods.iterator().next(); for (int i = 0; i < paramCount; i++) { paramNodes.add(params.get(i)); } // handle named params } else if (params.isObject()) { // loop through each method for (Method m : methods) { // get method annotations Annotation[][] annotations = m.getParameterAnnotations(); boolean found = true; List<JsonNode> namedParams = new ArrayList<JsonNode>(); for (int i = 0; i < annotations.length; i++) { // look for param name annotations String paramName = null; for (int j = 0; j < annotations[i].length; j++) { if (!JsonRpcParamName.class.isInstance(annotations[i][j])) { continue; } else { paramName = JsonRpcParamName.class.cast(annotations[i][j]).value(); continue; } } // bail if param name wasn't found if (paramName == null) { found = false; break; // found it by name } else if (params.has(paramName)) { namedParams.add(params.get(paramName)); } } // did we find it? if (found) { method = m; paramNodes.addAll(namedParams); break; } } } // invalid parameters if (method == null) { mapper.writeValue( ops, createErrorResponse(jsonRpc, id, -32602, "Invalid method parameters.", null)); return; } // invoke the method JsonNode result = null; ObjectNode error = null; Throwable thrown = null; try { result = invoke(method, paramNodes); } catch (Throwable e) { thrown = e; if (InvocationTargetException.class.isInstance(e)) { e = InvocationTargetException.class.cast(e).getTargetException(); } error = mapper.createObjectNode(); error.put("code", 0); error.put("message", e.getMessage()); error.put("data", e.getClass().getName()); } // bail if notification request if (id == null) { return; } // create response ObjectNode response = mapper.createObjectNode(); response.put("jsonrpc", jsonRpc); response.put("id", id); if (error == null) { response.put("result", result); } else if (error != null) { response.put("error", error); } // write it mapper.writeValue(ops, response); // re-throw errors if (thrown != null) { throw new RuntimeException(thrown); } }
@org.junit.Test public void testMerge() { standardInit(); ObjectMapper mapper = new ObjectMapper(); ObjectNode to_merge = mapper.createObjectNode(); int[] vector = {0, 0, 1, 0}; ArrayNode timestamp1 = createSerializedTimestamp(vector, mapper); ArrayNode timestamp2 = createSerializedTimestamp(vector, mapper); ObjectNode yale_value = mapper.createObjectNode(); yale_value.put("shmem_timestamp", timestamp2); yale_value.put("value", "College"); ObjectNode yale_node = mapper.createObjectNode(); yale_node.put("Yale", yale_value); ObjectNode name_value = mapper.createObjectNode(); name_value.put("shmem_timestamp", timestamp1); name_value.put("value", yale_node); ObjectNode name_object = mapper.createObjectNode(); name_object.put("name", name_value); // The merge should fail. We're expecting a MergeException. Throwable expected_exception = null; try { ShMem.s_state.merge(name_object, ""); } catch (Exception ex) { expected_exception = ex; } assertTrue(expected_exception instanceof ShMemObject.MergeException); // Now try merging something that doesn't conflict. expected_exception = null; standardInit(); ObjectNode abc_value = mapper.createObjectNode(); abc_value.put("value", "xyz"); abc_value.put("shmem_timestamp", timestamp1); ObjectNode abc_node = mapper.createObjectNode(); abc_node.put("abc", abc_value); // The merge should go through fine. try { ShMem.s_state.merge(abc_node, ""); } catch (Exception ex) { expected_exception = ex; } assertTrue(expected_exception == null); String xyz_string = ShMem.s_state.get("abc").getTextValue(); assertTrue(xyz_string.equals("xyz")); standardInit(); int[] new_timestamp = {2, 2, 1, 0}; timestamp1 = createSerializedTimestamp(new_timestamp, mapper); timestamp2 = createSerializedTimestamp(new_timestamp, mapper); yale_value.put("shmem_timestamp", timestamp2); name_value.put("shmem_timestamp", timestamp1); expected_exception = null; try { ShMem.s_state.merge(name_object, ""); } catch (Exception e) { expected_exception = e; } assertTrue(expected_exception == null); assertEquals(VectorTimestamp.Compare(ShMemObject.s_now, new_timestamp), Comparison.EQ); String college_string = ShMem.s_state.get("name").get("Yale").getTextValue(); assertTrue(college_string.equals("College")); int[] yale_timestamp = ((ShMemObject) ShMem.s_state.get("name")).m_key_map.get("Yale").m_timestamp; assertEquals(VectorTimestamp.Compare(yale_timestamp, new_timestamp), Comparison.EQ); int[] name_timestamp = ShMem.s_state.m_key_map.get("name").m_timestamp; assertEquals(VectorTimestamp.Compare(name_timestamp, new_timestamp), Comparison.EQ); }
@Override public ObjectNode process(long entrezGeneId, String[] values, ArrayList<Integer> sampleList) { ObjectNode _datum = mapper.createObjectNode(); // create map to pair sample and value HashMap<Integer, String> mapSampleValue = new HashMap<>(); for (int i = 0; i < values.length; i++) { String value = values[i]; Integer sampleId = sampleList.get(i); mapSampleValue.put(sampleId, value); } // remove empty entry Iterator it = mapSampleValue.entrySet().iterator(); while (it.hasNext()) { Map.Entry pair = (Map.Entry) it.next(); if (pair.getValue().equals("NA") || pair.getValue().equals("NaN") || pair.getValue().equals("null")) { it.remove(); } } // get Gene Name and Cytoband DaoGeneOptimized daoGeneOptimized = DaoGeneOptimized.getInstance(); String geneName = daoGeneOptimized.getGene(entrezGeneId).getHugoGeneSymbolAllCaps(); String cytoband = daoGeneOptimized.getGene(entrezGeneId).getCytoband(); // statistics analysis if (profileType.equals(GeneticAlterationType.COPY_NUMBER_ALTERATION.toString())) { if (!(Arrays.asList(queriedGenes)).contains(geneName)) { // remove queried genes from result _datum.put(COL_NAME_GENE, geneName); _datum.put(COL_NAME_CYTOBAND, cytoband); _datum.put( COL_NAME_PCT_ALTERED, Integer.toString(countAltered(mapSampleValue, profileType, "altered")) + "////" + Double.toString(calcPct(mapSampleValue, profileType, "altered"))); _datum.put( COL_NAME_PCT_UNALTERED, Integer.toString(countAltered(mapSampleValue, profileType, "unaltered")) + "////" + Double.toString(calcPct(mapSampleValue, profileType, "unaltered"))); _datum.put( COL_NAME_RATIO, calcRatio( calcPct(mapSampleValue, profileType, "altered"), calcPct(mapSampleValue, profileType, "unaltered"))); _datum.put(COL_NAME_DIRECTION, "place holder"); // calculation is done by the front-end _datum.put(COL_NAME_P_VALUE, calcPval(mapSampleValue, profileType, geneticProfileStableId)); if (!(calcPct(mapSampleValue, profileType, "altered") == 0.0 && calcPct(mapSampleValue, profileType, "unaltered") == 0.0) && !Double.isNaN(calcPval(mapSampleValue, profileType, geneticProfileStableId))) { return _datum; } } } else if (profileType.equals(GeneticAlterationType.MRNA_EXPRESSION.toString())) { _datum.put(COL_NAME_GENE, geneName); _datum.put(COL_NAME_CYTOBAND, cytoband); _datum.put( COL_NAME_MEAN_ALTERED, calcMean(mapSampleValue, "altered", geneticProfileStableId)); _datum.put( COL_NAME_MEAN_UNALTERED, calcMean(mapSampleValue, "unaltered", geneticProfileStableId)); _datum.put( COL_NAME_STDEV_ALTERED, calcSTDev(mapSampleValue, "altered", geneticProfileStableId)); _datum.put( COL_NAME_STDEV_UNALTERED, calcSTDev(mapSampleValue, "unaltered", geneticProfileStableId)); _datum.put(COL_NAME_P_VALUE, calcPval(mapSampleValue, profileType, geneticProfileStableId)); if (!Double.isNaN(calcPval(mapSampleValue, profileType, geneticProfileStableId))) { return _datum; } } else if (profileType.equals(GeneticAlterationType.PROTEIN_LEVEL.toString())) { _datum.put(COL_NAME_GENE, geneName); _datum.put(COL_NAME_CYTOBAND, cytoband); _datum.put( COL_NAME_MEAN_ALTERED, calcMean(mapSampleValue, "altered", geneticProfileStableId)); _datum.put( COL_NAME_MEAN_UNALTERED, calcMean(mapSampleValue, "unaltered", geneticProfileStableId)); _datum.put( COL_NAME_STDEV_ALTERED, calcSTDev(mapSampleValue, "altered", geneticProfileStableId)); _datum.put( COL_NAME_STDEV_UNALTERED, calcSTDev(mapSampleValue, "unaltered", geneticProfileStableId)); _datum.put(COL_NAME_P_VALUE, calcPval(mapSampleValue, profileType, geneticProfileStableId)); if (!Double.isNaN(calcPval(mapSampleValue, profileType, geneticProfileStableId))) { return _datum; } } return null; }
private void serialize() throws GVCException { JsonGenerator jsonGenerator; StringWriter stringWriter = new StringWriter(); try { jsonGenerator = jsonFactory.createJsonGenerator(stringWriter); } catch (IOException e) { throw new GVCException(e); } jsonGenerator.useDefaultPrettyPrinter(); ObjectNode rootNode = objectMapper.createObjectNode(); // Parent if (this.parent == null) rootNode.put("parent", "null"); else rootNode.put("parent", this.parent.getHash()); // Date rootNode.put("date", df.format(this.date)); // Comment rootNode.put("comment", this.comment); // Files Added /* This is a JSON "object", it looks something like this: * { * filesAdded: { * sd5df5s2: [file1, file2], * f52s556c: [file3] * } * } */ if (this.filesAdded == null) { rootNode.put("filesAdded", "null"); } else { ObjectNode addedOb = rootNode.putObject("filesAdded"); for (String fHash : this.filesAdded.keySet()) { // this will be an array of filenames for this hash ArrayNode aNode = addedOb.putArray(fHash); for (File file : this.filesAdded.get(fHash)) { // Normalize the filesystem separator to / String fileS = file.toString().replace(File.separator, "/"); aNode.add(fileS); } } } // Files Removed if (this.filesRemoved == null) { rootNode.put("filesRemoved", "null"); } else { ObjectNode removedOb = rootNode.putObject("filesRemoved"); for (String fHash : this.filesRemoved.keySet()) { // this will be an array of filenames for this hash ArrayNode rNode = removedOb.putArray(fHash); for (File file : this.filesRemoved.get(fHash)) { // Normalize the filesystem separator to / String fileS = file.toString().replace(File.separator, "/"); rNode.add(fileS); } } } // And write it all out to a string. try { jsonGenerator.writeObject(rootNode); this.serialized = stringWriter.getBuffer().toString(); } catch (Exception e) { throw new GVCException(e); } }
/** * @param request * @param claimDefs Array of claim defs * @return * @throws Exception */ public String createChallangeNClaimsThreads(String requests, String claimDefs) throws Exception { ObjectMapper mapper = new ObjectMapper(); // System.out.println(requests); String[] split = requests.split(","); ArrayNode claimDefNodes = (ArrayNode) mapper.readTree(claimDefs); ArrayList<IdentityClaimDefinition> icds = new ArrayList<IdentityClaimDefinition>(); ArrayList<Element> reqs = new ArrayList<Element>(); for (int i = 0; i < split.length; i++) { String onVal = claimDefNodes.get(i).getTextValue(); ObjectNode claimDefOn = (ObjectNode) mapper.readTree(onVal); IdentityClaimDefinition idClaimDef = new IdentityClaimDefinition(claimDefOn); icds.add(idClaimDef); Pairing pairing = idClaimDef.getParams().getPairing(); // System.out.println(idClaimDef.serializeJSON()); String tmpReq = split[i].replaceAll("\"", ""); byte[] reqElemBytes = Base64.decode(tmpReq); // System.out.println(reqElemBytes.length); Element reqElem = pairing.getG1().newElement(); reqElem.setFromBytes(reqElemBytes); // System.out.println(reqElem.getImmutable()); reqs.add(reqElem); } Pairing pairing = icds.get(0).getParams().getPairing(); Field gt = pairing.getGT(); Element sessionKey = gt.newRandomElement().getImmutable(); Element sessionKeyOrig = sessionKey.getImmutable(); // System.out.println("Key: " + sessionKey); JsonNode rootNode = mapper.createObjectNode(); ObjectNode on = (ObjectNode) rootNode; ArrayList<EncrypterThread> ets = new ArrayList<ServiceProvider.EncrypterThread>(); for (int i = 0; i < split.length; i++) { IdentityClaimDefinition claimDef = icds.get(i); Element share = null; if (i < (split.length - 1)) { share = gt.newRandomElement().getImmutable(); sessionKey = sessionKey.sub(share).getImmutable(); } else { // Last one should be the remaining part of session key share = sessionKey; } EncrypterThread t = new EncrypterThread(claimDef.getName(), claimDef.getParams(), share, reqs.get(i), on); t.start(); ets.add(t); } for (EncrypterThread t : ets) { t.join(); } String sk = new String(Base64.encode(sessionKeyOrig.toBytes())); sk = sk.replaceAll(" ", ""); on.put("SessionKey", sk); return on.toString(); }