public async Task GetUserByCriteriaTest()
{
var searchCrit = new UserSearchCriteria
{
EmployeeID = "EP001",
FirstName = "F1",
LastName = "L2"
};
var pmoUser = new PMOUser
{
EmployeeId = "EP001",
FirstName = "F1",
LastName = "L2",
Id = "Usr/1"
};
var mockUserRepo = new Mock <IUserRepo>();
var mockProjectTaskRepo = new Mock <IProjectTaskRepo>();
var mockMapper = new Mock <IMapper>();
var logger = createUserLogger();
mockUserRepo.Setup(usrRepo => usrRepo.GetAllUserMatchAnyCriteria(It.IsAny <UserSearchCriteria>()))
.Returns(Task.FromResult(new List <PMOUser> {
pmoUser
}));
var userService = new UserService(mockUserRepo.Object, mockProjectTaskRepo.Object, logger,
mockMapper.Object);
var result = await userService.GetUserByCriteria(searchCrit);
Assert.NotEmpty(result);
}
public async Task EditUserTest()
{
var result = new Tuple <bool, string>(true, "Usr/1");
var userMod = new UserModMsg
{
EmployeeId = "EP001",
FirstName = "F1",
LastName = "L2",
Id = "Usr/1"
};
var pmoUser = new PMOUser
{
EmployeeId = userMod.EmployeeId,
FirstName = userMod.FirstName,
LastName = userMod.LastName
};
var mockUserRepo = new Mock <IUserRepo>();
var mockProjectTaskRepo = new Mock <IProjectTaskRepo>();
var logger = createUserLogger();
mockUserRepo.Setup(usrRepo => usrRepo.EditUser(It.IsAny <PMOUser>()))
.Returns(Task.FromResult(result));
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(map => map.Map <PMOUser>(It.IsAny <UserModMsg>())).Returns(pmoUser);
var userService = new UserService(mockUserRepo.Object, mockProjectTaskRepo.Object, logger,
mockMapper.Object);
var modResult = await userService.Edit(userMod);
Assert.True(modResult.Item1);
Assert.Equal("Usr/1", modResult.Item2);
}
public async Task <IActionResult> RegisterPMO([FromBody] PMOUser userdetails)
{
string email = userdetails.email;
if (!ModelState.IsValid || email == null)
{
return(new BadRequestObjectResult(new { Message = "User Registration Failed" }));
}
string username = email.Substring(0, email.IndexOf("@"));
var identityUser = new IdentityUser()
{
UserName = username, Email = email
};
string password = "******";
var result = await userManager.CreateAsync(identityUser, password);
if (!result.Succeeded)
{
var dictionary = new ModelStateDictionary();
foreach (IdentityError error in result.Errors)
{
dictionary.AddModelError(error.Code, error.Description);
}
return(new BadRequestObjectResult(new { Message = "User Registration Failed", Errors = dictionary }));
}
await userManager.AddToRoleAsync(identityUser, "PMO");
return(Ok(new { Message = "User Reigstration Successful" }));
}
public async Task <ActionResult> RemovePmoUser([FromBody] PMOUser userdetails)
{
string username = userdetails.email.Substring(0, userdetails.email.IndexOf("@"));
var user = await userManager.FindByNameAsync(username);
if (user == null)
{
return(NotFound());
}
await userManager.RemoveFromRoleAsync(user, "PMO");
return(Ok());
}
public async Task <Tuple <bool, string> > AddUser(PMOUser pmoUser)
{
try
{
await asyncDocumentSession.StoreAsync(pmoUser);
await asyncDocumentSession.SaveChangesAsync();
return(new Tuple <bool, string>(true, pmoUser.Id));
}
catch (Exception ex)
{
throw ex;
}
}
public void GetterSetter()
{
var pmoUser = new PMOUser
{
EmployeeId = "E001",
FirstName = "First",
LastName = "Last",
Id = "PMOUser/1"
};
Assert.Equal("E001", pmoUser.EmployeeId);
Assert.Equal("First", pmoUser.FirstName);
Assert.Equal("Last", pmoUser.LastName);
Assert.Equal("PMOUser/1", pmoUser.Id);
}
public async Task <bool> DeleteUser(PMOUser pmoUser)
{
var dbPmoUser = await asyncDocumentSession.Query <PMOUser>()
.Where(user => user.EmployeeId == pmoUser.EmployeeId)
.FirstOrDefaultAsync();
try
{
asyncDocumentSession.Delete <PMOUser>(pmoUser);
await asyncDocumentSession.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task GetEmployeeById()
{
var mockUserService = new Mock <IUserService>();
var pmoUser = new PMOUser
{
EmployeeId = "EP001",
FirstName = "F1",
LastName = "L2"
};
mockUserService.Setup(usr => usr.GetUserByEmployeeId(It.IsAny <string>()))
.Returns(Task.FromResult(pmoUser));
var userLogger = createUserLogger();
var usrController = new UserController(mockUserService.Object, userLogger);
var actionResult = (await usrController.GetEmployeeById("EP001")).Result as OkObjectResult;
Assert.NotNull(actionResult);
var result = actionResult.Value as PMOUser;
Assert.NotNull(result);
}
public async Task Delete(int projUserCount, int taskUserCount)
{
var pmoUser = new PMOUser
{
EmployeeId = "EP001",
FirstName = "F1",
LastName = "L2",
Id = "Usr/1"
};
var mockUserRepo = new Mock <IUserRepo>();
var mockProjectTaskRepo = new Mock <IProjectTaskRepo>();
var logger = createUserLogger();
mockUserRepo.Setup(userRepo => userRepo.GetUserByEmployeeId(It.IsAny <string>()))
.Returns(Task.FromResult(pmoUser));
mockUserRepo.Setup(userRepo => userRepo.DeleteUser(pmoUser)).Returns(Task.FromResult(true));
var mockMapper = new Mock <IMapper>();
mockProjectTaskRepo.Setup(projTskRepo => projTskRepo.GetProjectCountByPM(It.IsAny <string>()))
.Returns(Task.FromResult(projUserCount));
mockProjectTaskRepo.Setup(projTskRepo => projTskRepo.GetTaskCountByUser(It.IsAny <string>()))
.Returns(Task.FromResult(taskUserCount));
var userService = new UserService(mockUserRepo.Object, mockProjectTaskRepo.Object, logger,
mockMapper.Object);
if (projUserCount > 0)
{
await Assert.ThrowsAsync <ApplicationException>(async() => await userService.Delete("EP001"));
}
else if (taskUserCount > 0)
{
await Assert.ThrowsAsync <ApplicationException>(async() => await userService.Delete("EP001"));
}
else
{
var delResult = await userService.Delete("EP001");
Assert.True(delResult);
}
}
public async Task GetUserByEmployeeIdTest()
{
var pmoUser = new PMOUser
{
EmployeeId = "EP001",
FirstName = "F1",
LastName = "L2",
Id = "Usr/1"
};
var mockUserRepo = new Mock <IUserRepo>();
var mockProjectTaskRepo = new Mock <IProjectTaskRepo>();
var mockMapper = new Mock <IMapper>();
var logger = createUserLogger();
mockUserRepo.Setup(usrRepo => usrRepo.GetUserByEmployeeId(It.IsAny <string>()))
.Returns(Task.FromResult(pmoUser));
var userService = new UserService(mockUserRepo.Object, mockProjectTaskRepo.Object, logger,
mockMapper.Object);
var result = await userService.GetUserByEmployeeId("EP001");
Assert.NotNull(result);
}
public async Task GetAllEmployee()
{
var mockUserService = new Mock <IUserService>();
var pmoUser = new PMOUser
{
EmployeeId = "EP001",
FirstName = "F1",
LastName = "L2"
};
var pmoList = new List <PMOUser> {
pmoUser
};
mockUserService.Setup(usr => usr.GetAllUser()).Returns(Task.FromResult(pmoList));
var userLogger = createUserLogger();
var usrController = new UserController(mockUserService.Object, userLogger);
var actionResult = (await usrController.GetAllEmployee()).Result as OkObjectResult;
Assert.NotNull(actionResult);
var result = actionResult.Value as List <PMOUser>;
Assert.NotEmpty(result);
}
public async Task SearchUserTest()
{
var mockUserService = new Mock <IUserService>();
var pmoUser = new PMOUser
{
EmployeeId = "EP001",
FirstName = "F1",
LastName = "L2"
};
mockUserService.Setup(usr => usr.GetUserByCriteria(It.IsAny <UserSearchCriteria>()))
.Returns(Task.FromResult(new List <PMOUser> {
pmoUser
}));
var userLogger = createUserLogger();
var usrController = new UserController(mockUserService.Object, userLogger);
var actionResult = (await usrController.SearchUser("EP001", "F1", "L2")).Result as OkObjectResult;
Assert.NotNull(actionResult);
var result = actionResult.Value as List <PMOUser>;
Assert.NotEmpty(result);
}
public async Task <Tuple <bool, string> > EditUser(PMOUser pmoUser)
{
var dbPmoUser = await asyncDocumentSession.Query <PMOUser>()
.Where(user => user.EmployeeId == pmoUser.EmployeeId)
.FirstOrDefaultAsync();
if (dbPmoUser == default)
{
throw new ApplicationException("Provided user is not yet added in DB");
}
dbPmoUser.EmployeeId = pmoUser.EmployeeId;
dbPmoUser.FirstName = pmoUser.FirstName;
dbPmoUser.LastName = pmoUser.LastName;
try
{
await asyncDocumentSession.SaveChangesAsync();
return(new Tuple <bool, string>(true, dbPmoUser.Id));
}
catch (Exception ex)
{
throw ex;
}
}
protected async Task ManageUserCollection()
{
var pmoUser1 = new PMOUser
{
EmployeeId = "EP001",
LastName = "L1",
FirstName = "F1"
};
var pmoUser2 = new PMOUser
{
EmployeeId = "EP002",
LastName = "L2",
FirstName = "F2"
};
var pmoUser3 = new PMOUser
{
EmployeeId = "EP003",
LastName = "L3",
FirstName = "F3"
};
var pmoUser4 = new PMOUser
{
EmployeeId = "E004",
LastName = "L4",
FirstName = "F4"
};
var pmoUser5 = new PMOUser
{
EmployeeId = "EP005",
LastName = "L5",
FirstName = "F5"
};
using (var session = DocStore.OpenAsyncSession())
{
var userCollectionLock = await session.Query <UserCollectionLock>()
.FirstOrDefaultAsync();
if ((userCollectionLock == default) || (!userCollectionLock.IsUserCollectionAdded))
{
var logger = createUserLogger();
var userRepo = new UserRepo(session, logger);
var result = await userRepo.AddUser(pmoUser1);
result = await userRepo.AddUser(pmoUser2);
result = await userRepo.AddUser(pmoUser3);
result = await userRepo.AddUser(pmoUser4);
result = await userRepo.AddUser(pmoUser5);
userCollectionLock = new UserCollectionLock {
IsUserCollectionAdded = true
};
await session.StoreAsync(userCollectionLock);
await session.SaveChangesAsync();
}
}
}
