public IXArchElement cloneElement(int depth) {
    synchronized (DOMUtils.getDOMLock(elt)) {
      Document doc = elt.getOwnerDocument();
      if (depth == 0) {
        Element cloneElt = (Element) elt.cloneNode(false);
        cloneElt = (Element) doc.importNode(cloneElt, true);
        AbstractChangeSetImpl cloneImpl = new AbstractChangeSetImpl(cloneElt);
        cloneImpl.setXArch(getXArch());
        return cloneImpl;
      } else if (depth == 1) {
        Element cloneElt = (Element) elt.cloneNode(false);
        cloneElt = (Element) doc.importNode(cloneElt, true);
        AbstractChangeSetImpl cloneImpl = new AbstractChangeSetImpl(cloneElt);
        cloneImpl.setXArch(getXArch());

        NodeList nl = elt.getChildNodes();
        int size = nl.getLength();
        for (int i = 0; i < size; i++) {
          Node n = nl.item(i);
          Node cloneNode = (Node) n.cloneNode(false);
          cloneNode = doc.importNode(cloneNode, true);
          cloneElt.appendChild(cloneNode);
        }
        return cloneImpl;
      } else /* depth = infinity */ {
        Element cloneElt = (Element) elt.cloneNode(true);
        cloneElt = (Element) doc.importNode(cloneElt, true);
        AbstractChangeSetImpl cloneImpl = new AbstractChangeSetImpl(cloneElt);
        cloneImpl.setXArch(getXArch());
        return cloneImpl;
      }
    }
  }
  private void parseQuestDropList(Node dropList, String questID) throws NullPointerException {
    if (DEBUG) _log.info("Parsing Droplist.");

    for (Node node = dropList.getFirstChild(); node != null; node = node.getNextSibling()) {
      if (isNodeName(node, "DROP")) {
        parseQuestDrop(node.cloneNode(true), questID);
      }
    }
  }
 /**
  * Get style from parent node. from first paret 'firstF', we will traverse the tree up untile
  * reaching Document node, get all style node's, we may insert rules here to stop the search at a
  * before paricular node. Style nodes could <b>, <u>...
  *
  * @param children
  * @param firstF
  */
 void assignFather(Vector children, Node firstF) {
   if (children.size() == 0) {
     return;
   }
   if (firstF != null && !isDocument(firstF)) {
     String name = firstF.getNodeName();
     // To see whether it is a style node that is our anticipated node.
     if (name != null && HTML_STYLE_NODES.contains(name.toLowerCase())) {
       Node newParent = firstF.cloneNode(false);
       while (children.size() > 0) {
         newParent.appendChild((Node) children.remove(0));
       }
       children.add(newParent);
     }
     assignFather(children, firstF.getParentNode());
   }
 }
  @Override
  public void parseScript(Node questNode, ScriptContext context) {
    if (DEBUG) _log.info("Parsing Quest.");

    String questID = attribute(questNode, "ID");

    for (Node node = questNode.getFirstChild(); node != null; node = node.getNextSibling()) {
      if (isNodeName(node, "DROPLIST")) {
        parseQuestDropList(node.cloneNode(true), questID);
      } else if (isNodeName(node, "DIALOG WINDOWS")) {
        // parseDialogWindows(node.cloneNode(true));
      } else if (isNodeName(node, "INITIATOR")) {
        // parseInitiator(node.cloneNode(true));
      } else if (isNodeName(node, "STATE")) {
        // parseState(node.cloneNode(true));
      }
    }
  }
 /**
  * Transform the DOM tree using the configuration.
  *
  * @param configuration the transformation configuration.
  * @param doc the DOM tree to be updated.
  */
 protected void applyTransformation(XmlConfiguration configuration, Document doc) {
   List<Parameter> parameters = configuration.getParameters();
   for (Parameter parameter : parameters) {
     displayMessageln("\t" + parameter.getKey() + " (mode:" + parameter.getMode() + ")");
     Node rootXpathNode = getMatchingNode(parameter.getKey(), doc);
     if (rootXpathNode != null) {
       for (Value value : parameter.getValues()) {
         switch (value.getMode()) {
           case XmlTreeHandler.MODE_INSERT:
             {
               createNewNode(doc, rootXpathNode, value);
             }
             break;
           case XmlTreeHandler.MODE_DELETE:
             {
               Node deletedNode = getMatchingNode(value.getLocation(), rootXpathNode);
               rootXpathNode.removeChild(deletedNode);
             }
             break;
           case XmlTreeHandler.MODE_UPDATE:
             {
               Node oldNode = getMatchingNode(value.getLocation(), rootXpathNode);
               if (oldNode == null) {
                 createNewNode(doc, rootXpathNode, value);
               } else {
                 if (rootXpathNode.equals(oldNode)) {
                   rootXpathNode = rootXpathNode.getParentNode();
                 }
                 Node newNode = oldNode.cloneNode(true);
                 if (oldNode instanceof Element) {
                   ((Element) newNode).setTextContent(value.getValue());
                   rootXpathNode.replaceChild(newNode, oldNode);
                 } else {
                   ((Attr) newNode).setValue(value.getValue());
                   rootXpathNode.getAttributes().setNamedItem(newNode);
                 }
               }
               break;
             }
         }
       }
     }
   }
 }
  /**
   * Decodes the given XML node. The optional "into" argument specifies an existing object to be
   * used. If no object is given, then a new instance is created using the constructor from the
   * codec.
   *
   * <p>The function returns the passed in object or the new instance if no object was given.
   *
   * @param node XML node to be decoded.
   * @param into Optional object to be decodec into.
   * @return Returns an object that represents the given node.
   */
  public Object decode(Node node, Object into) {
    Object obj = null;

    if (node != null && node.getNodeType() == Node.ELEMENT_NODE) {
      mxObjectCodec codec = mxCodecRegistry.getCodec(node.getNodeName());

      try {
        if (codec != null) {
          obj = codec.decode(this, node, into);
        } else {
          obj = node.cloneNode(true);
          ((Element) obj).removeAttribute("as");
        }
      } catch (Exception e) {
        System.err.println("Cannot decode " + node.getNodeName() + ": " + e.getMessage());
        e.printStackTrace();
      }
    }

    return obj;
  }
Beispiel #7
0
  /**
   * Constructs an overview-node in the pre-html where all steps are described. Also, information
   * about valid and non-valid form-schema's are placed in the steps-overview.
   *
   * <p>The node looks like this:
   *
   * <pre>
   * &lt;steps-validator valid="false" allowsave="false" allowcancel="true"&gt;
   *      &lt;step form-schema="schema-id" valid="true" /&gt;
   *      &lt;step form-schema="schema-id" valid="false" /&gt;
   * &lt;/steps-validator&gt;
   * </pre>
   *
   * THis method creates a steps-overview which can be used by the html to show what forms are valid
   * and what are not.
   *
   * @param prehtml the prehtml data node
   * @param schema the original wizardschema
   */
  public static void createStepsOverview(Document prehtml, Document schema) {

    // remove a "steps-validator" node if it exists.
    Node overview = Utils.selectSingleNode(prehtml, "/*/steps-overview");
    if (overview != null) prehtml.getDocumentElement().removeChild(overview);

    // create new overview node
    overview = prehtml.createElement("steps-validator");
    Utils.setAttribute(overview, "allowcancel", "true");

    int invalidforms = 0;

    // iterate through all defined steps
    NodeList steps = Utils.selectNodeList(schema, "/*/steps/step");
    for (int i = 0; i < steps.getLength(); i++) {
      Node step = steps.item(i);
      String schemaid = Utils.getAttribute(step, "form-schema", "");
      if (!schemaid.equals("")) {
        // find the referred form and check if the form is valid.
        Node form = Utils.selectSingleNode(prehtml, "/*/form[@id='" + schemaid + "']");
        if (form != null) {
          Node validationerror = Utils.selectSingleNode(form, ".//field/validator[@valid='false']");

          boolean valid = (validationerror == null);
          // copy step information to overview node and store validation results.
          Node newstep = prehtml.importNode(step.cloneNode(true), true);
          overview.appendChild(newstep);
          Utils.setAttribute(newstep, "valid", valid + "");
          if (!valid) invalidforms++;
        }
      }
    }

    // store global information about validationresults
    Utils.setAttribute(overview, "allowsave", (invalidforms == 0) + "");
    Utils.setAttribute(overview, "valid", (invalidforms == 0) + "");

    // store new overview node in the prehtml.
    prehtml.getDocumentElement().appendChild(overview);
  }
 void doApply(
     Stylesheet stylesheet,
     QName mode,
     Node context,
     int pos,
     int len,
     Node parent,
     Node nextSibling)
     throws TransformerException {
   Node result = null;
   Document doc = (parent instanceof Document) ? (Document) parent : parent.getOwnerDocument();
   short nodeType = source.getNodeType();
   if (nodeType == Node.ATTRIBUTE_NODE && parent.getFirstChild() != null) {
     // Ignore attributes added after child elements
   } else {
     // Namespace aliasing
     if (nodeType == Node.ELEMENT_NODE) {
       String prefix = source.getPrefix();
       if (prefix == null) prefix = "#default";
       String resultPrefix = (String) stylesheet.namespaceAliases.get(prefix);
       if (resultPrefix != null) {
         if ("#default".equals(resultPrefix)) resultPrefix = null;
         String uri = source.lookupNamespaceURI(resultPrefix);
         String name = source.getNodeName();
         // Create a new element node in the result document
         result = doc.createElementNS(uri, name);
         // copy attributes
         NamedNodeMap srcAttrs = source.getAttributes();
         NamedNodeMap dstAttrs = result.getAttributes();
         int l = srcAttrs.getLength();
         for (int i = 0; i < l; i++) {
           Node attr = srcAttrs.item(i);
           if (!Stylesheet.XSL_NS.equals(attr.getNamespaceURI())) {
             attr = attr.cloneNode(true);
             attr = doc.adoptNode(attr);
             dstAttrs.setNamedItemNS(attr);
           }
         }
       }
     }
     if (result == null) {
       // Create result node
       result = source.cloneNode(false);
       // Remove any XSL attributes
       NamedNodeMap attrs = result.getAttributes();
       if (attrs != null) {
         int l = attrs.getLength();
         for (int i = 0; i < l; i++) {
           Node attr = attrs.item(i);
           if (Stylesheet.XSL_NS.equals(attr.getNamespaceURI())) {
             attrs.removeNamedItem(attr.getNodeName());
             i--;
             l--;
           }
         }
       }
       Node result2 = doc.adoptNode(result);
       if (result2 == null) {
         String msg =
             "Error adopting node to result tree: "
                 + result
                 + " ("
                 + result.getClass().getName()
                 + ")";
         DOMSourceLocator l = new DOMSourceLocator(context);
         throw new TransformerException(msg, l);
       }
       result = result2;
     }
     if (nextSibling != null) parent.insertBefore(result, nextSibling);
     else parent.appendChild(result);
     if (nodeType == Node.ELEMENT_NODE)
       stylesheet.addNamespaceNodes(source, result, doc, elementExcludeResultPrefixes);
     // children
     if (children != null) children.apply(stylesheet, mode, context, pos, len, result, null);
   }
   // next sibling
   if (next != null) next.apply(stylesheet, mode, context, pos, len, parent, nextSibling);
 }
  public void doLoad(Widget frmModel, JXPathContext jctx) throws BindingException {
    // (There should be a general widget type checker for all the bindings to use,
    // coupled with a general informative exception class to throw if the widget is
    // of the wrong type or null.)
    Repeater repeater = (Repeater) selectWidget(frmModel, this.repeaterId);
    if (repeater == null) {
      String fullId = frmModel.getRequestParameterName();
      if (fullId == null || fullId.length() == 0) {
        fullId = "";
      } else {
        fullId = fullId + ".";
      }
      throw new RuntimeException(
          "TempRepeaterJXPathBinding: Repeater \""
              + fullId
              + this.repeaterId
              + "\" does not exist ("
              + frmModel.getLocation()
              + ")");
    }

    // Start by clearing the repeater, if necessary.
    if (this.clearOnLoad) {
      repeater.clear();
    }

    // Find the location of the repeater data.
    Pointer repeaterPointer = jctx.getPointer(this.repeaterPath);

    // Check if there is data present.
    //
    // (Otherwise, should we check the leniency config option
    // to decide whether to be silent or throw an exception?)
    if (repeaterPointer != null) {

      // Narrow to repeater context.
      JXPathContext repeaterContext = jctx.getRelativeContext(repeaterPointer);

      // Build a jxpath iterator for the repeater row pointers.
      Iterator rowPointers = repeaterContext.iteratePointers(this.rowPath);

      // Iterate through the rows of data.
      int rowNum = 0;
      while (rowPointers.hasNext()) {

        // Get or create a row widget.
        Repeater.RepeaterRow thisRow;
        if (repeater.getSize() > rowNum) {
          thisRow = repeater.getRow(rowNum);
        } else {
          thisRow = repeater.addRow();
        }
        rowNum++;

        // Narrow to the row context.
        Pointer rowPointer = (Pointer) rowPointers.next();
        JXPathContext rowContext = repeaterContext.getRelativeContext(rowPointer);

        // If virtual rows are requested, place a deep clone of the row data
        // into a temporary node, and narrow the context to this virtual row.
        //
        // (A clone of the data is used to prevent modifying the source document.
        // Otherwise, the appendChild method would remove the data from the source
        // document.  Is this protection worth the penalty of a deep clone?)
        //
        // (This implementation of virtual rows currently only supports DOM
        // bindings, but could easily be extended to support other bindings.)

        if (virtualRows) {
          Node repeaterNode = (Node) repeaterPointer.getNode();
          Node virtualNode = repeaterNode.getOwnerDocument().createElementNS(null, "virtual");
          Node node = (Node) rowPointer.getNode();
          Node clone = node.cloneNode(true);
          Node fakeDocElement = node.getOwnerDocument().getDocumentElement().cloneNode(false);
          virtualNode.appendChild(clone);
          fakeDocElement.appendChild(virtualNode);
          rowContext = JXPathContext.newContext(repeaterContext, fakeDocElement);
          rowContext = rowContext.getRelativeContext(rowContext.getPointer("virtual"));
        }

        // Finally, perform the load row binding.
        this.rowBinding.loadFormFromModel(thisRow, rowContext);
      }
    }

    if (getLogger().isDebugEnabled()) getLogger().debug("done loading rows " + this);
  }
  public void enviarFicheroGeneralEnPorciones(EnvioErroneo envio) {
    try {

      // Tenemos que dividir el archivo por cursos y unidades
      DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
      documentBuilderFactory.setNamespaceAware(false);
      documentBuilderFactory.setValidating(false);
      DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
      File tmpX = new File(getCarpetaFallidos(), envio.getFicheroEnvio().getName() + ".tmp");
      Archivo.setContenido(
          Archivo.getContenido(envio.getFicheroEnvio(), "latin1"), "UTF-8", tmpX, false);
      Document doc = documentBuilder.parse(tmpX);
      tmpX.delete();
      // Ahore recorremos el documento generando un archivo nuevo por cada version
      Node nCursos = doc.getElementsByTagName("CURSOS").item(0);
      Node datosGenerales = doc.getElementsByTagName("DATOS_GENERALES").item(0);
      NodeList cursos = nCursos.getChildNodes();
      for (int i = 0; i < cursos.getLength(); i++) {
        Object obj = cursos.item(i);
        if (!(obj instanceof Element)) {
          continue;
        }
        Element cursoActual = (Element) obj;
        // Creamos un nuevo documento
        Document nuevoDoc = documentBuilder.newDocument();
        // Le añadimos un nodo de servicio
        Node servicio = nuevoDoc.createElement("SERVICIO");
        nuevoDoc.appendChild(servicio);
        // A este le añadimos los datos generales (clonados)
        Node nuevoDatosGenerales = datosGenerales.cloneNode(true);
        nuevoDoc.adoptNode(nuevoDatosGenerales);
        servicio.appendChild(nuevoDatosGenerales);
        // Creamos un nodo de cursos y se lo añadimos
        Node nuevoCursos = nuevoDoc.createElement("CURSOS");
        servicio.appendChild(nuevoCursos);
        // Creamos un nodo de curso y se lo añadimos
        Node nuevoCurso = nuevoDoc.createElement("CURSO");
        nuevoCursos.appendChild(nuevoCurso);
        // Le añadimos los datos al curso
        Node el1 = cursoActual.getElementsByTagName("X_OFERTAMATRIG").item(0).cloneNode(true);
        nuevoDoc.adoptNode(el1);
        String nombreCurso = el1.getTextContent();
        Node el2 = cursoActual.getElementsByTagName("D_OFERTAMATRIG").item(0).cloneNode(true);
        nuevoDoc.adoptNode(el2);
        nuevoCurso.appendChild(el1);
        nuevoCurso.appendChild(el2);
        // Creamos un nodo de unidades y se lo añadimos
        Node nuevoUnidades = nuevoDoc.createElement("UNIDADES");
        nuevoCurso.appendChild(nuevoUnidades);
        // Ahora recorremos las unidades creando un documento nuevo por cada una
        Element nodoUnidadesActual = (Element) cursoActual.getElementsByTagName("UNIDADES").item(0);
        NodeList unidades = nodoUnidadesActual.getChildNodes();
        for (int x = 0; x < unidades.getLength(); x++) {
          Node nObj = unidades.item(x);
          if (!(nObj instanceof Element)) {
            continue;
          }
          // Clonamos la unidad
          Node unidad = nObj.cloneNode(true);
          // Clonamos el documento completo
          Document docActual = (Document) nuevoDoc.cloneNode(true);
          // Adoptamos el nodo creado
          docActual.adoptNode(unidad);
          // Y se lo añadimos a las unidades
          docActual.getElementsByTagName("UNIDADES").item(0).appendChild(unidad);
          // Guardamos el documento y lo enviamos
          String contenido = docToString(docActual);
          File tmp = new File(getCarpetaFallidos(), "tmp_curso_" + nombreCurso + "_" + x + ".xml");
          Archivo.setContenido(contenido, "latin1", tmp, false);
          String codigoOperacion = Cripto.md5(tmp.getName() + "" + Math.random());
          int ret = enviarFichero(tmp, codigoOperacion);
          if (ret == GestorEnvioFaltas.RET_ERROR_PROCESANDO) {
            tmp.delete();
            // Sobre ese archivo tenemos que hacer envíos alumno por alumno
            // Clonamos el documento
            docActual = (Document) nuevoDoc.cloneNode(true);
            // Y procesamos el envío
            enviarFicheroUnidadEnPorciones(envio, docActual, (Element) unidad);
          } else if (ret == GestorEnvioFaltas.RET_ERROR_ENVIANDO) {
            envio.getFallidos().add(tmp);
          } else {
            tmp.delete();
          }
        }
      }
    } catch (Exception ex) {
      Logger.getLogger(GeneradorFicherosSeneca.class.getName()).log(Level.SEVERE, null, ex);
    }
  }
  public Object put(Object key, Object value) {
    try {
      if (key.toString().equalsIgnoreCase("XmlNsPrefix")) {
        String oldPrefix = null;
        try {
          oldPrefix = nodeData.getPrefix();
        } catch (DOMException ex) {
          // Just log it
          com.nary.Debug.printStackTrace(ex);
        }
        nodeData.setPrefix(((cfData) value).toString());
        return oldPrefix;
      } else if (key.toString().equalsIgnoreCase("XmlNsURI")) {
        // Do nothing
        return null;
      } else if (key.toString().equalsIgnoreCase("XmlText")
          || key.toString().equalsIgnoreCase("XmlCData")) {
        boolean isCDATA = key.toString().equalsIgnoreCase("XmlCData");
        // Remove all text and CDATA nodes, and add 1 new one at the top
        remove("XmlText");
        remove("XmlCData");
        if (!((cfData) value).toString().trim().equals("")) {
          Node t = null;
          if (isCDATA)
            t = nodeData.getOwnerDocument().createCDATASection(((cfData) value).toString());
          else t = nodeData.getOwnerDocument().createTextNode(((cfData) value).toString());
          nodeData.insertBefore(t, nodeData.getFirstChild());
        }
        nodeData.normalize();
        return null;
      } else if (key.toString().equalsIgnoreCase("XmlComment")) {
        // Remove all comment nodes, and add 1 new one at the top
        remove(key);
        if (!((cfData) value).toString().trim().equals("")) {
          Comment c = nodeData.getOwnerDocument().createComment(((cfData) value).toString());
          nodeData.insertBefore(c, nodeData.getFirstChild());
        }
        nodeData.normalize();
        return null;
      } else if (key.toString().equalsIgnoreCase("XmlAttributes")) {
        // Overwrite any existing xml attributes with these new ones
        if (value instanceof cfStructData) {
          cfXmlDataAttributeStruct attribs = (cfXmlDataAttributeStruct) getXmlAttributes();
          cfStructData attribsToAdd = (cfStructData) value;

          Object[] keys = attribsToAdd.keys();
          for (int i = 0; i < keys.length; i++) {
            String str = keys[i].toString();
            cfData valueData = attribsToAdd.getData(str);
            attribs.setData(str, valueData);
          }
        }
        return null;
      } else if (key.toString().equalsIgnoreCase("XmlChildren")) {
        // Do nothing
        return null;
      } else if (key.toString().equalsIgnoreCase("XmlParent")) {
        // Do nothing
        return null;
      } else if (key.toString().equalsIgnoreCase("XmlNodes")) {
        // Do nothing
        return null;
      } else {
        if (value instanceof cfXmlData) {
          Node n = ((cfXmlData) value).getXMLNode();
          if (n.getParentNode() != null) n = n.cloneNode(true);

          cfData d = (cfData) get(key);
          if (d != null) {
            if (d instanceof cfXmlData)
              return nodeData.replaceChild(n, ((cfXmlData) d).getXMLNode());
            else if (d instanceof cfXmlDataArray)
              ((cfXmlDataArray) d)
                  .setData(1, new cfXmlData(n, ((cfXmlData) value).isCaseSensitive()));
          } else {
            nodeData.appendChild(n);
          }
          nodeData.normalize();
        } else if (value instanceof cfStructData) {
          Element e = nodeData.getOwnerDocument().createElement((String) key);
          nodeData.appendChild(e);
          buildParentElement((cfStructData) value, e);
          nodeData.normalize();
        } else if (value instanceof cfStringData) {
          if (((cfData) value).toString().trim().equals("")) {
            cfData d = (cfData) get(key);
            if (d != null) {
              if (d instanceof cfXmlData) nodeData.removeChild(((cfXmlData) d).getXMLNode());
              else if (d instanceof cfXmlDataArray) ((cfXmlDataArray) d).removeAllElements();
              nodeData.normalize();
            }
          }
        } else {
          super.put(key, value);
        }

        return null;
      }
    } catch (cfmRunTimeException ex) {
      // Nothing else we can do here
      com.nary.Debug.printStackTrace(ex);
    } catch (DOMException ex) {
      // Nothing else we can do here
      com.nary.Debug.printStackTrace(ex);
    }
    return null;
  }