public HttpResponseMessage SignIn(SignInRequestModel user)
{
try
{
this.userManager.SignIn(new UserDto
{
Login = user.Login,
Password = user.Password,
RememberMe = user.RememberMe
}, true);
if (!string.IsNullOrEmpty(this.Request.Headers.Referrer.Query) && this.Request.Headers.Referrer.Query.Contains("ReturnUrl"))
{
string query = this.Request.Headers.Referrer.Query;
string returnUrl = query.Replace("%2f", "/");
returnUrl = returnUrl.Substring(returnUrl.IndexOf('/'));
return(Request.CreateResponse(HttpStatusCode.OK, returnUrl));
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (ArgumentException ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, ex.Message));
}
}
public async Task <SignInResponseModel> SignInAsync(SignInRequestModel requestModel)
{
SignInResponseModel responseModel = new SignInResponseModel();
responseModel.SignInResult = await _signInManager.PasswordSignInAsync(requestModel.Email, requestModel.Password, false, false);
if (!responseModel.SignInResult.Succeeded)
{
return(responseModel);
}
ApplicationUser user = await _userManager.FindByEmailAsync(requestModel.Email);
if (user.IsRemoved)
{
responseModel.IsRemoved = user.IsRemoved;
return(responseModel);
}
string userRole = (await _userManager.GetRolesAsync(user)).FirstOrDefault();
responseModel.Id = user.Id;
responseModel.FirstName = user.FirstName;
responseModel.Token = _jwtHelper.GenerateAccessToken(user, userRole);
return(responseModel);
}
public IActionResult SignIn(SignInRequestModel signInRequest)
{
if (signInRequest == null ||
string.IsNullOrWhiteSpace(signInRequest.Login) ||
string.IsNullOrWhiteSpace(signInRequest.Password))
{
return(Ok(ToJson(ApiResponse.NewFail("InvalidCredentials"))));
}
var mbUser = _userService.UserLoginRequest(login: signInRequest.Login, pass: signInRequest.Password);
if (!mbUser.Success)
{
return(Ok(ToJson(ApiResponse.NewFail("InvalidCredentials"))));
}
var userContainer = new UserContainer(mbUser.Value);
_sessionOperator.CurrentUser_Set(HttpContext, userContainer);
var signinResponseModel = GetSigninResponseModel(mbUser.Value);
var result = ApiResponse <SignInResponseModel> .NewSuccess(signinResponseModel);
return(Ok(ToJson(result)));
}
public async Task <IActionResult> SignIn([FromBody] SignInRequestModel requestModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
SignInResponseModel responseModel = await _accountService.SignInAsync(requestModel);
if (responseModel.IsRemoved)
{
ModelState.AddModelError(string.Empty, "That user has been banned");
return(BadRequest(ModelState));
}
if (responseModel.SignInResult.Succeeded)
{
responseModel.SignInResult = null;
return(Ok(responseModel));
}
ModelState.AddModelError(string.Empty, "Wrong login or/and password");
return(BadRequest(ModelState));
}
public async Task <IActionResult> SignIn([FromBody] SignInRequestModel model)
{
User user = await this.userManager.FindByLoginAsync(model.Login);
if (user != null)
{
if (user.Roles.Any(r => r != "admin"))
{
this.responseStatus = new ResponseStatusModel {
Success = false, Message = "This user is not an administrator", Code = 400
};
return(BadRequest(new { ResponseStatus = this.responseStatus }));
}
string token = JWTHelper.GetToken(user);
this.responseStatus = new ResponseStatusModel {
Success = true
};
return(Ok(new { ResponseStatus = this.responseStatus, Token = token }));
}
else
{
this.responseStatus = new ResponseStatusModel {
Success = false, Message = "Invalid login or password", Code = 400
};
return(BadRequest(new { ResponseStatus = this.responseStatus }));
}
}
public async Task <IActionResult> SignIn([FromBody] SignInRequestModel model)
{
var result = await this.signInManager.PasswordSignInAsync(model.Login, model.Password, false, false);
if (result.Succeeded)
{
User user = await this.userManager.FindByNameAsync(model.Login);
UserDto userDto = new UserDto
{
ID = user.Id,
Name = user.UserName,
Email = user.Email,
Country = user.Country,
Phone = user.PhoneNumber,
Year = user.Year
};
HttpContext.Session.Remove("guestID");
HttpContext.Session.Set <UserDto>("current-user", userDto);
this.responseStatus = new ResponseStatusModel {
Success = result.Succeeded
};
return(Ok(new { ResponseStatus = this.responseStatus }));
}
else
{
this.responseStatus = new ResponseStatusModel {
Success = result.Succeeded, Message = "Invalid login or password", Code = 400
};
return(BadRequest(new { ResponseStatus = this.responseStatus }));
}
}
/// <summary>
/// Sign-in and get member information
/// </summary>
/// <param name="param">SignIn Request Model</param>
/// <remarks></remarks>
public ProfileResultModel SignIn(SignInRequestModel param)
{
ProfileResultModel result = new ProfileResultModel();
if (!this.ModelState.IsValid)
{
result.Status = false;
result.Message = this.ModelState.Values.Single(v => v.Errors.Count > 0).Errors.FirstOrDefault().ErrorMessage;
return(result);
}
try
{
MemberBL bl = new MemberBL();
var member = bl.SignIn(param);
if (member == null)
{
result.Status = false;
result.Message = "Invalid user name";
}
else
{
var token = IdentityHelper.GenerateToken(member);
bl.RegisterToken(token);
result.Status = true;
result.Message = "Sign-in successfully";
result.Member = member;
result.Member.AccessToken = token.Token;
}
}
catch (OrgException oex)
{
result.Status = false;
result.Message = oex.Message;
}
catch (Exception ex)
{
result.Status = false;
result.Message = AppConfigs.InternalErrorMessage;
if (AppConfigs.DebugInternalMessage)
{
result.InternalMessage = ex.Message;
}
}
return(result);
}
public async Task <IActionResult> SignIn([FromBody] SignInRequestModel model)
{
if (ModelState.IsValid)
{
User user = await userService.GetByEmailAsync(model.Email);
if (user != null)
{
bool isCorrectPassword = PasswordHasher.VerifyHashedPassword(user.Password, model.Password);
if (isCorrectPassword)
{
DateTime now = DateTime.UtcNow;
List <Claim> claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, model.Email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Iat, now.Second.ToString(), ClaimValueTypes.Integer64),
new Claim("UserId", user.UserId.ToString()),
new Claim("ExpireDate", now.Add(TimeSpan.FromDays(1)).ToString(CultureInfo.InvariantCulture)),
new Claim("Email", model.Email),
new Claim("Role", user.Role.ToString())
};
JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler();
byte[] key = Encoding.ASCII.GetBytes("mysupersecret_secretkey!WB");
SecurityTokenDescriptor tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.UtcNow.AddDays(1),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
SecurityToken SecurityToken = tokenHandler.CreateToken(tokenDescriptor);
string token = tokenHandler.WriteToken(SecurityToken);
return(ApiResult(new SignInResponseModel {
Token = token
}));
}
return(Error("Error", "Incorrect password!"));
}
return(Error("Error", "Incorrect Email!"));
}
return(Error(ModelState));
}
public MemberModel SignIn(SignInRequestModel model)
{
OrgComm.Data.Models.Member member = null;
using (OrgCommEntities dbc = new OrgCommEntities(DBConfigs.OrgCommConnectionString))
{
member = dbc.Members.FirstOrDefault(r => (!r.DelFlag) && (r.Email.Equals(model.Email)));
if ((member == null) || !member.PasswordHash.Equals(GenerateHash(member.Salt, model.Password)))
{
return(null);
}
if (!model.DeviceOSId.HasValue || String.IsNullOrWhiteSpace(model.DeviceToken))
{
throw new OrgException("Invalid device token");
}
this.RegisterDevice(member.Id, new DeviceTokenRequestModel
{
OSId = model.DeviceOSId.Value,
Token = model.DeviceToken
});
}
return(new MemberModel
{
Id = member.Id,
FacebookId = member.FacebookId,
Email = member.Email,
FirstName = member.FirstName,
LastName = member.LastName,
NickName = member.Nickname,
DisplayName = member.DisplayName,
Gender = member.Gender,
Company = member.Company.Name,
Department = member.Department.Name,
Position = member.Position.Name,
EmployeeId = member.EmployeeId,
Phone = member.Phone,
Photo = (member.Photo == null) ? null : MemberBL.PhotoUrlFormatString.Replace("{0}", member.Id.ToString())
});
}
public async Task <IActionResult> SignIn([FromBody] SignInRequestModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var result = await _authService.SignIn(model.UserName, model.Password);
return(result.Result
? Ok(new SignInResultModel
{
Result = result.Result,
Token = result.Token,
Errors = result.Errors
})
: BadRequest(new SignInResultModel
{
Result = result.Result,
Token = result.Token,
Errors = result.Errors
}));
}
public async Task <IActionResult> SignIn([FromBody] SignInRequestModel request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await userService.SignIn(request.Username, request.Password);
if (user == null)
{
return(BadRequest("Unable to find user. Please check your username and password."));
}
if (!user.IsActive)
{
return(BadRequest("Your account is inactive. Please contact an administrator to re-activate your account."));
}
var jwt = userService.GenerateJwtForUser(user);
return(Ok(new { token = jwt }));
}
public SignInCommand(SignInRequestModel requestModel)
{
UserName = requestModel.UserName.ToUpper();
Password = requestModel.Password;
IsPersistent = requestModel.IsPersistent.Value;
}
public async Task <IActionResult> SignInAsync([FromBody] SignInRequestModel model)
{
var token = await _authService.SignInAsync(model.Login, model.Password);
return(JsonResult(token));
}
public async Task <ActionResult> SignIn(SignInRequestModel requestModel)
{
await _mediator.Send(new SignInCommand(requestModel));
return(Ok());
}
