862 lines
33 KiB
C#
862 lines
33 KiB
C#
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
using System.IO.Ports;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Windows.Forms;
|
|
using System.Xml.Linq;
|
|
using Xylem.Common.CommonCore.Consts;
|
|
using Xylem.Common.Hardware.Interfaces.Ports.PortCore;
|
|
using Xylem.Common.Hardware.Interfaces.Ports.PortCore.EventArguments;
|
|
using Xylem.Common.Hardware.Interfaces.Ports.SerialPorts;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisConfig;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore;
|
|
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
|
|
using Xylem.Common.Utils.Logging;
|
|
using NLog;
|
|
using GenesisCordonelInterface.API;
|
|
|
|
namespace GenesisCordonelInterface.UI.LaatzenAPI_GenesisToolBox
|
|
{
|
|
/// <summary>
|
|
/// Setup of GTB
|
|
/// </summary>
|
|
public partial class FrmSetup : Form
|
|
{
|
|
private static readonly NLog.ILogger Logger = NLog.LogManager.GetLogger("GenesisCordonelInterface");
|
|
private readonly InterfaceGCIToLaatzen interfaceToLaatzen = new InterfaceGCIToLaatzen();
|
|
|
|
private const String RequestPortString = "RequestPort";
|
|
private const String RequestTypeString = "RequestType";
|
|
private const String StreamingPortString = "StreamingPort";
|
|
private const String SlotTypeString = "RefTemperature";
|
|
private const String SlotString = "Slot";
|
|
private const String StreamingDetectString = "DetectStreaming";
|
|
private const String RequestDetectString = "DetectRequest";
|
|
private const String ValueString = "Value";
|
|
private const String TextString = "Text";
|
|
|
|
private String _fileString;
|
|
private readonly String _serialConfigFilePathName;
|
|
private readonly String _offlinePwdPathName;
|
|
private readonly DataTable _slotConfigDataTable = new DataTable();
|
|
private readonly SirtConfig _sirtConfig = new SirtConfig();
|
|
private readonly ProcessConfig _configuration = new ProcessConfig();
|
|
|
|
private ConcurrentBag<String> _countRawData = new ConcurrentBag<String>();
|
|
private List<OfflinePasswordItem> _listOfOfflinePasswords = new List<OfflinePasswordItem>();
|
|
|
|
/// <summary>
|
|
/// Ctor
|
|
/// </summary>
|
|
public FrmSetup()
|
|
{
|
|
_serialConfigFilePathName = Path.Combine(
|
|
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
|
|
"Genesis",
|
|
ProgramConfig.SerialConfigFileName);
|
|
|
|
_offlinePwdPathName = Path.Combine(
|
|
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
|
|
"Genesis",
|
|
ProgramConfig.OfflineInfoFile);
|
|
|
|
if (!File.Exists(_offlinePwdPathName))
|
|
{
|
|
_listOfOfflinePasswords.Add(new OfflinePasswordItem("", ""));
|
|
File.WriteAllText(_offlinePwdPathName, JsonConvert.SerializeObject(_listOfOfflinePasswords));
|
|
}
|
|
|
|
_slotConfigDataTable.Columns.Add(SlotString, typeof(String));
|
|
_slotConfigDataTable.Columns.Add(StreamingPortString, typeof(String));
|
|
_slotConfigDataTable.Columns.Add(RequestPortString, typeof(String));
|
|
_slotConfigDataTable.Columns.Add(RequestTypeString, typeof(String));
|
|
_slotConfigDataTable.Columns.Add(SlotTypeString, typeof(String));
|
|
|
|
InitializeComponent();
|
|
|
|
tbcSlot.Name = SlotString;
|
|
cbcRequestPort.Name = RequestPortString;
|
|
cbcRequestType.Name = RequestTypeString;
|
|
cbcStreamingPort.Name = StreamingPortString;
|
|
cbcSlotType.Name = SlotTypeString;
|
|
btcDetectStreaming.Name = StreamingDetectString;
|
|
btcDetectRequest.Name = RequestDetectString;
|
|
btcDetectStreaming.Name = StreamingDetectString;
|
|
|
|
tbcSlot.HeaderText = SlotString;
|
|
cbcRequestPort.HeaderText = RequestPortString;
|
|
cbcRequestType.HeaderText = RequestTypeString;
|
|
cbcStreamingPort.HeaderText = StreamingPortString;
|
|
btcDetectRequest.HeaderText = RequestDetectString;
|
|
btcDetectStreaming.HeaderText = StreamingDetectString;
|
|
cbcSlotType.HeaderText = SlotTypeString;
|
|
|
|
LoadFromFile();
|
|
_configuration.ReadProcessConfig();
|
|
cbUseMinMaxCheck.Checked = _configuration.UseMinMaxCheck;
|
|
cbUseRegisterWatch.Checked = _configuration.UseRegisterWatchService;
|
|
txtWachSeriveUrl.Text = _configuration.RegisterWatchServiceUrl;
|
|
cbUpdateFiles.Checked = _configuration.AutoUpdateFiles;
|
|
cbxProductionMode.Checked = _configuration.ProductionMode;
|
|
|
|
_sirtConfig.ReadSirtConfig();
|
|
tbxSirtStationId.Text = _sirtConfig.StationId?.ToString();
|
|
tbxSirtBoxNo.Text = _sirtConfig.SirtBoxNo?.ToString();
|
|
|
|
if (_sirtConfig.SirtComport433MHz != null)
|
|
cbxSirtComport433MHz.Items.Add(_sirtConfig.SirtComport433MHz);
|
|
if (_sirtConfig.SirtComport868MHz != null)
|
|
cbxSirtComport868MHz.Items.Add(_sirtConfig.SirtComport868MHz);
|
|
|
|
var comPorts = SerialPort.GetPortNames().ToList();
|
|
foreach (var comPort in comPorts.Where(comPort => !cbxSirtComport433MHz.Items.Contains(comPort)))
|
|
{
|
|
cbxSirtComport433MHz.Items.Add(comPort);
|
|
}
|
|
foreach (var comPort in comPorts.Where(comPort => !cbxSirtComport868MHz.Items.Contains(comPort)))
|
|
{
|
|
cbxSirtComport868MHz.Items.Add(comPort);
|
|
}
|
|
|
|
if (cbxSirtComport433MHz.Items.Count > 0)
|
|
cbxSirtComport433MHz.Text = cbxSirtComport433MHz.Items[0].ToString();
|
|
if (cbxSirtComport868MHz.Items.Count > 0)
|
|
cbxSirtComport868MHz.Text = cbxSirtComport868MHz.Items[0].ToString();
|
|
|
|
if (_sirtConfig.ServiceSirtComport433MHz != null)
|
|
cbxSirtService433MHz.Items.Add(_sirtConfig.ServiceSirtComport433MHz);
|
|
if (_sirtConfig.ServiceSirtComport868MHz != null)
|
|
cbxSirtService868MHz.Items.Add(_sirtConfig.ServiceSirtComport868MHz);
|
|
|
|
foreach (var comPort in comPorts.Where(comPort => !cbxSirtService433MHz.Items.Contains(comPort)))
|
|
{
|
|
cbxSirtService433MHz.Items.Add(comPort);
|
|
}
|
|
foreach (var comPort in comPorts.Where(comPort => !cbxSirtService868MHz.Items.Contains(comPort)))
|
|
{
|
|
cbxSirtService868MHz.Items.Add(comPort);
|
|
}
|
|
|
|
if (cbxSirtService433MHz.Items.Count > 0)
|
|
cbxSirtService433MHz.Text = cbxSirtService433MHz.Items[0].ToString();
|
|
if (cbxSirtService868MHz.Items.Count > 0)
|
|
cbxSirtService868MHz.Text = cbxSirtService868MHz.Items[0].ToString();
|
|
|
|
Logger.Trace("CONFIG: Setup loaded.");
|
|
}
|
|
|
|
private void BtnReload_Click(Object sender, EventArgs e)
|
|
{
|
|
Logger.Trace("CONFIG: Reload setup requested.");
|
|
|
|
LoadFromFile();
|
|
LoadOfflineFile();
|
|
|
|
Logger.Trace("CONFIG: Setup reloaded.");
|
|
}
|
|
|
|
private void BtnStore_Click(Object sender, EventArgs e)
|
|
{
|
|
Logger.Trace("CONFIG: Save setup requested.");
|
|
|
|
StoreToPc();
|
|
StoreOfflineFile();
|
|
StoreSirtSettings();
|
|
|
|
Logger.Trace("CONFIG: Setup saved.");
|
|
}
|
|
|
|
private void StoreSirtSettings()
|
|
{
|
|
if (int.TryParse(tbxSirtStationId.Text, out var intNo))
|
|
{
|
|
_sirtConfig.StationId = intNo;
|
|
}
|
|
|
|
if (int.TryParse(tbxSirtBoxNo.Text, out intNo))
|
|
{
|
|
_sirtConfig.SirtBoxNo = intNo;
|
|
}
|
|
|
|
_sirtConfig.SirtComport433MHz = cbxSirtComport433MHz.Text;
|
|
_sirtConfig.SirtComport868MHz = cbxSirtComport868MHz.Text;
|
|
_sirtConfig.ServiceSirtComport433MHz = cbxSirtService433MHz.Text;
|
|
_sirtConfig.ServiceSirtComport868MHz = cbxSirtService868MHz.Text;
|
|
|
|
_sirtConfig.Update();
|
|
Logger.Trace("CONFIG: SIRT settings stored.");
|
|
}
|
|
|
|
private void StoreToPc()
|
|
{
|
|
Logger.Trace("CONFIG: Storing slot configuration to PC.");
|
|
|
|
var newFileContent = new List<SlotConfig>();
|
|
|
|
for (var row = 0; row < dgvConfig.Rows.Count; row++)
|
|
{
|
|
var slotStr = (String)dgvConfig.Rows[row].Cells[SlotString].Value;
|
|
int.TryParse(slotStr, out var slot);
|
|
|
|
var irdaType = typeof(IrdaSerialPort).FullName;
|
|
if (dgvConfig.Rows[row].Cells[RequestTypeString].Value != null)
|
|
{
|
|
irdaType = (String)dgvConfig.Rows[row].Cells[RequestTypeString].Value;
|
|
}
|
|
|
|
var requestPort = new PortConfig()
|
|
{
|
|
PortName = (String)dgvConfig.Rows[row].Cells[RequestPortString].Value,
|
|
Type = irdaType
|
|
};
|
|
|
|
var streamingPort = new PortConfig()
|
|
{
|
|
PortName = (String)dgvConfig.Rows[row].Cells[StreamingPortString].Value,
|
|
Type = typeof(UartSerialPort).FullName
|
|
};
|
|
|
|
var slotType = SlotType.DutMeter;
|
|
|
|
if (dgvConfig.Rows[row].Cells[SlotTypeString].Value != null)
|
|
{
|
|
var isChecked = dgvConfig.Rows[row].Cells[SlotTypeString].Value.ToString();
|
|
if (bool.TrueString == isChecked)
|
|
{
|
|
slotType = SlotType.TemperatureMeter;
|
|
}
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(slotStr))
|
|
{
|
|
newFileContent.Add(new SlotConfig()
|
|
{
|
|
Slot = slot,
|
|
Request = requestPort,
|
|
Streaming = streamingPort,
|
|
Type = slotType
|
|
});
|
|
}
|
|
}
|
|
|
|
var text = JsonConvert.SerializeObject(newFileContent);
|
|
|
|
if (text == _fileString)
|
|
{
|
|
Logger.Trace("CONFIG: No setup changes detected.");
|
|
LoadFromFile();
|
|
return;
|
|
}
|
|
|
|
if (File.Exists(_serialConfigFilePathName))
|
|
{
|
|
var backupSerialConfigFile =
|
|
$"{Path.GetDirectoryName(_serialConfigFilePathName)}\\Backup_{DateTime.Now:yyyyMMdd}_{DateTime.Now:HHmmss}_{ProgramConfig.SerialConfigFileName}";
|
|
File.Move(_serialConfigFilePathName, backupSerialConfigFile);
|
|
}
|
|
|
|
File.WriteAllText(_serialConfigFilePathName, text);
|
|
LoadFromFile();
|
|
LoadOfflineFile();
|
|
|
|
Logger.Trace("CONFIG: Slot configuration stored.");
|
|
}
|
|
|
|
private void LoadFromFile()
|
|
{
|
|
Logger.Trace("CONFIG: Loading slot configuration from file.");
|
|
|
|
_slotConfigDataTable.Clear();
|
|
dgvConfig.Rows.Clear();
|
|
|
|
if (!File.Exists(_serialConfigFilePathName))
|
|
{
|
|
Logger.Trace("CONFIG: Serial configuration file not found.");
|
|
return;
|
|
}
|
|
|
|
SlotConfig[] meterConfigList;
|
|
using (var tr = new StreamReader(_serialConfigFilePathName))
|
|
{
|
|
_fileString = tr.ReadToEnd();
|
|
meterConfigList = JsonConvert.DeserializeObject<SlotConfig[]>(_fileString);
|
|
}
|
|
|
|
foreach (var item in meterConfigList)
|
|
{
|
|
var row = _slotConfigDataTable.NewRow();
|
|
row[SlotString] = item.Slot;
|
|
row[RequestPortString] = item.Request.PortName;
|
|
row[RequestTypeString] = item.Request.Type;
|
|
row[StreamingPortString] = item.Streaming.PortName;
|
|
row[SlotTypeString] = item.Type == SlotType.TemperatureMeter;
|
|
_slotConfigDataTable.Rows.Add(row);
|
|
}
|
|
|
|
foreach (DataRow row in _slotConfigDataTable.Rows)
|
|
{
|
|
dgvConfig.Rows.Add(AddRowToGrid(row));
|
|
}
|
|
|
|
Logger.Trace("CONFIG: Slot configuration loaded.");
|
|
}
|
|
|
|
private DataGridViewRow AddRowToGrid(DataRow row = null)
|
|
{
|
|
var newRow = new DataGridViewRow();
|
|
|
|
var slotCell = new DataGridViewTextBoxCell();
|
|
newRow.Cells.Add(slotCell);
|
|
|
|
var requestPortCell = new DataGridViewComboBoxCell
|
|
{
|
|
DataSource = GetPorts(),
|
|
DisplayMember = TextString,
|
|
ValueMember = ValueString
|
|
};
|
|
newRow.Cells.Add(requestPortCell);
|
|
|
|
var requestTypeCell = new DataGridViewComboBoxCell
|
|
{
|
|
DataSource = GetTypes(),
|
|
DisplayMember = TextString,
|
|
ValueMember = ValueString
|
|
};
|
|
newRow.Cells.Add(requestTypeCell);
|
|
|
|
var streamingPortCell = new DataGridViewComboBoxCell
|
|
{
|
|
DataSource = GetPorts(),
|
|
DisplayMember = TextString,
|
|
ValueMember = ValueString
|
|
};
|
|
newRow.Cells.Add(streamingPortCell);
|
|
|
|
var slotTypeCell = new DataGridViewCheckBoxCell();
|
|
slotTypeCell.Value = false;
|
|
|
|
if (row == null)
|
|
{
|
|
return newRow;
|
|
}
|
|
|
|
slotCell.Value = row[SlotString];
|
|
streamingPortCell.Value = row[StreamingPortString];
|
|
requestPortCell.Value = row[RequestPortString];
|
|
|
|
try
|
|
{
|
|
requestTypeCell.Value = row[RequestTypeString];
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.Error("Failed to set request type in grid: " + ex.Message);
|
|
}
|
|
|
|
slotTypeCell.Value = row[SlotTypeString];
|
|
newRow.Cells.Add(slotTypeCell);
|
|
return newRow;
|
|
}
|
|
|
|
private DataTable GetSlotTypes()
|
|
{
|
|
var ret = new DataTable();
|
|
ret.Columns.Add(TextString);
|
|
ret.Columns.Add(ValueString, typeof(Int32));
|
|
|
|
ret.Rows.Add("DutMeter", SlotType.DutMeter.GetHashCode());
|
|
ret.Rows.Add("TemperatureMeter", SlotType.TemperatureMeter.GetHashCode());
|
|
|
|
return ret;
|
|
}
|
|
|
|
private DataTable GetPorts()
|
|
{
|
|
var ret = new DataTable();
|
|
ret.Columns.Add(ValueString);
|
|
ret.Columns.Add(TextString);
|
|
var portList = SerialPort.GetPortNames().ToList();
|
|
|
|
foreach (var item in portList)
|
|
{
|
|
ret.Rows.Add(item, item);
|
|
}
|
|
|
|
foreach (DataRow row in _slotConfigDataTable.Rows)
|
|
{
|
|
if (portList.All(pl => pl != (String)row[StreamingPortString]))
|
|
{
|
|
ret.Rows.Add(row[StreamingPortString].ToString(), BaseSerialPort.PortNotAssigned);
|
|
}
|
|
if (portList.All(pl => pl != (String)row[RequestPortString]))
|
|
{
|
|
ret.Rows.Add(row[RequestPortString].ToString(), BaseSerialPort.PortNotAssigned);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
private static DataTable GetTypes()
|
|
{
|
|
var ret = new DataTable();
|
|
ret.Columns.Add(ValueString);
|
|
ret.Columns.Add(TextString);
|
|
|
|
ret.Rows.Add(typeof(UartSerialPort).FullName, nameof(UartSerialPort));
|
|
ret.Rows.Add(typeof(RfidSerialPort).FullName, nameof(RfidSerialPort));
|
|
ret.Rows.Add(typeof(IrdaSerialPort).FullName, nameof(IrdaSerialPort));
|
|
|
|
return ret;
|
|
}
|
|
|
|
private void __DgvConfig_CellContentClick(Object sender, DataGridViewCellEventArgs e)
|
|
{
|
|
Logger.Trace("UI-CLICK: FrmSetup: DgvConfig_CellContentClick() use APILaatzen");
|
|
|
|
if (e.RowIndex < 0 || e.ColumnIndex < 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!dgvConfig.Columns[e.ColumnIndex].Name.Contains(StreamingDetectString) &&
|
|
!dgvConfig.Columns[e.ColumnIndex].Name.Contains(RequestDetectString))
|
|
{
|
|
return;
|
|
}
|
|
|
|
StoreToPc();
|
|
|
|
var slotString = (String)dgvConfig.Rows[e.RowIndex].Cells[SlotString].Value;
|
|
int.TryParse(slotString, out var slot);
|
|
|
|
using (var mb = new MeterBatch())
|
|
{
|
|
using (var meter = new GenesisMeter())
|
|
{
|
|
meter.SetupFromConfigFile(slot, false);
|
|
mb.AddMeter(meter);
|
|
|
|
const String checkMark = "\u2714";
|
|
|
|
if (dgvConfig.Columns[e.ColumnIndex].Name.Contains(StreamingDetectString))
|
|
{
|
|
Logger.Trace("COM: Detecting streaming port for slot " + slot + "...");
|
|
|
|
_countRawData = new ConcurrentBag<String>();
|
|
|
|
meter.StreamingPort.OnRawRecordReceived += delegate (Object o, BasePortDataEventArgs rawMsg)
|
|
{
|
|
var data = (String)rawMsg.GetData();
|
|
_countRawData.Add(data);
|
|
};
|
|
|
|
Thread.Sleep(500);
|
|
|
|
if (_countRawData.Any())
|
|
{
|
|
var text = $"SUCCESS\nSlot: {slot}\nStreaming port: {meter.StreamingPort.GetPortName()}\n\n{checkMark}";
|
|
MessageBox.Show(text, @"SUCCESS", MessageBoxButtons.OK);
|
|
dgvConfig.Rows[e.RowIndex].Cells[StreamingDetectString].Style.BackColor = Color.Green;
|
|
|
|
Logger.Info("COM: Streaming detection SUCCESS for slot " + slot + ", port " + meter.StreamingPort.GetPortName() + ".");
|
|
}
|
|
else
|
|
{
|
|
var text = $"FAILED\nSlot: {slot}\nStreaming port: {meter.StreamingPort.GetPortName()}";
|
|
MessageBox.Show(text, @"FAILED", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
dgvConfig.Rows[e.RowIndex].Cells[StreamingDetectString].Style.BackColor = Color.Red;
|
|
|
|
Logger.Error("COM: Streaming detection FAILED for slot " + slot + ", port " + meter.StreamingPort.GetPortName() + ".");
|
|
}
|
|
|
|
_countRawData = new ConcurrentBag<String>();
|
|
}
|
|
else
|
|
{
|
|
meter.Logout();
|
|
|
|
var pcbId = meter.GetPcbId();
|
|
|
|
if (string.IsNullOrEmpty(pcbId))
|
|
{
|
|
var text = $"FAILED\nSlot: {slot}\nRequest port: {meter.RequestPort.GetPortName()}";
|
|
MessageBox.Show(text, @"FAILED", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
dgvConfig.Rows[e.RowIndex].Cells[RequestDetectString].Style.BackColor = Color.Red;
|
|
|
|
Logger.Info("COM: Streaming detection SUCCESS for slot " + slot + ", port " + meter.StreamingPort.GetPortName() + ".");
|
|
}
|
|
else
|
|
{
|
|
var text = $"SUCCESS\nSlot: {slot}\nRequest port: {meter.RequestPort.GetPortName()}\n\n{checkMark}";
|
|
MessageBox.Show(text, @"SUCCESS", MessageBoxButtons.OK);
|
|
dgvConfig.Rows[e.RowIndex].Cells[RequestDetectString].Style.BackColor = Color.Green;
|
|
|
|
Logger.Error("COM: Streaming detection FAILED for slot " + slot + ", port " + meter.StreamingPort.GetPortName() + ".");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DgvConfig_CellContentClick(object sender, DataGridViewCellEventArgs e)
|
|
{
|
|
Logger.Trace("UI-CLICK: FrmSetup: DgvConfig_CellContentClick() use API2");
|
|
|
|
if (e.RowIndex < 0 || e.ColumnIndex < 0)
|
|
return;
|
|
|
|
var columnName = dgvConfig.Columns[e.ColumnIndex].Name;
|
|
|
|
if (!columnName.Contains(StreamingDetectString) &&
|
|
!columnName.Contains(RequestDetectString))
|
|
{
|
|
return;
|
|
}
|
|
|
|
StoreToPc();
|
|
|
|
var slotString = (string)dgvConfig.Rows[e.RowIndex].Cells[SlotString].Value;
|
|
if (!int.TryParse(slotString, out var slot))
|
|
return;
|
|
|
|
const string checkMark = "\u2714";
|
|
|
|
try
|
|
{
|
|
if (columnName.Contains(StreamingDetectString))
|
|
{
|
|
Logger.Trace("COM: Detecting streaming port for slot " + slot + "...");
|
|
|
|
var result = interfaceToLaatzen.DetectStreamingPort(slot);
|
|
|
|
if (result.Success)
|
|
{
|
|
var text = $"SUCCESS\nSlot: {result.Slot}\nStreaming port: {result.PortName}\n\n{checkMark}";
|
|
MessageBox.Show(text, @"SUCCESS", MessageBoxButtons.OK);
|
|
dgvConfig.Rows[e.RowIndex].Cells[StreamingDetectString].Style.BackColor = Color.Green;
|
|
|
|
Logger.Info("COM: Streaming detection SUCCESS for slot " + result.Slot + ", port " + result.PortName + ".");
|
|
}
|
|
else
|
|
{
|
|
var text = $"FAILED\nSlot: {result.Slot}\nStreaming port: {result.PortName}";
|
|
MessageBox.Show(text, @"FAILED", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
dgvConfig.Rows[e.RowIndex].Cells[StreamingDetectString].Style.BackColor = Color.Red;
|
|
|
|
Logger.Error("COM: Streaming detection FAILED for slot " + result.Slot + ", port " + result.PortName + ".");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var result = interfaceToLaatzen.DetectRequestPort(slot);
|
|
|
|
if (result.Success)
|
|
{
|
|
var text = $"SUCCESS\nSlot: {result.Slot}\nRequest port: {result.PortName}\n\n{checkMark}";
|
|
MessageBox.Show(text, @"SUCCESS", MessageBoxButtons.OK);
|
|
dgvConfig.Rows[e.RowIndex].Cells[RequestDetectString].Style.BackColor = Color.Green;
|
|
|
|
Logger.Info("COM: Request detection SUCCESS for slot " + result.Slot + ", port " + result.PortName + ".");
|
|
}
|
|
else
|
|
{
|
|
var text = $"FAILED\nSlot: {result.Slot}\nRequest port: {result.PortName}";
|
|
MessageBox.Show(text, @"FAILED", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
dgvConfig.Rows[e.RowIndex].Cells[RequestDetectString].Style.BackColor = Color.Red;
|
|
|
|
Logger.Error("COM: Request detection FAILED for slot " + result.Slot + ", port " + result.PortName + ".");
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, @"ERROR", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
Logger.Error(ex);
|
|
}
|
|
}
|
|
|
|
private void dgvConfig_DataError(Object sender, DataGridViewDataErrorEventArgs e)
|
|
{
|
|
Logger.Error("CONFIG: DataGridView data error.");
|
|
}
|
|
|
|
private void cbUseRegisterWatch_CheckedChanged(Object sender, EventArgs e)
|
|
{
|
|
_configuration.UseRegisterWatchService = cbUseRegisterWatch.Checked;
|
|
_configuration.Update();
|
|
StoreToPc();
|
|
|
|
Logger.Trace("UseRegisterWatchService changed to " + cbUseRegisterWatch.Checked);
|
|
}
|
|
|
|
private void cbUseMinMaxCheck_CheckedChanged(Object sender, EventArgs e)
|
|
{
|
|
_configuration.UseMinMaxCheck = cbUseMinMaxCheck.Checked;
|
|
_configuration.Update();
|
|
StoreToPc();
|
|
|
|
Logger.Trace("UseMinMaxCheck changed to " + cbUseMinMaxCheck.Checked);
|
|
}
|
|
|
|
private void textBox1_TextChanged(Object sender, EventArgs e)
|
|
{
|
|
_configuration.RegisterWatchServiceUrl = txtWachSeriveUrl.Text;
|
|
_configuration.Update();
|
|
StoreToPc();
|
|
|
|
Logger.Trace("RegisterWatchServiceUrl changed.");
|
|
}
|
|
|
|
private void cbUpdateFiles_CheckedChanged(Object sender, EventArgs e)
|
|
{
|
|
_configuration.AutoUpdateFiles = cbUpdateFiles.Checked;
|
|
_configuration.Update();
|
|
StoreToPc();
|
|
|
|
Logger.Trace("CONFIG: AutoUpdateFiles changed to " + cbUpdateFiles.Checked);
|
|
}
|
|
|
|
private void FrmSetup_Load(Object sender, EventArgs e)
|
|
{
|
|
LoadOfflineFile();
|
|
cbxProductionMode.CheckedChanged += cbxProductionMode_CheckedChanged;
|
|
|
|
Logger.Trace("FORM: FrmSetup loaded.");
|
|
}
|
|
|
|
private void StoreOfflineFile()
|
|
{
|
|
try
|
|
{
|
|
var listToRemove = _listOfOfflinePasswords.Where(offlinePwd => string.IsNullOrEmpty(offlinePwd.PcbID)).ToList();
|
|
foreach (var itemToRemove in listToRemove)
|
|
{
|
|
_listOfOfflinePasswords.Remove(itemToRemove);
|
|
}
|
|
_listOfOfflinePasswords.Add(new OfflinePasswordItem("", ""));
|
|
|
|
File.WriteAllText(_offlinePwdPathName, JsonConvert.SerializeObject(_listOfOfflinePasswords));
|
|
dgvofflinePw.CellValidated -= dgvofflinePw_CellValidated;
|
|
dgvofflinePw.DataSource = null;
|
|
dgvofflinePw.DataSource = _listOfOfflinePasswords;
|
|
dgvofflinePw.CellValidated += dgvofflinePw_CellValidated;
|
|
|
|
Logger.Trace("CONFIG: Offline password file stored.");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.Error("CONFIG: Failed to store offline password file: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
private void LoadOfflineFile()
|
|
{
|
|
try
|
|
{
|
|
_listOfOfflinePasswords = JsonConvert.DeserializeObject<List<OfflinePasswordItem>>(File.ReadAllText(_offlinePwdPathName));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_listOfOfflinePasswords = new List<OfflinePasswordItem>();
|
|
Logger.Error("CONFIG: Failed to load offline password file. New empty list created. " + ex.Message);
|
|
}
|
|
finally
|
|
{
|
|
if (!_listOfOfflinePasswords.Any())
|
|
{
|
|
_listOfOfflinePasswords.Add(new OfflinePasswordItem("", ""));
|
|
}
|
|
|
|
dgvofflinePw.CellValidated -= dgvofflinePw_CellValidated;
|
|
dgvofflinePw.DataSource = null;
|
|
dgvofflinePw.DataSource = _listOfOfflinePasswords;
|
|
dgvofflinePw.CellValidated += dgvofflinePw_CellValidated;
|
|
|
|
Logger.Trace("CONFIG: Offline password file loaded.");
|
|
}
|
|
}
|
|
|
|
private void dgvofflinePw_CellValidated(Object sender, DataGridViewCellEventArgs e)
|
|
{
|
|
StoreOfflineFile();
|
|
}
|
|
|
|
private void cmdAddOffline_Click(Object sender, EventArgs e)
|
|
{
|
|
_listOfOfflinePasswords.Add(new OfflinePasswordItem("", ""));
|
|
|
|
dgvofflinePw.DataSource = null;
|
|
dgvofflinePw.DataSource = _listOfOfflinePasswords;
|
|
|
|
Logger.Trace("TABLE: Offline password row added.");
|
|
}
|
|
|
|
private void cbxProductionMode_CheckedChanged(Object sender, EventArgs e)
|
|
{
|
|
if (cbxProductionMode.Checked)
|
|
{
|
|
MessageBox.Show(@"Production mode! Configuration.json has to be the latest! ");
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("Developer mode! Configuration.json can be exchanged on individual requirements.\n" +
|
|
"\nRISK:\n" +
|
|
"- Register ranges cannot be checked\n" +
|
|
"- Register may not be able to access");
|
|
}
|
|
|
|
_configuration.ProductionMode = cbxProductionMode.Checked;
|
|
_configuration.Update();
|
|
StoreToPc();
|
|
|
|
Logger.Trace("CHECKBOX: ProductionMode changed to " + cbxProductionMode.Checked);
|
|
}
|
|
|
|
private void tabPage4_Click(Object sender, EventArgs e)
|
|
{
|
|
Logger.Trace("TABPAGE4: Logging tab opened.");
|
|
|
|
try
|
|
{
|
|
var path = NLogHelper.GetCurrentApplicationFolder();
|
|
var a = XElement.Load(path);
|
|
lblLocalCurrentPath.Text = a.Elements()
|
|
.First(s => s.Name.LocalName == "variable")
|
|
.Attributes()
|
|
.First(s => s.Value == "BasePath")
|
|
.NextAttribute.Value;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
lblLocalCurrentPath.Text = ex.Message;
|
|
Logger.Error("TABPAGE4: Failed to read local NLog path: " + ex.Message);
|
|
}
|
|
|
|
try
|
|
{
|
|
var path = NLogHelper.GetApplicationDataPath();
|
|
var b = XElement.Load(path);
|
|
lblGlobalCurrentPath.Text = b.Elements()
|
|
.First(s => s.Name.LocalName == "variable")
|
|
.Attributes()
|
|
.First(s => s.Value == "BasePath")
|
|
.NextAttribute.Value;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
lblGlobalCurrentPath.Text = ex.Message;
|
|
Logger.Error("TABPAGE4: Failed to read global NLog path: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
private void Add(String path, String newDest)
|
|
{
|
|
try
|
|
{
|
|
var a = XElement.Load(path);
|
|
var firstIsVariable = a.Elements().First();
|
|
|
|
if (firstIsVariable.Name.LocalName != "variable")
|
|
{
|
|
var newElm = new XElement("variable", null);
|
|
newElm.SetAttributeValue("name", "BasePath");
|
|
newElm.SetAttributeValue("value", newDest);
|
|
a.AddFirst(newElm);
|
|
}
|
|
else if (a.Elements().First(b => b.Name.LocalName == "variable").Attributes()
|
|
.All(s => s.Value != "BasePath"))
|
|
{
|
|
var newElm = new XElement("variable", null);
|
|
newElm.SetAttributeValue("name", "BasePath");
|
|
newElm.SetAttributeValue("value", newDest);
|
|
a.AddFirst(newElm);
|
|
}
|
|
else
|
|
{
|
|
a.Elements().First(b => b.Name.LocalName == "variable").Attributes()
|
|
.First(s => s.Value == "BasePath").NextAttribute.Value = newDest;
|
|
}
|
|
|
|
a.Save(path);
|
|
tabPage4_Click(this, null);
|
|
|
|
Logger.Trace("Log path updated to: " + newDest);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.Trace("Failed to update log path: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
private void btnLocalDefaultLocal_Click(Object sender, EventArgs e)
|
|
{
|
|
Add(NLogHelper.GetCurrentApplicationFolder(), "C:\\GenesisLog\\");
|
|
Logger.Trace("Local log path set to default local.");
|
|
}
|
|
|
|
private void btnLocalDefaultLan_Click(Object sender, EventArgs e)
|
|
{
|
|
Add(NLogHelper.GetCurrentApplicationFolder(), "\\\\sla12buma\\cordonelds$\\${machinename}");
|
|
Logger.Trace("Local log path set to default LAN.");
|
|
}
|
|
|
|
private void btnGlobalDefaultLocal_Click(Object sender, EventArgs e)
|
|
{
|
|
Add(NLogHelper.GetApplicationDataPath(), "C:\\GenesisLog\\");
|
|
Logger.Trace("Global log path set to default local.");
|
|
}
|
|
|
|
private void btnGlobalDefaultLan_Click(Object sender, EventArgs e)
|
|
{
|
|
Add(NLogHelper.GetApplicationDataPath(), "\\\\sla12buma\\cordonelds$\\${{machinename}}");
|
|
Logger.Trace("Global log path set to default LAN.");
|
|
}
|
|
|
|
private void btnGlobalSearch_Click(Object sender, EventArgs e)
|
|
{
|
|
var dia = new FolderBrowserDialog();
|
|
dia.ShowDialog();
|
|
|
|
Add(NLogHelper.GetApplicationDataPath(), dia.SelectedPath);
|
|
Logger.Trace("Global log path selected by search dialog.");
|
|
}
|
|
|
|
private void btnLocalSearch_Click(Object sender, EventArgs e)
|
|
{
|
|
var dia = new FolderBrowserDialog();
|
|
dia.ShowDialog();
|
|
|
|
Add(NLogHelper.GetCurrentApplicationFolder(), dia.SelectedPath);
|
|
Logger.Trace("Local log path selected by search dialog.");
|
|
}
|
|
|
|
private void btnAddRow_Click(Object sender, EventArgs e)
|
|
{
|
|
dgvConfig.Rows.Add(AddRowToGrid());
|
|
Logger.Trace("TABLE: New slot row added.");
|
|
}
|
|
|
|
public class OfflinePasswordItem
|
|
{
|
|
public OfflinePasswordItem()
|
|
{
|
|
}
|
|
|
|
public OfflinePasswordItem(String pcbID, String password)
|
|
{
|
|
PcbID = pcbID;
|
|
Password = password;
|
|
}
|
|
|
|
public String PcbID { get; set; }
|
|
public String Password { get; set; }
|
|
}
|
|
}
|
|
} |