public ResponseModel Autenticarse()
{
var rm = new ResponseModel();
try
{
using (var ctx = new ApplicationDbContext())
{
var usuario = ctx.Usuarios.Where(x => x.Nombreusuario == this.Nombreusuario && x.Contraseña == this.Contraseña).SingleOrDefault();
if (usuario != null)
{
//SessionHelper.AddUserToSession(usuario.UsuarioId.ToString());
SessionHelper.AddUserToSessionTicket(usuario.UsuarioId, usuario.Nombreusuario, usuario.RolId.ToString());
rm.SetResponse(true);
}
else
{
rm.SetResponse(false, "Acceso denegado al sistema");
}
}
}
catch (Exception e)
{
rm.SetResponse(false, "Error en el sistema, contacte a su administrador");//Base de datos
}
return(rm);
}
public ResponseModel Acceder(string Email, string Password)
{
try
{
using (var ctx = new CmsContext())
{
Password = HashHelper.MD5(Password);
var usuario = ctx.Usuario.Where(x => x.Email == Email)
.Where(x => x.Password == Password)
.SingleOrDefault();
if (usuario != null)
{
SessionHelper.AddUserToSession(usuario.idUsuario.ToString());
rm.SetResponse(true);
}
else
{
rm.SetResponse(false, "Correo o contraseña incorrecta");
}
}
}
catch (Exception)
{
throw;
}
return(rm);
}
public JsonResult enviarCorreoFose(string correo, int id, string codigoorden, string clienteorden, string numeroorden)
{
var rm = new ResponseModel();
Usuario user = new Usuario();
var getemp = user.ObtenerPerfil(SessionHelper.GetUser());
var correousuario = getemp.correo.ToString();
EnvioCorreo correoo = new EnvioCorreo();
var resgenFose = generarFoseCorreo(id);
if (resgenFose)
{
try
{
//string stServidor = ConfigurationManager.AppSettings["stServidor"].ToString();
// string stUsuario = ConfigurationManager.AppSettings["stUsuario"].ToString();
// string stPassword = ConfigurationManager.AppSettings["stPassword"].ToString();
// string stPuerto = ConfigurationManager.AppSettings["stPuerto"].ToString();
string stServidor = "smtp.gmail.com";
string stUsuario = "*****@*****.**";
string stPassword = "******";
string asunto = "SERVICIO DE ALQUILER DE LAPTOP (fose) - " + clienteorden + " - " + codigoorden;
string mensaje = "Se adjunta el Fose N#" + numeroorden;
string stFrom = "*****@*****.**";
string stNombreFrom = "Renting (NetCorporate)";
string stTo = correousuario;
string stoCC = correo;
string stArchivo = "D:/netcorporate.net/rentt/correo/fose/fose" + id + ".pdf";
string stArchivo2 = "";
correoo.envioMensajeEmail(stServidor, stUsuario, stPassword, stFrom, stNombreFrom, stTo, asunto, mensaje, stArchivo, stArchivo2, stoCC);
rm.SetResponse(true);
rm.message = "enviado con exito";
stArchivo = null;
correoo.Dispose();
//Response.Write("<sript>alert('se envioi con exito')<script>");
}
catch (Exception ex)
{
// rm.SetResponse(false);
rm.message = ex.Message;
}
}
else
{
rm.SetResponse(false);
rm.message = "No se pudo Generar el Fose";
}
return(Json(rm, JsonRequestBehavior.AllowGet));
}
public ResponseModel ValidarLogin(string Usuario, string Contraseña)
{
var rm = new ResponseModel();
Contraseña = HashHelper.SHA1(Contraseña);
try
{
using (var db = new ModeloGGYM())
{
//Contraseña = HashHelper.SHA1(Contraseña);
var usuario = db.USUARIO.Where(x => x.EMAIL == Usuario)
.Where(x => x.PASSWORD == Contraseña)
.SingleOrDefault();
if (usuario != null)
{
SessionHelper.AddUserToSession(usuario.ID_USUARIO.ToString());
rm.SetResponse(true);
rm.idtipo = usuario.ID_TIPOUSUARIO;
}
else
{
rm.SetResponse(false, "Usuario y/o Password incorrectos");
}
}
}
catch (Exception)
{
throw;
}
return(rm);
}
public ResponseModel Autenticarse()
{
var rm = new ResponseModel();
try
{
using (var ctx = new BaseDeDatosEntities())
{
var usuario = ctx.Usuarios.Where(x => x.Correo == this.Correo && x.Password == this.Password).SingleOrDefault();
if (usuario != null)
{
SessionHelper.AddUserToSession(usuario.id.ToString());
rm.SetResponse(true);
}
else
{
rm.SetResponse(false, "Acceso denegado al sistema");
}
}
}
catch (Exception e)
{
throw;
}
return(rm);
}
public static ResponseModel Acceder(this DbSet <Usuario> dbset, string Email, string password)
{
var rm = new ResponseModel();
try
{
using (var ctx = new Model1())
{
password = HashHelper.MD5(password);
var usuario = ctx.Usuario.Where(x => x.Email == Email)
.Where(x => x.Password == password)
.SingleOrDefault();
if (usuario != null)
{
SessionHelper.AddUserToSession(usuario.UsuarioID.ToString());
rm.SetResponse(true);
}
else
{
rm.SetResponse(false, "Correo o Contraseña incorrecto.");
}
}
}
catch (Exception e)
{
throw;
}
return(rm);
}
public JsonResult GenerarCopia(EntidadFiltro model)
{
var rm = new ResponseModel();
int idPeriodo = model.IdPeriodo;
int idMoneda = model.IdMoneda;
if (ModelState.IsValid)
{
rm = foto.GenerarFoto(model.IdPeriodo, 5, model.FechaCalculo);
if (rm.response)
{
var lista = foto.ListarFoto(model.IdPeriodo, 5);
if (lista.Count > 0)
{
//rm.function = "MensajeGrabacion()";
rm.SetResponse(false, "La copia de las pólizas se generaron con exito!");
//rm.href = Url.Content("~/reserva/importar");
}
else
{
rm.SetResponse(false, "No hay pólizas para la moneda selecionada.");
}
}
}
return(Json(rm));
}
public JsonResult ver_guia_recepcion(int id)
{
var rm = new ResponseModel();
/*if (System.IO.File.Exists("C:/reports/fose/fose" + id + ".pdf"))
* {
* rm.message = "El Fichero ya existe, Desea Generar de nuevo";
* }else
* {*/
var resguiarecepcion = generarGuiaRecepcion(id);
if (resguiarecepcion)
{
rm.SetResponse(true);
rm.href = "http://192.168.0.9/rentt/reports/guiasrecepcion/guiarecepcion" + id + ".pdf";
}
else
{
rm.SetResponse(false);
rm.message = "no se pudo crear la guia de recepcion";
}
// }
return(Json(rm, JsonRequestBehavior.AllowGet));
}
public JsonResult guardarMasivo(NotificacionViewModel model)
{
var rm = new ResponseModel();
CTE_NOTIFICACION_GRUPO cTE_NOTIFICACION_GRUPO = new CTE_NOTIFICACION_GRUPO();
try
{
if (ModelState.IsValid)
{
var grupo = (from c in db.CTE_NOTIFICACION_GRUPO
where c.ID == model.GRUPO
select c.NOMBRE
).FirstOrDefault();
var data = cTE_NOTIFICACION_GRUPO.ListarEstadisticas(grupo);
if ((data != null) && (data.Count != 0))
{
foreach (var obj in data)
{
var tokenUser = (from c in db.CTE_CUENTA_USUARIO
where c.CuentaUsuarioId == obj.IDCLIENTE && c.BLOQUEADO == false
select c.FCM_TOKEN
).FirstOrDefault();
if (tokenUser != null)
{
rm = notificacion.enviarFirebase(model.TITULO, model.CUERPO_NOTIFICACION, tokenUser);
if (rm.response)
{
model.CuentaUsuarioId = obj.IDCLIENTE;
model.Guardar(model);
rm.function = "cleanForm()";
}
}
}
rm.SetResponse(true, "Notificaciones Enviadas!");
}
else
{
rm.SetResponse(false, "No existen registros para ser enviados");
}
}
else
{
rm.SetResponse(false, "El formulario esta incorrecto");
}
}
catch (Exception ex)
{
rm.SetResponse(false, ex.Message);
}
return(Json(rm));
}
public JsonResult Crear(string[] alumnos, string id_listaEspecialidades)
{
string[] alumnos_noRepeat = alumnos;
ResponseModel responseModel = new ResponseModel();
if (alumnos != null)
{
alumnos_noRepeat = alumnos.Distinct <String>().ToArray();
}
if (alumnos != null && !String.IsNullOrEmpty(id_listaEspecialidades))
{
var personas = db.Persona.Where(r => r.Rol.Equals("Alumno")).ToList();
foreach (var id in alumnos_noRepeat)
{
var comp = personas.Where(n => n.Numero_control.Equals(id)).FirstOrDefault();
if (comp == null && !String.IsNullOrEmpty(id) && !String.IsNullOrWhiteSpace(id))
{
Persona model = new Persona
{
Persona_id = Guid.NewGuid(),
Rol = "Alumno",
Nombre = " ",
Apellido_materno = " ",
Apellido_paterno = " ",
Numero_control = id,
Genero = true
};
PersonaEspecialidad personaEspecialidad = new PersonaEspecialidad
{
PersonaEspecialidad_id = Guid.NewGuid(),
Especialidad = db.ListaEspecialidades.Find(new Guid(id_listaEspecialidades)),
Persona = model
};
db.PersonaEspecialidad.Add(personaEspecialidad);
model.Especialidades.Add(personaEspecialidad);
db.Persona.Add(model);
}
}
db.SaveChanges();
responseModel.SetResponse(true);
responseModel.function = "CargarTabla()";
responseModel.message = "Cambios guardados correctamente";
return(Json(responseModel));
}
// responseModel.href = "/Admin/NumeroControl/Create/";
responseModel.SetResponse(true);
return(Json(responseModel));
}
public JsonResult Autenticar(LoginViewModel model)
{
var rm = new ResponseModel();
var errors = ModelState.Where(x => x.Value.Errors.Count > 0).Select(x => new { x.Key, x.Value.Errors }).ToArray();
if (ModelState.IsValid)
{
this.um.Nombreusuario = model.NombreDeUsuario;
this.um.Contraseña = model.Password;
rm = um.Autenticarse();
if (rm.response)
{
rm.href = Url.Action("Index", "Acts");
}
}
else
{
rm.SetResponse(false, "Debe llenar los campos para poder autenticarse.");
}
return(Json(rm));
}
/* Param Archivo --> el nombre del parámetro debe coincidir con el Nombre del Input de la vista parcial donde cargaremos el adjunto
* para que cuando se envia al servidor nuestro controlador, nuestra accion lo detecte y sepa que estamos especificando un archivo*/
public JsonResult GuardarAdjunto(Adjunto model, HttpPostedFileBase Archivo)
{
var rm = new ResponseModel();
//Es importante validar desde el servidor porque el Javascript puede ser desactivado
if (Archivo != null)
{
// Nombre del archivo, es decir, lo renombramos para que no se repita nunca , System.IO para usar Path, GetExtension va a a capturar la extension del archivo
string archivo = DateTime.Now.ToString("yyyyMMddHHmmss") + Path.GetExtension(Archivo.FileName);
// La ruta donde lo vamos guardar
Archivo.SaveAs(Server.MapPath("~/uploads/" + archivo));
// Establecemos en nuestro modelo el nombre del archivo
model.Archivo = archivo;
rm = model.Guardar();
if (rm.response)
{
rm.function = "CargarAdjuntos()";
}
}
rm.SetResponse(false, "Debe adjuntar una archivo");
return(Json(rm));
}
public ResponseModel Guardar()
{
var rm = new ResponseModel();
try
{
using (var ctx = new PortafolioContext())
{
if (this.id > 0)
{
ctx.Entry(this).State = EntityState.Modified;
}
else
{
ctx.Entry(this).State = EntityState.Added;
}
ctx.SaveChanges();
rm.SetResponse(true);
}
}
catch (Exception)
{
throw;
}
return(rm);
}
public JsonResult Crear(Subtema model, Guid id)
{
ResponseModel responseModel = new ResponseModel();
model.Tema = db.Tema.Find(id);
model.Subtema_id = Guid.NewGuid();
if (model.Tema == null)
{
RedirectToAction("Index");
}
else
{
if (String.IsNullOrEmpty(model.Subtema_nombre) || String.IsNullOrWhiteSpace(model.Subtema_nombre))
{
responseModel.function = "CargarTabla()";
responseModel.message = "No dejes campos vacios";
return(Json(responseModel));
}
db.Subtema.Add(model);
db.SaveChanges();
responseModel.SetResponse(true);
responseModel.function = "CargarTabla()";
responseModel.message = "Cambios guardados correctamente";
}
return(Json(responseModel));
}
public JsonResult Acceder(string Login, string Password)
{
var rm = new ResponseModel();
if (Login != "")
{
rm = usuario.Acceder(Login, Password);
if (rm.response)
{
rm.href = Url.Content("~/Default");
}
else
{
if (rm.bloqueo)
{
rm.href = Url.Content("~/");
}
//BloqueoUsuario(Login);
}
}
else
{
rm.SetResponse(false, "Correo o contraseña incorrecta");
}
return(Json(rm));
}
//Se guardan los alumnos del alumno en modo de edición
//HttpPostedFileBase name debe coincidir con el name de la etiqueta file en el form
public JsonResult GuardarAdjunto(Adjunto model, HttpPostedFileBase Archivo)
{
var rm = new ResponseModel();
// Validar si viene o no el archivo
if (Archivo != null)
{
//Nombre archivo: Fecha exacta actual más extensión de archivo
string archivo = DateTime.Now.ToString("yyyyMMddHHmmss") + Path.GetExtension(Archivo.FileName);
//Guardar archivo en la ruta con un nombre único
//MapPath: Devuelve ruta de acceso especificada de acuerdo a la que necesita al servidor
Archivo.SaveAs(Server.MapPath("~/uploads/" + archivo));
//Se le indica el nombre del archivo al modelo
model.Archivo = archivo;
rm = model.Guardar();
if (rm.response)
{
rm.function = "CargarAdjuntos();";
}
}
else
{
rm.SetResponse(false, "Debe adjuntar un archivo");
}
//Serializar objeto
return(Json(rm));
}
public JsonResult GuardarMesServicio(mesServicio model, String Objmeses = null)
{
var rm = new ResponseModel();
var ctx = new ProyectoContext();
if (Objmeses != null)
{
string[] mmmm = Objmeses.Split(',');
foreach (var m in mmmm)
{
var OMesServ = new mesServicio();
OMesServ.idorden = model.idorden;
OMesServ.idServicio = model.idServicio;
OMesServ.estado = model.estado;
OMesServ.meses = m;
ctx.mesServicio.Add(OMesServ);
ctx.SaveChanges();
}
rm.message = "Guardado correctamente";
rm.SetResponse(true);
}
return(Json(rm));
}
public static ResponseModel SaveAlumnos3(this DbSet <Alumno> dbset, Alumno model, int id)
{
var rm = new ResponseModel();
try
{
using (var ctx = new Model1())
{
if (id > 0)
{
//Actualizar
ctx.Entry(model).State = EntityState.Modified;
}
else
{
//Agregar
ctx.Entry(model).State = EntityState.Added;
}
rm.SetResponse(true);
ctx.SaveChanges();
}
}
catch (Exception e)
{
throw;
}
return(rm);
}
public JsonResult Autenticar(LoginViewModel model)
{
var rm = new ResponseModel();
var errors = ModelState.Where(x => x.Value.Errors.Count > 0).Select(x => new { x.Key, x.Value.Errors }).ToArray();
if (ModelState.IsValid)
{
this.um.Nombreusuario = model.NombreDeUsuario;
this.um.Contraseña = model.Password;
rm = um.Autenticarse();
if (rm.response)
{
//Aca deberia a la pantalla default, y si no tiene permiso deberia ir a una pantalla q le indique q no tiene permisos
Rol rol = db.Rols.Find(rm.result);
rm.href = rol.Window.Url;
// rm.href = Url.Action("Index/Turns");
}
}
else
{
rm.SetResponse(false, "Debe llenar los campos para poder autenticarse.");
}
return(Json(rm));
}
public JsonResult Guardar(NotificacionViewModel model)
{
Notificacion notificacion = new Notificacion();
var rm = new ResponseModel();
if (ModelState.IsValid)
{
var tokenUser = (from c in db.CTE_CUENTA_USUARIO
where c.CuentaUsuarioId == model.CuentaUsuarioId && c.BLOQUEADO == false
select c.FCM_TOKEN
).FirstOrDefault();
if (tokenUser != null)
{
rm = notificacion.enviarFirebase(model.TITULO, model.CUERPO_NOTIFICACION, tokenUser);
if (rm.response)
{
model.Guardar(model);
// rm.function= "closeModalCreate()";
rm.href = Url.Content("~/Admin/Notificaciones/Index");
}
}
else
{
rm.SetResponse(false, "No se encontro el Usuario");
}
}
return(Json(rm));
}
//home/guardar
public JsonResult GuardarAdjunto(Adjunto model, HttpPostedFileBase Archivo)
{
var rm = new ResponseModel();
if (Archivo != null /* && Archivo.ContentLength > 0*/)
{
// Nombre del archivo es decir, lo renombramos para que no se repita nunca
string archivo = DateTime.Now.ToString("yyyyMMddHHmmss") + Path.GetFileName(Archivo.FileName);
//La ruta donde lo vamos guardar
Archivo.SaveAs(Server.MapPath("~/uploads/") + archivo);
//Establecemos en nuestro modelo el nombre del archivo
model.Archivo = archivo;
rm = model.Guardar();
if (rm.response)
{
rm.function = "CargarAdjuntos()";
}
}
rm.SetResponse(false, "Debe adjuntar un archivo");
return(Json(rm));/*, JsonRequestBehavior.AllowGet*/
}
public ResponseModel GuardarHoras()
{
var rm = new ResponseModel();
try
{
using (var cnx = new Context())
{
if (this.IdRegistroHora > 0)
{
cnx.Entry(this).State = EntityState.Modified;
}
else
{
cnx.Entry(this).State = EntityState.Added;
}
cnx.SaveChanges();
rm.SetResponse(true);
}
}
catch (Exception ex)
{
throw;
}
return(rm);
}
public ActionResult Autenticar(LoginViewModel model)
{
var rm = new ResponseModel();
TempData.Clear();
if (ModelState.IsValid)
{
this.um.Email = model.Credenciales;
this.um.Password = model.Password;
rm = um.Autenticarse();
if (rm.response)
{
return(RedirectToAction("", "Home"));
}
else
{
TempData["Error"] = "1";
return(RedirectToAction("", "Login"));
}
}
else
{
rm.SetResponse(false, "Debe llenar los campos para poder autenticarse.");
}
return(Json(rm));
}
public ResponseModel finalizarTarea()
{
DateTime hoy = DateTime.Now;
var rm = new ResponseModel();
DateTime comprometida = retornarFechaComprometida(this.IdTarea);
int eficiencia = 0;
TimeSpan ts;
if (hoy >= comprometida)
{
ts = hoy - comprometida;
// Diferencia dias.
eficiencia = ts.Days;
}
string sql;
try
{
using (var ctx = new inventarioContext())
{
sql = "UPDATE dbo.tareas SET IdEstadoTarea=2,Eficiencia=" + eficiencia + ", FechaCierre='" + hoy.ToString("s") + "' Where idTarea=" + this.IdTarea;
ctx.Database.ExecuteSqlCommand(sql);
rm.SetResponse(true);
}
}
catch (Exception e)
{
throw;
}
return(rm);
}
public ResponseModel Guardar()
{
var rm = new ResponseModel();
try
{
using (var ctx = new inventarioContext())
{
if (this.IdTarea > 0)
{
ctx.Entry(this).State = EntityState.Modified;
}
else
{
this.Nro = this.ObtenerCorrelativo();
ctx.Entry(this).State = EntityState.Added;
}
if (this.editardatos(this.IdTarea))//se puede editar?
{
ctx.SaveChanges();
rm.SetResponse(true);
}
else
{
rm.message = "No se puede editar esta tarea finalizada";
}
}
}
catch (Exception e)
{
throw;
}
return(rm);
}
public JsonResult Guardar(usuariosSistema model, string[] menus, string Area, string Encargado, string IdResponsable)
{
model.Estado = 1;
model.Roles = JsonConvert.SerializeObject(menus);
var rm = new ResponseModel();
if (model.Nombre != null || model.Usuario != null || model.Email != null || model.Cargo != null)
{
if (ModelState.IsValid)
{
rm = model.Guardar();
if (rm.response)
{
//guardar responsable
this.GuardarResponsable(Area, Encargado, IdResponsable, model.idUsuario);
rm.function = "retornarTablaUsuarios()";
}
}
}
else
{
rm.SetResponse(false);
rm.message = "Complete los datos para continuar";
}
return(Json(rm));
}
public ResponseModel GuardarRequerimiento()
{
var rm = new ResponseModel();
try
{
using (var cnx = new Context())
{
this.FechaCreacion = DateTime.Now;
if (this.IdRequerimiento > 0)
{
cnx.Entry(this).State = EntityState.Modified;
}
else
{
cnx.Entry(this).State = EntityState.Added;
}
cnx.SaveChanges();
rm.SetResponse(true);
}
}
catch (Exception ex)
{
throw;
}
return(rm);
}
public JsonResult AgregarComodin(int Id, int IdPieza, int comodin, String cantidad)
{
var rm = new ResponseModel();
if (db.formulacion_comodin.Any(m => m.ID_PRODUCTO == Id && m.ID_PIEZA == IdPieza && m.ID_COMODIN == comodin))
{
rm.SetResponse(false, "Este comodin y aha sido agregado");
return(Json(rm, JsonRequestBehavior.AllowGet));
}
formulacion_comodin entity = new formulacion_comodin();
entity.ID_PRODUCTO = Id;
entity.ID_PIEZA = IdPieza;
entity.ID_COMODIN = comodin;
entity.CANTIDAD = (float)ExtensionMethods.ConverToDecimalFormat(cantidad);
db.formulacion_comodin.Add(entity);
if (db.SaveChanges() > 0)
{
rm.response = true;
rm.message = "Sus datos se guardaron correctamente";
rm.function = "reload('cmb-comodin" + IdPieza + "','grid-comodin" + IdPieza + "')";
}
return(Json(rm, JsonRequestBehavior.AllowGet));
}
public JsonResult Autenticar(LoginViewModel model)
//public ActionResult Autenticar(LoginViewModel model)
{
var rm = new ResponseModel();
if (ModelState.IsValid)
{
this.um.NombreUsuario = model.NombreUsuario;
this.um.Password = model.Password;
rm = um.Autenticarse();
if (rm.response)
{
rm.href = Url.Content("~/home");
//return RedirectToAction("Index", "Home");
}
}
else
{
rm.SetResponse(false, "Debe llenar los campos para poder autenticarse.");
}
return(Json(rm));
}
/// <summary>
/// Insert / update Method
/// </summary>
/// <param name="alumno"></param>
/// <returns></returns>
public ResponseModel Upsert(Alumno alumno)
{
var rm = new ResponseModel();
try
{
using (TestContext context = new TestContext())
{
if (alumno.IdAlumno != 0)
{
context.Entry(alumno).State = EntityState.Modified;
}
else
{
context.Entry(alumno).State = EntityState.Added;
}
rm.SetResponse(true);
context.SaveChanges();
}
} catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(rm);
}