private UserBE SetContextAndAuthenticate(DreamMessage request, uint serviceid, bool autoCreateExternalUser, bool allowAnon, bool touchUser, out bool altPassword)
{
UserBE user = AuthBL.Authenticate(DreamContext.Current, request, serviceid, autoCreateExternalUser, allowAnon, out altPassword);
// check if we should touch the user
bool update = false;
if (touchUser)
{
update = true;
}
else if (user.UserActive)
{
double?updateTimespan = DekiContext.Current.Instance.StatsUpdateUserOnAccess;
if (updateTimespan.HasValue && (user.Touched.AddSeconds(updateTimespan.Value) <= DateTime.UtcNow))
{
update = true;
}
}
// update user's last logged time column
if (update)
{
user = UserBL.UpdateUserTimestamp(user);
}
DekiContext.Current.User = user;
// check that a user token is set (it might not be set if a user logs-in directly using HTTP authentication)
if (!UserBL.IsAnonymous(user) && (DekiContext.Current.AuthToken == null))
{
DekiContext.Current.AuthToken = AuthBL.CreateAuthTokenForUser(user);
}
BanningBL.PerformBanCheckForCurrentUser();
return(user);
}
public Yield PostUserAuth(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
uint serviceId = context.GetParam <uint>("authprovider", 0);
bool altPassword;
//This will internally fail with a 501 response if credentials are invalid.
//Anonymous accounts (no credentials/authtoken) are not allowed -> 401
UserBE u = SetContextAndAuthenticate(request, serviceId, context.Verb == Verb.POST, false, true, out altPassword);
PermissionsBL.CheckUserAllowed(u, Permissions.LOGIN);
string token = AuthBL.CreateAuthTokenForUser(u);
try {
PageBL.CreateUserHomePage(DekiContext.Current.User);
} catch { }
XUri redirectUri = XUri.TryParse(context.GetParam("redirect", null));
DreamMessage ret = BuildSetAuthTokenResponse(token, redirectUri);
DekiContext.Current.Instance.EventSink.UserLogin(DekiContext.Current.Now, DekiContext.Current.User);
//TODO Max: Set a response header or status to indicate that an alt password was used.
response.Return(ret);
yield break;
}
private static string CreatePrinceHtml(XDoc content)
{
// use authtoken for embedded images
string authtoken = AuthBL.CreateAuthTokenForUser(DekiContext.Current.User);
foreach (XDoc img in content["//img"])
{
string src = img["@src"].AsText;
if (StringUtil.StartsWithInvariant(src, "/"))
{
src = DekiContext.Current.UiUri.Uri.SchemeHostPort + src;
}
if (StringUtil.StartsWithInvariantIgnoreCase(src, DekiContext.Current.UiUri.Uri.SchemeHostPort + "/") ||
StringUtil.StartsWithInvariantIgnoreCase(src, Utils.MKS_PATH))
{
img["@src"].ReplaceValue(new XUri(src).With("authtoken", authtoken));
}
}
// prepend doctype so prince uses xhtml parser
// need to use strings instead of XDoc since XDoc doesn't allow you to set a doctype
string doctype = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">";
return(doctype + content.ToXHtml());
}
public override async Task GrantResourceOwnerCredentials(
OAuthGrantResourceOwnerCredentialsContext context)
{
context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" });
AuthBL repo = new AuthBL();
IdentityUser user = repo.Find(context.UserName, context.Password);
if (user == null)
{
context.SetError("Error User Pass Not valid");
}
ClaimsIdentity claims = new ClaimsIdentity(context.Options.AuthenticationType);
claims.AddClaim(new Claim("Name", user.UserName));
claims.AddClaim(new Claim(ClaimTypes.Role, repo.getRole(user)));
//claims.AddClaim(new Claim(ClaimTypes.Role, "Admin"));
//claims.AddClaim(new Claim(ClaimTypes.Role, "Driver"));
//claims.AddClaim(new Claim(ClaimTypes.Role, "Client"));
//claims.AddClaim(new Claim("Role", "Admin"));
//claims.AddClaim(new Claim("Role", "User"));
context.Validated(claims);
//check user usin gLAyer
//create toke
//error
//context.UserName;
//context.Password
}
public ActionResult Logout()
{
AuthBL auth = new AuthBL();
auth.Logout();
return(RedirectToAction("Login"));
}
public IHttpActionResult RegistrationDriver(ApplicantDto userdto)
{
AuthBL repos = new AuthBL();
if (ModelState.IsValid == false)
{
return(BadRequest());
}
IdentityResult result = repos.CreateDriver(userdto);
if (result.Succeeded)
{
using (HttpClient httpClient = new HttpClient())
{
Dictionary <string, string> tokenDetails = null;
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:4700/");
var login = new Dictionary <string, string>
{
{ "grant_type", "password" },
{ "username", userdto.Email },
{ "password", userdto.Password },
};
var response = client.PostAsync("Token", new FormUrlEncodedContent(login)).Result;
if (response.IsSuccessStatusCode)
{
tokenDetails = JsonConvert.DeserializeObject <Dictionary <string, string> >(response.Content.ReadAsStringAsync().Result);
if (tokenDetails != null && tokenDetails.Any())
{
var tokenNo = tokenDetails.FirstOrDefault().Value;
IdentityUser user = repos.Find(userdto.Email, userdto.Password);
AdminController applicantobj = new AdminController();
NewApplicant applicant = applicantobj.getApplicant(userdto.NationalID);
Driver driver = new Driver
{
UserID = user.Id,
NationalID = applicant.NationalID,
Rate = 0,
numberOfTrips = 0,
AvgRate = 0.0,
};
applicant.Status = NewApplicantstatus.Accepted;
context.Entry(applicant).State = EntityState.Modified;
context.SaveChanges();
context.Drivers.Add(driver);
context.SaveChanges();
return(Ok());
}
}
}
}
return(BadRequest());
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" });
//Check User
AuthBL rep = new AuthBL();
IdentityUser user = rep.FindUser(context.UserName, context.Password);
//create toke
if (user == null)
{
context.SetError("User Not Found");
}
else
{
ClaimsIdentity identity = new ClaimsIdentity(context.Options.AuthenticationType);
identity.AddClaim(new Claim("UserName", context.UserName));
if (rep.FinduserRole(context.UserName, context.Password) == "Admin")
{
identity.AddClaim(new Claim(identity.RoleClaimType, "Admin"));
}
else if (rep.FinduserRole(context.UserName, context.Password) == "User")
{
identity.AddClaim(new Claim(identity.RoleClaimType, "User"));
}
context.Validated(identity);
}
}
public IHttpActionResult AddUser(UserMdel newuser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
AuthBL AuthBusLayer = new AuthBL();
ApplicationUser OldUser = AuthBusLayer.FindUser(newuser.UserName, newuser.Password);
if (OldUser != null)
{
return(BadRequest("Exist Befor"));
}
IdentityResult res = AuthBusLayer.CreateUser(newuser);
if (res.Succeeded)
{
return(Ok("User"));
}
string Errors = "";
foreach (var item in res.Errors)
{
Errors += item + " ";
}
return(BadRequest(Errors));
}
private void btnIngresar_Click(object sender, EventArgs e)
{
AuthBL authBL = new AuthBL();
AuthBE authBE = new AuthBE(txtUser.Text.Trim(), txtPassword.Text.Trim());
tries += 1;
try {
if (authBL.Authenticate(authBE) == true)
{
frmMain frmmain = new frmMain();
frmLogin frmlogin = new frmLogin();
frmmain.Show();
this.Hide();
//frmlogin.Close();
}
else
{
MessageBox.Show(this, "Error de autenticación ", "Atención", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
} catch (Exception ex) {
if (tries == 3)
{
MessageBox.Show(this, "Ya no tiene mas intentos", "Atención", MessageBoxButtons.OK, MessageBoxIcon.Error);
Application.Exit();
}
MessageBox.Show(this, "Error de autenticación: " + ex.Message, "Atención", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public IHttpActionResult post(UserDto User)
{
AuthBL repos = new AuthBL();
IdentityResult MyUser = repos.Create(User);
if (MyUser.Succeeded)
{
return(Created("", "Created"));
}
else
{
return(BadRequest(MyUser.Errors.FirstOrDefault()));
}
}
private void btnGuardar_Click(object sender, EventArgs e)
{
AuthBE authBE = new AuthBE(txtUsuario.Text.Trim(), txtPwd.Text.Trim(), int.Parse(cboEmpleado.SelectedValue.ToString()), chkActivo.Checked);
AuthBL authBL = new AuthBL();
if (authBL.CredentialNew(authBE) == true)
{
MessageBox.Show(this, "Se agrego el usuario correctamente", "Alerta", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show(this, "Ocurrió un error al agregar el usuario ", "Alerta", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private AuthResponseModel AuthenticateUser(AuthRequestModel login)
{
AuthResponseModel user = null;
var authBL = new AuthBL();
var authenticateResult = authBL.AuthenticateUser(login);
if (!authenticateResult.Status)
{
return(user);
}
user = authenticateResult.Value;
return(user);
}
protected void Page_Load(object sender, EventArgs e)
{
AuthBL abl = new AuthBL();
if (abl.IsAvailable() == true)
{
return;
}
else
{
lblMensaje.Text = "No hay conexión a la base de datos. Comuníquese con el encargado de IT";
btnIngresar.Enabled = false;
}
}
//public override async Task GrantResourceOwnerCredentials(
// OAuthGrantResourceOwnerCredentialsContext context)
//{
// context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" });
// AuthBL repo = new AuthBL();
// IdentityUser user = repo.Find(context.UserName, context.Password);
// if (user == null)
// {
// context.SetError("Error User Pass Not valid");
// }
// ClaimsIdentity claims = new ClaimsIdentity(context.Options.AuthenticationType);
// claims.AddClaim(new Claim("Name", user.UserName));
// claims.AddClaim(new Claim("Role", "Admin"));
// context.Validated(claims);
//}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" });
AuthBL repo = new AuthBL();
IdentityUser user = repo.Find(context.UserName, context.Password);
var identity = new ClaimsIdentity(context.Options.AuthenticationType);
identity.AddClaim(new Claim("Name", context.UserName));
identity.AddClaim(new Claim(ClaimTypes.Role, "User"));
// identity.AddClaim(new Claim("Name", user.UserName));
identity.AddClaim(new Claim("Role", "Admin"));
context.Validated(identity);
}
private void Login_Load(object sender, EventArgs e)
{
AuthBL abl = new AuthBL();
if (abl.IsAvailable() == true)
{
return;
}
else
{
MessageBox.Show(this, "No hay conexión a la base de datos. Comuníquese con el encargado de IT", "Alerta",
MessageBoxButtons.OK, MessageBoxIcon.Error);
this.Close();
}
}
public IHttpActionResult GetUSerID(LoginModel user)
{
AuthBL rep = new AuthBL();
ApplicationUser res = rep.FindUser(user.UserName, user.Password);
if (res != null)
{
if (res.IsDeleted == false)
{
return(Ok(res.Id));
}
}
return(NotFound());
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
AuthBL authBL = new AuthBL();
var user = authBL.ValidateUser(context.UserName, context.Password);
if (user == null)
{
context.SetError("invalid_grant", "Username or Password is invalid!");
return;
}
var identity = new ClaimsIdentity(context.Options.AuthenticationType);
identity.AddClaim(new Claim(ClaimTypes.Name, user.Username));
context.Validated(identity);
}
//you must install identity owin and owin self owin hosting
public IHttpActionResult Post(UserDTO userdto)
{
if (ModelState.IsValid == false)
{
return(BadRequest(ModelState));
}
AuthBL repos = new AuthBL();
IdentityResult result = repos.Create(userdto);
if (result.Succeeded)
{
return(Created("", "Created"));
}
return(BadRequest(result.Errors.FirstOrDefault()));
}
public async Task <ActionResult> Register(UserVM user)
{
if (ModelState.IsValid)
{
AuthBL auth = new AuthBL();
ErrorResponseVM response = await auth.RegisterAsync(user);
if (response.IsValid)
{
return(RedirectToAction("Login"));
}
else
{
ViewData["Errors"] = response.Errors;
}
}
return(View());
}
public async Task <ActionResult> Login(LoginVM user)
{
if (ModelState.IsValid)
{
AuthBL auth = new AuthBL();
bool isSuccess = await auth.LoginAsync(user);
if (isSuccess)
{
return(RedirectToAction("Home", "Car"));
}
else
{
ViewBag.Error = "Username or Password is incorrect!";
}
}
return(View());
}
public IHttpActionResult UpdateStudent(UserMdel user)
{
AuthBL rep = new AuthBL();
ApplicationUser res = context.Users.Where(u => u.Id == user.Id).FirstOrDefault();
if (res != null)
{
res.Name = user.Name;
res.Address = user.Address;
res.UserName = user.UserName;
res.Department_ID = user.Department_ID;
res.IsDeleted = false;
context.SaveChanges();
return(Ok());
}
return(NotFound());
}
public IActionResult Index()
{
ICollection <Login> logins = AuthBL.GetAllLoginsSync(_authRepository);
if (logins.Any())
{
return(View(new LoginsViewModel {
Logins = logins.ToList()
}));
}
List <Login> loginsFromJson = new GetLoginsFromJson("logins.json").Execute();
AuthBL.AddManyLoginsSync(loginsFromJson, _authRepository);
logins = loginsFromJson.ToList();
return(View(new LoginsViewModel {
Logins = logins.ToList()
}));
}
public IActionResult Login([FromForm] Login loginInput)
{
if (ModelState.IsValid)
{
Serilog.Log.Debug($"Login Attempt - Session: {HttpContext.Session.Id} - IP: {_accessor.HttpContext.Connection.RemoteIpAddress} - {loginInput}");
LoginResponse loginResponse = AuthBL.AuthenticateUser(loginInput, _authRepository, _configuration);
if (loginResponse.success)
{
Serilog.Log.Debug($"Login Success - Session: {HttpContext.Session.Id} - IP: {_accessor.HttpContext.Connection.RemoteIpAddress} - {loginInput}");
HttpContext.Session.SetString("JWToken", loginResponse.token); //
return(Redirect("~/"));
}
else
{
return(RedirectToAction("Login", "Auth", "Invalid"));
}
}
else
{
return(BadRequest("Invalid Login Model"));
}
}
protected void btnIngresar_Click(object sender, EventArgs e)
{
AuthBL authBL = new AuthBL();
AuthBE authBE = new AuthBE(txtUsuario.Text.Trim(), txtPassword.Text.Trim());
tries += 1;
try {
if (authBL.Authenticate(authBE) == true)
{
Response.Redirect("Overview.aspx");
}
else
{
lblMensaje.Text = "Credenciales incorrectas, intente nuevamente.";
}
} catch (Exception ex) {
if (tries == 3)
{
Response.Redirect("Error.aspx");
}
lblMensaje.Text = ex.Message;
}
}
public static bool AssignPermissions(List <Module> modules)
{
return(AuthBL.AssignPermissions(modules));
}
public static List <Operation> getOperations(int branchId)
{
return(AuthBL.getOperations(branchId));
}
public static List <Module> GetModulesByRole(int roleId, int branchId)
{
return(AuthBL.GetModulesByRole(roleId, branchId));
}
public static int InsertOrUpdateUserGroup(UserGroup group)
{
return(AuthBL.InsertOrUpdateUserGroup(group));
}
public static bool DeleteUserGroup(int groupId)
{
return(AuthBL.DeleteUserGroup(groupId));
}
/// <summary>
///
/// </summary>
/// <param name="branchId"></param>
/// <returns></returns>
public static List <UserGroup> GetUserGroups(int branchId)
{
return(AuthBL.GetUserGroups(branchId));
}
