//When the requested send to a Sink (client) is done
static void Client_RequestDone(object sender, PeerRequestDoneEventArgs e)
{
Iso8583Message response = e.Request.ResponseMessage as Iso8583Message;
//SourceNode sourceNode = e.Request.Payload as SourceNode;
SinkNode sinkNode = e.Request.Payload as SinkNode;
//continue coding
}
/// <summary>
/// Gets the sink node instance with given node name.
/// </summary>
/// <param name="name">The name of sink node</param>
/// <returns>The sink node instance</returns>
/// <feature>http://tizen.org/feature/machine_learning.inference</feature>
/// <exception cref="NotSupportedException">Thrown when the feature is not supported.</exception>
/// <exception cref="ArgumentException">Thrown when the method failed due to an invalid parameter.</exception>
/// <since_tizen> 8 </since_tizen>
public SinkNode GetSink(string name)
{
NNStreamer.CheckNNStreamerSupport();
/* Check the argument */
if (string.IsNullOrEmpty(name))
{
throw NNStreamerExceptionFactory.CreateException(NNStreamerError.InvalidParameter, "Node name is invalid");
}
SinkNode node;
if (_nodeList.ContainsKey(name))
{
if (_nodeList[name].Type != NodeType.Sink)
{
throw NNStreamerExceptionFactory.CreateException(NNStreamerError.InvalidParameter, name + " is not a sink node");
}
node = (SinkNode)_nodeList[name];
}
else
{
node = new SinkNode(name, this);
_nodeList.Add(name, node);
}
return(node);
}
public void Update(SinkNode sinkNode)
{
if (sinkNode != null)
{
_db.Update(sinkNode);
}
}
public void RouteToDestination(Iso8583Message message, SinkNode sinknode)
{
int maxNumberOfEntries = 3;
int serverTimeOut = 60000;
ClientPeer clientPeer = new Client().StartClient(sinknode);
int retries = 0;
while (retries < maxNumberOfEntries)
{
if (clientPeer.IsConnected)
{
break;
}
else
{
//clientPeer.Close();
retries++;
clientPeer.Connect();
}
Thread.Sleep(5000);
}
PeerRequest request = null;
if (clientPeer.IsConnected)
{
request = new PeerRequest(clientPeer, message);
request.Send();
request.WaitResponse(serverTimeOut);
//request.MarkAsExpired(); //uncomment to test timeout
if (request.Expired)
{
//logger.Log("Connection timeout.");
Console.WriteLine("Response received too late"); //Response received too late
}
// if (request != null)
// {
// response = request.ResponseMessage;
// //logger.Log("Message Recieved From FEP");
//
// }
clientPeer.Close();
// return response as Iso8583Message;
}
else
{
//logger.Log("Could not connect to Sink Node");
//clientPeer.Close();
Console.WriteLine("Client Peer is not Connected");
}
//clientPeer.Close();
}
public ActionResult Edit(SinkNode model)
{
var _context = new ApplicationDbContext();
Repo.Update(model);
return(View());
}
public async Task <HttpResponseMessage> CreateSinkNode(SinkNode sinkNode)
{
var sinkName = _context.SinkNodes.SingleOrDefault(c => c.Name == sinkNode.Name);
if (sinkName != null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, StatusCodes.NAME_ALREADY_EXIST));
}
sinkNode.Id = 0;
if (sinkNode.Status == "0")
{
sinkNode.Status = StatusCodes.ACTIVE;
}
else
{
sinkNode.Status = StatusCodes.INACTIVE;
}
Console.WriteLine("Posted SinkNode : " + sinkNode);
var sinkNodeInDb = new SinkNode()
{
Name = sinkNode.Name,
HostName = sinkNode.HostName,
Port = sinkNode.Port,
IPAddress = sinkNode.IPAddress,
Status = sinkNode.Status
};
_context.SinkNodes.Add(sinkNodeInDb);
_context.SaveChanges();
var options = new PusherOptions
{
Cluster = "mt1",
Encrypted = true
};
var pusher = new Pusher(
"619556",
"1e8d9229f9b58c374f76",
"d3f1b6b70b528626fbef",
options);
var result = await pusher.TriggerAsync(
"my-sinknodes",
"new-sinknode",
data : new
{
Id = sinkNodeInDb.Id,
Name = sinkNode.Name,
HostName = sinkNode.HostName,
IPAddress = sinkNode.IPAddress,
Port = sinkNode.Port,
Status = sinkNode.Status
});
return(Request.CreateResponse(HttpStatusCode.OK, StatusCodes.CREATED));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,Name,HostName,IPAdress,Port,Status")] SinkNode sinknode)
{
if (ModelState.IsValid)
{
await _sinknodeService.UpdateAsync(sinknode);
//db.Entry(sinknode).State = EntityState.Modified;
//await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(sinknode));
}
// GET: /sinknodes/Edit/5
public async Task <ActionResult> Edit(Guid id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SinkNode sinknode = await _sinknodeService.GetByIdAsync(id);
if (sinknode == null)
{
return(HttpNotFound());
}
return(View(sinknode));
}
public static void ClientPeer(SinkNode sinkNodeToConnect, List <ClientPeer> clientPeers) //join conn
{
ClientPeer client = new ClientPeer(sinkNodeToConnect.Id.ToString(),
new TwoBytesNboHeaderChannel(new Iso8583Ascii1987BinaryBitmapMessageFormatter(), sinkNodeToConnect.HostName, Convert.ToInt32(sinkNodeToConnect.Port)), new BasicMessagesIdentifier(11, 41));
client.RequestDone += new PeerRequestDoneEventHandler(Client_RequestDone);
client.RequestCancelled += new PeerRequestCancelledEventHandler(Client_RequestCancelled);
client.Connected += client_Connected;
client.Receive += new PeerReceiveEventHandler(Client_Receive);
clientPeers.Add(client);
client.Connect();
Console.WriteLine("Waiting for connection..");
}
public async Task <SinkNode> DeleteAsync(Guid Id)
{
SinkNode obj = await GetByIdAsync(Id);
if (obj == null)
{
throw new ProjectException("The record does not exist in the system. Thank you");
}
obj.IsDeleted = true;
// _ValidationProvider.Validate(attendance);
_ModelRepository.Attach(obj, EntityStatus.Modified);
await _UnitOfWork.SaveChangesAsync();
return(obj);
}
public async Task <SinkNode> SaveAsync(SinkNode model)
{
// model.id = SchoolId;
// ObjectValidation(model);
var existed = GetQueryable(x => x.Name.ToLower().Equals(model.Name.ToLower())).FirstOrDefault();
if (existed != null)
{
// return existed;
throw new ProjectException("The Sink Node already exists.");
}
_ModelRepository.Add(model);
await _UnitOfWork.SaveChangesAsync();
return(model);
}
public ClientPeer StartClient(SinkNode sinkNode)
{
ClientPeer clientPeer = new ClientPeer(sinkNode.Name, new TwoBytesNboHeaderChannel(
new Iso8583Ascii1987BinaryBitmapMessageFormatter(), sinkNode.IPAddress, Int32.Parse(sinkNode.Port)),
new Trx.Messaging.BasicMessagesIdentifier(11, 41));
//clientPeer.Connect();
clientPeer.RequestDone += new PeerRequestDoneEventHandler(Client_RequestDone);
clientPeer.RequestCancelled += new PeerRequestCancelledEventHandler(Client_RequestCancelled);
clientPeer.Connected += new PeerConnectedEventHandler(ClientPeerConnected);
clientPeer.Receive += new PeerReceiveEventHandler(ClientPeerOnReceive);
clientPeer.Disconnected += new PeerDisconnectedEventHandler(ClientPeerDisconnected);
return(clientPeer);
}
public async Task <HttpResponseMessage> UpdateSinkNode(SinkNode sinkNode)
{
var sinkNodeInDb = _context.SinkNodes.SingleOrDefault(c => c.Id == sinkNode.Id);
if (sinkNode.Status == "0")
{
sinkNode.Status = StatusCodes.ACTIVE;
}
else
{
sinkNode.Status = StatusCodes.INACTIVE;
}
sinkNodeInDb.Name = sinkNode.Name;
sinkNodeInDb.HostName = sinkNode.HostName;
sinkNodeInDb.IPAddress = sinkNode.IPAddress;
sinkNodeInDb.Port = sinkNode.Port;
sinkNodeInDb.Status = sinkNode.Status;
_context.SaveChanges();
// var options = new PusherOptions
// {
// Cluster = "mt1",
// Encrypted = true
// };
//
// var pusher = new Pusher(
// "619556",
// "1e8d9229f9b58c374f76",
// "d3f1b6b70b528626fbef",
// options);
//
// var result = await pusher.TriggerAsync(
// "my-sinknodes",
// "new-sinknode",
// data: new
// {
// Id = sinkNode.Id,
// Name = sinkNode.Name,
// HostName = sinkNode.HostName,
// IPAddress = sinkNode.IPAddress,
// Port = sinkNode.Port,
// Status = sinkNode.Status
// });
return(Request.CreateResponse(HttpStatusCode.OK, StatusCodes.UPDATED));
}
public ActionResult Edit(int?id)
{
var _context = new ApplicationDbContext();
if (id == null)
{
return(HttpNotFound());
}
SinkNode channels = _context.SinkNodes.Find(id);
if (channels == null)
{
return(HttpNotFound());
}
return(View(channels));
}
public async Task <ActionResult> Create([Bind(Include = "Name,HostName,IPAdress,Port,Status")] SinkNode sinknode)
{
if (ModelState.IsValid)
{
try
{
sinknode.Id = Guid.NewGuid();
await _sinknodeService.SaveAsync(sinknode);
}
catch (Exception ex)
{
throw ex;
}
//db.SinkNode.Add(sinknode);
//await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(sinknode));
}
public async Task <SinkNode> UpdateAsync(SinkNode model)
{
// model.IsUpdated = true;
// ObjectValidation(model);
var dbobj = await GetByIdAsync(model.Id);
if (dbobj == null)
{
throw new ProjectException("The Record does not exist in the system");
}
dbobj.HostName = model.HostName;
dbobj.IPAdress = model.IPAdress;
dbobj.Name = model.Name;
dbobj.Port = model.Port;
dbobj.Status = model.Status;
_ModelRepository.Attach(dbobj, EntityStatus.Modified);
await _UnitOfWork.SaveChangesAsync();
return(dbobj);
}
public bool AddSinkNode(SinkNode sinkNode)
{
bool result = false;
try
{
var node = _db.GetAll <SinkNode>().FirstOrDefault(x => x.IPAddress == sinkNode.IPAddress && x.Port == sinkNode.Port);
if (node != null)
{
throw new Exception("This Sink Node With this IP Address and Port already Exist");
}
else
{
result = _db.Add(sinkNode);
}
return(result);
}
catch (Exception ex)
{
_db.Rollback();
throw ex;
}
}
public bool Edit(SinkNode model)
{
try
{
bool result = false;
var sinkNode = _db.GetAll <SinkNode>().FirstOrDefault(x => x.IPAddress == model.IPAddress);
if (sinkNode != null)
{
sinkNode.Name = model.Name;
sinkNode.HostName = model.HostName;
sinkNode.IPAddress = model.IPAddress;
sinkNode.Port = model.Port;
sinkNode.IsActive = model.IsActive;
result = _db.Update(sinkNode);
}
return(result);
}
catch (Exception ex)
{
_db.Rollback();
throw ex;
}
}
private Iso8583Message RouteToDestination(Iso8583Message message, SinkNode sinkNode, out bool needReversal)
{
Message response = null;
needReversal = false;
try
{
if (message == null)
{
return(SetResponseMessage(message, "20"));
}
if (sinkNode == null)
{
Console.WriteLine("Sink Node is null");
return(SetResponseMessage(message, "91"));
}
if (sinkNode.Status == "In-active")
{
Console.WriteLine("Sink Node is Inactive");
return(SetResponseMessage(message, "91"));
}
int maxNumberOfEntries = 3;
int serverTimeOut = 60000;
ClientPeer clientPeer = new Client().StartClient(sinkNode);
int retries = 0;
while (retries < maxNumberOfEntries)
{
if (clientPeer.IsConnected)
{
break;
}
else
{
//clientPeer.Close();
retries++;
clientPeer.Connect();
}
Thread.Sleep(5000);
}
PeerRequest request = null;
if (clientPeer.IsConnected)
{
request = new PeerRequest(clientPeer, message);
request.Send();
request.WaitResponse(serverTimeOut);
//request.MarkAsExpired(); //uncomment to test timeout
if (request.Expired)
{
//logger.Log("Connection timeout.");
needReversal = true;
return(SetResponseMessage(message, "68")); //Response received too late
}
if (request != null)
{
response = request.ResponseMessage;
request = new PeerRequest(clientPeer, SetResponseMessage(message, "00"));
request.Send();
//logger.Log("Message Recieved From FEP");
}
clientPeer.Close();
return(response as Iso8583Message);
}
else
{
//logger.Log("Could not connect to Sink Node");
//clientPeer.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"));
}
}
public void Update(SinkNode channel)
{
Repo.Update(channel);
}
private void OnSinkNodeRemoved(object sender, ConfigurationNodeChangedEventArgs e)
{
this.sinkNode = null;
}
public ActionResult Add(SinkNode model)
{
Repo.Save(model);
return(View());
}
public Iso8583Message ValidateMessage(Iso8583Message originalMessage, int sourceID)
{
Logger.Log("\n Enter Validator");
//get source Node.
SourceNode sourceNode = new SourceNodeManager().GetByID(sourceID);
DateTime transmissionDate = DateTime.UtcNow;
//format TransactionDate
string transactionDate = string.Format("{0}{1}",
string.Format("{0:00}{1:00}", transmissionDate.Month, transmissionDate.Day),
string.Format("{0:00}{1:00}{2:00}", transmissionDate.Hour,
transmissionDate.Minute, transmissionDate.Second));
//set Original Data Element
string originalDataElement = string.Format("{0}{1}{2}", originalMessage.MessageTypeIdentifier.ToString(), originalMessage.Fields[11].ToString(), transactionDate);
//add original data element to original message
originalMessage.Fields.Add(90, originalDataElement);
//Do Message Log
Logger.LogTransaction(originalMessage, sourceNode);
// Check if it is reversal message and do the needful
if (originalMessage.MessageTypeIdentifier == 421)
{
Logger.Log("\n This is a reversal");
bool conReversal;
Iso8583Message reversalIsoMsg = GetReversalMessage(originalMessage, out conReversal);
if (!conReversal)
{
Logger.LogTransaction(reversalIsoMsg);
return(reversalIsoMsg);
}
originalMessage = reversalIsoMsg;
Logger.LogTransaction(originalMessage, sourceNode);
}
string theCardPan = originalMessage.Fields[2].Value.ToString();
string tranasactionTypeCode = originalMessage.Fields[3].Value.ToString().Substring(0, 2);
double amount = Convert.ToDouble(originalMessage.Fields[4].Value);
string orgExpiry = originalMessage.Fields[14].Value.ToString();
string code = originalMessage.Fields[123].ToString().Substring(13, 2);
Channel channel = new ChannelManager().GetByCode(code);
Fee fee = null;
// string cardPAN = theCardPan.Substring(0, 6);
Route theRoute = new RouteManager().GetRouteByCardPan(theCardPan.Substring(0, 6));
TransactionType transactionType = new TransactionTypeManager().GetByCode(tranasactionTypeCode);
Iso8583Message responseMessage;
//check if card has expired
DateTime cardExpiryDate = ParseExpiryDate(orgExpiry);
if (cardExpiryDate < DateTime.Now)
{
responseMessage = SetReponseMessage(originalMessage, "54"); //Expired card
Logger.LogTransaction(responseMessage, sourceNode);
return(responseMessage);
}
if (amount <= 0 && tranasactionTypeCode != "31")
{
responseMessage = SetReponseMessage(originalMessage, "13"); //Invalid amount
Logger.LogTransaction(responseMessage, sourceNode);
return(responseMessage);
}
if (theRoute == null)
{
Logger.Log("Sink node is null.");
responseMessage = SetReponseMessage(originalMessage, "15"); //No such issuer
Logger.LogTransaction(responseMessage, sourceNode);
return(responseMessage);
}
SinkNode sinkNode = theRoute.SinkNode;
if (sinkNode == null)
{
Logger.Log("Sink node is null.");
responseMessage = SetReponseMessage(originalMessage, "91"); //Issuer inoperative
Logger.LogTransaction(responseMessage, sourceNode);
return(responseMessage);
}
Logger.Log("Loading SourceNode Schemes");
var theSchemes = sourceNode.Schemes;
Scheme scheme = null;
try
{
scheme = theSchemes.Where(x => x.Route.CardPAN == theCardPan.Substring(0, 6)).SingleOrDefault();
}
catch (Exception ex)
{
Logger.Log("Error: \n" + ex.Message);
responseMessage = SetReponseMessage(originalMessage, "31"); // Lazy load error : Set correct response code later
Logger.LogTransaction(responseMessage, sourceNode);
return(responseMessage);
}
if (scheme == null)
{
responseMessage = SetReponseMessage(originalMessage, "92"); // Route not allowed : Set correct response code later
Logger.LogTransaction(responseMessage, sourceNode);
return(responseMessage);
}
// int panCount = sourceNode.Schemes.Count(x => x.Route == theRoute);
Logger.Log("Scheme : " + scheme.Name + " Loaded");
Logger.Log("Getting fee:");
fee = GetFeeIfTransactionIsAllowed(transactionType, channel, scheme);
if (fee == null)
{
responseMessage = SetReponseMessage(originalMessage, "58"); // Transaction type not allowed in this scheme
Logger.LogTransaction(responseMessage, sourceNode, scheme);
return(responseMessage);
}
else
{
originalMessage = SetFee(originalMessage, CalculateFee(fee, amount));
}
bool needReversal = false;
Iso8583Message msgFromFEP = ToFEP(originalMessage, sinkNode, out needReversal);
Logger.LogTransaction(msgFromFEP, sourceNode, scheme, fee, needReversal);
return(msgFromFEP);
}
private Iso8583Message ToFEP(Iso8583Message msgToSend, SinkNode sinkNode, out bool needReversal)
{
Message response = null;
string responseMsg = string.Empty;
needReversal = false;
try
{
if (msgToSend == null)
{
Logger.Log("Iso message is null.");
return(SetReponseMessage(msgToSend, "20")); //Invalid response
}
if (sinkNode == null)
{
Logger.Log("Sink node is null.");
return(SetReponseMessage(msgToSend, "91")); //Issuer inoperative
}
int maxNoRetries = 3;
int serverTimeout = 60000;
sinkNode.IsActive = true;
ClientPeer _clientPeer = new ClientPeer(sinkNode.Name, new TwoBytesNboHeaderChannel(
new Iso8583Ascii1987BinaryBitmapMessageFormatter(), sinkNode.IPAddress,
Convert.ToInt16(sinkNode.Port)), new Trx.Messaging.BasicMessagesIdentifier(11));
_clientPeer.Connect();
Thread.Sleep(1800);
int retries = 0;
while (retries < maxNoRetries)
{
if (_clientPeer.IsConnected)
{
break;
}
else
{
_clientPeer.Close();
retries++;
_clientPeer.Connect();
}
Thread.Sleep(2000);
}
PeerRequest request = null;
if (_clientPeer.IsConnected)
{
request = new PeerRequest(_clientPeer, msgToSend);
request.Send();
request.WaitResponse(serverTimeout);
//request.MarkAsExpired(); //uncomment to test timeout
if (request.Expired)
{
Logger.Log("Connection timeout.");
needReversal = true;
return(SetReponseMessage(msgToSend, "68")); //Response received too late
}
if (request != null)
{
response = request.ResponseMessage;
//ResponseMessage = GetResponseMesage(response as Iso8583Message);
}
return(response as Iso8583Message);
}
else
{
Console.WriteLine("\n Could not connect to the Sink Node..");
Console.BackgroundColor = ConsoleColor.Red;
Logger.Log("\n Could not connect to the Sink Node.");
return(SetReponseMessage(msgToSend, "91"));
}
}
catch (Exception ex)
{
Logger.Log("ERROR: " + ex.Message);
return(SetReponseMessage(msgToSend, "06")); //Error
}
}
public void Save(SinkNode channel)
{
Repo.Save(channel);
}
