package modelo;

import controlador.Utilidades;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Observable;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.MutableTreeNode;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Text;





// <editor-fold defaultstate="collapsed" desc=" UML Marker ">
// #[regen=yes,id=DCE.A9A2021E-5760-8394-6C1F-F91564E9B66B]
// </editor-fold>
public class DocumentoRequisitos extends Observable {
    Utilidades utilidades = new Utilidades();

    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,id=DCE.38C4B9B5-EB36-0374-C07A-F1BB9260F167]
    // </editor-fold>
    private ElementosTrazas mElementosTrazas;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,id=DCE.FEEC93A7-EB6B-BDA3-5E77-F887AC2CACAE]
    // </editor-fold>
    private ArrayList<Participante> mParticipante;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,id=DCE.F49B9FED-4A1C-CB61-4189-BD11D796F569]
    // </editor-fold>
    private ArrayList<Apendice> mApendice;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,id=DCE.194F2976-9126-AEA6-B51E-1B04E1173689]
    // </editor-fold>
    private ArrayList<Seccion> mSeccion;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,id=DCE.98DC635C-686D-147B-39C2-EA9E927146A4]
    // </editor-fold>
    private ArrayList<Organizacion> mOrganizacion;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,id=DCE.FA0D553A-1C6F-47A4-3799-6D77FEBEBBE2]
    // </editor-fold>
    private ArrayList<MatrizRastreabilidad> mMatrizRastreabilidad;



    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,id=DCE.42B32357-46CB-B416-2253-F29792782C92]
    // </editor-fold>
    public DocumentoRequisitos () {
        mElementosTrazas = new ElementosTrazas();
        mParticipante = new ArrayList<Participante>();
        mApendice = new ArrayList<Apendice>();
        mSeccion = new ArrayList<Seccion>();
        mOrganizacion = new ArrayList<Organizacion>();
        mMatrizRastreabilidad = new ArrayList<MatrizRastreabilidad>();
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.8F5DB735-6192-CABC-1600-B9C3E64350FC]
    // </editor-fold>
    public ArrayList<Apendice> getApendice () {
        return mApendice;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.FD250CA0-8AA7-ACCF-FD64-D713E4F88437]
    // </editor-fold>
    public void setApendice (ArrayList<Apendice> val) {
        this.mApendice = val;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.A44E2539-F9A3-4A9E-1EAD-209CE106C5A5]
    // </editor-fold>
    public ElementosTrazas getElementosTrazas () {
        return mElementosTrazas;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.82171C08-A5B7-F7FC-DE34-AB349B93E9BB]
    // </editor-fold>
    public void setElementosTrazas (ElementosTrazas val) {
        this.mElementosTrazas = val;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.7C9DD66D-4DC0-5887-389B-117EE09E04B1]
    // </editor-fold>
    public ArrayList<MatrizRastreabilidad> getMatrizRastreabilidad () {
        return mMatrizRastreabilidad;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.6040A478-FC52-7167-190D-17EF2AB616C0]
    // </editor-fold>
    public void setMatrizRastreabilidad (ArrayList<MatrizRastreabilidad> val) {
        this.mMatrizRastreabilidad = val;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.313A4D18-F214-AD72-9100-71BE38DC6D5A]
    // </editor-fold>
    public ArrayList<Organizacion> getOrganizacion () {
        return mOrganizacion;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.BDA4E365-49AA-6534-B99E-A491F2A2D444]
    // </editor-fold>
    public void setOrganizacion (ArrayList<Organizacion> val) {
        this.mOrganizacion = val;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.4F753CF5-12DF-58DA-83EB-6B4162867A06]
    // </editor-fold>
    public ArrayList<Participante> getParticipante () {
        return mParticipante;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.5DDDF6E1-52BC-1B46-BB44-B7C945B5EEA8]
    // </editor-fold>
    public void setParticipante (ArrayList<Participante> val) {
        this.mParticipante = val;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.1E82EF5F-8F90-7BAD-8317-4A6B203084EB]
    // </editor-fold>
    public ArrayList<Seccion> getSeccion () {
        return mSeccion;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.767B2FF7-D6F3-4EFE-8CA9-7AE1C2085357]
    // </editor-fold>
    public void setSeccion (ArrayList<Seccion> val) {
        this.mSeccion = val;
    }



    // Devuelve un ArrayList con los Casos de uso del documento
    public ArrayList<CasoUso> getCasosUso () {
        return this.getElementosTrazas().getCasoUso();
    }
    public CasoUso getCasoUso (String ident) {
        boolean encontrado = false;
        int i = 0;
        CasoUso cu = new CasoUso();

        while (!encontrado && i < getCasosUso().size()) {
            if (getCasosUso().get(i).getIdentificacion().equals(ident)) {
                cu = getCasosUso().get(i);
                encontrado = true;
            }
            i++;
        }

        return cu;
    }
    public Paso getPaso (String identCasoUso, String identPaso) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();
        
        Query q = em.createQuery("SELECT p FROM Paso p WHERE p.identificacion = '"+ identPaso +
                                         "' AND p.mCasoUso.identificacion = '"+ identCasoUso +"'");
        Paso p = (Paso) q.getSingleResult();

        return p;
    }
    
    public Excepcion getExcepcion (String identCasoUso, String identPaso, String identExcepcion) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();
        
        Query q = em.createQuery("SELECT e FROM Excepcion e WHERE e.identificacion = '"+ identExcepcion +
                                 "' AND e.mPaso.identificacion = '"+ identPaso +
                                 "' AND e.mPaso.mCasoUso.identificacion = '"+ identCasoUso +"'");
        Excepcion e = (Excepcion) q.getSingleResult();

        return e;
    }
    // Añade un nuevo Caso de uso al documento
    public void addCasoUso (CasoUso casoUso) {
        this.getElementosTrazas().getCasoUso().add(casoUso);                    // Añado al ArrayList
        persist(casoUso);                                                       // Añado a la BD

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Caso de uso del documento
    public void removeCasoUso (String identificador) {
        
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();

        //Eliminar todos los pasos.
        try {
            Query q = em.createQuery("SELECT p FROM Paso p WHERE p.mCasoUso.identificacion = '"+ identificador +"'");
            List<Paso> listaPasos = q.getResultList();
            for(int i = 0; i< listaPasos.size(); i++){
                removeCasoUso_Paso (identificador, listaPasos.get(i).getIdentificacion());
            }

        } catch (Exception e) {
            e.printStackTrace();
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
        CasoUso mCU = this.getCasoUso(identificador);
        eliminarCUPasos(mCU.getNombre() + " [" + mCU.getIdentificacion() + "]");
        eliminarCUExcepciones(mCU.getNombre() + " [" + mCU.getIdentificacion() + "]");

        CasoUso cu = getCasoUso(identificador);
        refreshRemoveCasoUso(2, cu); // Elimino de la BD
        this.getElementosTrazas().getCasoUso().remove(cu); // Elimino del ArrayList

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un Caso de uso del documento
    public void modifyCasoUso (CasoUso casoUso) {
        boolean encontrado = false;
        int i = 0;
        String ident = casoUso.getIdentificacion();
        ArrayList<CasoUso> casosUso = this.getCasosUso();

        // Busco y modifico
        while (!encontrado && i < casosUso.size()) {
            if (casosUso.get(i).getIdentificacion().equals(ident)) {

                casosUso.get(i).setVersion(casoUso.getVersion());               // Modifico en el ArrayList
                casosUso.get(i).setFecha(casoUso.getFecha());
                casosUso.get(i).setAutores(casoUso.getAutores());
                casosUso.get(i).setFuentes(casoUso.getFuentes());
                casosUso.get(i).setEsAbstracto(casoUso.getEsAbstracto());
                casosUso.get(i).setEventoActivacion(casoUso.getEventoActivacion());
                casosUso.get(i).setVeces(casoUso.getVeces());
                casosUso.get(i).setUnidad(casoUso.getUnidad());
                casosUso.get(i).setPrecondicion(casoUso.getPrecondicion());
                casosUso.get(i).setPostcondicion(casoUso.getPostcondicion());
                casosUso.get(i).setImportancia(casoUso.getImportancia());
                casosUso.get(i).setUrgencia(casoUso.getUrgencia());
                casosUso.get(i).setEstadoDesarrollo(casoUso.getEstadoDesarrollo());
                casosUso.get(i).setEstabilidad(casoUso.getEstabilidad());
                casosUso.get(i).setDestino(casoUso.getDestino());
                casosUso.get(i).setOrigen(casoUso.getOrigen());
                casosUso.get(i).setComentario(casoUso.getComentario());
                casosUso.get(i).setCasoUso(casoUso.getCasoUso());

                encontrado = true;
            }
            i++;
        }
        refreshRemoveCasoUso(1, casoUso);                                       // Modifico en la BD

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Añade un nuevo Paso a un Caso de uso
    public void addCasoUso_Paso (Paso paso) {
        persist(paso);                                                          // Añado a la BD

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Paso de un Caso de uso
    public void removeCasoUso_Paso (String identCasoUso, String identPaso) {
        //Eliminar todas las excepcioines que contiene este paso.
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();

        try {
            Query q = em.createQuery("SELECT e FROM Excepcion e WHERE e.mPaso.identificacion = '" + identPaso +
                                     "' AND e.mPaso.mCasoUso.identificacion = '" + identCasoUso +"'");
            List<Excepcion> listaExc = q.getResultList();
            for(int i = 0; i< listaExc.size(); i++)
                em.remove(listaExc.get(i));

            em.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            em.getTransaction().rollback();
        } finally {
            em.close();
        }


        Paso p = getPaso(identCasoUso, identPaso);
        refreshRemoveCasoUsoPaso(2, p);
        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();

    }
    // Modifica un Caso de uso del documento
    public void modifyCasoUso_Paso (Paso paso) {
        refreshRemoveCasoUsoPaso(1, paso);                                      // Modifico en la BD

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Añade una nueva Excepción a un Paso de un Caso de uso
    public void addCasoUso_Excepcion (Excepcion excepcion) {
        persist(excepcion);                                                // Añado a la BD

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina una Excepción de un Paso de un Caso de uso
    public void removeCasoUso_Excepcion (String identCasoUso, String identPaso, String identExcepcion) {
        Excepcion e = getExcepcion(identCasoUso, identPaso, identExcepcion);
        refreshRemoveCasoUsoExcepcion(2, e);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un Caso de uso del documento
    public void modifyCasoUso_Excepcion (Excepcion excepcion) {
        refreshRemoveCasoUsoExcepcion(1, excepcion);                            // Modifico en la BD

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Devuelve un ArrayList con los Requisitos Funcionales del documento
    public ArrayList<RequisitoFuncional> getRequisitosFuncionales () {
        return this.getElementosTrazas().getRequisitoFuncional();
    }
    // Añade un nuevo Requisito Funcional
    public void addReqFuncional (RequisitoFuncional reqFuncional) {
        this.getElementosTrazas().getRequisitoFuncional().add(reqFuncional);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Requisito Funcional
    public void removeReqFuncional (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<RequisitoFuncional> reqFuncionales = this.getElementosTrazas().getRequisitoFuncional();

        // Busco el Requisito Funcional y lo elimino
        while (!encontrado && i < reqFuncionales.size()) {
            if (reqFuncionales.get(i).getIdentificacion().equals(identificador)) {
                this.getElementosTrazas().getRequisitoFuncional().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un ReqFuncional del documento
    public void modifyReqFuncional (RequisitoFuncional requisito) {
        boolean encontrado = false;
        int i = 0;
        String ident = requisito.getIdentificacion();
        ArrayList<RequisitoFuncional> requisitos = this.getRequisitosFuncionales();

        // Busco y modifico
        while (!encontrado && i < requisitos.size()) {
            if (requisitos.get(i).getIdentificacion().equals(ident)) {

                requisitos.get(i).setIdentificacion(requisito.getIdentificacion());
                requisitos.get(i).setNombre(requisito.getNombre());
                requisitos.get(i).setVersion(requisito.getVersion());
                requisitos.get(i).setFecha(requisito.getFecha());
                requisitos.get(i).setAutores(requisito.getAutores());
                requisitos.get(i).setFuentes(requisito.getFuentes());
                requisitos.get(i).setTexto(requisito.getTexto());
                requisitos.get(i).setImportancia(requisito.getImportancia());
                requisitos.get(i).setUrgencia(requisito.getUrgencia());
                requisitos.get(i).setEstadoDesarrollo(requisito.getEstadoDesarrollo());
                requisitos.get(i).setEstabilidad(requisito.getEstabilidad());
                requisitos.get(i).setDestino(requisito.getDestino());
                requisitos.get(i).setOrigen(requisito.getOrigen());
                requisitos.get(i).setComentario(requisito.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Devuelve un ArrayList con los Requisitos No Funcionales del documento
    public ArrayList<RequisitoNoFuncional> getRequisitosNoFuncionales () {
        return this.getElementosTrazas().getRequisitoNoFuncional();
    }
    // Añade un nuevo Requisito No Funcional
    public void addReqNoFuncional (RequisitoNoFuncional reqNoFuncional) {
        this.getElementosTrazas().getRequisitoNoFuncional().add(reqNoFuncional);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Requisito No Funcional
    public void removeReqNoFuncional (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<RequisitoNoFuncional> reqNoFuncionales = this.getElementosTrazas().getRequisitoNoFuncional();

        // Busco el Requisito No Funcional y lo elimino
        while (!encontrado && i < reqNoFuncionales.size()) {
            if (reqNoFuncionales.get(i).getIdentificacion().equals(identificador)) {
                this.getElementosTrazas().getRequisitoNoFuncional().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un ReqNoFuncional del documento
    public void modifyReqNoFuncional (RequisitoNoFuncional requisito) {
        boolean encontrado = false;
        int i = 0;
        String ident = requisito.getIdentificacion();
        ArrayList<RequisitoNoFuncional> requisitos = this.getRequisitosNoFuncionales();

        // Busco y modifico
        while (!encontrado && i < requisitos.size()) {
            if (requisitos.get(i).getIdentificacion().equals(ident)) {

                requisitos.get(i).setIdentificacion(requisito.getIdentificacion());
                requisitos.get(i).setNombre(requisito.getNombre());
                requisitos.get(i).setVersion(requisito.getVersion());
                requisitos.get(i).setFecha(requisito.getFecha());
                requisitos.get(i).setAutores(requisito.getAutores());
                requisitos.get(i).setFuentes(requisito.getFuentes());
                requisitos.get(i).setTexto(requisito.getTexto());
                requisitos.get(i).setImportancia(requisito.getImportancia());
                requisitos.get(i).setUrgencia(requisito.getUrgencia());
                requisitos.get(i).setEstadoDesarrollo(requisito.getEstadoDesarrollo());
                requisitos.get(i).setEstabilidad(requisito.getEstabilidad());
                requisitos.get(i).setDestino(requisito.getDestino());
                requisitos.get(i).setOrigen(requisito.getOrigen());
                requisitos.get(i).setComentario(requisito.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Devuelve un ArrayList con los Requisitos de Información del documento
    public ArrayList<RequisitoInformacion> getRequisitosInformacion () {
        return this.getElementosTrazas().getRequisitoInformacion();
    }
    // Añade un nuevo Requisito de Informacion
    public void addReqInformacion (RequisitoInformacion reqInformacion) {
        this.getElementosTrazas().getRequisitoInformacion().add(reqInformacion);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Requisito de Informacion
    public void removeReqInformacion (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<RequisitoInformacion> reqsInformacion = this.getElementosTrazas().getRequisitoInformacion();

        // Busco el Requisito Funcional y lo elimino
        while (!encontrado && i < reqsInformacion.size()) {
            if (reqsInformacion.get(i).getIdentificacion().equals(identificador)) {
                this.getElementosTrazas().getRequisitoInformacion().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un ReqInformacion del documento
    public void modifyReqInformacion (RequisitoInformacion requisito) {
        boolean encontrado = false;
        int i = 0;
        String ident = requisito.getIdentificacion();
        ArrayList<RequisitoInformacion> requisitos = this.getRequisitosInformacion();

        // Busco y modifico
        while (!encontrado && i < requisitos.size()) {
            if (requisitos.get(i).getIdentificacion().equals(ident)) {

                requisitos.get(i).setIdentificacion(requisito.getIdentificacion());
                requisitos.get(i).setNombre(requisito.getNombre());
                requisitos.get(i).setVersion(requisito.getVersion());
                requisitos.get(i).setFecha(requisito.getFecha());
                requisitos.get(i).setAutores(requisito.getAutores());
                requisitos.get(i).setFuentes(requisito.getFuentes());
                requisitos.get(i).setConceptoRelevante(requisito.getConceptoRelevante());
                requisitos.get(i).setValorMaxVida(requisito.getValorMaxVida());
                requisitos.get(i).setUnidadTiempoMaxVida(requisito.getUnidadTiempoMaxVida());
                requisitos.get(i).setValorMedioVida(requisito.getValorMedioVida());
                requisitos.get(i).setUnidadTiempoMedioVida(requisito.getUnidadTiempoMedioVida());
                requisitos.get(i).setOcurrenciasMaxima(requisito.getOcurrenciasMaxima());
                requisitos.get(i).setOcurrenciasMedia(requisito.getOcurrenciasMedia());
                requisitos.get(i).setImportancia(requisito.getImportancia());
                requisitos.get(i).setUrgencia(requisito.getUrgencia());
                requisitos.get(i).setEstadoDesarrollo(requisito.getEstadoDesarrollo());
                requisitos.get(i).setEstabilidad(requisito.getEstabilidad());
                requisitos.get(i).setDestino(requisito.getDestino());
                requisitos.get(i).setOrigen(requisito.getOrigen());
                requisitos.get(i).setComentario(requisito.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Devuelve un ArrayList con los Requisitos de Restricción del documento
    public ArrayList<RequisitoRestriccion> getRequisitosRestriccion () {
        return this.getElementosTrazas().getRequisitoRestriccion();
    }
    // Añade un nuevo Requisito de Restriccion
    public void addReqRestriccion (RequisitoRestriccion reqRestriccion) {
        this.getElementosTrazas().getRequisitoRestriccion().add(reqRestriccion);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Requisito de Restriccion
    public void removeReqRestriccion (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<RequisitoRestriccion> reqsRestriccion = this.getElementosTrazas().getRequisitoRestriccion();

        // Busco el Requisito Restriccion y lo elimino
        while (!encontrado && i < reqsRestriccion.size()) {
            if (reqsRestriccion.get(i).getIdentificacion().equals(identificador)) {
                this.getElementosTrazas().getRequisitoRestriccion().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un ReqRestriccion del documento
    public void modifyReqRestriccion (RequisitoRestriccion requisito) {
        boolean encontrado = false;
        int i = 0;
        String ident = requisito.getIdentificacion();
        ArrayList<RequisitoRestriccion> requisitos = this.getRequisitosRestriccion();

        // Busco y modifico
        while (!encontrado && i < requisitos.size()) {
            if (requisitos.get(i).getIdentificacion().equals(ident)) {

                requisitos.get(i).setIdentificacion(requisito.getIdentificacion());
                requisitos.get(i).setNombre(requisito.getNombre());
                requisitos.get(i).setVersion(requisito.getVersion());
                requisitos.get(i).setFecha(requisito.getFecha());
                requisitos.get(i).setAutores(requisito.getAutores());
                requisitos.get(i).setFuentes(requisito.getFuentes());
                requisitos.get(i).setDescripcion(requisito.getDescripcion());
                requisitos.get(i).setImportancia(requisito.getImportancia());
                requisitos.get(i).setUrgencia(requisito.getUrgencia());
                requisitos.get(i).setEstadoDesarrollo(requisito.getEstadoDesarrollo());
                requisitos.get(i).setEstabilidad(requisito.getEstabilidad());
                requisitos.get(i).setDestino(requisito.getDestino());
                requisitos.get(i).setOrigen(requisito.getOrigen());
                requisitos.get(i).setComentario(requisito.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Añade un nuevo Participante al documento
    public void addParticipante(Participante participante) {
        this.getParticipante().add(participante);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    //    Elimina un Participante del documento
    public void removeParticipante (String identificador) {
String participanteSelec;

        // Obtengo todos los participantes e inicializo las variables auxiliares
        ArrayList<Participante> participantes = this.getParticipante();
        int i = 0, j = 0, jj = 0, k = 0;
        boolean encontrado = false, encontradoA = false, encontradoF = false, encontradoAs = false;

        // Recorro todos los participantes, encuentro el deseado y lo elimino
        while (i < participantes.size() && encontrado == false) {
            if (participantes.get(i).getIdentificacion().equals(identificador)) {           // SI encuentro el participante deseado...

                participanteSelec = participantes.get(i).getIdentificacion();

                // Busco el Participante en el ArrayList de Seccion y elimino
                ArrayList<Seccion> seccion = this.getSeccion();
                for(int a = 0; a < seccion.size(); a++){
                    //(AUTORES)
                    ArrayList<Participante> autoresS = seccion.get(a).getAutores();
                    while(!encontradoA && j < autoresS.size()){
                        if (autoresS.get(j).getIdentificacion().equals(participanteSelec)) {
                            autoresS.remove(j);
                            utilidades.removeArrayAutor(participanteSelec);
                            encontradoA = true;
                        }
                        j++;
                    }
                    //(FUENTES)
                    ArrayList<Participante> fuentesS = seccion.get(a).getFuentes();
                    while(!encontradoF && jj < fuentesS.size()){
                        if (fuentesS.get(jj).getIdentificacion().equals(participanteSelec)) {
                            fuentesS.remove(jj);
                            utilidades.removeArrayFuente(participanteSelec);
                            encontradoF = true;
                        }
                        jj++;
                    }
                }
                j = 0; jj = 0; encontradoA = false; encontradoF = false;

                // Busco el Participante en el ArrayList de Apendice y elimino
                ArrayList<Apendice> apendice = this.getApendice();
                for(int a = 0; a < apendice.size(); a++){
                    //(AUTORES)
                    ArrayList<Participante> autores = apendice.get(a).getAutores();
                    while(!encontradoA && j < autores.size()){
                        if (autores.get(j).getIdentificacion().equals(participanteSelec)) {
                            autores.remove(j);
                            utilidades.removeArrayAutor(participanteSelec);
                            encontradoA = true;
                        }
                        j++;
                    }
                    //(FUENTES)
                    ArrayList<Participante> fuentes = apendice.get(a).getFuentes();
                    while(!encontradoF && jj < fuentes.size()){
                        if (fuentes.get(jj).getIdentificacion().equals(participanteSelec)) {
                            fuentes.remove(jj);
                            utilidades.removeArrayFuente(participanteSelec);
                            encontradoF = true;
                        }
                        jj++;
                    }
                }
                j = 0; jj = 0; encontradoA = false; encontradoF = false;

                // Busco el Participante en el ArrayList de Parrafo y elimino
                ArrayList<Parrafo> parrafo = this.getParrafos();
                for(int a = 0; a < parrafo.size(); a++){
                    //(AUTORES)
                    ArrayList<Participante> autoresP = parrafo.get(a).getAutores();
                    while(!encontradoA && j < autoresP.size()){
                        if (autoresP.get(j).getIdentificacion().equals(participanteSelec)) {
                            autoresP.remove(j);
                            utilidades.removeArrayAutor(participanteSelec);
                            encontradoA = true;
                        }
                        j++;
                    }
                    //(FUENTES)
                    ArrayList<Participante> fuentesP = parrafo.get(a).getFuentes();
                    while(!encontradoF && jj < fuentesP.size()){
                        if (fuentesP.get(jj).getIdentificacion().equals(participanteSelec)) {
                            fuentesP.remove(jj);
                            utilidades.removeArrayFuente(participanteSelec);
                            encontradoF = true;
                        }
                        jj++;
                    }
                }
                j = 0; jj = 0; encontradoA = false; encontradoF = false;

                // Busco el Participante en el ArrayList de FicheroGrafico y elimino
                ArrayList<Imagen> imagen = this.getImagenes();
                for(int a = 0; a < imagen.size(); a++){
                    //(AUTORES)
                    ArrayList<Participante> autoresI = imagen.get(a).getAutores();
                    while(!encontradoA && j < autoresI.size()){
                        if (autoresI.get(j).getIdentificacion().equals(participanteSelec)) {
                            autoresI.remove(j);
                            utilidades.removeArrayAutor(participanteSelec);
                            encontradoA = true;
                        }
                        j++;
                    }
                    //(FUENTES)
                    ArrayList<Participante> fuentesI = imagen.get(a).getFuentes();
                    while(!encontradoF && jj < fuentesI.size()){
                        if (fuentesI.get(jj).getIdentificacion().equals(participanteSelec)) {
                            fuentesI.remove(jj);
                            utilidades.removeArrayFuente(participanteSelec);
                            encontradoF = true;
                        }
                        jj++;
                    }
                }
                j = 0; jj = 0; encontradoA = false; encontradoF = false;

                // Busco el Participante en el ArrayList de Organizacion y elimino
                ArrayList<Organizacion> organizacion = this.getOrganizacion();
                for(int a = 0; a < organizacion.size(); a++){
                    //(AUTORES)
                    ArrayList<Participante> autoresOr = organizacion.get(a).getAutores();
                    while(!encontradoA && j < autoresOr.size()){
                        if (autoresOr.get(j).getIdentificacion().equals(participanteSelec)) {
                            autoresOr.remove(j);
                            utilidades.removeArrayAutor(participanteSelec);
                            encontradoA = true;
                        }
                        j++;
                    }
                    //(FUENTES)
                    ArrayList<Participante> fuentesOr = organizacion.get(a).getFuentes();
                    while(!encontradoF && jj < fuentesOr.size()){
                        if (fuentesOr.get(jj).getIdentificacion().equals(participanteSelec)) {
                            fuentesOr.remove(jj);
                            utilidades.removeArrayFuente(participanteSelec);
                            encontradoF = true;
                        }
                        jj++;
                    }
                }
                j = 0; jj = 0; encontradoA = false; encontradoF = false;

                // Busco el Participante en el ArrayList de Participante y elimino
                ArrayList<Participante> participante = this.getParticipante();
                for(int a = 0; a < participante.size(); a++){
                    //(AUTORES)
                    ArrayList<Participante> autores = participante.get(a).getAutores();
                    while(!encontradoA && j < autores.size()){
                        if (autores.get(j).getIdentificacion().equals(participanteSelec)) {
                            autores.remove(j);
                            utilidades.removeArrayAutor(participanteSelec);
                            encontradoA = true;
                        }
                        j++;
                    }
                    //(FUENTES)
                    ArrayList<Participante> fuentes = participante.get(a).getFuentes();
                    while(!encontradoF && jj < fuentes.size()){
                        if (fuentes.get(jj).getIdentificacion().equals(participanteSelec)) {
                            fuentes.remove(jj);
                            utilidades.removeArrayFuente(participanteSelec);
                            encontradoF = true;
                        }
                        jj++;
                    }
                }
                j = 0; jj = 0; encontradoA = false; encontradoF = false;

                // Busco el Participante en el ArrayList de Reunion y elimino
                ArrayList<Reunion> reunion = this.getReuniones();
                for(int a = 0; a < reunion.size(); a++){
                    //(AUTORES)
                    ArrayList<Participante> autoresR = reunion.get(a).getAutores();
                    while(!encontradoA && j < autoresR.size()){
                        if (autoresR.get(j).getIdentificacion().equals(participanteSelec)) {
                            autoresR.remove(j);
                            utilidades.removeArrayAutor(participanteSelec);
                            encontradoA = true;
                        }
                        j++;
                    }
                    //(FUENTES)
                    ArrayList<Participante> fuentesR = reunion.get(a).getFuentes();
                    while(!encontradoF && jj < fuentesR.size()){
                        if (fuentesR.get(jj).getIdentificacion().equals(participanteSelec)) {
                            fuentesR.remove(jj);
                            utilidades.removeArrayFuente(participanteSelec);
                            encontradoF = true;
                        }
                        jj++;
                    }
                    //(ASISTENTES)
                    ArrayList<Participante> asistentesR = reunion.get(a).getAsistentes();
                    while(!encontradoAs && k < asistentesR.size()){
                        if (asistentesR.get(k).getIdentificacion().equals(participanteSelec)) {
                            asistentesR.remove(k);
                            utilidades.removeArrayAsistente(participanteSelec);
                            encontradoAs = true;
                        }
                        k++;
                    }
                }
                j = 0; jj = 0; k = 0; encontradoA = false; encontradoF = false; encontradoAs = false;

                // Busco el Participante en el ArrayList de Objetivo y elimino
                ArrayList<Objetivo> objetivo = this.getObjetivos();
                for(int a = 0; a < objetivo.size(); a++){
                    //(AUTORES)
                    ArrayList<Participante> autoresOb = objetivo.get(a).getAutores();
                    while(!encontradoA && j < autoresOb.size()){
                        if (autoresOb.get(j).getIdentificacion().equals(participanteSelec)) {
                            autoresOb.remove(j);
                            utilidades.removeArrayAutor(participanteSelec);
                            encontradoA = true;
                        }
                        j++;
                    }
                    //(FUENTES)
                    ArrayList<Participante> fuentesOb = objetivo.get(a).getFuentes();
                    while(!encontradoF && jj < fuentesOb.size()){
                        if (fuentesOb.get(jj).getIdentificacion().equals(participanteSelec)) {
                            fuentesOb.remove(jj);
                            utilidades.removeArrayFuente(participanteSelec);
                            encontradoF = true;
                        }
                        jj++;
                    }

                    // Si es un SUBOBJETIVO (Nivel 2)
                    if (objetivo.get(a).getSubObjetivos().size() != 0) {
                        ArrayList<Objetivo> subobjetivosN2 = objetivo.get(a).getSubObjetivos();
                        for (int b = 0; b < subobjetivosN2.size(); b++) {
                            int jjj = 0, jjjj = 0;
                            boolean encontradoA2 = false, encontradoF2 = false;
                            //(AUTORES)
                            ArrayList<Participante> autoresOb2 = subobjetivosN2.get(b).getAutores();
                            while(!encontradoA2 && jjj < autoresOb2.size()){
                                if (autoresOb2.get(jjj).getIdentificacion().equals(participanteSelec)) {
                                    autoresOb2.remove(jjj);
                                    utilidades.removeArrayAutor(participanteSelec);
                                    encontradoA = true;
                                }
                                jjj++;
                            }
                            //(FUENTES)
                            ArrayList<Participante> fuentesOb2 = subobjetivosN2.get(b).getFuentes();
                            while(!encontradoF2 && jjjj < fuentesOb2.size()){
                                if (fuentesOb2.get(jjjj).getIdentificacion().equals(participanteSelec)) {
                                    fuentesOb2.remove(jjjj);
                                    utilidades.removeArrayFuente(participanteSelec);
                                    encontradoF = true;
                                }
                                jjjj++;
                            }

                            // Nivel 3
                            if (subobjetivosN2.get(b).getEsSubObjetivo()) {
                                ArrayList<Objetivo> subobjetivosN3 = subobjetivosN2.get(b).getSubObjetivos();
                                for (int c = 0; c < subobjetivosN3.size(); c++) {
                                    int jjjjj = 0, jjjjjj = 0;
                                boolean encontradoA3 = false, encontradoF3 = false;
                                    //(AUTORES)
                                    ArrayList<Participante> autoresOb3 = subobjetivosN3.get(c).getAutores();
                                    while(!encontradoA3 && jjjjj < autoresOb3.size()){
                                        if (autoresOb3.get(jjjjj).getIdentificacion().equals(participanteSelec)) {
                                            autoresOb3.remove(jjjjj);
                                            utilidades.removeArrayAutor(participanteSelec);
                                            encontradoA = true;
                                        }
                                        jjjjj++;
                                    }
                                    //(FUENTES)
                                    ArrayList<Participante> fuentesOb3 = subobjetivosN3.get(c).getFuentes();
                                    while(!encontradoF3 && jjjjjj < fuentesOb3.size()){
                                        if (fuentesOb3.get(jjjjjj).getIdentificacion().equals(participanteSelec)) {
                                            fuentesOb3.remove(jjjjjj);
                                            utilidades.removeArrayFuente(participanteSelec);
                                            encontradoF = true;
                                        }
                                        jjjjjj++;
                                    }
                                }
                            }
                        }
                    }
                }
                j = 0; jj = 0; encontradoA = false; encontradoF = false;

                // Busco el Participante en el ArrayList de Actor y elimino
                ArrayList<Actor> actor = this.getActores();
                for(int a = 0; a < actor.size(); a++){
                    //(AUTORES)
                    ArrayList<Participante> autoresAc = actor.get(a).getAutores();
                    while(!encontradoA && j < autoresAc.size()){
                        if (autoresAc.get(j).getIdentificacion().equals(participanteSelec)) {
                            autoresAc.remove(j);
                            utilidades.removeArrayAutor(participanteSelec);
                            encontradoA = true;
                        }
                        j++;
                    }
                    //(FUENTES)
                    ArrayList<Participante> fuentesAc = actor.get(a).getFuentes();
                    while(!encontradoF && jj < fuentesAc.size()){
                        if (fuentesAc.get(jj).getIdentificacion().equals(participanteSelec)) {
                            fuentesAc.remove(jj);
                            utilidades.removeArrayFuente(participanteSelec);
                            encontradoF = true;
                        }
                        jj++;
                    }
                }
                j = 0; jj = 0; encontradoA = false; encontradoF = false;

                // Busco el Participante en el ArrayList de RequisitoInformacion y elimino
                ArrayList<RequisitoInformacion> reqInformacion = this.getRequisitosInformacion();
                for(int a = 0; a < reqInformacion.size(); a++){
                    //(AUTORES)
                    ArrayList<Participante> autoresRi = reqInformacion.get(a).getAutores();
                    while(!encontradoA && j < autoresRi.size()){
                        if (autoresRi.get(j).getIdentificacion().equals(participanteSelec)) {
                            autoresRi.remove(j);
                            utilidades.removeArrayAutor(participanteSelec);
                            encontradoA = true;
                        }
                        j++;
                    }
                    //(FUENTES)
                    ArrayList<Participante> fuentesRi = reqInformacion.get(a).getFuentes();
                    while(!encontradoF && jj < fuentesRi.size()){
                        if (fuentesRi.get(jj).getIdentificacion().equals(participanteSelec)) {
                            fuentesRi.remove(jj);
                            utilidades.removeArrayFuente(participanteSelec);
                            encontradoF = true;
                        }
                        jj++;
                    }
                }
                j = 0; jj = 0; encontradoA = false; encontradoF = false;

                // Busco el Participante en el ArrayList de RequisitoRestriccion y elimino
                ArrayList<RequisitoRestriccion> reqRestriccion = this.getRequisitosRestriccion();
                for(int a = 0; a < reqRestriccion.size(); a++){
                    //(AUTORES)
                    ArrayList<Participante> autoresRr = reqRestriccion.get(a).getAutores();
                    while(!encontradoA && j < autoresRr.size()){
                        if (autoresRr.get(j).getIdentificacion().equals(participanteSelec)) {
                            autoresRr.remove(j);
                            utilidades.removeArrayAutor(participanteSelec);
                            encontradoA = true;
                        }
                        j++;
                    }
                    //(FUENTES)
                    ArrayList<Participante> fuentesRr = reqRestriccion.get(a).getFuentes();
                    while(!encontradoF && jj < fuentesRr.size()){
                        if (fuentesRr.get(jj).getIdentificacion().equals(participanteSelec)) {
                            fuentesRr.remove(jj);
                            utilidades.removeArrayFuente(participanteSelec);
                            encontradoF = true;
                        }
                        jj++;
                    }
                }
                j = 0; jj = 0; encontradoA = false; encontradoF = false;

                // Busco el Participante en el ArrayList de CasoUso y elimino
                ArrayList<CasoUso> casoUso = this.getCasosUso();
                for(int a = 0; a < casoUso.size(); a++){
                    //(AUTORES)
                    ArrayList<Participante> autoresCu = casoUso.get(a).getAutores();
                    while(!encontradoA && j < autoresCu.size()){
                        if (autoresCu.get(j).getIdentificacion().equals(participanteSelec)) {
                            autoresCu.remove(j);
                            utilidades.removeArrayAutor(participanteSelec);
                            encontradoA = true;
                        }
                        j++;
                    }
                    //(FUENTES)
                    ArrayList<Participante> fuentesCu = casoUso.get(a).getFuentes();
                    while(!encontradoF && jj < fuentesCu.size()){
                        if (fuentesCu.get(jj).getIdentificacion().equals(participanteSelec)) {
                            fuentesCu.remove(jj);
                            utilidades.removeArrayFuente(participanteSelec);
                            encontradoF = true;
                        }
                        jj++;
                    }
                }
                j = 0; jj = 0; encontradoA = false; encontradoF = false;

                // Busco el Participante en el ArrayList de RequisitoFuncional y elimino
                ArrayList<RequisitoFuncional> reqFuncional = this.getRequisitosFuncionales();
                for(int a = 0; a < reqFuncional.size(); a++){
                    //(AUTORES)
                    ArrayList<Participante> autoresRf = reqFuncional.get(a).getAutores();
                    while(!encontradoA && j < autoresRf.size()){
                        if (autoresRf.get(j).getIdentificacion().equals(participanteSelec)) {
                            autoresRf.remove(j);
                            utilidades.removeArrayAutor(participanteSelec);
                            encontradoA = true;
                        }
                        j++;
                    }
                    //(FUENTES)
                    ArrayList<Participante> fuentesRf = reqFuncional.get(a).getFuentes();
                    while(!encontradoF && jj < fuentesRf.size()){
                        if (fuentesRf.get(jj).getIdentificacion().equals(participanteSelec)) {
                            fuentesRf.remove(jj);
                            utilidades.removeArrayFuente(participanteSelec);
                            encontradoF = true;
                        }
                        jj++;
                    }
                }
                j = 0; jj = 0; encontradoA = false; encontradoF = false;

                // Busco el Participante en el ArrayList de RequisitoNoFuncional y elimino
                ArrayList<RequisitoNoFuncional> reqNoFuncional = this.getRequisitosNoFuncionales();
                for(int a = 0; a < reqNoFuncional.size(); a++){
                    //(AUTORES)
                    ArrayList<Participante> autoresRnf = reqNoFuncional.get(a).getAutores();
                    while(!encontradoA && j < autoresRnf.size()){
                        if (autoresRnf.get(j).getIdentificacion().equals(participanteSelec)) {
                            autoresRnf.remove(j);
                            utilidades.removeArrayAutor(participanteSelec);
                            encontradoA = true;
                        }
                        j++;
                    }
                    //(FUENTES)
                    ArrayList<Participante> fuentesRnf = reqNoFuncional.get(a).getFuentes();
                    while(!encontradoF && jj < fuentesRnf.size()){
                        if (fuentesRnf.get(jj).getIdentificacion().equals(participanteSelec)) {
                            fuentesRnf.remove(jj);
                            utilidades.removeArrayFuente(participanteSelec);
                            encontradoF = true;
                        }
                        jj++;
                    }
                }
                j = 0; jj = 0; encontradoA = false; encontradoF = false;

                // Busco el Participante en el ArrayList de MatrizRastreabilidad y elimino
                ArrayList<MatrizRastreabilidad> matrizRastreabilidad = this.getMatrizRastreabilidad();
                for(int a = 0; a < matrizRastreabilidad.size(); a++){
                    //(AUTORES)
                    ArrayList<Participante> autoresM = matrizRastreabilidad.get(a).getAutores();
                    while(!encontradoA && j < autoresM.size()){
                        if (autoresM.get(j).getIdentificacion().equals(participanteSelec)) {
                            autoresM.remove(j);
                            utilidades.removeArrayAutor(participanteSelec);
                            encontradoA = true;
                        }
                        j++;
                    }
                    //(FUENTES)
                    ArrayList<Participante> fuentesM = matrizRastreabilidad.get(a).getFuentes();
                    while(!encontradoF && jj < fuentesM.size()){
                        if (fuentesM.get(jj).getIdentificacion().equals(participanteSelec)) {
                            fuentesM.remove(jj);
                            utilidades.removeArrayFuente(participanteSelec);
                            encontradoF = true;
                        }
                        jj++;
                    }
                }

                encontrado = true;                                              //  Lo indico
                this.getParticipante().remove(i);                               //  Y lo elimino
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un Participante del documento
    public void modifyParticipante (Participante participante) {
        boolean encontrado = false;
        int i = 0;
        String ident = participante.getIdentificacion();
        ArrayList<Participante> participantes = this.getParticipante();

        // Busco y modifico
        while (!encontrado && i < participantes.size()) {
            if (participantes.get(i).getIdentificacion().equals(ident)) {

                participantes.get(i).setIdentificacion(participante.getIdentificacion());
                participantes.get(i).setNombre(participante.getNombre());
                participantes.get(i).setVersion(participante.getVersion());
                participantes.get(i).setFecha(participante.getFecha());
                participantes.get(i).setAutores(participante.getAutores());
                participantes.get(i).setFuentes(participante.getFuentes());
                participantes.get(i).setRol(participante.getRol());
                participantes.get(i).setOrganizacion(participante.getOrganizacion());
                participantes.get(i).setEsCliente(participante.getEsCliente());
                participantes.get(i).setEsDesarrollador(participante.getEsDesarrollador());
                participantes.get(i).setEsUsuario(participante.getEsUsuario());
                participantes.get(i).setComentario(participante.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    
    // Devuelve un ArrayList con las Reuniones del documento
    public ArrayList<Reunion> getReuniones(){
        return this.getElementosTrazas().getReunion();
    }
    // Añade una nueva Reunion al documento
    public void addReunion(Reunion reunion) {
        this.getElementosTrazas().getReunion().add(reunion);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    //    Elimina una Reunion del documento
    public void removeReunion (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<Reunion> reunion = this.getReuniones();

        // Busco el Requisito Restriccion y lo elimino
        while (!encontrado && i < reunion.size()) {
            if (reunion.get(i).getIdentificacion().equals(identificador)) {
                this.getReuniones().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica una Reunion del documento
    public void modifyReunion (Reunion reunion) {
        boolean encontrado = false;
        int i = 0;
        String ident = reunion.getIdentificacion();
        ArrayList<Reunion> reuniones = this.getReuniones();

        // Busco y modifico
        while (!encontrado && i < reuniones.size()) {
            if (reuniones.get(i).getIdentificacion().equals(ident)) {

                reuniones.get(i).setIdentificacion(reunion.getIdentificacion());
                reuniones.get(i).setNombre(reunion.getNombre());
                reuniones.get(i).setVersion(reunion.getVersion());
                reuniones.get(i).setFecha(reunion.getFecha());
                reuniones.get(i).setAutores(reunion.getAutores());
                reuniones.get(i).setFuentes(reunion.getFuentes());
                reuniones.get(i).setLugar(reunion.getLugar());
                reuniones.get(i).setFechaReunion(reunion.getFechaReunion());
                reuniones.get(i).setHora(reunion.getHora());
                reuniones.get(i).setAsistentes(reunion.getAsistentes());
                reuniones.get(i).setResultados(reunion.getResultados());
                reuniones.get(i).setDestino(reunion.getDestino());
                reuniones.get(i).setOrigen(reunion.getOrigen());
                reuniones.get(i).setComentario(reunion.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Devuelve un ArrayList con los Objetivos del documento
    public ArrayList<Objetivo> getObjetivos(){
        return this.getElementosTrazas().getObjetivo();
    }
    // Añade un nuevo Objetivo al documento
    public void addObjetivo(Objetivo objetivo) {
        this.getElementosTrazas().getObjetivo().add(objetivo);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    //    Elimina un Objetivo del documento
    public void removeObjetivo (MutableTreeNode nodoSeleccionado, String identificador) {
        // Obtengo el ArrayList e inicializo las variables auxiliares
        ArrayList<Objetivo> objetivosPpal = this.getObjetivos();
        int i = 0;
        boolean encontrado = false, encontrado2 = false;

        MutableTreeNode nodoPadre = (MutableTreeNode) nodoSeleccionado.getParent();

        // Recorro el ArrayList, encuentro el elemento deseado y lo elimino
        while (!encontrado && i < objetivosPpal.size()) {
            if (objetivosPpal.get(i).getIdentificacion().equals(identificador)) {                   // SI encuentro el deseado...
                Objetivo objetivo = objetivosPpal.get(i);
                int nivel = objetivo.getNivel();
                if (nivel == 3) {                                           // NIVEL 3
                    String identNodoPadre = this.utilidades.getIdentificadorNodo(nodoPadre);
                    int j = 0;
                    while (!encontrado2 && j < objetivosPpal.size()) {
                        if (objetivosPpal.get(j).getIdentificacion().equals(identNodoPadre)) {
                            this.getObjetivos().get(j).getSubObjetivos().remove(objetivo);
                        }
                        j++;
                    }

                } else if (nivel == 2) {                                    // NIVEL 2
                    // Elimino los subobjetivos del Objetivo actual
                    for (int x = 0; x < objetivo.getSubObjetivos().size(); x++) {
                        this.getObjetivos().remove(objetivo.getSubObjetivos().get(x));
                        this.getObjetivos().get(i).getSubObjetivos().remove(x);
                    }
                    // Lo eliminamos del ArrayList del padre
                    String identNodoPadre = this.utilidades.getIdentificadorNodo(nodoPadre);
                    int j = 0;
                    while (!encontrado2 && j < objetivosPpal.size()) {
                        if (objetivosPpal.get(j).getIdentificacion().equals(identNodoPadre)) {
                            this.getObjetivos().get(j).getSubObjetivos().remove(objetivo);
                        }
                        j++;
                    }

                } else if (nivel == 1) {                                    // NIVEL 1
                    // Elimino los subobjetivos del Objetivo actual, previamente de los subobjetivos de estos subobjetivos
                    while (!objetivo.getSubObjetivos().isEmpty()) {
                        Objetivo objetivoAux = objetivo.getSubObjetivos().get(0);
                        while (!objetivoAux.getSubObjetivos().isEmpty()) {
                            Objetivo objetivoN3 = objetivoAux.getSubObjetivos().get(0);
                            this.getObjetivos().remove(objetivoN3);
                            this.getObjetivos().get(i).getSubObjetivos().get(0).getSubObjetivos().remove(objetivoN3);
                        }
                        this.getObjetivos().remove(objetivo.getSubObjetivos().get(0));
                        this.getObjetivos().get(i).getSubObjetivos().remove(0);
                    }

                }

                this.getObjetivos().remove(i);                                       // Y lo elimino del ArrayList ppal
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un Objetivo del documento
    public void modifyObjetivo (Objetivo objetivo) {
        boolean encontrado = false;
        int i = 0;
        String ident = objetivo.getIdentificacion();
        ArrayList<Objetivo> objetivos = this.getObjetivos();

        // Busco y modifico
        while (!encontrado && i < objetivos.size()) {
            if (objetivos.get(i).getIdentificacion().equals(ident)) {

                objetivos.get(i).setIdentificacion(objetivo.getIdentificacion());
                objetivos.get(i).setNombre(objetivo.getNombre());
                objetivos.get(i).setVersion(objetivo.getVersion());
                objetivos.get(i).setFecha(objetivo.getFecha());
                objetivos.get(i).setAutores(objetivo.getAutores());
                objetivos.get(i).setFuentes(objetivo.getFuentes());
                objetivos.get(i).setTexto(objetivo.getTexto());
                objetivos.get(i).setImportancia(objetivo.getImportancia());
                objetivos.get(i).setUrgencia(objetivo.getUrgencia());
                objetivos.get(i).setEstadoDesarrollo(objetivo.getEstadoDesarrollo());
                objetivos.get(i).setEstabilidad(objetivo.getEstabilidad());
                objetivos.get(i).setDestino(objetivo.getDestino());
                objetivos.get(i).setOrigen(objetivo.getOrigen());
                objetivos.get(i).setComentario(objetivo.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Devuelve un ArrayList con los Actores del documento
    public ArrayList<Actor> getActores () {
        return this.getElementosTrazas().getActor();
    }
    // Añade un nuevo Actor
    public void addActor (Actor actor) {
        this.getElementosTrazas().getActor().add(actor);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Actor
    public void removeActor (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<Actor> actor = this.getElementosTrazas().getActor();

        // Busco el Actor y lo elimino
        while (!encontrado &&  i < actor.size() ) {
            if (actor.get(i).getIdentificacion().equals(identificador)) {
                //Antes eliminamos de Paso y Excepcion.
                eliminarActorPasos(actor.get(i).getNombre() + " [" + actor.get(i).getIdentificacion() + "]");
                eliminarActorExcepciones(actor.get(i).getNombre() + " [" + actor.get(i).getIdentificacion() + "]");
                this.getElementosTrazas().getActor().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un Actor del documento
    public void modifyActor (Actor actor) {
        boolean encontrado = false;
        int i = 0;
        String ident = actor.getIdentificacion();
        ArrayList<Actor> actores = this.getActores();

        // Busco y modifico
        while (!encontrado && i < actores.size()) {
            if (actores.get(i).getIdentificacion().equals(ident)) {

                actores.get(i).setIdentificacion(actor.getIdentificacion());
                actores.get(i).setNombre(actor.getNombre());
                actores.get(i).setVersion(actor.getVersion());
                actores.get(i).setFecha(actor.getFecha());
                actores.get(i).setAutores(actor.getAutores());
                actores.get(i).setFuentes(actor.getFuentes());
                actores.get(i).setTexto(actor.getTexto());
                actores.get(i).setDestino(actor.getDestino());
                actores.get(i).setOrigen(actor.getOrigen());
                actores.get(i).setComentario(actor.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Añade una nueva Organizacion al documento
    public void addOrganizacion(Organizacion organizacion) {
        this.getOrganizacion().add(organizacion);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    //    Elimina una Organización del documento
    public void removeOrganizacion (String identificador) {
        ArrayList<Organizacion> organizacion = this.getOrganizacion();
        ArrayList<Participante> participantes = this.getParticipante();
        boolean encontrado = false;
        int i = 0;

        //Recorrer todos los participantes y eliminarlo de su variable organizacion
        // Busco si está la Organizacion y la elimino
        while (!encontrado && i < participantes.size()) {
            if (participantes.get(i).getOrganizacion().getIdentificacion() != null && participantes.get(i).getOrganizacion().getIdentificacion().equals(identificador)){
                this.getParticipante().get(i).setOrganizacion(new Organizacion());
                encontrado = true;
            }
            i++;
        }
        encontrado = false;
        i = 0;
        // Busco la Organizacion y la elimino
        while (!encontrado && i < organizacion.size()) {
            if (organizacion.get(i).getIdentificacion().equals(identificador)) {
                this.getOrganizacion().remove(i);
                encontrado = true;
            }
            i++;
        }
        
        //Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica una Organización del documento
    public void modifyOrganizacion (Organizacion organizacion) {
        boolean encontrado = false;
        int i = 0;
        String ident = organizacion.getIdentificacion();
        ArrayList<Organizacion> organizaciones = this.getOrganizacion();

        // Busco la Organizacion y la modifico
        while (!encontrado && i < organizaciones.size()) {
            if (organizaciones.get(i).getIdentificacion().equals(ident)) {
                organizaciones.get(i).setIdentificacion(organizacion.getIdentificacion());
                organizaciones.get(i).setNombre(organizacion.getNombre());
                organizaciones.get(i).setVersion(organizacion.getVersion());
                organizaciones.get(i).setFecha(organizacion.getFecha());
                organizaciones.get(i).setAutores(organizacion.getAutores());
                organizaciones.get(i).setFuentes(organizacion.getFuentes());
                organizaciones.get(i).setDireccion(organizacion.getDireccion());
                organizaciones.get(i).setTelefono(organizacion.getTelefono());
                organizaciones.get(i).setFax(organizacion.getFax());
                organizaciones.get(i).setComentario(organizacion.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }


    // Añade una nueva Sección al documento
    public void addSeccion(Seccion seccion) {
        this.getSeccion().add(seccion);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    //    Elimina una Sección del documento
    public void removeSeccion (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<Seccion> seccion = this.getSeccion();

        // Busco la Organizacion y la elimino
        while (!encontrado && i < seccion.size()) {
            if (seccion.get(i).getIdentificacion().equals(identificador)) {
                this.getSeccion().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica una Seccion del documento
    public void modifySeccion (Seccion seccion) {
        boolean encontrado = false;
        int i = 0;
        String ident = seccion.getIdentificacion();
        ArrayList<Seccion> secciones = this.getSeccion();

        // Busco y modifico
        while (!encontrado && i < secciones.size()) {
            if (secciones.get(i).getIdentificacion().equals(ident)) {

                secciones.get(i).setIdentificacion(seccion.getIdentificacion());
                secciones.get(i).setNombre(seccion.getNombre());
                secciones.get(i).setNumeracion(seccion.getNumeracion());
                secciones.get(i).setVersion(seccion.getVersion());
                secciones.get(i).setFecha(seccion.getFecha());
                secciones.get(i).setAutores(seccion.getAutores());
                secciones.get(i).setFuentes(seccion.getFuentes());
                secciones.get(i).setOrdenar(seccion.getOrdenar());
                secciones.get(i).setComentario(seccion.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Añade un nuevo Apéndice al documento
    public void addApendice(Apendice apendice) {
        this.getApendice().add(apendice);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    //    Elimina un Apéndice del documento
    public void removeApendice (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<Apendice> apendice = this.getApendice();

        // Busco la Organizacion y la elimino
        while (!encontrado && i < apendice.size()) {
            if (apendice.get(i).getIdentificacion().equals(identificador)) {
                this.getApendice().remove(i);
                encontrado = true;
            }
            i++;
        }
    }
    // Modifica un Apendice del documento
    public void modifyApendice (Apendice apendice) {
        boolean encontrado = false;
        int i = 0;
        String ident = apendice.getIdentificacion();
        ArrayList<Apendice> apendices = this.getApendice();

        // Busco y modifico
        while (!encontrado && i < apendices.size()) {
            if (apendices.get(i).getIdentificacion().equals(ident)) {

                apendices.get(i).setIdentificacion(apendice.getIdentificacion());
                apendices.get(i).setNombre(apendice.getNombre());
                apendices.get(i).setNumeracion(apendice.getNumeracion());
                apendices.get(i).setVersion(apendice.getVersion());
                apendices.get(i).setFecha(apendice.getFecha());
                apendices.get(i).setAutores(apendice.getAutores());
                apendices.get(i).setFuentes(apendice.getFuentes());
                apendices.get(i).setOrdenar(apendice.getOrdenar());
                apendices.get(i).setComentario(apendice.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Devuelve un ArrayList con los Parrafos del documento
    public ArrayList<Parrafo> getParrafos () {
        return this.getElementosTrazas().getParrafo();
    }
    // Añade un nuevo Parrafo
    public void addParrafo (Parrafo parrafo) {
        this.getElementosTrazas().getParrafo().add(parrafo);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Parrafo
    public void removeParrafo (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<Parrafo> parrafo = this.getElementosTrazas().getParrafo();

        // Busco el Parrafo y lo elimino
        while (!encontrado && i < parrafo.size()) {
            if (parrafo.get(i).getIdentificacion().equals(identificador)) {
                this.getElementosTrazas().getParrafo().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un Parrafo del documento
    public void modifyParrafo (Parrafo parrafo) {
        boolean encontrado = false;
        int i = 0;
        String ident = parrafo.getIdentificacion();
        ArrayList<Parrafo> parrafos = this.getParrafos();

        // Busco y modifico
        while (!encontrado && i < parrafos.size()) {
            if (parrafos.get(i).getIdentificacion().equals(ident)) {

                parrafos.get(i).setIdentificacion(parrafo.getIdentificacion());
                parrafos.get(i).setNombre(parrafo.getNombre());
                parrafos.get(i).setVersion(parrafo.getVersion());
                parrafos.get(i).setFecha(parrafo.getFecha());
                parrafos.get(i).setAutores(parrafo.getAutores());
                parrafos.get(i).setFuentes(parrafo.getFuentes());
                parrafos.get(i).setTexto(parrafo.getTexto());
                parrafos.get(i).setDestino(parrafo.getDestino());
                parrafos.get(i).setOrigen(parrafo.getOrigen());
                parrafos.get(i).setComentario(parrafo.getComentario());
                parrafos.get(i).setesElementoGlosario(parrafo.getesElementoGlosario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

     // Devuelve un ArrayList con los Ficheros Graficos del documento
    public ArrayList<Imagen> getImagenes () {
        return this.getElementosTrazas().getImagen();
    }
    // Añade un nuevo Fichero Grafico
    public void addImagen (Imagen imagen) {
        this.getElementosTrazas().getImagen().add(imagen);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Fichero Grafico
    public void removeImagen (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<Imagen> imagen = this.getElementosTrazas().getImagen();

        // Busco el Fichero Grafico y lo elimino
        while (!encontrado && i < imagen.size()) {
            if (imagen.get(i).getIdentificacion().equals(identificador)) {
                this.getElementosTrazas().getImagen().remove(i);
                encontrado = true;
            }
            i++;
        }
    }
    // Modifica una Imagen del documento
    public void modifyImagen (Imagen imagen) {
        boolean encontrado = false;
        int i = 0;
        String ident = imagen.getIdentificacion();
        ArrayList<Imagen> imagenes = this.getImagenes();

        // Busco y modifico
        while (!encontrado && i < imagenes.size()) {
            if (imagenes.get(i).getIdentificacion().equals(ident)) {

                imagenes.get(i).setIdentificacion(imagen.getIdentificacion());
                imagenes.get(i).setNombre(imagen.getNombre());
                imagenes.get(i).setVersion(imagen.getVersion());
                imagenes.get(i).setFecha(imagen.getFecha());
                imagenes.get(i).setAutores(imagen.getAutores());
                imagenes.get(i).setFuentes(imagen.getFuentes());
                imagenes.get(i).setRutaImagen(imagen.getRutaImagen());
                imagenes.get(i).setDestino(imagen.getDestino());
                imagenes.get(i).setOrigen(imagen.getOrigen());
                imagenes.get(i).setComentario(imagen.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Añade una nueva Matriz de rastreabilidad
    public void addMatrizRastreabilidad (MatrizRastreabilidad matrizRastreabilidad) {
        this.getMatrizRastreabilidad().add(matrizRastreabilidad);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina una Matriz de rastreabilidad
    public void removeMatrizRastreabilidad (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<MatrizRastreabilidad> matrizRastreabilidad = this.getMatrizRastreabilidad();

        // Busco la Matriz de rastreabilidad y lo elimino
        while (!encontrado && i < matrizRastreabilidad.size()) {
            if (matrizRastreabilidad.get(i).getIdentificacion().equals(identificador)) {
                this.getMatrizRastreabilidad().remove(i);
                encontrado = true;
            }
            i++;
        }
    }
    // Modifica una MatrizRastreabilidad del documento
    public void modifyMatrizRastreabilidad (MatrizRastreabilidad matriz) {
        boolean encontrado = false;
        int i = 0;
        String ident = matriz.getIdentificacion();
        ArrayList<MatrizRastreabilidad> matrices = this.getMatrizRastreabilidad();

        // Busco y modifico
        while (!encontrado && i < matrices.size()) {
            if (matrices.get(i).getIdentificacion().equals(ident)) {

                matrices.get(i).setIdentificacion(matriz.getIdentificacion());
                matrices.get(i).setNombre(matriz.getNombre());
                matrices.get(i).setVersion(matriz.getVersion());
                matrices.get(i).setFecha(matriz.getFecha());
                matrices.get(i).setAutores(matriz.getAutores());
                matrices.get(i).setFuentes(matriz.getFuentes());
                matrices.get(i).setMatrizFila(matriz.getMatrizFila());
                matrices.get(i).setMatrizColumna(matriz.getMatrizColumna());
                matrices.get(i).setComentario(matriz.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    
    
    // Añade un nuevo Dato Especifico
    public void addDatoEspecifico(String identReqInformacion, DatoEspecifico datoEspecifico) {
        ArrayList<RequisitoInformacion> reqInformacion = this.getElementosTrazas().getRequisitoInformacion();

        // Busco el Requisito de informacion que le corresponde y le añado el dato especifico.
        for (int i = 0; i < reqInformacion.size(); i++) {                             // Añado al ArrayList
            if (reqInformacion.get(i).getIdentificacion().equals(identReqInformacion))
                reqInformacion.get(i).getDatoEspecifico().add(datoEspecifico);
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Elimina un Paso de un Caso de uso
    public void removeDatoEspecifico (String identReqInformacion, String identDatoEspecifico) {
        boolean encontReqInformacion = false, encontDatoEspecifico = false;
        int i = 0, j = 0;
        ArrayList<RequisitoInformacion> reqInformacion = this.getElementosTrazas().getRequisitoInformacion();

        // Busco el Caso de uso, busco su Paso y lo elimino
        while (!encontReqInformacion && i < reqInformacion.size()) {
            if (reqInformacion.get(i).getIdentificacion().equals(identReqInformacion)) {
                ArrayList<DatoEspecifico> datoEspecifico = reqInformacion.get(i).getDatoEspecifico();
                while (!encontDatoEspecifico && j < datoEspecifico.size()) {
                    if (datoEspecifico.get(j).getIdentificacion().equals(identDatoEspecifico)) {
                        this.getElementosTrazas().getRequisitoInformacion().get(i).getDatoEspecifico().remove(j);  //Elimino del ArrayList
                        encontDatoEspecifico = true;
                    }
                    j++;
                }
                encontReqInformacion = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Modifica un Dato Especifico del documento
    public void modifyDatoEspecifico (String identReqInformacion, DatoEspecifico datoEspecifico) {
        boolean encontrado = false;
        int i = 0;
        RequisitoInformacion miReqInf = new RequisitoInformacion();
        ArrayList<RequisitoInformacion> reqInf = this.getRequisitosInformacion();
        while(!encontrado && i < reqInf.size()){
            if(identReqInformacion.equals(reqInf.get(i).getIdentificacion()))
            {
                encontrado = true;
                miReqInf = reqInf.get(i);
            }
        }

        String ident = datoEspecifico.getIdentificacion();
        ArrayList<DatoEspecifico> datosEspecificos = miReqInf.getDatoEspecifico();

        encontrado = false;
        i=0;
        // Busco y modifico
        while (!encontrado && i < datosEspecificos.size()) {
            if (datosEspecificos.get(i).getIdentificacion().equals(ident)) {

                datosEspecificos.get(i).setIdentificacion(datoEspecifico.getIdentificacion());
                datosEspecificos.get(i).setDescripcion(datoEspecifico.getDescripcion());
                datosEspecificos.get(i).setComentario(datoEspecifico.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    
    //Funcion para eliminar todo lo que contenga SEC o APE
    public void eliminarTodo(ArrayList<String> listadoObjetos, MutableTreeNode nodoSeleccionado)
    {
        for(int i=0; i<listadoObjetos.size(); i++){
            String identificador = listadoObjetos.get(i);
            String preIdentificador = utilidades.getPreIdentificador(identificador);

            if(preIdentificador.equals("SEC")){
                this.removeSeccion(identificador);
            }
            else if(preIdentificador.equals("APE")){
                this.removeApendice(identificador);
            }
            else if(preIdentificador.equals("PRG")){
                this.removeParrafo(identificador);
            }
            else if(preIdentificador.equals("GRF")){
                this.removeImagen(identificador);
            }
            else if(preIdentificador.equals("ORG")){
                this.removeOrganizacion(identificador);
            }
            else if(preIdentificador.equals("STK")){
                this.removeParticipante(identificador);
            }
            else if(preIdentificador.equals("MET")){
                this.removeReunion(identificador);
            }
            else if(preIdentificador.equals("OBJ")){
                ArrayList<Objetivo> objetivosPpal = this.getObjetivos();
                boolean encontrado = false;
                int j = 0;
                while(!encontrado && j<objetivosPpal.size()){
                    if(objetivosPpal.get(j).getEsSubObjetivo() == false){
                        this.removeObjetivo(nodoSeleccionado, identificador);
                        encontrado = true;
                    }
                }
            }
            else if(preIdentificador.equals("ACT")){
                this.removeActor(identificador);
            }
            else if(preIdentificador.equals("IRQ")){
                this.removeReqInformacion(identificador);
            }
            else if(preIdentificador.equals("CRQ")){
                this.removeReqRestriccion(identificador);
            }
            else if (preIdentificador.equals("UC")) {
                this.removeCasoUso(identificador);
            }
            else if(preIdentificador.equals("FRQ")){
                this.removeReqFuncional(identificador);
            }
            else if(preIdentificador.equals("NFR")){
                this.removeReqNoFuncional(identificador);
            }
            else if(preIdentificador.equals("TRM")){
                this.removeMatrizRastreabilidad(identificador);
            }
            else if(preIdentificador.equals("DTE")){
                //this.removeDatoEspecifico(identificador);
            }
        }
    }




    // Devuelve el siguiente identificador numérico de un caso de uso (para su creación)
    public String getNuevoIdentificadorCasoUso () {
        String nuevoIdentificador = "";
        
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        EntityManager em = emf.createEntityManager();
        Query q = em.createQuery("SELECT cu FROM CasoUso cu");
        int size = q.getResultList().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = ((CasoUso)q.getResultList().get(size-1)).getIdentificacion();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(3)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }
    // Devuelve el siguiente identificador numérico de un paso de un caso de uso (para su creación)
    public String getNuevoIdentificadorPaso (String identCasoUso) {
        String nuevoIdentificador = "";

        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        EntityManager em = emf.createEntityManager();
        Query q = em.createQuery("SELECT p FROM Paso p WHERE p.mCasoUso.identificacion = '"+ identCasoUso +"'");
        int size = q.getResultList().size();

        if (size == 0)                                                          // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {                                                                  // Si hay elementos...
            nuevoIdentificador = ((Paso)q.getResultList().get(size-1)).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;
            
            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        nuevoIdentificador = "UCP-" + nuevoIdentificador;

        return nuevoIdentificador;
    }
    // Devuelve el siguiente identificador numérico de una excepción de un paso de un caso de uso (para su creación)
    public String getNuevoIdentificadorExcepcion (String identCasoUso, String identPaso) {
        String nuevoIdentificador = "";

        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        EntityManager em = emf.createEntityManager();
        Query q = em.createQuery("SELECT e FROM Excepcion e WHERE e.mPaso.identificacion = '"+ identPaso +
                                 "' AND e.mPaso.mCasoUso.identificacion = '"+ identCasoUso +"'");
        int size = q.getResultList().size();

        if (size == 0)                                                          // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {                                                                  // Si hay elementos...
            nuevoIdentificador = ((Excepcion)q.getResultList().get(size-1)).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        nuevoIdentificador = "UCE-" + nuevoIdentificador;

        return nuevoIdentificador;
    }
    // Devuelve el siguiente identificador numérico de un requisito funcional
    public String getNuevoIdentificadorReqFuncional () {
        String nuevoIdentificador = "";
        int size = this.getElementosTrazas().getRequisitoFuncional().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getElementosTrazas().getRequisitoFuncional().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }
    // Devuelve el siguiente identificador numérico de un requisito no funcional
    public String getNuevoIdentificadorReqNoFuncional () {
        String nuevoIdentificador = "";
        int size = this.getElementosTrazas().getRequisitoNoFuncional().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getElementosTrazas().getRequisitoNoFuncional().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }
    // Devuelve el siguiente identificador numérico de un requisito de información
    public String getNuevoIdentificadorReqInformacion () {
        String nuevoIdentificador = "";
        int size = this.getElementosTrazas().getRequisitoInformacion().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getElementosTrazas().getRequisitoInformacion().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }
    // Devuelve el siguiente identificador numérico de un requisito de restricción
    public String getNuevoIdentificadorReqRestriccion () {
        String nuevoIdentificador = "";
        int size = this.getElementosTrazas().getRequisitoRestriccion().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getElementosTrazas().getRequisitoRestriccion().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }


// Devuelve el siguiente identificador numérico de un requisito funcional
    public String getNuevoIdentificadorReunion () {
        String nuevoIdentificador = "";
        int size = this.getElementosTrazas().getReunion().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getElementosTrazas().getReunion().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }
    // Devuelve el siguiente identificador numérico de un requisito funcional
    public String getNuevoIdentificadorObjetivo () {
        String nuevoIdentificador = "";
        int size = this.getElementosTrazas().getObjetivo().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getElementosTrazas().getObjetivo().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

        // Devuelve el siguiente identificador numérico de un requisito funcional
    public String getNuevoIdentificadorParticipante () {
        String nuevoIdentificador = "";
        int size = this.getParticipante().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getParticipante().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

    // Devuelve el siguiente identificador numérico de un Actor
    public String getNuevoIdentificadorActor () {
        String nuevoIdentificador = "";
        int size = this.getElementosTrazas().getActor().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getElementosTrazas().getActor().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

    // Devuelve el siguiente identificador numérico de una Organización
    public String getNuevoIdentificadorOrganizacion () {
        String nuevoIdentificador = "";

        int size = this.getOrganizacion().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getOrganizacion().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

    // Devuelve el siguiente identificador numérico de una Sección
    public String getNuevoIdentificadorSeccion () {
        String nuevoIdentificador = "";

        int size = this.getSeccion().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getSeccion().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

    // Devuelve el siguiente identificador numérico de un Apéndice
    public String getNuevoIdentificadorApendice () {
        String nuevoIdentificador = "";

        int size = this.getApendice().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";

        else {
            nuevoIdentificador = this.getApendice().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

    // Devuelve el siguiente identificador numérico de un Apéndice
    public String getNuevoIdentificadorParrafo () {
        String nuevoIdentificador = "";

        int size = this.getElementosTrazas().getParrafo().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";

        else {
            nuevoIdentificador = this.getElementosTrazas().getParrafo().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

        // Devuelve el siguiente identificador numérico de un Fichero Grafico
    public String getNuevoIdentificadorFicheroGrafico () {
        String nuevoIdentificador = "";

        int size = this.getElementosTrazas().getImagen().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";

        else {
            nuevoIdentificador = this.getElementosTrazas().getImagen().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

    // Devuelve el siguiente identificador numérico de una Matriz de Rastreabilidad
    public String getNuevoIdentificadorMatrizRastreabilidad () {
        String nuevoIdentificador = "";

        int size = this.getMatrizRastreabilidad().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";

        else {
            nuevoIdentificador = this.getMatrizRastreabilidad().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

// Devuelve el siguiente identificador numérico de un paso de un caso de uso (para su creación)
    public String getNuevoIdentificadorDatoEspecifico (String identReqInformacion) {
        ArrayList<RequisitoInformacion> reqInformacion = this.getElementosTrazas().getRequisitoInformacion();
        String nuevoIdentificador = "";
        int size = 0;

        for (int i = 0; i < reqInformacion.size(); i++) {
            if (reqInformacion.get(i).getIdentificacion().equals(identReqInformacion)) {
                ArrayList<DatoEspecifico> datoEspecifico = reqInformacion.get(i).getDatoEspecifico();
                size = datoEspecifico.size();
                if (size != 0)
                    nuevoIdentificador = datoEspecifico.get(size-1).getIdentificacion();
            }
        }

        if (size == 0)                                                          // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {                                                                  // Si hay elementos...
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }
    

   
    // Crea el fichero XML del Documento de Requisitos
    public void toXML(DefaultMutableTreeNode nodo, Result result, Document document, Element raiz) {

        if(nodo.getUserObject().toString().contains("SEC-")){
            ArrayList<Seccion> seccion = this.getSeccion();
                String id = utilidades.getIdentificadorNodo((MutableTreeNode) nodo);

                Seccion sec = new Seccion();
                boolean encontrado = false;
                int i = 0;
                while( !encontrado && i < seccion.size() )
                {
                    if(id.equals(seccion.get(i).getIdentificacion())){
                        sec = seccion.get(i);
                        encontrado = true;
                    }
                    i++;
                }
                    Element elemObjeto = document.createElement("Objeto"); //creamos un nuevo elemento
                    Element tipo = document.createElement("tipo");
                    tipo.appendChild( document.createTextNode("Seccion") );
                    elemObjeto.appendChild(tipo);

                    Element numeracion = document.createElement("numeracion"); //creamos un nuevo elemento
                    Text textNumeracion = document.createTextNode(sec.getNumeracion()); //Ingresamos la info
                    numeracion.appendChild(textNumeracion);
                    elemObjeto.appendChild(numeracion);

                    Element nombre = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textNombre = document.createTextNode(sec.getNombre()); //Ingresamos la info
                    nombre.appendChild(textNombre);
                    elemObjeto.appendChild(nombre);

                    raiz.appendChild(elemObjeto);
            }

            if(nodo.getUserObject().toString().contains("APE-")){

                ArrayList<Apendice> apendice = this.getApendice();

                String id = utilidades.getIdentificadorNodo((MutableTreeNode) nodo);

                Apendice ape = new Apendice();
                boolean encontrado = false;
                int i = 0;
                while( !encontrado && i < apendice.size() )
                {
                    if(id.equals(apendice.get(i).getIdentificacion())){
                        ape = apendice.get(i);
                        encontrado = true;
                    }
                    i++;
                }
                    Element elemObjeto = document.createElement("Objeto"); //creamos un nuevo elemento
                    Element tipo = document.createElement("tipo");
                    tipo.appendChild( document.createTextNode("Apendice") );
                    elemObjeto.appendChild(tipo);

                    Element numeracion = document.createElement("numeracion"); //creamos un nuevo elemento
                    Text textNumeracion = document.createTextNode(ape.getNumeracion()); //Ingresamos la info
                    numeracion.appendChild(textNumeracion);
                    elemObjeto.appendChild(numeracion);

                    Element nombre = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textNombre = document.createTextNode(ape.getNombre()); //Ingresamos la info
                    nombre.appendChild(textNombre);
                    elemObjeto.appendChild(nombre);

                    raiz.appendChild(elemObjeto);
            }

            if(nodo.getUserObject().toString().contains("PRG-")){
                ArrayList<Parrafo> parrafo = this.getElementosTrazas().getParrafo();

                String id = utilidades.getIdentificadorNodo((MutableTreeNode) nodo);

                Parrafo par = new Parrafo();
                boolean encontrado = false;
                int i = 0;
                while( !encontrado && i < parrafo.size() )
                {
                    if(id.equals(parrafo.get(i).getIdentificacion())){
                        par = parrafo.get(i);
                        encontrado = true;
                    }
                    i++;
                }
                Element elemObjeto = document.createElement("Objeto"); //creamos un nuevo elemento
                Element tipo = document.createElement("tipo");
                if (par.getesElementoGlosario()== true)
                    tipo.appendChild( document.createTextNode("ElementoGlosario") );
                else
                    tipo.appendChild( document.createTextNode("Parrafo") );
                elemObjeto.appendChild(tipo);

                Element identificacion = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacion = document.createTextNode(par.getIdentificacion()); //Ingresamos la info
                identificacion.appendChild(textIdentificacion);
                elemObjeto.appendChild(identificacion);

                Element nombre = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombre = document.createTextNode(par.getNombre()); //Ingresamos la info
                nombre.appendChild(textNombre);
                elemObjeto.appendChild(nombre);

                Element version = document.createElement("version"); //creamos un nuevo elemento
                Text textVersion = document.createTextNode(par.getVersion()); //Ingresamos la info
                version.appendChild(textVersion);
                elemObjeto.appendChild(version);

                Element fecha = document.createElement("fecha"); //creamos un nuevo elemento
                String cadFecha = formatearFecha(par.getFecha());
                Text textFecha = document.createTextNode(cadFecha); //Ingresamos la info
                fecha.appendChild(textFecha);
                elemObjeto.appendChild(fecha);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autores = par.getAutores();
                for ( int j = 0; j < autores.size(); j++){
                    Element elemAutores = document.createElement("Autor"); //creamos un nuevo elemento

                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autores.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutores.appendChild(elemIdentificacionAutor);

                    elemObjeto.appendChild(elemAutores);
                }

                //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentes = par.getFuentes();
                for ( int j = 0; j < fuentes.size(); j++){
                    Element elemFuentes = document.createElement("Fuente"); //creamos un nuevo elemento

                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentes.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentes.appendChild(elemIdentificacionFuente);

                    elemObjeto.appendChild(elemFuentes);
                }

                Element texto = document.createElement("texto"); //creamos un nuevo elemento
                Text textTexto = document.createTextNode(par.getTexto()); //Ingresamos la info
                texto.appendChild(textTexto);
                elemObjeto.appendChild(texto);

                //Hacer arbol de DESTINO
                ArrayList<ElementosTrazas> destino = par.getDestino();
                Element elemDestino = document.createElement("destino"); //creamos un nuevo elemento
                for ( int j = 0; j < destino.size(); j++){
                    Text textDestino = document.createTextNode("Destino"); //Ingresamos la info
                    elemDestino.appendChild(textDestino);
                    elemObjeto.appendChild(elemDestino);
                }

                //Hacer arbol de ORIGEN
                ArrayList<ElementosTrazas> origen = par.getOrigen();
                Element elemOrigen = document.createElement("origen"); //creamos un nuevo elemento
                for ( int j = 0; j < origen.size(); j++){
                    Text textOrigen = document.createTextNode("Origen"); //Ingresamos la info
                    elemOrigen.appendChild(textOrigen);
                    elemObjeto.appendChild(elemOrigen);
                }

                Element comentario = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentario = document.createTextNode(par.getComentario()); //Ingresamos la info
                comentario.appendChild(textComentario);
                elemObjeto.appendChild(comentario);

                raiz.appendChild(elemObjeto);
            }

            if(nodo.getUserObject().toString().contains("GRF-")){
                ArrayList<Imagen> imagen = this.getElementosTrazas().getImagen();

                String id = utilidades.getIdentificadorNodo((MutableTreeNode) nodo);

                Imagen img = new Imagen();
                boolean encontrado = false;
                int i = 0;
                while( !encontrado && i < imagen.size() )
                {
                    if(id.equals(imagen.get(i).getIdentificacion())){
                        img = imagen.get(i);
                        encontrado = true;
                    }
                    i++;
                }
                    Element elemObjeto = document.createElement("Objeto"); //creamos un nuevo elemento
                    Element tipo = document.createElement("tipo");
                    tipo.appendChild( document.createTextNode("Imagen") );
                    elemObjeto.appendChild(tipo);

                    Element identificacion = document.createElement("identificacion"); //creamos un nuevo elemento
                    Text textIdentificacion = document.createTextNode(img.getIdentificacion()); //Ingresamos la info
                    identificacion.appendChild(textIdentificacion);
                    elemObjeto.appendChild(identificacion);

                    Element nombre = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textNombre = document.createTextNode(img.getNombre()); //Ingresamos la info
                    nombre.appendChild(textNombre);
                    elemObjeto.appendChild(nombre);

                    Element version = document.createElement("version"); //creamos un nuevo elemento
                    Text textVersion = document.createTextNode(img.getVersion()); //Ingresamos la info
                    version.appendChild(textVersion);
                    elemObjeto.appendChild(version);

                    Element fecha = document.createElement("fecha"); //creamos un nuevo elemento
                    String cadFecha = formatearFecha(img.getFecha());
                    Text textFecha = document.createTextNode(cadFecha); //Ingresamos la info
                    fecha.appendChild(textFecha);
                    elemObjeto.appendChild(fecha);

                    //Hacer un arbol de AUTORES
                    ArrayList<Participante> autores = img.getAutores();
                    for ( int j = 0; j < autores.size(); j++){
                        Element elemAutores = document.createElement("Autor"); //creamos un nuevo elemento

                        Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionAutor = document.createTextNode(autores.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                        elemAutores.appendChild(elemIdentificacionAutor);

                        elemObjeto.appendChild(elemAutores);
                    }

                    //Hacer un arbol de FUENTES
                    ArrayList<Participante> fuentes = img.getFuentes();
                    for ( int j = 0; j < fuentes.size(); j++){
                        Element elemFuentes = document.createElement("Fuente"); //creamos un nuevo elemento

                        Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionFuente = document.createTextNode(fuentes.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                        elemFuentes.appendChild(elemIdentificacionFuente);

                        elemObjeto.appendChild(elemFuentes);
                    }

                    Element rutaImagen = document.createElement("rutaImagen"); //creamos un nuevo elemento
                    Text textRutaImagen = document.createTextNode(img.getRutaImagen()); //Ingresamos la info
                    rutaImagen.appendChild(textRutaImagen);
                    elemObjeto.appendChild(rutaImagen);


                   //Hacer arbol de DESTINO
                    ArrayList<ElementosTrazas> destino = img.getDestino();
                    Element elemDestino = document.createElement("destino"); //creamos un nuevo elemento
                    for ( int j = 0; j < destino.size(); j++){
                        Text textDestino = document.createTextNode("Destino"); //Ingresamos la info
                        elemDestino.appendChild(textDestino);
                        elemObjeto.appendChild(elemDestino);
                    }

                    //Hacer arbol de ORIGEN
                    ArrayList<ElementosTrazas> origen = img.getOrigen();
                    Element elemOrigen = document.createElement("origen"); //creamos un nuevo elemento
                    for ( int j = 0; j < origen.size(); j++){
                        Text textOrigen = document.createTextNode("Origen"); //Ingresamos la info
                        elemOrigen.appendChild(textOrigen);
                        elemObjeto.appendChild(elemOrigen);
                    }

                    Element comentario = document.createElement("comentario"); //creamos un nuevo elemento
                    Text textComentario = document.createTextNode(img.getComentario()); //Ingresamos la info
                    comentario.appendChild(textComentario);
                    elemObjeto.appendChild(comentario);

                    raiz.appendChild(elemObjeto);
            }

            if(nodo.getUserObject().toString().contains("ORG-")){
            ArrayList<Organizacion> organizacion = this.getOrganizacion();

                String id = utilidades.getIdentificadorNodo((MutableTreeNode) nodo);

                Organizacion org = new Organizacion();
                boolean encontrado = false;
                int i = 0;
                while( !encontrado && i < organizacion.size() )
                {
                    if(id.equals(organizacion.get(i).getIdentificacion())){
                        org = organizacion.get(i);
                        encontrado = true;
                    }
                    i++;
                }
                    Element elemObjeto = document.createElement("Objeto"); //creamos un nuevo elemento
                    Element tipo = document.createElement("tipo");
                    tipo.appendChild( document.createTextNode("Organizacion") );
                    elemObjeto.appendChild(tipo);

                    Element identificacion = document.createElement("identificacion"); //creamos un nuevo elemento
                    Text textIdentificacion = document.createTextNode(org.getIdentificacion()); //Ingresamos la info
                    identificacion.appendChild(textIdentificacion);
                    elemObjeto.appendChild(identificacion);

                    Element nombre = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textNombre = document.createTextNode(org.getNombre()); //Ingresamos la info
                    nombre.appendChild(textNombre);
                    elemObjeto.appendChild(nombre);

                    Element version = document.createElement("version"); //creamos un nuevo elemento
                    Text textVersion = document.createTextNode(org.getVersion()); //Ingresamos la info
                    version.appendChild(textVersion);
                    elemObjeto.appendChild(version);

                    Element fecha = document.createElement("fecha"); //creamos un nuevo elemento
                    String cadFecha = formatearFecha(org.getFecha());
                    Text textFecha = document.createTextNode(cadFecha); //Ingresamos la info
                    fecha.appendChild(textFecha);
                    elemObjeto.appendChild(fecha);

                    //Hacer un arbol de AUTORES
                    ArrayList<Participante> autores = org.getAutores();
                    for ( int j = 0; j < autores.size(); j++){
                        Element elemAutores = document.createElement("Autor"); //creamos un nuevo elemento

                        Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionAutor = document.createTextNode(autores.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                        elemAutores.appendChild(elemIdentificacionAutor);

                        elemObjeto.appendChild(elemAutores);
                    }

                    //Hacer un arbol de FUENTES
                    ArrayList<Participante> fuentes = org.getFuentes();
                    for ( int j = 0; j < fuentes.size(); j++){
                        Element elemFuentes = document.createElement("Fuente"); //creamos un nuevo elemento

                        Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionFuente = document.createTextNode(fuentes.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                        elemFuentes.appendChild(elemIdentificacionFuente);

                        elemObjeto.appendChild(elemFuentes);
                    }

                    Element direccion = document.createElement("direccion"); //creamos un nuevo elemento
                    Text textDireccion = document.createTextNode(org.getDireccion()); //Ingresamos la info
                    direccion.appendChild(textDireccion);
                    elemObjeto.appendChild(direccion);

                    Element telefono = document.createElement("telefono"); //creamos un nuevo elemento
                    Text textTelefono = document.createTextNode(org.getTelefono()); //Ingresamos la info
                    telefono.appendChild(textTelefono);
                    elemObjeto.appendChild(telefono);

                    Element fax = document.createElement("fax"); //creamos un nuevo elemento
                    Text textFax = document.createTextNode(org.getFax()); //Ingresamos la info
                    fax.appendChild(textFax);
                    elemObjeto.appendChild(fax);

                    Element comentario = document.createElement("comentario"); //creamos un nuevo elemento
                    Text textComentario = document.createTextNode(org.getComentario()); //Ingresamos la info
                    comentario.appendChild(textComentario);
                    elemObjeto.appendChild(comentario);

                    raiz.appendChild(elemObjeto);
            }

            if(nodo.getUserObject().toString().contains("STK-")){
                ArrayList<Participante> participante = this.getParticipante();

                String id = utilidades.getIdentificadorNodo((MutableTreeNode) nodo);

                Participante par = new Participante();
                boolean encontrado = false;
                int i = 0;
                while( !encontrado && i < participante.size() )
                {
                    if(id.equals(participante.get(i).getIdentificacion())){
                        par = participante.get(i);
                        encontrado = true;
                    }
                    i++;
                }
                    Element elemObjeto = document.createElement("Objeto"); //creamos un nuevo elemento
                    Element tipo = document.createElement("tipo");
                    tipo.appendChild( document.createTextNode("Participante") );
                    elemObjeto.appendChild(tipo);

                    Element identificacion = document.createElement("identificacion"); //creamos un nuevo elemento
                    Text textIdentificacion = document.createTextNode(par.getIdentificacion()); //Ingresamos la info
                    identificacion.appendChild(textIdentificacion);
                    elemObjeto.appendChild(identificacion);

                    Element nombre = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textNombre = document.createTextNode(par.getNombre()); //Ingresamos la info
                    nombre.appendChild(textNombre);
                    elemObjeto.appendChild(nombre);

                    Element version = document.createElement("version"); //creamos un nuevo elemento
                    Text textVersion = document.createTextNode(par.getVersion()); //Ingresamos la info
                    version.appendChild(textVersion);
                    elemObjeto.appendChild(version);

                    Element fecha = document.createElement("fecha"); //creamos un nuevo elemento
                    String cadFecha = formatearFecha(par.getFecha());
                    Text textFecha = document.createTextNode(cadFecha); //Ingresamos la info
                    fecha.appendChild(textFecha);
                    elemObjeto.appendChild(fecha);

                    //Hacer un arbol de AUTORES
                    ArrayList<Participante> autores = par.getAutores();
                    for ( int j = 0; j < autores.size(); j++){
                        Element elemAutores = document.createElement("Autor"); //creamos un nuevo elemento

                        Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionAutor = document.createTextNode(autores.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                        elemAutores.appendChild(elemIdentificacionAutor);

                        elemObjeto.appendChild(elemAutores);
                    }

                    //Hacer un arbol de FUENTES
                    ArrayList<Participante> fuentes = par.getFuentes();
                    for ( int j = 0; j < fuentes.size(); j++){
                        Element elemFuentes = document.createElement("Fuente"); //creamos un nuevo elemento

                        Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionFuente = document.createTextNode(fuentes.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                        elemFuentes.appendChild(elemIdentificacionFuente);

                        elemObjeto.appendChild(elemFuentes);
                    }

                    Element rol = document.createElement("rol"); //creamos un nuevo elemento
                    Text textRol = document.createTextNode(par.getRol()); //Ingresamos la info
                    rol.appendChild(textRol);
                    elemObjeto.appendChild(rol);

                    Element organizacion = document.createElement("Organizacion"); //creamos un nuevo elemento
                    if(par.getOrganizacion() != null){
                        if(par.getOrganizacion().getIdentificacion() != null){
                            Element idorganizacion = document.createElement("idenOrg"); //creamos un nuevo elemento
                            Text textOrganizacion = document.createTextNode(par.getOrganizacion().getIdentificacion()); //Ingresamos la info
                            idorganizacion.appendChild(textOrganizacion);
                            Element nomorganizacion = document.createElement("nombreOrg"); //creamos un nuevo elemento
                            Text textnomOrganizacion = document.createTextNode(par.getOrganizacion().getNombre()); //Ingresamos la info
                            nomorganizacion.appendChild(textnomOrganizacion);

                            organizacion.appendChild(idorganizacion);
                            organizacion.appendChild(nomorganizacion);
                        }
                    }
                    elemObjeto.appendChild(organizacion);

                    Element esCliente = document.createElement("esCliente"); //creamos un nuevo elemento
                    Text textEsCliente = document.createTextNode(par.getEsCliente().toString()); //Ingresamos la info
                    esCliente.appendChild(textEsCliente);
                    elemObjeto.appendChild(esCliente);

                    Element esDesarrollador = document.createElement("esDesarrollador"); //creamos un nuevo elemento
                    Text textEsDesarrollador = document.createTextNode(par.getEsDesarrollador().toString()); //Ingresamos la info
                    esDesarrollador.appendChild(textEsDesarrollador);
                    elemObjeto.appendChild(esDesarrollador);

                    Element esUsuario = document.createElement("esUsuario"); //creamos un nuevo elemento
                    Text textEsUsuario = document.createTextNode(par.getEsUsuario().toString()); //Ingresamos la info
                    esUsuario.appendChild(textEsUsuario);
                    elemObjeto.appendChild(esUsuario);

                    Element comentario = document.createElement("comentario"); //creamos un nuevo elemento
                    Text textComentario = document.createTextNode(par.getComentario()); //Ingresamos la info
                    comentario.appendChild(textComentario);
                    elemObjeto.appendChild(comentario);

                    raiz.appendChild(elemObjeto);
            }

        if(nodo.getUserObject().toString().contains("MET-")){
            ArrayList<Reunion> reunion = this.getElementosTrazas().getReunion();

                String id = utilidades.getIdentificadorNodo((MutableTreeNode) nodo);

                Reunion reu = new Reunion();
                boolean encontrado = false;
                int i = 0;
                while( !encontrado && i < reunion.size() )
                {
                    if(id.equals(reunion.get(i).getIdentificacion())){
                        reu = reunion.get(i);
                        encontrado = true;
                    }
                    i++;
                }
                    Element elemObjeto = document.createElement("Objeto"); //creamos un nuevo elemento
                    Element tipo = document.createElement("tipo");
                    tipo.appendChild( document.createTextNode("Reunion") );
                    elemObjeto.appendChild(tipo);

                    Element identificacion = document.createElement("identificacion"); //creamos un nuevo elemento
                    Text textIdentificacion = document.createTextNode(reu.getIdentificacion()); //Ingresamos la info
                    identificacion.appendChild(textIdentificacion);
                    elemObjeto.appendChild(identificacion);

                    Element nombre = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textNombre = document.createTextNode(reu.getNombre()); //Ingresamos la info
                    nombre.appendChild(textNombre);
                    elemObjeto.appendChild(nombre);

                    Element version = document.createElement("version"); //creamos un nuevo elemento
                    Text textVersion = document.createTextNode(reu.getVersion()); //Ingresamos la info
                    version.appendChild(textVersion);
                    elemObjeto.appendChild(version);

                    Element fecha = document.createElement("fecha"); //creamos un nuevo elemento
                    String cadFecha = formatearFecha(reu.getFecha());
                    Text textFecha = document.createTextNode(cadFecha); //Ingresamos la info
                    fecha.appendChild(textFecha);
                    elemObjeto.appendChild(fecha);

                    //Hacer un arbol de AUTORES
                    ArrayList<Participante> autores = reu.getAutores();
                    for ( int j = 0; j < autores.size(); j++){
                        Element elemAutores = document.createElement("Autor"); //creamos un nuevo elemento

                        Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionAutor = document.createTextNode(autores.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                        elemAutores.appendChild(elemIdentificacionAutor);

                        elemObjeto.appendChild(elemAutores);
                    }

                    //Hacer un arbol de FUENTES
                    ArrayList<Participante> fuentes = reu.getFuentes();
                    for ( int j = 0; j < fuentes.size(); j++){
                        Element elemFuentes = document.createElement("Fuente"); //creamos un nuevo elemento

                        Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionFuente = document.createTextNode(fuentes.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                        elemFuentes.appendChild(elemIdentificacionFuente);

                        elemObjeto.appendChild(elemFuentes);
                    }

                    Element lugar = document.createElement("lugar"); //creamos un nuevo elemento
                    Text textLugar = document.createTextNode(reu.getLugar()); //Ingresamos la info
                    lugar.appendChild(textLugar);
                    elemObjeto.appendChild(lugar);

                    Element elemFechaReunion = document.createElement("fechaReunion"); //creamos un nuevo elemento
                    String cadenaFechaReunion = formatearFecha(reu.getFechaReunion());
                    Text textFechaVidaReunion = document.createTextNode(cadenaFechaReunion); //Ingresamos la info
                    elemFechaReunion.appendChild(textFechaVidaReunion);
                    elemObjeto.appendChild(elemFechaReunion);
                    
                    Element elemHoraReunion = document.createElement("horaReunion"); //creamos un nuevo elemento
                    Text textHoraReunion = document.createTextNode(reu.getHora()); //Ingresamos la info
                    elemHoraReunion.appendChild(textHoraReunion);
                    elemObjeto.appendChild(elemHoraReunion);

                    //Hacer un arbol de ASISTENTES
                    ArrayList<Participante> asistentesReunion = reu.getAsistentes();
                    for ( int j = 0; j < asistentesReunion.size(); j++){
                        Element elemAsistentes = document.createElement("Asistentes"); //creamos un nuevo elemento

                        Element elemIdentificacionAsistente = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionAsistente = document.createTextNode(asistentesReunion.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionAsistente.appendChild(textIdentificacionAsistente);
                        elemAsistentes.appendChild(elemIdentificacionAsistente);

                        elemObjeto.appendChild(elemAsistentes);
                    }
                    
                    
                    Element elemResultados = document.createElement("resultados"); //creamos un nuevo elemento
                    Text textResultados = document.createTextNode(reu.getResultados()); //Ingresamos la info
                    elemResultados.appendChild(textResultados);
                    elemObjeto.appendChild(elemResultados);

                                       //Hacer arbol de DESTINO
                    ArrayList<ElementosTrazas> destino = reu.getDestino();
                    Element elemDestino = document.createElement("destino"); //creamos un nuevo elemento
                    for ( int j = 0; j < destino.size(); j++){
                        Text textDestino = document.createTextNode("Destino"); //Ingresamos la info
                        elemDestino.appendChild(textDestino);
                        elemObjeto.appendChild(elemDestino);
                    }

                    //Hacer arbol de ORIGEN
                    ArrayList<ElementosTrazas> origen = reu.getOrigen();
                    Element elemOrigen = document.createElement("origen"); //creamos un nuevo elemento
                    for ( int j = 0; j < origen.size(); j++){
                        Text textOrigen = document.createTextNode("Origen"); //Ingresamos la info
                        elemOrigen.appendChild(textOrigen);
                        elemObjeto.appendChild(elemOrigen);
                    }
                    
                    Element comentario = document.createElement("comentario"); //creamos un nuevo elemento
                    Text textComentario = document.createTextNode(reu.getComentario()); //Ingresamos la info
                    comentario.appendChild(textComentario);
                    elemObjeto.appendChild(comentario);

                    raiz.appendChild(elemObjeto);


            }

            if(nodo.getUserObject().toString().contains("OBJ-")){
                ArrayList<Objetivo> objetivo = this.getElementosTrazas().getObjetivo();
                 
                String id = utilidades.getIdentificadorNodo((MutableTreeNode) nodo);

                Objetivo obj = new Objetivo();
                boolean encontrado = false;
                int i = 0;
                while( !encontrado && i < objetivo.size() )
                {
                    if(id.equals(objetivo.get(i).getIdentificacion())){
                        obj = objetivo.get(i);
                        encontrado = true;
                    }
                    i++;
                }
                if(!obj.getEsSubObjetivo()){
                    Element elemObjeto = document.createElement("Objeto"); //creamos un nuevo elemento
                    Element tipo = document.createElement("tipo");
                    tipo.appendChild( document.createTextNode("Objetivo") );
                    elemObjeto.appendChild(tipo);

                    Element identificacion = document.createElement("identificacion"); //creamos un nuevo elemento
                    Text textIdentificacion = document.createTextNode(obj.getIdentificacion()); //Ingresamos la info
                    identificacion.appendChild(textIdentificacion);
                    elemObjeto.appendChild(identificacion);

                    Element nombre = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textNombre = document.createTextNode(obj.getNombre()); //Ingresamos la info
                    nombre.appendChild(textNombre);
                    elemObjeto.appendChild(nombre);

                    Element version = document.createElement("version"); //creamos un nuevo elemento
                    Text textVersion = document.createTextNode(obj.getVersion()); //Ingresamos la info
                    version.appendChild(textVersion);
                    elemObjeto.appendChild(version);

                    Element fecha = document.createElement("fecha"); //creamos un nuevo elemento
                    String cadFecha = formatearFecha(obj.getFecha());
                    Text textFecha = document.createTextNode(cadFecha); //Ingresamos la info
                    fecha.appendChild(textFecha);
                    elemObjeto.appendChild(fecha);

                    //Hacer un arbol de AUTORES
                    ArrayList<Participante> autores = obj.getAutores();
                    for ( int j = 0; j < autores.size(); j++){
                        Element elemAutores = document.createElement("Autor"); //creamos un nuevo elemento

                        Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionAutor = document.createTextNode(autores.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                        elemAutores.appendChild(elemIdentificacionAutor);

                        elemObjeto.appendChild(elemAutores);
                    }

                    //Hacer un arbol de FUENTES
                    ArrayList<Participante> fuentes = obj.getFuentes();
                    for ( int j = 0; j < fuentes.size(); j++){
                        Element elemFuentes = document.createElement("Fuente"); //creamos un nuevo elemento

                        Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionFuente = document.createTextNode(fuentes.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                        elemFuentes.appendChild(elemIdentificacionFuente);

                        elemObjeto.appendChild(elemFuentes);
                    }
                    
                    //Hacer un arbol de SUBOBJETIVOS
                    ArrayList<Objetivo> subObjetivos = obj.getSubObjetivos();
                    for ( int j = 0; j < subObjetivos.size(); j++){
                        Element elemSubObjetivo = document.createElement("SubObjetivo"); //creamos un nuevo elemento

                        Element elemIdentificacionSubObjetivo = document.createElement("identificacion"); //creamos un nuevo elemento
                        Text textIdentificacionSubObjetivo = document.createTextNode(subObjetivos.get(j).getIdentificacion()); //Ingresamos la info
                        elemIdentificacionSubObjetivo.appendChild(textIdentificacionSubObjetivo);
                        elemSubObjetivo.appendChild(elemIdentificacionSubObjetivo);
                        
                        Element elemNombreSubObjetivo = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textNombreSubObjetivo = document.createTextNode(subObjetivos.get(j).getNombre()); //Ingresamos la info
                        elemNombreSubObjetivo.appendChild(textNombreSubObjetivo);
                        elemSubObjetivo.appendChild(elemNombreSubObjetivo);
                        
                        Element elemDescripcionSubObjetivo = document.createElement("descripcion"); //creamos un nuevo elemento
                        Text textDescripcionSubObjetivo = document.createTextNode(subObjetivos.get(j).getTexto()); //Ingresamos la info
                        elemDescripcionSubObjetivo.appendChild(textDescripcionSubObjetivo);
                        elemSubObjetivo.appendChild(elemDescripcionSubObjetivo);   

                        //Nivel 2
                        ArrayList<Objetivo> subObjetivos2 = subObjetivos.get(j).getSubObjetivos();
                        for ( int k = 0; k < subObjetivos2.size(); k++){
                            Element elemSubObjetivo2 = document.createElement("SubObjetivo_n2"); //creamos un nuevo elemento

                            Element elemIdentificacionSubObjetivo2 = document.createElement("identificacion"); //creamos un nuevo elemento
                            Text textIdentificacionSubObjetivo2 = document.createTextNode(subObjetivos2.get(k).getIdentificacion()); //Ingresamos la info
                            elemIdentificacionSubObjetivo2.appendChild(textIdentificacionSubObjetivo2);
                            elemSubObjetivo2.appendChild(elemIdentificacionSubObjetivo2);

                            Element elemNombreSubObjetivo2 = document.createElement("nombre"); //creamos un nuevo elemento
                            Text textNombreSubObjetivo2 = document.createTextNode(subObjetivos2.get(k).getNombre()); //Ingresamos la info
                            elemNombreSubObjetivo2.appendChild(textNombreSubObjetivo2);
                            elemSubObjetivo2.appendChild(elemNombreSubObjetivo2);

                            Element elemDescripcionSubObjetivo2 = document.createElement("descripcion"); //creamos un nuevo elemento
                            Text textDescripcionSubObjetivo2 = document.createTextNode(subObjetivos2.get(k).getTexto()); //Ingresamos la info
                            elemDescripcionSubObjetivo2.appendChild(textDescripcionSubObjetivo2);
                            elemSubObjetivo2.appendChild(elemDescripcionSubObjetivo2);

                            elemSubObjetivo.appendChild(elemSubObjetivo2);
                        }
                        elemObjeto.appendChild(elemSubObjetivo);
                    }

                    Element elemTexto = document.createElement("texto"); //creamos un nuevo elemento
                    Text textTexto = document.createTextNode(obj.getTexto()); //Ingresamos la info
                    elemTexto.appendChild(textTexto);
                    elemObjeto.appendChild(elemTexto);
   
                    Element elemImportancia = document.createElement("importancia"); //creamos un nuevo elemento
                    Text textImportancia = document.createTextNode(obj.getImportancia()); //Ingresamos la info
                    elemImportancia.appendChild(textImportancia);
                    elemObjeto.appendChild(elemImportancia);

                    Element elemUrgencia = document.createElement("urgencia"); //creamos un nuevo elemento
                    Text textUrgenciasVida = document.createTextNode(obj.getUrgencia()); //Ingresamos la info
                    elemUrgencia.appendChild(textUrgenciasVida);
                    elemObjeto.appendChild(elemUrgencia);

                    Element elemEstadoDesarrollo = document.createElement("estadoDesarrollo"); //creamos un nuevo elemento
                    Text textEstadoDesarrollo = document.createTextNode(obj.getEstadoDesarrollo()); //Ingresamos la info
                    elemEstadoDesarrollo.appendChild(textEstadoDesarrollo);
                    elemObjeto.appendChild(elemEstadoDesarrollo);

                    Element elemEstabilidad = document.createElement("estabilidad"); //creamos un nuevo elemento
                    Text textEstabilidad = document.createTextNode(obj.getEstabilidad()); //Ingresamos la info
                    elemEstabilidad.appendChild(textEstabilidad);
                    elemObjeto.appendChild(elemEstabilidad);


                   //Hacer arbol de DESTINO
                    ArrayList<ElementosTrazas> destino = obj.getDestino();
                    Element elemDestino = document.createElement("destino"); //creamos un nuevo elemento
                    for ( int j = 0; j < destino.size(); j++){
                        Text textDestino = document.createTextNode("Destino"); //Ingresamos la info
                        elemDestino.appendChild(textDestino);
                        elemObjeto.appendChild(elemDestino);
                    }

                    //Hacer arbol de ORIGEN
                    ArrayList<ElementosTrazas> origen = obj.getOrigen();
                    Element elemOrigen = document.createElement("origen"); //creamos un nuevo elemento
                    for ( int j = 0; j < origen.size(); j++){
                        Text textOrigen = document.createTextNode("Origen"); //Ingresamos la info
                        elemOrigen.appendChild(textOrigen);
                        elemObjeto.appendChild(elemOrigen);
                    }

                    Element comentario = document.createElement("comentario"); //creamos un nuevo elemento
                    Text textComentario = document.createTextNode(obj.getComentario()); //Ingresamos la info
                    comentario.appendChild(textComentario);
                    elemObjeto.appendChild(comentario);
                
                    raiz.appendChild(elemObjeto);
                }
            }

            if(nodo.getUserObject().toString().contains("ACT-")){
                ArrayList<Actor> actor = this.getElementosTrazas().getActor();

                String id = utilidades.getIdentificadorNodo((MutableTreeNode) nodo);

                Actor act = new Actor();
                boolean encontrado = false;
                int i = 0;
                while( !encontrado && i < actor.size() )
                {
                    if(id.equals(actor.get(i).getIdentificacion())){
                        act = actor.get(i);
                        encontrado = true;
                    }
                    i++;
                }
                    Element elemObjeto = document.createElement("Objeto"); //creamos un nuevo elemento
                    Element tipo = document.createElement("tipo");
                    tipo.appendChild( document.createTextNode("Actor") );
                    elemObjeto.appendChild(tipo);

                    Element identificacion = document.createElement("identificacion"); //creamos un nuevo elemento
                    Text textIdentificacion = document.createTextNode(act.getIdentificacion()); //Ingresamos la info
                    identificacion.appendChild(textIdentificacion);
                    elemObjeto.appendChild(identificacion);

                    Element nombre = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textNombre = document.createTextNode(act.getNombre()); //Ingresamos la info
                    nombre.appendChild(textNombre);
                    elemObjeto.appendChild(nombre);

                    Element version = document.createElement("version"); //creamos un nuevo elemento
                    Text textVersion = document.createTextNode(act.getVersion()); //Ingresamos la info
                    version.appendChild(textVersion);
                    elemObjeto.appendChild(version);

                    Element fecha = document.createElement("fecha"); //creamos un nuevo elemento
                    String cadFecha = formatearFecha(act.getFecha());
                    Text textFecha = document.createTextNode(cadFecha); //Ingresamos la info
                    fecha.appendChild(textFecha);
                    elemObjeto.appendChild(fecha);

                    //Hacer un arbol de AUTORES
                    ArrayList<Participante> autores = act.getAutores();
                    for ( int j = 0; j < autores.size(); j++){
                        Element elemAutores = document.createElement("Autor"); //creamos un nuevo elemento

                        Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionAutor = document.createTextNode(autores.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                        elemAutores.appendChild(elemIdentificacionAutor);

                        elemObjeto.appendChild(elemAutores);
                    }

                    //Hacer un arbol de FUENTES
                    ArrayList<Participante> fuentes = act.getFuentes();
                    for ( int j = 0; j < fuentes.size(); j++){
                        Element elemFuentes = document.createElement("Fuente"); //creamos un nuevo elemento

                        Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionFuente = document.createTextNode(fuentes.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                        elemFuentes.appendChild(elemIdentificacionFuente);

                        elemObjeto.appendChild(elemFuentes);
                    }

                    Element elemTexto = document.createElement("texto"); //creamos un nuevo elemento
                    Text textTexto = document.createTextNode(act.getTexto()); //Ingresamos la info
                    elemTexto.appendChild(textTexto);
                    elemObjeto.appendChild(elemTexto);

                   //Hacer arbol de DESTINO
                    ArrayList<ElementosTrazas> destino = act.getDestino();
                    Element elemDestino = document.createElement("destino"); //creamos un nuevo elemento
                    for ( int j = 0; j < destino.size(); j++){
                        Text textDestino = document.createTextNode("Destino"); //Ingresamos la info
                        elemDestino.appendChild(textDestino);
                        elemObjeto.appendChild(elemDestino);
                    }

                    //Hacer arbol de ORIGEN
                    ArrayList<ElementosTrazas> origen = act.getOrigen();
                    Element elemOrigen = document.createElement("origen"); //creamos un nuevo elemento
                    for ( int j = 0; j < origen.size(); j++){
                        Text textOrigen = document.createTextNode("Origen"); //Ingresamos la info
                        elemOrigen.appendChild(textOrigen);
                        elemObjeto.appendChild(elemOrigen);
                    }

                    Element comentario = document.createElement("comentario"); //creamos un nuevo elemento
                    Text textComentario = document.createTextNode(act.getComentario()); //Ingresamos la info
                    comentario.appendChild(textComentario);
                    elemObjeto.appendChild(comentario);

                    raiz.appendChild(elemObjeto);
            }

            if(nodo.getUserObject().toString().contains("IRQ-")){
                ArrayList<RequisitoInformacion> reqInformacion = this.getElementosTrazas().getRequisitoInformacion();

                String id = utilidades.getIdentificadorNodo((MutableTreeNode) nodo);

                RequisitoInformacion reqInf = new RequisitoInformacion();
                boolean encontrado = false;
                int i = 0;
                while( !encontrado && i < reqInformacion.size() )
                {
                    if(id.equals(reqInformacion.get(i).getIdentificacion())){
                        reqInf = reqInformacion.get(i);
                        encontrado = true;
                    }
                    i++;
                }
                    Element elemObjeto = document.createElement("Objeto"); //creamos un nuevo elemento
                    Element tipo = document.createElement("tipo");
                    tipo.appendChild( document.createTextNode("ReqInformacion") );
                    elemObjeto.appendChild(tipo);

                    Element identificacion = document.createElement("identificacion"); //creamos un nuevo elemento
                    Text textIdentificacion = document.createTextNode(reqInf.getIdentificacion()); //Ingresamos la info
                    identificacion.appendChild(textIdentificacion);
                    elemObjeto.appendChild(identificacion);

                    Element nombre = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textNombre = document.createTextNode(reqInf.getNombre()); //Ingresamos la info
                    nombre.appendChild(textNombre);
                    elemObjeto.appendChild(nombre);

                    Element version = document.createElement("version"); //creamos un nuevo elemento
                    Text textVersion = document.createTextNode(reqInf.getVersion()); //Ingresamos la info
                    version.appendChild(textVersion);
                    elemObjeto.appendChild(version);

                    Element fecha = document.createElement("fecha"); //creamos un nuevo elemento
                    String cadFecha = formatearFecha(reqInf.getFecha());
                    Text textFecha = document.createTextNode(cadFecha); //Ingresamos la info
                    fecha.appendChild(textFecha);
                    elemObjeto.appendChild(fecha);

                    //Hacer un arbol de DATOS ESPECIFICOS
                    ArrayList<DatoEspecifico> datosEsp = reqInf.getDatoEspecifico();
                    for ( int j = 0; j < datosEsp.size(); j++){
                        Element elemDatoEsp = document.createElement("DatoEspecifico"); //creamos un nuevo elemento

                        Element elemDescripcionDato = document.createElement("descripcion"); //creamos un nuevo elemento
                        Text textDescripcionDato = document.createTextNode(datosEsp.get(j).getDescripcion()); //Ingresamos la info
                        elemDescripcionDato.appendChild(textDescripcionDato);
                        elemDatoEsp.appendChild(elemDescripcionDato);

                        Element elemComentarioDato = document.createElement("comentario"); //creamos un nuevo elemento
                        Text textComentarioDato = document.createTextNode(datosEsp.get(j).getComentario()); //Ingresamos la info
                        elemComentarioDato.appendChild(textComentarioDato);
                        elemDatoEsp.appendChild(elemComentarioDato);

                        elemObjeto.appendChild(elemDatoEsp);
                    }

                    //Hacer un arbol de AUTORES
                    ArrayList<Participante> autores = reqInf.getAutores();
                    for ( int j = 0; j < autores.size(); j++){
                        Element elemAutores = document.createElement("Autor"); //creamos un nuevo elemento

                        Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionAutor = document.createTextNode(autores.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                        elemAutores.appendChild(elemIdentificacionAutor);

                        elemObjeto.appendChild(elemAutores);
                    }

                    //Hacer un arbol de FUENTES
                    ArrayList<Participante> fuentes = reqInf.getFuentes();
                    for ( int j = 0; j < fuentes.size(); j++){
                        Element elemFuentes = document.createElement("Fuente"); //creamos un nuevo elemento

                        Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionFuente = document.createTextNode(fuentes.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                        elemFuentes.appendChild(elemIdentificacionFuente);

                        elemObjeto.appendChild(elemFuentes);
                    }

                    Element elemConceptoRelevante = document.createElement("conceptoRelevante"); //creamos un nuevo elemento
                    Text textConceptoRelevante = document.createTextNode(reqInf.getConceptoRelevante()); //Ingresamos la info
                    elemConceptoRelevante.appendChild(textConceptoRelevante);
                    elemObjeto.appendChild(elemConceptoRelevante);

                    Element elemValorMaxVida = document.createElement("valorMaxVida"); //creamos un nuevo elemento
                    Text textValorMaxVida = document.createTextNode(String.valueOf(reqInf.getValorMaxVida())); //Ingresamos la info
                    elemValorMaxVida.appendChild(textValorMaxVida);
                    elemObjeto.appendChild(elemValorMaxVida);

                    Element elemUnidadTiempoMaxVida = document.createElement("unidadTiempoMaxVida"); //creamos un nuevo elemento
                    Text textUnidadTiempoMaxVida = document.createTextNode(reqInf.getUnidadTiempoMaxVida()); //Ingresamos la info
                    elemUnidadTiempoMaxVida.appendChild(textUnidadTiempoMaxVida);
                    elemObjeto.appendChild(elemUnidadTiempoMaxVida);

                    Element elemValorMedioVida = document.createElement("valorMedioVida"); //creamos un nuevo elemento
                    Text textValorMedioVida = document.createTextNode(String.valueOf(reqInf.getValorMedioVida())); //Ingresamos la info
                    elemValorMedioVida.appendChild(textValorMedioVida);
                    elemObjeto.appendChild(elemValorMedioVida);

                    Element elemUnidadTiempoMedioVida = document.createElement("unidadTiempoMedioVida"); //creamos un nuevo elemento
                    Text textUnidadTiempoMedioVida = document.createTextNode(reqInf.getUnidadTiempoMedioVida()); //Ingresamos la info
                    elemUnidadTiempoMedioVida.appendChild(textUnidadTiempoMedioVida);
                    elemObjeto.appendChild(elemUnidadTiempoMedioVida);

                    Element elemOcurrenciasMaxima = document.createElement("ocurrenciasMaxima"); //creamos un nuevo elemento
                    Text textOcurrenciasMaximas = document.createTextNode(String.valueOf(reqInf.getOcurrenciasMaxima())); //Ingresamos la info
                    elemOcurrenciasMaxima.appendChild(textOcurrenciasMaximas);
                    elemObjeto.appendChild(elemOcurrenciasMaxima);

                    Element elemOcurrenciasMedia = document.createElement("ocurrenciasMedia"); //creamos un nuevo elemento
                    Text textOcurrenciasMedia = document.createTextNode(String.valueOf(reqInf.getOcurrenciasMedia())); //Ingresamos la info
                    elemOcurrenciasMedia.appendChild(textOcurrenciasMedia);
                    elemObjeto.appendChild(elemOcurrenciasMedia);

                    Element elemImportancia = document.createElement("importancia"); //creamos un nuevo elemento
                    Text textImportancia = document.createTextNode(reqInf.getImportancia()); //Ingresamos la info
                    elemImportancia.appendChild(textImportancia);
                    elemObjeto.appendChild(elemImportancia);

                    Element elemUrgencia = document.createElement("urgencia"); //creamos un nuevo elemento
                    Text textUrgencia = document.createTextNode(reqInf.getUrgencia()); //Ingresamos la info
                    elemUrgencia.appendChild(textUrgencia);
                    elemObjeto.appendChild(elemUrgencia);

                    Element elemEstadoDesarrollo = document.createElement("estadoDesarrollo"); //creamos un nuevo elemento
                    Text textEstadoDesarrollo = document.createTextNode(reqInf.getEstadoDesarrollo()); //Ingresamos la info
                    elemEstadoDesarrollo.appendChild(textEstadoDesarrollo);
                    elemObjeto.appendChild(elemEstadoDesarrollo);

                    Element elemEstabilidad = document.createElement("estabilidad"); //creamos un nuevo elemento
                    Text textEstabilidad = document.createTextNode(reqInf.getEstabilidad()); //Ingresamos la info
                    elemEstabilidad.appendChild(textEstabilidad);
                    elemObjeto.appendChild(elemEstabilidad);

                   //Hacer arbol de DESTINO
                    ArrayList<ElementosTrazas> destino = reqInf.getDestino();
                    Element elemDestino = document.createElement("destino"); //creamos un nuevo elemento
                    for ( int j = 0; j < destino.size(); j++){
                        Text textDestino = document.createTextNode("Destino"); //Ingresamos la info
                        elemDestino.appendChild(textDestino);
                        elemObjeto.appendChild(elemDestino);
                    }

                    //Hacer arbol de ORIGEN
                    ArrayList<ElementosTrazas> origen = reqInf.getOrigen();
                    Element elemOrigen = document.createElement("origen"); //creamos un nuevo elemento
                    for ( int j = 0; j < origen.size(); j++){
                        Text textOrigen = document.createTextNode("Origen"); //Ingresamos la info
                        elemOrigen.appendChild(textOrigen);
                        elemObjeto.appendChild(elemOrigen);
                    }

                    Element comentario = document.createElement("comentario"); //creamos un nuevo elemento
                    Text textComentario = document.createTextNode(reqInf.getComentario()); //Ingresamos la info
                    comentario.appendChild(textComentario);
                    elemObjeto.appendChild(comentario);

                    raiz.appendChild(elemObjeto);
            }

            if(nodo.getUserObject().toString().contains("CRQ-")){
                ArrayList<RequisitoRestriccion> reqRestriccion = this.getElementosTrazas().getRequisitoRestriccion();

                String id = utilidades.getIdentificadorNodo((MutableTreeNode) nodo);

                RequisitoRestriccion reqRes = new RequisitoRestriccion();
                boolean encontrado = false;
                int i = 0;
                while( !encontrado && i < reqRestriccion.size() )
                {
                    if(id.equals(reqRestriccion.get(i).getIdentificacion())){
                        reqRes = reqRestriccion.get(i);
                        encontrado = true;
                    }
                    i++;
                }
                    Element elemObjeto = document.createElement("Objeto"); //creamos un nuevo elemento
                    Element tipo = document.createElement("tipo");
                    tipo.appendChild( document.createTextNode("ReqRestriccion") );
                    elemObjeto.appendChild(tipo);

                    Element identificacion = document.createElement("identificacion"); //creamos un nuevo elemento
                    Text textIdentificacion = document.createTextNode(reqRes.getIdentificacion()); //Ingresamos la info
                    identificacion.appendChild(textIdentificacion);
                    elemObjeto.appendChild(identificacion);

                    Element nombre = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textNombre = document.createTextNode(reqRes.getNombre()); //Ingresamos la info
                    nombre.appendChild(textNombre);
                    elemObjeto.appendChild(nombre);

                    Element version = document.createElement("version"); //creamos un nuevo elemento
                    Text textVersion = document.createTextNode(reqRes.getVersion()); //Ingresamos la info
                    version.appendChild(textVersion);
                    elemObjeto.appendChild(version);

                    Element fecha = document.createElement("fecha"); //creamos un nuevo elemento
                    String cadFecha = formatearFecha(reqRes.getFecha());
                    Text textFecha = document.createTextNode(cadFecha); //Ingresamos la info
                    fecha.appendChild(textFecha);
                    elemObjeto.appendChild(fecha);

                    //Hacer un arbol de AUTORES
                    ArrayList<Participante> autores = reqRes.getAutores();
                    for ( int j = 0; j < autores.size(); j++){
                        Element elemAutores = document.createElement("Autor"); //creamos un nuevo elemento

                        Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionAutor = document.createTextNode(autores.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                        elemAutores.appendChild(elemIdentificacionAutor);

                        elemObjeto.appendChild(elemAutores);
                    }

                    //Hacer un arbol de FUENTES
                    ArrayList<Participante> fuentes = reqRes.getFuentes();
                    for ( int j = 0; j < fuentes.size(); j++){
                        Element elemFuentes = document.createElement("Fuente"); //creamos un nuevo elemento

                        Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionFuente = document.createTextNode(fuentes.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                        elemFuentes.appendChild(elemIdentificacionFuente);

                        elemObjeto.appendChild(elemFuentes);
                    }

                    Element elemDescripcion = document.createElement("descripcion"); //creamos un nuevo elemento
                    Text textDescripcion = document.createTextNode(reqRes.getDescripcion()); //Ingresamos la info
                    elemDescripcion.appendChild(textDescripcion);
                    elemObjeto.appendChild(elemDescripcion);

                    Element elemImportancia = document.createElement("importancia"); //creamos un nuevo elemento
                    Text textImportancia = document.createTextNode(reqRes.getImportancia()); //Ingresamos la info
                    elemImportancia.appendChild(textImportancia);
                    elemObjeto.appendChild(elemImportancia);

                    Element elemUrgencia = document.createElement("urgencia"); //creamos un nuevo elemento
                    Text textUrgencia = document.createTextNode(reqRes.getUrgencia()); //Ingresamos la info
                    elemUrgencia.appendChild(textUrgencia);
                    elemObjeto.appendChild(elemUrgencia);

                    Element elemEstadoDesarrollo = document.createElement("estadoDesarrollo"); //creamos un nuevo elemento
                    Text textEstadoDesarrollo = document.createTextNode(reqRes.getEstadoDesarrollo()); //Ingresamos la info
                    elemEstadoDesarrollo.appendChild(textEstadoDesarrollo);
                    elemObjeto.appendChild(elemEstadoDesarrollo);

                    Element elemEstabilidad = document.createElement("estabilidad"); //creamos un nuevo elemento
                    Text textEstabilidad = document.createTextNode(reqRes.getEstabilidad()); //Ingresamos la info
                    elemEstabilidad.appendChild(textEstabilidad);
                    elemObjeto.appendChild(elemEstabilidad);

                   //Hacer arbol de DESTINO
                    ArrayList<ElementosTrazas> destino = reqRes.getDestino();
                    Element elemDestino = document.createElement("destino"); //creamos un nuevo elemento
                    for ( int j = 0; j < destino.size(); j++){
                        Text textDestino = document.createTextNode("Destino"); //Ingresamos la info
                        elemDestino.appendChild(textDestino);
                        elemObjeto.appendChild(elemDestino);
                    }

                    //Hacer arbol de ORIGEN
                    ArrayList<ElementosTrazas> origen = reqRes.getOrigen();
                    Element elemOrigen = document.createElement("origen"); //creamos un nuevo elemento
                    for ( int j = 0; j < origen.size(); j++){
                        Text textOrigen = document.createTextNode("Origen"); //Ingresamos la info
                        elemOrigen.appendChild(textOrigen);
                        elemObjeto.appendChild(elemOrigen);
                    }

                    Element comentario = document.createElement("comentario"); //creamos un nuevo elemento
                    Text textComentario = document.createTextNode(reqRes.getComentario()); //Ingresamos la info
                    comentario.appendChild(textComentario);
                    elemObjeto.appendChild(comentario);

                    raiz.appendChild(elemObjeto);

            }

            if(nodo.getUserObject().toString().contains("UC-")){

                String id = utilidades.getIdentificadorNodo((MutableTreeNode) nodo);

                EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
                EntityManager em = emf.createEntityManager();
                Query qUni = em.createQuery("SELECT cu FROM CasoUso cu WHERE cu.identificacion = '"+ id +"'");
                CasoUso casoUsoUni = (CasoUso) qUni.getSingleResult();
                casoUsoUni = this.getCasoUso(id);

                Element elemObjeto = document.createElement("Objeto"); //creamos un nuevo elemento
                Element tipo = document.createElement("tipo");
                tipo.appendChild( document.createTextNode("CasoUso") );
                elemObjeto.appendChild(tipo);

                Element elemIdentificacionCU = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionCU = document.createTextNode(casoUsoUni.getIdentificacion()); //Ingresamos la identificacion

                elemIdentificacionCU.appendChild(textIdentificacionCU);
                elemObjeto.appendChild(elemIdentificacionCU);

                Element elemNombreCU = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreCU = document.createTextNode(casoUsoUni.getNombre()); //Ingresamos la info
                elemNombreCU.appendChild(textNombreCU);
                elemObjeto.appendChild(elemNombreCU);

                Element elemVersionCU = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionCU = document.createTextNode(casoUsoUni.getVersion()); //Ingresamos la info
                elemVersionCU.appendChild(textVersionCU);
                elemObjeto.appendChild(elemVersionCU);

                Element elemFechaCU = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaCU = formatearFecha(casoUsoUni.getFecha());
                Text textFechaCU = document.createTextNode(cadenaFechaCU); //Ingresamos la info
                elemFechaCU.appendChild(textFechaCU);
                elemObjeto.appendChild(elemFechaCU);

                //Hacer un arbol de AUTORES
                List<Participante> autoresCU = casoUsoUni.getAutores();
                for ( int j = 0; j < autoresCU.size(); j++){
                    Element elemAutoresCU = document.createElement("Autor");    //creamos un nuevo elemento

                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autoresCU.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutoresCU.appendChild(elemIdentificacionAutor);

                    elemObjeto.appendChild(elemAutoresCU);
                }

                //Hacer un arbol de FUENTES
                List<Participante> fuentesCU = casoUsoUni.getFuentes();
                for ( int j = 0; j < fuentesCU.size(); j++){
                    Element elemFuentesCU = document.createElement("Fuente");   //creamos un nuevo elemento

                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentesCU.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentesCU.appendChild(elemIdentificacionFuente);

                    elemObjeto.appendChild(elemFuentesCU);
                }

                Element elemEsAbstractoCU = document.createElement("esAbstracto"); //creamos un nuevo elemento
                Text textEsAbstractoCU = document.createTextNode(casoUsoUni.getEsAbstracto().toString()); //Ingresamos la info
                elemEsAbstractoCU.appendChild(textEsAbstractoCU);
                elemObjeto.appendChild(elemEsAbstractoCU);

                Element elemEventoActivacionCU = document.createElement("eventoActivacion"); //creamos un nuevo elemento
                Text textEventoActivacionCU = document.createTextNode(casoUsoUni.getEventoActivacion()); //Ingresamos la info
                elemEventoActivacionCU.appendChild(textEventoActivacionCU);
                elemObjeto.appendChild(elemEventoActivacionCU);

                Element elemVecesCU = document.createElement("veces"); //creamos un nuevo elemento
                Text textVecesCU = document.createTextNode(String.valueOf(casoUsoUni.getVeces())); //Ingresamos la info
                elemVecesCU.appendChild(textVecesCU);
                elemObjeto.appendChild(elemVecesCU);

                Element elemUnidadCU = document.createElement("unidad"); //creamos un nuevo elemento
                Text textUnidadCU = document.createTextNode(casoUsoUni.getUnidad()); //Ingresamos la info
                elemUnidadCU.appendChild(textUnidadCU);
                elemObjeto.appendChild(elemUnidadCU);

                Element elemPrecondicionCU = document.createElement("precondicion"); //creamos un nuevo elemento
                Text textPrecondicionCU = document.createTextNode(casoUsoUni.getPrecondicion()); //Ingresamos la info
                elemPrecondicionCU.appendChild(textPrecondicionCU);
                elemObjeto.appendChild(elemPrecondicionCU);

                Element elemPostcondicionCU = document.createElement("postcondicion"); //creamos un nuevo elemento
                Text textPostcondicionCU = document.createTextNode(casoUsoUni.getPostcondicion()); //Ingresamos la info
                elemPostcondicionCU.appendChild(textPostcondicionCU);
                elemObjeto.appendChild(elemPostcondicionCU);

                Element elemImportanciaCU = document.createElement("importancia"); //creamos un nuevo elemento
                Text textImportanciaCU = document.createTextNode(casoUsoUni.getImportancia()); //Ingresamos la info
                elemImportanciaCU.appendChild(textImportanciaCU);
                elemObjeto.appendChild(elemImportanciaCU);

                Element elemUrgenciaCU = document.createElement("urgencia"); //creamos un nuevo elemento
                Text textUrgenciaCU = document.createTextNode(casoUsoUni.getUrgencia()); //Ingresamos la info
                elemUrgenciaCU.appendChild(textUrgenciaCU);
                elemObjeto.appendChild(elemUrgenciaCU);

                Element elemEstadoDesarrolloCU = document.createElement("estadoDesarrollo"); //creamos un nuevo elemento
                Text textEstadoDesarrolloCU = document.createTextNode(casoUsoUni.getEstadoDesarrollo()); //Ingresamos la info
                elemEstadoDesarrolloCU.appendChild(textEstadoDesarrolloCU);
                elemObjeto.appendChild(elemEstadoDesarrolloCU);

                Element elemEstabilidadCU = document.createElement("estabilidad"); //creamos un nuevo elemento
                Text textEstabilidadCU = document.createTextNode(casoUsoUni.getEstabilidad()); //Ingresamos la info
                elemEstabilidadCU.appendChild(textEstabilidadCU);
                elemObjeto.appendChild(elemEstabilidadCU);

                //Hacer arbol de DESTINO
                List<ElementosTrazas> destinoCU = casoUsoUni.getDestino();
                Element elemDestinoCU = document.createElement("destino"); //creamos un nuevo elemento
                for ( int j = 0; j < destinoCU.size(); j++){
                    Text textDestinoCU = document.createTextNode("Destino"); //Ingresamos la info
                    elemDestinoCU.appendChild(textDestinoCU);
                    elemObjeto.appendChild(elemDestinoCU);
                }

                //Hacer arbol de ORIGEN
                List<ElementosTrazas> origenCU = casoUsoUni.getOrigen();
                Element elemOrigenCU = document.createElement("origen"); //creamos un nuevo elemento
                for ( int j = 0; j < origenCU.size(); j++){
                    Text textOrigenCU = document.createTextNode("Origen"); //Ingresamos la info
                    elemOrigenCU.appendChild(textOrigenCU);
                    elemObjeto.appendChild(elemOrigenCU);
                }

                // Árbol de PASOS
                Query qPasos = em.createQuery("SELECT p FROM Paso p WHERE p.mCasoUso.identificacion = '"+ id +"'");
                List<Paso> pasos = (List<Paso>) qPasos.getResultList();

                for ( int j = 0; j < pasos.size(); j++){
                    Element elemPasos = document.createElement("Paso"); //creamos un nuevo elemento

                    Element elemIdentificacionPaso = document.createElement("identificacion"); //creamos un nuevo elemento
                    Text textPaso = document.createTextNode(pasos.get(j).getIdentificacion()); //Ingresamos la info
                    elemIdentificacionPaso.appendChild(textPaso);
                    elemPasos.appendChild(elemIdentificacionPaso);

                    Element elemNombrePaso = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textNombrePaso = document.createTextNode(pasos.get(j).getNombre()); //Ingresamos la info
                    elemNombrePaso.appendChild(textNombrePaso);
                    elemPasos.appendChild(elemNombrePaso);

                    Element elemesCondicionalP = document.createElement("esCondicional"); //creamos un nuevo elemento
                    Text textesCondicionalP = document.createTextNode(pasos.get(j).getEsCondicional().toString()); //Ingresamos la info
                    elemesCondicionalP.appendChild(textesCondicionalP);
                    elemPasos.appendChild(elemesCondicionalP);

                    Element elemCondicionPaso = document.createElement("condicion"); //creamos un nuevo elemento
                    Text textCondicionPaso = document.createTextNode(pasos.get(j).getCondicion()); //Ingresamos la info
                    elemCondicionPaso.appendChild(textCondicionPaso);
                    elemPasos.appendChild(elemCondicionPaso);

                    Element elemAccionSistemaPaso = document.createElement("accionSistema"); //creamos un nuevo elemento
                    Text textAccionSistemaPaso = document.createTextNode(pasos.get(j).getAccionSistema().toString()); //Ingresamos la info
                    elemAccionSistemaPaso.appendChild(textAccionSistemaPaso);
                    elemPasos.appendChild(elemAccionSistemaPaso);

                    Element elemAccionActorPaso = document.createElement("accionActor"); //creamos un nuevo elemento
                    Text textAccionActorPaso = document.createTextNode(pasos.get(j).getAccionActor().toString()); //Ingresamos la info
                    elemAccionActorPaso.appendChild(textAccionActorPaso);
                    elemPasos.appendChild(elemAccionActorPaso);

                    Element elemInclusionExtPaso = document.createElement("inclusionExtension"); //creamos un nuevo elemento
                    Text textInclusionExtPaso = document.createTextNode(pasos.get(j).getInclusionExtension().toString()); //Ingresamos la info
                    elemInclusionExtPaso.appendChild(textInclusionExtPaso);
                    elemPasos.appendChild(elemInclusionExtPaso);

                    Element elemAccionPaso = document.createElement("accion"); //creamos un nuevo elemento
                    Text textAccionPaso = document.createTextNode(pasos.get(j).getDescripcionAccion()); //Ingresamos la info
                    elemAccionPaso.appendChild(textAccionPaso);
                    elemPasos.appendChild(elemAccionPaso);

                    Element elemValorRendPaso = document.createElement("valorRendimiento"); //creamos un nuevo elemento
                    Text textValorRendPaso = document.createTextNode(String.valueOf(pasos.get(j).getValorRendimiento())); //Ingresamos la info
                    elemValorRendPaso.appendChild(textValorRendPaso);
                    elemPasos.appendChild(elemValorRendPaso);

                    Element elemUnidadRendPaso = document.createElement("unidadRendimiento"); //creamos un nuevo elemento
                    Text textUnidadRendPaso = document.createTextNode(pasos.get(j).getUnidadRendimiento()); //Ingresamos la info
                    elemUnidadRendPaso.appendChild(textUnidadRendPaso);
                    elemPasos.appendChild(elemUnidadRendPaso);

                    Element elemComentarioPaso = document.createElement("comentario"); //creamos un nuevo elemento
                    Text texComentarioPaso = document.createTextNode(pasos.get(j).getUnidadRendimiento()); //Ingresamos la info
                    elemComentarioPaso.appendChild(texComentarioPaso);
                    elemPasos.appendChild(elemComentarioPaso);

                    //Buscamos las excepciones
                    Query qExcepciones = em.createQuery("SELECT e FROM Excepcion e WHERE e.mPaso.identificacion = '"+ pasos.get(j).getIdentificacion() +"'" +
                                                        " AND e.mPaso.mCasoUso.identificacion = '"+ id +"'");
                    List<Excepcion> excepciones = (List<Excepcion>) qExcepciones.getResultList();

                    for ( int k = 0; k < excepciones.size(); k++){
                        Element elemExcepcion = document.createElement("Excepcion"); //creamos un nuevo elemento

                        Element elemIdentificacionExcepcion = document.createElement("identificacion"); //creamos un nuevo elemento
                        Text textExcepcion = document.createTextNode(excepciones.get(k).getIdentificacion()); //Ingresamos la info
                        elemIdentificacionExcepcion.appendChild(textExcepcion);
                        elemExcepcion.appendChild(elemIdentificacionExcepcion);

                        Element elemNombreExcepcion = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textNombreExcepcion = document.createTextNode(excepciones.get(k).getNombre()); //Ingresamos la info
                        elemNombreExcepcion.appendChild(textNombreExcepcion);
                        elemExcepcion.appendChild(elemNombreExcepcion);

                        Element elemCondicionExcepcion = document.createElement("condicion"); //creamos un nuevo elemento
                        Text textCondicionExcepcion = document.createTextNode(excepciones.get(k).getCondicion()); //Ingresamos la info
                        elemCondicionExcepcion.appendChild(textCondicionExcepcion);
                        elemExcepcion.appendChild(elemCondicionExcepcion);

                        Element elemAccionSistemaExcepcion = document.createElement("accionSistema"); //creamos un nuevo elemento
                        Text textAccionSistemaExcepcion = document.createTextNode(excepciones.get(k).getAccionSistema().toString()); //Ingresamos la info
                        elemAccionSistemaExcepcion.appendChild(textAccionSistemaExcepcion);
                        elemExcepcion.appendChild(elemAccionSistemaExcepcion);

                        Element elemAccionActorExcepcion = document.createElement("accionActor"); //creamos un nuevo elemento
                        Text textAccionActorExcepcion = document.createTextNode(excepciones.get(k).getAccionActor().toString()); //Ingresamos la info
                        elemAccionActorExcepcion.appendChild(textAccionActorExcepcion);
                        elemExcepcion.appendChild(elemAccionActorExcepcion);

                        Element elemInclusionExtExcepcion = document.createElement("inclusionExtension"); //creamos un nuevo elemento
                        Text textInclusionExtExcepcion = document.createTextNode(excepciones.get(k).getInclusionExtension().toString()); //Ingresamos la info
                        elemInclusionExtExcepcion.appendChild(textInclusionExtExcepcion);
                        elemExcepcion.appendChild(elemInclusionExtExcepcion);

                        Element elemAccionExcepcion = document.createElement("accion"); //creamos un nuevo elemento
                        Text textAccionExcepcion = document.createTextNode(excepciones.get(k).getDescripcionAccion());//Ingresamos la info
                        elemAccionExcepcion.appendChild(textAccionExcepcion);
                        elemExcepcion.appendChild(elemAccionExcepcion);

                        Element elemValorRendExcepcion = document.createElement("valorRendimiento"); //creamos un nuevo elemento
                        Text textValorRendExcepcion = document.createTextNode(String.valueOf(excepciones.get(k).getValorRendimiento())); //Ingresamos la info
                        elemValorRendExcepcion.appendChild(textValorRendExcepcion);
                        elemExcepcion.appendChild(elemValorRendExcepcion);

                        Element elemUnidadRendExcepcion = document.createElement("unidadRendimiento"); //creamos un nuevo elemento
                        Text textUnidadRendExcepcion = document.createTextNode(excepciones.get(k).getUnidadRendimiento()); //Ingresamos la info
                        elemUnidadRendExcepcion.appendChild(textUnidadRendExcepcion);
                        elemExcepcion.appendChild(elemUnidadRendExcepcion);

                        Element elemComentarioExcepcion = document.createElement("comentario"); //creamos un nuevo elemento
                        Text texComentarioExcepcion = document.createTextNode(excepciones.get(k).getUnidadRendimiento()); //Ingresamos la info
                        elemComentarioExcepcion.appendChild(texComentarioExcepcion);
                        elemExcepcion.appendChild(elemComentarioExcepcion);

                        elemPasos.appendChild(elemExcepcion);
                    }
                    elemObjeto.appendChild(elemPasos);
                }

                Element elemComentarioCU = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioCU = document.createTextNode(casoUsoUni.getComentario()); //Ingresamos la info
                elemComentarioCU.appendChild(textComentarioCU);
                elemObjeto.appendChild(elemComentarioCU);

                raiz.appendChild(elemObjeto); //pegamos el elemento hijo a la raiz
            }            

            if(nodo.getUserObject().toString().contains("FRQ-")){
                ArrayList<RequisitoFuncional> reqFuncional = this.getElementosTrazas().getRequisitoFuncional();
                String id = utilidades.getIdentificadorNodo((MutableTreeNode) nodo);

                RequisitoFuncional reqFun = new RequisitoFuncional();
                boolean encontrado = false;
                int i = 0;
                while( !encontrado && i < reqFuncional.size() )
                {
                    if(id.equals(reqFuncional.get(i).getIdentificacion())){
                        reqFun = reqFuncional.get(i);
                        encontrado = true;
                    }
                    i++;
                }
                    Element elemObjeto = document.createElement("Objeto"); //creamos un nuevo elemento
                    Element tipo = document.createElement("tipo");
                    tipo.appendChild( document.createTextNode("ReqFuncional") );
                    elemObjeto.appendChild(tipo);

                    Element identificacion = document.createElement("identificacion"); //creamos un nuevo elemento
                    Text textIdentificacion = document.createTextNode(reqFun.getIdentificacion()); //Ingresamos la info
                    identificacion.appendChild(textIdentificacion);
                    elemObjeto.appendChild(identificacion);

                    Element nombre = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textNombre = document.createTextNode(reqFun.getNombre()); //Ingresamos la info
                    nombre.appendChild(textNombre);
                    elemObjeto.appendChild(nombre);

                    Element version = document.createElement("version"); //creamos un nuevo elemento
                    Text textVersion = document.createTextNode(reqFun.getVersion()); //Ingresamos la info
                    version.appendChild(textVersion);
                    elemObjeto.appendChild(version);

                    Element fecha = document.createElement("fecha"); //creamos un nuevo elemento
                    String cadFecha = formatearFecha(reqFun.getFecha());
                    Text textFecha = document.createTextNode(cadFecha); //Ingresamos la info
                    fecha.appendChild(textFecha);
                    elemObjeto.appendChild(fecha);

                    //Hacer un arbol de AUTORES
                    ArrayList<Participante> autores = reqFun.getAutores();
                    for ( int j = 0; j < autores.size(); j++){
                        Element elemAutores = document.createElement("Autor"); //creamos un nuevo elemento

                        Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionAutor = document.createTextNode(autores.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                        elemAutores.appendChild(elemIdentificacionAutor);

                        elemObjeto.appendChild(elemAutores);
                    }

                    //Hacer un arbol de FUENTES
                    ArrayList<Participante> fuentes = reqFun.getFuentes();
                    for ( int j = 0; j < fuentes.size(); j++){
                        Element elemFuentes = document.createElement("Fuente"); //creamos un nuevo elemento

                        Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionFuente = document.createTextNode(fuentes.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                        elemFuentes.appendChild(elemIdentificacionFuente);

                        elemObjeto.appendChild(elemFuentes);
                    }

                    Element elemDescripcion = document.createElement("texto"); //creamos un nuevo elemento
                    Text textDescripcion = document.createTextNode(reqFun.getTexto()); //Ingresamos la info
                    elemDescripcion.appendChild(textDescripcion);
                    elemObjeto.appendChild(elemDescripcion);

                    Element elemImportancia = document.createElement("importancia"); //creamos un nuevo elemento
                    Text textImportancia = document.createTextNode(reqFun.getImportancia()); //Ingresamos la info
                    elemImportancia.appendChild(textImportancia);
                    elemObjeto.appendChild(elemImportancia);

                    Element elemUrgencia = document.createElement("urgencia"); //creamos un nuevo elemento
                    Text textUrgencia = document.createTextNode(reqFun.getUrgencia()); //Ingresamos la info
                    elemUrgencia.appendChild(textUrgencia);
                    elemObjeto.appendChild(elemUrgencia);

                    Element elemEstadoDesarrollo = document.createElement("estadoDesarrollo"); //creamos un nuevo elemento
                    Text textEstadoDesarrollo = document.createTextNode(reqFun.getEstadoDesarrollo()); //Ingresamos la info
                    elemEstadoDesarrollo.appendChild(textEstadoDesarrollo);
                    elemObjeto.appendChild(elemEstadoDesarrollo);

                    Element elemEstabilidad = document.createElement("estabilidad"); //creamos un nuevo elemento
                    Text textEstabilidad = document.createTextNode(reqFun.getEstabilidad()); //Ingresamos la info
                    elemEstabilidad.appendChild(textEstabilidad);
                    elemObjeto.appendChild(elemEstabilidad);

                   //Hacer arbol de DESTINO
                    ArrayList<ElementosTrazas> destino = reqFun.getDestino();
                    Element elemDestino = document.createElement("destino"); //creamos un nuevo elemento
                    for ( int j = 0; j < destino.size(); j++){
                        Text textDestino = document.createTextNode("Destino"); //Ingresamos la info
                        elemDestino.appendChild(textDestino);
                        elemObjeto.appendChild(elemDestino);
                    }

                    //Hacer arbol de ORIGEN
                    ArrayList<ElementosTrazas> origen = reqFun.getOrigen();
                    Element elemOrigen = document.createElement("origen"); //creamos un nuevo elemento
                    for ( int j = 0; j < origen.size(); j++){
                        Text textOrigen = document.createTextNode("Origen"); //Ingresamos la info
                        elemOrigen.appendChild(textOrigen);
                        elemObjeto.appendChild(elemOrigen);
                    }

                    Element comentario = document.createElement("comentario"); //creamos un nuevo elemento
                    Text textComentario = document.createTextNode(reqFun.getComentario()); //Ingresamos la info
                    comentario.appendChild(textComentario);
                    elemObjeto.appendChild(comentario);

                    raiz.appendChild(elemObjeto);
            }

            if(nodo.getUserObject().toString().contains("NFR-")){
                ArrayList<RequisitoNoFuncional> reqNoFuncional = this.getElementosTrazas().getRequisitoNoFuncional();
                String id = utilidades.getIdentificadorNodo((MutableTreeNode) nodo);

                RequisitoNoFuncional reqNoFun = new RequisitoNoFuncional();
                boolean encontrado = false;
                int i = 0;
                while( !encontrado && i < reqNoFuncional.size() )
                {
                    if(id.equals(reqNoFuncional.get(i).getIdentificacion())){
                        reqNoFun = reqNoFuncional.get(i);
                        encontrado = true;
                    }
                    i++;
                }
                    Element elemObjeto = document.createElement("Objeto"); //creamos un nuevo elemento
                    Element tipo = document.createElement("tipo");
                    tipo.appendChild( document.createTextNode("ReqNoFuncional") );
                    elemObjeto.appendChild(tipo);

                    Element identificacion = document.createElement("identificacion"); //creamos un nuevo elemento
                    Text textIdentificacion = document.createTextNode(reqNoFun.getIdentificacion()); //Ingresamos la info
                    identificacion.appendChild(textIdentificacion);
                    elemObjeto.appendChild(identificacion);

                    Element nombre = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textNombre = document.createTextNode(reqNoFun.getNombre()); //Ingresamos la info
                    nombre.appendChild(textNombre);
                    elemObjeto.appendChild(nombre);

                    Element version = document.createElement("version"); //creamos un nuevo elemento
                    Text textVersion = document.createTextNode(reqNoFun.getVersion()); //Ingresamos la info
                    version.appendChild(textVersion);
                    elemObjeto.appendChild(version);

                    Element fecha = document.createElement("fecha"); //creamos un nuevo elemento
                    String cadFecha = formatearFecha(reqNoFun.getFecha());
                    Text textFecha = document.createTextNode(cadFecha); //Ingresamos la info
                    fecha.appendChild(textFecha);
                    elemObjeto.appendChild(fecha);

                    //Hacer un arbol de AUTORES
                    ArrayList<Participante> autores = reqNoFun.getAutores();
                    for ( int j = 0; j < autores.size(); j++){
                        Element elemAutores = document.createElement("Autor"); //creamos un nuevo elemento

                        Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionAutor = document.createTextNode(autores.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                        elemAutores.appendChild(elemIdentificacionAutor);

                        elemObjeto.appendChild(elemAutores);
                    }

                    //Hacer un arbol de FUENTES
                    ArrayList<Participante> fuentes = reqNoFun.getFuentes();
                    for ( int j = 0; j < fuentes.size(); j++){
                        Element elemFuentes = document.createElement("Fuente"); //creamos un nuevo elemento

                        Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionFuente = document.createTextNode(fuentes.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                        elemFuentes.appendChild(elemIdentificacionFuente);

                        elemObjeto.appendChild(elemFuentes);
                    }

                    Element elemDescripcion = document.createElement("texto"); //creamos un nuevo elemento
                    Text textDescripcion = document.createTextNode(reqNoFun.getTexto()); //Ingresamos la info
                    elemDescripcion.appendChild(textDescripcion);
                    elemObjeto.appendChild(elemDescripcion);

                    Element elemImportancia = document.createElement("importancia"); //creamos un nuevo elemento
                    Text textImportancia = document.createTextNode(reqNoFun.getImportancia()); //Ingresamos la info
                    elemImportancia.appendChild(textImportancia);
                    elemObjeto.appendChild(elemImportancia);

                    Element elemUrgencia = document.createElement("urgencia"); //creamos un nuevo elemento
                    Text textUrgencia = document.createTextNode(reqNoFun.getUrgencia()); //Ingresamos la info
                    elemUrgencia.appendChild(textUrgencia);
                    elemObjeto.appendChild(elemUrgencia);

                    Element elemEstadoDesarrollo = document.createElement("estadoDesarrollo"); //creamos un nuevo elemento
                    Text textEstadoDesarrollo = document.createTextNode(reqNoFun.getEstadoDesarrollo()); //Ingresamos la info
                    elemEstadoDesarrollo.appendChild(textEstadoDesarrollo);
                    elemObjeto.appendChild(elemEstadoDesarrollo);

                    Element elemEstabilidad = document.createElement("estabilidad"); //creamos un nuevo elemento
                    Text textEstabilidad = document.createTextNode(reqNoFun.getEstabilidad()); //Ingresamos la info
                    elemEstabilidad.appendChild(textEstabilidad);
                    elemObjeto.appendChild(elemEstabilidad);

                   //Hacer arbol de DESTINO
                    ArrayList<ElementosTrazas> destino = reqNoFun.getDestino();
                    Element elemDestino = document.createElement("destino"); //creamos un nuevo elemento
                    for ( int j = 0; j < destino.size(); j++){
                        Text textDestino = document.createTextNode("Destino"); //Ingresamos la info
                        elemDestino.appendChild(textDestino);
                        elemObjeto.appendChild(elemDestino);
                    }

                    //Hacer arbol de ORIGEN
                    ArrayList<ElementosTrazas> origen = reqNoFun.getOrigen();
                    Element elemOrigen = document.createElement("origen"); //creamos un nuevo elemento
                    for ( int j = 0; j < origen.size(); j++){
                        Text textOrigen = document.createTextNode("Origen"); //Ingresamos la info
                        elemOrigen.appendChild(textOrigen);
                        elemObjeto.appendChild(elemOrigen);
                    }

                    Element comentario = document.createElement("comentario"); //creamos un nuevo elemento
                    Text textComentario = document.createTextNode(reqNoFun.getComentario()); //Ingresamos la info
                    comentario.appendChild(textComentario);
                    elemObjeto.appendChild(comentario);

                    raiz.appendChild(elemObjeto);
            }

            if(nodo.getUserObject().toString().contains("TRM-")){
                ArrayList<MatrizRastreabilidad> matrizRastreabilidad = this.getMatrizRastreabilidad();
                String id = utilidades.getIdentificadorNodo((MutableTreeNode) nodo);

                MatrizRastreabilidad matrizRas = new MatrizRastreabilidad();
                boolean encontrado = false;
                int i = 0;
                while( !encontrado && i < matrizRastreabilidad.size() )
                {
                    if(id.equals(matrizRastreabilidad.get(i).getIdentificacion())){
                        matrizRas = matrizRastreabilidad.get(i);
                        encontrado = true;
                    }
                    i++;
                }
                    Element elemObjeto = document.createElement("Objeto"); //creamos un nuevo elemento
                    Element tipo = document.createElement("tipo");
                    tipo.appendChild( document.createTextNode("ReqInformacion") );
                    elemObjeto.appendChild(tipo);

                    Element identificacion = document.createElement("identificacion"); //creamos un nuevo elemento
                    Text textIdentificacion = document.createTextNode(matrizRas.getIdentificacion()); //Ingresamos la info
                    identificacion.appendChild(textIdentificacion);
                    elemObjeto.appendChild(identificacion);

                    Element nombre = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textNombre = document.createTextNode(matrizRas.getNombre()); //Ingresamos la info
                    nombre.appendChild(textNombre);
                    elemObjeto.appendChild(nombre);

                    Element version = document.createElement("version"); //creamos un nuevo elemento
                    Text textVersion = document.createTextNode(matrizRas.getVersion()); //Ingresamos la info
                    version.appendChild(textVersion);
                    elemObjeto.appendChild(version);

                    Element fecha = document.createElement("fecha"); //creamos un nuevo elemento
                    String cadFecha = formatearFecha(matrizRas.getFecha());
                    Text textFecha = document.createTextNode(cadFecha); //Ingresamos la info
                    fecha.appendChild(textFecha);
                    elemObjeto.appendChild(fecha);

                    //Hacer un arbol de AUTORES
                    ArrayList<Participante> autores = matrizRas.getAutores();
                    for ( int j = 0; j < autores.size(); j++){
                        Element elemAutores = document.createElement("Autor"); //creamos un nuevo elemento

                        Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionAutor = document.createTextNode(autores.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                        elemAutores.appendChild(elemIdentificacionAutor);

                        elemObjeto.appendChild(elemAutores);
                    }

                    //Hacer un arbol de FUENTES
                    ArrayList<Participante> fuentes = matrizRas.getFuentes();
                    for ( int j = 0; j < fuentes.size(); j++){
                        Element elemFuentes = document.createElement("Fuente"); //creamos un nuevo elemento

                        Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                        Text textIdentificacionFuente = document.createTextNode(fuentes.get(j).getNombre()); //Ingresamos la info
                        elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                        elemFuentes.appendChild(elemIdentificacionFuente);

                        elemObjeto.appendChild(elemFuentes);
                    }
                    
                    Element comentario = document.createElement("comentario"); //creamos un nuevo elemento
                    Text textComentario = document.createTextNode(matrizRas.getComentario()); //Ingresamos la info
                    comentario.appendChild(textComentario);
                    elemObjeto.appendChild(comentario);

                    raiz.appendChild(elemObjeto);
                
            }
  
       
            Source source = new DOMSource(document);


            Result console= new StreamResult(System.out);
            try {
                Transformer transformer = TransformerFactory.newInstance().newTransformer();
                transformer.transform(source, result);
                transformer.transform(source, console);

            } catch(Exception e) {
                System.out.println(e);
            }
            
    }
    
    public String formatearFecha (Date f) {
        // Pasamos la fecha a formato corto
        SimpleDateFormat formatearFecha = new SimpleDateFormat("dd/MM/yyyy");
        String cadenaFecha = formatearFecha.format(f);
        return (cadenaFecha);
    }
    
    public static List getCasoUsoBD (String identificador) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        List lista = emf.createEntityManager().createQuery("SELECT cu FROM CasoUso cu WHERE cu.identificacion = '"+ identificador +"'").getResultList();
        
        return lista;
    }

    public void persist(Object object) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();
        
        try {
            em.persist(object);
            em.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
    }

    public void refreshRemoveCasoUso(int eleccion, CasoUso casoUso) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();

        try {
            if (eleccion == 1) {                                                // Refresh
                CasoUso cu = em.find(CasoUso.class, casoUso.getIdentificacion());
                cu.setVersion(casoUso.getVersion());
                cu.setFecha(casoUso.getFecha());
                cu.setEventoActivacion(casoUso.getEventoActivacion());
                cu.setEsAbstracto(casoUso.getEsAbstracto());
                cu.setVeces(casoUso.getVeces());
                cu.setUnidad(casoUso.getUnidad());
                cu.setPrecondicion(casoUso.getPrecondicion());
                cu.setPostcondicion(casoUso.getPostcondicion());
                cu.setImportancia(casoUso.getImportancia());
                cu.setEstadoDesarrollo(casoUso.getEstadoDesarrollo());
                cu.setUrgencia(casoUso.getUrgencia());
                cu.setEstabilidad(casoUso.getEstabilidad());
                cu.setComentario(casoUso.getComentario());
            }
            else if (eleccion == 2) {                                           // Remove
                Query q = em.createQuery("SELECT cu FROM CasoUso cu WHERE cu.identificacion = '"+ casoUso.getIdentificacion() +"'");
                CasoUso cu = (CasoUso) q.getSingleResult();
                em.remove(cu);
            }
            em.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
    }

    public void refreshRemoveCasoUsoPaso(int eleccion, Paso paso) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();

        try {
            if (eleccion == 1) {                                                // Refresh
                Query q = em.createQuery("SELECT p FROM Paso p WHERE p.identificacion = '"+ paso.getIdentificacion() +
                                         "' AND p.mCasoUso.identificacion = '"+ paso.getMCasoUso().getIdentificacion() +"'");
                int idTabla = ((Paso)q.getSingleResult()).getIdTabla();
                Paso p = em.find(Paso.class, idTabla);
                p.setEsCondicional(paso.getEsCondicional());
                p.setCondicion(paso.getCondicion());
                p.setAccionSistema(paso.getAccionSistema());
                p.setAccionActor(paso.getAccionActor());
                p.setInclusionExtension(paso.getInclusionExtension());
                p.setActor(paso.getActor());
                p.setCasoUso(paso.getCasoUso());
                p.setDescripcionAccion(paso.getDescripcionAccion());
                p.setValorRendimiento(paso.getValorRendimiento());
                p.setUnidadRendimiento(paso.getUnidadRendimiento());
                p.setComentario(paso.getComentario());
                p.setExcepcion(paso.getExcepcion());
                p.setMCasoUso(paso.getMCasoUso());
                p.setNombre(paso.getNombre());
            }
            else if (eleccion == 2) {                                           // Remove
                Query q = em.createQuery("SELECT p FROM Paso p WHERE p.identificacion = '"+ paso.getIdentificacion() +
                                         "' AND p.mCasoUso.identificacion = '"+ paso.getMCasoUso().getIdentificacion() +"'");
                Paso p = (Paso) q.getSingleResult();
                em.remove(p);
            }
            em.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
    }

    public void refreshRemoveCasoUsoExcepcion(int eleccion, Excepcion excepcion) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();

        try {
            if (eleccion == 1) {                                                // Refresh
                Query q = em.createQuery("SELECT e FROM Excepcion e WHERE e.identificacion = '"+ excepcion.getIdentificacion() +
                                 "' AND e.mPaso.identificacion = '"+ excepcion.getMPaso().getIdentificacion() +
                                 "' AND e.mPaso.mCasoUso.identificacion = '"+ excepcion.getMPaso().getMCasoUso().getIdentificacion() +"'");
                int idTabla = ((Excepcion)q.getSingleResult()).getIdTabla();
                Excepcion e = em.find(Excepcion.class, idTabla);
                e.setCondicion(excepcion.getCondicion());
                e.setTerminacion(excepcion.getTerminacion());
                e.setAccionSistema(excepcion.getAccionSistema());
                e.setAccionActor(excepcion.getAccionActor());
                e.setInclusionExtension(excepcion.getInclusionExtension());
                e.setActor(excepcion.getActor());
                e.setCasoUso(excepcion.getCasoUso());
                e.setDescripcionAccion(excepcion.getDescripcionAccion());
                e.setValorRendimiento(excepcion.getValorRendimiento());
                e.setUnidadRendimiento(excepcion.getUnidadRendimiento());
                e.setComentario(excepcion.getComentario());
                e.setMPaso(excepcion.getMPaso());
                e.setNombre(excepcion.getNombre());
            }
            else if (eleccion == 2) {                                           // Remove
                Query q = em.createQuery("SELECT e FROM Excepcion e WHERE e.identificacion = '"+ excepcion.getIdentificacion() +
                                 "' AND e.mPaso.identificacion = '"+ excepcion.getMPaso().getIdentificacion() +
                                 "' AND e.mPaso.mCasoUso.identificacion = '"+ excepcion.getMPaso().getMCasoUso().getIdentificacion() +"'");
                Excepcion e = (Excepcion) q.getSingleResult();
                em.remove(e);
            }
            em.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
    }

    public void eliminarActorPasos(String identificador){
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();

        try {
                // Refresh
                Query q = em.createQuery("SELECT p FROM Paso p WHERE p.accionActor = '1'" +
                                         " AND p.actor = '" + identificador + "'");

                List<Paso> pasos = q.getResultList();
                for(int i = 0; i < pasos.size(); i++)
                {
                    int idTabla = pasos.get(i).getIdTabla();
                    Paso p = em.find(Paso.class, idTabla);
                    p.setAccionActor(false);
                    p.setAccionSistema(true);
                    p.setActor("");

                    p.setNombre("");
                    if (p.getEsCondicional()) {
                        p.setNombre("Si " + p.getCondicion() +", " );
  
                    }
                    p.setNombre(p.getNombre() + "el sistema "
                    + p.getDescripcionAccion() + " ");
                }

            em.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
    }

        public void eliminarCUPasos(String identificador){
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();

        try {
                // Refresh
                Query q = em.createQuery("SELECT p FROM Paso p WHERE p.inclusionExtension = '1'" +
                                         " AND p.casoUso = '" + identificador + "'");

                List<Paso> pasos = q.getResultList();
                for(int i = 0; i < pasos.size(); i++)
                {
                    int idTabla = pasos.get(i).getIdTabla();
                    Paso p = em.find(Paso.class, idTabla);
                    p.setInclusionExtension(false);
                    p.setAccionSistema(true);
                    p.setActor("");

                    p.setNombre("");
                    if (p.getEsCondicional()) {
                        p.setNombre("Si " + p.getCondicion() +", " );

                    }
                    p.setNombre(p.getNombre() + "el sistema "
                    + p.getDescripcionAccion() + " ");
                }

            em.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
    }

    public void eliminarActorExcepciones(String identificador){
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();

        try {
                // Refresh
                Query q = em.createQuery("SELECT e FROM Excepcion e WHERE e.accionActor = '1'" +
                                         " AND e.actor = '" + identificador + "'");

                List<Excepcion> excepcion = q.getResultList();
                for(int i = 0; i < excepcion.size(); i++)
                {
                    int idTabla = excepcion.get(i).getIdTabla();
                    Excepcion exc = em.find(Excepcion.class, idTabla);
                    exc.setAccionActor(false);
                    exc.setAccionSistema(true);
                    exc.setActor("");
                    exc.setNombre("");

                    exc.setNombre("Si " + exc.getCondicion() +", " + "el sistema "
                                + exc.getDescripcionAccion() + " ");

                }

            em.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
    }

    public void eliminarCUExcepciones(String identificador){
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("AZETA_REMPU");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();

        try {
                // Refresh
                Query q = em.createQuery("SELECT e FROM Excepcion e WHERE e.inclusionExtension = '1'" +
                                         " AND e.casoUso = '" + identificador + "'");

                List<Excepcion> excepcion = q.getResultList();
                for(int i = 0; i < excepcion.size(); i++)
                {
                    int idTabla = excepcion.get(i).getIdTabla();
                    Excepcion exc = em.find(Excepcion.class, idTabla);
                    exc.setInclusionExtension(false);
                    exc.setAccionSistema(true);
                    exc.setActor("");
                    exc.setNombre("");

                    exc.setNombre("Si " + exc.getCondicion() +", " + "el sistema "
                                + exc.getDescripcionAccion() + " ");

                }

            em.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
    }
}
