public RazorEmailResult SendAccountNameReminder(User model) { To.Add(model.Email); From = "*****@*****.**"; Subject = "Here's your missing Username"; return Email("SendAccountNameReminder", model); }
public RazorEmailResult SendAccountVerified(User model) { To.Add(model.Email); From = "*****@*****.**"; Subject = "Account Verification"; return Email("SendAccountVerified", model); }
public RazorEmailResult SendAccountDelete(User model) { To.Add(model.Email); From = "*****@*****.**"; Subject = "Delete Account"; return Email("SendAccountDelete", model); }
public RazorEmailResult SendChangeEmailRequestNotice(User model) { To.Add(model.Email); From = "*****@*****.**"; Subject = "Email Request Notice"; return Email("SendChangeEmailRequestNotice", model); }
public RazorEmailResult SendEmailChangedNotice(User model) { To.Add(model.Email); From = "*****@*****.**"; Subject = "Email Changed Notification"; return Email("SendEmailChangedNotice", model); }
private static string BuildUrl(User user, string action, string controller, object routeValues = null) { if (UrlHelper.RequestContext.HttpContext.Request.Url != null) { string scheme = UrlHelper.RequestContext.HttpContext.Request.Url.Scheme; return UrlHelper.Action(action, controller, routeValues, scheme); } return null; }
public virtual void SignIn(User user, bool isPersistant = false) { Tracing.Information(String.Format("[ClaimsBasedAuthenticationService.Signin] called: {0}", user.Username)); if (String.IsNullOrWhiteSpace(user.Username)) throw new ArgumentException("username"); // gather claims var claims = new List<Claim>(); foreach (UserClaim uc in user.Claims) claims.Add(new Claim(uc.Type, uc.Value)); if (!String.IsNullOrWhiteSpace(user.Email)) { claims.Insert(0, new Claim(ClaimTypes.Email, user.Email)); } claims.Insert(0, new Claim(ClaimTypes.AuthenticationMethod, AuthenticationMethods.Password)); claims.Insert(0, new Claim(ClaimTypes.AuthenticationInstant, DateTime.UtcNow.ToString("s"))); claims.Insert(0, new Claim(ClaimTypes.Name, user.Username)); claims.Insert(0, new Claim(ClaimTypes.NameIdentifier, user.Username)); // create principal/identity var id = new ClaimsIdentity(claims, "Forms"); var cp = new ClaimsPrincipal(id); // claims transform cp = FederatedAuthentication.FederationConfiguration.IdentityConfiguration.ClaimsAuthenticationManager.Authenticate(String.Empty, cp); // issue cookie var sam = FederatedAuthentication.SessionAuthenticationModule; if (sam == null) throw new Exception("SessionAuthenticationModule is not configured and it needs to be."); var token = new SessionSecurityToken(cp, isPersistant ? FormsAuthentication.Timeout : TimeSpan.FromMinutes(SessionHelpers.GetSessionTimeoutInMinutes)) { IsPersistent = isPersistant }; sam.WriteSessionTokenToCookie(token); Tracing.Verbose(String.Format("[ClaimsBasedAuthenticationService.Signin] cookie issued: {0}", claims.GetValue(ClaimTypes.NameIdentifier))); }
public void Seed(DataContext context) { var user = new User() { Id = 1, Email = "*****@*****.**", Username = "******", FirstName = "Rod", LastName = "Johnson", LastLogin = DateTime.UtcNow, Gender = Gender.Male, Address = "Admin address", PhoneNumber = "555-555-5555", IsLoginAllowed = true, IsAccountClosed = false, IsAccountVerified = true, Created = DateTime.UtcNow, Tenant = "default", // password is "admin" HashedPassword = "******", PasswordChanged = DateTime.UtcNow, FailedLoginCount = 0, Updated = DateTime.UtcNow }; user.Claims.Add(new UserClaim() { Type = ClaimTypes.Role, Value = "Admin" }); user.Claims.Add(new UserClaim() { Type = ClaimTypes.Role, Value = "Super Admin" }); context.Users.AddOrUpdate(user); context.SaveChanges(); }
public void SendAccountNameReminder(User user) { _controller.SendAccountNameReminder(user).Deliver(); }
public void SendAccountVerified(User user) { _controller.SendAccountVerified(user).Deliver(); }
public void SendChangeEmailRequestNotice(User user, string newEmail) { _controller.SendChangeEmailRequestNotice(user).Deliver(); }
public UserLoggedIn(User user) : base(user, "User Logged In") { }
public UserLoggedOut(User user) : base(user, "User Logged Out") { }
public UserCreated(User user, string loginUrl) : base(user, "User Created") { LoginUrl = loginUrl; }
public void SendPasswordChangeNotice(User user) { _controller.SendPasswordChangeNotice(user).Deliver(); }
public UserLockedOut(User user) { User = user; }
public RazorEmailResult SendPasswordChangeNotice(User model) { To.Add(model.Email); From = "*****@*****.**"; Subject = "Your Password has been updated"; return Email("SendPasswordChangeNotice", model); }
public MembershipEvent(MembershipEventCode code, User user) : base(code.GetDescription(), user, WebEventCodes.WebExtendedBase, (int)code) { _user = user; _culture = CultureInfo.CurrentCulture.Name; }
public void SendResetPassword(User user) { _controller.SendPasswordReset(user).Deliver(); }
public void SendAccountDelete(User user) { _controller.SendAccountDelete(user).Deliver(); }
protected internal virtual void DeleteAccount(User account) { if (_settings.AllowAccountDeletion || !account.IsAccountVerified) { Tracing.Verbose(String.Format("[UserAccountService.DeleteAccount] removing account record: {0}, {1}", account.Tenant, account.Username)); this.userRepository.Delete(account); } else { Tracing.Verbose(String.Format("[UserAccountService.DeleteAccount] marking account closed: {0}, {1}", account.Tenant, account.Username)); account.CloseAccount(); } using (var tx = new TransactionScope()) { this.userRepository.SaveOrUpdate(account); if (this.notificationService != null) { this.notificationService.SendAccountDelete(account); } tx.Complete(); } }
public virtual IValidationContainer<User> CreateAccount(string tenant, string username, string password, string email, string firstName, string lastName, string phone, string address) { Tracing.Information(String.Format("[UserAccountService.CreateAccount] called: {0}, {1}, {2}", tenant, username, email)); if (_settings.EmailIsUsername) { username = email; } if (!_settings.MultiTenant) { tenant = _settings.DefaultTenant; } if (String.IsNullOrWhiteSpace(tenant)) throw new ArgumentException("tenant"); if (String.IsNullOrWhiteSpace(username)) throw new ArgumentException("username"); if (String.IsNullOrWhiteSpace(password)) throw new ArgumentException("password"); if (String.IsNullOrWhiteSpace(email)) throw new ArgumentException("email"); if (String.IsNullOrWhiteSpace(email)) throw new ArgumentException("firstName"); if (String.IsNullOrWhiteSpace(email)) throw new ArgumentException("lastName"); if (String.IsNullOrWhiteSpace(email)) throw new ArgumentException("phone"); if (String.IsNullOrWhiteSpace(email)) throw new ArgumentException("address"); ValidatePassword(tenant, username, password); var validator = new EmailAddressAttribute(); if (!validator.IsValid(email)) { Tracing.Verbose(String.Format("[UserAccountService.CreateAccount] Email validation failed: {0}, {1}, {2}", tenant, username, email)); throw new ValidationException("Email is invalid."); } if (UsernameExists(tenant, username)) { Tracing.Verbose(String.Format("[UserAccountService.CreateAccount] Username already exists: {0}, {1}", tenant, username)); var msg = _settings.EmailIsUsername ? "Email" : "Username"; throw new ValidationException(msg + " already in use."); } if (EmailExists(tenant, email)) { Tracing.Verbose(String.Format("[UserAccountService.CreateAccount] Email already exists: {0}, {1}, {2}", tenant, username, email)); throw new ValidationException("Email already in use."); } var account = new User(tenant, username, password, email) { FirstName = firstName, LastName = lastName, Address = address, PhoneNumber = phone }; var validation = account.GetValidationContainer(); if (!validation.IsValid) return validation; this.userRepository.SaveOrUpdate(account); if (this.notificationService != null) { if (_settings.RequireAccountVerification) { this.notificationService.SendAccountCreate(account); } else { this.notificationService.SendAccountVerified(account); } } _unitOfWork.Commit(); return validation; }
public void SendEmailChangedNotice(User user, string oldEmail) { _controller.SendEmailChangedNotice(user).Deliver(); }
public RazorEmailResult SendPasswordReset(User model) { To.Add(model.Email); From = "*****@*****.**"; Subject = "Password Reset"; return Email("SendPasswordReset", model); }
public IValidationContainer<User> SaveOrUpdate(User user) { var container = user.GetValidationContainer(); if (!container.IsValid) return container; userRepository.SaveOrUpdate(user); _unitOfWork.Commit(); return container; }
protected internal virtual IValidationContainer<User> Authenticate(User account, string password, int failedLoginCount, TimeSpan lockoutDuration) { var container = account.GetValidationContainer(); if (!container.IsValid) return container; var result = account.Authenticate(password, failedLoginCount, lockoutDuration); if (!result) container.ValidationErrors.Add("", new List<string>() { "Unable to authenticate user" }); this.userRepository.SaveOrUpdate(account); _unitOfWork.Commit(); Tracing.Verbose(String.Format("[UserAccountService.Authenticate] authentication outcome: {0}, {1}, {2}", account.Tenant, account.Username, result ? "Successful Login" : "Failed Login")); return container; }
protected UserActivity(User user, string friendlyName) { FriendlyName = friendlyName; User = user; }