Пример #1
0
  /**
   * Parses AGGREGATE results for Oskari front
   *
   * @param response WPS vec:aggregate execute results
   * @param analysisLayer analysis layer params (field/columns info)
   * @return JSON.toSting() eg. aggregate WPS results
   *     **********************************************************************
   */
  public String parseAggregateResults(String response, AnalysisLayer analysisLayer) {

    try {

      // convert xml/text String to JSON

      final JSONObject json = XML.toJSONObject(response); // all
      // Add field name
      final AggregateMethodParams aggreParams =
          (AggregateMethodParams) analysisLayer.getAnalysisMethodParams();
      String fieldName = aggreParams.getAggreField1();
      if (analysisLayer.getInputAnalysisId() != null) {
        fieldName =
            analysisDataService.SwitchField2OriginalField(
                fieldName, analysisLayer.getInputAnalysisId());
      }
      json.put("fieldName", fieldName);
      return json.toString();

    } catch (JSONException e) {
      log.error(e, "XML to JSON failed", response);
    }

    return "{}";
  }
  public static HashMap<String, Integer> getAnimeSearchedMAL(
      String username, String password, String anime) {
    HashMap<String, Integer> map = new HashMap<String, Integer>();

    JSONObject xmlJSONObj;
    String json = "";
    String xml = "";
    try {
      xml = searchAnimeMAL(username, password, anime);
      xmlJSONObj = XML.toJSONObject(xml);
      json = xmlJSONObj.toString(4);
    } catch (Exception e) {
      MAMUtil.writeLog(e);
      e.printStackTrace();
    }
    JsonParser parser = new JsonParser();
    JsonObject root = parser.parse(json).getAsJsonObject();
    if (root.has("anime") && root.get("anime").getAsJsonObject().get("entry").isJsonArray()) {
      JsonArray searchedAnime = root.get("anime").getAsJsonObject().get("entry").getAsJsonArray();
      for (JsonElement obj : searchedAnime) {
        String name = obj.getAsJsonObject().get("title").getAsString();
        int id = obj.getAsJsonObject().get("id").getAsInt();
        map.put(name, id);
      }
    } else if (root.has("anime")) {
      JsonObject obj = root.get("anime").getAsJsonObject().get("entry").getAsJsonObject();
      int id = obj.getAsJsonObject().get("id").getAsInt();
      map.put(anime, id);
    }
    return map;
  }
  /**
   * This method <code>onlinePayment</code> is used for the Both M-pesa & Tigo-pesa PaymentGateways
   * to Pay the Money.
   *
   * @param requestData Containg input data in the Form of Xml/Soap .
   * @return
   */
  @POST
  @Consumes({MediaType.WILDCARD})
  @Produces({MediaType.APPLICATION_XML})
  public String onlinePayment(final String requestData) {

    try {
      final JSONObject xmlJSONObj = XML.toJSONObject(requestData);
      jsonData = this.returnJsonFromXml(xmlJSONObj);
      final CommandWrapper commandRequest =
          new CommandWrapperBuilder().createPaymentGateway().withJson(jsonData.toString()).build();
      result = this.commandsSourceWritePlatformService.logCommandSource(commandRequest);
      success = "SUCCESS";
      errorDesc = "";
      errorCode = Long.valueOf(0);
      contentData = "OBSTRANSACTIONID=" + result.resourceId();
      return this.returnToServer();
    } catch (ReceiptNoDuplicateException e) {
      success = "DUPLICATE_TXN";
      errorDesc = "DUPLICATE";
      errorCode = Long.valueOf(1);
      contentData = "TXNID ALREADY EXIST";
      return this.returnToServer();
    } catch (JSONException e) {
      return e.getCause().toString();
    } catch (PlatformDataIntegrityException e) {
      return null;
    }
  }
Пример #4
0
	protected void SaveDirectory(Document doc) throws TransformerException, ParserConfigurationException {
		
		String xmlStr = OperateXMLByDOM.doc2FormatString(doc);
		AsciiSaveUtil.saveAscii(outDir+"tree.xml", xmlStr);

		// hack的方法, 给每个目录加一个空节点
		List<Node> nl2 = new ArrayList<Node>();
		nl2.add(doc.getElementsByTagName("root").item(0));
		NodeList nl = doc.getElementsByTagName("children");
		for (int i = 0; i < nl.getLength(); i++) {
			if (((Element)nl.item(i)).getAttribute("id") == "")
				nl2.add(nl.item(i));
		}
		for (Node node: nl2){
			node.appendChild(doc.createElement("children"));
		}
		
		xmlStr = OperateXMLByDOM.doc2FormatString(doc);
		JSONObject soapDatainJsonObject = XML.toJSONObject(xmlStr);
				String jsonString = soapDatainJsonObject.toString();
		
		// 通过字符替换把这些空节点去掉,以达到产生[]括号对的目的
		String tmp = jsonString.replaceAll(",\\\"\\\"", "");
		String json = "["+tmp.substring(8, tmp.length()-1)+"]";
		AsciiSaveUtil.saveAscii(outDir+"tree.json", json);
	}
  public void LoadSeedData(String strColl, String metadatafile) throws Exception {
    try {
      InputStream is = this.getClass().getResourceAsStream(metadatafile);
      String xml;
      xml = IOUtils.toString(is);
      JSONObject rwSeed = XML.toJSONObject(xml);

      if (!rwSeed.isNull("ReferralWireSeedData")) {
        JSONObject json = rwSeed.getJSONObject("ReferralWireSeedData");
        DBCollection dbcoll = store.getColl(strColl);

        Object coll = (Object) json.get(strColl);
        if (coll instanceof JSONArray) {
          JSONArray defs = (JSONArray) coll;
          for (int i = 0; i < defs.length(); i++) {
            Object obj = (JSONObject) defs.get(i);
            dbcoll.insert((DBObject) com.mongodb.util.JSON.parse(obj.toString()));
          }
        } else {
          dbcoll.insert((DBObject) com.mongodb.util.JSON.parse(coll.toString()));
        }
      }
    } catch (IOException e) {
      // TODO Auto-generated catch block
      log.debug("API Error: ", e);
    }
  }
Пример #6
0
  public void writeSonarResults() {

    int page = 1;
    int total = 1;
    JSONArray issues = new JSONArray();
    JSONObject json = null;

    try {

      while (issues.length() < total) {
        json = new JSONObject(getSonarResults("http://localhost:9000", page));
        total = (int) json.get("total");

        JSONArray issueSubset = json.getJSONArray("issues");
        for (int i = 0; i < issueSubset.length(); i++) {
          issues.put(issueSubset.get(i));
        }
        page++;
      }

      json.put("issues", issues);

      String xml = XML.toString(json);
      java.io.FileWriter fw = new java.io.FileWriter(SONAR_FILE);
      fw.write(xml);
      fw.close();
    } catch (Exception e) {
      System.out.println("There was an error while writing SonarQube results.");
    }
  }
Пример #7
0
 /**
  * Parses an XML config file.
  *
  * @param filename The path to the file to parse.
  */
 public void parse(String filename) throws ConfigException {
   try {
     String xml = Utils.fileToString(filename);
     JSONObject jobj = XML.toJSONObject(xml);
     configObject = (Map) new JSONReader(jobj.toString()).readObject();
   } catch (Exception e) {
     throw new ConfigException("Error parsing config", e);
   }
 }
Пример #8
0
 /*     */ private static void stringify(JSONArray ja, StringBuffer b)
     /*     */ throws JSONException
       /*     */ {
   /* 243 */ b.append('<');
   /* 244 */ b.append(ja.get(0));
   /* 245 */ Object o = ja.opt(1);
   /*     */ int i;
   /*     */ int i;
   /* 246 */ if ((o instanceof JSONObject))
   /*     */ {
     /* 250 */ JSONObject jo = (JSONObject) o;
     /* 251 */ Iterator keys = jo.keys();
     /* 252 */ while (keys.hasNext()) {
       /* 253 */ String k = keys.next().toString();
       /* 254 */ Object v = jo.get(k).toString();
       /* 255 */ b.append(' ');
       /* 256 */ b.append(k);
       /* 257 */ b.append("=\"");
       /* 258 */ b.append(XML.escape((String) v));
       /* 259 */ b.append('"');
       /*     */ }
     /* 261 */ i = 2;
     /*     */ } else {
     /* 263 */ i = 1;
     /*     */ }
   /* 265 */ int len = ja.length();
   /*     */
   /* 267 */ if (i >= len) {
     /* 268 */ b.append("/>");
     /*     */ } else {
     /* 270 */ b.append('>');
     /* 271 */ while (i < len) {
       /* 272 */ Object v = ja.get(i);
       /* 273 */ if ((v instanceof JSONArray)) /* 274 */ stringify((JSONArray) v, b);
       /*     */ else {
         /* 276 */ b.append(XML.escape(v.toString()));
         /*     */ }
       /* 278 */ i++;
       /*     */ }
     /* 280 */ b.append("</");
     /* 281 */ b.append(ja.get(0));
     /* 282 */ b.append('>');
     /*     */ }
   /*     */ }
Пример #9
0
  public static byte[] convertToJSON(
      IExtensionHelpers helpers, IHttpRequestResponse requestResponse) {

    byte[] request = requestResponse.getRequest();

    if (Objects.equals(helpers.analyzeRequest(request).getMethod(), "GET")) {
      request = helpers.toggleRequestMethod(request);
    }

    IRequestInfo requestInfo = helpers.analyzeRequest(request);

    int bodyOffset = requestInfo.getBodyOffset();

    byte content_type = requestInfo.getContentType();

    String body = new String(request, bodyOffset, request.length - bodyOffset);

    String json = "";

    Boolean success = true;

    try {
      if (content_type == 3) {
        JSONObject xmlJSONObject = XML.toJSONObject(body);
        json = xmlJSONObject.toString(2);
      } else if (content_type == 0 || content_type == 1) {
        Map<String, String> params = splitQuery(body);
        Gson gson = new Gson();
        json = gson.toJson(params);
      } else {
        json = body;
      }
    } catch (Exception e) {
      success = false;
    }

    if (!success) {
      return request;
    } else {

      List<String> headers;

      headers = helpers.analyzeRequest(request).getHeaders();

      Iterator<String> iter = headers.iterator();
      while (iter.hasNext()) {
        if (iter.next().contains("Content-Type")) iter.remove();
      }

      headers.add("Content-Type: application/json;charset=UTF-8");

      return helpers.buildHttpMessage(headers, json.getBytes());
    }
  }
 private void sendResponse(HttpServletResponse resp, String payload, boolean json) {
   if (json) {
     JSONObject jsonObject = XML.toJSONObject(payload);
     payload = jsonObject.toString(3);
   }
   try {
     OutputStream outputStream = resp.getOutputStream();
     outputStream.write(payload.getBytes());
     outputStream.flush();
   } catch (IOException e) {
     throw new HTTPException(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
   }
 }
 // Send the response payload to the client.
 private void sendResponse(HttpServletResponse response, String payload, boolean json) {
   try {
     // Convert to JSON?
     if (json) {
       JSONObject jobt = XML.toJSONObject(payload);
       payload = jobt.toString(3); // 3 is indentation level for nice
       // look
     }
     OutputStream out = response.getOutputStream();
     out.write(payload.getBytes());
     out.flush();
   } catch (Exception exception) {
     throw new HTTPException(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
   }
 }
Пример #12
0
  public XMLImport(File xmlFile, String worksheetName, Workspace workspace) {
    super(worksheetName, workspace);

    try {
      String fileContents = FileUtil.readFileContentsToString(xmlFile);

      // Converting the XML to JSON
      JSONObject json = XML.toJSONObject(fileContents);
      jsonImport = new JsonImport(json, this.getFactory(), this.getWorksheet());
    } catch (JSONException ex) {
      logger.error("Error in populating the worksheet with XML");
    } catch (IOException ex) {
      logger.error("Error in reading the XML file");
    }
  }
  public void LoadSTNSpeakers(String mapfile) throws Exception {

    String mongoTableName = "rwParty";
    String xmlCollection = "SeedLOVMaps";
    try {
      InputStream is = this.getClass().getResourceAsStream(mapfile);
      String xml;
      xml = IOUtils.toString(is);
      JSONObject rwSeed = XML.toJSONObject(xml);

      if (!rwSeed.isNull(xmlCollection)) {
        JSONObject json = rwSeed.getJSONObject(xmlCollection);
        DBCollection dbTable = store.getColl(mongoTableName);

        Object xmlRecords = (Object) json.get(mongoTableName);
        if (xmlRecords instanceof JSONArray == false) {
          JSONObject xmlRecord = (JSONObject) xmlRecords;
          JSONArray jAry = new JSONArray();
          jAry.put(xmlRecord);
          xmlRecords = jAry;
        }

        if (xmlRecords instanceof JSONArray) {
          JSONArray xmlRecordAry = (JSONArray) xmlRecords;
          for (int i = 0; i < xmlRecordAry.length(); i++) {
            JSONObject xmlRecord = (JSONObject) xmlRecordAry.get(i);

            String parent_GlobalVal = xmlRecord.getString("parent_GlobalVal");
            String child_GlobalVal = xmlRecord.getString("child_GlobalVal");
            String parent_LovType = xmlRecord.getString("parent_LovType");
            String child_LovType = xmlRecord.getString("child_LovType");
            String childId = getLOVId(child_LovType, child_GlobalVal);
            String parentId = getLOVId(parent_LovType, parent_GlobalVal);
            xmlRecord.put("parentId", parentId);
            xmlRecord.put("childId", childId);
            dbTable.insert((DBObject) com.mongodb.util.JSON.parse(xmlRecord.toString()));
          }
        } else {
          dbTable.insert((DBObject) com.mongodb.util.JSON.parse(xmlRecords.toString()));
        }
      }
    } catch (IOException e) {
      // TODO Auto-generated catch block
      log.debug("API Error: ", e);
    }
  }
Пример #14
0
  /**
   * Marshals a SearchResult or ModsType object to an XML string. This string is converted to json
   * using the org.json package. Order of the json array is not guaranteed (as per spec); TO DO
   * (201405007) - investigate means for preserving XML order (json schema?)
   *
   * @param obj a a SearchResult or ModsType object for conversion to json string
   * @return the json String
   */
  protected String writeJson(Object obj) throws JAXBException {
    StringWriter sw = new StringWriter();
    String jsonString = null;
    Marshaller jaxbMarshaller = JAXBHelper.context.createMarshaller();
    jaxbMarshaller.marshal(obj, sw);

    try {
      String xml = sw.toString();
      JSONObject xmlJSONObj = XML.toJSONObject(xml);
      jsonString = xmlJSONObj.toString(5);
      // System.out.println(jsonString);
    } catch (JSONException je) {
      log.error(je.getMessage());
      je.printStackTrace();
    }
    return jsonString;
  }
Пример #15
0
  public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws IOException, ServletException {

    PrintWriter out = response.getWriter();
    String location = URLDecoder.decode(request.getParameter("location"));
    String type = URLDecoder.decode(request.getParameter("type"));
    String unit = URLDecoder.decode(request.getParameter("unit"));
    String awsURL =
        "http://default-environment-ii9naedwp8.elasticbeanstalk.com/?location="
            + URLEncoder.encode(location)
            + "&type="
            + type
            + "&unit="
            + unit;
    // out.write(awsURL);
    String myurl = URLEncoder.encode(awsURL);
    // out.write("\n"+myurl);
    URL url = new URL(awsURL);
    URLConnection urlConnection = url.openConnection();

    InputStream awsResponse = urlConnection.getInputStream();
    InputStreamReader iSReader = new InputStreamReader(awsResponse);
    StringBuffer sb = new StringBuffer();
    String xmlLine;
    BufferedReader buf = new BufferedReader(iSReader);
    try {
      while ((xmlLine = buf.readLine()) != null) {
        sb.append(xmlLine);
      }
    } catch (IOException ex) {
      ex.printStackTrace();
    }
    xmlLine = sb.toString();

    response.setContentType("application/json; charset=UTF-8");
    int indent = 6;
    try {
      JSONObject jsonObj = XML.toJSONObject(xmlLine);
      String json1 = jsonObj.toString(indent);
      out.write(json1);
    } catch (JSONException ex) {
      ex.printStackTrace();
    }
  }
  public void LoadSavedSearch(String datafile, String mongoTableName, String xmlCollection)
      throws Exception {
    // String mongoTableName = "rwSavedSearch";
    // String xmlCollection = "SavedSearches";
    try {
      InputStream is = this.getClass().getResourceAsStream(datafile);
      String xml;
      xml = IOUtils.toString(is);
      JSONObject rwSeed = XML.toJSONObject(xml);

      if (!rwSeed.isNull(xmlCollection)) {
        JSONObject json = rwSeed.getJSONObject(xmlCollection);
        DBCollection dbTable = store.getColl(mongoTableName);

        Object xmlRecords = (Object) json.get(mongoTableName);
        if (xmlRecords instanceof JSONArray == false) {
          JSONObject xmlRecord = (JSONObject) xmlRecords;
          JSONArray jAry = new JSONArray();
          jAry.put(xmlRecord);
          xmlRecords = jAry;
        }

        if (xmlRecords instanceof JSONArray) {
          JSONArray xmlRecordAry = (JSONArray) xmlRecords;
          for (int i = 0; i < xmlRecordAry.length(); i++) {
            JSONObject xmlRecord = (JSONObject) xmlRecordAry.get(i);
            dbTable.insert((DBObject) com.mongodb.util.JSON.parse(xmlRecord.toString()));
          }
        } else {
          dbTable.insert((DBObject) com.mongodb.util.JSON.parse(xmlRecords.toString()));
        }
      }
    } catch (IOException e) {
      // TODO Auto-generated catch block
      log.debug("API Error: ", e);
    }
  }
Пример #17
0
  private DocumentPojo buildDocument(
      SyndEntry entry, SourcePojo source, LinkedList<String> duplicateSources) {

    String tmpURL = this.cleanUrlStart(entry.getLink().toString());
    // (can't return null because called from code which checks this)

    // create the feed pojo
    DocumentPojo doc = new DocumentPojo();

    doc.setUrl(tmpURL);
    doc.setCreated(new Date());
    doc.setModified(new Date());

    // Strip out html if it is present
    if (entry.getTitle() != null) doc.setTitle(entry.getTitle().replaceAll("\\<.*?\\>", "").trim());
    if (entry.getDescription() != null)
      doc.setDescription(entry.getDescription().getValue().replaceAll("\\<.*?\\>", "").trim());
    if (entry.getPublishedDate() != null) {
      doc.setPublishedDate(entry.getPublishedDate());
    } else {
      doc.setPublishedDate(new Date());
    }

    // Clone from an existing source if we can:
    if (!duplicateSources.isEmpty()
        && (null == doc.getUpdateId())) { // (can't duplicate updating document)
      doc.setDuplicateFrom(duplicateSources.getFirst());
    }

    // GeoRSS
    GeoRSSModule geoRSSModule =
        GeoRSSUtils.getGeoRSS(entry); // currently does not handle <georss:circle>
    if (null != geoRSSModule) {
      if (null != geoRSSModule.getPosition()) {
        double lat = geoRSSModule.getPosition().getLatitude();
        double lon = geoRSSModule.getPosition().getLongitude();
        GeoPojo gp = new GeoPojo();
        gp.lat = lat;
        gp.lon = lon;
        doc.setDocGeo(gp);
      }
      if (null != geoRSSModule.getGeometry()) {
        AbstractGeometry ag = geoRSSModule.getGeometry();
        if (ag.getClass().equals(new LineString().getClass())) { // <georss:line>
          LineString ls = ((LineString) geoRSSModule.getGeometry());

          double latAvg = 0.0;
          double lonAvg = 0.0;
          int length = ls.getPositionList().size();
          for (int i = 0; i < length; i++) {
            latAvg += ls.getPositionList().getLatitude(i);
            lonAvg += ls.getPositionList().getLongitude(i);
          }
          latAvg = latAvg / length;
          lonAvg = lonAvg / length;
          GeoPojo gp = new GeoPojo();
          gp.lat = latAvg;
          gp.lon = lonAvg;
          doc.setDocGeo(gp);
        } else if (ag.getClass().equals(new Polygon().getClass())) // <georss:polygon>
        {
          Polygon poly = ((Polygon) geoRSSModule.getGeometry());
          AbstractRing ar = poly.getExterior();
          LinearRing lr = (LinearRing) ar;

          double latAvg = 0.0;
          double lonAvg = 0.0;
          int length = lr.getPositionList().size();
          for (int i = 0; i < length; i++) {
            latAvg += lr.getPositionList().getLatitude(i);
            lonAvg += lr.getPositionList().getLongitude(i);
          }
          latAvg = latAvg / length;
          lonAvg = lonAvg / length;
          GeoPojo gp = new GeoPojo();
          gp.lat = latAvg;
          gp.lon = lonAvg;
          doc.setDocGeo(gp);
        } else if (ag.getClass().equals(new Envelope().getClass())) { // <georss:box>
          Envelope env = ((Envelope) geoRSSModule.getGeometry());

          double latAvg = (env.getMaxLatitude() + env.getMinLatitude()) / 2;
          double lonAvg = (env.getMaxLongitude() + env.getMinLongitude()) / 2;

          GeoPojo gp = new GeoPojo();
          gp.lat = latAvg;
          gp.lon = lonAvg;
          doc.setDocGeo(gp);
        }
      }
    } // end if GeoRSS

    // Arbitrary other metadata:

    if (null != entry.getForeignMarkup()) {
      JSONObject rssMetadata = new JSONObject();

      @SuppressWarnings("unchecked")
      List<Element> fms = (List<Element>) entry.getForeignMarkup();
      for (Element fm : fms) {
        try {
          JSONObject subObj = XML.toJSONObject(new XMLOutputter().outputString(fm));
          if (1 == subObj.length()) {
            for (String name : JSONObject.getNames(subObj)) {
              rssMetadata.put(name, subObj.get(name));
            }
          } else { // (this will never happen in practice?)
            rssMetadata.put(fm.getName(), subObj);
          }
        } catch (JSONException e) {
        } // (do nothing just carry on)
      }
      if (!fms.isEmpty()) {
        doc.addToMetadata(
            "_FEED_METADATA_", XmlToMetadataParser.convertJsonObjectToLinkedHashMap(rssMetadata));
      }
    } // TESTED (longs converted to string, eg edgar:assistantDirector from
      // "http.www.sec.gov.archives.edgar.usgaap.rss.xml")

    return doc;
  }
Пример #18
0
  public static byte[] convertToXML(IExtensionHelpers helpers, IHttpRequestResponse requestResponse)
      throws Exception {

    byte[] request = requestResponse.getRequest();

    if (Objects.equals(helpers.analyzeRequest(request).getMethod(), "GET")) {
      request = helpers.toggleRequestMethod(request);
    }

    IRequestInfo requestInfo = helpers.analyzeRequest(request);

    int bodyOffset = requestInfo.getBodyOffset();

    byte content_type = requestInfo.getContentType();

    String body = new String(request, bodyOffset, request.length - bodyOffset, "UTF-8");

    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    Document doc =
        new Document() {
          public String getNodeName() {
            return null;
          }

          public String getNodeValue() throws DOMException {
            return null;
          }

          public void setNodeValue(String nodeValue) throws DOMException {}

          public short getNodeType() {
            return 0;
          }

          public Node getParentNode() {
            return null;
          }

          public NodeList getChildNodes() {
            return null;
          }

          public Node getFirstChild() {
            return null;
          }

          public Node getLastChild() {
            return null;
          }

          public Node getPreviousSibling() {
            return null;
          }

          public Node getNextSibling() {
            return null;
          }

          public NamedNodeMap getAttributes() {
            return null;
          }

          public Document getOwnerDocument() {
            return null;
          }

          public Node insertBefore(Node newChild, Node refChild) throws DOMException {
            return null;
          }

          public Node replaceChild(Node newChild, Node oldChild) throws DOMException {
            return null;
          }

          public Node removeChild(Node oldChild) throws DOMException {
            return null;
          }

          public Node appendChild(Node newChild) throws DOMException {
            return null;
          }

          public boolean hasChildNodes() {
            return false;
          }

          public Node cloneNode(boolean deep) {
            return null;
          }

          public void normalize() {}

          public boolean isSupported(String feature, String version) {
            return false;
          }

          public String getNamespaceURI() {
            return null;
          }

          public String getPrefix() {
            return null;
          }

          public void setPrefix(String prefix) throws DOMException {}

          public String getLocalName() {
            return null;
          }

          public boolean hasAttributes() {
            return false;
          }

          public String getBaseURI() {
            return null;
          }

          public short compareDocumentPosition(Node other) throws DOMException {
            return 0;
          }

          public String getTextContent() throws DOMException {
            return null;
          }

          public void setTextContent(String textContent) throws DOMException {}

          public boolean isSameNode(Node other) {
            return false;
          }

          public String lookupPrefix(String namespaceURI) {
            return null;
          }

          public boolean isDefaultNamespace(String namespaceURI) {
            return false;
          }

          public String lookupNamespaceURI(String prefix) {
            return null;
          }

          public boolean isEqualNode(Node arg) {
            return false;
          }

          public Object getFeature(String feature, String version) {
            return null;
          }

          public Object setUserData(String key, Object data, UserDataHandler handler) {
            return null;
          }

          public Object getUserData(String key) {
            return null;
          }

          public DocumentType getDoctype() {
            return null;
          }

          public DOMImplementation getImplementation() {
            return null;
          }

          public Element getDocumentElement() {
            return null;
          }

          public Element createElement(String tagName) throws DOMException {
            return null;
          }

          public DocumentFragment createDocumentFragment() {
            return null;
          }

          public Text createTextNode(String data) {
            return null;
          }

          public Comment createComment(String data) {
            return null;
          }

          public CDATASection createCDATASection(String data) throws DOMException {
            return null;
          }

          public ProcessingInstruction createProcessingInstruction(String target, String data)
              throws DOMException {
            return null;
          }

          public Attr createAttribute(String name) throws DOMException {
            return null;
          }

          public EntityReference createEntityReference(String name) throws DOMException {
            return null;
          }

          public NodeList getElementsByTagName(String tagname) {
            return null;
          }

          public Node importNode(Node importedNode, boolean deep) throws DOMException {
            return null;
          }

          public Element createElementNS(String namespaceURI, String qualifiedName)
              throws DOMException {
            return null;
          }

          public Attr createAttributeNS(String namespaceURI, String qualifiedName)
              throws DOMException {
            return null;
          }

          public NodeList getElementsByTagNameNS(String namespaceURI, String localName) {
            return null;
          }

          public Element getElementById(String elementId) {
            return null;
          }

          public String getInputEncoding() {
            return null;
          }

          public String getXmlEncoding() {
            return null;
          }

          public boolean getXmlStandalone() {
            return false;
          }

          public void setXmlStandalone(boolean xmlStandalone) throws DOMException {}

          public String getXmlVersion() {
            return null;
          }

          public void setXmlVersion(String xmlVersion) throws DOMException {}

          public boolean getStrictErrorChecking() {
            return false;
          }

          public void setStrictErrorChecking(boolean strictErrorChecking) {}

          public String getDocumentURI() {
            return null;
          }

          public void setDocumentURI(String documentURI) {}

          public Node adoptNode(Node source) throws DOMException {
            return null;
          }

          public DOMConfiguration getDomConfig() {
            return null;
          }

          public void normalizeDocument() {}

          public Node renameNode(Node n, String namespaceURI, String qualifiedName)
              throws DOMException {
            return null;
          }
        };

    StringBuilder xml = new StringBuilder();
    xml.append("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
    xml.append("<root>");

    if (content_type == 0 || content_type == 1) {

      Map<String, String> params = splitQuery(body);
      Gson gson = new Gson();
      body = gson.toJson(params);
    }

    Boolean success = true;

    try {
      JSONObject json = new JSONObject(body);

      xml.append(XML.toString(json));
      xml.append("</root>");

      DocumentBuilder builder = factory.newDocumentBuilder();

      ByteArrayInputStream input = new ByteArrayInputStream(xml.toString().getBytes("UTF-8"));
      doc = builder.parse(input);

    } catch (Exception e) {
      success = false;
    }

    if (!success) {
      return null;
    } else {

      List<String> headers;

      headers = helpers.analyzeRequest(request).getHeaders();

      Iterator<String> iter = headers.iterator();
      while (iter.hasNext()) {
        if (iter.next().contains("Content-Type")) iter.remove();
      }

      headers.add("Content-Type: application/xml;charset=UTF-8");

      return helpers.buildHttpMessage(headers, prettyPrint(doc).getBytes());
    }
  }
Пример #19
0
  /**
   * Parse XML values and store them in a JSONArray.
   *
   * @param x The XMLTokener containing the source string.
   * @param arrayForm true if array form, false if object form.
   * @param ja The JSONArray that is containing the current tag or null if we are at the outermost
   *     level.
   * @param keepStrings Don't type-convert text nodes and attibute values
   * @return A JSONArray if the value is the outermost tag, otherwise null.
   * @throws JSONException
   */
  private static Object parse(XMLTokener x, boolean arrayForm, JSONArray ja, boolean keepStrings)
      throws JSONException {
    String attribute;
    char c;
    String closeTag = null;
    int i;
    JSONArray newja = null;
    JSONObject newjo = null;
    Object token;
    String tagName = null;

    // Test for and skip past these forms:
    //      <!-- ... -->
    //      <![  ... ]]>
    //      <!   ...   >
    //      <?   ...  ?>

    while (true) {
      if (!x.more()) {
        throw x.syntaxError("Bad XML");
      }
      token = x.nextContent();
      if (token == XML.LT) {
        token = x.nextToken();
        if (token instanceof Character) {
          if (token == XML.SLASH) {

            // Close tag </

            token = x.nextToken();
            if (!(token instanceof String)) {
              throw new JSONException("Expected a closing name instead of '" + token + "'.");
            }
            if (x.nextToken() != XML.GT) {
              throw x.syntaxError("Misshaped close tag");
            }
            return token;
          } else if (token == XML.BANG) {

            // <!

            c = x.next();
            if (c == '-') {
              if (x.next() == '-') {
                x.skipPast("-->");
              } else {
                x.back();
              }
            } else if (c == '[') {
              token = x.nextToken();
              if (token.equals("CDATA") && x.next() == '[') {
                if (ja != null) {
                  ja.put(x.nextCDATA());
                }
              } else {
                throw x.syntaxError("Expected 'CDATA['");
              }
            } else {
              i = 1;
              do {
                token = x.nextMeta();
                if (token == null) {
                  throw x.syntaxError("Missing '>' after '<!'.");
                } else if (token == XML.LT) {
                  i += 1;
                } else if (token == XML.GT) {
                  i -= 1;
                }
              } while (i > 0);
            }
          } else if (token == XML.QUEST) {

            // <?

            x.skipPast("?>");
          } else {
            throw x.syntaxError("Misshaped tag");
          }

          // Open tag <

        } else {
          if (!(token instanceof String)) {
            throw x.syntaxError("Bad tagName '" + token + "'.");
          }
          tagName = (String) token;
          newja = new JSONArray();
          newjo = new JSONObject();
          if (arrayForm) {
            newja.put(tagName);
            if (ja != null) {
              ja.put(newja);
            }
          } else {
            newjo.put("tagName", tagName);
            if (ja != null) {
              ja.put(newjo);
            }
          }
          token = null;
          for (; ; ) {
            if (token == null) {
              token = x.nextToken();
            }
            if (token == null) {
              throw x.syntaxError("Misshaped tag");
            }
            if (!(token instanceof String)) {
              break;
            }

            // attribute = value

            attribute = (String) token;
            if (!arrayForm && ("tagName".equals(attribute) || "childNode".equals(attribute))) {
              throw x.syntaxError("Reserved attribute.");
            }
            token = x.nextToken();
            if (token == XML.EQ) {
              token = x.nextToken();
              if (!(token instanceof String)) {
                throw x.syntaxError("Missing value");
              }
              newjo.accumulate(attribute, keepStrings ? token : XML.stringToValue((String) token));
              token = null;
            } else {
              newjo.accumulate(attribute, "");
            }
          }
          if (arrayForm && newjo.length() > 0) {
            newja.put(newjo);
          }

          // Empty tag <.../>

          if (token == XML.SLASH) {
            if (x.nextToken() != XML.GT) {
              throw x.syntaxError("Misshaped tag");
            }
            if (ja == null) {
              if (arrayForm) {
                return newja;
              } else {
                return newjo;
              }
            }

            // Content, between <...> and </...>

          } else {
            if (token != XML.GT) {
              throw x.syntaxError("Misshaped tag");
            }
            closeTag = (String) parse(x, arrayForm, newja, keepStrings);
            if (closeTag != null) {
              if (!closeTag.equals(tagName)) {
                throw x.syntaxError("Mismatched '" + tagName + "' and '" + closeTag + "'");
              }
              tagName = null;
              if (!arrayForm && newja.length() > 0) {
                newjo.put("childNodes", newja);
              }
              if (ja == null) {
                if (arrayForm) {
                  return newja;
                } else {
                  return newjo;
                }
              }
            }
          }
        }
      } else {
        if (ja != null) {
          ja.put(
              token instanceof String
                  ? keepStrings ? token : XML.stringToValue((String) token)
                  : token);
        }
      }
    }
  }
Пример #20
0
  /**
   * Reverse the JSONML transformation, making an XML text from a JSONObject. The JSONObject must
   * contain a "tagName" property. If it has children, then it must have a "childNodes" property
   * containing an array of objects. The other properties are attributes with string values.
   *
   * @param jo A JSONObject.
   * @return An XML string.
   * @throws JSONException
   */
  public static String toString(JSONObject jo) throws JSONException {
    StringBuilder sb = new StringBuilder();
    int i;
    JSONArray ja;
    String key;
    Iterator<String> keys;
    int length;
    Object object;
    String tagName;
    String value;

    // Emit <tagName

    tagName = jo.optString("tagName");
    if (tagName == null) {
      return XML.escape(jo.toString());
    }
    XML.noSpace(tagName);
    tagName = XML.escape(tagName);
    sb.append('<');
    sb.append(tagName);

    // Emit the attributes

    keys = jo.keys();
    while (keys.hasNext()) {
      key = keys.next();
      if (!"tagName".equals(key) && !"childNodes".equals(key)) {
        XML.noSpace(key);
        value = jo.optString(key);
        if (value != null) {
          sb.append(' ');
          sb.append(XML.escape(key));
          sb.append('=');
          sb.append('"');
          sb.append(XML.escape(value));
          sb.append('"');
        }
      }
    }

    // Emit content in body

    ja = jo.optJSONArray("childNodes");
    if (ja == null) {
      sb.append('/');
      sb.append('>');
    } else {
      sb.append('>');
      length = ja.length();
      for (i = 0; i < length; i += 1) {
        object = ja.get(i);
        if (object != null) {
          if (object instanceof String) {
            sb.append(XML.escape(object.toString()));
          } else if (object instanceof JSONObject) {
            sb.append(toString((JSONObject) object));
          } else if (object instanceof JSONArray) {
            sb.append(toString((JSONArray) object));
          } else {
            sb.append(object.toString());
          }
        }
      }
      sb.append('<');
      sb.append('/');
      sb.append(tagName);
      sb.append('>');
    }
    return sb.toString();
  }
Пример #21
0
  /**
   * Reverse the JSONML transformation, making an XML text from a JSONArray.
   *
   * @param ja A JSONArray.
   * @return An XML string.
   * @throws JSONException
   */
  public static String toString(JSONArray ja) throws JSONException {
    int i;
    JSONObject jo;
    String key;
    Iterator<String> keys;
    int length;
    Object object;
    StringBuilder sb = new StringBuilder();
    String tagName;
    String value;

    // Emit <tagName

    tagName = ja.getString(0);
    XML.noSpace(tagName);
    tagName = XML.escape(tagName);
    sb.append('<');
    sb.append(tagName);

    object = ja.opt(1);
    if (object instanceof JSONObject) {
      i = 2;
      jo = (JSONObject) object;

      // Emit the attributes

      keys = jo.keys();
      while (keys.hasNext()) {
        key = keys.next();
        XML.noSpace(key);
        value = jo.optString(key);
        if (value != null) {
          sb.append(' ');
          sb.append(XML.escape(key));
          sb.append('=');
          sb.append('"');
          sb.append(XML.escape(value));
          sb.append('"');
        }
      }
    } else {
      i = 1;
    }

    // Emit content in body

    length = ja.length();
    if (i >= length) {
      sb.append('/');
      sb.append('>');
    } else {
      sb.append('>');
      do {
        object = ja.get(i);
        i += 1;
        if (object != null) {
          if (object instanceof String) {
            sb.append(XML.escape(object.toString()));
          } else if (object instanceof JSONObject) {
            sb.append(toString((JSONObject) object));
          } else if (object instanceof JSONArray) {
            sb.append(toString((JSONArray) object));
          }
        }
      } while (i < length);
      sb.append('<');
      sb.append('/');
      sb.append(tagName);
      sb.append('>');
    }
    return sb.toString();
  }
Пример #22
0
  private JSONObject convertXMLToJSON(String xmlData) throws JSONException, JAXBException {
    // Unmarshall the xml into a GraphML
    ByteArrayInputStream baiStream = new ByteArrayInputStream(xmlData.getBytes());
    JAXBContext jc = JAXBContext.newInstance(GraphMLUtil.GRAPHML_CLASSES);
    Unmarshaller unmarshaller = jc.createUnmarshaller();
    GraphML graphML = (GraphML) unmarshaller.unmarshal(baiStream);

    // eventually check version for compatibility
    s_logger.info("Importing chart version: {}", graphML.getversion());

    Graph graph = graphML.getGraph();

    JSONObject toReturn = new JSONObject(),
        miscData = null,
        columnJSON,
        nodeJSON = null,
        clusterJSON;
    String cachedClusterJSON = null;
    int columnIdx = -1, rowIdx = -1;
    List<List<JSONObject>> allColumns = new ArrayList<List<JSONObject>>();
    List<JSONObject> currColumn, outColumns = new ArrayList<JSONObject>();

    // first, set up the column and misc JSON data contained in the graph
    for (GraphDataXML data : graph.getdata()) {
      if (data.getkey().startsWith("column")) {
        columnJSON = XML.toJSONObject(data.getvalue());
        columnIdx = Integer.parseInt(data.getkey().substring(6));
        while (columnIdx >= outColumns.size()) {
          outColumns.add(new JSONObject());
        }

        outColumns.set(columnIdx, columnJSON);
        allColumns.add(new ArrayList<JSONObject>());
      } else if (data.getkey().equals("miscData")) {
        miscData = XML.toJSONObject(data.getvalue());
      }
    }

    // next, iterate through the graph nodes and place the JSONObject for each into it's proper
    // row/column
    for (GraphNode node : graph.getnode()) {
      for (GraphData data : node.getdata()) { // parse the goodies from each file node
        if (data.getkey().equals("column")) {
          columnIdx = Integer.parseInt(data.getvalue());
        } else if (data.getkey().equals("row")) {
          rowIdx = Integer.parseInt(data.getvalue());
        }
      }

      for (GraphDataXML data : node.getnodedata()) { // parse the goodies from each data node
        if (data.getkey().equals("fileJSON")) {
          nodeJSON = XML.toJSONObject(data.getvalue());
        } else if (data.getkey().equals("clusterJSON")) {
          cachedClusterJSON = data.getvalue();
        }
      }

      if (nodeJSON != null
          && nodeJSON.has("clusterUIObject")
          && !nodeJSON.get("clusterUIObject").toString().equals("null")) {
        clusterJSON = nodeJSON.getJSONObject("clusterUIObject"); // do annoying cleanup
        insertJSONArray(clusterJSON, "children");
        insertJSONArray(clusterJSON.getJSONObject("spec"), "members");
      }

      if (cachedClusterJSON != null) {
        PermitSet permits = new PermitSet();

        try {
          List<String> entityIds = new LinkedList<String>();
          List<FL_Cluster> allClusters = ClusterHelper.listFromJson(cachedClusterJSON);
          ;
          for (FL_Cluster cluster : allClusters) {
            entityIds.addAll(cluster.getMembers());
            for (FL_Property property : cluster.getProperties()) {
              if (!(property.getRange() instanceof FL_SingletonRange)) continue;
              FL_SingletonRange range = (FL_SingletonRange) property.getRange();
              if (!range.getType().equals(FL_PropertyType.STRING)) continue;
              property.setRange(
                  new SingletonRangeHelper(
                      StringEscapeUtils.unescapeXml((String) range.getValue())));
            }
          }

          final ContextReadWrite contextRW =
              contextCache.getReadWrite(nodeJSON.getString("xfId"), permits);
          contextRW.getContext().addClusters(allClusters);
          contextRW
              .getContext()
              .addEntities(entityAccess.getEntities(entityIds, FL_LevelOfDetail.SUMMARY));
          contextRW.setSimplifiedContext(allClusters);
        } catch (IOException e) {
          throw new ResourceException(
              Status.CLIENT_ERROR_BAD_REQUEST, "Exception during cluster cache processing.", e);
        } finally {
          permits.revoke();
        }
      }

      currColumn = allColumns.get(columnIdx);
      while (rowIdx >= currColumn.size()) {
        currColumn.add(new JSONObject());
      }
      currColumn.set(rowIdx, nodeJSON);
    }

    // place the files as children in the outgoing columns array
    for (int i = 0; i < allColumns.size(); i++) {
      columnJSON = outColumns.get(i);
      columnJSON.put("children", new JSONArray(allColumns.get(i)));
    }

    // finally, place the child columns and misc data in the resulting JSON object
    toReturn.put("children", new JSONArray(outColumns));
    for (String dataKey : JSONObject.getNames(miscData)) {
      toReturn.put(dataKey, miscData.get(dataKey));
    }

    return toReturn;
  }
Пример #23
0
  /**
   * Scan the content following the named tag, attaching it to the context.
   *
   * @param x The XMLTokener containing the source string.
   * @param context The JSONObject that will include the new material.
   * @param name The tag name.
   * @return true if the close tag is processed.
   * @throws JSONException
   */
  private static boolean parse(XMLTokener x, JSONObject context, String name) throws JSONException {
    char c;
    int i;
    JSONObject jsonobject = null;
    String string;
    String tagName;
    Object token;

    // Test for and skip past these forms:
    //      <!-- ... -->
    //      <!   ...   >
    //      <![  ... ]]>
    //      <?   ...  ?>
    // Report errors for these forms:
    //      <>
    //      <=
    //      <<

    token = x.nextToken();

    // <!

    if (token == BANG) {
      c = x.next();
      if (c == '-') {
        if (x.next() == '-') {
          x.skipPast("-->");
          return false;
        }
        x.back();
      } else if (c == '[') {
        token = x.nextToken();
        if ("CDATA".equals(token)) {
          if (x.next() == '[') {
            string = x.nextCDATA();
            if (string.length() > 0) {
              context.accumulate("content", string);
            }
            return false;
          }
        }
        throw x.syntaxError("Expected 'CDATA['");
      }
      i = 1;
      do {
        token = x.nextMeta();
        if (token == null) {
          throw x.syntaxError("Missing '>' after '<!'.");
        } else if (token == LT) {
          i += 1;
        } else if (token == GT) {
          i -= 1;
        }
      } while (i > 0);
      return false;
    } else if (token == QUEST) {

      // <?

      x.skipPast("?>");
      return false;
    } else if (token == SLASH) {

      // Close tag </

      token = x.nextToken();
      if (name == null) {
        throw x.syntaxError("Mismatched close tag " + token);
      }
      if (!token.equals(name)) {
        throw x.syntaxError("Mismatched " + name + " and " + token);
      }
      if (x.nextToken() != GT) {
        throw x.syntaxError("Misshaped close tag");
      }
      return true;

    } else if (token instanceof Character) {
      throw x.syntaxError("Misshaped tag");

      // Open tag <

    } else {
      tagName = (String) token;
      token = null;
      jsonobject = new JSONObject();
      for (; ; ) {
        if (token == null) {
          token = x.nextToken();
        }

        // attribute = value

        if (token instanceof String) {
          string = (String) token;
          token = x.nextToken();
          if (token == EQ) {
            token = x.nextToken();
            if (!(token instanceof String)) {
              throw x.syntaxError("Missing value");
            }
            jsonobject.accumulate(string, XML.stringToValue((String) token));
            token = null;
          } else {
            jsonobject.accumulate(string, "");
          }

          // Empty tag <.../>

        } else if (token == SLASH) {
          if (x.nextToken() != GT) {
            throw x.syntaxError("Misshaped tag");
          }
          if (jsonobject.length() > 0) {
            context.accumulate(tagName, jsonobject);
          } else {
            context.accumulate(tagName, "");
          }
          return false;

          // Content, between <...> and </...>

        } else if (token == GT) {
          for (; ; ) {
            token = x.nextContent();
            if (token == null) {
              if (tagName != null) {
                throw x.syntaxError("Unclosed tag " + tagName);
              }
              return false;
            } else if (token instanceof String) {
              string = (String) token;
              if (string.length() > 0) {
                jsonobject.accumulate("content", XML.stringToValue(string));
              }

              // Nested element

            } else if (token == LT) {
              if (parse(x, jsonobject, tagName)) {
                if (jsonobject.length() == 0) {
                  context.accumulate(tagName, "");
                } else if (jsonobject.length() == 1 && jsonobject.opt("content") != null) {
                  context.accumulate(tagName, jsonobject.opt("content"));
                } else {
                  context.accumulate(tagName, jsonobject);
                }
                return false;
              }
            }
          }
        } else {
          throw x.syntaxError("Misshaped tag");
        }
      }
    }
  }