public bool UpdateProject(ProjectModel projectModel)
{
EntityMapper <ProjectModel, Project> mapObj = new EntityMapper <ProjectModel, Project>();
var project = mapObj.Translate(projectModel);
return(ProjectManagerRepository.UpdateProject(project));
}
protected override void Seed(MainDataBase dataBase)
{
_usersRepository = new UsersRepository(dataBase);
_projectsRepository = new ProjectsRepository(dataBase);
_projectManagerRepository = new ProjectManagerRepository(dataBase);
}
public bool AddParentTask(ParentTaskModel parentTaskModel)
{
EntityMapper <ParentTaskModel, ParentTask> mapObj = new EntityMapper <ParentTaskModel, ParentTask>();
var parentTask = mapObj.Translate(parentTaskModel);
return(ProjectManagerRepository.InsertParentTask(parentTask));
}
public void Delete_Test()
{
ParentTask pTask = new ParentTask();
pTask.ParentId = 1;
pTask.TaskName = "ABCD";
var ptasks = new List <ParentTask>();
ptasks.Add(pTask);
var t = ptasks.AsQueryable();
//var mockSet = new Mock<DbSet<Task_Table>>();
var mockSet = new Mock <DbSet <ParentTask> >();
mockSet.As <IQueryable <ParentTask> >().Setup(m => m.Provider).Returns(t.Provider);
mockSet.As <IQueryable <ParentTask> >().Setup(m => m.Expression).Returns(t.Expression);
mockSet.As <IQueryable <ParentTask> >().Setup(m => m.ElementType).Returns(t.ElementType);
mockSet.As <IQueryable <ParentTask> >().Setup(m => m.GetEnumerator()).Returns(t.GetEnumerator());
var mockTaskMangerContext = new Mock <ProjectmanagerContext>();
mockTaskMangerContext.Setup(c => c.ParentTasks).Returns(mockSet.Object);
mockTaskMangerContext.Setup(c => c.Set <ParentTask>()).Returns(mockSet.Object);
mockTaskMangerContext.Setup(c => c.Set <ParentTask>().Remove(pTask));
mockTaskMangerContext.Setup(p => p.SaveChanges());
var objTestTaskrepo = new ProjectManagerRepository <ParentTask>(mockTaskMangerContext.Object);
objTestTaskrepo.Delete(pTask);
mockTaskMangerContext.Verify(mock => mock.Set <ParentTask>().Remove(pTask), Times.Once());
}
public bool UpdateTask(TaskModel taskModel)
{
EntityMapper <TaskModel, Task> mapObj = new EntityMapper <TaskModel, Task>();
var task = mapObj.Translate(taskModel);
return(ProjectManagerRepository.UpdateTask(task));
}
public bool AddUser(UserModel userModel)
{
EntityMapper <UserModel, User> mapObj = new EntityMapper <UserModel, User>();
var user = mapObj.Translate(userModel);
return(ProjectManagerRepository.InsertUser(user));
}
public void InsertParentTaskForValidDataTest()
{
var validData = new ParentTask()
{
ParentTaskName = "Build Framework"
};
var isSuccess = ProjectManagerRepository.InsertParentTask(validData);
Assert.AreEqual(true, isSuccess);
}
public void InsertParentTaskForInValidDataTest()
{
var inValidData = new ParentTask()
{
ParentTaskName = null
};
var isSuccess = ProjectManagerRepository.InsertParentTask(inValidData);
Assert.AreEqual(false, isSuccess);
}
public ParentTaskModel GetParentTask(int parentID)
{
EntityMapper <ParentTask, ParentTaskModel> mapObj = new EntityMapper <ParentTask, ParentTaskModel>();
ParentTask parentTask = ProjectManagerRepository.GetParentTask(parentID);
ParentTaskModel parentTaskModel = new ParentTaskModel();
parentTaskModel = mapObj.Translate(parentTask);
return(parentTaskModel);
}
public TaskModel GetTask(int taskID)
{
EntityMapper <Task, TaskModel> mapObj = new EntityMapper <Task, TaskModel>();
Task task = ProjectManagerRepository.GetTask(taskID);
TaskModel taskModel = new TaskModel();
taskModel = mapObj.Translate(task);
return(taskModel);
}
public ProjectModel GetProject(int projectID)
{
EntityMapper <Project, ProjectModel> mapObj = new EntityMapper <Project, ProjectModel>();
Project project = ProjectManagerRepository.GetProject(projectID);
ProjectModel projectModel = new ProjectModel();
projectModel = mapObj.Translate(project);
return(projectModel);
}
public UserModel GetUser(int userID)
{
EntityMapper <User, UserModel> mapObj = new EntityMapper <User, UserModel>();
User user = ProjectManagerRepository.GetUser(userID);
UserModel userModel = new UserModel();
userModel = mapObj.Translate(user);
return(userModel);
}
public List <UserModel> SearchUsers(string searchKeyWord, string sortBy)
{
EntityMapper <User, UserModel> mapObj = new EntityMapper <User, UserModel>();
List <User> userList = ProjectManagerRepository.SearchUsers(searchKeyWord, sortBy);
List <UserModel> userModels = new List <UserModel>();
foreach (var user in userList)
{
userModels.Add(mapObj.Translate(user));
}
return(userModels);
}
public void InsertProjectForInValidDataTest()
{
var inValidData = new Project()
{
ProjectName = null,
Start_Date = null,
End_Date = null,
Priority = 1
};
var isSuccess = ProjectManagerRepository.InsertProject(inValidData);
Assert.AreEqual(false, isSuccess);
}
public List <UserModel> GetUsers()
{
EntityMapper <User, UserModel> mapObj = new EntityMapper <User, UserModel>();
List <User> userList = ProjectManagerRepository.GetUsers();
List <UserModel> userModels = new List <UserModel>();
foreach (var user in userList)
{
userModels.Add(mapObj.Translate(user));
}
return(userModels);
}
public void InsertProjectForValidDataTest()
{
var validData = new Project()
{
ProjectName = "Microsoft",
Start_Date = null,
End_Date = null,
Priority = 1
};
var isSuccess = ProjectManagerRepository.InsertProject(validData);
Assert.AreEqual(true, isSuccess);
}
public List <ProjectModel> SearchProjects(string searchKeyWord, string sortBy)
{
EntityMapper <Project, ProjectModel> mapObj = new EntityMapper <Project, ProjectModel>();
List <Project> projectList = ProjectManagerRepository.SearchProjects(searchKeyWord, sortBy);
List <ProjectModel> projectModels = new List <ProjectModel>();
foreach (var project in projectList)
{
projectModels.Add(mapObj.Translate(project));
}
return(projectModels);
}
public ProjectController(ProjectRepository projectRepository,
CustomerRepository customerRepository,
ProjectManagerRepository projectManagerRepository,
IWebHostEnvironment webHostEnvironment,
Repo3 repo3
)
{
_projectRepository = projectRepository;
_customerRepository = customerRepository;
_projectManagerRepository = projectManagerRepository;
_webHostEnvironment = webHostEnvironment;
_repo3 = repo3;
}
public List <ParentTaskModel> GetParentTasks()
{
EntityMapper <ParentTask, ParentTaskModel> mapObj = new EntityMapper <ParentTask, ParentTaskModel>();
List <ParentTask> parentTaskList = ProjectManagerRepository.GetParentTasks();
List <ParentTaskModel> parentTaskModels = new List <ParentTaskModel>();
foreach (var parent in parentTaskList)
{
var parentTaskModel = mapObj.Translate(parent);
parentTaskModels.Add(parentTaskModel);
}
return(parentTaskModels);
}
public void InsertUserForValidDataTest()
{
var validData = new User()
{
FirstName = "Raja",
LastName = "J",
Employee_ID = 25,
Project_ID = 1,
Task_ID = 1
};
var isSuccess = ProjectManagerRepository.InsertUser(validData);
Assert.AreEqual(true, isSuccess);
}
public void InsertUserForInValidDataTest()
{
var inValidData = new User()
{
FirstName = null,
LastName = null,
Employee_ID = 1,
Project_ID = 1,
Task_ID = 1
};
var isSuccess = ProjectManagerRepository.InsertUser(inValidData);
Assert.AreEqual(false, isSuccess);
}
public bool AddProject(ProjectModel projectModel)
{
EntityMapper <ProjectModel, Project> mapObj = new EntityMapper <ProjectModel, Project>();
var project = mapObj.Translate(projectModel);
if (project.Start_Date == default(DateTime))
{
project.Start_Date = null;
}
if (project.End_Date == default(DateTime))
{
project.End_Date = null;
}
return(ProjectManagerRepository.InsertProject(project));
}
public void UpdateUserForValidDataTest()
{
var validData = new User()
{
User_ID = 1,
FirstName = "Reshma",
LastName = "Rajendran",
Employee_ID = 1,
Project_ID = 1,
Task_ID = 1
};
var isSuccess = ProjectManagerRepository.UpdateUser(validData);
Assert.AreEqual(true, isSuccess);
}
public List <TaskModel> GetTasks()
{
EntityMapper <Task, TaskModel> mapObj = new EntityMapper <Task, TaskModel>();
List <Task> taskList = ProjectManagerRepository.GetTasks();
List <TaskModel> taskModels = new List <TaskModel>();
foreach (var task in taskList)
{
var taskModel = mapObj.Translate(task);
taskModel.ParentTaskName = ProjectManagerRepository.GetParentTask(task.Parent_ID).ParentTaskName;
taskModels.Add(taskModel);
}
return(taskModels);
}
public void InsertTaskForInValidDataTest()
{
var inValidData = new Task()
{
TaskName = null,
Parent_ID = 1,
Project_ID = 1,
Start_Date = DateTime.Now,
End_Date = DateTime.Now.AddDays(1),
Priority = 1,
Status = true
};
var isSuccess = ProjectManagerRepository.InsertTask(inValidData);
Assert.AreEqual(false, isSuccess);
}
public List <ProjectModel> GetProjects()
{
EntityMapper <Project, ProjectModel> mapObj = new EntityMapper <Project, ProjectModel>();
List <Project> projectList = ProjectManagerRepository.GetProjects();
List <ProjectModel> projectModels = new List <ProjectModel>();
foreach (var project in projectList)
{
var projectModel = mapObj.Translate(project);
projectModel.NoOfTasks = ProjectManagerRepository.GetTasks().Where(x => x.Project_ID == projectModel.Project_ID).ToList().Count;
projectModel.CompletedTasks = ProjectManagerRepository.GetTasks().Where(x => x.Project_ID == projectModel.Project_ID && x.End_Date.Date <= DateTime.Now.Date).ToList().Count;
projectModels.Add(projectModel);
}
return(projectModels);
}
public void InsertTaskForValidDataTest()
{
var validData = new Task()
{
Parent_ID = 1,
Project_ID = 1,
TaskName = "Generate Scripts",
Start_Date = DateTime.Now,
End_Date = DateTime.Now.AddDays(1),
Priority = 1,
Status = true
};
var isSuccess = ProjectManagerRepository.InsertTask(validData);
Assert.AreEqual(true, isSuccess);
}
public void DeleteProjectTest()
{
var isSuccess = ProjectManagerRepository.DeleteProject(1);
Assert.AreEqual(true, isSuccess);
}
public void UpdateParentTaskForNullTest()
{
var isSuccess = ProjectManagerRepository.UpdateParentTask(null);
Assert.AreEqual(false, isSuccess);
}
public void SearchProjectsForNullTest()
{
var projects = ProjectManagerRepository.SearchProjects(null, null);
Assert.Zero(projects.Count);
}
