public IActionResult SignIn(UserSignIn user)
{
if (ModelState.IsValid)
{
string publicKey = _controllerAPI.GetPublicKey();
user.Password = _cryptingRSA.Encrypt(user.Password, publicKey);
UserLogin userLogin = _loginSystemAPI.Login <UserSignIn, UserLogin>(user);
if (userLogin.Email == user.Email)
{
SessionManager.UserID = userLogin.UserID;
SessionManager.TypeUser = userLogin.TypeUser;
SessionManager.Email = userLogin.Email;
SessionManager.LastName = userLogin.LastName;
SessionManager.FirstName = userLogin.FirstName;
}
else
{
ModelState.AddModelError(string.Empty, "Ce login n'existe pas ou le mot de passe n'est pas correct.");
return(View());
}
}
return(RedirectToAction("Index", "Home"));
}
/// <summary>
/// 用户签到
/// </summary
/// Item1签到结果,Item2提示信息
/// <returns></returns>
public Tuple <bool, string> Sign()
{
if (!HttpContext.Current.Request.IsAuthenticated)
{
return(new Tuple <bool, string>(false, "签到失败,请尝试刷新本页或者请重新登录!"));
}
if (IsUserSign(DateTime.Now))
{
return(new Tuple <bool, string>(false, "您今天已经签过了!"));
}
var model = new UserSignIn
{
CreationDate = DateTime.Now,
UserId = CurrentUserId
};
var result = MongoHelper.Instance.Save(model);
var msg = "签到失败!";
if (result)
{
var integral = new Integral
{
UserId = CurrentUserId,
CalculatorSystem = Application.CalculatorSystem,
IntegralType = IntegralType.签到,
CreationDate = DateTime.Now
};
MongoHelper.Instance.Save(integral);
msg = string.Format("{0} 签到成功!", DateTime.Now.ToString("yyyy/MM/dd"));
}
return(new Tuple <bool, string>(result, msg));
}
public ActionResult signIn(UserSignIn signInUser)//prima parametar User
{
if (ModelState.IsValid)
{
//if username and password match with user in database
var checkUser = db.Users.Where(x => x.Username == signInUser.Username && x.Password == signInUser.Password).FirstOrDefault();
if (checkUser != null)
{
//if there is match, check approved by admin
if (checkUser.Approved == true)
{
//if approved Sign In
Session["User"] = checkUser;
return(RedirectToAction("Index", "Home"));
}
//if not approved return message
return(RedirectToAction("Index", "Home", new { message = "Not Approved" }));
}
return(RedirectToAction("Index", "Home", new { message = "Not Registered" }));
}
//if not registered return message
return(RedirectToAction("Index", "Home"));
}
public override void OnAuthorization(HttpActionContext actionContext)
{
if (actionContext.Request.Headers.Authorization == null)
{
actionContext.Response = actionContext.Request
.CreateResponse(HttpStatusCode.Unauthorized);
}
else
{
var authenticationToken = actionContext.Request.Headers
.Authorization.Parameter;
var decodedAuthenticationToken = Encoding.UTF8.GetString(
Convert.FromBase64String(authenticationToken));
var usernamePasswordArray = decodedAuthenticationToken.Split(':');
var userSignIn = new UserSignIn
{
UserName = usernamePasswordArray[0],
Password = usernamePasswordArray[1]
};
if (_usersBusinessLogic.UserLoginAuthentication(userSignIn))
{
Thread.CurrentPrincipal = new GenericPrincipal(
new GenericIdentity(userSignIn.UserName), null);
}
else
{
actionContext.Response = actionContext.Request
.CreateResponse(HttpStatusCode.Unauthorized);
}
}
}
public ActionResult Login(UserSignIn user)
{
try
{
UserSignIn usr = user as UserSignIn;
if (usr != null)
{
FormsAuthentication.SetAuthCookie(usr.Username, false);
return(RedirectToAction("GetAdminPanel", "AdminPanel"));
List <UserSignIn> usrPWdControl = db.UserLogin(usr);
if (usrPWdControl != null)
{
foreach (UserSignIn usrItem in usrPWdControl)
{
if (pwd.ValidatePassword(usr.Password, usrItem.HashSalt, usrItem.HashPasword))
{
FormsAuthentication.SetAuthCookie(usrItem.Username, false);
return(RedirectToAction("GetAdminPanel", "AdminPanel"));
}
else
{
return(RedirectToAction("Login"));
}
}
}
return(RedirectToAction("Login"));
}
return(RedirectToAction("Login"));
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public async Task <string> Logout(UserSignIn users) =>
await Task.Run(() =>
{
try
{
HttpContext.Session.Remove("CurrentUser");
return("T");
}
catch { return("F"); }
});
public User SignIn(UserSignIn creds)
{
var user = _repo.GetUserByEmail(creds.Email);
if (user == null || !BCrypt.Net.BCrypt.Verify(creds.Password, user.Hash))
{
throw new Exception("Invalid Email or Password");
}
return(user);
}
public HomePage InputValueOfSignInPage(IWebDriver Driver)
{
Login.SendKeys(UserSignIn.WithAllProperties().Login);
NextButton.Click();
WebDriverWait wait = new WebDriverWait(Driver, TimeSpan.FromSeconds(10));
wait.Until(ExpectedConditions.ElementIsVisible(By.XPath("//input[@type='password']")));
Password.SendKeys(UserSignIn.WithAllProperties().Password);
Password.SendKeys(Keys.Enter);
return(new HomePage(Driver));
}
public async Task <IActionResult> SignIn([FromBody] UserSignIn model)
{
var result = await _userService.SignIn(model.UserName, model.Password);
if (result == null)
{
return(Ok(new { message = "User name or password is incorrect" }));
}
return(Ok(result));
}
public ActionResult SignIn(UserSignIn userSignIn)
{
try
{
_userProcessor.SignIn(userSignIn);
}
catch (Exception ex)
{
return(View("Error", ex));
}
return(View("Welcome"));
}
public ActionResult SignIn(UserSignIn user)
{
if (ModelState.IsValid)
{
var checkUser = db.Users.Where(x => x.Username == user.Username && x.Password == user.Password).FirstOrDefault();
if (checkUser != null)
{
Session["User"] = checkUser;
return(RedirectToAction("Index"));
}
}
return(View());
}
public void SignIn(UserSignIn entitie)
{
if (!_UserRepository.FindUserByEmailAndPassword(entitie))
{
throw new Exception("No existe el nombre de usuario o la constraseña es incorrecta");
}
//if(entitie.Email!=string.Empty && entitie.Password!=String.Empty)
//{
// UserRepository repo = new UserRepository();
// return repo.FindUserByEmailAndPassword(entitie);
//}
}
public async Task <IActionResult> GetUserFromDb([FromBody] UserSignIn user)
{
User userobj = new User();
if (user.Login == null || user.Password == null)
{
throw new ArgumentNullException();
}
// Хэширует пароль для сравнения зашифрованных паролей
string checkHashString = await HashMD5Service.HashPassword(user.Password);
// Сравнивает хэши
var isEqual = await EqualsHash(user.Login);
if (isEqual != checkHashString)
{
return(ErrorViewModel.ErrorEqualHash());
}
// Проверяет, есть ли пользователь в БД
var identity = await GetIdentity(user.Login, isEqual);
// Если пользователь найден, то получаем его ID
if (identity != null)
{
userobj = db.Users.FirstOrDefault(x => x.Login == user.Login);
}
var now = DateTime.UtcNow;
if (identity == null)
{
return(ErrorViewModel.ErrorToken());
}
// Создание JWT-токена
var jwt = new JwtSecurityToken(
issuer: AuthOptions.ISSUER,
audience: AuthOptions.AUDIENCE,
notBefore: now,
claims: identity.Claims,
expires: now.Add(TimeSpan.FromMinutes(AuthOptions.LIFETIME)),
signingCredentials: new SigningCredentials(AuthOptions.GetSymmetricSecurityKey(), SecurityAlgorithms.HmacSha256));
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
// Объект анонимного типа с токеном, который отсылается на фронт
var response = new {
access_token = encodedJwt,
userName = identity.Name,
id = userobj.Id
};
return(Json(response));
}
public void SignIn(IUserModel user)
{
var message = new UserSignIn
{
IsSignedIn = !user.IsSignedIn,
UserId = user.Id,
};
var changed = this.ModelUpdaterResolver.GetUpdater <IUpdatableUser, UserSignIn>().Update(this.model.Users.FirstOrDefault(x => x.Id == user.Id), message);
if (changed)
{
this.ServiceClient.PublishAsync <UserSignIn>(message);
}
}
public async Task <ActionResult <User> > Login([FromBody] UserSignIn creds)
{
try
{
User user = _as.SignIn(creds);
user.SetClaims();
await HttpContext.SignInAsync(user._principal);
return(Ok(user));
}
catch (Exception e)
{
return(Unauthorized(e.Message));
}
}
public bool UserLoginAuthentication(UserSignIn userSignIn)
{
try
{
return
(_unitOfWork
.Users
.UserLoginAuthentication(userSignIn.UserName, userSignIn.Password));
}
catch (Exception exception)
{
BusinessLogicExceptions.WriteExceptionMessageToFile(exception);
return(false);
}
}
public async Task <ActionResult <User> > SignIn([FromBody] UserSignIn creds)
{
try
{
User u = _accountService.SignIn(creds);
u.SetClaims();
await HttpContext.SignInAsync(u._principal);
return(Ok(u));
}
catch (System.Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <HttpResponseMessage> SignIn(UserSignIn model)
{
if (model == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "No Data"));
}
if (ModelState.IsValid)
{
// This doesn't count login failures towards lockout only two factor authentication
// To enable password failures to trigger lockout, change to shouldLockout: true
var result = await SignInHelper.PasswordSignIn(model.UserName, model.Password, true, false);
switch (result)
{
case Ullo.Models.SignInStatus.Success:
var user = await users.FindByNameAsync(model.UserName);
await SignInHelper.SignInAsync(user, true, false);
var account = new UserDetail();
account.UserName = user.UserName;
account.FirstName = user.FirstName;
account.LastName = user.LastName;
account.FacebookId = user.FacebookId;
account.isAuthenticated = true;
account.Route = user.Route;
var rolesForUser = users.GetRoles(user.Id);
account.isAdmin = rolesForUser.Contains("Admin");
return(Request.CreateResponse(account));
case Ullo.Models.SignInStatus.LockedOut:
return(Request.CreateErrorResponse(HttpStatusCode.Forbidden, "LockedOut"));
case Ullo.Models.SignInStatus.RequiresTwoFactorAuthentication:
return(Request.CreateErrorResponse(HttpStatusCode.Forbidden, "RequiresTwoFactorAuthentication"));
case Ullo.Models.SignInStatus.Failure:
return(Request.CreateErrorResponse(HttpStatusCode.Forbidden, "Failure"));
default:
return(Request.CreateErrorResponse(HttpStatusCode.Forbidden, "Invalid"));
}
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
public UsersViewModel UserSignIn(UserSignIn userSignIn)
{
try
{
return
(Mapper.Map <Users, UsersViewModel>
(_unitOfWork
.Users
.UserSignIn(userSignIn.UserName, userSignIn.Password)));
;
}
catch (Exception exception)
{
BusinessLogicExceptions.WriteExceptionMessageToFile(exception);
return(null);
}
}
public async Task <IActionResult> SignIn([FromBody] UserSignIn dto)
{
var user = _ctx.CheckUser(dto);
if (user is null)
{
return(NotFound("User not found"));
}
var userSigninResult = await _ctx.CheckUserPassword(user, dto);
if (userSigninResult)
{
return(Ok());
}
return(BadRequest("Email or password incorrect."));
}
public async Task <IActionResult> Authenticate(
[FromQuery] string client_id,
[FromQuery] string scope,
[FromQuery] string response_type,
[FromQuery] string redirect_uri,
[FromQuery] string state,
UserSignIn userSignIn)
{
var query = new QueryBuilder();
query.Add("state", state);
if (string.IsNullOrEmpty(state) || string.IsNullOrEmpty(client_id))
{
query.Add("error", "invalid_request");
return(Redirect($"{redirect_uri}?{query}"));
}
if (!_appSettings.OAuthSettings.Clients.Contains(client_id))
{
query.Add("error", "unauthorized_client");
return(Redirect($"{redirect_uri}?{query}"));
}
if (response_type != "code")
{
query.Add("error", "unsupported_response_type");
return(Redirect($"{redirect_uri}?{query}"));
}
var user = await _userRepository.GetAsync(userSignIn.Email);
if ((user is null) || !user.CheckPassword(userSignIn.Password))
{
query.Add("error", "access_denied");
}
UserToken userToken = new UserToken(user.Email, redirect_uri, DateTime.Now.AddMinutes(5).Ticks);
await _userTokenRepository.CreateAsync(userToken);
query.Add("code", userToken.AuthorizationCode);
return(Redirect($"{redirect_uri}{query}"));
}
public bool FindUserByEmailAndPassword(UserSignIn entitie)
{
bool result = false;
IQueryable <User> lista = null;
using (var context = new AgileInvoiceDbContext(connString))
{
//result = context.Users.Select(item => item.Email == entitie.Email && item.Password == entitie.Password).FirstOrDefault(); //dejo de funcionar!!!
lista = from item in context.Users
where item.Email == entitie.Email && item.Password == entitie.Password
select item;
if (lista.Count() > 0)
{
result = true;
}
}
return(result);
}
public async Task <IActionResult> GenrateJwtToken([FromBody] UserSignIn dto)
{
try
{
var user = _ctx.CheckUser(dto);
if (user != null)
{
var token = await _ctx.GenerateJwtToken(user);
return(Ok(token));
}
}
catch
{
return(BadRequest());
}
return(Ok());
}
public string GetUserSignInByMonth(string username)
{
try
{
if (string.IsNullOrWhiteSpace(username))
{
return(ReturnError("登录标识不能为空字符串，请检查", ""));
}
var user = Membership.GetUser(username);
if (user == null)
{
return(ReturnError("登录标识无效，请检查", ""));
}
var userId = user.ProviderUserKey;
UserSignIn usiBll = new UserSignIn();
var usiModel = usiBll.GetModelByUser(user.ProviderUserKey);
DateTime currTime = DateTime.Now;
if (usiModel == null)
{
return(GetUserSignInByMonthForNull());
}
XElement root = XElement.Parse(usiModel.SignInXml);
var currMonthXel = root.Elements("Xel").FirstOrDefault(x => x.Attribute("Month").Value == currTime.ToString("yyyyMM"));
if (currMonthXel == null)
{
return(GetUserSignInByMonthForNull());
}
currMonthXel.SetAttributeValue("Month", currTime.ToString("yyyy-MM-dd"));
return(ReturnSuccess("", "<Root>" + currMonthXel.ToString() + "</Root>"));
}
catch (Exception ex)
{
new CustomException(ex.Message, ex);
return(ReturnError(ex.Message, ""));
}
}
public async Task <ActionResult> SignIn(UserSignIn _user)
{
try
{
if (!ModelState.IsValid)
{
return(PartialView("_LoginView", _user));
}
var client = _httpClientFactory.CreateClient("uriUser");
var method = "";
var response = await client.PostAsJsonAsync(method, _user);
var result = await response.Content.ReadAsStringAsync();
return(View());
}
catch
{
return(View());
}
}
public async Task <string> Login(UserSignIn users) =>
await Task.Run(() =>
{
if (!ModelState.IsValid)
{
return("F");
}
else
{
HttpContext.Session.SetString("CurrentUser", users.UserName);
HttpContext.Response.Cookies.Append(LoginCookieBase64.GetCookieUserNameBase64,
RSAData.RSAEncryption(users.UserName, "username"),
new CookieOptions {
Expires = DateTimeOffset.Now.AddMonths(1)
});
HttpContext.Response.Cookies.Append(LoginCookieBase64.GetCookiePasswordBase64,
RSAData.RSAEncryption(users.Password, "password"),
new CookieOptions {
Expires = DateTimeOffset.Now.AddMonths(1)
});
var IsRemembered = users.IsRemembered;
if (IsRemembered == "true")
{
HttpContext.Response.Cookies.Append(LoginCookieBase64.GetCookieRememberBase64, "1",
new CookieOptions {
Expires = DateTimeOffset.Now.AddMonths(1)
});
}
else
{
HttpContext.Response.Cookies.Delete(LoginCookieBase64.GetCookieRememberBase64);
}
if (users.UserName == "aa")
{
return("F");
}
return("T");
}
});
public ActionResult Login(UserSignIn model)
{
var a = AuthenticateUser(model.UserID, model.Password);
if (a.Rows.Count < 1)
{
ViewData["Message"] = "Incorrect User ID or Password";
ViewData["MsgType"] = "warning";
return(View("Signin"));
}
else
{
if (TempData["returnUrl"] != null)
{
string returnUrl = TempData["returnUrl"].ToString();
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
}
return(RedirectToAction("CreateInstallment"));
}
}
public UserSignIn SignInUser(User user)
{
UserSignIn userSignIn = new UserSignIn();
userSignIn.user = user;
if (db.Users.Any(u => u.Email.ToLower() == user.Email.ToLower()))
{
if (db.Users.Any(p => p.Email.ToLower() == user.Email.ToLower() && p.Password == user.Password))
{
User userdet = db.Users.Where(x => x.Email.ToLower() == user.Email.ToLower() && x.Password == user.Password).First();
userSignIn.Message = "success";
MD5 mD5 = new MD5CryptoServiceProvider();
DateTime time = DateTime.Now;
mD5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(user.Email + time.Millisecond));
userSignIn.hash = ToHex(mD5.Hash, false);
UserLog userLog = new UserLog();
userLog.UserId = userdet.Id;
userLog.EncData = userSignIn.hash;
db.UserLogs.Add(userLog);
db.SaveChanges();
return(userSignIn);
}
else
{
userSignIn.Message = "Invalid Password";
return(userSignIn);
}
}
else
{
userSignIn.Message = "Not Exists";
return(userSignIn);
}
}
public IActionResult Post(UserSignIn users) => Redirect(HttpContext.Request.GetDisplayUrl());
public async Task <IActionResult> SignIn([FromBody] UserSignIn user)
{
User userobj = new User();
if (user.LoginOrEmail == null || user.Password == null)
{
throw new ArgumentNullException("Параметры авторизации не заполнены.");
}
// Хэширует пароль для сравнения зашифрованных паролей
string checkHashString = await HashMD5Service.HashPassword(user.Password);
// Сравнивает хэши
var isEqual = await EqualsHash(user.LoginOrEmail);
if (!isEqual.Equals(checkHashString))
{
throw new ArgumentException("Не верный пароль.");
}
// Проверяет, есть ли пользователь в БД
var identity = await GetIdentity(user.LoginOrEmail, isEqual);
// Если пользователь найден, то получаем его ID
if (identity != null)
{
bool isEmail = identity.Name.Contains("@"); // Проверяет логин передан или email.
if (isEmail)
{
userobj = await db.Users.FirstOrDefaultAsync(u => u.Email == user.LoginOrEmail);
}
else
{
userobj = await db.Users.FirstOrDefaultAsync(u => u.Login == user.LoginOrEmail);
}
}
var now = DateTime.UtcNow;
if (identity == null)
{
throw new ArgumentException("У пользователя отсутствует токен доступа.");
}
// Создание JWT-токена
var jwt = new JwtSecurityToken(
issuer: AuthOptions.ISSUER,
audience: AuthOptions.AUDIENCE,
notBefore: now,
claims: identity.Claims,
expires: now.Add(TimeSpan.FromMinutes(AuthOptions.LIFETIME)),
signingCredentials: new SigningCredentials(AuthOptions.GetSymmetricSecurityKey(), SecurityAlgorithms.HmacSha256));
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
// Объект анонимного типа с токеном, который отсылается на фронт
var response = new {
access_token = encodedJwt,
user_data = userobj
};
return(Json(response));
}
