public IHttpActionResult ManageTask([FromBody] ParentTaskModel parentTask)
{
if (!ModelState.IsValid)
{
return(BadRequest("Not a valid data"));
}
try
{
if (parentTask.ParentTaskID == 0)//if 0 for no chnage in parent task
{
return(TaskDBChanges(parentTask.Task.FirstOrDefault(), 0));
}
else if (parentTask.ParentTaskID == -1)// if -1 to create new parenk task
{
return(ManageParentTask(parentTask));
}
else // else update parent task details
{
return(TaskDBChanges(parentTask.Task.FirstOrDefault(), parentTask.ParentTaskID));
}
}
catch (Exception ex)
{
return(BadRequest("Error occurred in CreateTask :" + ex.StackTrace));
}
}
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 IHttpActionResult ManageTask([FromBody] ParentTaskModel parentTask)
{
if (!ModelState.IsValid)
{
return(BadRequest("Not a valid data"));
}
try
{
if (parentTask.ParentTaskID == 0)
{
return(TaskDBChanges(parentTask.Task.FirstOrDefault(), 0));
}
else if (parentTask.ParentTaskID == -1)
{
CreateParentTask(parentTask);
return(TaskDBChanges(parentTask.Task.FirstOrDefault()));
}
else
{
return(TaskDBChanges(parentTask.Task.FirstOrDefault(), parentTask.ParentTaskID));
}
}
catch (Exception ex)
{
return(BadRequest("Error occurred in CreateTask :" + ex.StackTrace));
}
}
public void setupParenttask()
{
var parenttask = new List <ParentTask>()
{
new ParentTask()
{
Parent_ID = 1,
Parent_Task = "Task first testing"
},
new ParentTask()
{
Parent_ID = 4,
Parent_Task = "Task for cleanup and testing"
}
};
var queryable = parenttask.AsQueryable();
parent = new ParentTaskModel();
MockSetParenttask.As <IQueryable <ParentTask> >().Setup(m => m.Expression).Returns(queryable.Expression);
MockSetParenttask.As <IQueryable <ParentTask> >().Setup(m => m.ElementType).Returns(queryable.ElementType);
MockSetParenttask.As <IQueryable <ParentTask> >().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator);
MockSetParenttask.As <IQueryable <ParentTask> >().Setup(m => m.Provider).Returns(queryable.Provider);
MockSetParenttask.As <IEnumerable <ParentTask> >().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator());
MockSetParenttask.As <IQueryable <ParentTask> >().Setup(m => m.Provider).Returns(new AsyncQueryProvider <ParentTask>(queryable.Provider));
MockSetParenttask.As <IDbAsyncEnumerable <ParentTask> >().Setup(m => m.GetAsyncEnumerator()).Returns(new AsyncEnumerator <ParentTask>(queryable.GetEnumerator()));
MockContext.Setup(c => c.SaveChangesAsync()).Returns(() => Task.Run(() => { return(1); })).Verifiable();
MockSetParenttask.Setup(m => m.Add(It.IsAny <ParentTask>())).Callback((ParentTask parent) => parenttask.Add(parent));
MockSetParenttask.Setup(m => m.Remove(It.IsAny <ParentTask>())).Callback((ParentTask parent) => parenttask.Remove(parent));
MockContext.Setup(m => m.ParentTask).Returns(MockSetParenttask.Object);
}
public static ParentTaskModel Clone(this ParentTaskModel source)
{
//var formatter = new BinaryFormatter();
//var memStream = new System.IO.MemoryStream();
//formatter.Serialize(memStream, source);
//memStream.Position = 0;
//var reulst = formatter.Deserialize(memStream);
//memStream.Close();
//return (T)reulst;
////var serilizatoin=new System.Security.se
////return source;
var result = new ParentTaskModel();
result.ParentTaskId = source.ParentTaskId;
result.Parent_Task = source.Parent_Task;
if (result.Tasks != null)
{
foreach (var item in source.Tasks)
{
result.Tasks.Add(item.Clone());
}
}
return(result);
}
public void ManageTask()
{
// Act on Test
List <TaskModel> tasks = new List <TaskModel>();
TaskModel task = new TaskModel()
{
TaskName = "New Child Task",
Priority = 1,
StartDate = "10-08-2019",
EndDate = "10-10-2019",
IsCompleted = false,
};
tasks.Add(task);
ParentTaskModel parentTask = new ParentTaskModel()
{
ParentTaskID = -1,
ParentTaskName = "New Parent Task",
Task = tasks,
};
IHttpActionResult response = _controller.ManageTask(parentTask);
var contentResult = response as OkNegotiatedContentResult <JObject>;
// Assert the result
Assert.IsNotNull(contentResult);
}
public bool AddParentTask(ParentTaskModel parentTaskModel)
{
EntityMapper <ParentTaskModel, ParentTask> mapObj = new EntityMapper <ParentTaskModel, ParentTask>();
var parentTask = mapObj.Translate(parentTaskModel);
return(ProjectManagerRepository.InsertParentTask(parentTask));
}
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));
}
}
private ParentTaskModel convertPTasktoPTaskModel(ParentTask Ptask)
{
ParentTaskModel PTM = new ParentTaskModel();
PTM.ParentTaskID = Ptask.Parent_ID;
PTM.ParentTaskName = Ptask.Parent_Task;
return(PTM);
}
public void AddParentTaskForInValidDataTest()
{
var inValidData = new ParentTaskModel()
{
ParentTaskName = null
};
var isSuccess = _projectManagerService.AddParentTask(inValidData);
Assert.AreEqual(false, isSuccess);
}
public void AddParentTaskForValidDataTest()
{
var validData = new ParentTaskModel()
{
ParentTaskName = "Build Framework"
};
var isSuccess = _projectManagerService.AddParentTask(validData);
Assert.AreEqual(true, 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 ParentTaskModel AddParentTask(ParentTaskModel parentTask)
{
dbContext.ParentTasks.Add(parentTask);
if (dbContext.SaveChanges() >= 0)
{
return(parentTask);
}
else
{
return(null);
}
}
public HttpResponseMessage AddParentTask([FromBody] ParentTaskModel parentTaskModel)
{
try
{
Repository repository = new Repository();
return(Request.CreateResponse(HttpStatusCode.OK, repository.AddParentTask(parentTaskModel)));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.ExpectationFailed, ex.Message));
}
}
public void CreateParentTask()
{
// Act on Test
ParentTaskModel parentTask = new ParentTaskModel()
{
ParentTaskName = "New Task",
};
IHttpActionResult response = _controller.CreateParentTask(parentTask);
var contentResult = response as OkNegotiatedContentResult <JObject>;
// Assert the result
Assert.IsNotNull(contentResult);
}
public List <ParentTaskModel> GetParentTasks()
{
var parentTasks = _repository.GetParentTasks();
var result = new List <ParentTaskModel>();
foreach (var pt in parentTasks)
{
var ptask = new ParentTaskModel()
{
Parent_ID = pt.Parent_ID, Parent_Task = pt.TaskName
};
result.Add(ptask);
}
return(result);
}
public void AddParentTaskTest()
{
ParentTaskModel parenttask = new ParentTaskModel();
parenttask.ParentTaskName = "Parent Task1test";
TaskController controller = new TaskController();
controller.Request = new HttpRequestMessage();
controller.Configuration = new System.Web.Http.HttpConfiguration();
HttpResponseMessage searchResultResponse = new HttpResponseMessage();
searchResultResponse = controller.AddParentTask(parenttask);
Assert.AreEqual(System.Net.HttpStatusCode.OK, searchResultResponse.StatusCode);
}
//[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 bool AddParentTask(ParentTaskModel parentTaskModel)
{
try
{
ParentTask parentTask = new ParentTask();
parentTask.Parent_Task = parentTaskModel.ParentTaskName;
_entity.ParentTasks.Add(parentTask);
_entity.SaveChanges();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public IHttpActionResult Post([FromBody] TaskModel taskModel)
{
return(tryCatchWebMethod(() =>
{
var isSuccess = false;
if (taskModel.SetAsParent)
{
var parentTaskModel = new ParentTaskModel()
{
ParentTaskName = taskModel.TaskName
};
isSuccess = new ProjectManagerService().AddParentTask(parentTaskModel);
}
else
{
isSuccess = new ProjectManagerService().AddTask(taskModel);
}
return Json(isSuccess);
}));
}
public void AddParentTask(ParentTaskModel pt)
{
_application.AddParentTask(pt.Parent_Task);
}
