public static bool CompleteBacklog(int backlogId, int?memberId)
{
using (var db = new ScrumApplicationDbContext())
{
var existTask = new ProductBacklog();
existTask = db.ProductBacklogs.FirstOrDefault(x => x.ProductBacklogId == backlogId);
if (!memberId.HasValue)
{
memberId = TeamRepository.GetUserMemberIdFromProjectId(existTask.ProjectId);
}
var existMember = db.Members.FirstOrDefault(x => x.MemberId == memberId);
if (existMember != null)
{
if (ProjectRepository.IsUserAssigned(backlogId, existMember.MemberId) == 1)
{
if (existTask.BacklogStatus < Status.Completed)
{
existTask.BacklogStatus = Status.Completed;
}
existTask.Done = true;
existMember.TotalPoint += existTask.StoryPoint;
db.SaveChanges();
ActivityRepository.ActivityCreator
("completed " + existTask.Name, existTask.ProjectId, existTask.ProductBacklogId);
return(true);
}
}
return(false);
}
}
//test et
public static bool DeleteTeam(int teamId)
{
using (var db = new ScrumApplicationDbContext())
{
var existTeam = new Team();
existTeam = db.Teams.FirstOrDefault(x => x.TeamId == teamId);
var teamProjects = new List <Project>();
teamProjects = existTeam.Projects.ToList();
if (teamProjects.Count != 0)
{
foreach (var p in teamProjects)
{
if (p.DayCount > 0)
{
return(false);
}
else
{
teamProjects.Remove(p);
}
}
}
else if (teamProjects.Count != 0)
{
db.Teams.Remove(existTeam);
db.SaveChanges();
return(true);
}
return(false);
}
}
public ActionResult Register(UserRegisterViewModel newUser)
{
using (var db = new ScrumApplicationDbContext())
{
if (db.Users.FirstOrDefault(x => x.Mail == newUser.User.Mail) == null)
{
if (newUser.ConfirmPassword == newUser.User.Password)
{
var _newUser = new User {
FirstName = newUser.User.FirstName,
LastName = newUser.User.LastName,
Name = newUser.User.FirstName + " " + newUser.User.LastName.Substring(0, 1) + ".",
Mail = newUser.User.Mail,
Password = newUser.User.Password
};
db.Users.Add(_newUser);
db.SaveChanges();
FormsAuthentication.SetAuthCookie(newUser.User.Mail, true);
UserRepository.UpdateUserCookie(newUser.User.UserId);
return(RedirectToAction("Index", "Team", new { id = UserRepository.GetUserId() }));
}
}
}
return(View(newUser));
}
//Check is user assigned to selected backlog, return bool
public static int IsUserAssigned(int backlogId, int?memberId)
{
using (var db = new ScrumApplicationDbContext())
{
var existBacklog = db.ProductBacklogs.FirstOrDefault(x => x.ProductBacklogId == backlogId);
if (!memberId.HasValue)
{
memberId = TeamRepository.GetUserMemberIdFromProjectId(existBacklog.ProjectId);
}
if (memberId != 0 && existBacklog != null)
{
var existBTM = db.BacklogToMembers.FirstOrDefault(x => x.MemberId == memberId && x.ProductBacklogId == backlogId);
if (existBTM != null)
{
return(1);
}
var _existBTM = db.BacklogToMembers.FirstOrDefault(x => x.ProductBacklogId == existBacklog.ProductBacklogId);
if (_existBTM != null && _existBTM.MemberId != memberId)
{
return(2);
}
}
return(0);
}
}
public static List <User> GetUserCommunity(int userId)
{
using (var db = new ScrumApplicationDbContext())
{
var userCommunity = new List <User>();
var userTeamMembers = new List <Member>();
var userTeams = GetTeams(userId);
foreach (var team in userTeams)
{
var query = from member in db.Members
where member.TeamId == team.TeamId
select member;
if (query.Count() != 0)
{
userTeamMembers.AddRange(query.ToList());
}
}
List <Member> distinctUsers = userTeamMembers
.GroupBy(m => m.UserId)
.Select(m => m.First())
.ToList();
foreach (var member in distinctUsers)
{
var existUser = new User();
existUser = db.Users.FirstOrDefault(x => x.UserId == member.UserId);
if (existUser != null && existUser.UserId != userId)
{
userCommunity.Add(existUser);
}
}
return(userCommunity);
}
}
public static List <Team> GetTeamsForManager(int userId)
{
var _teamList = new List <Team>();
var existUser = new User();
var userTeamsWithManagerRoleList = new List <Team>();
using (var db = new ScrumApplicationDbContext())
{
if (userId != 0)
{
var query = from member in db.Members
where member.UserId == userId
select member.Team;
_teamList = query.ToList();
foreach (var team in _teamList)
{
foreach (var member in db.Members)
{
if (member.TeamId == team.TeamId && member.UserId == userId)
{
if (member.RoleCode < 3)
{
userTeamsWithManagerRoleList.Add(team);
}
}
}
}
}
}
return(userTeamsWithManagerRoleList);
}
public static BacklogViewModel GetBacklogViewModel(int productBacklogId)
{
using (var db = new ScrumApplicationDbContext())
{
var backlogModel = new BacklogViewModel();
backlogModel.Backlog = db.ProductBacklogs.FirstOrDefault
(x => x.ProductBacklogId == productBacklogId);
var existProject = new Project();
existProject = db.Projects.FirstOrDefault(x => x.ProjectId == backlogModel.Backlog.ProjectId);
backlogModel.ProjectEpics = EpicRepository.GetEpics(backlogModel.Backlog.ProjectId);
backlogModel.Epic.ProjectId = backlogModel.Backlog.ProjectId;
var query = from btm in db.BacklogToMembers
where btm.ProductBacklogId == backlogModel.Backlog.ProductBacklogId
select btm;
var teamMembers = new List <Member>();
var tquery = from member in db.Members
where member.TeamId == existProject.TeamId
select member;
teamMembers = tquery.ToList();
var unAssignedTeamMembers = new List <Member>();
unAssignedTeamMembers = teamMembers.ToList();
unAssignedTeamMembers = unAssignedTeamMembers.OrderBy(x => x.MemberId).ToList();
foreach (var btm in query.ToList())
{
var member = new MemberViewModel();
member.MemberId = btm.MemberId;
member.Name = btm.MemberName;
backlogModel.AssignedMembers.Add(member);
foreach (var tmember in teamMembers)
{
if (tmember.MemberId == member.MemberId)
{
unAssignedTeamMembers.Remove(tmember);
}
}
}
foreach (var umember in unAssignedTeamMembers)
{
var memberModel = new MemberViewModel();
memberModel.MemberId = umember.MemberId;
memberModel.Name = umember.Name;
backlogModel.UnAssignedMembers.Add(memberModel);
}
var cquery = from comment in db.Comments
where comment.ProductBacklogId == backlogModel.Backlog.ProductBacklogId
orderby comment.CommentId descending
select comment;
backlogModel.BacklogComments = cquery.ToList();
if (IsUserAssigned(backlogModel.Backlog.ProductBacklogId, null) == 1)
{
backlogModel.IsUserAssigned = true;
}
else
{
backlogModel.IsUserAssigned = false;
}
return(backlogModel);
}
}
public static HomeViewModel PrepareHomeViewModel(int userId)
{
using (var db = new ScrumApplicationDbContext())
{
var existUser = db.Users.FirstOrDefault(x => x.UserId == userId);
var userTeams = TeamRepository.GetTeams(userId);
var homeVM = new HomeViewModel
{
UserId = userId,
UserName = existUser.Name,
UserTeams = userTeams,
UserActiveProjects = new List <HomeProjectViewModel>()
};
foreach (var team in userTeams)
{
var teamProjects = GetProjects(team.TeamId);
foreach (var project in teamProjects)
{
if (!project.IsDone)
{
var memberId = TeamRepository.GetUserMemberIdFromProjectId(project.ProjectId);
var member = db.Members.FirstOrDefault(x => x.MemberId == memberId);
var homeProjectVM = new HomeProjectViewModel
{
ProjectId = project.ProjectId,
ProjectName = project.Name,
TeamId = project.TeamId ?? default(int),
TeamName = team.Name,
MemberId = memberId,
RoleCode = member.RoleCode,
AssignedActiveBacklogs = new List <ProductBacklog>()
};
var projectBacklogs = GetProjectBacklogs(project.ProjectId);
foreach (var backlog in projectBacklogs)
{
if (!backlog.Done && IsUserAssigned(backlog.ProductBacklogId, memberId) == 1 && backlog.SprintNo == project.CurrentSprintNo)
{
var btm = db.BacklogToMembers.FirstOrDefault
(x => x.MemberId == memberId && x.ProductBacklogId == backlog.ProductBacklogId);
if (btm != null)
{
homeProjectVM.AssignedActiveBacklogs.Add(backlog);
}
}
}
if (homeProjectVM != null)
{
homeProjectVM.AssignedActiveBacklogs = homeProjectVM.AssignedActiveBacklogs.OrderBy(x => x.Priority).ToList();
homeVM.UserActiveProjects.Add(homeProjectVM);
}
}
}
}
return(homeVM);
}
}
public static void AddProjectToTeam(int projectId, int teamId)
{
using (var db = new ScrumApplicationDbContext())
{
var existProject = db.Projects.FirstOrDefault(x => x.ProjectId == projectId);
var existTeam = db.Teams.FirstOrDefault(x => x.TeamId == teamId);
existTeam.Projects.Add(existProject);
db.SaveChanges();
}
}
//public static SprintModel GetSprintModel(int projectId, int sprintNo)
//{
// using (var db = new ScrumApplicationDbContext())
// {
// var existProject = new Project();
// existProject= db.Projects.FirstOrDefault(x=>x.ProjectId == projectId);
// var newModel = new SprintModel();
// newModel.ProjectId = projectId;
// var sprintBacklogs = new List<ProductBacklog>();
// var projectEpics = new List<Epic>();
// sprintBacklogs = existProject.ProductBacklogs.ToList();
// projectEpics = existProject.Epics.ToList();
// if (sprintBacklogs != null)
// {
// var query = from backlog in sprintBacklogs
// where backlog.SprintNo == sprintNo
// orderby backlog.EpicId ascending, backlog.Priority ascending
// select backlog;
// newModel.ProductBacklogs = query.ToList();
// }
// if (projectEpics != null)
// {
// var equery = from epic in projectEpics
// orderby epic.IsDone ascending, epic.Priority ascending
// select epic;
// newModel.Epics = equery.ToList();
// }
// newModel.ProjectId = existProject.ProjectId;
// newModel.SprintNo = sprintNo;
// return newModel;
// }
//}
public static int GetActiveSprintNo(int projectId)
{
using (var db = new ScrumApplicationDbContext())
{
var existProject = new Project();
existProject = db.Projects.FirstOrDefault(x => x.ProjectId == projectId);
return(existProject.CurrentSprintNo);
}
}
public static void AddTeam(string name)
{
var _newTeam = new Team();
_newTeam.Name = name;
using (var db = new ScrumApplicationDbContext())
{
db.Teams.Add(_newTeam);
db.SaveChanges();
}
}
public static List <ProductBacklog> GetProjectBacklogs(int projectId, int sortBy = 0)
{
var projectBacklogs = new List <ProductBacklog>();
using (var db = new ScrumApplicationDbContext())
{
var query = from backlog in db.ProductBacklogs
where backlog.ProjectId == projectId
select backlog;
projectBacklogs = query.ToList().SortBacklogs(sortBy);
}
return(projectBacklogs);
}
public static void AddUser(string name, string email, string password)
{
var _newUser = new User();
_newUser.Name = name;
_newUser.Mail = email;
_newUser.Password = password;
using (var db = new ScrumApplicationDbContext())
{
db.Users.Add(_newUser);
db.SaveChanges();
}
}
public void AddEpic(string name, int projectId)
{
var _newEpic = new Epic();
_newEpic.Name = name;
_newEpic.ProjectId = projectId;
using (var db = new ScrumApplicationDbContext())
{
db.Epics.Add(_newEpic);
db.SaveChanges();
}
}
public static void AddProductBacklog(int projectId, string name)
{
var newTask = new ProductBacklog();
newTask.Name = name;
newTask.ProjectId = projectId;
using (var db = new ScrumApplicationDbContext())
{
db.ProductBacklogs.Add(newTask);
db.SaveChanges();
}
ActivityRepository.ActivityCreator
("added " + newTask.Name + " to the project.", newTask.ProjectId, newTask.ProductBacklogId);
}
public static List <ProductBacklog> GetSprintBacklogs(int projectId, int sprintNo)
{
var sprintBacklogs = new List <ProductBacklog>();
using (var db = new ScrumApplicationDbContext())
{
var query = from backlog in db.ProductBacklogs
where backlog.ProjectId == projectId && backlog.SprintNo == sprintNo
orderby backlog.Priority ascending, backlog.Done ascending
select backlog;
sprintBacklogs = query.ToList();
}
return(sprintBacklogs);
}
public static void AddProject(string name)
{
var _newProject = new Project();
_newProject.Name = name;
using (var db = new ScrumApplicationDbContext())
{
db.Projects.Add(_newProject);
db.SaveChanges();
ActivityRepository.ActivityCreator
("created" + _newProject.Name, _newProject.ProjectId, null);
}
}
public static Manager GetTeamManager(int teamId)
{
using (var db = new ScrumApplicationDbContext())
{
var existTeam = db.Teams.FirstOrDefault(x => x.TeamId == teamId);
if (existTeam != null && existTeam.ManagerId != 0)
{
var manager = db.Managers.FirstOrDefault(x => x.ManagerId == existTeam.ManagerId);
return(manager);
}
return(null);
}
}
public static List <Epic> GetProjectEpics(int projectId)
{
var projectEpics = new List <Epic>();
using (var db = new ScrumApplicationDbContext())
{
var query = from epic in db.Epics
where epic.ProjectId == projectId
orderby epic.IsDone ascending, epic.Priority ascending
select epic;
projectEpics = query.ToList();
}
return(projectEpics);
}
public static List <ProductBacklog> GetProductBacklogs(int projectId)
{
List <ProductBacklog> ProductBacklogs = new List <ProductBacklog>();
using (var db = new ScrumApplicationDbContext())
{
var query = from task in db.ProductBacklogs
where task.ProjectId == projectId
orderby task.Priority ascending
select task;
ProductBacklogs = query.ToList();
}
return(ProductBacklogs);
}
public static List <Project> GetProjects(int teamId)
{
var _projectList = new List <Project>();
using (var db = new ScrumApplicationDbContext())
{
var query = from project in db.Projects
where project.TeamId == teamId && project.DayCount > 0
orderby project.Name ascending
select project;
_projectList = query.ToList();
}
return(_projectList);
}
public bool IsValid(string _usermail, string _password)
{
using (var db = new ScrumApplicationDbContext())
{
var existUser = db.Users.FirstOrDefault(x => x.Mail == _usermail);
if (existUser != null)
{
if (existUser.Password == _password)
{
return(true);
}
}
}
return(false);
}
public static bool AddUserToTeam(int userId, int teamId, int roleCode)
{
using (var db = new ScrumApplicationDbContext())
{
var existTeam = new Team();
existTeam = db.Teams.FirstOrDefault(x => x.TeamId == teamId);
bool isMemberAdded = false;
if (existTeam != null)
{
foreach (var member in existTeam.Members.ToList())
{
if (member.UserId == userId)
{
isMemberAdded = true;
break;
}
}
if (!isMemberAdded)
{
var newMember = new Member();
var existUser = db.Users.FirstOrDefault(x => x.UserId == userId);
newMember.TeamId = teamId;
newMember.UserId = userId;
newMember.Name = existUser.Name;
newMember.Mail = existUser.Mail;
newMember.RoleCode = roleCode;
existTeam.Members.Add(newMember);
db.SaveChanges();
if (roleCode == 2)
{
var newManager = new Manager();
newManager.UserId = existUser.UserId;
newManager.MemberId = newMember.MemberId;
newManager.Name = existUser.Name;
newManager.Mail = existUser.Mail;
db.Managers.Add(newManager);
db.SaveChanges();
existTeam.ManagerId = newManager.ManagerId;
db.SaveChanges();
}
return(true);
}
}
}
return(false);
}
public static int GetProjectSprintCount(int projectId)
{
using (var db = new ScrumApplicationDbContext())
{
var existProject = db.Projects.FirstOrDefault(x => x.ProjectId == projectId);
var projectBacklogs = ProjectRepository.GetProjectBacklogs(projectId);
int sprintCount = 0;
foreach (var backlog in projectBacklogs)
{
if (sprintCount < backlog.SprintNo)
{
sprintCount = backlog.SprintNo;
}
}
return(sprintCount);
}
}
public static User GetUser()
{
var user = new User();
HttpCookie cookie = HttpContext.Current.Request.Cookies.Get("UserId");
int userId = Int32.Parse(cookie.Value);
using (var db = new ScrumApplicationDbContext())
{
user = db.Users.FirstOrDefault(x => x.UserId == userId);
if (user != null)
{
return(user);
}
}
return(null);
}
public static int GetUserMemberIdFromTeamId(int teamId)
{
using (var db = new ScrumApplicationDbContext())
{
var existTeam = new Team();
existTeam = db.Teams.FirstOrDefault(x => x.TeamId == teamId);
int userId = UserRepository.GetUserId();
foreach (var member in db.Members)
{
if (member.TeamId == existTeam.TeamId && member.UserId == userId)
{
return(member.MemberId);
}
}
return(0);
}
}
public static List <Team> GetTeams(int userId)
{
var _teamList = new List <Team>();
var existUser = new User();
using (var db = new ScrumApplicationDbContext())
{
if (userId != 0)
{
var query = from member in db.Members
where member.UserId == userId
select member.Team;
_teamList = query.ToList();
}
}
return(_teamList);
}
public static int GetTeamIdFromProductBacklog(int taskId)
{
using (var db = new ScrumApplicationDbContext())
{
var existBacklog = new ProductBacklog();
var existProject = new Project();
var existTeam = new Team();
existBacklog = db.ProductBacklogs.FirstOrDefault(x => x.ProductBacklogId == taskId);
existProject = db.Projects.FirstOrDefault(x => x.ProjectId == existBacklog.ProjectId);
existTeam = db.Teams.FirstOrDefault(x => x.TeamId == existProject.TeamId);
if (existTeam.TeamId != 0)
{
return(existTeam.TeamId);
}
return(0);
}
}
public static bool RemoveMemberFromTeam(int memberId)
{
using (var db = new ScrumApplicationDbContext())
{
var existMember = db.Members.FirstOrDefault(x => x.MemberId == memberId);
var existTeam = db.Teams.FirstOrDefault(x => x.TeamId == existMember.TeamId);
if (existMember != null && existTeam != null)
{
existTeam.Members.Remove(existMember);
db.Members.Remove(existMember);
db.SaveChanges();
return(true);
}
}
return(false);
}
public static List <Project> GetUserProjects(int userId)
{
using (var db = new ScrumApplicationDbContext())
{
var userTeams = TeamRepository.GetTeams(userId);
var userProjects = new List <Project>();
foreach (var team in userTeams)
{
foreach (var project in db.Projects)
{
if (project.TeamId == team.TeamId && project.IsDone == false)
{
userProjects.Add(project);
}
}
}
return(userProjects);
}
}
