public async Task <IActionResult> Post(SigninDto signinDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var userIsExist = await _userManager.FindByEmailAsync(signinDto.Email);
if (userIsExist != null)
{
var result = await _signinManager.PasswordSignInAsync(signinDto.Email, signinDto.Password, false, false);
if (!result.Succeeded)
{
return(BadRequest());
}
var user = await _userManager.FindByNameAsync(signinDto.Email);
return(Ok(_unitOfWork.Users.CreateToken(user)));
}
else
{
var user = _mapper.Map <IdentityUser>(signinDto);
var result = await _userManager.CreateAsync(user, signinDto.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await _signinManager.SignInAsync(user, isPersistent : false);
return(Ok(_unitOfWork.Users.CreateToken(user)));
}
return(BadRequest());
}
public async Task <IActionResult> LoginAsync([FromBody] SigninDto dto, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations, [FromServices] IApplicationUserService userService, [FromServices] IValidator <SigninDto> validatorSignin)
{
await HttpContext.SignOutAsync(IdentityConstants.ApplicationScheme);
var validated = await validatorSignin.ValidateAsync(dto);
if (!validated.IsValid)
{
return(UnprocessableEntity(validated.Errors.Select(e => new { message = e.ErrorMessage, statusCode = e.ErrorCode }).Distinct()));
}
var result = await _signInManager.PasswordSignInAsync(dto.Email, dto.Password, true, false);
if (result.Succeeded)
{
var user = (await userService.GetAllIncludingAsync((e => e.Phones))).SingleOrDefault(e => e.Email.ToUpper() == dto.Email.ToUpper());
if (user == null)
{
return(NotFound(new { message = "User Not Found", statusCode = 404 }));
}
user.LastLogin = DateTime.Now;
await userService.UpdateAsync(user, user.Id);
var response = this._mapper.Map <ApplicationUserDto>(user);
var objectToken = user.GenerateToken(tokenConfigurations, signingConfigurations);
return(Ok(new { user = response, token = objectToken }));
}
return(UnprocessableEntity(new { message = "Invalid e-mail or password", statusCode = 422 }));
}
public async Task <IActionResult> SigninAsync([FromBody] SigninDto signinDto, [FromServices] IValidator <SigninDto> validator)
{
var validated = await validator.ValidateAsync(signinDto);
if (!validated.IsValid)
{
return(BadRequest(validated.Errors.Select(e => new { message = e.ErrorMessage, statusCode = e.ErrorCode }).Distinct()));
}
var result = await _authService.AuthenticateAsync(signinDto);
// busca no cache
if (!result.Succeeded)
{
return(BadRequest(new { message = "Invalid e-mail or password", StatusCode = 401 }));
}
// generate token
var user = await _authService.FindAsync(signinDto);
user.Last_Login = DateTime.Now;
var data = _mapper.Map <UserDto>(user);
return(Ok(new {
message = "user logged!",
Token = _jwt.GenerateToken(user).AccessToken,
StatusCode = 200,
Data = data
}));
}
public async Task <ApplicationResult <Member> > IsValidateAsync(SigninDto dto)
{
var member = _memberRepository.GetFirstOrDefault(predicate: x => x.Account == dto.Account);
if (member == null)
{
return(ApplicationResult <Member> .Failed(new ApplicationError
{
Code = nameof(Member.Account),
Description = "會員不存在!!"
}));
}
if (member.Account != dto.Account)
{
var failed = ApplicationResult <Member> .Failed(
new ApplicationError
{
Code = nameof(member.Password),
Description = "輸入密碼錯誤!!"
}
);
failed.Data = _mapper.Map <Member>(member);
return(failed);
}
var success = ApplicationResult <Member> .Success;
success.Data = _mapper.Map <Member>(member);
return(success);
}
public IActionResult Signin([FromBody] CredentialsModel credentials)
{
if (CheckFieldsError())
{
return(BadRequest(ErrorResponse.CreateErrorResponse("Invalid fields", 3)));
}
if (credentials == null || string.IsNullOrWhiteSpace(credentials.Email) || string.IsNullOrWhiteSpace(credentials.Password))
{
return(BadRequest(ErrorResponse.CreateErrorResponse("Missing fields", 4)));
}
UserEntity user = _userService.Signin(credentials.Email, credentials.Password);
if (user != null)
{
SigninDto dto = new SigninDto
{
UserId = user.UserId,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
Password = user.Password,
Phones = user.Phones
};
return(Ok(Crosscutting.Response.CreateResponse(dto)));
}
else
{
return(Ok(ErrorResponse.CreateErrorResponse("Invalid e-mail or password", 5)));
}
}
public async Task <User> FindAsync(SigninDto dto)
{
var cache = _repositoryFacade.GetCache(dto.email.ToString());
UserDto userDto = JsonConvert.DeserializeObject <UserDto>(cache);
if (userDto.email.ToString() == dto.email.ToString())
{
User map = _mapper.Map <User>(userDto);
return(map);
}
User user = await _userManager.FindByEmailAsync(dto.email);
return(user);
}
public async Task <IActionResult> Signin(SigninDto data)
{
try
{
var loginData = await _authenticationService.Login(data.UserName.ToLower(), data.Password);
if (loginData == null)
{
return(Unauthorized());
}
var claims = new []
{
new Claim(ClaimTypes.NameIdentifier, loginData.Id.ToString()),
new Claim(ClaimTypes.Name, loginData.UserName)
};
var privateKey = _config.Value.Token;
var key = new SymmetricSecurityKey(
Encoding.UTF8.GetBytes(privateKey)
);
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(7),
SigningCredentials = creds
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
var user = _mapper.Map <AuthDto>(loginData);
return(Ok(new AuthReturnDto
{
User = user,
Token = tokenHandler.WriteToken(token)
}));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ActionResult SigninAPI(SigninDto signinRequest)
{
signinRequest = SanitizeSigninDto.Sanitize(signinRequest);
if (signinRequest.Errored)
{
return(BadRequest(signinRequest.ErrorMessages));
}
//Authenticate and retrieve token
var authenticator = new Authenticater();
authenticator.AuthenticateSignin(signinRequest.Password, signinRequest.Email);
if (authenticator.Errored)
{
return(BadRequest(authenticator.ErrorMessages));
}
return(Ok(authenticator.Token));
}
public async Task <IActionResult> SigninAsync(SigninDto dto)
{
var result = await _homeService.IsValidateAsync(dto);
if (result.Succeeded)
{
_logger.LogInformation("會員 {0} 登入成功", dto.Account);
return(Ok(result.Data));
}
_logger.LogInformation("會員 {0} 登入失敗", dto.Account);
foreach (var error in result.Errors)
{
ModelState.AddModelError(error.Code, error.Description);
}
return(ValidationProblem());
}
public ActionResult SignIn(SigninDto Vm)
{
var db = new StatementDbContext();
var user = db.Users
.Where(a => a.UserName == Vm.Username && a.Password == Vm.Password)
.FirstOrDefault();
if (user == null)
{
ModelState.AddModelError("Username", "Username or Password is incorrect ...!");
return(View());
}
Session["UserId"] = user.Id;
return(RedirectToAction("List", "Customer"));
}
public async Task <IActionResult> SignIn([FromBody] SigninDto model) => Ok(await _accountRepository.SignIn(model.Email, model.Password));
public async Task <SignInResult> AuthenticateAsync(SigninDto dto)
{
return(await _signInManager.PasswordSignInAsync(dto.email, dto.password, true, false));
}
