//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); }