private async Task LogOut(bool closeTill)
{
log.Debug("LogoutViewModel:Started Logout process.");
var result = posManager.PosLogout(closeTill);
if (!result)
{
log.Error("LogoutViewModel: Logout failed.");
log.Info("LogoutViewModel: Show MessageBox to user and inform him to retry.");
var response = messageBoxService.ShowMessageBox("ConnectionLoseWhileLogout", MessageBoxButtonType.OK);
log.Debug("LogoutViewModel: Close the navigation.");
await navigationService.Close(this);
}
else
{
log.Debug("LogoutViewModel: Successful logout.");
if (App.IsFcsConnected)
{
log.Debug("LogoutViewModel: Fcs is connected. try to sign off.");
await App.SignOffAsync();
}
else
{
log.Error("LogoutViewModel: Fcs is not connected.Go to LoginViewModel.");
await navigationService.Navigate <LoginViewModel>();
}
}
}
private async Task ProcessInputs()
{
if (IsInputValid())
{
log.Debug("PrepayViewModel: Input is valid.Update active sale.");
UpdateActiveSale();
await navigationService.Navigate <TenderSelectionViewModel, int>(PumpId);
}
else
{
log.Error("PrepayViewModel: Input is invalid.");
}
}
public async Task <bool> Ping()
{
var client = new System.Net.Http.HttpClient();
try {
string url = string.Format("{0}api/driver/ping", Constants.WebAPIBaseAddress);
client.BaseAddress = new Uri(url);
client.Timeout = TimeSpan.FromSeconds(10);
var response = await client.GetAsync(url);
if (response.IsSuccessStatusCode)
{
IsConnected = true;
return(true);
}
else
{
IsConnected = false;
}
} catch (WebException ex) {
_mvxLog.Error($"Ping error: {ex}");
IsConnected = false;
} catch (Exception e) {
if (e.InnerException != null && e.InnerException is WebException)
{
IsConnected = false;
}
else
{
IsConnected = true;
}
}
return(false);
}
private async Task <List <ReceiptInfo> > GetReceipts(string invoiceNo, ReceiptOrder receiptOrder)
{
log.Debug("ReprintReceiptViewModel: Trying to get receipts.");
List <ReceiptInfo> receiptData = null;
GetReceiptCriteria criteria = new GetReceiptCriteria()
{
Date = SelectedDate,
StartInvoiceNumber = new ReceiptStartInvoiceNumber()
{
InvoiceNumber = invoiceNo,
ReceiptOrder = receiptOrder
},
Count = appSettings.NoOfReceiptsToShow
};
log.Debug("ReprintReceiptViewModel: Trying to fetch all receipts");
var response = await this.fcsService?.GetReceipt(ReceiptType.PayInStore, criteria);
if (response.ResultOK)
{
log.Debug("ReprintReceiptViewModel: Fetched all receipts successfully");
receiptData = response.Data;
if (receiptOrder == ReceiptOrder.Ascending)
{
receiptData.Reverse();
}
log.Debug("ReprintReceiptViewModel: Receipt Data:{0}.", ReceiptData);
}
else
{
log.Error("ReprintReceiptViewModel: Can't fetch receipts data properly.");
}
return(receiptData);
}
private async Task NavigateToTenderSelection()
{
try
{
IsFcsConnected = App.IsFcsConnected;
if (IsFcsConnected)
{
System.Timers.Timer goToTenderSelectionTimer;
goToTenderSelectionTimer = new System.Timers.Timer(2000)
{
AutoReset = false
};
goToTenderSelectionTimer.Elapsed += async(sender, eventArgs) =>
{
log.Debug("CardRefundViewModel: Tps is not connected. Go to Tender Selection page again.");
await this.navigationService.Close(this);
};
goToTenderSelectionTimer.Enabled = true;
}
else
{
log.Error("CardRefundViewModel: Fcs is not connected. Can't navigate to tender selection page.");
}
}
catch (Exception ex)
{
log.DebugException(string.Format("CardRefundViewModel: Exception:{0}.", ex.Message), ex);
}
}
public void WriteUDPDataToDataBase(string frameToSend, bool sentTypeMessage)
{
SQLiteCRUD sql = new(ConnectionStringManager.GetConnectionString(ConnectionStringManager.DataBases.PCControllerDB));
UdpSenderModel udpFrame = new();
string incomingMessage = IncomingMessage;
if (incomingMessage is null)
{
_log.Error("Incoming Message is null");
}
else
{
if (incomingMessage.Contains("\r\n"))
{
incomingMessage = incomingMessage.Replace("\r\n", "!0A!0D");
}
else if (incomingMessage.Contains("\r"))
{
incomingMessage = incomingMessage.Replace("\r", "!0D");
}
else if (incomingMessage.Contains("\n"))
{
incomingMessage = incomingMessage.Replace("\n", "!0A");
}
if (sentTypeMessage is true)
{
udpFrame.OutgoingMessage = frameToSend;
udpFrame.IncomingMessage = incomingMessage;
udpFrame.RemoteIP = _asyncUdpLink.Address;
udpFrame.LocalIP = GetLocalIPAddress();
udpFrame.LocalPort = _asyncUdpLink.LocalPort;
udpFrame.RemotePort = _asyncUdpLink.Port;
udpFrame.Timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");
sql.InsertUdpSentData(udpFrame);
string udpFrameCombine =
$"SENT: {DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} Sent Frame: {frameToSend} Remote IP: {_asyncUdpLink.Address} This IP: {GetLocalIPAddress()} Remote Port: {_asyncUdpLink.LocalPort} Local Port: {_asyncUdpLink.Port}";
UdpFrameCombined = udpFrameCombine;
}
else
{
udpFrame.OutgoingMessage = string.Empty;
udpFrame.IncomingMessage = incomingMessage;
udpFrame.RemoteIP = _asyncUdpLink.Address;
udpFrame.LocalIP = GetLocalIPAddress();
udpFrame.LocalPort = _asyncUdpLink.LocalPort;
udpFrame.RemotePort = _asyncUdpLink.Port;
udpFrame.Timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");
sql.InsertUdpSentData(udpFrame);
string udpFrameCombine =
$"RECEIVED: {DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} Received Frame: {incomingMessage} Remote IP: {_asyncUdpLink.Address} This IP: {GetLocalIPAddress()} Remote Port: {_asyncUdpLink.LocalPort} Local Port: {_asyncUdpLink.Port}";
UdpFrameCombined = udpFrameCombine;
}
}
}
private void GetGrades()
{
log.Debug("GradesViewModel: Trying to get grades.");
var newGrades = new MvxObservableCollection <GradeDetails>();
if (fcsService.FCSConfig == null)
{
log.Error("GradesViewModel: Fcs configuration is null.");
return;
}
fcsService.FCSConfig.FuelPrice.Grades.ForEach(
grade => newGrades.Add(new GradeDetails()
{
Decimal = FuelUnitPriceDecimal,
CurrentData = grade
}));
SelectedGrade = null;
Grades = newGrades;
log.Debug("GradesViewModel: Finished fetching all grades.");
}
public override async void ViewAppeared()
{
log.Debug("CardTenderViewModel: View is appeared.");
base.ViewAppeared();
try
{
SubscribeAllEvents();
amount = posManager.ActiveSale.Amount;
IsTpsConnected = App.IsTpsConnected;
IsFcsConnected = App.IsFcsConnected;
if (!IsTpsConnected)
{
log.Error("CardTenderViewModel: TPS is not connected.Go to tender selection page.");
await NavigateToTenderSelection();
}
else
{
log.Debug("CardTenderViewModel: TPS is connected.Process sale.");
await ProcessSaleResponse();
}
}
catch (Exception ex)
{
log.ErrorException(string.Format("CardTenderViewModel: Exception:{0}", ex.Message), ex);
}
}
private async void SubscribeToUpdates(object sender, SlotEventArgs args)
{
var slot = args.Slot;
if (slot.Index != _slot.Index)
{
return;
}
var device = _slot.ConnectedDevice;
if (device != null)
{
try
{
_batteryUpdateEventHandler = new EventHandler <CharacteristicUpdatedEventArgs>((s, a) => SetBatteryStatus(s, a));
device.BatteryCharacteristic.ValueUpdated += _batteryUpdateEventHandler;
_infoUpdateEventHandler = new EventHandler <CharacteristicUpdatedEventArgs>((s, a) => SetSessionStatus(s, a));
device.InfoCharacteristic.ValueUpdated += _infoUpdateEventHandler;
_log.Info("Sending Get Info Command.");
var commandSuccessful = await SendCommand(CommandType.GetInfo);
if (commandSuccessful)
{
_log.Info("Command successfully sent.");
}
//BatteryLevel = -1;
//SessionStatus = -1;
}
catch (Exception)
{
_log.Error("Characteristic subscription for data logging could not be completed.");
}
}
}
private async Task CancelBasketHold()
{
log.Debug("RefundStatusViewModel: Refund not approved.Cancel hold basket.");
var response = await fcsService.CancelHoldBasket(posManager.ActiveSale.SoldBasket.BasketID);
if (response.ResultOK)
{
log.Debug("RefundStatusViewModel: Successfully cancel hold basket with basketID: {0}.", posManager.ActiveSale.SoldBasket.BasketID);
}
else
{
log.Error("RefundStatusViewModel: Cancel hold basket failure with basketID: {0}.", posManager.ActiveSale.SoldBasket.BasketID);
}
}
private void DonateInteraction(INInteraction interaction)
{
interaction.DonateInteraction(
error =>
{
if (error != null)
{
_logger.Error($"Interaction donation failed: {error}");
}
else
{
_logger.Info("Successfully donated interaction.");
}
});
}
private async Task GetReceiptData()
{
try
{
log.Debug("ReprintReceiptDataViewModel: Trying to get receipt data for invoice id:{0}.", invoiceId);
var response = await this.fcsService?.GetReceiptData(ReceiptType.PayInStore, invoiceId);
if (response.ResultOK)
{
log.Debug("ReprintReceiptDataViewModel: Successfully fetched receipt data.");
Receipt = response.Receipt;
log.Debug("ReprintReceiptDataViewModel: Receipt : {0}.", Receipt);
}
else
{
log.Error("ReprintReceiptDataViewModel: Error while fetching receipt data.");
}
}
catch (Exception ex)
{
log.ErrorException(string.Format("ReprintReceiptDataViewModel: Exception:{0}", ex.Message), ex);
}
}
private async void OnFcsConnectionStatusChanged(object sender, bool isConnected)
{
log.Info("App: Fcs Connection status is changed...");
//Todo: need to be aware of connection status changes
var fcsService = sender as IFcsService;
IsFcsConnected = isConnected;
if (!IsFcsConnected)
{
IsSignOnDone = false;
log.Debug("App: Fcs is disconnected. Navigate and stop pos.");
navigationService = Mvx.IoCProvider.Resolve <IMvxNavigationService>();
posManager = Mvx.IoCProvider.Resolve <PosManager>();
if (posManager.IsUserLoggedIn())
{
log.Debug("App: User logged in. Navigate to Home");
await navigationService.Navigate <HomeViewModel>();
}
else
{
log.Debug("App: User not logged in. Navigate to Login");
await navigationService.Navigate <LoginViewModel>();
}
await posManager.StopPos();
// Try re-connect
fcstimer.Enabled = true;
}
else
{
log.Error("App: Fcs is connected now.");
}
}
public void DataUpdate(byte[] data, DataType type, SensorDevice senderDevice)
{
var senderDeviceType = senderDevice.Type;
// Create a new list with a collection for each data type for holding incoming data.
var incomingData = new Dictionary <DataType, List <DataProfile> >();
foreach (DataType dataType in ValidSensorDataTypes)
{
incomingData.Add(dataType, new List <DataProfile>());
}
var outputID = Tuple.Create(senderDevice.SlotIndex, type).GetHashCode();
//_log.Debug($"{senderDevice.SlotIndex}");
// Parse incoming data.
if (senderDeviceType == DeviceType.Stroke)
{
if (type == DataType.accl)
{
try {
for (int i = 0; i < 4; i++)
{
outputID = Tuple.Create(senderDevice.SlotIndex, DataType.accl_z).GetHashCode();
incomingData[DataType.accl_z].Add(new DataProfile(type, _dataTime[outputID]++, (Int16)((data[1 + i * 6] << 8) | data[0 + i * 6])));
outputID = Tuple.Create(senderDevice.SlotIndex, DataType.accl_x).GetHashCode();
incomingData[DataType.accl_x].Add(new DataProfile(type, _dataTime[outputID]++, (Int16)((data[3 + i * 6] << 8) | data[2 + i * 6])));
outputID = Tuple.Create(senderDevice.SlotIndex, DataType.accl_y).GetHashCode();
incomingData[DataType.accl_y].Add(new DataProfile(type, _dataTime[outputID]++, (Int16)((data[5 + i * 6] << 8) | data[4 + i * 6])));
}
} catch (IndexOutOfRangeException) {
_log.Error($"Invalid data range received from device {senderDevice.SlotIndex}. Count: {data.Length} Data: {string.Join(" ", data)}");
if (senderDevice.SlotIndex >= 0)
{
DataErrorCount[senderDevice.SlotIndex]++;
}
return;
} catch (KeyNotFoundException) {
_log.Error($"Invalid key detected for device {senderDevice.SlotIndex}. Keys in scope: outputID {outputID}");
if (senderDevice.SlotIndex >= 0)
{
DataErrorCount[senderDevice.SlotIndex]++;
}
return;
}
}
}
//Task.Run(async () => await _dataLoggingService.WritePackage(incomingData, senderDeviceType));
//_dataLoggingService.AddCollectionAsync(incomingData, senderDeviceType);
// DataRefreshPointers for each data collection of data points.
foreach (KeyValuePair <DataType, List <DataProfile> > incomingDataforType in incomingData)
{
DataType dataType = incomingDataforType.Key;
List <DataProfile> dataPoints = incomingDataforType.Value;
outputID = Tuple.Create(senderDevice.SlotIndex, dataType).GetHashCode();
if (dataPoints.Count > 0)
{
// The Limit of the databuffer queue.
int queueDataPointLimit = _blePacketLimit * NumDataPointsPerPacket[dataType] / (int)DownSamplingRate[dataType];
// If the downsampling amount was specified. (i.e. accl_z)
if (DownSamplingRate[dataType] > 1)
{
// Calculate how many data points should be left after the downsampling.
int numOfDownsampledDataPoints = NumDataPointsPerPacket[dataType] / (int)DownSamplingRate[dataType];
for (int i = 0; i < dataPoints.Count; i += (int)DownSamplingRate[dataType])
{
int dataCount = Math.Min((int)DownSamplingRate[dataType], dataPoints.Count - i);
var partialData = dataPoints.GetRange(i, dataCount);
if (partialData.Count <= 0)
{
continue;
}
DataProfile downsampledData = partialData[partialData.Count - 1];
// Remove a datapoint from the queue if it's beyond the databuffer queue point limit.
if (GraphDataBuffer[outputID].Count > queueDataPointLimit)
{
GraphDataBuffer[outputID].TryDequeue(out DataProfile dequeuedData);
}
// Add the new downsampled data.
GraphDataBuffer[outputID].Enqueue(downsampledData);
}
DataProfile downsample = dataPoints[dataPoints.Count - 1];
// Remove a datapoint from the queue if it's beyond the databuffer queue point limit.
if (GraphDataBuffer[outputID].Count > queueDataPointLimit)
{
GraphDataBuffer[outputID].TryDequeue(out DataProfile dequeuedData);
}
// Add the new downsampled data.
GraphDataBuffer[outputID].Enqueue(downsample);
}
// Else the downsampling amount was not specified.
else
{
foreach (var dataPoint in dataPoints)
{
// Remove a datapoint from the queue if it's beyond the databuffer queue point limit.
if (GraphDataBuffer[outputID].Count > queueDataPointLimit)
{
GraphDataBuffer[outputID].TryDequeue(out DataProfile dequeuedData);
}
// Add the new data point.
GraphDataBuffer[outputID].Enqueue(dataPoint);
}
}
}
}
var timeStamp = ((data[27] << 24) | (data[26] << 16) | (data[25] << 8) | data[24]) / 4.0;
_dataLoggingService.UpdateTimeStamp(timeStamp);
}
public FcsMessageDeserializationResult Deserialize(byte[] data)
{
log.Debug("FcsMessageSerializer: Deserializing Message..");
FcsMessageDeserializationResult result = new FcsMessageDeserializationResult();
int processedBytes = 0;
using (MemoryStream memoryStream = new MemoryStream(data))
{
BinaryReader reader = new BinaryReader(memoryStream);
try
{
byte headerStart = reader.ReadByte();
processedBytes++;
if (headerStart != 0X01)
{
//Todo: handle error
log.Error("FcsMessageSerializer: Error in headerStart byte {0}", headerStart);
}
byte sequenceNumber = reader.ReadByte();
processedBytes++;
byte[] bytes = reader.ReadBytes(4);
processedBytes += 4;
bytes = bytes.Reverse().ToArray();
int xmlLength = BitConverter.ToInt32(bytes, 0);
log.Debug("FcsMessageSerializer: Seq#: {0}, XmlLength: {1}", sequenceNumber, xmlLength);
bytes = reader.ReadBytes(xmlLength);
processedBytes += xmlLength;
string xmlMessage = System.Text.Encoding.UTF8.GetString(bytes);
log.Debug("FcsMessageSerializer: Received xml message from Fcs: {0}", xmlMessage);
if (xmlLength != xmlMessage.Length)
{
//Todo: something wrong
}
byte messageEnd = reader.ReadByte();
processedBytes++;
if (messageEnd != 0x04)
{
//Todo: something wrong
log.Error("FcsMessageSerializer: Message end ({0} didn't match", messageEnd);
}
result.IsSuccessful = true;
XElement messageElement = XElement.Parse(xmlMessage);
XElement commandElement = messageElement.FirstNode as XElement;
if (messageElement.Name == "FCSCommand")
{
log.Debug("FcsMessageSerializer: Message element name:FcsCommand.");
if (commandElement.Name == "Basket")
{
log.Debug("FcsMessageSerializer: Command element name:Basket.");
FcsCommand <BasketRequest> fcsCommand = new FcsCommand <BasketRequest>();
fcsCommand.XmlCommand = commandElement;
result.MessageType = FcsMessageType.BasketCommand;
result.FcsMessage = fcsCommand;
}
else if (commandElement.Name == "Configuration")
{
log.Debug("FcsMessageSerializer: Command element name: Configuration");
FcsCommand <ConfigurationRequest> fcsCommand = new FcsCommand <ConfigurationRequest>();
//Todo: We need to remove this after FCS is fixed
ReplaceDescendantAttributeName(commandElement, "Grade", "Type", "type");
fcsCommand.XmlCommand = commandElement;
result.MessageType = FcsMessageType.ConfigurationCommand;
result.FcsMessage = fcsCommand;
}
}
else if (messageElement.Name == "FCSResponse")
{
log.Debug("FcsMessageSerializer: Message element name:FcsResponse.");
if (commandElement.Name == "SignOnResp")
{
log.Debug("FcsMessageSerializer: Command element name:SignOnResp.");
FcsResponse <SignOnResponse> fcsResponse = new FcsResponse <SignOnResponse>();
fcsResponse.XmlCommand = commandElement;
result.MessageType = FcsMessageType.SignOnResponse;
result.FcsMessage = fcsResponse;
}
else if (commandElement.Name == "SignOnTPOSResp")
{
log.Debug("FcsMessageSerializer: Command element name:SignOnTPOSResp.");
FcsResponse <SignOnTPosResponse> fcsResponse = new FcsResponse <SignOnTPosResponse>();
fcsResponse.XmlCommand = commandElement;
result.MessageType = FcsMessageType.SignOnTPosResponse;
result.FcsMessage = fcsResponse;
}
else if (commandElement.Name == "SignOffTPOSResp")
{
log.Debug("FcsMessageSerializer: Command element name:SignOffTPOSResp.");
FcsResponse <SignOffTPosResponse> fcsResponse = new FcsResponse <SignOffTPosResponse>();
fcsResponse.XmlCommand = commandElement;
result.MessageType = FcsMessageType.SignOffTPosResponse;
result.FcsMessage = fcsResponse;
}
else if (commandElement.Name == "PrepayResp")
{
log.Debug("FcsMessageSerializer: Command element name:PrepayResp.");
FcsResponse <PrepayResponse> fcsResponse = new FcsResponse <PrepayResponse>();
fcsResponse.XmlCommand = commandElement;
result.MessageType = FcsMessageType.PrepayResponse;
result.FcsMessage = fcsResponse;
}
else if (commandElement.Name == "BasketResp")
{
log.Debug("FcsMessageSerializer: Command element name:BasketResp.");
FcsResponse <BasketResponse> fcsResponse = new FcsResponse <BasketResponse>();
fcsResponse.XmlCommand = commandElement;
result.MessageType = FcsMessageType.BasketResponse;
result.FcsMessage = fcsResponse;
}
else if (commandElement.Name == "SetPumpResp")
{
log.Debug("FcsMessageSerializer: Command element name: SetPumpResp");
FcsResponse <SetPumpResponse> fcsResponse = new FcsResponse <SetPumpResponse>();
fcsResponse.XmlCommand = commandElement;
result.MessageType = FcsMessageType.SetPumpResponse;
result.FcsMessage = fcsResponse;
}
else if (commandElement.Name == "SetPriceResp")
{
log.Debug("FcsMessageSerializer: Command element name: SetPriceResp");
FcsResponse <SetPriceResponse> fcsResponse = new FcsResponse <SetPriceResponse>();
fcsResponse.XmlCommand = commandElement;
result.MessageType = FcsMessageType.SetPriceResponse;
result.FcsMessage = fcsResponse;
}
else if (commandElement.Name == "GetReportResp")
{
log.Debug("FcsMessageSerializer: Command element name: GetReportResp");
FcsResponse <GetReportResponse> fcsResponse = new FcsResponse <GetReportResponse>();
fcsResponse.XmlCommand = commandElement;
result.MessageType = FcsMessageType.GetReportResponse;
result.FcsMessage = fcsResponse;
}
else if (commandElement.Name == "GetReceiptResp")
{
log.Debug("FcsMessageSerializer: Command element name: GetReceiptResp");
FcsResponse <GetReceiptResponse> fcsResponse = new FcsResponse <GetReceiptResponse>();
fcsResponse.XmlCommand = commandElement;
result.MessageType = FcsMessageType.GetReceiptResponse;
result.FcsMessage = fcsResponse;
}
else if (commandElement.Name == "GetReceiptDataResp")
{
log.Debug("FcsMessageSerializer: Command element name: GetReceiptDataResp");
FcsResponse <GetReceiptDataResponse> fcsResponse = new FcsResponse <GetReceiptDataResponse>();
fcsResponse.XmlCommand = commandElement;
result.MessageType = FcsMessageType.GetReceiptDataResponse;
result.FcsMessage = fcsResponse;
}
}
else if (messageElement.Name == "FCSEvent")
{
log.Debug("FcsMessageSerializer: Message element name:FcsEvent.");
if (commandElement.Name == "Status")
{
log.Debug("FcsMessageSerializer: Command element name:Status.");
FcsEvent <FcsStatus> fcsEvent = new FcsEvent <FcsStatus>();
fcsEvent.XmlCommand = commandElement;
result.MessageType = FcsMessageType.EventStatus;
result.FcsMessage = fcsEvent;
}
else if (commandElement.Name == "PriceChanged")
{
log.Debug("FcsMessageSerializer: Command element name:PriceChanged.");
FcsEvent <PriceChangedEvent> fcsEvent = new FcsEvent <PriceChangedEvent>();
fcsEvent.XmlCommand = commandElement;
result.MessageType = FcsMessageType.EventPriceChanged;
result.FcsMessage = fcsEvent;
}
else if (commandElement.Name == "Prepay")
{
log.Debug("FcsMessageSerializer: Command element name:Prepay.");
FcsEvent <PrepayEvent> fcsEvent = new FcsEvent <PrepayEvent>();
fcsEvent.XmlCommand = commandElement;
result.MessageType = FcsMessageType.EventPrepay;
result.FcsMessage = fcsEvent;
}
}
}
catch (EndOfStreamException eos)
{
log.DebugException("FcsMessageSerializer: exception{0}.", eos);
processedBytes = 0;
result.IsSuccessful = false;
}
catch (XmlException xmlException)
{
log.DebugException("FcsMessageSerializer: exception{0}.", xmlException);
processedBytes = 0;
result.IsSuccessful = false;
}
}
result.ByteProcessed = processedBytes;
log.Debug("FcsMessageSerializer: Return DeSerialized data.");
return(result);
}
private void HandleBackgroundException(Exception ex)
{
_log.Error(ex, "Background Exception!");
IsBusy = false;
}
private string GetInvoiceNo(SaleStatus sale)
{
log.Debug("PosManager: Get invoice no.");
string invoiceNo = null;
if (sale?.SoldBasket?.Prepay != null)
{
invoiceNo = sale?.SoldBasket?.Prepay?.PrepayInvoice;
}
else
{
invoiceNo = sale?.InvoiceNo;
}
if (invoiceNo != null)
{
log.Debug("PosManager: Invoice no is:{0}", invoiceNo);
}
else
{
log.Error("PosManager: Invoice no is null.");
}
return(invoiceNo);
}