//===============================================================================================================================================================
public bool DeleteApoyo(Apoyo apoyo)
{
EstudianteDAO estudianteApoyado = RepositoryDAL1.Read <EstudianteDAO>(x => x.id_usuario.Equals(apoyo.id_estudianteApoyado)).FirstOrDefault();
EstudianteDAO estudianteApoya = RepositoryDAL1.Read <EstudianteDAO>(x => x.id_usuario.Equals(apoyo.id_estudianteQueApoya)).FirstOrDefault();;
TecnologiaDAO tecnologia = RepositoryDAL1.Read <TecnologiaDAO>(x => x.nombre.Equals(apoyo.Tecnologia)).FirstOrDefault();
ApoyoDAO apy = RepositoryDAL1.Read <ApoyoDAO>(x => x.id_estudianteApoyado.Equals(apoyo.id_estudianteApoyado) && x.id_estudianteDaApoyo.Equals(apoyo.id_estudianteQueApoya) && x.id_tecnologia.Equals(tecnologia.id)).FirstOrDefault();
//si no existe el apoyo
if (apy == null)
{
return(false); //el apoyo no existe
}
else
{
if (RepositoryDAL1.Delete(apy))
{
//sumamos la cantidad de apoyos disponibles y actualizamos
estudianteApoya.apoyos_disponibles += 1;
RepositoryDAL1.Update(estudianteApoya);
//se resta la cantidad de apoyos a la tabla de tecnologiasXestudiante
Tecnologia_x_EstudianteDAO tecEst = RepositoryDAL1.Read <Tecnologia_x_EstudianteDAO>(x => x.id_estudiante.Equals(estudianteApoyado.id_usuario) &&
x.id_tecnologia.Equals(tecnologia.id)).FirstOrDefault();
tecEst.cantidadApoyos -= 1;
RepositoryDAL1.Update(tecEst);
return(true); //borró el apoyo
}
}
//error al crear el apoyo
return(false);
}
protected void ImageButton1_Click(object sender, ImageClickEventArgs e)
{
EstudianteDAO estudianteDao = new EstudianteDAO();
Estudiante estudiante = new Estudiante();
Maestro maestro = new Maestro();
foreach (Estudiante aux in listaEstudiante)
{
if ((dropEstudiante.SelectedItem.Value).Equals((aux.idPersona + " " + aux.nombre + " " + aux.apellido)))
{
estudiante = new Estudiante(aux.idProyecto, aux.idPersona, aux.numHorasCumplidas, aux.idPersona, aux.nombre,
aux.apellido);
break;
}
}
foreach (Maestro aux in listaMaestro)
{
if ((dropMaestro.SelectedItem.Value).Equals(aux.idPersona + " " + aux.nombre + " " + aux.apellido))
{
maestro = new Maestro(aux.idProyecto, aux.idPersona, aux.cargo, aux.carrera, aux.nombre, aux.apellido);
break;
}
}
estudianteDao.registrarTutorAcademico(maestro, estudiante);
seleccionaEstudiante();
seleccionarAsignarTutorAcademico();
}
public bool SolicitudModificar(String codigo, String nombre, String apellido, int edad, String carrera, int semestre)
{
ClsEstudiante estudiante = new ClsEstudiante(codigo, nombre, apellido, edad, carrera, semestre);
EstudianteDAO estDAO = new EstudianteDAO();
return(estDAO.modificarEstudiante(estudiante));
}
public List <Estudiante> Seleccionar()
{
try
{
estudianteDAO = new EstudianteDAO();
lst = new List <Estudiante>();
lst = estudianteDAO.Seleccionar();
return(lst);
}
catch (Exception ex)
{
using (StreamWriter w = File.AppendText("C:\\log.txt"))
{
LogErrores.Log(ex.Message, w);
}
using (StreamReader reg = File.OpenText("C:\\log.txt"))
{
LogErrores.Registro(reg);
}
return(null);
}
}
//===============================================================================================================================================================
public bool AddSeguimiento(Seguimiento seguimiento)
{
//buscamos si ya existe un seguimiento (es decir si el estudiante "seguidor" sigue al estudiante "seguido")
Estudiante_sigue_EstudianteDAO seg = RepositoryDAL1.Read <Estudiante_sigue_EstudianteDAO>(x => x.id_estudianteSeguido.Equals(seguimiento.id_estudianteSeguido) && x.id_estudianteSeguidor.Equals(seguimiento.id_estudianteSigue)).FirstOrDefault();
//si no existe
if (seg == null)
{
seg = new Estudiante_sigue_EstudianteDAO {
id_estudianteSeguidor = seguimiento.id_estudianteSigue, id_estudianteSeguido = seguimiento.id_estudianteSeguido
};
if (RepositoryDAL1.Create(seg))
{
EstudianteDAO estSeguido = RepositoryDAL1.Read <EstudianteDAO>(x => x.id_usuario.Equals(seguimiento.id_estudianteSeguido)).FirstOrDefault();
if (estSeguido == null)
{
return(false); //error, no existe el estudiante q usted quiere seguir
}
//sumamos la cantidad de seguidores
estSeguido.numero_seguidores += 1;
return(RepositoryDAL1.Update(estSeguido)); //se creo el seguimiento correctamente y se sumo los seguidores al seguido
}
//fallo al entra a la base de datos
}
//ya existia el seguimiento, no se hizo nada
return(false);
}
public void seleccionaEstudiante()
{
dropEstudiante.Items.Clear();
EstudianteDAO estudianteDAO = new EstudianteDAO();
listaEstudiante = estudianteDAO.queryEstudiante(carrera);
foreach (Estudiante aux in listaEstudiante)
{
dropEstudiante.Items.Add(aux.idPersona + " " + aux.nombre + " " + aux.apellido);
}
}
public bool DeletePublicacion(int pubId)
{
PublicacionDAO publicacionAModificar = RepositoryDAL1.Read <PublicacionDAO>(x => x.id == pubId).FirstOrDefault();
publicacionAModificar.activo = false;
EstudianteDAO estudianteAModificar = RepositoryDAL1.Read <EstudianteDAO>(x => x.id_usuario.Equals(publicacionAModificar.id_estudiante)).FirstOrDefault();
estudianteAModificar.participacion--;
RepositoryDAL1.Update(estudianteAModificar);
return(RepositoryDAL1.Update <PublicacionDAO>(publicacionAModificar));
}
public ActionResult Editar(int id)
{
var estudianteDao = new EstudianteDAO();
var modelo = new EstudianteModel();
var estudiante = estudianteDao.ObtenerEstudiante(id);
modelo.Id = id;
modelo.Nombre = estudiante.Nombre;
modelo.Edad = estudiante.Edad;
modelo.Telefono = estudiante.Telefono;
return(View(modelo));
}
//metodos
//===============================================================================================================================================================
//Obtiene los datos del estudiante que está logueado
public Estudiante GetEstudiantePropio(string EstudianteId)
{
//obtner la informacion de usuario y de estudiante de la base de datos
EstudianteDAO estudiante = RepositoryDAL1.Read <EstudianteDAO>(x => x.id_usuario.Equals(EstudianteId)).FirstOrDefault();
UsuarioDAO user = RepositoryDAL1.Read <UsuarioDAO>(x => x.id.Equals(EstudianteId)).FirstOrDefault();
if (estudiante == null && user == null) //si no existen
{
return(null);
}
//obtener la informacion de tecnologias del estudiante
List <Tecnologia_x_EstudianteDAO> tecEstudiante = RepositoryDAL1.Read <Tecnologia_x_EstudianteDAO>(x => x.id_estudiante.Equals(EstudianteId));
//creamos la lista de tecnolgias con sus respectivos apoyos
List <Estudiante.TecnologiaPerfil> tecApoyo = new List <Estudiante.TecnologiaPerfil>();
IEnumerable <int> listaIdTecnologias = tecEstudiante.Select(x => x.id);
List <TecnologiaDAO> listaTecnologias = RepositoryDAL1.Read <TecnologiaDAO>(x => listaIdTecnologias.Contains(x.id));
foreach (Tecnologia_x_EstudianteDAO tec in tecEstudiante)
{
//se pone el apyo como "fijo" para que no salga el botoncito de "+" puesto que yo no me puedo apoyar a mi mismo
tecApoyo.Add(new Estudiante.TecnologiaPerfil {
Apoyos = tec.cantidadApoyos, MiApoyo = "fijo", Nombre = tec.Tecnologia.nombre
});
}
//crear el estudiante
Estudiante result = new Estudiante
{
Id = user.id,
Apellido = user.apellido,
CantSeguidores = estudiante.numero_seguidores,
Correo = user.correo_principal,
Correo2 = estudiante.correo_secundario,
Descripcion = estudiante.descripcion,
FechaInscripcion = user.fecha_creacion,
Nombre = user.nombre,
Pais = estudiante.Pai.nombre,
Participacion = estudiante.participacion,
Reputacion = estudiante.reputacion,
Telefono = estudiante.telefono_celular,
Telefono2 = estudiante.telefono_fijo,
Universidad = estudiante.Universidad.nombre,
Tecnologias = tecApoyo,
ApoyosDisponibles = estudiante.apoyos_disponibles,
Foto = estudiante.foto
};
return(result);
}
//===============================================================================================================================================================
public bool ModificarEstudiante(string estudianteId, Estudiante estudiante)
{
//primero intentamos obtener el estudiante correcto
UsuarioDAO user = RepositoryDAL1.Read <UsuarioDAO>(x => x.id.Equals(estudianteId)).FirstOrDefault();
EstudianteDAO existente = RepositoryDAL1.Read <EstudianteDAO>(x => x.Usuario.id.Equals(estudianteId)).FirstOrDefault();
//si no existe el estudiante
if (user == null && existente == null)
{
return(false); //error, no existe el estudiante, no deberia suceder
}
else
{
PaisDAO pais = RepositoryDAL1.Read <PaisDAO>(x => x.nombre.Equals(estudiante.Pais)).FirstOrDefault();
UniversidadDAO univ = RepositoryDAL1.Read <UniversidadDAO>(x => x.nombre.Equals(estudiante.Universidad)).FirstOrDefault();
//fallo al crear el pais y universidad
if (pais == null || univ == null)
{
return(false);
}
//modificar el usuario
user.apellido = estudiante.Apellido;
user.correo_principal = estudiante.Correo;
user.nombre = estudiante.Nombre;
//modificar estudiante
existente.id_usuario = estudiante.Id;
existente.apoyos_disponibles = APOYOS_SEMANA;
existente.descripcion = estudiante.Descripcion;
existente.correo_secundario = estudiante.Correo2;
existente.id_pais = pais.id;
existente.telefono_celular = estudiante.Telefono;
existente.telefono_fijo = estudiante.Telefono2;
existente.foto = estudiante.Foto;
//actualizar informacion
if (RepositoryDAL1.Update <UsuarioDAO>(user))
{
if (RepositoryDAL1.Update(existente))
{
//actualizar las tecnolgias----------------------------------------------'por hacer
}
return(true);
}
//fallo al ingresar a la base de datos
}
return(false);
}
public bool CreatePublicacion(Contenido contenido)
{
IEnumerable <string> nombresTecnologias = contenido.Tecnologias.Select(x => x.Nombre);
List <TecnologiaDAO> listaTecnologias = RepositoryDAL1.Read <TecnologiaDAO>(x => nombresTecnologias.Contains(x.nombre));
List <Tecnologia_x_publicacionDAO> listaTecnologiasPublicacion = new List <Tecnologia_x_publicacionDAO>();
if (RepositoryDAL1.Create <PublicacionDAO>(new PublicacionDAO
{
descripcion = contenido.Descripcion,
fecha_publicacion = DateTime.Now,
id_estudiante = contenido.Id_autor,
isTutoria = false,
titulo = contenido.Titulo,
Tecnologia_x_publicacion = listaTecnologiasPublicacion,
activo = true
}))
{
int id_publicacionCreada = RepositoryDAL1.Read <PublicacionDAO, int>(x => x.id > 0, x => x.id).FirstOrDefault().id;
if (contenido.Documento != null)
{
RepositoryDAL1.Create <DocumentoDAO>(new DocumentoDAO {
contenido = contenido.Documento, tipo = "", tamano = 0
});
}
int id_contenidoCreado = RepositoryDAL1.Read <DocumentoDAO, int>(x => x.id > 0, x => x.id).FirstOrDefault().id;
ContenidoDAO nuevoContenido = new ContenidoDAO
{
enlace_extra = contenido.Link,
enlace_video = contenido.Video,
id_publicacion = id_publicacionCreada,
id_documento = contenido.Documento != null ? (int?)id_contenidoCreado : null
};
if (RepositoryDAL1.Create <ContenidoDAO>(nuevoContenido))
{
foreach (var tecnologia in listaTecnologias)
{
listaTecnologiasPublicacion.Add(new Tecnologia_x_publicacionDAO {
id_tecnologia = tecnologia.id, id_publicacion = id_publicacionCreada
});
}
EstudianteDAO estudianteAModificar = RepositoryDAL1.Read <EstudianteDAO>(x => x.id_usuario.Equals(contenido.Id_autor)).FirstOrDefault();
estudianteAModificar.participacion++;
RepositoryDAL1.Update(estudianteAModificar);
return(RepositoryDAL1.Create <Tecnologia_x_publicacionDAO>(listaTecnologiasPublicacion));
}
}
return(false);
}
//===============================================================================================================================================================
public bool AddApoyo(Apoyo apoyo)
{
EstudianteDAO estudianteApoyado = RepositoryDAL1.Read <EstudianteDAO>(x => x.id_usuario.Equals(apoyo.id_estudianteApoyado)).FirstOrDefault();
EstudianteDAO estudianteApoya = RepositoryDAL1.Read <EstudianteDAO>(x => x.id_usuario.Equals(apoyo.id_estudianteQueApoya)).FirstOrDefault();;
TecnologiaDAO tecnologia = RepositoryDAL1.Read <TecnologiaDAO>(x => x.nombre.Equals(apoyo.Tecnologia)).FirstOrDefault();
ApoyoDAO apy = RepositoryDAL1.Read <ApoyoDAO>(x => x.id_estudianteApoyado.Equals(apoyo.id_estudianteApoyado) && x.id_estudianteDaApoyo.Equals(apoyo.id_estudianteQueApoya) && x.id_tecnologia.Equals(tecnologia.id)).FirstOrDefault();
//si no existe el apoyo
if (apy == null)
{
//si el estudiante que apoya tiene apoyos disponibles
if (estudianteApoya.apoyos_disponibles > 0)
{
ApoyoDAO apoyoAAgregar = new ApoyoDAO
{
fecha = DateTime.Now,
id_estudianteApoyado = apoyo.id_estudianteApoyado,
id_estudianteDaApoyo = apoyo.id_estudianteQueApoya,
id_tecnologia = tecnologia.id
};
RepositoryDAL1.Create(apoyoAAgregar);
//restamos la cantidad de apoyos disponibles y actualizamos
estudianteApoya.apoyos_disponibles -= 1;
RepositoryDAL1.Update(estudianteApoya);
//se suma la cantidad de apoyos a la tabla de tecnologiasXestudiante
Tecnologia_x_EstudianteDAO tecEst = RepositoryDAL1.Read <Tecnologia_x_EstudianteDAO>(x => x.id_estudiante.Equals(estudianteApoyado.id_usuario) &&
x.id_tecnologia.Equals(tecnologia.id)).FirstOrDefault();
tecEst.cantidadApoyos += 1;
RepositoryDAL1.Update(tecEst);
string nombreCompletoEstudianteQueApoya = estudianteApoya.Usuario.nombre + " " + estudianteApoya.Usuario.apellido;
string nombreCompletoEstudianteApoyado = estudianteApoyado.Usuario.nombre + " " + estudianteApoyado.Usuario.apellido;
ExternalAPIs.TwitterConnection.sendTweet(nombreCompletoEstudianteQueApoya, nombreCompletoEstudianteApoyado, tecnologia.nombre);
return(true); //creo el apoyo
}
//no tiene suficientes apoyos disponibles
}
//el apoyo ya existe
return(false);
}
public ActionResult Eliminar(int id)
{
try
{
if (ModelState.IsValid)
{
var estudianteDao = new EstudianteDAO();
estudianteDao.EliminarEstudiante(id);
}
return(Redirect("~/estudiante/leer"));
}
catch (Exception ex)
{
_logger.LogError(@"Error: {0}", ex);
throw;
}
}
public ActionResult Editar(EstudianteModel model)
{
try
{
if (ModelState.IsValid)
{
var estudianteDao = new EstudianteDAO();
estudianteDao.ActualizarEstudiante(new Modelos.DTOs.EstudianteDTO {
Id = model.Id, Nombre = model.Nombre, Edad = model.Edad, Telefono = model.Telefono
});
}
return(Redirect("~/estudiante/leer"));
}
catch (Exception ex)
{
_logger.LogError(@"Error: {0}", ex);
throw;
}
}
public bool CreateTutoria(Tutoria tutoria)
{
IEnumerable <string> nombresTecnologias = tutoria.Tecnologias.Select(x => x.Nombre);
List <TecnologiaDAO> listaTecnologias = RepositoryDAL1.Read <TecnologiaDAO>(x => nombresTecnologias.Contains(x.nombre));
List <Tecnologia_x_publicacionDAO> listaTecnologiasPublicacion = new List <Tecnologia_x_publicacionDAO>();
if (RepositoryDAL1.Create <PublicacionDAO>(new PublicacionDAO
{
descripcion = tutoria.Descripcion,
fecha_publicacion = DateTime.Now,
id_estudiante = tutoria.Id_autor,
isTutoria = true,
titulo = tutoria.Titulo,
Tecnologia_x_publicacion = listaTecnologiasPublicacion,
activo = true
}))
{
int id_publicacionCreada = RepositoryDAL1.Read <PublicacionDAO, int>(x => x.id > 0, x => x.id).FirstOrDefault().id;
TutoriaDAO nuevaTutoria = new TutoriaDAO
{
costo = tutoria.Costo,
id_publicacion = id_publicacionCreada,
lugar = tutoria.Lugar,
fecha_tutoria = tutoria.FechaTutoria
};
if (RepositoryDAL1.Create <TutoriaDAO>(nuevaTutoria))
{
foreach (var tecnologia in listaTecnologias)
{
listaTecnologiasPublicacion.Add(new Tecnologia_x_publicacionDAO {
id_tecnologia = tecnologia.id, id_publicacion = id_publicacionCreada
});
}
EstudianteDAO estudianteAModificar = RepositoryDAL1.Read <EstudianteDAO>(x => x.id_usuario.Equals(tutoria.Id_autor)).FirstOrDefault();
estudianteAModificar.participacion++;
RepositoryDAL1.Update(estudianteAModificar);
return(RepositoryDAL1.Create <Tecnologia_x_publicacionDAO>(listaTecnologiasPublicacion));
}
}
return(false);
}
//===============================================================================================================================================================
public bool DeleteSeguimiento(Seguimiento seguimiento)
{
Estudiante_sigue_EstudianteDAO seg = RepositoryDAL1.Read <Estudiante_sigue_EstudianteDAO>(x => x.id_estudianteSeguido.Equals(seguimiento.id_estudianteSeguido) && x.id_estudianteSeguidor.Equals(seguimiento.id_estudianteSigue)).FirstOrDefault();
if (seg == null)
{
return(false); //no existe el seguimiento
}
if (RepositoryDAL1.Delete(seg))
{
EstudianteDAO estSeguido = RepositoryDAL1.Read <EstudianteDAO>(x => x.id_usuario.Equals(seguimiento.id_estudianteSeguido)).FirstOrDefault();
if (estSeguido == null)
{
return(false); //error, no existe el estudiante q usted quiere dejar seguir
}
estSeguido.numero_seguidores -= 1; //restamos cantidad de seguidores
return(RepositoryDAL1.Update(estSeguido)); //se actualizo y dejo de seguir estudiante
//problema actualizando el estudiante
}
//problema borrando
return(false);
}
public IActionResult Leer()
{
var estudianteDao = new EstudianteDAO();
var modelo = new List <EstudianteModel>();
try
{
var estudiantes = estudianteDao.ObtenerEstudiantes();
foreach (var estudiante in estudiantes)
{
modelo.Add(new EstudianteModel {
Id = estudiante.Id, Nombre = estudiante.Nombre, Edad = estudiante.Edad, Telefono = estudiante.Telefono
});
}
return(View(modelo));
}
catch (Exception ex)
{
_logger.LogError(@"Error: {0}", ex);
throw;
}
}
public int Actualizar([FromBody] Estudiante estudiante)
{
try
{
estudianteDAO = new EstudianteDAO();
result = estudianteDAO.Actualizar(estudiante);
return(result);
}
catch (Exception ex)
{
using (StreamWriter w = File.AppendText("C:\\log.txt"))
{
LogErrores.Log(ex.Message, w);
}
using (StreamReader reg = File.OpenText("C:\\log.txt"))
{
LogErrores.Registro(reg);
}
return(0);
}
}
public int Eliminar(int Id)
{
try
{
estudianteDAO = new EstudianteDAO();
result = estudianteDAO.Eliminar(Id);
return(result);
}
catch (Exception ex)
{
using (StreamWriter w = File.AppendText("C:\\log.txt"))
{
LogErrores.Log(ex.Message, w);
}
using (StreamReader reg = File.OpenText("C:\\log.txt"))
{
LogErrores.Registro(reg);
}
return(0);
}
}
public bool AddOrModifyEvaluacion(Evaluacion evaluacion)
{
PublicacionDAO publicacionAEvaluar = RepositoryDAL1.Read <PublicacionDAO>(x => x.id == evaluacion.id_publicacion).FirstOrDefault();
EstudianteDAO estudianteEvaluado = RepositoryDAL1.Read <EstudianteDAO>(x => x.id_usuario.Equals(publicacionAEvaluar.id_estudiante)).FirstOrDefault();
List <PublicacionDAO> publicacionesDelUsuario = RepositoryDAL1.Read <PublicacionDAO>(x => x.id_estudiante.Equals(estudianteEvaluado.id_usuario));
int totalEvaluacionesNegativas = publicacionesDelUsuario.Select(x => x.evaluaciones_negativas).Sum();
int totalEvaluacionesPositivas = publicacionesDelUsuario.Select(x => x.evaluaciones_positivas).Sum();
int reputacion;
double porcentaje0a1;
EvaluacionDAO evaluacionExistente = RepositoryDAL1.Read <EvaluacionDAO>(x =>
x.id_estudiante.Equals(evaluacion.Id_estudiante) &&
x.id_publicacion == evaluacion.id_publicacion)
.FirstOrDefault();
if (evaluacion.Tipo_evaluacion.Equals("null") && evaluacionExistente != null)
{
if ((bool)evaluacionExistente.positiva)
{
publicacionAEvaluar.evaluaciones_positivas--;
totalEvaluacionesPositivas--;
}
else
{
publicacionAEvaluar.evaluaciones_negativas--;
totalEvaluacionesNegativas--;
}
if ((totalEvaluacionesPositivas + totalEvaluacionesNegativas) == 0)
{
reputacion = 0;
}
else
{
porcentaje0a1 = ((double)totalEvaluacionesPositivas / ((double)totalEvaluacionesPositivas + (double)totalEvaluacionesNegativas));
reputacion = (int)((porcentaje0a1) * 100);
}
estudianteEvaluado.reputacion = reputacion;
RepositoryDAL1.Update(estudianteEvaluado);
RepositoryDAL1.Update(publicacionAEvaluar);
return(RepositoryDAL1.Delete(evaluacionExistente));
}
if (publicacionAEvaluar.isTutoria)
{
EstudianteDAO estudianteQueEvalua = RepositoryDAL1.Read <EstudianteDAO>(x => x.id_usuario.Equals(evaluacion.Id_estudiante)).FirstOrDefault();
TutoriaDAO tutoriaEvaluada = publicacionAEvaluar.Tutorias.Where(x => x.id_publicacion == evaluacion.id_publicacion).FirstOrDefault();
IEnumerable <int> listaIdTutoriasRegistradas = estudianteQueEvalua.RegistroTutorias.Select(x => x.id_tutoria);
if (!listaIdTutoriasRegistradas.Contains(tutoriaEvaluada.id) || tutoriaEvaluada.fecha_tutoria > DateTime.Now)
{
return(false); //no se puede evaluar porque no está registrado o la tutoría no ha terminado
}
}
EvaluacionDAO evaluacionAAgregar = new EvaluacionDAO
{
id_publicacion = evaluacion.id_publicacion,
positiva = evaluacion.Tipo_evaluacion.Equals("pos") ? true : false,
id_estudiante = evaluacion.Id_estudiante
};
if (evaluacion.Tipo_evaluacion.Equals("pos") && evaluacionExistente != null)
{
if (!(bool)evaluacionExistente.positiva) //es negativa
{
publicacionAEvaluar.evaluaciones_positivas++;
totalEvaluacionesPositivas++;
publicacionAEvaluar.evaluaciones_negativas--;
totalEvaluacionesNegativas--;
}
else
{
return(true);
}
RepositoryDAL1.Delete(evaluacionExistente);
}
if (evaluacion.Tipo_evaluacion.Equals("pos") && evaluacionExistente == null)
{
publicacionAEvaluar.evaluaciones_positivas++;
totalEvaluacionesPositivas++;
}
if (evaluacion.Tipo_evaluacion.Equals("neg") && evaluacionExistente != null)
{
if ((bool)evaluacionExistente.positiva) //es negativa
{
publicacionAEvaluar.evaluaciones_positivas--;
totalEvaluacionesPositivas--;
publicacionAEvaluar.evaluaciones_negativas++;
totalEvaluacionesNegativas++;
}
else
{
return(true);
}
RepositoryDAL1.Delete(evaluacionExistente);
}
if (evaluacion.Tipo_evaluacion.Equals("neg") && evaluacionExistente == null)
{
publicacionAEvaluar.evaluaciones_negativas++;
totalEvaluacionesNegativas++;
}
porcentaje0a1 = ((double)totalEvaluacionesPositivas / ((double)totalEvaluacionesPositivas + (double)totalEvaluacionesNegativas));
reputacion = (int)((porcentaje0a1) * 100);
estudianteEvaluado.reputacion = reputacion;
RepositoryDAL1.Update(estudianteEvaluado);
RepositoryDAL1.Update(publicacionAEvaluar);
return(RepositoryDAL1.Create(evaluacionAAgregar));
}
public void ActivarEstudiante(int id)
{
EstudianteDAO estudianteDao = new EstudianteDAO();
estudianteDao.ActivarEstudiante(id);
}
public List <EstudianteDTO> ObtenerEstudiantes()
{
EstudianteDAO estudianteDao = new EstudianteDAO();
return(estudianteDao.ObtenerEstudiantes());
}
public List <EstudianteDTO> ObtenerEstudiantesAutocomplete(string filtro)
{
EstudianteDAO e = new EstudianteDAO();
return(e.ObtenerEstudiantesAutocomplete(filtro));
}
public EstudianteDTO ObtenerEsudiante(int id)
{
EstudianteDAO estudianteDao = new EstudianteDAO();
return(estudianteDao.ObtenerEsudiante(id));
}
public void CrearEstudiante(EstudianteDTO estudiante)
{
EstudianteDAO estudianteDao = new EstudianteDAO();
estudianteDao.CrearEstudiante(estudiante);
}
//===============================================================================================================================================================
public string CrearEstudiante(string password, Estudiante estudiante)
{
//primero buscamos a ver si existe ese estudiante
UsuarioDAO user = RepositoryDAL1.Read <UsuarioDAO>(x => x.id.Equals(estudiante.Id)).FirstOrDefault();
EstudianteDAO estud = RepositoryDAL1.Read <EstudianteDAO>(x => x.Usuario.id.Equals(estudiante.Id)).FirstOrDefault();
//si no existe el estudiante
if (user == null && estud == null)
{
PaisDAO pais = RepositoryDAL1.Read <PaisDAO>(x => x.nombre.Equals(estudiante.Pais)).FirstOrDefault();
UniversidadDAO univ = RepositoryDAL1.Read <UniversidadDAO>(x => x.nombre.Equals(estudiante.Universidad)).FirstOrDefault();
//fallo al crear el pais y universidad
if (pais == null || univ == null)
{
return("la universidad o pais dados no existen");
}
user = new UsuarioDAO
{
id = estudiante.Id,
activo = true,
apellido = estudiante.Apellido,
contrasena = password,
correo_principal = estudiante.Correo,
fecha_creacion = DateTime.Now,
is_admin = false,
nombre = estudiante.Nombre
};
estud = new EstudianteDAO
{
id_usuario = estudiante.Id,
apoyos_disponibles = APOYOS_SEMANA,
descripcion = estudiante.Descripcion,
correo_secundario = estudiante.Correo2,
id_pais = pais.id,
telefono_celular = estudiante.Telefono,
telefono_fijo = estudiante.Telefono2,
foto = estudiante.Foto,
id_universidad = univ.id,
numero_seguidores = 0,
participacion = 0,
reputacion = 0
};
//agregar los DAO a la base de Datos
if (RepositoryDAL1.Create(user))
{
if (RepositoryDAL1.Create(estud))
{
//una vez creados el usuario y estudiante, agregamos las tecnologias
//se obtiene la lista de tecnologias que el estudiante selecciono
IEnumerable <string> listaNombreTecnologias = estudiante.Tecnologias.Select(t => t.Nombre);
List <TecnologiaDAO> tecnologiasEstudiante = RepositoryDAL1.Read <TecnologiaDAO>(x => listaNombreTecnologias.Contains(x.nombre));
//por cada una de las tecnologías se agrega la nueva tecnologia
foreach (TecnologiaDAO tec in tecnologiasEstudiante)
{
if (!RepositoryDAL1.Create(new Tecnologia_x_EstudianteDAO
{
id_estudiante = estudiante.Id,
id_tecnologia = tec.id,
cantidadApoyos = 0
}))
{
return("Hubo un error al agregar las tecnologias del estudiante");//error al crear la tecnologia x estudiante
}
}
return(SUCCESS);
}
}
//fallo al ingresar a la base de datos
}
return("Ya existe un estudiante con ese Carne");
}
public ClsEstudiante SolicitudBuscar(String codigo)
{
EstudianteDAO estDAO = new EstudianteDAO();
return(estDAO.buscarEstudiante(codigo));
}
public bool ActualizarEstudiante(EstudianteDTO estudiante)
{
EstudianteDAO estudianteDao = new EstudianteDAO();
return(estudianteDao.ActualizarEstudiante(estudiante));
}
public bool solicitudEliminar(String codigo)
{
EstudianteDAO estDAO = new EstudianteDAO();
return(estDAO.eliminarEstudiante(codigo));
}
//===============================================================================================================================================================
public Estudiante GetEstudianteAjeno(string estudiante1, string EstudianteaBuscar)
{
//obtner el la informacion de usuario y de estudiante de la base de datos
EstudianteDAO estudiante = RepositoryDAL1.Read <EstudianteDAO>(x => x.id_usuario.Equals(EstudianteaBuscar)).FirstOrDefault();
UsuarioDAO user = RepositoryDAL1.Read <UsuarioDAO>(x => x.id.Equals(EstudianteaBuscar)).FirstOrDefault();
if (estudiante == null && user == null)
{
return(null);
}
//obtener la informacion de tecnologias del estudiante
List <Tecnologia_x_EstudianteDAO> tecEstudiante = RepositoryDAL1.Read <Tecnologia_x_EstudianteDAO>(x => x.id_estudiante.Equals(EstudianteaBuscar));
//creamos la lista de tecnolgias con sus respectivos apoyos
List <Estudiante.TecnologiaPerfil> tecApoyo = new List <Estudiante.TecnologiaPerfil>();
foreach (Tecnologia_x_EstudianteDAO tec in tecEstudiante)
{
//buscamos si la persona ha sido apoyada por el estudiante que lo busca
ApoyoDAO apoyo = RepositoryDAL1.Read <ApoyoDAO>(x => x.id_estudianteDaApoyo.Equals(estudiante1) && x.id_estudianteApoyado.Equals(EstudianteaBuscar) &&
x.id_tecnologia.Equals(tec.id_tecnologia)).FirstOrDefault();
if (apoyo != null)
{
//si el apoyo fue dado en la ultima semana
if (apoyo.fecha < DateTime.Now.AddDays(-WEEK))
{
tecApoyo.Add(new Estudiante.TecnologiaPerfil {
Apoyos = tec.cantidadApoyos, MiApoyo = "fijo", Nombre = tec.Tecnologia.nombre
});
}
//apoyo dado hace mas de una semana
else
{
tecApoyo.Add(new Estudiante.TecnologiaPerfil {
Apoyos = tec.cantidadApoyos, MiApoyo = "transitorio", Nombre = tec.Tecnologia.nombre
});
}
}
//no ha sido apoyado en esta tecnologia
else
{
tecApoyo.Add(new Estudiante.TecnologiaPerfil {
Apoyos = tec.cantidadApoyos, MiApoyo = "null", Nombre = tec.Tecnologia.nombre
});
}
}
//crear el estudiante
Estudiante result = new Estudiante
{
Id = user.id,
Apellido = user.apellido,
CantSeguidores = estudiante.numero_seguidores,
Correo = user.correo_principal,
Correo2 = estudiante.correo_secundario,
Descripcion = estudiante.descripcion,
FechaInscripcion = user.fecha_creacion,
Nombre = user.nombre,
Pais = estudiante.Pai.nombre,
Participacion = estudiante.participacion,
Reputacion = estudiante.reputacion,
Telefono = estudiante.telefono_celular,
Telefono2 = estudiante.telefono_fijo,
Universidad = estudiante.Universidad.nombre,
Tecnologias = tecApoyo,
Foto = estudiante.foto
};
return(result);
}
