1125 lines
40 KiB
C#
1125 lines
40 KiB
C#
using DE70_CMDv2;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Linq;
|
|
using SafeBagDE70.API;
|
|
using SafeBagDE70.Model;
|
|
using Serilog;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.ServiceProcess;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Forms.VisualStyles;
|
|
using System.Windows.Threading;
|
|
|
|
namespace SafeBagDE70
|
|
{
|
|
public static class AppData
|
|
{
|
|
public static string CDMPort = "COM4";
|
|
public static string SensorPort = "COM3";
|
|
public static Version? CurrentVersion = null;
|
|
public static ObservableCollection<CustomerAccount>? customerAccounts = null;
|
|
public static CustomerAccount? CurrentCustomerAccount{get;set;}
|
|
public static CCmdRsp? cCmdRsp=null;
|
|
public static bool IsAuthenticated = false;
|
|
public static bool IsInTransaction = false;
|
|
public static int WDTCount = 0;
|
|
public static ObservableCollection<string> logCollection = new ObservableCollection<string>();
|
|
public static ListView logListView = null;
|
|
public static int MaxLogCount = 500;
|
|
public static int MaxNotes = 300;
|
|
public static string BaseURL = "";
|
|
public static int TenantId = 0;
|
|
public static bool IsInternetOk = false;
|
|
static Task? resendTaskHistories = null;
|
|
static Task? resendTaskEvents = null;
|
|
static Task? commandTask = null;
|
|
private static DeviceStatus? _DeviceStatus = null;
|
|
public static DeviceStatusFile? DeviceStatusFile = null;
|
|
public static DeviceStatus? DeviceStatus
|
|
{
|
|
set { _DeviceStatus = value; }
|
|
get
|
|
{
|
|
if (_DeviceStatus == null)
|
|
{
|
|
InitDeviceStatus();
|
|
}
|
|
else
|
|
{
|
|
_DeviceStatus.DeviceTime = DateTime.Now;
|
|
}
|
|
return _DeviceStatus;
|
|
}
|
|
}
|
|
public static bool bInitUser = false;
|
|
static AppData()
|
|
{
|
|
CDMSTATE = new CDMSTATE();
|
|
ADMINDEVICESTATUS = new ADMINDEVICESTATUS();
|
|
customerAccounts = new ObservableCollection<CustomerAccount>();
|
|
GetDeviceStatusFromFile();
|
|
//InitDeviceStatus();
|
|
}
|
|
public static void Init()
|
|
{
|
|
try
|
|
{
|
|
bInitUser = InitUsers();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Fatal(ex, "AppInit: "+ex.Message);
|
|
if(DeviceStatus != null)
|
|
{
|
|
DeviceStatus.Description = "Exception in AppInit: "+ex.Message;
|
|
APIModels.SendEvent(DeviceStatus);
|
|
}
|
|
}
|
|
|
|
}
|
|
public static void RestartApp(bool bAutoRestart=false)
|
|
{
|
|
Application.Current.Dispatcher.Invoke(() =>
|
|
{
|
|
if (AppData.IsInTransaction)
|
|
{
|
|
if (!bAutoRestart)
|
|
{
|
|
MessageBox.Show("LƯU Ý, THAO TÁC NÀY SẼ LÀM MẤT TẤT CẢ DỮ LIỆU ĐANG THAO TÁC. " +
|
|
"HÃY HOÀN TẤT GIAO DỊCH ĐỂ TIẾP TỤC", "CẢNH BÁO", MessageBoxButton.OK);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
string exePath = Process.GetCurrentProcess().MainModule.FileName;
|
|
|
|
Process.Start(exePath);
|
|
|
|
System.Windows.Application.Current.Shutdown();
|
|
}
|
|
});
|
|
|
|
}
|
|
public static void InitDeviceStatus()
|
|
{
|
|
DeviceStatus = new DeviceStatus
|
|
{
|
|
Device = Environment.MachineName,
|
|
TenantId = AppData.TenantId,
|
|
Status = 0,
|
|
CDMStatus = 0,
|
|
PrinterStatus = 0,
|
|
SensorStatus = 0,
|
|
Notes = "",
|
|
OtherError = 0,
|
|
};
|
|
}
|
|
|
|
public static bool InitUsers()
|
|
{
|
|
int retryCount = 0;
|
|
int maxRetries = 20; // Max retries before giving up
|
|
int delay = 5000; // Delay between retries (5 seconds)
|
|
while (retryCount < maxRetries)
|
|
{
|
|
try
|
|
{
|
|
|
|
customerAccounts.Clear();
|
|
using (var context = new CDMDbContext())
|
|
{
|
|
var customers = context.Customers;
|
|
foreach (var customer in customers)
|
|
{
|
|
var ca = new CustomerAccount
|
|
{
|
|
Name = customer.TenantName,
|
|
CustomerId = customer.AccountNumber,
|
|
QRCode = customer.AccountNumber,
|
|
PINCode = customer.PinCode
|
|
};
|
|
customerAccounts.Add(ca);
|
|
}
|
|
}
|
|
CurrentCustomerAccount = customerAccounts[0];
|
|
Log.Information("InitUsers thành công");
|
|
bInitUser = true;
|
|
break;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Information($"Retry InitUser: {retryCount}/{maxRetries}");
|
|
retryCount++;
|
|
|
|
if (retryCount >= maxRetries)
|
|
{
|
|
Log.Fatal(ex, "InitUsers: " + ex.Message);
|
|
if (DeviceStatus != null)
|
|
{
|
|
DeviceStatus.Description = "Exception in InitUsers: " + ex.Message;
|
|
APIModels.SendEvent(DeviceStatus);
|
|
}
|
|
break;
|
|
}
|
|
// Wait for the next retry
|
|
Thread.Sleep(delay);
|
|
}
|
|
}
|
|
return bInitUser;
|
|
}
|
|
public static CDMSTATE CDMSTATE;
|
|
public static ADMINDEVICESTATUS ADMINDEVICESTATUS;
|
|
private static DateTime CutOffTime = new DateTime(1, 1, 1, 11, 0, 0); // 11:00 a.m as cut-off time
|
|
|
|
public static string GetNumberPartFromMerchantCode(string merchantCode)
|
|
{
|
|
if (merchantCode == null) return "";
|
|
var match = Regex.Match(merchantCode, @"\d+$");
|
|
string merchantCode_part = match.Value;
|
|
return merchantCode_part;
|
|
}
|
|
public static void CreateNewTransactionCode()
|
|
{
|
|
DateTime transactionDateTime = DateTime.Now;
|
|
|
|
string merchantCode_part = GetNumberPartFromMerchantCode(CurrentCustomerAccount.CustomerId);
|
|
// Adjust transaction date if it's past cut-off time (12:00 noon)
|
|
DateTime prevadjustedDate = CurrentCustomerAccount.TransactionTime.Hour >= CutOffTime.Hour ? transactionDateTime.Date : transactionDateTime.Date.AddDays(-1);
|
|
|
|
DateTime adjustedDate = transactionDateTime.Hour >= CutOffTime.Hour ? transactionDateTime.Date : transactionDateTime.Date.AddDays(-1);
|
|
if ((adjustedDate - prevadjustedDate).Days > 0)
|
|
{
|
|
CurrentCustomerAccount.TransactionCount =1;
|
|
}
|
|
else
|
|
{
|
|
CurrentCustomerAccount.TransactionCount++;
|
|
}
|
|
var transactionCount = CurrentCustomerAccount.TransactionCount;
|
|
string datePart = transactionDateTime.ToString("yyyyMMdd");
|
|
string timePart = transactionDateTime.ToString("HHmmss");
|
|
string transactionCountPart = transactionCount.ToString("D2"); // Ensure 2 digits
|
|
|
|
// Combine all parts to form the transaction ID
|
|
string transactionId = $"{datePart}{timePart}{merchantCode_part}{transactionCountPart}";
|
|
|
|
CurrentCustomerAccount.TransactionCode = transactionId;
|
|
CurrentCustomerAccount.TransactionTime = transactionDateTime;
|
|
}
|
|
public static string GetTransactionCode()
|
|
{
|
|
if (CurrentCustomerAccount != null)
|
|
return CurrentCustomerAccount.TransactionCode;
|
|
else
|
|
return "";
|
|
}
|
|
public static CDMSTATE? GetCDMState()
|
|
{
|
|
try
|
|
{
|
|
if (cCmdRsp != null)
|
|
{
|
|
cCmdRsp.SendDeSense();
|
|
string strSend = cCmdRsp.GetSendDat(false);
|
|
string strRecv = cCmdRsp.GetRecvDat();
|
|
Log.Information($"[SEND] {strSend}");
|
|
Log.Information($"[RECV] {strRecv}");
|
|
var data = cCmdRsp.recv_dat.dat;
|
|
if (AppData.CDMSTATE != null)
|
|
{
|
|
AppData.CDMSTATE.IsCassetteFull = data[17] & 0x08;
|
|
AppData.CDMSTATE.IsNotesInEscrow = data[4] & 0x01;
|
|
AppData.CDMSTATE.IsRejectPocketFull = data[3] & 0x40;
|
|
AppData.CDMSTATE.IsNotesInRejectPocket = data[3] & 0x10;
|
|
AppData.CDMSTATE.IsNotesInHopper = data[3] & 0x01;
|
|
AppData.CDMSTATE.IsStackerFull = (data[2] == 0x43?1:0);
|
|
|
|
if (data[0] == 0x40 && (data[1] == 0x07 || data[1]==0x09))
|
|
AppData.CDMSTATE.IsError = 0;
|
|
else
|
|
AppData.CDMSTATE.IsError = 1;
|
|
|
|
AppData.CDMSTATE.RequestTime = DateTime.Now;
|
|
AppData.CDMSTATE.UpdateCDMStatus(cCmdRsp.recv_dat);
|
|
}
|
|
|
|
}
|
|
return AppData.CDMSTATE;
|
|
}
|
|
catch (Exception ex) {
|
|
Log.Fatal(ex, "GetCDMState");
|
|
return null;
|
|
}
|
|
|
|
}
|
|
public static byte[] GetCassetteData()
|
|
{
|
|
//for(int i = 0; i < 2; i++)//Retry if failed
|
|
//{
|
|
// cCmdRsp.SendXXCmd((byte)Command.CMD_DE_READ_CASSETTE);
|
|
// if (cCmdRsp.recv_dat.dat[0] != 0x40)
|
|
// {
|
|
// Thread.Sleep(1000);
|
|
// }
|
|
// else
|
|
// break;
|
|
//}
|
|
cCmdRsp.SendXXCmd((byte)Command.CMD_DE_READ_CASSETTE);
|
|
var data = cCmdRsp.recv_dat.dat;
|
|
StringBuilder str = new StringBuilder();
|
|
var recv_dat = cCmdRsp.recv_dat;
|
|
|
|
AppData.DeviceStatus.Notes = GetNotesString(recv_dat.dat);
|
|
str.Append("DATA:");
|
|
for (int i = 0; i < recv_dat.leng - 1; i++)
|
|
{
|
|
var dat = string.Format("{0:X2} ", recv_dat.dat[i]);
|
|
str.Append(dat);
|
|
}
|
|
Log.Information("[CASSETTE]" + str.ToString());
|
|
return (byte[])data.Clone();
|
|
}
|
|
public static string GetNotesString(byte[] cassetData)
|
|
{
|
|
int notes = 0;
|
|
int offset = 14;
|
|
string str = "";
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
notes = cassetData[2 * i + offset] * 256 + cassetData[2 * i + 1 + offset];
|
|
str += notes + ",";
|
|
}
|
|
return str.Trim(',');
|
|
}
|
|
public static void ResendData()
|
|
{
|
|
ResendDepositHistories();
|
|
ResendEvents();
|
|
}
|
|
|
|
private static void ResendDepositHistories()
|
|
{
|
|
if (!AppData.IsInTransaction && AppData.IsInternetOk)
|
|
{
|
|
|
|
if (resendTaskHistories == null || resendTaskHistories.IsCompleted)
|
|
{
|
|
resendTaskHistories = Task.Run(async () =>
|
|
{
|
|
try
|
|
{
|
|
using (var context = new CDMDbContext())
|
|
{
|
|
var startTime = DateTime.Now.Date.AddDays(-2).Date;
|
|
var unsentHist = context.Histories
|
|
.Where(x => x.DepositTime >= startTime)
|
|
.Where(x => ((x.IsSent == null || x.IsSent == false)))
|
|
.ToList();
|
|
foreach (var item in unsentHist)
|
|
{
|
|
var data2Send = JsonConvert.DeserializeObject<CountingData2Send>(item.Data);
|
|
var bResult = await APIModels.SendCountingData(data2Send);
|
|
if (bResult)
|
|
{
|
|
item.IsSent = true;
|
|
context.Histories.Update(item);
|
|
context.SaveChanges();
|
|
Log.Information("ResendHistories: " + item.Data + " successfully");
|
|
}
|
|
else
|
|
{
|
|
Log.Error("ResendHistories: " + item.Data + " failed");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Fatal(ex, "ResendHistories failed");
|
|
}
|
|
});
|
|
}
|
|
else
|
|
{
|
|
Log.Information("Previous ResendHistories are running");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log.Information($"ResendHistories could not start IsInTransaction: {AppData.IsInTransaction} IsInternetOk: {AppData.IsInternetOk}");
|
|
}
|
|
}
|
|
private static void ResendEvents()
|
|
{
|
|
if (!AppData.IsInTransaction && AppData.IsInternetOk)
|
|
{
|
|
|
|
if (resendTaskEvents == null || resendTaskEvents.IsCompleted)
|
|
{
|
|
resendTaskEvents = Task.Run(async () =>
|
|
{
|
|
try
|
|
{
|
|
using (var context = new CDMDbContext())
|
|
{
|
|
var startTime = DateTime.Now.Date.AddDays(-2).Date;
|
|
var unsentHist = context.DeviceEvents
|
|
.Where(x => x.DeviceTime >= startTime)
|
|
.Where(x => ((x.IsSent == null || x.IsSent == false)))
|
|
.ToList();
|
|
foreach (var item in unsentHist)
|
|
{
|
|
var data2Send = JsonConvert.DeserializeObject<DeviceStatus?>(item.Data);
|
|
var bResult = await APIModels.TaskSendEvent(data2Send);
|
|
if (bResult)
|
|
{
|
|
item.IsSent = true;
|
|
context.DeviceEvents.Update(item);
|
|
context.SaveChanges();
|
|
Log.Information("ResendEvents: " + item.Data + " successfully");
|
|
}
|
|
else
|
|
{
|
|
Log.Error("ResendEvents: " + item.Data + " failed");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Fatal(ex, "ResendEvents failed");
|
|
}
|
|
});
|
|
}
|
|
else
|
|
{
|
|
Log.Information("Previous ResendEvents are running");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log.Information($"ResendEvents could not start IsInTransaction: {AppData.IsInTransaction} IsInternetOk: {AppData.IsInternetOk}");
|
|
}
|
|
}
|
|
|
|
public static void GetandExecuteCommands()
|
|
{
|
|
if (IsInternetOk && (commandTask == null || commandTask.IsCompleted))
|
|
{
|
|
commandTask = Task.Run(async () =>
|
|
{
|
|
try
|
|
{
|
|
var commands= await APIModels.GetCommands();
|
|
if(commands != null && commands.Count()>0)
|
|
{
|
|
foreach (var command in commands)
|
|
{
|
|
bool bResult = false;
|
|
switch(command.CommandCode)
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
Log.Information("Remote Reset CDM Error");
|
|
//Restart CDM
|
|
bResult=ResetCDMError();
|
|
break;
|
|
case 2:
|
|
Log.Information("Remote Reset CDM Counter");
|
|
bResult = ResetCDMCounter();
|
|
if (!bResult)
|
|
{
|
|
bResult = ResetCDMCounter();
|
|
}
|
|
break;
|
|
case 3:
|
|
if(IsInternetOk && !IsInTransaction)
|
|
{
|
|
Log.Information("Request update Customers");
|
|
int nCount = await UpdateCustomers();
|
|
Log.Information($"Updated {nCount} users");
|
|
InitUsers();
|
|
if (nCount > 0) bResult = true;
|
|
}
|
|
break;
|
|
case 4:
|
|
if (!IsInTransaction)
|
|
{
|
|
await APIModels.UpdateDeviceCommand(command.Id,1);
|
|
RestartApp(true);
|
|
}
|
|
break;
|
|
}
|
|
//
|
|
await APIModels.UpdateDeviceCommand(command.Id, bResult?1:2);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Fatal(ex, "GetandExecuteCommands failed");
|
|
}
|
|
});
|
|
}
|
|
else
|
|
{
|
|
var str = "";
|
|
if (commandTask != null && !commandTask.IsCompleted)
|
|
str += "Previous command state are running; ";
|
|
if (!IsInternetOk)
|
|
str += "No Internet Connection";
|
|
Log.Error("GetandExecuteCommands error: "+str);
|
|
}
|
|
}
|
|
static string deviceStatusFileName = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),"device_status.txt");
|
|
public static void GetDeviceStatusFromFile()
|
|
{
|
|
try
|
|
{
|
|
lock(deviceStatusFileName)
|
|
{
|
|
if (File.Exists(deviceStatusFileName))
|
|
{
|
|
var fileContent = File.ReadAllText(deviceStatusFileName);
|
|
DeviceStatusFile = JsonConvert.DeserializeObject<DeviceStatusFile>(fileContent);
|
|
}
|
|
else
|
|
{
|
|
DeviceStatusFile = new DeviceStatusFile();
|
|
UpdateDeviceStatusToFile();
|
|
}
|
|
}
|
|
Log.Information("GetPrinterStatusFromFile success");
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
Log.Fatal(ex, "GetPrinterStatusFromFile");
|
|
}
|
|
}
|
|
public static void UpdatePrinterStatus(bool IsPrinterPaperOut)
|
|
{
|
|
try
|
|
{
|
|
if (DeviceStatusFile!=null)
|
|
{
|
|
DeviceStatusFile.IsPrinterNearPaperOut = IsPrinterPaperOut;
|
|
if (!IsPrinterPaperOut)
|
|
{
|
|
DeviceStatusFile.PrintingCountFromNPO = 0;
|
|
}
|
|
}
|
|
}catch(Exception ex)
|
|
{
|
|
Log.Fatal(ex, "UpdatePrinterStatus");
|
|
}
|
|
}
|
|
public static void UpdatePrintingCountToStatusFile()
|
|
{
|
|
try
|
|
{
|
|
Log.Information("UpdateTransactionCountToStatusFile");
|
|
|
|
if (DeviceStatusFile!=null)
|
|
{
|
|
if (DeviceStatusFile.IsPrinterNearPaperOut)
|
|
{
|
|
DeviceStatusFile.PrintingCountFromNPO++;
|
|
}
|
|
else
|
|
{
|
|
DeviceStatusFile.PrintingCountFromNPO = 0;
|
|
}
|
|
UpdateDeviceStatusToFile();
|
|
|
|
Log.Information("UpdateTransactionCountToStatusFile success");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Fatal(ex, "UpdateTransactionCountToStatusFile");
|
|
}
|
|
}
|
|
public static void UpdateDeviceStatusToFile()
|
|
{
|
|
try
|
|
{
|
|
lock (deviceStatusFileName)
|
|
{
|
|
var fileContent = JsonConvert.SerializeObject(DeviceStatusFile);
|
|
File.WriteAllText(deviceStatusFileName, fileContent);
|
|
}
|
|
Log.Information("UpdatePrinterStatusFromFile success");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Fatal(ex, "UpdatePrinterStatusFromFile");
|
|
}
|
|
}
|
|
public static bool IsStopPrinting()
|
|
{
|
|
try
|
|
{
|
|
if (DeviceStatusFile != null)
|
|
return DeviceStatusFile.IsStopPrinting();
|
|
else
|
|
return false;
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static async Task<int> UpdateCustomers()
|
|
{
|
|
try
|
|
{
|
|
var amCustomers = await APIModels.GetAeonMallCustomers(AppData.TenantId);
|
|
using (var context = new CDMDbContext())
|
|
{
|
|
var customers = context.Customers;
|
|
context.Customers.RemoveRange(customers);
|
|
context.SaveChanges();
|
|
foreach (var amCustomer in amCustomers)
|
|
{
|
|
var customer = new Customer
|
|
{
|
|
AccountNumber = amCustomer.TenantCode,
|
|
AccountHolder = amCustomer.TenantName,
|
|
TenantName = amCustomer.TenantShortName,
|
|
TenantCode = amCustomer.TenantCode,
|
|
PinCode = amCustomer.TenantCode,
|
|
UpdatedTime = DateTime.Now,
|
|
};
|
|
customers.Add(customer);
|
|
}
|
|
context.SaveChanges();
|
|
}
|
|
return amCustomers.Count();
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
public static bool ResetCDMCounter()
|
|
{
|
|
bool bResetOk = false;
|
|
if (AppData.cCmdRsp != null)
|
|
{
|
|
Log.Information("[ADMIN] reset counter");
|
|
CCmdRsp cCmdRsp = AppData.cCmdRsp;
|
|
cCmdRsp.SendDeSense();
|
|
Thread.Sleep(1000);
|
|
cCmdRsp.SendXXCmd((byte)Command.CMD_DE_UNLOCK);
|
|
Thread.Sleep(1000);
|
|
cCmdRsp.SendDeSense();
|
|
Thread.Sleep(1000);
|
|
//Event fix
|
|
var recvData = cCmdRsp.recv_dat;
|
|
|
|
if (recvData.dat[14] == recvData.dat[16])
|
|
{
|
|
cCmdRsp.SendLock();
|
|
}
|
|
else
|
|
{
|
|
cCmdRsp.SendEventFix(recvData.dat[16]);
|
|
cCmdRsp.SendLock();
|
|
}
|
|
|
|
var currentMode = cCmdRsp.GetLockParam().mode;
|
|
cCmdRsp.GetLockParam().mode = Mode.MODE_COLLECTION;
|
|
cCmdRsp.SendLock();
|
|
Thread.Sleep(10000);
|
|
cCmdRsp.SendDeSense();
|
|
Thread.Sleep(1000);
|
|
recvData = cCmdRsp.recv_dat;
|
|
|
|
if (recvData.dat[14] != recvData.dat[16])
|
|
{
|
|
AppData.GetCassetteData();
|
|
bResetOk = true;
|
|
}
|
|
}
|
|
return bResetOk;
|
|
}
|
|
public static bool ResetCDMError()
|
|
{
|
|
var cCmdRsp = AppData.cCmdRsp;
|
|
bool bSuccess = false;
|
|
if(cCmdRsp!=null && cCmdRsp.recv_dat!=null)
|
|
{
|
|
if(cCmdRsp.recv_dat.dat[1] == 0x1C && cCmdRsp.recv_dat.dat[2] == 0x4A)
|
|
{
|
|
cCmdRsp.SendXXCmd((byte)Command.CMD_DE_SENSE);
|
|
|
|
var recvData = cCmdRsp.recv_dat;
|
|
|
|
if (recvData.dat[14] == recvData.dat[16])
|
|
{
|
|
cCmdRsp.SendLock();
|
|
}
|
|
else
|
|
{
|
|
cCmdRsp.SendEventFix(recvData.dat[16]);
|
|
}
|
|
Thread.Sleep(1000);
|
|
cCmdRsp.SendXXCmd((byte)Command.CMD_DE_RESET);
|
|
Thread.Sleep(2000);
|
|
cCmdRsp.SendXXCmd((byte)Command.CMD_DE_SENSE);
|
|
if (cCmdRsp.recv_dat.dat[1] == 0x04 && cCmdRsp.recv_dat.dat[2] == 0x41)
|
|
{
|
|
bSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
return bSuccess;
|
|
}
|
|
private static void LogCmdData()
|
|
{
|
|
try
|
|
{
|
|
string strSend = cCmdRsp.GetSendDat(false);
|
|
string strRecv = cCmdRsp.GetRecvDat();
|
|
Log.Information($"[SEND] {strSend}");
|
|
Log.Information($"[RECV] {strRecv}");
|
|
}
|
|
catch (Exception e) {
|
|
Log.Fatal(e, "LogCmdData");
|
|
}
|
|
|
|
}
|
|
public static bool ResetAbnormalStorage605()
|
|
{
|
|
|
|
|
|
var cCmdRsp = AppData.cCmdRsp;
|
|
bool bSuccess = false;
|
|
|
|
if (cCmdRsp != null)
|
|
{
|
|
Log.Information("START ABNORMAL STORAGE RESET PROC");
|
|
cCmdRsp.SendXXCmd((byte)Command.CMD_DE_SENSE);
|
|
LogCmdData();
|
|
if (cCmdRsp.recv_dat != null &&
|
|
((cCmdRsp.recv_dat.dat[18] & 0xF0) == 0xE0))
|
|
{
|
|
//0. Check notes in escrow or not?
|
|
|
|
//1. Event Fix
|
|
var recvData = cCmdRsp.recv_dat;
|
|
if (recvData.dat[14] == recvData.dat[16])
|
|
{
|
|
cCmdRsp.SendLock();
|
|
}
|
|
else
|
|
{
|
|
cCmdRsp.SendEventFix(recvData.dat[16]);
|
|
}
|
|
//2. UnLock
|
|
// cCmdRsp.SendXXCmd((byte)Command.CMD_DE_SENSE);
|
|
cCmdRsp.SendXXCmd((byte)Command.CMD_DE_UNLOCK);
|
|
LogCmdData();
|
|
Thread.Sleep(1000);
|
|
|
|
//3. Lock with MODE IMPORTANT ERROR
|
|
var currentMode = cCmdRsp.GetLockParam().mode;
|
|
cCmdRsp.GetLockParam().mode = Mode.MODE_SECERROR;
|
|
cCmdRsp.SendLock();
|
|
LogCmdData();
|
|
|
|
Thread.Sleep(1000);
|
|
|
|
cCmdRsp.SendXXCmd((byte)Command.CMD_DE_SENSE);
|
|
LogCmdData();
|
|
recvData = cCmdRsp.recv_dat;
|
|
var SR2 = recvData.dat[1];
|
|
var S2 = recvData.dat[18];
|
|
|
|
if (SR2 == 0x1C && (S2==0xE2 || S2==0xE4))
|
|
{
|
|
cCmdRsp.SendXXCmd((byte)Command.CMD_DE_RESET);
|
|
LogCmdData();
|
|
Thread.Sleep(1000);
|
|
for (int i=0;i<10;i++)
|
|
{
|
|
cCmdRsp.SendXXCmd((byte)Command.CMD_DE_SENSE);
|
|
LogCmdData();
|
|
Thread.Sleep(1000);
|
|
S2 = recvData.dat[18];
|
|
SR2 = recvData.dat[1];
|
|
if (SR2 == 0x07)
|
|
break;
|
|
}
|
|
Thread.Sleep(2000);
|
|
|
|
cCmdRsp.SendXXCmd((byte)Command.CMD_DE_CNTSTART);
|
|
LogCmdData();
|
|
Thread.Sleep(2000);
|
|
|
|
cCmdRsp.SendXXCmd((byte)Command.CMD_DE_STORESTART);
|
|
Thread.Sleep(2000);
|
|
LogCmdData();
|
|
if ((cCmdRsp.recv_dat.dat[1] == 0x07 || cCmdRsp.recv_dat.dat[1]==0x09) && cCmdRsp.recv_dat.dat[2] == 0x41)
|
|
{
|
|
//Wait until SR2=0x04
|
|
for(int i = 0; i < 10; i++)
|
|
{
|
|
cCmdRsp.SendXXCmd((byte)Command.CMD_DE_SENSE);
|
|
LogCmdData();
|
|
Thread.Sleep(1000);
|
|
|
|
SR2 = recvData.dat[1];
|
|
if (SR2 == 0x04)
|
|
{
|
|
bSuccess = true;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
Log.Information("END ABNORMAL STORAGE RESET PROC");
|
|
}
|
|
}
|
|
return bSuccess;
|
|
}
|
|
|
|
}
|
|
public class CustomerAccount
|
|
{
|
|
public string? Name { get; set; }
|
|
public string? CustomerId { get; set; }
|
|
public string? QRCode { get; set; }
|
|
public string? PINCode { get; set; }
|
|
public int TransactionCount { get; set; } = 1;
|
|
public DateTime TransactionTime { get; set; }
|
|
public string TransactionCode { get; set; }
|
|
}
|
|
public class CountSession
|
|
{
|
|
public CountSession()
|
|
{
|
|
for (int i = 0; i < QuantityDenomi.Count(); i++)
|
|
{
|
|
QuantityDenomi[i] = 0;
|
|
}
|
|
for (int i = 0; i < SumDenomi.Count(); i++)
|
|
{
|
|
SumDenomi[i] = 0;
|
|
}
|
|
for (int i = 0; i < TempNotes.Count(); i++)
|
|
{
|
|
TempNotes[i] = 0;
|
|
}
|
|
}
|
|
|
|
public int[] QuantityDenomi { get; set; } = new int[10];
|
|
public int[] SumDenomi { get; set; } = new int[10];
|
|
public bool IsStored = false;
|
|
public int[] TempNotes { get; set; } = new int[5];
|
|
|
|
}
|
|
|
|
public class CountingData2Send
|
|
{
|
|
public string? TransactionCode { get; set; }
|
|
public List<CountSession>? Sessions { get; set; }
|
|
public string? UserId { get; set; }
|
|
public string? MachineId { get; set; }
|
|
public string? MachineTime { get; set; }
|
|
public int RejectNotes { get; set; }
|
|
public int GenuineNotes { get; set; }
|
|
public int UnfitNotes { get; set; }
|
|
public int CounterfeitNotes { get; set; }
|
|
public int SuspendNotes { get; set; }
|
|
public int CountingState { get; set; }//0-Normal End, 1-Timeout End
|
|
}
|
|
|
|
public class NotesInSession : INotifyPropertyChanged
|
|
{
|
|
|
|
private int _GenuineNotes;
|
|
public int GenuineNotes
|
|
{
|
|
get
|
|
{
|
|
return _GenuineNotes;
|
|
}
|
|
set
|
|
{
|
|
if (_GenuineNotes != value)
|
|
{
|
|
_GenuineNotes = value;
|
|
OnPropertyChanged(nameof(GenuineNotes));
|
|
}
|
|
}
|
|
}
|
|
private int _RejectNotes;
|
|
public int RejectNotes
|
|
{
|
|
get
|
|
{
|
|
return _RejectNotes;
|
|
}
|
|
set
|
|
{
|
|
if (_RejectNotes != value)
|
|
{
|
|
_RejectNotes = value;
|
|
OnPropertyChanged(nameof(RejectNotes));
|
|
}
|
|
}
|
|
}
|
|
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
protected virtual void OnPropertyChanged(string propertyName)
|
|
{
|
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
|
|
}
|
|
}
|
|
public enum COUNTINGSTATE
|
|
{
|
|
NORMAL=0,
|
|
AUTOEND=1,
|
|
FULLIFSTORE=2
|
|
}
|
|
public class ADMINDEVICESTATUS : INotifyPropertyChanged
|
|
{
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
protected virtual void OnPropertyChanged(string propertyName)
|
|
{
|
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
|
|
}
|
|
private string? _PrinterStatus;
|
|
public string? PrinterStatus
|
|
{
|
|
get
|
|
{
|
|
return _PrinterStatus;
|
|
}
|
|
set
|
|
{
|
|
if (_PrinterStatus != value)
|
|
{
|
|
_PrinterStatus = value;
|
|
|
|
OnPropertyChanged(nameof(PrinterStatus));
|
|
}
|
|
}
|
|
}
|
|
private string? _SensorStatus;
|
|
public string? SensorStatus
|
|
{
|
|
get
|
|
{
|
|
return _SensorStatus;
|
|
}
|
|
set
|
|
{
|
|
if (_SensorStatus != value)
|
|
{
|
|
_SensorStatus = value;
|
|
|
|
OnPropertyChanged(nameof(SensorStatus));
|
|
}
|
|
}
|
|
}
|
|
private string? _DeviceStatus;
|
|
public string? DeviceStatus
|
|
{
|
|
get
|
|
{
|
|
return _DeviceStatus;
|
|
}
|
|
set
|
|
{
|
|
if (_DeviceStatus != value)
|
|
{
|
|
_DeviceStatus = value;
|
|
|
|
OnPropertyChanged(nameof(DeviceStatus));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public class CDMSTATE : INotifyPropertyChanged
|
|
{
|
|
public int IsCassetteFull = 0;
|
|
public int IsNotesInEscrow = 0;
|
|
public int IsRejectPocketFull = 0;
|
|
public int IsNotesInRejectPocket = 0;
|
|
public int IsNotesInHopper = 0;
|
|
public int IsStackerFull = 0;
|
|
public int IsError = 0;
|
|
public RecvData? RecvDat = null;
|
|
public byte GetSR1()
|
|
{
|
|
if (RecvDat != null)
|
|
return RecvDat.dat[0];
|
|
return 0;
|
|
}
|
|
public byte GetSR2()
|
|
{
|
|
if (RecvDat != null)
|
|
return RecvDat.dat[1];
|
|
return 0;
|
|
}
|
|
public byte GetSR3()
|
|
{
|
|
if (RecvDat != null)
|
|
return RecvDat.dat[2];
|
|
return 0;
|
|
}
|
|
public string GetSRStatus()
|
|
{
|
|
if (RecvDat != null)
|
|
return "SR1/2/3: " + AppData.cCmdRsp.GetSR1Summary(RecvDat.dat[0]) + ", " + AppData.cCmdRsp.GetSR2Summary(RecvDat.dat[1]) + ", " + AppData.cCmdRsp.GetSR3Summary(RecvDat.dat[2]);
|
|
else
|
|
return "";
|
|
}
|
|
public string GetDtatus()
|
|
{
|
|
string strStatus = "";
|
|
if (RecvDat != null)
|
|
{
|
|
if(RecvDat.leng>8)
|
|
{
|
|
var dat=RecvDat.dat;
|
|
strStatus += "D1: "+AppData.cCmdRsp.GetD1Summary(dat[3]);
|
|
strStatus += "\r\nD2: "+AppData.cCmdRsp.GetD2Summary(dat[4]);
|
|
strStatus += "\r\nD3: " + AppData.cCmdRsp.GetD3Summary(dat[5]);
|
|
strStatus += "\r\nD4: " + AppData.cCmdRsp.GetD4Summary(dat[6]);
|
|
strStatus += "\r\nD5: " + AppData.cCmdRsp.GetD5Summary(dat[7]);
|
|
strStatus += "\r\nD6: " + AppData.cCmdRsp.GetD6Summary(dat[8]);
|
|
}
|
|
}
|
|
return strStatus;
|
|
}
|
|
public string GetSStatus()
|
|
{
|
|
string strStatus = "";
|
|
if (RecvDat != null)
|
|
{
|
|
if (RecvDat.leng > 18)
|
|
{
|
|
var dat = RecvDat.dat;
|
|
strStatus += "S1: "+ AppData.cCmdRsp.GetS1Summary(dat[17]);
|
|
strStatus += "\r\nS2: " + AppData.cCmdRsp.GetS2Summary(dat[18]);
|
|
}
|
|
}
|
|
return strStatus;
|
|
}
|
|
public string GetFullStatus()
|
|
{
|
|
string strStatus = "";
|
|
strStatus = GetSRStatus();
|
|
strStatus += "\r\n"+GetDtatus();
|
|
strStatus += "\r\n"+GetSStatus();
|
|
return strStatus;
|
|
}
|
|
public void UpdateCDMStatus(RecvData recv_data)
|
|
{
|
|
RecvDat=recv_data;
|
|
if (AppData.cCmdRsp != null) {
|
|
CDMStatus = RequestTime.ToString("yyyy/MM/dd HH:mm:ss ") + GetSRStatus();
|
|
}
|
|
}
|
|
private string? _CDMStatus;
|
|
public string? CDMStatus
|
|
{
|
|
get
|
|
{
|
|
return _CDMStatus;
|
|
}
|
|
set
|
|
{
|
|
if (_CDMStatus != value)
|
|
{
|
|
_CDMStatus = value;
|
|
|
|
OnPropertyChanged(nameof(CDMStatus));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public DateTime RequestTime = DateTime.Now;
|
|
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
protected virtual void OnPropertyChanged(string propertyName)
|
|
{
|
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
|
|
}
|
|
}
|
|
public class DeviceStatus
|
|
{
|
|
public int TenantId { get; set; }
|
|
public string Device { get; set; }
|
|
public int Status { get; set; }
|
|
public DateTime DeviceTime { get; set; }
|
|
public int CDMStatus { get; set; }
|
|
public int PrinterStatus { get; set; }
|
|
public int SensorStatus { get; set; }
|
|
public int OtherError { get; set; }
|
|
public string? Notes { get; set; }
|
|
public string? TransactionCode { get; set; }
|
|
public string Description { get; set; }
|
|
}
|
|
public class DeviceStatusFile
|
|
{
|
|
public bool IsPrinterNearPaperOut = false;
|
|
public int PrintingCountFromNPO = 0;//Transaction Count From Near Paper Out
|
|
public bool IsStopPrinting()
|
|
{
|
|
if (IsPrinterNearPaperOut && PrintingCountFromNPO >= 50)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
public enum DeviceStatusCode {
|
|
NORMAL=0,
|
|
ERROR=1
|
|
}
|
|
public enum PrinterStatusCode
|
|
{
|
|
NORMAL = 0,
|
|
NEARPAPEROUT = 1,
|
|
PAPEROUT=2,
|
|
ERROR=3
|
|
}
|
|
public enum SensorStatusCode
|
|
{
|
|
NORMAL = 0,
|
|
ERROR = 4
|
|
}
|
|
public enum CDMStatusCode
|
|
{
|
|
NORMAL = 0,
|
|
DISCONNECT_SERIALPORT=1,
|
|
ERROR = 3,
|
|
}
|
|
}
|