private async void mButtonLoginClick(object sender, EventArgs args)
{
//grab user info
var email = FindViewById<EditText>(Resource.Id.txtLoginEmail).Text;
var password = FindViewById<EditText>(Resource.Id.txtPassword).Text;
// build model
var model = new LoginBindingModel
{
Email = email,
Password = password
};
try
{
// authenticate
await RentProof.API.Service.Login(model);
// proceed to main menu
}
catch (Exception)
{
throw;
}
var intent = new Intent(this, typeof (MainMenuController));
StartActivity(intent);
Finish();
}
public async Task<IHttpActionResult> Login(LoginBindingModel model)
{
if (!ModelState.IsValid)
{
return this.BadRequest(this.ModelState);
}
var user = UserManager.FindAsync(model.UserName, model.Password);
if (user == null)
{
return this.BadRequest("Wrong username or password!");
}
// Invoke the "token" OWIN service to perform the login (POST /api/token)
var testServer = TestServer.Create<Startup>();
var requestParams = new List<KeyValuePair<string, string>>
{
new KeyValuePair<string, string>("grant_type", "password"),
new KeyValuePair<string, string>("username", model.UserName),
new KeyValuePair<string, string>("password", model.Password)
};
var requestParamsFormUrlEncoded = new FormUrlEncodedContent(requestParams);
var tokenServiceResponse = await testServer.HttpClient
.PostAsync(Common.Constants.TokenEndpointPath, requestParamsFormUrlEncoded);
return this.ResponseMessage(tokenServiceResponse);
}
public HttpResponseMessage Login(LoginBindingModel login)
{
if (login.Username == "admin" && login.Password == "password") //Do real auth
{
string role = "Librarian";
var jwtToken = TokenManager.CreateJwtToken(login.Username, role);
return new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ObjectContent<object>(new
{
UserName = login.Username,
Roles = role,
AccessToken = jwtToken
}, Configuration.Formatters.JsonFormatter)
};
}
return new HttpResponseMessage(HttpStatusCode.BadRequest);
}
public async Task<ActionResult> Login(LoginBindingModel model, string returnUrl)
{
if (!this.ModelState.IsValid)
{
return this.View(model);
}
var result = await this.SignInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, true);
switch (result)
{
case SignInStatus.Success:
return this.RedirectToLocal(returnUrl);
case SignInStatus.LockedOut:
return this.View("Lockout");
default:
this.ModelState.AddModelError(string.Empty, "Invalid login attempt.");
return this.View(model);
}
}
public async Task<HttpResponseMessage> LoginUser(LoginBindingModel loginData)
{
if (loginData == null)
{
loginData = new LoginBindingModel();
}
var request = HttpContext.Current.Request;
var tokenServiceUrl = request.Url.GetLeftPart(UriPartial.Authority) +
request.ApplicationPath + Startup.TokenEndpointPath;
using (var client = new HttpClient())
{
var requestParams = new List<KeyValuePair<string, string>>
{
new KeyValuePair<string, string>("grant_type", "password"),
new KeyValuePair<string, string>("username", loginData.Username),
new KeyValuePair<string, string>("password", loginData.Password)
};
var requestParamsFormUrlEncoded = new FormUrlEncodedContent(requestParams);
var tokenServiceResponse = await client.PostAsync(tokenServiceUrl, requestParamsFormUrlEncoded);
var responseString = await tokenServiceResponse.Content.ReadAsStringAsync();
var responseCode = tokenServiceResponse.StatusCode;
if (responseCode == HttpStatusCode.OK)
{
var jsSerializer = new JavaScriptSerializer();
var responseData =
jsSerializer.Deserialize<Dictionary<string, string>>(responseString);
var accessToken = responseData["access_token"];
var username = responseData["userName"];
this.userSessionManager.CreateUserSession(username, accessToken);
this.userSessionManager.RemoveExpiredSessions();
}
var responseMessage = new HttpResponseMessage(responseCode)
{
Content = new StringContent(responseString, Encoding.UTF8, "application/json")
};
return responseMessage;
}
}
private User VerifyUser(LoginBindingModel loginModel)
{
return(this.Data.User.Query()
.FirstOrDefault(u => u.Email == loginModel.Email && u.Password == loginModel.Password));
}
public async Task <IHttpActionResult> LogIn(LoginBindingModel model)
{
try
{
_logger.Debug("ini LogIn - process");
if (ModelState.IsValid)
{
User user = await _appUserManager.FindByEmailAsync(model.Email);
if (user != null)
{
if (user.Disabled)
{
ModelState.AddModelError("", "Your account is disabled, please contact with the web master");
return(BadRequest(ModelState));
}
var validCredentials = await _appUserManager.FindAsync(user.UserName, model.Password);
// When a user is lockedout, this check is done to ensure that even if the credentials are valid
// the user can not login until the lockout duration has passed
if (await _appUserManager.IsLockedOutAsync(user.Id))
{
ModelState.AddModelError("", string.Format(
"Your account has been locked out for {0} minutes due to multiple failed login attempts.",
ConfigurationManager.AppSettings["DefaultAccountLockoutTimeSpan"]));
}
// if user is subject to lockouts and the credentials are invalid
// record the failure and check if user is lockedout and display message, otherwise,
// display the number of attempts remaining before lockout
else if (await _appUserManager.GetLockoutEnabledAsync(user.Id) && validCredentials == null)
{
// Record the failure which also may cause the user to be locked out
await _appUserManager.AccessFailedAsync(user.Id);
string message;
if (await _appUserManager.IsLockedOutAsync(user.Id))
{
message =
string.Format(
"Your account has been locked out for {0} minutes due to multiple failed login attempts.",
ConfigurationManager.AppSettings["DefaultAccountLockoutTimeSpan"]);
}
else
{
int accessFailedCount = await _appUserManager.GetAccessFailedCountAsync(user.Id);
int attemptsLeft =
Convert.ToInt32(
ConfigurationManager.AppSettings["MaxFailedAccessAttemptsBeforeLockout"]) -
accessFailedCount;
message =
string.Format(
"Invalid credentials. You have {0} more attempt(s) before your account gets locked out..",
attemptsLeft);
}
ModelState.AddModelError("", message);
}
else if (validCredentials == null)
{
ModelState.AddModelError("", "Invalid credentials. Please try again.");
}
else
{
await _appUserManager.ResetAccessFailedCountAsync(user.Id);
var signInStatus = await _appSignInManager.PasswordSignInAsync(user.UserName, model.Password, model.RememberMe, false);
switch (signInStatus)
{
case SignInStatus.Success:
{
_logger.Debug("LogIn - Success");
_logger.Debug(string.Format("user LogIn info email:{0}, idUser:{1}", user.Email, user.Id));
return(Ok(ModelFactory.Create(user)));
}
case SignInStatus.Failure:
{
_logger.Debug("LogIn - Invalid password");
ModelState.AddModelError("", "Invalid credentials. Please try again");
break;
}
}
}
}
else
{
_logger.Debug("LogIn - invalid email.");
ModelState.AddModelError("", "Invalid credentials. Please try again");
}
}
_logger.Debug("LogIn - BadRequest.");
return(BadRequest(ModelState));
}
catch (Exception ex)
{
LogError(ex);
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> Login(LoginBindingModel LoginModel)
{
var ctx = ApplicationDbContext.Create();
if (string.IsNullOrWhiteSpace(LoginModel.username) || string.IsNullOrWhiteSpace(LoginModel.password))
{
return(NotFound());
}
var user = await AppUserManager.FindByNameAsync(LoginModel.username);
if (user == null)
{
return(NotFound());
}
var passwordSignInResult = await AppUserManager.CheckPasswordAsync(user, LoginModel.password);
if (!passwordSignInResult)
{
ctx.Login_Logs.Add(new Login_Logs()
{
Ip_Address = Request.GetOwinContext().Request.RemoteIpAddress,
Status = "The password is incorrect.",
Time = DateTime.Now,
UserId = user.Id,
});
await ctx.SaveChangesAsync();
return(NotFound());
}
//Get Token from ~//oauth/token
HttpClient client = new HttpClient();
client.BaseAddress = new Uri(Startup.address);
client.DefaultRequestHeaders
.Accept
.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/json; charset=utf-8");
var json = new JavaScriptSerializer().Serialize(LoginModel);
HttpResponseMessage response = await client.PostAsJsonAsync("/oauth/token", json);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
ctx.Login_Logs.Add(new Login_Logs()
{
Ip_Address = Request.GetOwinContext().Request.RemoteIpAddress,
Status = "Login Successful.",
Time = DateTime.Now,
UserId = user.Id,
});
await ctx.SaveChangesAsync();
return(Ok(response.Content));
}
else
{
return(BadRequest(response.ReasonPhrase));
}
}
public async Task<IHttpActionResult> Login(LoginBindingModel model)
{
if (this.User.Identity.GetUserId() != null)
{
return this.BadRequest("User is already logged in.");
}
if (model == null)
{
return this.BadRequest("Invalid user data.");
}
var testServer = TestServer.Create<Startup>();
var requestParams = new List<KeyValuePair<string, string>>
{
new KeyValuePair<string, string>("grant_type", "password"),
new KeyValuePair<string, string>("username", model.Username),
new KeyValuePair<string, string>("password", model.Password)
};
var requestParamsFormUrlEncoded = new FormUrlEncodedContent(requestParams);
var tokenServiceResponse = await testServer.HttpClient.PostAsync(
"/api/token", requestParamsFormUrlEncoded);
if (tokenServiceResponse.StatusCode == HttpStatusCode.OK)
{
// Sucessful login --> create user session in the database
var responseString = await tokenServiceResponse.Content.ReadAsStringAsync();
var jsSerializer = new JavaScriptSerializer();
var responseData =
jsSerializer.Deserialize<Dictionary<string, string>>(responseString);
var authToken = responseData["access_token"];
var username = responseData["userName"];
var owinContext = this.Request.GetOwinContext();
var userSessionManager = new UserSessionManager(owinContext);
userSessionManager.CreateUserSession(username, authToken);
// Cleanup: delete expired sessions from the database
userSessionManager.DeleteExpiredSessions();
}
return this.ResponseMessage(tokenServiceResponse);
}
internal bool IsLoginModelValid(LoginBindingModel lbm)
{
return(this.Context.Users.Any(u => u.Email == lbm.Email && u.Password == lbm.Password));
}
public async Task <JsonWebToken> Login(LoginBindingModel userModel)
{
var user = await LoginUser(userModel);
return(_tokenService.CreateAccessToken(user.UserName, Guid.Parse(user.Id)));
}
public User GetUserFromLoginBind(LoginBindingModel model)
{
return(this.Context.Users.FirstOrDefault(u => u.Username == model.Username &&
u.Password == model.Password));
}
public async Task <ActionResult <LoginDto> > Login([FromBody] LoginBindingModel loginBm)
{
var response = await Mediator.Send(Mapper.Map <LoginQuery>(loginBm));
return(Ok(response));
}
public async Task <bool> SignIn(LoginBindingModel model)
{
var result = await this._signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure : true);
return(result.Succeeded);
}
