public async Task ConfirmUserAccountAsyncShouldCallUserManager()
{
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var testUserRepository = new EfDeletableEntityRepository <ApplicationUser>(context);
var testNotConfirmedUsers = TestDataHelpers.GetTestNotConfirmedUsers();
var testAccountManagementService = new AccountManagementService(this.userManager.Object, testUserRepository, this.accountRepository.Object, this.positionService.Object, this.feePaymentsRepository.Object);
foreach (var tester in testNotConfirmedUsers)
{
await testUserRepository.AddAsync(tester);
await testUserRepository.SaveChangesAsync();
}
var user = new ClientToBeConfirmedViewModel
{
UserId = "11",
Username = "******",
Email = "[email protected]",
Balance = 5000,
TradeFee = 50,
MonthlyFee = 100,
Notes = null,
};
await testAccountManagementService.ConfirmUserAccountAsync(user);
this.userManager.Verify(u => u.RemoveFromRoleAsync(It.IsAny <ApplicationUser>(), GlobalConstants.NotConfirmedUserRoleName), Times.Once);
this.userManager.Verify(u => u.AddToRoleAsync(It.IsAny <ApplicationUser>(), GlobalConstants.ConfirmedUserRoleName), Times.Once);
}
public void SetUserAvatarCorectly()
{
// Arrange
var mockedUnitOfWork = new Mock <IUnitOfWorkEF>();
var mockedCarsRepo = new Mock <IProjectableRepositoryEf <Car> >();
var mockedUserRepo = new Mock <IProjectableRepositoryEf <User> >();
var service = new AccountManagementService(mockedCarsRepo.Object, mockedUserRepo.Object, () => mockedUnitOfWork.Object);
string logedUserId = "userId";
string imageUrl = "imageUrl";
var user = new User()
{
Id = logedUserId
};
mockedUserRepo.Setup(x => x.GetById(logedUserId))
.Returns(user);
// Act
service.SetUserAvatar(logedUserId, imageUrl);
// Assert
Assert.AreEqual(imageUrl, user.AvatarImageurl);
mockedUnitOfWork.Verify(x => x.Commit(), Times.Once);
}
public HttpResponseMessage RemoveThirdPartyInfo([FromBody] ThirdPartyInfoM model)
{
System.Diagnostics.EventLog.WriteEntry("Application", "Controller Remove Third Party started");
AccountManagementService accService = new AccountManagementService();
HttpStatusCode ReturnCode = HttpStatusCode.OK;
TranInfo <ThirdPartyInfoM> transaction = new TranInfo <ThirdPartyInfoM>();
ReturnResult <ThirdPartyInfoM> result = new ReturnResult <ThirdPartyInfoM>();
try
{
result = accService.RemoveThirdPartyInfo(model);
if (result.status.Status == StatusEnum.Success)
{
transaction.status = true;
}
else
{
transaction.status = false;
transaction.AddException(result.status.StatusMessage);
}
}
catch (Exception ex)
{
transaction.status = false;
transaction.AddException(ex.Message);
ReturnCode = HttpStatusCode.InternalServerError;
result.status = _eHandler.HandleException(ex);
_commonService.LogError(result.status);
}
return(Request.CreateResponse <TranInfo <ThirdPartyInfoM> >(ReturnCode, transaction));
}
public async Task RestoreUserAccountAsyncShouldCallUserManager()
{
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var testAccountRepository = new EfDeletableEntityRepository <Account>(context);
var testAccounts = TestDataHelpers.GetTestData();
foreach (var testAccount in testAccounts)
{
if (testAccount.Id == 1)
{
testAccount.IsDeleted = true;
}
await testAccountRepository.AddAsync(testAccount);
await testAccountRepository.SaveChangesAsync();
}
var testAccountManagementService = new AccountManagementService(this.userManager.Object, this.userRepository.Object, testAccountRepository, this.positionService.Object, this.feePaymentsRepository.Object);
await testAccountManagementService.RestoreUserAccountAsync("1", 1);
this.userManager.Verify(u => u.RemoveFromRoleAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>()), Times.Once);
this.userManager.Verify(u => u.AddToRoleAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>()), Times.Once);
}
public async Task RestoreUserAccountAsyncShouldWorkCorrectly()
{
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var testAccountRepository = new EfDeletableEntityRepository <Account>(context);
var testAccounts = TestDataHelpers.GetTestData();
foreach (var testAccount in testAccounts)
{
if (testAccount.Id == 1)
{
testAccount.IsDeleted = true;
}
await testAccountRepository.AddAsync(testAccount);
await testAccountRepository.SaveChangesAsync();
}
var testAccountManagementService = new AccountManagementService(this.userManager.Object, this.userRepository.Object, testAccountRepository, this.positionService.Object, this.feePaymentsRepository.Object);
await testAccountManagementService.RestoreUserAccountAsync("1", 1);
var account = testAccountRepository
.AllWithDeleted()
.FirstOrDefault(a => a.Id == 1);
Assert.IsFalse(account.IsDeleted);
}
public HttpResponseMessage SaveTranslationServiceInfo([FromBody] TranslationServiceInfoM model)
{
AccountManagementService accService = new AccountManagementService();
HttpStatusCode ReturnCode = HttpStatusCode.OK;
TranInfo <Boolean> transaction = new TranInfo <Boolean>();
ReturnResult <Boolean> result = new ReturnResult <Boolean>();
try
{
result = accService.SaveTranslationServiceInfo(model);
if (result.status.Status == StatusEnum.Success)
{
transaction.status = true;
}
else
{
transaction.status = false;
transaction.AddException(result.status.StatusMessage);
}
}
catch (Exception ex)
{
transaction.status = false;
transaction.AddException(ex.Message);
ReturnCode = HttpStatusCode.InternalServerError;
result.status = _eHandler.HandleException(ex);
_commonService.LogError(result.status);
}
return(Request.CreateResponse <TranInfo <Boolean> >(ReturnCode, transaction));
}
public void Return_Fasle_IfTheEmailisUnique()
{
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedUoW = new Mock <Func <IUnitOfWork> >();
var service = new AccountManagementService(mockedUserRepo.Object, mockedUoW.Object);
string email = "*****@*****.**";
var users = new List <User>()
{
new User()
{
Email = email
}
};
mockedUserRepo.Setup(x => x.GetAll(It.IsAny <Expression <Func <User, bool> > >(), It.IsAny <Expression <Func <User, string> > >()))
.Returns(
(Expression <Func <User, bool> > predicate, Expression <Func <User, string> > select) =>
users.Where(predicate.Compile())
.Select(select.Compile()));
var result = service.IsEmailUnique(email);
Assert.IsFalse(result);
}
public async Task ConfirmUserAccountAsyncWorkCorrectly()
{
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var testUserRepository = new EfDeletableEntityRepository <ApplicationUser>(context);
var testNotConfirmedUsers = TestDataHelpers.GetTestNotConfirmedUsers();
var testAccountManagementService = new AccountManagementService(this.userManager.Object, testUserRepository, this.accountRepository.Object, this.positionService.Object, this.feePaymentsRepository.Object);
foreach (var tester in testNotConfirmedUsers)
{
await testUserRepository.AddAsync(tester);
await testUserRepository.SaveChangesAsync();
}
var user = new ClientToBeConfirmedViewModel
{
UserId = "11",
Username = "******",
Email = "[email protected]",
Balance = 5000,
TradeFee = 50,
MonthlyFee = 100,
Notes = null,
};
var testUser = testUserRepository.All().FirstOrDefault(u => u.Id == "11");
Assert.IsNull(testUser.Account);
await testAccountManagementService.ConfirmUserAccountAsync(user);
Assert.IsNotNull(testUser.Account);
}
public HttpResponseMessage DeleteCityUser([FromUri] int UserID)
{
System.Diagnostics.EventLog.WriteEntry("Application", "Controller Delete Customer started");
AccountManagementService accService = new AccountManagementService();
HttpStatusCode ReturnCode = HttpStatusCode.OK;
TranInfo <bool> transaction = new TranInfo <bool>();
ReturnResult <bool> result = new ReturnResult <bool>();
try
{
result = accService.DeleteCityUser(UserID);
if (result.status.Status == StatusEnum.Success)
{
transaction.status = true;
}
else
{
transaction.status = false;
transaction.AddException(result.status.StatusMessage);
}
}
catch (Exception ex)
{
transaction.status = false;
transaction.AddException(ex.Message);
ReturnCode = HttpStatusCode.InternalServerError;
result.status = _eHandler.HandleException(ex);
_commonService.LogError(result.status);
}
return(Request.CreateResponse <TranInfo <bool> >(ReturnCode, transaction));
}
public HttpResponseMessage GetAccountSearch([FromBody] AccountSearch accountSearch)
{
AccountManagementService accService = new AccountManagementService();
HttpStatusCode ReturnCode = HttpStatusCode.OK;
TranInfo <SearchResult> transaction = new TranInfo <SearchResult>();
ReturnResult <SearchResult> result = new ReturnResult <SearchResult>();
try
{
result = accService.GetAccountSearch(accountSearch);
if (result.status.Status == StatusEnum.Success)
{
transaction.data = result.result;
transaction.status = true;
}
else
{
transaction.status = false;
transaction.AddException(result.status.StatusMessage);
}
}
catch (Exception ex)
{
transaction.status = false;
transaction.AddException(ex.Message);
ReturnCode = HttpStatusCode.InternalServerError;
result.status = _eHandler.HandleException(ex);
_commonService.LogError(result.status);
}
return(Request.CreateResponse <TranInfo <SearchResult> >(ReturnCode, transaction));
}
public HttpResponseMessage CreateCityUserAccount([FromBody] CityUserAccount_M cityUserModel)
{
System.Diagnostics.EventLog.WriteEntry("Application", "Controller Save Customer started");
AccountManagementService accService = new AccountManagementService();
IEmailService emailService = new EmailService();
HttpStatusCode ReturnCode = HttpStatusCode.OK;
TranInfo <CityUserAccount_M> transaction = new TranInfo <CityUserAccount_M>();
ReturnResult <CityUserAccount_M> result = new ReturnResult <CityUserAccount_M>();
try
{
result = accService.CreateCityUserAccount(cityUserModel);
if (result.status.Status == StatusEnum.Success)
{
//emailService.SendEmail(getRegisterCustomerEmailModel(result.result));
transaction.status = true;
}
else
{
transaction.status = false;
transaction.AddException(result.status.StatusMessage);
}
}
catch (Exception ex)
{
transaction.status = false;
transaction.AddException(ex.Message);
ReturnCode = HttpStatusCode.InternalServerError;
result.status = _eHandler.HandleException(ex);
_commonService.LogError(result.status);
}
return(Request.CreateResponse <TranInfo <CityUserAccount_M> >(ReturnCode, transaction));
}
public void Call_GetFirst_Correct_FromUserRepo()
{
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedUoW = new Mock <Func <IUnitOfWork> >();
var expecedUser = new User()
{
UserName = NonNullString
};
var list = new List <User>()
{
expecedUser,
new User()
{
UserName = "******"
}
};
Expression <Func <User, bool> > funcFromMethod = null;
Expression <Func <User, bool> > expectedString = x => x.UserName == NonNullString;
mockedUserRepo.Setup(x => x.GetFirst(It.IsAny <Expression <Func <User, bool> > >()))
.Callback <Expression <Func <User, bool> > >(r => funcFromMethod = r);
var service = new AccountManagementService(mockedUserRepo.Object, mockedUoW.Object);
service.UploadAvatar(NonNullString, NonNullString);
var result = list.FirstOrDefault(x => funcFromMethod.Compile()(x));
Assert.AreSame(expecedUser, result);
}
public bool DeleteUser(int id)
{
using var repositoriesContainer = new LmPlatformRepositoriesContainer();
var query = new Query <User>().AddFilterClause(u => u.Id == id).Include(u => u.ProjectUsers).Include(u => u.Student);
var user = repositoriesContainer.UsersRepository.GetBy(query);
repositoriesContainer.MessageRepository.DeleteUserMessages(user.Id);
var projects = user.ProjectUsers.DistinctBy(e => e.ProjectId).Select(e => e.ProjectId);
foreach (var projectId in projects)
{
ProjectManagementService.DeleteUserFromProject(id, projectId);
}
if (user.Student != null)
{
var acp = user.Student.AssignedCourseProjects.Select(e => e.CourseProjectId);
foreach (var acpId in acp)
{
CPManagementService.DeleteUserFromAcpProject(id, acpId);
}
var subjects = repositoriesContainer.RepositoryFor <SubjectStudent>()
.GetAll(new Query <SubjectStudent>(e => e.StudentId == id));
foreach (var subjectS in subjects)
{
repositoriesContainer.RepositoryFor <SubjectStudent>().Delete(subjectS);
}
var diplomas = Context.AssignedDiplomProjects.Where(e => e.StudentId == id).ToList();
var diplomasRessList = Context.DiplomPercentagesResults.Where(e => e.StudentId == id).ToList();
foreach (var diploma in diplomas)
{
Context.AssignedDiplomProjects.Remove(diploma);
Context.SaveChanges();
}
foreach (var diplomasRes in diplomasRessList)
{
Context.DiplomPercentagesResults.Remove(diplomasRes);
Context.SaveChanges();
}
}
CPManagementService.DeletePercenageAndVisitStatsForUser(id);
repositoriesContainer.ApplyChanges();
var result = AccountManagementService.DeleteAccount(user.UserName);
repositoriesContainer.ApplyChanges();
return(result);
}
public void Throw_ArgumentNullException_WithMsgCointainEmail_WhenEmailIsNull()
{
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedUoW = new Mock <Func <IUnitOfWork> >();
var service = new AccountManagementService(mockedUserRepo.Object, mockedUoW.Object);
Assert.That(() => service.IsEmailUnique(null),
Throws.ArgumentNullException.With.Message.Contain("email"));
}
public void ThrowArgumentNullException_WhenUnitOfWork_IsNull()
{
var mockedUserRepo = new Mock <IRepository <User> >();
Assert.Throws <ArgumentNullException>(() =>
{
var service = new AccountManagementService(mockedUserRepo.Object, null);
});
}
public void Throw_ArgumentNullException_WhenUserNameIsNull_WithMsgContainingUserName()
{
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedUoW = new Mock <Func <IUnitOfWork> >();
var service = new AccountManagementService(mockedUserRepo.Object, mockedUoW.Object);
Assert.That(() => service.GetUserAvatarUrl(null),
Throws.ArgumentNullException.With.Message.Contain("userName"));
}
public void UpdateUserAccountAsyncShouldNotWorkWithWrongData()
{
var testAccountRepository = GetTestAcctRepository().GetAwaiter().GetResult();
var testAccountManagementService = new AccountManagementService(this.userManager.Object, this.userRepository.Object, testAccountRepository, this.positionService.Object, this.feePaymentsRepository.Object);
Assert.ThrowsAsync <NullReferenceException>(async() =>
await testAccountManagementService.UpdateUserAccountAsync("-1", 10000M, 80M, 80M));
}
public void SetUp()
{
AuthUserContext = Substitute.For <IAuthenticatedUserContext>();
ItemReferences = Substitute.For <IItemReferences>();
EntitlementsContext = Substitute.For <IUserEntitlementsContext>();
SiteRoots = Substitute.For <ISiteRootsContext>();
AccountManagementService = new AccountManagementService(AuthUserContext, ItemReferences, EntitlementsContext, SiteRoots);
GeneralPage = Substitute.For <IGeneral_Content_Page>();
}
public void RegistrationUser(IList <string> roles)
{
AccountManagementService.CreateAccount(UserName, Password, roles, Email, requireConfirmationToken: false);
var user = UsersManagementService.GetUser(new Query <User>(e => e.UserName == UserName));
user.Email = Email;
UsersManagementService.UpdateUser(user);
}
public void CallGetAllMethod_FromUserRepo_Once(string email)
{
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedUoW = new Mock <Func <IUnitOfWork> >();
var service = new AccountManagementService(mockedUserRepo.Object, mockedUoW.Object);
service.IsEmailUnique(email);
mockedUserRepo.Verify(x => x.GetAll(It.IsAny <Expression <Func <User, bool> > >(), It.IsAny <Expression <Func <User, string> > >()), Times.Once);
}
public void ThrowArgumentNullException_WithMessageContaining_UserName_WhenUserNameIsNull()
{
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedUoW = new Mock <Func <IUnitOfWork> >();
var service = new AccountManagementService(mockedUserRepo.Object, mockedUoW.Object);
Assert.That(() => service.UploadAvatar(null, NonNullString),
Throws.ArgumentNullException.With.Message.Contain("userName"));
}
public void ThrowArgumentNullException_WithMessageContaining_AvatarUrl_WhenAvatarUrlIsEmpty()
{
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedUoW = new Mock <Func <IUnitOfWork> >();
var service = new AccountManagementService(mockedUserRepo.Object, mockedUoW.Object);
Assert.That(() => service.UploadAvatar(NonNullString, string.Empty),
Throws.ArgumentException.With.Message.Contain("avatarUrl"));
}
public void ThrowArgumentNullException_WhenUserRepo_IsNull()
{
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedUoW = new Mock <Func <IUnitOfWork> >();
Assert.Throws <ArgumentNullException>(() =>
{
var service = new AccountManagementService(null, mockedUoW.Object);
});
}
public void DoesNotThrow_WhenArgumentsAreValid()
{
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedUoW = new Mock <Func <IUnitOfWork> >();
Assert.DoesNotThrow(() =>
{
var service = new AccountManagementService(mockedUserRepo.Object, mockedUoW.Object);
});
}
public async Task DeleteUserAccountAsyncShouldCallUserManager()
{
var testAccountRepository = await GetTestAcctRepository();
var testAccountManagementService = new AccountManagementService(this.userManager.Object, this.userRepository.Object, testAccountRepository, this.positionService.Object, this.feePaymentsRepository.Object);
await testAccountManagementService.DeleteUserAccountAsync("1", 1);
this.userManager.Verify(u => u.RemoveFromRoleAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>()), Times.Once);
this.userManager.Verify(u => u.AddToRoleAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>()), Times.Once);
}
protected void signUpSubmit_Click(object sender, EventArgs e)
{
var patronFirstName = firstName.Value;
var patronLastName = lastName.Value;
var patronEmail = email.Value;
var patronPhoneNumber = mobileNumber.Value;
var patronPassword = password.Value;
// Validate form
// create account if validation successful
var accountHandler = new AccountManagementService();
accountHandler.CreateNewUser(new UserSetUp
{
FirstName = patronFirstName,
LastName = patronLastName,
Email = patronEmail,
PhoneNumber = patronPhoneNumber,
Password = patronPassword,
UserType = PatronUserGroup
});
// user key has been created
var userCredentials = new UserSession
{
UserName = patronEmail,
Password = patronPassword,
IpAddress = Request.UserHostAddress,
XForwardedFor = Request.Headers["X-Forwarded-For"],
Browser = HttpContext.Current.Request.Browser.Browser,
ServerName = Request.ServerVariables["SERVER_NAME"],
DateCreated = DateTime.Now,
UserKey = String.Empty
};
var authenticationHandler = new UserAuthenticationManagement();
UserSession userValidationResults = new UserSession();
userValidationResults = authenticationHandler.LogSessionForNewUserAfterSignUp(userCredentials);
if (userValidationResults.SessionValidated)
{
Response.Cookies["SessionInfo"].Value = userValidationResults.SessionKey;
Response.Cookies["SessionInfo"].Expires = DateTime.Now.AddHours(3);
Response.Cookies["User"].Value = userValidationResults.UserKey;
if (userValidationResults.UserGroup == PatronUserGroup)
{
Response.Redirect("/Clients/JoinQueue.aspx?profile=1");
}
}
}
public void Call_GetFirst_FromUserRepo()
{
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedUoW = new Mock <Func <IUnitOfWork> >();
var service = new AccountManagementService(mockedUserRepo.Object, mockedUoW.Object);
service.UploadAvatar(NonNullString, NonNullString);
mockedUserRepo.Verify(x => x.GetFirst(It.IsAny <Expression <Func <User, bool> > >()), Times.Once);
}
public void ReturnAndInstance_WhenAllArgumentsAreValid()
{
// Arrange
var mockedUnitOfWork = new Mock <Func <IUnitOfWorkEF> >();
var mockedCarsRepo = new Mock <IProjectableRepositoryEf <Car> >();
var mockedUserRepo = new Mock <IProjectableRepositoryEf <User> >();
// Act
var service = new AccountManagementService(mockedCarsRepo.Object, mockedUserRepo.Object, mockedUnitOfWork.Object);
// Assert
Assert.IsAssignableFrom <AccountManagementService>(service);
}
private AccountManagementService GetAcctManServiceWithTestUserManager(out Mock <UserManager <ApplicationUser> > testUserManager)
{
var testUserStoreMock = new Mock <IQueryableUserStore <ApplicationUser> >();
testUserManager = new Mock <UserManager <ApplicationUser> >(
testUserStoreMock.Object, null, null, null, null, null, null, null, null);
testUserManager
.Setup(u => u.Users)
.Returns(this.mockUsers.Object);
var testAccountManagementService = new AccountManagementService(testUserManager.Object, this.userRepository.Object, this.accountRepository.Object, this.positionService.Object, this.feePaymentsRepository.Object);
return(testAccountManagementService);
}
protected void signUpSubmit_Click(object sender, EventArgs e)
{
// Get values
var businessName = companyName.Value.Trim();
var businessAddress = address.Value.Trim();
var businessSeatingCapacity = seatingCapacity.Value.Trim();
var businessAdminFirstName = firstName.Value.Trim();
var businessAdminLastName = lastName.Value.Trim();
var businessAdminPhoneNumber = mobileNumber.Value.Trim();
var businessAdminEmail = email.Value.Trim();
var businessAdminPassword = password.Value.Trim();
// 1. Server Side Validation
bool formValuesValidationResult = ValidateRequest();
// 2. Save
if (formValuesValidationResult)
{
var businessAccountInformation = new BusinessAccountInformation()
{
BusinessName = businessName,
BusinessAddress = businessAddress,
Capacity = Convert.ToInt32(businessSeatingCapacity),
AdminFirstName = businessAdminFirstName,
AdminLastName = businessAdminLastName,
AdminPhone = businessAdminPhoneNumber,
AdminEmail = businessAdminEmail,
AdminPassword = businessAdminPassword
};
var accountSetService = new AccountManagementService();
var result = accountSetService.CreateNewBusinessAccount(businessAccountInformation);
if (result.BusinessAccountCreated)
{
UserMessage = "New Business Account created successfully.";
businessProfileUrl = "/Admins/ViewProfile?businessId=" + result.BusinessId.ToString();
ResetFieldValues();
}
else
{
UserMessage = "New Business Account failed to be created.";
}
}
else
{
// return error message
}
}
