public async Task <string> LoginAsync(vmLogin para)
{
var cookieJar = new CookieContainer();
var handler = new HttpClientHandler
{
CookieContainer = cookieJar,
UseCookies = true,
UseDefaultCredentials = false
};
var client = CreateHttpClient(handler);
var formData = new FormUrlEncodedContent(new[] {
new KeyValuePair <string, string>("logonUsername", para.UserName),
new KeyValuePair <string, string>("password", para.Password.Md5Encrypt()),
new KeyValuePair <string, string>("rememberType", "10080"),
new KeyValuePair <string, string>("loginType", "user"),
new KeyValuePair <string, string>("verificationCode", "请输入验证码"),
new KeyValuePair <string, string>("timeStamp", TimeExtension.GetTimeStamp().ToString()),
});
var Uri = CreateUri("/auth/loginSubmit");
var response = await client.PostAsync(Uri, formData);
response.EnsureSuccessStatusCode();
var responseCookies = cookieJar.GetCookies(Uri);
var ret = string.Empty;
foreach (Cookie cookie in responseCookies)
{
ret += $"{cookie.Name}={cookie.Value};";
}
return(ret);
}
private ActionResult index(vmLogin model, string strReturnURL)
{
this.setReturnURL(strReturnURL);
this.setViewBagController();
return(this.View(model));
}
public ActionResult Login(vmLogin vmLogin)
{
if (ModelState.IsValid)
{
Users users = context.Users.FirstOrDefault(u => u.Username == vmLogin.Username);
if (users != null)
{
if (users.Password == vmLogin.Password)
{
Session["Loginner"] = true;
Session["LoginnerId"] = users.Id;
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("Password", "Incorrect Password");
}
}
else
{
ModelState.AddModelError("Username", "Incorrect Username");
}
}
return(View(vmLogin));
}
public ActionResult Login(vmLogin login)
{
if (ModelState.IsValid)
{
Admin admin = context.Admins.FirstOrDefault(a => a.Email == login.Email);
if (admin != null)
{
if (Crypto.VerifyHashedPassword(admin.Password, login.Password) == true)
{
Session["Loginner"] = admin;
Session["LoginnerId"] = admin.Id;
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("Password", "Incorrect Password");
}
}
else
{
ModelState.AddModelError("Email", "Incorrect Email");
}
}
return(View());
}
//[ValidateAntiForgeryToken]
public ActionResult LoginWithModalPopup([FromBody] vmLogin model)
{
try
{
if (ModelState.IsValid)
{
var admin = UserHelper.Login(model.Email, model.Password);
if (admin == null || (string.IsNullOrEmpty(admin.Email) && admin.Id <= 0))
{
ModelState.AddModelError("", "Invalid email or password. Please try again!");
return(Json(
new { success = false, message = "Something went wrong, please try again soon." }
));
}
HttpContext.Session.SetString("UserID", admin.Id.ToString());
HttpContext.Session.SetString("Name", admin.Name.Trim());
HttpContext.Session.SetString("Email", admin.Email.Trim());
return(Json(new { success = true, message = "Login successful." }));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
return(Json(
"Something went wrong, please try again soon."
));
}
public ActionResult Login(vmLogin model, string returnUrl)
{
try
{
if (ModelState.IsValid)
{
var admin = UserHelper.Login(model.Email, model.Password);
if (admin == null || (string.IsNullOrEmpty(admin.Email) && admin.Id <= 0))
{
ModelState.AddModelError("", "Invalid email or password. Please try again!");
return(View(model));
}
HttpContext.Session.SetString("UserID", admin.Id.ToString());
HttpContext.Session.SetString("Name", admin.Name.Trim());
HttpContext.Session.SetString("Email", admin.Email.Trim());
if (!string.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("Index", "FeedProvider"));
}
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
return(View(model));
}
public ActionResult Login(vmLogin model, string returnUrl)
{
returnUrl = Assess.setString(returnUrl);
if (this.setSession(model))
{
return(this.setRedirectAction(returnUrl));
}
return(this.index(model, returnUrl));
}
public ActionResult Login(vmLogin vmLogin)
{
if (String.IsNullOrEmpty(Request.Form.Get("SignIn")))
{
return(View());
}
else
{
return(View(vmLogin));
}
}
public async Task <IActionResult> Login([FromBody] vmLogin para)
{
try
{
var token = await _repoProxy.LoginAsync(para);
return(Ok(token));
}
catch (Exception ex)
{
return(ExceptionDefault(ex));
}
}
private bool setSession(vmLogin model)
{
try
{
this.isModelValid();
model = model.getData();
dynamic data = null;
var sc = new StringContent(JsonConvert.SerializeObject(new { username = model.username, password = model.password }), Encoding.UTF8, "application/json");
using (HttpClient hc = new HttpClient())
{
hc.BaseAddress = new Uri(Config.getValue("webapi"));
HttpResponseMessage hrm = hc.PostAsync("api/login", sc).Result;
if (hrm.IsSuccessStatusCode)
{
data = JObject.Parse(hrm.Content.ReadAsStringAsync().Result);
}
else
{
throw new Exception("Error Code: " + hrm.StatusCode + "|Message: " + hrm.ReasonPhrase);
}
}
ApplicationUser appUser = new ApplicationUser()
{
Id = Assess.setString((string)data.user.id).ToLower(),
UserName = Assess.setString((string)data.user.name),
Token = Assess.setString((string)data.token),
};
ApplicationSignInManager signInManager = this.HttpContext.GetOwinContext().Get <ApplicationSignInManager>();
signInManager.SignIn(appUser, isPersistent: model.rememberme, rememberBrowser: false);
return(true);
}
catch (Exception ex)
{
this.addModelError(ex);
}
return(false);
}
public ActionResult Login(vmLogin login)
{
#region Card
HttpCookie cookie = Request.Cookies["Card"];
if (cookie != null)
{
List <string> Card = cookie.Value.Split(',').ToList();
Card.RemoveAt(Card.Count - 1);
ViewBag.Card = Card;
ViewBag.CardCount = Card.Count;
}
else
{
ViewBag.CardCount = 0;
}
#endregion
ViewBag.setting = context.Settings.FirstOrDefault();
if (ModelState.IsValid)
{
User user = context.Users.FirstOrDefault(u => u.Email == login.Email);
if (user != null)
{
if (Crypto.VerifyHashedPassword(user.Password, login.Password) == true)
{
Session["LoginnerUser"] = user;
Session["LoginnerUserName"] = user.Name + " " + user.Surname;
Session["LoginnerUserId"] = user.Id;
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("Password", "Incorrect Password");
}
}
else
{
ModelState.AddModelError("Username", "Incorrect Username");
}
}
return(View());
}
public ActionResult Login(vmLogin model, string returnUrl)
{
if (ModelState.IsValid)
{
if (authProvider.Authenticate(model.UserName, model.Password))
{
return(Redirect(returnUrl ?? Url.Action("Index", "Admin")));
}
else
{
ModelState.AddModelError("", "Incorrect username or password");
return(View());
}
}
else
{
return(View());
}
}
public async Task <IActionResult> Login([FromBody] vmLogin para)
{
using (var db = DbContextFactory.CreateSxhContext())
{
var targetUser = await db.User.FirstOrDefaultAsync(u => u.Id == para.UserName);
if (targetUser != null)
{
if (targetUser.Expired.HasValue)
{
if (DateTime.UtcNow > targetUser.Expired.Value.ToUniversalTime())
{
return(StatusCode((int)HttpStatusCode.Forbidden, "user expired"));
}
}
var pswEncrpyt = TypeParser.GetStringValue(para.Password).Md5Encrypt();
if (string.IsNullOrEmpty(targetUser.Psw) || targetUser.Psw == pswEncrpyt)
{
if (string.IsNullOrEmpty(targetUser.Psw))
{
//first time login
targetUser.Psw = pswEncrpyt;
db.User.Update(targetUser);
await db.SaveChangesAsync();
}
var mgr = new JwtManager(AppSetting.Instance.SecretKey);
var token = mgr.TokenCreate(para.UserName, para.UserName, AppSetting.Instance.TokenExpiredHour);
return(Ok(token));
}
else
{
return(StatusCode((int)HttpStatusCode.Forbidden, "invalid user name or password"));
}
}
}
return(Unauthorized());
}
public ActionResult Login(vmLogin model, string returnUrl)
{
try
{
if (ModelState.IsValid)
{
UserType userType;
var User = _Trainer.Login(model.Email, model.Password, out userType);
if (User != null)
{
CreateSession(userType, User);
FormsAuthentication.SetAuthCookie(
User.Email, false);
FormsAuthenticationTicket ticket1 =
new FormsAuthenticationTicket(
1,
User.Email,
DateTime.Now,
DateTime.Now.AddMinutes(20),
false, User.Email);
HttpCookie cookie1 = new HttpCookie(
FormsAuthentication.FormsCookieName,
FormsAuthentication.Encrypt(ticket1));
Response.Cookies.Add(cookie1);
FormsAuthentication.RedirectFromLoginPage(User.Email, true);
return(RedirectToAction("Index", "Home"));
}
}
ViewData["Error"] = "Invalid Email or Password.";
}
catch (Exception ex)
{
ViewData["Error"] = ex.Message;
}
return(View(model));
}
public void Can_Login_With_Valid_Credentials()
{
// Arrange - create a mock authentication provider
Mock <IAuthProvider> mock = new Mock <IAuthProvider>();
mock.Setup(m => m.Authenticate(" admin", "secret")).Returns(true);
// Arrange - create the view model
vmLogin model = new vmLogin
{
UserName = "******",
Password = "******"
};
// Arrange = create the controller
AccountController target = new AccountController(mock.Object);
// Act = authenticate using valid credentials
ActionResult result = target.Login(model, "/MyURL");
// Assert
Assert.IsInstanceOfType(result, typeof(RedirectResult));
Assert.AreEqual("/MyUrl", ((RedirectResult)result).Url);
}
public void Cannot_Login_With_Invalid_Credentials()
{
// Arrange - create a mock authentication provider
Mock <IAuthProvider> mock = new Mock <IAuthProvider>();
mock.Setup(m => m.Authenticate("badUser", "badPass")).Returns(false);
// Arrange - create the view model
vmLogin model = new vmLogin
{
UserName = "******",
Password = "******"
};
// Arrange - create the controller
AccountController target = new AccountController(mock.Object);
// Act - authenticate using valid credentials
ActionResult result = target.Login(model, "/MyURL");
// Assert
Assert.IsInstanceOfType(result, typeof(ViewResult));
Assert.IsFalse(((ViewResult)result).ViewData.ModelState.IsValid);
}
public IActionResult LoadLoginHistory()
{
var draw = Request.Form["draw"].FirstOrDefault();
var start = Request.Form["start"].FirstOrDefault();
var length = Request.Form["length"].FirstOrDefault();
var sortColumn = Request.Form["columns[" + Request.Form["order[0][column]"].FirstOrDefault() + "][name]"].FirstOrDefault();
var sortColumnDir = Request.Form["order[0][dir]"].FirstOrDefault();
var searchValue = Request.Form["search[value]"].FirstOrDefault();
int pageSize = length != null?Convert.ToInt32(length) : 0;
int skip = start != null?Convert.ToInt32(start) : 0;
int recordsTotal = 0;
// var loggedInEmployeeId = User.GetCurrentEmployeeId(db.Employee);
List <LoginHistory> loginHistoryList = db.LoginHistory.GetAll().Where(Model => Model.IsActive == true && Model.IsDeleted == false).ToList();
List <vmLogin> loginHistoryItem = new List <vmLogin>();
foreach (var item in loginHistoryList)
{
var history = new vmLogin
{
Id = item.Id,
UserId = item.UserId,
ChangeLoginTime = item.LoginTime.ToString("hh:mm:ss tt"),
Details = item.Details,
};
var employee = db.Employee.GetFirstOrDefault(x => x.UserId == history.UserId);
if (employee != null)
{
//history.UserId = employee.UserId;
history.UserName = employee.FullName;
}
loginHistoryItem.Add(history);
}
if (!string.IsNullOrEmpty(sortColumn) && !string.IsNullOrEmpty(sortColumnDir))
{
}
else
{
loginHistoryItem = loginHistoryItem.OrderByDescending(model => model.Id).ToList();
}
//Search
if (!string.IsNullOrEmpty(searchValue))
{
loginHistoryItem = loginHistoryItem.Where(model => model.LoginTime.ToShortDateString().Contains(searchValue) || model.UserId.Contains(searchValue)).ToList();
}
//total number of rows count
recordsTotal = loginHistoryItem.Count();
//Paging
var data = loginHistoryItem.Skip(skip).Take(pageSize).ToList();
//Returning Json Data
return(Json(new { draw = draw, recordsFiltered = recordsTotal, recordsTotal = recordsTotal, data = data }));
}
public ActionResult LoginWithModalPopup()
{
var vmLogin = new vmLogin();
return(PartialView("LoginPopup", vmLogin));
}
