public bool IsTaskComplete(SlgPB.Task task)
{
DataTask dataTask = DataManager.instance.dataTaskGroup.GetTask(task.taskId);
if (!dataTask.command.Equals("ArenaRankings"))
{
if (task.progress >= dataTask.totalProgress)
{
return(true);
}
else
{
return(false);
}
}
else
{
if (task.progress <= dataTask.totalProgress)
{
return(true);
}
else
{
return(false);
}
}
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Name,What_Date,Start_Date,Finish_Date,Total_Of_Hours")] DataTask dataTask)
{
if (id != dataTask.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(dataTask);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DataTaskExists(dataTask.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(dataTask));
}
public override void Run(string[] args)
{
Logger.Info("run");
var countToCreate = 1;
var threadCount = 1;
var cmdargs = ParseArgs(args);
foreach (var cmdarg in cmdargs)
{
switch (cmdarg.Item1)
{
case "-n":
countToCreate = int.Parse(cmdarg.Item2);
break;
case "-t":
threadCount = int.Parse(cmdarg.Item2);
break;
}
}
_dataTask = new DataTask <Tuple <int, int> >();
for (var i = 0; i < threadCount; i++)
{
_dataTask.AddTask(new Tuple <int, int>(i, countToCreate / threadCount));
}
_dataTask.Start(DoTask, threadCount);
_dataTask.Wait();
}
public Task ReadTask(string name)
{
DataTask dt = idataTask.ReadTask(name);
return(new Task {
Id = dt.Id, Name = dt.Name, UrgencyMeasure = dt.UrgencyMeasure, ImportanceMeasure = dt.ImportanceMeasure, Description = dt.Description
});
}
public void AddTask(Task task)
{
DataTask dt = new DataTask {
Id = task.Id, Name = task.Name, UrgencyMeasure = task.UrgencyMeasure, ImportanceMeasure = task.ImportanceMeasure, Description = task.Description
};
idataTask.AddTask(dt);
}
public TaskLevel(DataTask dataTask, TaskDisplay taskDisplayer)
{
this._taskDisplayer = taskDisplayer;
taskDisplayer.SetInfo(dataTask);
_taskChecking = TaskCheckingInitializer.GetTaskCheking(dataTask.TypeTask);
_countTask = dataTask.Count;
}
protected void Page_Load(object sender, EventArgs e)
{
// txtFeedBack.Text = "";
if (Session["UserAccount"] == null)
{
Response.Redirect("../login.aspx");
return;
}
data = new DataTask();
}
public void CreateTask(DataTask dataTask)
{
TaskDisplay taskDisplayer = Instantiate(_prefTaskDisplay, _parentTasks);
taskDisplayer.SetInfo(dataTask);
TaskLevel taskLevel = new TaskLevel(dataTask, taskDisplayer);
_listTaskLevel.Add(taskLevel);
}
public void SaveInJson(DataTask task)
{
string json = JsonConvert.SerializeObject(task);
using (StreamWriter file = File.CreateText(@"../DataJson/" + task.Name + ".json"))
{
JsonSerializer serializer = new JsonSerializer();
serializer.Serialize(file, json);
}
}
public override void Run(string[] args)
{
var cmdArgs = this.ParseArgs(args);
string fn = "acc.txt";
foreach (var arg in cmdArgs)
{
switch (arg.Item1)
{
case "fn":
fn = arg.Item2;
break;
}
}
var filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, fn);
if (!File.Exists(filePath))
{
Console.WriteLine($"{filePath} not exists");
return;
}
LevelDbHelper.Instance.Init();
Rpcclient = new RpcClient(new Uri($"http://127.0.0.1:10008"));
DataTask.DataTask <dynamic> contractTask = new DataTask <dynamic>();
using (var fr = new StreamReader(filePath)) {
while (true)
{
var line = fr.ReadLine();
if (string.IsNullOrEmpty(line))
{
break;
}
var pair = line.Split(",");
var addr = pair[0];
var key = pair[1];
if (LevelDbHelper.Instance.IsKeyExists(addr))
{
continue;
}
contractTask.AddTask(pair);
}
}
contractTask.Start(DoTask);
contractTask.Wait();
LevelDbHelper.Instance.Destroy();
}
public static TaskStep Create(GameObject parent, int name, DataTask dataTask)
{
GameObject go = new GameObject("taskbase" + name);
go.transform.parent = parent.transform;
TaskStep taskBase = go.AddComponent <TaskStep>();
taskBase.LoadData(dataTask);
return(taskBase);
}
public async Task <IActionResult> Create([Bind("ID,Name,What_Date,Start_Date,Finish_Date,Total_Of_Hours")] DataTask dataTask)
{
if (ModelState.IsValid)
{
_context.Add(dataTask);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(dataTask));
}
public void SetInfo(DataTask dataTask, bool isCheckCompleted = false)
{
_imgTask.sprite = dataTask.Sprite;
_tmpCountTask.text = dataTask.Count.ToString();
if (isCheckCompleted && dataTask.Count == 0)
{
_tmpCountTask.gameObject.SetActive(false);
_imgCompleteTask.gameObject.SetActive(true);
_imgCompleteTask.fillAmount = 1;
}
}
public List <DataTask> ReadAllTasks()
{
string[] allFoundFiles = Directory.GetFiles(@"../DataJson/", @"*.json", SearchOption.AllDirectories);
List <DataTask> tasks = new List <DataTask>();
foreach (string path in allFoundFiles)
{
DataTask tsk = DeserializeTask(File.ReadAllText(path));
if (tsk != null)
{
tasks.Add(tsk);
}
}
return(tasks);
}
//处理数据接收队列
private void ReceiveDataTaskTake()
{
while (true)
{
DataTask _DataTask = this.m_ReceiveDataTasks.Take();
try
{
SocketClient _SocketClient = _DataTask.Args.UserToken as SocketClient;
this.ReceiveData(_DataTask.Args, _SocketClient.State == SocketClientStateOptions.Online, _DataTask.Data);
}
catch (Exception ex)
{
this.DoException(_DataTask.Args, ex);
}
}
}
public void Load(string name)
{
byte[] bin = DynamicFileControl.QueryFileContent(name);
string content = StringHelper.ReadFromBytes(bin);
LitJson.JSONNode json = LitJson.JSON.Parse(content);
_tasksMap = new Dictionary <int, DataTask> ();
foreach (LitJson.JSONNode subNode in json.Childs)
{
DataTask data = new DataTask();
data.Load(subNode);
_tasksMap.Add(data.id, data);
}
}
private async void startBtn_Click(object sender, EventArgs e)
{
try
{
DataTask task = new DataTask(LinksFile, !skipCheckBox.Checked);
task.Log += ProgressChanged;
await Task.Run(async() =>
{
await task.Execute();
});
}
catch (IOException ex)
{
MessageBox.Show("Hiba: " + ex.Message);
}
}
public void Init(int countMoves, JsonDataTasksLevel dataTasksLevel, int numberLevel)
{
NumberLevel = numberLevel;
MovesMatch.Init(countMoves + GameManager.LevelLoadingData.ExtraMoves);
_tmpNumberLevel.text = $"lvl: {numberLevel}";
foreach (var jsonDataTask in dataTasksLevel.listJsonTaskData)
{
Sprite sprite = ResourceLoader.LoadSprite(jsonDataTask.typeTask);
TypeTask typeTask = ResourceLoader.GetTypeTask(jsonDataTask.typeTask);
DataTask dataTask = new DataTask(sprite, jsonDataTask.countTask, typeTask);
_tasksLevelInformation.CreateTask(dataTask);
_startTaskPanel.CreateTaskDisplayer(dataTask);
}
}
public TasksViewModel()
{
ObservableRangeCollection <DataTask> d0 = new ObservableRangeCollection <DataTask>();
DataTask d1 = new DataTask(TipusTask.Dieta);
DataTask d2 = new DataTask(TipusTask.Exercici);
DataTask d3 = new DataTask(TipusTask.Pastilles);
d0.Add(d1);
d0.Add(d2);
d0.Add(d3);
dataTasks = d0;
ObservableRangeCollection <DataTask> d00 = new ObservableRangeCollection <DataTask>();
DataTask d10 = new DataTask(TipusTask.ExerciciSet);
d00.Add(d10);
dataTasksSetmanals = d00;
}
public void Load(string path)
{
if (_isLoad)
{
return;
}
_isLoad = true;
_dataTask = new Dictionary <int, DataTask>();
TaskDataConfig taskData = LoadJson.LoadJsonTaskFromFile(path);
foreach (TaskDataBase taskDataBase in taskData.taskDataBaseGroup)
{
DataTask data = new DataTask();
data.Load(taskDataBase);
_dataTask.Add(data.id, data);
}
}
private void OnEnable() => Task = (DataTask)target;
public void LoadData(DataTask data)
{
taskId = data.id;
_dataTask = data;
}
virtual public void EnterTask(int taskId)
{
_dataTask = DataManager.instance.taskGroup.GetTask(taskId);
Debug.Log("<color=red>" + " 当前任务 " + "</color>" + taskId + ":" + _dataTask.stageDesc + "--" + _dataTask.desc);
//TestReadJson.Instance.text.text = "当前任务 " + taskId + ":" + _dataTask.stageDesc + "--" + _dataTask.desc;
}
private void LoadData()
{
List <DataTask> listTask = DataManager.instance.taskGroup.GetAllTask();
int taskCount = listTask.Count;
for (int i = 0; i < taskCount; ++i)
{
int taskId = listTask[i].id;
string desc = listTask[i].desc;
DataTask dataTask = listTask[i];
TaskStep taskBase = TaskStep.Create(this.gameObject, taskId, dataTask);
_taskList.Add(taskBase);
switch (taskId)
{
case 1001:
arrTaskIndexLevel[0] = i;
break;
case 2001:
arrTaskIndexLevel[1] = i;
break;
case 3001:
arrTaskIndexLevel[2] = i;
break;
case 4001:
arrTaskIndexLevel[3] = i;
break;
case 5001:
arrTaskIndexLevel[4] = i;
break;
case 6001:
arrTaskIndexLevel[5] = i;
break;
case 7001:
break;
case 8001:
break;
case 9001:
break;
case 10001:
break;
case 11001:
break;
case 12001:
break;
case 13001:
break;
case 14001:
break;
case 15001:
break;
case 16001:
break;
case 17001:
break;
case 18001:
break;
case 19001:
break;
case 20001:
break;
case 21001:
break;
case 22001:
break;
case 23001:
break;
case 24001:
break;
case 25001:
break;
case 26001:
break;
case 27001:
break;
case 28001:
break;
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
data = new DataTask();
refreshData();
}
/// <summary> /// Allows awaiting of this cache directly. /// </summary> public TaskAwaiter <T> GetAwaiter() => DataTask.GetAwaiter();
public void AddTask(DataTask task)
{
SaveInJson(task);
}
