public UserDashboardWrapper(int studentNumber)
{
this.StudentNumber = studentNumber;
student = DatabaseFactory.getInstance().getDAOStudent();
project = DatabaseFactory.getInstance().getDAOProject();
FillCurrentProject();
if (HasProject)
{
FillNextReportDate();
FillProjectMembers(student.getStudentGroup(studentNumber).First());
FillCurrentProjectOwners(student.getStudentGroup(studentNumber).First());
CurrentProjectTutor = ProjectMembers.FirstOrDefault().ProjectGroup.User;
}
try
{
FillAllProjects();
FillAllIndividualGrades();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message + " in " + ex.Source);
// doe niks met error. (dit laten staan)
}
}
//POST: Add member to project
// Need user id and project ID
// POST: Projects/Create
public async Task <IActionResult> AddMember(string id, int ProjectId)
{
if (ModelState.IsValid)
{
var users = from u in _context.Users
select u;
var UserIdToString = id;
var user = users.Where(u => u.Id.Contains(UserIdToString));
ProjectMembers projectmembers = new ProjectMembers() // Change to add members?
{
ProjectId = ProjectId,
IsCreator = false,
UserId = id,
ProjectsProjectId = ProjectId
};
_context.Add(projectmembers); // Change to add member / project members
await _context.SaveChangesAsync(); // Posts
return(View(AddedMemberSuccessfully(ProjectId)));
//return RedirectToAction(nameof(AddedMemberSuccessfully(ProjectId, UserIdToString));
//return RedirectToAction("AddedMemberSuccessfully", new { ProjectId = ProjectId, UserId = UserIdToString });
//TODO: Ensure all button operations work correctly
}
return(View());
}
public async Task <IActionResult> InviteToProject(InviteContributorViewModel input)
{
var User = await userManager.FindByIdAsync(input.UserId);
var project = await gsv.FindProjectFromProjectId(input.ProjectId);
if (project != null)
{
var projectMember = new ProjectMembers()
{
Applicationstatus = "Invited", AuthorTestUser = User, Project = project
};
var check = await gsv.RecruitContributor(projectMember);
if (check)
{
TempData["submission"] = "User has been invited to the project! ";
TempData["AlertType"] = "alert-success";
return(RedirectToAction("index"));
}
}
TempData["submission"] = "User has been not been invited to the project! check the Project Id is correct. ";
TempData["AlertType"] = "alert-danger";
return(RedirectToAction("index"));
}
public ActionResult DeleteMembers(ProjectMembers _projectmember)
{
Guid ProjectGUID = _projectmember.ProjectGUID;
Guid EmployeeGUID = _projectmember.EmployeeGUID;
ProjectMembersRepo.Delete(ProjectMembersRepo.Find(EmployeeGUID, ProjectGUID));
return(RedirectToAction("EditMember", ProjectGUID));
}
public async Task <ProjectMembers> CreateNewProjectMember(ProjectMembers newMember)
{
var insertedNewMember = await _context.ProjectMembers.AddAsync(newMember);
await _context.SaveChangesAsync();
return(insertedNewMember.Entity);
}
public List <ProjectMembers> GetProjectMember(ProjectMembers pj)
{
var y = (from x in projectMembers
where x.Member.Equals(pj.Member) &&
x.ProjectId.Equals(pj.ProjectId)
select x).ToList <ProjectMembers>();
return(y);
}
public HttpResponseMessage Insert([FromBody] ProjectMembers projMembers)
{
_ProjectMembersRepo.InsertProjectMembersDetailsAsync(projMembers);
var message = Request.CreateResponse(HttpStatusCode.Created, projMembers);
message.Headers.Location = new Uri(Request.RequestUri + projMembers.Id.ToString());
return(message);
}
private void AddUserFromProject(ProjectMember user)
{
foreach (var member in ProjectMembers.Where(member => member.Name == user.Name || member.Email == user.Email).ToList())
{
ProjectMembers.Remove(member);
}
ProjectMembers.Add(user);
ProjectMembers.Move(ProjectMembers.Count - 1, 0);
}
public ActionResult EditPMScore(ProjectMembers _projectMember)
{
var pm = ProjectMembersRepo.Find(_projectMember.EmployeeGUID, _projectMember.ProjectGUID);
pm.PMscore = _projectMember.PMscore;
pm.PMScoreDate = DateTime.Now;
ProjectMembersRepo.Update(pm);
return(Content("success"));
}
public bool AddMember(ProjectMembers mem)
{
if (IsNotExists(mem.ProjectId, mem.Member) == true)
{
projectMembers.Add(mem);
SaveChanges();
return(true);
}
return(false);
}
/// <summary>
/// get permission user in a project
/// </summary>
public bool GetUserPermission(int userId, int projectId)
{
try
{
return(ProjectMembers.Any(a => a.UserID == userId && a.ProjectID == projectId));
}
catch (Exception)
{
throw;
}
}
public ActionResult AddProjectMember(Guid memberID)
{
ProjectMembers pm = new ProjectMembers();
pm.ProjectGUID = new Guid(Request.Cookies["ProjectGUID"].Value);
pm.EmployeeGUID = memberID;
pm.IsRead = false;
pm.InvideDate = DateTime.Now;
projectMembers.Add(pm);
return(RedirectToAction("Index", "ProjectMember"));
}
public async Task <ProjectMembers> InsertProjectMember(Invitation invitation)
{
var newMember = new ProjectMembers
{
Project = invitation.Project,
Member = invitation.For_Who,
Role = (int)invitation.Role
};
var inserted = await _projectMemberRepository.CreateNewProjectMember(newMember);
return(inserted);
}
public bool DeleteMember(ProjectMembers ff)
{
var pj = GetProjectMember(ff);
if (pj.Count == 0)
{
return(false);
}
projectMembers.Remove(pj[0]);
SaveChanges();
return(true);
}
public Project Post([FromBody] Project project)
{
using (var db = new ApplicationDbContext())
{
var membership = new ProjectMembers();
db.Add(project);
membership.Admin = true;
membership.Project = project;
membership.UserId = "13dc3112-2427-4275-bcad-368021f01a2b";
db.Add(membership);
db.SaveChanges();
return(project);
}
}
public void InsertProjectMembersDetailsAsync(ProjectMembers projMembers)
{
if (myconn.State != ConnectionState.Open)
{
myconn.Open();
}
SqlTransaction tran = myconn.BeginTransaction();
projMembers.createdDate = DateTime.Now;
projMembers.modifiedDate = DateTime.Now;
SqlCommand sqlCmd = new SqlCommand();
sqlCmd.CommandType = CommandType.StoredProcedure;
sqlCmd.CommandText = "SP_ProjectMembersInsertUpdate";
sqlCmd.Parameters.Add(new SqlParameter("@mode", "I"));
sqlCmd.Parameters.Add(new SqlParameter("@ID", projMembers.Id));
sqlCmd.Parameters.Add(new SqlParameter("@projId", projMembers.projId));
sqlCmd.Parameters.Add(new SqlParameter("@memberId", projMembers.memberId));
sqlCmd.Parameters.Add(new SqlParameter("@statusId", projMembers.statusId));
sqlCmd.Parameters.Add(new SqlParameter("@createdDate", projMembers.createdDate));
sqlCmd.Parameters.Add(new SqlParameter("@modifiedDate", projMembers.modifiedDate));
sqlCmd.Parameters.Add(new SqlParameter("@userId", projMembers.userId));
try
{
sqlCmd.Connection = myconn;
sqlCmd.Transaction = tran;
projMembers.Id = Convert.ToInt32(sqlCmd.ExecuteScalar());
// InsertProjectMembersRateDetailsAsync(ProjectMembersRates, ProjectMembers.ProjectMembersID, tran);
tran.Commit();
}
catch (Exception ex)
{
tran.Rollback();
gs.LogData(ex);
throw ex;
}
finally
{
if (myconn.State != ConnectionState.Closed)
{
myconn.Close();
}
}
}
public ActionResult WatchChartSelfScore(ProjectMembers _projectMember)
{
ChartData <SingleColorChartDataset <int> > chartData = new ChartData <SingleColorChartDataset <int> >();
chartData.labels = ProjectMembersRepo.GetCollections().Where(p => p.ProjectGUID == _projectMember.ProjectGUID && p.Employee.JobTitle.TitleName != "專案經理").Select(p => p.Employee.EmployeeName).ToList();
chartData.datasets.Add(new SingleColorChartDataset <int>
{
label = "自評分",
backgroundColor = "rgba(91, 155, 213, 0.5)",
borderColor = "rgba(91, 155, 213, 1)",
data = ProjectMembersRepo.GetCollections().Where(p => p.ProjectGUID == _projectMember.ProjectGUID && p.Employee.JobTitle.TitleName != "專案經理" && p.Selfscore != null).Select(p => (int)p.Selfscore).ToList()
});
return(Content(JsonConvert.SerializeObject(chartData), "application/json"));
}
private async Task InitializeProjectMembers()
{
IsLoading = true;
ProjectMembers.Clear();
var usersFromProject = _projectQueryService.Project?.ProjectMembersNotInRepository ??
new List <ProjectMember>();
var usersFromRepo = await _repositoryService.GetAllUniqueCommiters();
foreach (var user in usersFromProject.Concat(usersFromRepo).Distinct().OrderBy(pm => pm.Name))
{
ProjectMembers.Add(user);
}
IsLoading = false;
}
public Project Join(int id)
{
using (var db = new ApplicationDbContext())
{
var project = db.Projects.Include(proj => proj.ProjectMembers)
.Where(b => b.Id == id).FirstOrDefault();
var membership = new ProjectMembers();
membership.Project = project;
membership.UserId = "13dc3112-2427-4275-bcad-368021f01a2b";
db.Add(membership);
db.SaveChanges();
return(project);
}
}
public async Task <IActionResult> Create([Bind("Id,UserId,ProjectId")] ProjectMembers projectMembers)
{
if (ModelState.IsValid && !(_context.ProjectMembers.Any(d => d.ProjectId == projectMembers.ProjectId) && _context.ProjectMembers.Any(d => d.UserId.Equals(projectMembers.UserId))))
{
projectMembers.Id = 0;
_context.Add(projectMembers);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", "Project", new { id = projectMembers.ProjectId }));
}
ViewData["UserId"] = new SelectList(_context.Users, "Id", "Id", projectMembers.UserId);
ViewData["ProjectId"] = projectMembers.ProjectId;
ViewBag.UsersName = _context.Users.ToArray();
ViewBag.ProjectName = _context.Project.Where(d => d.Id == projectMembers.ProjectId).First().Name;
ViewBag.UsersExist = 1;
return(View(projectMembers));
}
public ActionResult New([Bind(Include = "Name, SuperiorID, Start, Finish, ProjectMembers")] AddProjectViewModel project)
{
if (Session["EmployeeID"] == null)
{
Session["PleaseLogin"] = true;
return(RedirectToAction("", "Home"));
}
var permutil = new PermissionUtil();
if (permutil.IsAdministrator((int)Session["JobPosition"]))
{
if (project.Finish != null && project.Start > project.Finish)
{
ModelState.AddModelError("Start", "Data rozpoczęcia jest późniejsza niż data zakończenia projektu.");
PopulateSuperiorsList();
return(View());
}
var projectToAdd = new Projects();
projectToAdd.Name = project.Name;
projectToAdd.SuperiorID = project.SuperiorID;
projectToAdd.Start = project.Start;
projectToAdd.Finish = project.Finish;
projectToAdd.CreatedBy = (int)Session["EmployeeID"];
projectToAdd.CreationDate = DateTime.Now;
projectToAdd.ProjectStateID = 1; // TODO: Change this magic value
ctx.Projects.Add(projectToAdd);
ctx.SaveChanges();
foreach (var emplID in project.ProjectMembers)
{
var pm = new ProjectMembers()
{
ProjectID = projectToAdd.ProjectID,
EmployeeID = emplID
};
ctx.ProjectMembers.Add(pm);
}
ctx.SaveChanges();
return(RedirectToAction("Overview", "Project"));
}
return(RedirectToAction("Overview", "Project"));
}
//<-------------------------- Contributors ---------------------->
public async Task <bool> AddUserToProject(string userId, int projectId)
{
// Get the user and the project, create a projectmember for them and add it the the database.
var user = await FindUserFromUserId(userId);
var project = await FindProjectFromProjectId(projectId);
var projectMember = await GetProjectMember(userId, projectId);
// Check if user has been invited to project, if they have then change their status to accepted, need to check if null to prevent null reference exception.
if (projectMember != null && projectMember.Applicationstatus.ToLower().Equals("invited"))
{
projectMember.Applicationstatus = "Accepted";
await authorDbContext.SaveChangesAsync();
return(true);
}
// Ensure user and project exist
if (user != null && project != null)
{
var projectMemberNew = new ProjectMembers {
AuthorTestUser = user, Project = project, Applicationstatus = "Pending Review", ProjectUpdate = "No updates currently."
};
//update the projects participant count
project.CurrentNumberOfParticipants += 1;
var checkAdded = await authorDbContext.projectMembers.AddAsync(projectMemberNew);
await authorDbContext.SaveChangesAsync();
if (checkAdded == null)
{
return(false);
}
else
{
return(true);
}
}
return(false);
}
private void GetButtons()
{
decimal n = nUpDown1.Value;
int count = Convert.ToInt32(n);
int x = 0;
int y = 1;
int position1 = 200;
int position2 = 260;
for (int i = 0; i < count; i++)
{
ProjectMembers btn = new ProjectMembers();
btn.Text = y.ToString();
btn.Location = new Point(btn.Width * x + position1, position2);
x++;
y++;
Controls.Add(btn);
}
}
public async Task <bool> RecruitContributor(ProjectMembers Pm)
{
await authorDbContext.projectMembers.AddAsync(Pm);
await authorDbContext.SaveChangesAsync();
var checkAdded = await authorDbContext.projectMembers.Include("Project").FirstOrDefaultAsync(p => p.Project.Id == Pm.Project.Id);
checkAdded.Project.CurrentNumberOfParticipants++;
if (checkAdded == null)
{
return(false);
}
else
{
return(true);
}
}
public ActionResult AddUserToCurrentProject(int id)
{
var user = dbContext.Users.Where(u => u.ID == id).FirstOrDefault();
// Change project manager
if (user.UserRole == Enums.UserRole.ProjectManager)
{
var projectManagers = dbContext.ProjectManagers;
var pm = projectManagers
.Where(p => p.ProjectID == ApplicationState.Instance.CurrentProjectID).FirstOrDefault();
if (pm != null)
{
pm.ProjectManagerID = id;
}
else
{
pm = new ProjectManagers
{
ProjectID = ApplicationState.Instance.CurrentProjectID,
ProjectManagerID = id
};
dbContext.ProjectManagers.Add(pm);
}
dbContext.SaveChanges();
}
// ad user as member to project
else
{
var projectMembers = new ProjectMembers
{
ProjectID = ApplicationState.Instance.CurrentProjectID,
ProjectMemberID = id
};
dbContext.ProjectMembers.Add(projectMembers);
dbContext.SaveChanges();
}
return(Redirect(Request.UrlReferrer.ToString()));
}
private void UpdateDb(ProjectViewModel projectVM)
{
// Update Project Table
var project = new Project
{
Name = projectVM.Name
};
db.Projects.Add(project);
db.SaveChanges();
//Update ProjectManagers Table
var projectManager = new ProjectManagers
{
ProjectID = project.ID,
ProjectManagerID = projectVM.ProjectManagerID
};
db.ProjectManagers.Add(projectManager);
//Update ProjectMembers Table
foreach (var user in projectVM.TeamMembers)
{
var projectMember = new ProjectMembers
{
ProjectID = project.ID,
ProjectMemberID = user.ID
};
db.ProjectMembers.Add(projectMember);
}
db.SaveChanges();
// Update ActivityMonitor Table
var activityDescription = ApplicationState.Instance.CurrentUser.FirstName + " " + ApplicationState.Instance.CurrentUser.LastName + " created project.";
new ActivityMonitorUpdater(db).WriteToDatabase(activityDescription, project.ID);
}
public async Task <IActionResult> Create([Bind("ProjectId,Name,Details,Repo")] Projects projects)
{
if (ModelState.IsValid)
{
var user = await GetCurrentUserAsync();
_context.Add(projects);
await _context.SaveChangesAsync();
ProjectMembers projectmembers = new ProjectMembers()
{
ProjectId = projects.ProjectId,
UserId = user.Id,
IsCreator = true,
User = user,
ProjectsProjectId = projects.ProjectId
};
_context.Add(projectmembers);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(projects));
}
public JsonResult AssignEmployeeToProject(int projID, int emplID)
{
if (Session["EmployeeID"] == null || !Request.IsAjaxRequest())
{
Response.StatusCode = (int)HttpStatusCode.Forbidden;
return(Json("Nie masz uprawnień do wykonania tego zapytania"));
}
var projectMember = new ProjectMembers();
projectMember.EmployeeID = emplID;
projectMember.ProjectID = projID;
if (ctx.ProjectMembers.Any(pm => (pm.EmployeeID == emplID && pm.ProjectID == projID)))
{
return(Json(new
{
Error = 2
}));
}
projectMember = ctx.ProjectMembers.Add(projectMember);
int recordsWritten = ctx.SaveChanges();
if (recordsWritten != 0)
{
return(Json(new
{
Error = 0
}));
}
return(Json(new
{
Error = 1
}));
}
public async void Update([FromBody] ProjectMembers projMembers)
{
await Task.Run(() => _ProjectMembersRepo.UpdateProjectMembersDetailsAsync(projMembers));
}
public MainFormData(IList <Project> projects, int projectId, bool onlyMe, Filter filter)
{
Projects = new List <ClientProject>();
Projects.Add(new ClientProject(new Project {
Id = -1, Name = Languages.Lang.ShowAllIssues
}));
foreach (Project p in projects)
{
Projects.Add(new ClientProject(p));
}
NameValueCollection parameters = new NameValueCollection();
if (projectId != -1)
{
parameters.Add("project_id", projectId.ToString());
}
if (RedmineClientForm.RedmineVersion >= ApiVersion.V13x)
{
if (projectId < 0)
{
try
{
List <Tracker> allTrackers = (List <Tracker>)RedmineClientForm.redmine.GetTotalObjectList <Tracker>(null);
Trackers = allTrackers.ConvertAll(new Converter <Tracker, ProjectTracker>(TrackerToProjectTracker));
}
catch (Exception e)
{
throw new LoadException(Languages.Lang.BgWork_LoadTrackers, e);
}
Categories = null;
Versions = null;
}
else
{
try
{
NameValueCollection projectParameters = new NameValueCollection {
{ "include", "trackers" }
};
Project project = RedmineClientForm.redmine.GetObject <Project>(projectId.ToString(), projectParameters);
Trackers = new List <ProjectTracker>(project.Trackers);
}
catch (Exception e)
{
throw new LoadException(Languages.Lang.BgWork_LoadProjectTrackers, e);
}
try
{
Categories = new List <IssueCategory>(RedmineClientForm.redmine.GetTotalObjectList <IssueCategory>(parameters));
Categories.Insert(0, new IssueCategory {
Id = 0, Name = ""
});
}
catch (Exception e)
{
throw new LoadException(Languages.Lang.BgWork_LoadCategories, e);
}
try
{
Versions = (List <Redmine.Net.Api.Types.Version>)RedmineClientForm.redmine.GetTotalObjectList <Redmine.Net.Api.Types.Version>(parameters);
Versions.Insert(0, new Redmine.Net.Api.Types.Version {
Id = 0, Name = ""
});
}
catch (Exception e)
{
throw new LoadException(Languages.Lang.BgWork_LoadVersions, e);
}
}
Trackers.Insert(0, new ProjectTracker {
Id = 0, Name = ""
});
try
{
Statuses = new List <IssueStatus>(RedmineClientForm.redmine.GetTotalObjectList <IssueStatus>(parameters));
Statuses.Insert(0, new IssueStatus {
Id = 0, Name = Languages.Lang.AllOpenIssues
});
Statuses.Add(new IssueStatus {
Id = -1, Name = Languages.Lang.AllClosedIssues
});
Statuses.Add(new IssueStatus {
Id = -2, Name = Languages.Lang.AllOpenAndClosedIssues
});
}
catch (Exception e)
{
throw new LoadException(Languages.Lang.BgWork_LoadStatuses, e);
}
try
{
if (RedmineClientForm.RedmineVersion >= ApiVersion.V14x &&
projectId > 0)
{
List <ProjectMembership> projectMembers = (List <ProjectMembership>)RedmineClientForm.redmine.GetTotalObjectList <ProjectMembership>(parameters);
ProjectMembers = projectMembers.ConvertAll(new Converter <ProjectMembership, ProjectMember>(ProjectMember.MembershipToMember));
}
else
{
List <User> allUsers = (List <User>)RedmineClientForm.redmine.GetTotalObjectList <User>(null);
ProjectMembers = allUsers.ConvertAll(new Converter <User, ProjectMember>(UserToProjectMember));
}
ProjectMembers.Insert(0, new ProjectMember());
}
catch (Exception)
{
ProjectMembers = null;
//throw new LoadException(Languages.Lang.BgWork_LoadProjectMembers, e);
}
try
{
if (RedmineClientForm.RedmineVersion >= ApiVersion.V22x)
{
Enumerations.UpdateIssuePriorities(RedmineClientForm.redmine.GetTotalObjectList <IssuePriority>(null));
Enumerations.SaveIssuePriorities();
Enumerations.UpdateActivities(RedmineClientForm.redmine.GetTotalObjectList <TimeEntryActivity>(null));
Enumerations.SaveActivities();
}
IssuePriorities = new List <Enumerations.EnumerationItem>(Enumerations.IssuePriorities);
IssuePriorities.Insert(0, new Enumerations.EnumerationItem {
Id = 0, Name = "", IsDefault = false
});
Activities = new List <Enumerations.EnumerationItem>(Enumerations.Activities);
Activities.Insert(0, new Enumerations.EnumerationItem {
Id = 0, Name = "", IsDefault = false
});
}
catch (Exception e)
{
throw new LoadException(Languages.Lang.BgWork_LoadPriorities, e);
}
try
{
if (RedmineClientForm.RedmineVersion >= ApiVersion.V24x)
{
CustomFields = RedmineClientForm.redmine.GetTotalObjectList <CustomField>(null);
}
}
catch (Exception e)
{
throw new LoadException(Languages.Lang.BgWork_LoadCustomFields, e);
}
}
try
{
if (onlyMe)
{
parameters.Add("assigned_to_id", "me");
}
else if (filter.AssignedToId > 0)
{
parameters.Add("assigned_to_id", filter.AssignedToId.ToString());
}
if (filter.TrackerId > 0)
{
parameters.Add("tracker_id", filter.TrackerId.ToString());
}
if (filter.StatusId > 0)
{
parameters.Add("status_id", filter.StatusId.ToString());
}
else if (filter.StatusId < 0)
{
switch (filter.StatusId)
{
case -1: // all closed issues
parameters.Add("status_id", "closed");
break;
case -2: // all open and closed issues
parameters.Add("status_id", "*");
break;
}
}
if (filter.PriorityId > 0)
{
parameters.Add("priority_id", filter.PriorityId.ToString());
}
if (filter.VersionId > 0)
{
parameters.Add("fixed_version_id", filter.VersionId.ToString());
}
if (filter.CategoryId > 0)
{
parameters.Add("category_id", filter.CategoryId.ToString());
}
if (!String.IsNullOrEmpty(filter.Subject))
{
parameters.Add("subject", "~" + filter.Subject);
}
Issues = RedmineClientForm.redmine.GetTotalObjectList <Issue>(parameters);
}
catch (Exception e)
{
throw new LoadException(Languages.Lang.BgWork_LoadIssues, e);
}
}
