public async Task <SigninResponse> SignInAsync(SigninRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var response = null as SigninResponse;
var manager = await this.managerRepository.GetManagerAsync(request.Email)
.ConfigureAwait(false);
if (manager != null)
{
if ((manager.VerificationStatus == VerificationStatus.Verified) && (PasswordHelper.IsValid(request.Password, manager.Password)))
{
var token = TokenHelper.CreateToken(
this.TokenSigningKey,
manager.Id.ToString(),
manager.Name);
response = new SigninResponse()
{
Token = TokenHelper.EncodeToken(token)
};
}
}
return(response);
}
public UserTokenResponse signin([FromBody] SigninRequest signinRequest)
{
User user = _userRepository.Authenticate(signinRequest.username, signinRequest.password);
return(new UserTokenResponse
{
token = user.token
});
}
public async Task <ActionResult <SigninResponse> > SignInAsync([FromBody] SigninRequest request)
{
var response = await this.service.SignInAsync(request);
if (response == null)
{
return(new StatusCodeResult(401));
}
return(Ok(response));
}
public async Task <ActionResult <SigninResponse> > Signin(SigninRequest request)
{
var token = await _userService.SignInAsync(request.Email, request.Password);
if (token == null)
{
return(NotFound(new ErrorResponse(ErrorCode.UserNotFound)));
}
return(new SigninResponse {
Email = request.Email, Token = token.Token
});
}
/// <summary>
/// Sign in the user account.
/// </summary>
/// <param name="userName">
/// Citrus Pay UserName.
/// </param>
/// <param name="password">
/// Citrus Pay Password.
/// </param>
/// <returns>
/// Sign In state, true for success, false for failure
/// </returns>
public static async Task <bool> SigninUser(string userName, string password)
{
var request = new SigninRequest {
User = new User {
UserName = userName, Password = password
}
};
var rest = new RestWrapper();
var result = await rest.Post <object>(Service.Signin, request);
return(result != null);
}
public static async Task<bool> IsCitrusMemeber(string email, string mobile)
{
var newUser = await BindUser(email, mobile);
var randomPasswordGenerator = new RandomPasswordGenerator();
newUser.Password = randomPasswordGenerator.Generate(newUser.Email, newUser.Mobile);
var request = new SigninRequest { User = new User { UserName = newUser.UserName, Password = newUser.Password } };
var rest = new RestWrapper();
var result = await rest.Post<OAuthToken>(Service.Signin, AuthTokenType.None, request);
if (!(result is Error))
{
return false;
}
return true;
}
public async Task <ActionResult <SigninResponse> > SignIn([FromBody] SigninRequest body)
{
var user = await _userService.GetUserAsync(body.email, body.password);
if (user == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
await _userService.UpdateAsync(user);
return(Ok(new {
user.id,
user.created_at,
user.updated_at,
user.last_login,
user.access_token,
}));
}
public override void BuildPacket()
{
base.BuildPacket();
var siginRequest = new SigninRequest
{
email = Email,
password = Password,
type = SiginType
};
byte[] packetData;
using (var stream = new MemoryStream())
{
Serializer.Serialize(stream, siginRequest);
packetData = stream.ToArray();
}
GlobalVariables.CountRequest++;
Packet = StoreConnection.BuildServerPacket(packetData.Length + 16, (int)MessageType.Type.SIGNIN, 2,
packetData, GlobalVariables.CountRequest);
}
public async Task <ActionResult <SigninResponse> > Signup(SigninRequest request)
{
try
{
await _userService.SignUpAsync(request.Email, request.Password);
}
catch (AppBusinessException e)
{
if (e.ErrorCode == "EmailAreadyExists")
{
return(Conflict());
}
}
catch
{
return(BadRequest());
}
return(await Signin(request));
}
public IHttpActionResult Signin([FromBody] SigninRequest request)
{
try
{
var decrypted = RsaEncryption.Decrypt(request.Request);
var auth = JsonConvert.DeserializeObject <AuthModel>(decrypted);
// use hard-coded user name and hashed password
if (auth.Username.ToLower() == "demo" && auth.Password == "QBG6AuURBMZ4wxp2pERIWzjzhl5QTYnDoKgLQ5uxojc=")
{
return(Ok(JwtUtil.GenerateToken(auth)));
}
return(Unauthorized());
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
/// <summary>
/// Autenticar um usuário válido
/// </summary>
/// <param name="signinRequest">Dados para autenticação</param>
/// <returns></returns>
public async Task<SigninResponse> AuthValidUserAsync(
SigninRequest signinRequest)
{
_httpClient.DefaultRequestHeaders.Authorization = null;
HttpResponseMessage response = await _httpClient.PostAsync(
Endpoints.Auth.Signin_v1_0,
signinRequest.ToStringContent()).ConfigureAwait(false);
response.StatusCode.Should().Be(HttpStatusCode.OK);
string bodyResponse = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
SigninResponse signinResponse = JsonConvert.DeserializeObject<SigninResponse>(
bodyResponse);
signinResponse.Should().NotBeNull();
signinResponse.Token.Should().NotBeNull();
signinResponse.RefreshToken.Should().NotBeNull();
return signinResponse;
}
/// <summary>
/// Tentativa de autenticar um usuário antes que ele valide o email
/// </summary>
/// <param name="signinRequest">Dados para autenticação</param>
/// <returns></returns>
public async Task<ErrorListResponse> TryAuthUserWithoutEmailValidatedAsync(
SigninRequest signinRequest)
{
_httpClient.DefaultRequestHeaders.Authorization = null;
HttpResponseMessage response = await _httpClient.PostAsync(
Endpoints.Auth.Signin_v1_0,
signinRequest.ToStringContent()).ConfigureAwait(false);
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
string bodyResponse = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
ErrorListResponse errorListResponse = JsonConvert.DeserializeObject<ErrorListResponse>(
bodyResponse);
errorListResponse.Should().NotBeNull();
errorListResponse.Errors.Should().NotBeNull();
errorListResponse.Errors.Count(w => w.ErrorType == 1 && w.Message == "Usuário ou senha inválidos").Should().Be(1);
return errorListResponse;
}
/// <summary>
/// Sign in the user account.
/// </summary>
/// <param name="userName">
/// Citrus Pay UserName.
/// </param>
/// <param name="password">
/// Citrus Pay Password.
/// </param>
/// <returns>
/// Sign In state, true for success, false for failure
/// </returns>
public static async Task<bool> SigninUser(string userName, string password)
{
if (string.IsNullOrEmpty(Config.SignInId) || string.IsNullOrEmpty(Config.SignInSecret))
{
throw new ServiceException("Invalid Configuration: Client ID & Client Secret");
}
var request = new SigninRequest { User = new User { UserName = userName, Password = password } };
var rest = new RestWrapper();
var result = await rest.Post<OAuthToken>(Service.Signin, AuthTokenType.None, request);
if (!(result is Error))
{
signInToken = result as OAuthToken;
simpleToken = result as OAuthToken;
Utility.SaveToLocalStorage(Utility.SignInTokenKey, signInToken);
Utility.SaveToLocalStorage(Utility.SimpleTokenKey, simpleToken);
return signInToken != null && !string.IsNullOrEmpty(signInToken.AccessToken);
}
Utility.ParseAndThrowError((result as Error).Response);
return false;
}
public SigninResponse Signin(SigninRequest request, dbDataContext db)
{
var md5Password = Md5SecurityHelper.GetMd5Hash(request.Password);
var result = db.sp_Signin(request.Email, md5Password).FirstOrDefault();
if (result == null)
{
throw new HappyHourException(ErrorCode.InvalidUser);
}
if (ConfigHelper.Config.SignupActivationRequired)
{
if (!result.IsEmailVerified)
{
throw new HappyHourException(ErrorCode.EmailNotVerified);
}
}
return(new SigninResponse()
{
UserId = result.Id
});
}
public async Task <IActionResult> Signin([FromBody] SigninRequest request)
{
if (ModelState.IsValid)
{
var issuer = _appSettings.Value.Tokens.Issuer;
var audience = _appSettings.Value.Tokens.Audience;
var key = _configuration["SecretKey:Key"];
var user = await _userManager.FindByEmailAsync(request.Username);
if (user == null)
{
return(StatusCode(403, new ApiResponse {
Status = false, Message = "Authorization Error"
}));
}
var result = await _signInManager.PasswordSignInAsync(request.Username, request.Password, false, true);
if (result.Succeeded)
{
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Email, user.Email),
new Claim(JwtRegisteredClaimNames.Jti, user.Id),
new Claim(JwtRegisteredClaimNames.FamilyName, user.LastName),
new Claim(JwtRegisteredClaimNames.GivenName, user.FirstName)
};
var credential = new SigningCredentials(new SymmetricSecurityKey(Encoding.UTF8.GetBytes(key)),
SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(issuer, audience, claims, expires: DateTime.Now.AddMinutes(60),
signingCredentials: credential);
return(Ok(new ApiResponse
{
Status = true,
Message = "Success",
Result = new
{
username = user.UserName,
name = $"{user.FirstName} {user.LastName}",
token = new JwtSecurityTokenHandler().WriteToken(token)
}
}));
}
if (!result.Succeeded)
{
return(BadRequest(new ApiResponse {
Status = false, Message = "Invalid Username or Password"
}));
}
if (result.IsLockedOut)
{
if (user.UserName == request.Username)
{
var forgotPasswordLink = Url.ActionLink("ForgotPassword", "Auth", new { }, Request.Scheme);
var subject = "Your account has been locked out due to someone trying to access it, click link below to reset password if you are the one.";
await _sendMail.SendMailAsync(_appSettings.Value.FromAddress, request.Username, subject, forgotPasswordLink);
}
}
}
return(BadRequest(new ApiResponse {
Status = false, Message = "Validation Error"
}));
}
public Response Signin(SigninRequest request)
{
var loggedInUser = _repository.Select<User>()
.FirstOrDefault(u => u.Email == request.Email);
if (loggedInUser == null)
{
throw Errors.User_InvalidEmailOrPassword;
}
var passHash = _crypto.ComputeHash(request.Password);
if (passHash != loggedInUser.Password)
{
throw Errors.User_InvalidEmailOrPassword;
}
var login = _repository.Select<Login>()
.FirstOrDefault(l => l.User.Id == loggedInUser.Id);
if (login?.ExpireDate > DateTime.UtcNow)
{
// Extend login
login.ExpireDate = DateTime.UtcNow.AddDays(Constants.LoginTokenValidDays);
_repository.Update(login);
}
else
{
login = CreateLogin(loggedInUser);
}
// Get note list
var notes = GetNoteList(loggedInUser.Id);
// Create Note
if (!string.IsNullOrEmpty(request.UnsavedNoteContent))
{
var newNote = _repository.SaveNote(request.UnsavedNoteContent, loggedInUser);
notes.Insert(0, newNote);
}
return Response.Success.WithData(new
{
Notes = notes,
login.Token
});
}
public SigninResponse Signin(SigninRequest request)
{
return(new SigninResponse());
}
public async Task <SigninResponse> SigninUser(SigninRequest request)
{
return(new SigninResponse());
}
public SigninResponse Signin(SigninRequest request)
{
return new SigninResponse();
}
