Exemplo n.º 1
2
  public static void writeXmlFile(Document doc, File saveFile, boolean systemOut) {
    try {

      Source source = new DOMSource(doc);
      Transformer xformer = TransformerFactory.newInstance().newTransformer();
      xformer.setParameter(OutputKeys.INDENT, "yes");
      xformer.setOutputProperty(OutputKeys.INDENT, "yes");
      xformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");

      if (saveFile != null) {
        Result result = new StreamResult(saveFile);
        xformer.transform(source, result);
      }

      Writer outputWriter = new StringWriter();
      Result stringOut = new StreamResult(outputWriter);
      xformer.transform(source, stringOut);

      //            new SinglePanelPopup(new TextAreaPane(outputWriter.toString()));

      if (systemOut) {
        Result system = new StreamResult(System.out);
        xformer.transform(source, system);
      }

    } catch (TransformerConfigurationException e) {
    } catch (TransformerException e) {
    }
  }
Exemplo n.º 2
0
  private void _writeDocument(Document doc, HttpServletResponse response) {
    try {
      doc.getDocumentElement().normalize();

      TransformerFactory transformerFactory = TransformerFactory.newInstance();

      Transformer transformer = transformerFactory.newTransformer();

      DOMSource source = new DOMSource(doc);

      if (_log.isDebugEnabled()) {
        StreamResult result = new StreamResult(System.out);

        transformer.transform(source, result);
      }

      response.setContentType("text/xml; charset=UTF-8");
      response.setHeader("Cache-Control", "no-cache");

      PrintWriter out = response.getWriter();

      StreamResult result = new StreamResult(out);

      transformer.transform(source, result);

      out.flush();
      out.close();
    } catch (Exception e) {
      throw new FCKException(e);
    }
  }
Exemplo n.º 3
0
  public static void main(String[] args) {

    try {

      DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
      DocumentBuilder builder = factory.newDocumentBuilder();
      Document document = builder.newDocument();
      Element root = document.createElement("Languages");
      root.setAttribute("cat", "it");

      Element lan1 = document.createElement("lan");
      lan1.setAttribute("id", "1");
      Element name1 = document.createElement("name");
      name1.setTextContent("Java");
      Element ide1 = document.createElement("ide");
      ide1.setTextContent("Eclipse");
      lan1.appendChild(name1);
      lan1.appendChild(ide1);

      Element lan2 = document.createElement("lan");
      lan1.setAttribute("id", "2");
      Element name2 = document.createElement("name");
      name1.setTextContent("Swift");
      Element ide2 = document.createElement("ide");
      ide1.setTextContent("Xcode");
      lan1.appendChild(name2);
      lan1.appendChild(ide2);

      Element lan3 = document.createElement("lan");
      lan1.setAttribute("id", "1");
      Element name3 = document.createElement("name");
      name1.setTextContent("Java");
      Element ide3 = document.createElement("ide");
      ide1.setTextContent("Eclipse");
      lan1.appendChild(name3);
      lan1.appendChild(ide3);

      root.appendChild(lan1);
      root.appendChild(lan2);
      root.appendChild(lan3);
      document.appendChild(root);

      TransformerFactory transformerFactory = TransformerFactory.newInstance();
      Transformer transformer = transformerFactory.newTransformer();
      StringWriter writer = new StringWriter();
      transformer.transform(new DOMSource(document), new StreamResult(writer));
      System.out.println(writer.toString());

      transformer.transform(new DOMSource(document), new StreamResult("newXML.xml"));

    } catch (ParserConfigurationException e) {
      e.printStackTrace();
    } catch (TransformerConfigurationException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (TransformerException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
Exemplo n.º 4
0
  public void writeAsAttachment(Object obj, OutputStream out) throws IOException {
    try {
      if (obj instanceof StreamSource) {
        StreamSource source = (StreamSource) obj;
        InputSource inputSource = null;

        InputStream is = source.getInputStream();
        Reader reader = source.getReader();
        String systemId = source.getSystemId();

        if (is != null) inputSource = new InputSource(is);
        else if (reader != null) inputSource = new InputSource(reader);
        else if (systemId != null) inputSource = new InputSource(systemId);

        XMLReader xmlReader = XMLReaderFactory.createXMLReader();
        xmlReader.setEntityResolver(_entityResolver);

        SAXSource saxSource = new SAXSource(xmlReader, inputSource);
        _transformer.transform(saxSource, new StreamResult(out));
      } else _transformer.transform((Source) obj, new StreamResult(out));
    } catch (TransformerException e) {
      IOException ioe = new IOException();
      ioe.initCause(e);

      throw ioe;
    } catch (SAXException saxe) {
      IOException ioe = new IOException();
      ioe.initCause(saxe);

      throw ioe;
    }
  }
Exemplo n.º 5
0
  /**
   * Writes visual structure to output XML
   *
   * @param visualStructure Given visual structure
   * @param pageViewport Page's viewport
   */
  public void writeXML(VisualStructure visualStructure, Viewport pageViewport) {
    try {
      DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
      DocumentBuilder docBuilder = docFactory.newDocumentBuilder();

      doc = docBuilder.newDocument();
      Element vipsElement = doc.createElement("VIPSPage");

      String pageTitle =
          pageViewport
              .getRootElement()
              .getOwnerDocument()
              .getElementsByTagName("title")
              .item(0)
              .getTextContent();

      vipsElement.setAttribute("Url", pageViewport.getRootBox().getBase().toString());
      vipsElement.setAttribute("PageTitle", pageTitle);
      vipsElement.setAttribute("WindowWidth", String.valueOf(pageViewport.getContentWidth()));
      vipsElement.setAttribute("WindowHeight", String.valueOf(pageViewport.getContentHeight()));
      vipsElement.setAttribute("PageRectTop", String.valueOf(pageViewport.getAbsoluteContentY()));
      vipsElement.setAttribute("PageRectLeft", String.valueOf(pageViewport.getAbsoluteContentX()));
      vipsElement.setAttribute("PageRectWidth", String.valueOf(pageViewport.getContentWidth()));
      vipsElement.setAttribute("PageRectHeight", String.valueOf(pageViewport.getContentHeight()));
      vipsElement.setAttribute("neworder", "0");
      vipsElement.setAttribute("order", String.valueOf(pageViewport.getOrder()));

      doc.appendChild(vipsElement);

      writeVisualBlocks(vipsElement, visualStructure);

      TransformerFactory transformerFactory = TransformerFactory.newInstance();
      Transformer transformer = transformerFactory.newTransformer();
      transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
      transformer.setOutputProperty(OutputKeys.INDENT, "yes");
      DOMSource source = new DOMSource(doc);

      if (_escapeOutput) {
        StreamResult result = new StreamResult(new File(_filename + ".xml"));
        transformer.transform(source, result);
      } else {
        StringWriter writer = new StringWriter();
        transformer.transform(source, new StreamResult(writer));
        String result = writer.toString();

        result = result.replaceAll(">", ">");
        result = result.replaceAll("&lt;", "<");
        result = result.replaceAll("&quot;", "\"");

        FileWriter fstream = new FileWriter(_filename + ".xml");
        fstream.write(result);
        fstream.close();
      }
    } catch (Exception e) {
      System.err.println("Error: " + e.getMessage());
      e.printStackTrace();
    }
  }
Exemplo n.º 6
0
  public void saveCurrentRoute(View view) {

    if (GPS_captureStarted) {
      Log.w("Saving Route", "Can't Save, tracking not paused");
      return;
    }

    Element metadata = gpx_document.createElement("metadata");
    Element filename = gpx_document.createElement("name");
    Element author = gpx_document.createElement("author");
    Element trackName = gpx_document.createElement("name");

    String fn = "TestFile";
    String tn = "TestTrack";
    String auth = "Username";

    filename.appendChild(gpx_document.createTextNode(fn));
    author.appendChild(gpx_document.createTextNode(auth));
    trackName.appendChild(gpx_document.createTextNode(tn));

    track.appendChild(trackName);
    metadata.appendChild(filename);
    metadata.appendChild(author);
    rootElement.appendChild(metadata);

    try {

      ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
      NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
      boolean isConnected = activeNetwork != null && activeNetwork.isConnected();

      Transformer transformer = TransformerFactory.newInstance().newTransformer();
      DOMSource source = new DOMSource(gpx_document);
      StreamResult result;
      if (isConnected) {
        result = new StreamResult(new StringWriter());
        transformer.transform(source, result);
        String gpx = result.getWriter().toString();
        Request.send_GPX(gpx);
      } else {
        FileOutputStream stream = openFileOutput(fn + ".gpx", MODE_PRIVATE);
        result = new StreamResult(stream);
        transformer.transform(source, result);

        Log.i("writing file", "success");
        filesToSync.put(fn + ".gpx", true);
      }

    } catch (TransformerConfigurationException e) {
      e.printStackTrace();
    } catch (TransformerException e) {
      e.printStackTrace();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
  private static void diffAll(
      String htmlOutputDir, String previousChangelist, String currentChangelist) throws Exception {
    ResultFileSetLoader loader = new ResultFileSetLoader();
    Map currentTests = loader.loadResultFiles(".");

    FileTestImporter imp = new FileTestImporter();
    Map previousTests = imp.getTestsForChangelist(previousChangelist);

    ArrayList diffs = new ArrayList(currentTests.keySet().size());
    Object[] keys = currentTests.keySet().toArray();
    Arrays.sort(keys);

    for (int i = 0; i < keys.length; i++) {
      String testFile = (String) keys[i];

      XMLResult previous = (XMLResult) previousTests.get(testFile);
      if (null == previous) {
        System.out.println("Null Test file: " + testFile);
        previous = new EmptyXMLResult(testFile);
        previousTests.put(testFile, previous);
      }
      previous.setChangelist(previousChangelist);
      XMLResult current = (XMLResult) currentTests.get(testFile);
      current.setChangelist(currentChangelist);
      ResultDiff diff = new ResultDiff(previous, current);
      diffs.add(diff);
    }

    String databaseType = System.getProperty("database.key");
    ReportIndex index = new ReportIndex(previousChangelist, currentChangelist, databaseType);
    XMLOutputter out = new XMLOutputter("  ", true);
    final String ACS_HOME = System.getProperty("ACS_HOME");
    Transformer tran =
        TransformerFactory.newInstance()
            .newTransformer(new StreamSource(ACS_HOME + "/test/xsl/junit.xsl"));
    for (Iterator iterator = diffs.iterator(); iterator.hasNext(); ) {
      ResultDiff resultDiff = (ResultDiff) iterator.next();
      index.addResult(resultDiff);

      String htmlFile = resultDiff.getAttributeValue("name") + ".html";
      FileWriter file = new FileWriter(htmlOutputDir + "/" + htmlFile);
      JDOMResult html = new JDOMResult();
      tran.transform(new JDOMSource(new Document(resultDiff)), html);
      out.output(html.getDocument(), file);
    }

    JDOMResult indexHtml = new JDOMResult();
    tran =
        TransformerFactory.newInstance()
            .newTransformer(new StreamSource(ACS_HOME + "/test/xsl/index.xsl"));
    tran.transform(new JDOMSource(new Document(index)), indexHtml);
    FileWriter indexFile = new FileWriter(htmlOutputDir + "/index.html");
    out.output(indexHtml.getDocument(), indexFile);

    out.output(
        new Document(index), new FileOutputStream("report_index_" + currentChangelist + ".xml"));
  }
Exemplo n.º 8
0
  private void createTestModel0(final I_EXP_Format exportFormat) throws Exception {
    final File directory = getTestModelDirectory();
    final File file = new File(directory, getTestModelFileName(exportFormat));

    final ExportHelper expHelper = new ExportHelper(getCtx(), getAD_Client_ID());
    final IReplicationAccessContext racCtx =
        new ReplicationAccessContext(10, false); // TODO hardcoded

    final Document doc =
        expHelper.exportRecord(
            (MEXPFormat) LegacyAdapters.convertToPO(exportFormat),
            "",
            MReplicationStrategy.REPLICATION_TABLE,
            X_AD_ReplicationTable.REPLICATIONTYPE_Merge,
            ModelValidator.TYPE_AFTER_CHANGE,
            racCtx);
    if (doc == null) {
      addLog(
          "Not creating test XML for format '"
              + exportFormat.getName()
              + "', because with AD_Client_ID="
              + getAD_Client_ID()
              + "the system can't access any '"
              + exportFormat.getAD_Table().getName()
              + "'-record");
      return;
    }
    // Save the document to the disk file
    final TransformerFactory tranFactory = TransformerFactory.newInstance();

    final Transformer aTransformer = tranFactory.newTransformer();
    aTransformer.setOutputProperty(OutputKeys.METHOD, "xml");
    aTransformer.setOutputProperty(OutputKeys.INDENT, "yes");
    final Source src = new DOMSource(doc);

    // =================================== Write to String
    final Writer writer = new StringWriter();
    final Result dest2 = new StreamResult(writer);
    aTransformer.transform(src, dest2);
    // =================================== Write to Disk
    try {
      final Result dest = new StreamResult(file);
      aTransformer.transform(src, dest);
      writer.flush();
      writer.close();

    } catch (TransformerException ex) {
      ex.printStackTrace();
      throw ex;
    }
    addLog("Created test model: " + file);
  }
Exemplo n.º 9
0
  /** Save the modifications */
  public static void writeDocument(String filename, Node written) {
    Transformer transformer = null;
    try {
      transformer = ScilabTransformerFactory.newInstance().newTransformer();
    } catch (TransformerConfigurationException e1) {
      System.err.println(ERROR_WRITE + filename);
      return;
    } catch (TransformerFactoryConfigurationError e1) {
      System.err.println(ERROR_WRITE + filename);
      return;
    }
    transformer.setOutputProperty(OutputKeys.INDENT, "yes");

    StreamResult result = new StreamResult(new File(filename));
    DOMSource source = new DOMSource(written);
    try {
      transformer.transform(source, result);
    } catch (TransformerException e) {
      System.err.println(ERROR_WRITE + filename);
      return;
    }

    // Invalidate the current document
    if (filename.equals(USER_CONFIG_FILE)) {
      doc = null;
    }
  }
Exemplo n.º 10
0
 public String transform(String type, String input, Map<String, String> transformModel)
     throws TransformException {
   if (log.isDebugEnabled()) {
     log.debug("transform(input=" + input + ")");
   }
   try {
     Templates template = templates.get(type);
     if (log.isDebugEnabled()) {
       log.debug("template=" + template);
     }
     if (template != null) {
       Transformer transformer = template.newTransformer();
       StringWriter writer = new StringWriter(INITIAL_BUFFER_SIZE);
       transformer.setErrorListener(new DefaultErrorListener());
       if (transformModel != null) {
         for (Map.Entry<String, String> entry : transformModel.entrySet()) {
           transformer.setParameter(entry.getKey(), entry.getValue());
         }
       }
       transformer.transform(new StreamSource(new StringReader(input)), new StreamResult(writer));
       String result = writer.toString().trim();
       if (log.isDebugEnabled()) {
         log.debug("result=" + result);
       }
       return result;
     } else {
       String errMsg = "Transformation '" + type + "' not available";
       log.error(errMsg);
       throw new RuntimeException(errMsg);
     }
   } catch (Exception e) {
     log.error("Error during transform", e);
     throw new TransformException(e);
   }
 }
  @Override
  public boolean handleMessage(LogicalMessageContext logicalMessageContext) {
    try {
      boolean outboundMessage =
          (boolean) logicalMessageContext.get(MessageContext.MESSAGE_OUTBOUND_PROPERTY);

      if (!outboundMessage) {
        return true;
      }

      LogicalMessage logicalMessage = logicalMessageContext.getMessage();

      Transformer transformer =
          _transformerFactory.newTransformer(new StreamSource(_url.openStream()));

      DOMResult domResult = new DOMResult();

      transformer.transform(logicalMessage.getPayload(), domResult);

      logicalMessage.setPayload(new DOMSource(domResult.getNode()));

      return true;
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
Exemplo n.º 12
0
  public void createDom()
      throws ParserConfigurationException, SAXException, IOException, TransformerException {
    String filePath = "maven_template.xml";
    DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
    DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
    Document doc = dBuilder.parse(filePath);

    Node projectUrl = doc.getElementsByTagName("projectUrl").item(0);
    projectUrl.setTextContent("https://github.com/YuesongWang/TestJenkins/");

    Node url = doc.getElementsByTagName("url").item(0);
    url.setTextContent("[email protected]:YuesongWang/TestJenkins.git");

    Node credentialsId = doc.getElementsByTagName("credentialsId").item(0);
    credentialsId.setTextContent("c56c7063-12a8-4a0f-b772-83b16732f6bf");

    Node targets = doc.getElementsByTagName("targets").item(0);
    targets.setTextContent("clean install");

    TransformerFactory transformerFactory = TransformerFactory.newInstance();
    Transformer transformer = transformerFactory.newTransformer();
    DOMSource source = new DOMSource(doc);
    StreamResult result = new StreamResult(new File("config.xml"));
    transformer.transform(source, result);
  }
Exemplo n.º 13
0
  public void write(Document doc, OutputStream outputStream) throws IOException {
    //        OutputFormat format = new OutputFormat(doc);
    //        format.setIndenting(true);
    //        format.setEncoding("UTF-8");
    //        XMLSerializer serializer = new XMLSerializer(outputStream, format);
    //        serializer.asDOMSerializer();
    //        serializer.serialize(doc);

    try {
      TransformerFactory factory = TransformerFactory.newInstance();
      try {
        factory.setAttribute("indent-number", 4);
      } catch (Exception e) {; // guess we can't set it, that's ok
      }

      Transformer transformer = factory.newTransformer();
      transformer.setOutputProperty(OutputKeys.METHOD, "xml");
      transformer.setOutputProperty(OutputKeys.INDENT, "yes");
      transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");

      // need to nest outputStreamWriter to get around JDK 5 bug.  See
      // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6296446
      transformer.transform(
          new DOMSource(doc), new StreamResult(new OutputStreamWriter(outputStream, "utf-8")));
    } catch (TransformerException e) {
      throw new IOException(e.getMessage());
    }
  }
 private String transformXml(final Document document) throws TransformerException {
   final Transformer transformer = XmlUtils.createIndentingTransformer();
   final DOMSource source = new DOMSource(document);
   final StreamResult result = new StreamResult(new StringWriter());
   transformer.transform(source, result);
   return result.getWriter().toString();
 }
 protected Document wbxmlStream2Doc(InputStream in, boolean event) throws Exception {
   XMLStreamReader xmlStreamReader = null;
   XMLEventReader xmlEventReader = null;
   try {
     if (event) {
       xmlEventReader = inFact.createXMLEventReader(in);
     } else {
       xmlStreamReader = inFact.createXMLStreamReader(in);
     }
     Transformer xformer = TransformerFactory.newInstance().newTransformer();
     StAXSource staxSource =
         event ? new StAXSource(xmlEventReader) : new StAXSource(xmlStreamReader);
     DOMResult domResult = new DOMResult();
     xformer.transform(staxSource, domResult);
     Document doc = (Document) domResult.getNode();
     doc.normalize();
     return doc;
   } finally {
     if (xmlStreamReader != null) {
       try {
         xmlStreamReader.close();
       } catch (Exception e) {
       }
     }
     if (xmlEventReader != null) {
       try {
         xmlEventReader.close();
       } catch (Exception e) {
       }
     }
   }
 }
Exemplo n.º 16
0
  /**
   * Serialize this instance to a steam.
   *
   * <p>Default deserialization is pretty-printed but not schema-validated.
   *
   * @param out the stream for writing
   * @param validate whether to perform schema validation
   * @throws JAXBException if the steam can't be written to
   */
  public void marshal(final OutputStream out, final Boolean validate) throws JAXBException {
    try {
      // Create an empty DOM
      DOMResult intermediateResult = new DOMResult();

      // Marshal from JAXB to DOM
      Marshaller marshaller = /*BPMN_CONTEXT*/ newContext().createMarshaller();
      marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
      if (validate) {
        marshaller.setSchema(getBpmnSchema() /*BPMN_SCHEMA*/);
      }
      marshaller.marshal(new BpmnObjectFactory().createDefinitions(this), intermediateResult);

      // Apply the XSLT transformation, from DOM to the output stream
      TransformerFactory transformerFactory = TransformerFactory.newInstance();
      Transformer transformer =
          transformerFactory.newTransformer(
              new StreamSource(
                  new java.io.StringBufferInputStream(
                      fixNamespacesXslt[0] + getTargetNamespace() + fixNamespacesXslt[1])));
      DOMSource finalSource = new DOMSource(intermediateResult.getNode());
      StreamResult finalResult = new StreamResult(out);
      transformer.transform(finalSource, finalResult);
    } catch (TransformerException e) {
      throw new JAXBException("Dodgy wrapped exception", e);
    } // TODO - create transformer elsewhere
  }
Exemplo n.º 17
0
    @Override
    public void go(Source input) throws IOException, ServletException {
      // Set the content-type for the output
      assignContentType(this.getTransformCtx());

      Transformer trans;
      try {
        trans = this.getCompiled().newTransformer();
      } catch (TransformerConfigurationException ex) {
        throw new ServletException(ex);
      }

      // Populate any params which might have been set
      if (this.getTransformCtx().getTransformParams() != null)
        populateParams(trans, this.getTransformCtx().getTransformParams());

      Result res;
      if (this.getNext().isLast())
        res = new StreamResult(this.getNext().getResponse().getOutputStream());
      else res = new SAXResult(this.getNext().getSAXHandler());

      try {
        trans.transform(input, res);
      } catch (TransformerException ex) {
        throw new ServletException(ex);
      }

      this.getNext().done();
    }
  /**
   * @param monitor
   * @throws Exception
   */
  private void addServletToGwtXml(IProgressMonitor monitor) throws Exception {

    monitor = Util.getNonNullMonitor(monitor);

    try {

      monitor.beginTask("", 1);

      DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

      DocumentBuilder builder = factory.newDocumentBuilder();

      File moduleFile = getModuleFile();

      Document document = builder.parse(moduleFile);
      Node module = document.getDocumentElement();

      Element newServlet = document.createElement("servlet");
      newServlet.setAttribute("path", "/" + serviceUri); // $NON-NLS-2$
      newServlet.setAttribute(
          "class",
          getPackageFragment().getElementName() + '.' + getTypeName() + "Impl"); // $NON-NLS-2$

      module.appendChild(newServlet);

      Transformer writer = TransformerFactory.newInstance().newTransformer();

      writer.transform(new DOMSource(document), new StreamResult(moduleFile));

    } finally {
      monitor.done();
    }
  }
Exemplo n.º 19
0
  /**
   * Pomocnicza klasa wysyłająca dokument XML do writera
   *
   * @param doc dokument, który chcemy wysłać
   * @param out Writer, do którego chcemy pisać
   */
  private void XML2Writer(Document doc, PrintWriter out) {
    Transformer transformer = null;

    try {

      transformer = TransformerFactory.newInstance().newTransformer();

    } catch (TransformerFactoryConfigurationError e) {

      e.printStackTrace();
    } catch (TransformerConfigurationException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    StreamResult result = new StreamResult(out);
    DOMSource source = new DOMSource(doc);

    try {
      if (transformer != null) {
        transformer.transform(source, result);
      }
    } catch (TransformerException e) {

      e.printStackTrace();
    }
  }
Exemplo n.º 20
0
  /**
   * Marshal jaxb element and try to perform basic formatting like namespace clean up and attribute
   * formatting with xsl transformation.
   *
   * @param jaxbElement
   * @return
   */
  private String getXmlContent(Object jaxbElement) {
    StringResult jaxbContent = new StringResult();

    springBeanMarshaller.marshal(jaxbElement, jaxbContent);

    Source xsltSource;
    try {
      xsltSource =
          new StreamSource(new ClassPathResource("transform/format-bean.xsl").getInputStream());
      Transformer transformer = transformerFactory.newTransformer(xsltSource);

      // transform
      StringResult result = new StringResult();
      transformer.transform(new StringSource(jaxbContent.toString()), result);

      if (log.isDebugEnabled()) {
        log.debug("Created bean definition:\n" + result.toString());
      }

      return result.toString();
    } catch (IOException e) {
      throw new ApplicationRuntimeException(UNABLE_TO_READ_TRANSFORMATION_SOURCE, e);
    } catch (TransformerException e) {
      throw new ApplicationRuntimeException(FAILED_TO_UPDATE_BEAN_DEFINITION, e);
    }
  }
Exemplo n.º 21
0
  /**
   * Method removes a Spring bean definition from the XML application context file. Bean definition
   * is identified by its id or bean name.
   *
   * @param project
   * @param id
   */
  public void removeBeanDefinition(File configFile, Project project, String id) {
    Source xsltSource;
    Source xmlSource;
    try {
      xsltSource =
          new StreamSource(new ClassPathResource("transform/delete-bean.xsl").getInputStream());
      xsltSource.setSystemId("delete-bean");

      List<File> configFiles = new ArrayList<>();
      configFiles.add(configFile);
      configFiles.addAll(getConfigImports(configFile, project));

      for (File file : configFiles) {
        xmlSource = new StringSource(FileUtils.readToString(new FileInputStream(configFile)));

        // create transformer
        Transformer transformer = transformerFactory.newTransformer(xsltSource);
        transformer.setParameter("bean_id", id);

        // transform
        StringResult result = new StringResult();
        transformer.transform(xmlSource, result);
        FileUtils.writeToFile(format(result.toString(), project.getSettings().getTabSize()), file);
        return;
      }
    } catch (IOException e) {
      throw new ApplicationRuntimeException(UNABLE_TO_READ_TRANSFORMATION_SOURCE, e);
    } catch (TransformerException e) {
      throw new ApplicationRuntimeException(FAILED_TO_UPDATE_BEAN_DEFINITION, e);
    }
  }
Exemplo n.º 22
0
  /**
   * Method adds a new Spring bean definition to the XML application context file.
   *
   * @param project
   * @param jaxbElement
   */
  public void addBeanDefinition(File configFile, Project project, Object jaxbElement) {
    Source xsltSource;
    Source xmlSource;
    try {
      xsltSource =
          new StreamSource(new ClassPathResource("transform/add-bean.xsl").getInputStream());
      xsltSource.setSystemId("add-bean");
      xmlSource = new StringSource(FileUtils.readToString(new FileInputStream(configFile)));

      // create transformer
      Transformer transformer = transformerFactory.newTransformer(xsltSource);
      transformer.setParameter(
          "bean_content",
          getXmlContent(jaxbElement)
              .replaceAll("(?m)^(.)", getTabs(1, project.getSettings().getTabSize()) + "$1"));

      // transform
      StringResult result = new StringResult();
      transformer.transform(xmlSource, result);
      FileUtils.writeToFile(
          format(result.toString(), project.getSettings().getTabSize()), configFile);
      return;
    } catch (IOException e) {
      throw new ApplicationRuntimeException(UNABLE_TO_READ_TRANSFORMATION_SOURCE, e);
    } catch (TransformerException e) {
      throw new ApplicationRuntimeException(FAILED_TO_UPDATE_BEAN_DEFINITION, e);
    }
  }
Exemplo n.º 23
0
  /** Save the modifications */
  public static String dumpNode(Node written) {
    Transformer transformer = null;
    try {
      transformer = ScilabTransformerFactory.newInstance().newTransformer();
    } catch (TransformerConfigurationException e1) {
      System.err.println("Cannot dump xml");
      return "";
    } catch (TransformerFactoryConfigurationError e1) {
      System.err.println("Cannot dump xml");
      return "";
    }
    transformer.setOutputProperty(OutputKeys.INDENT, "yes");

    ByteArrayOutputStream stream = new ByteArrayOutputStream();
    StreamResult result = new StreamResult(new BufferedOutputStream(stream));
    DOMSource source = new DOMSource(written);
    String str = "";
    try {
      transformer.transform(source, result);
      str = stream.toString();
    } catch (TransformerException e) {
      System.err.println("Cannot dump xml");
      return str;
    } finally {
      try {
        stream.close();
      } catch (Exception e) {
      }
    }

    return str;
  }
Exemplo n.º 24
0
  public void storeMappings(WorkspaceLanguageConfiguration config) throws CoreException {
    try {
      // Encode mappings as XML and serialize as a String.
      Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
      Element rootElement = doc.createElement(WORKSPACE_MAPPINGS);
      doc.appendChild(rootElement);
      addContentTypeMappings(config.getWorkspaceMappings(), rootElement);
      Transformer serializer = createSerializer();
      DOMSource source = new DOMSource(doc);
      StringWriter buffer = new StringWriter();
      StreamResult result = new StreamResult(buffer);
      serializer.transform(source, result);
      String encodedMappings = buffer.getBuffer().toString();

      IEclipsePreferences node = InstanceScope.INSTANCE.getNode(CCorePlugin.PLUGIN_ID);
      node.put(CCorePreferenceConstants.WORKSPACE_LANGUAGE_MAPPINGS, encodedMappings);
      node.flush();
    } catch (ParserConfigurationException e) {
      throw new CoreException(Util.createStatus(e));
    } catch (TransformerException e) {
      throw new CoreException(Util.createStatus(e));
    } catch (BackingStoreException e) {
      throw new CoreException(Util.createStatus(e));
    }
  }
Exemplo n.º 25
0
  protected void doTransform(
      MuleMessage message, String outputEncoding, Source sourceDoc, Result result)
      throws Exception {
    DefaultErrorListener errorListener = new DefaultErrorListener(this);
    javax.xml.transform.Transformer transformer = null;

    try {
      transformer = (javax.xml.transform.Transformer) transformerPool.borrowObject();

      transformer.setErrorListener(errorListener);
      transformer.setOutputProperty(OutputKeys.ENCODING, outputEncoding);

      // set transformation parameters
      if (contextProperties != null) {
        for (Entry<String, Object> parameter : contextProperties.entrySet()) {
          String key = parameter.getKey();
          transformer.setParameter(
              key, evaluateTransformParameter(key, parameter.getValue(), message));
        }
      }

      transformer.transform(sourceDoc, result);

      if (errorListener.isError()) {
        throw errorListener.getException();
      }
    } finally {
      if (transformer != null) {
        transformerPool.returnObject(transformer);
      }
    }
  }
  private void parseWebFragmentXml() throws XMLStreamException, IOException, TransformerException {
    final XMLInputFactory xif = XMLInputFactory.newInstance();
    final XMLStreamReader xsr = xif.createXMLStreamReader(getInputStream());
    xsr.nextTag(); // web-fragment tag skipped

    while (xsr.hasNext() && xsr.nextTag() == XMLStreamConstants.START_ELEMENT) {
      final String tagName = xsr.getLocalName();
      // webFragmentName
      if ("name".equalsIgnoreCase(tagName)) {
        final String element = xsr.getElementText();
        allWebFragmentNames.add(element);
        webFragmentXmlComponents.add("<name>" + element + "</name>");
      } else {
        final TransformerFactory tf = TransformerFactory.newInstance();
        final Transformer t = tf.newTransformer();
        final StringWriter res = new StringWriter();
        t.transform(new StAXSource(xsr), new StreamResult(res));
        final String element =
            org.apache.commons.lang3.StringUtils.substringAfter(res.toString(), "?>");
        if ("ordering".equalsIgnoreCase(tagName)) {
          // ordering
          parseOrdering(element);
        } else {
          // webFragmentXmlComponents
          webFragmentXmlComponents.add(element);
        }
      }
    }
    if (allWebFragmentNames.isEmpty()) {
      throw new IllegalStateException(
          "Name tag is missing. Please specify a name in the web-fragment.xml!");
    }
  }
Exemplo n.º 27
0
  public static void main(String[] args) {

    String outputDir = "./";

    for (int i = 0; i < args.length; i++) {
      String arg = args[i];
      if ("-o".equals(arg)) {
        outputDir = args[++i];
        continue;
      } else {
        System.out.println("XMLSchemaGenerator -o <path to newly created xsd schema file>");
        return;
      }
    }

    File f = new File(outputDir, "JGroups-" + Version.major + "." + Version.minor + ".xsd");
    try {
      FileWriter fw = new FileWriter(f, false);
      DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
      DocumentBuilder builder = factory.newDocumentBuilder();
      DOMImplementation impl = builder.getDOMImplementation();
      Document xmldoc = impl.createDocument("http://www.w3.org/2001/XMLSchema", "xs:schema", null);
      xmldoc.getDocumentElement().setAttribute("targetNamespace", "urn:org:jgroups");
      xmldoc.getDocumentElement().setAttribute("elementFormDefault", "qualified");

      Element xsElement = xmldoc.createElement("xs:element");
      xsElement.setAttribute("name", "config");
      xmldoc.getDocumentElement().appendChild(xsElement);

      Element complexType = xmldoc.createElement("xs:complexType");
      xsElement.appendChild(complexType);

      Element allType = xmldoc.createElement("xs:choice");
      allType.setAttribute("maxOccurs", "unbounded");
      complexType.appendChild(allType);

      Set<Class<?>> classes = getClasses("bboss.org.jgroups.protocols", Protocol.class);
      for (Class<?> clazz : classes) {
        classToXML(xmldoc, allType, clazz, "");
      }
      classes = getClasses("bboss.org.jgroups.protocols.pbcast", Protocol.class);
      for (Class<?> clazz : classes) {
        classToXML(xmldoc, allType, clazz, "pbcast.");
      }

      DOMSource domSource = new DOMSource(xmldoc);
      StreamResult streamResult = new StreamResult(fw);
      TransformerFactory tf = TransformerFactory.newInstance();
      Transformer serializer = tf.newTransformer();
      serializer.setOutputProperty(OutputKeys.METHOD, "xml");
      serializer.setOutputProperty(OutputKeys.INDENT, "yes");
      serializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "1");
      serializer.transform(domSource, streamResult);

      fw.flush();
      fw.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Exemplo n.º 28
0
 // write the content into xml file
 private void writeToXml(String fileName, Document doc) throws Exception {
   TransformerFactory transformerFactory = TransformerFactory.newInstance();
   Transformer transformer = transformerFactory.newTransformer();
   DOMSource source = new DOMSource(doc);
   StreamResult result = new StreamResult(new File(fileName));
   transformer.transform(source, result);
 }
Exemplo n.º 29
0
  private void eatMemory(int callIndex, File foFile, int replicatorRepeats) throws Exception {
    Source src = new StreamSource(foFile);

    Transformer transformer = replicatorTemplates.newTransformer();
    transformer.setParameter("repeats", new Integer(replicatorRepeats));

    OutputStream out = new NullOutputStream(); // write to /dev/nul
    try {
      FOUserAgent userAgent = fopFactory.newFOUserAgent();
      userAgent.setBaseURL(foFile.getParentFile().toURL().toExternalForm());
      Fop fop = fopFactory.newFop(MimeConstants.MIME_PDF, userAgent, out);
      Result res = new SAXResult(fop.getDefaultHandler());

      transformer.transform(src, res);

      stats.notifyPagesProduced(fop.getResults().getPageCount());
      if (callIndex == 0) {
        System.out.println(
            foFile.getName() + " generates " + fop.getResults().getPageCount() + " pages.");
      }
      stats.checkStats();
    } finally {
      IOUtils.closeQuietly(out);
    }
  }
Exemplo n.º 30
0
  // TODO - change the return type and the factory parameter to be Definitions and ObjectFactory,
  // and move to bpmn-schema
  public BpmnDefinitions correctFlowNodeRefs(
      final BpmnDefinitions definitions, final BpmnObjectFactory factory)
      throws JAXBException, TransformerException {

    JAXBContext context =
        JAXBContext.newInstance(
            factory.getClass(),
            com.processconfiguration.ObjectFactory.class,
            org.omg.spec.bpmn._20100524.di.ObjectFactory.class,
            org.omg.spec.bpmn._20100524.model.ObjectFactory.class,
            org.omg.spec.dd._20100524.dc.ObjectFactory.class,
            org.omg.spec.dd._20100524.di.ObjectFactory.class,
            com.signavio.ObjectFactory.class);

    // Marshal the BPMN into a DOM tree
    DOMResult intermediateResult = new DOMResult();
    Marshaller marshaller = context.createMarshaller();
    marshaller.marshal(factory.createDefinitions(definitions), intermediateResult);

    // Apply the XSLT transformation, generating a new DOM tree
    TransformerFactory transformerFactory = TransformerFactory.newInstance();
    Transformer transformer =
        transformerFactory.newTransformer(
            new StreamSource(
                getClass().getClassLoader().getResourceAsStream("xsd/fix-flowNodeRef.xsl")));
    DOMSource finalSource = new DOMSource(intermediateResult.getNode());
    DOMResult finalResult = new DOMResult();
    transformer.transform(finalSource, finalResult);

    // Unmarshal back to JAXB
    Object def2 = context.createUnmarshaller().unmarshal(finalResult.getNode());
    return ((JAXBElement<BpmnDefinitions>) def2).getValue();
  }