/// <remarks>This method is thread-safe.</remarks>
public static async Task AddControllerAsync(int ID, string orgId, string name, int type, string version, string model, string IPAddress, bool enabled = true, double?geo_latitude = null, double?geo_longitude = null)
{
var ctrl = new Controller()
{
ID = ID,
OrgId = !string.IsNullOrWhiteSpace(orgId) ? orgId.Trim() : throw new ArgumentNullException(nameof(orgId)),
IsEnabled = enabled,
Name = !string.IsNullOrWhiteSpace(name) ? name.Trim() : throw new ArgumentNullException(nameof(name)),
Type = (type >= 0) ? type : throw new ArgumentOutOfRangeException(nameof(type)),
Version = !string.IsNullOrWhiteSpace(version) ? version.Trim() : throw new ArgumentNullException(nameof(version)),
Model = !string.IsNullOrWhiteSpace(model) ? model.Trim() : throw new ArgumentNullException(nameof(model)),
IP = ProcessIPAddress(IPAddress) ?? throw new ArgumentOutOfRangeException(nameof(IPAddress)),
GeoLatitude = geo_latitude,
GeoLongitude = geo_longitude
};
using (var db = new ConfigDB(m_Schema, m_Version)) {
var cx = await db.Controllers.AsNoTracking().FirstOrDefaultAsync(c => c.ID == ID).ConfigureAwait(false);
if (cx != null)
{
throw new ApplicationException("ID already exists: " + ID);
}
db.Controllers.Add(ctrl);
await db.SaveChangesAsync().ConfigureAwait(false);
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <User> DeleteUserAsync(string orgId, string password)
{
if (string.IsNullOrWhiteSpace(orgId))
{
throw new ArgumentNullException(nameof(orgId));
}
if (string.IsNullOrWhiteSpace(password))
{
throw new ArgumentNullException(nameof(password));
}
orgId = orgId.Trim();
password = password.Trim();
using (var db = new ConfigDB(m_Schema)) {
var user = await db.Users
.Where(x => x.OrgId.Equals(orgId, StringComparison.OrdinalIgnoreCase))
.FirstOrDefaultAsync(x => x.Password.Equals(password, StringComparison.OrdinalIgnoreCase))
.ConfigureAwait(false);
if (user == null)
{
throw new ArgumentOutOfRangeException(nameof(password));
}
db.Users.Remove(user);
await db.SaveChangesAsync().ConfigureAwait(false);
return(user);
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <int> AddMoldAsync(string name, int?controller, bool enabled = true, IReadOnlyDictionary <ushort, ushort> data = null)
{
var mold = new Mold()
{
IsEnabled = enabled,
Name = !string.IsNullOrWhiteSpace(name) ? name.Trim() : throw new ArgumentNullException(nameof(name)),
ControllerId = (!controller.HasValue || controller.Value > 0) ? controller : throw new ArgumentOutOfRangeException(nameof(controller)),
Guid = Guid.NewGuid()
};
using (var db = new ConfigDB(m_Schema)) {
var cx = await db.Molds.AsNoTracking().FirstOrDefaultAsync(x => x.Name.Equals(name, StringComparison.OrdinalIgnoreCase) && x.ControllerId == controller).ConfigureAwait(false);
if (cx != null)
{
throw new ApplicationException($"Controller/Name already exists: {controller}/{name}");
}
db.Molds.Add(mold);
if (data != null)
{
db.MoldSettings.AddRange(data.Select(s => new MoldSetting()
{
Mold = mold,
Offset = (short)s.Key,
RawData = s.Value
}));
}
await db.SaveChangesAsync().ConfigureAwait(false);
return(mold.ID);
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task ReplaceMoldSettingsAsync(int moldId, IReadOnlyDictionary <ushort, ulong> data)
{
if (moldId <= 0)
{
throw new ArgumentOutOfRangeException(nameof(moldId));
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
using (var db = new ConfigDB(m_Schema)) {
var existing = await db.MoldSettings.Where(mx => mx.MoldId == moldId).ToListAsync().ConfigureAwait(false);
db.MoldSettings.RemoveRange(existing);
await db.SaveChangesAsync().ConfigureAwait(false);
foreach (var kv in data)
{
(var value, var variable) = UnpackMoldSettingValue(kv.Value);
db.MoldSettings.Add(new MoldSetting()
{
MoldId = moldId,
Offset = (short)kv.Key,
RawData = value,
Variable = variable
});
}
await db.SaveChangesAsync().ConfigureAwait(false);
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <ushort> GetMoldSettingValueAsync(int moldId, int offset)
{
using (var db = new ConfigDB(m_Schema)) {
var setting = await db.MoldSettings.AsNoTracking().FirstOrDefaultAsync(ms => ms.MoldId == moldId && ms.Offset == offset).ConfigureAwait(false);
return(setting?.RawData ?? 0);
}
}
public TextMapCache()
{
using (var db = new ConfigDB()) {
m_IdToText = new ConcurrentDictionary <int, string>(db.TextMaps.AsNoTracking().AsEnumerable().Select(tm => new KeyValuePair <int, string>(tm.ID, tm.Text)));
}
m_TextToId = new ConcurrentDictionary <string, int>(m_IdToText.Select(kv => new KeyValuePair <string, int>(kv.Value, kv.Key)), StringComparer.OrdinalIgnoreCase);
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <ICollection <Mold> > GetAllMoldsAsync(int?controller)
{
if (controller.HasValue && controller.Value <= 0)
{
throw new ArgumentOutOfRangeException(nameof(controller));
}
using (var db = new ConfigDB(m_Schema)) {
return(await db.Molds.AsNoTracking().Where(x => x.ControllerId == controller).ToListAsync().ConfigureAwait(false));
}
}
public static async Task <ICollection <Organization> > GetAllOrgsAsync()
{
if (m_Version < ConfigDB.Version_Organization)
{
return(new Organization[0]);
}
using (var db = new ConfigDB(m_Schema, m_Version)) {
return(await db.Organizations.AsNoTracking().ToListAsync().ConfigureAwait(false));
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <ICollection <Controller> > GetAllControllersAsync(string orgId)
{
if (orgId != null && string.IsNullOrWhiteSpace(orgId))
{
throw new ArgumentNullException(nameof(orgId));
}
using (var db = new ConfigDB(m_Schema, m_Version)) {
return((orgId == null)
? await db.Controllers.AsNoTracking().ToListAsync().ConfigureAwait(false)
: await db.Controllers.AsNoTracking().Where(c => c.OrgId.Equals(orgId, StringComparison.OrdinalIgnoreCase)).ToListAsync().ConfigureAwait(false));
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <ICollection <Mold> > SearchMoldsByControllerAndKeywordAsync(int controller, string keyword)
{
if (controller <= 0)
{
return(null);
}
if (string.IsNullOrWhiteSpace(keyword))
{
return(null);
}
using (var db = new ConfigDB(m_Schema)) {
return(await db.Molds.AsNoTracking().Where(x => x.ControllerId == controller && x.Name.Contains(keyword)).ToListAsync().ConfigureAwait(false));
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <Mold> GetMoldByControllerAndNameAsync(int controller, string name)
{
if (controller <= 0)
{
return(null);
}
if (string.IsNullOrWhiteSpace(name))
{
return(null);
}
using (var db = new ConfigDB(m_Schema)) {
return(await db.Molds.AsNoTracking().FirstOrDefaultAsync(x => x.ControllerId == controller && x.Name.Equals(name, StringComparison.OrdinalIgnoreCase)).ConfigureAwait(false));
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <ushort[]> GetMoldSettingsAsync(int moldId)
{
IList <MoldSetting> data;
using (var db = new ConfigDB(m_Schema)) {
data = await db.MoldSettings.AsNoTracking().Where(s => s.MoldId == moldId).OrderBy(s => s.Offset).ToListAsync().ConfigureAwait(false);
}
var list = new ushort[(data.Count <= 0) ? 0 : data[data.Count - 1].Offset + 1];
foreach (var s in data)
{
list[s.Offset] = s.RawData;
}
return(list);
}
public static async Task <Organization> GetOrgAsync(string orgId)
{
if (string.IsNullOrWhiteSpace(orgId))
{
throw new ArgumentNullException(nameof(orgId));
}
if (m_Version < ConfigDB.Version_Organization)
{
return(null);
}
using (var db = new ConfigDB(m_Schema, m_Version)) {
return(await db.Organizations.AsNoTracking().FirstOrDefaultAsync(o => o.ID.Equals(orgId, StringComparison.OrdinalIgnoreCase)).ConfigureAwait(false));
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <Controller> DeleteControllerAsync(int ID)
{
using (var db = new ConfigDB(m_Schema, m_Version)) {
var ctrl = await db.Controllers.FirstOrDefaultAsync(c => c.ID == ID).ConfigureAwait(false);
if (ctrl == null)
{
throw new ArgumentOutOfRangeException(nameof(ID));
}
db.Controllers.Remove(ctrl);
await db.SaveChangesAsync().ConfigureAwait(false);
return(ctrl);
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <int> AddMoldAsync(string name, int?controller, bool enabled = true, IList <ulong> data = null)
{
var mold = new Mold()
{
IsEnabled = enabled,
Name = !string.IsNullOrWhiteSpace(name) ? name.Trim() : throw new ArgumentNullException(nameof(name)),
ControllerId = (!controller.HasValue || controller.Value > 0) ? controller : throw new ArgumentOutOfRangeException(nameof(controller)),
Guid = Guid.NewGuid()
};
using (var db = new ConfigDB(m_Schema)) {
var cx = await db.Molds.AsNoTracking().FirstOrDefaultAsync(x => x.Name.Equals(name, StringComparison.OrdinalIgnoreCase) && x.ControllerId == controller).ConfigureAwait(false);
if (cx != null)
{
throw new ApplicationException($"Controller/Name already exists: {controller}/{name}");
}
db.Molds.Add(mold);
if (data != null)
{
for (var x = 0; x < data.Count; x++)
{
(var value, var variable) = UnpackMoldSettingValue(data[x]);
// Make sure the last item is always stored to keep the accurate length of the whole data set
if (value == 0 && x < data.Count - 1)
{
continue;
}
db.MoldSettings.Add(new MoldSetting()
{
Mold = mold,
Offset = (short)x,
RawData = value,
Variable = variable
});
}
}
await db.SaveChangesAsync().ConfigureAwait(false);
return(mold.ID);
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task UpdateMoldAsync(int ID, bool enabled, string name, int?controller)
{
using (var db = new ConfigDB(m_Schema)) {
var mold = await db.Molds.FirstOrDefaultAsync(m => m.ID == ID).ConfigureAwait(false);
if (mold == null)
{
throw new ArgumentOutOfRangeException(nameof(ID));
}
mold.IsEnabled = enabled;
mold.Name = !string.IsNullOrWhiteSpace(name) ? name.Trim() : throw new ArgumentNullException(nameof(name));
mold.ControllerId = (!controller.HasValue || controller.Value > 0) ? controller : throw new ArgumentOutOfRangeException(nameof(controller));
mold.Modified = DateTime.Now;
await db.SaveChangesAsync().ConfigureAwait(false);
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task UpdateUserAsync(string orgId, string password, bool enabled, string name, Filters filters, byte level)
{
if (string.IsNullOrWhiteSpace(orgId))
{
throw new ArgumentNullException(nameof(orgId));
}
if (string.IsNullOrWhiteSpace(password))
{
throw new ArgumentNullException(nameof(password));
}
orgId = orgId.Trim();
password = password.Trim();
using (var db = new ConfigDB(m_Schema)) {
var user = await db.Users
.Where(x => x.OrgId.Equals(orgId, StringComparison.OrdinalIgnoreCase))
.FirstOrDefaultAsync(x => x.Password.Equals(password, StringComparison.OrdinalIgnoreCase))
.ConfigureAwait(false);
if (user == null)
{
throw new ArgumentOutOfRangeException(nameof(password));
}
var ux = await db.Users.AsNoTracking()
.Where(x => x.OrgId.Equals(orgId, StringComparison.OrdinalIgnoreCase))
.FirstOrDefaultAsync(x => x.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
.ConfigureAwait(false);
if (ux != null)
{
throw new ApplicationException($"User name already exists in org {orgId}: {name}");
}
user.Name = !string.IsNullOrWhiteSpace(name) ? name.Trim() : throw new ArgumentNullException(nameof(name));
user.IsEnabled = enabled;
user.Filters = filters;
user.AccessLevel = level;
user.Modified = DateTime.Now;
await db.SaveChangesAsync().ConfigureAwait(false);
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task AddMoldSettingsAsync(int moldId, IReadOnlyDictionary <ushort, ulong> data)
{
if (moldId <= 0)
{
throw new ArgumentOutOfRangeException(nameof(moldId));
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
using (var db = new ConfigDB(m_Schema)) {
var existing = await db.MoldSettings.AsNoTracking().Where(mx => mx.MoldId == moldId).ToListAsync().ConfigureAwait(false);
if (existing.Any(s => data.ContainsKey((ushort)s.Offset)))
{
throw new ApplicationException($"Some MoldId/Offset already exist.");
}
int maxkey = (data.Count > 0) ? data.Keys.Max() : 0;
foreach (var kv in data)
{
(var value, var variable) = UnpackMoldSettingValue(kv.Value);
// Skip zeros but always keep the last item
if (value == 0 && kv.Key != maxkey)
{
continue;
}
db.MoldSettings.Add(new MoldSetting()
{
MoldId = moldId,
Offset = (short)kv.Key,
RawData = value,
Variable = variable
});
}
await db.SaveChangesAsync().ConfigureAwait(false);
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <Mold> DeleteMoldAsync(int ID)
{
using (var db = new ConfigDB(m_Schema)) {
var mold = await db.Molds.FirstOrDefaultAsync(m => m.ID == ID).ConfigureAwait(false);
if (mold == null)
{
throw new ArgumentOutOfRangeException(nameof(ID));
}
await db.Entry(mold).Collection(m => m.MoldSettings).LoadAsync().ConfigureAwait(false);
db.MoldSettings.RemoveRange(mold.MoldSettings);
db.Molds.Remove(mold);
await db.SaveChangesAsync().ConfigureAwait(false);
return(mold);
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <User> GetUserAsync(string orgId, string password)
{
if (string.IsNullOrWhiteSpace(orgId))
{
throw new ArgumentNullException(nameof(orgId));
}
if (string.IsNullOrWhiteSpace(password))
{
throw new ArgumentNullException(nameof(password));
}
password = password.Trim();
using (var db = new ConfigDB(m_Schema)) {
return(await db.Users.AsNoTracking()
.Where(x => x.OrgId.Equals(orgId, StringComparison.OrdinalIgnoreCase))
.FirstOrDefaultAsync(x => x.Password.Equals(password, StringComparison.OrdinalIgnoreCase))
.ConfigureAwait(false));
}
}
public async Task <int> GetTextIdAsync(string text)
{
if (string.IsNullOrWhiteSpace(text))
{
throw new ArgumentNullException(nameof(text));
}
if (m_TextToId.TryGetValue(text, out var id))
{
return(id);
}
// Not found in cache, add it
using (var db = new ConfigDB()) {
var map = await db.TextMaps.SingleOrDefaultAsync(tm => tm.Text.Equals(text, StringComparison.OrdinalIgnoreCase));
if (map == null)
{
try {
db.TextMaps.Add(new TextMap()
{
Text = text
});
await db.SaveChangesAsync();
} catch (DbUpdateException) {
// Probably already added by some other process
}
}
map = db.TextMaps.Single(tm => tm.Text.Equals(text, StringComparison.OrdinalIgnoreCase));
m_TextToId.AddOrUpdate(map.Text, map.ID, (x, v) => v);
m_IdToText.AddOrUpdate(map.ID, map.Text, (x, v) => v);
return(map.ID);
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task UpdateControllerAsync(int ID, bool enabled, string name, int type, string version, string model, string IPAddress, double?geo_latitude, double?geo_longitude)
{
using (var db = new ConfigDB(m_Schema, m_Version)) {
var ctrl = await db.Controllers.FirstOrDefaultAsync(c => c.ID == ID).ConfigureAwait(false);
if (ctrl == null)
{
throw new ArgumentOutOfRangeException(nameof(ID));
}
ctrl.IsEnabled = enabled;
ctrl.Name = !string.IsNullOrWhiteSpace(name) ? name.Trim() : throw new ArgumentNullException(nameof(name));
ctrl.Type = (type >= 0) ? type : throw new ArgumentOutOfRangeException(nameof(type));
ctrl.Version = !string.IsNullOrWhiteSpace(version) ? version.Trim() : throw new ArgumentNullException(nameof(version));
ctrl.Model = !string.IsNullOrWhiteSpace(model) ? model.Trim() : throw new ArgumentNullException(nameof(model));
ctrl.IP = ProcessIPAddress(IPAddress) ?? throw new ArgumentOutOfRangeException(nameof(IPAddress));
ctrl.GeoLatitude = geo_latitude;
ctrl.GeoLongitude = geo_longitude;
ctrl.Modified = DateTime.Now;
await db.SaveChangesAsync().ConfigureAwait(false);
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task AddUserAsync(string orgId, string password, string name, Filters filters, byte level, bool enabled)
{
var user = new User()
{
OrgId = !string.IsNullOrWhiteSpace(orgId) ? orgId.Trim() : throw new ArgumentNullException(nameof(orgId)),
Password = !string.IsNullOrWhiteSpace(password) ? password.Trim() : throw new ArgumentNullException(nameof(password)),
IsEnabled = enabled,
Name = !string.IsNullOrWhiteSpace(name) ? name.Trim() : throw new ArgumentNullException(nameof(name)),
Filters = filters,
AccessLevel = level
};
using (var db = new ConfigDB(m_Schema)) {
var ux = await db.Users.AsNoTracking()
.Where(x => x.OrgId.Equals(orgId, StringComparison.OrdinalIgnoreCase))
.FirstOrDefaultAsync(x => x.Password.Equals(password, StringComparison.OrdinalIgnoreCase))
.ConfigureAwait(false);
if (ux != null)
{
throw new ApplicationException($"Password already exists in org {orgId}: {password}");
}
ux = await db.Users.AsNoTracking()
.Where(x => x.OrgId.Equals(orgId, StringComparison.OrdinalIgnoreCase))
.FirstOrDefaultAsync(x => x.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
.ConfigureAwait(false);
if (ux != null)
{
throw new ApplicationException($"User name already exists in org {orgId}: {name}");
}
db.Users.Add(user);
await db.SaveChangesAsync().ConfigureAwait(false);
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <Controller> GetControllerAsync(int ID)
{
using (var db = new ConfigDB(m_Schema, m_Version)) {
return(await db.Controllers.AsNoTracking().FirstOrDefaultAsync(c => c.ID == ID).ConfigureAwait(false));
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <ICollection <Mold> > GetAllMoldsAsync()
{
using (var db = new ConfigDB(m_Schema)) {
return(await db.Molds.AsNoTracking().ToListAsync().ConfigureAwait(false));
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <Mold> GetMoldAsync(int id)
{
using (var db = new ConfigDB(m_Schema)) {
return(await db.Molds.AsNoTracking().FirstOrDefaultAsync(m => m.ID == id).ConfigureAwait(false));
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <MoldSetting> GetMoldSettingAsync(int moldId, int offset)
{
using (var db = new ConfigDB(m_Schema)) {
return(await db.MoldSettings.AsNoTracking().FirstOrDefaultAsync(ms => ms.MoldId == moldId && ms.Offset == offset).ConfigureAwait(false));
}
}
/// <remarks>This method is thread-safe.</remarks>
public static async Task <ICollection <MoldSetting> > GetMoldSettingsDataAsync(int moldId)
{
using (var db = new ConfigDB(m_Schema)) {
return(await db.MoldSettings.AsNoTracking().Where(s => s.MoldId == moldId).OrderBy(s => s.Offset).ToListAsync().ConfigureAwait(false));
}
}
