/// <summary>
/// Constructor.
/// </summary>
/// <param name="collector"></param>
public GXAmiCommandPromptForm(GXAmiClient client, GXAmiDataCollector collector)
{
Client = client;
DataCollector = collector;
InitializeComponent();
ConnectingPanel.Dock = DockStyle.Fill;
string selected = null;
if (!string.IsNullOrEmpty(Gurux.DeviceSuite.Properties.Settings.Default.CommandPrompSettings))
{
List<string> arr = new List<string>(Gurux.DeviceSuite.Properties.Settings.Default.CommandPrompSettings.Split(new char[]{';'}));
if (arr.Count > 1)
{
selected = arr[0];
}
}
foreach (string media in collector.Medias)
{
//Gateway is not shown here.
if (media != "Gateway")
{
int pos = MediaCB.Items.Add(media);
if (selected != null && string.Compare(selected, media) == 0)
{
MediaCB.SelectedIndex = pos;
}
}
}
if (MediaCB.SelectedIndex == -1)
{
MediaCB.SelectedIndex = 0;
}
}
public GXAMICommandPromptTab(Control parentForm, GXAmiClient client, GXAmiDataCollector collector, string media, string name, string settings)
{
Settings = settings.Replace(Environment.NewLine, "");
ParentDlg = parentForm;
Media = media;
MediaName = name;
Client = client;
Client.OnDeviceErrorsAdded += new DeviceErrorsAddedEventHandler(Client_OnDeviceErrorsAdded);
Client.OnTasksAdded += new TasksAddedEventHandler(Client_OnTasksAdded);
Collector = collector;
InitializeComponent();
CancelBtn.Dock = CommandPromptTB.Dock = DockStyle.Fill;
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
try
{
CreateCaret(CommandPromptTB.Handle, IntPtr.Zero, 10, CommandPromptTB.Font.Height);
ShowCaret(CommandPromptTB.Handle);
}
catch
{
//It's OK if this fails.
}
}
}
/// <summary>
/// Stop listen events.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public GXEventsUnregisterResponse Put(GXEventsUnregisterRequest request)
{
if (request.Instance.Equals(Guid.Empty))
{
throw new Exception("Guid is empty.");
}
Guid guid = Guid.Empty;
IAuthSession s = this.GetSession(false);
long id;
if (!long.TryParse(s.Id, out id))
{
if (!GXBasicAuthProvider.IsGuid(s.UserAuthName, out guid))
{
throw new ArgumentException("Access denied.");
}
}
AppHost host = this.ResolveService <AppHost>();
host.RemoveEvent(request.Instance, request.DataCollectorGuid);
if (guid != Guid.Empty)
{
//Notify that DC is disconnected.
List <GXEventsItem> events = new List <GXEventsItem>();
lock (Db)
{
GXAmiDataCollector dc = Db.Select <GXAmiDataCollector>(q => q.Guid == guid)[0];
dc.State = Gurux.Device.DeviceStates.None;
Db.UpdateOnly(dc, p => p.StatesAsInt, p => p.Id == dc.Id);
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.State, dc));
}
host.SetEvents(Db, this.Request, 0, events);
}
return(new GXEventsUnregisterResponse());
}
bool FindMediaFromCollector(string media, GXAmiDataCollector collector)
{
if (collector == null)
{
return true;
}
foreach(string it in collector.Medias)
{
if (string.Compare(it, media, true) == 0)
{
return true;
}
}
return false;
}
public static GXAmiDataCollector AddDataCollector(IDbConnection Db)
{
GXAmiDataCollector dc = new GXAmiDataCollector();
dc.Guid = Guid.NewGuid();
dc.MAC = GetMACAddress();
dc.Added = DateTime.Now.ToUniversalTime();
Db.Insert(dc);
#if !SS4
dc.Id = (ulong)Db.GetLastInsertId();
#else
dc.Id = (ulong)Db.LastInsertId();
#endif
return(dc);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="collectors"></param>
/// <param name="medias"></param>
/// <param name="media"></param>
public RedundantForm(GXClient client, GXAmiDataCollector[] collectors, GXAmiMediaType[] medias, GXAmiDeviceMedia media)
{
InitializeComponent();
Client = client;
Collectors = collectors;
Medias = medias;
SelectedMedia = media;
UpdateCollectors();
if (media.DataCollectorId == null)
{
UpdateMedias();
}
if (!string.IsNullOrEmpty(SelectedMedia.Settings))
{
Media.Settings = SelectedMedia.Settings;
((IGXPropertyPage)PropertiesForm).Initialize();
}
}
/// <summary>
/// Update new data collector state.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public GXDataCollectorStateUpdateResponse Put(GXDataCollectorStateUpdateRequest request)
{
List <GXEventsItem> events = new List <GXEventsItem>();
lock (Db)
{
foreach (var it in request.States)
{
#if !SS4
GXAmiDataCollector dc = Db.GetById <GXAmiDataCollector>(it.Key);
#else
GXAmiDataCollector dc = Db.SingleById <GXAmiDataCollector>(it.Key);
#endif
dc.State = it.Value;
Db.UpdateOnly(dc, p => p.State, p => p.Id == it.Key);
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.State, dc));
}
}
AppHost host = this.ResolveService <AppHost>();
host.SetEvents(Db, this.Request, 0, events);
return(new GXDataCollectorStateUpdateResponse());
}
/// <summary>
/// Update trace level for selected devices or Data Collectors.
/// </summary>
public GXTraceUpdateResponse Post(GXTraceUpdateRequest request)
{
List <GXEventsItem> events = new List <GXEventsItem>();
lock (Db)
{
if (request.DataCollectorIDs != null)
{
foreach (ulong id in request.DataCollectorIDs)
{
#if !SS4
GXAmiDataCollector it = Db.GetById <GXAmiDataCollector>(id);
#else
GXAmiDataCollector it = Db.SingleById <GXAmiDataCollector>(id);
#endif
it.TraceLevel = request.Level;
Db.UpdateOnly(it, p => p.TraceLevelAsInt, p => p.Id == id);
events.Add(new GXEventsItem(ActionTargets.Trace, Actions.Edit, it));
}
}
if (request.DeviceIDs != null)
{
foreach (ulong id in request.DeviceIDs)
{
#if !SS4
GXAmiDevice it = Db.GetById <GXAmiDevice>(id);
#else
GXAmiDevice it = Db.SingleById <GXAmiDevice>(id);
#endif
it.TraceLevel = request.Level;
Db.UpdateOnly(it, p => p.TraceLevelAsInt, p => p.Id == id);
events.Add(new GXEventsItem(ActionTargets.Trace, Actions.Edit, it));
}
}
}
AppHost host = this.ResolveService <AppHost>();
host.SetEvents(Db, this.Request, 0, events);
return(new GXTraceUpdateResponse());
}
/// <summary>
/// Get trace level state.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public GXTraceLevelResponse Get(GXTraceLevelRequest request)
{
lock (Db)
{
List <System.Diagnostics.TraceLevel> list = new List <System.Diagnostics.TraceLevel>();
if (request.DataCollectors != null)
{
foreach (Guid guid in request.DataCollectors)
{
GXAmiDataCollector it = Db.Select <GXAmiDataCollector>(q => q.Guid == guid)[0];
list.Add(it.TraceLevel);
}
}
if (request.DeviceIDs != null)
{
foreach (ulong id in request.DeviceIDs)
{
GXAmiDevice it = Db.Select <GXAmiDevice>(q => q.Id == id)[0];
list.Add(it.TraceLevel);
}
}
return(new GXTraceLevelResponse(list.ToArray()));
}
}
public GXAmiDataCollectorForm(GXAmiClient client, GXAmiDataCollector collector, DataCollectorActionType action)
{
Action = action;
Client = client;
InitializeComponent();
Collector = collector;
RefreshBtn.Text = Gurux.DeviceSuite.Properties.Resources.RefreshTxt;
RefreshBtn.Enabled = action != DataCollectorActionType.Add;
if (collector != null)
{
this.NameTB.Text = Collector.Name;
this.IPAddressTB.Text = Collector.IP;
this.DescriptionTB.Text = Collector.Description;
if (Collector.Guid != Guid.Empty)
{
this.GuidTB.Text = Collector.Guid.ToString();
}
if (Collector.LastRequestTimeStamp.HasValue)
{
LastConnectedTB.Text = Collector.LastRequestTimeStamp.Value.ToString();
}
InternalCB.Checked = collector.Internal;
}
}
public GXAmiDeviceSettingsForm(GXAmiClient client, GuruxAMI.Common.GXAmiDevice device, GXAmiDataCollector[] dcs)
{
InitializeComponent();
DataCollectors = dcs;
AvailableMedias = new List<string>();
Client = client;
Device = device;
ulong id = GetAllAvailableMediasFromDCs();
if (Device != null)
{
MediaConnections.AddRange(Device.Medias);
}
this.CollectorsCB.Items.Add("");
foreach (GXAmiDataCollector it in DataCollectors)
{
int pos2 = this.CollectorsCB.Items.Add(it);
if (id == it.Id)
{
this.CollectorsCB.SelectedIndex = pos2;
}
}
if (this.CollectorsCB.SelectedIndex == -1)
{
this.CollectorsCB.SelectedIndex = 0;
}
SettingsPanel.Dock = PropertyGrid.Dock = PresetList.Dock = CustomDeviceProfile.Dock = DockStyle.Fill;
//GuruxAMI.Common.Device type can not be changed after creation. This is for secure reasons.
PresetCB.Enabled = CustomRB.Enabled = PresetList.Enabled = CustomDeviceProfile.Enabled = Device == null;
CustomDeviceProfile.Visible = false;
if (Device != null)
{
//Add redundant conections.
for (int pos = 1; pos < Device.Medias.Length; ++pos)
{
AddConnection(Device.Medias[pos]);
}
NameTB.Text = Device.Name;
RefreshRateTp.Value = new DateTime(((long)Device.UpdateInterval) * 10000000 + RefreshRateTp.MinDate.Ticks);
UpdateResendCnt(Device.ResendCount);
UpdateWaitTime(Device.WaitTime);
//Create UI Device so all assemblys are loaded.
string path = Path.Combine(Gurux.Common.GXCommon.ApplicationDataPath, "Gurux");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
Gurux.Common.GXFileSystemSecurity.UpdateDirectorySecurity(path);
}
path = Path.Combine(path, "Gurux.DeviceSuite");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
Gurux.Common.GXFileSystemSecurity.UpdateDirectorySecurity(path);
}
path = Path.Combine(path, "DeviceProfiles");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
Gurux.Common.GXFileSystemSecurity.UpdateDirectorySecurity(path);
}
path = Path.Combine(path, Device.ProfileGuid.ToString());
//Load Device template if not loaded yet.
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
Gurux.Common.GXFileSystemSecurity.UpdateDirectorySecurity(path);
byte[] data = Client.GetDeviceProfilesData(Device.ProfileGuid);
GXZip.Import(this, data, path + "\\");
}
path = Path.Combine(path, Device.ProfileGuid.ToString() + ".gxp");
UIDevice = GXDevice.Load(path);
}
else
{
RefreshRateTp.Value = new DateTime(((long)1) * 10000000 + RefreshRateTp.MinDate.Ticks);
}
//Add disabled actions.
m_DisActions = new DisabledAction(Device == null ? Gurux.Device.DisabledActions.None : (Gurux.Device.DisabledActions)Device.DisabledActions);
tabControl1.TabPages.Add(m_DisActions.DisabledActionsTB);
this.Text = Gurux.DeviceSuite.Properties.Resources.DeviceSettingsTxt;
this.GeneralTab.Text = Gurux.DeviceSuite.Properties.Resources.GeneralTxt;
//Update helps from the resources.
this.helpProvider1.SetHelpString(this.NameTB, Gurux.DeviceSuite.Properties.Resources.DeviceNameHelp);
this.helpProvider1.SetHelpString(this.MediaCB, Gurux.DeviceSuite.Properties.Resources.MediaListHelp);
this.helpProvider1.SetHelpString(this.RefreshRateTp, Gurux.DeviceSuite.Properties.Resources.RefreshRateHelp);
this.helpProvider1.SetHelpString(this.OkBtn, Gurux.DeviceSuite.Properties.Resources.OKHelp);
this.helpProvider1.SetHelpString(this.CancelBtn, Gurux.DeviceSuite.Properties.Resources.CancelHelp);
}
/// <summary>
/// Start GuruxAMI Data collector as console.
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
//Update previous installed settings.
if (Properties.Settings.Default.UpdateSettings)
{
Properties.Settings.Default.Upgrade();
Properties.Settings.Default.UpdateSettings = false;
Properties.Settings.Default.Save();
}
bool trace = false;
GXAmiDataCollectorServer collector = null;
try
{
for (int pos = 0; pos != args.Length; ++pos)
{
string tag = args[pos];
if (tag[0] == '/' || tag[0] == '-')
{
tag = tag.Substring(1).ToLower();
if (tag == "h")
{
GuruxAMI.DataCollector.Properties.Settings.Default.AmiHostName = args[++pos];
}
if (tag == "p")
{
GuruxAMI.DataCollector.Properties.Settings.Default.AmiHostPort = args[++pos];
}
//Register Data Collector again.
if (tag == "r")
{
GuruxAMI.DataCollector.Properties.Settings.Default.AmiDCGuid = Guid.Empty;
}
//Trace messages
if (tag == "t")
{
trace = true;
}
}
}
string host = GuruxAMI.DataCollector.Properties.Settings.Default.AmiHostName;
if (string.IsNullOrEmpty(host))
{
ShowHelp();
return;
}
Guid guid = GuruxAMI.DataCollector.Properties.Settings.Default.AmiDCGuid;
Console.WriteLine("Starting Data Collector...");
if (!host.StartsWith("http://"))
{
host = "http://" + host + ":" + GuruxAMI.DataCollector.Properties.Settings.Default.AmiHostPort + "/";
}
Console.WriteLine("Connecting " + host);
GXAmiUser user = null;
string r, dcName = null;
GuruxAMI.Client.GXAmiClient cl = null;
if (guid == Guid.Empty)
{
Console.WriteLine("Registering Data Collector to GuruxAMI Service: ");
int pos = 0;
do
{
Console.WriteLine("Enter user name:");
string username = Console.ReadLine();
if (username == "")
{
return;
}
Console.WriteLine("Enter password:"******"")
{
return;
}
cl = new GXAmiClient(host, username, password);
//Get info from registered user.
try
{
user = cl.GetUserInfo();
break;
}
catch (UnauthorizedAccessException)
{
continue;
}
}while(++pos != 3);
//If authorisation failed.
if (user == null)
{
return;
}
Console.WriteLine("Finding data collectors.");
GXAmiDataCollector[] dcs = cl.GetDataCollectors();
//If there are existing DCs...
if (dcs.Length != 0)
{
Console.WriteLine("Do you want to register new data collector or bind old? (n/b)");
do
{
r = Console.ReadLine().Trim().ToLower();
if (r == "n" || r == "b")
{
break;
}
}while (r == "");
}
else
{
r = "n";
}
//Old DC replaced.
if (r == "b")
{
Console.WriteLine("Select data collector number that you want to bind:");
pos = 0;
foreach (GXAmiDataCollector it in dcs)
{
++pos;
Console.WriteLine(pos.ToString() + ". " + it.Name);
}
do
{
r = Console.ReadLine().Trim();
int sel = 0;
if (int.TryParse(r, out sel) && sel > 0 && sel <= pos)
{
guid = dcs[sel - 1].Guid;
break;
}
}while (true);
}
else
{
do
{
Console.WriteLine("Enter name of the data collector:");
dcName = Console.ReadLine().Trim();
if (dcName == "")
{
return;
}
if (cl.Search(new string[] { dcName }, ActionTargets.DataCollector, SearchType.Name).Length == 0)
{
GXAmiDataCollector tmp = new GXAmiDataCollector(dcName, "", "");
cl.AddDataCollector(tmp, cl.GetUserGroups(false));
guid = tmp.Guid;
break;
}
Console.WriteLine("Name exists. Give new one.");
}while (true);
}
}
collector = new GXAmiDataCollectorServer(host, guid);
if (trace)
{
collector.OnTasksAdded += new TasksAddedEventHandler(OnTasksAdded);
collector.OnTasksClaimed += new TasksClaimedEventHandler(OnTasksClaimed);
collector.OnTasksRemoved += new TasksRemovedEventHandler(OnTasksRemoved);
collector.OnError += new ErrorEventHandler(OnError);
}
collector.OnAvailableSerialPorts += new AvailableSerialPortsEventHandler(OnAvailableSerialPorts);
GXAmiDataCollector dc = collector.Init(dcName);
//If new Data collector is added bind it to the user groups.
if (guid == Guid.Empty && cl != null)
{
cl.AddDataCollector(dc, cl.GetUserGroups(false));
}
if (dc != null)
{
GuruxAMI.DataCollector.Properties.Settings.Default.AmiDCGuid = dc.Guid;
}
Console.WriteLine(string.Format("Data Collector '{0}' started.", dc.Name));
GuruxAMI.DataCollector.Properties.Settings.Default.Save();
}
catch (Exception ex)
{
if (ex is UnauthorizedAccessException)
{
Console.WriteLine("Unknown data collector.");
GuruxAMI.DataCollector.Properties.Settings.Default.AmiDCGuid = Guid.Empty;
GuruxAMI.DataCollector.Properties.Settings.Default.Save();
}
else
{
Console.WriteLine(ex.Message);
}
}
//Wait until user press enter.
ConsoleKeyInfo key;
while ((key = System.Console.ReadKey()).Key != ConsoleKey.Enter)
{
System.Console.Write("\b \b");
}
if (collector != null)
{
collector.Dispose();
}
}
public GXDataCollectorUpdateResponse(GXAmiDataCollector[] collectors)
{
this.Collectors = collectors;
}
/// <summary>
/// Start GuruxAMI Data collector as console.
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
//Update previous installed settings.
if (Properties.Settings.Default.UpdateSettings)
{
Properties.Settings.Default.Upgrade();
Properties.Settings.Default.UpdateSettings = false;
Properties.Settings.Default.Save();
}
bool trace = false;
GXAmiDataCollectorServer collector = null;
try
{
for (int pos = 0; pos != args.Length; ++pos)
{
string tag = args[pos];
if (tag[0] == '/' || tag[0] == '-')
{
tag = tag.Substring(1).ToLower();
if (tag == "h")
{
GuruxAMI.DataCollector.Properties.Settings.Default.AmiHostName = args[++pos];
}
if (tag == "p")
{
GuruxAMI.DataCollector.Properties.Settings.Default.AmiHostPort = args[++pos];
}
//Register Data Collector again.
if (tag == "r")
{
GuruxAMI.DataCollector.Properties.Settings.Default.AmiDCGuid = Guid.Empty;
}
//Trace messages
if (tag == "t")
{
trace = true;
}
}
}
string host = GuruxAMI.DataCollector.Properties.Settings.Default.AmiHostName;
if (string.IsNullOrEmpty(host))
{
ShowHelp();
return;
}
Guid guid = GuruxAMI.DataCollector.Properties.Settings.Default.AmiDCGuid;
Console.WriteLine("Starting Data Collector...");
if (!host.StartsWith("http://"))
{
host = "http://" + host + ":" + GuruxAMI.DataCollector.Properties.Settings.Default.AmiHostPort + "/";
}
Console.WriteLine("Connecting " + host);
GXAmiUser user = null;
string r, dcName = null;
GuruxAMI.Client.GXAmiClient cl = null;
if (guid == Guid.Empty)
{
Console.WriteLine("Registering Data Collector to GuruxAMI Service: ");
int pos = 0;
do
{
Console.WriteLine("Enter user name:");
string username = Console.ReadLine();
if (username == "")
{
return;
}
Console.WriteLine("Enter password:"******"")
{
return;
}
cl = new GXAmiClient(host, username, password);
//Get info from registered user.
try
{
user = cl.GetUserInfo();
break;
}
catch(UnauthorizedAccessException)
{
continue;
}
}while(++pos != 3);
//If authorisation failed.
if (user == null)
{
return;
}
Console.WriteLine("Finding data collectors.");
GXAmiDataCollector[] dcs = cl.GetDataCollectors();
//If there are existing DCs...
if (dcs.Length != 0)
{
Console.WriteLine("Do you want to register new data collector or bind old? (n/b)");
do
{
r = Console.ReadLine().Trim().ToLower();
if (r == "n" || r == "b")
{
break;
}
}
while (r == "");
}
else
{
r = "n";
}
//Old DC replaced.
if (r == "b")
{
Console.WriteLine("Select data collector number that you want to bind:");
pos = 0;
foreach (GXAmiDataCollector it in dcs)
{
++pos;
Console.WriteLine(pos.ToString() + ". " + it.Name);
}
do
{
r = Console.ReadLine().Trim();
int sel = 0;
if (int.TryParse(r, out sel) && sel > 0 && sel <= pos)
{
guid = dcs[sel - 1].Guid;
break;
}
}
while (true);
}
else
{
do
{
Console.WriteLine("Enter name of the data collector:");
dcName = Console.ReadLine().Trim();
if (dcName == "")
{
return;
}
if (cl.Search(new string[] { dcName }, ActionTargets.DataCollector, SearchType.Name).Length == 0)
{
GXAmiDataCollector tmp = new GXAmiDataCollector(dcName, "", "");
cl.AddDataCollector(tmp, cl.GetUserGroups(false));
guid = tmp.Guid;
break;
}
Console.WriteLine("Name exists. Give new one.");
}
while (true);
}
}
collector = new GXAmiDataCollectorServer(host, guid);
if (trace)
{
collector.OnTasksAdded += new TasksAddedEventHandler(OnTasksAdded);
collector.OnTasksClaimed += new TasksClaimedEventHandler(OnTasksClaimed);
collector.OnTasksRemoved += new TasksRemovedEventHandler(OnTasksRemoved);
collector.OnError += new ErrorEventHandler(OnError);
}
collector.OnAvailableSerialPorts += new AvailableSerialPortsEventHandler(OnAvailableSerialPorts);
GXAmiDataCollector dc = collector.Init(dcName);
//If new Data collector is added bind it to the user groups.
if (guid == Guid.Empty && cl != null)
{
cl.AddDataCollector(dc, cl.GetUserGroups(false));
}
if (dc != null)
{
GuruxAMI.DataCollector.Properties.Settings.Default.AmiDCGuid = dc.Guid;
}
Console.WriteLine(string.Format("Data Collector '{0}' started.", dc.Name));
GuruxAMI.DataCollector.Properties.Settings.Default.Save();
}
catch (Exception ex)
{
if (ex is UnauthorizedAccessException)
{
Console.WriteLine("Unknown data collector.");
GuruxAMI.DataCollector.Properties.Settings.Default.AmiDCGuid = Guid.Empty;
GuruxAMI.DataCollector.Properties.Settings.Default.Save();
}
else
{
Console.WriteLine(ex.Message);
}
}
//Wait until user press enter.
ConsoleKeyInfo key;
while ((key = System.Console.ReadKey()).Key != ConsoleKey.Enter)
{
System.Console.Write("\b \b");
}
if (collector != null)
{
collector.Dispose();
}
}
/// <summary>
/// Add new Data collector. This is called when database is created and we want to add new DC.
/// </summary>
/// <param name="dc"></param>
public void AddDataCollector(GXAmiDataCollector[] collectors)
{
if (Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors == null)
{
Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors = new System.Collections.Specialized.StringCollection();
}
foreach (GXAmiDataCollector dc in collectors)
{
if (dc.Internal)
{
if (string.IsNullOrEmpty(dc.Name))
{
dc.Description = dc.Name = "Default data collector ";
}
dc.Medias = Gurux.Communication.GXClient.GetAvailableMedias(true);
dc.SerialPorts = Gurux.Serial.GXSerial.GetPortNames();
dc.MAC = GXAmiClient.GetMACAddressAsString();
GXAmiDataCollectorServer cl = StartDataCollector(dc.Guid);
cl.Update(dc);
dc.Internal = true;
}
}
}
public GXDataCollectorsResponse(GXAmiDataCollector[] collectors)
{
Collectors = collectors;
}
void Client_OnDataCollectorStateChanged(object sender, GXAmiDataCollector[] collectors)
{
if (this.InvokeRequired)
{
this.BeginInvoke(new DataCollectorsStateChangedEventHandler(OnDataCollectorStateChanged), sender, collectors);
}
else
{
OnDataCollectorStateChanged(sender, collectors);
}
}
void DC_OnDataCollectorsUpdated(object sender, GXAmiDataCollector[] collectors)
{
foreach (GXAmiDataCollector it in collectors)
{
if (it.Guid == this.DC.DataCollectorGuid)
{
TraceLevel = it.TraceLevel;
break;
}
}
}
/// <summary>
/// Update DC.
/// </summary>
/// <param name="sender"></param>
/// <param name="collectors"></param>
void OnDataCollectorsUpdated(object sender, GXAmiDataCollector[] collectors)
{
try
{
foreach (GXAmiDataCollector it in collectors)
{
if (it.UnAssigned)
{
ListViewItem node = UnassignedDCToListViewItem[it.Guid] as ListViewItem;
if (node != null)
{
node.Text = it.MAC;
}
}
else
{
ListViewItem node = DCToListViewItem[it.Guid] as ListViewItem;
if (node != null)
{
//Update data.
bool Internal = (node.Tag as GXAmiDataCollector).Internal;
node.Tag = it;
it.Internal = Internal;
if (Internal)
{
if (Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors == null)
{
Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors = new StringCollection();
}
if (!Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors.Contains(it.Guid.ToString()))
{
Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors.Add(it.Guid.ToString());
StartDataCollector(it.Guid);
}
}
else if (Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors != null)
{
int pos = Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors.IndexOf(it.Guid.ToString());
if (pos != -1)
{
Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors.RemoveAt(pos);
foreach (GXAmiDataCollectorServer it2 in InternalDCs)
{
if (it2.Guid == it.Guid)
{
it2.Close();
InternalDCs.Remove(it2);
break;
}
}
}
}
if (it.Internal)
{
node.Text = it.Name + " [Internal]";
}
else
{
node.Text = it.Name;
}
}
}
}
}
catch (Exception ex)
{
GXCommon.ShowError(this.ParentComponent, Gurux.DeviceSuite.Properties.Resources.GuruxDeviceSuiteTxt, ex);
}
}
/// <summary>
/// Update data collector settings.
/// </summary>
/// <param name="dc"></param>
public void Update(GXAmiDataCollector dc)
{
DC.Update(dc);
}
/// <summary>
/// Remove DC.
/// </summary>
/// <param name="sender"></param>
/// <param name="collectors"></param>
void OnDataCollectorsRemoved(object sender, GXAmiDataCollector[] collectors)
{
try
{
foreach (GXAmiDataCollector it in collectors)
{
if (it.UnAssigned)
{
UnassignedDCList.Items.Remove(UnassignedDCToListViewItem[it.Guid] as ListViewItem);
UnassignedDCToListViewItem.Remove(it.Guid);
}
else
{
DCList.Items.Remove(DCToListViewItem[it.Guid] as ListViewItem);
DCToListViewItem.Remove(it);
if (Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors != null)
{
foreach (string str in Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors)
{
if (it.Guid.ToString().Equals(str))
{
Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors.Remove(str);
break;
}
}
}
}
}
}
catch (Exception ex)
{
GXCommon.ShowError(this.ParentComponent, Gurux.DeviceSuite.Properties.Resources.GuruxDeviceSuiteTxt, ex);
}
}
/// <summary>
/// Add new DC.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void NewDataCollectorMenuItem_Click(object sender, EventArgs e)
{
try
{
GXAmiUserGroup[] ugs = Client.GetUserGroups(false);
GXAmiDataCollector dc = new GXAmiDataCollector();
GXAmiDataCollectorForm dlg = new GXAmiDataCollectorForm(Client, dc, DataCollectorActionType.Add);
if (dlg.ShowDialog(this.ParentComponent) == System.Windows.Forms.DialogResult.OK)
{
AddDataCollector(new GXAmiDataCollector[]{dc});
}
}
catch (Exception ex)
{
GXCommon.ShowError(this.ParentComponent, Gurux.DeviceSuite.Properties.Resources.GuruxDeviceSuiteTxt, ex);
}
}
/// <summary>
/// Search DC.
/// </summary>
void SearchDC()
{
try
{
DCSearchBtn.Enabled = false;
object[] tmp = Client.Search(new string[] { DCSearchBtn.Text }, ActionTargets.DataCollector, SearchType.All);
//Remove exists DCs.
DCToListViewItem.Clear();
DCList.Items.Clear();
GXAmiDataCollector[] dcs = new GXAmiDataCollector[tmp.Length];
Array.Copy(tmp, dcs, tmp.Length);
OnDataCollectorsAdded(null, dcs);
}
catch (Exception ex)
{
GXCommon.ShowError(this.ParentComponent, Gurux.DeviceSuite.Properties.Resources.GuruxDeviceSuiteTxt, ex);
}
DCSearchBtn.Enabled = true;
DCSearchBtn.Focus();
}
/// <summary>
/// Add new data collector.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public GXDataCollectorUpdateResponse Put(GXDataCollectorUpdateRequest request)
{
GXAmiDataCollector[] collectors = request.Collectors;
IAuthSession s = this.GetSession(false);
long id;
List<GXEventsItem> events = new List<GXEventsItem>();
lock (Db)
{
string lastIP;
#if !SS4
lastIP = GuruxAMI.Server.AppHost.GetIPAddress(base.RequestContext);
#else
lastIP = "";//TODO;
#endif
using (var trans = Db.OpenTransaction(IsolationLevel.ReadCommitted))
{
if (long.TryParse(s.Id, out id))
{
//Normal user can't change add new data collectors.
if (!GuruxAMI.Server.GXBasicAuthProvider.CanEditDevice(s))
{
throw new ArgumentException("Access denied.");
}
bool superAdmin = GuruxAMI.Server.GXBasicAuthProvider.IsSuperAdmin(s);
//If user want's to add new data collectors.
if (request.Collectors != null)
{
foreach (GXAmiDataCollector collector in request.Collectors)
{
if (collector.Id == 0)
{
collector.Guid = Guid.NewGuid();
collector.Added = DateTime.Now.ToUniversalTime();
Db.Insert(collector);
#if !SS4
collector.Id = (ulong)Db.GetLastInsertId();
#else
collector.Id = (ulong)Db.LastInsertId();
#endif
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.Add, collector));
}
else
{
//If DC is added to user group it's state is no longer unassigned.
bool assigned = false;
if (collector.UnAssigned && request.UserGroupIDs != null)
{
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.Remove, collector.Clone()));
assigned = true;
collector.UnAssigned = false;
}
Db.UpdateOnly(collector, p => p.MAC, p => p.Id == collector.Id);
Db.UpdateOnly(collector, p => p.UnAssigned, p => p.Id == collector.Id);
Db.UpdateOnly(collector, p => p.Name, p => p.Id == collector.Id);
Db.UpdateOnly(collector, p => p.Description, p => p.Id == collector.Id);
//If DC is assigned remove it first and then add like assigned.
if (assigned)
{
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.Add, collector));
}
else
{
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.Edit, collector));
}
}
//If data collector is added to device group.
if (request.UserGroupIDs != null)
{
foreach (long it in request.UserGroupIDs)
{
//Can user access user group.
if (!superAdmin && !GXUserGroupService.CanAccess(Db, id, it))
{
throw new ArgumentException("Access denied.");
}
//Check that DC is not already added to the user group.
List<GXAmiDataCollectorUserGroup> dcu = Db.Select<GXAmiDataCollectorUserGroup>(q => q.DataCollectorID == collector.Id && q.UserGroupID == it);
if (dcu.Count == 0)
{
GXAmiDataCollectorUserGroup u = new GXAmiDataCollectorUserGroup();
u.DataCollectorID = collector.Id;
u.UserGroupID = it;
Db.Insert(u);
#if !SS4
GXAmiUserGroup ug = Db.QueryById<GXAmiUserGroup>(it);
#else
GXAmiUserGroup ug = Db.SingleById<GXAmiUserGroup>(it);
#endif
events.Add(new GXEventsItem(ActionTargets.UserGroup, Actions.Edit, ug));
}
}
}
}
}
//User is adding collector by MAC address.
else if (request.MacAddress != null)
{
GXAmiDataCollector it = new GXAmiDataCollector();
collectors = new GXAmiDataCollector[] { it };
it.Guid = Guid.NewGuid();
s.UserAuthName = it.Guid.ToString();
it.Added = DateTime.Now.ToUniversalTime();
it.IP = lastIP;
it.UnAssigned = true;
if (request.MacAddress != null)
{
it.MAC = MacToString(request.MacAddress);
}
Db.Insert(it);
#if !SS4
it.Id = (ulong)Db.GetLastInsertId();
#else
it.Id = (ulong)Db.LastInsertId();
#endif
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.Add, it));
}
else
{
throw new ArgumentNullException("MAC Address.");
}
}
else
{
//DC is updating itself.
if (request.MacAddress == null)
{
Guid guid;
if (!GuruxAMI.Server.GXBasicAuthProvider.IsGuid(s.Id, out guid))
{
throw new ArgumentException("Access denied.");
}
List<GXAmiDataCollector> tmp = Db.Select<GXAmiDataCollector>(q => q.Guid == guid);
if (tmp.Count != 1)
{
throw new ArgumentException("Access denied.");
}
foreach (GXAmiDataCollector col in request.Collectors)
{
col.IP = lastIP;
Db.Update(col);
collectors = request.Collectors;
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.Edit, col));
}
}
else
{
List<GXAmiDataCollector> tmp = Db.Select<GXAmiDataCollector>(q => q.MAC == MacToString(request.MacAddress));
//If data collector is adding itself.
//Check if DC is already try to add itself.
if (tmp.Count == 0)
{
GXAmiDataCollector it = new GXAmiDataCollector();
collectors = new GXAmiDataCollector[] { it };
it.Guid = Guid.NewGuid();
s.UserAuthName = it.Guid.ToString();
it.Added = DateTime.Now.ToUniversalTime();
it.IP = lastIP;
it.UnAssigned = true;
if (request.MacAddress != null)
{
it.MAC = MacToString(request.MacAddress);
}
Db.Insert(it);
#if !SS4
it.Id = (ulong)Db.GetLastInsertId();
#else
it.Id = (ulong)Db.LastInsertId();
#endif
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.Add, it));
}
else
{
collectors = new GXAmiDataCollector[] { tmp[0] };
}
}
}
//Accept changes.
trans.Commit();
}
}
AppHost host = this.ResolveService<AppHost>();
host.SetEvents(Db, this.Request, id, events);
return new GXDataCollectorUpdateResponse(collectors);
}
/// <summary>
/// Add new data collector.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public GXDataCollectorUpdateResponse Put(GXDataCollectorUpdateRequest request)
{
GXAmiDataCollector[] collectors = request.Collectors;
IAuthSession s = this.GetSession(false);
long id;
List <GXEventsItem> events = new List <GXEventsItem>();
lock (Db)
{
string lastIP;
#if !SS4
lastIP = GuruxAMI.Server.AppHost.GetIPAddress(base.RequestContext);
#else
lastIP = "";//TODO;
#endif
using (var trans = Db.OpenTransaction(IsolationLevel.ReadCommitted))
{
if (long.TryParse(s.Id, out id))
{
//Normal user can't change add new data collectors.
if (!GuruxAMI.Server.GXBasicAuthProvider.CanEditDevice(s))
{
throw new ArgumentException("Access denied.");
}
bool superAdmin = GuruxAMI.Server.GXBasicAuthProvider.IsSuperAdmin(s);
//If user want's to add new data collectors.
if (request.Collectors != null)
{
foreach (GXAmiDataCollector collector in request.Collectors)
{
if (collector.Id == 0)
{
collector.Guid = Guid.NewGuid();
collector.Added = DateTime.Now.ToUniversalTime();
Db.Insert(collector);
#if !SS4
collector.Id = (ulong)Db.GetLastInsertId();
#else
collector.Id = (ulong)Db.LastInsertId();
#endif
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.Add, collector));
}
else
{
//If DC is added to user group it's state is no longer unassigned.
bool assigned = false;
if (collector.UnAssigned && request.UserGroupIDs != null)
{
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.Remove, collector.Clone()));
assigned = true;
collector.UnAssigned = false;
}
Db.UpdateOnly(collector, p => p.MAC, p => p.Id == collector.Id);
Db.UpdateOnly(collector, p => p.UnAssigned, p => p.Id == collector.Id);
Db.UpdateOnly(collector, p => p.Name, p => p.Id == collector.Id);
Db.UpdateOnly(collector, p => p.Description, p => p.Id == collector.Id);
//If DC is assigned remove it first and then add like assigned.
if (assigned)
{
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.Add, collector));
}
else
{
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.Edit, collector));
}
}
//If data collector is added to device group.
if (request.UserGroupIDs != null)
{
foreach (long it in request.UserGroupIDs)
{
//Can user access user group.
if (!superAdmin && !GXUserGroupService.CanAccess(Db, id, it))
{
throw new ArgumentException("Access denied.");
}
//Check that DC is not already added to the user group.
List <GXAmiDataCollectorUserGroup> dcu = Db.Select <GXAmiDataCollectorUserGroup>(q => q.DataCollectorID == collector.Id && q.UserGroupID == it);
if (dcu.Count == 0)
{
GXAmiDataCollectorUserGroup u = new GXAmiDataCollectorUserGroup();
u.DataCollectorID = collector.Id;
u.UserGroupID = it;
Db.Insert(u);
#if !SS4
GXAmiUserGroup ug = Db.QueryById <GXAmiUserGroup>(it);
#else
GXAmiUserGroup ug = Db.SingleById <GXAmiUserGroup>(it);
#endif
events.Add(new GXEventsItem(ActionTargets.UserGroup, Actions.Edit, ug));
}
}
}
}
}
//User is adding collector by MAC address.
else if (request.MacAddress != null)
{
GXAmiDataCollector it = new GXAmiDataCollector();
collectors = new GXAmiDataCollector[] { it };
it.Guid = Guid.NewGuid();
s.UserAuthName = it.Guid.ToString();
it.Added = DateTime.Now.ToUniversalTime();
it.IP = lastIP;
it.UnAssigned = true;
if (request.MacAddress != null)
{
it.MAC = MacToString(request.MacAddress);
}
Db.Insert(it);
#if !SS4
it.Id = (ulong)Db.GetLastInsertId();
#else
it.Id = (ulong)Db.LastInsertId();
#endif
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.Add, it));
}
else
{
throw new ArgumentNullException("MAC Address.");
}
}
else
{
//DC is updating itself.
if (request.MacAddress == null)
{
Guid guid;
if (!GuruxAMI.Server.GXBasicAuthProvider.IsGuid(s.Id, out guid))
{
throw new ArgumentException("Access denied.");
}
List <GXAmiDataCollector> tmp = Db.Select <GXAmiDataCollector>(q => q.Guid == guid);
if (tmp.Count != 1)
{
throw new ArgumentException("Access denied.");
}
foreach (GXAmiDataCollector col in request.Collectors)
{
col.IP = lastIP;
Db.Update(col);
collectors = request.Collectors;
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.Edit, col));
}
}
else
{
List <GXAmiDataCollector> tmp = Db.Select <GXAmiDataCollector>(q => q.MAC == MacToString(request.MacAddress));
//If data collector is adding itself.
//Check if DC is already try to add itself.
if (tmp.Count == 0)
{
GXAmiDataCollector it = new GXAmiDataCollector();
collectors = new GXAmiDataCollector[] { it };
it.Guid = Guid.NewGuid();
s.UserAuthName = it.Guid.ToString();
it.Added = DateTime.Now.ToUniversalTime();
it.IP = lastIP;
it.UnAssigned = true;
if (request.MacAddress != null)
{
it.MAC = MacToString(request.MacAddress);
}
Db.Insert(it);
#if !SS4
it.Id = (ulong)Db.GetLastInsertId();
#else
it.Id = (ulong)Db.LastInsertId();
#endif
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.Add, it));
}
else
{
collectors = new GXAmiDataCollector[] { tmp[0] };
}
}
}
//Accept changes.
trans.Commit();
}
}
AppHost host = this.ResolveService <AppHost>();
host.SetEvents(Db, this.Request, id, events);
return(new GXDataCollectorUpdateResponse(collectors));
}
void StartServer(object param)
{
bool initialize = (bool) param;
GXDBService Server = null;
try
{
this.BeginInvoke(new UpdateStatusEventHandler(OnUpdateStatusEventHandler), 0, "Starting GuruxAMI...");
string baseUr = Gurux.DeviceSuite.Properties.Settings.Default.AmiHostName;
bool useServer = Gurux.DeviceSuite.Properties.Settings.Default.AmiHostName.Contains("localhost") || Gurux.DeviceSuite.Properties.Settings.Default.AmiHostName.Contains("*");
if (useServer)
{
string connStr = null;
//If DB is set
if (!string.IsNullOrEmpty(Gurux.DeviceSuite.Properties.Settings.Default.AmiDatabaseHostName))
{
connStr = string.Format("Data Source={0};Initial Catalog={1};Persist Security Info=True;User ID={2};Password={3}",
Gurux.DeviceSuite.Properties.Settings.Default.AmiDatabaseHostName, Gurux.DeviceSuite.Properties.Settings.Default.AmiDatabaseName,
Gurux.DeviceSuite.Properties.Settings.Default.AmiDBUserName, Gurux.DeviceSuite.Properties.Settings.Default.AmiDBPassword);
}
try
{
OrmLiteConnectionFactory f = new OrmLiteConnectionFactory(connStr, false, ServiceStack.OrmLite.MySql.MySqlDialectProvider.Instance);
f.AutoDisposeConnection = true;
Server = new GXDBService(baseUr, f,
Gurux.DeviceSuite.Properties.Settings.Default.AmiDatabaseTablePrefix);
if (Server.IsDatabaseCreated())
{
Server.Update();
}
}
catch (System.Net.HttpListenerException)
{
//If GuruxAMI service is already started.
Server = null;
}
}
else
{
baseUr = Gurux.DeviceSuite.Properties.Settings.Default.AmiHostName;
}
if (Client == null)
{
if (baseUr.Contains("*"))
{
baseUr = baseUr.Replace("*", "localhost");
}
Client = new GXAmiClient(baseUr,
Gurux.DeviceSuite.Properties.Settings.Default.AmiUserName,
Gurux.DeviceSuite.Properties.Settings.Default.AmiPassword);
}
//Create schedule server.
if (SchedulerServer == null)
{
this.BeginInvoke(new UpdateStatusEventHandler(OnUpdateStatusEventHandler), -1, "Starting GuruxAMI schedule server...");
SchedulerServer = new GXAmiSchedulerServer(baseUr,
Gurux.DeviceSuite.Properties.Settings.Default.AmiUserName,
Gurux.DeviceSuite.Properties.Settings.Default.AmiPassword);
}
if (Client.IsDatabaseCreated())
{
Client.OnDeviceProfilesAdded += new DeviceProfilesAddedEventHandler(Client_OnDeviceProfilesAdded);
Client.OnDeviceProfilesRemoved += new DeviceProfilesRemovedEventHandler(Client_OnDeviceProfilesRemoved);
Client.OnDataCollectorsAdded += new DataCollectorsAddedEventHandler(Client_OnDataCollectorsAdded);
Client.OnDataCollectorsRemoved += new DataCollectorsRemovedEventHandler(Client_OnDataCollectorsRemoved);
Client.OnDataCollectorsUpdated += new DataCollectorsUpdatedEventHandler(Client_OnDataCollectorsUpdated);
Client.OnDeviceErrorsAdded += new DeviceErrorsAddedEventHandler(Client_OnDeviceErrorsAdded);
Client.OnDeviceErrorsRemoved += new DeviceErrorsRemovedEventHandler(Client_OnDeviceErrorsRemoved);
Client.OnDeviceGroupsAdded += new DeviceGroupsAddedEventHandler(Client_OnDeviceGroupsAdded);
Client.OnDeviceGroupsRemoved += new DeviceGroupsRemovedEventHandler(Client_OnDeviceGroupsRemoved);
Client.OnDeviceGroupsUpdated += new DeviceGroupsUpdatedEventHandler(Client_OnDeviceGroupsUpdated);
Client.OnDevicesAdded += new DevicesAddedEventHandler(Client_OnDevicesAdded);
Client.OnDevicesRemoved += new DevicesRemovedEventHandler(Client_OnDevicesRemoved);
Client.OnDevicesUpdated += new DevicesUpdatedEventHandler(Client_OnDevicesUpdated);
Client.OnSystemErrorsAdded += new SystemErrorsAddedEventHandler(Client_OnSystemErrorsAdded);
Client.OnSystemErrorsRemoved += new SystemErrorsRemovedEventHandler(Client_OnSystemErrorsRemoved);
Client.OnTasksAdded += new TasksAddedEventHandler(Client_OnTasksAdded);
Client.OnTasksClaimed += new TasksClaimedEventHandler(Client_OnTasksClaimed);
Client.OnTasksRemoved += new TasksRemovedEventHandler(Client_OnTasksRemoved);
Client.OnValueUpdated += new ValueUpdatedEventHandler(Client_OnValueUpdated);
Client.OnDeviceStateChanged += new DeviceStateChangedEventHandler(Client_OnDeviceStateChanged);
Client.OnDataCollectorStateChanged += new DataCollectorsStateChangedEventHandler(Client_OnDataCollectorStateChanged);
Client.OnTraceStateChanged += new TraceStateChangedEventHandler(Client_OnTraceStateChanged);
Client.OnTraceAdded += new TraceAddedEventHandler(Client_OnTraceAdded);
Client.OnTraceClear += new TraceClearEventHandler(Client_OnTraceClear);
Client.OnSchedulesAdded += new SchedulesAddedEventHandler(Client_OnSchedulesAdded);
Client.OnSchedulesRemoved += new SchedulesRemovedEventHandler(Client_OnSchedulesRemoved);
Client.OnSchedulesUpdated += new SchedulesUpdatedEventHandler(Client_OnSchedulesUpdated);
Client.OnSchedulesStateChanged += new SchedulesStateChangedEventHandler(Client_OnSchedulesStateChanged);
Client.StartListenEvents();
SchedulerServer.Start();
//Get all DC automatically.
GXAmiDataCollector[] collectors = new GXAmiDataCollector[0];
if (Gurux.DeviceSuite.Properties.Settings.Default.GetDataCollectorsAutomatically)
{
this.BeginInvoke(new UpdateStatusEventHandler(OnUpdateStatusEventHandler), -1, "Starting GuruxAMI data collectors...");
collectors = Client.GetDataCollectors();
Client_OnDataCollectorsAdded(Client, collectors);
}
if (Gurux.DeviceSuite.Properties.Settings.Default.GetDevicesAutomatically)
{
this.BeginInvoke(new UpdateStatusEventHandler(OnUpdateStatusEventHandler), -1, "Starting GuruxAMI devices...");
DateTime start = DateTime.Now;
GXAmiDevice[] devices = Client.GetDevices(false, DeviceContentType.Main);
Client_OnDevicesAdded(Client, null, devices);
System.Diagnostics.Debug.WriteLine("Getting devices: " + (DateTime.Now - start).TotalSeconds.ToString());
}
//Get all tasks and show them.
Client_OnTasksAdded(Client, Client.GetTasks(TaskState.All, false));
//Get all schedules and show them.
Client_OnSchedulesAdded(Client, Client.GetSchedules());
//Get all device profiles and show them
GXAmiDeviceProfile[] profiles = Client.GetDeviceProfiles(true, false);
Client_OnDeviceProfilesAdded(Client, profiles);
this.BeginInvoke(new ServerStateChanged(OnServerStateChanged), true);
//Start Data Collectors.
if (Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors != null)
{
List<string> tmp = new List<string>(Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors.Cast<string>());
foreach (string str in tmp)
{
Guid guid = new Guid(str);
try
{
GXAmiDataCollector dc = null;
foreach (GXAmiDataCollector it2 in collectors)
{
if (it2.Guid == guid)
{
dc = it2;
break;
}
}
if (dc == null)
{
dc = Client.GetDataCollectorByGuid(guid);
//DC might be null if DC not found from the DB.
if (dc != null)
{
Client_OnDataCollectorsAdded(Client, new GXAmiDataCollector[] { dc });
}
else
{
Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors.Remove(str);
}
}
if (dc != null)
{
dc.Internal = true;
StartDataCollector(guid);
}
}
//If DC is removed.
catch (UnauthorizedAccessException)
{
Gurux.DeviceSuite.Properties.Settings.Default.AmiDataCollectors.Remove(str);
}
}
}
}
else
{
throw new Exception("GuruxAMI database not created.");
}
Started.Set();
this.BeginInvoke(new UpdateStatusEventHandler(OnUpdateStatusEventHandler), 1, Gurux.DeviceSuite.Properties.Resources.ReadyTxt);
}
catch (Exception ex)
{
if (initialize)
{
this.BeginInvoke(new UpdateStatusEventHandler(OnUpdateStatusEventHandler), 1, Gurux.DeviceSuite.Properties.Resources.ReadyTxt);
}
else
{
this.BeginInvoke(new UpdateStatusEventHandler(OnUpdateStatusEventHandler), 2, "GuruxAMI start failed: " + ex.Message);
}
Started.Set();
if (Client != null)
{
Client.Dispose();
Client = null;
}
}
ClosingApplication.WaitOne();
if (SchedulerServer != null)
{
SchedulerServer.Stop();
SchedulerServer = null;
}
if (Server != null)
{
Server.Stop();
Server = null;
}
if (Client != null)
{
Client.Dispose();
Client = null;
}
foreach (GXAmiDataCollectorServer it in DataCollectors)
{
it.Close();
}
ServerThreadClosed.Set();
}
/// <summary>
/// Add new DC.
/// </summary>
/// <param name="sender"></param>
/// <param name="collectors"></param>
void OnDataCollectorsAdded(object sender, GXAmiDataCollector[] collectors)
{
try
{
List<ListViewItem> assigned = new List<ListViewItem>();
List<ListViewItem> unAssigned = new List<ListViewItem>();
foreach (GXAmiDataCollector it in collectors)
{
if (it.UnAssigned)
{
ListViewItem node = new ListViewItem(new string[]{it.MAC, it.IP});
UnassignedDCToListViewItem.Add(it.Guid, node);
unAssigned.Add(node);
node.Tag = it;
}
else
{
ListViewItem node = new ListViewItem(it.Name);
UpdateDCImage(node, it);
DCToListViewItem.Add(it.Guid, node);
assigned.Add(node);
node.Tag = it;
}
}
if (assigned.Count != 0)
{
DCList.Items.AddRange(assigned.ToArray());
}
if (unAssigned.Count != 0)
{
UnassignedDCList.Items.AddRange(unAssigned.ToArray());
}
}
catch (Exception ex)
{
GXCommon.ShowError(this.ParentComponent, Gurux.DeviceSuite.Properties.Resources.GuruxDeviceSuiteTxt, ex);
}
}
void UpdateDCImage(ListViewItem li, GXAmiDataCollector dc)
{
if (dc.State == DeviceStates.Connected)
{
li.ImageIndex = 5;
}
else
{
li.ImageIndex = 4;
}
}
void OnDataCollectorStateChanged(object sender, GXAmiDataCollector[] collectors)
{
foreach (GXAmiDataCollector it in collectors)
{
ListViewItem node = DCToListViewItem[it.Guid] as ListViewItem;
if (node != null)
{
UpdateDCImage(node, it);
}
}
}
public GuruxAMI.Common.Messages.GXEventsItem[] WaitEvents(IDbConnection Db, Guid listenerGuid, out Guid guid)
{
//Wait until event occurs.
GXSession session;
lock (Sessions)
{
session = GetSession(listenerGuid);
//If session not found. This is happening when DC is connected to the server and
//Server is restarted.
if (session == null)
{
guid = Guid.Empty;
return(new GuruxAMI.Common.Messages.GXEventsItem[0]);
//TODO: Check is this better. throw new System.Net.WebException("", System.Net.WebExceptionStatus.RequestCanceled);
}
session.Received.Set();
//Update DC last request time stamp.
foreach (GXEvent it in session.NotifyClients)
{
if (it.DataCollectorGuid != Guid.Empty)
{
lock (Db)
{
GXAmiDataCollector item = Db.Select <GXAmiDataCollector>(q => q.Guid == it.DataCollectorGuid)[0];
item.LastRequestTimeStamp = DateTime.Now.ToUniversalTime();
Db.UpdateOnly(item, p => p.LastRequestTimeStamp, p => p.Guid == it.DataCollectorGuid);
}
}
}
//Search if there are new events that are occurred when client is executed previous action.
bool found = false;
foreach (GXEvent it in session.NotifyClients)
{
if (it.Rows.Count != 0)
{
found = true;
break;
}
}
if (!found)
{
Thread.Sleep(1);
session.Received.Reset();
}
}
session.Received.WaitOne();
lock (Sessions)
{
//Search occurred event.
foreach (GXEvent it in session.NotifyClients)
{
if (it.Rows.Count != 0)
{
guid = it.Instance;
GuruxAMI.Common.Messages.GXEventsItem[] rows = it.Rows.ToArray();
it.Rows.Clear();
return(rows);
}
}
}
guid = Guid.Empty;
return(new GuruxAMI.Common.Messages.GXEventsItem[0]);
}
/// <summary>
/// Start listen events.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public GXEventsRegisterResponse Post(GXEventsRegisterRequest request)
{
if (request.SessionListener.Equals(Guid.Empty) ||
request.Instance.Equals(Guid.Empty))
{
throw new Exception("Listener Guid is empty.");
}
if (request.Actions == Actions.None && request.Targets == ActionTargets.None)
{
return(new GXEventsRegisterResponse());
}
IAuthSession s = this.GetSession(false);
long id = 0;
bool superAdmin = false;
Guid guid = request.DataCollectorGuid;
//Guid is set if DC is retreaving new tasks.
if (long.TryParse(s.Id, out id))
{
superAdmin = GuruxAMI.Server.GXBasicAuthProvider.IsSuperAdmin(s);
}
else
{
if (request.DataCollectorGuid.Equals(Guid.Empty))
{
throw new Exception("Data collector Guid is empty.");
}
}
AppHost host = this.ResolveService <AppHost>();
//Check that there are no several DCs with same Guid.
//Note! This might happend when DC is restarted wrong.
//For this reason we are only give a warning.
List <GXEventsItem> events = new List <GXEventsItem>();
if (host.IsDCRegistered(guid))
{
lock (Db)
{
GXAmiSystemError e = new GXAmiSystemError(1, ActionTargets.SystemError, Actions.State, new Exception("Data collector already exists."));
Db.Insert <GXAmiSystemError>(e);
events.Add(new GXEventsItem(ActionTargets.SystemError, Actions.Add, e));
}
}
ulong mask = (ulong)(((int)request.Targets << 16) | (int)request.Actions);
GXEvent e1 = new GXEvent(id, superAdmin, guid, request.Instance, mask);
host.AddEvent(request.SessionListener, e1);
if (guid != Guid.Empty)
{
//Notify that DC is connected.
lock (Db)
{
GXAmiDataCollector dc = Db.Select <GXAmiDataCollector>(q => q.Guid == guid)[0];
dc.State = Gurux.Device.DeviceStates.Connected;
Db.UpdateOnly(dc, p => p.StatesAsInt, p => p.Id == dc.Id);
events.Add(new GXEventsItem(ActionTargets.DataCollector, Actions.State, dc));
}
host.SetEvents(Db, this.Request, 0, events);
}
return(new GXEventsRegisterResponse());
}
