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); }
}
/// <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);
}
}
}
/// <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);
}
}
}
/// <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 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 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"));
}
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"));
}
/// <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);
}
}
}
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); }
}
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 bool EditTime(TblTimes time)
{
try
{
using (var db = new DBContextModel())
{
db.Entry(time).State = EntityState.Modified;
db.SaveChanges();
return(true);
}
}
catch (Exception) { return(false); }
}
public static Object EditGrade(TblEvaluationStudents grade)
{
try
{
using (var db = new DBContextModel())
{
db.Entry(grade).State = EntityState.Modified;
db.SaveChanges();
return(new { result = true });
}
}
catch (Exception) { return(new { result = false, info = "Não foi possível alterar a nota da avaliação" }); }
}
public static Boolean EditFloor(TblFloors floor)
{
try
{
using (var db = new DBContextModel())
{
db.Entry(floor).State = EntityState.Modified;
db.SaveChanges();
return(true);
}
}
catch (Exception) { return(false); }
}
public static Boolean EditFaults(TblLessonStudents lesson)
{
try
{
using (var db = new DBContextModel())
{
db.Entry(lesson).State = EntityState.Modified;
db.SaveChanges();
return(true);
}
}
catch (Exception) { return(false); }
}
public static bool EditSubject(TblSubjects subject)
{
try
{
using (var db = new DBContextModel())
{
db.Entry(subject).State = EntityState.Modified;
db.SaveChanges();
return(true);
}
}
catch (Exception) { return(false); }
}
public categoria ActualizarCategoria(categoria item)
{
var obj = db.categoria.Find(item.id_categoria);
if (obj == null)
{
return(null);
}
obj.img = item.img;
obj.nombre = item.nombre;
db.Entry(obj).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(obj);
}
public static Boolean EditTask(TblTasks task, int userID)
{
try
{
using (var db = new DBContextModel())
{
db.Entry(task).State = EntityState.Modified;
db.SaveChanges();
BAction.SetActionToUser(String.Format("Editou a tarefa '{0}' ao utilizador '{1}'", task.Description, db.TblUsers.Find(task.UserFK).Name), userID);
return(true);
}
}
catch (Exception) { return(false); }
}
public static Object EditClass(TblClasses alteredClass, int userID)
{
try
{
using (var db = new DBContextModel())
{
db.Entry(alteredClass).State = EntityState.Modified;
db.SaveChanges();
BAction.SetActionToUser(String.Format("Editou a turma '{0}' da escola '{1}'", alteredClass.Year + alteredClass.ClassDesc, db.TblSchools.Find(alteredClass.SchoolFK).Name), userID);
return(new { result = true });
}
}
catch (Exception) { return(new { result = false, info = "Não foi possível editar a turma." }); }
}
public static Boolean AcceptNotification(int notifID, int userID)
{
try
{
using (var db = new DBContextModel())
{
var valid = db.TblValidations.Find(userID, notifID);
valid.Accepted = true;
db.Entry(valid).State = EntityState.Modified;
db.SaveChanges();
return(true);
}
}
catch (Exception) { return(false); }
}
public static bool EditNotice(TblNotices notice, int userID)
{
try
{
using (var db = new DBContextModel())
{
db.Entry(notice).State = EntityState.Modified;
db.SaveChanges();
BAction.SetActionToUser(String.Format("Editou o anuncio '{0}' de escola '{1}'", notice.Title, db.TblSchools.Find(notice.SchoolFK).Name), userID);
return(true);
}
}
catch (Exception) { return(false); }
}
public static Object EditEvaluation(TblEvaluations evaluation, int userID)
{
try
{
using (var db = new DBContextModel())
{
db.Entry(evaluation).State = EntityState.Modified;
db.SaveChanges();
var cla = db.TblClasses.Find(evaluation.ClassFK);
BAction.SetActionToUser(String.Format("Editou uma avaliação na turma '{0}' da escola '{1}'", 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 alterar a avaliação" }); }
}
public static Boolean EditSchedule(TblSchedules schedule, int userID)
{
try
{
using (var db = new DBContextModel())
{
db.Entry(schedule).State = EntityState.Modified;
db.SaveChanges();
var clas = db.TblClasses.Find(schedule.ClassFK);
BAction.SetActionToUser(String.Format("Editou o horário de uma aula da turma '{0}'", clas.Year + clas.ClassDesc), userID);
return(true);
}
}
catch (Exception) { return(false); }
}
public static Boolean CreateSesnor(TblSensors sensor)
{
try
{
using (var db = new DBContextModel())
{
db.TblSensors.Add(sensor);
db.SaveChanges();
var room = db.TblRooms.Find(sensor.RoomFK);
room.HasSensor = true;
db.Entry(room).State = EntityState.Modified;
db.SaveChanges();
return(true);
}
}
catch (Exception) { return(false); }
}
public static Object SwitchActivity(int classID, int userID)
{
try
{
using (var db = new DBContextModel())
{
var cla = db.TblClasses.Find(classID);
cla.IsActive = cla.IsActive ? false : true;
db.Entry(cla).State = EntityState.Modified;
db.SaveChanges();
BAction.SetActionToUser(String.Format("Alterou o estado de actividade da turma '{0}' da escola '{1}' para '{2}'", cla.Year + cla.ClassDesc, db.TblSchools.Find(cla.SchoolFK).Name, (cla.IsActive?"ACTIVO":"INACTIVO")), userID);
return(new { result = true });
}
}
catch (Exception) { return(new { result = false, info = "Não foi possível alterar estado de atividade da turma." }); }
}
public static Boolean EditLesson(TblLessons lesson, int userID)
{
try
{
using (var db = new DBContextModel())
{
db.Entry(lesson).State = EntityState.Modified;
db.SaveChanges();
var schedule = db.TblSchedules.Find(lesson.ScheduleFK);
var clas = db.TblClasses.Find(schedule.ClassFK);
BAction.SetActionToUser(String.Format("Editou a lição à disciplina '{0}' da turma '{1}' da escola '{2}'", db.TblSubjects.Find(schedule.SubjectFK).Name, clas.Year + clas.ClassDesc, db.TblSchools.Find(clas.SchoolFK).Name), userID);
return(true);
}
}
catch (Exception) { return(false); }
}
public static Boolean SwitchActivity(int userID, int currentUser)
{
try
{
using (var db = new DBContextModel())
{
var user = db.TblUsers.Find(userID);
user.IsActive = (bool)user.IsActive ? false : true;
db.Entry(user).State = EntityState.Modified;
db.SaveChanges();
//ActiveDirectory.DisableOrEnableUser(user.Email);
BAction.SetActionToUser(String.Format("Alterou o estado de atividade do utilizador '{0}'", user.Name), currentUser);
return(true);
}
}
catch (Exception) { return(false); }
}
public static Boolean RemoveSensor(int sensorID)
{
try
{
using (var db = new DBContextModel())
{
var sensor = db.TblSensors.Find(sensorID);
var room = db.TblRooms.Find(sensor.RoomFK);
if (db.TblSensors.Where(x => x.RoomFK == room.ID).Count() <= 1)
{
room.HasSensor = false;
db.Entry(room).State = EntityState.Modified;
db.SaveChanges();
}
db.TblSensors.Remove(sensor);
db.SaveChanges();
return(true);
}
}
catch { 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, users item)
{
using (var db = new DBContextModel())
{
db.Configuration.ProxyCreationEnabled = false;
users dbitem = db.users.Find(id);
if (dbitem == null)
{
return(false);
}
//Intercambio los atributos del objeto viejo con los del nuevo}
dbitem.apellido = item.apellido;
dbitem.descripcion = item.descripcion;
dbitem.dui = item.dui;
dbitem.email = item.email;
dbitem.isActive = item.isActive;
dbitem.isDeleted = item.isDeleted;
dbitem.isVendor = item.isVendor;
dbitem.nombre = item.nombre;
dbitem.num_telefono = item.num_telefono;
dbitem.puesto_name = item.puesto_name;
dbitem.puntaje = item.puntaje;
dbitem.username = item.username;
dbitem.xlat = item.xlat;
dbitem.ylon = item.ylon;
//guardo cambios
try
{
db.Entry(dbitem).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
}
public HttpResponseMessage ChangePhoto(int id, 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 usuario a actualizar"));
}
try
{
data.img = itemNew.img;
using (var db = new DBContextModel())
{
db.Entry(data).State = EntityState.Modified;
db.SaveChanges();
}
return(Request.CreateResponse(HttpStatusCode.OK, $"Foto cambiada"));
}
catch (Exception ex)
{
Debug.Print(ex.Message);
}
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"No fue posible actualizar la contraseña"));
}
public static Object EditDocument(TblDocuments document, int userID)
{
try
{
using (var db = new DBContextModel())
{
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 alterar o documento." });
}
db.Entry(document).State = EntityState.Modified;
db.SaveChanges();
var cla = db.TblClasses.Find(document.ClassFK);
BAction.SetActionToUser(String.Format("Alterou 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 alterar o documento." }); }
}