public ProjectModel getProject([FromUri] int projectID)
{
TaskManagerRepository tmRep = new TaskManagerRepository();
Project_Tbl projectDb = tmRep.getProject(projectID);
return(_modelFactory.getProjectModel(projectDb));
}
public IHttpActionResult deleteProject([FromUri] int projectID)
{
if (!ModelState.IsValid)
{
return(BadRequest("Not a valid data"));
}
try
{
TaskManagerRepository tmRep = new TaskManagerRepository();
if (projectID > 0)
{
if (tmRep.getUserFromProjectID(projectID) != null)
{
return(BadRequest("Could not delete Project having User mapped"));
}
else
{
tmRep.deleteProject(projectID);
return(Ok());
}
}
else
{
return(BadRequest("Error occurred during data deletion in deleteProject"));
}
}
catch (Exception ex)
{
return(BadRequest("Error occurred in DeleteTask :" + ex.StackTrace));
}
}
public IHttpActionResult EditEndTask([FromBody] TaskModel taskModel)
{
if (!ModelState.IsValid)
{
return(BadRequest("Not a valid data"));
}
try
{
TaskManagerRepository taskRep = new TaskManagerRepository();
Task_Tbl taskDb = taskRep.GetTaskRepo(taskModel.TaskId);
if (taskDb != null)
{
string result = "{'TaskID': " + taskRep.EditEndTask(taskModel.TaskId, taskModel.IsCompleted) + "}";
JObject json = JObject.Parse(result);
return(Ok <JObject>(json));
}
else
{
return(BadRequest("Error occurred during data update in EditEndTask"));
}
}
catch (Exception ex)
{
return(BadRequest("Error occurred in EditEndTask :" + ex.StackTrace));
}
}
public IHttpActionResult DeleteTask(int TaskID)
{
if (!ModelState.IsValid)
{
return(BadRequest("Not a valid data"));
}
try
{
TaskManagerRepository TaskRep = new TaskManagerRepository();
if (TaskID > 0)
{
TaskRep.DeleteTask(TaskID);
return(Ok());
}
else
{
return(BadRequest("Error occurred during data deletion in DeleteTask"));
}
}
catch (Exception ex)
{
return(BadRequest("Error occurred in DeleteTask :" + ex.StackTrace));
}
}
public IHttpActionResult deleteUser([FromUri] int userID)
{
if (!ModelState.IsValid)
{
return(BadRequest("Not a valid data"));
}
try
{
TaskManagerRepository tmRep = new TaskManagerRepository();
if (userID > 0)
{
tmRep.deleteUser(userID);
return(Ok());
}
else
{
return(BadRequest("Error occurred during data deletion in deleteUser"));
}
}
catch (Exception ex)
{
return(BadRequest("Error occurred in deleteUser :" + ex.StackTrace));
}
}
public UsersModel getUser([FromUri] int userID)
{
TaskManagerRepository tmRep = new TaskManagerRepository();
User_Tbl userDb = tmRep.getUser(userID);
return(_modelFactory.getUsersModel(userDb));
}
public IHttpActionResult addUser([FromBody] UsersModel user)
{
if (!ModelState.IsValid)
{
return(BadRequest("Not a valid data"));
}
try
{
if (user != null)//if 0 for no chnage in parent task
{
TaskManagerRepository tmRep = new TaskManagerRepository();
User_Tbl userDb = new User_Tbl
{
First_Name = user.FirstName,
Last_Name = user.LastName,
Employee_ID = user.EmpID,
};
string result = "{'UserID': " + tmRep.addUser(userDb) + "}";
JObject json = JObject.Parse(result);
return(Ok <JObject>(json));
}
else
{
return(BadRequest("Error occurred in AddUser"));
}
}
catch (Exception ex)
{
return(BadRequest("Error occurred in AddUser :" + ex.StackTrace));
}
}
public IHttpActionResult editUser([FromBody] UsersModel user)
{
if (!ModelState.IsValid)
{
return(BadRequest("Not a valid data"));
}
try
{
TaskManagerRepository tmRep = new TaskManagerRepository();
User_Tbl userDb = tmRep.getUser(user.UserId);
if (userDb != null)
{
userDb.First_Name = user.FirstName;
userDb.Last_Name = user.LastName;
userDb.Employee_ID = Convert.ToInt32(user.EmpID);
string result = "{'UserID': " + tmRep.editUser(userDb) + "}";
JObject json = JObject.Parse(result);
return(Ok <JObject>(json));
}
else
{
return(BadRequest("Error occurred during data update in editUser"));
}
}
catch (Exception ex)
{
return(BadRequest("Error occurred in editUser :" + ex.StackTrace));
}
}
//// PUT api/values/5
//[HttpPut]
//public IHttpActionResult EditTask([FromBody]TaskModel TaskModel)
//{
// if (!ModelState.IsValid)
// return BadRequest("Not a valid data");
// try
// {
// return TaskDBChanges(TaskModel);
// }
// catch (Exception ex)
// {
// return BadRequest("Error occurred in EditTask :" + ex.StackTrace);
// }
//}
private IHttpActionResult TaskDBChanges(TaskModel taskModel, int parentID = 0)
{
TaskManagerRepository taskRep = new TaskManagerRepository();
Task_Tbl taskDb = taskRep.GetTaskRepo(taskModel.TaskId);
if (taskDb != null)
{
taskDb.Parent_ID = parentID > 0 ? parentID : (int?)null;
taskDb.Task = taskModel.TaskName;
taskDb.Start_Date = Convert.ToDateTime(taskModel.StartDate);
taskDb.End_Date = Convert.ToDateTime(taskModel.EndDate);
taskDb.Priority = taskModel.Priority;
taskDb.Is_Completed = Convert.ToBoolean(taskModel.IsCompleted);
string result = "{'TaskID': " + taskRep.EditTask(taskDb) + "}";
JObject json = JObject.Parse(result);
return(Ok <JObject>(json));
}
else
{
Task_Tbl taskDbNew = new Task_Tbl
{
Task = taskModel.TaskName,
Start_Date = Convert.ToDateTime(taskModel.StartDate),
End_Date = Convert.ToDateTime(taskModel.EndDate),
Priority = taskModel.Priority
};
string result = "{'TaskID': " + taskRep.CreateTask(taskDbNew) + "}";
JObject json = JObject.Parse(result);
return(Ok <JObject>(json));
}
}
public IHttpActionResult editParentTask([FromBody] ParentTaskModel parentTask)
{
if (!ModelState.IsValid)
{
return(BadRequest("Not a valid data"));
}
try
{
if (parentTask != null)//if 0 for no chnage in parent task
{
TaskManagerRepository tmRep = new TaskManagerRepository();
Parent_Task_Tbl parentTaskDb = new Parent_Task_Tbl
{
Parent_ID = parentTask.ParentTaskID,
Parent_Task = parentTask.ParentTaskName,
};
string result = "{'ParentTaskID': " + tmRep.EditParentTask(parentTaskDb) + "}";
JObject json = JObject.Parse(result);
return(Ok <JObject>(json));
}
else
{
return(BadRequest("Error occurred in editProject"));
}
}
catch (Exception ex)
{
return(BadRequest("Error occurred in EditParentTask :" + ex.StackTrace));
}
}
public TaskModel GetTask([FromUri] int taskID)
{
TaskManagerRepository tmRep = new TaskManagerRepository();
Task_Tbl taskDb = tmRep.GetTaskRepo(taskID);
return(_modelFactory.getTaskModel(taskDb));
}
public IHttpActionResult CreateParentTask([FromBody] ParentTaskModel parentTask)
{
if (!ModelState.IsValid)
{
return(BadRequest("Not a valid data"));
}
try
{
TaskManagerRepository parentTaskRep = new TaskManagerRepository();
Parent_Task_Tbl parentTaskDb = new Parent_Task_Tbl
{
Parent_Task = parentTask.ParentTaskName,
};
string result = "{'ParentTaskID': " + parentTaskRep.CreateParentTask(parentTaskDb) + "}";
JObject json = JObject.Parse(result);
return(Ok <JObject>(json));
}
catch (Exception ex)
{
return(BadRequest("Error occurred in CreateParentTask :" + ex.StackTrace));
}
}
public async Task TestGet_VerifyTaskName()
{
SetUpMockData();
var taskRepository = new TaskManagerRepository(mockContext.Object);
var taskDetails = await taskRepository.GetAsync(2);
Assert.IsType <TaskItem>(taskDetails);
}
public async Task TestGetAll_ReturnsTwoTaskDetails()
{
SetUpMockData();
var taskRepository = new TaskManagerRepository(mockContext.Object);
var taskDetails = await taskRepository.GetAllAsync();
Assert.Equal(2, taskDetails.Count());
}
public IEnumerable <ParentTaskModel> Get()
{
TaskManagerRepository parentTaskRep = new TaskManagerRepository();
var allParentTask = parentTaskRep.GetAllParentTasksRepo().ToList();
var allChildTask = parentTaskRep.GetAllTaskRepo().ToList();
Parent_Task_Tbl newParent = new Parent_Task_Tbl
{
Task_Tbl = allChildTask,
};
allParentTask.Add(newParent);
return(allParentTask.Select(p => _modelFactory.GetParentTaskMoDel(p)));
}
public List <UserTaskModel> GetTaskDetails()
{
try
{
using (var repository = new TaskManagerRepository())
{
var taskdetails = repository.GetTaskDetails();
return(taskdetails);
}
}
catch (Exception ex)
{
throw ex;
}
}
//[HttpGet]
//public ParentTaskModel GetParentTask(int parentID)
//{
// TaskManagerRepository parentTaskRep = new TaskManagerRepository();
// return _modelFactory.GetParentTaskMoDel(parentTaskRep.GetParentTaskRepo(parentID));
//}
//[HttpGet]
//public IEnumerable<TaskModel> GetAllTask()
//{
// TaskManagerRepository parentTaskRep = new TaskManagerRepository();
// return parentTaskRep.GetAllTaskRepo().ToList().Select(t => _modelFactory.GetTaskModel(t));
//}
//[HttpGet]
//public TaskModel GetTask(int taskID)
//{
// TaskManagerRepository parentTaskRep = new TaskManagerRepository();
// return _modelFactory.GetTaskModel(parentTaskRep.GetTaskRepo(taskID));
//}
public int CreateParentTask([FromBody] ParentTaskModel parentTask)
{
try
{
TaskManagerRepository parentTaskRep = new TaskManagerRepository();
Parent_Task_Tbl parentTaskDb = new Parent_Task_Tbl
{
Parent_Task = parentTask.ParentTaskName,
};
return(parentTaskRep.CreateParentTask(parentTaskDb));
}
catch (Exception ex)
{
return(0);
}
}
public void SetUp()
{
CreateDbContext().Database.EnsureDeleted();
using (var context = CreateDbContext())
{
context.Assignment.Add(new Assignment {
Id = 1, TaskName = "Test", TaskStatus = (int)AssignmentStatus.Completed
});
context.Assignment.Add(new Assignment {
Id = 2, TaskName = "Test1", TaskStatus = (int)AssignmentStatus.Open
});
context.SaveChanges();
}
_taskManagerRepository = new TaskManagerRepository(CreateDbContext());
}
public async Task TestInsertAsync_VerifySaveChangesCalledOnce()
{
SetUpMockData();
var taskRepository = new TaskManagerRepository(mockContext.Object);
var taskDetail = new TaskItem()
{
Id = 1, Name = "Task 1 ", Priority = 10
};
var mockSet = new Mock <DbSet <TaskItem> >();
mockContext.Setup(m => m.Tasks).Returns(mockSet.Object);
var result = await taskRepository.InsertAsync(taskDetail);
mockSet.Verify(m => m.Add(taskDetail), Times.Once);
mockContext.Verify(m => m.SaveChangesAsync(System.Threading.CancellationToken.None), Times.Once);
}
public async Task TestUpdateAsync_VerifySaveChangesCalledOnce()
{
var contextOptions = new DbContextOptions <TaskManagerDbContext>();
var mockContext = new Mock <TaskManagerDbContext>(contextOptions);
var taskRepository = new TaskManagerRepository(mockContext.Object);
var taskDetail = new TaskItem()
{
Id = 1, Name = "Task 1 ", Priority = 10
};
var mockSet = new Mock <DbSet <TaskItem> >();
mockContext.Setup(m => m.Tasks).Returns(mockSet.Object);
await taskRepository.UpdateAsync(1, taskDetail);
mockSet.Verify(m => m.Update(taskDetail), Times.Once);
mockContext.Verify(m => m.SaveChangesAsync(System.Threading.CancellationToken.None), Times.Once);
}
public IHttpActionResult editProject([FromBody] ProjectModel project)
{
if (!ModelState.IsValid)
{
return(BadRequest("Not a valid data"));
}
try
{
if (project != null)//if 0 for no chnage in parent task
{
TaskManagerRepository tmRep = new TaskManagerRepository();
Project_Tbl projectDb = new Project_Tbl
{
Project_ID = project.ProjectID,
Project = project.ProjectName,
Start_Date = project.StartDate != null?Convert.ToDateTime(project.StartDate) : (DateTime?)null,
End_Date = project.EndDate != null?Convert.ToDateTime(project.EndDate) : (DateTime?)null,
Priority = project.Priority,
};
int userId = project.Users != null?project.Users.FirstOrDefault().UserId : 0;
string result = "{'ProjectID': " + tmRep.editProject(projectDb, userId) + "}";
JObject json = JObject.Parse(result);
return(Ok <JObject>(json));
}
else
{
return(BadRequest("Error occurred in editProject"));
}
}
catch (Exception ex)
{
return(BadRequest("Error occurred in editProject :" + ex.StackTrace));
}
}
public async Task TestGet_VerifyTaskName()
{
var contextOptions = new DbContextOptions <TaskManagerDbContext>();
var mockContext = new Mock <TaskManagerDbContext>(contextOptions);
var taskRepository = new TaskManagerRepository(mockContext.Object);
IQueryable <TaskItem> taskDetailsList = new List <TaskItem>()
{
new TaskItem()
{
Id = 1, Name = "Task 1", Priority = 10
},
new TaskItem()
{
Id = 2, Name = "Task 2", Priority = 20
},
}.AsQueryable();
var mockSet = new Mock <DbSet <TaskItem> >();
mockSet.As <IAsyncEnumerable <TaskItem> >()
.Setup(m => m.GetEnumerator())
.Returns(new TestAsyncEnumerator <TaskItem>(taskDetailsList.GetEnumerator()));
mockSet.As <IQueryable <TaskItem> >()
.Setup(m => m.Provider)
.Returns(new TestAsyncQueryProvider <TaskItem>(taskDetailsList.Provider));
mockSet.As <IQueryable <TaskItem> >().Setup(m => m.Expression).Returns(taskDetailsList.Expression);
mockSet.As <IQueryable <TaskItem> >().Setup(m => m.ElementType).Returns(taskDetailsList.ElementType);
mockSet.As <IQueryable <TaskItem> >().Setup(m => m.GetEnumerator()).Returns(() => taskDetailsList.GetEnumerator());
mockContext.Setup(m => m.Tasks).Returns(mockSet.Object);
var taskDetails = await taskRepository.GetAsync(2);
Assert.Equal("Task 2", taskDetails.Name);
}
public IEnumerable <ProjectModel> getAllProjects()
{
TaskManagerRepository tmRep = new TaskManagerRepository();
return(tmRep.getAllProjects().ToList().Select(u => _modelFactory.getProjectModel(u)));
}
