/// <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)); }