HengshanPumpHandler.cs 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493
  1. using Edge.Core.IndustryStandardInterface.Pump;
  2. using Dfs.WayneChina.HengshanPayTerminal.MessageEntity.Outgoing;
  3. using System;
  4. using System.Collections.Generic;
  5. using System.Threading.Tasks;
  6. using Wayne.FDCPOSLibrary;
  7. namespace Dfs.WayneChina.HengshanPayTerminal
  8. {
  9. /// <summary>
  10. /// A neutral pump handler that represents a Hengshan pump regardless of its protocol (Hengshan or TQC).
  11. /// Actuall this is a fake pump handler since it doesn't have direct control over the pumps.
  12. /// </summary>
  13. public class HengshanPumpHandler : IFdcPumpController
  14. {
  15. #region Fields
  16. //The parent of the pump handler.
  17. private HengshanPayTermHandler terminalHandler;
  18. private LogicalDeviceState state = LogicalDeviceState.FDC_READY;
  19. //private SpsManager spsManager;
  20. private byte frameSqNo;
  21. private object syncObj = new object();
  22. private bool totalizerRequested = false;
  23. private byte totalizerRequestedNozzleLogicId = 0;
  24. private bool lockPumpRequested = false;
  25. private bool unlockPumpRequested = false;
  26. private LogicalNozzle nozzle;
  27. private List<LogicalNozzle> nozzleList;
  28. private List<int> siteNozzleNoList;
  29. #endregion
  30. #region Logger
  31. private static NLog.Logger logger = NLog.LogManager.LoadConfiguration("NLog.config").GetLogger("IPosPlusApp");
  32. #endregion
  33. #region Constructor
  34. public HengshanPumpHandler(HengshanPayTermHandler terminalHandler,string name, int pumpId, List<int> nozzles, List<int> siteNozzleNoList)
  35. {
  36. this.terminalHandler = terminalHandler;
  37. this.terminalHandler.OnCheckCommandReceived += TerminalHandler_OnCheckCommandReceived;
  38. Name = name;
  39. PumpId = pumpId;
  40. nozzle = new LogicalNozzle(pumpId, Convert.ToByte(pumpId), 1, null);
  41. //spsManager = new SpsManager();
  42. this.siteNozzleNoList = siteNozzleNoList;
  43. nozzleList = new List<LogicalNozzle>();
  44. foreach (var nozzleNo in nozzles)
  45. {
  46. var logicalNozzle = new LogicalNozzle(PumpId, Convert.ToByte(nozzleNo), Convert.ToByte(nozzleNo), null);
  47. nozzleList.Add(logicalNozzle);
  48. }
  49. }
  50. #endregion
  51. #region Properties
  52. public string Name { get; }
  53. public int PumpId { get; }
  54. public int PumpPhysicalId => 1;
  55. public IEnumerable<LogicalNozzle> Nozzles
  56. {
  57. get
  58. {
  59. //For Hengshan pumps, there is only one logical nozzle per pump, no real price set.
  60. return nozzleList;//return new List<LogicalNozzle> { nozzle };
  61. }
  62. }
  63. //Decimal digit settings, China domestic standard
  64. //小数点后位数设定,中国国内标准,一般为2位
  65. public int AmountDecimalDigits => 2;
  66. public int VolumeDecimalDigits => 2;
  67. public int PriceDecimalDigits => 2;
  68. public int VolumeTotalizerDecimalDigits => 2;
  69. public byte FrameSqNo
  70. {
  71. get
  72. {
  73. lock (syncObj)
  74. {
  75. return frameSqNo;
  76. }
  77. }
  78. set
  79. {
  80. lock (syncObj)
  81. {
  82. frameSqNo = value;
  83. }
  84. }
  85. }
  86. #endregion
  87. #region Events
  88. public event EventHandler<FdcPumpControllerOnStateChangeEventArg> OnStateChange;
  89. public event EventHandler<FdcTransactionDoneEventArg> OnCurrentFuellingStatusChange;
  90. public event EventHandler<FuelPriceChangeRequestEventArgs> OnFuelPriceChangeRequested;
  91. #endregion
  92. #region Event handlers
  93. private byte GetSiteNozzleNoByLogicId(byte logicId)
  94. {
  95. foreach (var nozzleNo in siteNozzleNoList)
  96. {
  97. if (terminalHandler.NozzleLogicIdDict[nozzleNo] == logicId)
  98. return Convert.ToByte(nozzleNo);
  99. }
  100. return Convert.ToByte(PumpId);
  101. }
  102. private void TerminalHandler_OnCheckCommandReceived(object sender, CheckCommandEventArgs e)
  103. {
  104. if (totalizerRequested
  105. && e.CheckCommandRequest.SourceAddress == terminalHandler.GetSubAddressForPump(PumpId))
  106. {
  107. var request = new ReadVolumeTotal
  108. {
  109. Prefix = 0xFA,
  110. SourceAddress = Convert.ToByte(terminalHandler.GetSubAddressForPump(PumpId)),
  111. DestinationAddress = Convert.ToByte(terminalHandler.GetSubAddressForPump(PumpId)),
  112. FrameSqNoByte = e.CheckCommandRequest.FrameSqNoByte,
  113. Handle = (byte)MessageEntity.Command.ReadVolumeTotalizer,
  114. NozzleNo = GetSiteNozzleNoByLogicId(totalizerRequestedNozzleLogicId)//Convert.ToByte(PumpId)
  115. };
  116. terminalHandler.PendMessage(request);
  117. Log("Request to terminal to get totalizer, pending!");
  118. }
  119. else if ((lockPumpRequested || unlockPumpRequested)
  120. && e.CheckCommandRequest.SourceAddress == terminalHandler.GetSubAddressForPump(PumpId))
  121. {
  122. LockOrUnlockPumpRequest request = new LockOrUnlockPumpRequest
  123. {
  124. Prefix = 0xFA,
  125. SourceAddress = Convert.ToByte(terminalHandler.GetSubAddressForPump(PumpId)),
  126. DestinationAddress = Convert.ToByte(terminalHandler.GetSubAddressForPump(PumpId)),
  127. Handle = Convert.ToByte(MessageEntity.Command.LockOrUnlockPump),
  128. FrameSqNoByte = e.CheckCommandRequest.FrameSqNoByte,
  129. FPCode = EncodeFPCodeString(PumpId, PumpId),
  130. OperationType = lockPumpRequested ? Support.LockUnlockOperation.Lock : Support.LockUnlockOperation.Unlock
  131. };
  132. terminalHandler.PendMessage(request);
  133. var currentPump = terminalHandler.PumpStatusDict.GetValueOrDefault(PumpId);
  134. if (currentPump == null)
  135. Log("Could not get the pump state holder");
  136. else
  137. Log($"Current pump state holder, pump no: {currentPump.PumpNo}");
  138. currentPump.OperationType = request.OperationType;
  139. Log($"Current pump state holder, operation type set to: {request.OperationType}");
  140. //terminalHandler.Write(request);
  141. if (lockPumpRequested)
  142. Log($"PumpNo: {PumpId}, Request to lock pump, pending!");
  143. if (unlockPumpRequested)
  144. Log($"PumpNo: {PumpId}, Request to unlock pump, pending!");
  145. }
  146. }
  147. public void FirePumpStateChange(LogicalDeviceState state, byte nozzeLogicId)
  148. {
  149. var logicalNozzle = new LogicalNozzle(PumpId, Convert.ToByte(PumpPhysicalId), nozzeLogicId, null);
  150. this.state = state;
  151. if (state == LogicalDeviceState.FDC_READY)
  152. OnStateChange?.Invoke(this, new FdcPumpControllerOnStateChangeEventArg(LogicalDeviceState.FDC_READY));
  153. else
  154. OnStateChange?.Invoke(this, new FdcPumpControllerOnStateChangeEventArg(state, logicalNozzle));
  155. }
  156. public void FireNozzleStateChange(LogicalDeviceState? state)
  157. {
  158. nozzle = new LogicalNozzle(PumpId, Convert.ToByte(PumpPhysicalId), 1, null);
  159. if (state.HasValue)
  160. nozzle.LogicalState = state;
  161. else
  162. nozzle.LogicalState = null;
  163. OnStateChange?.Invoke(this, new FdcPumpControllerOnStateChangeEventArg(LogicalDeviceState.FDC_READY, nozzle));
  164. }
  165. //2023-08-22 状态变更
  166. public void FireFuelingStatusChange(FdcTransaction fuelingTransaction)
  167. {
  168. OnCurrentFuellingStatusChange?.Invoke(this, new FdcTransactionDoneEventArg(fuelingTransaction));
  169. }
  170. #endregion
  171. #region Pump interactions
  172. public LogicalDeviceState QueryStatus()
  173. {
  174. var stateHolder = terminalHandler.PumpStatusDict.GetValueOrDefault(PumpId);
  175. if (stateHolder != null)
  176. {
  177. if (stateHolder.State.DispenserState == 3)
  178. {
  179. return LogicalDeviceState.FDC_READY;
  180. }
  181. else if (stateHolder.State.DispenserState == 2)
  182. {
  183. return LogicalDeviceState.FDC_LOCKED;
  184. }
  185. }
  186. return LogicalDeviceState.FDC_READY;
  187. }
  188. /// <summary>
  189. /// locks a nozzle
  190. /// </summary>
  191. /// <param name="logicalNozzleId"></param>
  192. /// <returns></returns>
  193. public Task<bool> LockNozzleAsync(byte logicalNozzleId)
  194. {
  195. var stateHolder = terminalHandler.PumpStatusDict.GetValueOrDefault(PumpId);
  196. if (stateHolder != null)
  197. {
  198. if (stateHolder.State.DispenserState == 2)
  199. {
  200. // If the pump is already locked, reply with success immediately.
  201. return Task.FromResult(true);
  202. }
  203. else if (stateHolder.State.DispenserState != 3)
  204. {
  205. // Avoid handling locking when pump is fueling or in other states.
  206. return Task.FromResult(false);
  207. }
  208. }
  209. TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();
  210. EventHandler<LockUnlockEventArgs> eventHandler = null;
  211. eventHandler += (o, e) =>
  212. {
  213. Log($"Locking pump, result received, success? {e.Result}");
  214. lockPumpRequested = false;
  215. tcs.SetResult(e.Result);
  216. if (e.Result)
  217. {
  218. FireNozzleStateChange(LogicalDeviceState.FDC_LOCKED);
  219. }
  220. terminalHandler.OnLockUnlockCompleted -= eventHandler;
  221. var currentPump = terminalHandler.PumpStatusDict.GetValueOrDefault(PumpId);
  222. if (currentPump != null)
  223. {
  224. currentPump.OperationType = Support.LockUnlockOperation.None;
  225. }
  226. };
  227. terminalHandler.OnLockUnlockCompleted += eventHandler;
  228. lockPumpRequested = true;
  229. return tcs.Task;
  230. }
  231. /// <summary>
  232. /// unlock a locked nozzle
  233. /// </summary>
  234. /// <param name="logicalNozzleId"></param>
  235. /// <returns></returns>
  236. public Task<bool> UnlockNozzleAsync(byte logicalNozzleId)
  237. {
  238. var stateHolder = terminalHandler.PumpStatusDict.GetValueOrDefault(PumpId);
  239. if (stateHolder != null)
  240. {
  241. if (stateHolder.State.DispenserState == 3)
  242. {
  243. // Need to do nothing when pump is not locked.
  244. return Task.FromResult(true);
  245. }
  246. }
  247. TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();
  248. EventHandler<LockUnlockEventArgs> eventHandler = null;
  249. eventHandler += (o, e) =>
  250. {
  251. Log($"Unlocking pump, result received, success? {e.Result}");
  252. unlockPumpRequested = false;
  253. tcs.SetResult(e.Result);
  254. if (e.Result)
  255. {
  256. FireNozzleStateChange(null);
  257. }
  258. terminalHandler.OnLockUnlockCompleted -= eventHandler;
  259. var currentPump = terminalHandler.PumpStatusDict.GetValueOrDefault(PumpId);
  260. if(currentPump!= null)
  261. {
  262. currentPump.OperationType = Support.LockUnlockOperation.None;
  263. }
  264. };
  265. terminalHandler.OnLockUnlockCompleted += eventHandler;
  266. unlockPumpRequested = true;
  267. return tcs.Task;
  268. }
  269. #endregion
  270. #region FDC Server Init
  271. public void OnFdcServerInit(Dictionary<string, object> parameters)
  272. {
  273. }
  274. public Task<LogicalDeviceState> QueryStatusAsync()
  275. {
  276. return Task.FromResult(state);
  277. }
  278. public void QueryTotalizerAsync(int pumpId, byte logicalNozzleId)
  279. {
  280. Log($"Query totalizer internally...");
  281. var request = new ReadVolumeTotal
  282. {
  283. Prefix = 0xFA,
  284. SourceAddress = Convert.ToByte(pumpId),
  285. DestinationAddress = Convert.ToByte(pumpId),
  286. FrameSqNoByte = frameSqNo,
  287. Handle = (byte)MessageEntity.Command.ReadVolumeTotalizer,
  288. NozzleNo = logicalNozzleId
  289. };
  290. terminalHandler.Write(request);
  291. }
  292. public Task<Tuple<int, int>> QueryTotalizerAsync(byte logicalNozzleId)
  293. {
  294. Log($"LogicalNozzle {logicalNozzleId} querying totalizer...");
  295. TaskCompletionSource<Tuple<int, int>> tcs = new TaskCompletionSource<Tuple<int, int>>();
  296. EventHandler<TotalizerDataEventArgs> eventHandler = null;
  297. eventHandler += (o, e) =>
  298. {
  299. Log($"Totalizer data for nozzle: {e.NozzleNo}, money acc: {e.Totalizer.Item1}, volume acc: {e.Totalizer.Item2}");
  300. totalizerRequested = false; //Reset the value so that no more request will be sent.
  301. if (e.NozzleNo == GetSiteNozzleNoByLogicId(logicalNozzleId))
  302. {
  303. Log("Totalizer data ready");
  304. tcs.SetResult(e.Totalizer);
  305. terminalHandler.OnTotalizerReceived -= eventHandler;
  306. }
  307. totalizerRequestedNozzleLogicId = 0;
  308. };
  309. terminalHandler.OnTotalizerReceived += eventHandler;
  310. totalizerRequestedNozzleLogicId = logicalNozzleId;
  311. totalizerRequested = true;
  312. return tcs.Task;
  313. }
  314. public Task<bool> ChangeFuelPriceAsync(int newPriceWithoutDecimalPoint, byte logicalNozzleId)
  315. {
  316. logger.Info($"Change price received, Pump {PumpId}, LogicalNozzle {logicalNozzleId}, Price {newPriceWithoutDecimalPoint}");
  317. //Let the iPOS App handle the fuel price change.
  318. OnFuelPriceChangeRequested?.Invoke(this, new FuelPriceChangeRequestEventArgs
  319. {
  320. NozzleId = logicalNozzleId,
  321. PumpId = (byte)PumpId,
  322. Price = newPriceWithoutDecimalPoint
  323. });
  324. Log($"application handled fuel price change");
  325. return Task.FromResult(true);
  326. //TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();
  327. //EventHandler<FuelPriceDownloadRequestedEventArgs> eventHandler = null;
  328. //eventHandler += (o, e) =>
  329. //{
  330. // Log("Terminal requested fuel price");
  331. // tcs.SetResult(e.Requested);
  332. // terminalHandler.OnTerminalFuelPriceDownloadRequested -= eventHandler;
  333. //};
  334. //terminalHandler.OnTerminalFuelPriceDownloadRequested += eventHandler;
  335. //return tcs.Task;
  336. }
  337. public Task<bool> AuthorizeAsync(byte logicalNozzleId)
  338. {
  339. return Task.FromResult(false);
  340. }
  341. public Task<bool> UnAuthorizeAsync(byte logicalNozzleId)
  342. {
  343. return Task.FromResult(false);
  344. }
  345. public Task<bool> AuthorizeWithAmountAsync(int moneyAmountWithoutDecimalPoint, byte logicalNozzleId)
  346. {
  347. return Task.FromResult(false);
  348. }
  349. public Task<bool> AuthorizeWithVolumeAsync(int volumnWithoutDecimalPoint, byte logicalNozzleId)
  350. {
  351. return Task.FromResult(false);
  352. }
  353. public Task<bool> FuelingRoundUpByAmountAsync(int amount)
  354. {
  355. return Task.FromResult(false);
  356. }
  357. public Task<bool> FuelingRoundUpByVolumeAsync(int volume)
  358. {
  359. return Task.FromResult(false);
  360. }
  361. public Task<bool> SuspendFuellingAsync()
  362. {
  363. return Task.FromResult(false);
  364. }
  365. public Task<bool> ResumeFuellingAsync()
  366. {
  367. return Task.FromResult(false);
  368. }
  369. #endregion
  370. private string EncodeFPCodeString(int nozzleId, int pumpId)
  371. {
  372. return nozzleId.ToString("X").PadLeft(2, '0') + pumpId.ToString("X").PadLeft(2, '0');
  373. }
  374. #region Log
  375. private void Log(string message)
  376. {
  377. logger.Info($"Pump Handler: {PumpId}, {message}");
  378. }
  379. #endregion
  380. }
  381. }