public async Task <IActionResult> SignInPost(SignInVM signInVM)
{
if (!ModelState.IsValid)
{
return(View(signInVM));
}
MyUser user = await _userManager.FindByNameAsync(signInVM.Username);
if (user == null)
{
ModelState.AddModelError("", "İstifadəçi adı və ya şifrə düzgün deyil");
return(View(signInVM));
}
Microsoft.AspNetCore.Identity.SignInResult result = await _signInManager.PasswordSignInAsync(user, signInVM.Password, signInVM.RememberMe, true);
if (!result.Succeeded)
{
ModelState.AddModelError("", "İstifadəçi adı və ya şifrə düzgün deyil");
return(View(signInVM));
}
return(RedirectToAction(nameof(UserProfileController.MyProfile), "UserProfile"));
}
public ActionResult SignIn(SignInVM user)
{
try
{
var usr = db.UserDatas.SingleOrDefault(x => x.email == user.email && x.password == user.password);
if (usr != null)
{
Session["UserID"] = usr.id;
Session["UserName"] = usr.name;
Session["UserPhone"] = usr.phone;
Session["UserScore"] = usr.score;
return(RedirectToAction("Index"));
}
return(View("SignUp"));
}
catch (Exception ex)
{
ViewBag.error = ex.Message;
return(View("Error"));
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> SignIn(string returnUrl, SignInVM model)
{
var usuario = _ctx.Usuarios.FirstOrDefault(x => x.Email == model.Email && x.Senha == model.Senha.Encrypt());
if (usuario == null)
{
return(Unauthorized());
}
var claims = new List <Claim>()
{
new Claim("id", usuario.Id.ToString()),
new Claim("nome", usuario.Nome),
new Claim("email", usuario.Email),
new Claim("roles", "admin,ti,estagiario")
};
var identity = new ClaimsIdentity(
claims,
CookieAuthenticationDefaults.AuthenticationScheme,
"nome", "roles"
);
var principal = new ClaimsPrincipal(identity);
await HttpContext.SignInAsync(principal, new AuthenticationProperties {
IsPersistent = model.Lembrar,
ExpiresUtc = DateTime.UtcNow.AddMinutes(10)
});
return(Redirect(returnUrl ?? "/"));
}
public SignUserCommand(SignInVM signInVM, Messenger messenger, DBUser dbUser, DBLogIn dbLogIn)
{
this.signInVM = signInVM;
this.messenger = messenger;
this.dbUser = dbUser;
this.dbLogIn = dbLogIn;
}
public static String Sign_Up(SignInVM signInModel)
{
DataContext db = new DataContext();
User User = db.Users.Where(x => x.EMail == signInModel.EMail).FirstOrDefault();
if (User != null)
{
return("Not Valid");
}
else
{
byte[] passwordbyte = System.Text.Encoding.ASCII.GetBytes(signInModel.Password);
System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create();
byte[] passhash = md5.ComputeHash(passwordbyte);
string finalPass = "";
for (int i = 0; i < passhash.Length; i++)
{
finalPass += passhash[i];
}
User user = new User()
{
Name = signInModel.Name,
SurName = signInModel.SurName,
EMail = signInModel.EMail,
Password = signInModel.Password
};
db.Users.Add(user);
db.SaveChanges();
return("Added");
}
}
public async Task <IActionResult> SignIn(SignInVM model)
{
if (ModelState.IsValid)
{
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure : false);
if (result.Succeeded)
{
//base._logger.Log<>("User logged in.");
return(LocalRedirect(model.ReturnUrl));
}
//if (result.RequiresTwoFactor)
//{
// return RedirectToPage("./LoginWith2fa", new { ReturnUrl = returnUrl, RememberMe = Input.RememberMe });
//}
if (result.IsLockedOut)
{
//_logger.LogWarning("Konto użytkownika jest zablokowane, prosimy o kontakt z administracją.");
ModelState.AddModelError(string.Empty, "Konto użytkownika jest zablokowane, prosimy o kontakt z administracją.");
return(View(model));
}
else
{
ModelState.AddModelError(string.Empty, "Nieudana próba logowania.");
return(View(model));
}
}
return(View(model));
}
public async Task <IActionResult> Login(SignInVM thisModel)
{
System.Threading.Thread.Sleep(2000);
ViewBag.LoginMessage = "";
// ModelState.IsValid performs server side validation.
// *ALWAYS* perform server side validation.
if (ModelState.IsValid)
{
var result = await _signInManager.PasswordSignInAsync(thisModel.LoginVM.Email, thisModel.LoginVM.Password, thisModel.LoginVM.RememberMe, lockoutOnFailure : true);
if (result.Succeeded)
{
return(RedirectToAction("Index", "AllDiaryAds"));
}
else if (result.IsLockedOut)
{
ViewBag.LoginMessage = "Login attempt locked out for the next 10 minutes.";
return(View("Index", thisModel));
}
else if (result.IsNotAllowed)
{
ViewBag.LoginMessage = "Please confirm your email before logging in.";
return(View("Index", thisModel));
}
ViewBag.LoginMessage = "Invalid user name or password.";
return(View("Index", thisModel));
}
else
{
ViewBag.LoginMessage = "This entry is invalid.";
}
// return view with errors
return(View("Index", thisModel));
}
public async Task <IActionResult> Login(SignInVM logInData, string returnUrl)
{
if (ModelState.IsValid)
{
HttpContext.Session.Clear();
var user = await db.ApplicationUserList.AsNoTracking().SingleOrDefaultAsync(x => x.UserName == logInData.UserCode || x.PhoneNumber == logInData.UserCode || x.Email == logInData.UserCode);
if (user == null)
{
ModelState.AddModelError(string.Empty, "User not found");
return(View(logInData));
}
var result = await signInManager.PasswordSignInAsync(user.UserName, logInData.Password, false, lockoutOnFailure : false);
if (result.Succeeded)
{
return(RedirectToAction("Index", "home"));
}
ModelState.AddModelError(string.Empty, "Invalid Login Attempt");
}
return(View(logInData));
}
public IActionResult SignIn(SignInVM model)
{
if (ModelState.IsValid)
{
if (model.Email == "*****@*****.**" && model.Senha == "123456")
{
// gerar o cookie de autenticação
var claims = new List <Claim>()
{
new Claim("id", "1"),
new Claim("nome", "Ricardo"),
new Claim("email", model.Email),
new Claim("perfis", string.Join(',', new string[] { "admin", "ti" }))
};
// vai ser encapsulado dentro de um cookie
var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme, "email", "perfis");
var principal = new ClaimsPrincipal(identity);
HttpContext.SignInAsync(principal);
if (!string.IsNullOrEmpty(model.ReturnUrl) && Url.IsLocalUrl(model.ReturnUrl))
{
return(Redirect(model.ReturnUrl));
}
return(RedirectToAction("Index", "Produtos"));
}
ModelState.AddModelError("Email", "usuário ou senha inválidos");
}
return(View());
}
public async Task <IActionResult> SignIn(string returnUrl, SignInVM model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var usuario = await _usuarioRepo.AuthenticateAsync(model.Email, model.Senha);
if (usuario == null)
{
ModelState.AddModelError("", "E-mail ou senha inválidos.");
return(View(model));
}
var claims = new List <Claim>()
{
new Claim("id", usuario.Id.ToString()),
new Claim("nome", usuario.Nome),
new Claim("email", usuario.Email),
new Claim("roles", "admin,ti,estagiario")
};
var identity = new ClaimsIdentity(
claims,
CookieAuthenticationDefaults.AuthenticationScheme,
"nome", "roles"
);
var principal = new ClaimsPrincipal(identity);
await HttpContext.SignInAsync(principal, new AuthenticationProperties {
IsPersistent = model.Lembrar,
ExpiresUtc = DateTime.UtcNow.AddMinutes(10)
});
return(Redirect(returnUrl ?? "/"));
}
private SignInVM CreateSignInVM()
{
if (signInVM == null)
{
signInVM = new SignInVM(messenger, dbUser, dbLogin);
}
return(signInVM);
}
public void ShowResendCodeGrid(bool flag = false)
{
try
{
TwoFactorResendGrid.Visibility = Visibility.Visible;
SignInVM.StartTimer(flag);
}
catch { }
}
public void HideResendCodeGrid()
{
try
{
TwoFactorResendGrid.Visibility = Visibility.Collapsed;
SignInVM.StopTimer();
}
catch { }
}
public IActionResult Index(SignInVM vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
HttpContext.Session.SetString("UserName", vm.UserName);
return(RedirectToAction("Chat"));
}
public IActionResult SignIn(string returnUrl = null)
{
returnUrl ??= Url.Content("~/");
var model = new SignInVM();
model.ReturnUrl = returnUrl;
return(View(model));
}
public ActionResult SignIn(SignInVM signInModel)
{
String s = DBService.Sign_Up(signInModel);
if (s.Equals("Not Valid"))
{
return(View());
}
return(Redirect("~/WebArea/Home/LogIn"));
}
public async Task <IActionResult> signIn(SignInVM signIn)
{
try
{
return(NotFound());
}
catch (Exception xcp)
{
//log exception
return(new StatusCodeResult((int)HttpStatusCode.InternalServerError));
}
}
public async Task <ActionResult> SignIn(SignInVM model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
ApplicationUser user = userManager.FindByName(model.UserName);
if (user.AccessFailedCount > 3)
{
// require captcha
}
if (!user.EmailConfirmed)
{
ModelState.AddModelError("", "Your e-mail has not been confirmed. Please find an e-mail in your mailbox and click the link we have sent you to confirm your e-mail.");
return(View(model));
}
if (!user.IsApproved)
{
ModelState.AddModelError("", "The user has not been yet approved by the administrator.");
return(View(model));
}
if (user.IsDisabled)
{
ModelState.AddModelError("", "The user has been disabled. You cannot log in.");
return(View(model));
}
var result = await signInManager.PasswordSignInAsync(model.UserName, model.Password, isPersistent : model.RememberMe, shouldLockout : true);
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));
}
}
public async Task <IActionResult> SignIn(string returnUrl, SignInVM model)
{
var usuario = await _usuarioRepo.AuthenticateAsync(model.Email, model.Senha.Encrypt());
if (usuario == null)
{
ModelState.AddModelError("", "Email e/ou Senha inválidos");
return(View(model));
}
AddSignIn(usuario, model.Lembrar);
return(LocalRedirect(returnUrl ?? "/"));
}
public async Task <IActionResult> SignIn(SignInVM signInModel)
{
if (ModelState.IsValid)
{
var result = await _accountRepository.PasswordSignInAsync(signInModel);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Exercise"));
}
else
{
ModelState.AddModelError("", "Błędny adres e-mail albo hasło");
}
}
return(View(signInModel));
}
private async void ChallengeV2kWebViewDOMContentLoaded(WebView sender, WebViewDOMContentLoadedEventArgs args)
{
// {"location": "instagram://checkpoint/dismiss", "type": "CHALLENGE_REDIRECTION", "status": "ok"}
SignInVM.LoadingOff();
try
{
string html = await FacebookWebView.InvokeScriptAsync("eval", new string[] { "document.documentElement.outerHTML;" });
if (html.Contains("\"instagram://checkpoint/dismiss\"") || html.Contains("instagram://checkpoint/dismiss"))
{
ChallengeV2CloseButtonClick(null, null);
SignInVM.Login(null);
}
}
catch { }
}
public IActionResult SignIn(SignInVM model)
{
var usuario = _usuarioRepository.GetByEmail(model.Email);
if (usuario == null)
{
ModelState.AddModelError("Email", "Email não cadastrado");
}
else
{
if (model.Senha.Encrypt() != usuario.Senha)
{
ModelState.AddModelError("Senha", "Senha inválida");
}
}
if (ModelState.IsValid)
{
// gerar o cookie de autenticação
var claims = new List <Claim>()
{
new Claim("id", usuario.Id.ToString()),
new Claim("nome", usuario.Nome),
new Claim("email", model.Email),
new Claim("perfis", string.Join(',', new string[] { "admin", "ti" }))
};
// vai ser encapsulado dentro de um cookie
var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme, "email", "perfis");
var principal = new ClaimsPrincipal(identity);
HttpContext.SignInAsync(principal);
if (!string.IsNullOrEmpty(model.ReturnUrl) && Url.IsLocalUrl(model.ReturnUrl))
{
return(Redirect(model.ReturnUrl));
}
return(RedirectToAction("Index", "Produtos"));
}
ModelState.AddModelError("Email", "usuário ou senha inválidos");
return(View());
}
private async void FbStart()
{
try
{
FacebookGrid.Visibility = Visibility.Visible;
SignInVM.LoadingOn();
using (var client = new HttpClient())
{
var response = await client.GetAsync(InstaFbHelper.FacebookAddress);
if (!response.IsSuccessStatusCode)
{
FacebookGrid.Visibility = Visibility.Collapsed;
SignInVM.LoadingOff();
FacebookBlockedMsg.ShowMsg();
return;
}
}
}
catch
{
FacebookGrid.Visibility = Visibility.Collapsed;
SignInVM.LoadingOff();
FacebookBlockedMsg.ShowMsg();
return;
}
try
{
UserAgentHelper.SetUserAgent("Mozilla/5.0 (Linux; Android 4.4; Nexus 5 Build/_BuildID_) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/30.0.0.0 Mobile Safari/537.36");
}
catch { }
try
{
DeleteFacebookCookies();
}
catch { }
FacebookGrid.Visibility = Visibility.Visible;
SignInVM.LoadingOn();
await Task.Delay(1500);
var facebookLogin = InstaFbHelper.GetFacebookLoginUri();
FacebookWebView.Navigate(facebookLogin);
}
public ActionResult SignIn(SignInVM User)
{
//add fullname and userid to vm
if (ModelState.IsValid)
{
Users u = new Users();
if (u.Authenticate(User.Login, User.Passkey))
{
DateTime exDate = User.RememberMe ? DateTime.Now.AddMonths(6) : DateTime.Now.AddDays(1);
FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(1, u.UserID,
DateTime.Now,
exDate,
true,
u.Fullname, FormsAuthentication.FormsCookiePath);
AppUtility.SetCookie(FormsAuthentication.FormsCookieName, FormsAuthentication.Encrypt(ticket), exDate, FormsAuthentication.RequireSSL);
AppUtility.SetCookie("UserFName", u.FirstName);
AppUtility.SetCookie("DeviceType", AppUtility.GetDeviceType());
if (string.IsNullOrEmpty(User.ReturnUrl))
{
return(Redirect(FormsAuthentication.DefaultUrl));
}
else
{
return(Redirect("~" + HttpUtility.UrlDecode(User.ReturnUrl)));
}
}
else
{
ModelState.AddModelError("", Users.ReturnMessage);
TempData["SignInMsg"] = Users.ReturnMessage;
return(RedirectToAction("Index", "Home"));
}
}
ModelState.AddModelError("", "Provide login and password");
TempData["SignInMsg"] = "Provide login and password";
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> Create(SignInVM thisModel)
{
System.Threading.Thread.Sleep(2000);
var user = new ApplicationUser {
UserName = thisModel.RegisterVM.Email, Email = thisModel.RegisterVM.Email
};
if (ModelState.IsValid)
{
var result = await _userManager.CreateAsync(user, thisModel.RegisterVM.Password);
if (result.Succeeded)
{
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Link("Default", new { Controller = "Login", Action = "ConfirmEmail", userId = user.Id, code = code });
await _emailSender.SendEmailAsync(thisModel.RegisterVM.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
// here we assign the new user the "Traveler" role
await _userManager.AddToRoleAsync(user, "Traveler");
ViewBag.Email = thisModel.RegisterVM.Email;
return(View("Create", thisModel));
}
var errorList = new List <string>();
foreach (var errors in result.Errors)
{
errorList.Add(errors.Description);
}
ViewBag.ErrorMessage = errorList;
// Reset the site key if there is an error.
ViewData["SiteKey"] = _configuration["Authentication:Recaptcha:SiteKey"];
return(View("Index", thisModel));
}
else
{
ViewData["SiteKey"] = _configuration["Authentication:Recaptcha:SiteKey"];
}
return(View("Index", thisModel));
}
public async void StartChallengeV2(InstaChallengeLoginInfo challengeLoginInfo)
{
try
{
try
{
//UserAgentHelper.SetUserAgent("Mozilla/5.0 (Linux; Android 4.4; Nexus 5 Build/_BuildID_) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/30.0.0.0 Mobile Safari/537.36");
UserAgentHelper.SetUserAgent($"Mozilla/5.0 (Linux; Android 10; SM-A205U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.86 Mobile Safari/537.36");
}
catch { }
try
{
DeleteFacebookCookies();
}
catch { }
ChallengeV2Grid.Visibility = Visibility.Visible;
SignInVM.ChallengeV2LoadingOn();
await Task.Delay(1500);
Uri baseUri = new Uri(challengeLoginInfo.Url);
HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
var cookies = Helper.InstaApiTrash.HttpRequestProcessor.HttpHandler.CookieContainer
.GetCookies(Helper.InstaApiTrash.HttpRequestProcessor.Client.BaseAddress);
foreach (System.Net.Cookie c in cookies)
{
HttpCookie cookie = new HttpCookie(c.Name, baseUri.Host, "/")
{
Value = c.Value
};
filter.CookieManager.SetCookie(cookie, false);
}
HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, baseUri);
ChallengeV2kWebView.NavigateWithHttpRequestMessage(httpRequestMessage);
}
catch (Exception ex)
{
SignInVM.ChallengeV2LoadingOff();
Helper.ShowErr("Something unexpected happened", ex);
}
}
private void PasswordTextKeyDown(object sender, KeyRoutedEventArgs e)
{
if (e.Key == Windows.System.VirtualKey.Enter)
{
try
{
if (string.IsNullOrEmpty(UsernameText.Text))
{
UsernameText.Focus(FocusState.Keyboard);
}
else if (string.IsNullOrEmpty(PasswordText.Password))
{
PasswordText.Focus(FocusState.Keyboard);
}
else
{
SignInVM.LoginAsync();
}
}
catch { }
}
}
public async Task <IActionResult> SignIn(SignInVM signVm)
{
if (!ModelState.IsValid)
{
return(View());
}
User user = await userManager.FindByEmailAsync(signVm.Email);
if (user == null)
{
ModelState.AddModelError("", "Email or password is invalid.");
return(View(signVm));
}
Microsoft.AspNetCore.Identity.SignInResult signInResult = await signInManager.PasswordSignInAsync(user, signVm.Password, true, true);
if (!signInResult.Succeeded)
{
ModelState.AddModelError("", "Email or password is invalid.");
return(View(signVm));
}
return(RedirectToAction("Index", "Home"));
}
private void SignInViewLoaded(object sender, RoutedEventArgs e)
{
//try
//{
// Visibility = Visibility.Collapsed;
// try
// {
// MainPage.Current.ShowLoading("Gathering information...");
// }
// catch { }
// await Task.Delay(2000);
// await SessionHelper.LoadSession();
// SignInVM.Connected();
//}
//catch { }
//try
//{
// MainPage.Current.HideLoading();
//}
//catch { }
SignInVM.BeforeLogin();
}
private async void WebViewFacebookDOMContentLoaded(WebView sender, WebViewDOMContentLoadedEventArgs args)
{
try
{
SignInVM.LoadingOff();
try
{
string html = await FacebookWebView.InvokeScriptAsync("eval", new string[] { "document.documentElement.outerHTML;" });
if (InstaFbHelper.IsLoggedIn(html))
{
var cookies = GetBrowserCookie(args.Uri);
var sbCookies = new StringBuilder();
foreach (var item in cookies)
{
sbCookies.Append($"{item.Name}={item.Value}; ");
}
var fbToken = InstaFbHelper.GetAccessToken(html);
Helper.InstaApiTrash = Helper.BuildApi();
await Helper.InstaApiTrash.SendRequestsBeforeLoginAsync();
SignInVM.LoadingOn();
var loginResult = await Helper.InstaApiTrash.LoginWithFacebookAsync(fbToken, sbCookies.ToString());
FacebookGrid.Visibility = Visibility.Collapsed;
SignInVM.HandleLogin(loginResult);
}
}
catch { }
}
catch (Exception ex)
{
ex.PrintException("WebViewFacebookDOMContentLoaded");
}
}
