/// <summary> Not sure yet if we should delete it </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <dynamic> Delete([FromUri] long id)
{
long UserId = long.Parse(User.Identity.GetUserId());
var oldTask = await db.Tasks.Where(f => f.Id == id).Include(f => f.ForField)
.Include(f => f.ForField.OnOrganisation).Include(f => f.ForField.OnOrganisation.Bonds).FirstOrDefaultAsync();
if (oldTask == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ErrorResponse.DoesntExist));
}
//Setup variables
string role = OrganisationsController.FindAndGetRole(oldTask.ForField.OnOrganisation, UserId);
TaskManagementRole = BondDb.CanAssignJobsToOthers.Contains(role);
if (!CheckPermission(TaskManagementRole, UserId, oldTask))
{
oldTask.MarkedDeleted = true;
eventLog = JsonConvert.DeserializeObject <List <TaskEvent> >(oldTask.EventLog);
var it = new TaskEvent((DTO.TaskDTO)oldTask, UserId, "Task was deleted");
eventLog.Add(it);
oldTask.EventLog = JsonConvert.SerializeObject(eventLog);
await db.SaveChangesAsync();
return(Ok());
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ErrorResponse.PermissionsTooLow));
};
}
static void WorkThread(TaskGraph taskGraph)
{
while (true)
{
taskGraph.mEventDispatch.Wait();
{
if (taskGraph.mEventExit.Wait(0))
{
break;
}
taskGraph.mEventReady.Signal();
taskGraph.mEventReady.Wait();
if (taskGraph.mTaskListHeads.Count > 0 && taskGraph.mTaskListDependence.Count > 0)
{
TaskEvent taskEvent = taskGraph.mEventRun;
do
{
taskEvent.Wait();
while (true)
{
bool bFinish = false;
TaskBase task = null;
taskGraph.mMutex.WaitOne();
{
if (taskGraph.mTaskListHeads.ContainsKey(taskEvent) && taskGraph.mTaskListHeads[taskEvent] != null)
{
task = taskGraph.mTaskListHeads[taskEvent];
taskGraph.mTaskListHeads[taskEvent] = taskGraph.mTaskListHeads[taskEvent].Next;
}
else
{
bFinish = true;
}
}
taskGraph.mMutex.ReleaseMutex();
if (task != null)
{
task.TaskFunc();
task.SetEventSignal();
}
if (bFinish)
{
break;
}
}
taskEvent = taskGraph.mTaskListDependence.Count > 0 ? taskGraph.mTaskListDependence[taskEvent] : null;
} while (taskEvent != null);
}
}
taskGraph.mEventDispatch.Reset();
taskGraph.mEventFinish.Signal();
}
}
/// <summary>
/// Send web socket message to target clients.
/// </summary>
/// <param name="taskEvent">
/// Task event.
/// </param>
/// <param name="task">
/// Task itself.
/// </param>
public void Send(TaskEvent taskEvent, TaskData task)
{
IHubContext hubContext = GlobalHost.ConnectionManager.GetHubContext <TasksManagerHub>();
lock (task)
{
var result = new
{
task.Id,
TaskType = task.TaskType.GetName(),
DisplayName = task.TaskType.GetDisplayValue(),
Created = task.Created.ToString(OutputFormats.DateTimeFormat),
Started = task.Started?.ToString(OutputFormats.DateTimeFormat),
Completed = task.Completed?.ToString(OutputFormats.DateTimeFormat),
ExecutionTime = task.ExecutionTime?.ToString(OutputFormats.TimeFormat),
TaskState = task.TaskState.ToString(),
TaskStateName = task.TaskState.GetDisplayValue(),
task.UserId,
task.UserName
};
hubContext.Clients.Group("admins").TaskEvent(taskEvent.ToString(), result);
if (!AccountHelper.IsAdmin())
{
hubContext.Clients.Group(task.UserId.ToString()).TaskEvent(taskEvent.ToString(), result);
}
}
}
protected override void Dispatch(Org.Apache.Hadoop.Yarn.Event.Event @event)
{
if (@event is TaskAttemptEvent)
{
TaskAttemptEvent killEvent = (TaskAttemptEvent)@event;
if (killEvent.GetType() == TaskAttemptEventType.TaKill)
{
TaskAttemptId taID = killEvent.GetTaskAttemptID();
if (taID.GetTaskId().GetTaskType() == TaskType.Reduce && taID.GetTaskId().GetId()
== 0 && taID.GetId() == 0)
{
base.Dispatch(new TaskAttemptEvent(taID, TaskAttemptEventType.TaDone));
base.Dispatch(new TaskAttemptEvent(taID, TaskAttemptEventType.TaContainerCleaned)
);
base.Dispatch(new TaskTAttemptEvent(taID, TaskEventType.TAttemptSucceeded));
this.cachedKillEvent = killEvent;
return;
}
}
}
else
{
if (@event is TaskEvent)
{
TaskEvent taskEvent = (TaskEvent)@event;
if (taskEvent.GetType() == TaskEventType.TAttemptSucceeded && this.cachedKillEvent
!= null)
{
base.Dispatch(this.cachedKillEvent);
return;
}
}
}
base.Dispatch(@event);
}
public MessageHandler(SynchronizationContext windowsFormsContext, ReplicationTaskInfo source, TaskEvent onStatusUI, TaskEvent onErrorUI)
{
this.OnStatusUI = onStatusUI;
this.OnErrorUI = onErrorUI;
this.windowsFormsContext = windowsFormsContext;
this.source = source;
}
public static TaskEventCollection?Collect(BrainVisionPackage filesContent)
{
IHeaderFileContentVer1 headerContent = filesContent.HeaderFileContent;
IMarkerFileContentVer1?markerContent = filesContent.MarkerFileContent;
List <MarkerInfo>?markers = markerContent?.GetMarkers();
if (markers == null)
{
return(null);
}
double samplingFrequency = Common.GetSamplingFrequencyFromSamplingInterval(headerContent.SamplingInterval !.Value);
TaskEventCollection taskEvents = new TaskEventCollection();
foreach (MarkerInfo marker in markers)
{
TaskEvent taskEvent = new TaskEvent(
//REQUIRED
onset: marker.Position / samplingFrequency,
duration: marker.Length / samplingFrequency)
{
//OPTIONAL
Sample = marker.Position + 1, // I suppose bids uses 1-based sample position. This info is not present in the official bids documentations
TrialType = marker.Type,
Value = !string.IsNullOrEmpty(marker.Description) ? marker.Description : Defs.NotAvailable,
};
taskEvents.Add(taskEvent);
}
return(taskEvents);
}
public void Equality_SettingValues()
{
var a = new TaskEvent
{
Version = "1",
TaskId = "2",
Action = TaskAction.Activate,
NewParentId = "x",
Annoyance = Likert5Point.Negative1,
Importance = Likert5Point.Neutral,
Urgency = Likert5Point.Positive1
};
var b = new TaskEvent
{
Version = "1",
TaskId = "2",
Action = TaskAction.Activate,
NewParentId = "x",
Annoyance = Likert5Point.Negative1,
Importance = Likert5Point.Neutral,
Urgency = Likert5Point.Positive1
};
Assert.AreEqual(a, b);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
}
public void FileAddWrite(string text, string url, TaskEvent finished = null, ErrorEvent error = null)
{
try
{
FtpWebRequest request = (FtpWebRequest)WebRequest.Create(new Uri(accessUrlBase + url));
request.Method = WebRequestMethods.Ftp.AppendFile;
byte[] fileContents = Encoding.UTF8.GetBytes(text);
request.ContentLength = fileContents.Length;
request.Credentials = icr;
Stream requestStream = request.GetRequestStream();
requestStream.Write(fileContents, 0, fileContents.Length);
requestStream.Close();
FtpWebResponse response = (FtpWebResponse)request.GetResponse();
response.Close();
requestStream.Dispose();
response.Dispose();
finished?.Invoke();
}
catch (WebException e)
{
error?.Invoke(((FtpWebResponse)e.Response).StatusDescription);
}
}
/// <summary>
/// Publishes the task event to all subscribed event listeners.
/// </summary>
/// <param name="event">The event to publish.</param>
public void Publish(TaskEvent @event)
{
foreach (var listener in _listeners[@event.GetType()])
{
listener.OnEvent(@event);
}
}
/// <summary>
/// 添加计时器任务
/// </summary>
/// <param name="task"></param>
/// <param name="time">于time毫秒后执行</param>
/// <returns></returns>
public int AddSchedule(TaskEvent task, long time)
{
Index++;
TimeTaskModel m = new TimeTaskModel(Index, time * 10000 + DateTime.Now.Ticks, task);
TaskDic.Add(Index, m);
return(Index);
}
public void Equality_Default()
{
var a = new TaskEvent();
var b = new TaskEvent();
Assert.AreEqual(a, b);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
}
public TaskEventArgs(IGisTask task, TaskEvent taskEvent)
{
if (task == null)
{
throw new ArgumentNullException("task");
}
Task = task;
Event = taskEvent;
}
private void FireTaskChanged(IGisTask task, TaskEvent taskEvent)
{
var handler = TaskChanged;
if (handler != null)
{
handler(this, new TaskEventArgs(task, taskEvent));
}
}
public void SetEvent(TaskEvent taskEvent)
{
mTaskEvent = taskEvent;
if (mTaskEvent != null)
{
mTaskEvent.Unsignal();
}
}
/**
* Just calls {@link #tick()} to make the ExecutionParallel task evolve
* according to the status of its children.
*
* @see jbt.execution.core.ExecutionTask#statusChanged(jbt.execution.core.event.TaskEvent)
*/
public override void StatusChanged(TaskEvent e)
{
/*
* TODO: the TaskEvent could be used to improve the efficiency of this
* method, since we only have to analyse the status of the task that
* fired the event, not the status of all the tasks (which is what
* tick() does).
*/
Tick();
}
public void Equality_DifferentParent()
{
var a = new TaskEvent
{
NewParentId = "x"
};
var b = new TaskEvent();
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
public void Equality_DifferentImportance()
{
var a = new TaskEvent
{
Importance = Likert5Point.Neutral
};
var b = new TaskEvent();
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
public void Equality_DifferentTask()
{
var a = new TaskEvent
{
TaskId = "2"
};
var b = new TaskEvent();
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
public void Equality_DifferentVersion()
{
var a = new TaskEvent
{
Version = "1"
};
var b = new TaskEvent();
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
public void Equality_DifferentUrgency()
{
var a = new TaskEvent
{
Urgency = Likert5Point.Positive1
};
var b = new TaskEvent();
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
// Starts a new background task and returns its task ID
public static int StartTask(int delay, TaskEvent onInvoke, TaskEvent onExpire = null)
{
if (taskInvokerPlugin == null)
{
createTaskInvoker();
}
int id = taskInvokerPlugin.StartTask(delay);
runningTasks.Add(new Task(id, onInvoke, onExpire));
return(id);
}
public void Equality_DifferentDifferentAnnoyance()
{
var a = new TaskEvent
{
Annoyance = Likert5Point.Negative1
};
var b = new TaskEvent();
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
public void Equality_DifferentAction()
{
var a = new TaskEvent
{
Action = TaskAction.Activate
};
var b = new TaskEvent();
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
public void DefaultValues()
{
var sut = new TaskEvent();
Assert.AreEqual("", sut.Version);
Assert.AreEqual("", sut.TaskId);
Assert.AreEqual(TaskAction.Create, sut.Action);
Assert.Null(sut.NewParentId);
Assert.Null(sut.Annoyance);
Assert.Null(sut.Importance);
Assert.Null(sut.Urgency);
}
public TaskEventViewModel(TaskEvent taskEvent)
{
Id = taskEvent.Id;
Title = taskEvent.Title;
Start = DateTime.SpecifyKind(taskEvent.Start, DateTimeKind.Utc);
End = DateTime.SpecifyKind(taskEvent.End, DateTimeKind.Utc);
StartTimezone = taskEvent.StartTimeZone;
EndTimezone = taskEvent.EndTimeZone;
Description = taskEvent.Description;
IsAllDay = taskEvent.IsAllDay;
RecurrenceRule = taskEvent.RecurrenceRule;
RecurrenceException = taskEvent.RecurrenceException;
RecurrenceID = taskEvent.RecurrenceId;
OwnerID = taskEvent.OwnerId ?? 0;
}
private async Async.Task <Error?> OnWorkerEventRunning(Guid machineId, WorkerRunningEvent running)
{
var(task, node) = await(
_context.TaskOperations.GetByTaskId(running.TaskId),
_context.NodeOperations.GetByMachineId(machineId));
if (task is null)
{
return(new Error(
Code: ErrorCode.INVALID_REQUEST,
Errors: new string[] { $"unable to find task: {running.TaskId}" }));
}
if (node is null)
{
return(new Error(
Code: ErrorCode.INVALID_REQUEST,
Errors: new string[] { $"unable to find node: {machineId}" }));
}
if (!node.State.ReadyForReset())
{
await _context.NodeOperations.SetState(node, NodeState.Busy);
}
var nodeTask = new NodeTasks(
MachineId: machineId,
TaskId: running.TaskId,
State: NodeTaskState.Running);
await _context.NodeTasksOperations.Replace(nodeTask);
if (task.State.ShuttingDown())
{
_log.Info($"ignoring task start from node. machine_id:{machineId} job_id:{task.JobId} task_id:{task.TaskId} (state: {task.State})");
return(null);
}
_log.Info($"task started on node. machine_id:{machineId} job_id:{task.JobId} task_id:{task.TaskId}");
await _context.TaskOperations.SetState(task, TaskState.Running);
var taskEvent = new TaskEvent(
TaskId: task.TaskId,
MachineId: machineId,
EventData: new WorkerEvent(Running: running));
await _context.TaskEventOperations.Replace(taskEvent);
return(null);
}
/// <summary>
/// Initializes the dialog with the specified task event.
/// </summary>
/// <param name="taskEvent">The <see cref="TaskEvent"/> to show initially.</param>
/// <param name="log">The <see cref="TaskEventLog"/> for the task.</param>
public void Initialize(TaskEvent taskEvent, TaskEventLog log = null)
{
if (taskEvent == null)
throw new ArgumentNullException("taskEvent");
if (log != null)
{
eventEnum = log.GetEnumerator() as TaskEventEnumerator;
eventEnum.Seek(CurrentEvent.EventRecord.Bookmark);
}
else
{
eventEnum = null;
}
CurrentEvent = taskEvent;
}
public void Create(int numThreads)
{
mThreads = new Thread[numThreads];
mEventRun = new TaskEvent(true);
mEventReady = new TaskEvent(true);
mEventFinish = new TaskEvent(true);
mEventExit = new TaskEvent(false);
mEventDispatch = new TaskEvent(false);
for (int index = 0; index < numThreads; index++)
{
mThreads[index] = new Thread(() => WorkThread(this));
mThreads[index].Start();
}
}
static void Main(string[] args)
{
int count = 10;
Data data = new Data();
TaskStep0[] step0 = new TaskStep0[count];
TaskStep1[] step1 = new TaskStep1[count];
TaskStep2[] step2 = new TaskStep2[count];
for (int index = 0; index < count; index++)
{
step0[index] = new TaskStep0(data, index, count);
step1[index] = new TaskStep1(data, index, count);
step2[index] = new TaskStep2(data, index, count);
}
TaskEvent event1 = new TaskEvent();
TaskEvent event2 = new TaskEvent();
TaskGraph taskGraph = new TaskGraph();
taskGraph.Create(8);
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
if (key.Key != ConsoleKey.Escape)
{
Console.WriteLine("");
for (int index = 0; index < count; index++)
{
taskGraph.Task(step0[index], event1, null);
taskGraph.Task(step1[index], event2, event1);
taskGraph.Task(step2[index], null, event2);
}
taskGraph.Dispatch();
taskGraph.Wait();
continue;
}
break;
}
taskGraph.Destroy();
}
public void FileUpload(string local, string url, TaskEvent finished = null, ErrorEvent error = null)
{
try
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls;
webClient.UploadFile(accessUrlBase + url, local);
finished?.Invoke();
}
catch (WebException e)
{
error?.Invoke(((FtpWebResponse)e.Response).StatusDescription);
}
catch (Exception e)
{
error?.Invoke(e.Message);
}
}
public void Delete(string url, TaskEvent finished = null, ErrorEvent error = null)
{
try
{
FtpWebRequest ftpReq = (FtpWebRequest)WebRequest.Create(accessUrlBase + url);
ftpReq.Credentials = icr;
ftpReq.Method = WebRequestMethods.Ftp.DeleteFile;
FtpWebResponse ftpRes = (FtpWebResponse)ftpReq.GetResponse();
ftpRes.Close();
}
catch (WebException e)
{
error?.Invoke(((FtpWebResponse)e.Response).StatusDescription);
}
catch (Exception e)
{
error?.Invoke(e.Message);
}
}
/// <summary>
/// Send web socket message to all clients.
/// </summary>
/// <param name="taskEvent">
/// Task event.
/// </param>
/// <param name="task">
/// Task itself.
/// </param>
public static void Send(TaskEvent taskEvent, TaskData task)
{
var hubContext = GlobalHost.ConnectionManager.GetHubContext<TasksManagerHub>();
lock (task)
{
var result = new
{
task.Id,
task.DisplayName,
Created = task.Created.ToString(OutputFormats.DateTimeFormat),
Started = task.Started == null ? string.Empty : ((DateTimeOffset)task.Started).ToString(OutputFormats.DateTimeFormat),
Completed = task.Completed == null ? string.Empty : ((DateTimeOffset)task.Completed).ToString(OutputFormats.DateTimeFormat),
ExecutionTime = task.ExecutionTime == null ? string.Empty : ((TimeSpan)task.ExecutionTime).ToString(OutputFormats.TimeFormat),
TaskState = task.TaskState.ToString(),
TaskStateName = task.TaskState.GetDisplayValue(),
task.UserId,
task.UserName
};
hubContext.Clients.All.TaskEvent(taskEvent.ToString(), result);
}
}
/// <summary>
/// Regenerates a task from an XElement node
/// </summary>
/// <param name="task">The XElement node to regenerate the task from.</param>
/// <returns>The regenerated task.</returns>
private Task GenerateTaskFromXElement(XElement task)
{
Task newTask = null;
try
{
string type = task.Attribute("type").Value;
int id = Int32.Parse(task.Attribute("id").Value);
string taskName = task.Element("Name").Value;
DateTime startTime, endTime;
DateTimeSpecificity isSpecific = new DateTimeSpecificity();
XElement DTSpecElement = task.Element("DateTimeSpecificity");
if (DTSpecElement != null) isSpecific = DTSpecElement.FromXElement<DateTimeSpecificity>();
bool state;
if (task.Element("Done").Value == "True") state = true;
else state = false;
switch (type)
{
case "Floating":
newTask = new TaskFloating(taskName, state, id);
break;
case "Deadline":
endTime = DateTime.Parse(task.Element("EndTime").Value);
newTask = new TaskDeadline(taskName, endTime, isSpecific, state, id);
break;
case "Event":
endTime = DateTime.Parse(task.Element("EndTime").Value);
startTime = DateTime.Parse(task.Element("StartTime").Value);
newTask = new TaskEvent(taskName, startTime, endTime, isSpecific, state, id);
break;
}
}
catch (NullReferenceException)
{
throw new TaskFileCorruptedException();
}
return newTask;
}
public ITaskEvent CreateTaskEvent(TaskEvent currentEvent)
{
return new Dev2TaskEvent(currentEvent);
}
public Dev2TaskEvent(TaskEvent nativeObject)
{
_nativeObject = nativeObject;
}
private static TaskEvent GetTaskEvent(dynamic dTaskEvent)
{
string content = dTaskEvent.Content;
if (string.IsNullOrWhiteSpace(content)) return null;
XDocument doc = null;
try
{
doc = XDocument.Parse(content);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
Debug.WriteLine(content);
}
if (doc == null) return null;
if (doc.Root == null) return null;
var result = new TaskEvent
{
ReportTimeDateTime = DateTime.Parse(dTaskEvent.ReportTimeDateTime.ToString(),
CultureInfo.InvariantCulture)
};
foreach (var el in doc.Root.Elements())
{
if (el.Name == "PlannedEndTime")
{
var ticks = long.Parse(el.Value);
if (ticks > 0)
{
result.PlannedEndTime = new DateTime(ticks);
}
}
else if (el.Name == "Comment")
{
result.Comment = el.Value;
}
else if (el.Name == "UserJobTitleName")
{
result.UserJobTitleName = el.Value;
}
}
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="EventViewerDialog"/> class.
/// </summary>
/// <param name="taskEvent">The <see cref="TaskEvent"/> to show initially.</param>
/// <param name="log">The <see cref="TaskEventLog"/> for the task.</param>
public EventViewerDialog(TaskEvent taskEvent = null, TaskEventLog log = null)
{
InitializeComponent();
if (taskEvent != null)
Initialize(taskEvent, log);
}
