public void Execute(TaskComplete callback)
{
// Find all the matches we can to various weathers
var match = WeatherUtils.OrderedMatches(phrase);
// Debugging why we picked X
if (debug)
{
Debug.Log("");
Debug.Log("------ WEATHER CHOICE DEBUG ------");
Debug.Log("found " + match.Count + " possible weather matches...");
foreach (var m in match) { m.Debug(); }
}
// Select best match~
selected = match.Count > 0 ? match[0] : null;
var selectedId = match.Count > 0 ? match[0].weather.weather : WeatherId.FINE;
// Update symbol phrase
phrase.weather = selectedId;
phrase.weatherPrefab = WeatherUtils.WeatherPrefab(phrase.weather);
if (debug)
{
Debug.Log(string.Format("Pick weather for phrase: {0}", selected));
Debug.Log("");
}
// Done~
if (callback != null)
{ callback(this); }
}
public void Execute(TaskComplete callback)
{
player.ClearPhrase();
// Shuffle components, then make sure at least 1 of each type is present
// and the rest are all random.
var components = Scene.FindComponents<SelectSymbol>();
Jam.Utils.Random.Shuffle(components);
/// Default symbol states we always expect
var always = Scene.FindComponents<FixedSymbolBehaviour>();
// Apply all then always that we can
var offset = 0;
foreach (var required in always)
{
if (components.Count > offset)
{
components[offset].symbol.humidity = required.detail.humidity;
components[offset].symbol.temperature = required.detail.temperature;
components[offset].symbol.wind = required.detail.wind;
}
offset += 1;
}
// Do the rest~
for (var i = always.Count; i < components.Count; ++i)
{ components[i].symbol.Randomize(); }
// Done~
if (callback != null)
{ callback(this); }
}
public ArraysTurple A()
{
int[,] M1 = new int[n, n];
int[] M2 = new int[n];
Random rand = new Random();
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
M1[i, j] = rand.Next(n);
}
}
for (int i = 0; i < M2.Length; i++)
{
M2[i] = rand.Next(0, 100);
}
var infoTask = new Info()
{
id = "A", time_end = "[TIME STOP]: " + DateTime.Now + ":" + DateTime.Now.Millisecond
};
TaskComplete?.Invoke(infoTask);
return(new ArraysTurple {
M1 = M1, M2 = M2
});
}
public void Execute(TaskComplete callback)
{
// Change weather
var weatherControl = Scene.FindComponent<WeatherSystem>();
if (weatherControl != null)
{
weatherControl.TransitionTo(phrase.weather);
}
else { Debug.LogError("Missing WeatherSystem on scene"); }
// Apply some ambient audio if there is any
var ambientController = Scene.FindComponent<AmbienceController>();
if (ambientController != null)
{
var sound = WeatherUtils.AmbientSoundFor(phrase.weather);
if (sound != null)
{
Debug.Log("Running");
Debug.Log(sound);
ambientController.PlaySound(sound);
}
}
else { Debug.LogError("Missing AmbienceController"); }
Debug.Log(string.Format("Execute weather change: {0}", phrase.weather));
// Done~
if (callback != null)
{ callback(this); }
}
/// <summary>
/// Add a task to the thread queue. When a thread is available, it will
/// dequeue this task and run it. Once complete, the task will be marked
/// complete, but your application won't be called back until the next
/// time Update() is called (so that callbacks are from the main thread).
/// </summary>
/// <param name="function">The function to call within the thread.</param>
/// <param name="completion">The callback to report results to, or null. If
/// you care about which particular task has completed, use a different instance
/// for this delegate per task (typically, a delegate on the task itself).</param>
/// <param name="ctx">A previously allocated TaskContext, to allow for waiting
/// on the task, or null. It cannot have been already used.</param>
/// <returns>A Task identifier for the operation in question. Note: because
/// of the threaded behavior, the task may have already completed when it
/// is returned. However, if you AddTask() from the main thread, the completion
/// function will not yet have been called.</returns>
public Task AddTask(TaskFunction function, TaskComplete completion, TaskContext ctx)
{
if (function == null)
{
throw new System.ArgumentNullException("function");
}
Worker w;
lock (this)
{
if (disposed_)
{
throw new System.ObjectDisposedException("ParallelThreadPool");
}
qDepth_++;
w = NewWorker(function, completion);
if (ctx != null)
{
ctx.Init(w);
}
if (workList_ == null)
{
workList_ = w;
}
else
{
workListEnd_.next_ = w;
}
workListEnd_ = w;
}
workEvent_.Set();
return(w);
}
/// <summary>
/// Add a task to the thread queue. When a thread is available, it will
/// dequeue this task and run it. Once complete, the task will be marked
/// complete, but your application won't be called back until the next
/// time Update() is called (so that callbacks are from the main thread).
/// </summary>
/// <param name="function">The function to call within the thread.</param>
/// <param name="completion">The callback to report results to, or null. If
/// you care about which particular task has completed, use a different instance
/// for this delegate per task (typically, a delegate on the task itself).</param>
/// <param name="ctx">A previously allocated TaskContext, to allow for waiting
/// on the task, or null. It cannot have been already used.</param>
/// <returns>A Task identifier for the operation in question. Note: because
/// of the threaded behavior, the task may have already completed when it
/// is returned. However, if you AddTask() from the main thread, the completion
/// function will not yet have been called.</returns>
public ITask AddTask(TaskFunction function, TaskComplete completion, TaskContext ctx)
{
if (function == null)
{
throw new ArgumentNullException("function");
}
Worker w;
lock (this)
{
if (_disposed)
{
throw new ObjectDisposedException("ParallelThreadPool");
}
_qDepth++;
w = NewWorker(function, completion);
if (ctx != null)
{
ctx.Init(w);
}
if (_workList == null)
{
_workList = w;
}
else
{
_workListEnd.Next = w;
}
_workListEnd = w;
}
_workEvent.Set();
return(w);
}
public Task(IEnumerator task, TaskComplete taskComplete, TaskResult taskResult, string taskName = "defaultTaskName")
{
this.task = task;
this.taskResult = taskResult;
this.taskComplete = taskComplete;
this.taskName = taskName;
}
public void Execute(TaskComplete callback)
{
// Destroy old markers
foreach (var slot in Scene.FindComponents<SlotMarker>())
{ GameObject.Destroy(slot.gameObject); }
// Add currently selected
var offset = 0;
foreach (var symbol in phrase.symbols)
{
GameObject parent = null;
switch (offset)
{
case 0:
parent = slots.slot1;
break;
case 1:
parent = slots.slot2;
break;
case 2:
parent = slots.slot3;
break;
}
if (parent != null)
{
if (symbol.symbolPrefab == null)
{
Debug.LogError(string.Format("Warning: Symbol {0} does not have a prefab assigned forward it's symbol", symbol));
}
else
{
Scene.Spawn(symbol.symbolPrefab).Then((gp) =>
{
gp.transform.position = parent.transform.position;
var rotation = parent.transform.rotation;
gp.transform.rotation = rotation;
gp.transform.localScale = new Vector3(0.12f, 0.12f, 0.12f);
gp.AddComponent<SlotMarker>();
symbol.SetHighlightState(gp, true, player);
});
}
}
offset += 1;
}
// Find all SelectSymbol components and update their display state
foreach (var target in Scene.FindComponents<SelectSymbol>())
{
var item = target as SelectSymbol;
item.currentlyHighlighted = phrase.Has(item.symbol);
item.symbol.SetGlowColor(target.gameObject, player.GetSymbolColorFor(item.symbol));
}
// Done~
if (callback != null)
{ callback(this); }
}
public void SetValue(int parentId, int fieldIndex, List <OSCValue> values, TaskComplete completeCallback)
{
var task = CreateTask(RECommand.SetValue, parentId, null, completeCallback);
values.Insert(0, OSCValue.Int(fieldIndex));
Send(Address, task, values.ToArray());
}
public ITask AddTask(TaskFunction function, TaskComplete completion, TaskContext ctx)
{
//Just cycle to the next free one.
lock (_nextThreadTargetLock)
_nextThreadTarget = (ThreadTarget)(((int)(_nextThreadTarget) + 1) % _nThreads);
return(AddTask(_nextThreadTarget, function, completion, ctx));
}
private void OnFinished(int errorcode)
{
TaskComplete handler = Finished;
if (handler != null)
{
handler(errorcode);
}
}
public void Execute(TaskComplete callback)
{
// Update any plant on the scene
foreach (var plant in Scene.FindComponents<UpdatePlantState>())
{ plant.UpdateState(delta); }
// Done~
if (callback != null)
{ callback(this); }
}
private void Timer_Tick(object sender, EventArgs e)
{
timer.Stop();
foreach (var task in Tasks.Values)
{
if (!task.IsStart || task.IsStop || task.IsComplete)
{
continue;
}
ThunderDll.QueryTaskInfo(task.ID, task.Info);
if (task.Info.Status == ThunderDll.DOWN_TASK_STATUS.TSC_STOPENDING)
{
task.IsStop = true;
}
if (task.Info.Status == ThunderDll.DOWN_TASK_STATUS.TSC_COMPLETE)
{
TaskComplete?.Invoke(this, task);
task.IsComplete = true;
}
TaskInfoChange?.Invoke(this, task);
}
if (AutoManage)
{
int cnt = RunTaskCount();
if (cnt < MaxTaskCount)
{
foreach (var task in Tasks.Values)
{
if (!task.IsStart)
{
task.StartTask();
cnt++;
}
if (cnt >= MaxTaskCount)
{
break;
}
}
}
DeleteCompleted();
}
if (!Exit)
{
timer.Start();
}
}
public int E(int result)
{
var res = result / 50;
var infoTask = new Info()
{
id = "E", time_end = "[TIME STOP]: " + DateTime.Now + ":" + DateTime.Now.Millisecond
};
TaskComplete?.Invoke(infoTask);
return(res);
}
public int H(int resE, int resD)
{
int res = resD * resE * 3;
var infoTask = new Info()
{
id = "H", time_end = "[TIME STOP]: " + DateTime.Now + ":" + DateTime.Now.Millisecond
};
TaskComplete?.Invoke(infoTask);
return(res);
}
public void K(int resF, int resG, int resH)
{
//some func
int res = resF + resG + resH;
var infoTask = new Info()
{
id = "K", time_end = "[TIME STOP]: " + DateTime.Now + ":" + DateTime.Now.Millisecond
};
TaskComplete?.Invoke(infoTask);
}
public void Execute(TaskComplete callback)
{
if (emitter != null)
{
emitter.enableEmission = ready;
}
// Done~
if (callback != null)
{ callback(this); }
}
private void Grid_Tapped(object sender, TappedRoutedEventArgs e)
{
IsComplete = !IsComplete;
if (IsComplete)
{
TaskComplete.Begin();
}
else
{
TaskIncomplete.Begin();
}
}
/// <summary>
/// cancel a background task - or prevent a task from running
/// </summary>
public void Cancel()
{
lock (_lock)
{
if (_client != null)
{
_client.CancelAsync();
}
else
{
// probably an unstarted task or a task that has completed
_complete = true;
TaskComplete.Set();
}
}
}
Worker NewWorker(TaskFunction tf, TaskComplete tc)
{
if (freeList_ == null)
{
freeList_ = new Worker(null, null);
}
Worker ret = freeList_;
freeList_ = ret.next_;
ret.function_ = tf;
ret.completion_ = tc;
ret.context_ = null;
ret.error_ = null;
ret.next_ = null;
return(ret);
}
void ClientDownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
{
StatusUpdateEventArgs args = null;
lock (_lock)
{
var syncItem = e.UserState as SyncItem;
if (syncItem == null)
{
args = new StatusUpdateEventArgs(StatusUpdateLevel.Error, "Missing token from download completed", false, null);
}
else if (e.Cancelled)
{
args = new StatusUpdateEventArgs(StatusUpdateLevel.Status, string.Format(CultureInfo.InvariantCulture, "{0} Cancelled", syncItem.EpisodeTitle), false, syncItem);
}
else if (e.Error != null && e.Error.InnerException != null)
{
args = new StatusUpdateEventArgs(StatusUpdateLevel.Error, string.Format(CultureInfo.InvariantCulture, "Error in: {0}", syncItem.EpisodeTitle), e.Error.InnerException, false, syncItem);
}
else if (e.Error != null)
{
args = new StatusUpdateEventArgs(StatusUpdateLevel.Error, string.Format(CultureInfo.InvariantCulture, "Error in: {0}", syncItem.EpisodeTitle), e.Error, false, syncItem);
}
else
{
args = new StatusUpdateEventArgs(StatusUpdateLevel.Status, string.Format(CultureInfo.InvariantCulture, "{0} Completed", syncItem.EpisodeTitle), true, syncItem);
_fileUtilities.FileRename(GetDownloadFilename(), _syncItem.DestinationPath, true);
RecordHighTideMark(syncItem);
ExecutePostDownloadCommand();
}
OnStatusUpdate(args);
_client.Dispose();
_client = null;
_complete = true;
_counterFactory.CreateAverageCounter(Constants.PodcastUtilitiesCommonCounterCategory,
Constants.AverageTimeToDownload,
Constants.NumberOfDownloads).RegisterTime(_stopWatch);
_counterFactory.CreateAverageCounter(Constants.PodcastUtilitiesCommonCounterCategory,
Constants.AverageMBDownload,
Constants.SizeOfDownloads).RegisterValue(ConvertBytesToMB(_bytesDownloaded));
TaskComplete.Set();
}
}
private Worker NewWorker(TaskFunction tf, TaskComplete tc)
{
if (_freeList == null)
{
_freeList = new Worker(null, null);
}
var ret = _freeList;
_freeList = ret.Next;
ret.Function = tf;
ret.Completion = tc;
ret.Context = null;
ret.Error = null;
ret.Next = null;
return(ret);
}
/// <summary>
/// Sets task's state to completed and
/// </summary>
/// <param name="taskComplete">Completed task</param>
public void TaskRemove(TaskComplete taskComplete)
{
using (MySqlConnection connection = WebApiConfig.Connection())
{
connection.Open();
if (taskComplete.IsSuccessfull)
{
using (MySqlCommand command = new MySqlCommand(@"UPDATE `tbTasks` SET `Completed`= 1 WHERE `Id` = @IdTask", connection))
{
command.Parameters.AddWithValue("@IdTask", taskComplete.IDTask);
command.ExecuteNonQuery();
}
}
string debugLog = "";
if (taskComplete.DebugLog != null)
{
foreach (string item in taskComplete.DebugLog)
{
debugLog += item + "\n";
}
}
using (MySqlCommand command = new MySqlCommand($"INSERT INTO `tbTasksCompleted` VALUES (null,{GetDaemonId(taskComplete.DaemonInfo)},{taskComplete.IDTask},@backupjournal,@datetime,'{debugLog}',{taskComplete.IsSuccessfull},0)", connection))
{
command.Parameters.AddWithValue("@backupjournal", b.Base64Encode(JsonConvert.SerializeObject(taskComplete.DatFile)));
command.Parameters.AddWithValue("@datetime", taskComplete.TimeOfCompletition);
command.ExecuteNonQuery();
}
int Id = sqlAdmin.NextAutoIncrement("tbTasksCompleted") - 1;
List <int> toInsert = new List <int>();
using (MySqlCommand command = new MySqlCommand($"select Id from tbAdminAccounts where 1 order by Id", connection))
{
using (MySqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
toInsert.Add((int)reader["Id"]);
}
}
foreach (int item in toInsert)
{
command.CommandText = $"INSERT INTO `tbTasksCompletedAdminNOTNotified`(`IdTaskCompleted`, `IdAdmin`) VALUES({Id}, {item})";
command.ExecuteNonQuery();
}
}
}
}
public new void Execute(string input)
{
try
{
var cached = TaskBuffer.Get(input);
cached.Update("status", "Published");
_publisher.SendQueue(input, cached.ToString());
UpdateCacheAndDatabase(input, cached);
_complete = new TaskComplete();
_complete.Execute(input);
}
catch (Exception e)
{
TaskCancel cancel = new TaskCancel(e);
cancel.Execute(input);
}
}
public int C(ArraysTurple result)
{
var M1 = result.M1;
var M2 = result.M2;
int res = 0;
for (int i = 0; i < M2.Length; i++)
{
res = M2[i] - 100;
}
var infoTask = new Info()
{
id = "C", time_end = "[TIME STOP]: " + DateTime.Now + ":" + DateTime.Now.Millisecond
};
TaskComplete?.Invoke(infoTask);
return(res);
}
public int B(ArraysTurple result)
{
var M1 = result.M1;
var M2 = result.M2;
int res = 0;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
res = M1[i, j] + res;
}
}
var infoTask = new Info()
{
id = "B", time_end = "[TIME STOP]: " + DateTime.Now + ":" + DateTime.Now.Millisecond
};
TaskComplete?.Invoke(infoTask);
return(res);
}
public void Execute(TaskComplete callback)
{
// Push the history into the display?
DeleteOldHistory();
var offset = 0;
var history = new List<SymbolPhrase>();
history.AddRange(this.history.history);
history.Reverse();
foreach (var historyItem in history)
{
SpawnHistoryPrefabsAndLayout(historyItem, offset);
offset += 1;
if (offset >= this.history.historySize)
{
break;
}
}
Debug.Log(string.Format("Update history with {0} items", history.Count));
// Done~
if (callback != null)
{ callback(this); }
}
public void TaskCompletionRecieved(TaskComplete task, MySqlConnection connection)
{
using (MySqlCommand command = new MySqlCommand(@"SELECT `RepeatInJSON`,`TimeOfExecution` FROM `tbTasks` WHERE Id = @Id", connection))
{
command.Parameters.AddWithValue("@Id", task.IDTask);
using (MySqlDataReader reader = command.ExecuteReader())
{
if (reader.Read())
{
if (reader["RepeatInJSON"] == DBNull.Value || JsonSerializationUtility.Deserialize <TaskRepeating>((string)reader["RepeatInJSON"]).Repeating == new TimeSpan(0))
{
reader.Close();
TaskRemove(task);
}
else
{
string json = (string)reader["RepeatInJSON"];
reader.Close();
TaskExtend(task, json);
}
}
}
}
}
internal Worker(TaskFunction function, TaskComplete completion)
{
Function = function;
Completion = completion;
Error = null;
}
public void RefreshObjects(int parentId, TaskProcess processCallback, TaskComplete completeCallback)
{
var task = CreateTask(RECommand.GetObjects, parentId, processCallback, completeCallback);
Send(Address, task, OSCValue.Int(0));
}
public void ClearObjects(TaskComplete completeCallback)
{
var task = CreateTask(RECommand.Clear, 0, null, completeCallback);
Send(Address, task);
}
private Task CreateTask(RECommand command, int parentId, TaskProcess processCallback, TaskComplete completeCallback)
{
var taskId = string.Format("{0}_{1}", parentId, command);
var task = new Task(command, parentId, taskId);
if (_tasksDictionary.ContainsKey(taskId))
{
_tasksDictionary.Remove(taskId);
}
_tasksDictionary.Add(taskId, task);
task.ProcessCallback = processCallback;
task.CompleteCallback = completeCallback;
return(task);
}
private void TryBackup(TaskInfo task)
{
DateTime now = DateTime.Now;
if (existTask == null)//如果没有正在备份
{
//if (!Directory.Exists(task.TargetDirectory))//如果不存在目标目录
//{
// try
// {
// //尝试去创建
// Directory.CreateDirectory(task.TargetDirectory);
// }
// catch
// {
// task.LastBackupTime = now;
// // AppendLog(itemsName[i], "目标目录不存在且无法创建，将在下一个周期重试。");
// // txtLogPanel.Text = log.ToString();
// // lvwTasks.Items.Refresh();
// return;
// }
//}
//else//如果目录存在
//{
//如果校验失败
task.Status = TaskInfo.Statuses.BackingUp;
currentCore = new BackupCore(task);
Task t = new Task(currentCore.Backup);
existTask = t;
t.ContinueWith(p =>
{
existTask = null;
task.Status = TaskInfo.Statuses.Waiting;
if (task.RealTime)
{
task.LastBackupTime = DateTime.MaxValue;
task.DisplayStatus = "正在侦测";
}
else
{
task.LastBackupTime = DateTime.Now;
}
if (needToStop)
{
timer.Stop();
needToStop = false;
}
App.Current?.Dispatcher.Invoke(() =>
{
if (App.Current.MainWindow as MainWindow != null && App.Current.MainWindow.Visibility == System.Windows.Visibility.Visible)
{
(App.Current.MainWindow as MainWindow).ResetButtons();
}
});
TaskComplete?.Invoke(this, new TaskCompleteEventArgs(task));
});
t.Start();
// }
}
else//如果正在备份其他的东西
{
task.DisplayStatus = "排队中";
LogHelper.AppendLog(task, "因已有工作中的备份任务，该任务正在排队等待");
task.Status = TaskInfo.Statuses.InTheLine;
}
}
public void ForceComplete()
{
_complete = true;
TaskComplete.Set();
}
/// <summary>
///
/// </summary>
/// <param name="iClient"></param>
public void Start(IPresenter.ICalculatorClient iClient)
{
this.iClient = iClient;
this.IsRunning = true;
this.TaskName = this.iClient.TaskName;
this.Comment = this.iClient.Comment;
this.taskWork = this.iClient.TaskWork;
if (this.task == null)
{
this.task = new Thread(new ThreadStart(this.Run));
this.task.Start();
}
if (this.isPause)
{
this.isPause = false;
}
}
/// <summary>
/// If next execution time exists new task is created and current is marked as completed else task is removed with <see cref="TaskRemove(TaskComplete)"/>
/// </summary>
/// <param name="taskComplete">Completed task</param>
/// <param name="JsonTime">T<see cref="TaskRepeating"/> in json</param>
private void TaskExtend(TaskComplete taskComplete, string JsonTime)
{
using (MySqlConnection connection = WebApiConfig.Connection())
{
connection.Open();
TaskRepeating repeat = JsonSerializationUtility.Deserialize <TaskRepeating>(JsonTime);
repeat = timer.TaskExtend(repeat);
if (repeat == null)
{
TaskRemove(taskComplete);
return;
}
else
{
foreach (var item in repeat.ExecutionTimes)
{
while (this.HasDateException(item, repeat.ExceptionDates))
{
item.Add(repeat.Repeating);
}
}
}
repeat = timer.TaskExtend(repeat);
//new task
Task originalTask = null;
Task newTask;
string order = "";
//BackupType: 0=Full, 1=Incr, 2=Diff
int previousTaskID = 0;
using (MySqlCommand command = new MySqlCommand("SELECT * FROM `tbTasks` WHERE `Id` = @id", connection))
{
command.Parameters.AddWithValue("@id", taskComplete.IDTask);
using (MySqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
originalTask = JsonSerializationUtility.Deserialize <Task>((string)reader["Task"]);
order = (string)reader["BackupTypePlan"];
previousTaskID = (int)reader["Id"];
}
}
}
if (originalTask == null)
{
throw new Exception("Task " + taskComplete.IDTask + "cannot be found in database");
}
TaskRemove(taskComplete);
string newOrder = "";
newOrder += order.Substring(1, order.Length - 1);
newOrder += order[0];
int previousTaskIDLast = previousTaskID;
ISource[] previousTasksSources = new ISource[newOrder.Length];
int[] previousTasksIds = new int[newOrder.Length];
//List<string> previousTasksData = new List<string>(order.Length);
//Dictionary<int, string> previousTasksData = new Dictionary<int, string>(order.Length);
for (int i = 0; i < newOrder.Length; i++)
{
using (MySqlCommand command = new MySqlCommand("SELECT Task, IdPreviousTask FROM `tbTasks` WHERE `Id` = " + previousTaskIDLast, connection))
{
using (MySqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
//previousTasksTypes.Add((int)reader["PreviousTaskID"], (byte)reader["BackupType"]);
previousTasksSources[i] = JsonSerializationUtility.Deserialize <Task>((string)reader["Task"]).Sources;
previousTasksIds[i] = previousTaskIDLast;
previousTaskIDLast = (int)reader["IdPreviousTask"];
}
}
}
}
if (newOrder != null && newOrder.Length > 0)
{
newTask = originalTask;
newTask.TimeToBackup = repeat.ExecutionTimes[0];
if (newOrder[0] == '0')
{
for (int i = newOrder.Length - 1; i > 0; i--)
{
if (previousTasksSources[i] is SourceFolders)
{
newTask.Sources = previousTasksSources[i];
break;
}
}
}
else if (newOrder[0] == '1')
{
for (int i = newOrder.Length - 1; i > 0; i--)
{
if (previousTasksSources[i] is SourceFolders)
{
using (MySqlCommand command = new MySqlCommand("SELECT BackupJournal FROM tbTasksCompleted WHERE IdTask = " + previousTasksIds[i], connection))
{
using (MySqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
newTask.Sources = JsonConvert.DeserializeObject <BackupJournalObject>((string)reader["BackupJournal"]);
}
}
}
break;
}
}
//int lastID = previousTasksIds[newOrder.Length - 1];
//int i = 0;
//while (lastID == 0)
//{
// lastID = previousTasksIds[newOrder.Length - 1 - i];
// i++;
//}
//using (MySqlCommand command = new MySqlCommand("SELECT BackupJournal FROM tbTasksCompleted WHERE IdTask = " + lastID, connection))
//{
// using (MySqlDataReader reader = command.ExecuteReader())
// {
// while (reader.Read())
// {
// //previousTasksTypes.Add((int)reader["PreviousTaskID"], (byte)reader["BackupType"]);
// newTask.Sources = JsonConvert.DeserializeObject<BackupJournalObject>(b.Base64Decode((string)reader["BackupJournal"]));
// }
// }
//}
}
else if (newOrder[0] == '2')
{
for (int i = newOrder.Length - 1; i > 0; i--)
{
int lastID = previousTasksIds[i];
int y = 1;
while (lastID == 0)
{
lastID = previousTasksIds[i] - y;
y++;
}
if (newOrder[i] == '0')
{
using (MySqlCommand command = new MySqlCommand("SELECT BackupJournal FROM tbTasksCompleted WHERE IdTask = " + previousTasksIds[i], connection))
{
using (MySqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
//previousTasksTypes.Add((int)reader["PreviousTaskID"], (byte)reader["BackupType"]);
newTask.Sources = JsonConvert.DeserializeObject <BackupJournalObject>((string)reader["BackupJournal"]);
}
}
}
break;
}
}
}
}
else
{
throw new Exception("Order is undefined");
}
newTask.IDTask = sqlAdmin.NextAutoIncrement("tbTasks");
sqlAdmin.AlterTable(new Models.Tables.ChangeTable()
{
ColumnName = "RepeatInJSON", Id = taskComplete.IDTask, TableName = "tbTasks", Value = JsonSerializationUtility.Serialize(repeat)
});
using (MySqlCommand command = new MySqlCommand("INSERT INTO `tbTasks`(`IdDaemon`, `Task`, `TimeOfExecution`, `IdPreviousTask`, `BackupTypePlan`, `RepeatInJSON`, `Completed`)" +
" VALUES (@IdDaemon, @Task, @TimeOfExecution, @IdPreviousTask, @BackupPlan, @Repeat, 0 )", connection))
{
command.Parameters.AddWithValue("@IdDaemon", GetDaemonId(taskComplete.DaemonInfo));
command.Parameters.AddWithValue("@Task", JsonSerializationUtility.Serialize(newTask));
command.Parameters.AddWithValue("@TimeOfExecution", repeat.ExecutionTimes[0]);
command.Parameters.AddWithValue("@Repeat", JsonSerializationUtility.Serialize(repeat));
command.Parameters.AddWithValue("@IdPreviousTask", taskComplete.IDTask);
command.Parameters.AddWithValue("@BackupPlan", newOrder);
command.ExecuteNonQuery();
}
/*
* repeat.ExecutionTimes.Sort();
* DateTime nextDate = repeat.ExecutionTimes.Last();
* bool DateChanged = false;
* foreach (var item in repeat.ExecutionTimes)
* {
* if (item > DateTime.Now)
* {
* bool NotException = HasDateException(item, repeat.ExceptionDates);
* if (NotException)
* {
* nextDate = item;
* DateChanged = true;
* break;
* }
* }
* }
* if (!DateChanged)
* {
* if (repeat.RepeatTill == null)
* {
* bool DateOk = true;
* while (repeat.ExecutionTimes[0] < DateTime.Now || !DateOk)
* {
* for (int i = 0; i < repeat.ExecutionTimes.Count; i++)
* {
* repeat.ExecutionTimes[i] += repeat.Repeating;
* }
* DateOk = DateAvailable(repeat.ExecutionTimes, repeat.ExceptionDates);
* }
* }
* else
* {
* bool DateOk = true;
* while (repeat.ExecutionTimes[0] < DateTime.Now || !DateOk)
* {
* List<int> ToDelete = new List<int>();
* for (int i = 0; i < repeat.ExecutionTimes.Count; i++)
* {
* if (repeat.ExecutionTimes[i] + repeat.Repeating < repeat.RepeatTill)
* repeat.ExecutionTimes[i] += repeat.Repeating;
* else
* ToDelete.Add(i);
* }
* for (int i = ToDelete.Count - 1; i >= 0; i--)
* {
* repeat.ExecutionTimes.RemoveAt(ToDelete[i]);
* }
* if (repeat.ExecutionTimes.Count == 0)
* break;
* DateOk = DateAvailable(repeat.ExecutionTimes, repeat.ExceptionDates);
* }
* }
* foreach (var item in repeat.ExecutionTimes)
* {
* if (item > DateTime.Now)
* {
* nextDate = item;
* break;
* }
* }
* }
* if (repeat.ExecutionTimes.Count == 0)
* {
* TaskRemove(taskComplete);
* }
* else
* {
* using (MySqlCommand command = new MySqlCommand(@"SELECT * FROM `tbTasks` WHERE Id = @Id", connection))
* {
* int IdDaemon;
* string Task;
* DateTime TimeOfExecution;
* string RepeatInJSON;
* command.Parameters.AddWithValue("@Id", taskComplete.IDTask);
* using (MySqlDataReader reader = command.ExecuteReader())
* {
* if (reader.Read())
* {
* IdDaemon = (int)reader["IdDaemon"];
* Task = (string)reader["Task"];
* TimeOfExecution = (DateTime)reader["TimeOfExecution"];
* RepeatInJSON = (string)reader["RepeatInJSON"];
* }
* else
* {
* throw new Exception();
* }
* }
* Task TaskClass = JsonSerializationUtility.Deserialize<Task>(Task);
* TaskRemove(taskComplete);
* command.CommandText = "SELECT AUTO_INCREMENT FROM information_schema.TABLES WHERE TABLE_SCHEMA = '3b1_kocourekmatej_db2' AND TABLE_NAME = 'tbTasks'";
* using (MySqlDataReader reader = command.ExecuteReader())
* {
* if (reader.Read())
* taskComplete.IDTask = Convert.ToInt32(reader["AUTO_INCREMENT"]);
* else
* throw new Exception();
* }
* TaskClass.IDTask = taskComplete.IDTask;
* TaskClass.Sources = taskComplete.DatFile;
* Task = JsonSerializationUtility.Serialize(TaskClass);
* command.CommandText = "INSERT INTO `tbTasks` VALUES (null, @IdDaemon, @Task, @TimeOfExecution, @RepeatInJSON, @Completed)";
* command.Parameters.AddWithValue("@IdDaemon", IdDaemon);
* command.Parameters.AddWithValue("@Task", Task);
* command.Parameters.AddWithValue("@TimeOfExecution", TimeOfExecution);
* command.Parameters.AddWithValue("@RepeatInJSON", RepeatInJSON);
* command.Parameters.AddWithValue("@Completed", 0);
* command.ExecuteNonQuery();
* }
* }*/
}
}
internal Worker(TaskFunction function, TaskComplete completion)
{
function_ = function;
completion_ = completion;
error_ = null;
}
public ITask AddTask(ThreadTarget threadTarget, TaskFunction function, TaskComplete completion, TaskContext ctx)
{
return(_wrappers[(int)threadTarget].AddTask(function, completion, ctx));
}
internal Worker(TaskFunction function, TaskComplete completion)
{
function_ = function;
completion_ = completion;
error_ = null;
}
/// <summary>
/// Add a task to the thread queue. When a thread is available, it will
/// dequeue this task and run it. Once complete, the task will be marked
/// complete, but your application won't be called back until the next
/// time Update() is called (so that callbacks are from the main thread).
/// </summary>
/// <param name="function">The function to call within the thread.</param>
/// <param name="completion">The callback to report results to, or null. If
/// you care about which particular task has completed, use a different instance
/// for this delegate per task (typically, a delegate on the task itself).</param>
/// <param name="ctx">A previously allocated TaskContext, to allow for waiting
/// on the task, or null. It cannot have been already used.</param>
/// <returns>A Task identifier for the operation in question. Note: because
/// of the threaded behavior, the task may have already completed when it
/// is returned. However, if you AddTask() from the main thread, the completion
/// function will not yet have been called.</returns>
public Task AddTask(TaskFunction function, TaskComplete completion, TaskContext ctx, object argument)
{
if (function == null)
throw new System.ArgumentNullException("function");
Worker w;
lock (this)
{
if (disposed_)
throw new System.ObjectDisposedException("ParallelThreadPool");
qDepth_++;
w = NewWorker(function, completion, argument);
if (ctx != null)
ctx.Init(w);
if (workList_ == null)
workList_ = w;
else
workListEnd_.next_ = w;
workListEnd_ = w;
}
workEvent_.Set();
return w;
}
Worker NewWorker(TaskFunction tf, TaskComplete tc, object argument)
{
if (freeList_ == null)
freeList_ = new Worker(null, null);
Worker ret = freeList_;
freeList_ = ret.next_;
ret.function_ = tf;
ret.completion_ = tc;
ret.context_ = null;
ret.error_ = null;
ret.next_ = null;
ret.argument = argument;
return ret;
}