/// <summary>
/// This method getting the list of all projects
/// </summary>
/// <returns>list of projects</returns>
public async Task <IEnumerable <ProjectAc> > GetAllProjectsAsync()
{
var projects = await _projectDataRepository.GetAll().ToListAsync();
var projectAcList = new List <ProjectAc>();
foreach (var project in projects)
{
var userAc = new UserAc();
if (!string.IsNullOrEmpty(project.TeamLeaderId))
{
var user = await _userDataRepository.FirstAsync(x => x.Id.Equals(project.TeamLeaderId));
userAc = _mapperContext.Map <ApplicationUser, UserAc>(user);
}
else
{
userAc.FirstName = _stringConstant.TeamLeaderNotAssign;
userAc.LastName = _stringConstant.TeamLeaderNotAssign;
userAc.Email = _stringConstant.TeamLeaderNotAssign;
}
var projectAc = _mapperContext.Map <Project, ProjectAc>(project);
projectAc.TeamLeader = userAc;
projectAc.CreatedBy = (await _userDataRepository.FirstAsync(x => x.Id == project.CreatedBy)).FirstName;
projectAc.CreatedDate = project.CreatedDateTime;
projectAc.UpdatedBy = (await _userDataRepository.FirstOrDefaultAsync(x => x.Id == project.UpdatedBy))?.FirstName;
projectAc.UpdatedDate = project.UpdatedDateTime;
projectAcList.Add(projectAc);
}
return(projectAcList);
}
public async Task TestChangePasswordAsync()
{
UserAc _testUser = new UserAc()
{
Email = _stringConstant.UserName,
FirstName = _stringConstant.FirstName,
LastName = _stringConstant.LastName,
IsActive = true,
SlackUserId = _stringConstant.SlackUserId,
UserName = _stringConstant.UserName,
SlackUserName = _stringConstant.SlackUserName,
JoiningDate = new DateTime(DateTime.UtcNow.Year, 3, 2),
RoleName = _stringConstant.Employee
};
string id = await _userRepository.AddUserAsync(_testUser, _stringConstant.RawFirstNameForTest);
ChangePasswordViewModel changePasswordViewModel = new ChangePasswordViewModel()
{
ConfirmPassword = _stringConstant.LastName,
Email = _stringConstant.UserName,
NewPassword = _stringConstant.LastName,
OldPassword = _stringConstant.SlackUserId,
};
var returnMessage = await _userRepository.ChangePasswordAsync(changePasswordViewModel);
Assert.NotEmpty(returnMessage.ErrorMessage);
}
public async Task <IActionResult> GetLoggedInUSer()
{
var username = User.Identity.Name;
if (username == null)
{
return(RedirectToAction("Login", "Account"));
}
else
{
AppUser user = await _userManager.FindByNameAsync(username);
var userRoles = await _userManager.GetRolesAsync(user);
UserAc userAC = new UserAc
{
Id = user.Id,
Name = user.Name,
Email = user.Email,
Roles = userRoles,
IsUserAllowedToDelete = user.IsUserAllowedToDelete,
IsUserAllowedToEdit = user.IsUserAllowedToEdit,
IsUserAllowedToPost = user.IsUserAllowedToPost
};
return(Ok(userAC));
}
}
/// <summary>
/// This method is used to edit the details of an existing user
/// </summary>
/// <param name="editedUser">Passed UserAc object</param>
/// <param name="updatedBy">Passed id of user who has updated this user.</param>
/// <returns>Updated user id.</returns>
public async Task <string> UpdateUserDetailsAsync(UserAc editedUser, string updatedBy)
{
var user = await _userManager.FindByIdAsync(editedUser.Id);
user.FirstName = editedUser.FirstName;
user.LastName = editedUser.LastName;
user.Email = editedUser.Email;
user.IsActive = editedUser.IsActive;
user.UpdatedBy = updatedBy;
user.UpdatedDateTime = DateTime.UtcNow;
user.NumberOfCasualLeave = editedUser.NumberOfCasualLeave;
user.NumberOfSickLeave = editedUser.NumberOfSickLeave;
await _userManager.UpdateAsync(user);
//get user roles
IList <string> listofUserRole = await _userManager.GetRolesAsync(user);
//remove user role
await _userManager.RemoveFromRoleAsync(user, listofUserRole.First());
//add new role of user.
await _userManager.AddToRoleAsync(user, editedUser.RoleName);
return(user.Id);
}
/// <summary>
/// The method is used to get list of projects along with its users for a specific teamleader - GA
/// </summary>
/// <param name="teamLeaderId">Id of the teamleader</param>
/// <returns>list of projects with users for a specific teamleader</returns>
public async Task <List <UserAc> > GetProjectUsersByTeamLeaderIdAsync(string teamLeaderId)
{
List <UserAc> userAcList = new List <UserAc>();
//Get projectid's for that specific teamleader
IEnumerable <int> projectIds = await _projectDataRepository.Fetch(x => x.TeamLeaderId.Equals(teamLeaderId)).Select(y => y.Id).ToListAsync();
//Get details of teamleader
ApplicationUser teamLeader = await _applicationUserDataRepository.FirstAsync(x => x.Id.Equals(teamLeaderId));
UserAc projectTeamLeader = _mapperContext.Map <ApplicationUser, UserAc>(teamLeader);
projectTeamLeader.Role = _stringConstant.TeamLeader;
userAcList.Add(projectTeamLeader);
//Get details of distinct employees for projects with that particular teamleader
var userIds = await _projectUserRepository.Fetch(x => projectIds.Contains(x.ProjectId)).Select(y => y.UserId).Distinct().ToListAsync();
foreach (var userId in userIds)
{
ApplicationUser user = await _applicationUserDataRepository.FirstAsync(x => x.Id.Equals(userId));
UserAc userAc = _mapperContext.Map <ApplicationUser, UserAc>(user);
userAc.Role = _stringConstant.Employee;
userAcList.Add(userAc);
}
return(userAcList);
}
/// <summary>
/// Method to assign teamleader and users in a project -GA
/// </summary>
/// <param name="project"></param>
/// <returns>members in a project</returns>
private async Task <ProjectAc> AssignTeamMembers(Project project)
{
//getting the teamleader details
ApplicationUser applicationUser = await _userDataRepository.FirstAsync(x => x.Id == project.TeamLeaderId);
UserAc teamLeader = _mapperContext.Map <ApplicationUser, UserAc>(applicationUser);
teamLeader.Role = _stringConstant.TeamLeader;
//mapping from project to projectAc
ProjectAc projectAc = _mapperContext.Map <Project, ProjectAc>(project);
projectAc.CreatedDate = project.CreatedDateTime;
projectAc.TeamLeader = teamLeader;
//getting users in the project
List <ProjectUser> projectUsers = await _projectUserDataRepository.Fetch(x => x.ProjectId == project.Id).ToListAsync();
foreach (var projectUser in projectUsers)
{
ApplicationUser user = await _userDataRepository.FirstAsync(x => x.Id == projectUser.UserId);
UserAc userAc = _mapperContext.Map <ApplicationUser, UserAc>(user);
userAc.Role = _stringConstant.Employee;
projectAc.ApplicationUsers.Add(userAc);
}
return(projectAc);
}
/// <summary>
/// Method is used to return a user after assigning a role and mapping from ApplicationUser class to UserAc class - GA
/// </summary>
/// <param name="user">Details of application user</param>
/// <returns>user</returns>
private async Task <UserAc> GetUserAsync(ApplicationUser user)
{
//Gets a list of roles the specified user belongs to
string roles = (await _userManager.GetRolesAsync(user)).First();
UserAc newUser = _mapperContext.Map <ApplicationUser, UserAc>(user);
//assign role
newUser.Role = roles;
return(newUser);
}
public UserAc GetUser(AppUser user)
{
UserAc userAC = new UserAc();
userAC.Id = user.Id;
userAC.Name = user.Name;
userAC.Email = user.Email;
return(userAC);
}
public async Task <IActionResult> RegisterUserAsync([FromBody] UserAc newUser)
{
if (ModelState.IsValid)
{
string createdBy = _userManager.GetUserId(User);
await _userRepository.AddUserAsync(newUser, createdBy);
return(Ok(true));
}
return(BadRequest());
}
/// <summary>
/// This method used for get user detail by user id
/// </summary>
/// <param name="id">Passed user id</param>
/// <returns>UserAc application class object</returns>
public async Task <UserAc> GetByIdAsync(string id)
{
ApplicationUser applicationUser = await _userManager.FindByIdAsync(id);
if (applicationUser != null)
{
UserAc userAc = _mapperContext.Map <ApplicationUser, UserAc>(applicationUser);
userAc.RoleName = (await _userManager.GetRolesAsync(applicationUser)).First();
return(userAc);
}
throw new UserNotFound();
}
/// <summary>
/// Creates mock user
/// </summary>
/// <returns>id of user created</returns>
private async Task <string> MockOfUserAc()
{
UserAc user = new UserAc()
{
Email = _stringConstant.RawEmailIdForTest,
JoiningDate = DateTime.UtcNow,
IsActive = true,
RoleName = _stringConstant.Employee
};
return(await _userRepository.AddUserAsync(user, _stringConstant.RawFirstNameForTest));
}
public async Task <IActionResult> RegisterUserAsync([FromBody] UserAc newUser)
{
if (ModelState.IsValid)
{
newUser.JoiningDate = DateTime.ParseExact(newUser.JoinDate, _stringConstant.DateFormatForJoinnigDate, CultureInfo.InvariantCulture);
string createdBy = _userManager.GetUserId(User);
await _userRepository.AddUserAsync(newUser, createdBy);
return(Ok(true));
}
return(BadRequest());
}
public async Task <IActionResult> UpdateUserAsync(string id, [FromBody] UserAc editedUser)
{
if (ModelState.IsValid)
{
string updatedBy = _userManager.GetUserId(User);
editedUser.Id = id;
await _userRepository.UpdateUserDetailsAsync(editedUser, updatedBy);
return(Ok(true));
}
return(BadRequest());
}
/// <summary>
/// This method is used to create new user.
/// </summary>
/// <returns></returns>
public async Task <string> CreateMockAndUserAsync()
{
UserAc _testUser = new UserAc()
{
Email = _stringConstant.UserName,
FirstName = _stringConstant.FirstName,
LastName = _stringConstant.LastName,
IsActive = true,
SlackUserId = _stringConstant.SlackUserId,
UserName = _stringConstant.UserName,
SlackUserName = _stringConstant.SlackUserName,
JoiningDate = DateTime.UtcNow,
RoleName = _stringConstant.Employee
};
return(await _userRepository.AddUserAsync(_testUser, _stringConstant.RawFirstNameForTest));
}
public async Task GetUserRoleAdmin()
{
UserAc _testUser = new UserAc()
{
Email = _stringConstant.RawEmailIdForTest,
FirstName = _stringConstant.RawFirstNameForTest,
LastName = _stringConstant.RawLastNameForTest,
IsActive = true,
UserName = _stringConstant.RawEmailIdForTest,
JoiningDate = DateTime.UtcNow,
RoleName = _stringConstant.Admin
};
string id = await _userRepository.AddUserAsync(_testUser, _stringConstant.CreatedBy);
var userRole = await _userRepository.GetUserRoleAsync(id);
Assert.Equal(1, userRole.Count());
}
public async Task CalculateAllowedLeavesForFutureyear()
{
UserAc _testUser = new UserAc()
{
Email = _stringConstant.RawEmailIdForTest,
FirstName = _stringConstant.RawFirstNameForTest,
LastName = _stringConstant.RawLastNameForTest,
IsActive = true,
UserName = _stringConstant.RawEmailIdForTest,
JoiningDate = DateTime.UtcNow.AddYears(+1),
RoleName = _stringConstant.Employee
};
string id = await _userRepository.AddUserAsync(_testUser, _stringConstant.CreatedBy);
var user = await _userManager.FindByIdAsync(id);
Assert.NotNull(user);
}
/// <summary>
/// This method is used to add new user
/// </summary>
/// <param name="newUser">Passed userAC object</param>
/// <param name="createdBy">Passed id of user who has created this user.</param>
/// <returns>Added user id</returns>
public async Task <string> AddUserAsync(UserAc newUser, string createdBy)
{
LeaveAllowed leaveAllowed = CalculateAllowedLeaves(Convert.ToDateTime(newUser.JoiningDate));
newUser.NumberOfCasualLeave = leaveAllowed.CasualLeave;
newUser.NumberOfSickLeave = leaveAllowed.SickLeave;
var user = _mapperContext.Map <UserAc, ApplicationUser>(newUser);
user.UserName = user.Email;
user.CreatedBy = createdBy;
user.CreatedDateTime = DateTime.UtcNow;
string password = GetRandomString();//get readom password.
await _userManager.CreateAsync(user, password);
await _userManager.AddToRoleAsync(user, newUser.RoleName); //add role of new user.
SendEmail(user.FirstName, user.Email, password); //send mail with generated password of new user.
return(user.Id);
}
/// <summary>
/// Method is used to return a user after assigning a role and mapping from ApplicationUser class to UserAc class - GA
/// </summary>
/// <param name="user">Details of application user</param>
/// <returns>user</returns>
private async Task <UserAc> GetUserAsync(ApplicationUser user)
{
//Gets a list of roles the specified user belongs to
string roles = (await _userManager.GetRolesAsync(user)).First();
UserAc newUser = _mapperContext.Map <ApplicationUser, UserAc>(user);
//assign role
if (roles.Equals(_stringConstant.Admin))
{
newUser.Role = roles;
}
else
{
Project project = await _projectDataRepository.FirstOrDefaultAsync(x => x.TeamLeaderId.Equals(user.Id));
newUser.Role = (project != null) ? _stringConstant.TeamLeader : _stringConstant.Employee;
}
return(newUser);
}
public async Task AddUserWithJuneJoiningDate()
{
UserAc _testUser = new UserAc()
{
Email = _stringConstant.UserName,
FirstName = _stringConstant.FirstName,
LastName = _stringConstant.LastName,
IsActive = true,
SlackUserId = _stringConstant.SlackUserId,
UserName = _stringConstant.UserName,
SlackUserName = _stringConstant.SlackUserName,
JoiningDate = new DateTime(DateTime.UtcNow.Year, 6, 16),
RoleName = _stringConstant.Employee
};
string id = await _userRepository.AddUserAsync(_testUser, _stringConstant.RawFirstNameForTest);
var user = await _userManager.FindByIdAsync(id);
Assert.NotNull(user);
}
public async Task UserDetailByIdOfAdminUser()
{
UserAc _testUser = new UserAc()
{
Email = _stringConstant.UserName,
FirstName = _stringConstant.FirstName,
LastName = _stringConstant.LastName,
IsActive = true,
SlackUserId = _stringConstant.SlackUserId,
UserName = _stringConstant.UserName,
SlackUserName = _stringConstant.SlackUserName,
JoiningDate = DateTime.UtcNow,
RoleName = _stringConstant.Admin
};
string id = await _userRepository.AddUserAsync(_testUser, _stringConstant.RawFirstNameForTest);
var user = await _userRepository.UserDetailByIdAsync(id);
Assert.Equal(user.Email, _stringConstant.UserName);
}
public async Task ManagementDetails()
{
await CreateMockAndUserAsync();
UserAc userLocal = new UserAc()
{
Email = _stringConstant.Email,
FirstName = _stringConstant.RawFirstNameForTest,
LastName = _stringConstant.RawLastNameForTest,
IsActive = true,
UserName = _stringConstant.Email,
JoiningDate = DateTime.UtcNow,
RoleName = _stringConstant.Admin
};
string id = await _userRepository.AddUserAsync(userLocal, _stringConstant.RawFirstNameForTest);
var user = await _userRepository.ListOfManagementDetailsAsync();
Assert.Equal(1, user.Count);
}
public async Task GetActiveUserWithAdminRole()
{
string userId = await CreateMockAndUserAsync();
ProjectAc projectac = new ProjectAc()
{
Name = _stringConstant.Name,
IsActive = _stringConstant.IsActive,
TeamLeader = new UserAc {
FirstName = _stringConstant.FirstName
},
TeamLeaderId = userId,
CreatedBy = _stringConstant.CreatedBy
};
var projectId = await _projectRepository.AddProjectAsync(projectac, _stringConstant.CreatedBy);
ProjectUser projectUser = new ProjectUser()
{
ProjectId = projectId,
UserId = userId,
CreatedBy = userId,
CreatedDateTime = DateTime.UtcNow,
};
await _projectRepository.AddUserProjectAsync(projectUser);
UserAc _testUser = new UserAc()
{
Email = _stringConstant.RawEmailIdForTest,
FirstName = _stringConstant.RawFirstNameForTest,
LastName = _stringConstant.RawLastNameForTest,
IsActive = true,
UserName = _stringConstant.RawEmailIdForTest,
JoiningDate = DateTime.UtcNow,
RoleName = _stringConstant.Admin
};
string id = await _userRepository.AddUserAsync(_testUser, _stringConstant.CreatedBy);
var userRole = await _userRepository.GetUserRoleAsync(id);
Assert.Equal(2, userRole.Count());
}
/// <summary>
/// mock of users data.
/// </summary>
/// <returns></returns>
private List <UserAc> GetUserListMockData()
{
List <UserAc> userlist = new List <UserAc>();
UserAc user = new UserAc()
{
FirstName = _stringConstant.FirstName
};
UserAc userSecound = new UserAc()
{
Id = _stringConstant.UserIdSecond, FirstName = _stringConstant.FirstNameSecond
};
UserAc userThird = new UserAc()
{
Id = _stringConstant.UserIdThird, FirstName = _stringConstant.FirstNameThird
};
userlist.Add(user);
userlist.Add(userSecound);
userlist.Add(userThird);
return(userlist);
}
public async Task <IActionResult> ForgotPassword(UserAc userAc)
{
if (string.IsNullOrEmpty(userAc.Email))
{
ModelState.AddModelError("Email", "Email can not be null or empty");
}
else
{
ApplicationUser user = await _userManager.FindByEmailAsync(userAc.Email);
if (user == null)
{
ModelState.AddModelError("Email", "User does not exist");
}
else
{
await _userManagementRepository.SendForgotPasswordEmailAsync(user);
userAc.IsForgotPasswordMailSent = true;
}
}
return(View(userAc));
}
