public async Task <IActionResult> SignInAsync(SignInUserViewModel model)
{
if (ModelState.IsValid)
{
var user = new User
{
Email = model.Email,
UserName = model.Email,
FirstName = char.ToUpper(model.FirstName[0]) + model.FirstName.Substring(1),
LastName = char.ToUpper(model.LastName[0]) + model.LastName.Substring(1),
PhoneNumber = model.PhoneNumber,
Gender = model.Gender,
CreatedAt = DateTime.UtcNow,
ProfilePicture = _fileService.UploadFile(model),
};
var result = await _userManager.CreateAsync(user, model.Password1);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, "Klient");
return(View("SignInConfirmation"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
ModelState.Clear();
ModelState.AddModelError("", "Użytkownik o tej nazwie jest już zarejestrowany, spróbuj jeszcze raz!");
}
return(View());
}
public async Task <ActionResult> SignIn(SignInUserViewModel details)
{
if (this.User.Identity.IsAuthenticated)
{
return(View("Error"));
}
var user = await UserManager.FindAsync(details.Name, details.Password);
if (user == null)
{
ModelState.AddModelError("", "Wrong name or password.");
}
else
{
ClaimsIdentity ident = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignOut();
AuthManager.SignIn(new AuthenticationProperties
{
IsPersistent = false
}, ident);
return(RedirectToAction("Index"));
}
return(View(details));
}
public ActionResult SignInUser(SignInUserViewModel model)
{
if (!ModelState.IsValid)
{
Helpers.InvalidModelState(ModelState);
}
var userId = _userService.SignInUser(model);
return(Json(userId));
}
public async Task <SignInUserResponse> SignIn(SignInUserViewModel signInUserViewModel)
{
var loginContent = GetContent(signInUserViewModel);
var response = await _httpClient.PostAsync($"/api/auth/sign-in", loginContent);
if (!TreateErrorsResponse(response))
{
return(new SignInUserResponse
{
ResponseResult = await DeserializeObjectResponse <ResponseResult>(response)
});
}
return(await DeserializeObjectResponse <SignInUserResponse>(response));
}
public ActionResult SignIn(SignInUserViewModel signInUser)
{
if (ModelState.IsValid)
{
if (_accountManager.UserExists(signInUser.UserName, signInUser.Password))
{
_accountManager.SignIn(signInUser.UserName, HttpContext);
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "Wrong username or password.");
}
}
return(View(signInUser));
}
Guid IUserService.SignInUser(SignInUserViewModel model)
{
_unitOfWork.BeginTransaction();
var user = _userRepository.GetAll().Where(x => x.Email == model.Email && x.Password == model.Password).FirstOrDefault();
if (user == null)
{
_unitOfWork.Commit();
throw new Exception(ExceptionMessages.UserException.NOT_FOUND);
}
var userId = _userRepository.signIn(user);
_unitOfWork.Commit();
return(userId);
}
public async Task <IActionResult> Signin(SignInUserViewModel usermodel, string returnUrl)
{
if (ModelState.IsValid)
{
var result = await _accountRepository.PasswordSignInUserAsync(usermodel);
if (result.Succeeded)
{
if (!string.IsNullOrEmpty(returnUrl))
{
return(LocalRedirect(returnUrl));
}
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "Invalid info");
}
return(View(usermodel));
}
public async Task <IActionResult> SignIn(SignInUserViewModel signInUserViewModel, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (!ModelState.IsValid)
{
return(View(signInUserViewModel));
}
var response = await _authService.SignIn(signInUserViewModel);
if (ResponseHaveErrors(response.ResponseResult))
{
return(View(signInUserViewModel));
}
await SignIn(response);
return(string.IsNullOrEmpty(returnUrl) ?
RedirectToAction("Index", "Catalog") :
LocalRedirect(returnUrl));
}
public async Task <JsonNetResult> SignInUser(SignInUserViewModel model)
{
if (ModelState.IsValid == false)
{
return(JsonFailure());
}
// Verify the user's credentials
Guid?userId = await _userManagement.VerifyCredentials(model.EmailAddress, model.Password);
if (userId == null)
{
ModelState.AddModelError(string.Empty, "Invalid email address or password");
return(JsonFailure());
}
SignTheUserIn(userId.Value);
return(JsonSuccess(new UserSignedInViewModel {
AfterLoginUrl = Url.Action("Index", "Home")
}));
}
public async Task <IActionResult> Login(SignInUserViewModel user)
{
var signInUserDto = Mapper.Map <SignInUserDto>(user);
ServiceResult serviceResult = await UserService.SignInAsync(signInUserDto);
if (serviceResult.Result == Result.Error)
{
foreach (var error in serviceResult.Errors)
{
ModelState.AddModelError(error.Key, error.Message);
}
return(View(user));
}
// проверяем, принадлежит ли URL приложению
if (!string.IsNullOrEmpty(user.ReturnUrl) && Url.IsLocalUrl(user.ReturnUrl))
{
return(Redirect(user.ReturnUrl));
}
return(RedirectToTimetables());
}
public async Task <IActionResult> SignIn([FromBody] SignInUserViewModel signInUserViewModel)
{
var signInUser = signInUserViewModel.ConvertToEntity();
if (!signInUser.IsValid())
{
return(CustomResponse(signInUser));
}
var result = await __signInManager.PasswordSignInAsync(signInUser.Email, signInUser.Password, false, true);
if (result.Succeeded)
{
return(CustomResponse(await GenerateJWT(signInUser.Email)));
}
if (result.IsLockedOut)
{
AdicionarErroProcessamento("Usuário temporariamente bloqueado por tentativas inválidas.");
return(CustomResponse());
}
AdicionarErroProcessamento("Usuário ou senha incorretos.");
return(CustomResponse());
}
public async Task <SignInResult> PasswordSignInUserAsync(SignInUserViewModel userViewModel)
{
var result = await _SignInManager.PasswordSignInAsync(userViewModel.Username, userViewModel.Password, userViewModel.RememberMe, false);
return(result);
}
public IActionResult SignIn()
{
var user = new SignInUserViewModel();
return(View(user));
}
public static SignInUser ConvertToEntity(this SignInUserViewModel model) => new SignInUser(model.Email, model.Password);
