public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel) { var validation = new SignInModelValidator().Valid(signInModel); if (!validation.Success) { return(new ErrorDataResult <TokenModel>(validation.Message)); } UserDomainService.GenerateHash(signInModel); var signedInModel = await UserRepository.SignInAsync(signInModel); validation = new SignedInModelValidator().Valid(signedInModel); if (!validation.Success) { return(new ErrorDataResult <TokenModel>(validation.Message)); } var addUserLogModel = new AddUserLogModel(signedInModel.UserId, LogType.SignIn); await UserLogApplicationService.AddAsync(addUserLogModel); var tokenModel = UserDomainService.GenerateToken(signedInModel); return(new SuccessDataResult <TokenModel>(tokenModel)); }
public override void OnAuthorization(AuthorizationContext filterContext) { if (!filterContext.HttpContext.User.Identity.IsAuthenticated) { filterContext.Result = new RedirectResult("/Account/Login"); } else { var id = filterContext.HttpContext.User.Identity.AuthenticationType; UserDomainService userService = new UserDomainService(); var user = Task.Run(async() => await userService.GetUserRolesById(new Guid(id))).Result; bool existsRole = false; foreach (var role in user) { if (UserRole.Contains(role)) { existsRole = true; } } if (!existsRole) { filterContext.HttpContext.Response.Clear(); filterContext.HttpContext.Response.StatusDescription = "Access Denied"; filterContext.HttpContext.Response.Write("Access Denied, You don't have enough permissions to see this page"); filterContext.HttpContext.Response.StatusCode = 403; filterContext.Result = new EmptyResult(); filterContext.HttpContext.Response.End(); } } }
/// <summary> /// 保存用户 /// </summary> /// <param name="saveInfo">保存信息</param> /// <returns></returns> public Result <UserDto> SaveUser(SaveUserCmdDto saveInfo) { if (saveInfo == null || saveInfo.User == null) { return(Result <UserDto> .FailedResult("没有指定任何要保存的用户信息")); } using (var businessWork = WorkFactory.Create()) { var user = saveInfo.User.MapTo <User>(); var userSaveResult = UserDomainService.SaveUser(user); if (!userSaveResult.Success) { return(Result <UserDto> .FailedResult(userSaveResult.Message)); } var commitResult = businessWork.Commit(); Result <UserDto> result = null; if (commitResult.EmptyResultOrSuccess) { result = Result <UserDto> .SuccessResult("保存成功"); result.Data = userSaveResult.Data.MapTo <UserDto>(); } else { result = Result <UserDto> .FailedResult("保存失败"); } return(result); } }
public async Task Create_Should_Return_Fail_Result_For_Invalid_Interests(UserRegistrationDTO userRegistrationDTO) { var errorMessage = "Error Message"; byte[] randomByteArray = new byte[32]; Random random = new Random(); random.NextBytes(randomByteArray); var hashingServiceMock = new Mock <IHashingService>(); hashingServiceMock.Setup(x => x.GenerateSalt()).Returns(randomByteArray); hashingServiceMock.Setup(x => x.GetHash(userRegistrationDTO.Password, It.IsAny <byte[]>())).Returns(randomByteArray); List <Interest> interests; List <UserInterest> userInterests; CreateInterestsAndUserInterests(out interests, out userInterests, userRegistrationDTO.InterestIds); var interestRepositoryMock = new Mock <IInterestRepository>(); interestRepositoryMock.Setup(x => x.GetInterestsByIds(It.IsAny <int[]>())).ReturnsAsync(Result.Fail <IReadOnlyList <Interest> >(errorMessage)); var userDomainService = new UserDomainService(interestRepositoryMock.Object); var userFactory = new UserFactory(hashingServiceMock.Object, userDomainService); var userResult = await userFactory.CreateUserAsync(userRegistrationDTO); userResult.IsSuccessed.Should().BeFalse(); userResult.GetErrorString().Should().Be(errorMessage); }
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel) { var validation = new AddUserModelValidator().Valid(addUserModel); if (!validation.Success) { return(new ErrorDataResult <long>(validation.Message)); } addUserModel.Login = UserDomainService.GenerateHash(addUserModel.Login); addUserModel.Password = UserDomainService.GenerateHash(addUserModel.Password); var userDomain = UserDomainFactory.Create(addUserModel); userDomain.Add(); var userEntity = userDomain.Map <UserEntity>(); await UserRepository.AddAsync(userEntity); await DatabaseUnitOfWork.SaveChangesAsync(); return(new SuccessDataResult <long>(userEntity.UserId)); }
public UserDomainServiceTests() { _mockOfUserRepository = new Mock <IUserRepository>(); _mockOfUserPhoneRepository = new Mock <IUserPhoneRepository>(); _service = new UserDomainService(_mockOfUserRepository.Object, _mockOfUserPhoneRepository.Object); }
public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel) { var validation = new SignInModelValidator().Valid(signInModel); if (!validation.Success) { return(new ErrorDataResult <TokenModel>(validation.Message)); } var signedInModel = await UserRepository.SignInAsync(signInModel); if (!UserDomainService.Validate(signedInModel, signInModel)) { return(new ErrorDataResult <TokenModel>(Texts.LoginPasswordInvalid)); } var tokenModel = UserDomainService.CreateToken(signedInModel); var addUserLogModel = new AddUserLogModel(signedInModel.UserId, LogType.SignIn); await UserLogApplicationService.AddAsync(addUserLogModel); await UnitOfWork.SaveChangesAsync(); return(new SuccessDataResult <TokenModel>(tokenModel)); }
public override async void OnAuthorization(HttpActionContext actionContext) { var authHeader = actionContext.Request.Headers.Authorization; if (authHeader != null) { var authenticationToken = actionContext.Request.Headers.Authorization.Parameter; var decodedAuthenticationToken = Encoding.UTF8.GetString(Convert.FromBase64String(authenticationToken)); var usernamePasswordArray = decodedAuthenticationToken.Split(':'); var userName = usernamePasswordArray[0]; var password = usernamePasswordArray[1]; UserDomainService userService = new UserDomainService(); var user = await userService.GetUserByNameAndPassword(userName, password); if (user != null) { actionContext.Response = actionContext.Request.CreateResponse(HttpStatusCode.OK, "User " + userName + " successfully authenticated"); return; } } HandleUnathorized(actionContext); }
public async Task Create_Should_Return_Success_User_Result_With_Longitude_As_Null(UserRegistrationDTO userRegistrationDTO) { byte[] randomByteArray = new byte[32]; Random random = new Random(); random.NextBytes(randomByteArray); List <Interest> interests; List <UserInterest> userInterests; CreateInterestsAndUserInterests(out interests, out userInterests, userRegistrationDTO.InterestIds); var hashingServiceMock = new Mock <IHashingService>(); var interestRepositoryMock = new Mock <IInterestRepository>(); interestRepositoryMock.Setup(x => x.GetInterestsByIds(It.IsAny <int[]>())).ReturnsAsync(Result.Ok((IReadOnlyList <Interest>)interests)); var userDomainService = new UserDomainService(interestRepositoryMock.Object); hashingServiceMock.Setup(x => x.GenerateSalt()).Returns(randomByteArray); hashingServiceMock.Setup(x => x.GetHash(userRegistrationDTO.Password, It.IsAny <byte[]>())).Returns(randomByteArray); var userFactory = new UserFactory(hashingServiceMock.Object, userDomainService); var userResult = await userFactory.CreateUserAsync(userRegistrationDTO); userResult.IsSuccessed.Should().BeTrue(); userResult.Value.Location.Longitude.Should().Be(0); userResult.Value.Location.Latitude.Should().Be(84.444454); }
public async Task <IDataResult <SignedInModel> > SignInAsync(SignInModel signInModel) { var validation = new SignInModelValidator().Valid(signInModel); if (!validation.Success) { return(new ErrorDataResult <SignedInModel>(validation.Message)); } signInModel.Login = UserDomainService.GenerateHash(signInModel.Login); signInModel.Password = UserDomainService.GenerateHash(signInModel.Password); var signedInModel = await UserRepository.SignInAsync(signInModel); validation = new SignedInModelValidator().Valid(signedInModel); if (!validation.Success) { return(new ErrorDataResult <SignedInModel>(validation.Message)); } await AddUserLogAsync(signedInModel.UserId, LogType.SignIn).ConfigureAwait(false); return(new SuccessDataResult <SignedInModel>(signedInModel)); }
public async Task SetUserInterestsAsync_Should_Return_Success_Result() { var interestIds = new int[] { 1, 2, 3 }; List <Interest> interests = new List <Interest>(); for (int i = 1; i <= 3; i++) { var t = Interest.Create("mock", "mock").Value; t.Id = i; interests.Add(t); } var userRepositoryMock = new Mock <IUserRepository>(); var userFactoryMock = new Mock <IUserFactory>(); var userIdentityProviderMock = new Mock <IIdentityProvider>(); var mediatorMock = new Mock <IMediator>(); var interestRepositoryMock = new Mock <IInterestRepository>(); interestRepositoryMock.Setup(x => x.GetInterestsByIds(interestIds)).ReturnsAsync(Result.Ok(interests as IReadOnlyList <Interest>)); var userDomainService = new UserDomainService(interestRepositoryMock.Object); userIdentityProviderMock.Setup(x => x.GetUser()).ReturnsAsync(Result.Ok(_user)); userRepositoryMock.Setup(x => x.SaveChangesAsync(It.IsAny <string>())).ReturnsAsync(Result.Ok()); UserService userService = new UserService(userRepositoryMock.Object, userFactoryMock.Object, userIdentityProviderMock.Object, mediatorMock.Object, userDomainService); var result = await userService.SetUserInterestsAsync(interestIds); result.IsSuccessed.Should().BeTrue(); }
public UserAppService(UserDomainService userDomainService, IUserRepository userRepository, IUserAvatarRepository userAvatarRepository) { _userDomainService = userDomainService; _userRepository = userRepository; _userAvatarRepository = userAvatarRepository; }
public UserService(IRepository <User> userRepository, UserDomainService userDomainService, IRepository <UserInvite> userInviteRepository, IUnitOfWork unitOfWork) { this.userRepository = userRepository; this.userDomainService = userDomainService; this.userInviteRepository = userInviteRepository; this.unitOfWork = unitOfWork; }
public async Task GetAllUsersAsyncTest_Empty() { var mockState = new MockReliableStateManager(); var userDomainService = new UserDomainService(mockState, this.statefulServiceContext); var result = await userDomainService.GetAllUsersAsync(); Assert.IsNotNull(result); Assert.IsTrue(result.Count == 0); }
public UserAppService(IDemoRepository repository, IAppUnitOfWork unitOfWork, UserDomainService userDomainService, ILockProvider lockProvider) : base(repository, unitOfWork) { _userDomainService = userDomainService; _lockProvider = lockProvider; }
public async Task GetAllUsersTestAsync_NotEmpty() { var mockState = await this.CreateMockStateManager(); var userDomainService = new UserDomainService(mockState, this.statefulServiceContext); var result = await userDomainService.GetAllUsersAsync(); Assert.IsNotNull(result); Assert.IsTrue(result.Count == 1); Assert.IsTrue(result[0].IdCardNo == "111"); }
public GroupService(GroupDomainService groupDomainService, IRepository <User> userRepo, IRepository <Group> groupRepository, UserDomainService userDomainService, IRepository <UserInvite> userInviteRepo, IUnitOfWork unitOfWork) { this.groupDomainService = groupDomainService; this.groupRepo = groupRepository; this.userRepo = userRepo; this.userDomainService = userDomainService; this.userInviteRepo = userInviteRepo; this.unitOfWork = unitOfWork; }
public void Init() { this.userRepo = new Mock <IRepository <User> >(); this.userInviteRepo = new Mock <IRepository <UserInvite> >(); this.groupRepo = new Mock <IRepository <Group> >(); this.stopRepo = new Mock <IRepository <Stop> >(); this.tenantId = Guid.NewGuid(); this.userDomainService = new UserDomainService(this.userRepo.Object, this.userInviteRepo.Object, this.groupRepo.Object, this.stopRepo.Object); }
public UsersAppService( IUserRepository userRepo, IHttpContextAccessor accessor, IMapper mapper, UserDomainService userDomainService, DomainMapperCreator domainMapper ) : base(accessor, userRepo) { _autoMapper = mapper; _userDomainService = userDomainService; _domainMapper = domainMapper; }
public async Task <IDataResult <TokenModel> > SignInJwtAsync(SignInModel signInModel) { var result = await SignInAsync(signInModel).ConfigureAwait(false); if (!result.Success) { return(ErrorDataResult <TokenModel>(result.Message)); } var tokenModel = UserDomainService.GenerateToken(result.Data); return(SuccessDataResult(tokenModel)); }
public async Task <IDataResult <TokenModel> > SignInJwtAsync(SignInModel signInModel) { var result = await SignInAsync(signInModel).ConfigureAwait(false); if (!result.Success) { return(new ErrorDataResult <TokenModel>(result.Message)); } var token = UserDomainService.GenerateToken(result.Data); var userInfo = await SelectAsync(result.Data.UserId).ConfigureAwait(false); var tokenModel = new TokenModel(token, userInfo); return(new SuccessDataResult <TokenModel>(tokenModel)); }
/// <summary> /// 删除用户 /// </summary> /// <param name="deleteInfo">删除信息</param> /// <returns></returns> public Result DeleteUser(DeleteUserCmdDto deleteInfo) { if (deleteInfo == null || deleteInfo.UserIds.IsNullOrEmpty()) { return(Result.FailedResult("没有指定任何要删除的用户信息")); } using (var businessWork = WorkFactory.Create()) { var deleteResult = UserDomainService.DeleteUser(deleteInfo.UserIds); if (!deleteResult.Success) { return(deleteResult); } var commitResult = businessWork.Commit(); return(commitResult.ExecutedSuccess ? Result.SuccessResult("删除成功") : Result.FailedResult("删除失败")); } }
public async Task SetUserInterests_Should_Set_User_Interests_For_Valid_Interest_IdsAsync(int[] interestIds) { List <Interest> interests = new List <Interest>(); List <UserInterest> userInterests = new List <UserInterest>(); CreateInterestsAndUserInterests(out interests, out userInterests, interestIds); var interestRepositoryMock = new Mock <IInterestRepository>(); interestRepositoryMock.Setup(x => x.GetInterestsByIds(It.IsAny <int[]>())).ReturnsAsync(Result.Ok((IReadOnlyList <Interest>)interests)); var userDomainService = new UserDomainService(interestRepositoryMock.Object); var setUserInterestsResult = await userDomainService.SetUserInterests(_user, interestIds); setUserInterestsResult.IsSuccessed.Should().BeTrue(); _user.Interests.Should().BeEquivalentTo(userInterests); }
public async Task SetUserInterests_Should_Return_Fail_Result_For_Valid_And_Invalid_Interest_IdsAsync() { var interestIds = new int[] { 1, 2, 3, 98, 99, 100 }; var inputForCreatingInterestForMockingInterestRepository = new int[] { 1, 2, 3 }; List <Interest> interests = new List <Interest>(); List <UserInterest> userInterests = new List <UserInterest>(); CreateInterestsAndUserInterests(out interests, out userInterests, inputForCreatingInterestForMockingInterestRepository); var interestRepositoryMock = new Mock <IInterestRepository>(); interestRepositoryMock.Setup(x => x.GetInterestsByIds(It.IsAny <int[]>())).ReturnsAsync(Result.Ok((IReadOnlyList <Interest>)interests)); var userDomainService = new UserDomainService(interestRepositoryMock.Object); var setUserInterestsResult = await userDomainService.SetUserInterests(_user, interestIds); setUserInterestsResult.IsSuccessed.Should().BeFalse(); setUserInterestsResult.GetErrorString().Should().Be(UserDomainService.Invalid_Interest); }
public async Task SetUserInterests_Should_Return_Fail_Result_For_Invalid_Interest_IdsAsync() { const string Error_Message = "Invalid Interests"; int[] interestIds = new int[] { 98, 99, 100 }; List <Interest> interests = new List <Interest>(); List <UserInterest> userInterests = new List <UserInterest>(); CreateInterestsAndUserInterests(out interests, out userInterests, interestIds); var interestRepositoryMock = new Mock <IInterestRepository>(); interestRepositoryMock.Setup(x => x.GetInterestsByIds(It.IsAny <int[]>())).ReturnsAsync(Result.Fail <IReadOnlyList <Interest> >(Error_Message)); var userDomainService = new UserDomainService(interestRepositoryMock.Object); var setUserInterestsResult = await userDomainService.SetUserInterests(_user, interestIds); setUserInterestsResult.IsSuccessed.Should().BeFalse(); setUserInterestsResult.GetErrorString().Should().Be(Error_Message); }
public async Task Create_Should_Return_Success_User_ResultAsync(UserRegistrationDTO userRegistrationDTO) { byte[] randomByteArray = new byte[32]; Random random = new Random(); random.NextBytes(randomByteArray); var hashingServiceMock = new Mock <IHashingService>(); hashingServiceMock.Setup(x => x.GenerateSalt()).Returns(randomByteArray); hashingServiceMock.Setup(x => x.GetHash(userRegistrationDTO.Password, It.IsAny <byte[]>())).Returns(randomByteArray); List <Interest> interests; List <UserInterest> userInterests; CreateInterestsAndUserInterests(out interests, out userInterests, userRegistrationDTO.InterestIds); var interestRepositoryMock = new Mock <IInterestRepository>(); interestRepositoryMock.Setup(x => x.GetInterestsByIds(It.IsAny <int[]>())).ReturnsAsync(Result.Ok((IReadOnlyList <Interest>)interests)); var userDomainService = new UserDomainService(interestRepositoryMock.Object); var userFactory = new UserFactory(hashingServiceMock.Object, userDomainService); var userResult = await userFactory.CreateUserAsync(userRegistrationDTO); userResult.IsSuccessed.Should().BeTrue(); userResult.Value.Should().BeAssignableTo <User>(); userResult.Value.PhoneNumber.PhoneNumber.Should().Be(userRegistrationDTO.PhoneNumber); userResult.Value.PhoneNumber.CountryCode.Should().Be(userRegistrationDTO.CountryCode); userResult.Value.Password.PasswordHash.Should().BeEquivalentTo(randomByteArray); userResult.Value.Password.PasswordSalt.Should().BeEquivalentTo(randomByteArray); userResult.Value.FullName.Should().Be(userRegistrationDTO.FullName); userResult.Value.Age.DateOfBirth.Should().Be(userRegistrationDTO.DateOfBirth); userResult.Value.Gender.GenderType.Should().Be((GenderType)userRegistrationDTO.Gender); userResult.Value.Profession.Should().Be(userRegistrationDTO.Profession); userResult.Value.School.Should().Be(userRegistrationDTO.School); userResult.Value.MatchPreference.LookingFor.GenderType.Should().Be(userRegistrationDTO.LookingFor); userResult.Value.MatchPreference.MinAge.Should().Be(userRegistrationDTO.MinAge); userResult.Value.MatchPreference.MaxAge.Should().Be(userRegistrationDTO.MaxAge); userResult.Value.MatchPreference.Distance.Should().Be(userRegistrationDTO.Distance); userResult.Value.FunAndInterestingThings.Should().Be(userRegistrationDTO.FunAndInteresting); userResult.Value.BucketList.Should().Be(userRegistrationDTO.BucketList); userResult.Value.Interests.Should().BeEquivalentTo(userInterests); }
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel) { var validation = new AddUserModelValidator().Valid(addUserModel); if (!validation.Success) { return(new ErrorDataResult <long>(validation.Message)); } addUserModel.SignIn = UserDomainService.CreateSignInHash(addUserModel.SignIn); var userEntity = UserEntityFactory.Create(addUserModel); userEntity.Add(); await UserRepository.AddAsync(userEntity); await UnitOfWork.SaveChangesAsync(); return(new SuccessDataResult <long>(userEntity.UserId)); }
/// <summary> /// 用户登录 /// </summary> /// <param name="userDto">登录用户信息</param> /// <returns></returns> public Result <UserDto> Login(UserDto userDto) { if (userDto == null) { return(Result <UserDto> .FailedResult("用户登录信息为空")); } var loginResult = UserDomainService.Login(new UserLogin() { UserName = userDto.UserName, Pwd = userDto.Pwd }); if (!loginResult.Success) { return(Result <UserDto> .FailedResult(loginResult.Message)); } var result = Result <UserDto> .SuccessResult("登陆成功"); result.Data = loginResult.Data.MapTo <UserDto>(); return(result); }
/// <summary> /// 修改用户状态 /// </summary> /// <param name="statusInfo">状态信息</param> /// <returns>执行结果</returns> public Result ModifyStatus(ModifyUserStatusCmdDto statusInfo) { using (var businessWork = WorkFactory.Create()) { if (statusInfo == null || statusInfo.UserId <= 0) { return(Result.FailedResult("没有指定要修改状态的用户信息")); } var modifyResult = UserDomainService.ModifyStatus(new UserStatusInfo() { UserId = statusInfo.UserId, Status = statusInfo.Status }); if (!modifyResult.Success) { return(modifyResult); } var commitVal = businessWork.Commit(); return(commitVal.ExecutedSuccess ? Result.SuccessResult("修改成功") : Result.FailedResult("修改失败")); } }
protected void Page_Load(object sender, EventArgs e) { try { UserDomainService userDomainService = new UserDomainService(); var subDomain = Request.Url.GetSubDomain(); Response.Write(subDomain); var q = userDomainService.GetUserDomain(subDomain); if (!string.IsNullOrEmpty(q.Domain)) { Response.Redirect("Crm/ViewPost/"); } else { Response.Write("Account/Login"); } } catch (Exception ex) { } }