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)
{
}
}
