private void AddScanRunningTaskJob()
{
Core.Entities.Task scanRunningTask = DbContext.Task.FirstOrDefault(t => t.Name == ScanRunningTaskJobName);
if (scanRunningTask == null)
{
scanRunningTask = new Core.Entities.Task
{
ApplicationName = "DotnetSpider.Hub",
Cron = $"0/15 * * * *",
IsEnabled = true,
IsDeleted = true,
Developers = "DotnetSpider",
Owners = "DotnetSpider",
Arguments = "",
NodeCount = 1,
NodeRunningCount = 0,
Name = ScanRunningTaskJobName,
Package = "0001",
NodeType = "HUB"
};
DbContext.Task.Add(scanRunningTask);
DbContext.SaveChanges();
}
var taskId = scanRunningTask.Id.ToString();
var job = new SchedulerJobDto
{
Id = taskId,
Name = scanRunningTask.Name,
Cron = "0/15 * * * *",
Url = string.Format(Configuration.SchedulerCallback, taskId),
Data = JsonConvert.SerializeObject(new { TaskId = taskId })
};
_schedulerAppService.Create(job);
}
private void InitTestData()
{
var random = new Random();
for (int i = 0; i < 100; ++i)
{
Core.Entities.Task task = new Core.Entities.Task
{
ApplicationName = "dotnet",
Cron = $"* * * {i} *",
IsEnabled = true,
Developers = "沈威",
Owners = "刘菲",
Arguments = "-a:1,2",
NodeCount = 1,
NodeRunningCount = 0,
Analysts = "刘菲",
Name = $"360指数采集",
Version = "abcd",
NodeType = 1
};
_context.Task.Add(task);
}
_context.SaveChanges();
}
public async Task GetTasksByAttendant_GivenAnUnexistentAttendantId_ShouldReturnNoTasks()
{
var taskId = Guid.NewGuid();
var attendantId = Guid.NewGuid();
var taskEntity = new Core.Entities.Task
{
TaskId = taskId,
StatusId = 1,
PriorityId = 1,
Title = "Test Task",
Description = "Task Test",
AttendantId = attendantId,
AuthorId = Guid.NewGuid(),
CreatedDate = DateTime.Now
};
List <Core.Entities.Task> tasks = new List <Core.Entities.Task>()
{
taskEntity
};
taskRepositoryMock.Setup(s => s.GetTasksByAttendant(It.IsAny <Guid>()))
.Returns(Task.FromResult(new List <Core.Entities.Task>()));
var taskService = new TaskService(taskRepositoryMock.Object, mapper, converter);
var response = await taskService.GetTasksByAttendant(It.IsAny <Guid>());
Assert.NotNull(response);
Assert.True(response.Count == 0);
}
private void AddUpgradSchedulerJob()
{
Core.Entities.Task upgradeScheduler = DbContext.Task.FirstOrDefault(t => t.Name.StartsWith(UpgradeTaskSchedulerTaskName));
if (upgradeScheduler == null)
{
upgradeScheduler = new Core.Entities.Task
{
ApplicationName = "DotnetSpider.Hub",
Cron = $"* * * * 2999",
IsEnabled = true,
IsDeleted = true,
Developers = "DotnetSpider.Hub",
Owners = "DotnetSpider.Hub",
Arguments = "",
NodeCount = 1,
NodeRunningCount = 0,
Name = UpgradeTaskSchedulerTaskName,
Version = "0001",
NodeType = 1
};
DbContext.Task.Add(upgradeScheduler);
DbContext.SaveChanges();
}
var taskId = upgradeScheduler.Id.ToString();
var job = new SchedulerJobDto
{
Id = taskId,
Name = upgradeScheduler.Name,
Cron = "* * * * 2999",
Url = string.Format(Configuration.SchedulerCallback, taskId),
Data = JsonConvert.SerializeObject(new { TaskId = taskId })
};
_schedulerAppService.Create(job);
}
public void LoadData(IUnitOfWork uow, int taskId, int projectId)
{
Tasks = uow.Tasks.GetById(taskId);
List <EmployeeProject> employees = uow.EmployeeProjects.GetAllByProjectId(projectId);
Employees = new SelectList(employees, nameof(EmployeeProject.EmployeeId), nameof(Employee));
this.Project = uow.Projects.GetById(projectId);
this.ProjectId = projectId;
}
public async Task <int> Update(Core.Entities.Task entity)
{
entity.DateModified = DateTime.Now;
var sql = "UPDATE Tasks SET Name = @Name, Description = @Description, Status = @Status, DueDate = @DueDate, DateModified = @DateModified WHERE Id = @Id;";
using (var connection = new SqlConnection(_configuration.GetConnectionString("DefaultConnection")))
{
connection.Open();
var affectedRows = await connection.ExecuteAsync(sql, entity);
return(affectedRows);
}
}
public async Task <int> Add(Core.Entities.Task entity)
{
entity.DateCreated = DateTime.Now;
var sql = "INSERT INTO Tasks (Name, Description, Status, DueDate, DateCreated) Values (@Name, @Description, @Status, @DueDate, @DateCreated);";
using (var connection = new SqlConnection(_configuration.GetConnectionString("DefaultConnection")))
{
connection.Open();
var affectedRows = await connection.ExecuteAsync(sql, entity);
return(affectedRows);
}
}
public async Task <int> Update(Core.Entities.Task entity)
{
entity.ModifiedDate = DateTime.Now;
//Order should be same as columns
var sql = "Update Task Set TaskName = @TaskName, TaskDescription = @TaskDescription, TaskStatus = @TaskStatus, ModifiedDate = @ModifiedDate Where TaskId=@TaskId";
using (var connection = new SqlConnection(Configuration.GetConnectionString("DefaultConnection")))
{
connection.Open();
var affectedrows = await connection.ExecuteAsync(sql, entity);
return(affectedrows);
}
}
public async Task <int> Add(Core.Entities.Task entity)
{
entity.CreatedDate = DateTime.Now;
//Order should be same as columns
var sql = "Insert into Task(TaskName,TaskDescription,TaskStatus,CreatedDate,ModifiedDate) values (@TaskName,@TaskDescription,@TaskStatus,@CreatedDate,@ModifiedDate)";
using (var connection = new SqlConnection(Configuration.GetConnectionString("DefaultConnection")))
{
connection.Open();
var affectedrows = await connection.ExecuteAsync(sql, entity);
return(affectedrows);
}
}
public async Task EditTask_GivenAnExistentTaskToEdit_ShouldEditTask()
{
var taskId = Guid.NewGuid();
var personId = Guid.NewGuid();
var taskEntity = new Core.Entities.Task
{
TaskId = taskId,
StatusId = 1,
PriorityId = 1,
Title = "Test Task",
Description = "Task Test",
AttendantId = personId,
AuthorId = personId,
CreatedDate = DateTime.Now
};
var editedTask = new EditTaskDto
{
TaskId = taskId,
AttendantId = personId,
AuthorId = personId,
StatusId = 1,
PriorityId = 1,
Title = "Test Task edit",
Description = "Task Test edit"
};
taskRepositoryMock.Setup(s => s.GetSingleByCondition(It.IsAny <Expression <Func <Core.Entities.Task, bool> > >()))
.Returns(Task.FromResult(taskEntity));
taskRepositoryMock.Setup(s => s.Update(It.IsAny <Core.Entities.Task>()))
.Returns(Task.CompletedTask);
taskRepositoryMock.Setup(s => s.SaveChanges())
.Returns(Task.FromResult(true));
var taskService = new TaskService(taskRepositoryMock.Object, mapper, converter);
var response = await taskService.EditTask(editedTask);
taskRepositoryMock.Verify(v => v.SaveChanges(), Times.AtLeastOnce);
Assert.IsTrue(response);
}
private string PushTask(Core.Entities.Task task)
{
var nodes = _nodeAppService.GetAvailable(task.Os, task.NodeType, task.NodeCount);
if (nodes.Count == 0)
{
// TODO LOG
return(null);
}
var identity = Guid.NewGuid().ToString("N");
var messages = new List <CreateMessageInput>();
foreach (var node in nodes)
{
var arguments = string.Concat(task.Arguments, task.IsSingle ? " --tid:" : " ", task.Id, task.IsSingle ? " -i:" : " ", identity);
var msg = new CreateMessageInput
{
TaskId = task.Id,
ApplicationName = task.ApplicationName,
Name = Core.Entities.Message.RunMessageName,
NodeId = node.NodeId,
Package = task.Package,
Arguments = arguments
};
messages.Add(msg);
}
_messageAppService.Create(messages);
var taskHistory = new AddTaskHistoryInput
{
Identity = identity,
NodeIds = string.Join("|", nodes.Select(a => a.NodeId)),
TaskId = task.Id
};
_taskHistoryAppService.Add(taskHistory);
return(identity);
}
private void ExitTask(Core.Entities.Task task)
{
var runningNodes = _nodeAppService.GetAllOnline();
var messages = new List <CreateMessageInput>();
foreach (var status in runningNodes)
{
var msg = new CreateMessageInput
{
ApplicationName = "NULL",
TaskId = task.Id,
Name = Core.Entities.Message.CanleMessageName,
NodeId = status.NodeId
};
Logger.Warning($"Add CANCLE message: {JsonConvert.SerializeObject(msg)}.");
messages.Add(msg);
}
_messageAppService.Create(messages);
task.IsRunning = false;
task.NodeRunningCount = 0;
}
public async Task GetTaskById_GivenAnExistingTaskId_ShouldReturnTask()
{
var taskId = Guid.NewGuid();
var taskEntity = new Core.Entities.Task
{
TaskId = taskId,
StatusId = 1,
PriorityId = 1,
Title = "Test Task",
Description = "Task Test",
AttendantId = Guid.NewGuid(),
AuthorId = Guid.NewGuid(),
CreatedDate = DateTime.Now
};
taskRepositoryMock.Setup(s => s.GetSingleByCondition(It.IsAny <Expression <Func <Core.Entities.Task, bool> > >()))
.Returns(Task.FromResult(taskEntity));
var taskService = new TaskService(taskRepositoryMock.Object, mapper, converter);
var response = await taskService.GetTaskByTaskId(It.IsAny <Guid>());
Assert.NotNull(response);
Assert.AreEqual(taskId, response.TaskId);
}
public async Task <IActionResult> Put(int TaskId, Core.Entities.Task Model)
{
return(Ok(await Repo.Update(Model)));
}
public async Task <IActionResult> Post(Core.Entities.Task Model)
{
return(Ok(await Repo.Add(Model)));
}
public void LoadData(IUnitOfWork uow, int taskId)
{
EmployeeTask = uow.EmployeeTasks.GetEmployeeTaskByTaskId(taskId);
Task = uow.Tasks.GetById(taskId);
}
