/// <summary>
/// Method to get all project list
/// </summary>
/// <returns></returns>
public List <ProjectModel> GetAllProject()
{
using (ProjectManagerEntities entity = new ProjectManagerEntities())
{
var projectList = (from project in entity.Projects
join task in entity.Tasks on project.Project_ID equals task.Project_ID into allPro
from temp in allPro.DefaultIfEmpty()
where project.Status == true
//orderby project.Project_ID descending
select new ProjectModel()
{
ProjectId = project.Project_ID,
Project = project.Project1,
Priority = project.Priority,
StartDate = project.Start_Date,
EndDate = project.End_Date,
IsActive = project.Status,
NoOfTasks = project.Tasks.Count(),
ManagerId = project.Manager_ID,
CompletedTasks = project.Tasks.Where(x => x.Status == false).Count()
}).Distinct().ToList();
return(projectList.OrderByDescending(x => x.ProjectId).ToList());
}
}
/// <summary>
/// Method to create new project or update an existing project
/// </summary>
/// <param name="projectModel"></param>
/// <returns></returns>
public string AddOrUpdateProject(ProjectModel projectModel)
{
string result = string.Empty;
using (ProjectManagerEntities entity = new ProjectManagerEntities())
{
if (projectModel != null)
{
Project addProject = new Project();
addProject.Project_ID = projectModel.ProjectId;
addProject.Project1 = projectModel.Project;
if (projectModel.StartDateString != null && !string.IsNullOrEmpty(projectModel.StartDateString))
{
addProject.Start_Date = Convert.ToDateTime(projectModel.StartDateString);
}
if (projectModel.EndDateString != null && !string.IsNullOrEmpty(projectModel.EndDateString))
{
addProject.End_Date = Convert.ToDateTime(projectModel.EndDateString);
}
addProject.Priority = projectModel.Priority;
addProject.Manager_ID = projectModel.ManagerId;
addProject.Status = true;
result = addProject.Project_ID == 0 ? "ADD" : "UPDATE";
entity.Entry(addProject).State = addProject.Project_ID == 0 ? System.Data.Entity.EntityState.Added : System.Data.Entity.EntityState.Modified;
entity.SaveChanges();
}
}
return(result);
}
public int DeleteUserDetails(UserModel userModel)
{
int returnVal = 0;
using (ProjectManagerEntities userEntity = new ProjectManagerEntities())
{
User objUser = userEntity.Users.Where(x => x.User_ID == userModel.User_ID).FirstOrDefault();
if (objUser != null)
{
objUser.First_Name = userModel.First_Name;
objUser.Last_Name = userModel.Last_Name;
objUser.Employee_ID = userModel.Employee_ID;
//objUser.Project_ID = userModel.ProjectId;
objUser.IsActive = false;
userEntity.Entry(objUser).State = EntityState.Modified;
try
{
userEntity.SaveChanges();
returnVal = 1;
}
catch (Exception ex)
{
return(returnVal);
}
}
}
return(returnVal);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public List <ProjectModel> GetProjectName()
{
List <ProjectModel> projectModelList = null;
using (ProjectManagerEntities db = new ProjectManagerEntities())
{
var projectList = db.Projects.Select(o => new { o.Project_ID, o.Project1 }).Distinct().ToList();
if (projectList != null)
{
projectModelList = new List <ProjectModel>();
foreach (var item in projectList)
{
projectModelList.Add(new ProjectModel()
{
Project_ID = item.Project_ID,
Project = item.Project1,
});
}
}
return(projectModelList);
}
}
public List <TaskModel> GetAllTaskRepository()
{
List <TaskModel> taskModel = null;
using (ProjectManagerEntities taskManagerEntity = new ProjectManagerEntities())
{
taskModel = (from taskDts in taskManagerEntity.Tasks.Include("ParentTask")
orderby taskDts.Start_Date, taskDts.Task_ID descending
select new TaskModel
{
Parent_ID = taskDts.ParentTask.Parent_ID,
ParentTask = taskDts.ParentTask.Parent_Task,
Task_ID = taskDts.Task_ID,
Task = taskDts.Task1,
Start_Date = taskDts.Start_Date,
End_Date = taskDts.End_Date,
Priority = taskDts.Priority,
IsActive = taskDts.IsActive,
User_ID = taskDts.User_ID,
Project_ID = taskDts.Project_ID,
Project_Name = taskDts.Project.Project1,
Parent_Task = taskDts.ParentTask.Parent_Task
}).ToList();
}
return(taskModel);
}
public int UpdateTaskRepository(TaskModel taskModel)
{
int returnVal = 0;
using (ProjectManagerEntities taskManagerEntity = new ProjectManagerEntities())
{
Task objtask = taskManagerEntity.Tasks.Where(x => x.Task_ID == taskModel.Task_ID).FirstOrDefault();
if (objtask != null)
{
objtask.Task1 = taskModel.Task;
objtask.Parent_ID = taskModel.Parent_ID;
objtask.Start_Date = taskModel.Start_Date;
objtask.End_Date = taskModel.End_Date;
objtask.IsActive = taskModel.IsActive;
objtask.Priority = taskModel.Priority;
objtask.Project_ID = taskModel.Project_ID;
objtask.User_ID = taskModel.User_ID;
taskManagerEntity.Entry(objtask).State = EntityState.Modified;
try
{
taskManagerEntity.SaveChanges();
returnVal = 1;
}
catch (Exception ex)
{
return(returnVal);
}
}
}
return(returnVal);
}
public List <DAL.User> GetUsers()
{
using (ProjectManagerEntities context = new ProjectManagerEntities())
{
var user = (from p in context.Users
select new
{
First_Name = p.First_Name,
Last_Name = p.Last_Name,
Employee_ID = p.Employee_ID,
Project_ID = p.Project_ID,
Task_ID = p.Task_ID,
User_ID = p.User_ID
}).ToList()
.Select(x => new User()
{
First_Name = x.First_Name,
Last_Name = x.Last_Name,
Employee_ID = x.Employee_ID,
Project_ID = x.Project_ID,
Task_ID = x.Task_ID,
User_ID = x.User_ID
});
return(user.ToList());
}
}
public void SuspendProject(int projectID)
{
ProjectManagerEntities mockContext = MockDataSetList();
var projectBL = new ProjectBL(mockContext);
projectBL.SuspendProject(projectID);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public List <ParentTaskModel> GetParentTaskList()
{
List <ParentTaskModel> parenttaskModelList = null;
using (ProjectManagerEntities db = new ProjectManagerEntities())
{
var parentTaskList = db.Parent_Task.ToList();
if (parentTaskList != null)
{
parenttaskModelList = new List <ParentTaskModel>();
foreach (var item in parentTaskList)
{
parenttaskModelList.Add(new ParentTaskModel()
{
Parent_ID = item.Parent_ID,
Parent_Task = item.Parent_Task1
});
}
}
return(parenttaskModelList);
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public List <TaskModel> GetTaskDetailList()
{
List <TaskModel> taskModelList = null;
using (ProjectManagerEntities db = new ProjectManagerEntities())
{
var taskList = db.Tasks.ToList();
if (taskList != null)
{
taskModelList = new List <TaskModel>();
foreach (var item in taskList)
{
taskModelList.Add(new TaskModel()
{
Task_ID = item.Task_ID,
Parent_ID = item.Parent_ID,
Parent_Task = item.Parent_Task != null ? item.Parent_Task.Parent_Task1 : "",
Task = item.Task1,
Start_Date = item.Start_Date,
End_Date = item.End_Date,
Priority = item.Priority,
Project_ID = item.Project_ID,
Status = item.Status,
User_ID = item.User_ID,
Project_Name = item.Project != null ? item.Project.Project1 : "",
Is_Active = item.Is_Active
});
}
}
return(taskModelList);
}
}
private bool InsertTaskDetail(TaskModel taskModel)
{
var isSubmitted = false;
using (ProjectManagerEntities objEntities = new ProjectManagerEntities())
{
try
{
Task objTask = new Task();
objTask.Task1 = taskModel.Task;
objTask.Project_ID = taskModel.Project_ID.Value;
objTask.Parent_ID = taskModel.Parent_ID;
objTask.Priority = taskModel.Priority;
objTask.Start_Date = taskModel.Start_Date;
objTask.End_Date = taskModel.End_Date;
objTask.User_ID = taskModel.User_ID;
objTask.Is_Active = 1;
objEntities.Tasks.Add(objTask);
var insertedRecord = objEntities.SaveChanges();
isSubmitted = insertedRecord > 0;
}
catch (Exception ex)
{
isSubmitted = false;
}
}
return(isSubmitted);
}
private bool UpdateTaskDetail(TaskModel taskModel)
{
var isSubmitted = false;
using (ProjectManagerEntities objEntities = new ProjectManagerEntities())
{
var existingTask = objEntities.Tasks.FirstOrDefault(p => p.Task_ID == taskModel.Task_ID);
if (existingTask != null)
{
existingTask.Task1 = taskModel.Task;
existingTask.Project_ID = taskModel.Project_ID.Value;
existingTask.Parent_ID = taskModel.Parent_ID;
existingTask.Priority = taskModel.Priority;
existingTask.Start_Date = taskModel.Start_Date;
existingTask.End_Date = taskModel.End_Date;
existingTask.User_ID = taskModel.User_ID;
}
var updatedRecord = objEntities.SaveChanges();
isSubmitted = updatedRecord > 0;
}
return(isSubmitted);
}
public int UpdateProjectDetails(ProjectModel prjModel)
{
int returnVal = 0;
using (ProjectManagerEntities projEntity = new ProjectManagerEntities())
{
Project objProject = projEntity.Projects.Where(x => x.Project_ID == prjModel.Project_ID).FirstOrDefault();
if (objProject != null)
{
objProject.Project1 = prjModel.Project;
objProject.Start_Date = prjModel.Start_Date;
objProject.End_Date = prjModel.End_Date;
objProject.Priority = prjModel.Priority;
objProject.Manager_ID = prjModel.Manager_ID;
objProject.Status = prjModel.Status;
projEntity.Entry(objProject).State = EntityState.Modified;
try
{
projEntity.SaveChanges();
returnVal = 1;
}
catch (Exception ex)
{
return(returnVal);
}
}
}
return(returnVal);
}
public int InsertProjectDetails(ProjectModel prjModel)
{
int returnVal = 0;
using (ProjectManagerEntities projectEntity = new ProjectManagerEntities())
{
Project objProject = new Project();
objProject.Project1 = prjModel.Project;
objProject.Start_Date = prjModel.Start_Date;
objProject.End_Date = prjModel.End_Date;
objProject.Priority = prjModel.Priority;
objProject.Manager_ID = prjModel.Manager_ID;
objProject.Status = true;
projectEntity.Projects.Add(objProject);
try
{
returnVal = projectEntity.SaveChanges();
}
catch (Exception ex)
{
return(returnVal);
}
}
return(returnVal);
}
public DAL.User GetUsersByID(int iUserID)
{
using (ProjectManagerEntities context = new ProjectManagerEntities())
{
var user = (from p in context.Users
where p.User_ID == iUserID
select new
{
First_Name = p.First_Name,
Last_Name = p.Last_Name,
Employee_ID = p.Employee_ID,
Project_ID = p.Project_ID,
Task_ID = p.Task_ID,
User_ID = p.User_ID
}).ToList()
.Select(x => new User()
{
First_Name = x.First_Name,
Last_Name = x.Last_Name,
Employee_ID = x.Employee_ID,
Project_ID = x.Project_ID,
Task_ID = x.Task_ID,
User_ID = x.User_ID
});
return(user.FirstOrDefault());
}
}
public void UpdateProject(CommonEntities.Projects project)
{
ProjectManagerEntities mockContext = MockDataSetList();
var projectBL = new ProjectBL(mockContext);
projectBL.UpdateProject(project);
}
/// <summary>
/// Method to end task
/// </summary>
/// <param name="taskModel"></param>
/// <returns></returns>
public bool End(TaskModel taskModel)
{
using (ProjectManagerEntities entity = new ProjectManagerEntities())
{
if (taskModel != null && taskModel.TaskId != 0)
{
Task endTask = new Task();
endTask.Task_ID = taskModel.TaskId;
endTask.Task1 = taskModel.Task;
if (taskModel.StartDateString != null)
{
endTask.Start_Date = Convert.ToDateTime(taskModel.StartDateString);
}
if (taskModel.EndDateString != null)
{
endTask.End_Date = Convert.ToDateTime(taskModel.EndDateString);
}
endTask.Priority = taskModel.Priority;
endTask.Parent_ID = taskModel.ParentId;
endTask.Project_ID = taskModel.ProjectId;
endTask.Status = false;
entity.Entry(endTask).State = System.Data.Entity.EntityState.Modified;
entity.SaveChanges();
}
return(true);
}
}
public void UpdateExistingUSersTask(int id)
{
using (var db = new ProjectManagerEntities())
{
db.SP_UpdateExistingUsersTask(id);
}
}
private bool InsertProjectDetail(ProjectModel projectModel)
{
var isSubmitted = false;
using (ProjectManagerEntities objEntities = new ProjectManagerEntities())
{
try
{
Project objProject = new Project();
objProject.Project1 = projectModel.Project;
objProject.Priority = projectModel.Priority;
objProject.Start_Date = projectModel.Start_Date;
objProject.End_Date = projectModel.End_Date;
objProject.Manager_ID = projectModel.Manager_ID;
objProject.Is_Active = 1;
objEntities.Projects.Add(objProject);
var insertedRecord = objEntities.SaveChanges();
isSubmitted = insertedRecord > 0;
}
catch (Exception ex)
{
isSubmitted = false;
}
}
return(isSubmitted);
}
public int InsertTaskRepository(TaskModel taskModel)
{
int returnVal = 0;
using (ProjectManagerEntities taskManagerEntity = new ProjectManagerEntities())
{
Task objtask = new Task();
objtask.Task1 = taskModel.Task;
objtask.Parent_ID = taskModel.Parent_ID;
objtask.Start_Date = taskModel.Start_Date;
objtask.End_Date = taskModel.End_Date;
objtask.IsActive = true;
objtask.Priority = taskModel.Priority;
objtask.Project_ID = taskModel.Project_ID;
objtask.User_ID = taskModel.User_ID;
taskManagerEntity.Tasks.Add(objtask);
try
{
returnVal = taskManagerEntity.SaveChanges();
}
catch (Exception ex)
{
return(returnVal);
}
}
return(returnVal);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public List <ProjectModel> GetProjectDetails()
{
List <ProjectModel> projectModelList = null;
using (ProjectManagerEntities db = new ProjectManagerEntities())
{
var projectList = db.Projects.ToList();
if (projectList != null)
{
projectModelList = new List <ProjectModel>();
foreach (var item in projectList)
{
projectModelList.Add(new ProjectModel()
{
Project_ID = item.Project_ID,
Project = item.Project1,
Start_Date = item.Start_Date,
End_Date = item.End_Date,
Priority = item.Priority,
Manager_ID = item.Manager_ID,
ProjStatus = item.Is_Active != 0 ? "Completed" : "Pending",
Is_Active = item.Is_Active,
TaskCount = item.Tasks.Count(),
Active_Progress = Convert.ToString((item.Priority * 100) / 30)
});
}
}
return(projectModelList);
}
}
public int InsertUserDetails(UserModel userModel)
{
int returnVal = 0;
using (ProjectManagerEntities userEntity = new ProjectManagerEntities())
{
User objUser = new User();
objUser.First_Name = userModel.First_Name;
objUser.Last_Name = userModel.Last_Name;
objUser.Employee_ID = userModel.Employee_ID;
//objUser.Project_ID = userModel.ProjectId;
objUser.IsActive = true;
userEntity.Users.Add(objUser);
try
{
returnVal = userEntity.SaveChanges();
}
catch (Exception ex)
{
return(returnVal);
}
}
return(returnVal);
}
/// <summary>
/// Method to suspend project
/// </summary>
/// <param name="projectModel"></param>
/// <returns></returns>
public bool SuspendProject(ProjectModel projectModel)
{
using (ProjectManagerEntities entity = new ProjectManagerEntities())
{
if (projectModel != null && projectModel.ProjectId != 0)
{
Project suspendProject = new Project();
suspendProject.Project1 = projectModel.Project;
suspendProject.Project_ID = projectModel.ProjectId;
if (projectModel.StartDateString != null)
{
suspendProject.Start_Date = Convert.ToDateTime(projectModel.StartDateString);
}
if (projectModel.EndDateString != null)
{
suspendProject.End_Date = Convert.ToDateTime(projectModel.EndDateString);
}
suspendProject.Priority = projectModel.Priority;
suspendProject.Status = false;
entity.Entry(suspendProject).State = System.Data.Entity.EntityState.Modified;
entity.SaveChanges();
}
return(true);
}
}
private bool InsertUserDetail(UserModel userModel)
{
var isSubmitted = false;
using (ProjectManagerEntities objEntities = new ProjectManagerEntities())
{
try
{
User objUser = new User();
objUser.First_Name = userModel.First_Name;
objUser.Last_Name = userModel.Last_Name;
objUser.Employee_ID = userModel.Employee_ID;
objEntities.Users.Add(objUser);
var insertedRecord = objEntities.SaveChanges();
isSubmitted = insertedRecord > 0;
}
catch (Exception ex)
{
isSubmitted = false;
}
}
return(isSubmitted);
}
public List <ProjectModel> GetAllProject()
{
List <ProjectModel> projectDetails = null;
using (ProjectManagerEntities projectEntity = new ProjectManagerEntities())
{
projectDetails = (from projectDts in projectEntity.Projects
where projectDts.Status == true
select new ProjectModel
{
Project_ID = projectDts.Project_ID,
Project = projectDts.Project1,
Start_Date = projectDts.Start_Date,
End_Date = projectDts.End_Date,
Priority = projectDts.Priority,
Status = projectDts.Status,
NoOfTasks = projectDts.Tasks.Where(x => x.Project_ID == projectDts.Project_ID).Count(),
Manager_ID = projectDts.Manager_ID,
CompletedTasks = projectDts.Tasks.Where(x => x.IsActive == false && x.Project_ID == projectDts.Project_ID).Count(),
Active_Progress =
((projectDts.Tasks.Where(x => x.Project_ID == projectDts.Project_ID).Count() > 0) ?
(projectDts.Tasks.Where(x => x.IsActive == false && x.Project_ID == projectDts.Project_ID).Count() * 100) / projectDts.Tasks.Where(x => x.Project_ID == projectDts.Project_ID).Count() : 0),
}).OrderByDescending(x => x.Project_ID).ToList();
}
return(projectDetails);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public List <UserModel> GetUserDetails()
{
List <UserModel> userModelList = null;
using (ProjectManagerEntities db = new ProjectManagerEntities())
{
var userList = db.Users.ToList();
if (userList != null)
{
userModelList = new List <UserModel>();
foreach (var item in userList)
{
userModelList.Add(new UserModel()
{
User_ID = item.User_ID,
First_Name = item.First_Name,
Last_Name = item.Last_Name,
Employee_ID = item.Employee_ID
});
}
}
return(userModelList);
}
}
public bool DeleteUserDetail(int userId)
{
var isDeleted = false;
using (ProjectManagerEntities objEntities = new ProjectManagerEntities())
{
var existingUser = objEntities.Users.FirstOrDefault(p => p.User_ID == userId);
var existingUserTask = objEntities.Tasks.FirstOrDefault(p => p.User_ID == userId);
if (existingUserTask != null)
{
objEntities.Tasks.Remove(existingUserTask);
var deletedRecord = objEntities.SaveChanges();
isDeleted = deletedRecord > 0;
}
if (existingUser != null)
{
objEntities.Users.Remove(existingUser);
var deletedRecord = objEntities.SaveChanges();
isDeleted = deletedRecord > 0;
}
return(isDeleted);
}
}
private static ProjectManagerEntities MockDataSetList()
{
MockProjectManager mockProj = new MockProjectManager();
ProjectManagerEntities mockContext = mockProj.MockDataSetList();
return(mockContext);
}
public void EndTask(CommonEntities.Tasks task)
{
ProjectManagerEntities mockContext = MockDataSetList();
var taskBL = new TaskBL(mockContext);
taskBL.EndTask(task);
}
public Collection <CommonEntities.ParentTasks> GetParentTasks()
{
ProjectManagerEntities mockContext = MockDataSetList();
var taskBL = new TaskBL(mockContext);
Collection <CommonEntities.ParentTasks> tasks = taskBL.GetParentTasks();
return(tasks);
}
