public async Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
{
HttpRequestMessage request = context.Request;
string token = string.Empty;
bool existTokenKey = request.Headers.Any(z => z.Key.Equals("Token"));
if (existTokenKey)
{
token = request.Headers.FirstOrDefault(z => z.Key.Equals("Token")).Value.First();
}
if (string.IsNullOrEmpty(token))
{
context.ErrorResult = new AuthenticationFailureResult("Token Required", request);
return;
}
AuthenticationBusiness authenticationFactory = new AuthenticationBusiness();
SessionEntity session = authenticationFactory.ApplicationSessionCheck(token);
if (session == null || session.ApplicationID == 0)
{
context.ErrorResult = new AuthenticationFailureResult("Token Not Found Or Expired", request);
return;
}
context.Request.Properties.Add(CommonConstants.SessionName, session);
}
public LoginResultModel Login([FromBody] LoginModel request)
{
AuthenticationBusiness authenticationFactory = new AuthenticationBusiness();
LoginResultModel response = authenticationFactory.Login(request);
return(response);
}
public ActionResult Login(LoginVM model)
{
AuthenticationBusiness userBL = new AuthenticationBusiness();
Person user = userBL.LoginPerson(model);
if (user != null)
{
ConnexionService.SetSession(user);
TempData["LoginMessage"] = "Welcome " + model.Login;
if (user is Student)
{
return(RedirectToAction(nameof(HomeController.Index), "Home"));
}
else if (user is Instructor)
{
return(RedirectToAction(nameof(HomeController.Index), "Home"));
}
}
else
{
ModelState.AddModelError("", "Invalid login or password");
return(View());
}
return(View());
}
//private bool AuthenticateUser(string username, string password)
//{
// // ConfigurationManager class is in System.Configuration namespace
// string CS = ConfigurationManager.ConnectionStrings["DBCS"].ConnectionString;
// // SqlConnection is in System.Data.SqlClient namespace
// using (SqlConnection con = new SqlConnection(CS))
// {
// SqlCommand cmd = new SqlCommand("spAuthenticateUser", con);
// cmd.CommandType = CommandType.StoredProcedure;
// // FormsAuthentication is in System.Web.Security
// string EncryptedPassword = FormsAuthentication.HashPasswordForStoringInConfigFile(password, "SHA1");
// // SqlParameter is in System.Data namespace
// SqlParameter paramUsername = new SqlParameter("@UserName", username);
// SqlParameter paramPassword = new SqlParameter("@Password", EncryptedPassword);
// cmd.Parameters.Add(paramUsername);
// cmd.Parameters.Add(paramPassword);
// con.Open();
// int ReturnCode = (int)cmd.ExecuteScalar();
// return ReturnCode == 1;
// }
//}
#endregion Old Implementation
private void AuthenticateUserNew(User user)
{
AuthenticationBusiness bll = new AuthenticationBusiness();
User userInfo = bll.AuthenticateUser(user);
int RetryAttempts = userInfo.RetryAttempts;
if (!userInfo.IsAuthenticated && !userInfo.IsAccountLocked && RetryAttempts == 0)
{
lblMessage.Text = "Not registered user. Please register first.";
}
else if (userInfo.IsAccountLocked)
{
lblMessage.Text = "Account locked. Please contact administrator";
}
else if (RetryAttempts > 0)
{
int AttemptsLeft = (4 - RetryAttempts);
lblMessage.Text = "Invalid user name and/or password. " +
AttemptsLeft.ToString() + "attempt(s) left";
}
else if (userInfo.IsAuthenticated)
{
Session["Username"] = txtUserName.Text;
FormsAuthentication.RedirectFromLoginPage(txtUserName.Text, chkBoxRememberMe.Checked);
}
}
public string ResetPassword(VahapYigit.Test.Core.IUserContext userContext, string email, string passwordResponse)
{
using (var et = new ExecutionTracerService())
{
var business = new AuthenticationBusiness();
return(business.ResetPassword(userContext, email, passwordResponse));
}
}
public bool Create(VahapYigit.Test.Core.IUserContext userContext, ref VahapYigit.Test.Models.User user, out System.Collections.Generic.IList <VahapYigit.Test.Core.TranslationEnum> errors)
{
using (var et = new ExecutionTracerService())
{
var business = new AuthenticationBusiness();
return(business.Create(userContext, ref user, out errors));
}
}
public bool IsRegistered(VahapYigit.Test.Core.IUserContext userContext, out VahapYigit.Test.Models.User user)
{
using (var et = new ExecutionTracerService())
{
var business = new AuthenticationBusiness();
return(business.IsRegistered(userContext, out user));
}
}
public bool IsEmailUsed(VahapYigit.Test.Core.IUserContext userContext, string email)
{
using (var et = new ExecutionTracerService())
{
var business = new AuthenticationBusiness();
return(business.IsEmailUsed(userContext, email));
}
}
public void Initialize()
{
// httpContext = new MockHttpContextWrapper();
//authenticationBusinessToTest.ControllerContext = new ControllerContext(HttpContent.Context.Object, new RouteData(), authenticationBusinessToTest);
DBUtils.db = new DAL.SchoolContext(this.ConnectionString);
authenticationBusinessToTest = new AuthenticationBusiness();
authenticationBusinessToTest.DbContext = DBUtils.db;
}
public async Task <IActionResult> Authentication([FromBody] AuthenticationRequest input)
{
if (!ModelState.IsValid)
{
return(new ResponseBase("204", "", ModelState).ToActionResult());
}
IAuthenticationBusiness business = new AuthenticationBusiness();
return(business.Authentication(input).ToActionResult());
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
AuthenticationBusiness bll = new AuthenticationBusiness();
if (!bll.IsPasswordResetLinkValid(Request.QueryString["uid"]))
{
lblMessage.ForeColor = System.Drawing.Color.Red;
lblMessage.Text = "Password Reset link has expired or is invalid";
}
}
}
public List <string> SignUp(UserModel userObj)
{
try
{
using (AuthenticationBusiness objAuthenticationBusiness = new AuthenticationBusiness())
{
return(objAuthenticationBusiness.signUpBusiness(userObj));
}
}
catch (Exception ex)
{
throw;
}
}
protected void btnSave_Click(object sender, EventArgs e)
{
string uid = Request.QueryString["uid"];
string newPwd = new EncryptionAlgorithm().GetEncryptedValue(txtNewPassword.Text);
AuthenticationBusiness bll = new AuthenticationBusiness();
if (bll.ChangeUserPassword(uid, newPwd))
{
lblMessage.Text = "Password Changed Successfully!";
}
else
{
lblMessage.ForeColor = System.Drawing.Color.Red;
lblMessage.Text = "Password Reset link has expired or is invalid";
}
}
private async Task <string> LoginAsync()
{
var authenticationBusiness = new AuthenticationBusiness();
string email = ConfigurationManager.AppSettings["email"];
string password = ConfigurationManager.AppSettings["password"];
var hash = await authenticationBusiness.LoginKucktrack(email, password, _httpClient);
var appLog = new EventLog("Application");
appLog.Source = "LumoTrack";
appLog.WriteEntry("Response of kucktrack :" + hash.Message);
return(hash.Data.Hash);
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
var allowedOrigin = context.OwinContext.Get <string>("as:clientAllowedOrigin");
if (allowedOrigin == null)
{
allowedOrigin = "*";
}
context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" });
UsuarioDTO user = new AuthenticationBusiness().FindUser(context.UserName, context.Password);
if (user == null)
{
context.SetError("invalid_grant", "The user name or password is incorrect.");
return;
}
var identity = new ClaimsIdentity(context.Options.AuthenticationType);
identity.AddClaim(new Claim("sub", context.UserName));
identity.AddClaim(new Claim("userId", user.Id.ToString()));
identity.AddClaim(new Claim("userName", user.Nome));
identity.AddClaim(new Claim("isAdmin", user.IsAdmin.ToString()));
var props = new AuthenticationProperties(new Dictionary <string, string>
{
{ "userName", user.Nome },
{ "isAdmin", user.Id.ToString() }
});
var ticket = new AuthenticationTicket(identity, props);
context.Validated(ticket);
}
public ActionResult Register(PersonVM model)
{
if (ModelState.IsValid)
{
UsernameValidation user = new UsernameValidation();
if (user.UsernameIsAvailable(model.Login) == true && model.Role == "Student")
{
AuthenticationBusiness student = new AuthenticationBusiness();
student.CreateNewStudent(model);
ViewBag.MessageSuccess = "Registration successful !";
return(RedirectToAction("Login"));
}
else if (user.UsernameIsAvailable(model.Login) == true && model.Role == "Instructor")
{
AuthenticationBusiness instructor = new AuthenticationBusiness();
instructor.CreateNewInstructor(model);
ViewBag.MessageSuccess = "Registration successful !";
return(RedirectToAction("Login"));
}
}
return(View());
}
public Guid CreateAuthenticationControl(Guid userId, AuthOrigin origin)
{
return(AuthenticationBusiness.CreateAuthenticationControl(userId, origin));
}
public AuthenticationController(AuthenticationBusiness authenticationBusiness)
{
_authenticateBusiness = authenticationBusiness;
}
public Menu()
{
authBusiness = new AuthenticationBusiness();
userBusiness = new UserBusiness();
}
public async Task ValidateToken(AuthenticationInformationEntity authInfo)
{
AuthenticationBusiness.ValidateToken(authInfo);
}
public SecurityController()
{
_userBusiness = new UserBusiness();
_authBusiness = new AuthenticationBusiness();
}
public void DeleteAuthentication(string userId, string token)
{
AuthenticationBusiness.DeleteAuthentication(userId, token);
}
