public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Valid(signInModel);
if (!validation.Success)
{
return(new ErrorDataResult <TokenModel>(validation.Message));
}
var userDomain = UserDomainFactory.Create(signInModel);
userDomain.SignIn();
signInModel = userDomain.Map <SignInModel>();
var signedInModel = await UserRepository.SignInAsync(signInModel).ConfigureAwait(false);
validation = new SignedInModelValidator().Valid(signedInModel);
if (!validation.Success)
{
return(new ErrorDataResult <TokenModel>(validation.Message));
}
await AddUserLogAsync(signedInModel.UserId, LogType.SignIn).ConfigureAwait(false);
var tokenModel = CreateJsonWebToken(signedInModel);
return(new SuccessDataResult <TokenModel>(tokenModel));
}
public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Validate(signInModel);
if (validation.IsError)
{
return(DataResult <TokenModel> .Error(validation.Message));
}
var signedInModel = await UserRepository.SignInAsync(signInModel);
validation = SignInService.Validate(signedInModel, signInModel);
if (validation.IsError)
{
return(DataResult <TokenModel> .Error(validation.Message));
}
var userLogModel = new UserLogModel(signedInModel.Id, LogType.SignIn);
await UserLogApplicationService.AddAsync(userLogModel);
await UnitOfWork.SaveChangesAsync();
var tokenModel = SignInService.CreateToken(signedInModel);
return(DataResult <TokenModel> .Success(tokenModel));
}
public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Valid(signInModel);
if (!validation.Success)
{
return(new ErrorDataResult <TokenModel>(validation.Message));
}
UserDomainService.GenerateHash(signInModel);
var signedInModel = await UserRepository.SignInAsync(signInModel);
validation = new SignedInModelValidator().Valid(signedInModel);
if (!validation.Success)
{
return(new ErrorDataResult <TokenModel>(validation.Message));
}
var addUserLogModel = new AddUserLogModel(signedInModel.UserId, LogType.SignIn);
await UserLogApplicationService.AddAsync(addUserLogModel);
var tokenModel = UserDomainService.GenerateToken(signedInModel);
return(new SuccessDataResult <TokenModel>(tokenModel));
}
public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Valid(signInModel);
if (!validation.Success)
{
return(new ErrorDataResult <TokenModel>(validation.Message));
}
var signedInModel = await UserRepository.SignInAsync(signInModel);
if (!SignInService.Validate(signedInModel, signInModel))
{
return(new ErrorDataResult <TokenModel>(Texts.LoginPasswordInvalid));
}
var tokenModel = SignInService.CreateToken(signedInModel);
var addUserLogModel = new AddUserLogModel(signedInModel.UserId, LogType.SignIn);
await UserLogApplicationService.AddAsync(addUserLogModel);
await UnitOfWork.SaveChangesAsync();
return(new SuccessDataResult <TokenModel>(tokenModel));
}
public Task <IResult <string> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Valid(signInModel);
if (!validation.Success)
{
return(Task.FromResult(validation));
}
var signedInModel = UserRepository.SignInAsync(signInModel).Result;
validation = new SignedInModelValidator().Valid(signedInModel);
if (!validation.Success)
{
return(Task.FromResult(validation));
}
var userLogModel = new UserLogModel(signedInModel.UserId, LogType.Login);
UserLogDomain.SaveAsync(userLogModel);
var jwt = CreateJwt(signedInModel);
IResult <string> successResult = new SuccessResult <string>(jwt);
return(Task.FromResult(successResult));
}
public IResult <string> SignIn(SignInModel signInModel)
{
var signInModelValidator = new SignInModelValidator().Valid(signInModel);
if (!signInModelValidator.Success)
{
return(signInModelValidator);
}
var signedInModel = UserRepository.SignIn(signInModel);
var signedInModelValidator = new SignedInModelValidator().Valid(signedInModel);
if (!signedInModelValidator.Success)
{
return(signedInModelValidator);
}
var userLogModel = new UserLogModel(signedInModel.UserId, LogType.Login);
UserLogDomain.Save(userLogModel);
var jwt = CreateJwt(signedInModel);
return(new SuccessResult <string>(jwt));
}
public async Task <IResult <TokenModel> > SignInAsync(SignInModel model)
{
var failResult = Result <TokenModel> .Fail("Invalid login or password!");
var validation = new SignInModelValidator().Validation(model);
if (validation.Failed)
{
return(failResult);
}
var auth = await _authRepository.GetByLoginAsync(model.Login);
if (auth is null)
{
return(failResult);
}
var password = _hashService.Create(model.Password, auth.Salt);
if (auth.Password != password)
{
return(failResult);
}
return(CreateToken(auth));
}
public async Task <IActionResult> Index(SignInModel model)
{
var validator = new SignInModelValidator();
var result = await validator.ValidateAsync(model);
if (result.IsValid)
{
var context = await interactionService.GetAuthorizationContextAsync(model.ReturnUrl);
if (context != null)
{
if (await this.userService.SignInAsync(model.Email, model.Password, model.ReturnUrl, context.Client.ClientId))
{
return(this.Redirect(model.ReturnUrl));
}
}
}
var viewModel = this.signInModelBuilder.BuildModel(new SignInComponentModel {
ReturnUrl = model.ReturnUrl
});
return(this.View(viewModel));
}
public async Task <IDataResult <SignedInModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Valid(signInModel);
if (!validation.Success)
{
return(new ErrorDataResult <SignedInModel>(validation.Message));
}
signInModel.Login = UserDomainService.GenerateHash(signInModel.Login);
signInModel.Password = UserDomainService.GenerateHash(signInModel.Password);
var signedInModel = await UserRepository.SignInAsync(signInModel);
validation = new SignedInModelValidator().Valid(signedInModel);
if (!validation.Success)
{
return(new ErrorDataResult <SignedInModel>(validation.Message));
}
await AddUserLogAsync(signedInModel.UserId, LogType.SignIn).ConfigureAwait(false);
return(new SuccessDataResult <SignedInModel>(signedInModel));
}
public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Validate(signInModel);
if (validation.Failed)
{
return(DataResult <TokenModel> .Fail(validation.Message));
}
var signedInModel = await _userRepository.SignInAsync(signInModel);
validation = _signInService.Validate(signedInModel, signInModel);
if (validation.Failed)
{
return(DataResult <TokenModel> .Fail(validation.Message));
}
var userLogModel = new UserLogModel(signedInModel.Id, LogType.SignIn);
await _userLogApplicationService.AddAsync(userLogModel);
var tokenModel = _signInService.CreateToken(signedInModel);
return(DataResult <TokenModel> .Success(tokenModel));
}
public AuthenticationController(IMyAuthentication myAuthentication,
ResponseBadRequest badRequest,
SignInModelValidator signInModelValidator,
SignOutModelValidator signOutModelValidator,
GenerateTokenModelValidator generateTokenModelValidator)
{
_myAuthentication = myAuthentication;
_badRequest = badRequest;
_signInModelValidator = signInModelValidator;
_signOutModelValidator = signOutModelValidator;
_generateTokenModelValidator = generateTokenModelValidator;
}
public async Task <IResult <TokenModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Validate(signInModel);
if (validation.Failed)
{
return(Result <TokenModel> .Fail(validation.Message));
}
var authEntity = await _authRepository.GetByLoginAsync(signInModel.Login);
validation = Validate(authEntity, signInModel);
if (validation.Failed)
{
return(Result <TokenModel> .Fail(validation.Message));
}
var tokenModel = CreateToken(authEntity);
return(Result <TokenModel> .Success(tokenModel));
}
public async Task <IDataResult <SignedInModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Valid(signInModel);
if (!validation.Success)
{
return(ErrorDataResult <SignedInModel>(validation.Message));
}
UserDomainService.GenerateHash(signInModel);
var signedInModel = await UserRepository.SignInAsync(signInModel);
validation = new SignedInModelValidator().Valid(signedInModel);
if (!validation.Success)
{
return(ErrorDataResult <SignedInModel>(validation.Message));
}
return(SuccessDataResult(signedInModel));
}
public async Task <IDataResult <string> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Valid(signInModel);
if (!validation.Success)
{
return(new ErrorDataResult <string>(validation.Message));
}
var signedInModel = await UserRepository.SignInAsync(signInModel);
validation = new SignedInModelValidator().Valid(signedInModel);
if (!validation.Success)
{
return(new ErrorDataResult <string>(validation.Message));
}
await AddUserLogAsync(signedInModel.UserId, LogType.SignIn);
var jwt = CreateJwt(signedInModel);
return(new SuccessDataResult <string>(jwt));
}
