public async Task AddTaskTestPassed()
{
TaskModel newTask = new TaskModel
{
Name = "Dupa",
ShortDescription = "DupaDupa",
LongDescription = "DupaDupaDupa",
Priority = DAL.DAO.Enums.PriorityEnum.High,
CreatedAt = DateTime.Now,
IsDone = false,
Category = DAL.DAO.Enums.CategoryEnum.Work,
Comments = new List <Comment>()
};
int numberOfRecordsBeforeAdd = _appDbContext.Tasks.Count();
await Sut.AddTask(newTask);
int numberOfRecordsAfterAdd = _appDbContext.Tasks.Count();
var addedRecord = _appDbContext.Tasks.Last();
Assert.NotNull(newTask);
Assert.Equal(numberOfRecordsBeforeAdd + 1, numberOfRecordsAfterAdd);
Assert.Equal(newTask.Name, addedRecord.Name);
Assert.Equal(newTask.ShortDescription, addedRecord.ShortDescription);
Assert.Equal(newTask.LongDescription, addedRecord.LongDescription);
Assert.Equal(newTask.Priority, addedRecord.Priority);
Assert.Equal(newTask.IsDone, addedRecord.IsDone);
Assert.Equal(newTask.Category, addedRecord.Category);
}
public void TestAddTask()
{
try
{
var data = new List <ProjectManager.Persistence.Task>()
{
}.AsQueryable();
var mockSet = new Mock <DbSet <ProjectManager.Persistence.Task> >();
mockSet.As <IQueryable <ProjectManager.Persistence.Task> >().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As <IQueryable <ProjectManager.Persistence.Task> >().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As <IQueryable <ProjectManager.Persistence.Task> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As <IQueryable <ProjectManager.Persistence.Task> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
mockSet.As <IQueryable <ProjectManager.Persistence.Task> >().Setup(m => m.Provider).Returns(data.Provider);
Task Task = new Persistence.Task {
ProjectId = 25, TaskName = "Support Test Driven Development", IsParentTask = true, Priority = 2, ParentTask = 5, StartDate = new DateTime(2018, 8, 12), EndDate = DateTime.Now, UserId = 20
};
var mockContext = new Mock <ProjectManagerContext>();
mockContext.Setup(m => m.tasks).Returns(mockSet.Object);
var service = new TaskRepository(mockContext.Object);
List <Task> TaskList = service.GetAllTasks();
Assert.That(TaskList.Count == 0);
bool ret = service.AddTask(Task);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Assert.That(1 == 0);
}
}
public void AddTask_Successful()
{
Task taskEdit = new Task();
taskEdit.TaskId = 1;
taskEdit.TaskName = "ABCD";
taskEdit.StartDate = DateTime.Now;
taskEdit.Priority = 1;
var tasks = new List <Task>();
tasks.Add(taskEdit);
var t = tasks.AsQueryable();
//var mockSet = new Mock<DbSet<Task_Table>>();
var mockSet = new Mock <DbSet <Task> >();
mockSet.As <IQueryable <Task> >().Setup(m => m.Provider).Returns(t.Provider);
mockSet.As <IQueryable <Task> >().Setup(m => m.Expression).Returns(t.Expression);
mockSet.As <IQueryable <Task> >().Setup(m => m.ElementType).Returns(t.ElementType);
mockSet.As <IQueryable <Task> >().Setup(m => m.GetEnumerator()).Returns(t.GetEnumerator());
IQueryable <Task> childTasks = Enumerable.Empty <Task>().AsQueryable();
var mockTaskMangerContext = new Mock <TaskManagerContext>();
mockTaskMangerContext.Setup(c => c.Tasks).Returns(mockSet.Object);
mockTaskMangerContext.Setup(p => p.SaveChanges());
var objTestTaskrepo = new TaskRepository(mockTaskMangerContext.Object);
objTestTaskrepo.AddTask(taskEdit);
mockTaskMangerContext.Verify(mock => mock.SaveChanges(), Times.Once());
}
public bool AddTask(object taskModel)
{
TaskRepository obj = new TaskRepository();
obj.AddTask(ModelConverter(taskModel));
return(true);
}
public void AddTaskTest()
{
var tdata = new List <Task>()
{
new Task {
Task_ID = 1, Parent_ID = 1, Project_ID = 1, TaskName = "TestTask1", StartDate = DateTime.Now, EndDate = DateTime.Now.AddDays(1), Priority = 10, User_ID = 1, IsParentTask = false, ParentTaskName = "ParentTask1", UserName = "******", ProjectName = "TestProject1"
},
new Task {
Task_ID = 2, Parent_ID = 1, Project_ID = 1, TaskName = "TestTask2", StartDate = DateTime.Now, EndDate = DateTime.Now.AddDays(1), Priority = 10, User_ID = 1, IsParentTask = false, ParentTaskName = "ParentTask1", UserName = "******", ProjectName = "TestProject1"
}
}.AsQueryable();
var tmock = new Mock <DbSet <Task> >();
tmock.As <IQueryable <Task> >().Setup(x => x.Provider).Returns(tdata.Provider);
tmock.As <IQueryable <Task> >().Setup(x => x.Expression).Returns(tdata.Expression);
tmock.As <IQueryable <Task> >().Setup(x => x.ElementType).Returns(tdata.ElementType);
tmock.As <IQueryable <Task> >().Setup(x => x.GetEnumerator()).Returns(tdata.GetEnumerator());
var context = new Mock <ProjectManagerContext>();
context.Setup(x => x.tasks).Returns(tmock.Object);
var service = new TaskRepository(context.Object);
Task task = new Task {
Task_ID = 3, Parent_ID = 1, Project_ID = 1, TaskName = "TestTask3", StartDate = DateTime.Now, EndDate = DateTime.Now.AddDays(1), Priority = 10, User_ID = 1, IsParentTask = false, ParentTaskName = "ParentTask1", UserName = "******", ProjectName = "TestProject1"
};
string ret = service.AddTask(task);
Assert.That(ret == "Task added successfully.");
}
public void AddTask(string taskTitle)
{
TaskRepository taskRepo = new TaskRepository(Properties.Settings.Default.conStr);
taskRepo.AddTask(taskTitle);
SendTasks();
}
public void Create(TaskModel taskModel)
{
TaskRepository taskRepository = new TaskRepository();
taskRepository.AddTask(taskModel.MapTask());
taskRepository.Commit();
}
public JsonResult CreateTask(TaskEx task)
{
try
{
// Validation
if (!ModelState.IsValid)
{
return(Json(new { Result = "ERROR", Message = "Form is not valid! Please correct it and try again." }));
}
var taskRespo = new TaskRepository();
TaskEx addedTask = taskRespo.AddTask(task);
// Inform all connected clients
var clientName = Request["clientName"];
Task.Factory.StartNew(
() =>
{
// var clients = Hub.GetClients<TaskHub>();
_context.Clients.RecCreated(clientName, task);
});
// Return result to current (caller) client
return(Json(new { Result = "OK", Record = addedTask }));
}
catch (Exception ex)
{
return(Json(new { Result = "ERROR", Message = ex.Message }));
}
}
public bool AddTask(string taskName, string categoryName)
{
var newTask = new Tasks();
taskRepository.AddTask(newTask);
return(true);
}
public IHttpActionResult AddTask(JObject json)
{
var result = TaskRepository.AddTask(new Task());
string test = json.ToString();
return(Ok(test));
}
public ActionResult CreateProcess(string title)
{
//등록 처리: DB에 저장
repo.AddTask(new TaskModel {
Title = title
});
return(RedirectToAction("Index")); // 리스트로 이동
}
public void NewTask(string title)
{
var repo = new TaskRepository(connectionString);
var task = new UserTask {
Title = title, Completed = false
};
repo.AddTask(task);
RenderTasks();
}
public TaskUpdateResult UpdateTask(TaskModel oTask)
{
Status oStatus = new Status();
if (oTask.Parent_ID == null)
{
ParentTask oParent = new ParentTask()
{
Parent_Task = oTask.TaskName
};
oParent = parent.AddParentTask(oParent);
oTask.Parent_ID = oParent.Parent_ID;
}
if (oTask.Parent_ID != null && oTask.User_ID == null)
{
parent.UpdateParentTask(new ParentTask()
{
Parent_ID = oTask.Parent_ID.Value, Parent_Task = oTask.TaskName
});
}
DataAccessLayer.Task task = new DataAccessLayer.Task()
{
End_Date = oTask.End_Date,
Parent_ID = oTask.Parent_ID,
Priority = oTask.Priority,
Project_ID = oTask.Project_ID,
Start_Date = oTask.Start_Date,
Status = oTask.Status,
Task1 = oTask.TaskName,
User_ID = oTask.User_ID
};
if (oTask.Task_ID == 0)
{
task = repoTask.AddTask(task);
oStatus = new Status()
{
Message = "Task added successfully", Result = true
};
}
else
{
task.Task_ID = oTask.Task_ID;
task = repoTask.UpdateTask(task);
oStatus = new Status()
{
Message = "Task updated successfully", Result = true
};
}
return(new TaskUpdateResult()
{
status = oStatus,
task = null
});
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
Page.Validate();
if (!Page.IsValid)
{
return;
}
//Upload image
string path = Server.MapPath("Images/");
string picturePath = "";
if (fuPicture.HasFile)
{
string ext = Path.GetExtension(fuPicture.FileName);
if (ext == ".jpg" || ext == ".png")
{
fuPicture.SaveAs(path + fuPicture.FileName);
picturePath = "~/Images/" + fuPicture.FileName;
Response.Write("Your file has been uploaded");
}
else
{
Response.Write("Your can upload only .jpg and .png files");
return;
}
}
else
{
Response.Write("Please select an file");
return;
}
TaskRepository tr = new TaskRepository();
Guid newTaskId = tr.AddTask(txtFirstDate.Text, txtLastDate.Text, txtTitle.Text, txtDescription.Text, ddlPriority.SelectedValue,
ddlAssignee.SelectedValue, picturePath, ddlState.SelectedValue);
TagRepository tgr = new TagRepository();
for (int i = 0; i < cblTags.Items.Count; i++)
{
if (cblTags.Items[i].Selected)
{
Guid tagId = Guid.Empty, result;
if (Guid.TryParse(cblTags.Items[i].Value, out result))
{
tagId = result;
}
tgr.AddTaskTag(newTaskId, tagId);
}
}
}
public ActionResult AddTasks(CreateTaskRequest createRequest)
{
if (_validator.Validate(createRequest))
{
return(BadRequest(new { error = "please enter all fields" }));
}
var newTask = _repository.AddTask(createRequest.TaskName, createRequest.Comment, createRequest.StartDate, createRequest.StartTime, createRequest.EndTime, createRequest.NumberOfPeopleNeed, createRequest.NumberOfPeopleSignUp, createRequest.EventId);
return(Created($"api/task/{newTask.Id}", newTask));
}
public void SaveTask()
{
var task = new Task()
{
What = this.What,
Where = this.Where,
When = this.When
};
_repository.AddTask(task);
this.Tasks.Add(task);
}
public IActionResult AddTask(TasksViewModel tasksViewModel)
{
try
{
Domain.Socioboard.Models.Mongo.Tasks _task = TaskRepository.AddTask(tasksViewModel, _logger, _redisCache, _appSettings);
TaskRepository.AddTaskComment(_task.senderUserId, _task.strId, tasksViewModel.taskComment, _logger, _redisCache, _appSettings);
return(Ok("task added"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
//private ITaskRepository<object> taskRepo;
//public TaskManagerBal(ITaskRepository<object> repos)
//{
// this.taskRepo = repos;
//}
public bool AddTask(TaskManagerDetails taskDetails)
{
try
{
using (var repository = new TaskRepository())
{
return(repository.AddTask(taskDetails));
}
}
catch (Exception ex)
{
throw ex;
}
}
/* To insert or update the task */
public TaskUpdateModel InsertUpdateTask(TaskModel task_Model)
{
StatusModel _status = new StatusModel();
if (task_Model.Parent_ID == null)
{
ParentTasks oParent = new ParentTasks()
{
Parent_Task = task_Model.TaskName
};
oParent = parent.AddParentTask(oParent);
task_Model.Parent_ID = oParent.Parent_ID;
}
Task task = new Task()
{
End_Date = task_Model.End_Date,
Parent_ID = task_Model.Parent_ID,
Priority = task_Model.Priority,
Project_ID = task_Model.Project_ID,
Start_Date = task_Model.Start_Date,
Status = task_Model.Status,
Task1 = task_Model.TaskName,
User_ID = task_Model.User_ID
};
if (task_Model.Task_ID == 0)
{
task = repoTask.AddTask(task);
_status = new StatusModel()
{
Message = "Task details are added successfully", Result = true
};
}
else
{
task.Task_ID = task_Model.Task_ID;
task = repoTask.UpdateTask(task);
_status = new StatusModel()
{
Message = "Task details are updated successfully", Result = true
};
}
return(new TaskUpdateModel()
{
status = _status,
task = null
});
}
public ActionResult Create(DomainClasses.Task model)
{
try
{
int backlogId = Int32.Parse(Session["BacklogId"].ToString()),
userId = Int32.Parse(Session["UserId"].ToString());
var repo = new TaskRepository();
repo.AddTask(model, backlogId, userId);
return(RedirectToAction("Index", "Backlog"));
}
catch
{
return(View());
}
}
public void CanDeleteByValidId()
{
TaskEntity taskEntity = new TaskEntity
{
Id = "Guid1",
Completeness = false,
DateTime = DateTime.Now,
Description = "Description",
Name = "Name",
};
ITaskRepository taskRepository = new TaskRepository();
// Act
taskRepository.AddTask(taskEntity);
taskRepository.DeleteTaskById(taskEntity.Id);
// Assert
Assert.IsNotNull(taskEntity);
}
public IActionResult AddTask(TasksViewModel tasksViewModel)
{
try
{
Domain.Socioboard.Models.Mongo.Tasks _task = TaskRepository.AddTask(tasksViewModel, _logger, _redisCache, _appSettings);
string postmessage = "";
string[] updatedmessgae = Regex.Split(tasksViewModel.taskComment, "<br>");
foreach (var item in updatedmessgae)
{
if (!string.IsNullOrEmpty(item))
{
if (item.Contains("hhh"))
{
postmessage = postmessage + item.Replace("hhh", "#");
}
if (item.Contains("nnn"))
{
postmessage = postmessage.Replace("nnn", "&");
}
if (item.Contains("ppp"))
{
postmessage = postmessage.Replace("ppp", "+");
}
if (item.Contains("jjj"))
{
postmessage = postmessage.Replace("jjj", "-+");
}
else
{
postmessage = postmessage + "\n\r" + item;
}
}
}
tasksViewModel.taskComment = postmessage;
TaskRepository.AddTaskComment(_task.senderUserId, _task.strId, tasksViewModel.taskComment, _logger, _redisCache, _appSettings);
return(Ok("task added"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
/// <summary>
/// 添加作业
/// </summary>
/// <param name="taskOptions"></param>
/// <param name="schedulerFactory"></param>
/// <param name="init">是否初始化，false持久化，true不持久化</param>
/// <returns></returns>
public static async Task<object> AddJob(this TaskOptions taskOptions, ISchedulerFactory schedulerFactory, bool init = false)
{
try
{
(bool, string) validExpression = taskOptions.interval.IsValidExpression();
if (!validExpression.Item1)
return new { status = false, msg = validExpression.Item2 };
(bool, object) result = taskOptions.Exists(init);
if (!result.Item1)
return result.Item2;
if (!init)
{
TaskRepository.AddTask(taskOptions);
}
IJobDetail job = JobBuilder.Create<HttpResultful>()
.WithIdentity(taskOptions.name, taskOptions.group_name)
.Build();
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity(taskOptions.name, taskOptions.group_name)
.StartNow().WithDescription(taskOptions.describe)
.WithCronSchedule(taskOptions.interval)
.Build();
IScheduler scheduler = await schedulerFactory.GetScheduler();
await scheduler.ScheduleJob(job, trigger);
//如果任务处于正常状态
if (taskOptions.status == (int)TriggerState.Normal)
{
await scheduler.Start();
}
else
{
//暂定任务
await schedulerFactory.Pause(taskOptions);
}
}
catch (Exception ex)
{
return new { status = false, msg = ex.Message };
}
return new { status = true };
}
public void AddTask_Test()
{
Task tsk = new Task();
tsk.TaskName = "testTask";
tsk.StartDate = DateTime.Now;
tsk.EndDate = DateTime.Now.AddDays(1);
tsk.Priority = 10;
tsk.UserId = 1;
tsk.ProjectId = 1;
tsk.TaskId = 5;
var mocktaskRepository = new Mock <IProjectManagerRepository <Task> >(MockBehavior.Strict);
mocktaskRepository.Setup(p => p.Create(tsk));
mocktaskRepository.Setup(p => p.SaveChange());
var objtaskRepo = new TaskRepository(mocktaskRepository.Object);
objtaskRepo.AddTask(tsk);
mocktaskRepository.Verify(mock => mock.Create(tsk), Times.Once());
mocktaskRepository.Verify(mock => mock.SaveChange(), Times.Once());
}
public void CanAddValidTask_ReturnTask()
{
// Arrange
TaskEntity taskEntity = new TaskEntity
{
Id = "Guid1",
Completeness = false,
DateTime = DateTime.Now,
Description = "Description",
Name = "Name",
};
ITaskRepository taskRepository = new TaskRepository();
// Act
var result = taskRepository.AddTask(taskEntity);
// Assert
Assert.AreEqual(taskEntity, result);
taskRepository.DeleteTaskById(taskEntity.Id);
}
public void CanGetTasksByName()
{
// Arrange
TaskEntity taskEntity = new TaskEntity
{
Id = "Guid1",
Completeness = false,
DateTime = DateTime.Now,
Description = "Description",
Name = "Name",
};
ITaskRepository taskRepository = new TaskRepository();
taskRepository.AddTask(taskEntity);
// Act
var result = taskRepository.GetTasksByName(taskEntity.Name);
// Assert
Assert.AreEqual(taskEntity, result.FirstOrDefault(t => t.Name == taskEntity.Name));
taskRepository.DeleteTaskById(taskEntity.Id);
}
public void SortTasksByCategory_CanSortByCategoryTitle_ReturnTasks()
{
// Arrange
var category = new TaskCategoryEntity()
{
Id = "Guid 1",
DateTime = DateTime.Now,
Title = "Daily",
};
var taskEntity = new TaskEntity
{
Id = "Guid1",
Completeness = false,
DateTime = DateTime.Now,
Description = "Description",
Name = "Name",
Category = category,
};
ITaskRepository taskRepository = new TaskRepository();
ITaskCategoryRepository taskCategoryRepository = new TaskCategoryRepository();
taskRepository.AddTask(taskEntity);
// Act
var result = taskRepository.SortTasksByCategory(taskEntity.Category.Title);
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(taskEntity, result.FirstOrDefault(t => t.Name == taskEntity.Name));
taskRepository.DeleteTaskById(taskEntity.Id);
taskCategoryRepository.DeleteCategoryById(category.Id);
}
public void CanUpdateValidTask_ReturnTask()
{
// Arrange
var taskEntity = new TaskEntity
{
Id = Guid.NewGuid().ToString(),
Completeness = false,
DateTime = DateTime.Now,
Description = "Description",
Name = "Name",
};
var taskEntityUPDATE = new TaskEntity
{
Id = taskEntity.Id,
Completeness = true,
DateTime = DateTime.Now,
Description = "Description 2",
Name = "Name 2",
};
ITaskRepository taskRepository = new TaskRepository();
taskRepository.AddTask(taskEntity);
// Act
var result = taskRepository.UpdateTask(taskEntityUPDATE);
taskRepository.DeleteTaskById(taskEntityUPDATE.Id);
// Assert
Assert.AreEqual(taskEntity, result);
Assert.AreEqual(taskEntityUPDATE.Name, result.Name);
Assert.AreEqual(taskEntityUPDATE.Description, result.Description);
Assert.AreEqual(taskEntityUPDATE.DateTime, result.DateTime);
Assert.AreEqual(taskEntityUPDATE.Id, result.Id);
}
public void AddTask(UserTask task)
{
var repo = new TaskRepository(_connection);
repo.AddTask(task);
}
/// <summary>
/// Add or change task
/// </summary>
/// <param name="nomerTask">number of task</param>
/// <returns></returns>
private static void AddOrChange(int nomerTask)
{
try
{
string NameTask;
int TypeTask, ComplexityTask, Priority;
bool pr = false;
//Name
Console.ForegroundColor = (ConsoleColor)ConsoleColors.EnumConsoleColors.MenuItems;
System.Console.Write("\t Write Name Task: ");
NameTask = System.Console.ReadLine();
//Complexity
do
{
Console.ForegroundColor = (ConsoleColor)ConsoleColors.EnumConsoleColors.MenuItems;
Console.Write("\t Write Complexity Task(from 1 to 5): ");
pr = int.TryParse(Console.ReadLine(), out ComplexityTask);
if (!(ComplexityTask >= 1 && ComplexityTask <= 5))
{
Console.ForegroundColor = (ConsoleColor)ConsoleColors.EnumConsoleColors.Info;
Console.Write("\t Write Complexity only from 1 to 5\tInvalid input. Try again:\n");
Console.ResetColor();
pr = false;
}
} while (!pr);
//Priority
do
{
Console.ForegroundColor = (ConsoleColor)ConsoleColors.EnumConsoleColors.MenuItems;
Console.Write("\t Write Priority Task(from 1 to 5): ");
pr = int.TryParse(Console.ReadLine(), out Priority);
if (!(Priority >= 1 && Priority <= 5))
{
Console.ForegroundColor = (ConsoleColor)ConsoleColors.EnumConsoleColors.Info;
Console.Write("\t Write Priority only from 1 to 5\tInvalid input. Try again:\n");
Console.ResetColor();
pr = false;
}
} while (!pr);
//Type
do
{
Console.ForegroundColor = (ConsoleColor)ConsoleColors.EnumConsoleColors.MenuItems;
Console.Write("\t Write Type Task(Bag:1, Task:2, Technical debt: 3): ");
pr = int.TryParse(System.Console.ReadLine(), out TypeTask);
if (!(TypeTask >= 1 && TypeTask <= 3))
{
Console.ForegroundColor = (ConsoleColor)ConsoleColors.EnumConsoleColors.Info;
Console.Write("\t Write Type only 1 or 2 or 3\tInvalid input. Try again:\n");
Console.ResetColor();
pr = false;
}
} while (!pr);
if (nomerTask > 0)
{
nomerTask--;
string status = TaskRepository.Tasks[nomerTask].Status;
switch (TypeTask)
{
case 1:
TaskRepository.Tasks[nomerTask] = new Bug(NameTask, Priority, ComplexityTask, status);
break;
case 2:
TaskRepository.Tasks[nomerTask] = new Task(NameTask, Priority, ComplexityTask, status);
break;
case 3:
TaskRepository.Tasks[nomerTask] = new TechnicalDebt(NameTask, Priority, ComplexityTask, status);
break;
default:
break;
}
Console.ForegroundColor = (ConsoleColor)ConsoleColors.EnumConsoleColors.MenuNameColor;
Console.WriteLine("\tTask successfully changed");
}
else
{
//Add Task
switch (TypeTask)
{
case 1:
TaskRepository.AddTask(new Bug(NameTask, Priority, ComplexityTask, "BackLog"));
break;
case 2:
TaskRepository.AddTask(new Task(NameTask, Priority, ComplexityTask, "BackLog"));
break;
case 3:
TaskRepository.AddTask(new TechnicalDebt(NameTask, Priority, ComplexityTask, "BackLog"));
break;
default:
break;
}
Console.ForegroundColor = (ConsoleColor)ConsoleColors.EnumConsoleColors.Info;
Console.WriteLine("\tSuccessfully Task Add");
}
}
catch (Exception e)
{
Console.ForegroundColor = (ConsoleColor)ConsoleColors.EnumConsoleColors.ErrorOrOther;
Console.WriteLine("\tError. Something went wrong!)", e.Message);
LogMsg.WriteLog(e.Message);
}
}
