private static void ReadEventLog(string portName, SmlComServiceClient proxy, Guid clientGuid)
{
Console.WriteLine("Reading event log.");
var logList = proxy.ReadEventLog(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
foreach (var li in logList)
{
Console.WriteLine("Event log read: {0}", Stringify(li));
}
Console.WriteLine();
}
private static void EnableOperationModeEdl40(string portName, SmlComServiceClient proxy, Guid clientGuid, DateTime newTime)
{
Console.WriteLine("Enabling EDL40 mode with new meter time: " + newTime);
proxy.EnableOperationModeEdl40(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), newTime);
var booleanResult = proxy.ReadIsOperationModeEdl40(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
Console.WriteLine("Operation mode read: " + Stringify(booleanResult));
var meterTimeResult = proxy.ReadDateAndTime(
clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
Console.WriteLine("Meter time read: " + Stringify(meterTimeResult));
Console.WriteLine();
}
public async Task<bool> ProcessDevice(SmlComServiceClient svc, Guid guid, CommunicationPort port, CancellationToken token)
{
// cancellation setup
this.cts?.Cancel();
var timeoutCts = new CancellationTokenSource(TimeSpan.FromMinutes(5));
this.cts = CancellationTokenSource.CreateLinkedTokenSource(timeoutCts.Token, token);
token = cts.Token;
var sw = Stopwatch.StartNew();
try
{
if (!this.IsOccupiedByDevice)
{
Log.Warning($"Station {this.Number} is not assigned by a device (MAC address missing)");
// only use active stations where a device is assigned (by scanning or user action)
return false;
}
var dr = new DeviceRepository();
this.Device = dr.GetOne(this.Device.ServerId);
this.SetStatusMessageAndProgress("Processing started...", 5);
this.Status = StationStatus.Processing;
var rnd = new Random();
var policy = Policy
.Handle<Exception>()
.WaitAndRetryAsync(new[] { TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2) });
var portlist = await svc.GetPortListAsync();
if (!portlist.FirstOrDefault(p => p.ComPortName == this.ComAddress).IsInitialized)
{
throw new InvalidOperationException("Service Comport is not initialized!");
}
foreach (var param in this.Device.ParameterList)
{
await Task.Delay(100, token);
if (!param.IsActive)
{
continue;
}
// execute communication with retry policy...
await policy.ExecuteAsync(async () =>
{
this.SetStatusMessageAndProgress($"Writing at {port.ComPortName} parameter {param.TagId} with value {param.TargetValue}...", this.Progress);
switch (param.TagId)
{
case ParameterTagId.ServerId:
var serverId = param.TargetValue.FromHexString();
await svc.WriteServerIdAsync(guid, port, serverId);
var serverIdParam = await svc.ReadServerIdAsync(guid, port);
param.RealValue = serverIdParam.Data.AsHexString("-");
break;
case ParameterTagId.ManufacturerSerialNumber:
await svc.WriteManufacturerSerialNumberAsync(guid, port, param.TargetValue);
var serialNoParam = await svc.ReadManufacturerSerialNoAsync(guid, port);
var serialNoBytes = serialNoParam.Data;
param.RealValue = Encoding.UTF8.GetString(serialNoBytes);
break;
case ParameterTagId.GenerateKeys:
await svc.WriteCreateKeysAsync(guid, port);
param.RealValue = "True";
param.IsWritten = true;
break;
case ParameterTagId.PublicKey:
param.RealValue = (await svc.ReadPublicKeyAsync(guid, port)).Data.AsHexString("-");
break;
case ParameterTagId.PinCodeActive:
var isPinActive = bool.Parse(param.TargetValue);
await svc.WriteIsPinProtectionActiveAsync(guid, port, isPinActive);
param.RealValue = (await svc.ReadIsPinProtectionActiveAsync(guid, port)).Data.ToString();
break;
case ParameterTagId.InitialKeyM:
await svc.WriteInitialSymKeyAsync(guid, port, param.TargetValue.FromHexString());
param.RealValue = (await svc.ReadInitialSymKeyAsync(guid, port)).Data.AsHexString("-");
break;
case ParameterTagId.PinCode:
await svc.WritePinAsync(guid, port, param.TargetValue);
param.RealValue = param.TargetValue;
param.IsWritten = true;
break;
case ParameterTagId.MeasurementMode:
await svc.WriteMeasurementModeAsync(guid, port, param.TargetValue);
param.RealValue = $"MM{(await svc.ReadMeasurementModeAsync(guid, port)).Data}";
break;
case ParameterTagId.GridOption:
var isGridOption = bool.Parse(param.TargetValue);
await svc.WriteEnableGridOptionAsync(guid, port, isGridOption);
param.RealValue = (await svc.ReadEnableGridOptionAsync(guid, port)).Data.ToString();
break;
case ParameterTagId.TarifOptionActive:
var isTariffActive = bool.Parse(param.TargetValue);
await svc.WriteEnableTariffFunctionAsync(guid, port, isTariffActive);
param.RealValue = (await svc.ReadEnableTariffFunctionAsync(guid, port)).Data.ToString();
break;
case ParameterTagId.InverseTariffControl:
var isInverse = bool.Parse(param.TargetValue);
await svc.WriteIsTerminalControlReverseAsync(guid, port, isInverse);
param.RealValue = (await svc.ReadIsTerminalControlReverseAsync(guid, port)).Data.ToString();
break;
case ParameterTagId.BaudRateConfigurable:
var isBaudrateConfigurable = bool.Parse(param.TargetValue);
await svc.WriteEnableBaudRateSettingAsync(guid, port, isBaudrateConfigurable);
param.RealValue = (await svc.ReadEnableBaudRateSettingAsync(guid, port)).Data.ToString();
break;
case ParameterTagId.BaudRate:
break;
case ParameterTagId.Type:
param.RealValue = param.TargetValue;
param.IsWritten = true;
break;
case ParameterTagId.Eigentumsnummer:
param.RealValue = param.TargetValue;
param.IsWritten = true;
break;
default:
throw new InvalidEnumArgumentException();
}
this.SetStatusMessageAndProgress($"{port.ComPortName} parameter {param.TagId} with value {param.TargetValue} write OK...", this.Progress += 5);
});
}
this.Device.SetAllParametersWritten(true);
sw.Stop();
Log.Warning("Device completed in {@sw}!", sw.Elapsed);
// update database
this.Device.ProducedAt = DateTime.Now;
// dr.Update(device);
this.LastProducedDeviceServerId = this.Device.ServerId;
this.SetStatusMessageAndProgress("Processed", 100);
this.Status = StationStatus.ProcessingCompleted;
await Task.Delay(TimeSpan.FromSeconds(1), token);
return true;
}
catch (OperationCanceledException)
{
Log.Warning("Station {s} cancelled", this.Number);
this.SetStatusMessageAndProgress($"Cancelled", 0);
}
catch (Exception ex)
{
Log.Error(ex, "Station {s} failed", this.Number);
this.SetStatusMessageAndProgress($"Error: {ex.Message}", 0);
this.Status = StationStatus.Error;
}
return false;
}
private static void WriteServerId(string portName, SmlComServiceClient proxy, Guid clientGuid)
{
byte serverId_Id = 0x0A;
byte serverId_Type = 0x01;
var serverId_Man = Encoding.ASCII.GetBytes("DZG");
byte serverId_Block = 0x01;
var serverId_No = Enumerable.Range(1, 4).Select(n => (byte)n).ToArray();
var serverId = new byte[1 + 1 + 3 + 1 + 4];
serverId[0] = serverId_Id;
serverId[1] = serverId_Type;
serverId_Man.CopyTo(serverId, 2);
serverId[5] = serverId_Block;
serverId_No.CopyTo(serverId, 6);
Console.WriteLine("Setting ServerId to: " + BitConverter.ToString(serverId));
proxy.WriteServerId(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), serverId);
Console.WriteLine();
}
private static void WriteEnableGridOption(string portName, SmlComServiceClient proxy, Guid clientGuid, bool isOn)
{
Console.WriteLine("Setting Grid Optionto: " + isOn);
proxy.WriteEnableGridOption(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), isOn);
var result = proxy.ReadEnableGridOption(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
Console.WriteLine("Grid Option read: " + result.Data);
Console.WriteLine();
}
/// <summary>
/// Sets the operation mode.
/// </summary>
/// <param name="portlist">The portlist.</param>
/// <param name="proxy">The proxy.</param>
/// <param name="clientGuid">The client GUID.</param>
/// <param name="operationMode">if set to <c>true</c> [operation mode].</param>
private static void WriteOperationMode(string portName, SmlComServiceClient proxy, Guid clientGuid, bool operationMode)
{
Console.WriteLine("Setting operation mode to: " + operationMode);
proxy.WriteIsOperationModeEdl40(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), operationMode);
var booleanResult = proxy.ReadIsOperationModeEdl40(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
Console.WriteLine("Operation mode read: " + Stringify(booleanResult));
Console.WriteLine();
}
private static void WritePinCode(string portName, SmlComServiceClient proxy, Guid clientGuid, string pin)
{
Console.WriteLine("Setting PIN code to: " + pin);
proxy.WritePin(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), pin);
Console.WriteLine();
}
private static void ReadDeviceIdentification(string portName, SmlComServiceClient proxy, Guid clientGuid)
{
Console.WriteLine("Reading device identification");
var di = proxy.ReadDeviceIdentification(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
Console.WriteLine("Device identification: {0}", Stringify(di));
Console.WriteLine();
}
private static void ReadPublicKey(string portName, SmlComServiceClient proxy, Guid clientGuid)
{
Console.WriteLine("Reading public key");
var di = proxy.ReadPublicKey(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
Console.WriteLine("Public key: {0}", Stringify(di));
Console.WriteLine();
}
private static void ReadHistoricEnergyLastWeek(string portName, SmlComServiceClient proxy, Guid clientGuid)
{
Console.WriteLine("{0} Reading register of last 7d.", DateTime.Now);
var mv = proxy.ReadHistoricEnergyLastWeek(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
Console.WriteLine("\t{0} Register value: {1}\n.", DateTime.Now, Stringify(mv));
Console.WriteLine();
}
private static void ClearHistoricValues(string portName, SmlComServiceClient proxy, Guid clientGuid)
{
Console.WriteLine("Erasing historic values.");
proxy.WriteEraseHistoricEnergy(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
Console.WriteLine();
}
private static double? ReadRegister(string portName, SmlComServiceClient proxy, Guid clientGuid, long registerObis)
{
Console.WriteLine("{0} Reading register {1}.", portName, GetHexString(registerObis));
var mv = proxy.ReadEnergyRegister(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), registerObis);
Console.WriteLine("{0} Register value: {1}", portName, Stringify(mv));
if (mv.ValueSignature != null)
{
Console.WriteLine("Signature: " + BitConverter.ToString(mv.ValueSignature));
}
return mv.DataValue;
}
private static void ReadStatusWord(string portName, SmlComServiceClient proxy, Guid clientGuid)
{
Console.WriteLine("Reading statusword.");
var statusWord = proxy.ReadEdlStatusWord(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
Console.WriteLine("Statusword read: [{0}], {1}", Convert.ToString((long)statusWord, 2), statusWord);
}
private static void ReadRegisters(string portName, SmlComServiceClient proxy, Guid clientGuid)
{
ReadRegister(portName, proxy, clientGuid, 0x0100010800FFL);
/*ReadRegister(portName, proxy, clientGuid, 0x0100010801FFL);
ReadRegister(portName, proxy, clientGuid, 0x0100010802FFL);
ReadRegister(portName, proxy, clientGuid, 0x0100010803FFL);
ReadRegister(portName, proxy, clientGuid, 0x0100010804FFL);
ReadRegister(portName, proxy, clientGuid, 0x0100010805FFL);
ReadRegister(portName, proxy, clientGuid, 0x0100010806FFL);
ReadRegister(portName, proxy, clientGuid, 0x0100010807FFL);
ReadRegister(portName, proxy, clientGuid, 0x0100010808FFL);*/
/*ReadRegister(portName, proxy, clientGuid, 0x0100020800FFL);
ReadRegister(portName, proxy, clientGuid, 0x0100020801FFL);
ReadRegister(portName, proxy, clientGuid, 0x0100020802FFL);
ReadRegister(portName, proxy, clientGuid, 0x0100020803FFL);
ReadRegister(portName, proxy, clientGuid, 0x0100020804FFL);
ReadRegister(portName, proxy, clientGuid, 0x0100020805FFL);
ReadRegister(portName, proxy, clientGuid, 0x0100020806FFL);
ReadRegister(portName, proxy, clientGuid, 0x0100020807FFL);
ReadRegister(portName, proxy, clientGuid, 0x0100020808FFL);*/
}
static void Main(string[] args)
{
Thread.Sleep(2000);
var portSettings = ConfigurationManager.AppSettings["COMports"].Split(
new[] { ",", ", " },
StringSplitOptions.RemoveEmptyEntries);
Console.WriteLine("Creating service proxy.");
var proxy = new SmlComServiceClient(new BasicHttpBinding(), new EndpointAddress("http://localhost:7081/SmlComService"));
var serviceVersion = proxy.GetVersion();
Console.WriteLine("Service Version: '{0}'.", serviceVersion);
Console.WriteLine("Resetting all ports.");
proxy.ResetAllPorts();
foreach (var portName in portSettings)
{
portList.Add(
new CommunicationPort
{
ComPortName = portName,
ComTimeOut = TimeSpan.FromSeconds(3),
MeterType = MeterType.Basemeter
});
}
var configuredAt = DateTime.Now;
Console.WriteLine("{0} - Calling configuration command.", configuredAt);
var clientGuid = Guid.Empty;
clientGuid = ConfigurePortsOrExit(proxy, configuredAt, clientGuid);
Console.ReadLine();
var serverPorts = proxy.GetPortList();
foreach (var communicationPort in serverPorts)
{
Console.WriteLine("Server port: {0}, init {1}", communicationPort.ComPortName, communicationPort.IsInitialized);
}
Console.ReadLine();
string port = "COM101";
while (true)
{
// read register test
//ReadRegister(port, proxy, clientGuid, RegisterIds.ActiveEnergyPlus.AsLong());
ReadRegister(port, proxy, clientGuid, RegisterIds.ActiveEnergyMinus.AsLong());
WriteManufacturerId(port, proxy, clientGuid, "IVU");
//WriteMeasurementMode(port, proxy, clientGuid, "MM2");
//ReadHistoricEnergyLastDay(port, proxy, clientGuid);
//ReadHistoricEnergyLastWeek(port, proxy, clientGuid);
//WriteEnableTariffFunction(port, proxy, clientGuid, true);
//WriteAplusTariff(port, proxy,clientGuid, 2);
//WritePinCode(port, proxy, clientGuid, "1221");
//ReadPublicKey(port, proxy, clientGuid);
//WriteServerId(port, proxy, clientGuid);
//WriteManufacturerId(port, proxy, clientGuid, "DZG");
//WriteFactoryMode(port, proxy, clientGuid, false);
//WriteEnableGridOption(port, proxy, clientGuid, true);
Thread.Sleep(3000);
}
Console.WriteLine();
Console.WriteLine("Command execution finished.");
Console.ReadLine();
}
private static void WriteAminusTariff(string portName, SmlComServiceClient proxy, Guid clientGuid, byte tariffNo)
{
Console.WriteLine("Setting -A tariff to no: " + tariffNo);
proxy.WriteCurrentAminusTariff(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), tariffNo);
Console.WriteLine("Tariff was set.");
Console.WriteLine();
}
/// <summary>
/// Reads the billing data.
/// </summary>
/// <param name="portlist">The portlist.</param>
/// <param name="proxy">The proxy.</param>
/// <param name="clientGuid">The client GUID.</param>
private static void ReadBillingData(string portName, SmlComServiceClient proxy, Guid clientGuid)
{
Console.WriteLine("Reading billing data.");
var result = proxy.ReadLastPushedBillingData(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
//Console.WriteLine("BillingData: " + Stringify(result));
if (result != null)
{
if (result.ActiveEnergyPlusTotalSigned != null)
{
Console.WriteLine(
"Signed +A billingData available for port {0}, Verification {1}.",
portName,
(SignatureVerificationResult)result.ActiveEnergyPlusTotalSigned.SignatureVerificationStatus);
}
else if (result.ActiveEnergyMinusTotalSigned != null)
{
Console.WriteLine(
"Signed -A billingData available for port {0}, Verification {1}.",
portName,
(SignatureVerificationResult)result.ActiveEnergyPlusTotalSigned.SignatureVerificationStatus);
}
else if (result.ActiveEnergyPlusTotal != null)
{
Console.WriteLine("Unsigned +A BillingData available for port {0}, ServerId {1}, Second index {2}.", portName, BitConverter.ToString(result.ServerId), result.OperationSecondCounter);
}
else if (result.ActiveEnergyMinusTotal != null)
{
Console.WriteLine("Unsigned -A BillingData available for port {0}.", portName);
}
}
else
{
Console.WriteLine("BillingData failed for port {0}.", portName);
}
Console.WriteLine();
}
private static void WriteSwitchingProgramNumber(string portName, SmlComServiceClient proxy, Guid clientGuid, string programNumberText)
{
Console.WriteLine("Setting switching program no to: " + programNumberText);
proxy.WriteTariffSwitchingProgramNumber(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), programNumberText);
Console.WriteLine("Switching program was set.");
Console.WriteLine();
}
private static void WriteMeasurementMode(string portName, SmlComServiceClient proxy, Guid clientGuid, string measurementMode)
{
Console.WriteLine("Setting measurement mode to: " + measurementMode);
proxy.WriteMeasurementMode(clientGuid, portList.FirstOrDefault(m=> m.ComPortName == portName), measurementMode);
var result = proxy.ReadMeasurementMode(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
Console.WriteLine("Measurement mode read: MM" + result.Data.Value);
Console.WriteLine();
}
private static void WriteSetPinActive(string portName, SmlComServiceClient proxy, Guid clientGuid, bool isActive)
{
Console.WriteLine("Setting PIN active to: " + isActive);
proxy.WriteIsPinProtectionActive(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), isActive);
Console.WriteLine("PIN activation state was set.");
Console.WriteLine();
}
private static void WriteFactoryMode(string portName, SmlComServiceClient proxy, Guid clientGuid, bool isOn)
{
Console.WriteLine("Setting Factory mode to: " + isOn);
proxy.WriteEnableFactoryModeK2Enabled(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), isOn);
Console.WriteLine();
}
/// <summary>
/// Reads the date time.
/// </summary>
/// <param name="portlist">The portlist.</param>
/// <param name="proxy">The proxy.</param>
/// <param name="clientGuid">The client GUID.</param>
private static async Task ReadDateTime(string portName, SmlComServiceClient proxy, Guid clientGuid)
{
Console.WriteLine();
Console.WriteLine("{0} - Reading current meter time", portName);
var dt = proxy.ReadDateAndTimeParam(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
Console.WriteLine("{0} - Meter time (localtime): {1}, read at: {2}.", portName, dt.Data.Value.ToLocalTime(), dt.ReadAt.Value.ToLocalTime());
Console.WriteLine();
}
private static void WriteManufacturerId(string portName, SmlComServiceClient proxy, Guid clientGuid, string manId)
{
Console.WriteLine("Setting manufactuer idto: " + manId);
proxy.WriteManufacturerId(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), manId);
var result = proxy.ReadManufacturerId(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
Console.WriteLine("Manufacturer id read: " + Encoding.ASCII.GetString(result.Data));
Console.WriteLine();
}
/// <summary>
/// Writes the date time.
/// </summary>
/// <param name="portlist">The portlist.</param>
/// <param name="proxy">The proxy.</param>
/// <param name="clientGuid">The client GUID.</param>
/// <param name="meterTime">The meter time.</param>
private static void WriteDateTime(string portName, SmlComServiceClient proxy, Guid clientGuid, DateTime meterTime)
{
Console.WriteLine("Writing meter time to: {0}.", meterTime);
proxy.WriteDateAndTime(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), meterTime);
Console.WriteLine("Meter time was set.");
Console.WriteLine();
}
private static void WriteCustomerPush(string portName, SmlComServiceClient proxy, Guid clientGuid, bool customerPush)
{
Console.WriteLine("Setting customer push mode to: " + customerPush);
proxy.WriteCustomerPush(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), customerPush);
var booleanResult = proxy.ReadCustomerPush(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
Console.WriteLine("Customer push mode read: " + Stringify(booleanResult));
Console.WriteLine();
}
private static void WriteDateTime(string portName, SmlComServiceClient proxy, Guid clientGuid, int offset)
{
Console.WriteLine("Writing meter time with offset: {0}.", offset);
proxy.WriteDateAndTimeWithHostOffset(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), offset);
Console.WriteLine("Meter time was set.");
Console.WriteLine();
}
private static async Task EnableOperationModeEdl40(string portName, SmlComServiceClient proxy, Guid clientGuid, int hostOffset)
{
Console.WriteLine();
Console.WriteLine("{0} - Enabling EDL40 mode with host offset: {1}.", portName, hostOffset);
proxy.EnableOperationModeEdl40WithHostOffset(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), hostOffset);
var booleanResult = proxy.ReadIsOperationModeEdl40(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
//Console.WriteLine("Operation mode read: " + Stringify(booleanResult));
var meterTimeResult = proxy.ReadDateAndTime(
clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
Console.WriteLine("{0} - Meter time read: {1}", portName, Stringify(meterTimeResult));
Console.WriteLine();
}
public static void WriteParams(string portName, SmlComServiceClient proxy, Guid clientGuid)
{
Console.WriteLine("Writing parameters...");
//proxy.WriteClearBilling(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
//proxy.WriteClearEvent(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName));
//proxy.WriteMeasurementMode(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), "MM2");
proxy.WriteIsPinProtectionActive(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), false);
proxy.WriteIsManipulationDetectionActive(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), true);
proxy.WriteDisplaySpecialText(clientGuid, portList.FirstOrDefault(m => m.ComPortName == portName), "abc");
}
static SmlComManager()
{
var cfg = AppConfigRepository.Get();
Proxy = new SmlComServiceClient();
Proxy.Endpoint.Address = new EndpointAddress(cfg.SmlServiceEndpoint);
}
private static Guid ConfigurePortsOrExit(SmlComServiceClient proxy, DateTime configuredAt, Guid clientGuid)
{
try
{
string configureResult = proxy.ConfigurePorts(portList.ToArray(), null);
Console.WriteLine("Configure Result: {0}", configureResult);
if (configureResult.StartsWith("ERROR"))
{
Console.WriteLine(
"Seconds elapsed: {0}. A handled configuration error has occured: {1}.",
(DateTime.Now - configuredAt).Duration().TotalSeconds,
configureResult);
}
else
{
clientGuid = Guid.Parse(configureResult);
Console.WriteLine(
"Seconds elapsed: {0}. Client GUID obtained from service: {1}.",
(DateTime.Now - configuredAt).Duration().TotalSeconds,
clientGuid);
}
}
catch (Exception ex)
{
Console.WriteLine("A unhandled configuration error has occured. {0} - {1}.", ex.Message, ex.StackTrace);
Console.ReadLine();
Application.Exit();
}
return clientGuid;
}
