public void StartListener(List<SourceNode> sourceNodes)
{
foreach (var theSourceNode in sourceNodes)
{
Console.WriteLine("Initializing Listener on..." + theSourceNode.IPAddress + "\t" + theSourceNode.Port);
Logger.Log("Initializing Listener on... " + theSourceNode.IPAddress + "\t" + theSourceNode.Port);
string ipAddress = theSourceNode.IPAddress;
int port = Convert.ToInt32(theSourceNode.Port);
TcpListener tcpListener = new TcpListener(port);
tcpListener.LocalInterface = ipAddress;
tcpListener.Start();
ListenerPeer listener = new ListenerPeer(theSourceNode.Id.ToString(), new TwoBytesNboHeaderChannel
(new Iso8583Ascii1987BinaryBitmapMessageFormatter(), ipAddress, port),
new BasicMessagesIdentifier(11, 41), tcpListener);
Logger.Log("Source: " + theSourceNode.Name + " listening at " + ipAddress + " on " + port);
listener.Connected += new PeerConnectedEventHandler(listenerPeerConnected);
listener.Receive += new PeerReceiveEventHandler(Listener_Receive);
listener.Disconnected += new PeerDisconnectedEventHandler(listenerPeerDisconnected);
theSourceNode.IsActive = true;
new SourceNodeManager().Update(theSourceNode);
}
}
private static Iso8583Message PerformReversal(Iso8583Message message, ListenerPeer listener)
{
var STAN = ExtractSTAN(message);
message = SetFee(message, 0);
var transactionsToReverse = _context.TransactionLogs.Where(c => c.STAN.Equals(STAN) && !c.Narration.Equals("Reversal")).ToList();
try
{
string responseCode = null;
if (transactionsToReverse != null || transactionsToReverse.Count > 0)
{
foreach (var transaction in transactionsToReverse)
{
if (!transaction.Narration.Equals("Balance Enquiry"))
{
if (transaction.TypeOfEntry.Equals("Debit"))
{
if (transaction.Account2 == null)
{
bool remote1 = false;
if (transaction.RemoteOnUs == true)
{
remote1 = true;
}
responseCode = CBA.PerformDoubleEntry("Credit", transaction.Account1, transaction.Amount, remote1);
var isoAmt = Convert.ToDouble(FormatTo2Dp(Convert.ToDecimal(transaction.Amount))) * 100;
message.Fields.Add(4, isoAmt.ToString().PadLeft(10, '0'));
new TransactionLogger().LogTransaction(message, "Credit", "Reversal");
transaction.STAN = transaction.STAN + "R";
continue;
}
}
bool remote = false;
if (transaction.RemoteOnUs == true)
{
remote = true;
}
responseCode = CBA.PerformDoubleEntry("Debit", transaction.Account1, transaction.Amount, remote);
var isoAmount = Convert.ToDouble(FormatTo2Dp(Convert.ToDecimal(transaction.Amount))) * 100;
message.Fields.Add(4, isoAmount.ToString().PadLeft(10, '0'));
new TransactionLogger().LogTransaction(message, "Debit", "Reversal");
transaction.STAN = transaction.STAN + "R";
}
}
_context.SaveChanges();
message = SetResponseMessage(message, responseCode);
message = SendResponseMessage(listener, message);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
return(message);
}
static void Listener_Receive(object sender, ReceiveEventArgs e)
{
//Cast event sender as ClientPeer
ListenerPeer sourcePeer = sender as ListenerPeer;
// Get source node from client - client Name = SourceNode ID
long sourceID = Convert.ToInt64(sourcePeer.Name); //wher message is coming from
//then use the ID to retrieve the source node
//Get the Message received
Iso8583Message originalMessage = e.Message as Iso8583Message;
//continue coding
SourceNode sourceNode = new SourceNode
{
Name = ConfigurationSettings.AppSettings["NodeNameTroughSwitch"],
IPAddress = ConfigurationSettings.AppSettings["NodeIPThroughSwitch"],
Port = ConfigurationSettings.AppSettings["NodePortThroughSwitch"]
};
CheckSourceNode checkSourceNode = new CheckSourceNode();
//checkSourceNode.SourceNode(sourceNode, originalMessage);
checkSourceNode.SourceNode(originalMessage);
//originalMessage.SetResponseMessageTypeIdentifier();
sourcePeer.Send(originalMessage);
sourcePeer.Listener.Start();
}
public void StartListener(List <SourceNode> sourceNodes)
{
foreach (var theSourceNode in sourceNodes)
{
Console.WriteLine("Initializing Listener on..." + theSourceNode.IPAddress + "\t" + theSourceNode.Port);
Logger.Log("Initializing Listener on... " + theSourceNode.IPAddress + "\t" + theSourceNode.Port);
string ipAddress = theSourceNode.IPAddress;
int port = Convert.ToInt32(theSourceNode.Port);
TcpListener tcpListener = new TcpListener(port);
tcpListener.LocalInterface = ipAddress;
tcpListener.Start();
ListenerPeer listener = new ListenerPeer(theSourceNode.Id.ToString(), new TwoBytesNboHeaderChannel
(new Iso8583Ascii1987BinaryBitmapMessageFormatter(), ipAddress, port),
new BasicMessagesIdentifier(11, 41), tcpListener);
Logger.Log("Source: " + theSourceNode.Name + " listening at " + ipAddress + " on " + port);
listener.Connected += new PeerConnectedEventHandler(listenerPeerConnected);
listener.Receive += new PeerReceiveEventHandler(Listener_Receive);
listener.Disconnected += new PeerDisconnectedEventHandler(listenerPeerDisconnected);
theSourceNode.IsActive = true;
new SourceNodeManager().Update(theSourceNode);
}
}
public Iso8583Message ProcessTransaction(Iso8583Message message, ListenerPeer listener)
{
if (message != null)
{
if (!message.IsReversalOrChargeBack())
{
message = CheckIfFeeApplies(message);
var fee = ExtractFee(message);
var trxType = ExtractTransactionType(message);
var accountNumber = ExtractAccountNumber(message);
var amount = ExtractAmount(message);
var STAN = ExtractSTAN(message);
var RRN = ExtractRRN(message);
if (trxType.ToString().Equals(Codes.WITHDRAWAL) || trxType.ToString().Equals(Codes.PAYMENT))
{
if (accountNumber != null && amount != null)
{
if (trxType.ToString().Equals(Codes.PAYMENT))
{
}
var responseCode = CBA.PerformDoubleEntry("Debit", accountNumber, (amount + fee), CheckIfRemote(message));
message = SetResponseMessage(message, responseCode);
message = SendResponseMessage(listener, message);
if (!message.Fields[39].Value.ToString().Equals(Codes.APPROVED))
{
Debug.WriteLine("Transaction Incomplete ...");
}
else
{
new TransactionLogger().LogTransaction(message, "Debit", "Request");
Debug.WriteLine("Transaction Complete ...");
}
}
}
else if (trxType.ToString().Equals(Codes.BALANCE_ENQUIRY))
{
var amountEnquired = CBA.BalanceEnquiry(accountNumber);
if (amountEnquired != null)
{
message.Fields.Add(54, amountEnquired);
message.Fields.Add(4, "0000000000");
SetResponseMessage(message, Codes.APPROVED);
message = SendResponseMessage(listener, message);
new TransactionLogger().LogTransaction(message, null, "Balance Enquiry");
}
}
return(message);
}
if (message.IsReversalOrChargeBack())
{
message = PerformReversal(message, listener);
}
}
return(message);
}
private void ListenerPeerConnected(object sender, EventArgs e)
{
ListenerPeer listenerPeer = sender as ListenerPeer;
if (listenerPeer == null)
{
return;
}
//logger.Log("Listener Peer connected to " + listenerPeer.Name);
}
private void listenerPeerConnected(object sender, EventArgs e)
{
ListenerPeer peer = sender as ListenerPeer;
Logger.Log("Connected to ==> " + peer.Name);
if (peer == null)
{
return;
}
}
private void ListenerPeerDisconnected(object sender, EventArgs e)
{
ListenerPeer listenerPeer = sender as ListenerPeer;
if (listenerPeer == null)
{
return;
}
//logger.Log("Listener Peer disconnected from " + listenerPeer.Name);
StartListener();
}
private static Iso8583Message SendResponseMessage(ListenerPeer listenerPeer, Iso8583Message message)
{
bool needReversal = false;
int maxNumberOfEntries = 3;
Message response = null;
int serverTimeOut = 60000;
PeerRequest request = null;
try
{
if (listenerPeer.IsConnected)
{
request = new PeerRequest(listenerPeer, message);
request.Send();
request.WaitResponse(serverTimeOut);
if (request.Expired)
{
//logger.Log("Connection timeout.");
needReversal = true;
return(SetResponseMessage(message, "68")); //Response received too late
}
if (request != null)
{
response = request.ResponseMessage;
//logger.Log("Message Recieved From FEP");
}
//
//request.MarkAsExpired(); //uncomment to test timeout
return(response as Iso8583Message);
}
else
{
//logger.Log("Could not connect to Sink Node");
//clientPeer.Close();
listenerPeer.Close();
Console.WriteLine("Client Peer is not Connected");
return(SetResponseMessage(message, "91"));
}
//clientPeer.Close();
}
catch (Exception e)
{
//logger.Log("An error occured " + e.Message);
return(SetResponseMessage(message, "06"));
}
}
private void listenerPeerDisconnected(object sender, EventArgs e)
{
List <SourceNode> SourceNodes = new List <SourceNode>();
ListenerPeer peer = sender as ListenerPeer;
if (peer == null)
{
return;
}
Logger.Log("(Event) Source server disconnected from: " + peer.Name);
SourceNode sourceNode = new SourceNodeManager().GetByID(Convert.ToInt32(peer.Name));
SourceNodes.Add(sourceNode);
StartListener(SourceNodes);
}
public static void ListenerPeer(SourceNode sourceNode) //create conn
{
TcpListener tcpListener = new TcpListener(Convert.ToInt32(sourceNode.Port));
tcpListener.LocalInterface = sourceNode.IPAddress;
ListenerPeer listener = new ListenerPeer(sourceNode.Id.ToString(),
new TwoBytesNboHeaderChannel(new Iso8583Ascii1987BinaryBitmapMessageFormatter()),
new BasicMessagesIdentifier(11, 41),
tcpListener);
listener.Receive += new PeerReceiveEventHandler(Listener_Receive);
listener.Connected += listener_Connected;
listener.Connect();
Console.WriteLine("Listening for connection.. on " + sourceNode.Port);
}
public static void StartUpListener(string name, string hostName, int port) //create conn
{
Trx.Messaging.FlowControl.TcpListener tcpListener = new Trx.Messaging.FlowControl.TcpListener(port);
tcpListener.LocalInterface = hostName;
ListenerPeer listener = new ListenerPeer(name,
new TwoBytesNboHeaderChannel(new Iso8583Ascii1987BinaryBitmapMessageFormatter()),
new BasicMessagesIdentifier(11, 41),
tcpListener);
listener.Receive += new PeerReceiveEventHandler(Listener_Receive);
listener.Connected += new PeerConnectedEventHandler(Listener_Connected);
listener.Disconnected += new PeerDisconnectedEventHandler(Listener_Disconnected);
listener.Connect();
//Console.WriteLine("Waiting for connection...");
}
static void Listener_Receive(object sender, ReceiveEventArgs e)
{
Console.WriteLine("Listener Received is called.");
//Cast event sender as ClientPeer
ListenerPeer sourcePeer = sender as ListenerPeer;
// Get source node from client - client Name = SourceNode ID
long sourceID = Convert.ToInt64(sourcePeer.Name); //wher message is coming from
//then use the ID to retrieve the source node
//Get the Message received
Iso8583Message originalMessage = e.Message as Iso8583Message;
//continue coding
}
public void StartListener(SourceNode node)
{
TcpListener tcpListener = new TcpListener(node.Port);
tcpListener.LocalInterface = node.IPAddress;
ListenerPeer listener = new ListenerPeer(node.Id.ToString(),
new TwoBytesNboHeaderChannel(new Iso8583Ascii1987BinaryBitmapMessageFormatter()),
new BasicMessagesIdentifier(11, 41),
tcpListener);
// ListenerPeer
listener.Error += (sender, e) => ErrorListener(sender, e);
listener.Receive += (sender, e) => ReceiveListener(sender, e, node);
listener.Disconnected += (sender, e) => DisconnectListener(sender, node);
listener.Connect();
Console.WriteLine($"Now listening to {node.Name} on IP {node.IPAddress} port {node.Port}");
}
private void ListenerPeerReceive(object sender, ReceiveEventArgs e)
{
ListenerPeer listenerPeer = sender as ListenerPeer;
Iso8583Message message = e.Message as Iso8583Message;
if (message == null)
{
return;
}
//logger.Log("Receiving Message >>>>");
Processor processor = new Processor();
Iso8583Message response;
try
{
processor.LogTransaction(message);
if (message.IsReversalOrChargeBack())
{
response = processor.Process(message);
}
else
{
response = processor.Process(message);
}
processor.LogTransaction(response);
//logger.Log("Sending Response >>>>");
}
catch (Exception ex)
{
message.Fields.Add(39, "06");
message.SetResponseMessageTypeIdentifier();
processor.LogTransaction(message);
response = message;
//processor.LogTransaction(response);
//logger.Log("Error, Something went wrong somewhere");
}
listenerPeer.Send(response);
listenerPeer.Close();
listenerPeer.Dispose();
}
public void StartListener(string ipAddress, int port, string id)
{
TcpListener tcpListener = new TcpListener(port);
tcpListener.LocalInterface = ipAddress;
ListenerPeer listener = new ListenerPeer(id,
new TwoBytesNboHeaderChannel(new Iso8583Ascii1987BinaryBitmapMessageFormatter()),
new BasicMessagesIdentifier(11, 41),
tcpListener);
// ListenerPeer
listener.Error += (sender, e) => ErrorListener(sender, e);
listener.Receive += (sender, e) => ReceiveListener(sender, e);
listener.Disconnected += (sender, e) => DisconnectListener(sender);
listener.Connect();
Debug.WriteLine($"Now listening on IP {ipAddress} port {port}");
}
public void StartListener()
{
TcpListener tcpListener = new TcpListener(port);
tcpListener.LocalInterface = localInterface;
tcpListener.Start();
ListenerPeer listenerPeer = new ListenerPeer("Switch", new TwoBytesNboHeaderChannel(
new Iso8583Ascii1987BinaryBitmapMessageFormatter()), tcpListener);
//logger.Log("Phantom FEP now listening at " + localInterface + " on " + port);
listenerPeer.Connected += new PeerConnectedEventHandler(ListenerPeerConnected);
listenerPeer.Receive += new PeerReceiveEventHandler(ListenerPeerReceive);
listenerPeer.Disconnected += new PeerDisconnectedEventHandler(ListenerPeerDisconnected);
listenerPeer.Connect();
}
public InstantiateListenerPeer()
{
SourceNode sourceNode = new SourceNode
{
Name = ConfigurationSettings.AppSettings["NodeNameThroughSwitch"],
IPAddress = ConfigurationSettings.AppSettings["NodeIPThroughSwitch"],
Port = ConfigurationSettings.AppSettings["NodePortThroughSwitch"]
};
TcpListener tcpListener = new TcpListener(int.Parse(sourceNode.Port));
tcpListener.LocalInterface = sourceNode.IPAddress;
ListenerPeer listener = new ListenerPeer(sourceNode.Id.ToString(), new TwoBytesNboHeaderChannel
(new Iso8583Ascii1987BinaryBitmapMessageFormatter(), sourceNode.IPAddress, int.Parse(sourceNode.Port)),
new BasicMessagesIdentifier(11, 41), tcpListener);
listener.Receive += new PeerReceiveEventHandler(Listener_Receive);
Console.WriteLine("Listening on Source {0} on port {1}", sourceNode.Name, sourceNode.Port);
tcpListener.Start();
}
private void Listener_Receive(object sender, ReceiveEventArgs e)
{
//Cast event sender as ClientPeer
ListenerPeer sourcePeer = sender as ListenerPeer;
Logger.Log("Listener Peer is now receiving..." + DateTime.Now.ToString("dd/MMM/yyyy hh:mm:ss tt") + Environment.NewLine);
//Get the Message received
Iso8583Message incomingMessage = e.Message as Iso8583Message;
if (incomingMessage == null)
{
return;
}
long sourceID = Convert.ToInt64(sourcePeer.Name); //where message is coming from
Iso8583Message receivedMessage = new TransactionManager().ValidateMessage(incomingMessage, Convert.ToInt32(sourceID));
sourcePeer.Send(receivedMessage);
sourcePeer.Close();
sourcePeer.Dispose();
}
public static void SourcePeers()
{
List <SourceNode> nodes = new GenericService <SourceNode>().FilterBy(x => x.Status == true).ToList();
foreach (var node in nodes)
{
// ISourceNode source= new
Console.WriteLine("Listening for connection on Port: " + node.Port);
TcpListener tcpListener = new TcpListener(node.Port);
tcpListener.LocalInterface = node.IPAdress;// "127.0.0.1";// SourceNode.IPAddress.ToString();
tcpListener.Start();
ListenerPeer listener = new ListenerPeer(node.Id.ToString(), new TwoBytesNboHeaderChannel
(new Iso8583Ascii1987BinaryBitmapMessageFormatter(), node.IPAdress /*SourceNode.IPAddress.ToString()*/, node.Port),
new BasicMessagesIdentifier(11, 41), tcpListener);
listener.Receive += new PeerReceiveEventHandler(Listener_Receive);
listener.Connected += new PeerConnectedEventHandler(Listener_Connected);
}
// Thread.Sleep(15000);
}
private static void SendSourceNodeResponse(ListenerPeer sourceNodePeer, Iso8583Message message)
{
int tries = 10;
while (!sourceNodePeer.IsConnected && tries > 0)
{
Console.WriteLine("Could not connect to source node. Retrying in 5 seconds.");
tries--;
sourceNodePeer.Connect();
Thread.Sleep(5000);
}
if (tries <= 0 && !sourceNodePeer.IsConnected)
{
Console.WriteLine("Reconnection attempt failed. Could not send response to source");
}
else
{
PeerRequest request = new PeerRequest(sourceNodePeer, message);
request.Send();
request.Peer.Close();
}
}
private static void ProcessResponseMessage(Iso8583Message isoMessage, string response, ListenerPeer listener, bool isCanceled = false)
{
if (!isCanceled)
{
var message = JsonConvert.DeserializeObject <JObject>(response)["EventData"];
var switchCheckResponse = JsonConvert.DeserializeObject <Dictionary <string, object> >(message["IsoMessage"].ToString());
if (switchCheckResponse == null)
{
isoMessage.Fields.Add(IsoMessageFieldDefinitions.RESPONSE_CODE, IsoMessageFieldDefinitions.ResponseCodes.ERROR);
}
else
{
if (switchCheckResponse.Keys.Contains(IsoMessageFieldDefinitions.RESPONSE_CODE.ToString()))
{
if (isoMessage.Fields.Contains(IsoMessageFieldDefinitions.RESPONSE_CODE))
{
isoMessage.Fields[IsoMessageFieldDefinitions.RESPONSE_CODE].Value =
switchCheckResponse[IsoMessageFieldDefinitions.RESPONSE_CODE.ToString()].ToString();
}
else
{
isoMessage.Fields.Add(IsoMessageFieldDefinitions.RESPONSE_CODE,
switchCheckResponse[IsoMessageFieldDefinitions.RESPONSE_CODE.ToString()].ToString());
}
}
if (switchCheckResponse.Keys.Contains(IsoMessageFieldDefinitions.TRANSACTION_FEE.ToString()))
{
if (isoMessage.Fields.Contains(IsoMessageFieldDefinitions.TRANSACTION_FEE))
{
isoMessage.Fields[IsoMessageFieldDefinitions.TRANSACTION_FEE].Value =
switchCheckResponse[IsoMessageFieldDefinitions.TRANSACTION_FEE.ToString()].ToString();
}
else
{
isoMessage.Fields.Add(IsoMessageFieldDefinitions.TRANSACTION_FEE,
switchCheckResponse[IsoMessageFieldDefinitions.TRANSACTION_FEE.ToString()].ToString());
}
}
if (switchCheckResponse.Keys.Contains(IsoMessageFieldDefinitions.FROM_ACCOUNT.ToString()))
{
if (isoMessage.Fields.Contains(IsoMessageFieldDefinitions.FROM_ACCOUNT))
{
isoMessage.Fields[IsoMessageFieldDefinitions.FROM_ACCOUNT].Value =
switchCheckResponse[IsoMessageFieldDefinitions.FROM_ACCOUNT.ToString()].ToString();
}
else
{
isoMessage.Fields.Add(IsoMessageFieldDefinitions.FROM_ACCOUNT,
switchCheckResponse[IsoMessageFieldDefinitions.FROM_ACCOUNT.ToString()].ToString());
}
}
if (switchCheckResponse.Keys.Contains(IsoMessageFieldDefinitions.TO_ACCOUNT.ToString()))
{
if (isoMessage.Fields.Contains(IsoMessageFieldDefinitions.TO_ACCOUNT))
{
isoMessage.Fields[IsoMessageFieldDefinitions.TO_ACCOUNT].Value =
switchCheckResponse[IsoMessageFieldDefinitions.TO_ACCOUNT.ToString()].ToString();
}
else
{
isoMessage.Fields.Add(IsoMessageFieldDefinitions.TO_ACCOUNT,
switchCheckResponse[IsoMessageFieldDefinitions.TO_ACCOUNT.ToString()].ToString());
}
}
if (isoMessage[IsoMessageFieldDefinitions.RESPONSE_CODE].ToString().Equals(IsoMessageFieldDefinitions.ResponseCodes.APPROVED))
{
var sinkNode = JsonConvert.DeserializeObject <SourceNode>(message["SinkNode"].ToString());
Console.WriteLine("Sink Node IP: " + sinkNode.IPAddress);
Console.WriteLine("Sink Node Port: " + sinkNode.Port);
ClientPeer peer = new ClientPeer(sinkNode.Id.ToString(), new TwoBytesNboHeaderChannel(new Iso8583Ascii1987BinaryBitmapMessageFormatter(), sinkNode.IPAddress, sinkNode.Port),
new BasicMessagesIdentifier(11, 41));
try
{
isoMessage = GetSinkNodeResponse(peer, isoMessage);
}
catch (Exception)
{
if (isoMessage.Fields[IsoMessageFieldDefinitions.RESPONSE_CODE].Value != null)
{
isoMessage.Fields[IsoMessageFieldDefinitions.RESPONSE_CODE].Value = IsoMessageFieldDefinitions.ResponseCodes.ISSUER_SWITCH_INOPERATIVE;
}
else
{
isoMessage.Fields.Add(IsoMessageFieldDefinitions.RESPONSE_CODE, IsoMessageFieldDefinitions.ResponseCodes.ISSUER_SWITCH_INOPERATIVE);
}
}
}
else
{
if (isoMessage.MessageTypeIdentifier == IsoMessageFieldDefinitions.MTI.AUTHORIZATION_REQUEST || isoMessage.MessageTypeIdentifier == IsoMessageFieldDefinitions.MTI.AUTHORIZATION_REQUEST_REPEAT)
{
isoMessage.MessageTypeIdentifier = IsoMessageFieldDefinitions.MTI.AUTHORIZATION_RESPONSE;
}
else if (isoMessage.MessageTypeIdentifier == IsoMessageFieldDefinitions.MTI.FINANCIAL_REQUEST || isoMessage.MessageTypeIdentifier == IsoMessageFieldDefinitions.MTI.FINANCIAL_REQUEST_REPEAT)
{
isoMessage.MessageTypeIdentifier = IsoMessageFieldDefinitions.MTI.FINANCIAL_RESPONSE;
}
else if (isoMessage.MessageTypeIdentifier == IsoMessageFieldDefinitions.MTI.REVERSAL_ADVICE || isoMessage.MessageTypeIdentifier == IsoMessageFieldDefinitions.MTI.REVERSAL_ADVICE_REPEAT)
{
isoMessage.MessageTypeIdentifier = IsoMessageFieldDefinitions.MTI.REVERSAL_RESPONSE;
}
}
}
}
SendSourceNodeResponse(listener, isoMessage);
Console.WriteLine("Transaction Finished Successfully");
}
public async void ProcessTransaction(Iso8583Message message, string sourceNodeId, ListenerPeer peer,
List <Scheme> schemes)
{
schemeList = schemes;
if (message.Fields.Contains(IsoMessageFieldDefinitions.FORWARDING_INSTITUTION_CODE))
{
message.Fields[IsoMessageFieldDefinitions.FORWARDING_INSTITUTION_CODE].Value =
ConfigurationManager.AppSettings["SwitchInstitutionCode"];
}
else
{
message.Fields.Add(IsoMessageFieldDefinitions.FORWARDING_INSTITUTION_CODE,
ConfigurationManager.AppSettings["SwitchInstitutionCode"]);
}
Dictionary <string, object> parsedMessage = MessageToCBA(message);
var instructions = new Dictionary <string, string>()
{
{ "Institution Code", ConfigurationManager.AppSettings["InstitutionCode"] },
{ "Service", ConfigurationManager.AppSettings["Service"] },
{ "FlowId", ConfigurationManager.AppSettings["ProcessTransactionFlow"] }
};
var data = new Dictionary <string, object>()
{
{ "IsoMessage", parsedMessage },
{ "MTI", message.MessageTypeIdentifier },
{ "SourceNodeId", sourceNodeId }
};
var jsonData = new
{
instruction = instructions,
data
};
Console.WriteLine(JsonConvert.SerializeObject(jsonData));
HttpClient client = new HttpClient();
client.Timeout = new TimeSpan(0, 0, 30);
try
{
var content = new StringContent(JsonConvert.SerializeObject(jsonData), Encoding.UTF8,
"application/json");
var response = await client.PostAsync(ConfigurationManager.AppSettings["WorkflowUrl"], content);
ProcessResponseMessage(message, await response.Content.ReadAsStringAsync(), peer);
}
catch (Exception)
{
message.Fields.Add(IsoMessageFieldDefinitions.RESPONSE_CODE,
IsoMessageFieldDefinitions.ResponseCodes.ISSUER_SWITCH_INOPERATIVE);
ProcessResponseMessage(message, null, peer, true);
}
}
