public async Task NotifyTriangleTasks_HasTasksToNotify_Notify()
{
IEmailService emailService = A.Fake <IEmailService>();
IWorkTaskService workTaskService = A.Fake <IWorkTaskService>();
TaskTriangleBuilder taskTriangleBuilder = new TaskTriangleBuilder();
TaskTriangle taskTriangle = taskTriangleBuilder.AddContent("content1")
.AddResource("resource1")
.AddPercentageProgressToNotify(60)
.SetTime("20/09/2020", DayPeriod.Noon, 4, halfWorkDay: true)
.Build();
IWorkTask workTask = A.Fake <IWorkTask>();
A.CallTo(() => workTask.TaskMeasurement).Returns(taskTriangle);
List <IWorkTask> workTasks = new List <IWorkTask>()
{
workTask
};
A.CallTo(() => workTaskService.FindWorkTasksByConditionAsync(A <Func <IWorkTask, bool> > .Ignored))
.Returns(workTasks);
NotifierService notifierService = new NotifierService(
emailService, workTaskService, NullLogger <NotifierService> .Instance);
await notifierService.NotifyTriangleTasks().ConfigureAwait(false);
A.CallTo(() => emailService.SendEmail(A <string> .Ignored)).MustHaveHappenedOnceExactly();
}
public async Task SaveTaskAsync_ValidWorkTaskToAdd_SuccessResponseReturnedAndSavePerformed()
{
IWorkTask validWorkTask = A.Fake <IWorkTask>();
validWorkTask.GroupName = "groupName";
validWorkTask.Description = "validDescription";
ITasksGroup tasksGroup = mTasksGroupFactory.CreateGroup("bla");
tasksGroup.SetGroupName(validWorkTask.GroupName);
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
A.CallTo(() => dbRepository.ListAsync()).Returns(new List <ITasksGroup>()
{
tasksGroup
});
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
IResponse <IWorkTask> response =
await tasksGroupService.SaveTaskAsync(validWorkTask.GroupName, validWorkTask.Description)
.ConfigureAwait(false);
Assert.True(response.IsSuccess);
Assert.Equal(tasksGroup.GetAllTasks().First(), response.ResponseObject);
A.CallTo(() => dbRepository.UpdateAsync(A <ITasksGroup> .Ignored)).MustHaveHappenedOnceExactly();
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.Status == null))
{
IStatus statusCasted = item.As <IStatus>();
if ((statusCasted != null))
{
this._parent.Status = statusCasted;
return;
}
}
if ((this._parent.WorkCostDetail == null))
{
IWorkCostDetail workCostDetailCasted = item.As <IWorkCostDetail>();
if ((workCostDetailCasted != null))
{
this._parent.WorkCostDetail = workCostDetailCasted;
return;
}
}
if ((this._parent.WorkTask == null))
{
IWorkTask workTaskCasted = item.As <IWorkTask>();
if ((workTaskCasted != null))
{
this._parent.WorkTask = workTaskCasted;
return;
}
}
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.WorkTask == null))
{
IWorkTask workTaskCasted = item.As <IWorkTask>();
if ((workTaskCasted != null))
{
this._parent.WorkTask = workTaskCasted;
return;
}
}
ISwitchingStep scheduleStepsCasted = item.As <ISwitchingStep>();
if ((scheduleStepsCasted != null))
{
this._parent.ScheduleSteps.Add(scheduleStepsCasted);
}
if ((this._parent.Interval == null))
{
IDateTimeInterval intervalCasted = item.As <IDateTimeInterval>();
if ((intervalCasted != null))
{
this._parent.Interval = intervalCasted;
return;
}
}
ICrew crewsCasted = item.As <ICrew>();
if ((crewsCasted != null))
{
this._parent.Crews.Add(crewsCasted);
}
}
/// <summary>
/// Removes the given item from the collection
/// </summary>
/// <returns>True, if the item was removed, otherwise False</returns>
/// <param name="item">The item that should be removed</param>
public override bool Remove(IModelElement item)
{
IWorkTask workTaskItem = item.As <IWorkTask>();
if (((workTaskItem != null) &&
this._parent.WorkTasks.Remove(workTaskItem)))
{
return(true);
}
if ((this._parent.ValidityInterval == item))
{
this._parent.ValidityInterval = null;
return(true);
}
if ((this._parent.Crew == item))
{
this._parent.Crew = null;
return(true);
}
ICraft craftItem = item.As <ICraft>();
if (((craftItem != null) &&
this._parent.Crafts.Remove(craftItem)))
{
return(true);
}
if ((this._parent.Status == item))
{
this._parent.Status = null;
return(true);
}
return(false);
}
public async Task ListAsync_AsExpected()
{
AppDbContext database = new AppDbContext(
Options.Create(new DatabaseConfigurtaion()),
mObjectSerializer,
mIDProducer,
NullLogger <AppDbContext> .Instance);
WorkTaskRepository workTaskRepository =
new WorkTaskRepository(database, NullLogger <WorkTaskRepository> .Instance);
ITasksGroup tasksGroup1 = mTasksGroupBuilder.CreateGroup("group1");
IWorkTask workTask1 = mTasksGroupBuilder.CreateTask(tasksGroup1, "task1");
IWorkTask workTask2 = mTasksGroupBuilder.CreateTask(tasksGroup1, "task2");
ITasksGroup tasksGroup2 = mTasksGroupBuilder.CreateGroup("group2");
IWorkTask workTask3 = mTasksGroupBuilder.CreateTask(tasksGroup2, "task3");
database.Entities.Add(tasksGroup1);
database.Entities.Add(tasksGroup2);
List <IWorkTask> workTasks = (await workTaskRepository.ListAsync().ConfigureAwait(false)).ToList();
Assert.Equal(workTask1, workTasks[0]);
Assert.Equal(workTask2, workTasks[1]);
Assert.Equal(workTask3, workTasks[2]);
}
public async Task AddAsync_WorkTaskAlreadyExist_NotAdded()
{
AppDbContext database = new AppDbContext(
Options.Create(new DatabaseConfigurtaion()),
mObjectSerializer,
mIDProducer,
NullLogger <AppDbContext> .Instance);
WorkTaskRepository workTaskRepository =
new WorkTaskRepository(database, NullLogger <WorkTaskRepository> .Instance);
const string tasksGroupName = "group1";
ITasksGroup tasksGroup = mTasksGroupBuilder.CreateGroup(tasksGroupName);
IWorkTask workTask = mTasksGroupBuilder.CreateTask(tasksGroup, "taskDescription");
database.Entities.Add(tasksGroup);
Assert.Single(await workTaskRepository.ListAsync().ConfigureAwait(false));
await workTaskRepository.AddAsync(workTask).ConfigureAwait(false);
Assert.NotNull(await workTaskRepository.FindAsync(workTask.ID).ConfigureAwait(false));
Assert.Single(await workTaskRepository.ListAsync().ConfigureAwait(false));
}
public void AllowCorrectionWorkTask(IWorkTask workTask)
{
if (WorkTaskStatus == WorkTaskStatus.Executed)
{
AllowCorrectionWorkTask();
}
}
private void AddTaskMeasurementIfNeeded(IWorkTask task, List <TaskMeasurement> tasksMeasurements)
{
if (mOpenTasksMeasurementsDict.TryGetValue(task.ID, out TaskMeasurementInfo taskMeasurementInfo))
{
if (!taskMeasurementInfo.TaskMeasurement.Triangle.ShouldNotifyExact())
{
return;
}
int currentProgressPercentage =
taskMeasurementInfo.TaskMeasurement.Triangle.GetCurrentTimeProgressPercentage();
if (taskMeasurementInfo.PercentageProgress < currentProgressPercentage)
{
AddOrUpdateNewTaskMeasurement(taskMeasurementInfo, tasksMeasurements);
}
return;
}
TaskMeasurement taskMeasurement = new TaskMeasurement(task.ID, task.Description, task.TaskMeasurement);
taskMeasurementInfo = new TaskMeasurementInfo(taskMeasurement);
AddOrUpdateNewTaskMeasurement(taskMeasurementInfo, tasksMeasurements);
}
/// <summary>
/// Removes the given item from the collection
/// </summary>
/// <returns>True, if the item was removed, otherwise False</returns>
/// <param name="item">The item that should be removed</param>
public override bool Remove(IModelElement item)
{
ISpecification specificationItem = item.As <ISpecification>();
if (((specificationItem != null) &&
this._parent.Specifications.Remove(specificationItem)))
{
return(true);
}
IWorkTask workTaskItem = item.As <IWorkTask>();
if (((workTaskItem != null) &&
this._parent.WorkTasks.Remove(workTaskItem)))
{
return(true);
}
ICULaborItem cULaborItemItem = item.As <ICULaborItem>();
if (((cULaborItemItem != null) &&
this._parent.CULaborItems.Remove(cULaborItemItem)))
{
return(true);
}
ISkill skillItem = item.As <ISkill>();
if (((skillItem != null) &&
this._parent.Skills.Remove(skillItem)))
{
return(true);
}
return(false);
}
public async Task PutWorkTaskAsync_RequestSuccess_ExpectedResourceReturned()
{
IWorkTask expectedWorkTask = A.Fake <IWorkTask>();
A.CallTo(() => expectedWorkTask.Description).Returns("description");
A.CallTo(() => expectedWorkTask.GroupName).Returns("newGroupName");
ITasksGroupService tasksGroupService = A.Fake <ITasksGroupService>();
A.CallTo(() => tasksGroupService.SaveTaskAsync(expectedWorkTask.GroupName, expectedWorkTask.Description))
.Returns(new SuccessResponse <IWorkTask>(expectedWorkTask));
using TestServer testServer = ApiTestHelper.BuildTestServerWithFakes(tasksGroupService);
using HttpClient httpClient = testServer.CreateClient();
WorkTaskResource workTaskResource = new WorkTaskResource
{
GroupName = expectedWorkTask.GroupName,
Description = expectedWorkTask.Description
};
using StringContent jsonContent =
new StringContent(JsonConvert.SerializeObject(workTaskResource), Encoding.UTF8, PostMediaType);
using HttpResponseMessage response = await httpClient.PutAsync(MainRoute, jsonContent).ConfigureAwait(false);
string stringResponse = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
WorkTaskResource returnedResource = JsonConvert.DeserializeObject <WorkTaskResource>(stringResponse);
Assert.Equal(expectedWorkTask.GroupName, returnedResource.GroupName);
Assert.Equal(expectedWorkTask.Description, returnedResource.Description);
}
/// <summary>
/// 获取评审报告中指定工作任务的下个工作任务
/// </summary>
/// <param name="reviewReport">评审报告</param>
/// <param name="workTask">指定工作任务</param>
/// <returns></returns>
public static IWorkTask GetNextWorkTask(IReviewReport reviewReport, IWorkTask workTask)
{
if (reviewReport.DataReports == null)
{
return(null);
}
var dataReports = reviewReport.DataReports.ToList();
if (dataReports.Any(p => p.ID == workTask.ID))
{
if (reviewReport.DataReportType == DataReportType.Parallel)
{
return(reviewReport); // 在审批报告中，审批报告是子工作任务的下个流程
}
else
{
var index = dataReports.FindIndex(p => p.ID.Equals(workTask.ID));
if (0 <= index && index < dataReports.Count - 1)
{
return(dataReports[index + 1]);
}
else if (index == dataReports.Count - 1)
{
return(reviewReport); // 在审批报告中，审批报告是子工作任务的下个流程
}
}
}
return(null);
}
public async Task SaveTaskAsync_DescriptionExistsInTheSameGroup_SaveNotPerformed()
{
IWorkTask workTask = A.Fake <IWorkTask>();
workTask.GroupName = "groupName";
workTask.Description = "description";
IWorkTask workTaskWithSameDescription = A.Fake <IWorkTask>();
workTask.GroupName = workTask.GroupName;
workTask.Description = workTask.Description;
ITasksGroup tasksGroup = A.Fake <ITasksGroup>();
tasksGroup.SetGroupName(workTask.GroupName);
A.CallTo(() => tasksGroup.GetAllTasks()).Returns(new List <IWorkTask> {
workTask
});
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
A.CallTo(() => dbRepository.ListAsync()).Returns(new List <ITasksGroup>()
{
tasksGroup
});
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
await tasksGroupService.SaveTaskAsync(workTask.GroupName, workTask.Description).ConfigureAwait(false);
A.CallTo(() => dbRepository.UpdateAsync(A <ITasksGroup> .Ignored)).MustNotHaveHappened();
}
public async Task UpdateTaskAsync_TaskExists_TaskUpdated()
{
IWorkTask taskToUpdate = A.Fake <IWorkTask>();
A.CallTo(() => taskToUpdate.Description).Returns("some-description");
A.CallTo(() => taskToUpdate.ID).Returns("some-id");
ITasksGroup tasksGroup = A.Fake <ITasksGroup>();
OperationResult <IWorkTask> getTaskResult = new OperationResult <IWorkTask>(true, taskToUpdate);
A.CallTo(() => tasksGroup.GetTask(A <string> .Ignored)).Returns(getTaskResult);
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
A.CallTo(() => dbRepository.ListAsync()).Returns(new List <ITasksGroup>()
{
tasksGroup
});
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
await tasksGroupService.UpdateTaskAsync(
new WorkTaskResource
{
TaskId = taskToUpdate.ID,
Description = taskToUpdate.Description
}).ConfigureAwait(false);
A.CallTo(() => dbRepository.UpdateAsync(tasksGroup)).MustHaveHappenedOnceExactly();
}
public async Task SaveTaskAsync_DescriptionExistsInTheSameGroup_FailResponseReturned()
{
IWorkTask workTask = A.Fake <IWorkTask>();
workTask.GroupName = "groupName";
workTask.Description = "description";
IWorkTask workTaskWithSameDescription = A.Fake <IWorkTask>();
workTask.GroupName = workTask.GroupName;
workTask.Description = workTask.Description;
ITasksGroup tasksGroup = A.Fake <ITasksGroup>();
tasksGroup.SetGroupName(workTask.GroupName);
A.CallTo(() => tasksGroup.GetAllTasks()).Returns(new List <IWorkTask> {
workTask
});
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
A.CallTo(() => dbRepository.ListAsync()).Returns(new List <ITasksGroup>()
{
tasksGroup
});
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
IResponse <IWorkTask> response =
await tasksGroupService.SaveTaskAsync(workTask.GroupName, workTask.Description).ConfigureAwait(false);
Assert.False(response.IsSuccess);
Assert.Null(response.ResponseObject);
}
public async Task SaveTaskAsync_InvalidTaskName_FailResponseReturnedAndSaveNotPerformed()
{
const string groupName = "groupName";
IWorkTask workTask = A.Fake <IWorkTask>();
workTask.GroupName = groupName;
workTask.Description = mInvalidTaskName;
OperationResult <IWorkTask> createTaskResult = new OperationResult <IWorkTask>(true, workTask);
ITasksGroup tasksGroup = A.Fake <ITasksGroup>();
tasksGroup.SetGroupName(groupName);
A.CallTo(() => tasksGroup.CreateTask(A <string> .Ignored, A <string> .Ignored)).Returns(createTaskResult);
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
A.CallTo(() => dbRepository.ListAsync()).Returns(new List <ITasksGroup> {
tasksGroup
});
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
IResponse <IWorkTask> response =
await tasksGroupService.SaveTaskAsync(workTask.GroupName, workTask.Description).ConfigureAwait(false);
Assert.False(response.IsSuccess);
Assert.Null(response.ResponseObject);
A.CallTo(() => dbRepository.AddAsync(A <ITasksGroup> .Ignored)).MustNotHaveHappened();
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
ISpecification specificationsCasted = item.As <ISpecification>();
if ((specificationsCasted != null))
{
this._parent.Specifications.Add(specificationsCasted);
}
IWorkTask workTasksCasted = item.As <IWorkTask>();
if ((workTasksCasted != null))
{
this._parent.WorkTasks.Add(workTasksCasted);
}
ICULaborItem cULaborItemsCasted = item.As <ICULaborItem>();
if ((cULaborItemsCasted != null))
{
this._parent.CULaborItems.Add(cULaborItemsCasted);
}
ISkill skillsCasted = item.As <ISkill>();
if ((skillsCasted != null))
{
this._parent.Skills.Add(skillsCasted);
}
}
public async Task UpdateTaskAsync_TaskExists_SuccessResponseReturned()
{
IWorkTask taskToUpdate = A.Fake <IWorkTask>();
A.CallTo(() => taskToUpdate.Description).Returns("some-description");
A.CallTo(() => taskToUpdate.ID).Returns("some-id");
ITasksGroup tasksGroup = A.Fake <ITasksGroup>();
OperationResult <IWorkTask> getTaskResult = new OperationResult <IWorkTask>(true, taskToUpdate);
A.CallTo(() => tasksGroup.GetTask(A <string> .Ignored)).Returns(getTaskResult);
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
A.CallTo(() => dbRepository.ListAsync()).Returns(new List <ITasksGroup>()
{
tasksGroup
});
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
IResponse <IWorkTask> response = await tasksGroupService.UpdateTaskAsync(
new WorkTaskResource
{
TaskId = taskToUpdate.ID,
Description = taskToUpdate.Description
}).ConfigureAwait(false);
Assert.True(response.IsSuccess);
Assert.Equal(taskToUpdate, response.ResponseObject);
}
/// <summary>
/// 获取下个工作任务
/// </summary>
/// <param name="workTask"></param>
/// <returns></returns>
public IWorkTask GetNextWorkTask(IWorkTask workTask)
{
var index = _workTasks.FindIndex(p => p.ID.Equals(workTask.ID));
if (index == _workTasks.Count - 1)
{
return(null);
}
return(_workTasks[index + 1]);
}
/// <summary>
/// Queues work that will be run in the engine main thread.
/// </summary>
/// <param name="task">The work task.</param>
public static void QueueWork(IWorkTask task)
{
if (task == null)
{
throw new ArgumentNullException("task");
}
workQueue.Enqueue(task);
workQueueResetEvent.Set();
}
private async Task <(ITasksGroup, IWorkTask)> FindWorkTaskAndItsParentGroup(string workTaskId)
{
foreach (ITasksGroup group in await ListAsync().ConfigureAwait(false))
{
IWorkTask task = group.GetTask(workTaskId).Value;
if (task != null)
{
return(group, task);
}
}
return(null, null);
}
public void IsFinished_HasOpenTasks_False()
{
ITasksGroup taskGroup = mTaskGroupFactory.CreateGroup("TestGroup", mTasksGroupProducer).Value;
mTaskGroupFactory.CreateTask(taskGroup, "task1", mWorkTaskProducer);
IWorkTask task2 = mTaskGroupFactory.CreateTask(taskGroup, "task2", mWorkTaskProducer).Value;
IWorkTask task3 = mTaskGroupFactory.CreateTask(taskGroup, "task3", mWorkTaskProducer).Value;
task2.CloseTask(string.Empty);
task3.CloseTask(string.Empty);
Assert.False(taskGroup.IsFinished);
}
public async Task Start(IWorkTask workTask, int workTheardCount)
{
await workQueue.EnqueueAsync(workTask);
if (workTheardCount < 1)
{
workTheardCount = 1;
}
tasks = new Task[workTheardCount];
for (int i = 0; i < tasks.Length; i++)
{
tasks[i] = Work();
}
await Task.WhenAll(tasks);
}
public async Task <IActionResult> PutNoteAsync([FromBody] NoteResource noteResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
if (noteResource == null)
{
return(BadRequest($"Parameter {nameof(noteResource)} is null"));
}
IEnumerable <IWorkTask> workTasks =
await mWorkTaskService.FindWorkTasksByConditionAsync(task => task.ID == noteResource.NotePath)
.ConfigureAwait(false);
if (!workTasks.Any())
{
return(StatusCode(StatusCodes.Status405MethodNotAllowed, $"Could not find work task {noteResource.NotePath}"));
}
mLogger.LogDebug($"Requesting putting new note {noteResource.NotePath}");
IWorkTask firstWorkTask = workTasks.First();
string noteName = $"{firstWorkTask.ID}-{firstWorkTask.Description}{AppConsts.NoteExtension}";
try
{
IResponse <NoteResourceResponse> result =
await mNoteService.CreatePrivateNote(noteName, noteResource.Text).ConfigureAwait(false);
NoteResource noteResourceResult = mMapper.Map <NoteResourceResponse, NoteResource>(result.ResponseObject);
if (!result.IsSuccess)
{
return(StatusCode(StatusCodes.Status405MethodNotAllowed, result.Message));
}
return(Ok(noteResourceResult));
}
catch (Exception ex)
{
mLogger.LogError(ex, "Put operation failed with error");
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
}
private void Item_OnWorkTaskStatusChange(IWorkTask workTask)
{
if ((workTask as IWorkFlow).WorkFlowStatus == WorkFlowStatus.NoPass)
{
ProjectFlowStatus = ProjectFlowStatus.NoPass;
UpdateWorkTaskStatus(WorkTaskStatus.Executed);
}
else if ((workTask as IWorkFlow).WorkFlowStatus == WorkFlowStatus.Pass)
{
ExecutNextWorkTask();
}
if (_workTasks.All(p => (p as IWorkFlow).WorkFlowStatus == WorkFlowStatus.Pass))
{
ProjectFlowStatus = ProjectFlowStatus.Pass;
UpdateWorkTaskStatus(WorkTaskStatus.Executed);
}
}
public async Task FindAsync_IdExist_Found()
{
AppDbContext database = new AppDbContext(
Options.Create(new DatabaseConfigurtaion()),
mObjectSerializer,
mIDProducer,
NullLogger <AppDbContext> .Instance);
WorkTaskRepository workTaskRepository =
new WorkTaskRepository(database, NullLogger <WorkTaskRepository> .Instance);
ITasksGroup tasksGroup = mTasksGroupBuilder.CreateGroup("group1");
IWorkTask workTask = mTasksGroupBuilder.CreateTask(tasksGroup, "taskDescription");
database.Entities.Add(tasksGroup);
Assert.NotNull(await workTaskRepository.FindAsync(workTask.ID).ConfigureAwait(false));
}
/// <summary>
/// 工作任务允许修改
/// 将下个工作任务由执行状态改为等待状态
/// 本工作任务由执行完成状态改为执行状态
/// 只有已执行完成的工作任务才可以请求【工作任务允许修改】
/// </summary>
/// <param name="nexWorkTask">下个工作任务</param>
public void AllowCorrectionWorkTask(IWorkTask nexWorkTask)
{
if (WorkTaskStatus == WorkTaskStatus.Executing)
{
throw new Exception("工作任务处于执行状态，可以直接修改数据报告！");
}
if (WorkTaskStatus == WorkTaskStatus.Waiting)
{
throw new Exception("工作任务处于等待状态，不能修改数据报告状态！");
}
if (nexWorkTask != null)
{
nexWorkTask.Wait();
}
UpdateWorkTaskStatus(WorkTaskStatus.Executing);
}
public async Task <IResponse <IWorkTask> > SaveTaskAsync(string taskGroupIdentifier, string workTaskDescription)
{
try
{
ITasksGroup tasksGroup =
(await FindTasksGroupsByConditionAsync(group => group.ID == taskGroupIdentifier)
.ConfigureAwait(false))
.FirstOrDefault();
if (tasksGroup == null && taskGroupIdentifier != null)
{
tasksGroup = (await FindTasksGroupsByConditionAsync(group =>
string.Equals(group.Name, taskGroupIdentifier, StringComparison.OrdinalIgnoreCase))
.ConfigureAwait(false))
.FirstOrDefault();
}
if (tasksGroup == null)
{
return(new FailResponse <IWorkTask>($"Tasks group {taskGroupIdentifier} does not exist"));
}
if (!ValidateUniqueTaskDescription(tasksGroup, workTaskDescription))
{
return(new FailResponse <IWorkTask>($"Tasks group {tasksGroup.Name} " +
$"has already work task with description {workTaskDescription}"));
}
IWorkTask workTask = mTaskGroupFactory.CreateTask(tasksGroup, workTaskDescription);
if (!mWorkTaskNameValidator.IsNameValid(workTask.Description))
{
return(new FailResponse <IWorkTask>($"Task description'{workTask.Description}' is invalid"));
}
await mTasksGroupRepository.UpdateAsync(tasksGroup).ConfigureAwait(false);
return(new SuccessResponse <IWorkTask>(workTask));
}
catch (Exception ex)
{
return(new FailResponse <IWorkTask>($"An error occurred when saving work task {taskGroupIdentifier}: {ex.Message}"));
}
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
IWorkTask workTasksCasted = item.As <IWorkTask>();
if ((workTasksCasted != null))
{
this._parent.WorkTasks.Add(workTasksCasted);
}
if ((this._parent.ValidityInterval == null))
{
IDateTimeInterval validityIntervalCasted = item.As <IDateTimeInterval>();
if ((validityIntervalCasted != null))
{
this._parent.ValidityInterval = validityIntervalCasted;
return;
}
}
if ((this._parent.Crew == null))
{
ICrew crewCasted = item.As <ICrew>();
if ((crewCasted != null))
{
this._parent.Crew = crewCasted;
return;
}
}
ICraft craftsCasted = item.As <ICraft>();
if ((craftsCasted != null))
{
this._parent.Crafts.Add(craftsCasted);
}
if ((this._parent.Status == null))
{
IStatus statusCasted = item.As <IStatus>();
if ((statusCasted != null))
{
this._parent.Status = statusCasted;
return;
}
}
}
public OperationResult <IWorkTask> CreateTask(ITasksGroup tasksGroup, string description, IWorkTaskProducer workTaskProducer)
{
if (workTaskProducer == null)
{
throw new ArgumentNullException(nameof(workTaskProducer));
}
IWorkTask createdTask = workTaskProducer.ProduceTask(mIDProducer.ProduceID(), description);
OperationResult addTaskResult = tasksGroup.AddTask(createdTask);
addTaskResult.Log(mLogger);
if (!addTaskResult.Success)
{
return(new OperationResult <IWorkTask>(false, addTaskResult.Reason, createdTask));
}
return(new OperationResult <IWorkTask>(true, addTaskResult.Reason, createdTask));
}