public ActionResult IniciarSesion(Usuarios u)
{
if (ModelState.IsValid)
{
var usuario = UsuarioServicio.IniciarSesion(u);
//obtiene la url traida con la session
var urlAnterior = System.Web.HttpContext.Current.Session["UrlAnterior"] as String;
if (usuario != null)
{
var action = "Inicio";
var controller = "Administracion";
UsuarioServicio.AgregarUsuarioASesion(usuario.NombreUsuario);
Session["Usuario"] = usuario.NombreUsuario;
//Verifica si el viewdata no es nulo
if (urlAnterior != null)
{
var urlArray = urlAnterior.ToString().Trim('/').Split('/');
if (urlArray.Count() == 2)
{
controller = urlArray[0].ToString();
action = urlArray[1].ToString();
}
}
return(RedirectToAction(action, controller));
}
else
{
ViewBag.Mensaje = "Usuario y/o Contraseña invalidos";
}
}
return(View("Login"));
}
/*Este método sirve para detectar donde estas entrando. Esto se ejecuta antes que el ActionResult
* correspondiente. Es bueno, por ejemplo, para preguntar por la sesión, traer una id, o lo que sea
* que se use para ver si el user esta logeado o no (SIN TENER QUE REPETIR LO MISMO EN CADA MÉTODO)*/
protected override void OnActionExecuting(ActionExecutingContext filterContext)
{
string controllerName = this.ControllerContext.RouteData.Values["controller"].ToString();
Debug.WriteLine("====Estas en el controlador: " + controllerName);
if (Session["Usuario"] == null)
{
string token = filterContext.HttpContext.Request.Params["token"]?.ToString();
Usuario logeado = UsuarioServicio.LoginPorToken(token);
if (logeado != null)
{
Session["Usuario"] = logeado;
ViewBag.Usuario = Session["Usuario"];
}
else
{
string urlIntentada = Request.Url.ToString();
UrlHelper u = new UrlHelper(this.ControllerContext.RequestContext);
string urlNueva = u.Action("Login",
"Home",
new { ReturnUrl = urlIntentada });
filterContext.Result = Redirect(urlNueva);
}
}
else
{
//villereada rápida
Usuario usuario = Session["Usuario"] as Usuario;
ViewBag.Usuario = UsuarioServicio.ObtenerUsuarioPorId(usuario.Id);
Session["Usuario"] = ViewBag.Usuario;
}
}
public IHttpActionResult PostParo(Paro paro)
{
paro.FechaReporte = DateTime.Now;
paro.Activo = true;
paro.ActividadesEnParo = new List <ActividadEnParo> {
new ActividadEnParo {
Fecha = DateTime.Now, Descripcion = "Nueva Falla reportada!!", IdPersona = paro.IdReportador
}
};
paro.TiemposDeParo = new List <TiempoDeParo> {
new TiempoDeParo {
Inicio = DateTime.Now
}
};
ParoServicio servicio = new ParoServicio(db);
var respuesta = servicio.PostParo(paro);
NotificationService notify = new NotificationService();
UsuarioServicio usuarioServicio = new UsuarioServicio();
List <DispositivoView> dispositivos = usuarioServicio.GetMecanicosPorOrigen(paro.IdOrigen);
List <string> llaves = dispositivos.Select(x => x.Llave).ToList();
foreach (string notificacion in llaves)
{
//notify.SendPushNotification(notificacion, "El modulo " + paroAdded.Origen.Modulo.NombreCorto + " necesita de tu ayuda urgentemente.", "Nueva Falla reportada en " + paroAdded.Origen.WorkCenter.NombreCorto + " por favor ve lo mas pronto posible a ayudarlos.");
}
return(Ok(respuesta));
}
private void _vista_VistaCargandosePorPrimeraVez(object sender, EventArgs e)
{
try
{
_vista.Parametros = new List <Parametro>();
_vista.Clientes = ClienteServicio.ObtenerClientes();
_vista.Vehiculos = VehiculoServicio.ObtenerVehiculos(new VehiculoArgumento {
Vehiculo = new Vehiculo()
});
_vista.Bodegas = BodegaServicio.ObtenerBodegaAsignadaAUsuario(InteraccionConUsuarioServicio.ObtenerUsuario());
_vista.UsuariosParaAutorizar = UsuarioServicio.ObtenerUsuariosActivosPorCentroDeDistribucion(InteraccionConUsuarioServicio.ObtenerCentroDistribucion());
_vista.UsuariosParaEntrega = UsuarioServicio.ObtenerUsuariosActivosPorCentroDeDistribucion(InteraccionConUsuarioServicio.ObtenerCentroDistribucion());
ObtenerParametros();
_vista.SoloVehiculos = VehiculoServicio.ObtenerVehiculos(new VehiculoArgumento {
Vehiculo = new Vehiculo()
});
_vista.Pilotos = PilotoServicio.ObtenerPilotos(new PilotoArgumento {
Piloto = new Piloto()
});
_vista.DespachosDetalles = new List <DemandaDespachoDetalle>();
_vista.PaseDeSalidas = new List <PaseDeSalida>();
ObtenerTiposDeSalida();
}
catch (Exception ex)
{
InteraccionConUsuarioServicio.MensajeErrorDialogo(ex.Message);
}
}
public LoginDialog()
{
InitializeComponent();
// Inicializa el contexto de la base de datos
invEnt = new diinventarioEntities();
usuServ = new UsuarioServicio(invEnt);
}
public ActionResult Registro(string email, string contrasenia, string nombre, string apellido, string token, bool paciente)
{
if (String.IsNullOrEmpty(email) ||
String.IsNullOrEmpty(contrasenia) ||
String.IsNullOrEmpty(token) ||
String.IsNullOrEmpty(nombre) ||
String.IsNullOrEmpty(apellido))
{
return(Json(new { msg = "Complete todos los campos" }));
}
if (UsuarioServicio.EmailEnUso(email))
{
return(Json(new { msg = "El email esta en uso" }));
}
using (Epilepsia_TP_Entities ctx = new Epilepsia_TP_Entities())
{
Usuario u = new Usuario();
u.Nombre = nombre;
u.Apellido = apellido;
u.FechaNacimiento = DateTime.Now;
u.Email = email;
u.Contrasenia = contrasenia;
u.Token = token;
u.Paciente = paciente;
ctx.Usuario.Add(u);
ctx.SaveChanges();
}
return(Json(new { msg = "Usuario registrado" }));
}
// Estado: Cambiado
// Creado por Juan Castro - 20.11.2019
// Cambiado por Miguel Bogota - 15.12.2019
// Funcion toma la informacion del login y valida si es correcta y devuelve la informacion del usuario
public Usuario LoginDatos(String usuario, String contrasenia)
{
// Se declaran variables locales para guardar los valores prevenientes de la vista y se validan en la base de datos
Usuario usuarioLogin = new UsuarioServicio().IniciarSesion(usuario, contrasenia);
// Se valida si la consulta trajo algun valor
if (usuarioLogin != null)
{
return(usuarioLogin);
}
// De lo contrario sumar a contador
else
{
//contador para ingresos errorneos
Contador++;
MessageBox.Show("Ha introducido erroneamente usuario o contraseña, por favor vuelva a intentar", "error - numero de intentos" + Contador, MessageBoxButtons.OK, MessageBoxIcon.Warning);
//en caso de 3 intentos erroneos lanza mensaje y cierra aplicacion
if (Contador == 3)
{
MessageBox.Show("Ha intentado ingresar erronamente en 3 ocaciones. Por cuestiones de seguridad se cerrará la aplicacion", "Error", MessageBoxButtons.OK, MessageBoxIcon.Stop);
new FuncionesController().Finalizar();
}
return(null);
}
}
public ActionResult Create(StatusVentana statusVentana)
{
if (ModelState.IsValid)
{
PersonaServicio personaServicio = new PersonaServicio();
IRespuestaServicio <Persona> persona = personaServicio.GetPersona(User.Identity.GetUserId());
if (persona.EjecucionCorrecta)
{
statusVentana.IdResponsable = persona.Respuesta.Id;
}
var IdSubCategoria = db.Ventana.Where(x => x.Id == statusVentana.IdVentana).Select(x => x.IdSubCategoria).FirstOrDefault();
WorkFlowServicio workflowServicio = new WorkFlowServicio();
IRespuestaServicio <WorkFlowView> workFlow = workflowServicio.nextEstatus(IdSubCategoria, statusVentana.IdStatus, false);
statusVentana.IdStatus = workFlow.Respuesta.EstatusSiguiente.Id;
statusVentana.Fecha = DateTime.Now;
if (statusVentana.Comentarios == null)
{
statusVentana.Comentarios = " ";
}
db.StatusVentana.Add(statusVentana);
db.SaveChanges();
var ventana = db.Ventana
.Include(v => v.StatusVentana)
.Include(v => v.StatusVentana.Select(s => s.Status))
.Include(v => v.BitacoraVentana)
.Include(v => v.BitacoraVentana.Select(b => b.Estatus))
.Include(v => v.BitacoraVentana.Select(b => b.Rechazo))
.Include(v => v.Evento)
.Include(v => v.Proveedor)
.Where(x => x.Id == statusVentana.IdVentana)
.FirstOrDefault();
try
{
UsuarioServicio usuarioServicio = new UsuarioServicio();
NotificationService notify = new NotificationService();
string senders = usuarioServicio.GetEmailByStatus(ventana);
if (senders != "")
{
EmailService emailService = new EmailService();
emailService.SendMail(senders, ventana);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(RedirectToAction("Index", "Evento", new { Area = "Operaciones" }));
}
return(View(statusVentana));
}
public CambioPasswordDialog(gestiondocumentalEntities gEnt, usuarios usu)
{
InitializeComponent();
this.gEnt = gEnt;
usuario = usu;
usuService = new UsuarioServicio(gEnt);
}
private ValidaMVC valMVC; //Clase de validacion
public DialogUsuarioMVC(diinventarioEntities ent)
{
InitializeComponent();
invEnt = ent;
usuServ = new UsuarioServicio(invEnt);
//validacion
valMVC = new ValidaMVC();
//inicializar mediante servicio generico
tipoUsuServ = new ServicioGenerico <tipousuario>(invEnt);
rolServ = new ServicioGenerico <rol>(invEnt);
grupoServ = new ServicioGenerico <grupo>(invEnt);
departamentoServ = new ServicioGenerico <departamento>(invEnt);
/*
* tipoUsuServ = new TipoUsuarioServicio(invEnt);
* rolServ = new RolServicio(invEnt);
* grupoServ = new GrupoServicio(invEnt);
* dptoServ = new DptoServicio(invEnt);
*/
//poner las listas en el combo
comboTipoUsu.ItemsSource = tipoUsuServ.getAll().ToList();
comboRolUsu.ItemsSource = rolServ.getAll().ToList();
comboGrupoUsu.ItemsSource = grupoServ.getAll().ToList();
comboDepartamentoUsu.ItemsSource = departamentoServ.getAll().ToList();
}
// Estado: Activo
// Creado por Miguel Bogota - 24.11.2019
// Hace autenticacion
public IActionResult Auth([Bind("NombreUsuario, Contrasenia")] Usuario login)
{
// Si no hay usuario no se ha logueado
if (login.NombreUsuario == null)
{
return(RedirectToAction("/Login"));
}
// Busca en la base de datos con usuario y contraseña, si no encuentra devuelve null
Usuario UsuarioLogin = new UsuarioServicio().IniciarSesion(login.NombreUsuario, login.Contrasenia);
// Devolver al login si es incorrecto
if (UsuarioLogin == null)
{
return(RedirectToAction("/Login"));
}
var user = new List <Claim>()
{
new Claim("NombreUsuario", UsuarioLogin.NombreUsuario),
new Claim("Contrasenia", UsuarioLogin.Contrasenia)
};
var userIte = new ClaimsIdentity(user, "Identi");
var userPrincipal = new ClaimsPrincipal(new[] { userIte });
HttpContext.SignInAsync(userPrincipal);
return(RedirectToAction("Inicio"));
}
public IHttpActionResult PostDefecto(Defecto defecto)
{
RespuestaServicio <DefectoView> respuesta = new RespuestaServicio <DefectoView>();
if (defecto != null)
{
defecto.Activo = true;
defecto.FechaReporte = DateTime.Now;
DefectoServicio servicio = new DefectoServicio(db);
respuesta = servicio.PostDefecto(defecto);
if (respuesta.EjecucionCorrecta)
{
NotificationService notify = new NotificationService();
UsuarioServicio usuarioServicio = new UsuarioServicio();
List <DispositivoView> dispositivos = usuarioServicio.GetMecanicosPorOrigen(defecto.IdOrigen);
List <string> llaves = dispositivos.Select(x => x.Llave).ToList();
foreach (string notificacion in llaves)
{
notify.SendPushNotification(notificacion, "El modulo " + respuesta.Respuesta.Origen.Modulo.NombreCorto + " no parece estar funcionando muy bien.", "Nuevo defecto reportado en " + respuesta.Respuesta.Origen.WorkCenter.NombreCorto + ".");
}
}
else
{
}
}
else
{
respuesta.Mensaje = "El defecto no se puede agregar porque llego nulo :(";
}
return(Ok(respuesta));
}
private void _vista_VistaCargandosePorPrimeraVez(object sender, EventArgs e)
{
try
{
_vista.Usuarios = UsuarioServicio.ObtenerUsuarios(new Usuario {
LOGIN = null
});
_vista.TiposDeUsuario = ClasificacionServicio.ObtenerClasificaciones(new Clasificacion {
GROUP_CLASSIFICATION = "USER_ROLE"
});
_vista.RolesDeUsuario = RolServicio.ObtenerRoles();
_vista.Zonas = ZonaServicio.ObtenerZonas();
_vista.Vendedores = VendedorServicio.ObtenerVendedores(new Vendedor {
SELLER_CODE = null
});
_vista.CentrosDeDistribucion = CentroDeDistribucionServicio.ObtenerCentroDeDistribucion(new CentroDeDistribucion {
DISTRIBUTION_CENTER_ID = null
});
_vista.ListasDePrecios = ListaDePreciosServicio.ObtenerListasDePrecios(new ListaDePrecio {
CODE_PRICE_LIST = null
});
}
catch (Exception ex)
{
_vista.EstablecerError(ex.Message, sender);
}
}
private void _vista_UsuarioDeseaGuardarUsuario(object sender, UsuarioArgumento e)
{
var op = UsuarioServicio.GuardarUsuario(e);
if (op.Resultado == ResultadoOperacionTipo.Exito)
{
var data = e.Data;
var us = UsuarioServicio.ObtenerUsuarios(data);
var listaBodegas = new List <Bodega>();
foreach (var bodegaIngresar in from bodegaIngresar in e.Bodegas let existeBodega = listaBodegas.Any(bodega => bodega.CODE_WAREHOUSE == bodegaIngresar.CODE_WAREHOUSE) where !existeBodega select bodegaIngresar)
{
listaBodegas.Add(new Bodega {
CODE_WAREHOUSE = bodegaIngresar.CODE_WAREHOUSE, DESCRIPTION_WAREHOUSE = bodegaIngresar.DESCRIPTION_WAREHOUSE
});
var bodegaAccesoUsuario = new BodegaConAccesoPorUsuario
{
USER_CORRELATIVE = us[0].CORRELATIVE
,
CODE_WAREHOUSE = bodegaIngresar.CODE_WAREHOUSE
,
DESCRIPTION_WAREHOUSE = bodegaIngresar.DESCRIPTION_WAREHOUSE
};
BodegaServicio.GuardarBodegaConAccesoPorUsuario(bodegaAccesoUsuario);
}
_vista.TerminoProceso("cpLimpiarControles", "Enabled", sender);
_vista_VistaCargandosePorPrimeraVez(sender, e);
}
else
{
_vista.EstablecerError(op.Mensaje, sender);
}
}
public ActionResult Login(FormLogin formLogin)
{
if (!ModelState.IsValid)
{
return(View());
}
Usuario usuario = UsuarioServicio.ObtenerUsuario(formLogin);
if (usuario != null)
{
Session.Add("Usuario", usuario);
//Por si se intento ingresar a una url que requería estar logeado, te llevo ahí
string destino = HttpUtility.ParseQueryString(Request.UrlReferrer.Query)["ReturnUrl"];
if (destino != null)
{
return(Redirect(destino));
}
return(RedirectToAction("Index"));
}
ViewData["MensajeLogin"] = "******";
return(View());
}
private void _vista_VistaCargandosePorPrimeraVez(object sender, EventArgs e)
{
try
{
_vista.Operadores = UsuarioServicio.ObtenerUsuariosTipoBodegaAsignadosCD(InteraccionConUsuarioServicio.ObtenerCentroDistribucion());
_vista.TiposDeRecepcion = ConfiguracionServicio.ObtenerConfiguracionesGrupoYTipo(new Entidades.Configuracion {
PARAM_TYPE = "SISTEMA", PARAM_GROUP = "TYPE_RECEPTION"
});
_vista.Prioridad = ConfiguracionServicio.ObtenerConfiguracionesGrupoYTipo(new Entidades.Configuracion {
PARAM_TYPE = "SISTEMA", PARAM_GROUP = "PRIORITY"
});
_vista.FuenteExterna = FuenteExternaServicio.ObtenerFuentesExternas();
_vista.Usuario = InteraccionConUsuarioServicio.ObtenerUsuario();
_vista.ParametrosDeSistema =
ParametroServicio.ObtenerParametro(new ConsultaArgumento
{
GrupoParametro = Enums.GetStringValue(GrupoParametro.Sistema),
IdParametro = Enums.GetStringValue(IdParametro.TipoDeClienteMovilDe3Pl)
});
}
catch (Exception ex)
{
InteraccionConUsuarioServicio.Mensaje(ex.Message);
}
}
public ModificarUsuario(PantallaUsuarios pantallaUsuarios, long id)
{
_usuarioServicio = new UsuarioServicio();
_pantallaUsuarios = pantallaUsuarios;
_usuario = _usuarioServicio.ObtenerUsuario(id);
InitializeComponent();
}
public GestionarComputadoraUsuarioControlador(IGestionarComputadoraUsuarioVista vista, UsuarioModelo usuarioModelo)
{
_vista = vista;
_usuarioModelo = usuarioModelo;
_usuarioServicio = new UsuarioServicio();
_computadoraServicio = new ComputadoraServicio();
}
public ActionResult Logout()
{
Session.Clear();
Session.Abandon();
UsuarioServicio.CerrarSesion();
return(RedirectToAction("Login", "Home"));
}
public List <DataUsuario> listaUsuarios()
{
UsuarioServicio servicio = new UsuarioServicio();
List <DataUsuario> listaUsuarios = servicio.obtenerUsuarios();
return(listaUsuarios);
}
public frmProyecto()
{
InitializeComponent();
oProductoServicio = new ProductoServicio();
oUsuarioServicio = new UsuarioServicio();
oProyectoServicio = new ProyectoServicio();
}
public LoginDialog(gestiondocumentalEntities gEnt)
{
InitializeComponent();
this.gEnt = gEnt;
usuService = new UsuarioServicio(gEnt);
gEnt.Database.Connection.Open();
}
//public void Put(int id, [FromBody]string value)
//public ActionResult Put(int id, [FromBody]Usuario usu)
public ActionResult Put(int id, [FromBody] Usuario usu)
{
UsuarioServicio usuServ = new UsuarioServicio();
string resultado = usuServ.modificarUsuario(usu);
return(Ok(resultado));
}
public CrearContraPageViewModel(INavigationService navigationService, IPageDialogService dialogService)
{
_navigation = navigationService;
_dialogService = dialogService;
RegresarCommand = new Command(async() => { await OnRegresar(); });
FinalizarCommand = new Command(async() => { await OnFinalizar(); });
_servicio = new UsuarioServicio();
}
/// <summary>
/// Método privado que inicializa las variables
/// </summary>
private void inicializa()
{
dptoServ = new DptoServicio(invEnt);
grpServ = new GrupoServicio(invEnt);
tipoServ = new ServicioGenerico <tipousuario>(invEnt);
rolServ = new ServicioGenerico <rol>(invEnt);
usuServ = new UsuarioServicio(invEnt);
usuNuevo = new usuario();
}
public RegistroPageViewModel(INavigationService navigationService, IPageDialogService dialogService)
{
_navigation = navigationService;
_dialogService = dialogService;
RegresarCommand = new Command(async() => { await OnRegresar(); });
SiguienteCommand = new Command(async() => { await OnSiguiente(); });
Title = "Registro de Usuario";
_servicio = new UsuarioServicio();
}
public bool SendMail(string To_Mail, Evento evento)
{
try
{
MailMessage smail = new MailMessage();
smail.IsBodyHtml = true;
smail.BodyEncoding = System.Text.Encoding.GetEncoding("iso-8859-1");
smail.From = new MailAddress("*****@*****.**", "*****@*****.**");
string[] emails = To_Mail.Split(',');
foreach (string email in emails)
{
if (email != "")
{
smail.To.Add(email);
}
}
smail.Subject = "[PMMX Notification] Info: " + evento.Descripcion;
smail.Body = string.Format("<html><head><meta charset='UTF-8'></head><body> ");
smail.Body = smail.Body + string.Format("<div align='center' style='font-weight:bold; text-align: center; width:50%; margin: 0 auto; display: table; background: #D6EAF8;' >");
smail.Body = smail.Body + string.Format(" <h1 style ='text - transform: uppercase; background: #21618C; color: #FFFFFF;'> New Event </h1></div>");
smail.Body = smail.Body + string.Format("<span style = 'font - family:Arial; font - size:10pt'> ");
smail.Body = smail.Body + string.Format(" A new event has been asigned to you <h3>" + evento.Descripcion + "</h3> to " + evento.FechaInicio);
smail.Body = smail.Body + string.Format(" <br /><br /></span> ");
smail.Body = smail.Body + string.Format("<h3 style ='text - transform: uppercase; background: #21618C; color: #FFFFFF;'>"
+ "<a style='color: #FFFFFF;'' href='https://serverpmi.tr3sco.net/'>For more information click here</a>"
+ "<br /></h3> ");
smail.Body = smail.Body + string.Format(" </body></html> ");
SmtpClient smtp = new SmtpClient();
smtp.Host = "smtp.gmail.com";
smtp.Port = 587;
smtp.EnableSsl = true;
smtp.UseDefaultCredentials = false;
smtp.Credentials = new System.Net.NetworkCredential("*****@*****.**", "82000100");
smtp.Send(smail);
NotificationService notify = new NotificationService();
UsuarioServicio usuarioServicio = new UsuarioServicio();
List <DispositivoView> dispositivos = usuarioServicio.GetDispositivoByEvento(evento.Id);
List <string> llaves = dispositivos.Select(x => x.Llave).ToList();
foreach (string notificacion in llaves)
{
notify.SendPushNotification(notificacion, "Evento: " + evento.Descripcion + ". ", " A new event has been asigned to you " + evento.Descripcion + " to " + evento.FechaInicio);
}
}
catch (SmtpException ex)
{
Console.WriteLine(ex.StatusCode);
Console.WriteLine(ex.Message);
return(false);
}
return(true);
}
[HttpGet("{emailent}/{contrasenya}", Name = "GetUsuLogin")] //Nota: en los Get de las api, cambiar el name, sino da problemas
public ActionResult Get(string emailent, string contrasenya)
{
UsuarioServicio usuServ = new UsuarioServicio();
Usuario usu = new Usuario();
usu = usuServ.usuarioLogin(emailent, contrasenya);
return(Ok(usu));
}
public RecuperarContraDatosPageViewModel(INavigationService navigationService, IPageDialogService dialogService)
{
_navigation = navigationService;
_dialogService = dialogService;
_servicio = new UsuarioServicio();
RecuperarCommand = new Command(async() => { await OnRecuperar(); });
RegresarCommand = new Command(async() => { await OnRegresar(); });
Title = "Verificar Datos";
}
[HttpGet("{id}", Name = "GetUsu")] //Nota: en los Get de las api, cambiar el name, sino da problemas
public ActionResult Get(int id)
{
UsuarioServicio usuServ = new UsuarioServicio();
Usuario usu = new Usuario();
usu = usuServ.obtenerUsuPorId(id);
return(Ok(usu));
}
