public async Task <IActionResult> Login([FromBody] LoginViewModel user)
{
IActionResult _result = new ObjectResult(false);
GenericResult _authenticationResult = null;
try
{
MembershipContext _userContext = _membershipService.ValidateUser(user.Username, user.Password);
if (_userContext.User != null)
{
IEnumerable <Role> _roles = _userRepository.GetUserRoles(user.Username);
List <Claim> _claims = new List <Claim>();
foreach (Role role in _roles)
{
Claim _claim = new Claim(ClaimTypes.Role, "Admin", ClaimValueTypes.String, user.Username);
_claims.Add(_claim);
}
await HttpContext.Authentication.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme,
new ClaimsPrincipal(new ClaimsIdentity(_claims, CookieAuthenticationDefaults.AuthenticationScheme)),
new Microsoft.AspNetCore.Http.Authentication.AuthenticationProperties {
IsPersistent = user.RememberMe
});
_authenticationResult = new GenericResult()
{
Succeeded = true,
Message = "Authentication succeeded"
};
}
else
{
_authenticationResult = new GenericResult()
{
Succeeded = false,
Message = "Authentication failed"
};
}
}
catch (Exception ex)
{
_authenticationResult = new GenericResult()
{
Succeeded = false,
Message = ex.Message
};
_loggingRepository.Add(new Error()
{
Message = ex.Message, StackTrace = ex.StackTrace, DateCreated = DateTime.Now
});
_loggingRepository.Commit();
}
_result = new ObjectResult(_authenticationResult);
return(_result);
}
public void TriggerTheDbCreationTest()
{
Application app = null;
using (MembershipContext ctx = new MembershipContext("membershipDb"))
{
app = ctx.Applications.Find(Guid.Empty);
}
Assert.IsNull(app);
}
public static void SetBackupDetails(IEnumerable <string> cloudDirectories, int intervalMins)
{
using (var a = new MembershipContext())
{
SetBackupPaths(cloudDirectories, a);
a.BackupDataSet.First().BackupIntervalMinutes = intervalMins;
a.SaveChanges();
}
}
private static void TestMembership()
{
EnableTracing();
var context = new MembershipContext("Claims");
var unitOfWork = new MembershipUnitOfWork(context);
var role = unitOfWork.Roles.Create();
unitOfWork.Roles.Add(role);
role.Name = "Admin";
unitOfWork.Commit();
var roles = unitOfWork.Roles.FindAll(r => r.Name == "Test");
roles.ToList().ForEach(r => Console.WriteLine(r.Name));
role.Name = "Test";
unitOfWork.Commit();
Console.WriteLine("Done");
var provider = new MembershipService(unitOfWork);
string password;
var user = provider.CreateUser("christopher.nystrom", out password);
unitOfWork.Commit();
Console.WriteLine(password);
Console.WriteLine("User created");
var validate = provider.ValidateUser(user.Email, password);
Console.WriteLine(validate);
var foundUser = provider.GetUser("christopher.nystrom");
Console.WriteLine(foundUser.Email);
foundUser = provider.GetUser("john.larsson");
if (foundUser != null)
{
Console.WriteLine(foundUser.Email);
}
else
{
Console.WriteLine("John didn't exist");
}
}
public async Task <ActionResult> UserDetails(string id)
{
if (string.IsNullOrEmpty(id))
{
id = User.Identity.GetUserId();
}
var m = await MembershipContext.GetUserDetails(id);
return(View(m));
}
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
IEnumerable <string> authHeaderValues = null;
request.Headers.TryGetValues("Authorization", out authHeaderValues);
if (authHeaderValues == null)
{
return(base.SendAsync(request, cancellationToken)); //next IMessageHandler
}
var tokens = authHeaderValues.FirstOrDefault(); //Basic amVyZW15eWFuZzoxMjM0NTY=
tokens = tokens.Replace("Basic", "").Trim();
if (!string.IsNullOrEmpty(tokens))
{
byte[] data = Convert.FromBase64String(tokens);
string decodeString = Encoding.UTF8.GetString(data);
string[] tokensValues = decodeString.Split(':');
string userUame = tokensValues[0];
string hashPassword = tokensValues[1];
//通过DI（WebAPI DependencyScope）获取认证服务
IDependencyScope dependencyScope = request.GetDependencyScope();
var accountAppService = (AccountAppService)dependencyScope.GetService(typeof(AccountAppService));
MembershipContext membership = accountAppService.Login(new LoginInputDto
{
Username = userUame,
Password = hashPassword
});
if (membership.IsAuthenticated)
{
//创建认证Token
var identity = new GenericIdentity(membership.UserName);
IPrincipal principal = new GenericPrincipal(identity, membership.Roles);
Thread.CurrentPrincipal = principal;
HttpContext.Current.User = principal;
}
else
{
var response = new HttpResponseMessage(HttpStatusCode.Forbidden);
var tsc = new TaskCompletionSource <HttpResponseMessage>();
tsc.SetResult(response);
return(tsc.Task); //401 result
}
}
else
{
var response = new HttpResponseMessage(HttpStatusCode.Forbidden);
var tsc = new TaskCompletionSource <HttpResponseMessage>();
tsc.SetResult(response);
return(tsc.Task); //403 result
}
return(base.SendAsync(request, cancellationToken)); //next IMessageHandler
}
private MembershipContext CreateMembershipContext(User user)
{
var membershipContext = new MembershipContext {
User = user
};
var identity = new GenericIdentity(user.Email);
membershipContext.Principal = new GenericPrincipal(identity, new[] { user.Role.Title });
return(membershipContext);
}
public MembershipContext ValidateUser(string username, string password)
{
var membershipCtx = new MembershipContext();
var user = _userRepository.GetSingleByUsername(username);
if (user != null && isUserValid(user, password))
{
var userRoles = GetUserRoles(user.Username); membershipCtx.User = user;
var identity = new GenericIdentity(user.Username);
membershipCtx.Principal = new GenericPrincipal(identity, userRoles.Select(x => x.Name).ToArray());
}
return membershipCtx;
}
public async static void Initialize(MembershipContext context,
UserManager <ApplicationUser> userManager,
RoleManager <ApplicationRole> roleManager)
//UserManager<ApplicationUser> userManager)
{
// Do any initialization code here for the DB.
// Can include populate lookups, data based configurations etc.
//SeedData seed_data;
PasswordHashService p_hasher = new PasswordHashService();
SeedData seed_data = new SeedData(context, p_hasher, userManager, roleManager); //, roleManager, userManager);
// Get counts if users.
Task <int> numUsersResult = SumUsers(context);
int numUsers = await SumUsers(context);
// Get counts of data. Do this asynchronously.
Task <int> numMembersResult = SumMembers(context);
int numMembers = await SumMembers(context);
Task <int> numMemberDetailsResult = SumMemberDetails(context);
int numMemberDetails = await SumMemberDetails(context);
Task <int> numMemberAddressResult = SumMemberAddresses(context);
int numMemberAddresses = await SumMemberAddresses(context);
// Full rebuild user authentication data - If no User data then regenerate User/Role records.
if (numUsers == 0)
{
// Create initial users and roles.
//seed_data.CreateUsersAsync();
seed_data.CreateUsers();
}
// Full rebuild data - If no Member data then regenerate Member base table and all child tables.
if (numMembers == 0)
{
// Add 50 random members to database.
seed_data.GenerateMembers(50);
}
// If Member base table exists and child tables don't then generate those.
if ((numMembers > 0) && (numMemberDetails == 0))
{
seed_data.GenerateMemberDetails();
}
// If Member base table exists and child tables don't then generate those.
if ((numMembers > 0) && (numMemberAddresses == 0))
{
seed_data.GenerateMemberAddresses();
}
}
public MembershipContext ValidateUser(string username, string password)
{
var membershipCtx = new MembershipContext();
var user = _userRepository.GetSingleByUsername(username);
if (user != null && isUserValid(user, password))
{
var userRoles = GetUserRoles(username);
membershipCtx.User = user;
var identity = new GenericIdentity(user.Username);
membershipCtx.Principal = new GenericPrincipal(identity, userRoles.Select(ur => ur.Name).ToArray());
}
return(membershipCtx);
}
//POST api/values
public void Post([FromBody]User value)
{
var validator = new UserValidator();
if (!validator.Validate(value)){
{
return;
}
using (var db = new MembershipContext())
{
value = new User();
db.Users.Add(value);
db.SaveChanges();
}
}
/// <summary>
/// Checks user impersonation settings.
/// </summary>
private bool EnsureImpersonation()
{
var userIsImpersonated = MembershipContext.CurrentUserIsImpersonated();
// Show impersonate button for global admin only or impersonated user
if (CookieHelper.AllowCookies && (MembershipContext.AuthenticatedUser.CheckPrivilegeLevel(UserPrivilegeLevelEnum.Admin) || userIsImpersonated))
{
lnkUsers.Visible = true;
lnkUsers.OnClientClick = ucUsers.GetSelectionDialogScript();
// Show all users except global administrators and public user, in CMSDesk show only site users
ucUsers.WhereCondition = GetImpersonateWhereCondition().ToString(true);
// Script for open uniselector modal dialog
string impersonateScript = "function userImpersonateShowDialog () {US_SelectionDialog_" + ucUsers.ClientID + "()}";
ScriptHelper.RegisterClientScriptBlock(this, typeof(string), "ImpersonateContextMenu", ScriptHelper.GetScript(impersonateScript));
string userName = HTMLHelper.HTMLDecode(ValidationHelper.GetString(ucUsers.Value, String.Empty));
if (userName != String.Empty)
{
// Get selected user info
UserInfo iui = UserInfoProvider.GetUserInfo(userName);
if (!iui.CheckPrivilegeLevel(UserPrivilegeLevelEnum.Admin))
{
// Indicates whether user will be able to continue in the administration interface
bool keepAdimUI = iui.CheckPrivilegeLevel(UserPrivilegeLevelEnum.Editor, SiteContext.CurrentSiteName);
AuthenticationHelper.ImpersonateUser(iui, null, !keepAdimUI);
if (keepAdimUI)
{
PortalScriptHelper.RegisterAdminRedirectScript(Page);
}
}
}
// Set visibility of Cancel impersonation item in menu
plcCancelImpersonate.Visible = userIsImpersonated;
// Hide impersonate action in menu if user is already impersonated
plcImpersonate.Visible = !plcCancelImpersonate.Visible;
return(true);
}
// Hide impersonate action in menu
plcImpersonate.Visible = false;
plcCancelImpersonate.Visible = false;
return(false);
}
public MembershipContext ValidateUser(string username, string password)
{
var membershipContext = new MembershipContext(username);
var user = this._userRepository.GetSingleByUsername(username);
if (user != null && isUserValid(user, password))
{
membershipContext.IsAuthenticated = true;
membershipContext.UserId = user.ID;
membershipContext.Email = user.Email;
membershipContext.Roles = user.Roles.Select(r => r.Name.ToString()).Distinct().ToArray();
}
return(membershipContext);
}
public static Exception TestConnection()
{
try
{
using (var a = new MembershipContext())
{
a.CloudDirectories.Any();
}
}
catch (Exception ex)
{
return(ex);
}
return(null);
}
public AccountDataController(
MembershipContext membershipContext,
SignInManager <ApplicationUser> signInManager,
UserManager <ApplicationUser> userManager,
RoleManager <ApplicationRole> roleManager,
//IAccountDataRequest accountdatarequest,
IMapper objectmapper)
{
_membershipContext = membershipContext;
_signinmanager = signInManager;
_usermanager = userManager;
_roleManager = roleManager;
//_accountdatarequest = accountdatarequest;
_objectmapper = objectmapper;
}
private void GetMembers()
{
using (MembershipContext db = new MembershipContext())
{
try
{
var Members = (from allMembers in db.Members select allMembers);
MemberGridView.DataSource = Members.ToList();
MemberGridView.DataBind();
}
catch
{
}
}
}
public EditMemberViewModel()
{
_memberContext = ContextFactory.GetTeamContext();
_userContext = ContextFactory.GetUserRegistrationContext();
_countryContext = ContextFactory.GetCountryContext();
_membershipContext = ContextFactory.GetMembershipContext();
_saveChangesCommand = new RelayCommand( OnSaveChanges );
_changePasswordCommand = new RelayCommand( OnChangePassword );
statusTimer = new DispatcherTimer();
statusTimer.Interval = new TimeSpan( 0, 0, 0, 3 );
statusTimer.Tick += new EventHandler( OnTimerTick );
IsStatusVisible = Visibility.Collapsed;
IsLoggedIn = true;
//LoadData(id);
UpdateForUsersRole();
}
public MembershipContext ValidateUser(string username, string password)
{
var membershipContext = new MembershipContext();
var existingUser = _repository.GetSingle <Entities.DatabaseEntities.User>(u => u.Username == username, u => u.Roles);
if (existingUser != null && IsPasswordValid(password, existingUser.HashedPassword))
{
membershipContext.User = _mapper.Map <Entities.ServicesEntities.User>(existingUser);
var identity = new GenericIdentity(existingUser.Username);
membershipContext.Principal = new GenericPrincipal(identity, existingUser.Roles.Select(r => r.Name).ToArray());
}
return(membershipContext);
}
public MembershipContext ValidateUser(string userName, string password)
{
var membershipContext = new MembershipContext();
var user = _userRepository.GetSingleByUserName(userName);
if (null != user && IsUserValid(user, password))
{
var roles = GetUserRoles(userName);
membershipContext.User = user;
var userIdenity = new GenericIdentity(userName);
membershipContext.Principal = new GenericPrincipal(userIdenity, roles.Select(s => s.Name).ToArray());
}
return(membershipContext);
}
private async Task <IEnumerable <TypeInfo> > GetListOfControllersAsync(MembershipContext membershipContext, IAuthorizationService authorizer, int?groupId = null)
{
ClaimsPrincipal principal = membershipContext.Principal;
if (groupId.HasValue)
{
// If groupId is present, then uses that's roles for authorize, otherwise using real principal's roles
principal = await CreateFakePrincipal(membershipContext, groupId);
if (principal == null)
{
throw new ArgumentOutOfRangeException(nameof(principal));
}
}
var allowedList = new List <TypeInfo>();
var controllersList = authorizerAdapter.GetControllers <Controller>("Index", "IndexAsync");
foreach (var type in controllersList)
{
var method = type.GetMethod("Index", BindingFlags.Public | BindingFlags.Instance)
?? type.GetMethod("IndexAsync", BindingFlags.Public | BindingFlags.Instance);
if (method != null)
{
var authorizeAttribute = method.GetCustomAttribute <AuthorizeAttribute>(true);
if (authorizeAttribute != null)
{
if (string.IsNullOrWhiteSpace(authorizeAttribute.ActiveAuthenticationSchemes) || string.Equals(authorizeAttribute.ActiveAuthenticationSchemes, membershipContext.Identity.AuthenticationType))
{
var allow = await authorizer.AuthorizeAsync(principal, authorizeAttribute.Policy);
if (allow)
{
allowedList.Add(type.GetTypeInfo());
}
}
}
else
{
allowedList.Add(type.GetTypeInfo());
}
}
}
return(allowedList);
}
public async Task <IActionResult> AccountUserLogin([FromBody] UserCredentialModel user)
{
ActionResult _result = new ObjectResult(false);
BaseResponse _authenticationResponse = null;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
MembershipContext _membershipContext = _userService.ValidateUser(user.Username, user.Password);
if (_membershipContext.User != null)
{
// generate Json Web Token
string token = GenerateToken(user.Username);
_authenticationResponse = new BaseResponse()
{
Succeeded = true,
Message = token
};
}
else
{
_authenticationResponse = new BaseResponse()
{
Succeeded = false,
Message = "Authentication failed"
};
}
}
catch (Exception ex)
{
_authenticationResponse = new BaseResponse()
{
Succeeded = false,
Message = ex.Message
};
}
_result = new ObjectResult(_authenticationResponse);
return(_result);
}
public MembershipContext ValidateUser(string username, string password)
{
var membershipCtx = new MembershipContext();
var newuser = GetSingleByUsername(username);
if (newuser != null && isUserValid(newuser, password))
{
var userRoles = GetUserRoles(newuser.username);
membershipCtx.objuser = newuser;
var identity = new GenericIdentity(newuser.username);
membershipCtx.Principal = new GenericPrincipal(
identity,
userRoles.Select(x => x.description).ToArray());
}
return(membershipCtx);
}
public JwtProvider(
RequestDelegate next,
MembershipContext dbContext,
UserManager <ApplicationUser> userManager,
RoleManager <ApplicationRole> roleManager,
SignInManager <ApplicationUser> signInManager)
{
_next = next;
// Instantiate JWT-related members
TokenExpiration = TimeSpan.FromMinutes(86400);
SigningCredentials = new SigningCredentials(SecurityKey, SecurityAlgorithms.HmacSha256);
// Instantiate through Dependency Injection
DbContext = dbContext;
UserManager = userManager;
SignInManager = signInManager;
RoleManager = roleManager;
}
public HttpResponseMessage Login(HttpRequestMessage request, LoginViewModel viewModel)
{
var httpResponse = CreateHttpResponse(request, () =>
{
HttpResponseMessage response;
if (ModelState.IsValid)
{
MembershipContext userContext = _membershipService.ValidateUser(viewModel.Username, viewModel.Password);
response = request.CreateResponse(HttpStatusCode.OK, userContext.User != null ? new { success = true } : new { success = false });
}
else
{
response = request.CreateResponse(HttpStatusCode.OK, new { success = false });
}
return(response);
});
return(httpResponse);
}
public MembershipContext ValidateUser(string username, string password)
{
var membershipCtx = new MembershipContext();
var user = GetUserByEmail(username);
if (user != null && IsUserValid(user, password))
{
var userRoles = GetUserRoles(user.EmailAddress);
membershipCtx.EmplonomyUser = user;
var identity = new GenericIdentity(user.EmailAddress);
membershipCtx.Principal = new GenericPrincipal(
identity,
userRoles.Select(x => x.Name).ToArray());
}
return(membershipCtx);
}
public MembershipContext ValidateUser(string username, string password)
{
var membershipCtx = new MembershipContext();
var user = this._authenticationContext.Users.Single(x => x.Username == username); //_userRepository.GetSingleByUsername(username);
if (user != null && this.AuthenticateUser(username, password, UserType.User) > 0)
{
//var userRoles = GetUserRoles(user.Username);
membershipCtx.User = user;
var identity = new GenericIdentity(user.Username);
membershipCtx.Principal = new GenericPrincipal(
identity,
new string[] { "User" });
}
return(membershipCtx);
}
public HttpResponseMessage ChangePassword(HttpRequestMessage request, RegistrationVM userVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors).Select(m => m.ErrorMessage).ToArray());
}
else
{
MembershipContext _userContext = _membershipService.ValidateUser(userVM.Username, userVM.OldPassword);
if (_userContext.User != null)
{
var _user = _membershipService.UpdateUser(userVM.Username, userVM.Email, userVM.Password);
if (_user != null && _user.Item1 != null)
{
response = request.CreateResponse(HttpStatusCode.OK,
new
{
message = _user.Item2,
success = true,
role = _user.Item1.UserRoles.FirstOrDefault().Role.Name,
email = _user.Item1.Email
});
}
else
{
response = request.CreateResponse(HttpStatusCode.OK, new { message = _user.Item2, success = false });
}
}
else
{
response = request.CreateResponse(HttpStatusCode.OK, new { message = "Old Password is incorrect", success = false });
}
}
return response;
}));
}
public MembershipContext ValidateUser(string email, string senha, int perfilModulo)
{
var membershipCtx = new MembershipContext();
var usuario = _usuarioRep.GetSingleByEmail(email, perfilModulo);
if (usuario != null && isUserValid(usuario, senha))
{
membershipCtx.Usuario = usuario;
string[] perfil = { usuario.Perfil.DescPerfil };
var identity = new GenericIdentity(usuario.UsuarioEmail);
identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, usuario.Id.ToString(), ClaimValueTypes.String));
membershipCtx.Principal = new GenericPrincipal(identity, perfil);
}
return(membershipCtx);
}
protected void MemberGridView_RowDeleting(object sender, GridViewDeleteEventArgs e)
{
int selectedRow = e.RowIndex;
int MemberID = Convert.ToInt32(MemberGridView.DataKeys[selectedRow].Values["MemberID"]);
try
{
using (MembershipContext db = new MembershipContext())
{
member deleteMember = (from memberRecords in db.members
where memberRecords.memberID == MemberID
select memberRecords).FirstOrDefault();
db.members.Remove(deleteMember);
db.SaveChanges();
this.GetMembers();
}
}
catch
{
}
}
public async Task <ActionResult> ChangeAccountInfo(ChangeAccountInfoModel model, string returnUrl)
{
if (ModelState.IsValid)
{
ApplicationUser user = new ApplicationUser {
FirstName = model.FirstName, LastName = model.LastName
};
if (!string.IsNullOrEmpty(model.Email))
{
user.Email = model.Email;
}
await MembershipContext.ChangeAccountInfo(User.Identity.GetUserId(), user);
}
if (string.IsNullOrEmpty(returnUrl))
{
return(RedirectToAction("Index", "Home"));
}
else
{
return(Redirect(returnUrl));
}
}
private async Task <ClaimsPrincipal> CreateFakePrincipal(MembershipContext membershipContext, int?groupId)
{
if (!groupId.HasValue)
{
throw new ArgumentNullException(nameof(groupId));
}
var group = await groupRepository.AsQueryable(g => g.Role).Where(g => g.Role.Delstat == 0 && g.Delstat == 0 && g.Id == groupId).ToListAsync();
var roles = group.Select(g => g.Role.Code).Distinct().ToList();
if (roles.Count <= 0)
{
return(null);
}
var claims = roles.Select(roleCode => new Claim(ClaimTypes.Role, roleCode, ClaimValueTypes.String, membershipContext.Userid)).ToList();
var identity = new ClaimsIdentity(claims, SidAuthenticationDefaults.AuthenticationScheme);
var principal = new ClaimsPrincipal(identity);
return(principal);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, MembershipContext context)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
app.UseCookiePolicy();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
DbInitializer.Initialize(context);
}
public void Initialize()
{
Database.SetInitializer <MembershipContext>(null);
try
{
using (var context = new MembershipContext())
{
if (!context.Database.Exists())
{
// Create the SimpleMembership database without Entity Framework migration schema
((IObjectContextAdapter)context).ObjectContext.CreateDatabase();
}
}
WebSecurity.InitializeDatabaseConnection("Membership", "UserProfiles", "UserId", "Username", autoCreateTables: true);
}
catch (Exception ex)
{
throw new InvalidOperationException("The ASP.NET Simple Membership database could not be initialized. For more information, please see http://go.microsoft.com/fwlink/?LinkId=256588", ex);
}
}
internal void EmailBodyUserEmail(string emailAddress, string fromDisplayName, string from, string subject, string body, Action<InvokeOperation> completedAction, object userState)
{
MembershipContext membership = new MembershipContext();
membership.EmailBodyUserEmail(emailAddress, fromDisplayName, from, subject, body, completedAction, userState);
}
internal void EmailTemplateEmail(string emailAddress, string fromDisplayName, string from, string subject, string bodyFileName, string replacements, Action<InvokeOperation> completedAction, object userState)
{
MembershipContext membership = new MembershipContext();
membership.EmailTemplateEmail(emailAddress, fromDisplayName, from, subject, bodyFileName, replacements, completedAction, userState);
}
internal void UnlockUser(string userName, Action<InvokeOperation<bool>> completedAction, object userState)
{
MembershipContext membership = new MembershipContext();
membership.UnlockUser(userName, completedAction, userState);
}
private bool UserNameExist(string userName, MembershipContext ctx)
{
bool exist = false;
var predicate = MatchApplication().And(MatchUserName(userName));
exist = ctx.Users.Count(predicate.ToExpressionFunc()) > 0;
return exist;
}
public UserRepository(MembershipContext ctx)
{
this.ctx = ctx;
}
public UnitOfWork()
{
ctx = new MembershipContext();
}
private User GetUserByEmail(string email, MembershipContext ctx)
{
return GetUser(u => u.Email.ToLower() == email.ToLower(), ctx);
}
internal void ValidateResetPasswordCode(string resetPasswordCode, Action<InvokeOperation<string>> completedAction, object userState)
{
MembershipContext membership = new MembershipContext();
membership.ValidateResetPasswordCode(resetPasswordCode, completedAction, userState);
}
internal void DeleteUser(string userName, bool deleteAllRelatedData, Action<InvokeOperation<bool>> completedAction, object userState)
{
MembershipContext membership = new MembershipContext();
membership.DeleteUser(userName, deleteAllRelatedData, completedAction, userState);
}
internal void CreateUser(string userName, string password, string emailAddress, string roleName, Action<InvokeOperation> completedAction, object userState)
{
MembershipContext membership = new MembershipContext();
membership.CreateUser(userName, password, emailAddress, roleName, completedAction, userState);
}
private User GetUserByName(string userName, MembershipContext ctx)
{
return GetUser(u => u.Name.ToLower() == userName.ToLower(), ctx);
}
private bool UserEmailExist(string email, MembershipContext ctx)
{
bool exist = false;
var predicate = MatchApplication().And(MatchEmail(email));
exist = ctx.Users.Count(predicate.ToExpressionFunc()) > 0;
return exist;
}
public RoleRepository(MembershipContext ctx)
{
this.ctx = ctx;
}
internal void GetUserNameByEmail(string emailToMatch, Action<InvokeOperation<string>> completedAction, object userState)
{
MembershipContext membership = new MembershipContext();
membership.GetUserNameByEmail(emailToMatch, completedAction, userState);
}
internal void GetNumberOfUsersOnline(Action<InvokeOperation<int>> completedAction, object userState)
{
MembershipContext membership = new MembershipContext();
membership.GetNumberOfUsersOnline(completedAction, userState);
}
internal void ResetAndChangePassword(string resetPasswordCode, string newPassword, Action<InvokeOperation<bool>> completedAction, object userState)
{
MembershipContext membership = new MembershipContext();
membership.ResetAndChangePassword(resetPasswordCode, newPassword, completedAction, userState);
}
private User GetUser(Expression<Func<User, bool>> query, MembershipContext context)
{
User user = context.Users.Where(query).Where(MatchApplication()).Single();
return user;
}
private Function GetFunctionByName(string funcName, MembershipContext ctx)
{
return GetFunction(MatchName(funcName), ctx);
}
private Function GetFunction(Expression<Func<Function, bool>> predicate, MembershipContext ctx)
{
return ctx.Functions.SingleOrDefault(MatchApplication().And(predicate).ToExpressionFunc());
}
internal void ChangePasswordQuestionAndAnswer(string userName, string password, string newPasswordQuestion, string newPasswordAnswer, Action<InvokeOperation<bool>> completedAction, object userState)
{
MembershipContext membership = new MembershipContext();
membership.ChangePasswordQuestionAndAnswer(userName, password, newPasswordQuestion, newPasswordAnswer, completedAction, userState);
}
internal void ResetPassword(string userName, Action<InvokeOperation<string>> completedAction, object userState)
{
MembershipContext membership = new MembershipContext();
membership.ResetPassword(userName, completedAction, userState);
}
/// <summary>
/// validate the user and password
/// throw exceptions for NotExist/NotConfirmed/LockedOut user;
/// if wrong password is given, increase the FaildPasswordAttempCount, if this exceeds the MaxInvalidPasswordAttemps, throw exception;
/// </summary>
/// <param name="username"></param>
/// <param name="password"></param>
/// <param name="ctx"></param>
/// <param name="user"></param>
/// <returns></returns>
private bool ValidateUser(string username, string password, MembershipContext ctx, out User user)
{
user = GetUser(u => u.Name.ToLower() == username.ToLower(), ctx);
if (user == null)
{
throw new EFMemberException(EFMembershipValidationStatus.UserNotExist, string.Format(Resource.msg_UserNotExist, username));
}
if (!user.IsConfirmed)
{
throw new EFMemberException(EFMembershipValidationStatus.UserNotConfirmed, string.Format(Resource.msg_UserNotConfirmed, username));
}
if (user.IsLockedOut)
{
throw new EFMemberException(EFMembershipValidationStatus.UserIsLockedOut, string.Format(Resource.msg_UserLockedOut, username));
}
string encryptedPwd = EncryptPassword(password);
if (encryptedPwd != user.Password)
{
// update falure password attempt count
DateTime? lastFailureTry = user.FailedPasswordAttempWindowStart;
if (lastFailureTry == null || DateTime.Now > lastFailureTry.Value.AddMinutes(PasswordAttemptWindow))
{
user.FailedPasswordAttempWindowStart = DateTime.Now;
user.FailedPasswordAttempCount = 1;
}
else
{
++user.FailedPasswordAttempCount;
}
if (user.FailedPasswordAttempCount >= MaxInvalidPasswordAttempts)
{
user.IsLockedOut = true;
user.LastLockoutDate = DateTime.Now;
}
ctx.SaveChanges();
throw new EFMemberException(EFMembershipValidationStatus.WrongPassword, string.Format(Resource.msg_WrongPassword, username));
}
// update last date
user.LastActiveDate = DateTime.Now;
user.LastLoginDate = DateTime.Now;
return true;
}
internal void ChangePassword(string userName, string currentPassword, string newPassword, Action<InvokeOperation<bool>> completedAction, object userState)
{
MembershipContext membership = new MembershipContext();
membership.ChangePassword(userName, currentPassword, newPassword, completedAction, userState);
}
public static MembershipContext GetMembershipContext()
{
return _membershipContext ?? (_membershipContext = new MembershipContext());
}
private bool FuncExist(string funcName, MembershipContext ctx)
{
if (string.IsNullOrEmpty(funcName))
{
throw new ArgumentNullException("funcName");
}
return ctx.Functions.Count(MatchApplication().And(MatchName(funcName)).ToExpressionFunc()) > 0;
}
internal void ValidateUser(string userName, string password, Action<InvokeOperation<bool>> completedAction, object userState)
{
MembershipContext membership = new MembershipContext();
membership.ValidateUser(userName, password, completedAction, userState);
}
