public void SaveNewTask(TaskModel taskModel, TaskListModel listModel)
{
_dataContext.Tasks.Add(taskModel);
_dataContext.TaskLists.Add(listModel);
_dataContext.SaveChanges();
}
public void Create_Task_Model_isInvalid()
{
#region Arrange
TaskListModel mockTaskList = new TaskListModel
{
ID = 1,
TaskCompleted = false,
TaskDescription = null
};
this.mockContext.SetupGet(x => x.Request).Returns(this.mockRequest.Object);
this.mockContext.SetupGet(x => x.Response).Returns(this.mockResponse.Object);
mockContext.Setup(x => x.Session["InMemoryTaskList"]).Returns(null);
var mockControllerContext = new RequestContext(this.mockContext.Object, new RouteData());
TaskListController controller = new TaskListController();
controller.tasklist = mockTasklist.Object;
controller.ControllerContext = new ControllerContext(mockControllerContext, controller);
controller.ViewData.ModelState.AddModelError("TaskDescription", "Please specify a task description before submitting again");
#endregion
#region Act
var result = (ViewResult)controller.Create(mockTaskList);
var viewModel = controller.ViewData.Model as TaskListModel;
#endregion
#region Assert
Assert.IsFalse(result.ViewData.ModelState.IsValid);
Assert.IsNull(controller.HttpContext.Session["InMemoryTaskList"]);
#endregion
}
public void Index_with_1_Task_in_List()
{
#region Arrange
List <TaskDetailsModel> mockTaskList = new List <TaskDetailsModel>();
TaskDetailsModel mockTaskDetails = new TaskDetailsModel
{
ID = 1,
TaskCompleted = false,
TaskDescription = HttpUtility.HtmlEncode("Mocked Task")
};
TaskListModel mockTaskListModel = new TaskListModel();
mockTaskList.Add(mockTaskDetails);
this.mockContext.SetupGet(x => x.Request).Returns(this.mockRequest.Object);
this.mockContext.SetupGet(x => x.Response).Returns(this.mockResponse.Object);
mockContext.Setup(x => x.Session["InMemoryTaskList"]).Returns(mockTaskListModel);
var mockControllerContext = new RequestContext(this.mockContext.Object, new RouteData());
TaskListController controller = new TaskListController();
controller.tasklist = mockTasklist.Object;
controller.ControllerContext = new ControllerContext(mockControllerContext, controller);
this.mockTasklist.Setup(c => c.GetAllTasks()).Returns(mockTaskList);
#endregion
#region Act
var result = (ActionResult)controller.Index();
var viewModel = controller.ViewData.Model as TaskListModel;
#endregion
#region Assert
this.mockTasklist.Verify(c => c.GetAllTasks(), Times.Once());
Assert.IsNotNull(controller.HttpContext.Session["InMemoryTaskList"]);
Assert.AreEqual(1, mockTaskList.Count);
#endregion
}
public async Task <ApiResult> UpdateAsync(SubmitDTO <ScheduleTaskDTO> model)
{
var dto = model.Data;
if (dto.Version != this.State.Version)
{
return(ApiResultUtil.IsFailed("数据已被修改，请重新再加载！"));
}
bool bRet = await _scheduleRepository.SetAsync(() => new { task_name = dto.TaskName, line_code = dto.LineCode, version = (dto.Version + 1) }, oo => oo.Id == this.GrainId);
if (!bRet)
{
return(ApiResultUtil.IsFailed("数据更新失败！"));
}
ScheduleTaskState scheduleTaskState = this.State;
scheduleTaskState.TaskName = dto.TaskName;
scheduleTaskState.LineCode = dto.LineCode;
scheduleTaskState.Version++;
///任务完成 进行系统对接
if (dto.TaskState == TaskState.Complete)
{
TaskListModel scheduleTaskModel = new TaskListModel()
{
TaskCode = dto.TaskCode
};
await Observer.PublishAsync(EventContract.ComConcrete.TaskListToZK, scheduleTaskModel);
}
await this.Persist(ProcessAction.Update, scheduleTaskState);
return(ApiResultUtil.IsSuccess());
}
public dynamic RetrieveTasks()
{
var tasks = _tasksDao.FindAll();
var taskList = new TaskListModel(tasks, _hostName);
return(taskList);
}
public ActionResult TaskChanged(string taskListEncoded, string taskID, string completed)
{
TaskListModel taskListmodel = JsonConvert.DeserializeObject <TaskListModel>(taskListEncoded);
//Loop through all the existing tasks
foreach (var task in taskListmodel.TaskList)
{
//Check if the next task is the task selected
if (task.TaskID.ToString() == taskID)
{
if (completed != null)
{
if (completed.Equals("false"))
{
task.Completed = true;
}
else if (completed.Equals("true"))
{
task.Completed = false;
}
break;
}
else
{
task.Completed = false;
}
}
}
return(View("Index", taskListmodel));
}
public void SetUpFixture()
{
List <DomainModel.Task> tasks = new List <DomainModel.Task>()
{
new DomainModel.Task {
TaskName = "test"
},
new DomainModel.Task {
TaskName = "test2"
}
};
taskService = new Mock <ITaskRemoteService>();
taskService.Setup(x => x.ReadAllTasksByCategoryAsync(It.IsAny <DomainModel.Category>())).Returns(
System.Threading.Tasks.Task.FromResult(tasks));
taskFilter = new TaskFilter();
Mock <ApplicationGlobalModel> applicationGlobalModel = new Mock <ApplicationGlobalModel>();
var eventAgregator = new Mock <IEventAggregator>();
var taskDeltedEvent = new Mock <TaskDeletedEvent>();
eventAgregator.Setup(x => x.GetEvent <TaskDeletedEvent>()).Returns(taskDeltedEvent.Object);
model = new TaskListModel(taskService.Object, taskFilter, applicationGlobalModel.Object, eventAgregator.Object,
new Mock <IMapper>().Object);
}
public dynamic RetrieveTasks()
{
var db = Database.Opener.OpenFile(DatabasePath);
var tasks = db.Tasks.All().ToList <Task>();
var taskList = new TaskListModel(tasks, hostName);
return(taskList);
}
public ActionResult Index()
{
var model = new TaskListModel();
model.TaskList = new List <TaskModel>();
return(View(model));
}
//GET: /Task/TaskList
public ActionResult TaskList()
{
ICollection <ITask> tasks = _taskRepository.GetAllEnities();
TaskListModel taskListModel = new TaskListModel(tasks);
taskListModel.PersonCount = _personRepository.Count();
return(View(taskListModel));
}
public OperationResult Get()
{
TaskListModel responseResource = taskListRetriever.RetrieveTasks();
return(new OperationResult.OK {
ResponseResource = responseResource
});
}
public ActionResult Index()
{
TaskListModel modelTaskList = new TaskListModel();
modelTaskList.Tasks = tasklist.GetAllTasks();
return(View(modelTaskList));
}
public IActionResult Edit(TaskListModel task)
{
task.UpdatedDate = DateTime.Now;
task.TaskUserId = Convert.ToInt32(HttpContext.Session.GetString("UserLog"));
_context.TaskList.Update(task);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Index()
{
var model = new TaskListModel
{
Tasks = GetTaskListItems()
};
return(View(model));
}
public ActionResult DelTask(int id)
{
using (TaskListModel ORM = new TaskListModel())
{
Task toDel = ORM.Tasks.Single(t => t.ID == id);
ORM.Tasks.Attach(toDel);
ORM.Tasks.Remove(toDel);
ORM.SaveChanges();
return(RedirectToAction("Index", new { msg = "Task removed." }));
}
}
public bool CanRegister(string user)
{
using (TaskListModel ORM = new TaskListModel())
{
if (ORM.Users.Any(u => u.Name == user))
{
return(false);
}
return(true);
}
}
public ActionResult Index()
{
TaskListModel model = new TaskListModel();
model.Tasks = _taskService.GetAll();
model.Projects = _projectService.GetAll();
model.TasStatuses = _taskStatusService.GetAll();
model.Users = _userService.GetAll();
return(View(model));
}
public ActionResult Delete(int index, int id)
{
var model = new TaskListModel();
model.GridIndex = index;
try {
TaskManagerService.DeleteTask(id);
} catch (Exception e1) {
model.Error.Icon = ErrorIcon.Error;
model.Error.Message = "Error: " + e1.Message;
}
return(Json(model, JsonRequestBehavior.AllowGet));
}
public ActionResult ToggleComplete(int id)
{
using (TaskListModel ORM = new TaskListModel())
{
Task toToggle = ORM.Tasks.Single(t => t.ID == id);
ORM.Tasks.Attach(toToggle);
toToggle.Complete = !toToggle.Complete;
ORM.SaveChanges();
return(RedirectToAction("Index", new { msg = "Completion toggled." }));
}
}
public TaskListView(TaskListModel model)
{
InitializeComponent();
this.DataContext = model;
RegionContext.GetObservableContext(this).PropertyChanged += (s, e) =>
{
if (RegionContext.GetObservableContext(this).Value != null)
{
model.Category = RegionContext.GetObservableContext(this).Value as Category;
}
};
}
public ActionResult Search(TaskSearchModel searchModel)
{
TaskListModel model = new TaskListModel();
model.Tasks = _taskService.Search(new TaskSearchDto
{
ProjectId = searchModel.ProjectId,
TaskStatusId = searchModel.TaskStatusId,
UserId = searchModel.UserId
});
return(PartialView("_List", model));
}
public IActionResult Add(TaskListModel task)
{
var newID = _context.TaskList.Select(x => x.ID).Max() + 1;
task.ID = newID;
task.UpdatedDate = DateTime.Now;
task.TaskUserId = Convert.ToInt32(HttpContext.Session.GetString("UserLog"));
_context.TaskList.Add(task);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public TaskListModel FindTaskListModel(CompanyModel company,
UserModel user,
int index,
int pageNo,
int pageSize,
int period,
int businessUnitId,
int userId,
int taskTypeId,
int customerId,
string search,
int tz,
bool bIncludeDeleted = false)
{
var model = new TaskListModel();
var start = DateTimeOffset.Now.StartOfDay(tz);
var end = start.EndOfDay(tz);
if (period < 0)
{
start = start.AddDays(period);
}
else if (period > 0)
{
end = end.AddDays(period);
}
model.GridIndex = index;
var allItems = db.FindTasks()
.Where(t => t.CompanyId == company.Id &&
((t.CreatedDate >= start || t.DueDate >= start) &&
(t.CreatedDate <= end || t.DueDate <= end)) &&
(businessUnitId == 0 || t.BusinessUnitId == businessUnitId) &&
(userId == 0 || t.UserId == user.Id) &&
(taskTypeId == 0 || t.TaskTypeId == taskTypeId) &&
(bIncludeDeleted == true || t.Enabled == true) &&
(customerId == 0 || t.CustomerId == customerId) &&
((string.IsNullOrEmpty(search) || (!string.IsNullOrEmpty(search) && (t.Description != null && t.Description.Contains(search) ||
t.Customer != null && t.Customer.Name.Contains(search))))));
model.TotalRecords = allItems.Count();
foreach (var item in allItems.Skip((pageNo - 1) * pageSize)
.Take(pageSize))
{
var newItem = mapToModel(item);
model.Items.Add(newItem);
}
return(model);
}
public void Create_2nd_Task_Success()
{
#region Arrange
List <TaskDetailsModel> mockTaskList = new List <TaskDetailsModel>();
TaskDetailsModel mock1stTaskDetails = new TaskDetailsModel
{
ID = 1,
TaskCompleted = false,
TaskDescription = HttpUtility.HtmlEncode("Mocked Task")
};
TaskDetailsModel mock2ndTaskDetails = new TaskDetailsModel
{
ID = 2,
TaskCompleted = false,
TaskDescription = HttpUtility.HtmlEncode("2nd Mocked Task")
};
TaskListModel mockTaskListModel = new TaskListModel();
mockTaskList.Add(mock1stTaskDetails);
mockTaskListModel.ID = mock2ndTaskDetails.ID;
mockTaskListModel.TaskCompleted = mock2ndTaskDetails.TaskCompleted;
mockTaskListModel.TaskDescription = mock2ndTaskDetails.TaskDescription;
mockTaskListModel.Tasks = mockTaskList;
this.mockContext.SetupGet(x => x.Request).Returns(this.mockRequest.Object);
this.mockContext.SetupGet(x => x.Response).Returns(this.mockResponse.Object);
mockContext.Setup(x => x.Session["InMemoryTaskList"]).Returns(mockTaskListModel);
var mockControllerContext = new RequestContext(this.mockContext.Object, new RouteData());
TaskListController controller = new TaskListController();
controller.tasklist = mockTasklist.Object;
controller.ControllerContext = new ControllerContext(mockControllerContext, controller);
this.mockTasklist.Setup(c => c.GetAllTasks()).Returns(mockTaskList);
this.mockTasklist.Setup(c => c.GenerateNextIdNumber()).Returns(2);
this.mockTasklist.Setup(c => c.Inserttask(mock2ndTaskDetails.ID, mock2ndTaskDetails.TaskDescription, mock2ndTaskDetails.TaskCompleted));
#endregion
#region Act
var result = (RedirectToRouteResult)controller.Create(mockTaskListModel);
var viewModel = controller.ViewData.Model as TaskListModel;
#endregion
#region Assert
this.mockTasklist.Verify(c => c.GetAllTasks(), Times.Once());
this.mockTasklist.Verify(c => c.GenerateNextIdNumber(), Times.Once());
this.mockTasklist.Verify(c => c.Inserttask(mock2ndTaskDetails.ID, mock2ndTaskDetails.TaskDescription, mock2ndTaskDetails.TaskCompleted), Times.Once());
Assert.AreEqual(2, mock2ndTaskDetails.ID);
Assert.IsNotNull(controller.HttpContext.Session["InMemoryTaskList"]);
#endregion
}
public void EditTask(TaskModel taskModel, TaskListModel listModel)
{
var taskDB = _dataContext.Tasks.Find(taskModel.Id);
var listDB = _dataContext.TaskLists.Where(x => x.TaskId == taskModel.Id).FirstOrDefault();
taskDB.Ticket = taskModel.Ticket;
taskDB.ProjectId = taskModel.ProjectId;
taskDB.Description = taskModel.Description;
listDB.StartDate = listModel.StartDate;
listDB.CancelDate = listModel.CancelDate;
_dataContext.SaveChanges();
}
public ActionResult Login(string user, string password)
{
using (TaskListModel ORM = new TaskListModel())
{
string error;//message gotten from TryLogin
if (TryLogin(user, password, out error))
{
User logging = ORM.Users.Single(u => u.Name == user);
Session["Logged"] = logging;
return(RedirectToAction("Index"));
}
return(RedirectToAction("LoginRegister", new { msg = error }));
}
}
public ActionResult AddTask(string taskListEncoded, string taskDescription)
{
TaskListModel taskListmodel = JsonConvert.DeserializeObject <TaskListModel>(taskListEncoded);
//Initialise the new task
TaskModel taskModel = new TaskModel();
//Creating a random object
Random random = new Random();
//Add values to the new task class
//Check if the task list has tasks
if (taskListmodel.TaskList.Count != 0)
{
bool uniqueID = false;
int randomID = 0;
//Check if the random ID created is unique
while (uniqueID == false)
{
randomID = random.Next(1000);
int index = taskListmodel.TaskList.FindIndex(task => task.TaskID == randomID);
if (index >= 0)
{
uniqueID = false;
}
else
{
uniqueID = true;
}
}
taskModel.TaskID = randomID;
}
else
{
int randomID = random.Next(1000);
taskModel.TaskID = randomID;
}
taskModel.Description = taskDescription;
taskModel.Completed = false;
//Add new task class to the task list
taskListmodel.TaskList.Add(taskModel);
return(View("Index", taskListmodel));
}
public TaskListModel PrepareTaskListModel(TaskSearchModel searchModel)
{
var items = _workTaskService.getTasksByConTractId(searchModel.ContractId, searchModel.ParentId).Select(c =>
{
var m = PrepareTaskModelList(c);
m.taskStatusText = _localizationService.GetLocalizedEnum(c.taskStatus);
return(m);
}).ToList();
var model = new TaskListModel
{
Data = items,
Total = items.Count
};
return(model);
}
public void SaveNewTask(FormModel model)
{
var task = new TaskModel {
Ticket = model.TaskName,
Description = model.Description,
ProjectId = int.Parse(model.ProjectId)
};
var list = new TaskListModel
{
Task = task,
StartDate = DateTime.Parse(model.StartTime),
CancelDate = DateTime.Parse(model.EndTime),
CreateDate = DateTime.Now
};
_taskRepository.SaveNewTask(task, list);
}
/// <summary>
/// 分布式事务
/// </summary>
/// <returns></returns>
public async Task <ApiResult> CapWithTransaction()
{
var bRet = await _scheduleRepository.BeginTransactionAsync(async transaction =>
{
bool result = await _scheduleRepository.SetAsync(() => new { task_name = "cesces" }, oo => oo.Id == this.GrainId);
TaskListModel scheduleTaskModel = new TaskListModel()
{
TaskCode = "sssss"
};
await this.PublishAsync(scheduleTaskModel);
transaction.Commit();
return(result);
});
return(ApiResultUtil.IsSuccess());
}
