path: root/EjercitarServer/ejbModule/beans/AdministracionBean.java

package beans;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.ejb.LocalBean;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import smile.Network;

import model.Alumno;
import model.Asignatura;
import model.Concepto;
import model.Curso;
import model.Ejercicio;
import model.Profesor;
import model.Sesion;
import model.Tarea;
import model.Tema;

/**
 * Session Bean implementation class AdministracionBean
 */
@Stateless
@LocalBean
public class AdministracionBean implements AdministracionBeanRemote, AdministracionBeanLocal {
	
	@PersistenceContext 
    EntityManager em;

    /**
     * Default constructor. 
     */
    public AdministracionBean() {
        // TODO Auto-generated constructor stub
    }
    
    public List getConceptoList(int idTema) {
    	Tema tema = em.find(Tema.class, idTema);
    	List conceptoList = tema.getConceptoList();
    	System.out.println(conceptoList.toString());
    	return conceptoList;
    }
    
    public void agregarEjercicio(Ejercicio ejercicio) {
    	//Poner en una transaccion
    	// em.getTransaction().begin();
    	em.persist(ejercicio);
    	agregarEjercicioRed(ejercicio);   	
    	//em.getTransaction().commit();
    }
    
    public void agregarTema(Tema tema) {
    	
    	em.persist(tema);
    	agregarTemaRed(tema);   	
    	
    }
    
    public void editarTema(Tema tema){
    	em.merge(tema);
    	//falta actualizar red
    }
    
    public void eliminarTema(int idTema) {
    	Tema tema = em.find(Tema.class, idTema);
    	
    	for(Concepto concepto : tema.getConceptoList()) {
    		eliminarConcepto(concepto.getIdConcepto());
    	}
    	
    	em.remove(tema);
    	eliminarTemaRed(tema);
    }
    
    private void eliminarTemaRed(Tema tema) {
		// TODO Auto-generated method stub
    	String nombreRed = "red_base_curso_1.xdsl";
    	Network net = new Network();
		net.readFile("redes/" + nombreRed);
		net.deleteNode(tema.getNombre());
		net.writeFile("redes/" + nombreRed);
	}

	public void agregarConcepto(Concepto concepto) {
    	//Poner en una transaccion
    	em.persist(concepto);
    	agregarConceptoRed(concepto);   	
    	
    }
    
    public void editarConcepto(Concepto concepto) {
    	em.merge(concepto);
    	//falta actualizar red
    }
    
    public void eliminarConcepto(int idConcepto) {
    	Concepto concepto = em.find(Concepto.class, idConcepto);
    	em.remove(concepto);
    	eliminarConceptoRed(concepto);
    }
    
    
    
    private void eliminarConceptoRed(Concepto concepto) {
		// TODO Auto-generated method stub\
    	String nombreRed = "red_asignatura_" + 1 + ".xdsl";
    	Network net = new Network();
		net.readFile("redes/" + nombreRed);
		net.deleteNode(concepto.getNombre());
		net.writeFile("redes/" + nombreRed);
		
	}

	public void agregarProfesor(Profesor profesor) {
    	em.persist(profesor);
    }
    public void agregarAsignatura(Asignatura asignatura) {
 
    	em.persist(asignatura);
    	Network net = new Network();
    	String nombreRed = "red_asignatura_" + asignatura.getIdAsignatura() + ".xdsl";
    	net.writeFile("redes/" + nombreRed);

    }
   
    public void agregarTarea(Tarea tarea, ArrayList<Concepto> conceptoList) {
    	
    	em.persist(tarea);
    	tarea.setConceptoList(conceptoList);
    	em.merge(tarea);
    }
    
    public void calcularProbabilidades(int idAsignatura) {
    	// Calculo de las probabilidades condicionales de las relaciones de agregacion
    	
    	String nombreRed = "red_asignatura_" + idAsignatura + ".xdsl";
		System.out.println("redes/" + nombreRed);
		Network net = new Network();
		net.readFile("redes/" + nombreRed);
		
		Asignatura asignatura = em.find(Asignatura.class, idAsignatura);

    	List<Tema> temaList = (List<Tema>) em.createQuery("Select e from Tema e where e.profesor = :profesor")
				.setParameter("profesor", asignatura.getProfesor()).getResultList();
    	for(Tema tema : temaList) {
    		double[] temaDef = calcularProbabilidadesTema(tema);
    		net.setNodeDefinition(tema.getNombre(), temaDef);
    	}
    	

    	double[] asignaturaDef = calcularProbabilidadesAsignatura(asignatura);
    	net.setNodeDefinition(asignatura.getNombre(), asignaturaDef);
    	
    	
    	net.writeFile("redes/" + nombreRed);
    }
    
    private double[] calcularProbabilidadesAsignatura(Asignatura asignatura) {
    	int dimension = (int) Math.pow(2, asignatura.getTemaList().size());
    	double [] asignaturaDef = new double[dimension * 2];
    	
    	int j = 0;
    	for(int i = 0; i < dimension; i++) {
    		asignaturaDef[j] = cpAsignatura(asignatura, i);
    		j++;
    		asignaturaDef[j] = 1 - asignaturaDef[j-1];
    		j++;
    		
    	}
    	
    	return asignaturaDef;
	}

	private double cpAsignatura(Asignatura asignatura, int i) {
		
		
		////HAY QUE REVISAR ESTA FUNCION
		String comb = Integer.toBinaryString(i);
		int dimension = asignatura.getTemaList().size();
    	while(comb.length() != dimension){
    		comb = "0" + comb;
    	}
    	int k = dimension - 1;
    	double valTemp = 0;
		List<Tema> temaList = em.createQuery("Select e from Tema e where e.asignatura = :asignatura")
				.setParameter("asignatura", asignatura).getResultList(); 
		System.out.println(temaList);
    	for (int j = 0; j < temaList.size(); j++) {
    		 if(comb.charAt(k) == '1') {
    			 valTemp = valTemp + temaList.get(j).getPeso();
    		 } 
    		 k--;
    	}
    	
    	return valTemp;
	}

	private double [] calcularProbabilidadesEval(Ejercicio ejercicio) {
    	//Calculo de las probabilidades condicionales 
    	int dimension = (int) Math.pow(2, ejercicio.getConceptoList().size());
    	double [] ejercicioDef = new double[dimension * 2];
    	
    	int j = 0;
    	for(int i = 0; i < dimension; i++) {
    		ejercicioDef[j] = cp(ejercicio, i);
    		j++;
    		ejercicioDef[j] = 1 - ejercicioDef[j-1];
    		j++;
    		
    	}
    	
    	return ejercicioDef;
    }
    
    private double cp(Ejercicio ejercicio, int i) {
    	
    	String comb = Integer.toBinaryString(i);
    	while(comb.length() < ejercicio.getConceptoList().size()){
    		comb = "0" + comb;
    		System.out.println(comb);
    	}
    	int k = ejercicio.getConceptoList().size() - 1;
    	double valTemp = 1;
    	for (int j = 0; j < ejercicio.getConceptoList().size(); j++) {
    		 if(comb.charAt(k) == '0') {
    			 valTemp = valTemp * ejercicio.getConceptoList().get(j).getAdivinanza();
    		 } else {
    			 valTemp = valTemp * (1 - 
    					 ejercicio.getConceptoList().get(j).getDescuido());
    		 }
    		 
    		 k--;
    	}
    	
    	return valTemp;
    	
    }
    
    private double [] calcularProbabilidadesTema(Tema tema) {
    	//Calculo de las probabilidades condicionales 
    	int dimension = (int) Math.pow(2, tema.getConceptoList().size());
    	double [] temaDef = new double[dimension * 2];
    	
    	int j = 0;
    	for(int i = 0; i < dimension; i++) {
    		temaDef[j] = cpTema(tema, i);
    		j++;
    		temaDef[j] = 1 - temaDef[j-1];
    		j++;
    		
    	}
    	
    	return temaDef;
    }
    
    private double cpTema(Tema tema, int i) {
    	
    	String comb = Integer.toBinaryString(i);
    	while(comb.length() < tema.getConceptoList().size()){
    		comb = "0" + comb;
    	}
    	int k = tema.getConceptoList().size() - 1;
    	double valTemp = 0;
    	for (int j = 0; j < tema.getConceptoList().size(); j++) {
    		 if(comb.charAt(k) == '1') {
    			 valTemp = valTemp + tema.getConceptoList().get(j).getPeso();
    		 } 
    		 k--;
    	}
    	
    	return valTemp;
    	
    }
    
    private void agregarEjercicioRed(Ejercicio ejercicio) {
    	//operaciones sobre la red bayesiana con smile
    	String nombreRed = "red_asignatura_" + 1 + ".xdsl";
		System.out.println("redes/" + nombreRed);
		Network net = new Network();
		net.readFile("redes/" + nombreRed);
		
		//agregar nodo ejercicio
		String titulo = "E" + Integer.toString(ejercicio.getIdEjercicio());
		net.addNode(Network.NodeType.Cpt, titulo);
		net.setOutcomeId(titulo, 0, "Incorrecto");
		net.setOutcomeId(titulo, 1, "Correcto");
		
		//agregar los arcos
		List<Concepto> conceptoList = ejercicio.getConceptoList(); 
		for(Concepto concepto : conceptoList) {
			net.addArc(concepto.getNombre(), titulo);
		}
		
		//definir probabilidades condicionales
		double[] ejercicioDef = calcularProbabilidadesEval(ejercicio);
		net.setNodeDefinition(titulo, ejercicioDef);
		
		net.writeFile("redes/" + nombreRed);
    }
    
    private void agregarTemaRed(Tema tema) {
    	//operaciones sobre la red bayesiana con smile
    	String nombreRed = "red_asignatura_" + 1 + ".xdsl";
		System.out.println("redes/" + nombreRed);
		Network net = new Network();
		net.readFile("redes/" + nombreRed);
		
		//agregar nodo ejercicio
		String titulo = tema.getNombre();
		net.addNode(Network.NodeType.Cpt, titulo);
		net.setOutcomeId(titulo, 0, "No_conoce");
		net.setOutcomeId(titulo, 1, "Conoce");
		
		net.writeFile("redes/" + nombreRed);
    }
    
    private void agregarConceptoRed(Concepto concepto) {
    	//operaciones sobre la red bayesiana con smile
    	String nombreRed = "red_asignatura_" + 1 + ".xdsl";

		System.out.println("redes/" + nombreRed);
		Network net = new Network();
		net.readFile("redes/" + nombreRed);
		
		//agregar nodo concepto
		String titulo = concepto.getNombre();
		net.addNode(Network.NodeType.Cpt, titulo);
		net.setOutcomeId(titulo, 0, "No_conoce");
		net.setOutcomeId(titulo, 1, "Conoce");
		
		//agregar los arcos
		
		net.addArc(titulo, concepto.getTema().getNombre());
				
		//definir probabilidades
		double [] conceptoDef = new double [2];
		conceptoDef[1] = concepto.getApriori();
		conceptoDef[0] = 1 - conceptoDef[1];
		net.setNodeDefinition(titulo, conceptoDef);
		net.writeFile("redes/" + nombreRed);
    }

	@Override
	public Profesor logIn(String usuario, String password) {
		// TODO Auto-generated method stub
		Profesor profesor = (Profesor) em.createNamedQuery("Profesor.findByUsuario")
				.setParameter("usuario", usuario).getSingleResult();
		
		if(password.trim().equals(profesor.getUsuario().trim())){
			System.out.println(profesor.getAsignaturaList().toString());//No Borrar, sirve para la inicializacion
			return profesor;
		}
		
		return null;
	}

	@Override
	public void agregarAsignatura(Asignatura asignatura, boolean usaPlantilla,
			String plantilla) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public String getValorNodoRed(String nombre) {
		// TODO Auto-generated method stub
    	String nombreRed = "red_asignatura_" + 1 + ".xdsl";

		Network net = new Network();
		net.readFile("redes/" + nombreRed);
		
		net.updateBeliefs();
		
		double [] valor = net.getNodeValue(nombre);
		
		double conoce = valor[1];
		
		return Double.toString(conoce);
		
	}

	

	@Override
	public void crearRedAlumnos(int idAsignatura) {
		// TODO Auto-generated method stub
		
		Asignatura asignatura = em.find(Asignatura.class, idAsignatura);
        Curso curso = asignatura.getCurso();
        List<Alumno> alumnoList = em.createQuery("Select e from Alumno e where e.curso = :curso")
				.setParameter("curso", curso).getResultList();
		
		String nombreRed = "red_asignatura_" + idAsignatura + ".xdsl";
		Network net = new Network();
		net.readFile("redes/" + nombreRed);
		
        
		for (Alumno alumno : alumnoList) {

			String nombreRedAlumno = "red_alumno_" + alumno.getIdAlumno() + ".xdsl";
			net.writeFile("redes/" + nombreRedAlumno);
			
		}
		
	}

	@Override
	public void agregarSesion(int idAlumno, Boolean ayudaPadres, Boolean desdeHogar, String estadoAnimo) {
		Sesion sesion = new Sesion();
		
		sesion.setEntrada(new Date(System.currentTimeMillis()));
		sesion.setAyudaPadres(ayudaPadres);
		sesion.setDesdeHogar(desdeHogar);
		sesion.setEstadoAnimo(estadoAnimo);
		em.persist(sesion);
		
	}
}