void pc_OnError(GXAmiTask task, Exception ex)
{
if (Server.m_Error != null)
{
Server.m_Error(this, ex);
}
DC.AddDeviceError(task, ex, 1);
}
public GXAmiTaskLog(GXAmiTask task)
{
Id = task.Id;
Data = task.Data;
TaskType = task.TaskType;
Priority = task.Priority;
TargetType = task.TargetType;
TargetID = task.TargetID;
TargetDeviceID = task.TargetDeviceID;
UserID = task.UserID;
SenderDataCollectorGuid = task.SenderDataCollectorGuid;
State = task.State;
DataCollectorID = task.DataCollectorID;
DataCollectorGuid = task.DataCollectorGuid;
CreationTime = task.CreationTime;
ClaimTime = task.ClaimTime;
ExpirationTime = task.ExpirationTime;
}
/// <summary>
/// Notify DC if device is connected to the DC.
/// </summary>
/// <param name="Db"></param>
/// <param name="task"></param>
/// <param name="dataCollectorGuid"></param>
/// <returns></returns>
static bool IsDeviceConnectedToDC(IDbConnection Db, GXAmiTask task, Guid dataCollectorGuid)
{
if ((task.TargetType == TargetType.Device || task.TargetType == TargetType.Category ||
task.TargetType == TargetType.Table || task.TargetType == TargetType.Property) &&
dataCollectorGuid != Guid.Empty)
{
string query = string.Format("SELECT COUNT(*) FROM {0} LEFT JOIN {1} ON {0}.DataCollectorId = {1}.ID WHERE Disabled = FALSE AND DeviceID = {2} AND {1}.Guid = '{3}'",
GuruxAMI.Server.AppHost.GetTableName <GXAmiDeviceMedia>(Db),
GuruxAMI.Server.AppHost.GetTableName <GXAmiDataCollector>(Db),
task.TargetDeviceID,
dataCollectorGuid.ToString().Replace("-", ""));
lock (Db)
{
return(Db.SqlScalar <long>(query, null) != 0);
}
}
return(false);
}
/// <summary>
/// Update sender and target to string so it's easier to show them on UI.
/// </summary>
/// <param name="task"></param>
void UpdateTaskTarget(GXAmiTask task)
{
if (string.IsNullOrEmpty(task.SenderAsString))
{
//Update sender name.
if (task.TargetType == TargetType.Device)
{
task.SenderAsString = Db.GetById<GXAmiDevice>(task.TargetID).Name;
}
else if (task.UserID != null)
{
task.SenderAsString = Db.GetById<GXAmiUser>(task.UserID.Value).Name;
}
else if (task.TargetID != 0 && (task.TargetType == TargetType.DataCollector || task.TargetType == TargetType.Media))
{
task.SenderAsString = Db.Select<GXAmiDataCollector>(q => q.Guid == task.DataCollectorGuid)[0].Name;
}
}
//Update target name.
if (string.IsNullOrEmpty(task.TargetAsString))
{
//Update target name.
if (task.TargetType == TargetType.Device)
{
task.TargetAsString = Db.GetById<GXAmiDevice>(task.TargetID).Name;
}
else if (task.TargetID != 0 && (task.TargetType == TargetType.DataCollector || task.TargetType == TargetType.Media))
{
task.TargetAsString = Db.GetById<GXAmiDataCollector>(task.TargetID).Name;
}
else if (task.UserID != null)
{
task.TargetAsString = Db.GetById<GXAmiUser>(task.UserID.Value).Name;
}
}
}
/// <summary>
/// New task is added.
/// </summary>
/// <param name="sender"></param>
/// <param name="tasks"></param>
static void OnTasksAdded(object sender, GXAmiTask[] tasks)
{
foreach (GXAmiTask it in tasks)
{
if (it.TaskType == TaskType.MediaWrite)
{
string[] tmp = it.Data.Split(Environment.NewLine.ToCharArray());
Console.WriteLine(string.Format("{0} Task {1} Added. {2}", it.TaskType, it.Id, tmp[tmp.Length - 1]));
}
else
{
Console.WriteLine(string.Format("{0} Task {1} Added.", it.TaskType, it.Id));
}
}
}
/// <summary>
/// Task is claimed.
/// </summary>
/// <param name="sender"></param>
/// <param name="tasks"></param>
static void OnTasksClaimed(object sender, GXAmiTask[] tasks)
{
foreach (GXAmiTask it in tasks)
{
Console.WriteLine(string.Format("{0} Task {1} claimed.", it.TaskType, it.Id));
}
}
/// <summary>
/// Task is removed.
/// </summary>
/// <param name="sender"></param>
/// <param name="tasks"></param>
static void OnTasksRemoved(object sender, GXAmiTask[] tasks)
{
foreach(GXAmiTask it in tasks)
{
Console.WriteLine(string.Format("Task {0} removed.", it.Id));
}
}
public GXTasksResponse(GXAmiTask[] tasks)
{
this.Items = tasks;
}
public GXTaskUpdateResponse(GXAmiTask[] tasks)
{
this.Tasks = tasks;
}
/// <summary>
/// Some other data collector is clamed task.
/// </summary>
/// <param name="sender"></param>
/// <param name="tasks"></param>
void DC_OnTasksClaimed(object sender, GXAmiTask[] tasks)
{
lock (UnclaimedTasks)
{
foreach (GXAmiTask task in tasks)
{
foreach (GXAmiTask t in UnclaimedTasks)
{
if (t.Id == task.Id && t.State == TaskState.Pending)
{
t.State = TaskState.Succeeded;
TaskModified.Set();
break;
}
}
}
}
}
/// <summary>
/// New task is added for the DC.
/// </summary>
/// <param name="sender"></param>
/// <param name="tasks"></param>
void OnTasksAdded(object sender, GXAmiTask[] tasks)
{
foreach (GXAmiTask task in tasks)
{
System.Diagnostics.Debug.Assert(task.Id != 0);
string claimTime = "";
if (task.ClaimTime != null)
{
claimTime = task.ClaimTime.Value.ToString();
}
//Show task ID when debugging.
#if DEBUG
ListViewItem li = new ListViewItem(new string[] { task.Id.ToString() + " " + GetTaskStatus(task), task.SenderAsString, task.TargetAsString, task.CreationTime.ToString(), claimTime });
#else
ListViewItem li = new ListViewItem(new string[] { GetTaskStatus(task), task.SenderAsString, task.TargetAsString, task.CreationTime.ToString(), claimTime });
#endif
li.Tag = task;
TaskList.Items.Add(li);
TaskToListItem.Add(task.Id, li);
//LogTasks.Add(new GXAmiTaskLog(task));
TaskLogList.VirtualListSize = LogTasks.Count;
}
}
string GetTaskStatus(GXAmiTask task)
{
if (task.TargetType == TargetType.Media)
{
if (task.TaskType == TaskType.MediaState)
{
if (task.State == TaskState.Pending)
{
string[] tmp = task.Data.Split(Environment.NewLine.ToCharArray());
MediaState state = (MediaState)int.Parse(tmp[tmp.Length - 1]);
return task.TaskType.ToString() + " Changing: " + state.ToString();
}
if (task.State == TaskState.Succeeded)
{
return task.TaskType.ToString() + "Changed.";
}
return task.TaskType.ToString();
}
if (task.TaskType == TaskType.MediaWrite)
{
if (task.State == TaskState.Pending)
{
string[] tmp = task.Data.Split(Environment.NewLine.ToCharArray());
return "-> " + GetStateAsString(task.State) + " " + tmp[tmp.Length - 1];
}
return task.TaskType.ToString() + " " + task.State.ToString() + " " + task.Data;
}
return task.TaskType.ToString() + " " + GetStateAsString(task.State);
}
return task.TargetType.ToString() + " " + task.TaskType.ToString() + " " + task.State.ToString();
}
/// <summary>
/// Task is claimed.
/// </summary>
/// <param name="sender"></param>
/// <param name="tasks"></param>
void OnTasksClaimed(object sender, GXAmiTask[] tasks)
{
try
{
foreach (GXAmiTask task in tasks)
{
if (!TaskToListItem.ContainsKey(task.Id))
{
OnTasksAdded(sender, new GXAmiTask[] { task});
}
ListViewItem li = TaskToListItem[task.Id] as ListViewItem;
if (li != null)
{
#if DEBUG
li.SubItems[0].Text = task.Id.ToString() + " " + GetTaskStatus(task);
#else
li.SubItems[0].Text = GetTaskStatus(task);
#endif
li.SubItems[3].Text = task.ClaimTime.Value.ToString();
}
}
}
catch (Exception ex)
{
GXCommon.ShowError(this.ParentComponent, Gurux.DeviceSuite.Properties.Resources.GuruxDeviceSuiteTxt, ex);
}
}
/// <summary>
/// Remove task.
/// </summary>
/// <param name="sender"></param>
/// <param name="tasks"></param>
void OnTasksRemoved(object sender, GXAmiTask[] tasks)
{
foreach (GXAmiTask task in tasks)
{
if (TaskToListItem.ContainsKey(task.Id))
{
ListViewItem li = TaskToListItem[task.Id] as ListViewItem;
if (li != null)
{
TaskList.Items.Remove(li);
TaskToListItem.Remove(task.Id);
}
}
}
}
/// <summary>
/// Task is removed from the DC.
/// </summary>
/// <param name="sender"></param>
/// <param name="tasks"></param>
void DC_OnTasksRemoved(object sender, GXAmiTask[] tasks)
{
lock (UnclaimedTasks)
{
foreach (GXAmiTask task in tasks)
{
if (task.DataCollectorGuid != this.Guid)
{
throw new Exception("Wrong Data Collector.");
}
foreach (GXAmiTask t in UnclaimedTasks)
{
if (t.Id == task.Id)
{
UnclaimedTasks.Remove(t);
break;
}
}
}
if (m_TasksRemoved != null)
{
m_TasksRemoved(this, tasks);
}
}
}
/// <summary>
/// New task is added to the DC.
/// </summary>
/// <param name="sender"></param>
/// <param name="tasks"></param>
void DC_OnTasksAdded(object sender, GXAmiTask[] tasks)
{
lock (UnclaimedTasks)
{
foreach (GXAmiTask task in tasks)
{
System.Diagnostics.Debug.WriteLine("New task added: " + task.Id);
if (task.DataCollectorGuid != Guid.Empty &&
DC.DataCollectorGuid != task.DataCollectorGuid)
{
throw new Exception("Wrong Data Collector.");
}
}
UnclaimedTasks.AddRange(tasks);
if (m_TasksAdded != null)
{
m_TasksAdded(this, tasks.ToArray());
}
TaskModified.Set();
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="tasks"></param>
public GXTaskDeleteResponse(GXAmiTask[] tasks)
{
Tasks = tasks;
}
void Client_OnTasksAdded(object sender, GXAmiTask[] tasks)
{
foreach (GXAmiTask it in tasks)
{
System.Diagnostics.Debug.Assert(it.SenderDataCollectorGuid == Collector.Guid);
if (it.TaskType == TaskType.MediaState)
{
Connected.Set();
string[] tmp = it.Data.Split(new string[]{Environment.NewLine}, StringSplitOptions.None);
string media = tmp[0];
string name = tmp[1];
if (Media == media && MediaName == name)
{
if (ParentDlg.InvokeRequired)
{
ParentDlg.BeginInvoke(new MediaStateChangeEventHandler(OnMediaStateChange), sender, new MediaStateEventArgs((MediaState)Convert.ToInt32(tmp[2])));
}
else
{
OnMediaStateChange(sender, new MediaStateEventArgs((MediaState)Convert.ToInt32(tmp[2])));
}
Client.RemoveTask(it);
}
}
if (it.TaskType == TaskType.MediaWrite)
{
string[] tmp = it.Data.Split(new string[] { "\r\n" }, StringSplitOptions.None);
string media = tmp[0];
string name = tmp[1];
if (Media == media && MediaName == name)
{
ParentDlg.BeginInvoke(new UpdateDataEventHandler(UpdateData), Gurux.Common.GXCommon.HexToBytes(tmp[2], false));
Client.RemoveTask(it);
}
}
}
}
/// <summary>
/// New task is added for the DC.
/// </summary>
/// <param name="sender"></param>
/// <param name="tasks"></param>
void Client_OnTasksAdded(object sender, GXAmiTask[] tasks)
{
if (this.InvokeRequired)
{
this.BeginInvoke(new TasksAddedEventHandler(OnTasksAdded), sender, tasks);
}
else
{
OnTasksAdded(sender, tasks);
}
}
void ConnectAsync(object sender, GXAsyncWork work, object[] parameters)
{
ExecutedTask = Client.MediaOpen((Guid)parameters[0], (string)parameters[1], (string)parameters[2], (string)parameters[3], Connected);
Connected.WaitOne();
}
/// <summary>
/// Notify from new device tasks.
/// </summary>
/// <param name="Db"></param>
/// <param name="task"></param>
/// <param name="e"></param>
void HandleTasks(IDbConnection Db, GXAmiTask task, GXEventsItem e)
{
ulong mask = (ulong)((int)e.Target << 16 | (int)e.Action);
lock (Db)
{
if (task.State == TaskState.Pending)
{
GXAmiTaskLog it = new GXAmiTaskLog(task);
Db.Insert <GXAmiTaskLog>(it);
it.Id = (ulong)Db.GetLastInsertId();
if (it.Data != null)
{
foreach (string value in GXTaskService.SplitByLength(it.Data, 255))
{
GXAmiTaskLogData d = new GXAmiTaskLogData();
d.TaskId = it.Id;
d.Data = value;
Db.Insert(d);
}
}
}
//DC is claimed the task.
else if (task.State == TaskState.Processing)
{
GXAmiTaskLog it = Db.GetById <GXAmiTaskLog>(task.Id);
it.ClaimTime = task.ClaimTime;
Db.UpdateOnly(it, p => p.ClaimTime, q => q.Id == task.Id);
}
else //Task is finished (succeeded or failed)
{
GXAmiTaskLog it = Db.GetById <GXAmiTaskLog>(task.Id);
it.FinishTime = DateTime.Now.ToUniversalTime();
Db.UpdateOnly(it, p => p.FinishTime, q => q.Id == task.Id);
}
}
foreach (GXSession it in Sessions)
{
foreach (GXEvent e1 in it.NotifyClients)
{
if ((mask & e1.Mask) != 0)
{
//Do not notify task sender.
if (task.State == TaskState.Pending && e1.Instance == task.Instance)
{
continue;
}
//Do not notify sender DC.
if (task.State == TaskState.Processing && e1.DataCollectorGuid == task.DataCollectorGuid)
{
continue;
}
//Do not notify other DCs for task success or fail.
if ((task.State == TaskState.Succeeded ||
task.State == TaskState.Failed ||
task.State == TaskState.Timeout) &&
e1.DataCollectorGuid != Guid.Empty &&
e1.DataCollectorGuid != task.DataCollectorGuid)
{
continue;
}
//Notify only super admin, user and DC from the task.
if (e1.SuperAdmin || (e1.UserID != 0 && e1.UserID == task.UserID) ||
e1.DataCollectorGuid == task.DataCollectorGuid ||
//If device is read notify DCs that owns the device.
IsDeviceConnectedToDC(Db, task, e1.DataCollectorGuid))
{
if (e1.DataCollectorGuid != Guid.Empty)
{
System.Diagnostics.Debug.WriteLine("Server notifies: " + task.TaskType.ToString() + " " + task.State.ToString() + " DC: " + e1.DataCollectorGuid.ToString());
}
e1.Rows.Add(e);
it.Received.Set();
}
}
}
}
}
/// <summary>
/// New task is added to DC.
/// </summary>
/// <param name="sender"></param>
/// <param name="tasks"></param>
static void DC_OnTasksAdded(object sender, GXAmiTask[] tasks)
{
/*
foreach (GXAmiTask it in tasks)
{
System.Diagnostics.Debug.WriteLine(string.Format("Task {0} Added.", it.Id));
}
* */
}
