private static IEnumerable<WorkerTask> GenerateNormalRandomList(EngineType? tasktype)
{
var tasks = new List<WorkerTask>();
var random = new Random();
var numberOfTasks = random.Next(16, 32);
for (int i = 1; i <= numberOfTasks; i++)
{
var loopTask = Task.Factory.StartNew(t => FakeTaskActionMethod(), TaskCreationOptions.LongRunning);
WorkerTask cloudTask;
const string operationName = "Test Operation";
if (tasktype.HasValue)
{
cloudTask = new WorkerTask(operationName, loopTask,
FakeTaskActionMethod,
tasktype.Value);
}
else
{
cloudTask = new WorkerTask(operationName, loopTask,
FakeTaskActionMethod,
i % 2 == 0 ? EngineType.ScheduledTask : (i % 3 == 0 ? EngineType.Workflow : EngineType.Maintenance));
}
tasks.Add(cloudTask);
}
return tasks;
}
public override IEnumerable<WorkerTask> CreateTaskThreads()
{
var loopTask = Task.Factory.StartNew(ScheduledTaskMonitorLoop, TaskCreationOptions.LongRunning);
var cloudTask = new WorkerTask(OperationContext.LoggingCategory, loopTask, ScheduledTaskMonitorLoop, EngineType.ScheduledTask);
return new[] { cloudTask };
}
private static ulong CorrectBlockSize(WorkerTask task, ulong I)
{
ulong maxValue = I + PerformanceConstants.WorkerBlockSize;
ulong blockSize = maxValue > task.MainTask.To
? PerformanceConstants.WorkerBlockSize - (maxValue - task.MainTask.To)
: PerformanceConstants.WorkerBlockSize;
return blockSize;
}
public override IEnumerable<WorkerTask> CreateTaskThreads()
{
var tasks = new List<WorkerTask>();
var parallelThreadCount = ((WorkflowContext) OperationContext).ParallelThreadCount;
for (var i = 1; i <= parallelThreadCount; i++)
{
var loopTask = Task.Factory.StartNew(t => WorkflowMonitorLoop(), TaskCreationOptions.LongRunning);
var cloudTask = new WorkerTask(OperationContext.LoggingCategory, loopTask, WorkflowMonitorLoop, EngineType.Workflow);
tasks.Add(cloudTask);
}
return tasks;
}
public void GiveTask(WorkerTask task)
{
_targetReached = false;
if (_task)
_task.SetInUse(false);
if (task)
{
_task = task;
GoToTarget();
}
else
{
_task = null;
_status = WorkerStatus.Idle;
}
}
public void RetryTask(WorkerTask task)
{
task.Errors.Clear();
task.MyWorker = CreateWorker();
task.PublishData();
}
private void ExecuteInThread(WorkerTask task)
{
var primes = task.KnownPrimes.ToArray();
List<ulong> primesResult = new List<ulong>();
Dictionary<ulong, List<ulong>> ordered = new Dictionary<ulong, List<ulong>>();
Parallel.ForEach(SplitTask(task.MainTask),
I =>
{
var blockSize = CorrectBlockSize(task, I);
var sieve = BuildSieve(blockSize);
Sifting(sieve, blockSize, I, primes);
var partResult = BuildPartResult(I, sieve);
if (partResult.Count > 0)
lock (_sync)
ordered.Add(partResult[0], partResult);
});
foreach (var pair in ordered.OrderBy(x => x.Key))
{
primesResult.AddRange(pair.Value);
}
_pauseEvent.Reset();
_free = true;
_receiver.CalculationEnd(new WorkerResult(task.MainTask, primesResult));
_pauseEvent.Set();
}
public override void CaptureRectRegionClipboard()
{
WorkerTask hkrcTask = CreateTask(WorkerTask.JobLevel2.CaptureRectRegionClipboard);
RunWorkerAsync(hkrcTask);
}
public override void CaptureFreeHandRegion()
{
WorkerTask hkfhrTask = CreateTask(WorkerTask.JobLevel2.CaptureFreeHandRegion);
RunWorkerAsync(hkfhrTask);
}
public override void BwApp_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
WorkerTask task = (WorkerTask)e.Result;
PostWorkerTasks();
if (task == null)
{
return;
}
this.Text = Engine.GetProductName();
niTray.Tag = task;
if (task.UploadResults.Count > 0)
{
UploadManager.UploadResultLast = task.UploadResults[task.UploadResults.Count - 1];
UploadManager.ResetCumulativePercentage();
}
try
{
if (task.IsError && task.Errors[0].Contains(ExceptionMessage.ProxyAuthenticationRequired))
{
ProxyUI ui = new ProxyUI();
if (ui.ShowDialog() == DialogResult.OK)
{
Engine.ConfigUI.ConfigProxy.ProxyList.Add(ui.Proxy);
Engine.ConfigUI.ConfigProxy.ProxyConfigType = EProxyConfigType.ManualProxy;
Uploader.ProxySettings = Adapter.CheckProxySettings();
}
RetryTask(task);
}
WorkerTask checkTask = RetryUpload(task);
if (checkTask.States.Contains(WorkerTask.TaskState.RetryPending))
{
string message = string.Format("{0}\r\n\r\nAutomatically retrying upload for {1}.", string.Join("\r\n", task.Errors.ToArray()), checkTask.WorkflowConfig.DestConfig.ToStringImageUploaders());
niTray.ShowBalloonTip(5000, Application.ProductName, message, ToolTipIcon.Warning);
}
else
{
task.States.Add(WorkerTask.TaskState.Finished);
if (task.WorkflowConfig.DestConfig.TaskClipboardContent.Contains(ClipboardContentEnum.Local) && Engine.ConfigUI.ShowSaveFileDialogImages)
{
string fp = task.WriteImageAs();
if (!string.IsNullOrEmpty(fp))
{
task.UpdateLocalFilePath(fp);
}
}
switch (task.Job1)
{
case EDataType.Text:
if (task.Job2 == WorkerTask.JobLevel2.Translate)
{
UpdateGoogleTranslateGUI(task.TranslationInfo);
Loader.MyGTGUI.btnTranslate.Enabled = true;
Loader.MyGTGUI.btnTranslateTo.Enabled = true;
}
break;
case EDataType.Image:
if (!task.WorkflowConfig.DestConfig.TaskClipboardContent.Contains(ClipboardContentEnum.Local) && Engine.ConfigOptions.DeleteLocal && File.Exists(task.Info.LocalFilePath))
{
try
{
File.Delete(task.Info.LocalFilePath);
}
catch (Exception ex) // TODO: sometimes file is still locked... delete those files sometime
{
DebugHelper.WriteException(ex, "Error while finalizing job");
}
}
break;
}
if (Engine.ConfigOptions.TwitterEnabled)
{
Adapter.TwitterMsg(task);
}
bool bLastSourceButtonsEnabled = task.UploadResults.Count > 0 && !string.IsNullOrEmpty(task.UploadResults[task.UploadResults.Count - 1].Source);
this.btnOpenSourceText.Enabled = bLastSourceButtonsEnabled;
this.btnOpenSourceBrowser.Enabled = bLastSourceButtonsEnabled;
this.btnOpenSourceString.Enabled = bLastSourceButtonsEnabled;
if (task.UploadResults.Count > 0 || File.Exists(task.Info.LocalFilePath) || task.Job2 == WorkerTask.JobLevel2.Translate)
{
if (Engine.ConfigOptions.CompleteSound)
{
if (Engine.ConfigWorkflow.EnableSoundTaskCompleted && !string.IsNullOrEmpty(Engine.ConfigWorkflow.SoundPath) && File.Exists(Engine.ConfigWorkflow.SoundPath))
{
new SoundPlayer(Engine.ConfigWorkflow.SoundPath).Play();
}
else
{
SystemSounds.Exclamation.Play();
}
}
if (Engine.ConfigOptions.ShowBalloonTip)
{
ShowBalloonTip(task);
}
}
if (task.IsError)
{
foreach (string error in task.Errors)
{
DebugHelper.WriteLine(error);
}
niTray.ShowBalloonTip(5000, Application.ProductName, niTray.BalloonTipText + Environment.NewLine + task.Errors[task.Errors.Count - 1], ToolTipIcon.Error);
}
}
if (!task.IsError)
{
AddHistoryItem(task);
}
// do this last
UploadManager.ShowUploadResults(task, false);
}
catch (Exception ex)
{
DebugHelper.WriteException(ex, "Job Completed with errors: ");
}
finally
{
UploadManager.Commit(task.Id);
if (TaskbarManager.IsPlatformSupported)
{
Adapter.TaskbarSetProgressState(this, TaskbarProgressBarState.NoProgress);
}
}
DebugHelper.WriteLine(string.Format("Job completed: {0}", task.Job2));
DebugHelper.WriteLine(string.Format("Task duration: {0} ms", task.UploadDuration));
PostWorkerTasks();
}
public override void CaptureActiveMonitor()
{
WorkerTask hkesTask = CreateTask(WorkerTask.JobLevel2.CaptureActiveMonitor);
RunWorkerAsync(hkesTask);
}
/// <summary>
/// Start the background operation.
/// </summary>
/// <exception cref="InvalidOperationException">When <see cref="IsBusy"/> is true.</exception>
public void RunWorkerAsync()
{
if (IsBusy)
throw new InvalidOperationException();
task = new WorkerTask(this, null);
}
private static void task_UploadCompleted(WorkerTask task)
{
try
{
if (ListViewControl != null && task != null && task.Result != null)
{
ListViewItem lvi = ListViewControl.Items[task.Id];
lvi.Tag = task.Result;
if (task.Result.IsError)
{
string errors = string.Join("\r\n\r\n", task.Result.Errors.ToArray());
DebugHelper.WriteLine("Upload failed. ID: {0}, Filename: {1}, Errors:\r\n{2}", task.Id, task.Info.FileName, errors);
lvi.SubItems[1].Text = "Error";
lvi.SubItems[8].Text = string.Empty;
lvi.ImageIndex = 1;
if (Engine.ConfigOptions.CompleteSound)
{
SystemSounds.Asterisk.Play();
}
}
else
{
DebugHelper.WriteLine("Upload completed. ID: {0}, Filename: {1}, URL: {2}, Duration: {3}ms", task.Id, task.Info.FileName,
task.Result.URL, (int)task.UploadDuration);
lvi.SubItems[1].Text = task.Status.GetDescription();
lvi.ImageIndex = 2;
if (!string.IsNullOrEmpty(task.Result.URL))
{
string url = string.IsNullOrEmpty(task.Result.ShortenedURL) ? task.Result.URL : task.Result.ShortenedURL;
lvi.SubItems[8].Text = url;
if (Engine.ConfigWorkflow.ClipboardOverwrite)
{
ZAppHelper.CopyTextSafely(url);
}
if (Engine.ConfigOptions.HistorySave)
{
HistoryManager.AddHistoryItemAsync(Engine.HistoryPath, task.GenerateHistoryItem());
}
}
if (Engine.ConfigOptions.CompleteSound)
{
SystemSounds.Exclamation.Play();
}
}
lvi.EnsureVisible();
}
}
finally
{
StartTasks();
// UpdateTrayIcon();
}
}
protected override void OnNewWorkerTask(WorkerTask workerTask, bool firstCreation)
{
workerTask.Updater.RefreshRate = 1;
workerTask.SynchronizationType = EudiSynchronizationType.TrueMultiThreading;
}
internal void OnDone()
{
task = null;
}
/// <summary>
/// Sets Clipboard text and returns the content
/// </summary>
/// <returns></returns>
public static string SetClipboardText(WorkerTask task, bool showDialog)
{
string clipboardText = "";
switch (task.JobCategory)
{
case JobCategoryType.PICTURES:
case JobCategoryType.SCREENSHOTS:
case JobCategoryType.BINARY:
ScreenshotsHistory = task.LinkManager;
if (GraphicsMgr.IsValidImage(task.LocalFilePath))
{
if (Engine.conf.ShowClipboardModeChooser || showDialog)
{
ClipboardOptions cmp = new ClipboardOptions(task);
cmp.Icon = Resources.zss_main;
if (showDialog)
{
cmp.ShowDialog();
}
else
{
cmp.Show();
}
}
if (task.MyImageUploader == ImageDestType.FILE)
{
clipboardText = task.LocalFilePath;
}
else
{
clipboardText = ScreenshotsHistory.GetUrlByType(Engine.conf.ClipboardUriMode).ToString().Trim();
if (task.MakeTinyURL)
{
string tinyUrl = ScreenshotsHistory.GetUrlByType(ClipboardUriType.FULL_TINYURL);
if (!string.IsNullOrEmpty(tinyUrl))
{
clipboardText = tinyUrl.Trim();
}
}
}
}
break;
case JobCategoryType.TEXT:
switch (task.Job)
{
case WorkerTask.Jobs.LANGUAGE_TRANSLATOR:
if (null != task.TranslationInfo)
{
clipboardText = task.TranslationInfo.Result.TranslatedText;
}
break;
default:
if (!string.IsNullOrEmpty(task.RemoteFilePath))
{
clipboardText = task.RemoteFilePath;
}
else if (null != task.MyText)
{
clipboardText = task.MyText.LocalString;
}
else
{
clipboardText = task.LocalFilePath;
}
break;
}
break;
}
// after all this the clipboard text can be null
if (!string.IsNullOrEmpty(clipboardText))
{
Engine.ClipboardUnhook();
FileSystem.AppendDebug("Setting Clipboard with URL: " + clipboardText);
Clipboard.SetText(clipboardText);
// optional deletion link
string linkdel = ScreenshotsHistory.GetDeletionLink();
if (!string.IsNullOrEmpty(linkdel))
{
FileSystem.AppendDebug("Deletion Link: " + linkdel);
}
Engine.zClipboardText = clipboardText;
Engine.ClipboardHook();
}
return(clipboardText);
}
public TaskManager(WorkerTask task)
{
this.mTask = task;
}
/// <summary>
/// Sets Clipboard text and returns the content
/// </summary>
/// <returns></returns>
public static void ShowUploadResults(WorkerTask task, bool showDialog)
{
if (!task.WorkflowConfig.ClipboardOverwrite && !Clipboard.ContainsFileDropList() && !Clipboard.ContainsImage() && !Clipboard.ContainsText() || task.WorkflowConfig.ClipboardOverwrite)
{
if (task.UploadResults.Count > 0)
{
if (task.WorkflowConfig.DestConfig.TaskClipboardContent.Count > 1 || Engine.ConfigUI.ShowUploadResultsWindow || showDialog)
{
ClipboardOptions cmp = new ClipboardOptions(task);
cmp.Icon = Resources.zss_main;
if (showDialog)
{
cmp.ShowDialog();
}
else
{
NativeMethods.ShowWindow(cmp.Handle, (int)WindowShowStyle.ShowNoActivate);
}
showDialog = true;
}
}
if (task.WorkflowConfig.DestConfig.Outputs.Contains(OutputEnum.Clipboard))
{
StringBuilder clipboardText = new StringBuilder();
if (task.JobIsImageToClipboard())
{
Adapter.CopyImageToClipboard(task.TempImage, task.WorkflowConfig.ClipboardForceBmp);
}
else if (task.WorkflowConfig.DestConfig.TaskClipboardContent.Contains(ClipboardContentEnum.Local))
{
foreach (UploadResult ur in task.UploadResults)
{
if (Engine.ConfigUI.ConfLinkFormat.Count > 0)
{
clipboardText.AppendLine(ur.GetUrlByType((LinkFormatEnum)task.WorkflowConfig.DestConfig.LinkFormat[0], ur.LocalFilePath));
}
if (!Engine.ConfigUI.ClipboardAppendMultipleLinks && clipboardText.Length > 0)
{
break;
}
}
}
else if (task.WorkflowConfig.DestConfig.TaskClipboardContent.Contains(ClipboardContentEnum.OCR))
{
if (!string.IsNullOrEmpty(task.OCRText))
{
clipboardText.Append(task.OCRText);
}
}
// If the user requests for the full image URL, preference is given for the Shortened URL is exists
else if (task.Job1 == EDataType.Image && task.WorkflowConfig.DestConfig.LinkFormat.Contains((int)LinkFormatEnum.FULL))
{
if (task.Job3 == WorkerTask.JobLevel3.ShortenURL && !string.IsNullOrEmpty(task.UploadResults[0].ShortenedURL))
{
foreach (UploadResult ur in task.UploadResults)
{
if (!string.IsNullOrEmpty(ur.ShortenedURL))
{
clipboardText.AppendLine(ur.ShortenedURL);
if (!Engine.ConfigUI.ClipboardAppendMultipleLinks && clipboardText.Length > 0)
{
break;
}
}
}
}
// If no shortened URL exists then default full URL will be used
else
{
foreach (UploadResult ur in task.UploadResults)
{
if (!string.IsNullOrEmpty(ur.URL))
{
clipboardText.AppendLine(FileSystem.GetBrowserFriendlyUrl(ur.URL));
if (!Engine.ConfigUI.ClipboardAppendMultipleLinks && clipboardText.Length > 0)
{
break;
}
}
}
if (clipboardText.Length == 0 && task.WorkflowConfig.DestConfig.TaskClipboardContent.Contains(ClipboardContentEnum.Local))
{
foreach (UploadResult ur in task.UploadResults)
{
if (!string.IsNullOrEmpty(ur.LocalFilePath))
{
clipboardText.AppendLine(ur.LocalFilePath);
if (!Engine.ConfigUI.ClipboardAppendMultipleLinks && clipboardText.Length > 0)
{
break;
}
}
}
}
}
}
else
{
// From this point onwards app needs to respect all other Clipboard URL modes for Images
if (task.UploadResults.Count > 0 && task.Job1 == EDataType.Image)
{
foreach (UploadResult ur in task.UploadResults)
{
if (task.WorkflowConfig.DestConfig.LinkFormat.Count > 0)
{
clipboardText.AppendLine(ur.GetUrlByType((LinkFormatEnum)task.WorkflowConfig.DestConfig.LinkFormat[0], ur.URL));
}
if (!Engine.ConfigUI.ClipboardAppendMultipleLinks && clipboardText.Length > 0)
{
break;
}
}
}
// Text and File catagories are still left to process. Exception for Google Translate
else if (task.Job1 == EDataType.Text && task.Job2 == WorkerTask.JobLevel2.Translate)
{
if (task.TranslationInfo != null)
{
clipboardText.AppendLine(task.TranslationInfo.Result);
}
}
// Text and File catagories are still left to process. If shortened URL exists, preference is given to that
else if (task.UploadResults.Count > 0 && task.Job3 == WorkerTask.JobLevel3.ShortenURL && !string.IsNullOrEmpty(task.UploadResults[0].ShortenedURL))
{
foreach (UploadResult ur in task.UploadResults)
{
if (!string.IsNullOrEmpty(ur.ShortenedURL))
{
clipboardText.AppendLine(ur.ShortenedURL);
break;
}
}
}
// Otherwise full URL for Text or File is used
else if (task.UploadResults.Count > 0)
{
clipboardText.AppendLine(FileSystem.GetBrowserFriendlyUrl(task.UploadResults[0].URL));
}
}
if (clipboardText.Length > 0)
{
bool bClipboardFormatOnLongUrl = Engine.ConfigUI.EnableClipboardFormatForLongURLs && task.Job1 == EDataType.URL;
bool bClipboardFormat = bClipboardFormatOnLongUrl || task.Job1 != EDataType.URL;
var np = new NameParser(NameParserType.Clipboard)
{
Link = clipboardText.ToString().Trim(),
FileSize = task.Info.FileSize,
FileName = task.Info.FileName
};
if (bClipboardFormat)
{
np.WindowText = task.Info.WindowTitleText;
}
string tempText = bClipboardFormat ? np.Convert(Engine.ConfigUI.ClipboardFormat) : clipboardText.ToString().Trim();
if (!string.IsNullOrEmpty(tempText))
{
DebugHelper.WriteLine("Setting Clipboard with URL: " + tempText);
Clipboard.SetText(tempText); // auto
Engine.zPreviousSetClipboardText = tempText;
Engine.IsClipboardUploading = false;
// optional deletion link
if (task.UploadResults != null)
{
foreach (UploadResult ur in task.UploadResults)
{
string linkdel = ur.DeletionURL;
if (!string.IsNullOrEmpty(linkdel))
{
DebugHelper.WriteLine("Deletion Link: " + linkdel);
}
}
}
}
}
}
if (!showDialog)
{
task.Dispose();
}
}
}
/// <summary>
/// Start the background operation.
/// </summary>
/// <exception cref="InvalidOperationException">When <see cref="IsBusy"/> is true.</exception>
public void RunWorkerAsync(object argument)
{
if (IsBusy)
throw new InvalidOperationException();
task = new WorkerTask(this, argument);
}
public string ShowBalloonTip(WorkerTask task)
{
StringBuilder sbMsg = new StringBuilder();
ToolTipIcon tti = ToolTipIcon.Info;
if (task.Job2 == WorkerTask.JobLevel2.Translate)
{
sbMsg.AppendLine(task.TranslationInfo.SourceLanguage + " -> " + task.TranslationInfo.TargetLanguage);
sbMsg.AppendLine("Text: " + task.TranslationInfo.Text);
sbMsg.AppendLine("Result: " + task.TranslationInfo.Result);
}
else
{
sbMsg.AppendLine("Name: " + task.GetDescription());
switch (task.Job1)
{
case EDataType.Text:
string dest = string.Empty;
switch (task.Job3)
{
case WorkerTask.JobLevel3.ShortenURL:
dest = task.WorkflowConfig.DestConfig.ToStringLinkUploaders();
break;
default:
dest = task.WorkflowConfig.DestConfig.ToStringTextUploaders();
break;
}
sbMsg.AppendLine(string.Format("Destination: {0}", dest));
break;
default:
sbMsg.Append("Outputs: ");
sbMsg.AppendLine(task.WorkflowConfig.DestConfig.ToStringOutputs());
break;
}
foreach (UploadResult ur in task.UploadResults)
{
if (!string.IsNullOrEmpty(ur.URL))
{
sbMsg.AppendLine(ur.URL);
break;
}
}
if (task.UploadResults.Count == 0 && task.IsError)
{
tti = ToolTipIcon.Warning;
sbMsg.AppendLine("Warnings: ");
foreach (string err in task.Errors)
{
sbMsg.AppendLine(err);
}
}
if (Engine.ConfigOptions.ShowUploadDuration && task.UploadDuration > 0)
{
sbMsg.AppendLine("Upload duration: " + task.UploadDuration + " ms");
}
}
string message = sbMsg.ToString();
if (!string.IsNullOrEmpty(message))
{
niTray.ShowBalloonTip(1000, Application.ProductName, message, tti);
}
return(message);
}
private async Task ExecuteNextTask(IServiceProvider scopedServiceProvider)
{
var workerTasksData = scopedServiceProvider.GetService <IWorkerTasksDataService>();
WorkerTask workerTask;
try
{
workerTask = workerTasksData.GetForProcessing();
}
catch (Exception ex)
{
this.logger.LogCritical($"Unable to get task for processing. Error: {ex}");
await Task.Delay(WaitTimeOnErrorInSeconds * 1000);
return;
}
if (workerTask == null)
{
// No task available.
return;
}
if (!TasksIds.TryAdd(workerTask.Id, true))
{
// Other thread is processing the same task.
return;
}
try
{
workerTask.Processing = true;
await workerTasksData.UpdateAsync(workerTask);
}
catch (Exception ex)
{
TasksIds.TryRemove(workerTask.Id, out _);
this.logger.LogError($"Unable to set workerTask.{nameof(WorkerTask.Processing)} to true! Error: {ex}");
await Task.Delay(WaitTimeOnErrorInSeconds * 1000);
return;
}
this.logger.LogInformation($"Task #{workerTask.Id} started with parameters: {workerTask.Parameters}");
ITask task = null;
try
{
task = this.GetTaskInstance(workerTask.TypeName, scopedServiceProvider);
}
catch (Exception ex)
{
this.logger.LogError($"Exception in {nameof(this.GetTaskInstance)} on task #{workerTask.Id}: {ex}");
workerTask.ProcessingComment = $"Error in {nameof(this.GetTaskInstance)}: {ex}";
}
if (task == null)
{
try
{
workerTask.Processed = true;
workerTask.Processing = false;
await workerTasksData.UpdateAsync(workerTask);
TasksIds.TryRemove(workerTask.Id, out _);
}
catch (Exception ex)
{
this.logger.LogError($"Unable to save final changes on task #{workerTask.Id}! Error: {ex}");
await Task.Delay(WaitTimeOnErrorInSeconds * 1000);
}
return;
}
// Call DoWork()
string result = null;
var doWorkStopwatch = Stopwatch.StartNew();
try
{
result = await task.DoWork(workerTask.Parameters);
doWorkStopwatch.Stop();
this.logger.LogInformation(
$"Task #{workerTask.Id} completed in {doWorkStopwatch.Elapsed} ({DateTime.UtcNow}) with result: {result}");
}
catch (Exception ex)
{
this.logger.LogError($"Error in {nameof(ITask.DoWork)} on task #{workerTask.Id}: {ex}");
workerTask.ProcessingComment = $"Error in {nameof(ITask.DoWork)}: {ex}";
}
// Call Recreate()
WorkerTask nextTask = null;
try
{
nextTask = task.Recreate(workerTask);
}
catch (Exception ex)
{
this.logger.LogError($"Error in {nameof(ITask.Recreate)} on task #{workerTask.Id}: {ex}");
workerTask.ProcessingComment += $"Error in {nameof(ITask.Recreate)}: {ex}";
}
// Save result
try
{
workerTask.Result = result;
workerTask.Duration = doWorkStopwatch.Elapsed.TotalDays >= 1.0
? new TimeSpan(0, 23, 59, 59)
: doWorkStopwatch.Elapsed;
workerTask.Processed = true;
workerTask.Processing = false;
await workerTasksData.UpdateAsync(workerTask);
TasksIds.TryRemove(workerTask.Id, out _);
}
catch (Exception ex)
{
this.logger.LogError($"Unable to save result on task #{workerTask.Id}! Error: {ex}");
await Task.Delay(WaitTimeOnErrorInSeconds * 1000);
return;
}
// Save the new task
if (nextTask != null)
{
try
{
await workerTasksData.AddAsync(nextTask);
}
catch (Exception ex)
{
this.logger.LogError($"Unable to recreate task #{workerTask.Id}! Error: {ex}");
await Task.Delay(WaitTimeOnErrorInSeconds * 1000);
}
}
}
public async Task CreatedTask(string message)
{
var createdTask = JsonConvert.DeserializeObject <TaskCreation>(message);
using (var applicationDbContext = ApplicationDbContext.FromConnectionString(_config))
{
var username = Context.User.FindFirstValue(ClaimTypes.NameIdentifier);
var user = await applicationDbContext.Users.Where(x => x.NormalizedEmail == username.ToUpper())
.Select(x => new { x.Id, x.Credits })
.FirstOrDefaultAsync();
if (user.Credits <= 0)
{
var error = new CannotCreateTask
{
Reason = "Insufficient credits."
};
await Clients.Caller.SendAsync("CannotCreateTask", JsonConvert.SerializeObject(error));
return;
}
var userId = user.Id;
var dbRequestorTask = new RequestorTask
{
RequestorId = userId,
WasmB64 = createdTask.WasmB64,
WorkerTasks = new List <WorkerTask>()
};
#if DEBUG
var allConnections = await applicationDbContext.Workers
.Where(x => x.ConnexionId != null)
.OrderBy(x => Guid.NewGuid())
.ToDictionaryAsync(x => x.ConnexionId, x => new { WorkerId = x.Id, x.UserId });
#else
var allConnections = await applicationDbContext.Workers
.Where(x => x.ConnexionId != null && x.UserId != userId)
.OrderBy(x => Guid.NewGuid())
.ToDictionaryAsync(x => x.ConnexionId, x => new { WorkerId = x.Id, x.UserId });
#endif
var i = 0;
Dictionary <string, string> tasksToSend = new Dictionary <string, string>();
foreach (var conn in allConnections)
{
var workerTask = new WorkerTask
{
Parameter = i,
ProviderId = conn.Value.UserId,
WorkerId = conn.Value.WorkerId
};
dbRequestorTask.WorkerTasks.Add(workerTask);
var response = new ReceivedTask
{
Parameter = i,
WasmB64 = createdTask.WasmB64,
TaskId = workerTask.Id,
SubTaskTimeout = 3600000
};
tasksToSend.Add(conn.Key, JsonConvert.SerializeObject(response));
i++;
if (i == createdTask.NumberOfNodes)
{
break;
}
}
if (tasksToSend.Count < createdTask.NumberOfNodes)
{
var error = new CannotCreateTask
{
Reason = "Not enough nodes."
};
await Clients.Caller.SendAsync("CannotCreateTask", JsonConvert.SerializeObject(error));
return;
}
applicationDbContext.RequestorTasks.Add(dbRequestorTask);
await applicationDbContext.SaveChangesAsync();
foreach (var task in tasksToSend)
{
await Clients.Client(task.Key).SendAsync("NewTask", task.Value);
}
await SendNewStatisicsInternal(username.ToUpper(), true);
}
}
internal void OnDone()
{
task = null;
}
private static void Main(string[] args)
{
string dirImages = string.Empty;
string dirRoot = string.Empty;
string mSettingsFilePath = string.Empty;
string dirTorrents = string.Empty;
bool mFileCollection = false;
bool mShowHelp = false;
var p = new OptionSet()
{
{ "c", "Treat multiple files as a collection", v => mFileCollection = v != null },
{ "m|media=", "Location of the media file/folder", v => mMediaLoc = v },
{ "o|options=", "Location of the settings file", v => mSettingsFilePath = v },
{ "rd=", "Root directory for screenshots, torrent and all other output files. Overrides all other custom folders.", v => dirRoot = v },
{ "s", "Create screenshots", v => mScreenshotsCreate = v != null },
{ "sd=", "Create screenshots in a custom folder and upload", v => dirImages = v },
{ "t", "Create torrent file in the parent folder of the media file", v => mTorrentCreate = v != null },
{ "td=", "Create torrent file in a custom folder", v => dirTorrents = v },
{ "u", "Upload screenshots", v => mScreenshotsUpload = v != null },
{ "x|xml", "Folder path of the XML torrent description file", v => mXmlCreate = v != null },
{ "h|help", "Show this message and exit", v => mShowHelp = v != null }
};
if (args.Length == 0)
{
mShowHelp = true;
}
// give cli the ability to replace environment variables
string[] args2 = new string[args.Length];
int count = 0;
foreach (string arg in args)
{
args2[count++] = arg.Replace("%appdata%", Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData));
}
try
{
p.Parse(args2);
// set root folder for images or set images dir if set one
mScreenshotDir = Directory.Exists(dirRoot) ? dirRoot : dirImages;
// set root folder for torrents or set torrents dir if set one
mTorrentsDir = Directory.Exists(dirRoot) ? dirRoot : dirTorrents;
}
catch (Exception ex)
{
Console.Write("tdmakercli: ");
Console.WriteLine(ex.Message);
Console.WriteLine("Try 'tdmakercli --help' for more information.");
return;
}
if (mShowHelp)
{
ShowHelp(p);
return;
}
if (!File.Exists(mSettingsFilePath))
{
mSettingsFilePath = App.SettingsFilePath;
}
if (File.Exists(mSettingsFilePath))
{
App.Settings = Settings.Load(mSettingsFilePath);
App.UploadersConfig = UploadersConfig.Load(App.UploadersConfigPath);
}
if (App.Settings != null)
{
App.InitializeDefaultFolderPaths();
List <string> listFileOrDir = new List <string>()
{
mMediaLoc
};
MediaWizardOptions mwo = Adapter.GetMediaType(listFileOrDir, true);
if (mwo.MediaTypeChoice == MediaType.MediaIndiv && mFileCollection)
{
mwo.MediaTypeChoice = MediaType.MediaCollection;
}
TaskSettings ts = new TaskSettings();
ts.MediaOptions.CreateScreenshots = mScreenshotsCreate;
ts.MediaOptions.UploadScreenshots = mScreenshotsUpload;
WorkerTask task = new WorkerTask(ts);
MediaInfo2 mi = new MediaInfo2(mwo, mMediaLoc);
mi.ReadMedia();
if (mScreenshotsUpload)
{
TakeScreenshots(task);
task.UploadScreenshots();
}
else if (mScreenshotsCreate)
{
TakeScreenshots(task);
}
// CreatePublish(ti);
// CreateTorrent(ti);
}
}
public override void CaptureEntireScreen()
{
WorkerTask hkesTask = CreateTask(WorkerTask.JobLevel2.CaptureEntireScreen);
RunWorkerAsync(hkesTask);
}
private void AnalyzeMedia(List <string> files)
{
if (!ValidateInput())
{
return;
}
DialogResult dlgResult = DialogResult.OK;
List <TaskSettings> taskSettingsList = new List <TaskSettings>();
MediaWizardOptions mo = Adapter.GetMediaType(files);
if (mo.ShowWizard)
{
ShowMediaWizard(ref mo, files);
}
if (mo.PromptShown)
{
dlgResult = mo.DialogResult;
}
else
{
// fill previous settings
mo.CreateTorrent = App.Settings.ProfileActive.CreateTorrent;
mo.CreateScreenshots = App.Settings.ProfileActive.CreateScreenshots;
mo.UploadScreenshots = App.Settings.ProfileActive.UploadScreenshots;
}
if (!mo.PromptShown && App.Settings.ShowMediaWizardAlways)
{
MediaWizard mw = new MediaWizard(files);
dlgResult = mw.ShowDialog();
if (dlgResult == DialogResult.OK)
{
mo = mw.Options;
}
}
if (dlgResult == DialogResult.OK)
{
if (mo.MediaTypeChoice == MediaType.MediaCollection)
{
TaskSettings ts = new TaskSettings();
ts.MediaOptions = mo;
files.Sort();
string firstPath = files[0];
PrepareNewMedia(ts, File.Exists(firstPath) ? Path.GetDirectoryName(files[0]) : firstPath);
foreach (string p in files)
{
if (File.Exists(p))
{
ts.Media.FileCollection.Add(p);
}
}
taskSettingsList.Add(ts);
}
else
{
foreach (string fd in files)
{
if (File.Exists(fd) || Directory.Exists(fd))
{
TaskSettings ts = new TaskSettings();
ts.MediaOptions = mo;
PrepareNewMedia(ts, fd);
ts.Media.DiscType = MediaHelper.GetSourceType(fd);
if (ts.Media.DiscType == SourceType.Bluray)
{
ts.Media.Overall = new MediaFile(FileSystemHelper.GetLargestFilePathFromDir(fd), cboSource.Text);
ts.Media.Overall.Summary = BDInfo(fd);
}
if (!string.IsNullOrEmpty(txtTitle.Text))
{
ts.Media.SetTitle(txtTitle.Text);
}
taskSettingsList.Add(ts);
}
}
}
foreach (TaskSettings ts in taskSettingsList)
{
WorkerTask task = WorkerTask.CreateTask(ts);
task.UploadProgressChanged += Task_UploadProgressChanged;
task.MediaLoaded += Task_MediaLoaded;
task.StatusChanged += Task_StatusChanged;
task.ScreenshotUploaded += Task_ScreenshotUploaded;
task.TorrentInfoCreated += Task_TorrentInfoCreated;
task.TorrentProgressChanged += Task_TorrentProgressChanged;
task.TaskCompleted += Task_TaskCompleted;
TaskManager.Start(task);
}
UpdateGuiControls();
pBar.Value = 0;
}
}
public override void CaptureSelectedWindow()
{
WorkerTask hkswTask = CreateTask(WorkerTask.JobLevel2.CaptureSelectedWindow);
RunWorkerAsync(hkswTask);
}
private void Task_TorrentProgressChanged(WorkerTask task)
{
pBar.Value = (int)task.Info.TorrentProgress;
}
public override void CaptureRectRegionLast()
{
WorkerTask hkrclTask = CreateTask(WorkerTask.JobLevel2.CaptureLastCroppedWindow);
RunWorkerAsync(hkrclTask);
}
private void Task_UploadProgressChanged(WorkerTask task)
{
pBar.Value = TaskManager.GetAverageProgress();
}
public bool UploadUsingFileSystem(params string[] fileList)
{
List <string> strListFilePath = new List <string>();
bool succ = true;
foreach (string fp in fileList)
{
try
{
if (!string.IsNullOrEmpty(fp) && File.Exists(fp))
{
if (HelpersLib.GraphicsHelper.Core.IsValidImage(fp))
{
string dirfp = Path.GetDirectoryName(fp);
string fsfp = FileSystem.GetUniqueFilePath(Engine.ConfigWorkflow, Engine.ImagesDir, Path.GetFileName(fp));
if (fp != fsfp && dirfp != Engine.ImagesDir)
{
string dir = Path.GetDirectoryName(fsfp);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
try
{
File.Copy(fp, fsfp, true);
if (Path.GetDirectoryName(fp) == Engine.ConfigUI.FolderMonitorPath)
{
File.Delete(fp);
}
}
catch (Exception e)
{
fsfp = fp;
DebugHelper.WriteException(e);
}
strListFilePath.Add(fsfp);
}
else
{
strListFilePath.Add(fp);
}
}
else
{
strListFilePath.Add(fp); // yes we use the orignal file path
}
}
}
catch (Exception ex)
{
DebugHelper.WriteException(ex, "Error while uploading using file system");
succ = false;
}
}
strListFilePath.Sort();
List <Image> tempImages = new List <Image>();
bool bCreateAni = strListFilePath.Count > 1 && strListFilePath.Count < Engine.ConfigWorkflow.ImageAnimatedFramesMax && HelpersLib.GraphicsHelper.Core.HasIdenticalImages(strListFilePath, out tempImages);
if (bCreateAni)
{
WorkerTask agifTask = CreateTask(WorkerTask.JobLevel2.UploadFromExplorer);
agifTask.SetImages(tempImages);
agifTask.RunWorker();
}
else
{
foreach (string fp in strListFilePath)
{
var tifs = new TaskInfo()
{
ExistingFilePath = fp
};
var fpdataTask = CreateTask(WorkerTask.JobLevel2.UploadFromExplorer, tifs);
fpdataTask.UpdateLocalFilePath(fp);
fpdataTask.RunWorker();
}
}
return(succ);
}
private void Task_StatusChanged(WorkerTask task)
{
sBar.Text = task.Info.Status;
}
public override void BwApp_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
switch ((WorkerTask.ProgressType)e.ProgressPercentage)
{
case WorkerTask.ProgressType.PrintImage:
Adapter.PrintImage(e.UserState as Image);
break;
case WorkerTask.ProgressType.PrintText:
Adapter.PrintText(e.UserState as string);
break;
case (WorkerTask.ProgressType) 102:
throw new Exception("Unsupported progress");
case (WorkerTask.ProgressType) 103:
throw new Exception("Unsupported progress");
case (WorkerTask.ProgressType) 104:
Adapter.CopyDataToClipboard(e.UserState);
break;
case WorkerTask.ProgressType.CopyToClipboardImage:
if (e.UserState.GetType() == typeof(string))
{
Adapter.CopyImageToClipboard(e.UserState as string);
}
else if (e.UserState is Image)
{
Adapter.CopyImageToClipboard((Image)e.UserState, false);
}
break;
case WorkerTask.ProgressType.FlashIcon:
Adapter.FlashNotifyIcon(this.niTray, e.UserState as Icon);
break;
case WorkerTask.ProgressType.UpdateCropMode:
this.cboCropGridMode.Checked = Engine.ConfigUI.CropGridToggle;
break;
case WorkerTask.ProgressType.ChangeTrayIconProgress:
UploadManager.SetCumulativePercentatge((int)((ProgressManager)e.UserState).Percentage);
Adapter.UpdateNotifyIconProgress(this.niTray, UploadManager.CumulativePercentage);
Adapter.TaskbarSetProgressValue(this, UploadManager.CumulativePercentage);
this.Text = string.Format("{0}% - {1}", UploadManager.CumulativePercentage, Engine.GetProductName());
break;
case WorkerTask.ProgressType.UpdateProgressMax:
TaskbarProgressBarState tbps = (TaskbarProgressBarState)e.UserState;
Adapter.TaskbarSetProgressState(this, tbps);
break;
case WorkerTask.ProgressType.ShowBalloonTip:
WorkerTask task = e.UserState as WorkerTask;
if (Engine.ConfigOptions.ShowBalloonTip)
{
ShowBalloonTip(task);
}
break;
case WorkerTask.ProgressType.ShowTrayWarning:
Adapter.TaskbarSetProgressValue(this, 33);
Adapter.TaskbarSetProgressState(this, TaskbarProgressBarState.Error);
Adapter.SetNotifyIconBalloonTip(this.niTray, this.Text, e.UserState as string, ToolTipIcon.Warning);
break;
}
rtbDebugLog.Text = Engine.EngineLogger.ToString();
}
public void ParallelForEachExceptionTest()
{
ExceptionCollector ec = new ExceptionCollector();
AsyncQueue <int> q1 = new AsyncQueue <int>(5);
Func <Task> t1 = async delegate()
{
for (int i = 0; i < 100; ++i)
{
await q1.Enqueue(i, ec.CancellationToken);
}
q1.WriteEof();
};
AsyncQueue <int> q2 = new AsyncQueue <int>(5);
Func <Task> t2 = WorkerTask.ForEach
(
q1,
async delegate(ForEachInfo <int> fi)
{
await q2.Enqueue(fi.Item * 100, fi.CancellationToken);
if (fi.Item == 53)
{
throw new InvalidOperationException("test 1");
}
},
delegate()
{
q2.WriteEof();
return(Task.CompletedTask);
},
ec
);
List <int> items = new List <int>();
Func <Task> t3 = WorkerTask.ForEach
(
q2,
delegate(ForEachInfo <int> fi)
{
items.Add(fi.Item);
return(Task.CompletedTask);
},
delegate()
{
return(Task.CompletedTask);
},
ec
);
Task T1 = Task.Run(t1);
Task T2 = Task.Run(t2);
Task T3 = Task.Run(t3);
bool threwException = false;
try
{
ec.WaitAll(T1, T2, T3);
}
catch (Exception exc)
{
System.Diagnostics.Debug.WriteLine(exc);
threwException = true;
}
Assert.IsTrue(threwException);
}
public void CalculationBegin(WorkerTask task)
{
_free = false;
_thread = new Thread(() => ExecuteInThread(task));
_thread.Start();
}
public void ParallelMultiSourceForEachTest()
{
object rSyncRoot = new object();
Random r = new Random((int)((System.Diagnostics.Stopwatch.GetTimestamp() >> 3) & 0x7FFFFFFF));
ExceptionCollector ec = new ExceptionCollector();
AsyncQueue <int> q1 = new AsyncQueue <int>(5);
Func <Task> t1 = async delegate()
{
for (int i = 0; i < 100; ++i)
{
await q1.Enqueue(i, ec.CancellationToken);
}
q1.WriteEof();
};
AsyncQueue <int> q2 = new AsyncQueue <int>(5);
Func <Task> t2 = async delegate()
{
for (int i = 100; i < 200; ++i)
{
await q2.Enqueue(i, ec.CancellationToken);
}
q2.WriteEof();
};
AsyncQueue <int> q3 = new AsyncQueue <int>(5);
ParallelWorker pw = new ParallelWorker(8);
Func <Task> t3 = WorkerTask.ParallelForEach
(
new IQueueSource <int>[] { q1, q2 },
InputPriorities.RoundRobin,
pw,
async fei =>
{
await q3.Enqueue(fei.Item, fei.CancellationToken);
int time;
lock (rSyncRoot)
{
time = 100 + r.Next(800);
}
await Task.Delay(time);
},
() =>
{
q3.WriteEof();
return(Task.CompletedTask);
},
ec
);
Func <Task> t4 = WorkerTask.ForEach
(
q3,
fei =>
{
System.Diagnostics.Debug.WriteLine(fei.Item);
return(Task.CompletedTask);
},
null,
ec
);
Task T1 = Task.Run(t1);
Task T2 = Task.Run(t2);
Task T3 = Task.Run(t3);
Task T4 = Task.Run(t4);
ec.WaitAll(T1, T2, T3, T4);
}
protected override WorkerTask Recreate(WorkerTask currentTask, Input currentParameters, Output currentResult) => new WorkerTask(currentTask, DateTime.UtcNow.AddDays(7).Date.AddHours(4));
public void LogTaskRefusedAsync(WorkerTask task, Guid poolId)
{
throw new NotImplementedException();
}
public void ParallelForEachTest()
{
object rSyncRoot = new object();
Random r = new Random((int)((System.Diagnostics.Stopwatch.GetTimestamp() >> 3) & 0x7FFFFFFF));
ExceptionCollector ec = new ExceptionCollector();
AsyncQueue <int> q1 = new AsyncQueue <int>(5);
Func <Task> t1 = async delegate()
{
for (int i = 0; i < 100; ++i)
{
await q1.Enqueue(r.Next(1000), ec.CancellationToken);
}
q1.WriteEof();
};
AsyncQueue <int> q2 = new AsyncQueue <int>(5);
ParallelWorker pw = new ParallelWorker(8);
Func <Task> t2 = WorkerTask.ParallelForEach
(
q1,
pw,
async delegate(ForEachInfo <int> fi)
{
await q2.Enqueue(fi.Item * 100, fi.CancellationToken);
int time;
lock (rSyncRoot)
{
time = 100 + r.Next(800);
}
await Task.Delay(time);
},
delegate()
{
q2.WriteEof();
return(Task.CompletedTask);
},
ec
);
List <int> items = new List <int>();
Func <Task> t3 = WorkerTask.ForEach
(
q2,
delegate(ForEachInfo <int> fi)
{
items.Add(fi.Item);
System.Diagnostics.Debug.WriteLine(fi.Item);
return(Task.CompletedTask);
},
delegate()
{
return(Task.CompletedTask);
},
ec
);
Task T1 = Task.Run(t1);
Task T2 = Task.Run(t2);
Task T3 = Task.Run(t3);
Task.WaitAll(T1, T2, T3);
Assert.AreEqual(0, ec.Exceptions.Count);
Assert.AreEqual(100, items.Count);
}
private static void task_UploadPreparing(WorkerTask info)
{
Engine.EngineLogger.WriteLine("Upload preparing. ID: {0}", info.Id);
ChangeListViewItemStatus(info);
}
public void MultiSourceForEachExceptionTest()
{
ExceptionCollector ec = new ExceptionCollector();
AsyncQueue <int> q1 = new AsyncQueue <int>(5);
Func <Task> t1 = async delegate()
{
for (int i = 0; i < 100; ++i)
{
await q1.Enqueue(i, ec.CancellationToken);
}
q1.WriteEof();
};
AsyncQueue <int> q2 = new AsyncQueue <int>(5);
Func <Task> t2 = async delegate()
{
for (int i = 100; i < 200; ++i)
{
await q2.Enqueue(i, ec.CancellationToken);
}
q2.WriteEof();
};
AsyncQueue <int> q3 = new AsyncQueue <int>(5);
Func <Task> t3 = WorkerTask.ForEach
(
new IQueueSource <int>[] { q1, q2 },
InputPriorities.RoundRobin,
async fei =>
{
if (fei.Item == 133)
{
throw new InvalidOperationException("test");
}
await q3.Enqueue(fei.Item, fei.CancellationToken);
},
() =>
{
q3.WriteEof();
return(Task.CompletedTask);
},
ec
);
Func <Task> t4 = WorkerTask.ForEach
(
q3,
fei =>
{
System.Diagnostics.Debug.WriteLine(fei.Item);
return(Task.CompletedTask);
},
null,
ec
);
Task T1 = Task.Run(t1);
Task T2 = Task.Run(t2);
Task T3 = Task.Run(t3);
Task T4 = Task.Run(t4);
try
{
ec.WaitAll(T1, T2, T3, T4);
}
catch (Exception exc)
{
System.Diagnostics.Debug.WriteLine(exc);
}
}
public void SetTask(GameObject selectedTaskObject)
{
var tree = selectedTaskObject.GetComponent<ChristmasTree>();
var wareHouse = selectedTaskObject.GetComponent<Warehouse>();
if(tree != null)
{
//Debug.Log("ChristmasTree!");
currentTask = WorkerTask.Lumberjack;
// Official statement: Please note that this function is very slow. It is not recommended to use this function every frame.
// In most cases you can use the singleton pattern instead. So what its saying is that I should be manually registering objects. F that!
//Warehouse[] ob = FindObjectsOfType(typeof(Warehouse)) as Warehouse[];
//Warehouse nearestWareHouse = null;
//foreach(var o in ob)
//{
// if(nearestWareHouse == null)
// {
// nearestWareHouse = o;
// }
// else if(Vector3.Distance(o.transform.position, this.transform.position) <
// Vector3.Distance(nearestWareHouse.transform.position, this.transform.position))
// {
// nearestWareHouse = o;
// }
//}
Warehouse nearestWareHouse = RTSUnitQueryCollection.FindNearestObjectOfType<Warehouse>(this.transform.gameObject);
// find nearest warehouse
woodChopping = null; // hopefully this will dispose of the object? It doesn't have any unmanaged res.
woodChopping = new ChoppingWoodState(tree, nearestWareHouse, this.gameObject);
}
if(wareHouse != null)
{
currentTask = WorkerTask.Lumberjack;
ChristmasTree nearestTree = RTSUnitQueryCollection.FindNearestObjectOfType<ChristmasTree>(this.transform.gameObject);
woodChopping = null;
woodChopping = new ChoppingWoodState(nearestTree, wareHouse, this.gameObject);
}
}
public WorkerTaskInfo(WorkerTask task, int index)
{
this.task = task;
roomTaskIndex = index;
}
//set base condition to null, so that we may move into idle state.
public void SetTask(Vector3 moveTo, int unitsCount, int i, WorkerTask taskContext = WorkerTask.Idle)
{
currentTask = taskContext;
MoveTo(moveTo, unitsCount, i);
}
public void LogTaskDoneAsync(WorkerTask task, Guid workerId, Guid poolId)
{
throw new NotImplementedException();
}
protected override WorkerTask Recreate(WorkerTask currentTask, Input currentParameters, Output currentResult)
{
currentParameters.LastId = currentResult.LastId;
return(new WorkerTask(currentTask, JsonConvert.SerializeObject(currentParameters), DateTime.UtcNow.AddHours(1)));
}
