public GXDeviceDeleteResponse Post(GXDeviceDeleteRequest request)
{
IAuthSession s = this.GetSession(false);
int id = Convert.ToInt32(s.Id);
if (id == 0)
{
throw new ArgumentException("Remove failed. Invalid session ID.");
}
//Normal user can't remove device.
if (!GuruxAMI.Server.GXBasicAuthProvider.CanUserEdit(s))
{
throw new ArgumentException("Access denied.");
}
bool superAdmin = GuruxAMI.Server.GXBasicAuthProvider.IsSuperAdmin(s);
List <GXEventsItem> events = new List <GXEventsItem>();
bool permanently = request.Permanently;
List <GXAmiDevice> devices = new List <GXAmiDevice>();
lock (Db)
{
foreach (ulong it in request.DeviceIDs)
{
if (it == 0)
{
throw new ArgumentException("ID is required");
}
if (!superAdmin && !CanUserAccessDevice(Db, id, it))
{
throw new ArgumentException("Access denied.");
}
#if !SS4
GXAmiDevice device = Db.QueryById <GXAmiDevice>(it);
#else
GXAmiDevice device = Db.SingleById <GXAmiDevice>(it);
#endif
devices.Add(device);
events.Add(new GXEventsItem(ActionTargets.Device, Actions.Remove, device));
}
}
//Notify before delete or DC is not notified because device is not found from the DB.
AppHost host = this.ResolveService <AppHost>();
host.SetEvents(Db, this.Request, id, events);
lock (Db)
{
foreach (GXAmiDevice it in devices)
{
if (permanently)
{
Db.DeleteById <GXAmiDevice>(it.Id);
}
else
{
it.Removed = DateTime.Now.ToUniversalTime();
Db.UpdateOnly(it, p => p.Removed, p => p.Id == it.Id);
}
}
}
return(new GXDeviceDeleteResponse());
}
/// <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>
/// Update new device state.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public GXDeviceStateUpdateResponse Put(GXDeviceStateUpdateRequest request)
{
List <GXEventsItem> events = new List <GXEventsItem>();
lock (Db)
{
foreach (var it in request.States)
{
#if !SS4
GXAmiDevice device = Db.GetById <GXAmiDevice>(it.Key);
#else
GXAmiDevice device = Db.SingleById <GXAmiDevice>(it.Key);
#endif
device.State = it.Value;
Db.UpdateOnly(device, p => p.StatesAsInt, p => p.Id == it.Key);
events.Add(new GXEventsItem(ActionTargets.Device, Actions.State, device));
}
}
AppHost host = this.ResolveService <AppHost>();
host.SetEvents(Db, this.Request, 0, events);
return(new GXDeviceStateUpdateResponse());
}
void IJob.Execute(IJobExecutionContext context)
{
GXAmiClient client = context.JobDetail.JobDataMap["Client"] as GXAmiClient;
ulong id = (ulong)context.JobDetail.JobDataMap["Target"];
GXAmiDevice device = new GXAmiDevice();
//Get schedule
GXAmiSchedule schedule = client.GetSchedule(id);
//Notify that schedule task is started.
client.NotifyScheduleStateChange(schedule, ScheduleState.TaskStart);
//Add tasks.
foreach (GXAmiScheduleTarget t in schedule.Targets)
{
if (t.TargetType == TargetType.Device)
{
device.Id = t.TargetID;
client.Read(device);
}
}
//Notify that schedule task is ended.
client.NotifyScheduleStateChange(schedule, ScheduleState.TaskFinish);
}
/// <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()));
}
}
/// <summary>
/// Create new device from the device template.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public GXCreateDeviceResponse Get(GXCreateDeviceRequest request)
{
lock (Db)
{
//Create devices from the device templates.
List <GXAmiDevice> devices = new List <GXAmiDevice>();
foreach (ulong id in request.Ids)
{
List <GXAmiDeviceProfile> tmp = Db.Select <GXAmiDeviceProfile>(q => q.Id == id);
if (tmp.Count != 1)
{
throw new ArgumentException("Access denied.");
}
GXAmiDevice dev = tmp[0] as GXAmiDevice;
dev.Guid = Guid.NewGuid();
dev.Id = 0;
dev.ProfileId = id;
List <GXAmiParameterTemplate> list = Db.Select <GXAmiParameterTemplate>(q => q.ParentID == id << 16);
dev.Parameters = list.ConvertAll <GXAmiParameter>(new Converter <GXAmiParameterTemplate, GXAmiParameter>(p => p.ToParameter())).ToArray();
devices.Add(dev);
}
return(new GXCreateDeviceResponse(devices.ToArray()));
}
}
public GXDevicesResponse(GXAmiDevice[] devices)
{
this.Devices = devices;
}
internal static void UpdateContent(IDbConnection Db, GXAmiDevice device, DeviceContentType content)
{
string query;
if (content == DeviceContentType.All)
{
device.ProfileGuid = Db.Select <GXAmiDeviceProfile>(q => q.Id == device.ProfileId)[0].Guid;
SortedList <ulong, object> items = new SortedList <ulong, object>();
//Get categories.
device.Categories = Db.Select <GXAmiCategory>(q => q.DeviceID == device.Id).ToArray();
foreach (GXAmiCategory cat in device.Categories)
{
items.Add(cat.Id, cat);
}
//Get tables.
device.Tables = Db.Select <GXAmiDataTable>(q => q.DeviceID == device.Id).ToArray();
foreach (GXAmiDataTable table in device.Tables)
{
items.Add(table.Id, table);
}
//Get properties.
query = string.Format("SELECT * FROM {0} WHERE DeviceID = {1} ORDER BY ParentID, ID",
GuruxAMI.Server.AppHost.GetTableName <GXAmiProperty>(Db),
device.Id);
List <GXAmiProperty> properties = Db.SqlList <GXAmiProperty>(query);
ulong id = 0;
List <GXAmiProperty> list = new List <GXAmiProperty>();
foreach (GXAmiProperty it in properties)
{
//If parent changes.
if (it.ParentID != id)
{
if (id != 0)
{
object target = items[id];
if (target is GXAmiCategory)
{
(target as GXAmiCategory).Properties = list.ToArray();
}
else if (target is GXAmiDataTable)
{
(target as GXAmiDataTable).Columns = list.ToArray();
}
}
id = it.ParentID;
list.Clear();
}
list.Add(it);
}
if (list.Count != 0 && id != 0)
{
object target = items[id];
if (target is GXAmiCategory)
{
(target as GXAmiCategory).Properties = list.ToArray();
}
else if (target is GXAmiDataTable)
{
(target as GXAmiDataTable).Columns = list.ToArray();
}
}
foreach (GXAmiProperty it in properties)
{
items.Add(it.Id, it);
}
items.Add(device.Id, device);
//Get Parameters.
query = string.Format("SELECT * FROM {0} WHERE DeviceID = {1} ORDER BY ParentID, ID",
GuruxAMI.Server.AppHost.GetTableName <GXAmiParameter>(Db),
device.Id);
List <GXAmiParameter> parameters = Db.SqlList <GXAmiParameter>(query);
id = 0;
List <GXAmiParameter> paramList = new List <GXAmiParameter>();
foreach (GXAmiParameter it in parameters)
{
//If parent changes.
if (it.ParentID != id)
{
if (id != 0)
{
object target = items[id];
if (target is GXAmiDevice)
{
(target as GXAmiDevice).Parameters = paramList.ToArray();
}
else if (target is GXAmiCategory)
{
(target as GXAmiCategory).Parameters = paramList.ToArray();
}
else if (target is GXAmiDataTable)
{
(target as GXAmiDataTable).Parameters = paramList.ToArray();
}
else if (target is GXAmiProperty)
{
(target as GXAmiProperty).Parameters = paramList.ToArray();
}
else
{
throw new Exception("Unknown target.");
}
}
id = it.ParentID;
paramList.Clear();
}
paramList.Add(it);
}
if (paramList.Count != 0 && id != 0)
{
object target = items[id];
if (target is GXAmiDevice)
{
(target as GXAmiDevice).Parameters = paramList.ToArray();
}
else if (target is GXAmiCategory)
{
(target as GXAmiCategory).Parameters = paramList.ToArray();
}
else if (target is GXAmiDataTable)
{
(target as GXAmiDataTable).Parameters = paramList.ToArray();
}
else if (target is GXAmiProperty)
{
(target as GXAmiProperty).Parameters = paramList.ToArray();
}
else
{
throw new Exception("Unknown target.");
}
}
items.Clear();
foreach (GXAmiParameter it in parameters)
{
items.Add(it.TemplateId, it);
}
//Get Parameters.
query = string.Format("SELECT * FROM {0} WHERE ProfileId = {1} ORDER BY ParameterId, ID",
GuruxAMI.Server.AppHost.GetTableName <GXAmiValueItem>(Db),
device.ProfileId);
List <GXAmiValueItem> values = Db.SqlList <GXAmiValueItem>(query);
id = 0;
List <GXAmiValueItem> valueList = new List <GXAmiValueItem>();
foreach (GXAmiValueItem it in values)
{
//If parent changes.
if (it.ParameterId != null && it.ParameterId != id)
{
if (id != 0)
{
if (items.ContainsKey(id))
{
object target = items[id];
(target as GXAmiParameter).Values = valueList.ToArray();
}
else
{
System.Diagnostics.Debug.WriteLine("Failed to find value item parent: " + it.UIValue);
}
}
id = it.ParameterId.Value;
valueList.Clear();
}
valueList.Add(it);
}
}
//Get Media settings.
query = "SELECT * FROM " + GuruxAMI.Server.AppHost.GetTableName <GXAmiDeviceMedia>(Db) +
" WHERE DeviceId = " + device.Id.ToString();
List <GXAmiDeviceMedia> list2 = Db.Select <GXAmiDeviceMedia>(query);
device.Medias = list2.ToArray();
}
/// <summary>
/// Add or update device.
/// </summary>
public GXDeviceUpdateResponse Put(GXDeviceUpdateRequest request)
{
List <GXEventsItem> events = new List <GXEventsItem>();
IAuthSession s = this.GetSession(false);
//Normal user can't change device group name or add new one.
if (!GuruxAMI.Server.GXBasicAuthProvider.CanUserEdit(s))
{
throw new ArgumentException("Access denied.");
}
long adderId = Convert.ToInt64(s.Id);
lock (Db)
{
using (var trans = Db.OpenTransaction(IsolationLevel.ReadCommitted))
{
bool newDevice;
bool superAdmin = GuruxAMI.Server.GXBasicAuthProvider.IsSuperAdmin(s);
//Add new device groups
foreach (GXAmiDevice it in request.Devices)
{
if (string.IsNullOrEmpty(it.Name))
{
throw new ArgumentException("Invalid name.");
}
//If new device.
newDevice = it.Id == 0;
if (newDevice)
{
it.Id = GXAmiSettings.GetNewDeviceID(Db);
it.Added = DateTime.Now.ToUniversalTime();
it.ProfileGuid = Db.Select <GXAmiDeviceProfile>(q => q.Id == it.ProfileId)[0].Guid;
Db.Insert(it);
events.Add(new GXEventsItem(ActionTargets.Device, Actions.Add, it));
//Add adder to user group if adder is not super admin.
foreach (ulong dgId in request.DeviceGroups)
{
//Can user access to the device group.
if (!superAdmin && dgId != 0 && !GXDeviceGroupService.CanUserAccessDeviceGroup(Db, adderId, dgId))
{
throw new ArgumentException("Access denied.");
}
GXAmiDeviceGroupDevice g = new GXAmiDeviceGroupDevice();
g.DeviceGroupID = dgId;
g.DeviceID = it.Id;
g.Added = DateTime.Now.ToUniversalTime();
Db.Insert(g);
events.Add(new GXEventsItem(ActionTargets.DeviceGroup, Actions.Edit, dgId));
}
it.Categories = null;
it.Tables = null;
}
else //Update device.
{
if (request.DeviceGroups != null)
{
foreach (ulong dgId in request.DeviceGroups)
{
//Can user access to the device group.
if (!superAdmin && !GXDeviceGroupService.CanUserAccessDeviceGroup(Db, adderId, dgId))
{
throw new ArgumentException("Access denied.");
}
if (dgId == 0)
{
GXAmiDeviceGroupDevice g = new GXAmiDeviceGroupDevice();
g.DeviceGroupID = dgId;
g.DeviceID = it.Id;
g.Added = DateTime.Now.ToUniversalTime();
Db.Insert(g);
events.Add(new GXEventsItem(ActionTargets.DeviceGroup, Actions.Edit, dgId));
}
}
}
//Get Added time.
#if !SS4
GXAmiDevice orig = Db.GetById <GXAmiDevice>(it.Id);
#else
GXAmiDevice orig = Db.SingleById <GXAmiDevice>(it.Id);
#endif
it.Added = orig.Added;
Db.Update(it);
events.Add(new GXEventsItem(ActionTargets.Device, Actions.Edit, it));
}
//Bind user groups to the device groups.
if (request.DeviceGroups != null)
{
foreach (ulong dgId in request.DeviceGroups)
{
string query = string.Format("SELECT DeviceID FROM " +
GuruxAMI.Server.AppHost.GetTableName <GXAmiDeviceGroupDevice>(Db) +
"WHERE DeviceID = {0} AND DeviceGroupID = {1}", it.Id, dgId);
if (Db.Select <GXAmiUserGroupDeviceGroup>(query).Count == 0)
{
GXAmiDeviceGroupDevice item = new GXAmiDeviceGroupDevice();
item.DeviceGroupID = dgId;
item.DeviceID = it.Id;
item.Added = DateTime.Now.ToUniversalTime();
Db.Insert <GXAmiUserGroupDeviceGroup>();
events.Add(new GXEventsItem(ActionTargets.Device, Actions.Edit, it));
events.Add(new GXEventsItem(ActionTargets.DeviceGroup, Actions.Edit, dgId));
}
}
}
///////////////////////////////////////////////
//Update device parameters.
UpdateParameters(Db, it.Id, it.Id, it.Parameters, newDevice);
//Update device Media Settings.
Db.Delete <GXAmiDeviceMedia>(q => q.DeviceId == it.Id);
foreach (GXAmiDeviceMedia m in it.Medias)
{
if (m.DataCollectorId == 0)
{
m.DataCollectorId = null;
}
m.DeviceId = it.Id;
Db.Insert <GXAmiDeviceMedia>(m);
}
///////////////////////////////////////////////
//Update categories
if (it.Categories == null)
{
GXAmiCategoryTemplate[] tmp22 = Db.Select <GXAmiCategoryTemplate>(q => q.DeviceID == it.ProfileId).ToArray();
List <GXAmiCategory> categories = new List <GXAmiCategory>();
foreach (GXAmiCategoryTemplate tmp in tmp22)
{
GXAmiCategory cat = tmp.ToCategory();
cat.DeviceID = it.Id;
Db.Insert(cat);
categories.Add(cat);
List <GXAmiParameterTemplate> list = Db.Select <GXAmiParameterTemplate>(q => q.ParentID == tmp.Id);
cat.Parameters = list.ConvertAll <GXAmiParameter>(new Converter <GXAmiParameterTemplate, GXAmiParameter>(p => p.ToParameter())).ToArray();
UpdateParameters(Db, it.Id, cat.Id, cat.Parameters, true);
GXAmiPropertyTemplate[] tmp23 = Db.Select <GXAmiPropertyTemplate>(q => q.ParentID == tmp.Id).ToArray();
List <GXAmiProperty> properties = new List <GXAmiProperty>();
foreach (GXAmiPropertyTemplate tmp2 in tmp23)
{
GXAmiProperty p = tmp2.ToProperty();
p.ParentID = cat.Id;
p.DeviceID = it.Id;
Db.Insert(p);
list = Db.Select <GXAmiParameterTemplate>(q => q.ParentID == tmp2.Id);
p.Parameters = list.ConvertAll <GXAmiParameter>(new Converter <GXAmiParameterTemplate, GXAmiParameter>(q => q.ToParameter())).ToArray();
UpdateParameters(Db, it.Id, p.Id, p.Parameters, true);
properties.Add(p);
}
cat.Properties = properties.ToArray();
}
it.Categories = categories.ToArray();
}
else
{
foreach (GXAmiCategory cat in it.Categories)
{
//User can change category so it is not updated. Db.Update(cat);
//Update category parameters.
UpdateParameters(Db, cat.Id, cat.Id, cat.Parameters, false);
//Update properties
foreach (GXAmiProperty p in cat.Properties)
{
//User can change property so it is not updated. Db.Update(p);
//Update property parameters.
UpdateParameters(Db, p.Id, p.Id, p.Parameters, false);
}
}
}
///////////////////////////////////////////////
//Update tables
if (it.Tables == null)
{
GXAmiDataTableTemplate[] tmp22 = Db.Select <GXAmiDataTableTemplate>(q => q.DeviceID == it.ProfileId).ToArray();
List <GXAmiDataTable> tables = new List <GXAmiDataTable>();
foreach (GXAmiDataTableTemplate tmp in tmp22)
{
GXAmiDataTable table = tmp.ToTable();
table.DeviceID = it.Id;
Db.Insert(table);
tables.Add(table);
List <GXAmiParameterTemplate> list = Db.Select <GXAmiParameterTemplate>(q => q.ParentID == tmp.Id);
table.Parameters = list.ConvertAll <GXAmiParameter>(new Converter <GXAmiParameterTemplate, GXAmiParameter>(p => p.ToParameter())).ToArray();
UpdateParameters(Db, it.Id, table.Id, table.Parameters, true);
GXAmiPropertyTemplate[] tmp23 = Db.Select <GXAmiPropertyTemplate>(q => q.ParentID == tmp.Id).ToArray();
List <GXAmiProperty> properties = new List <GXAmiProperty>();
foreach (GXAmiPropertyTemplate tmp2 in tmp23)
{
GXAmiProperty p = tmp2.ToProperty();
p.ParentID = table.Id;
p.DeviceID = it.Id;
Db.Insert(p);
list = Db.Select <GXAmiParameterTemplate>(q => q.ParentID == tmp2.Id);
p.Parameters = list.ConvertAll <GXAmiParameter>(new Converter <GXAmiParameterTemplate, GXAmiParameter>(q => q.ToParameter())).ToArray();
UpdateParameters(Db, it.Id, p.Id, p.Parameters, true);
properties.Add(p);
}
table.Columns = properties.ToArray();
}
it.Tables = tables.ToArray();
}
else
{
foreach (GXAmiDataTable table in it.Tables)
{
//User can change table so it is not updated. Db.Update(table);
//Update category parameters.
UpdateParameters(Db, table.Id, table.Id, table.Parameters, false);
//Update properties
foreach (GXAmiProperty p in table.Columns)
{
//User can change category so it is not updated. Db.Update(p);
//Update property parameters.
UpdateParameters(Db, p.Id, p.Id, p.Parameters, false);
}
}
}
}
trans.Commit();
}
}
AppHost host = this.ResolveService <AppHost>();
host.SetEvents(Db, this.Request, adderId, events);
return(new GXDeviceUpdateResponse(request.Devices));
}
internal static void UpdateContent(IDbConnection Db, GXAmiDevice device, DeviceContentType content)
{
string query;
if (content == DeviceContentType.All)
{
device.ProfileGuid = Db.Select<GXAmiDeviceProfile>(q => q.Id == device.ProfileId)[0].Guid;
SortedList<ulong, object> items = new SortedList<ulong, object>();
//Get categories.
device.Categories = Db.Select<GXAmiCategory>(q => q.DeviceID == device.Id).ToArray();
foreach(GXAmiCategory cat in device.Categories)
{
items.Add(cat.Id, cat);
}
//Get tables.
device.Tables = Db.Select<GXAmiDataTable>(q => q.DeviceID == device.Id).ToArray();
foreach(GXAmiDataTable table in device.Tables)
{
items.Add(table.Id, table);
}
//Get properties.
query = string.Format("SELECT * FROM {0} WHERE DeviceID = {1} ORDER BY ParentID, ID",
GuruxAMI.Server.AppHost.GetTableName<GXAmiProperty>(Db),
device.Id);
List<GXAmiProperty> properties = Db.SqlList<GXAmiProperty>(query);
ulong id = 0;
List<GXAmiProperty> list = new List<GXAmiProperty>();
foreach (GXAmiProperty it in properties)
{
//If parent changes.
if (it.ParentID != id)
{
if (id != 0)
{
object target = items[id];
if (target is GXAmiCategory)
{
(target as GXAmiCategory).Properties = list.ToArray();
}
else if (target is GXAmiDataTable)
{
(target as GXAmiDataTable).Columns = list.ToArray();
}
}
id = it.ParentID;
list.Clear();
}
list.Add(it);
}
if (list.Count != 0 && id != 0)
{
object target = items[id];
if (target is GXAmiCategory)
{
(target as GXAmiCategory).Properties = list.ToArray();
}
else if (target is GXAmiDataTable)
{
(target as GXAmiDataTable).Columns = list.ToArray();
}
}
foreach (GXAmiProperty it in properties)
{
items.Add(it.Id, it);
}
items.Add(device.Id, device);
//Get Parameters.
query = string.Format("SELECT * FROM {0} WHERE DeviceID = {1} ORDER BY ParentID, ID",
GuruxAMI.Server.AppHost.GetTableName<GXAmiParameter>(Db),
device.Id);
List<GXAmiParameter> parameters = Db.SqlList<GXAmiParameter>(query);
id = 0;
List<GXAmiParameter> paramList = new List<GXAmiParameter>();
foreach (GXAmiParameter it in parameters)
{
//If parent changes.
if (it.ParentID != id)
{
if (id != 0)
{
object target = items[id];
if (target is GXAmiDevice)
{
(target as GXAmiDevice).Parameters = paramList.ToArray();
}
else if (target is GXAmiCategory)
{
(target as GXAmiCategory).Parameters = paramList.ToArray();
}
else if (target is GXAmiDataTable)
{
(target as GXAmiDataTable).Parameters = paramList.ToArray();
}
else if (target is GXAmiProperty)
{
(target as GXAmiProperty).Parameters = paramList.ToArray();
}
else
{
throw new Exception("Unknown target.");
}
}
id = it.ParentID;
paramList.Clear();
}
paramList.Add(it);
}
if (paramList.Count != 0 && id != 0)
{
object target = items[id];
if (target is GXAmiDevice)
{
(target as GXAmiDevice).Parameters = paramList.ToArray();
}
else if (target is GXAmiCategory)
{
(target as GXAmiCategory).Parameters = paramList.ToArray();
}
else if (target is GXAmiDataTable)
{
(target as GXAmiDataTable).Parameters = paramList.ToArray();
}
else if (target is GXAmiProperty)
{
(target as GXAmiProperty).Parameters = paramList.ToArray();
}
else
{
throw new Exception("Unknown target.");
}
}
items.Clear();
foreach (GXAmiParameter it in parameters)
{
items.Add(it.TemplateId, it);
}
//Get Parameters.
query = string.Format("SELECT * FROM {0} WHERE ProfileId = {1} ORDER BY ParameterId, ID",
GuruxAMI.Server.AppHost.GetTableName<GXAmiValueItem>(Db),
device.ProfileId);
List<GXAmiValueItem> values = Db.SqlList<GXAmiValueItem>(query);
id = 0;
List<GXAmiValueItem> valueList = new List<GXAmiValueItem>();
foreach (GXAmiValueItem it in values)
{
//If parent changes.
if (it.ParameterId != null && it.ParameterId != id)
{
if (id != 0)
{
if (items.ContainsKey(id))
{
object target = items[id];
(target as GXAmiParameter).Values = valueList.ToArray();
}
else
{
System.Diagnostics.Debug.WriteLine("Failed to find value item parent: " + it.UIValue);
}
}
id = it.ParameterId.Value;
valueList.Clear();
}
valueList.Add(it);
}
}
//Get Media settings.
query = "SELECT * FROM " + GuruxAMI.Server.AppHost.GetTableName<GXAmiDeviceMedia>(Db) +
" WHERE DeviceId = " + device.Id.ToString();
List<GXAmiDeviceMedia> list2 = Db.Select<GXAmiDeviceMedia>(query);
device.Medias = list2.ToArray();
}
/// <summary>
/// Search device.
/// </summary>
void SearchDevice()
{
try
{
DeviceSearchBtn.Enabled = false;
object[] tmp = Client.Search(new string[] { DeviceSearchBtn.Text }, ActionTargets.Device, SearchType.All);
//Remove exists devices.
PropertyList.Items.Clear();
PropertyToListItem.Clear();
DevicesList.Items.Clear();
DeviceToListItem.Clear();
GXAmiDevice[] dcs = new GXAmiDevice[tmp.Length];
Array.Copy(tmp, dcs, tmp.Length);
OnDevicesAdded(null, null, dcs);
}
catch (Exception ex)
{
GXCommon.ShowError(this.ParentComponent, Gurux.DeviceSuite.Properties.Resources.GuruxDeviceSuiteTxt, ex);
}
DeviceSearchBtn.Enabled = true;
DeviceSearchBtn.Focus();
}
/// <summary>
/// Device settings are changed.
/// </summary>
/// <param name="sender"></param>
/// <param name="devices"></param>
void DC_OnDevicesUpdated(object sender, GXAmiDevice[] devices)
{
return;
}
/// <summary>
/// If device is removed remove device templates.
/// </summary>
/// <param name="sender"></param>
/// <param name="devices"></param>
void DC_OnDevicesRemoved(object sender, GXAmiDevice[] devices)
{
//TODO: Delete template files.
}
public GXCreateDeviceResponse(GXAmiDevice[] devices)
{
Devices = devices;
}
/// <summary>
/// Schedule is started or stopped.
/// </summary>
/// <param name="sender"></param>
/// <param name="schedules"></param>
void Client_OnSchedulesStateChanged(object sender, GXAmiSchedule[] schedules)
{
//Update schedule state.
lock (Schedules)
{
GXAmiDevice device = new GXAmiDevice();
foreach (GXAmiSchedule it in schedules)
{
if (Schedules[it.Id].Status != it.Status)
{
Schedules[it.Id].Status = it.Status;
if (it.Status == ScheduleState.Run)
{
foreach (GXAmiScheduleTarget t in Schedules[it.Id].Targets)
{
if (t.TargetType == TargetType.Device)
{
device.Id = t.TargetID;
Client.Read(device);
}
}
}
else if (it.Status == ScheduleState.Start)
{
System.Collections.Generic.IDictionary<string, object> data = new Dictionary<string, object>();
data.Add(new KeyValuePair<string, object>("Client", Client));
//Target is added by ID because devices can be added or removed from it.
data.Add(new KeyValuePair<string, object>("Target", it.Id));
JobKey id = new JobKey(it.Name + it.Id.ToString(), it.Name + it.Id.ToString());
IJobDetail job = JobBuilder.Create(typeof(GXScheduleJob)).WithIdentity(new JobKey(it.Name + it.Id.ToString(), it.Name + it.Id.ToString()))
.WithIdentity(id)
.SetJobData(new JobDataMap(data))
.Build();
ITrigger t = GetTrigger(it);
m_sched.ScheduleJob(job, t);
}
else if (it.Status == ScheduleState.End)
{
if ((it.Status & ScheduleState.Run) != 0)
{
it.Status = ScheduleState.None;
m_sched.DeleteJob(new JobKey(it.Name + it.Id.ToString(), it.Name + it.Id.ToString()));
}
}
}
}
}
if (m_ScheduleStateChanged != null)
{
m_ScheduleStateChanged(sender, schedules);
}
}
