public void AddUserRolesTest()
{
GXUser user = new GXUser();
user.Id = "642c8f77-aeeb-4e86-86db-1a8b1b2fc982";
user.UserName = "******";
List <string> roles = new List <string>();
roles.Add("Admin");
roles.Add("User");
roles.Add("DeviceManager");
roles.Add("SystemErrorManager");
GXSelectArgs sel = GXSelectArgs.Select <GXRole>(q => q.Id);
GXSelectArgs sel2 = GXSelectArgs.Select <GXUserRole>(q => q.UserId, q => q.UserId == "642c8f77-aeeb-4e86-86db-1a8b1b2fc982");
sel.Where.And <GXRole>(q => !GXSql.Exists <GXRole, GXUserRole>(q => q.Id, q => q.RoleId, sel2));
sel.Where.And <GXRole>(q => roles.Contains(q.Name));
GXUserRole ur = new GXUserRole();
ur.UserId = user.Id;
GXInsertArgs i = GXInsertArgs.Insert(ur);
i.Add <GXUserRole>(sel, q => q.RoleId);
Assert.AreEqual("", i.ToString());
}
public ActionResult <AddSystemErrorResponse> Post(AddSystemError request)
{
request.Error.Generation = DateTime.Now;
host.Connection.Insert(GXInsertArgs.Insert(request.Error));
host.SetChange(TargetType.SystemError, DateTime.Now);
return(new AddSystemErrorResponse());
}
public ActionResult <AddReaderResponse> Post(AddReader request)
{
GXSelectArgs arg = GXSelectArgs.SelectAll <GXReaderInfo>();
arg.Where.And <GXReaderInfo>(q => q.Guid == request.Reader.Guid);
GXReaderInfo i = host.Connection.SingleOrDefault <GXReaderInfo>(arg);
if (i == null)
{
request.Reader.Detected = request.Reader.Generation = DateTime.Now;
host.Connection.Insert(GXInsertArgs.Insert(request.Reader));
}
else if (i.Name != request.Reader.Name && !string.IsNullOrEmpty(request.Reader.Name))
{
//Update reader name.
i.Detected = DateTime.Now;
host.Connection.Update(GXUpdateArgs.Update(i, u => new { u.Detected, u.Name }));
}
else
{
i.Detected = DateTime.Now;
host.Connection.Update(GXUpdateArgs.Update(i, u => u.Detected));
}
host.SetChange(TargetType.Readers, DateTime.Now);
return(new AddReaderResponse());
}
public void InsertTest()
{
TestClass t = new TestClass();
t.Text = "Gurux";
GXInsertArgs args = GXInsertArgs.Insert(t, x => new { x.Text, x.Guid });
Assert.AreEqual("INSERT INTO TestClass (`Text`, `Guid`) VALUES('Gurux', '00000000000000000000000000000000')", args.ToString());
}
public void ExcludeInsertTest()
{
TestClass t = new TestClass();
t.Text = "Gurux";
GXInsertArgs args = GXInsertArgs.Insert(t);
args.Exclude <TestClass>(x => new { x.Time, x.Text2, x.Text3, x.Text4, x.BooleanTest, x.IntTest, x.DoubleTest, x.FloatTest, x.Span, x.Object, x.Status });
Assert.AreEqual("INSERT INTO TestClass (`Guid`, `Text`) VALUES('00000000000000000000000000000000', 'Gurux')", args.ToString());
}
public ActionResult <AddDeviceLogResponse> Post(AddDeviceLog request)
{
AddDeviceLogResponse ret = new AddDeviceLogResponse();
DateTime now = DateTime.Now;
foreach (var it in request.Logs)
{
it.Generation = now;
host.Connection.Insert(GXInsertArgs.Insert(it));
}
host.SetChange(TargetType.DeviceLog, DateTime.Now);
return(ret);
}
public ActionResult <UpdateScheduleResponse> Post(UpdateSchedule request)
{
if (request.Schedules == null || request.Schedules.Count == 0)
{
return(BadRequest("Schedules array is empty."));
}
UpdateScheduleResponse ret = new UpdateScheduleResponse();
List <UInt64> list = new List <UInt64>();
List <GXScheduleToAttribute> list2 = new List <GXScheduleToAttribute>();
foreach (var it in request.Schedules)
{
List <GXObject> tmp = it.Objects;
it.Objects = null;
if (it.Id == 0)
{
host.Connection.Insert(GXInsertArgs.Insert(it));
list.Add(it.Id);
if (tmp != null)
{
foreach (GXObject o in tmp)
{
if (o.Attributes != null)
{
foreach (GXAttribute a in o.Attributes)
{
list2.Add(new GXScheduleToAttribute()
{
ScheduleId = it.Id, AttributeId = a.Id
});
}
}
}
host.Connection.Insert(GXInsertArgs.InsertRange(list2));
}
}
else
{
host.Connection.Update(GXUpdateArgs.Update(it));
}
}
ret.ScheduleIds = list.ToArray();
host.SetChange(TargetType.Schedule, DateTime.Now);
return(ret);
}
public void ExcludeTest()
{
GXUser user = new GXUser()
{
Id = "Default"
};
GXUserGroup item = new GXUserGroup()
{
Name = "Default"
};
item.Users.Add(user);
GXInsertArgs insert = GXInsertArgs.Insert(item);
insert.Exclude <GXUserGroup>(e => e.CreationTime);
insert.Exclude <GXUserGroup>(e => e.Users);
Assert.AreEqual("Mikko", insert.ToString());
}
public ActionResult <AddTaskResponse> Post(AddTask request)
{
AddTaskResponse ret = new AddTaskResponse();
DateTime now = DateTime.Now;
foreach (var it in request.Actions)
{
if (it.Object.Id == 0)
{
UInt64 dId = it.Object.DeviceId;
int ot = it.Object.ObjectType;
string ln = it.Object.LogicalName;
it.Object = host.Connection.SingleOrDefault <GXObject>(GXSelectArgs.Select <GXObject>(null, q => q.DeviceId == dId && q.ObjectType == ot && q.LogicalName == ln));
if (it.Object == null)
{
return(BadRequest(string.Format("Invalid target {0}:{1} DeviceID {2}.", ot, ln, dId)));
}
}
it.Generation = now;
host.Connection.Insert(GXInsertArgs.Insert(it));
}
host.SetChange(TargetType.Tasks, DateTime.Now);
return(ret);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
if (!Configuration.GetSection("Scheduler").Get <SchedulerOptions>().Disabled)
{
services.AddHostedService <TimedHostedService>();
}
string settings = Configuration.GetSection("Database").Get <DatabaseOptions>().Settings;
string type = Configuration.GetSection("Database").Get <DatabaseOptions>().Type;
Console.WriteLine("Database type: " + type);
Console.WriteLine("Connecting: " + settings);
DbConnection connection;
if (string.IsNullOrEmpty(type))
{
//Gurux.DLMS.AMI DB is defined elsewhere.
connection = null;
}
if (string.Compare(type, "Oracle", true) == 0)
{
connection = new OracleConnection(settings);
}
else if (string.Compare(type, "MSSQL", true) == 0)
{
connection = new SqlConnection(settings);
}
else if (string.Compare(type, "MySQL", true) == 0)
{
connection = new MySql.Data.MySqlClient.MySqlConnection(settings);
}
else if (string.Compare(type, "SQLite", true) == 0)
{
connection = new SQLiteConnection(settings);
}
else
{
throw new Exception("Invalid connection type. " + type);
}
if (connection != null)
{
connection.Open();
GXHost h = new GXHost()
{
Connection = new GXDbConnection(connection, null)
};
if (!h.Connection.TableExist <GXDevice>())
{
Console.WriteLine("Creating tables.");
h.Connection.CreateTable <GXSystemError>(false, false);
h.Connection.CreateTable <GXDeviceTemplate>(false, false);
h.Connection.CreateTable <GXDevice>(false, false);
h.Connection.CreateTable <GXObjectTemplate>(false, false);
h.Connection.CreateTable <GXAttributeTemplate>(false, false);
h.Connection.CreateTable <GXObject>(false, false);
h.Connection.CreateTable <GXAttribute>(false, false);
h.Connection.CreateTable <GXValue>(false, false);
h.Connection.CreateTable <GXTask>(false, false);
h.Connection.CreateTable <GXError>(false, false);
h.Connection.CreateTable <GXSchedule>(false, false);
h.Connection.CreateTable <GXScheduleToAttribute>(false, false);
h.Connection.CreateTable <GXSchedulerInfo>(false, false);
h.Connection.CreateTable <GXReaderInfo>(false, false);
h.Connection.CreateTable <GXDeviceToReader>(false, false);
AddSchedule();
}
else
{
h.Connection.UpdateTable <GXSystemError>();
h.Connection.UpdateTable <GXError>();
h.Connection.UpdateTable <GXReaderInfo>();
h.Connection.UpdateTable <GXObjectTemplate>();
h.Connection.UpdateTable <GXAttributeTemplate>();
h.Connection.UpdateTable <GXDeviceTemplate>();
h.Connection.UpdateTable <GXObject>();
h.Connection.UpdateTable <GXAttribute>();
h.Connection.UpdateTable <GXDevice>();
}
h.Connection.Insert(GXInsertArgs.Insert(new GXSystemError()
{
Generation = DateTime.Now,
Error = "Service started: " + ServerAddress
}));;
Console.WriteLine("Service started: " + ServerAddress);
services.AddScoped <GXHost>(q =>
{
return(h);
});
}
services.Configure <ReaderOptions>(Configuration.GetSection("Reader"));
if (!Configuration.GetSection("Scheduler").Get <SchedulerOptions>().Disabled)
{
services.AddHostedService <TimedHostedService>();
}
if (Configuration.GetSection("Reader").Get <ReaderOptions>().Threads != 0)
{
services.AddHostedService <ReaderService>();
}
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
}
public ActionResult <UpdateDeviceResponse> Post(UpdateDevice request)
{
if (request.Device.TemplateId == 0)
{
return(BadRequest("Device template ID is unknown."));
}
bool newDevice = request.Device.Id == 0;
if (request.Device.DeviceSystemTitle != null)
{
request.Device.DeviceSystemTitle = request.Device.DeviceSystemTitle.Replace(" ", "");
}
if (request.Device.AuthenticationKey != null)
{
request.Device.AuthenticationKey = request.Device.AuthenticationKey.Replace(" ", "");
}
if (request.Device.BlockCipherKey != null)
{
request.Device.BlockCipherKey = request.Device.BlockCipherKey.Replace(" ", "");
}
if (newDevice)
{
DateTime now = DateTime.Now;
request.Device.Generation = now;
//Add new DC.
List <GXObject> tmp = request.Device.Objects;
request.Device.Objects = null;
request.Device.Generation = now;
host.Connection.Insert(GXInsertArgs.Insert(request.Device));
//Add default objects.
GXSelectArgs arg = GXSelectArgs.SelectAll <GXObjectTemplate>(q => q.DeviceTemplateId == request.Device.TemplateId && q.Removed == DateTime.MinValue);
arg.Columns.Add <GXAttributeTemplate>();
arg.Joins.AddLeftJoin <GXObjectTemplate, GXAttributeTemplate>(o => o.Id, a => a.ObjectTemplateId);
arg.Where.And <GXAttributeTemplate>(q => q.Removed == DateTime.MinValue);
List <GXObjectTemplate> l = host.Connection.Select <GXObjectTemplate>(arg);
foreach (GXObjectTemplate it in l)
{
GXObject obj = new GXObject()
{
TemplateId = it.Id,
Generation = now,
DeviceId = request.Device.Id,
ObjectType = it.ObjectType,
Name = it.Name,
LogicalName = it.LogicalName,
ShortName = it.ShortName,
};
host.Connection.Insert(GXInsertArgs.Insert(obj));
foreach (GXAttributeTemplate ait in it.Attributes)
{
GXAttribute a = new GXAttribute();
a.ObjectId = obj.Id;
a.Index = ait.Index;
a.TemplateId = ait.Id;
a.AccessLevel = ait.AccessLevel;
a.DataType = ait.DataType;
a.UIDataType = ait.UIDataType;
a.Generation = now;
a.ExpirationTime = ait.ExpirationTime;
obj.Attributes.Add(a);
}
;
host.Connection.Insert(GXInsertArgs.InsertRange(obj.Attributes));
}
host.SetChange(TargetType.ObjectTemplate, DateTime.Now);
}
else
{
request.Device.Updated = DateTime.Now;
host.Connection.Update(GXUpdateArgs.Update(request.Device));
host.SetChange(TargetType.DeviceTemplate, DateTime.Now);
}
return(new UpdateDeviceResponse()
{
DeviceId = request.Device.Id
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
#if !NETCOREAPP2_0 && !NETCOREAPP2_1
services.AddControllers();
#endif//!NETCOREAPP2_0 && !NETCOREAPP2_1
DatabaseOptions db = Configuration.GetSection("Database").Get <DatabaseOptions>();
string settings = db.Settings;
string type = db.Type;
bool disabled = db.Disabled;
if (disabled)
{
Console.WriteLine("Database service is disabled.");
}
else
{
Console.WriteLine("Database type: " + type);
Console.WriteLine("Connecting: " + settings);
}
DbConnection connection;
if (disabled || string.IsNullOrEmpty(type))
{
//Gurux.DLMS.AMI DB is defined elsewhere.
connection = null;
}
else if (string.Compare(type, "Oracle", true) == 0)
{
connection = new OracleConnection(settings);
}
else if (string.Compare(type, "MSSQL", true) == 0)
{
connection = new SqlConnection(settings);
}
else if (string.Compare(type, "MySQL", true) == 0)
{
connection = new MySql.Data.MySqlClient.MySqlConnection(settings);
}
else if (string.Compare(type, "SQLite", true) == 0)
{
connection = new SQLiteConnection(settings);
}
else
{
throw new Exception("Invalid connection type. " + type);
}
if (connection != null)
{
connection.Open();
GXHost h = new GXHost()
{
Connection = new GXDbConnection(connection, null)
};
h.Connection.OnSqlExecuted += Connection_OnSqlExecuted;
if (!h.Connection.TableExist <GXDevice>())
{
Console.WriteLine("Creating tables.");
h.Connection.CreateTable <GXSystemError>(false, false);
h.Connection.CreateTable <GXDeviceTemplate>(false, false);
h.Connection.CreateTable <GXDevice>(false, false);
h.Connection.CreateTable <GXObjectTemplate>(false, false);
h.Connection.CreateTable <GXAttributeTemplate>(false, false);
h.Connection.CreateTable <GXObject>(false, false);
h.Connection.CreateTable <GXAttribute>(false, false);
h.Connection.CreateTable <GXValue>(false, false);
h.Connection.CreateTable <GXTask>(false, false);
h.Connection.CreateTable <GXError>(false, false);
h.Connection.CreateTable <GXSchedule>(false, false);
h.Connection.CreateTable <GXScheduleToAttribute>(false, false);
h.Connection.CreateTable <GXSchedulerInfo>(false, false);
h.Connection.CreateTable <GXReaderInfo>(false, false);
h.Connection.CreateTable <GXDeviceToReader>(false, false);
h.Connection.CreateTable <GXDeviceLog>(false, false);
AddSchedule(h.Connection);
}
else
{
h.Connection.UpdateTable <GXSystemError>();
h.Connection.UpdateTable <GXError>();
h.Connection.UpdateTable <GXReaderInfo>();
h.Connection.UpdateTable <GXObjectTemplate>();
h.Connection.UpdateTable <GXAttributeTemplate>();
h.Connection.UpdateTable <GXDeviceTemplate>();
h.Connection.UpdateTable <GXObject>();
h.Connection.UpdateTable <GXAttribute>();
h.Connection.UpdateTable <GXDevice>();
if (!h.Connection.TableExist <GXDeviceLog>())
{
h.Connection.CreateTable <GXDeviceLog>(false, false);
}
else
{
h.Connection.UpdateTable <GXDeviceLog>();
}
}
h.Connection.Insert(GXInsertArgs.Insert(new GXSystemError()
{
Generation = DateTime.Now,
Error = "Service started: " + ServerAddress
}));;
Console.WriteLine("Service started: " + ServerAddress);
services.AddScoped <GXHost>(q =>
{
return(h);
});
}
services.Configure <ListenerOptions>(Configuration.GetSection("Listener"));
ListenerOptions listener = Configuration.GetSection("Listener").Get <ListenerOptions>();
if (!listener.Disabled)
{
services.AddHostedService <GXListenerService>();
}
else
{
Console.WriteLine("Listener service is disabled.");
}
services.Configure <NotifyOptions>(Configuration.GetSection("Notify"));
NotifyOptions n = Configuration.GetSection("Notify").Get <NotifyOptions>();
if (!n.Disabled && n.Port != 0)
{
services.AddHostedService <GXNotifyService>();
}
else
{
Console.WriteLine("Notify service is disabled.");
}
services.Configure <SchedulerOptions>(Configuration.GetSection("Scheduler"));
SchedulerOptions s = Configuration.GetSection("Scheduler").Get <SchedulerOptions>();
if (!s.Disabled)
{
services.AddHostedService <GXSchedulerService>();
}
else
{
Console.WriteLine("Scheduler service is disabled.");
}
services.Configure <ReaderOptions>(Configuration.GetSection("Reader"));
ReaderOptions r = Configuration.GetSection("Reader").Get <ReaderOptions>();
Console.WriteLine("Reader trace level is " + r.TraceLevel);
Console.WriteLine("Listener trace level is " + listener.TraceLevel);
if (r.Threads != 0 && !r.Disabled)
{
services.AddHostedService <ReaderService>();
}
else
{
Console.WriteLine("Reader '" + r.Name + "' ID: " + r.Id);
}
#if NETCOREAPP2_0 || NETCOREAPP2_1
services.AddMvc().SetCompatibilityVersion(Microsoft.AspNetCore.Mvc.CompatibilityVersion.Version_2_1);
#endif //NETCOREAPP2_0 || NETCOREAPP2_1
}
public ActionResult <AddTestDeviceResponse> Post(AddTestDevice request)
{
if (request.Device.TemplateId == 0)
{
return(BadRequest("Device template ID is unknown."));
}
if (request.Device.DeviceSystemTitle != null)
{
request.Device.DeviceSystemTitle = request.Device.DeviceSystemTitle.Replace(" ", "");
}
if (request.Device.AuthenticationKey != null)
{
request.Device.AuthenticationKey = request.Device.AuthenticationKey.Replace(" ", "");
}
if (request.Device.BlockCipherKey != null)
{
request.Device.BlockCipherKey = request.Device.BlockCipherKey.Replace(" ", "");
}
DateTime now = DateTime.Now;
//Add new DC.
request.Device.Generation = now;
//We are accessing meters using serial number when test mode is used.
request.Device.HDLCAddressing = ManufacturerSettings.HDLCAddressType.SerialNumber;
request.Device.LogicalAddress = request.Index;
for (UInt16 pos = 0; pos != request.Count; ++pos)
{
request.Device.Objects = null;
request.Device.Name = "Test_" + request.Device.LogicalAddress;
++request.Device.LogicalAddress;
request.Device.Id = 0;
host.Connection.Insert(GXInsertArgs.Insert(request.Device));
//Add default objects.
GXSelectArgs arg = GXSelectArgs.SelectAll <GXObjectTemplate>(q => q.DeviceTemplateId == request.Device.TemplateId);
arg.Columns.Add <GXAttributeTemplate>();
arg.Joins.AddLeftJoin <GXObjectTemplate, GXAttributeTemplate>(o => o.Id, a => a.ObjectTemplateId);
List <GXObjectTemplate> l = host.Connection.Select <GXObjectTemplate>(arg);
foreach (GXObjectTemplate it in l)
{
GXObject obj = new GXObject()
{
TemplateId = it.Id,
Generation = now,
DeviceId = request.Device.Id,
ObjectType = it.ObjectType,
Name = it.Name,
LogicalName = it.LogicalName,
ShortName = it.ShortName,
};
host.Connection.Insert(GXInsertArgs.Insert(obj));
foreach (GXAttributeTemplate ait in it.Attributes)
{
GXAttribute a = new GXAttribute();
a.ObjectId = obj.Id;
a.Index = ait.Index;
a.TemplateId = ait.Id;
a.AccessLevel = ait.AccessLevel;
a.DataType = ait.DataType;
a.UIDataType = ait.UIDataType;
a.Generation = now;
a.ExpirationTime = ait.ExpirationTime;
obj.Attributes.Add(a);
}
;
host.Connection.Insert(GXInsertArgs.InsertRange(obj.Attributes));
}
}
host.SetChange(TargetType.Device, DateTime.Now);
return(new AddTestDeviceResponse());
}
public ActionResult <UpdateDeviceTemplateResponse> Post(UpdateDeviceTemplate request)
{
GXDeviceTemplate dev = request.Device;
if (dev == null)
{
return(BadRequest("Device is null."));
}
bool newDevice = dev.Id == 0;
if (dev.DeviceSystemTitle != null)
{
dev.DeviceSystemTitle = dev.DeviceSystemTitle.Replace(" ", "");
}
if (dev.AuthenticationKey != null)
{
dev.AuthenticationKey = dev.AuthenticationKey.Replace(" ", "");
}
if (dev.BlockCipherKey != null)
{
dev.BlockCipherKey = dev.BlockCipherKey.Replace(" ", "");
}
dev.Generation = DateTime.Now;
if (newDevice)
{
//Add new DC.
List <GXObjectTemplate> tmp = dev.Objects;
dev.Objects = null;
DateTime now = DateTime.Now;
dev.Generation = now;
host.Connection.Insert(GXInsertArgs.Insert(dev));
if (tmp != null)
{
//Add default objects.
foreach (GXObjectTemplate it in tmp)
{
List <GXAttributeTemplate> tmp2 = it.Attributes;
it.Attributes = null;
it.DeviceTemplateId = dev.Id;
it.Generation = now;
host.Connection.Insert(GXInsertArgs.Insert(it));
if (it.Attributes != tmp2)
{
foreach (GXAttributeTemplate a in tmp2)
{
a.Generation = now;
a.ObjectTemplateId = it.Id;
}
host.Connection.Insert(GXInsertArgs.InsertRange(tmp2));
}
}
}
host.SetChange(TargetType.Object, DateTime.Now);
}
else
{
host.Connection.Update(GXUpdateArgs.Update(dev));
host.SetChange(TargetType.DeviceTemplate, DateTime.Now);
}
return(new UpdateDeviceTemplateResponse()
{
DeviceId = dev.Id
});
}
