private void contextBtnSchedule_Click(object sender, RoutedEventArgs e)
{
ScheduleWindow window = new ScheduleWindow((Window)Global.MAIN_WINDOW);
bool? nullable = window.ShowDialog();
if ((nullable.GetValueOrDefault() ? nullable.HasValue : false) && (this.gvTasks.SelectedItems.Count > 0))
{
List <string> list = new List <string>();
foreach (object obj3 in this.gvTasks.SelectedItems)
{
if (obj3 is TaskObject)
{
list.Add(((TaskObject)obj3).Id);
}
}
foreach (string id in list)
{
TaskObject obj2 = Global.SETTINGS.TASKS.First <TaskObject>(x => x.Id == id);
if (((obj2.State == TaskObject.StateEnum.error) || (obj2.State == TaskObject.StateEnum.stopped)) || ((obj2.State == TaskObject.StateEnum.scheduled) || (obj2.State == TaskObject.StateEnum.success)))
{
obj2.State = TaskObject.StateEnum.scheduled;
obj2.IsStartScheduled = true;
if (obj2.Platform != TaskObject.PlatformEnum.shopify)
{
obj2.ScheduleStart = window.PickedTime;
}
else
{
obj2.ScheduleStart = window.PickedTime.AddMinutes(-5.0);
}
}
}
Helpers.SaveSettings();
}
}
/// <summary> 体力buff日常更新 </summary>
public void BuffPowerUpdate()
{
try
{
var rule = Variable.BASE_RULE.FirstOrDefault(m => m.id == "7033");
if (rule == null) return;
var buffvalue = Convert.ToInt32(rule.value);
tg_role.GetPowerBuffUpdate(buffvalue);
foreach (var item in Variable.OnlinePlayer.Keys)
{
var session = Variable.OnlinePlayer[item] as TGGSession;
if (session == null) return;
session.Player.Role.Kind.buff_power = buffvalue;
var list = new List<string> { "power", "rolepower" };
var role = session.Player.Role.Kind;
var user_id = session.Player.User.id;
var obj = new TaskObject { role = role, user_id = user_id, list = list };
var token = new CancellationTokenSource();
Task.Factory.StartNew(m =>
{
var entity = m as TaskObject;
if (entity == null) return;
(new RoleAttUpdate()).RoleUpdatePush(entity.role, entity.user_id, entity.list);
token.Cancel();
}, obj, token.Token);
}
}
catch { XTrace.WriteLine("体力buff日常更新错误"); }
}
public Barneys(TaskRunner runner, TaskObject task)
{
Class7.RIuqtBYzWxthF();
this._currentDoc = new HtmlDocument();
this._runner = runner;
this._task = task;
}
public Notificator(TaskObject task, string url, string productName)
{
Class7.RIuqtBYzWxthF();
this._task = task;
this._url = url;
this._productName = productName;
}
private void ProcessEmailAddressReporter(TaskObject task, string emailAddress)
{
TIS.BL.Internal.Employee blEmp = new TIS.BL.Internal.Employee();
TIS.DL.Internal.Employee.EmployeeObject employee;
TIS.DL.Internal.TaskPeople.TaskPeopleObject taskPeople;
try
{
//Voorlopig enkel werkbaar voor Thomas
employee = blEmp.GetEmployeeByEmail("*****@*****.**");
if (employee == null)
{
throw new System.Exception("E-mail adres van outlook account is niet gekend binnen TIS, gelieve de applicatiebeheerder te contacteren");
}
else
{
taskPeople = ProcessEmployee(employee);
taskPeople.Task = task;
task.Reporters.Add(taskPeople);
}
}
catch (System.Exception exception1)
{
System.Exception innerException = exception1;
throw new System.Exception(MethodBase.GetCurrentMethod().Name, innerException);
}
}
public ActionResult EditMethod(TaskObject task)
{
TasksContext context = HttpContext.RequestServices.GetService(typeof(TasksContext)) as TasksContext;
context.UpdateTask(task);
return(RedirectToAction("Index"));
}
private void BtnEditTask_Click(object sender, RoutedEventArgs e)
{
if (this.gvTasks.SelectedItems.Count == 1)
{
try
{
TaskObject task = (TaskObject)this.gvTasks.SelectedItems[0];
TaskWindow2 window = new TaskWindow2((Window)Global.MAIN_WINDOW, task);
window.ShowDialog();
if (window.RunAfterSave)
{
List <string> ids = new List <string>();
foreach (string id in window.RunIds)
{
TaskObject obj3 = Global.SETTINGS.TASKS.First <TaskObject>(x => x.Id == id);
if ((obj3.State != TaskObject.StateEnum.running) && (obj3.State != TaskObject.StateEnum.waiting))
{
ids.Add(obj3.Id);
}
}
TaskManager.StartTasks(ids);
}
}
catch (Exception)
{
}
}
}
public void Save(TaskObject task)
{
SqlCommand cmd = null;
try
{
ExecuteNonQuery(out cmd, false, "Task_SAVE",
CreateParameter("@taskID", SqlDbType.UniqueIdentifier, task.TaskID, ParameterDirection.InputOutput),
CreateParameter("@Tag", SqlDbType.VarChar, task.Tag),
CreateParameter("@CreationDate", SqlDbType.VarChar, task.CreationDate),
CreateParameter("@UpdateDate", SqlDbType.VarChar, task.UpdateDate),
CreateParameter("@DueDate", SqlDbType.VarChar, task.DueDate),
CreateParameter("@Description", SqlDbType.VarChar, task.Description),
CreateParameter("@Status", SqlDbType.Int, task.Status),
CreateParameter("@Priority", SqlDbType.Int, task.Priority),
CreateParameter("@Effort", SqlDbType.Int, task.Effort)
);
task.TaskID = (Guid)cmd.Parameters["@taskID"].Value;
}
catch (Exception exception1)
{
Exception innerException = exception1;
throw new Exception(MethodBase.GetCurrentMethod().Name, innerException);
}
finally
{
if (cmd != null)
{
cmd.Dispose();
}
cmd = null;
}
}
public Edit(string connectionString, TaskObject t)
{
this.task = t;
this.connect = connectionString;
InitializeComponent();
setFields();
}
// called by TaskObjects when they are completed
public void logTaskAndDestroy(int id)
{
TaskObject[] taskObjects = FindObjectsOfType <TaskObject>();
if (taskObjects.Length >= 0)
{
// loop through TaskObjects in scene and find the TaskObject with the given instanceID.
// this will be the TaskObject that called this method upon being completed.
for (int i = 0; i < taskObjects.Length; i++)
{
if (taskObjects[i].gameObject.GetInstanceID() == id)
{
// found TaskObject that called this method
TaskObject t = taskObjects[i];
// create json representation of task data for logging
JSONObject task = new JSONObject();
task.Add("spawnMoment", new JSONString(t.getSpawnMoment().ToString()));
task.Add("roverEnterMoment", new JSONString(t.getRoverEnterMoment().ToString()));
task.Add("completionMoment", new JSONString(t.getCompletionMoment().ToString()));
task.Add("numGoalObjects", new JSONNumber(t.getNumGoalObjects()));
// add task to session["tasks"] array
data["session"]["tasks"].AsArray.Add(task);
// debug log the task data
Debug.Log("spawnMoment: " + t.getSpawnMoment());
Debug.Log("roverEnterMoment: " + t.getRoverEnterMoment());
Debug.Log("completionMoment: " + t.getCompletionMoment());
Debug.Log("numGoalObjects: " + t.getNumGoalObjects());
// destroy TaskObject
GameObject.Destroy(t.gameObject);
break;
}
}
}
}
/// <summary>
/// Instantiates a task object. Deactivates it immediately because only the pre
/// task object is visible in the beginning. The task objects are displayed after
/// the pre task object is selected.
/// </summary>
private GameObject InstantiateGameObject(TaskObject obj, Transform startObject = null, bool activeOnStart = false)
{
GameObject prefab = prefabs.Find(p => p.name.Equals(obj.prefabName));
GameObject created = Instantiate(prefab, obj.position + userStartPosition, obj.rotation, taskObjectsParent);
created.transform.localScale = obj.scale;
// Reset transform properties of the target object if not supported by the current technique
if (startObject)
{
if (!chosenTechniques[0].supportedTaskTypes.HasFlag(TaskType.Positioning))
{
created.transform.position = startObject.position;
}
if (!chosenTechniques[0].supportedTaskTypes.HasFlag(TaskType.Rotating))
{
created.transform.rotation = startObject.rotation;
}
if (!chosenTechniques[0].supportedTaskTypes.HasFlag(TaskType.Scaling))
{
created.transform.localScale = startObject.localScale;
}
}
if (created.GetComponent <Takeable>() != null)
{
created.GetComponent <Takeable>().taskObject = obj;
}
currentGameObjects.Add(created);
created.SetActive(activeOnStart);
return(created);
}
// Тестирует обновление статуса у всего поддерева
public async Task UpdateTaskTest()
{
var taskObj1 = new TaskObject
{
Id = 1,
Status = Status.Running
};
var taskObj2 = new TaskObject
{
Id = 2,
Status = Status.Running,
ParentId = 1
};
var taskObj3 = new TaskObject
{
Id = 3,
Status = Status.Assigned,
ParentId = 2
};
await repository.Add(taskObj1);
await repository.Add(taskObj2);
await repository.Add(taskObj3);
taskObj1.Status = Status.Completed;
Assert.ThrowsAsync<TaskRepositoryException>(async () => await repository.Update(taskObj1)); // т.к. у третьей задачи статус Assigned
taskObj3.Status = Status.Running;
await repository.Update(taskObj3);
await repository.Update(taskObj1); // должны обновиться статусы у всех подзадач
var tasks = await repository.GetAll();
Assert.IsTrue(tasks.All(t => t.Status == Status.Completed));
}
/// <summary> 每周奖励 </summary>
public void SendYouYiYuanReward()
{
var list = view_ranking_game.GetRewardList(10);
foreach (var item in list)
{
var token = new CancellationTokenSource();
var obj = new TaskObject {
Userid = item.id, Ranking = item.ranks
};
Task.Factory.StartNew(n =>
{
var temp = n as TaskObject;
if (temp == null)
{
return;
}
var reward = Variable.BASE_YOUYIYUANREWARD.FirstOrDefault(m => m.ranking == temp.Ranking);
if (reward == null)
{
return;
}
if (reward.reward == "")
{
return;
}
(new Message()).BuildMessagesSend(temp.Userid, "游艺园每周奖励", "游艺园第" + temp.Ranking + "名奖励发放", reward.reward);
token.Cancel();
}, obj, token.Token);
}
}
public Task <ListResult <TaskObject> > GetTasksAsync(string searchString, int page, int page_size, string order_by = "", bool descending = false)
{
//var request = new RestRequest(Method.GET);
//request.Resource = "";
//return this.Sdk.ExecuteAsync<ListResult<TaskObject>>(request);
var val = Task.Run(() =>
{
ListResult <TaskObject> tasks = new ListResult <TaskObject>();
for (int i = 1; i < 5; i++)
{
TaskObject task = new TaskObject();
task.name = $"Task {i}";
task.description = $"Description {i}";
//task.Activities = AddActivities(i).items;
tasks.items.Add(task);
}
return(tasks);
});
return(val);
}
public void ReadMasterListFromSQL()
{
var connectionString = @"Data Source=CIM-STF-00417\CMSQLSERVER;Initial Catalog = ChecklistProjectDB; Integrated Security = True";
var sqlConnection = new SqlConnection(connectionString);
using (sqlConnection)
{
sqlConnection.Open();
using (SqlCommand cmd = new SqlCommand("SELECT * FROM ChecklistTasksTable", sqlConnection))
{
using (SqlDataReader reader = cmd.ExecuteReader())
{
if (reader != null)
{
while (reader.Read())
{
TaskObject openTask = new TaskObject()
{
Description = reader["Task Description"].ToString(),
DueDate = (DateTime)reader["Due Date"],
CompletionStatus = (bool)reader["Completion Status"],
};
TaskObjectLogic.masterTaskList.Add(openTask);
}
}
}
}
}
sqlConnection.Close();
}
public ActionResult CreateMethod(TaskObject task)
{
TasksContext context = HttpContext.RequestServices.GetService(typeof(TasksContext)) as TasksContext;
context.InsertTask(task);
return(RedirectToAction("Index", new { moduleID = task.ModuleID }));
}
public bool Remove(TaskObject task)
{
SqlCommand cmd = null;
try
{
ExecuteNonQuery(out cmd, false, "Task_DELETE",
CreateParameter("@taskID", SqlDbType.UniqueIdentifier, task.TaskID, ParameterDirection.Input)
);
return(true);
}
catch (Exception exception1)
{
Exception innerException = exception1;
throw new Exception(MethodBase.GetCurrentMethod().Name, innerException);
}
finally
{
if (cmd != null)
{
cmd.Dispose();
}
cmd = null;
}
}
/// <summary>高级任务推送</summary>
/// <param name="user_id">玩家编号</param>
/// <param name="task">推送任务实体</param>
public void AdvancedWorkPush(Int64 user_id, tg_task task)
{
var token = new CancellationTokenSource();
Object obj = new TaskObject {
user_id = user_id, task = task
};
System.Threading.Tasks.Task.Factory.StartNew(m =>
{
var entity = m as TaskObject;
if (entity == null)
{
return;
}
if (!Variable.OnlinePlayer.ContainsKey(user_id))
{
return;
}
var session = Variable.OnlinePlayer[entity.user_id] as TGGSession;
if (session == null)
{
return;
}
var data = new ASObject(BulidData((int)ResultType.SUCCESS, entity.task));
Push(session, data, (int)WorkCommand.WORK_PUSH_UPDATE);
token.Cancel();
}, obj, token.Token);
}
private void CreateEmailAddress(TaskObject task, string emailAddress)
{
TIS.BL.Internal.Employee blEmp = new TIS.BL.Internal.Employee();
TIS.BL.Internal.Supplier blSup = new TIS.BL.Internal.Supplier();
TIS.BL.Internal.Unknown blUnk = new TIS.BL.Internal.Unknown();
TIS.DL.Internal.Employee.EmployeeObject employee;
TIS.DL.Internal.Supplier.SupplierObject supplier;
TIS.DL.Internal.Unknown.UnknownObject unknown;
TIS.DL.Internal.TaskPeople.TaskPeopleObject taskPeople;
try
{
if (PROF_IT.Common.Functions.Functions.IsEmailAddress(emailAddress))
{
employee = blEmp.GetEmployeeByEmail(emailAddress);
if (employee != null)
{
taskPeople = ProcessEmployee(employee);
taskPeople.Task = task;
task.AssigneesEmployee.Add(taskPeople);
}
supplier = blSup.GetSupplierByEmail(emailAddress);
if (supplier != null)
{
taskPeople = ProcessSupplier(supplier);
taskPeople.Task = task;
task.AssigneesSupplier.Add(taskPeople);
}
if (supplier == null & employee == null)
{
unknown = blUnk.GetUnknownByEmail(emailAddress);
if (unknown != null)
{
taskPeople = ProcessUnknown(unknown);
taskPeople.Task = task;
task.AssigneesUnknown.Add(taskPeople);
}
else
{
//Create Unknown record
unknown = new UnknownObject();
unknown.Email = emailAddress;
unknown.State = PROF_IT.Common.Enumerations.ObjectState.Created;
blUnk.Save(unknown);
taskPeople = ProcessUnknown(unknown);
taskPeople.Task = task;
task.AssigneesUnknown.Add(taskPeople);
}
}
}
}
catch (System.Exception exception1)
{
System.Exception innerException = exception1;
throw new System.Exception(MethodBase.GetCurrentMethod().Name, innerException);
}
}
public void AddTask(Task task, Object o)
{
lock (locker)
{
TaskObject to = new TaskObject(task, o);
_tos.Enqueue(to);
}
}
public SupremeInstore(TaskRunner runner, TaskObject task)
{
Class7.RIuqtBYzWxthF();
this._currentDoc = new HtmlDocument();
this._diData = new Dictionary <string, string>();
this._runner = runner;
this._task = task;
this.SetClient();
}
/// <summary>
/// Is called if a object is released.
/// </summary>
public void ObjectReleased(TaskObject taskObject, GameObject gObj)
{
// move object back to environment if necessary
if (!currentTask.taskTypes.HasFlag(TaskType.Selection) && !gObj.GetComponent <Takeable>().preTaskObject)
{
GameObject currentObj = GetRealObject(gObj);
MoveObjectBackToEnvironment(currentObj);
}
}
public bool GetTaskObject(int taskID, out TaskObject taskObject)
{
taskObject = null;
if (!_mTaskObjectDic.TryGetValue(taskID, out taskObject))
{
return(false);
}
return(true);
}
public void GetTaskFromInputData(String taskDescription, DateTime dueDate)
{
TaskObject newOpenTask = new TaskObject()
{
Description = taskDescription,
DueDate = dueDate,
CompletionStatus = false,
};
masterTaskList.Add(newOpenTask);
}
/// <summary>
/// Adds a new task object to the queue.
/// </summary>
/// <param name="task"></param>
/// <param name="delay">The amount of time in milliseconds to wait before executing the task.</param>
public void Add(TaskObject task, int delay = 0)
{
if (task == null)
{
throw new ArgumentNullException("task");
}
lock(_taskLock)
{
_tasks.Add(new TaskThread(task, delay));
}
}
/// <summary>
/// Adds a new task object to the queue.
/// </summary>
/// <param name="task"></param>
/// <param name="delay">The amount of time in milliseconds to wait before executing the task.</param>
public void Add(TaskObject task, int delay = 0)
{
if (task == null)
{
throw new ArgumentNullException("task");
}
lock (_taskLock)
{
_tasks.Add(new TaskThread(task, delay));
}
}
public void GetDescription(TaskObject task)
{
try
{
task.Description = new TaskDataService().GetDescription(task.TaskID);
}
catch (Exception exception1)
{
Exception innerException = exception1;
throw new Exception(MethodBase.GetCurrentMethod().Name, innerException);
}
}
public async Task <TaskObject> GetTaskObject(string task)
{
string url = baseAddress + $"v2/actor-tasks/{task}?token={_appSettingsSecrets.Value.Token}";
Log.Debug($"Querying: {url}");
string data = await _transport.GetDataString(url);
Log.Debug($"Result: {data}");
TaskObject taskObject = JsonSerializer.Deserialize <TaskObject>(data);
return(taskObject);
}
public void Save(TaskObject task)
{
try
{
CheckTransaction();
new TaskDataService(Transaction).Save(task);
if (task.AssigneesCustomer != null)
{
new TaskPeople(Transaction).Save(task.AssigneesCustomer);
}
if (task.AssigneesEmployee != null)
{
new TaskPeople(Transaction).Save(task.AssigneesEmployee);
}
if (task.AssigneesSupplier != null)
{
new TaskPeople(Transaction).Save(task.AssigneesSupplier);
}
if (task.AssigneesUnknown != null)
{
new TaskPeople(Transaction).Save(task.AssigneesUnknown);
}
if (task.Reporters != null)
{
new TaskPeople(Transaction).Save(task.Reporters);
}
if (task.Subscriptions != null)
{
new TaskSchedule(Transaction).Save(task.Subscriptions);
}
if (IsOwner)
{
Transaction.Commit();
}
}
catch (Exception exception1)
{
if (IsOwner)
{
Transaction.Rollback();
}
Exception innerException = exception1;
throw new Exception(MethodBase.GetCurrentMethod().Name, innerException);
}
finally
{
if (IsOwner)
{
Connection.Close();
}
}
}
/// <summary>
/// Action when task was edited
/// </summary>
private void UpdateTaskAfterEditing(object taskUI)
{
//if ComboBox
if (taskUI != null)
{
TaskObject task = taskUI as TaskObject;
_databaseService.UpdateTaskAsync(task.Task);
}
else
{
_databaseService.UpdateTaskAsync(SelectedListItem.Task);
}
}
public static TaskView Create(TaskObject o)
{
var animal = new TaskView
{
Id = o._task.Id,
Name = o._task.Name,
Description = o._task.Description,
ValidFrom = o._task.ValidFrom,
ValidTo = o._task.ValidTo
};
return(animal);
}
private void btnCancel_Click(object sender, EventArgs e)
{
try
{
TaskMember = _taskOriginal;
this.Close();
}
catch (System.Exception exception1)
{
System.Exception thisException = exception1;
Management.ShowException(thisException);
}
}
private void HandleQueryOut_Raw(TaskObject to)
{
String problem = "";
try
{
if (_con == null || !_con.Ping())
{
String ip = ConfigManager.Ins().Config.GetValue(ConfigKeyConst.DB_SERVER_IP);
_con = _dbManager.CreateConnection(ip, CommonConst.DATABASE_MADVIPER);
}
_con.Open();
List<String> arr = to._o as List<String>;
foreach (String query in arr)
{
MySqlCommand cmd = new MySqlCommand(query, _con);
problem = query;
int ret = cmd.ExecuteNonQuery();
if (ret < 0)
{
logger.Warn("DB Error in DBOutManager.HandleQueryOut_Raw...");
logger.Warn(String.Format("Query: ({0})", problem));
}
else if (ret == 0)
{
if (!query.ToUpper().StartsWith("DELETE"))
{
logger.Warn("DB Error in DBOutManager.HandleQueryOut_Raw...");
logger.Warn(String.Format("Query: ({0})", problem));
}
}
}
}
catch (System.Exception ex)
{
logger.Warn(ex.ToString());
logger.Warn(String.Format("Query: ({0})", problem));
}
finally
{
_dbManager.Close(_con);
}
}
private void HandleTaskObject(TaskObject to)
{
// lock을 잡지 말고 바로 맘놓고 일을 한다.
// 호출하는 곳에서 이미 락을 잡았다.
if (to._task == Task.QueryOut)
{
HandleQueryOut_Raw(to);
}
}
public TaskThread(TaskObject task, int delay)
{
_task = task;
Delay = delay;
}
