public async Task <IActionResult> Login(UserSignInViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByNameAsync(model.UserName);
if (user != null)
{
var ıdentıtyResult = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, true);
if (ıdentıtyResult.Succeeded)
{
var role = await _userManager.GetRolesAsync(user);
if (role.Contains("Admin"))
{
return(RedirectToAction("Index", "Home", new { area = "Admin" }));
}
else
{
return(RedirectToAction("Index", "Home", new { area = "Member" }));
}
}
}
ModelState.AddModelError("", "Kullanıcı adı veya şifre hatalı");
}
return(View(model));
}
public async Task <ActionResult> Register(UserSignInViewModel userSignInViewModel)
{
if (!ModelState.IsValid)
{
return(View(userSignInViewModel));
}
var userExistsInDatabase = await _db.User.FirstOrDefaultAsync(m => m.Email == userSignInViewModel.Email);
if (userExistsInDatabase != null)
{
TempData["StatusMessage"] = "Error - User already exists, use another email.";
return(View(userSignInViewModel));
}
User user = new User()
{
FirstName = userSignInViewModel.FirstName,
LastName = userSignInViewModel.LastName,
Gender = userSignInViewModel.Gender.ToString(),
Email = userSignInViewModel.Email,
Password = userSignInViewModel.Password,
Role = "Admin"
};
_db.User.Add(user);
await _db.SaveChangesAsync();
return(RedirectToAction("Index", "Survey", new { area = "Respondent" }));
/*return View(userSignInViewModel);*/
}
public IActionResult Auth([FromBody] UserSignInViewModel userSignInViewModel)
{
Models.Response.ResponseModel response = ResponseModelFactory.CreateInstance;
DncUser user;
user = _dbContext.DncUser.FirstOrDefault(x => x.LoginName == userSignInViewModel.UserName.Trim());
string[] passwordSplit = user.Password.Split("$");
if (user == null)
{
response.SetFailed("用户不存在");
return(Ok(response));
}
if (passwordSplit[1] != PasswordCalculator.SaltPassword(passwordSplit[0], userSignInViewModel.PasswordMD5))
{
response.SetFailed("密码不正确");
return(Ok(response));
}
try
{
response.SetData(TokenBulider(user));
return(Ok(response));
}
catch (InvalidOperationException ex)
{
response.SetFailed(ex.Message);
return(Ok(response));
}
}
public HttpResponseMessage Post([FromBody] UserSignInViewModel model)
{
TdIdentityContext context = new TdIdentityContext();
var userStore = new UserStore <TicketDeskUser>(context);
var roleStore = new RoleStore <TicketDeskRole>(context);
var userManager = new TicketDeskUserManager(userStore);
var roleManager = new TicketDeskRoleManager(roleStore);
IOwinContext context1 = HttpContext.Current.GetOwinContext();
//UserSignInViewModel model = new UserSignInViewModel();
//model.UserNameOrEmail = "*****@*****.**";
//model.Password = "******";
//model.RememberMe = false;
HttpResponseMessage result;
TicketDeskSignInManager signinmanager = new TicketDeskSignInManager(userManager, context1.Authentication);
TdDomainContext domain = new TdDomainContext(null);
UserController controller = new UserController(userManager, signinmanager, domain);
controller.SignInApi(model, "");
//var response = Request.CreateResponse(HttpStatusCode.Moved);
//response.Headers.Location = new Uri("https://localhost:44373/ticket/new") ;
//return response;
result = Request.CreateResponse(HttpStatusCode.OK, "https://localhost:44373/ticket/new");
return(result);
//var employee = "Megha";
//if (employee == null)
//{
// return NotFound();
//}
//return Ok(employee);
}
public async Task <IActionResult> SignIn(UserSignInViewModel model)
{
if (ModelState.IsValid)
{
var result = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, true);
if (result.IsLockedOut)
{
ModelState.AddModelError("", "Çok fazla başarısız giriş denemesi yaptığınız için hesabınız geçici süreyle kilitlenmiştir");
return(View("Index", model));
}
if (result.IsNotAllowed)
{
ModelState.AddModelError("", "Giriş yapabilmeniz için, email adresinizi doğrulamanız gerekmektedir.");
return(View("Index", model));
}
if (result.Succeeded)
{
return(RedirectToAction("Index", "Panel"));
}
var yanlisGirilme = await _userManager.GetAccessFailedCountAsync(await _userManager.FindByNameAsync(model.UserName));
ModelState.AddModelError("", $"Kullanıcı adı veya şifre hatalı {5 - yanlisGirilme} giriş denemesi hakkınız kaldı");
}
return(View("Index", model));
}
public async Task <ActionResult> Register(UserSignInViewModel userSignInViewModel)
{
if (!ModelState.IsValid)
{
return(View(userSignInViewModel));
}
//var user = new User()
//{
// Email = userSignInViewModel.Email,
// Gender = userSignInViewModel.Gender,
// FirstName = userSignInViewModel.FirstName,
// LastName = userSignInViewModel.LastName,
// Role = "Respondent",
// Password = userSignInViewModel.Password,
//};
_db.User.Add(userSignInViewModel.User);
await _db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> GirisYap(UserSignInViewModel model)
{
if (ModelState.IsValid)
{
var identityResult = await _singInManager.PasswordSignInAsync(model.Username, model.Password, model.RememberMe, true);
var accessFailedCount = await _singInManager.UserManager.FindByNameAsync(model.Username);
int kalanGirisHakki = 3 - accessFailedCount.AccessFailedCount;
if (identityResult.Succeeded)
{
return(RedirectToAction("Index", "Panel"));
}
if (identityResult.IsLockedOut)
{
var kilitlenmeTarihi = await _singInManager.UserManager.FindByNameAsync(model.Username);
int kalanZaman = (int)(kilitlenmeTarihi.LockoutEnd - DateTime.Now).Value.TotalMinutes;
ModelState.AddModelError("", $"Şifreyi 3 Defa Yanlış Girmeniz Nedeniyle Hesabınız 10 Dakika Süre İle Kilitlenmiştir. Hesabınız {kalanZaman.ToString()} Dakika Sonra Açılacaktır.");
return(View("Index", model));
}
ModelState.AddModelError("", $"Kullanıcı adınız yada Şifreniz Hatalıdır. Kalan hakkınız {kalanGirisHakki.ToString()}");
}
return(View("Index", model));
}
public async Task <IActionResult> GirisYap(UserSignInViewModel model)
{
if (ModelState.IsValid)
{
var identityResult = await _signInManager.PasswordSignInAsync(model.Username, model.Password, model.RememberMe, true);
if (identityResult.IsLockedOut)
{
var gelen = await _userManager.GetLockoutEndDateAsync(await _userManager.FindByNameAsync(model.Username));
var kisitlananSure = gelen.Value;
var kalanDakika = kisitlananSure.Minute - DateTime.Now.Minute;
ModelState.AddModelError("", $"3 kere yanlış şifre girdiğiniz için hesabınız kitlenmiştir {kalanDakika} dakika boyunca kiltlenmiştir");
return(View("Index", model));
}
//if (identityResult.IsNotAllowed)
//{
// ModelState.AddModelError("", "Lütfen Email adresinizi doğrulayın");
// return View("Index", model);
//}
if (identityResult.Succeeded)
{
return(RedirectToAction("Index", "Panel"));
}
var yanlisGirilmeSayisi = await _userManager.GetAccessFailedCountAsync(await _userManager.FindByNameAsync(model.Username));
ModelState.AddModelError("", $"Kullanıcı adı veya şifre hatalı {3 - yanlisGirilmeSayisi} kere yanlış girerseniz hesabınız bloklanacaktır");
}
return(View("Index", model));
}
public async Task <IActionResult> GirisYap(UserSignInViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByNameAsync(model.UserName);
if (user != null)
{
var userPasswordCheck = await _signInManager.PasswordSignInAsync(user, model.Password,
model.RememberMe, false);
if (userPasswordCheck.Succeeded)
{
var rol = await _userManager.GetRolesAsync(user);
if (rol.Contains("Admin"))
{
return(RedirectToAction("Index", "AnaSayfa", new { area = "Admin" }));
}
else
{
return(RedirectToAction("Index", "AnaSayfa", new { area = "Ekip" }));
}
}
}
ModelState.AddModelError("", "Ekip Adı veya Şifre HATALI !");
}
return(View("Index", model));
}
public IActionResult Post(UserSignInViewModel userSignInViewModel)
{
var audience = Request.HttpContext.Connection.RemoteIpAddress.MapToIPv4().ToString();
var accessToken = _signInUserService.SignIn(userSignInViewModel, audience);
return(accessToken.Match <IActionResult>(
success => Ok(success),
failure => Problem()
));
}
public ActionResult SignIn(UserSignInViewModel model)
{
if (ModelState.IsValid)
{
authenticationService.SignIn(model.Username, model.StayLoggedIn);
return(RedirectToAction("Index", "Home"));
}
else
{
return(View(model));
}
}
public async Task <IActionResult> Login(UserSignInViewModel model)
{
var result = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, false, false);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
public void SignInApi(UserSignInViewModel model, string returnUrl)
{
var result = SignInManager.PasswordSignInAsync(model.UserNameOrEmail, model.Password, model.RememberMe, true);
if (result.Result != SignInStatus.Success && model.UserNameOrEmail.Contains("@"))
{
var user = UserManager.FindByEmailAsync(model.UserNameOrEmail);
if (user != null)
{
//result = SignInManager.PasswordSignInAsync(user.UserName, model.Password, model.RememberMe, true);
}
}
}
public async Task <IActionResult> GirisYap(UserSignInViewModel model)
{
if (ModelState.IsValid)
{
var identityResult = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, false, false);
if (identityResult.Succeeded)
{
return(RedirectToAction("Index", "Panel"));
}
ModelState.AddModelError("", "Kullanıcı adı veya şifre hatalı ");
}
return(View("Index", model));
}
public async Task <IActionResult> GirisYap(UserSignInViewModel model)
{
if (ModelState.IsValid)
{
var identityResult = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, true);
if (identityResult.Succeeded)
{
return(RedirectToAction("Index", "Anasayfa"));
}
}
return(View("Index", model));
}
public async Task <IActionResult> SignIn(UserSignInViewModel model)
{
if (ModelState.IsValid)
{
var result = await signInManager.PasswordSignInAsync(
model.UserName, model.Password, model.RememberUser, false);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Reservations"));
}
}
ViewData["Message"] = "Invalid creditentials!";
return(View());
}
public ActionResult UserSignIn(UserSignInViewModel signInUser)
{
string errorMessage = null;
if (signInUser == null)
{
signInUser = new UserSignInViewModel();
errorMessage = MessageManager.GetMessage(OperationStatus.DataFormatError);
}
else
{
try
{
IAccountDriver driver = DependencyResolver.Current.GetService <IAccountDriver>();
TokenUser tokenUser;
UserSignInClient client = new UserSignInClient()
{
Identifier = signInUser.Identifier,
Password = signInUser.Password
};
OperationStatus status = driver.TrySignIn(client, out tokenUser);
if (status == OperationStatus.SignInSuccess)
{
SaveTicketToCookie(tokenUser, signInUser.IsCookiePersistent);
string returnUrl = FormsAuthentication.GetRedirectUrl(string.Empty, false);
return(Redirect(returnUrl));
}
else
{
errorMessage = MessageManager.GetMessage(status);
}
}
catch (Exception ex)
{
LoggingWork.Error(ex);
errorMessage = MessageManager.GetMessage(OperationStatus.GenericError);
}
}
if (!string.IsNullOrEmpty(errorMessage))
{
ViewBag.ErrorMessage = errorMessage;
}
return(PartialView("_UserSignIn", signInUser));
}
//eger bu tokenı bütün heryerde kullanmak istersek controllerların üzerine [AutoValidateAntiforgeryToken] yazılır.
//Bu attribute yazıldıgı action da client'da bir token degeri varsa ancak o client buraya bir istekte bulunabilir.
public async Task <IActionResult> GirisYap(UserSignInViewModel model)
{
if (ModelState.IsValid)
{
//giriş yapma işlemleri
//3.parametremiz isPersistent yani kullancıyı birdaha hatırlayıp/hatırlamayacagı biz false verdik.
//4.parametre lockOutOnFailure yani kullanıcının belirli sayıda sifreyi yanlıs girdiği durumda kullanıcıyı bloklayıp/bloklamayacagı
//biz true verdik ve db de AccessFailedCount alanı her yanlış girişte 1 artıcak.4.yanlışın sonunda Lockoutende kolonuna bir tarih atancak ve o tarihe kadar kullanıcı bloklandı.
var identityResult = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, true);
if (identityResult.IsLockedOut)
{
var gelen = await _userManager.GetLockoutEndDateAsync
(await _userManager.FindByNameAsync(model.UserName));
var kisitlanansure = gelen.Value;
//Şuanki dakikadan ksııtlanan dakikayı cıkararak kalan dakikayı bulup,bilgi mesajı gönderdik.
var kalanDakika = kisitlanansure.Minute - DateTime.Now.Minute;
// eger bloklandıysa error mesajı verip,modeli index sayfasına yönlendiriyoruz.
ModelState.AddModelError("", $"3 kere yanlış girdiğiniz için hesabınız {kalanDakika} dk kilitlenmiştir.");
return(View("Index", model));
}
//if (identityResult.IsNotAllowed)
//{
// ModelState.AddModelError("", "E-mail adresinizi lütfen doğrulayınız.");
// return View("Index", model);
//}
if (identityResult.Succeeded)
{
//ındex gidicek panelkontrollerına gidicek
return(RedirectToAction("Index", "Panel"));
}
var yanlisGirilmeSayisi = await _userManager.GetAccessFailedCountAsync
(await _userManager.FindByNameAsync(model.UserName));
ModelState.AddModelError("", $"Kullanıcı adı veya Şifre hatalı {3-yanlisGirilmeSayisi} defa daha yanlış girerseniz hesabınız kilitlenecektir.");
}
return(View("Index", model));
}
public async Task <IActionResult> Index(UserSignInViewModel model)
{
if (ModelState.IsValid)
{
if (LoginUser(model))
{
User user = userService.GetByUsername(model.UserName);
List <Role> roles = userService.GetRoles(user.Id);
List <Privilege> privileges = new List <Privilege>();
if (roles?.Count > 0)
{
privileges = GetRolesPrivileges(roles);
}
List <Claim> claims = new List <Claim>
{
new Claim(ClaimTypes.Name, model.UserName)
};
if (privileges?.Count > 0)
{
foreach (var priv in privileges)
{
claims.Add(new Claim(priv.Name, priv.Name));
}
}
ClaimsIdentity identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
ClaimsPrincipal principal = new ClaimsPrincipal(identity);
await HttpContext.SignInAsync(principal);
return(RedirectToAction("Index", "Panel"));
}
else
{
ModelState.AddModelError("", "Kullanıcı adı veya şifre hatalı");
}
}
return(View(model));
}
[ValidateAntiForgeryToken] // client üzerinden bir istek var ise token kontrolü yapar. Mevcut sayfa üzerinde token bulunmaktadır.
public async Task <IActionResult> GirisYap(UserSignInViewModel model)
{
if (ModelState.IsValid)
{
/*
* parametre değerleri
* 1 - Kullanıcı adı
* 2 - Şifre
* 3 - Beni hatırla
* 4 - Lock olup/olmaması
*/
var result = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, true);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Panel"));
}
else if (result.IsLockedOut) // hesap kitli ise
{
var gelen = await _userManager.GetLockoutEndDateAsync(await _userManager.FindByNameAsync(model.UserName));
var kisitlananSure = gelen.Value;
var kalanDakika = kisitlananSure.AddMinutes((-1) * DateTime.Now.Minute);
ModelState.AddModelError("", $"3 Kere yanlış girdiğiniz için hesabınız kitlenmiştir. {kalanDakika} dk sonra tekrar deneyebilirsiniz.");
}
else if (result.IsNotAllowed) // mail adresi doğrulama yapılmamışsa
{
ModelState.AddModelError("", "Email adresinizi lütfen doğrulayınız.");
}
else
{
var yanlisGirilmeSayisi = await _userManager.GetAccessFailedCountAsync(await _userManager.FindByNameAsync(model.UserName));
ModelState.AddModelError("", $"Kullanıcı adı veya şifre hatalı. {5- yanlisGirilmeSayisi} kadar yanlış girerseniz hesabınız kitlenecektir.");
}
}
return(View("Index", model));
}
public IActionResult SignIn(UserSignInViewModel userInfo)
{
if (userInfo.Username == null || userInfo.Username == "")
{
ViewData["Error"] = "Username must be provided";
return(View());
}
else if (userInfo.Password == null || userInfo.Password == "")
{
ViewData["Error"] = "Password must be provided";
return(View());
}
string username = userInfo.Username;
string password = userInfo.Password;
var user =
from rider in _context.Set <Rider>()
where rider.UserName == username
select rider;
if (user.Count() == 0)
{
ViewData["Error"] = "Failed to sign in due to invalid username";
return(View());
}
var hashedPassword = user.First().Password;
if (!Crypto.VerifyHashedPassword(hashedPassword, password))
{
ViewData["Error"] = "Failed to sign in due to wrong password";
return(View());
}
else
{
HttpContext.Response.Cookies.Append("AuthUserId", user.First().Id.ToString());
return(RedirectToAction("Index"));
}
}
public async Task <IActionResult> GirisYap(UserSignInViewModel model)
{
if (ModelState.IsValid)
{
//ispersistent = kullanıcıyı hatırlamak için kullanılır.
//lockout = kullanıcıbelirli bir sayıda şifresini yanlıs girdi. bloklayayım mı diye kulanılır.
var identityResult = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, true);
//isLockedOut = hesabın kilitli olup olmadıgına bakıyor veritabanında var.
//successed = başarılı giriş yapma durumu
//isNotAllowed = bir kullanıcının sistemde aktif bir üye olması için emaili doğrulamasını isteyebilirsiniz.email aktivasyonu
//iki aşamalı doğrulama = email veya telefonunuza sms gelmesi (twofactor)
if (identityResult.IsLockedOut)
{
var gelen = await _usermanager.GetLockoutEndDateAsync(await _usermanager.FindByNameAsync(model.UserName));
var kisitlananSure = gelen.Value;
var kalanDakika = kisitlananSure.Minute - DateTime.Now.Minute;
ModelState.AddModelError("", $"3 kere yanlış girdiğiniz için hesabınız {kalanDakika} dakika kilitlenmiştir.");
return(View("Index", model));
}
if (identityResult.IsNotAllowed)
{
ModelState.AddModelError("", "Lütfen email adresinizi doğrulayınız.");
return(View("Index", model));
}
if (identityResult.Succeeded)
{
//başarılı ise panelcontrollerdaki indexe git.
return(RedirectToAction("Index", "Panel"));
}
var yanlisGirilmeSayisi = await _usermanager.GetAccessFailedCountAsync(await _usermanager.FindByNameAsync(model.UserName));
ModelState.AddModelError("", $"Kullanıcı adı veya şifre hatalı{3-yanlisGirilmeSayisi} kadar yanlış girerseniz hesabınız bloklanacak.");
}
return(View("Index", model));
}
public HttpResponseMessage AuthenticateUser(UserSignInViewModel userParam)
{
UserManager userManager = new UserManager();
HistoryManager historyManager = new HistoryManager();
try
{
var user = userManager.FindAuthenticatedUser(userParam.UserName, userParam.Password);
var dbUser = userManager.FindUserEmail(user.Email);
historyManager.AddHistory(new History(dbUser)
{
Activity = Activities.Login,
Description = Helper.GenerateActivityDescription(dbUser, Activities.Login)
});
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, user);
return(response);
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public async Task <ActionResult> SignIn(UserSignInViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, true);
switch (result)
{
case SignInStatus.Success:
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
public async Task <IActionResult> SignIn(UserSignInViewModel signModel)
{
if (ModelState.IsValid)
{
var identityResult = await _signInManager.PasswordSignInAsync(signModel.UserName, signModel.Password, signModel.RememberMe, true);
//yanlış girilmeye karşı hesap kilitleme
if (identityResult.IsLockedOut)
{
//Hangi kullanıcı için engelenen girilen hesap süresi
var values = await _userManager.GetLockoutEndDateAsync(await _userManager.FindByNameAsync(signModel.UserName));
var limitedTime = values.Value;
var limitedMinute = limitedTime.Minute - DateTime.Now.Minute;
ModelState.AddModelError("", $"5 kere yanlış girdiğiniz için hesabınız kitlenmiştir.{limitedMinute} dk kilitlenmiştir ");
return(View("Index", signModel));
}
//Email doğrulama isteği
if (identityResult.IsNotAllowed)
{
ModelState.AddModelError("", "Email adresinizi lütfen doğrulayınız.");
return(View("Index", signModel));
}
//başarılı ise
if (identityResult.Succeeded)
{
return(RedirectToAction("Index", "Panel"));
}
var failCount = await _userManager.GetAccessFailedCountAsync(await _userManager.FindByNameAsync(signModel.UserName));
ModelState.AddModelError("", $"Kullanıcı adı veya şifre hatalı {5 - failCount} kadar yanlış girerseniz hesabınız bloklanacak");
}
return(View("Index", signModel));
}
public async Task <IActionResult> SignIn(UserSignInViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
IbanScannerUser user;
var loginProvider = Utility.GetLoginProvider(model.Username);
if (loginProvider == LoginProvider.Email)
{
user = await _userManager.FindByEmailAsync(model.Username);
}
else
{
user = await _userManager.FindByNameAsync(model.Username);
}
if (user != null)
{
var result = await _signInManager.PasswordSignInAsync(user.UserName, model.Password, model.RememberMe, false);
if (result.Succeeded)
{
if (TempData["returnUrl"] != null)
{
return(Redirect(TempData["returnUrl"].ToString()));
}
return(RedirectToAction("index", "home"));
}
}
ViewData["SignInError"] = "Please check the information.";
return(View(model));
}
public async Task <ActionResult> SignIn(UserSignInViewModel model, string returnUrl)
{
ViewBag.IsDemoMode = (ConfigurationManager.AppSettings["ticketdesk:DemoModeEnabled"] ?? "false").Equals("true", StringComparison.InvariantCultureIgnoreCase);
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, true);
switch (result)
{
case SignInStatus.Success:
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
default:
ModelState.AddModelError("", Strings.InvalidLoginAttempt);
return(View(model));
}
}
public Result <AuthenticatedUserViewModel> SignIn(UserSignInViewModel viewModel, string audience)
{
var user = new User
{
Id = 10,
Email = viewModel.Email,
Age = 28,
Name = "Jhone Due"
};
var expireDate = DateTime.UtcNow.AddHours(2);
var accessToken = _tokenManager.GenerateToken(user, audience, expireDate);
return(accessToken.Match <Result <AuthenticatedUserViewModel> >(
success => new Result <AuthenticatedUserViewModel>(
new AuthenticatedUserViewModel
{
Email = viewModel.Email,
AccessToken = success,
ExpiredAt = expireDate.ToString()
}),
failure => new Result <AuthenticatedUserViewModel>(failure)
));
}
private bool LoginUser(UserSignInViewModel model)
{
return(userService.LoginUser(model.UserName, model.Password));
}
public async Task <ActionResult> SignIn(UserSignInViewModel model, string returnUrl)
{
ViewBag.IsDemoMode = (ConfigurationManager.AppSettings["ticketdesk:DemoModeEnabled"] ?? "false").Equals("true", StringComparison.InvariantCultureIgnoreCase);
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await SignInManager.PasswordSignInAsync(model.UserNameOrEmail, model.Password, model.RememberMe, true);
if (result != SignInStatus.Success && model.UserNameOrEmail.Contains("@"))
{
var user = await UserManager.FindByEmailAsync(model.UserNameOrEmail);
if (user != null)
{
result = await SignInManager.PasswordSignInAsync(user.UserName, model.Password, model.RememberMe, true);
}
}
switch (result)
{
case SignInStatus.Success:
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
}
var domain = (DomainContext.TicketDeskSettings.SecuritySettings.DefaultLogonDomain ?? string.Empty).Trim();
if (!string.IsNullOrEmpty(domain))
{
var user = await UserManager.FindByNameAsync(model.UserNameOrEmail);
if (user == null)
{
user = await UserManager.FindByNameAsync(model.UserNameOrEmail + "@" + domain);
}
if (user != null)
{
var dsEntry = new DirectoryEntry("LDAP://" + domain)
{
Username = user.UserName,
Password = model.Password
};
var dsSearch = new DirectorySearcher(dsEntry);
dsSearch.Filter = "(objectclass=user)";
var OK = false;
try
{
OK = dsSearch.FindOne() != null;
}
catch { }
if (OK)
{
await UserManager.ResetAccessFailedCountAsync(user.Id);
await SignInManager.SignInAsync(user, model.RememberMe, true);
return(RedirectToLocal(returnUrl));
}
}
}
ModelState.AddModelError("", Strings.InvalidLoginAttempt);
return(View(model));
}
