public Gateway1Simulator(
IRedGreenQueueAdapter redq,
IOptions <Gateway1SimulatorOptions> options,
ILogger <Gateway1Simulator> logger,
IGatewayApi gatewayApi,
IEntityApi entityApi,
TagReadsSync tagReadsSync,
DeviceStatusSync devicestatusSync,
RNCHeartbeatSync RNCHeartbeatSync,
UnreadRFIDSync unreadRFIDSync,
KeyFrameSync keyFrameSync,
LoggerX loggerX
)
{
_entityApi = entityApi ?? throw new ArgumentNullException(nameof(entityApi));
_gatewayApi = gatewayApi ?? throw new ArgumentNullException(nameof(gatewayApi));
_redq = redq ?? throw new ArgumentNullException(nameof(redq));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_options = options ?? throw new ArgumentException(nameof(options));
if (options.Value.Active)
{
logger.LogInformation("GATEWAY.1 simulator active");
}
//Init all Innotrack Sync Classes
_tagReadsSync = tagReadsSync;
_devicestatusSync = devicestatusSync;
_RNCHeartbeatSync = RNCHeartbeatSync;
_unreadRFIDSync = unreadRFIDSync;
_keyFrameSync = keyFrameSync;
LoggerX = loggerX;
RunIntegration();
}
public async Task StartDeviceStatus()
{
while (true)
{
try
{
await UpdateLastCheckedLog(InterfaceType.deviceheartbeat);
await RefreshDeviceStatusList();
var lst = new List <(string, string, object)>();
foreach (var device in Devices)
{
//if (device.Status != "Active")
// continue;
//Add Heartbeat of device and send
var _iotObject = new IotObject();
//_iotObject.Device = device;
_iotObject.DeviceName = device.DeviceName;
_iotObject.DeviceType = "DEVICE";
_iotObject.ObjectType = "HEARTBEAT";
_iotObject.Object = device.Status == "Active" ? 1 : 0;
lst.Add(_iotObject.ToString());
//Send list to Iot Cloud Platform
}
await SendNotification(lst);
await UpdateLastUpdatedLog(InterfaceType.deviceheartbeat);
}
catch (Exception ex)
{
LoggerX.WriteErrorLog(ex);
_logger.LogError(ex, $"Sending notification for gateway {IotGateway.GatewayId}");
}
await Task.Delay(IotGateway.DeviceHeatbeatInterval * 1000);
}
}
public Task <creditorC> GetCreditorSingle(int cr_account_id)
{
creditorC _obj = null;
string _sql = null;
try
{
using (var _db = fnn.GetDbConnection())
{
_sql = string.Format("select TOP(1) * from {0} where cr_account_id={1} and delete_id = 0", FleetManager.DbBase.tableNames.creditor_tb.ToDbSchemaTable(), cr_account_id);
_obj = _db.Query <creditorC>(_sql).FirstOrDefault();
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_obj));
}
public Task <List <vh_expense_typeC> > GetAll(long fs_timestamp)
{
List <vh_expense_typeC> _list = null;
string _sql = null;
try
{
using (var _db = fnn.GetDbConnection())
{
if (fs_timestamp == 0)
{
_sql = string.Format("select * from {0} where delete_id = 0", _table_name.ToDbSchemaTable());
_list = _db.Query <vh_expense_typeC>(_sql).ToList();
}
else
{
_sql = string.Format("select * from {0} where fs_timestamp > {1}", _table_name.ToDbSchemaTable(), fs_timestamp);
_list = _db.Query <vh_expense_typeC>(_sql).ToList();
}
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_list));
}
public Task <List <creditorC> > GetAllCreditors(long fs_timestamp)
{
List <creditorC> _list = null;
string _sql = null;
try
{
using (var _db = fnn.GetDbConnection())
{
if (fs_timestamp == 0)
{
_sql = string.Format("select * from {0} where delete_id = 0", FleetManager.DbBase.tableNames.creditor_tb.ToDbSchemaTable());
_list = _db.Query <creditorC>(_sql).ToList();
}
else
{
_sql = string.Format("select * from {0} where fs_timestamp > {1}", FleetManager.DbBase.tableNames.creditor_tb.ToDbSchemaTable(), fs_timestamp);
_list = _db.Query <creditorC>(_sql).ToList();
}
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_list));
}
public Task <List <vh_expense_transC> > GetAllRecentVehicleExpenses(dto_vehicle_expense_recentC _dto)
{
List <vh_expense_transC> _list = null;
if (_dto == null)
{
AddErrorMessage("Error", "Error", "DTO Object Can Not Be Null");
return(Task.FromResult(_list));
}
string _sql = null;
try
{
using (var _db = fnn.GetDbConnection())
{
_sql = string.Format("select TOP 15 * from {0} where vehicle_id={1} and exp_type_id={2} and delete_id = 0 order by expense_fs_id desc",
_table_name.ToDbSchemaTable(), _dto.vehicle_id, _dto.exp_type_id);
_list = _db.Query <vh_expense_transC>(_sql).ToList();
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_list));
}
public Task <List <creditor_depositC> > GetAllCreditorDepositsByMonthPartition(dto_month_partitionC _dto)
{
List <creditor_depositC> _list = null;
string _sql = null;
try
{
using (var _db = fnn.GetDbConnection())
{
if (_dto.fs_timestamp == 0)
{
_sql = string.Format("select * from {0} where m_partition_id = {1} and delete_id = 0", FleetManager.DbBase.tableNames.creditor_deposit_tb.ToDbSchemaTable(), _dto.m_partition_id);
_list = _db.Query <creditor_depositC>(_sql).ToList();
}
else
{
_sql = string.Format("select * from {0} where m_partition_id = {1} and fs_timestamp > {2}", FleetManager.DbBase.tableNames.creditor_deposit_tb.ToDbSchemaTable(), _dto.m_partition_id, _dto.fs_timestamp);
_list = _db.Query <creditor_depositC>(_sql).ToList();
}
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_list));
}
public Task <List <vh_expense_transC> > GetAllExpensesByMonthPartition(dto_month_partitionC _dto)
{
List <vh_expense_transC> _list = null;
string _sql = null;
try
{
using (var _db = fnn.GetDbConnection())
{
if (_dto.fs_timestamp == 0)
{
_sql = string.Format("select * from {0} where m_partition_id = {1} and delete_id = 0", _table_name.ToDbSchemaTable(), _dto.m_partition_id);
_list = _db.Query <vh_expense_transC>(_sql).ToList();
}
else
{
_sql = string.Format("select * from {0} where m_partition_id = {1} and fs_timestamp > {2}", _table_name.ToDbSchemaTable(), _dto.m_partition_id, _dto.fs_timestamp);
_list = _db.Query <vh_expense_transC>(_sql).ToList();
}
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_list));
}
public Task <vh_expense_typeC> GetSingle(int id)
{
vh_expense_typeC _item = null;
string _sql = null;
try
{
using (var _db = fnn.GetDbConnection())
{
_sql = string.Format("select * from {0} where exp_type_id = {1} and delete_id = 0", _table_name.ToDbSchemaTable());
_item = _db.Query <vh_expense_typeC>(_sql).FirstOrDefault();
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_item));
}
public IoTBase(IRedGreenQueueAdapter redq, LoggerX loggerX)
{
this._redq = redq;
LoggerX = loggerX;
integrationLog = new IntegrationProcessLog();
processLog = new IntegrationProcessLog();
}
public Task <vh_driverC> Add(dto_driver_newC _dto)
{
vh_driverC _obj = null;
if (fnn.LOGGED_USER.DoesNotHaveRight(em.user_rights_types.can_create_vehicle_driver))
{
_obj = null;
AddErrorMessage("Limited Rights Error", "Rights Error", "You Can Not Perform This Operation");
return(Task.FromResult(_obj));
}
if (_dto == null)
{
AddErrorMessage("Error", "Error", "New Driver Object Is Null");
return(Task.FromResult(_obj));
}
if (string.IsNullOrEmpty(_dto.driver_name))
{
AddErrorMessage("Error", "Error", "Driver Name Is Missing");
return(Task.FromResult(_obj));
}
try
{
using (var _db = fnn.GetDbContext())
{
_obj = new vh_driverC()
{
driver_name = _dto.driver_name.Trim(),
server_edate = fnn.GetServerDate(),
driver_phone_no = _dto.driver_phone_no,
fs_timestamp = fnn.GetUnixTimeStamp(),
created_by_user_id = m_logged_user.user_id,
renew_expiry_date = _dto.renew_expiry_date,
renew_issue_date = _dto.renew_issue_date,
permit_no = _dto.permit_no
};
_db.DRIVERS.Add(_obj);
var _retVal = _db.SaveChangesWithDuplicateKeyDetected();
if (_retVal == null || _retVal.Value == true)
{
AddErrorMessage("Duplicate Key Error", "Duplicate Key Error", "You Have Entered A Duplicate Name");
_obj = null;
return(Task.FromResult(_obj));
}
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_obj));
}
public Task<vh_categoryC> AddVehicleCategory(dto_vehicle_category_newC _dto)
{
vh_categoryC _obj = null;
if (fnn.LOGGED_USER.DoesNotHaveRight(em.user_rights_types.can_create_vehicle_category))
{
AddErrorMessage("Limited Rights Error", "Rights Error", "You Can Not Perform This Operation");
return Task.FromResult(_obj);
}
if (string.IsNullOrEmpty(_dto.vehicle_cat_name))
{
AddErrorMessage("Insert Error", "Save Error", "Vehicle Category Name Is Null");
_obj = null;
return Task.FromResult(_obj);
}
try
{
using (var _db = fnn.GetDbContext())
{
_obj = new vh_categoryC()
{
vehicle_cat_name = _dto.vehicle_cat_name.Trim().ToProperCase(),
fs_timestamp = fnn.GetUnixTimeStamp(),
server_edate = fnn.GetServerDate(),
created_by_user_id = m_logged_user.user_id
};
_db.VEHICLE_CATEGORIES.Add(_obj);
var _retVal = _db.SaveChangesWithDuplicateKeyDetected();
if (_retVal == null || _retVal.Value == true)
{
AddErrorMessage("Duplicate Key Error", "Duplicate Key Error", "You Have Entered A Duplicate Cake Category Name");
_obj = null;
return Task.FromResult(_obj);
}
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return Task.FromResult(_obj);
}
public Task <vehicle_ownerC> Add(dto_vehicle_owner_newC _dto)
{
vehicle_ownerC _obj = null;
if (_dto == null)
{
AddErrorMessage("Error", "Error", "New Vehicle Owner Object Is Null");
return(Task.FromResult(_obj));
}
if (string.IsNullOrEmpty(_dto.vh_owner_name))
{
AddErrorMessage("Error", "Error", "Vehicle Owner Name Is Missing");
return(Task.FromResult(_obj));
}
try
{
using (var _db = fnn.GetDbContext())
{
_obj = new vehicle_ownerC()
{
vh_owner_name = _dto.vh_owner_name.Trim(),
server_edate = fnn.GetServerDate(),
fs_timestamp = fnn.GetUnixTimeStamp(),
created_by_user_id = m_logged_user.user_id,
};
_db.VEHICLE_OWNERS.Add(_obj);
var _retVal = _db.SaveChangesWithDuplicateKeyDetected();
if (_retVal == null || _retVal.Value == true)
{
AddErrorMessage("Duplicate Key Error", "Duplicate Key Error", "You Have Entered A Duplicate Vehicle Owner Name");
_obj = null;
return(Task.FromResult(_obj));
}
fnn.CreateCreditor(_obj.vh_owner_id, _obj.vh_owner_name, _obj.vh_owner_phone_no, FleetManager.Shared.em.creditor_typeS.vehicle_owner, _db);
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_obj));
}
/// <summary>
/// Added tags collection
/// </summary>
/// <param name="uniqueDicCode"></param>
/// <returns></returns>
///
private void StartIntegration()
{
Task.Run(() => _tagReadsSync.StartTagReads());
LoggerX.WriteEventLog("Tag Read Monitor has started...");
Task.Run(() => _RNCHeartbeatSync.StartAsync());
LoggerX.WriteEventLog("RNC Heartbeat Monitor started...");
Task.Run(() => _devicestatusSync.StartDeviceStatus());
LoggerX.WriteEventLog("Device Status Monitor started...");
Task.Run(() => _unreadRFIDSync.StartUnSeenMonitor());
LoggerX.WriteEventLog("Unread list Monitor started...");
Task.Run(() => _devicestatusSync.StartDeviceStatus());
LoggerX.WriteEventLog("Keyframe sending started...");
Task.Run(() => _keyFrameSync.StartKeyFrameMonitor());
}
public async Task StartAsync()
{
try
{
var _iotObject = new IotObject();
_iotObject.Group = "RFID";
_iotObject.DeviceType = "RNC";
_iotObject.DeviceName = IotGateway.GatewayId;
_iotObject.ObjectType = "HEARTBEAT";
while (true)
{
await UpdateLastCheckedLog(InterfaceType.rncheartbeat);
var lst = new List <(string, string, object)>();
Console.WriteLine("Check RNC Heartbeat");
//Check if the RNC Server is online -RNC IP Address is configurable in app.config
if (await IsRNCAlive(IotGateway.RNCIpAddress))
{
_iotObject.Object = 1;
IotGateway.Heartbeat = true;
LoggerX.WriteEventLog($"RNC Heartbeat is alive");
}
else
{
_iotObject.Object = 0;
IotGateway.Heartbeat = false;
LoggerX.WriteEventLog($"RNC Heartbeat is dead");
}
lst.Add(_iotObject.ToString());
Console.WriteLine("Attempting to send " + DateTime.Now.ToString());
await SendNotification(lst);
await UpdateLastUpdatedLog(InterfaceType.rncheartbeat);
LoggerX.WriteEventLog($"RNC Heartbeat Notification Sent ");
if (IotGateway.RNCCheckInterval > 0)
{
await Task.Delay((int)(IotGateway.RNCCheckInterval * 1000));
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
LoggerX.WriteErrorLog(ex);
_logger.LogError(ex, $"Sending notification for gateway {IotGateway.GatewayId}");
}
}
public Task <projectC> Add(dto_project_newC _dto)
{
projectC _obj = null;
if (_dto == null)
{
AddErrorMessage("Error", "Error", "New Project Object Is Null");
return(Task.FromResult(_obj));
}
if (string.IsNullOrEmpty(_dto.project_name))
{
AddErrorMessage("Error", "Error", "Project Name Is Missing");
return(Task.FromResult(_obj));
}
try
{
using (var _db = fnn.GetDbContext())
{
_obj = new projectC()
{
project_name = _dto.project_name.Trim(),
server_edate = fnn.GetServerDate(),
fs_timestamp = fnn.GetUnixTimeStamp(),
created_by_user_id = m_logged_user.user_id,
};
_db.PROJECTS.Add(_obj);
var _retVal = _db.SaveChangesWithDuplicateKeyDetected();
if (_retVal == null || _retVal.Value == true)
{
AddErrorMessage("Duplicate Key Error", "Duplicate Key Error", "You Have Entered A Duplicate Project Name");
_obj = null;
return(Task.FromResult(_obj));
}
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_obj));
}
public Task <List <vh_expense_transC> > GetExpensesByExpenseType(dto_fs_rangeC _dto)
{
List <vh_expense_transC> _list = null;
if (_dto == null)
{
AddErrorMessage("Error", "Error", "Expense Object Can Not Be Null");
return(Task.FromResult(_list));
}
if (_dto.filter_id == 0)
{
AddErrorMessage("Error", "Error", "Filter Id Can Not Be Null");
return(Task.FromResult(_list));
}
string _sql = null;
try
{
using (var _db = fnn.GetDbConnection())
{
if (_dto.fs_time_stamp == 0)
{
_sql = string.Format("select * from {0} where delete_id = 0", _table_name.ToDbSchemaTable());
_list = _db.Query <vh_expense_transC>(_sql).ToList();
}
else
{
_sql = string.Format("select * from {0} where exp_type_id = {1} and fs_timestamp > {2} and fs_timestamp < {3} and delete_id = 0",
_table_name.ToDbSchemaTable(), _dto.filter_id, _dto.start_fs_id, _dto.end_fs_id);
_list = _db.Query <vh_expense_transC>(_sql).ToList();
}
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_list));
}
public async Task InitAsync()
{
try
{
_logger.LogInformation("Waiting for connecting...");
LoggerX.WriteEventLog("Waiting for connecting...");
if (!string.IsNullOrWhiteSpace(IotGateway.Secret))
{
_logger.LogInformation($"Registering gateway {IotGateway.GatewayId}");
LoggerX.WriteEventLog($"Registering gateway {IotGateway.GatewayId}");
var gw = new Gateway.API.Abstractions.Gateway
{
GatewayId = IotGateway.GatewayId,
Secret = IotGateway.Secret,
Make = "Innotrack",
Model = "Vodaworld-RNC",
FirmwareVersion = typeof(Gateway1Simulation).Assembly.GetName().Version.ToString(),
Devices = new Dictionary <string, Device>()
};
gw.Devices = await IotGateway.GetIotDevices();
// gw.Devices.Add("RFID|1:ZONE|ZONE1", new Device() { DeviceName = "RFID|1:ZONE|ZONE1", DeviceType = "ZONE", Properties = new Dictionary<string, DeviceProperty>() { { "TAGS", new DeviceProperty() { PropertyName = "TAGS", DataType = "RFIDDictionary" } } } });
await DapiContext.ExecuteAsync(username : IotGateway.UserName, action : () => _gatewayApi.RegisterGatewayFromGatewayAsync(gw));
if (!string.IsNullOrWhiteSpace(IotGateway.ClientId))
{
_logger.LogInformation($"Associating gateway {IotGateway.GatewayId} with client {IotGateway.ClientId}");
LoggerX.WriteEventLog($"Associating gateway {IotGateway.GatewayId} with client {IotGateway.ClientId}");
await DapiContext.ExecuteAsync(username : "******", action : () => _entityApi.AssociateGatewayAndClientAsync(IotGateway.GatewayId, IotGateway.ClientId));
}
}
connected = true;
_logger.LogInformation($"Simulating gateway {IotGateway.GatewayId} started...");
LoggerX.WriteEventLog($"Simulating gateway {IotGateway.GatewayId} started...");
StartIntegration();
}
catch (Exception ex)
{
connected = false;
_logger.LogError(ex, "Error initialization simulator");
}
}
public Task <List <creditor_depositC> > GetAllCreditorDepositsByRange(dto_fs_rangeC _dto)
{
List <creditor_depositC> _list = null;
if (_dto == null)
{
AddErrorMessage("Error", "Error", "DTO Can Not Be Null");
return(Task.FromResult(_list));
}
string _sql = null;
try
{
using (var _db = fnn.GetDbConnection())
{
if (_dto.fs_time_stamp == 0)
{
_sql = string.Format("select * from {0} where (deposit_fs_id>={1} and deposit_fs_id <= {2}) and delete_id = 0",
FleetManager.DbBase.tableNames.creditor_deposit_tb.ToDbSchemaTable(), _dto.start_fs_id, _dto.end_fs_id);
_list = _db.Query <creditor_depositC>(_sql).ToList();
}
else
{
_sql = string.Format("select * from {0} where (deposit_fs_id >={1} and deposit_fs_id <= {2}) and fs_timestamp >{3}",
FleetManager.DbBase.tableNames.creditor_deposit_tb.ToDbSchemaTable(), _dto.start_fs_id, _dto.end_fs_id, _dto.fs_time_stamp);
_list = _db.Query <creditor_depositC>(_sql).ToList();
}
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_list));
}
public Task <List <creditor_depositC> > GetCreditorDepositsByCreditorId(int cr_account_id, long fs_timestamp)
{
List <creditor_depositC> _list = null;
string _sql = null;
try
{
using (var _db = fnn.GetDbConnection())
{
if (fs_timestamp == 0)
{
_sql = string.Format("select * from {0} where cr_account_id={1} and delete_id = 0",
FleetManager.DbBase.tableNames.creditor_deposit_tb.ToDbSchemaTable(), cr_account_id);
_list = _db.Query <creditor_depositC>(_sql).ToList();
}
else
{
_sql = string.Format("select * from {0} where cr_account_id={1} and fs_timestamp > {2}",
FleetManager.DbBase.tableNames.creditor_deposit_tb.ToDbSchemaTable(), cr_account_id, fs_timestamp);
_list = _db.Query <creditor_depositC>(_sql).ToList();
}
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_list));
}
public TagReadsSync(IRedGreenQueueAdapter redq, ILogger <TagReads> logger, LoggerX loggerx) : base(redq, loggerx)
{
_logger = logger;
TagList = new List <TagReads>();
}
/// <summary>
/// Loop through all devices and send current tag list to IoT Cloud Platform
/// </summary>
/// <returns></returns>
public async Task StartKeyFrameMonitor()
{
while (DeviceList.Count == 0)
{
DeviceList = await new Device().ReadAsync();
}
while (true)
{
try
{
await UpdateLastCheckedLog(InterfaceType.keyframe);
var lst = new List <(string, string, object)>();
foreach (var device in DeviceList)
{
var _iotObject = new IotObject();
_iotObject.Group = "RFID";
await _iotObject.SetDevice(device);
_iotObject.ObjectType = "TAGS";
//Add all added tag of device
await Task.Delay(100);
Dictionary <string, JObject> Alltags = null;
while (Alltags == null)
{
Alltags = await GetCurrentDeviceTagList(device);
}
//if (Alltags.Count == 0)
// continue;
LoggerX.WriteEventLog($"{Alltags.Count} tags found at device {device.DeviceName}");
var value = new JObject
{
["reset"] = JObject.FromObject(Alltags)
};
_iotObject.Object = value;
lst.Add(_iotObject.ToString());
//Console.WriteLine(JArray.FromObject(lst).ToString());
}
_logger.LogTrace("Logging: Key frame attempt");
Console.WriteLine("Key frame try..");
LoggerX.WriteEventLog("Reset Notification Try");
await SendNotification(lst);
await UpdateLastUpdatedLog(InterfaceType.keyframe);
LoggerX.WriteEventLog("Reset Notification Sent");
//Delay For Total Key Frame Interval Seconds
if (IotGateway.KeyframeInterval > 0)
{
await Task.Delay((int)(IotGateway.KeyframeInterval * 1000));
}
}
catch (Exception ex)
{
LoggerX.WriteErrorLog(ex);
_logger.LogError(ex, $"Sending notification for gateway {IotGateway.GatewayId}");
}
}
}
public KeyFrameSync(IRedGreenQueueAdapter redq, ILogger <KeyFrameSync> logger, LoggerX loggerX) : base(redq, loggerX)
{
DeviceList = new List <Device>();
_logger = logger;
}
public Task <vh_expense_typeC> Add(dto_expense_type_newC _dto)
{
vh_expense_typeC _obj = null;
if (fnn.LOGGED_USER.DoesNotHaveRight(em.user_rights_types.can_delete_expense_type_field))
{
AddErrorMessage("Limited Rights Error", "Rights Error", "You Can Not Perform This Operation");
return(Task.FromResult(_obj));
}
if (_dto == null)
{
AddErrorMessage("Error", "Error", "New Expense Object Is Null");
return(Task.FromResult(_obj));
}
if (_dto.exp_cat_id == 0)
{
AddErrorMessage("Error", "Error", "No Expense Category Selected");
return(Task.FromResult(_obj));
}
if (string.IsNullOrEmpty(_dto.exp_type_name))
{
AddErrorMessage("Error", "Error", "Expense Type Name Is Missing");
return(Task.FromResult(_obj));
}
try
{
using (var _db = fnn.GetDbContext())
{
_obj = new vh_expense_typeC()
{
exp_cat_id = _dto.exp_cat_id,
exp_type_name = _dto.exp_type_name.Trim(),
server_edate = fnn.GetServerDate(),
fs_timestamp = fnn.GetUnixTimeStamp(),
created_by_user_id = m_logged_user.user_id,
};
_db.EXPENSE_TYPES.Add(_obj);
var _retVal = _db.SaveChangesWithDuplicateKeyDetected();
if (_retVal == null || _retVal.Value == true)
{
AddErrorMessage("Duplicate Key Error", "Duplicate Key Error", "You Have Entered A Duplicate Expense Type Name");
_obj = null;
return(Task.FromResult(_obj));
}
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_obj));
}
public Task <vh_expense_typeC> Update(dto_expense_type_updateC _dto)
{
vh_expense_typeC _existing = null;
if (fnn.LOGGED_USER.DoesNotHaveRight(em.user_rights_types.can_edit_expense_type))
{
_existing = null;
AddErrorMessage("Limited Rights Error", "Rights Error", "You Can Not Perform This Operation");
return(Task.FromResult(_existing));
}
if (string.IsNullOrEmpty(_dto.exp_type_name))
{
AddErrorMessage("Update Error", "Save Error", "Expense Type Name Is Null!");
return(Task.FromResult(_existing));
}
try
{
using (var _trans = new ZUpdateContext())
{
_existing = _trans.Context.EXPENSE_TYPES.Where(e => e.exp_type_id == _dto.exp_type_id & e.delete_id == 0).FirstOrDefault();
if (_existing == null)
{
AddErrorMessage("Update Error", "Save Error", "Unable To Find Expense Type Object");
return(Task.FromResult(_existing));
}
if (_existing.exp_type_id < 0)
{
AddErrorMessage("Update Error", "Update Error", "Cannot Update A System Defined Expense Type");
return(Task.FromResult(_existing));
}
if (_existing.exp_type_name.ToLower() != _dto.exp_type_name.ToLower())
{
var _ret = DbHelper.UpdatePrimaryKeyColumn(new DbHelperPrimarykeyUpdateC
{
col_to_update = "exp_type_name",
new_col_value = _dto.exp_type_name.Trim().ToProperCase(),
table_name = DbHelper.GetTableSchemaName(_table_name),
pk_col_name = "exp_type_id",
pk_id = _dto.exp_type_id
}, _trans.Context);
if (_ret == null || _ret.Value == false)
{
AddErrorMessage("Error", "Update Error", "Expense Type Name Already Exists");
_trans.RollBack();
return(Task.FromResult(_existing));
}
else
{
_trans.Context.SaveChanges();
_existing = _trans.Context.EXPENSE_TYPES.Where(e => e.exp_type_id == _dto.exp_type_id & e.delete_id == 0).FirstOrDefault();
}
}
SimpleMapper.PropertyMap(_dto, _existing);
_trans.Context.EXPENSE_TYPES.AddOrUpdateExtension(_existing);
_trans.Context.SaveChanges();
_trans.Commit();
return(Task.FromResult(_existing));
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_existing));
}
public Task <bool> Delete(int id)
{
bool _record_deleted = false;
if (fnn.LOGGED_USER.DoesNotHaveRight(em.user_rights_types.can_delete_expense_type))
{
_record_deleted = false;
AddErrorMessage("Limited Rights Error", "Rights Error", "You Can Not Perform This Operation");
return(Task.FromResult(_record_deleted));
}
try
{
using (var _db = fnn.GetDbContext())
{
var exp_type = _db.EXPENSE_TYPES.Where(e => e.exp_type_id == id & e.delete_id == 0).FirstOrDefault();
if (exp_type == null)
{
AddErrorMessage("Error", "Error", "Unable To Find Expense Type Object");
_record_deleted = false;
return(Task.FromResult(_record_deleted));
}
else
{
if (exp_type.exp_type_id < 0)
{
AddErrorMessage("Update Error", "Update Error", "Cannot Delete A System Defined Expense Type");
_record_deleted = false;
return(Task.FromResult(_record_deleted));
}
var _has_dependency = DbHelper.HasDbDependencies(_db.Database, new string[] { DbHelper.GetTableSchemaName(_table_name) }, DbHelper.GetDbSchema(), new string[] { "exp_type_id" }, id);
if (_has_dependency == null || _has_dependency == true)
{
AddErrorMessage("Delete Error", "Delete Error", "Unable To Delete Record Because It Has System Dependencies.");
_record_deleted = false;
return(Task.FromResult(_record_deleted));
}
else
{
var _result = DbHelper.DeleteRecordWithDeleteId(new DbHelperDeleteRecordC()
{
pk_col_name = "exp_type_id",
pk_id = exp_type.exp_type_id,
table_name = DbHelper.GetTableSchemaName(_table_name)
}, _db);
if (_result == null || _result == false)
{
AddErrorMessage("Delete Error", "Delete Error", "Error Encountered While Trying To Delete Record");
_record_deleted = false;
return(Task.FromResult(_record_deleted));
}
else
{
_record_deleted = true;
_db.SaveChanges();
return(Task.FromResult(_record_deleted));
}
}
}
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_record_deleted));
}
public Task <vehicle_ownerC> Update(dto_vehicle_owner_updateC _dto)
{
vehicle_ownerC _existing = null;
if (_dto == null)
{
AddErrorMessage("Update Error", "Save Error", "Driver Object Is Null!");
_existing = null;
return(Task.FromResult(_existing));
}
if (_dto.vh_owner_id == 0)
{
AddErrorMessage("Error", "Error", "Vehicle Owner Id Is Missing");
return(Task.FromResult(_existing));
}
if (string.IsNullOrEmpty(_dto.vh_owner_name))
{
AddErrorMessage("Error", "Error", "Vehicle Owner Name Is Missing");
return(Task.FromResult(_existing));
}
try
{
using (var _trans = new ZUpdateContext())
{
_existing = _trans.Context.VEHICLE_OWNERS.Where(e => e.vh_owner_id == _dto.vh_owner_id & e.delete_id == 0).FirstOrDefault();
if (_existing == null)
{
_existing = null;
AddErrorMessage("Update Error", "Save Error", "Unable To Find Project Object");
return(Task.FromResult(_existing));
}
if (_existing.vh_owner_name.ToLower() != _dto.vh_owner_name.ToLower())
{
var _ret = DbHelper.UpdatePrimaryKeyColumn(new DbHelperPrimarykeyUpdateC
{
col_to_update = "vh_owner_name",
new_col_value = _dto.vh_owner_name.Trim().ToProperCase(),
table_name = DbHelper.GetTableSchemaName(_table_name),
pk_col_name = "vh_owner_id",
pk_id = _dto.vh_owner_id
}, _trans.Context);
if (_ret == null || _ret.Value == false)
{
AddErrorMessage("Error", "Update Error", "Vehicle Owner Name Already Exists");
_existing = null;
_trans.RollBack();
return(Task.FromResult(_existing));
}
else
{
_trans.Context.SaveChanges();
_existing = _trans.Context.VEHICLE_OWNERS.Where(e => e.vh_owner_id == _dto.vh_owner_id & e.delete_id == 0).FirstOrDefault();
}
}
if (_existing.cr_account_id > 0)
{
string _sql = string.Format("update {0} set cr_account_name=@v1,cr_phone_no=@v2,fs_timestamp=@v3 where cr_account_id=@v4 and delete_id=0",
FleetManager.DbBase.tableNames.creditor_tb.ToDbSchemaTable());
_trans.Context.Database.Connection.Execute(_sql, new
{
v1 = _existing.vh_owner_name,
v2 = _existing.vh_owner_phone_no,
v3 = fnn.GetUnixTimeStamp(),
v4 = _existing.cr_account_id
}, _trans.Context.Database.GetDbTransaction());
_trans.Context.SaveChanges();
}
SimpleMapper.PropertyMap(_dto, _existing);
_trans.Context.VEHICLE_OWNERS.AddOrUpdateExtension(_existing);
_trans.Context.SaveChanges();
_trans.Commit();
return(Task.FromResult(_existing));
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
return(Task.FromResult(_existing));
}
public Task <bool> Delete(int id)
{
vehicle_ownerC _existing = null;
bool _record_deleted = false;
try
{
using (var _db = fnn.GetDbContext())
{
_existing = _db.VEHICLE_OWNERS.Where(e => e.vh_owner_id == id & e.delete_id == 0).SingleOrDefault();
if (_existing == null)
{
_record_deleted = false;
AddErrorMessage("Delete Error", "Delete Error", "Could Not Find Vehicle Owner Object");
return(Task.FromResult(_record_deleted));
}
else
{
var _has_dependency = DbHelper.HasDbDependencies(_db.Database, new string[] { DbHelper.GetTableSchemaName(_table_name) },
DbHelper.GetDbSchema(), new string[] { "vh_owner_id" }, id);
if (_has_dependency == null || _has_dependency == true)
{
AddErrorMessage("Delete Error", "Delete Error", "Unable To Delete Record Because It Has System Dependencies.");
_record_deleted = false;
return(Task.FromResult(_record_deleted));
}
else
{
var _result = DbHelper.DeleteRecordWithDeleteId(new DbHelperDeleteRecordC()
{
pk_col_name = "vh_owner_id",
pk_id = _existing.vh_owner_id,
table_name = _table_name.ToDbSchemaTable()
}, _db);
if (_result == null || _result == false)
{
AddErrorMessage("Delete Error", "Delete Error", "Error Encountered While Trying To Delete Record");
_record_deleted = false;
return(Task.FromResult(_record_deleted));
}
else
{
_record_deleted = true;
_db.SaveChanges();
}
}
}
}
}
catch (SqlException ex)
{
LoggerX.LogException(ex);
}
catch (DbException ex)
{
LoggerX.LogException(ex);
}
catch (Exception ex)
{
LoggerX.LogException(ex);
}
if (_record_deleted)
{
Task.Run(() =>
{
if (_existing.cr_account_id > 0)
{
fnn.DeleteCreditor(_existing.cr_account_id);
}
});
}
return(Task.FromResult(_record_deleted));
}
public DeviceStatusSync(IRedGreenQueueAdapter redq, ILogger <DeviceStatusSync> logger, LoggerX loggerX) : base(redq, loggerX)
{
Devices = new List <Device>();
_logger = logger;
}
public async Task StartTagReads()
{
// await Gateway.InitAsync();
while (true)
{
LoggerX.WriteDebugLog("1. Check for un processed tags");
//Get all un seen tags
//while(TagList == null)
TagList = await CheckForUnprocessedTags();
//Loop through all unprocessed tags
LoggerX.WriteDebugLog($"2. {TagList.Count} Tags found to process");
foreach (var read in TagList)
{
try
{
var lst = new List <(string, string, object)>();
var _iotObject = new IotObject("RFID");//Group name
await UpdateLastCheckedLog(InterfaceType.tagreads);
//Add new tag read of device
LoggerX.WriteDebugLog($"3. Get all tags of device {read.Device.DeviceName}");
Dictionary <string, RfidTag> addedUpdatedTags = null;
while (addedUpdatedTags == null)
{
addedUpdatedTags = await GetAddedTags(read.Device.DeviceName);
}
var value = new JObject
{
["addOrUpdate"] = JObject.FromObject(addedUpdatedTags)
};
LoggerX.WriteDebugLog($"4. Add device taglist to iot object");
//AddTagRead(read.Device.DeviceName, read.EPC, read.DateTime.ToString());
//Remove all tags from last device and add to
LoggerX.WriteDebugLog($"5. Get remove list");
await AddRemovedTagsToList(lst);
LoggerX.WriteDebugLog($"6. Remove list added to iot object");
// await Task.Delay(10);
LoggerX.WriteEventLog($"7. {read.EPC} tags read at device: {read.Device.DeviceName}");
_iotObject.Object = value;
_iotObject.Group = "RFID";
// _iotObject.DeviceType = "ZONE";
await _iotObject.SetDevice((Innotrack.DeviceManager.Entities.Device) read.Device);
//_iotObject.DeviceName = read.Device.DeviceName;
_iotObject.ObjectType = "TAGS";
lst.Add(_iotObject.ToString());
LoggerX.WriteEventLog($"8. Fill iot object");
// lst.Add(("RFID|1:ZONE|" + read.Device.DeviceName, "TAGS", value));
if (lst.Count > 0)
{
LoggerX.WriteEventLog(JArray.FromObject(lst).ToString());
LoggerX.WriteEventLog("Tag Reads Notification Try");
await SendNotification(lst);
LoggerX.WriteEventLog("Tag Reads Notification Sent");
UpdateTagReadsHostSeen();
//read.HostSeen = true;
//read.Update();
await UpdateLastUpdatedLog(InterfaceType.tagreads);
lst.Clear();
}
}
catch (Exception ex)
{
LoggerX.WriteErrorLog(ex);
_logger.LogError(ex, $"Sending notification for gateway {IotGateway.GatewayId}");
// await Task.Delay((int)(Math.Max(1, sim.IntervalSeconds) * 1000));
}
break;
}
await Task.Delay(50);
}
// ReSharper disable once FunctionNeverReturns
}
