/// <summary>
/// This method to return all project for specific user
/// </summary>
/// <param name="userId">passed login user id</param>
/// <returns>project information</returns>
public async Task <IEnumerable <ProjectAc> > GetAllProjectForUserAsync(string userId)
{
List <ProjectAc> projectAcList = new List <ProjectAc>();
//list of project where specific user are team leader.
var projects = await _projectDataRepository.Fetch(x => x.TeamLeaderId == userId).ToListAsync();
if (projects != null)
{
foreach (var project in projects)
{
var teamLeader = await _userManager.FindByIdAsync(project.TeamLeaderId);
var projectMapper = _mapperContext.Map <ApplicationUser, UserAc>(teamLeader);
ProjectAc projectAc = _mapperContext.Map <Project, ProjectAc>(project);
projectAc.TeamLeader = projectMapper;
projectAcList.Add(projectAc);
}
}
//list of project where user are as team member.
var projectUser = await _projectUserDataRepository.Fetch(x => x.UserId == userId).ToListAsync();
foreach (var project in projectUser)
{
var projectDetails = await _projectDataRepository.FirstAsync(x => x.Id == project.ProjectId);
var teamLeader = await _userManager.FindByIdAsync(projectDetails.TeamLeaderId);
var projectMapper = _mapperContext.Map <ApplicationUser, UserAc>(teamLeader);
ProjectAc projectAc = _mapperContext.Map <Project, ProjectAc>(projectDetails);
projectAc.TeamLeader = projectMapper;
projectAcList.Add(projectAc);
}
return(projectAcList);
}
/// <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>
/// this method to check Project and SlackChannelName is already exists or not
/// </summary>
/// <param name="project">projectAc object</param>
/// <returns>projectAc object</returns>
public async Task <ProjectAc> CheckDuplicateProjectAsync(ProjectAc project)
{
string projectName;
string slackChannelName;
if (project.Id == 0) // for new project
{
projectName = (await _projectDataRepository.FirstOrDefaultAsync(x => x.Name == project.Name))?.Name;
slackChannelName = (await _projectDataRepository.FirstOrDefaultAsync(x => x.SlackChannelName == project.SlackChannelName))?.SlackChannelName;
}
else // for edit project
{
projectName = (await _projectDataRepository.FirstOrDefaultAsync(x => x.Id != project.Id && x.Name == project.Name))?.Name;
slackChannelName = (await _projectDataRepository.FirstOrDefaultAsync(x => x.Id != project.Id && x.SlackChannelName == project.SlackChannelName))?.SlackChannelName;
}
if (string.IsNullOrEmpty(projectName) && string.IsNullOrEmpty(slackChannelName))
{
return(project);
}
//if project name already exists then return project name as null
if (!string.IsNullOrEmpty(projectName) && string.IsNullOrEmpty(slackChannelName))
{
project.Name = null; return(project);
}
//if slack channel name already exists then return slack channel name as null
if (string.IsNullOrEmpty(projectName) && !string.IsNullOrEmpty(slackChannelName))
{
project.SlackChannelName = null; return(project);
}
//if project name and slack channel name both are exists then return both as null.
project.Name = null; project.SlackChannelName = null; return(project);
}
public async Task <IActionResult> AddProjectAsync([FromBody] ProjectAc project)
{
if (ModelState.IsValid)
{
var createdBy = _userManager.GetUserId(User);
ProjectAc projectAc = await _projectRepository.CheckDuplicateProjectAsync(project);
if (!string.IsNullOrEmpty(projectAc.Name) && !string.IsNullOrEmpty(projectAc.SlackChannelName))
{
int projectId = await _projectRepository.AddProjectAsync(project, createdBy);
foreach (var applicationUser in project.ApplicationUsers)
{
ProjectUser projectUser = new ProjectUser();
projectUser.ProjectId = projectId;
projectUser.UserId = applicationUser.Id;
projectUser.CreatedBy = createdBy;
projectUser.CreatedDateTime = DateTime.UtcNow;
await _projectRepository.AddUserProjectAsync(projectUser);
}
return(Ok(project));
}
else
{
return(Ok(project));
}
}
else
{
return(BadRequest());
}
}
public async Task GetProjectUserBySlackChannelNameAsync()
{
string userId = await CreateMockAndUserAsync();
ProjectAc projectac = new ProjectAc();
projectac.Name = _stringConstant.Name;
projectac.SlackChannelName = _stringConstant.SlackChannelName;
projectac.IsActive = _stringConstant.IsActive;
projectac.TeamLeader = new UserAc {
FirstName = _stringConstant.FirstName
};
projectac.TeamLeaderId = _stringConstant.TeamLeaderId;
projectac.CreatedBy = _stringConstant.CreatedBy;
int projectId = await _projectRepository.AddProjectAsync(projectac, _stringConstant.CreatedBy);
ProjectUser projectUser = new ProjectUser()
{
ProjectId = projectId,
UserId = userId,
CreatedBy = userId,
CreatedDateTime = DateTime.UtcNow,
};
await _projectRepository.AddUserProjectAsync(projectUser);
var projectUsers = await _userRepository.GetProjectUserBySlackChannelNameAsync(projectac.SlackChannelName);
Assert.Equal(projectUsers.Count, 1);
}
public async Task <IActionResult> EditProjectAsync(int id, [FromBody] ProjectAc project)
{
try
{
if (ModelState.IsValid)
{
var updatedBy = _userManager.GetUserId(User);
ProjectAc projectAc = await _projectRepository.CheckDuplicateProjectAsync(project);
if (!string.IsNullOrEmpty(projectAc.Name) && !string.IsNullOrEmpty(projectAc.SlackChannelName))
{
await _projectRepository.EditProjectAsync(id, project, updatedBy);
}
else
{
return(Ok(project));
}
}
return(Ok(project));
}
catch (ProjectNotFound)
{
return(NotFound());
}
}
public async Task EditProject()
{
List <UserAc> userlist = GetUserListMockData();
var id = await GetProjectMockData();
await GetProjectUserMockData();
ProjectAc projectacSecound = new ProjectAc()
{
Id = id,
Name = _stringConstant.EditName,
IsActive = _stringConstant.IsActive,
TeamLeader = new UserAc {
FirstName = _stringConstant.FirstName
},
TeamLeaderId = _stringConstant.TeamLeaderId,
CreatedBy = _stringConstant.CreatedBy,
CreatedDate = DateTime.UtcNow,
ApplicationUsers = userlist
};
await _projectRepository.EditProjectAsync(id, projectacSecound, _stringConstant.CreatedBy);
var project = _dataRepository.Fetch(x => x.Id == 1);
_dataRepositoryProjectUser.Fetch(x => x.ProjectId == 1);
Assert.NotNull(project);
}
public async Task GetTeamMembersAsync()
{
string userId = await CreateMockAndUserAsync();
ProjectAc projectac = new ProjectAc()
{
Name = _stringConstant.Name,
SlackChannelName = _stringConstant.SlackChannelName,
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);
var userRole = await _userRepository.GetTeamMembersAsync(userId);
Assert.Equal(2, userRole.Count());
}
/// <summary>
/// Method to return the details of scrum for a particular project
/// </summary>
/// <param name="projectId">project Id</param>
/// <param name="scrumDate">Date of scrum</param>
/// <param name="userId">userId of user</param>
/// <returns>Details of the scrum</returns>
public async Task <ScrumProjectDetails> ScrumReportDetailsAsync(int projectId, DateTime scrumDate, string userId)
{
_logger.Debug("start Method : " + scrumDate + "projectId :" + projectId);
//Getting details of the logged in user from Oauth server
User loginUser = await _oauthCallsRepository.GetUserByEmployeeIdAsync(userId);
//Getting details of the specific project from Oauth server
ProjectAc project = await _oauthCallsRepository.GetProjectDetailsAsync(projectId);
//Getting scrum for a specific project
Scrum scrum = await _scrumDataRepository.FirstOrDefaultAsync(x => x.ProjectId == project.Id && DbFunctions.TruncateTime(x.ScrumDate) == DbFunctions.TruncateTime(scrumDate));
_logger.Debug("scrume object: " + scrum);
ScrumProjectDetails scrumProjectDetail = new ScrumProjectDetails();
scrumProjectDetail.ScrumDate = scrumDate.ToString(_stringConstant.FormatForDate);
if (scrum != null)
{
scrumProjectDetail.ProjectCreationDate = project.CreatedDate;
if (loginUser.Role == _stringConstant.Admin)
{
project.TeamLeaderId = loginUser.Id;
}
//getting scrum answers of employees in a specific project
scrumProjectDetail.EmployeeScrumAnswers = await GetEmployeeScrumDetailsAsync(project, scrum, loginUser, scrumDate);
}
return(scrumProjectDetail);
}
public async void TestGetProjectUsersByTeamLeaderId()
{
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);
var projectUsers = await _userRepository.GetProjectUsersByTeamLeaderIdAsync(userId);
Assert.Equal(2, projectUsers.Count);
}
public async Task GetProjectByGroupNameException()
{
ProjectAc projectAc = MockOfProjectAc();
await _projectRepository.AddProjectAsync(projectAc, _stringConstant.CreatedBy);
Assert.Throws <AggregateException>(() => _projectRepository.GetProjectBySlackChannelNameAsync("test").Result);
}
/// <summary>
/// Check various conditions before linking or unlinking slack channels to OAuth projects- JJ
/// </summary>
/// <param name="slackUserId">UserId of slack user</param>
/// <param name="slackChannelId">slack channel id from which message is send</param>
/// <param name="givenProjectName">the project name mentioned in the slack message</param>
/// <param name="command">link or unlink</param>
/// <returns>appropriate message</returns>
private async Task <string> ProcessCommandsAsync(string slackUserId, string slackChannelId, string givenProjectName, string command)
{
//Checks whether channelId starts with "G" or "C". This is done inorder to make sure that only gruops or channels are added manually
if (IsPrivateChannel(slackChannelId))
{
var accessToken = await GetAccessToken(slackUserId);
if (accessToken != null)
{
ApplicationUser appUser = await _applicationUser.FirstAsync(x => x.SlackUserId == slackUserId);
//the project which is mentioned by user
ProjectAc project = (await _oauthCallsRepository.GetListOfProjectsEnrollmentOfUserByUserIdAsync(appUser.Id, accessToken)).FirstOrDefault(x => String.Compare(givenProjectName, x.Name, StringComparison.OrdinalIgnoreCase) == 0);
if (project != null)
{
//check whether user is the team leader of the project
if (project.TeamLeader != null && project.TeamLeaderId == appUser.Id)
{
if (project.TeamLeader.IsActive)
{
//command to link
if (String.Compare(command, _stringConstant.Link, StringComparison.OrdinalIgnoreCase) == 0)
{
return(await LinkAsync(slackChannelId, givenProjectName, project));
}
//command to unlink
else if (String.Compare(command, _stringConstant.Unlink, StringComparison.OrdinalIgnoreCase) == 0)
{
return(await UnlinkAsync(slackChannelId, givenProjectName, project));
}
return(string.Empty);
}
else
{
return(string.Format(_stringConstant.NotActiveUser, slackUserId));
}
}
else
{
return(string.Format(_stringConstant.NotTeamLeader, slackUserId));
}
}
else
{
return(string.Format(_stringConstant.NotTeamLeaderOfProject, givenProjectName, slackUserId));
}
}
else
{
// if user doesn't exist then this message will be shown to user
return(_stringConstant.YouAreNotInExistInOAuthServer);
}
}
else
{
return(_stringConstant.OnlyPrivateChannel);
}
}
/// <summary>
/// Method to return project details by using projectId - GA
/// </summary>
/// <param name="projectId">passed project Id</param>
/// <returns>project details along with users</returns>
public async Task <ProjectAc> GetProjectDetailsAsync(int projectId)
{
Project project = await _projectDataRepository.FirstOrDefaultAsync(x => x.Id == projectId);
ProjectAc projectAc = await AssignTeamMembers(project);
return(projectAc);
}
public async Task CheckDuplicateNegative()
{
ProjectAc projectAc = MockOfProjectAc();
await _projectRepository.AddProjectAsync(projectAc, _stringConstant.CreatedBy);
var project = await _projectRepository.CheckDuplicateProjectAsync(projectAc);
Assert.Null(project.Name);
}
/// <summary>
/// mock data of project
/// </summary>
/// <returns></returns>
private async Task <int> GetProjectMockData()
{
ProjectAc projectac = new ProjectAc();
projectac.Name = _stringConstant.Name;
projectac.IsActive = _stringConstant.IsActive;
projectac.CreatedBy = _stringConstant.CreatedBy;
return(await _projectRepository.AddProjectAsync(projectac, _stringConstant.CreatedBy));
}
public async Task GetProjectById()
{
var id = await GetProjectMockData();
await GetProjectUserMockData();
ProjectAc project = await _projectRepository.GetProjectByIdAsync(id);
Assert.NotNull(project);
}
/// <summary>
/// This method is used to add new project
/// </summary>
/// <param name="newProject">project that need to be added</param>
/// <param name="createdBy">passed id of user who has create this project</param>
/// <returns>project id of newly created project</returns>
public async Task <int> AddProjectAsync(ProjectAc newProject, string createdBy)
{
var project = _mapperContext.Map <ProjectAc, Project>(newProject);
project.CreatedDateTime = DateTime.UtcNow;
project.CreatedBy = createdBy;
project.ApplicationUsers = null;
_projectDataRepository.AddAsync(project);
await _projectDataRepository.SaveChangesAsync();
return(project.Id);
}
public async Task GetProjectByGroupName()
{
var userId = await MockOfUserAc();
ProjectAc projectAc = MockOfProjectAc();
projectAc.TeamLeaderId = userId;
await _projectRepository.AddProjectAsync(projectAc, _stringConstant.CreatedBy);
var project = await _projectRepository.GetProjectBySlackChannelNameAsync(projectAc.SlackChannelName);
Assert.Equal(projectAc.Name, project.Name);
}
/// <summary>
/// mock of project ac
/// </summary>
/// <returns></returns>
private ProjectAc MockOfProjectAc()
{
ProjectAc projectAc = new ProjectAc();
projectAc.Name = _stringConstant.Name;
projectAc.IsActive = _stringConstant.IsActive;
projectAc.TeamLeader = new UserAc {
FirstName = _stringConstant.FirstName
};
projectAc.TeamLeaderId = _stringConstant.TeamLeaderId;
projectAc.CreatedBy = _stringConstant.CreatedBy;
return(projectAc);
}
public async Task GetAllProjectForUserAsync()
{
var userId = await MockOfUserAc();
ProjectAc projectAc = MockOfProjectAc();
projectAc.TeamLeaderId = userId;
await _projectRepository.AddProjectAsync(projectAc, _stringConstant.CreatedBy);
var project = await _projectRepository.GetAllProjectForUserAsync(userId);
Assert.NotNull(projectAc);
}
/// <summary>
/// Method to call an api from project oAuth server and get Project details of the given project id. - JJ
/// </summary>
/// <param name="projectId">Id of OAuth Project</param>
/// <returns>object of ProjectAc</returns>
public async Task <ProjectAc> GetProjectDetailsAsync(int projectId, string accessToken)
{
string requestUrl = string.Format(_stringConstant.FirstAndSecondIndexStringFormat, _stringConstant.ProjectDetailUrl, projectId.ToString());
string response = await _httpClientService.GetAsync(_stringConstant.ProjectUrl, requestUrl, accessToken, _stringConstant.Bearer);
ProjectAc project = new ProjectAc();
if (!string.IsNullOrEmpty(response))
{
project = JsonConvert.DeserializeObject <ProjectAc>(response);
}
return(project);
}
/// <summary>
/// Method to call an api from project oAuth server and get Project details of the given group - JJ
/// </summary>
/// <param name="groupName"></param>
/// <returns>object of ProjectAc</returns>
public async Task <ProjectAc> GetProjectDetails(string groupName, string accessToken)
{
var requestUrl = string.Format("{0}", groupName);
var response = await _httpClientRepository.GetAsync(_stringConstant.ProjectUrl, requestUrl, accessToken);
ProjectAc project = new ProjectAc();
if (response != null)
{
project = JsonConvert.DeserializeObject <ProjectAc>(response);
}
return(project);
}
/// <summary>
/// Method to return list of projects along with the users and teamleader in a project - GA
/// </summary>
/// <returns>list of projects along with users</returns>
public async Task <IList <ProjectAc> > GetProjectsWithUsersAsync()
{
List <ProjectAc> projectList = new List <ProjectAc>();
List <Project> projects = await _projectDataRepository.Fetch(x => !string.IsNullOrEmpty(x.TeamLeaderId)).ToListAsync();
foreach (var project in projects)
{
ProjectAc projectAc = await AssignTeamMembers(project);
projectList.Add(projectAc);
}
return(projectList);
}
/// <summary>
/// Method to call an api from oauth server and get the details of a project using projecId. - GA
/// </summary>
/// <param name="projectId">id of project</param>
/// <returns>Details of a project</returns>
public async Task <ProjectAc> GetProjectDetailsAsync(int projectId)
{
var accessToken = await GetCurrentUserAcceesToken();
ProjectAc project = new ProjectAc();
var requestUrl = string.Format(_stringConstant.FirstAndSecondIndexStringFormat, projectId, _stringConstant.GetProjectDetails);
var response = await _httpClientService.GetAsync(_stringConstant.ProjectUrl, requestUrl, accessToken, _stringConstant.Bearer);
if (response != null)
{
project = JsonConvert.DeserializeObject <ProjectAc>(response);
}
return(project);
}
public async Task GetAllProjects()
{
var id = await MockOfUserAc();
ProjectAc projectAc = MockOfProjectAc();
projectAc.TeamLeaderId = "";
projectAc.CreatedBy = id;
var projectId = await _projectRepository.AddProjectAsync(projectAc, id);
IEnumerable <ProjectAc> projects = await _projectRepository.GetAllProjectsAsync();
Assert.NotNull(projects);
}
/// <summary>
/// Method to return the project details of the given slack channel name - JJ
/// </summary>
/// <param name="slackChannelName">passed slack channel name</param>
/// <returns>object of ProjectAc</returns>
public async Task <ProjectAc> GetProjectBySlackChannelNameAsync(string slackChannelName)
{
Project project = await _projectDataRepository.FirstOrDefaultAsync(x => x.SlackChannelName == slackChannelName);
if (!string.IsNullOrEmpty(project?.TeamLeaderId))
{
var user = await _userDataRepository.FirstOrDefaultAsync(x => x.Id.Equals(project.TeamLeaderId));
if (user != null && user.IsActive)
{
ProjectAc projectAc = _mapperContext.Map <Project, ProjectAc>(project);
return(projectAc);
}
}
throw new ProjectNotFound();
}
/// <summary>
/// Used to add channel manually by command "add channel channelname"
/// </summary>
/// <param name="channelName"></param>
/// <param name="channelId"></param>
/// <param name="username"></param>
/// <returns>status message</returns>
private async Task <string> AddChannelManually(string channelName, string username, string channelId)
{
string returnMsg = string.Empty;
//Checks whether channelId starts with "G". This is done inorder to make sure that only private channels are added manually
if (IsPrivateChannel(channelId))
{
// getting user name from user's slack name
var applicationUser = _applicationUser.FirstOrDefault(x => x.SlackUserName == username);
// getting access token for that user
if (applicationUser != null)
{
// get access token of user for promact oauth server
string accessToken = await _attachmentRepository.AccessToken(applicationUser.UserName);
//get the project details of the given channel name
ProjectAc project = await _projectUser.GetProjectDetails(channelName, accessToken);
//add channel details only if the channel has been registered as project in OAuth server
if (project != null && project.Id > 0)
{
SlackChannelDetails channel = new SlackChannelDetails();
channel.ChannelId = channelId;
channel.CreatedOn = DateTime.UtcNow;
channel.Deleted = false;
channel.Name = channelName;
_slackChannelRepository.AddSlackChannel(channel);
returnMsg = _stringConstant.ChannelAddSuccess;
}
else
{
returnMsg = _stringConstant.ProjectNotInOAuth;
}
}
else
{
// if user doesn't exist then this message will be shown to user
returnMsg = _stringConstant.YouAreNotInExistInOAuthServer;
}
}
else
{
return(_stringConstant.OnlyPrivateChannel);
}
return(returnMsg);
}
public async void TestGetProjectDetails()
{
string id = await CreateMockAndUserAsync();
ProjectAc project = new ProjectAc()
{
Name = _stringConstant.Name,
IsActive = _stringConstant.IsActive,
TeamLeaderId = id,
CreatedBy = _stringConstant.CreatedBy,
};
var projectId = await _projectRepository.AddProjectAsync(project, _stringConstant.CreatedBy);
var projectDetails = await _projectRepository.GetProjectDetailsAsync(projectId);
Assert.Equal(projectDetails.Name, _stringConstant.Name);
}
public async void TestGetProjectsWithUsers()
{
string id = await CreateMockAndUserAsync();
ProjectAc project = new ProjectAc()
{
Name = _stringConstant.Name,
IsActive = _stringConstant.IsActive,
TeamLeaderId = id,
CreatedBy = _stringConstant.CreatedBy,
};
await _projectRepository.AddProjectAsync(project, _stringConstant.CreatedBy);
var projectUsers = await _projectRepository.GetProjectsWithUsersAsync();
Assert.NotNull(projectUsers);
}
/// <summary>
/// this method to check Project is already exists or not
/// </summary>
/// <param name="project">projectAc object</param>
/// <returns>projectAc object</returns>
public async Task <ProjectAc> CheckDuplicateProjectAsync(ProjectAc project)
{
string projectName;
if (project.Id == 0) // for new project
{
projectName = (await _projectDataRepository.FirstOrDefaultAsync(x => x.Name == project.Name))?.Name;
}
else // for edit project
{
projectName = (await _projectDataRepository.FirstOrDefaultAsync(x => x.Id != project.Id && x.Name == project.Name))?.Name;
}
//if project name already exists then return project name as null
if (!string.IsNullOrEmpty(projectName))
{
project.Name = null; return(project);
}
return(project);
}
