public ActionResult Get(SignInViewModel signInViewModel)
{
if (!ValidateLoginAgainstDatabase())
{
return View();
}
return SignIn(signInViewModel);
}
private RedirectResult SignIn(SignInViewModel signInViewModel)
{
if (!ClaimsPrincipal.Current.Identity.IsAuthenticated)
{
CreateGeneralClaimsAndSerializeToStsCookie(signInViewModel.UserName);
}
return new RedirectResult(signInViewModel.ReturnUrl);
}
public async Task sets_the_values_in_the_session() {
Arrange();
ArrangeSession();
var model = new SignInViewModel { Url = _tfsUrl, Username = "******", Password = "******", RememberMe = true };
await _controller.Signin(model);
Assert.AreEqual(_tfsUrl, _sessionProvider.Session.Url);
Assert.AreEqual("*****@*****.**", _sessionProvider.Session.Username);
Assert.AreEqual("12345", _sessionProvider.Session.Password);
Assert.AreEqual(true, _sessionProvider.Session.RememberMe);
}
public ActionResult SignIn(SignInViewModel signinViewModel)
{
Customer db = iCustomerRepository.SignIn(signinViewModel.CustomerName, signinViewModel.Password);
if (db == null)
{
ViewBag.Errormessage = "Invalid Customer Name and Password";
return(View("SignIn"));
}
else
{
Session["Customer"] = db;
return(RedirectToAction("Index", "Home"));
}
return(View("Login", "Customer"));
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
// set up button delegates
FindViewById <Button>(Resource.Id.btnConnect).Click += delegate { this._Connect(); };
FindViewById <Button>(Resource.Id.btnAbortConnect).Click += ButtonAbortConnection_Click;
// set up view model
this._SignInViewModel = new SignInViewModel();
this._SignInViewModel.OnViewModelChanged += _SignInViewModel_OnSignInViewModelChanged;
this._Connect();
}
public async Task <IActionResult> SignIn(SignInViewModel ViewModel)
{
if (ModelState.IsValid)
{
var User = await _userManager.FindByNameAsync(ViewModel.UserName);
if (User != null)
{
if (User.IsActive)
{
var result = await _signInManager.PasswordSignInAsync(ViewModel.UserName, ViewModel.Password, ViewModel.RememberMe, true);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Dashboard", new { area = "Admin" }));
}
else if (result.IsLockedOut)
{
ModelState.AddModelError(string.Empty, "حساب کاربری شما به مدت 20 دقیقه به دلیل تلاش های ناموفق قفل شد.");
}
else if (result.RequiresTwoFactor)
{
return(RedirectToAction("SendCode", new { RememberMe = ViewModel.RememberMe }));
}
else
{
ModelState.AddModelError(string.Empty, "نام کاربری یا کلمه عبور شما صحیح نمی باشد.");
_logger.LogWarning($"The user attempts to login with the IP address({_accessor.HttpContext?.Connection?.RemoteIpAddress.ToString()}) and username ({ViewModel.UserName}) and password ({ViewModel.Password}).");
}
}
else
{
ModelState.AddModelError(string.Empty, "حساب کابری شما غیرفعال است.");
}
}
else
{
ModelState.AddModelError(string.Empty, "نام کاربری یا کلمه عبور شما صحیح نمی باشد.");
_logger.LogWarning($"The user attempts to login with the IP address({_accessor.HttpContext?.Connection?.RemoteIpAddress.ToString()}) and username ({ViewModel.UserName}) and password ({ViewModel.Password}).");
}
}
return(View());
}
public async Task <IActionResult> SignIn(SignInViewModel signInModel)
{
if (ModelState.IsValid)
{
var result = await _signInManager.PasswordSignInAsync(signInModel.Email, signInModel.Password, false, false);
if (result.Succeeded)
{
return(RedirectToAction("Read", "Tasks"));
}
ModelState.AddModelError("Email", "The user with specified credentials is not registered");
return(View());
}
return(View());
}
public ActionResult Index(SignInViewModel viewModel)
{
if (viewModel.Username == "flaviogf" && viewModel.Password == "test123")
{
var context = Request.GetOwinContext();
var claims = new[] { new Claim(ClaimTypes.Name, viewModel.Username) };
var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationType);
context.Authentication.SignIn(identity);
return(RedirectToAction("Index", "Home"));
}
return(View(viewModel));
}
public async Task <ActionResult> Login(string returnUrl, SignInViewModel viewModel)
{
var authResult = await _contentRepository
.WithModelState(this)
.Users()
.Authentication()
.AuthenticateCredentials(new AuthenticateUserCredentialsQuery()
{
Username = viewModel.Username,
Password = viewModel.Password,
UserAreaCode = CofoundryAdminUserArea.Code,
PropertyToValidate = nameof(viewModel.Password)
})
.ExecuteAsync();
if (!ModelState.IsValid)
{
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(Login));
return(View(viewPath, viewModel));
}
// Support redirect urls from login
var redirectUrl = RedirectUrlHelper.GetAndValidateReturnUrl(this);
if (authResult.User.RequirePasswordChange)
{
return(Redirect(_adminRouteLibrary.Auth.ChangePassword(returnUrl)));
}
// If no action required, log the user in
await _contentRepository
.Users()
.Authentication()
.SignInAuthenticatedUserAsync(new SignInAuthenticatedUserCommand()
{
UserId = authResult.User.UserId,
RememberUser = true
});
if (redirectUrl != null)
{
return(Redirect(redirectUrl));
}
return(await GetLoggedInDefaultRedirectActionAsync());
}
public ActionResult SignIn(SignInViewModel viewModel)
{
var drUser = CRCDataAccess.GetCRCUserByLogin(viewModel.Email, viewModel.Password);
if (drUser != null)
{
Session["useremail"] = viewModel.Email;
var authTicket = new FormsAuthenticationTicket(1, drUser["Email"].ToString(), DateTime.Now, DateTime.Now.AddDays(1), true, string.Empty);
var encryptedAuthTicket = FormsAuthentication.Encrypt(authTicket);
var authCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedAuthTicket);
Response.Cookies.Add(authCookie);
return(RedirectToAction("Index"));
}
return(View(viewModel));
}
public MainWindowViewModel()
{
eventsRepository = new EventsRepository();
currentUser = eventsRepository.GetUserByName("cal");
SignInViewModel.ChangeUserCallback switchCurrentUserDelegate = SwitchCurrentUser;
var signInViewModel = new SignInViewModel(eventsRepository, switchCurrentUserDelegate);
WeekGridViewModel = new WeekGridViewModel(eventsRepository, currentUser);
MonthGridViewModel = new MonthGridViewModel(eventsRepository, currentUser);
addEventViewModel = new AddEventViewModel(eventsRepository, currentUser);
CurrentViewModel = signInViewModel;
ChangeCalendarModeCommand = new RelayCommand <CalendarMode>(OnChangeCalendarModeSelected);
ShowAddEventCommand = new RelayCommand(OnShowAddEventSelected);
RefreshCommand = new RelayCommand(OnRefreshSelected);
EditEventsCommand = new RelayCommand(OnEditEventsSelected);
}
public ActionResult SignIn(string returnUrl)
{
var vm = new SignInViewModel();
//So that the user can be referred back to where they were when they click logon
if (string.IsNullOrEmpty(returnUrl) && Request.UrlReferrer != null)
{
returnUrl = Server.UrlEncode(Request.UrlReferrer.PathAndQuery);
}
if (Url.IsLocalUrl(returnUrl) && !string.IsNullOrEmpty(returnUrl))
{
vm.ReturnUrl = returnUrl;
}
return(View(vm));
}
public async Task <IActionResult> SignInAsync(SignInViewModel viewModel)
{
var userId = await _userService.TrySignInAsync(viewModel.Email, viewModel.Password);
if (string.IsNullOrEmpty(userId))
{
return(Unauthorized());
}
await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
var principal = await _principalFactory.CreateAsync(userId);
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal);
return(Ok());
}
public async Task <IActionResult> SignIn(SignInViewModel model)
{
if (ModelState.IsValid)
{
var result = await _signInManager.PasswordSignInAsync(model.Username, model.Password,
model.ShouldIRememberYou, false);
if (result.Succeeded)
{
return(RedirectToAction("List", "BankAccount"));
}
model.ShouldIShowSignInError = true;
}
return(View(model));
}
public async Task <IActionResult> SignIn(SignInViewModel model)
{
if (ModelState.IsValid)
{
var result = await _authenticationManager.SignUpUserAsync(model);
if (result.Success)
{
return(Redirect($"{WebSitesUrls.CallingPoient}"));
}
foreach (var err in result.Errors)
{
ModelState.AddModelError(err.Code, err.Description);
}
}
return(View(model));
}
public async Task <IActionResult> SignIn()
{
if (User.Identity.IsAuthenticated)
{
return(Forbid());
}
var model = new SignInViewModel();
var content = await this.RenderViewToStringAsync("/Views/Authentication/SignIn.cshtml", model);
return(new ContentResult
{
ContentType = "text/html",
StatusCode = (int)HttpStatusCode.OK,
Content = content
});
}
public IActionResult SignIn(SignInViewModel requestModel)
{
if (ModelState.IsValid)
{
string userId = userService.SignIn(requestModel.Email, requestModel.Password);
if (userId != null)
{
HttpContext.Session.SetString("logeduser", userId);
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "Invalid email or password.");
}
}
return(View());
}
public async Task <IHttpActionResult> ConfirmEmail(ConfirmEmalViewModel model)
{
try
{
var account = await _auth.AccountGetAsync(model.UserId);
if (object.Equals(account, null))
{
return(AccountNotFound());
}
model.Token = HttpUtility.UrlDecode(model.Token);
IdentityResult result = null;
if (string.IsNullOrEmpty(model.Token)) //such bad solution, but saves a lot of time
{
result = await _auth.AccountConfirmEmailAsync(account.Id);
}
else
{
result = await _auth.AccountConfirmEmailAsync(account.Id, model.Token);
}
var errorResult = GetErrorResult(result);
if (!object.Equals(errorResult, null))
{
return(errorResult);
}
if (model.IsBusiness())
{
await _auth.AccountMaskAsBusinessAsync(account);
}
await _auth.AccountActivateAsync(account);
await _auth.AccountVisitorIdSetAsync(account, model.VisitorId);
var internalSignInViewModel = new SignInViewModel(account);
return(ResponseMessage(await OauthManager.InternalSignIn(internalSignInViewModel)));
}
catch (Exception exc) { return(Request.HttpExceptionResult(exc)); }
}
public async Task <IActionResult> SignIn(SignInViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user != null)
{
var logins = await _userManager.GetLoginsAsync(user);
if (logins.Any())
{
ModelState.AddModelError("LoginExists",
$"This user has signed up using {logins.First().LoginProvider}. Please use {logins.First().ProviderDisplayName} to sign in."
);
return(View(model));
}
}
var result =
await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, false);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
if (result.IsLockedOut)
{
ModelState.AddModelError("LockOut",
"Your account is suspended. If you have tried to login several times, wait for 10 minutes then try again. Otherwise contact support!");
}
else
if (result.IsNotAllowed)
{
ModelState.AddModelError("NotAllowed",
"It seems that you have not confirmed your email yet. Check your mailbox and click on the link we have sent to you!");
}
else
{
ModelState.AddModelError("LoginFailed", "Login failed. Have you entered a correct password?");
}
}
return(View(model));
}
/// <exception cref="T:System.ArgumentNullException"><paramref name="model"/> is <see langword="null"/></exception>
/// <exception cref="T:System.UriFormatException">
/// Note: In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception,
/// <see cref="T:System.FormatException"/>, instead.
/// uriString is empty.
/// -or-
/// The scheme specified in uriString is not correctly formed. See
/// <see cref="M:System.Uri.CheckSchemeName(System.String)"/>.
/// -or-
/// uriString contains too many slashes.
/// -or-
/// The password specified in uriString is not valid.
/// -or-
/// The host name specified in uriString is not valid.
/// -or-
/// The file name specified in uriString is not valid.
/// -or-
/// The user name specified in uriString is not valid.
/// -or-
/// The host or authority name specified in uriString cannot be terminated by backslashes.
/// -or-
/// The port number specified in uriString is not valid or cannot be parsed.
/// -or-
/// The length of uriString exceeds 65519 characters.
/// -or-
/// The length of the scheme specified in uriString exceeds 1023 characters.
/// -or-
/// There is an invalid character sequence in uriString.
/// -or-
/// The MS-DOS path specified in uriString must start with c:\\.
/// </exception>
/// <exception cref="T:System.Net.NetworkInformation.NetworkInformationException">When model is unprocessable.</exception>
public async Task <UserLoginResponse> SignInAsync(SignInViewModel model)
{
if (model is null)
{
_logger.LogError($"{nameof(AuthenticationService)}: sign in: model was null");
throw new ArgumentNullException(nameof(model));
}
if (model.LoginOrEmail is null)
{
_logger.LogError($"{nameof(AuthenticationService)}: sign in: login or email was null");
throw new ArgumentNullException(nameof(model.LoginOrEmail));
}
if (model.RawPassword is null)
{
_logger.LogError($"{nameof(AuthenticationService)}: sign in: raw password was null");
throw new ArgumentNullException(nameof(model.RawPassword));
}
var client = _httpClientFactory.CreateClient("Sign In client");
client.PrepareJsonRequest($"{MicroservicesUrls.IdentityServer}{IdentityServerRoutes.Authentication.AuthenticationEndpoint}/");
var mappedRequestModel = _mapper.Map <SignInViewModel, UserSignInRequest>(model);
var responseMessage = await client.PostAsJsonAsync($"{IdentityServerRoutes.Authentication.SignIn}", mappedRequestModel);
if (!responseMessage.IsSuccessStatusCode)
{
_logger.LogError($"Request from {nameof(AuthenticationService)}, Sign In: to Identity server returned a server error : StatusCode: {responseMessage.StatusCode}");
if (responseMessage.StatusCode == HttpStatusCode.UnprocessableEntity)
{
throw new NetworkInformationException((int)responseMessage.StatusCode);
}
}
var signInResponseContent = await responseMessage.Content.ReadFromJsonAsync <UserLoginResponse>();
return(signInResponseContent);
}
public async Task <IActionResult> SignIn([FromQuery(Name = "ReturnUrl")] string returnUrl,
[Bind("Email, Password")] SignInViewModel data)
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Recipe"));
}
try
{
if (!ModelState.IsValid)
{
throw new Exception("The credentials provided are invalid");
}
var connection = dbFactory.GetConnection(RolesEnum.Anonymous);
var passwordHash = Helpers.EncodePassword(data.Password);
var queryString = $"SELECT Email, Password FROM AspNetUsers WHERE Email=@Email AND Password=@Password;";
SqlCommand command = new SqlCommand(queryString, connection);
command.Parameters.Add("@Email", System.Data.SqlDbType.NVarChar);
command.Parameters.Add("@Password", System.Data.SqlDbType.NVarChar);
command.Parameters["@Email"].Value = data.Email;
command.Parameters["@Password"].Value = passwordHash;
using (SqlDataReader reader = command.ExecuteReader())
{
bool found = reader.Read();
if (!found)
{
throw new Exception("The credentials provided are invalid");
}
var user = await userManager.FindByEmailAsync(data.Email);
await signInManager.SignInAsync(user, false);
}
}
catch (Exception e)
{
ViewData["Error"] = "Girilen kullanıcı bilgilerini kontrol ediniz";
ViewData["ReturnUrl"] = string.IsNullOrEmpty(returnUrl) == true ? "/" : returnUrl;
return(View(data));
}
if (!string.IsNullOrEmpty(returnUrl) && Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
return(RedirectToAction(actionName: "Index", controllerName: "Recipe"));
}
public void ShouldCreateUserIfNoUserExistsWithGivenUserName()
{
var userName = "******";
eventsRepositoryMock.Setup(er => er.GetUserByName(userName)).Returns((User)null);
var signInViewModel = new SignInViewModel(eventsRepositoryMock.Object, user => { });
signInViewModel.UsernameText = userName;
((ICommand)signInViewModel.SignInCommand).Execute(null);
var newUser = new User
{
Name = userName
};
eventsRepositoryMock.Verify(er => er.AddUser(It.IsAny <User>()));
}
public async Task <string> SignIn(SignInViewModel model)
{
await _authValidationService.ValidateSignInViewModel(model);
var result = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, false, false);
if (!result.Succeeded)
{
throw new SignInFailedException(
$"An error occured while signing in user: {model.UserName}");
}
var user = await _userManager.FindByNameAsync(model.UserName);
var token = await GetToken(user);
return(token);
}
public async Task <ActionResult> SignIn(SignInViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (_securityService.VerifyUserPassword(model.UserName, model.Password) != true)
{
ModelState.AddModelError("UserName", "These credentials aren't valid.");
return(View(model));
}
var user = _userQueries.GetUserByUserName(model.UserName);
await _securityService.SignIn(user.Id);
return(Redirect("/"));
}
public SignInResult SignIn(SignInViewModel user)
{
var request = new RestSharp.RestRequest(AccountAPI.SignIn)
{
JsonSerializer = new NewtonsoftJsonSerializer()
};
request.AddJsonBody(user);
IRestResponse response = _client.Post(request);
var json = JsonConvert.DeserializeObject <GenericAPIResponse>(response.Content);
return(new SignInResult()
{
Succeed = json.success,
ErrorMessage = json.error
});
}
public IActionResult SignIn(SignInViewModel model)
{
//attempting to find customer in database
User user = DataReader.SignIn(model.Email).GetAwaiter().GetResult();
//if not found, show error message
if (user == null)
{
ViewBag.Error = "We do not recognize your email and/or password. Please try again or Register for an account.";
return(View(model));
}
//if found, save to session and redirect to UserHome
HttpContext.Session.SetString(SessionKeyName, user.Name);
HttpContext.Session.SetString(SessionKeyEmail, user.Email);
return(RedirectToAction("Bot"));
}
public async Task <IActionResult> SignIn(SignInViewModel model, string ReturnUrl)
{
if (ModelState.IsValid)
{
var Result = await signInManager.PasswordSignInAsync(model.Username, model.Password, model.RememberMe, false);
if (Result.Succeeded)
{
if (!string.IsNullOrEmpty(ReturnUrl) && Url.IsLocalUrl(ReturnUrl))
{
return(Redirect(ReturnUrl));
}
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError(string.Empty, "Invalid login attempt.");
}
return(View(model));
}
public IActionResult signIn(SignInViewModel model)
{
var data = _userService.GetUser(model.Username, model.Password);
if (data == null)
{
return(Ok(false));
}
else
{
HttpContext.Session.SetObject("username", data.Username);
HttpContext.Session.SetObject("id", data.Id);
var us = HttpContext.Session.GetObject <String>("username");
return(Ok(data.Username));
}
}
public async Task <IActionResult> SignIn(SignInViewModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
User user;
if (await this.usersService.ValidateCredentials(out user, model.Email, model.Password, "Default"))
{
await SignInUser(user, returnUrl);
if (returnUrl != null)
{
return(Redirect(returnUrl));
}
return(RedirectToAction("Index", "Home"));
}
}
return(View(model));
}
public async Task <IActionResult> SignIn(SignInViewModel model)
{
if (ModelState.IsValid)
{
var result = await _signinManager.PasswordSignInAsync(model.UserName, model.Password, model.RemeberMe, false);
if (result.Succeeded)
{
return(RedirectToAction("Search", "PersonFinder"));
}
else
{
ModelState.AddModelError("Login", "Cannot login.");
}
}
return(View(model));
}
//TODO: SignIn and SignUp
public async Task <bool> SignIn(SignInViewModel model)
{
try
{
var response = await httpClient.PostAsJsonAsync(uri + "SignIn", model);
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Success");
return(true);
}
}
catch (Exception e)
{
Console.WriteLine($"{e.Message}");
}
return(false);
}
public ActionResult Create(SignInViewModel model)
{
var users = db.Users.Where(u => u.Email == model.Email).ToList();
foreach (var user in users)
{
if (user.Password == model.Password)
{
TempData["success"] = "Welcome back, " + user.Name;
FormsAuthentication.SetAuthCookie(user.Id.ToString(), false);
// Session["CurrentUser"] = user;
return(RedirectToAction("Dashboard", "Home"));
}
}
TempData["error"] = "Invalid email/password combination.";
return(View());
}
public IActionResult Admin(SignInViewModel signInViewModel)
{
User user = context.Users.FirstOrDefault(c => c.Username == "Admin");
if (signInViewModel.Username != "Admin")
{
ViewBag.Title = "Check the name you entered";
return(View(signInViewModel));
}
if (signInViewModel.Password != "littlehelp")
{
ViewBag.Title = "Wrong Password";
return(View(signInViewModel));
}
return(RedirectToAction("Index", "Admin"));
}
