public byte[] Send(IDeviceMessage message) { if (OnMessageSent != null) { OnMessageSent(message.ToString()); } try { string payload = Convert.ToBase64String(message.GetSendBuffer()); _client = HttpWebRequest.Create(string.Format("http://{0}:{1}?{2}", _settings.IpAddress, _settings.Port, payload)); var response = (HttpWebResponse)_client.GetResponse(); var buffer = new List <byte>(); using (var sr = new StreamReader(response.GetResponseStream())) { var rec_buffer = sr.ReadToEnd(); foreach (char c in rec_buffer) { buffer.Add((byte)c); } } return(buffer.ToArray()); } catch (Exception exc) { throw new HpsMessageException("Failed to send message. Check inner exception for more details.", exc); } }
public byte[] Send(IDeviceMessage message) { OnMessageSent?.Invoke(message.ToString()); try { string payload = Convert.ToBase64String(message.GetSendBuffer()); return(Task.Run(async() => { _client = HttpWebRequest.Create(string.Format("http://{0}:{1}?{2}", _settings.IpAddress, _settings.Port, payload)); var response = await _client.GetResponseAsync(); var buffer = new List <byte>(); using (var sr = new StreamReader(response.GetResponseStream())) { var rec_buffer = await sr.ReadToEndAsync(); foreach (char c in rec_buffer) { buffer.Add((byte)c); } } return buffer.ToArray(); }).Result); } catch (Exception exc) { throw new MessageException("Failed to send message. Check inner exception for more details.", exc); } }
public byte[] Send(IDeviceMessage message) { Connect(); var str_message = message.ToString(); message_queue = new List <byte>(); try { byte[] buffer = message.GetSendBuffer(); OnMessageSent?.Invoke(message.ToString().Substring(2)); if (_stream != null) { _stream.Write(buffer, 0, buffer.Length); _stream.Flush(); var task = BeginReceiveTask(); if (!task.Wait(_settings.Timeout)) { throw new MessageException("Device did not respond within the timeout."); } return(message_queue.ToArray()); } else { throw new MessageException("Device not connected."); } } finally { Disconnect(); } }
public byte[] Send(IDeviceMessage message) { byte[] buffer = message.GetSendBuffer(); Connect(); try { for (int i = 0; i < 3; i++) { _stream.WriteAsync(buffer, 0, buffer.Length).Wait(); var rvalue = _stream.GetTerminalResponseAsync(); if (rvalue != null) { byte lrc = rvalue[rvalue.Length - 1]; // Should be the LRC if (lrc != TerminalUtilities.CalculateLRC(rvalue)) { SendControlCode(ControlCodes.NAK); } else { SendControlCode(ControlCodes.ACK); return(rvalue); } } } throw new MessageException("Terminal did not respond in the given timeout."); } catch (Exception exc) { throw new MessageException(exc.Message, exc); } finally { OnMessageSent?.Invoke(message.ToString()); Disconnect(); } }
public byte[] Send(IDeviceMessage message) { try { if (_serialPort != null) { _transComplete = false; _exit = false; string bufferSend = Encoding.ASCII.GetString(message.GetSendBuffer()); OnMessageSent?.Invoke(bufferSend.Substring(1, bufferSend.Length - 3)); Task <bool> task = WriteMessage(message); lock (_lock) { while (!_transComplete) { if (!Monitor.Wait(_lock, _settings.Timeout)) { _exit = true; _transComplete = true; throw new ApiException("Terminal did not respond within timeout."); } } } return(_messageResponse.ToArray()); } else { throw new ConfigurationException("Terminal not connected."); } } catch (ApiException e) { throw new ApiException(e.Message); } }
internal byte[] Send(IDeviceMessage message) { byte[] buffer = message.GetSendBuffer(); bool timedOut = false; Connect(PrimaryEndpoint, PrimaryPort); try { for (int i = 0; i < 2; i++) { DateTime requestSent = DateTime.UtcNow; if (client != null && client.Connected && sslStream.IsAuthenticated) { sslStream.Write(buffer, 0, buffer.Length); sslStream.Flush(); } byte[] rvalue = GetGatewayResponse(); if (rvalue != null && !ForceGatewayTimeout) { return(rvalue); } // did not get a response, switch endpoints and try again timedOut = true; if (!currentEndpoint.Equals("secondary") && !string.IsNullOrEmpty(SecondaryEndpoint) && i < 1) { Disconnect(); Connect(SecondaryEndpoint, SecondaryPort); } } throw new GatewayTimeoutException(); } catch (GatewayTimeoutException exc) { exc.GatewayEvents = events; throw exc; } catch (Exception exc) { if (timedOut) { GatewayTimeoutException gatewayException = new GatewayTimeoutException(exc) { GatewayEvents = events }; throw gatewayException; } else { GatewayException gatewayException = new GatewayException("Failed to connect to primary or secondary processing endpoints.", exc); throw gatewayException; } } finally { Disconnect(); // remove the force timeout if (ForceGatewayTimeout) { ForceGatewayTimeout = false; } } }
public byte[] Send(IDeviceMessage message) { byte[] buffer = message.GetSendBuffer(); ControlCodes?code = null; OnControlCodeReceived += (rec_code) => { code = rec_code; _await.Set(); }; byte[] rvalue = null; OnMessageReceived += (rec_buffer) => { rvalue = rec_buffer; _await.Set(); }; for (int i = 0; i < 3; i++) { _stream.Write(buffer, 0, buffer.Length); if (OnMessageSent != null) { OnMessageSent(message.ToString()); } _await.WaitOne(1000); if (!code.HasValue) { throw new HpsMessageException("Terminal did not respond in the given timeout."); } if (code == ControlCodes.NAK) { continue; } else if (code == ControlCodes.EOT) { throw new HpsMessageException("Terminal returned EOT for the current message."); } else if (code == ControlCodes.ACK) { _await.WaitOne(_settings.TimeOut); break; } else { throw new HpsMessageException(string.Format("Unknown message received: {0}", code)); } } return(rvalue); }
private async Task <GatewayResponse> StageTransactionAsync(IDeviceMessage message) { try { string payload = Encoding.UTF8.GetString(message.GetSendBuffer()); string url = ServiceEndpoints.GENIUS_TERMINAL_TEST; if (_gatewayConfig.Environment.Equals(Entities.Environment.PRODUCTION)) { url = ServiceEndpoints.GENIUS_TERMINAL_PRODUCTION; } HttpClient httpClient = new HttpClient { Timeout = TimeSpan.FromMilliseconds(_settings.Timeout) }; HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, url); request.Headers.Add("SOAPAction", "http://transport.merchantware.net/v4/CreateTransaction"); HttpResponseMessage response = null; try { request.Content = new StringContent(payload, Encoding.UTF8, "text/xml"); response = await httpClient.SendAsync(request); return(new GatewayResponse { StatusCode = response.StatusCode, RequestUrl = response.RequestMessage.RequestUri.ToString(), RawResponse = response.Content.ReadAsStringAsync().Result }); } catch (Exception exc) { throw new GatewayException("Error occurred while communicating with gateway.", exc); } } catch (Exception exc) { throw new MessageException("Failed to send message. Check inner exception for more details.", exc); } }
public byte[] Send(IDeviceMessage message) { byte[] buffer = message.GetSendBuffer(); _termResponse = null; _bufferSend = false; _isResponseNeeded = true; try { // Validate if server is starting if (!_listener.Active) { throw new ConfigurationException("Server is not running."); } // Validate keep alive for setting of timeout during Transaction _stream.ReadTimeout = _settings.Timeout; if (_ipAddresses.Count > 0 || _client.Connected) { _stream.WriteAsync(buffer, 0, buffer.Length).Wait(); _bufferSend = true; if (_settings.ConnectionMode.Equals(ConnectionModes.PAY_AT_TABLE)) { string data = Encoding.UTF8.GetString(buffer); OnMessageSent?.Invoke(data.Substring(1, data.Length - 3)); return(null); } OnMessageSent?.Invoke(Encoding.UTF8.GetString(RemoveHeader(buffer))); while (_termResponse == null) { Thread.Sleep(100); if (_receivingException != null) { Exception ex = _receivingException; _receivingException = null; throw ex; } if (_termResponse != null) { // Remove timeout for stream read if (!_isKeepAlive) { _stream.ReadTimeout = -1; } _isResponseNeeded = false; _receivingException = null; } } return(_termResponse); } else { throw new ConfigurationException("No terminal connected to server."); } } catch (Exception ex) { throw new ApiException(ex.Message); } }
public byte[] Send(IDeviceMessage message) { byte[] buffer = message.GetSendBuffer(); var readyReceived = false; byte[] responseMessage = null; Connect(); try { var task = _stream.WriteAsync(buffer, 0, buffer.Length); if (!task.Wait(_settings.Timeout)) { throw new MessageException("Terminal did not respond in the given timeout."); } do { var rvalue = _stream.GetTerminalResponseAsync(); if (rvalue != null) { var msgValue = GetResponseMessageType(rvalue); switch (msgValue) { case UpaMessageType.Ack: break; case UpaMessageType.Nak: break; case UpaMessageType.Ready: readyReceived = true; break; case UpaMessageType.Busy: break; case UpaMessageType.TimeOut: break; case UpaMessageType.Msg: responseMessage = TrimResponse(rvalue); if (IsNonReadyResponse(responseMessage)) { readyReceived = true; // since reboot doesn't return READY } SendAckMessageToDevice(); break; default: throw new Exception("Message field value is unknown in API response."); } } else { // Reset the connection before the next attempt Disconnect(); Connect(); } } while (!readyReceived); return(responseMessage); } catch (Exception exc) { throw new MessageException(exc.Message, exc); } finally { OnMessageSent?.Invoke(message.ToString()); Disconnect(); } }
private async Task <bool> WriteMessage(IDeviceMessage message) { return(await Task.Run(() => { try { int enquiryCount = 0; _messageResponse = new List <byte>(); if (_serialPort == null) { return false; } do { _serialPort.Write(BitConverter.GetBytes((char)ControlCodes.ENQ), 0, 1); if (!_isAcknowledge) { Thread.Sleep(1000); _serialPort.Write(BitConverter.GetBytes((char)ControlCodes.EOT), 0, 1); enquiryCount++; if (enquiryCount.Equals(3)) { throw new MessageException("Terminal did not respond in enquiry for three (3) times. Send aborted."); } } else { do { byte[] msg = message.GetSendBuffer(); foreach (byte b in msg) { byte[] _b = new byte[] { b }; _serialPort.Write(_b, 0, 1); } if (_isAcknowledge) { _serialPort.Write(BitConverter.GetBytes((char)ControlCodes.EOT), 0, 1); _isAcknowledge = false; break; } } while (true); do { Thread.Sleep(100); if (_isBroadcast) { byte[] bMsg = Encoding.ASCII.GetBytes(_bufferReceived); BroadcastMessage broadcastMsg = new BroadcastMessage(bMsg); OnBroadcastMessage?.Invoke(broadcastMsg.Code, broadcastMsg.Message); _isBroadcast = false; } if (_isXML) { while (!_transComplete) { if (_report.ToString().Contains(INGENICO_RESP.ENDXML)) { string xmlData = _report.ToString().Substring(1, _report.ToString().Length - 3); if (MessageReceived(xmlData)) { _serialPort.Write(BitConverter.GetBytes((char)ControlCodes.ACK), 0, 1); _report = new StringBuilder(); _isXML = false; _transComplete = true; } } else { _report.Append(_bufferReceived); } Thread.Sleep(0500); } ; } if (_isResult) { string check = Encoding.UTF8.GetString(message.GetSendBuffer()); string refNumber = check.Substring(0, 2); if (_bufferReceived.Contains(refNumber)) { do { string responseData = _bufferReceived.Substring(1, _bufferReceived.Length - 3); string actualReceived = _bufferReceived.Substring(1, _bufferReceived.Length - 3); bool validateLRC = ValidateResponseLRC(responseData, actualReceived); if (validateLRC) { if (MessageReceived(responseData)) { _serialPort.Write(BitConverter.GetBytes((char)ControlCodes.ACK), 0, 1); _isResult = false; _transComplete = true; } } } while (!_transComplete); } } } while (!_transComplete); return _transComplete; } } while (true); } catch (ApiException e) { throw new ApiException(e.Message); } })); }