public BaseResponseModel SignIn(SignInInputModel inputModel)
{
var vm = new AuthResponseModel();
var user = UserService.Authenticate(inputModel.Email, inputModel.Password);
if (user != null)
{
_auth.DoAuth(inputModel.Email, inputModel.RememberMe);
vm.Success = true;
vm.Token = user.AuthToken.Token;
vm.Expires = user.AuthToken.Expires;
}
else
{
vm.Errors.Add("Invalid email or password");
LogService.CreateLog(new Log
{
Category = LogCategory.Security,
IpAddress = GetClientIp(ControllerContext.Request),
Level = LogLevel.Info,
Message = "Authentication failed using email: " + inputModel.Email
});
}
return(vm);
}
private async Task <SignInViewModel> BuildSignInViewModelAsync(SignInInputModel model)
{
var viewModel = await BuildSignInViewModelAsync(model.ReturnUrl);
viewModel.Email = model.Email;
viewModel.RememberMe = model.RememberMe;
return(viewModel);
}
private async Task <SignInViewModel> CreateSigninModelAsync(SignInInputModel signIn)
{
var model = await CreateSigninModelAsync(signIn.ReturnUrl);
model.Email = signIn.Email;
model.RememberMe = signIn.RememberMe;
return(model);
}
public async Task <IActionResult> SignIn([FromBody] SignInInputModel signInInputModel)
{
var retorno = await _userService.SignIn(signInInputModel);
if (retorno == null)
{
return(NotFound());
}
return(Ok(BuildToken(retorno)));
}
public bool Is_Customer_Sign_Input_Valid(SignInInputModel CustomerSignInInput)
{
string passwordPattern = @"^[^\s^<>]*$";
string emailPattern = @"[\w-]+@([\w-]+\.)+[\w-]+";
Regex passwordRegex = new Regex(passwordPattern);
Regex emailRegex = new Regex(emailPattern);
if (emailRegex.IsMatch(CustomerSignInInput.EmailAddress) && passwordRegex.IsMatch(CustomerSignInInput.Password) && CustomerSignInInput.EmailAddress != null && CustomerSignInInput.Password != null)
{
return(true);
}
return(false);
}
public IActionResult SignIn([FromBody] SignInInputModel inputModel)
{
if (!ModelState.IsValid)
{
BadRequest();
}
string passwordHash = _cryptographyService.GetHashString(inputModel.Password);
var user = _userService.GetUser(inputModel.EmailAddress, passwordHash);
if (user == null)
{
NotFound("User not found");
}
return(Ok(user));
}
public async Task <SignInViewModel> SignIn(SignInInputModel signInInputModel)
{
SignInViewModel ret = null;
var user = await _userRepository.SignIn(signInInputModel.Email, signInInputModel.Password);
if (user != null)
{
AddressViewModel address = null;
var person = _mapper.Map <Person, PersonViewModel>(user.Person);
if (user.Person.Address.Count() > 0)
{
address = _mapper.Map <Address, AddressViewModel>(user.Person.Address.FirstOrDefault());
}
ret = new SignInViewModel(null, DateTime.Now, person, address);
}
return(ret);
}
public ActionResult SignIn(SignInInputModel inputModel)
{
if (ModelState.IsValid)
{
if (!User.Identity.IsAuthenticated)
{
var saltedInputPassword = HashUtilities.GetPasswordHash(inputModel.Password,
SiteSettings.PasswordSalt);
if (saltedInputPassword == SiteSettings.PasswordHash && inputModel.Username == SiteSettings.Username)
{
FormsAuthentication.SetAuthCookie(inputModel.Username, inputModel.RememberMe);
return Redirect(inputModel.ReturnUrl);
}
ModelState.AddModelError("Username", "Username & Password are not correct");
ModelState.AddModelError("Password", "Username & Password are not correct");
}
}
return SignIn();
}
public async Task <IActionResult> SignIn(SignInInputModel model, string button)
{
var context = await _interactionService.GetAuthorizationContextAsync(model.ReturnUrl);
if (button != "signin")
{
if (context is not null)
{
await _interactionService.DenyAuthorizationAsync(context, AuthorizationError.AccessDenied);
if (context.IsNativeClient())
{
return(this.LoadingPage("Redirect", model.ReturnUrl));
}
return(Redirect(model.ReturnUrl));
}
else
{
return(Redirect("/"));
}
}
if (ModelState.IsValid)
{
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure : true);
if (result.Succeeded)
{
var user = await _userManager.FindByEmailAsync(model.Email);
await _eventService.RaiseAsync(new UserLoginSuccessEvent(user.Email, user.Id, user.UserName, clientId : context?.Client.ClientId));
if (context is not null)
{
if (context.IsNativeClient())
{
return(this.LoadingPage("Redirect", model.ReturnUrl));
}
return(Redirect(model.ReturnUrl));
}
if (Url.IsLocalUrl(model.ReturnUrl))
{
return(Redirect(model.ReturnUrl));
}
else if (string.IsNullOrEmpty(model.ReturnUrl))
{
return(Redirect("~/"));
}
else
{
throw new Exception("Invalid return URL");
}
}
await _eventService.RaiseAsync(new UserLoginFailureEvent(model.Email, "Invalid credentials", clientId : context?.Client.ClientId));
ModelState.AddModelError(string.Empty, AccountOptions.InvalidCredentialsErrorMessage);
}
var viewModel = await BuildSignInViewModelAsync(model);
ViewData["ReturnUrl"] = model.ReturnUrl;
return(View(viewModel));
}
public async Task <IActionResult> Signin([FromForm] SignInInputModel model, [FromForm] string button)
{
var context = await interactions.GetAuthorizationContextAsync(model.ReturnUrl);
if ("signin" != button)
{
logger.LogDebug("Signin executing");
if (null != context)
{
await interactions.GrantConsentAsync(context, ConsentResponse.Denied);
if (await clientStore.IsPkceClientAsync(context.ClientId))
{
return(View("Redirect", new RedirectModel {
RedirectUrl = model.ReturnUrl
}));
}
return(Redirect(model.ReturnUrl));
}
return(Redirect("~/"));
}
if (ModelState.IsValid)
{
var result = await mediator.Send(
new GetCustomerQuery(model.Email, model.Password),
HttpContext.RequestAborted
);
if (result.IsFailed)
{
return(View());
}
if (result.IsNotAllowed)
{
return(View());
}
if (result.IsLockedOut)
{
return(View());
}
if (result.RequiresTwoFactor)
{
return(View());
}
if (result.IsSucceeded)
{
var customer = result.Customer;
await eventService.RaiseAsync(new UserLoginSuccessEvent(
IdentityServerConstants.LocalIdentityProvider,
customer.Id.ToString(),
customer.Email,
customer.UserName)
);
await mediator.Send(
new SigninCommand(customer, model.RememberMe),
HttpContext.RequestAborted
);
if (null != context)
{
if (await clientStore.IsPkceClientAsync(context.ClientId))
{
return(View("Redirect", new RedirectModel {
RedirectUrl = model.ReturnUrl
}));
}
return(Redirect(model.ReturnUrl));
}
if (Url.IsLocalUrl(model.ReturnUrl))
{
return(Redirect(model.ReturnUrl));
}
if (String.IsNullOrEmpty(model.ReturnUrl))
{
return(Redirect("~/"));
}
var uri = new Uri(model.ReturnUrl);
if (uri.IsAbsoluteUri)
{
return(Redirect(model.ReturnUrl));
}
throw new Exception("Invalid redirect url");
}
}
//var invalidCredentials = localizer.InvalidCredentials(context?.UiLocales);
var invalidCredentials = "Invalid credentials";
await eventService.RaiseAsync(new UserLoginFailureEvent(model.Email, invalidCredentials));
ModelState.AddModelError(String.Empty, invalidCredentials);
return(View(await CreateSigninModelAsync(model)));
}
public Customer CustomerLoggingIn(SignInInputModel CustomerSignInInput)
{
var result = db.Customers.Where(customer => customer.EmailAddress == CustomerSignInInput.EmailAddress && customer.Password == CustomerSignInInput.Password).First();
return(result);
}
public string LoggedInUser(SignInInputModel CustomerSignInInput)
{
Customer customer = CustomerRepository.CustomerLoggingIn(CustomerSignInInput);
return(customer.FirstName + "," + customer.Id.ToString());
}
public bool IsCustomerSignInExist(SignInInputModel CustomerSignInInput)
{
var result = db.Customers.Where(customer => customer.EmailAddress == CustomerSignInInput.EmailAddress && customer.Password == CustomerSignInInput.Password).ToList();
return(result.Count > 0);
}
