803 lines
29 KiB
C#
803 lines
29 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.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using System.Xml.Linq;
|
|
using Xylem.Common.CommonCore.Consts;
|
|
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;
|
|
|
|
namespace Xylem.Common.Ui.GenesisToolBox
|
|
{
|
|
public partial class FrmSetup : Form
|
|
{
|
|
private const String RequestPortString = "RequestPort";
|
|
private const String RequestBaudRateString = "RequestBaudRate";
|
|
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 _serialConfigFile;
|
|
private readonly DataTable _dataTable = new DataTable();
|
|
|
|
|
|
private readonly ProcessConfig _configuration;
|
|
|
|
public FrmSetup()
|
|
{
|
|
_serialConfigFile = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
|
|
"Genesis", ProgramConfig.SerialConfigFileName);
|
|
|
|
//build header of data table for reference by name
|
|
_dataTable.Columns.Add(SlotString, typeof(String));
|
|
_dataTable.Columns.Add(StreamingPortString, typeof(String));
|
|
_dataTable.Columns.Add(RequestPortString, typeof(String));
|
|
_dataTable.Columns.Add(RequestTypeString, typeof(String));
|
|
_dataTable.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 = new ProcessConfig(ProgramConfig.ConfigFileName);
|
|
cbUseMinMaxCheck.Checked = _configuration.UseMinMaxCheck;
|
|
cbUseRegisterWatch.Checked = _configuration.UseRegisterWatchService;
|
|
txtWachSeriveUrl.Text = _configuration.RegisterWatchServiceUrl;
|
|
cbUpdateFiles.Checked = _configuration.AutoUpdateFiles;
|
|
cbxProductionMode.Checked = _configuration.ProductionMode;
|
|
|
|
|
|
}
|
|
|
|
private void BtnReload_Click(Object sender, EventArgs e)
|
|
{
|
|
LoadFromFile();
|
|
}
|
|
|
|
private void BtnStore_Click(Object sender, EventArgs e)
|
|
{
|
|
StoreToPc();
|
|
}
|
|
|
|
private void StoreToPc()
|
|
{
|
|
var newFileContent = new List<SlotConfig>();
|
|
|
|
for (var row = 0; row < dgvConfig.Rows.Count; row++)
|
|
{
|
|
Int32 slot;
|
|
int.TryParse((String)dgvConfig.Rows[row].Cells[SlotString].Value, out slot);
|
|
|
|
|
|
//dgvConfig.Rows[row].Cells[_streamingPortString].Value
|
|
//dgvConfig.Rows[row].Cells[_requestPortString].Value,
|
|
var irdaType = typeof(IrdaSerialPort).FullName;
|
|
if (dgvConfig.Rows[row].Cells[RequestTypeString].Value != null)
|
|
{
|
|
irdaType = (String)dgvConfig.Rows[row].Cells[RequestTypeString].Value;
|
|
}
|
|
|
|
var requestPort = new Xylem.Common.Hardware.WaterMeter.Genesis.GenesisConfig.PortConfig()
|
|
{
|
|
PortName = (String)dgvConfig.Rows[row].Cells[RequestPortString].Value,
|
|
Type = irdaType
|
|
};
|
|
|
|
var streamingPort = new Xylem.Common.Hardware.WaterMeter.Genesis.GenesisConfig.PortConfig()
|
|
{
|
|
PortName = (String)dgvConfig.Rows[row].Cells[StreamingPortString].Value,
|
|
Type = typeof(UartSerialPort).FullName
|
|
};
|
|
|
|
SlotType 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;
|
|
}
|
|
}
|
|
|
|
newFileContent.Add(new SlotConfig() { Slot = slot, Request = requestPort, Streaming = streamingPort, Type = slotType });
|
|
}
|
|
|
|
var text = JsonConvert.SerializeObject(newFileContent);
|
|
if (text == _fileString)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//save file only on changed content
|
|
if (File.Exists(_serialConfigFile))
|
|
{
|
|
var backupSerialConfigFile = $"{Path.GetDirectoryName(_serialConfigFile)}" +
|
|
$"\\Backup_{DateTime.Now:yyyyMMdd}_{DateTime.Now:HHmmss}_{ProgramConfig.SerialConfigFileName}";
|
|
File.Move(_serialConfigFile, backupSerialConfigFile);
|
|
}
|
|
|
|
File.WriteAllText(_serialConfigFile, text);
|
|
LoadFromFile();
|
|
}
|
|
|
|
private void LoadFromFile()
|
|
{
|
|
_dataTable.Clear();
|
|
dgvConfig.Rows.Clear();
|
|
|
|
if (!File.Exists(_serialConfigFile))
|
|
{
|
|
return;
|
|
}
|
|
|
|
SlotConfig[] meterConfigList;
|
|
using (var tr = new StreamReader(_serialConfigFile))
|
|
{
|
|
_fileString = tr.ReadToEnd();
|
|
meterConfigList = JsonConvert.DeserializeObject<SlotConfig[]>(_fileString);
|
|
}
|
|
|
|
foreach (var item in meterConfigList)
|
|
{
|
|
var row = _dataTable.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;
|
|
_dataTable.Rows.Add(row);
|
|
}
|
|
|
|
foreach (DataRow row in _dataTable.Rows)
|
|
{
|
|
dgvConfig.Rows.Add(AddRowToGrid(row));
|
|
}
|
|
}
|
|
|
|
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;// SlotType.DutMeter.GetHashCode();
|
|
|
|
|
|
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)
|
|
{
|
|
|
|
}
|
|
try
|
|
{
|
|
slotTypeCell.Value = row[SlotTypeString];// Enum.Parse(typeof(SlotType), row[_slotTypeString].ToString()).GetHashCode();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw;
|
|
}
|
|
|
|
|
|
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 _dataTable.Rows)
|
|
{
|
|
if (portList.All(pl => pl != (String)row[StreamingPortString]))
|
|
{
|
|
ret.Rows.Add(row[StreamingPortString].ToString(), "NA");
|
|
}
|
|
if (portList.All(pl => pl != (String)row[RequestPortString]))
|
|
{
|
|
ret.Rows.Add(row[RequestPortString].ToString(), "NA");
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
private static DataTable GetTypes()
|
|
{
|
|
var ret = new DataTable();
|
|
ret.Columns.Add(ValueString);
|
|
ret.Columns.Add(TextString);
|
|
|
|
ret.Rows.Add(typeof(UartSerialPort).FullName, typeof(UartSerialPort).Name);
|
|
ret.Rows.Add(typeof(RfidSerialPort).FullName, typeof(RfidSerialPort).Name);
|
|
ret.Rows.Add(typeof(IrdaSerialPort).FullName, typeof(IrdaSerialPort).Name);
|
|
|
|
return ret;
|
|
}
|
|
|
|
private void BtnAddRow_Click(Object sender, EventArgs e)
|
|
{
|
|
dgvConfig.Rows.Add(AddRowToGrid());
|
|
}
|
|
|
|
|
|
|
|
private ConcurrentBag<String> _countRawData = new ConcurrentBag<String>();
|
|
|
|
private void DgvConfig_CellContentClick(Object sender, DataGridViewCellEventArgs e)
|
|
{
|
|
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;
|
|
Int32 slot;
|
|
int.TryParse(slotString, out 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))
|
|
{
|
|
meter.StartMeasurement();
|
|
_countRawData = new ConcurrentBag<String>();
|
|
|
|
meter.StreamingPort.OnRawRecordReceived += delegate (Object o, BasePortDataEventArgs rawMsg)
|
|
{
|
|
_countRawData.Add((String)rawMsg.GetData());
|
|
};
|
|
|
|
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;
|
|
}
|
|
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;
|
|
}
|
|
|
|
_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;
|
|
}
|
|
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;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
//private void btnAutoDetect_Click(object sender, EventArgs e)
|
|
//{
|
|
// var allPorts = SerialPort.GetPortNames();
|
|
// if (allPorts.Length < 2)
|
|
// {
|
|
// throw new ApplicationException("Comports NOT found");
|
|
// }
|
|
// allPorts = new string[] { "COM107", "COM108", "COM109" };
|
|
// int hitCount = 0;
|
|
// PortConfig? hitRequestPort = null;
|
|
// foreach (var PortName in allPorts)
|
|
// {
|
|
// try
|
|
// {
|
|
// var altPort = hitCount + 1;
|
|
// if (altPort >= allPorts.Length)
|
|
// {
|
|
// altPort = 0;
|
|
// }
|
|
// var tmpPortRequest = new PortConfig() { PortName = allPorts[hitCount], BaudRate = 9600,
|
|
// Type = "Xylem.Common.Hardware.Interfaces.Ports.SerialPorts.RfidSerialPort" };
|
|
// var tmpPortStreaming = new PortConfig() { PortName = allPorts[altPort], BaudRate = 115200,
|
|
// Type = "Xylem.Common.Hardware.Interfaces.Ports.SerialPorts.UartSerialPort" };
|
|
|
|
// var tmpMeter = new GenesisMeter(0, tmpPortRequest, null, false);
|
|
// var mb = new MeterBatch();
|
|
// mb.AddMeter(tmpMeter);
|
|
// if (tmpMeter.Login())
|
|
// {
|
|
// //hit
|
|
// Byte[] flowTestAndCalibData = {0x00, 0x00, 0x00, (Byte)LedMode.FlowTestAndCalibData};
|
|
// tmpMeter.WriteRegisterSafe(Register.Genesisflow.LedMode, (Byte)LedMode.FlowTestAndCalibData, checkRegister: true);
|
|
// hitRequestPort = tmpPortRequest;
|
|
// MessageBox.Show($"Found request port {tmpPortRequest.SerialPort.PortName}");
|
|
// break;
|
|
// }
|
|
// else
|
|
// {
|
|
// mb.RemoveAllMeters();
|
|
// }
|
|
// }
|
|
// catch (Exception exception)
|
|
// {
|
|
// Console.WriteLine(exception);
|
|
// }
|
|
// hitCount = hitCount + 1;
|
|
// }
|
|
// var hitStreamingPort = "";
|
|
// if (hitRequestPort != null)
|
|
// {
|
|
// foreach (var streaming in allPorts)
|
|
// {
|
|
// try
|
|
// {
|
|
// if (hitRequestPort.Value.PortName != streaming)
|
|
// {
|
|
// var tmpSerialPort = new SerialPort(streaming, 115200);
|
|
// tmpSerialPort.Open();
|
|
// var result = tmpSerialPort.ReadLine();
|
|
// if (result.Contains("@"))
|
|
// {
|
|
// hitStreamingPort = streaming;
|
|
// MessageBox.Show($"Found streaming port {hitStreamingPort}");
|
|
// tmpSerialPort.Close();
|
|
// //var tmpPortStreaming = new PortConfig() { SerialPort = tmpSerialPort, SerialPortType = typeof(SerialPort) };
|
|
|
|
// //var tmpMeter = new GenesisMeter(0, null, tmpPortStreaming, false);
|
|
// //var mb = new MeterBatch();
|
|
// //mb.AddMeter(tmpMeter);
|
|
// //tmpMeter.
|
|
|
|
// }
|
|
|
|
// }
|
|
// }
|
|
// catch (Exception exception)
|
|
// {
|
|
// Console.WriteLine(exception);
|
|
// }
|
|
// }
|
|
// }
|
|
// if (hitRequestPort == null)
|
|
// {
|
|
// MessageBox.Show($"Request port NOT found");
|
|
// }
|
|
|
|
// if (String.IsNullOrEmpty(hitStreamingPort))
|
|
// {
|
|
// MessageBox.Show($"Streaming port NOT found");
|
|
// }
|
|
//}
|
|
|
|
private void BtnCheckAll_Click(Object sender, EventArgs e)
|
|
{
|
|
StoreToPc();
|
|
using (var meterBatch = new MeterBatch())
|
|
{
|
|
for (var row = 0; row < dgvConfig.Rows.Count; row++)
|
|
{
|
|
var slotString = (String)dgvConfig.Rows[row].Cells[SlotString].Value;
|
|
|
|
Int32 slot;
|
|
int.TryParse(slotString, out slot);
|
|
var meter = new GenesisMeter();
|
|
meter.SetupFromConfigFile(slot, false);
|
|
meterBatch.AddMeter(meter);
|
|
}
|
|
var taskResultList = new List<Task<Tuple<Int32, Boolean, Int32>>>();
|
|
|
|
foreach (var meter in meterBatch.ListOfMeters)
|
|
{
|
|
if (!(meter is GenesisMeter))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
taskResultList.Add(new Task<Tuple<Int32, Boolean, Int32>>(() =>
|
|
{
|
|
try
|
|
{
|
|
var genMeter = ((GenesisMeter)meter);
|
|
genMeter.Login();
|
|
var id = genMeter.GetPcbId();
|
|
if (string.IsNullOrEmpty(id))
|
|
{
|
|
id = genMeter.GetPcbId();
|
|
if (string.IsNullOrEmpty(id))
|
|
{
|
|
return new Tuple<Int32, Boolean, Int32>(genMeter.Slot, false, 0);
|
|
}
|
|
}
|
|
genMeter.InitMeasurement();
|
|
genMeter.SyncStreamingBuffer(SyncMarkRecord.DecodeEveryPackage);
|
|
_countRawData = new ConcurrentBag<String>();
|
|
genMeter.StreamingPort.OnRawRecordReceived += delegate (Object o, BasePortDataEventArgs rawMsg)
|
|
{
|
|
_countRawData.Add((String)rawMsg.GetData());
|
|
};
|
|
Thread.Sleep(500);
|
|
|
|
|
|
return _countRawData.Count <= 10 ? new Tuple<Int32, Boolean, Int32>(genMeter.Slot, true, 0)
|
|
: new Tuple<Int32, Boolean, Int32>(genMeter.Slot, true, _countRawData.Count);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return new Tuple<Int32, Boolean, Int32>(-1, false, 0);
|
|
}
|
|
}));
|
|
}
|
|
|
|
taskResultList.ForEach(t => t.Start());
|
|
Task.WaitAll(taskResultList.ToArray(), 50000);
|
|
|
|
var sb = new StringBuilder();
|
|
foreach (var result in taskResultList)
|
|
{
|
|
var r = result.Result;
|
|
sb.AppendLine($"Slot{r.Item1} | Request={r.Item2} | Streaming={r.Item3}");
|
|
}
|
|
|
|
MessageBox.Show(sb.ToString());
|
|
}
|
|
}
|
|
|
|
private void dgvConfig_DataError(Object sender, DataGridViewDataErrorEventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
private void cbUseRegisterWatch_CheckedChanged(Object sender, EventArgs e)
|
|
{
|
|
_configuration.UseRegisterWatchService = cbUseRegisterWatch.Checked;
|
|
_configuration.Update(ProgramConfig.ConfigFileName);
|
|
StoreToPc();
|
|
}
|
|
|
|
private void cbUseMinMaxCheck_CheckedChanged(Object sender, EventArgs e)
|
|
{
|
|
_configuration.UseMinMaxCheck = cbUseMinMaxCheck.Checked;
|
|
_configuration.Update(ProgramConfig.ConfigFileName);
|
|
StoreToPc();
|
|
}
|
|
|
|
private void textBox1_TextChanged(Object sender, EventArgs e)
|
|
{
|
|
_configuration.RegisterWatchServiceUrl = txtWachSeriveUrl.Text;
|
|
_configuration.Update(ProgramConfig.ConfigFileName);
|
|
StoreToPc();
|
|
}
|
|
|
|
private void cbUpdateFiles_CheckedChanged(Object sender, EventArgs e)
|
|
{
|
|
_configuration.AutoUpdateFiles = cbUpdateFiles.Checked;
|
|
_configuration.Update(ProgramConfig.ConfigFileName);
|
|
StoreToPc();
|
|
}
|
|
|
|
private List<OfflinePaswordItem> listOfOfflinePassowrds = new List<OfflinePaswordItem>();
|
|
|
|
|
|
private void FrmSetup_Load(Object sender, EventArgs e)
|
|
{
|
|
LoadOfflineFile();
|
|
this.cbxProductionMode.CheckedChanged += new System.EventHandler(this.cbxProductionMode_CheckedChanged);
|
|
|
|
}
|
|
|
|
|
|
|
|
private void StoreOfflineFile()
|
|
{
|
|
try
|
|
{
|
|
File.WriteAllText(ProgramConfig.OfflineInfoFile, JsonConvert.SerializeObject(listOfOfflinePassowrds));
|
|
dgvofflinePw.CellValidated -= dgvofflinePw_CellValidated;
|
|
dgvofflinePw.DataSource = null;
|
|
dgvofflinePw.DataSource = listOfOfflinePassowrds;
|
|
dgvofflinePw.CellValidated += dgvofflinePw_CellValidated;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private void LoadOfflineFile()
|
|
{
|
|
try
|
|
{
|
|
listOfOfflinePassowrds = JsonConvert.DeserializeObject<List<OfflinePaswordItem>>(File.ReadAllText(ProgramConfig.OfflineInfoFile));
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
listOfOfflinePassowrds = new List<OfflinePaswordItem>();
|
|
}
|
|
finally
|
|
{
|
|
|
|
dgvofflinePw.CellValidated -= dgvofflinePw_CellValidated;
|
|
dgvofflinePw.DataSource = null;
|
|
dgvofflinePw.DataSource = listOfOfflinePassowrds;
|
|
dgvofflinePw.CellValidated += dgvofflinePw_CellValidated;
|
|
}
|
|
|
|
}
|
|
|
|
private void dgvofflinePw_RowsAdded(Object sender, DataGridViewRowsAddedEventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
private void dgvofflinePw_RowsRemoved(Object sender, DataGridViewRowsRemovedEventArgs e)
|
|
{
|
|
StoreOfflineFile();
|
|
}
|
|
|
|
private void dgvofflinePw_CellValidated(Object sender, DataGridViewCellEventArgs e)
|
|
{
|
|
StoreOfflineFile();
|
|
|
|
}
|
|
|
|
private void cmdAddOffline_Click(Object sender, EventArgs e)
|
|
{
|
|
|
|
|
|
listOfOfflinePassowrds.Add(new OfflinePaswordItem("", ""));
|
|
|
|
|
|
dgvofflinePw.DataSource = null;
|
|
dgvofflinePw.DataSource = listOfOfflinePassowrds;
|
|
|
|
StoreOfflineFile();
|
|
}
|
|
|
|
private void dgvofflinePw_KeyUp(Object sender, KeyEventArgs e)
|
|
{
|
|
if (e.KeyCode == Keys.Delete)
|
|
{
|
|
if (dgvofflinePw.SelectedRows.Count == 1)
|
|
{
|
|
listOfOfflinePassowrds.RemoveAt(dgvofflinePw.SelectedRows[0].Index);
|
|
StoreOfflineFile();
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private void cbxProductionMode_CheckedChanged(Object sender, EventArgs e)
|
|
{
|
|
if (cbxProductionMode.Checked)
|
|
{
|
|
MessageBox.Show("Production mode!Configraution.json muss zwingend dem Aktuellen Release entsprechen! ");
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("Developer mode!Configraution.json muss nicht zwingend auf aktuellen Release entsprechen. Es wird die letzte gültige Configraution.json anwendet.Dies führt dazu dass Grenzwerte nicht sauber überprüft werden und ggf. Register nicht sichtbar sind die der Zähler unterstützt. ");
|
|
}
|
|
|
|
_configuration.ProductionMode = cbxProductionMode.Checked;
|
|
_configuration.Update(ProgramConfig.ConfigFileName);
|
|
StoreToPc();
|
|
|
|
}
|
|
|
|
private void dgvofflinePw_RowsAdded_1(Object sender, DataGridViewRowsAddedEventArgs e)
|
|
{
|
|
// StoreOfflineFile();
|
|
}
|
|
|
|
private void dgvofflinePw_RowsRemoved_1(Object sender, DataGridViewRowsRemovedEventArgs e)
|
|
{
|
|
// StoreOfflineFile();
|
|
}
|
|
|
|
private void tabPage4_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
var a = XElement.Load(NLogHelper.GetCurrentApplicationFolder());
|
|
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.ToString();
|
|
}
|
|
|
|
try
|
|
{
|
|
var b = XElement.Load(NLogHelper.GetApplicationDataPath());
|
|
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.ToString();
|
|
}
|
|
}
|
|
|
|
private void add(string path, string newDest)
|
|
{
|
|
var a = XElement.Load(path);
|
|
if (!a.Elements().First(b => b.Name.LocalName == "variable").Attributes().Any(s => s.Value == "BasePath"))
|
|
{
|
|
var newElm = new XElement("variable", null);
|
|
newElm.SetAttributeValue("name", "BasePath");
|
|
newElm.SetAttributeValue("value", newDest);
|
|
a.Add(newElm);
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
a.Elements().First(b => b.Name.LocalName == "variable").Attributes().First(s => s.Value == "BasePath").NextAttribute.Value = newDest;
|
|
|
|
}
|
|
a.Save(path);
|
|
|
|
}
|
|
private void btnLocalDefaultLocal_Click(object sender, EventArgs e)
|
|
{
|
|
add(NLogHelper.GetCurrentApplicationFolder(), $"C:\\GenesisLog\\");
|
|
|
|
}
|
|
|
|
private void btnLocalDefaultLan_Click(object sender, EventArgs e)
|
|
{
|
|
add(NLogHelper.GetCurrentApplicationFolder(), $"\\\\sla12buma\\cordonelds$\\${{machinename}}");
|
|
}
|
|
|
|
private void btnGlobalDefaultLocal_Click(object sender, EventArgs e)
|
|
{
|
|
add(NLogHelper.GetApplicationDataPath(), $"C:\\GenesisLog\\");
|
|
}
|
|
|
|
private void btnGlobalDefaultLan_Click(object sender, EventArgs e)
|
|
{
|
|
add(NLogHelper.GetApplicationDataPath(), $"\\\\sla12buma\\cordonelds$\\${{machinename}}");
|
|
}
|
|
|
|
private void btnGlobalSearch_Click(object sender, EventArgs e)
|
|
{
|
|
var dia = new FolderBrowserDialog();
|
|
|
|
var diaRes = dia.ShowDialog();
|
|
|
|
add(NLogHelper.GetApplicationDataPath(), dia.SelectedPath);
|
|
|
|
|
|
}
|
|
|
|
private void btnLocalSearch_Click(object sender, EventArgs e)
|
|
{
|
|
var dia = new FolderBrowserDialog();
|
|
|
|
var diaRes = dia.ShowDialog();
|
|
|
|
add(NLogHelper.GetCurrentApplicationFolder(), dia.SelectedPath);
|
|
}
|
|
}
|
|
}
|