public async Task <ParameterValue> GetParameterValue(string channelId, int nodeId, ushort index, byte subIndex)
{
ParameterValue result = null;
try
{
MsgLogger.WriteLine($"get parameter, index=0x{index:X4}, subindex=0x{subIndex:X4}, device node id={nodeId}");
var query = HttpUtility.ParseQueryString(string.Empty);
query["callerId"] = channelId;
query["nodeId"] = $"{nodeId}";
query["index"] = $"{index}";
query["subIndex"] = $"{subIndex}";
var url = UrlHelper.BuildUrl(Url, "api/parameter/value", query);
var json = await Transporter.Get(_identity, url);
var parameterValue = json.TryDeserializeObject <ParameterValue>();
if (parameterValue != null)
{
result = parameterValue;
MsgLogger.WriteLine($"get parameter, index=0x{index:X4}, subindex=0x{subIndex:X4}, device node id={nodeId} - success");
}
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - GetParameterValue", e);
}
return(result);
}
public void SetDisconnected()
{
bool result = false;
if (Mutex.TryOpenExisting(LockingObjectName, out var lockingObject))
{
try
{
if (lockingObject.WaitOne(0))
{
lockingObject.ReleaseMutex();
}
lockingObject.Close();
_lockingObject.Dispose();
}
catch (AbandonedMutexException e)
{
MsgLogger.Exception($"{GetType().Name} - method", e);
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - method", e);
}
_lockingObject = null;
result = true;
}
MsgLogger.WriteLine($"Set device {_device.Family} disconnected = {result}");
}
public bool SetConnected()
{
bool result = false;
try
{
if (Mutex.TryOpenExisting(LockingObjectName, out var lockingObject))
{
result = lockingObject.WaitOne(0);
}
else
{
_lockingObject = new Mutex(true, LockingObjectName);
result = _lockingObject != null;
}
}
catch (AbandonedMutexException e)
{
MsgLogger.Exception($"{GetType().Name} - method", e);
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - method", e);
}
MsgLogger.WriteLine($"Set device {_device.Family} connected = {result}");
return(result);
}
public bool Run()
{
bool result = false;
try
{
if (File.Exists(InputFileName))
{
MsgLogger.WriteLine($"Read input file '{InputFileName}'");
if (ReadInput(out var base64EncodedInput))
{
result = GenerateOutput(base64EncodedInput);
}
else
{
MsgLogger.WriteError($"{GetType().Name} - Run", $"Reading file '{InputFileName}' failed!");
}
}
else
{
MsgLogger.WriteError($"{GetType().Name} - Run", $"Specified file '{InputFileName}' doesn't exist!");
}
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - Run", e);
}
return(result);
}
protected bool ConnectToChannel()
{
bool result = false;
var t = Task.Run(async() =>
{
if (ConnectionManager != null)
{
MsgLogger.WriteLine($"{GetType().Name} - ConnectToChannel, connect to channel = {WsChannelName}");
if (await ConnectionManager.Connect(WsChannelId, WsChannelName))
{
if (!await SendChannelIdentyficationRequest())
{
MsgLogger.WriteError($"{GetType().Name} - ConnectToChannel", $"send ident request failed, channel = {WsChannelName}");
}
else
{
result = true;
}
}
}
});
t.Wait();
return(result);
}
private async void OnDeviceStatusChanged(object sender, EventArgs e)
{
if (sender is EposDevice device)
{
switch (device.Status)
{
case DeviceStatus.Connected:
{
MsgLogger.WriteLine($"Connected: device='{device.Family}', serial number=0x{device.Identification.SerialNumber:X}");
if (string.IsNullOrEmpty(device.Name))
{
device.Name = device.Identification.Name;
}
await CloudAgent.RegisterDevice(device);
} break;
case DeviceStatus.Disconnected:
{
MsgLogger.WriteLine($"Disconnected: device = {device.Family} - Unregister");
await CloudAgent.UnregisterDevice(device);
device.Status = DeviceStatus.Unregistered;
} break;
}
}
}
public override async Task <bool> SetCommandStatus(ExecuteCommandStatus status)
{
bool result = false;
if (ConnectionManager != null && status != null)
{
var wsChannelId = GetActiveChannelName(status.ChannelId, status.NodeId);
if (!string.IsNullOrEmpty(wsChannelId))
{
MsgLogger.WriteLine($"set (WS) command='{status.CommandName}' status='{status.Status}' for device with nodeid={status.NodeId}");
if (await ConnectionManager.Send(wsChannelId, _userIdentity, status))
{
result = true;
}
else
{
MsgLogger.WriteError($"{GetType().Name} - SetCommandStatus",
$"set (WS) command='{status.CommandName}' status='{status.Status}' for device with nodeid={status.NodeId} failed");
}
}
}
return(result);
}
private async void OnDeviceDetected(object sender, ScannerDeviceStatusChangedEventArgs e)
{
var device = e.Device;
if (device is EposDevice eposDevice)
{
AddDevice(device);
RegisterDeviceEvents(eposDevice);
MsgLogger.WriteDebug($"{GetType().Name} - method", $"try to connect to device {eposDevice.Family}");
if (!await ConnectDevice(eposDevice))
{
MsgLogger.WriteError($"{GetType().Name} - OnDeviceDetected", $"connect to device {eposDevice.Family} failed!");
UnregisterDeviceEvents(eposDevice);
}
else
{
MsgLogger.WriteDebug($"{GetType().Name} - method", $"connect to device {eposDevice.Family} successful");
}
}
else
{
MsgLogger.WriteLine($"device: {device.Family} not supported!");
}
}
private void OnStatusChanged()
{
MsgLogger.WriteLine($"agent status changed to {Status}");
StatusChanged?.Invoke(this, new AgentStatusEventArgs()
{
Status = Status
});
}
private async void OnVersionUpdated(object sender, DeviceVersionEventArgs e)
{
Status = DeviceStatus.VersionAvailable;
var msg =
$"Device version: 0x{e.Version.HardwareVersion:X} 0x{e.Version.SoftwareVersion:X} 0x{e.Version.ApplicationNumber:X} 0x{e.Version.ApplicationVersion:X}";
MsgLogger.WriteLine(msg);
await ReadDeviceDescriptionFile();
}
private async void HandleBrokenConnection(WebSocketError errorCode)
{
MsgLogger.WriteError($"{GetType().Name} - HandleBrokenConnection", $"Connection to '{Url}' failed, error code = {errorCode}");
if (errorCode == WebSocketError.ConnectionClosedPrematurely && Socket.State == WebSocketState.Open)
{
MsgLogger.WriteLine("try recover connection ...");
Initialize();
}
await Task.Delay(100);
}
public bool CanExecute(ExecuteCommand command)
{
bool result = false;
_lock.Wait();
if (command != null && !string.IsNullOrEmpty(command.CommandId))
{
var deviceCommand = command.Command;
if (!_cache.ContainsKey(command.CommandId))
{
_cache.Add(command.CommandId, new List <ExecuteCommandCacheEntry> {
new ExecuteCommandCacheEntry(deviceCommand)
});
result = true;
}
else
{
var entryList = _cache[command.CommandId];
if (entryList != null && deviceCommand != null)
{
result = true;
foreach (var entry in entryList)
{
if (entry.Status == deviceCommand.Status)
{
result = false;
break;
}
}
}
}
Cleanup();
}
_lock.Release();
if (!result)
{
MsgLogger.WriteLine($"drop command");
}
return(result);
}
protected void OnIdentificationStateChanged(object sender, DeviceIdentificationEventArgs e)
{
if (e.State == DeviceIdentificationState.Success)
{
Status = DeviceStatus.Identified;
MsgLogger.WriteLine($"Identified device='{e.Device.Family}' has serial number=0x{e.SerialNumber:X}");
(Version as EposDeviceVersion)?.Read();
}
else if (e.State == DeviceIdentificationState.Failed)
{
MsgLogger.WriteLine($"Device: {e.Device.Family} ({(e.Device as EposDevice)?.PortName}) - Identification failed, reason={e.LastErrorCode}");
}
}
private bool AddToRegisteredParameters(RegisteredParameter registeredParameter)
{
bool result = false;
if (_registeredParameters != null)
{
_registeredParameters.Add(registeredParameter.Key, registeredParameter);
registeredParameter.RefCount++;
MsgLogger.WriteLine($"(+)register parameter key='{registeredParameter.Key}'");
result = true;
}
return(result);
}
public bool Unregister(RegisteredParameter registeredParameter)
{
bool result = false;
MsgLogger.WriteDebug($"{GetType().Name} - Unregister", $"Unregister Parameter '{registeredParameter.Key}', index = {registeredParameter.Parameter.Index:X4}, subindex = {(registeredParameter.Parameter as XddParameter).SubIndex:X4}");
lock (RegisteredParametersLock)
{
if (_registeredParameters.ContainsKey(registeredParameter.Key))
{
var parameter = _registeredParameters[registeredParameter.Key];
if (parameter != null)
{
parameter.RefCount--;
if (parameter.RefCount == 0)
{
result = _registeredParameters.Remove(registeredParameter.Key);
MsgLogger.WriteLine($"(-)unregister parameter key='{registeredParameter.Key}', result={result}");
}
else
{
MsgLogger.WriteLine($"(-)unregister parameter key='{registeredParameter.Key}', refCount = {parameter.RefCount}");
result = true;
}
}
else
{
MsgLogger.WriteError($"{GetType().Name} - Unregister", $"(-)unregister parameter key='{registeredParameter.Key}' failed, parameter empty!");
}
}
else
{
MsgLogger.WriteError($"{GetType().Name} - Unregister", $"(-)unregister parameter key='{registeredParameter.Key}' failed, parametere not found!");
}
}
MsgLogger.WriteDebug($"{GetType().Name} - Unregister", $"Unregister Parameter '{registeredParameter.Key}' - OK");
return(result);
}
public async Task <ParameterValueHistoryStatistics> GetParameterHistoryStatistics(string callerId, int nodeId, string uniqueId, DateTime from, DateTime to)
{
ParameterValueHistoryStatistics result = null;
try
{
MsgLogger.WriteLine($"get parameter history statistics, device node id={nodeId}");
var query = HttpUtility.ParseQueryString(string.Empty);
query["callerId"] = callerId;
query["nodeId"] = $"{nodeId}";
query["uniqueId"] = $"{uniqueId}";
query["from"] = $"{from}";
query["to"] = $"{to}";
var url = UrlHelper.BuildUrl(Url, "api/parameter/history-statistics", query);
var json = await Transporter.Get(_identity, url);
if (!string.IsNullOrEmpty(json))
{
var historyStatistics = json.TryDeserializeObject <ParameterValueHistoryStatistics>();
if (historyStatistics != null)
{
result = historyStatistics;
MsgLogger.WriteLine($"get parameter history statistics, device serial number={nodeId} - success");
}
}
else
{
MsgLogger.WriteError($"{GetType().Name} - GetParameterHistoryStatistics", $"get parameter history statistics, device serial number={nodeId} - failed");
}
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - GetParameterHistoryStatistics", e);
}
return(result);
}
public async Task <string> Receive()
{
string result = string.Empty;
try
{
var wsMsg = await ReadWsMessage();
if (wsMsg is WsMessageAck)
{
result = wsMsg.Data;
}
else if (wsMsg != null)
{
if (await Send(new UserIdentity(), new WsMessageAck()))
{
result = wsMsg.Data;
LastCloseStatus = null;
}
}
else if (IsConnected)
{
MsgLogger.WriteError($"{GetType().Name} - Receive", $"receive ws message failed!");
}
else
{
MsgLogger.WriteLine($"receive ws message skipped, socket state = {Socket.State}!");
}
}
catch (WebSocketException e)
{
MsgLogger.Exception($"{GetType().Name} - Receive", e);
HandleBrokenConnection(e.WebSocketErrorCode);
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - Receive", e);
}
return(result);
}
static int Main(string[] args)
{
int result = 1;
MsgLogger.LogOutputs = "Console;Debug;";
MsgLogger.LogLevels = MsgLogger.SupportedLogLevels;
MsgLogger.WriteLine("Eltra navigo hash generator, Copyright (c) 2020 Dawid Sienkiewicz!");
if (args.Length > 0)
{
string fileName = args[0];
var hashGenerator = new HashGenerator()
{
InputFileName = fileName
};
if (hashGenerator.Run())
{
FileInfo fi = new FileInfo(fileName);
FileInfo fo = new FileInfo(hashGenerator.OutputFileName);
MsgLogger.WriteLine($"File '{fi.Name}' hash '{hashGenerator.OutputHashCode}' generation success!");
MsgLogger.WriteLine($"File '{fo.Name}' generation success!");
MsgLogger.WriteLine($"File output path '{fo.DirectoryName}'");
result = 0;
}
else
{
MsgLogger.WriteError("Program - Main", $"File '{fileName}' hash generation failed!");
}
}
else
{
MsgLogger.WriteError("Program - Main", "No file specified!");
}
return(result);
}
private void QueueParameterChanged(ParameterChangeQueueItem queueItem)
{
queueItem.WorkingTask = Task.Run(async() =>
{
MsgLogger.WriteLine($"changed: {queueItem.UniqueId}, new value = '{CreateShortLogValue(queueItem.ActualValue)}'");
bool skipProcessing = _parameterChangeQueue.ShouldSkip(queueItem);
if (!skipProcessing)
{
await UpdateParameterValue(queueItem.NodeId, queueItem.Index, queueItem.SubIndex, queueItem.ActualValue);
}
else
{
MsgLogger.WriteDebug($"{GetType().Name} - QueueParameterChanged", "Skip parameter change processing, queue already has item with higher timestamp");
}
});
_parameterChangeQueue.Add(queueItem);
}
private bool UpdateParameterRefCount(RegisteredParameter registeredParameter)
{
bool result = false;
var parameter = _registeredParameters[registeredParameter.Key];
if (parameter != null)
{
parameter.RefCount++;
MsgLogger.WriteLine($"(+)register parameter key='{registeredParameter.Key}', refCount = {parameter.RefCount}");
result = true;
}
else
{
MsgLogger.WriteError($"{GetType().Name} - Register", $"(+)register parameter key='{registeredParameter.Key}' failed, parameter empty!");
}
return(result);
}
public override async Task <bool> SetCommandStatus(ExecuteCommandStatus status)
{
bool result = false;
if (ConnectionManager != null && ConnectionManager.IsConnected(CommandExecUuid))
{
MsgLogger.WriteLine($"set (WS) command='{status.CommandName}' status='{status.Status}' for device with nodeid={status.NodeId}");
if (await ConnectionManager.Send(CommandExecUuid, UserIdentity, status))
{
result = true;
}
else
{
MsgLogger.WriteError($"{GetType().Name} - SetCommandStatus",
$"set (WS) command='{status.CommandName}' status='{status.Status}' for device with nodeid={status.NodeId} failed");
}
}
return(result);
}
public async Task <bool> RegisterDevice(EltraDevice device)
{
bool result = true;
if (!await IsChannelRegistered())
{
if (await RegisterChannel())
{
MsgLogger.WriteLine($"register channel='{Channel.Id}' success");
}
else
{
MsgLogger.WriteError($"{GetType().Name} - RegisterDevice", $"register channel='{Channel.Id}' failed!");
result = false;
}
}
if (result)
{
if (!await IsDeviceRegistered(device))
{
result = await DeviceControllerAdapter.RegisterDevice(device);
}
else
{
result = await DeviceControllerAdapter.UpdateDevice(device);
}
}
if (result)
{
if (FindDevice(device.NodeId) == null)
{
AddDevice(device);
}
}
return(result);
}
public async Task <bool> Upload(DeviceDescriptionPayload deviceDescription)
{
bool result = false;
try
{
MsgLogger.WriteLine($"upload device description version='{deviceDescription.Version}'");
var postResult = await Transporter.Post(_identity, Url, "api/description/upload", deviceDescription.ToJson());
if (postResult.StatusCode == HttpStatusCode.OK)
{
result = true;
}
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - Upload", e);
}
return(result);
}
internal async Task <bool> UploadPayload(DeviceToolPayload payload)
{
bool result = false;
try
{
MsgLogger.WriteLine($"upload payload version='{payload.FileName}'");
var postResult = await Transporter.Post(_identity, Url, "api/description/payload-upload", payload.ToJson());
if (postResult.StatusCode == HttpStatusCode.OK)
{
result = true;
}
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - Upload", e);
}
return(result);
}
public async Task <T> Receive <T>()
{
T result = default;
try
{
var json = await Receive();
if (IsJson(json))
{
result = JsonConvert.DeserializeObject <T>(json);
}
else if (string.IsNullOrEmpty(json) && IsConnected)
{
MsgLogger.WriteLine($"empty string received, close status='{Socket.CloseStatus}'");
}
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - Receive", e);
}
return(result);
}
public async Task <List <ParameterValue> > GetParameterHistory(string callerId, int nodeId, string uniqueId, DateTime from, DateTime to)
{
var result = new List <ParameterValue>();
try
{
MsgLogger.WriteLine($"get parameter history, device serial number={nodeId}");
var query = HttpUtility.ParseQueryString(string.Empty);
query["callerId"] = callerId;
query["nodeId"] = $"{nodeId}";
query["uniqueId"] = $"{uniqueId}";
query["from"] = $"{from}";
query["to"] = $"{to}";
var url = UrlHelper.BuildUrl(Url, "api/parameter/history", query);
var json = await Transporter.Get(_identity, url);
var parameterValues = json.TryDeserializeObject <ParameterValueList>();
if (parameterValues != null)
{
result = parameterValues.Items;
MsgLogger.WriteLine($"get parameter history, device serial number={nodeId} - success");
}
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - GetParameterHistory", e);
}
return(result);
}
protected virtual void OnConnectionManagerChanged()
{
MsgLogger.WriteLine($"{GetType().Name} - OnConnectionManagerChanged, connection manager set, channel = {WsChannelName}");
ConnectToChannel();
}
private Task UpdateAvailableDevicesListAsync(string deviceName)
{
MsgLogger.WriteLine($"Update device: {deviceName}");
return(Task.Run(() => UpdateAvailableDevicesList(_cancelationTokenSource.Token, deviceName)));
}
public override async Task <bool> Update()
{
bool result = false;
try
{
MsgLogger.WriteDebug($"{GetType().Name} - Update", $"Is channel='{Channel.Id}' registered...");
if (await IsChannelRegistered())
{
MsgLogger.WriteDebug($"{GetType().Name} - Update", $"Is any channel='{Channel.Id}' device not registered...");
if (await AnyDeviceUnRegistered())
{
MsgLogger.WriteLine($"re-register channel='{Channel.Id}' devices");
if (!await DeviceControllerAdapter.RegisterDevices())
{
MsgLogger.WriteError($"{GetType().Name} - Update", $"register channel='{Channel.Id}' devices failed!");
}
}
MsgLogger.Write($"{GetType().Name} - Update", $"Updating channel='{Channel.Id}' status...");
result = await SetChannelStatus(ChannelStatus.Online);
}
else
{
MsgLogger.WriteLine($"Registering channel='{Channel.Id}' ...");
if (await RegisterChannel())
{
MsgLogger.Write($"{GetType().Name} - Update", $"updating channel='{Channel.Id}' status ...");
result = await SetChannelStatus(ChannelStatus.Online);
if (result)
{
MsgLogger.WriteLine($"update channel='{Channel.Id}' status success");
}
else
{
MsgLogger.WriteError($"{GetType().Name} - Update", $"update channel='{Channel.Id}' status failed!");
}
}
else
{
MsgLogger.WriteError($"{GetType().Name} - Update", $"register channel='{Channel.Id}' failed!");
}
if (result)
{
MsgLogger.WriteLine($"Registering devices='{Channel.Id}' ...");
result = await DeviceControllerAdapter.RegisterDevices();
if (result)
{
MsgLogger.WriteLine($"register channel='{Channel.Id}' devices success");
}
else
{
MsgLogger.WriteError($"{GetType().Name} - Update", $"register channel='{Channel.Id}' devices failed!");
}
}
}
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - AnyDeviceUnRegistered", e);
}
return(result);
}
