Example usage for org.json.simple JSONObject writeJSONString

List of usage examples for org.json.simple JSONObject writeJSONString

Introduction

In this page you can find the example usage for org.json.simple JSONObject writeJSONString.

Prototype

public void writeJSONString(Writer out) throws IOException 

Source Link

Usage

From source file:com.mobicage.rogerthat.xmpp.CallBackApiXMPPListener.java

/**
 * Establish an XMPP connection to XmppService and listen for Rogerthat API callbacks.
 *///  ww w .  j  a v  a 2  s . c o m
public void startListening() {

    if (connectionThread != null) {
        throw new RuntimeException("Previous connection has not yet been closed!");
    }

    if (xmppUsername == null || xmppService == null || xmppPassword == null || sik == null)
        throw new RuntimeException("Not enough information present to setup an xmpp connection");

    final ConnectionListener connectionListener = new ConnectionListener() {
        @Override
        public void reconnectionSuccessful() {
            log.info("Reconnection to jabber server succeeded.");
            status = XmppConnectionStatus.Connected;
        }

        @Override
        public void reconnectionFailed(Exception e) {
            log.info("Reconnection to jabber server failed.");
        }

        @Override
        public void reconnectingIn(int seconds) {
            log.info("Reconnecting to jabber in " + seconds + " seconds ...");
            status = XmppConnectionStatus.Reconnecting;
        }

        @Override
        public void connectionClosedOnError(Exception e) {
            log.info("Connection closed to jabber due to " + e.toString());
        }

        @Override
        public void connectionClosed() {
            log.info("Connection to jabber closed.");
        }
    };

    tasks.clear();

    connectionThread = new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                while (true) {
                    Runnable task = tasks.take();
                    task.run();
                }
            } catch (StopListeningException e) {
                disconnect(connectionListener);
                status = XmppConnectionStatus.Closed;
                statusLine = "";
            } catch (Throwable e) {
                disconnect(connectionListener);
                status = XmppConnectionStatus.Closed;
                statusLine = "Connection interrupted.";
            } finally {
                connectionThread = null;
            }
        }
    });
    connectionThread.setName("Rogerthat callback listener");
    connectionThread.setDaemon(true);
    connectionThread.start();

    tasks.add(new Runnable() {
        @Override
        public void run() {
            ConnectionConfiguration conf = new ConnectionConfiguration(xmppService);

            status = XmppConnectionStatus.Connecting;

            log.info("Connecting to jabber server ...");
            conn = new XMPPConnection(conf);
            try {
                conn.connect();
            } catch (XMPPException e) {
                status = XmppConnectionStatus.ConnectionFailed;
                statusLine = "Failed to reach Rogerthat servers.\n" + e.getMessage();
                conn = null;
                connectionThread = null;
                if (onConnectionFailed != null)
                    try {
                        onConnectionFailed.run();
                    } catch (Throwable t) {
                        log.log(Level.WARNING, "Failure in onConnectionFailed handler.", t);
                    }
                throw new RuntimeException(e); // Stop thread.
            }

            if (onConnected != null)
                try {
                    onConnected.run();
                } catch (Throwable t) {
                    log.log(Level.WARNING, "Failure in onConnected handler.", t);
                }

            conn.addConnectionListener(connectionListener);

            SASLAuthentication.supportSASLMechanism("PLAIN", 0);

            PacketFilter filter = new PacketFilter() {
                @Override
                public boolean accept(Packet packet) {
                    boolean accept = packet instanceof Message
                            && ROGERTHAT_CALLBACK_BOT.equals(packet.getFrom());
                    if (!accept)
                        log.info("Dropping packet:\n" + packet.toXML());
                    return accept;
                }
            };

            conn.addPacketListener(new PacketListener() {
                @Override
                public void processPacket(Packet packet) {
                    log.info("Processing packet:\n" + packet.toXML());
                    if (!(packet instanceof Message)) {
                        log.info("Ignoring non message packet.");
                        return;
                    }
                    Message message = (Message) packet;
                    PacketExtension extension = packet.getExtension("call", "mobicage:comm");
                    if (extension == null || !(extension instanceof CallbackRequestExtension)) {
                        log.info("Ignoring incomplete packet.");
                        return;
                    }
                    CallbackRequestExtension call = (CallbackRequestExtension) extension;
                    if (!sik.equals(call.getSik())) {
                        log.info("Ignoring packet with incorrect sik.");
                        return;
                    }
                    String json;
                    try {
                        json = new String(DatatypeConverter.parseBase64Binary(call.getBase64Body()), "UTF-8");
                    } catch (UnsupportedEncodingException e) {
                        log.log(Level.WARNING, "Could not decode base64 packet.", e);
                        return;
                    }
                    final JSONObject request = (JSONObject) JSONValue.parse(json);

                    if (logTraffic)
                        log.info(String.format("Incoming Rogerthat API Callback.\nSIK: %s\n\n%s", sik, json));

                    final String id = (String) request.get("id");

                    if (callbackDedup != null) {
                        byte[] response = callbackDedup.getResponse(id);
                        if (response != null) {
                            Message resultMessage = new Message(message.getFrom());
                            resultMessage.setFrom(message.getTo());
                            resultMessage.addExtension(new CallbackResponseExtension(sik,
                                    DatatypeConverter.printBase64Binary(response)));
                            log.info("Sending message:\n" + resultMessage.toXML());
                            conn.sendPacket(resultMessage);
                            return;
                        }
                    }

                    final JSONObject result = new JSONObject();
                    final RequestContext requestContext = new RequestContext(id, sik);
                    try {
                        processor.process(request, result, requestContext);
                    } finally {
                        try {
                            StringWriter writer = new StringWriter();
                            try {
                                result.writeJSONString(writer);
                                writer.flush();
                                json = writer.toString();

                                if (logTraffic)
                                    log.info("Returning result:\n" + json);

                            } finally {
                                writer.close();
                            }
                        } catch (IOException e) {
                            log.log(Level.SEVERE, "Could not write json object to string", e);
                            return;
                        }
                        Message resultMessage = new Message(message.getFrom());
                        resultMessage.setFrom(message.getTo());
                        try {
                            byte[] response = json.getBytes("UTF-8");
                            resultMessage.addExtension(new CallbackResponseExtension(sik,
                                    DatatypeConverter.printBase64Binary(response)));
                            if (callbackDedup != null) {
                                callbackDedup.storeResponse(id, response);
                            }
                        } catch (UnsupportedEncodingException e) {
                            log.log(Level.SEVERE, "Could not add result to message packet", e);
                            return;
                        }
                        log.info("Sending message:\n" + resultMessage.toXML());
                        conn.sendPacket(resultMessage);
                    }

                }
            }, filter);

            try {
                conn.login(xmppUsername, xmppPassword);
            } catch (XMPPException e1) {
                status = XmppConnectionStatus.ConnectionFailed;
                statusLine = "Failed to authenticate jabber connection. Verify your configuration.\n"
                        + e1.getMessage();
                conn = null;
                connectionThread = null;
                if (onAuthenticationFailed != null)
                    try {
                        onAuthenticationFailed.run();
                    } catch (Throwable t) {
                        log.log(Level.WARNING, "Failure in onAuthenticationFailed handler.", t);
                    }
                throw new RuntimeException(); // Stop thread.
            }

            status = XmppConnectionStatus.Connected;

            if (onAuthenticated != null)
                try {
                    onAuthenticated.run();
                } catch (Throwable t) {
                    log.log(Level.WARNING, "Failure in onAuthenticated handler.", t);
                }
        }
    });

}

From source file:edu.vt.vbi.patric.portlets.CompPathwayMap.java

private void processEcTable(ResourceRequest request, ResourceResponse response) throws IOException {
    String genomeId = request.getParameter("genomeId");
    String taxonId = request.getParameter("taxonId");
    String cType = request.getParameter("cType");
    String map = request.getParameter("map");
    String algorithm = request.getParameter("algorithm");
    String pk = request.getParameter("pk");

    Map<String, String> key = null;
    if (pk != null && !pk.isEmpty()) {
        key = jsonReader.readValue(SessionHandler.getInstance().get(SessionHandler.PREFIX + pk));
    }/*from  w  ww. j  a v  a2s  . c om*/

    int count_total = 0;
    JSONArray results = new JSONArray();
    try {
        Set<String> ecNumbers = new HashSet<>();

        DataApiHandler dataApi = new DataApiHandler(request);

        SolrQuery query = new SolrQuery("pathway_id:" + map + " AND annotation:" + algorithm);
        if (taxonId != null && !taxonId.equals("")) {
            query.addFilterQuery(
                    SolrCore.GENOME.getSolrCoreJoin("genome_id", "genome_id", "taxon_lineage_ids:" + taxonId));
        }
        if (genomeId != null && !genomeId.equals("")) {
            query.addFilterQuery(SolrCore.GENOME.getSolrCoreJoin("genome_id", "genome_id",
                    "genome_id:(" + genomeId.replaceAll(",", " OR ") + ")"));
        }
        if (key != null && key.containsKey("genomeId") && !key.get("genomeId").equals("")) {
            query.addFilterQuery("genome_id:(" + key.get("genomeId").replaceAll(",", " OR ") + ")");
        }

        query.setRows(0).setFacet(true);
        query.add("json.facet",
                "{stat:{field:{field:ec_number,limit:-1,facet:{genome_count:\"unique(genome_id)\",gene_count:\"unique(feature_id)\"}}}}");

        String apiResponse = dataApi.solrQuery(SolrCore.PATHWAY, query);

        Map resp = jsonReader.readValue(apiResponse);
        Map respBody = (Map) resp.get("response");
        int numFound = (Integer) respBody.get("numFound");

        if (numFound > 0) {
            List<Map> buckets = (List<Map>) ((Map) ((Map) resp.get("facets")).get("stat")).get("buckets");

            Map<String, Map> mapStat = new HashMap<>();
            for (Map value : buckets) {
                if (Integer.parseInt(value.get("gene_count").toString()) > 0) {
                    mapStat.put(value.get("val").toString(), value);
                    ecNumbers.add(value.get("val").toString());
                }
            }

            if (!ecNumbers.isEmpty()) {
                query = new SolrQuery(
                        "pathway_id:" + map + " AND ec_number:(" + StringUtils.join(ecNumbers, " OR ") + ")");
                query.setRows(ecNumbers.size()).setFields("ec_number,ec_description,occurrence");
                query.addSort("ec_number", SolrQuery.ORDER.asc);

                apiResponse = dataApi.solrQuery(SolrCore.PATHWAY_REF, query);
                resp = jsonReader.readValue(apiResponse);
                Map respBdoby = (Map) resp.get("response");

                count_total = (Integer) respBdoby.get("numFound");
                List<Map> sdl = (List<Map>) respBdoby.get("docs");

                for (Map doc : sdl) {
                    String ecNumber = doc.get("ec_number").toString();
                    Map stat = mapStat.get(ecNumber);

                    JSONObject item = new JSONObject();
                    item.put("algorithm", algorithm);
                    item.put("ec_name", doc.get("ec_description"));
                    item.put("ec_number", ecNumber);
                    item.put("occurrence", doc.get("occurrence"));
                    item.put("gene_count", stat.get("gene_count"));
                    item.put("genome_count", stat.get("genome_count"));

                    results.add(item);
                }
            }
        }
    } catch (IOException e) {
        LOGGER.error(e.getMessage(), e);
    }

    JSONObject jsonResult = new JSONObject();
    try {
        jsonResult.put("total", count_total);
        jsonResult.put("results", results);
    } catch (Exception ex) {
        LOGGER.error(ex.getMessage(), ex);
    }

    PrintWriter writer = response.getWriter();
    jsonResult.writeJSONString(writer);
    writer.close();
}

From source file:edu.vt.vbi.patric.portlets.GenomicFeature.java

@SuppressWarnings("unchecked")
public void serveResource(ResourceRequest request, ResourceResponse response)
        throws PortletException, IOException {

    String sraction = request.getParameter("sraction");

    if (sraction != null && sraction.equals("save_params")) {

        LOGGER.debug("{}", request.getParameterMap());

        Map<String, String> key = new HashMap<>();

        String genomeId = request.getParameter("genomeId");
        String taxonId = "";
        String cType = request.getParameter("cType");
        String cId = request.getParameter("cId");

        if (cType != null && cId != null && cType.equals("taxon") && !cId.equals("")) {
            taxonId = cId;//from   w w w  .j av  a2s  .  c o m
        }

        String keyword = request.getParameter("keyword");
        String state = request.getParameter("state");
        String ncbi_taxon_id = request.getParameter("ncbi_taxon_id");
        String exact_search_term = request.getParameter("exact_search_term");

        if (genomeId != null && !genomeId.equalsIgnoreCase("")) {
            key.put("genomeId", genomeId);
        }
        if (!taxonId.equalsIgnoreCase("")) {
            key.put("taxonId", taxonId);
        }
        if (keyword != null) {
            key.put("keyword", keyword.trim());
        }
        if (ncbi_taxon_id != null) {
            key.put("ncbi_taxon_id", ncbi_taxon_id);
        }
        if (state != null) {
            key.put("state", state);
        }
        if (exact_search_term != null) {
            key.put("exact_search_term", exact_search_term);
        }

        if (!key.containsKey("genomeId") && cType != null && cType.equals("genome") && cId != null
                && !cId.equals("")) {
            key.put("genomeId", cId);
        }
        if (!key.containsKey("taxonId") && cType != null && cType.equals("taxon") && cId != null
                && !cId.equals("")) {
            key.put("taxonId", cId);
        }
        // random
        long pk = (new Random()).nextLong();

        SessionHandler.getInstance().set(SessionHandler.PREFIX + pk, jsonWriter.writeValueAsString(key));

        PrintWriter writer = response.getWriter();
        writer.write("" + pk);
        writer.close();

    } else {

        String need = request.getParameter("need");
        JSONObject jsonResult = new JSONObject();

        switch (need) {
        case "feature":
        case "featurewofacet": {
            // Getting Feature List
            Map data = processFeatureTab(request);

            int numFound = (Integer) data.get("numFound");
            List<GenomeFeature> records = (List<GenomeFeature>) data.get("features");

            JSONArray docs = new JSONArray();
            for (GenomeFeature item : records) {
                docs.add(item.toJSONObject());
            }

            jsonResult.put("results", docs);
            jsonResult.put("total", numFound);

            response.setContentType("application/json");
            PrintWriter writer = response.getWriter();
            jsonResult.writeJSONString(writer);
            writer.close();

            break;
        }
        case "download": {
            List<String> tableHeader = new ArrayList<>();
            List<String> tableField = new ArrayList<>();
            JSONArray tableSource = new JSONArray();

            String fileName = "FeatureTable";
            String fileFormat = request.getParameter("fileformat");

            // features
            Map data = processFeatureTab(request);
            List<GenomeFeature> features = (List<GenomeFeature>) data.get("features");

            for (GenomeFeature feature : features) {
                tableSource.add(feature.toJSONObject());
            }

            tableHeader.addAll(DownloadHelper.getHeaderForFeatures());
            tableField.addAll(DownloadHelper.getFieldsForFeatures());

            ExcelHelper excel = new ExcelHelper("xssf", tableHeader, tableField, tableSource);
            excel.buildSpreadsheet();

            if (fileFormat.equalsIgnoreCase("xlsx")) {
                response.setContentType("application/octetstream");
                response.addProperty("Content-Disposition",
                        "attachment; filename=\"" + fileName + "." + fileFormat + "\"");

                excel.writeSpreadsheettoBrowser(response.getPortletOutputStream());
            } else if (fileFormat.equalsIgnoreCase("txt")) {

                response.setContentType("application/octetstream");
                response.addProperty("Content-Disposition",
                        "attachment; filename=\"" + fileName + "." + fileFormat + "\"");

                response.getPortletOutputStream().write(excel.writeToTextFile().getBytes());
            }

            break;
        }
        }
    }
}

From source file:edu.vt.vbi.patric.portlets.DiseaseOverview.java

@SuppressWarnings("unchecked")
public void serveResource(ResourceRequest request, ResourceResponse response)
        throws PortletException, IOException {

    response.setContentType("application/json");

    String type = request.getParameter("type");
    String cId = request.getParameter("cId");

    DBDisease conn_disease = new DBDisease();
    int count_total;
    JSONArray results = new JSONArray();
    PrintWriter writer = response.getWriter();

    if (type.equals("incidence")) {

        JSONObject jsonResult = new JSONObject();
        // String cType = request.getParameter("cType");

        // sorting
        // String sort_field = request.getParameter("sort");
        // String sort_dir = request.getParameter("dir");

        // Map<String, String> key = new HashMap<>();
        // Map<String, String> sort = null;
        ///*from   w ww.jav a2 s  . c  o m*/
        // if (sort_field != null && sort_dir != null) {
        // sort = new HashMap<String, String>();
        // sort.put("field", sort_field);
        // sort.put("direction", sort_dir);
        // }
        //
        // key.put("cId", cId);
        // key.put("cType", cType);
        count_total = 1;
        jsonResult.put("total", count_total);

        JSONObject obj = new JSONObject();
        obj.put("rownum", "1");
        obj.put("pathogen", "Pathogen");
        obj.put("disease", "Disease");
        obj.put("incidence", "10");
        obj.put("infection", "5");

        results.add(obj);
        jsonResult.put("results", results);

        jsonResult.writeJSONString(writer);
    } else if (type.equals("disease_tree")) {

        JSONArray jsonResult = new JSONArray();
        String tree_node = request.getParameter("node");
        List<ResultType> items = conn_disease.getMeshHierarchy(cId, tree_node);

        if (items.size() > 0) {
            int min = Integer.parseInt(items.get(0).get("lvl"));
            try {
                for (ResultType item : items) {
                    if (min == Integer.parseInt(item.get("lvl"))) {

                        boolean flag = false;
                        JSONObject obj = DiseaseOverview.encodeNodeJSONObject(item);

                        String mesh_id = (String) obj.get("tree_node");

                        for (int j = 0; j < jsonResult.size(); j++) {

                            JSONObject temp = (JSONObject) jsonResult.get(j);

                            if (temp.get("tree_node").equals(mesh_id)) {
                                flag = true;
                                temp.put("pathogen", temp.get("pathogen") + "<br>" + obj.get("pathogen"));
                                temp.put("genome", temp.get("genome") + "<br>" + obj.get("genome"));
                                temp.put("vfdb", temp.get("vfdb") + "<br>" + obj.get("vfdb"));
                                temp.put("gad", temp.get("gad") + "<br>" + obj.get("gad"));
                                temp.put("ctd", temp.get("ctd") + "<br>" + obj.get("ctd"));
                                temp.put("taxon_id", temp.get("taxon_id") + "<br>" + obj.get("taxon_id"));

                                jsonResult.set(j, temp);
                            }
                        }
                        if (!flag) {
                            jsonResult.add(obj);
                        }
                    }
                }
            } catch (Exception ex) {
                LOGGER.error(ex.getMessage(), ex);
            }
        }
        jsonResult.writeJSONString(writer);
    }
    writer.close();
}

From source file:edu.vt.vbi.patric.portlets.CompareRegionViewer.java

@SuppressWarnings("unchecked")
private void printTrackInfo(ResourceRequest request, ResourceResponse response) throws IOException {
    String _rowID = request.getParameter("rowId");
    String pk = request.getParameter("key");

    Gson gson = new Gson();
    String pin_strand = null;/*from   w w  w  .j  a  va  2 s. c  om*/
    CRTrack crTrack = null;
    String pseed_ids = null;
    try {
        CRResultSet crRS = gson.fromJson(SessionHandler.getInstance().get(SessionHandler.PREFIX + pk),
                CRResultSet.class);
        pin_strand = crRS.getPinStrand();
        crTrack = crRS.getTrackMap().get(Integer.parseInt(_rowID));
        pseed_ids = crTrack.getSeedIds();
    } catch (Exception e) {
        LOGGER.error(e.getMessage());
        LOGGER.debug("{}", SessionHandler.getInstance().get(SessionHandler.PREFIX + pk));
    }

    int _window_size = 0;
    try {
        _window_size = Integer
                .parseInt(SessionHandler.getInstance().get(SessionHandler.PREFIX + "_windowsize" + pk));
    } catch (Exception e) {
        LOGGER.error(e.getMessage());
        LOGGER.debug("pk:{}, {}", SessionHandler.getInstance().get(SessionHandler.PREFIX + "_windowsize" + pk));
    }

    int features_count = 0;
    try {
        crTrack.relocateFeatures(_window_size, pin_strand);
        Collections.sort(crTrack.getFeatureList());
        features_count = crTrack.getFeatureList().size();
    } catch (Exception ex) {
        LOGGER.error(ex.getMessage(), ex);
    }

    Map<String, GenomeFeature> pseedMap = getPSeedMapping(request, pseed_ids);

    // formatting
    JSONArray nclist = new JSONArray();
    CRFeature feature;
    GenomeFeature feature_patric;
    for (int i = 0; i < features_count; i++) {

        feature = crTrack.getFeatureList().get(i);
        feature_patric = pseedMap.get(feature.getfeatureID());

        if (feature_patric != null) {

            JSONArray alist = new JSONArray();

            alist.addAll(Arrays.asList(0, feature.getStartPosition(), feature.getStartString(),
                    feature.getEndPosition(), (feature.getStrand().equals("+") ? 1 : -1), feature.getStrand(),

                    feature_patric.getId(), feature_patric.getPatricId(), feature_patric.getRefseqLocusTag(),
                    feature_patric.getAltLocusTag(), "PATRIC", feature_patric.getFeatureType(),
                    feature_patric.getProduct(),

                    feature_patric.getGene(), feature_patric.getGenomeName(), feature_patric.getAccession(),
                    feature.getPhase()));

            nclist.add(alist);
        }
    }
    // formatter.close();

    JSONObject track = new JSONObject();
    track.put("featureCount", features_count);
    track.put("formatVersion", 1);
    track.put("histograms", new JSONObject());

    JSONObject intervals = new JSONObject();
    JSONArray _clses = new JSONArray();
    JSONObject _cls = new JSONObject();
    _cls.put("attributes",
            Arrays.asList("Start", "Start_str", "End", "Strand", "strand_str", "id", "patric_id",
                    "refseq_locus_tag", "alt_locus_tag", "source", "type", "product", "gene", "genome_name",
                    "accession", "phase"));
    _cls.put("isArrayAttr", new JSONObject());
    _clses.add(_cls);
    intervals.put("classes", _clses);
    intervals.put("lazyClass", 5);
    intervals.put("minStart", 1);
    intervals.put("maxEnd", 20000);
    intervals.put("urlTemplate", "lf-{Chunk}.json");
    intervals.put("nclist", nclist);
    track.put("intervals", intervals);

    response.setContentType("application/json");
    track.writeJSONString(response.getWriter());
    response.getWriter().close();
}

From source file:edu.vt.vbi.patric.portlets.GlobalSearch.java

private void processGlobalSearch(ResourceRequest request, ResourceResponse response) throws IOException {

    //      String spellCheck = request.getParameter("spellcheck");
    JSONObject result = new JSONObject();

    try {//from w  w  w  . j  a  v  a2 s .  c  om
        //         if(Boolean.parseBoolean(spellCheck)){
        //            JSONObject a = solr.getSpellCheckerResult(keyword);
        //            result.put("suggestion", a.get("suggestion"));
        //         }
        //         result.put("suggestion", new JSONArray());

        JSONArray data = new JSONArray();

        {
            Map resp = processGlobalSearchFeature(request);

            JSONObject obj = new JSONObject();
            obj.putAll(resp);

            data.add(obj);
        }
        {
            Map resp = processGlobalSearchGenome(request);

            JSONObject obj = new JSONObject();
            obj.putAll(resp);

            data.add(obj);
        }
        {
            Map resp = processGlobalSearchTaxonomy(request);

            JSONObject obj = new JSONObject();
            obj.putAll(resp);

            data.add(obj);
        }
        {
            Map resp = processGlobalSearchExperiment(request);

            JSONObject obj = new JSONObject();
            obj.putAll(resp);

            data.add(obj);
        }
        result.put("data", data);
    } catch (IOException e) {
        LOGGER.error(e.getMessage(), e);
    }

    response.setContentType("application/json");
    result.writeJSONString(response.getWriter());
}

From source file:ddf.metrics.reporting.internal.rrd4j.RrdMetricsRetriever.java

@Override
public String createJsonData(String metricName, String rrdFilename, long startTime, long endTime)
        throws IOException, MetricsGraphException {
    LOGGER.trace("ENTERING: createJsonData");

    JSONObject obj = new JSONObject();

    String displayableMetricName = convertCamelCase(metricName);

    MetricData metricData = getMetricData(rrdFilename, startTime, endTime);

    String title = displayableMetricName + " for " + getCalendarTime(startTime) + " to "
            + getCalendarTime(endTime);/*from  www. j a va2 s  .  co  m*/
    obj.put("title", title);

    List<Long> timestamps = metricData.getTimestamps();
    List<Double> values = metricData.getValues();
    JSONArray samples = new JSONArray();

    for (int i = 0; i < timestamps.size(); i++) {
        String timestamp = getCalendarTime(timestamps.get(i));
        JSONObject sample = new JSONObject();
        sample.put("timestamp", timestamp);
        sample.put("value", new Double(values.get(i)));
        samples.add(sample);
    }
    obj.put("data", samples);

    if (metricData.hasTotalCount()) {
        obj.put("totalCount", metricData.getTotalCount());
    }

    JsonWriter writer = new JsonWriter();
    obj.writeJSONString(writer);
    String jsonText = writer.toString();

    LOGGER.trace("jsonText = {}", jsonText);

    LOGGER.trace("EXITING: createJsonData");

    return jsonText;
}

From source file:be.fedict.eid.applet.service.JSONServlet.java

public static void outputJSON(EIdData eIdData, PrintWriter writer)
        throws IOException, CertificateEncodingException {
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("MM/dd/yyyy");

    JSONObject eidJSONObject = new JSONObject();

    JSONObject identityJSONObject = new JSONObject();
    eidJSONObject.put("identity", identityJSONObject);
    Identity identity = eIdData.identity;
    identityJSONObject.put("nationalNumber", identity.nationalNumber);
    identityJSONObject.put("name", identity.name);
    identityJSONObject.put("firstName", identity.firstName);
    identityJSONObject.put("middleName", identity.middleName);
    identityJSONObject.put("dateOfBirth", simpleDateFormat.format(identity.dateOfBirth.getTime()));
    identityJSONObject.put("placeOfBirth", identity.placeOfBirth);
    identityJSONObject.put("gender", identity.gender.toString());

    JSONObject cardJSONObject = new JSONObject();
    eidJSONObject.put("card", cardJSONObject);
    cardJSONObject.put("cardNumber", identity.cardNumber);
    cardJSONObject.put("chipNumber", identity.chipNumber);
    cardJSONObject.put("cardDeliveryMunicipality", identity.cardDeliveryMunicipality);
    cardJSONObject.put("cardValidityDateBegin",
            simpleDateFormat.format(identity.cardValidityDateBegin.getTime()));
    cardJSONObject.put("cardValidityDateEnd", simpleDateFormat.format(identity.cardValidityDateEnd.getTime()));

    Address address = eIdData.address;/*from  w  ww.ja  v a  2s. c o m*/
    if (null != address) {
        JSONObject addressJSONObject = new JSONObject();
        eidJSONObject.put("address", addressJSONObject);
        addressJSONObject.put("streetAndNumber", address.streetAndNumber);
        addressJSONObject.put("municipality", address.municipality);
        addressJSONObject.put("zip", address.zip);
    }

    EIdCertsData certsData = eIdData.certs;
    if (null != certsData) {
        JSONObject certsJSONObject = new JSONObject();
        eidJSONObject.put("certs", certsJSONObject);

        X509Certificate authnCertificate = certsData.authn;
        JSONObject authnCertJSONObject = createCertJSONObject(authnCertificate, simpleDateFormat);
        certsJSONObject.put("authn", authnCertJSONObject);

        X509Certificate signCertificate = certsData.sign;
        JSONObject signCertJSONObject = createCertJSONObject(signCertificate, simpleDateFormat);
        certsJSONObject.put("sign", signCertJSONObject);

        X509Certificate citizenCACertificate = certsData.ca;
        JSONObject citizenCACertJSONObject = createCertJSONObject(citizenCACertificate, simpleDateFormat);
        certsJSONObject.put("citizenCA", citizenCACertJSONObject);

        X509Certificate rootCACertificate = certsData.root;
        JSONObject rootCACertJSONObject = createCertJSONObject(rootCACertificate, simpleDateFormat);
        certsJSONObject.put("rootCA", rootCACertJSONObject);
    }

    eidJSONObject.writeJSONString(writer);
}

From source file:edu.vt.vbi.patric.portlets.GenomeFinder.java

@SuppressWarnings("unchecked")
public void serveResource(ResourceRequest request, ResourceResponse response)
        throws PortletException, IOException {

    String sraction = request.getParameter("sraction");

    if (sraction != null) {
        if (sraction.equals("save_params")) {

            Map<String, String> key = new HashMap<>();

            String genomeId = request.getParameter("genomeId");
            String taxonId = request.getParameter("taxonId");
            String cType = request.getParameter("cType");
            String cId = request.getParameter("cId");
            if (cType != null && cId != null && cType.equals("taxon") && !cId.equals("")) {
                taxonId = cId;/*ww w  .  j  a v  a 2  s.co  m*/
            }
            String keyword = request.getParameter("keyword");
            String state = request.getParameter("state");
            String exact_search_term = request.getParameter("exact_search_term");
            String search_on = request.getParameter("search_on");

            if (genomeId != null && !genomeId.equals("")) {
                key.put("genomeId", genomeId);
            }
            if (taxonId != null && !taxonId.equals("")) {
                key.put("taxonId", taxonId);
            }
            if (keyword != null) {
                key.put("keyword", keyword.trim());
            }
            if (state != null) {
                key.put("state", state);
            }
            if (exact_search_term != null) {
                key.put("exact_search_term", exact_search_term);
            }
            if (search_on != null) {
                key.put("search_on", search_on);
            }

            if (!key.containsKey("genomeId") && cType != null && cType.equals("genome") && cId != null
                    && !cId.equals("")) {
                key.put("genomeId", cId);
            }
            if (!key.containsKey("taxonId") && cType != null && cType.equals("taxon") && cId != null
                    && !cId.equals("")) {
                key.put("taxonId", cId);
            }

            long pk = (new Random()).nextLong();

            SessionHandler.getInstance().set(SessionHandler.PREFIX + pk, jsonWriter.writeValueAsString(key));

            PrintWriter writer = response.getWriter();
            writer.write("" + pk);
            writer.close();
        } else if (sraction.equals("get_params")) {

            String ret = "";
            String pk = request.getParameter("pk");
            String json = SessionHandler.getInstance().get(SessionHandler.PREFIX + pk);
            if (json != null) {
                Map<String, String> key = jsonReader.readValue(json);
                ret = key.get("keyword");
            }

            PrintWriter writer = response.getWriter();
            writer.write("" + ret);
            writer.close();
        }
    } else {

        String need = request.getParameter("need");
        JSONObject jsonResult = new JSONObject();

        switch (need) {
        case "0": {
            // Getting Genome List
            String pk = request.getParameter("pk");
            Map data = processGenomeTab(request);

            Map<String, String> key = (Map) data.get("key");
            int numFound = (Integer) data.get("numFound");
            List<Genome> records = (List<Genome>) data.get("genomes");

            JSONArray docs = new JSONArray();
            for (Genome item : records) {
                docs.add(item.toJSONObject());
            }

            if (data.containsKey("facets")) {
                JSONObject facets = FacetHelper.formatFacetTree((Map) data.get("facets"));
                key.put("facets", facets.toJSONString());
                SessionHandler.getInstance().set(SessionHandler.PREFIX + pk,
                        jsonWriter.writeValueAsString(key));
            }

            jsonResult.put("results", docs);
            jsonResult.put("total", numFound);

            response.setContentType("application/json");
            PrintWriter writer = response.getWriter();
            jsonResult.writeJSONString(writer);
            writer.close();
            break;
        }
        case "1": {
            // getting Genome Sequence List
            Map data = processSequenceTab(request);

            int numFound = (Integer) data.get("numFound");
            List<GenomeSequence> sequences = (List<GenomeSequence>) data.get("sequences");

            JSONArray docs = new JSONArray();
            for (GenomeSequence item : sequences) {
                docs.add(item.toJSONObject());
            }

            jsonResult.put("results", docs);
            jsonResult.put("total", numFound);

            response.setContentType("application/json");
            PrintWriter writer = response.getWriter();
            jsonResult.writeJSONString(writer);
            writer.close();
            break;
        }
        case "tree": {

            String pk = request.getParameter("pk");
            String state;
            Map<String, String> key = jsonReader
                    .readValue(SessionHandler.getInstance().get(SessionHandler.PREFIX + pk));

            if (key.containsKey("state")) {
                state = key.get("state");
            } else {
                state = request.getParameter("state");
            }

            key.put("state", state);

            SessionHandler.getInstance().set(SessionHandler.PREFIX + pk, jsonWriter.writeValueAsString(key));

            JSONArray tree = new JSONArray();
            try {
                if (key.containsKey("facets") && !key.get("facets").isEmpty()) {

                    JSONObject facet_fields = (JSONObject) (new JSONParser()).parse(key.get("facets"));
                    DataApiHandler dataApi = new DataApiHandler(request);
                    tree = FacetHelper.processStateAndTree(dataApi, SolrCore.GENOME, key, need, facet_fields,
                            key.get("facet"), state, key.get("join"), 4);
                }
            } catch (ParseException e) {
                LOGGER.error(e.getMessage(), e);
            }

            response.setContentType("application/json");
            PrintWriter writer = response.getWriter();
            tree.writeJSONString(writer);
            writer.close();
            break;
        }
        case "tree_for_taxon": {
            // This is called by Taxon Overview page to faceted summary of genome under a specific taxa.

            String facet = request.getParameter("facet");
            String keyword = request.getParameter("keyword");

            Map<String, String> key = new HashMap<>();
            key.put("keyword", keyword);

            DataApiHandler dataApi = new DataApiHandler(request);
            SolrQuery query = dataApi.buildSolrQuery(key, null, facet, 0, 0, false); // build solr query

            LOGGER.debug("tree_for_taxon: [{}] {}", SolrCore.GENOME.getSolrCoreName(), query.toString());

            String apiResponse = dataApi.solrQuery(SolrCore.GENOME, query);

            Map resp = jsonReader.readValue(apiResponse);

            JSONObject facet_fields = FacetHelper.formatFacetTree((Map) resp.get("facet_counts"));
            JSONArray tree = FacetHelper.processStateAndTree(dataApi, SolrCore.GENOME, key, need, facet_fields,
                    facet, "", null, 4);

            response.setContentType("application/json");
            PrintWriter writer = response.getWriter();
            tree.writeJSONString(writer);
            writer.close();
            break;
        }
        case "getGenome": {
            // This is called by Genome Overview page to display genome metadata.

            DataApiHandler dataApi = new DataApiHandler(request);
            Genome genome = dataApi.getGenome(request.getParameter("id"));

            response.setContentType("application/json");
            PrintWriter writer = response.getWriter();
            if (genome != null) {
                genome.toJSONObject().writeJSONString(writer);
            }
            writer.close();
            break;
        }
        case "download": {
            List<String> tableHeader = new ArrayList<>();
            List<String> tableField = new ArrayList<>();
            JSONArray tableSource = new JSONArray();

            String fileName = "GenomeFinder";
            String fileFormat = request.getParameter("fileformat");
            //            String _tablesource = request.getParameter("tablesource");

            String aT = request.getParameter("aT");

            switch (aT) {
            case "0": {
                // genome
                Map data = processGenomeTab(request);
                List<Genome> genomes = (List<Genome>) data.get("genomes");

                for (Genome genome : genomes) {
                    tableSource.add(genome.toJSONObject());
                }

                tableHeader.addAll(DownloadHelper.getHeaderForGenomes());
                tableField.addAll(DownloadHelper.getFieldsForGenomes());
                break;
            }
            case "1": {
                // sequence
                Map data = processSequenceTab(request);
                List<GenomeSequence> sequences = (List<GenomeSequence>) data.get("sequences");

                for (GenomeSequence sequence : sequences) {
                    tableSource.add(sequence.toJSONObject());
                }

                tableHeader.addAll(DownloadHelper.getHeaderForGenomeSequence());
                tableField.addAll(DownloadHelper.getFieldsForGenomeSequence());
                break;
            }
            }

            ExcelHelper excel = new ExcelHelper("xssf", tableHeader, tableField, tableSource);
            excel.buildSpreadsheet();

            if (fileFormat.equalsIgnoreCase("xlsx")) {
                response.setContentType("application/octetstream");
                response.addProperty("Content-Disposition",
                        "attachment; filename=\"" + fileName + "." + fileFormat + "\"");

                excel.writeSpreadsheettoBrowser(response.getPortletOutputStream());
            } else if (fileFormat.equalsIgnoreCase("txt")) {

                response.setContentType("application/octetstream");
                response.addProperty("Content-Disposition",
                        "attachment; filename=\"" + fileName + "." + fileFormat + "\"");

                response.getPortletOutputStream().write(excel.writeToTextFile().getBytes());
            }
        }
        }
    }
}

From source file:me.timothy.ddd.quests.QuestManager.java

@SuppressWarnings("unchecked")
public QuestManager(Player player, AchievementManager aManager, EntityManager entManager) {
    logger = LogManager.getLogger();
    entityManager = entManager;//  ww w .j  av  a 2  s  .  c  o m
    achievementManager = aManager;
    acceptedQuests = new ArrayList<>();
    completedQuests = new ArrayList<>();
    this.player = player;

    File questsFile = new File("quests.json");
    if (questsFile.exists()) {
        try (FileReader fr = new FileReader(new File("quests.json"))) {
            JSONObject jObj = (JSONObject) (new JSONParser().parse(fr));

            JSONArray questsArr = (JSONArray) jObj.get("current");
            for (int i = 0; i < questsArr.size(); i++) {
                JSONObject questObj = (JSONObject) questsArr.get(i);
                String classStr = (String) questObj.get("class");
                Class<?> cl = Class.forName(classStr);
                Quest quest = null;
                try {
                    quest = (Quest) cl.getMethod("fromObject", getClass(), JSONObject.class).invoke(null, this,
                            questObj);
                } catch (NoSuchMethodException nsme) {
                    quest = (Quest) cl.getConstructor(QuestManager.class).newInstance(this);
                }
                acceptedQuests.add(quest);
            }

            JSONArray complete = (JSONArray) jObj.get("complete");
            for (int i = 0; i < complete.size(); i++) {
                //               completedQuests.add((Class<? extends Quest>) Class.forName((String) complete.get(i)));
            }
        } catch (Exception e) {
            logger.catching(e);
        }
    }

    Runnable saveQuests = new Runnable() {

        @Override
        public void run() {
            if (!DrunkDuckDispatch.ddd.save)
                return;
            JSONObject jObj = new JSONObject();
            JSONArray questsArr = new JSONArray();
            for (Quest qu : acceptedQuests) {
                questsArr.add(qu.asObject());
            }
            jObj.put("current", questsArr);
            JSONArray completed = new JSONArray();
            for (Class<? extends Quest> cl : completedQuests) {
                completed.add(cl.getCanonicalName());
            }
            jObj.put("complete", completed);
            try (FileWriter fw = new FileWriter(new File("quests.json"))) {
                jObj.writeJSONString(fw);
            } catch (IOException ie) {

            }
        }

    };

    Runtime.getRuntime().addShutdownHook(new Thread(saveQuests));
}