Example #1
0
        //public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        public async Task<ActionResult> Login()
        {

            LoginViewModel model=new LoginViewModel();
            model.Email = Request.Params["Email"];
            model.Password = Request.Params["Password"];
            model.RememberMe = true;

            if (!ModelState.IsValid)
            {
                return RedirectToAction("Index", "Genre");
            }

            // Сбои при входе не приводят к блокированию учетной записи
            // Чтобы ошибки при вводе пароля инициировали блокирование учетной записи, замените на shouldLockout: true
           var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
            switch (result)
            {
                case SignInStatus.Success:
                    //return RedirectToLocal(returnUrl);
                    return RedirectToAction("Index", "Genre");
                case SignInStatus.LockedOut:
                    return View("Lockout");
               // case SignInStatus.RequiresVerification:
                    //return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
                //case SignInStatus.Failure:
                //default:
                   // ModelState.AddModelError("", "Неудачная попытка входа.");
                   // return View(model);
                    
            }
            return RedirectToAction("Index", "Genre");
        }
Example #2
0
        public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
        {
            ViewBag.ReturnUrl = returnUrl;
            if (ModelState.IsValid)
            {
                // This doesn't count login failures towards account lockout
                // To enable password failures to trigger account lockout, set shouldLockout: true
                var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
                if (result.Succeeded)
                {
                    return RedirectToLocal(returnUrl);
                }
                if (result.RequiresTwoFactor)
                {
                    return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
                }
                if (result.IsLockedOut)
                {
                    return View("Lockout");
                }
                else
                {
                    ModelState.AddModelError(string.Empty, "Invalid login attempt.");
                    return View(model);
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }
Example #3
0
        public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
        {
            EnsureDatabaseCreated(_applicationDbContext);
            ViewData["ReturnUrl"] = returnUrl;
            if (ModelState.IsValid)
            {
                // This doesn't count login failures towards account lockout
                // To enable password failures to trigger account lockout, set lockoutOnFailure: true
                var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure: false);
                if (result.Succeeded)
                {
                    return RedirectToLocal(returnUrl);
                }
                if (result.RequiresTwoFactor)
                {
                    return RedirectToAction(nameof(SendCode), new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
                }
                if (result.IsLockedOut)
                {
                    return View("Lockout");
                }
                else
                {
                    ModelState.AddModelError(string.Empty, "Invalid login attempt.");
                    return View(model);
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }
        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }

            // This doesn't count login failures towards account lockout
            // To enable password failures to trigger account lockout, change to shouldLockout: true
            var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
            switch (result)
            {
                case SignInStatus.Success:
                    return RedirectToLocal(returnUrl);
                case SignInStatus.LockedOut:
                    return View("Lockout");
                case SignInStatus.RequiresVerification:
                    return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
                case SignInStatus.Failure:
                default:
                    ModelState.AddModelError("", "Invalid login attempt.");
                    return View(model);
            }
        }
Example #5
0
        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }

            // No cuenta los errores de inicio de sesión para el bloqueo de la cuenta
            // Para permitir que los errores de contraseña desencadenen el bloqueo de la cuenta, cambie a shouldLockout: true
            var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
            switch (result)
            {
                case SignInStatus.Success:
                    return RedirectToLocal(returnUrl);
                case SignInStatus.LockedOut:
                    return View("Lockout");
                case SignInStatus.RequiresVerification:
                    return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
                case SignInStatus.Failure:
                default:
                    ModelState.AddModelError("", "Intento de inicio de sesión no válido.");
                    return View(model);
            }
        }
Example #6
0
        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }

            // これは、アカウント ロックアウトの基準となるログイン失敗回数を数えません。
            // パスワード入力失敗回数に基づいてアカウントがロックアウトされるように設定するには、shouldLockout: true に変更してください。
            var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
            switch (result)
            {
                case SignInStatus.Success:
                    return RedirectToLocal(returnUrl);
                case SignInStatus.LockedOut:
                    return View("Lockout");
                case SignInStatus.RequiresVerification:
                    return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
                case SignInStatus.Failure:
                default:
                    ModelState.AddModelError("", "無効なログイン試行です。");
                    return View(model);
            }
        }
        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }

            // 這不會計算為帳戶鎖定的登入失敗
            // 若要啟用密碼失敗來觸發帳戶鎖定,請變更為 shouldLockout: true
            var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
            switch (result)
            {
                case SignInStatus.Success:
                    return RedirectToLocal(returnUrl);
                case SignInStatus.LockedOut:
                    return View("Lockout");
                case SignInStatus.RequiresVerification:
                    return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
                case SignInStatus.Failure:
                default:
                    ModelState.AddModelError("", "登入嘗試失試。");
                    return View(model);
            }
        }
        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            if (!ModelState.IsValid)
            {
                TempData["tipo"] = "alert alert-warning";
                TempData["message"] = "Colocar correo y contraseña con el formato indicado";
                return Redirect("~/Home/Index");
            }

            // This doesn't count login failures towards account lockout
            // To enable password failures to trigger account lockout, change to shouldLockout: true
            CuentaUsuario cuentausuario = db.CuentaUsuario.Find(model.Email);
            PuntoVenta punt = new PuntoVenta();
            try
            {
                if (cuentausuario.codPerfil == 2)
                {
                    string macAddresses = "";
                    DateTime hora = DateTime.Now;
                    List<Turno> turnos = db.Turno.Where(c => c.usuario == cuentausuario.correo).ToList();
                    turnos = turnos.Where(c => c.fecha.Date == DateTime.Today.Date).ToList();
                    foreach (Turno turno in turnos)
                    {
                        TurnoSistema tS = turno.TurnoSistema;
                        string horaInicio = tS.horIni;
                        string horaFin = tS.horFin;
                        DateTime horaInicioDate = DateTime.ParseExact(horaInicio, "H:m:s", null);
                        DateTime horaFinDate = DateTime.ParseExact(horaFin, "H:m:s", null);
                        if (horaInicioDate <= hora && hora <= horaFinDate)
                        {
                            macAddresses = turno.PuntoVenta.dirMAC;
                            break;
                        }
                    }

                    /*foreach (NetworkInterface nic in NetworkInterface.GetAllNetworkInterfaces())
                    {
                        if (nic.OperationalStatus == OperationalStatus.Up)
                        {
                            macAddresses += nic.GetPhysicalAddress().ToString();
                            break;
                        }
                    }*/
                    if (macAddresses != "")
                    {
                        List<PuntoVenta> lpu = db.PuntoVenta.Where(c => c.dirMAC == macAddresses).ToList();
                        punt = lpu.First();
                    }
                }

            }
            catch (Exception ex)
            {
                try
                {
                    if (cuentausuario.codPerfil == 2)
                    {
                        TempData["tipo"] = "alert alert-warning";
                        TempData["message"] = "Iniciar Sesión desde un punto de venta registrado.";
                    }
                }
                catch (Exception ex2)
                {
                    TempData["tipo"] = "alert alert-warning";
                    TempData["message"] = "Correo no registrado.";
                }

                return Redirect("~/Home/Index");
            }

            if (cuentausuario.codPerfil != 1 && cuentausuario.estado == false) return Redirect("~/Home/Index");

            var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
            Session["orgPago"] = null;
            Session["orgPago2"] = null;
            Session["vendAsig"] = null;
            Session["Pagos2"] = null;
            Session["ListaTurnoVendedor"] = null;
            Session["Pagos"] = null;
            Session["Pendiente"] = null;
            Session["Pendiente2"] = null;
            Session["EventoSeleccionadoPago"] = null;
            Session["EventoSeleccionadoPago2"] = null;
            TempData["tipo"] = "alert alert-warning";
            TempData["message"] = "Logueo Incorrecto";

            switch (result)
            {
                case SignInStatus.Success:
                    TempData["tipo"] = "alert alert-success";
                    TempData["message"] = "Logueado Correctamente";
                    if (cuentausuario.codPerfil == 1)
                    {
                        Session["UsuarioLogueado"] = cuentausuario;
                        return Redirect("~/Home/Index");
                    }
                    else
                    {
                        if (cuentausuario.codPerfil == 2)
                        {
                            Turno tu = null;
                            DateTime hoy = DateTime.Now;
                            int idPunto = 1;
                            TimeSpan da = DateTime.Now.TimeOfDay;
                            TurnoSistema ts = new TurnoSistema();
                            List<TurnoSistema> listaturno = db.TurnoSistema.AsNoTracking().Where(c => c.activo == true).ToList();
                            for (int i = 0; i < listaturno.Count; i++)
                            {
                                if ((TimeSpan.Parse(listaturno[i].horIni) < da) && (TimeSpan.Parse(listaturno[i].horFin) > da))
                                {
                                    ts = listaturno[i];
                                }
                            }
                            Session["ListaTurnoHoy"] = null;
                            List<Turno> liT = new List<Turno>();
                            List<Turno> liTV = new List<Turno>();
                            liT = db.Turno.AsNoTracking().Where(j => j.usuario == cuentausuario.usuario && j.codPuntoVenta == punt.codPuntoVenta && j.codTurnoSis == ts.codTurnoSis).ToList();
                            liTV = db.Turno.AsNoTracking().Where(j => j.codPuntoVenta == punt.codPuntoVenta && j.codTurnoSis == ts.codTurnoSis).ToList();
                            liTV = liTV.Where(c => c.fecha == hoy.Date).ToList();
                            Session["ListaTurnoHoy"] = liTV;
                            Session["PuntoVentaLoguedo"] = punt.codPuntoVenta;
                            if (liT != null)
                            {
                                for (int i = 0; i < liT.Count; i++)
                                {
                                    if (liT[i].fecha.Date == hoy.Date)
                                    {
                                        tu = liT[i];
                                        Session["TurnoHoy"] = tu;
                                        break;
                                    }
                                }
                            }
                            if (tu != null && tu.estado == "Pendiente")
                            {
                                int idPol = 4;
                                int limite = (int)db.Politicas.Find(idPol).valor;
                                TimeSpan time1 = TimeSpan.FromMinutes(limite);
                                TimeSpan horalimite = TimeSpan.Parse(ts.horIni);
                                TimeSpan hora1 = horalimite.Add(time1);
                                //db.Entry(tu).State = EntityState.Modified;
                                if (hora1 > da)
                                {
                                    tu.estado = "Asistio";
                                }
                                else
                                {
                                    tu.estado = "Tarde";
                                }
                                tu.horaRegistro = da.ToString(@"hh\:mm\:ss");
                                Session["MensajeIngresoTurno"] = "Hora de ingreso registrada a las: " + da.ToString(@"hh\:mm\:ss") + " hs";
                                db.SaveChanges();
                                //db.Entry(tu).State = EntityState.Detached;
                            }
                        }
                        Session["UsuarioLogueado"] = cuentausuario;
                        return Redirect("~/Home/Index2");
                    }
                case SignInStatus.LockedOut:
                    return View("Lockout");
                case SignInStatus.RequiresVerification:
                    return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
                case SignInStatus.Failure:
                    return Redirect("~/Home/Index");
                default:
                    ModelState.AddModelError("", "Invalid login attempt.");
                    return Redirect("~/Home/Index");
            }
        }