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 bool QuitarRegistro(int pubId, string estId)
        {
            PublicacionDAO     publicacion       = RepositoryDAL1.Read <PublicacionDAO>(x => x.id == pubId).FirstOrDefault();
            TutoriaDAO         tutoria           = publicacion.Tutorias.FirstOrDefault();
            RegistroTutoriaDAO registroExistente = RepositoryDAL1.Read <RegistroTutoriaDAO>(x => x.id_estudiante.Equals(estId) && x.id_tutoria == tutoria.id).FirstOrDefault();

            if (registroExistente != null)
            {
                return(RepositoryDAL1.Delete(registroExistente));
            }
            return(false);
        }
        public bool RegistrarseEnTutoria(int pubId, string estId)
        {
            PublicacionDAO     publicacion       = RepositoryDAL1.Read <PublicacionDAO>(x => x.id == pubId).FirstOrDefault();
            TutoriaDAO         tutoria           = publicacion.Tutorias.FirstOrDefault();
            RegistroTutoriaDAO registroExistente = RepositoryDAL1.Read <RegistroTutoriaDAO>(x => x.id_estudiante.Equals(estId) && x.id_tutoria == tutoria.id).FirstOrDefault();

            if (registroExistente == null)
            {
                RegistroTutoriaDAO nuevoRegistro = new RegistroTutoriaDAO
                {
                    id_estudiante = estId,
                    id_tutoria    = tutoria.id
                };
                return(RepositoryDAL1.Create(nuevoRegistro));
            }
            return(false);
        }
        public bool AddComentario(Comentario comentario)
        {
            PublicacionDAO publicacionDeComentario = RepositoryDAL1.Read <PublicacionDAO>(x => x.id == comentario.id_publicacion).FirstOrDefault();
            bool           puedeComentar           = true;

            if (publicacionDeComentario.isTutoria)
            {
                TutoriaDAO tutoria = publicacionDeComentario.Tutorias.FirstOrDefault();
                List <RegistroTutoriaDAO> registroTutoria        = tutoria.RegistroTutorias.ToList();
                IEnumerable <string>      estudiantesRegistrados = registroTutoria.Select(x => x.id_estudiante);
                puedeComentar = estudiantesRegistrados.Contains(comentario.Id_Autor);
            }
            ComentarioDAO nuevoComentario = new ComentarioDAO
            {
                contenido      = comentario.Contenido,
                fecha_creacion = DateTime.Now,
                id_estudiante  = comentario.Id_Autor,
                id_publicacion = comentario.id_publicacion,
                activo         = true
            };

            return(RepositoryDAL1.Create(nuevoComentario));
        }
        public string BuscarPublicaciones(object obj)
        {
            PublicacionDAO l = new PublicacionDAO();

            return(l.devuelvePublicacionSP(obj));
        }
        public int modificarPublicacion(object obj)
        {
            PublicacionDAO l = new PublicacionDAO();

            return(l.modificaPublicacionSP(obj));
        }
        public int EliminarPublicacion(object obj)
        {
            PublicacionDAO l = new PublicacionDAO();

            return(l.eliminaPublicacionSP(obj));
        }
        public string TopPublicaciones2()
        {
            PublicacionDAO l = new PublicacionDAO();

            return(l.TopPublicaciones2());
        }
        //Publicación A,B,C Y B
        public int AgregarPublicacion(object obj)
        {
            PublicacionDAO l = new PublicacionDAO();

            return(l.creaPublicacionSP(obj));
        }
        public DataSet Videos(int cod)
        {
            PublicacionDAO s = new PublicacionDAO();

            return(s.video(cod));
        }
        public byte[] imagenes(int cod)
        {
            PublicacionDAO s = new PublicacionDAO();

            return(s.imagen(cod));
        }
        public string jsonReporte()
        {
            PublicacionDAO s = new PublicacionDAO();

            return(s.jsonReporte());
        }
        public string jsonPublicidad()
        {
            PublicacionDAO s = new PublicacionDAO();

            return(s.jsonPublicidad());
        }
        public string jsonAviso()
        {
            PublicacionDAO s = new PublicacionDAO();

            return(s.jsonAviso());
        }
        public string jsonpublicaciones()
        {
            PublicacionDAO s = new PublicacionDAO();

            return(s.jsonPublicacion());
        }
        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));
        }