public static Object DeleteDocument(int documentID, int userID)
{
try
{
using (var db = new DBContextModel())
{
var document = db.TblDocuments.Find(documentID);
if (document.UserFK != userID)
{
return(new { result = false, info = "Não Autorizado, não foi o utilizador a submeter o documento." });
}
if (!BClass.GetActivity(document.ClassFK ?? 0))
{
return(new { result = false, info = "A turma enconstra-se inativa, já não é possível eliminar o documento." });
}
db.TblDocuments.Remove(document);
db.SaveChanges();
var cla = db.TblClasses.Find(document.ClassFK);
BAction.SetActionToUser(String.Format("Eliminou o documento '{0}' da turma '{1}' da escola '{2}'", document.File.Split('.')[1] + document.File.Split('.')[2], cla.Year + cla.ClassDesc, db.TblSchools.Find(cla.SchoolFK).Name), userID);
return(new { result = true });
}
}
catch (Exception) { return(new { result = false, info = "Não foi possível eliminar o documento." }); }
}
public static List <TblLessonStudents> GetLessonToGuardian(int lessonID, int guardianID)
{
try
{
using (var db = new DBContextModel())
{
var availableStudents = BParenting.GetChildren(guardianID);
List <TblLessonStudents> students = new List <TblLessonStudents>();
availableStudents.ForEach(studentID =>
{
var aux = db.TblLessonStudents.Where(x => x.LessonFK == lessonID && x.StudentFK == studentID).FirstOrDefault();
if (aux != null)
{
students.Add(aux);
}
});
if (students.Count() == 0)
{
return(null);
}
return(students);
}
}
catch (Exception) { return(null); }
}
/// <summary>
/// Metodo que verifica si es posible actualizar datos
/// </summary>
/// <param name="id"></param>
/// <param name="item"></param>
/// <returns></returns>
public bool Put(int id, like_comentario item)
{
using (var db = new DBContextModel())
{
db.Configuration.ProxyCreationEnabled = false;
like_comentario dbitem = db.like_comentario.Find(id);
if (dbitem == null)
{
return(false);
}
//Intercambio los atributos del objeto viejo con los del nuevo}
dbitem.id_user = item.id_user;
dbitem.id_comentario = item.id_comentario;
dbitem.fecha = item.fecha;
//guardo cambios
try
{
db.Entry(dbitem).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
}
public static Boolean EditSesnor(TblSensors sensor)
{
try
{
using (var db = new DBContextModel())
{
var old = db.TblSensors.Find(sensor.ID);
if (old.RoomFK != sensor.RoomFK)
{
var oldroom = db.TblRooms.Find(old.RoomFK);
if (db.TblSensors.Where(x => x.RoomFK == oldroom.ID).Count() <= 1)
{
oldroom.HasSensor = false;
db.Entry(oldroom).State = EntityState.Modified;
db.SaveChanges();
}
var room = db.TblRooms.Find(sensor.RoomFK);
room.HasSensor = true;
db.Entry(room).State = EntityState.Modified;
db.SaveChanges();
}
db.Entry(sensor).State = EntityState.Modified;
db.SaveChanges();
return(true);
}
}
catch (Exception) { return(false); }
}
public static object GetGradesToGuardian(int evaluationID, int guardianID)
{
try
{
using (var db = new DBContextModel())
{
var availableStudents = BParenting.GetChildren(guardianID);
List <TblEvaluationStudents> grades = new List <TblEvaluationStudents>();
availableStudents.ForEach(studentID =>
{
var grade = db.TblEvaluationStudents.Where(x => x.EvaluationFK == evaluationID && x.StudentFK == studentID).FirstOrDefault();
if (grade != null)
{
grades.Add(grade);
}
});
if (grades.Count() == 0)
{
return(new { result = false, info = "Não existe avaliação." });
}
return(new { result = true, data = grades });
}
}
catch (ArgumentException) { return(new { result = false, info = "Não foi encontrada avaliação." }); }
}
public HttpResponseMessage ChangePassWord(string oldPassWord, users itemNew)
{
var data = r.GetById(itemNew.id_user);
if (data == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $"No existe en la base de datos sobre el user a actualizar"));
}
try
{
if (data.pass == oldPassWord)
{
data.pass = itemNew.pass;
using (var db = new DBContextModel())
{
db.Entry(data).State = EntityState.Modified;
db.SaveChanges();
}
return(Request.CreateResponse(HttpStatusCode.OK, $"Contraseña cambiada"));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.NotModified, $"Contraseña incorrecta"));
}
}
catch (Exception ex)
{
Debug.Print(ex.Message);
}
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"No fue posible actualizar la contraseña"));
}
/// <summary>
/// Metodo que verifica si es posible actualizar datos
/// </summary>
/// <param name="id"></param>
/// <param name="item"></param>
/// <returns></returns>
public bool Put(int id, publicaciones item)
{
using (var db = new DBContextModel())
{
db.Configuration.ProxyCreationEnabled = false;
publicaciones dbitem = db.publicaciones.Find(id);
if (dbitem == null)
{
return(false);
}
//Intercambio los atributos del objeto viejo con los del nuevo}
dbitem.id_user = item.id_user;
dbitem.descripcion = item.descripcion;
dbitem.fecha_creacion = item.fecha_creacion;
dbitem.fecha_actualizacion = item.fecha_actualizacion;
dbitem.isDeleted = item.isDeleted;
//guardo cambios
try
{
db.Entry(dbitem).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
}
public HttpResponseMessage getSeguidores(int idUser)//idUser es el seguido
{
if (!ValidandoSiExistenDatosRelacionados.ExistsUser(idUser))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $"No existe tal usuario, id: {idUser}"));
}
using (var db = new DBContextModel())
{
List <userModel> usuarios = db.seguidores.Where(o => o.id_seguido == idUser)
.Include(o => o.users).Select(
b => new userModel
{
apellido = b.users.apellido,
descripcion = b.users.descripcion,
email = b.users.email,
id_user = b.users.id_user,
isVendor = b.users.isVendor,
nombre = b.users.nombre,
pass = "******",
puntaje = b.users.puntaje,
username = b.users.username,
img = b.users.img,
puesto_name = b.users.puesto_name,
isActive = b.users.isActive,
dui = b.users.dui,
isDeleted = b.users.isDeleted,
num_telefono = b.users.num_telefono,
xlat = b.users.xlat,
ylon = b.users.ylon
}
).ToList();
return(Request.CreateResponse(HttpStatusCode.OK, usuarios));
}
}
public HttpResponseMessage logout(int id, users item)
{
if (id == item.id_user)
{
var data = r.GetById(id);
if (data == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $"No existe en la base de datos sobre el usuario a actualizar"));
}
try
{
data.Phone_OS = "";
data.Device_id = "";
using (var db = new DBContextModel())
{
db.Entry(data).State = EntityState.Modified;
db.SaveChanges();
}
return(Request.CreateResponse(HttpStatusCode.OK, $"Sesión finalizada"));
}
catch (Exception ex)
{
Debug.Print(ex.Message);
}
}
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"No fue posible actualizar la contraseña"));
}
public HttpResponseMessage vendors()
{
using (var db = new DBContextModel())
{
var vendedores = db.users
.Where(u => u.isVendor)
.Select(u =>
new userModel
{
apellido = u.apellido,
descripcion = u.descripcion,
email = u.email,
id_user = u.id_user,
isVendor = u.isVendor,
nombre = u.nombre,
pass = "******",
puntaje = u.puntaje,
username = u.username,
img = u.img,
puesto_name = u.puesto_name,
isActive = u.isActive,
dui = u.dui,
isDeleted = u.isDeleted,
num_telefono = u.num_telefono,
xlat = u.xlat,
ylon = u.ylon,
id_categoria = u.id_categoria,
imgCategoria = u.categoria.img,
nombreCategoria = u.categoria.nombre
}
).ToList();
return(Request.CreateResponse(HttpStatusCode.OK, vendedores));
}
}
public static Boolean SendNotificationToUser(NotificationUser notification, int userID)
{
try
{
using (var db = new DBContextModel())
{
TblNotifications notif = new TblNotifications
{
Description = notification.Description,
Hour = DateTime.Now,
Subject = notification.Subject,
Urgency = notification.Urgency,
Approval = notification.Approval,
UserFK = notification.SenderFK
};
db.TblNotifications.Add(notif);
db.SaveChanges();
TblValidations valid = new TblValidations
{
NotificationFK = notif.ID,
ReceiverFK = notification.ReceiverFK,
Accepted = false,
Read = false,
StudentFK = notification.StudentFK
};
db.TblValidations.Add(valid);
db.SaveChanges();
BAction.SetActionToUser(String.Format("enviou uma notificação ao utilizador '{0}'", db.TblUsers.Find(notification.ReceiverFK).Name), userID);
return(true);
}
}
catch (Exception) { return(false); }
}
public HttpResponseMessage deviceRegisterAgain(users item)
{
try
{
using (var db = new DBContextModel())
{
var userObtenido = db.users.Find(item.id_user);
if (userObtenido != null)
{
userObtenido.Device_id = item.Device_id;
userObtenido.Phone_OS = item.Phone_OS;
db.Entry(userObtenido).State = EntityState.Modified;
db.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, "Notificaciones Push configuradas"));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Contraseña incorrecta"));
}
}
}
catch (Exception) { }
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "No es posible comparar los datos proporcionados"));
}
public static object GetStudentsWithoutClass()
{
try
{
using (var db = new DBContextModel())
{
string year;
if (DateTime.Now.Month < 13 && DateTime.Now.Month > 7)
{
year = (DateTime.Now.Year + 1).ToString();
}
else
{
year = DateTime.Now.Year.ToString();
}
var students = db.TblUsers.Where(x => db.TblUserRoles.Any(y => y.RoleFK == 1 && y.UserFK == x.ID)).ToList();
var studentsWithoutClass = students.Where(x => !db.TblClassUsers.Any(y => x.ID == y.UserFK)).ToList();
if (studentsWithoutClass.Count() == 0)
{
return(null);
}
return(studentsWithoutClass);
}
}
catch (Exception) { return(null); }
}
/// <summary>
/// Metodo que verifica si es posible actualizar datos
/// </summary>
/// <param name="id"></param>
/// <param name="item"></param>
/// <returns></returns>
public bool Put(int id, seguidores item)
{
using (var db = new DBContextModel())
{
db.Configuration.ProxyCreationEnabled = false;
seguidores dbitem = db.seguidores.Find(id);
if (dbitem == null)
{
return(false);
}
//Intercambio los atributos del objeto viejo con los del nuevo}
dbitem.seguidor_id = item.seguidor_id;
dbitem.id_seguido = item.id_seguido;
dbitem.accepted = item.accepted;
dbitem.fecha = item.fecha;
//guardo cambios
try
{
db.Entry(dbitem).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
}
/// <summary>
/// Metodo que verifica si es posible actualizar datos
/// </summary>
/// <param name="id"></param>
/// <param name="item"></param>
/// <returns></returns>
public bool Put(int id, visita_busqueda item)
{
using (var db = new DBContextModel())
{
db.Configuration.ProxyCreationEnabled = false;
visita_busqueda dbitem = db.visita_busqueda.Find(id);
if (dbitem == null)
{
return(false);
}
//Intercambio los atributos del objeto viejo con los del nuevo}
dbitem.id_userquebusco = item.id_userquebusco;
dbitem.id_perfilvisitado = item.id_perfilvisitado;
dbitem.fecha = item.fecha;
//guardo cambios
try
{
db.Entry(dbitem).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
}
public static Boolean EditUser(User editedUser, int userID)
{
try
{
using (var db = new DBContextModel())
{
var user = db.TblUsers.Find(editedUser.ID);
user.Name = editedUser.Name;
user.Email = editedUser.Email;
user.Address = editedUser.Address;
user.CitizenCard = editedUser.CitizenCard;
user.Curriculum = editedUser.Curriculum;
user.FiscalNumber = editedUser.FiscalNumber;
user.PhoneNumber = editedUser.PhoneNumber;
user.Photo = editedUser.Photo;
user.Function = editedUser.Function;
user.DateOfBirth = editedUser.DateOfBirth;
db.Entry(user).State = EntityState.Modified;
db.SaveChanges();
BAction.SetActionToUser(String.Format("Editou os dados do utilizador '{0}'", editedUser.Name), userID);
return(true);
}
}
catch (Exception) { return(false); }
}
/// <summary>
/// Recibe un objeto como paramentro y posteriormente intenta almacenarlo en la base de datos
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public async Task <HttpResponseMessage> Post(seguidores item)
{
if (item == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"El seguidor no puede estar sin datos"));
}
if (!ValidandoSiExistenDatosRelacionados.ExistsUser(item.id_seguido))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"No existe el usuario seguido {item.id_seguido}"));
}
if (!ValidandoSiExistenDatosRelacionados.ExistsUser(item.seguidor_id))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"No existe el seguidor {item.seguidor_id}"));
}
if (item.id_seguido == item.seguidor_id)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"No puedes seguirte a ti mismo"));
}
using (var db = new DBContextModel())
{
var seguidorDatos = db.seguidores
.FirstOrDefault(s => s.id_seguido == item.id_seguido && s.seguidor_id == item.seguidor_id);
if (seguidorDatos == default(seguidores))
{
item.accepted = true;
item.fecha = DateTime.Now;
if (r.Post(item))
{
//TODO Push Seguido
var usuarioSeguido = db.users.Find(item.id_seguido);
var usuarioSEGUIDOR = db.users.Find(item.seguidor_id);
var receiptInstallID = new Dictionary <string, string>();
try
{
receiptInstallID.Add(usuarioSeguido.Phone_OS, usuarioSeguido.Device_id);
}
catch (Exception) { /**No todos los usuarios tienen telefono asociado **/ }
AppCenterPush appCenterPush = new AppCenterPush(receiptInstallID);
await appCenterPush.Notify("Seguidor nuevo",
$"{usuarioSEGUIDOR.username} ahora te sigue",
"Ve a darle una revisada a su perfil",
new Dictionary <string, string>() {
{ DLL.PushConstantes.gotoPage, DLL.PushConstantes.goto_profile },
{ DLL.PushConstantes.id_user, item.seguidor_id.ToString() }
});
return(Request.CreateResponse(HttpStatusCode.Created, "seguidor guardado correctamente"));
}
}
else
{
return(Request.CreateResponse(HttpStatusCode.OK, "Ya sigues a este usuario, actualiza la página en la que te encuentras"));
}
}
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "No es posible guardar los datos del seguidor"));
}
public HttpResponseMessage login(users item)
{
//Retorno objeto con id
if (item == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "No es posible analizar los datos proporcionados"));
}
try
{
using (var db = new DBContextModel())
{
var userObtenido = db.users.Where(u => u.username == item.username || u.email == item.username).ToList();
if (userObtenido.Count <= 0)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No se encontro el usuario o correo proporcionado"));
}
var usuarioDB = userObtenido.First();
if (usuarioDB.pass == item.pass)
{
usuarioDB.isDeleted = false;
usuarioDB.Device_id = item.Device_id;
usuarioDB.Phone_OS = item.Phone_OS;
db.Entry(usuarioDB).State = EntityState.Modified;
db.SaveChanges();
userModel usuario = new userModel()
{
apellido = usuarioDB.apellido,
descripcion = usuarioDB.descripcion,
email = usuarioDB.email,
id_user = usuarioDB.id_user,
isVendor = usuarioDB.isVendor,
nombre = usuarioDB.nombre,
pass = usuarioDB.pass,
puntaje = usuarioDB.puntaje,
username = usuarioDB.username,
img = usuarioDB.img,
puesto_name = usuarioDB.puesto_name,
isActive = usuarioDB.isActive,
dui = usuarioDB.dui,
isDeleted = usuarioDB.isDeleted,
num_telefono = usuarioDB.num_telefono,
xlat = usuarioDB.xlat,
ylon = usuarioDB.ylon
};
return(Request.CreateResponse(HttpStatusCode.OK, usuario));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Contraseña incorrecta"));
}
}
}
catch (Exception) { }
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "No es posible comparar los datos proporcionados"));
}
public static Object GetUserProfile(int userID)
{
try
{
using (var db = new DBContextModel())
{ return(db.TblUsers.Where(x => x.ID == userID).Select(x => new { x.ID, x.Photo, x.Name, x.Email, x.IsActive, x.Function }).FirstOrDefault()); }
}
catch (Exception) { return(null); }
}
public static Object GetUserDetails(int userID)
{
try
{
using (var db = new DBContextModel())
{ return(db.TblUsers.Where(x => x.ID == userID).Select(x => new { x.ID, x.Photo, x.FiscalNumber, x.CitizenCard, x.PhoneNumber, x.Address, x.Name, x.Email, x.RegisterDate, x.Function, x.Curriculum, x.DateOfBirth, x.IsActive }).FirstOrDefault()); }
}
catch (Exception) { return(null); }
}
public HttpResponseMessage GetPostsSaved(int idUser)
{
using (var db = new DBContextModel())
{
var publicacionesGuardadas = db.publicacion_guardada
.Include(p => p.users)
.Include(p => p.publicaciones)
.Include(p => p.publicaciones.like_post)
.Where(p => p.id_user == idUser)
.OrderByDescending(f => f.fecha)
.Select(
p =>
new ResponsePublicacionFeed
{
publicacion = new DLL.Models.publicacionesModel
{
descripcion = p.publicaciones.descripcion,
fecha_actualizacion = p.publicaciones.fecha_actualizacion,
fecha_creacion = p.publicaciones.fecha_creacion,
id_post = p.publicaciones.id_post,
id_user = p.publicaciones.id_user,
img = p.publicaciones.img,
isImg = p.publicaciones.isImg,
isDeleted = p.publicaciones.isDeleted
},
UsuarioCreator = new DLL.Models.userModel
{
apellido = p.users.apellido,
descripcion = p.users.descripcion,
email = p.users.email,
id_user = p.users.id_user,
isVendor = p.users.isVendor,
nombre = p.users.nombre,
pass = "******",
puntaje = p.users.puntaje,
username = p.users.username,
img = p.users.img,
puesto_name = p.users.puesto_name,
isActive = p.users.isActive,
dui = p.users.dui,
isDeleted = p.users.isDeleted,
num_telefono = p.users.num_telefono,
xlat = p.users.xlat,
ylon = p.users.ylon
},
cantComentarios = p.publicaciones.comentarios.Count,
cantLikes = p.publicaciones.like_post.Count,
IsLiked = p.publicaciones.like_post.FirstOrDefault(l => l.id_user == idUser) == default(like_post) ? false : true,
IsSavedPost = true
}
).OrderByDescending(f => f.publicacion.fecha_creacion).ToList();
return(Request.CreateResponse(HttpStatusCode.OK, publicacionesGuardadas));
}
}
public static Object GetFloor(int floorID)
{
try
{
using (var db = new DBContextModel())
{
return(db.TblFloors.Find(floorID));
}
}
catch (Exception) { return(null); }
}
private static Boolean _VerifyUser(String CitizenCard)
{
try
{
using (var db = new DBContextModel())
{
return((db.TblUsers.Any(x => x.CitizenCard == CitizenCard)) ? true : false);
}
}
catch (Exception) { return(false); }
}
public static Object GetNotification(int notifID)
{
try
{
using (var db = new DBContextModel())
{
return(db.TblNotifications.Find(notifID));
}
}
catch (Exception) { return(null); }
}
public static int GetUnreadCount(int userID)
{
try
{
using (var db = new DBContextModel())
{
return(db.TblValidations.Where(x => x.ReceiverFK == userID && x.Read == false).Count());
}
}
catch (Exception) { return(0); }
}
public static Object GetSchools()
{
try
{
using (var db = new DBContextModel())
{
return(new { result = true, data = db.TblSchools.ToList() });
}
}
catch (Exception) { return(new { result = true, info = "Não foram encontradas escolas" }); }
}
public static Object GetSchool(int schoolID)
{
try
{
using (var db = new DBContextModel())
{
return(new { result = true, data = db.TblSchools.Find(schoolID) });
}
}
catch (Exception) { return(new { result = false, info = "Escola não encontrada." }); }
}
public static TblLessonStudents GetLessonToStudent(int lessonID, int studentID)
{
try
{
using (var db = new DBContextModel())
{
return(db.TblLessonStudents.Find(lessonID, studentID));
}
}
catch (Exception) { return(null); }
}
public static int GetClassbyLesson(TblLessonStudents lesson)
{
try
{
using (var db = new DBContextModel())
{
return(db.TblSchedules.Find(db.TblLessons.Find(lesson.LessonFK).ScheduleFK).ClassFK ?? default(int));
}
}
catch (Exception) { return(0); }
}
public static Boolean VerifyTeacher(TblLessonStudents lesson, int teacherID)
{
try
{
using (var db = new DBContextModel())
{
return(db.TblSchedules.Find(db.TblLessons.Find(lesson.LessonFK).ScheduleFK).TeacherFK == teacherID ? true : false);
}
}
catch (Exception) { return(false); }
}
