public Task(Guid id, string description)
{
var @event = new TaskCreated(id, description);
EnqueueEvent(@event);
Apply(@event);
}
private void Apply(TaskCreated e)
{
Id = e.Id;
planId = e.PlanId;
Title = e.Title;
interval = e.Interval;
}
public TemplatesAction()
: base(3600)
{
DateTime lastRun = DateTime.Today, today = DateTime.Today;
using (IRepository <Settings, long> repository = PersistentFactory.GetContext().GetRepository <Settings, long>())
{
Settings settings = SettingsFactory.GetSettings(repository);
lastRun = settings.LastRun.GetDate();
}
if (lastRun < today)
{
using (IRepository <Template, long> repository = PersistentFactory.GetContext().GetRepository <Template, long>())
{
while (lastRun < today)
{
foreach (Template template in repository.GetAll())
{
if (template.SatisfiesCondition(lastRun))
{
Task newTask = template.CreateTask(lastRun);
TaskCreated?.Invoke(newTask);
repository.Update(template);
Log.Info($"Task {newTask.Name} was created from template for day {lastRun.ToShortDateString()}", this);
}
}
lastRun = lastRun.AddDays(1);
}
}
}
}
private void CreateOkButton_Click(object sender, EventArgs e)
{
if (!ValidateFields())
{
return;
}
TaskExtModel task = new TaskExtModel();
task.Title = titleTextBox.Text;
task.Description = descriptionTextBox.Text;
task.Begin = DateTime.Now;
task.Deadline = dateTimePicker.Value.Date;
try
{
task.Id = TaskProvider.CreateTask(
task, SubjectId, GroupId);
if (picturePath.Text != "")
{
TaskProvider.UploadImage(task.Id, picturePath.Text);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return;
}
TaskCreated?.Invoke(task, EventArgs.Empty);
this.Close();
}
public void Start()
{
_cancellationTokenSource = new CancellationTokenSource();
Task.Factory.StartNew(() =>
{
try
{
TaskEx.Delay(5000, _cancellationTokenSource.Token).GetAwaiter().GetResult();
if (_cancellationTokenSource.IsCancellationRequested)
{
return;
}
}
catch (TaskCanceledException)
{
return;
}
_taskData = new CreatedNetworkTaskData
{
Id = Guid.NewGuid(),
ComputerNumber = TaskHelper.GenerateComputerNumber(),
Frequency = TaskHelper.GenerateValidR173Frequency(),
FrequencyNumber = TaskHelper.GenerateValidR173NumpadValue()
};
TaskCreated?.Invoke(this, new DataEventArgs <CreatedNetworkTaskData>(_taskData));
});
}
public NewTaskVM()
{
Create = new DelegateCommand(() =>
{
CurrentTasks.Instance().InsertNewTask(task);
TaskCreated?.Invoke();
});
}
public void When(TaskCreated e)
{
writer.Add(e.Id, () => new TaskView
{
Id = e.Id,
Name = e.DefaultName
});
}
public ClientResult Post([FromBody] TaskCreated signal)
{
return(new ClientResult
{
State = true,
Message = $"Signal TaskCreated"
});
}
private Guid GetExistingStreamId()
{
var @event = new TaskCreated {
TaskId = _taskId, Description = "Description"
};
var streamId = EventStore.StartStream <TaskList>(@event);
Session.SaveChanges();
return(streamId);
}
public NewTask(CurrentTasks currentTasks)
{
task = new ProductionTask();
Create = new DelegateCommand(() =>
{
task.CreationDate = DateTime.Now;
task.Status = "1";
currentTasks.InsertNewTask(task);
TaskCreated?.Invoke();
});
}
public void GivenOneEvent_WhenStreamIsStarting_ThenEventsAreSavedWithoutError()
{
var @event = new TaskCreated {
TaskId = Guid.NewGuid(), Description = "Description"
};
var streamId = EventStore.StartStream <TaskList>(@event.TaskId, @event);
streamId.Should().Not.Be.Null();
Session.SaveChanges();
}
private async Task Submit()
{
await TaskManager.ApplyChanges(_taskEditingState)
.ConfigureAwait(false);
if (TaskCreated.HasDelegate)
{
await TaskCreated.InvokeAsync(_task).ConfigureAwait(false);
}
NavigationManager.NavigateTo("/overview");
}
public Task(Guid id, Guid projectId, string title, string priority, DateTime?deadline)
{
if (string.IsNullOrWhiteSpace(title))
{
throw new ArgumentException(nameof(title));
}
State = new TaskState(id, projectId, title, priority, deadline);
var taskCreated = new TaskCreated(id, projectId, title, priority, deadline);
_events.Add(taskCreated);
}
public void Process(TaskCreated @event)
{
var todo = new Todo
{
Id = @event.Id,
Text = @event.Text,
Category = @event.Category,
Status = @event.Status
};
_repository.Insert(todo);
}
public NewTask(CurrentTasks currentTasks, ProductionTask task)
{
this.task = task;
Create = new DelegateCommand(() =>
{
this.task.Status = "f";
this.task.CreationDate = DateTime.Now;
this.task.FinishDate = DateTime.Now;
currentTasks.InsertNewTask(this.task);
TaskCreated?.Invoke();
});
}
public Task BeginBuild(int WorkerID)
{
if (ThrowException)
{
throw new PIODataException("UnitTestException", null, 1, "UnitTest", "UnitTest");
}
Task task = new Task()
{
WorkerID = WorkerID, ETA = DateTime.Now
};
TaskCreated?.Invoke(this, new Task[] { task });
return(task);
}
private void RunTasksJob()
{
var tasks = TCAdmin.TaskScheduler.SDK.Objects.Task.GetTasks(DateTime.UtcNow.Subtract(TimeSpan.FromMinutes(1)), DateTime.UtcNow, true, true, false, true, true, 0, null, null).ToArray();
foreach (TCAdmin.TaskScheduler.SDK.Objects.Task task in tasks)
{
if (_snapshotTasksIds.Contains(task.TaskId))
{
continue;
}
_snapshotTasksIds.Add(task.TaskId);
TaskCreated?.Invoke(task);
}
}
public void GivenOneEvent_WhenEventsArePublishedWithStreamId_ThenEventsAreSavedWithoutErrorAndStreamIsStarted()
{
var @event = new TaskCreated {
TaskId = Guid.NewGuid(), Description = "Description"
};
var streamId = Guid.NewGuid();
EventStore.Append(streamId, @event);
Session.SaveChanges();
var streamState = EventStore.FetchStreamState(streamId);
streamState.Should().Not.Be.Null();
streamState.Version.Should().Be.EqualTo(1);
}
public void GivenStartedStream_WhenStartStreamIsBeingCalledAgain_ThenExceptionIsThrown()
{
var @event = new TaskCreated {
TaskId = Guid.NewGuid(), Description = "Description"
};
var streamId = EventStore.StartStream <TaskList>(@event.TaskId, @event);
Session.SaveChanges();
Assert.Throws <Events.ExistingStreamIdCollisionException>(() =>
{
EventStore.StartStream <TaskList>(@event.TaskId, @event);
Session.SaveChanges();
});
}
protected override void RunAction()
{
using (IRepository <Template, long> repository = PersistentFactory.GetContext().GetRepository <Template, long>())
{
foreach (Template template in repository.GetAll())
{
if (template.SatisfiesCondition())
{
Task newTask = template.CreateTask();
TaskCreated?.Invoke(newTask);
repository.Update(template);
Log.Info($"Task {newTask.Name} was created from template", this);
}
}
}
}
public async Task CreateTask(TaskViewModel taskViewModel)
{
var result = await Create(taskViewModel.ToCreateTaskCommand());
if (result != null)
{
var updatedList = (await GetAllTasks()).Payload;
if (updatedList != null)
{
_tasks = updatedList;
SelectNullTask();
TaskCreated?.Invoke(this, null);
return;
}
CreateTaskFailed?.Invoke(this, "The creation was successful, but we can no longer get an updated list of members from the server.");
}
CreateTaskFailed?.Invoke(this, "Unable to create record.");
}
/// <summary>
/// Function that creates a new Task
/// </summary>
/// <param name="newTask"></param>
/// <returns></returns>
public CommandResult Execute(TaskCreatorCmd newTask)
{
try
{
if (!newTask.IsCommandValid())
{
var message = newTask.ReturnInvalidNotifications();
return(new CommandResult(false, message));
}
var task = new Task(Guid.NewGuid(), newTask.Title, TaskStatus.CREATED, newTask.Description);
_repository.Insert(task);
var taskDTO = new TaskCreated()
{
id = task.Id, title = task.Title, description = task.Description
};
return(new CommandResult(true, SuccessMessages.OPERATION_SUCCESS, taskDTO));
}
catch (Exception exception)
{
_logger.Log(exception.Message);
throw new Exception(FailMessages.EXCEPTION_FAIL_MESSAGE);
}
}
public void Apply(TaskCreated @event)
{
Id = @event.TaskId;
Description = @event.Description;
}
private void Apply(TaskCreated e)
{
id = e.Id;
}
public void Apply(TaskCreated @event)
{
List.Add(new Task {
TaskId = @event.TaskId, Description = @event.Description
});
}
internal void ApplyEvent(TaskCreated @event)
{
Descriptions.Add(@event.TaskId, @event.Description);
}
private void Persist(TaskDescriptionView view, TaskCreated @event)
{
view.ApplyEvent(@event);
}
private void QualityListItem_Selected(object sender, RoutedEventArgs e)
{
DownloadTask downloadTask = new DownloadTask(new DownloadInfo(((VideoInfo.Page.Quality)((ListBoxItem)sender).Tag), ConfigManager.GetSettings().DownloadThreads));
TaskCreated?.Invoke(downloadTask);
}
private async Task TaskLoop(CancellationToken ct)
{
try
{
while (!ct.IsCancellationRequested)
{
State = NetworkServiceState.Finding;
var result = await _netService.WaitForOneConnection(ct);
var connection = result.Key;
var commingType = result.Value;
var writer = new BinaryWriter(connection.GetStream());
var reader = new BinaryReader(connection.GetStream());
if (commingType == ConnectionCommingType.FromListen)
{
var jsontask = reader.ReadString();
var task = JsonConvert.DeserializeObject <CreatedNetworkTaskData>(jsontask);
TaskCreated?.Invoke(this, new DataEventArgs <CreatedNetworkTaskData>(task));
}
else
{
//todo: generate task...
var task = new CreatedNetworkTaskData()
{
Frequency = 33100,
FrequencyNumber = new Random().Next(0, 10),
Id = Guid.NewGuid()
};
var jsontask = JsonConvert.SerializeObject(task);
writer.Write(jsontask);
writer.Flush();
TaskCreated?.Invoke(this, new DataEventArgs <CreatedNetworkTaskData>(task));
}
State = NetworkServiceState.RequestForConfirm;
var remoteConfirm = TaskEx.Run(() =>
{
var confirmationResult = reader.ReadString();
var isConfirmed = JsonConvert.DeserializeObject <ConfirmationResult>(confirmationResult);
return(isConfirmed);
});
var localConfirm = _completationConfirm.Task.ContinueWith(t =>
{
var cjs = JsonConvert.SerializeObject(t.Result);
writer.Write(cjs);
writer.Flush();
return(t.Result);
}, TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.NotOnCanceled);
var bothConfirmation = await TaskEx.WhenAll(remoteConfirm, localConfirm);
bool isBothConfimed = bothConfirmation.All(x => x.Result);
if (isBothConfimed)
{
TaskStarted?.Invoke(this, new DataEventArgs <CreatedNetworkTaskData>());
}
connection.Close();
}
}
catch (TaskCanceledException) { }
catch (Exception ex)
{
SimpleLogger.Log(ex);
}
}
public void RaiseTaskCreated(Task task, [CallerMemberName] string taskName = default)
{
var status = $"[Created] Task: {taskName}";
TaskCreated?.Invoke(this, new TaskStatusChangedEventArgs(task, status));
}
public void When(TaskCreated taskCreated)
{
TaskId = taskCreated.TaskId;
}
