public override Exchange Execute(Exchange exchange)
{
Camel.TryLog(exchange, "consumer", _sedaProcessor.UriInformation.ComponentName);
_sedaProcessor.Process(exchange);
return exchange;
}
public static bool Evaluate(Exchange exchange, string expression)
{
try
{
var expressionParts = expression.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
var operatorType = expressionParts[1];
var lhs = expressionParts[0];
var rhs = expressionParts[2];
var lhsResult = ResolveSpecifiedUriPart(lhs, exchange);
var rhsResult = ResolveSpecifiedUriPart(rhs, exchange);
switch (operatorType)
{
case "=":
return lhsResult == rhsResult;
case "!=":
return lhsResult != rhsResult;
case "<=":
return lhsResult != rhsResult;
case ">=":
return lhsResult != rhsResult;
}
}
catch (Exception exception)
{
}
return false;
}
public override void Process(Exchange exchange)
{
var xE = XElement.Parse(exchange.InMessage.Body.ToString().Replace("\\r\\n", ""));
var xElement = xE.Element("claim-type");
if (xElement != null)
{
exchange.InMessage.SetHeader("response-message", "ola .. in tcp/ip test processor");
var ans = DateTime.Now.Second % 3;
var xml = new XElement("payments",
new XElement("code", ans != 0 ? "00" : "91"),
new XElement("information", new XElement("payment", new XAttribute("ref", "12345")),
new XElement("payment", new XAttribute("ref", "34343")),
new XElement("payment", new XAttribute("ref", "33411")),
new XElement("payment", new XAttribute("ref", "41445")),
new XElement("payment", new XAttribute("ref", "55553")))
).ToString(SaveOptions.DisableFormatting);
exchange.InMessage.Body = xml;
exchange.InMessage.SetHeader("email_address", "*****@*****.**");
}
exchange.Exception.Push(new Exception("Error processing transaction request"));
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
try
{
var host = endPointDescriptor.GetUriProperty("host");
var isBodyXml = endPointDescriptor.GetUriProperty<bool>("isBodyXml");
var database = endPointDescriptor.GetUriProperty("database");
var collection = endPointDescriptor.GetUriProperty("collection");
var createCollection = endPointDescriptor.GetUriProperty<bool>("createCollection");
var operation = endPointDescriptor.GetUriProperty<OperationType>("operation");
var client = new MongoClient("mongodb://" + host);
var db = client.GetServer().GetDatabase(database);
if (!db.CollectionExists(collection) && createCollection)
db.CreateCollection(collection);
var bson = exchange.InMessage.Body.ToString();
if (isBodyXml)
{
var doc = new XmlDocument();
doc.LoadXml(exchange.InMessage.Body.ToString());
bson = JsonConvert.SerializeXmlNode(doc);
}
var bsonDoc = BsonDocument.Parse(bson);
ServeOperation(db, exchange, endPointDescriptor, bsonDoc, operation, collection);
}
catch (Exception exception)
{
Console.WriteLine("{0}-{1}", exception.Message, exception.StackTrace);
}
return exchange;
}
public static void HandleTransform(XElement step, Route routeObj, Exchange exchange)
{
try
{
var transformXml = step.Elements().First();
var opName = transformXml.Name.ToString();
switch (opName)
{
case "simple":
ProcessSimple(transformXml, routeObj, exchange);
break;
case "xpath":
break;
}
}
catch (AggregateException aggregateException)
{
}
catch (Exception exception)
{
}
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
try
{
var inReverse = endPointDescriptor.GetUriProperty("reverse", false);
var useOut = endPointDescriptor.GetUriProperty("useout", false);
var body = useOut ? exchange.OutMessage.Body.ToString() : exchange.InMessage.Body.ToString();
if (!inReverse)
{
var doc = new XmlDocument();
doc.LoadXml(body);
var jsonText = JsonConvert.SerializeXmlNode(doc);
exchange.InMessage.Body = jsonText;
}
else
{
var doc = JsonConvert.DeserializeXmlNode(body);
exchange.InMessage.Body = doc.InnerXml;
}
Camel.TryLog(exchange, "processor", endPointDescriptor.ComponentName);
}
catch (Exception exception)
{
}
return base.Process(exchange, endPointDescriptor);
}
private void ValidateUser(Exchange exchange)
{
var token = exchange.InMessage.GetHeader<String>("securityToken");
if (!string.IsNullOrWhiteSpace(token))
{
try
{
var secToken = JWT.JsonWebToken.Decode(token, Encoding.ASCII.GetBytes("password"));
var userInfo = JsonConvert.DeserializeObject<UserAuth.UserInfo>(secToken);
if (userInfo.Name == "adeola")
{
var data = new UserAuth { SessionToken = "djsdjhj3i9sdhnw3", ResponseCode = ResponseCode.Success };
exchange.InMessage.Body = JsonConvert.SerializeObject(data);
}else
{
var data = new UserAuth { SessionToken = "", ResponseCode = ResponseCode.InCorrectAuthenticationParamaters, ResponseMsg = "Incorrect login details" };
exchange.InMessage.Body = JsonConvert.SerializeObject(data);
}
}
catch (Exception e)
{
var data = new UserAuth { SessionToken = "", ResponseCode = ResponseCode.AuthenticationUnknownError, ResponseMsg = e.Message };
exchange.InMessage.Body = JsonConvert.SerializeObject(data);
}
}
else
{
var data = new UserAuth { SessionToken = "", ResponseCode = ResponseCode.Unknown };
exchange.InMessage.Body = JsonConvert.SerializeObject(data);
}
}
public static void DoWhen(XElement choicElement, Exchange exchange)
{
var whenElements = choicElement.Elements("when");
foreach (var whenElement in whenElements)
{
var passed = CheckRequiremnt(whenElement, exchange);
if (!passed) continue;
var functions = whenElement.Elements().Skip(1);
foreach (var xmlStep in functions)
{
RouteStep.ProcessStep(xmlStep, exchange.Route, exchange);
}
break;
}
//handle otherwise
var otherwiseXml = choicElement.Element("otherwise");
if (otherwiseXml == null) return;
var otherwiseFunctions = otherwiseXml.Elements();
foreach (var xmlStep in otherwiseFunctions)
{
RouteStep.ProcessStep(xmlStep, exchange.Route, exchange);
}
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
try
{
Camel.TryLog(exchange, "provider", endPointDescriptor.ComponentName);
var dbHost = endPointDescriptor.ComponentPath;
var port = endPointDescriptor.GetUriProperty<int>("port");
var couchDbDatabase = exchange.InMessage.GetHeader("CouchDbDatabase");
var createDb = endPointDescriptor.GetUriProperty<bool>("createDb");
var document = exchange.InMessage.Body;
var dbUrl = string.Format("http://{0}:{1}", dbHost, port);
var conn = new Connection(new Uri(dbUrl));
if (createDb && !conn.ListDatabases().Contains(couchDbDatabase))
{
conn.CreateDatabase(couchDbDatabase.ToString());
}
}
catch (Exception exception)
{
}
return base.Process(exchange, endPointDescriptor);
}
/// <summary>
/// Execute
/// </summary>
/// <param name="loopTag"></param>
/// <param name="exchange"></param>
/// <param name="route"></param>
public static void Execute(XElement loopTag, Exchange exchange, Route route)
{
Camel.TryLog(exchange, "processor", "loop");
var expressionTag = loopTag.Elements().FirstOrDefault();
if (expressionTag == null || (expressionTag.Name != "count"))
return;
var xpression = expressionTag.Value;
var count = SimpleExpression.ResolveSpecifiedUriPart(xpression, exchange);
var mCount = Convert.ToInt32(count);
for (var i = 0; i < mCount; i++)
{
var data = loopTag.Elements().Skip(1);
foreach (var dataItem in data)
{
try
{
RouteStep.ProcessStep(dataItem, route, exchange);
}
catch (Exception exception)
{
}
}
}
}
private static bool CheckRequiremnt(XElement whenElement, Exchange exchange)
{
var conditionXml = whenElement.Elements().FirstOrDefault();
if (conditionXml == null)
return false;
var conditionType = conditionXml.Name.ToString();
switch (conditionType)
{
case "simple":
return ProcessSimple(conditionXml, exchange);
break;
case "xpath":
return ProcessXPath(conditionXml, exchange);
break;
case "method":
return ProcessBean(conditionXml, exchange);
break;
case "processor-method":
return ProcessExchangeBean(conditionXml, exchange);
break;
default:
return false;
}
return false;
}
/// <summary>
///
/// </summary>
/// <param name="step"></param>
/// <param name="exchange"></param>
/// <param name="routeObj"></param>
public static void Enrich(XElement step, Exchange exchange, Route routeObj)
{
try
{
var uri = step.Attribute("uri");
var strategyref = step.Attribute("strategyref");
if (uri == null || strategyref == null)
return;
var uriInfo = UriDescriptor.Parse(uri.Value, exchange);
var clonedExchange = exchange.CloneExchange();
EndPointBuilder.HandleTo(uriInfo, clonedExchange, routeObj);
//fetch strategy
var stragegyObj = Camel.Registry[strategyref.Value] as AggregationStrategy;
if (stragegyObj != null)
{
stragegyObj.Aggregate(exchange, clonedExchange);
}
}
catch (Exception exc)
{
}
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
var baseApiUri = endPointDescriptor.ComponentPath;
var location = endPointDescriptor.GetUriProperty("location", "");
var resultHeader = endPointDescriptor.GetUriProperty("resultHeader");
var lat = endPointDescriptor.GetUriProperty("lat");
var lon = endPointDescriptor.GetUriProperty("lon");
using (var client = new WebClient())
{
if (!string.IsNullOrEmpty(lat))
client.QueryString.Add("lat", lat);
if (!string.IsNullOrEmpty(lon))
client.QueryString.Add("lon", lon);
var finaUrl = string.Format("{0}?q={1}", baseApiUri, location);
var result = client.DownloadString(finaUrl);
if (!string.IsNullOrEmpty(resultHeader))
exchange.InMessage.SetHeader("resultHeader", result);
else
{
exchange.InMessage.Body = result;
}
}
return exchange;
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
try
{
var protocol = endPointDescriptor.GetUriProperty<string>("protocol");
switch (protocol)
{
case "smtp":
Task.Factory.StartNew(() => SendMail(endPointDescriptor, exchange));
break;
case "imap":
break;
}
}
catch (AggregateException aggregateException)
{
Console.WriteLine("aggr-error sending mail: {0}", aggregateException.Message);
}
catch (Exception exception)
{
Console.WriteLine("error sending mail: {0}", exception.Message);
}
return base.Process(exchange, endPointDescriptor);
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
try
{
var method = endPointDescriptor.GetUriProperty("method");
var objectTypePath = endPointDescriptor.ComponentPath;
var objectType = Type.GetType(objectTypePath);
if (objectType != null)
{
var objectInstance = Activator.CreateInstance(objectType, null);
if (!string.IsNullOrEmpty(method))
{
//process normalizer method
var methodMember = objectInstance.GetType()
.GetMethod(method, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
methodMember.Invoke(objectInstance, null);
}
}
}
catch (Exception exception)
{
}
return base.Process(exchange, endPointDescriptor);
}
/// <summary>
/// ProcessRouteInformation From Method
/// </summary>
/// <param name="leafDescriptor"></param>
/// <param name="route"></param>
public static void HandleFrom(UriDescriptor leafDescriptor, Route route, Exchange exchangeData = null)
{
try
{
//init endpoint
DefaultEndpoint endPoint;
if (Camel.EnPointCollection.TryGetValue(leafDescriptor.FullUri, out endPoint))
{
}
else
{
var execAssembly = Assembly.GetExecutingAssembly();
var types = execAssembly.GetTypes();
foreach (var namespaceToCheck in PermissibleNamespaces)
{
var typeData =
types.FirstOrDefault(
c =>
c.FullName.Equals(
string.Format("{0}.{1}.{2}", namespaceToCheck, leafDescriptor.ComponentName,
leafDescriptor.ComponentName),
StringComparison.InvariantCultureIgnoreCase) ||
c.FullName.Equals(
string.Format("{0}.{1}.{2}EndPoint", namespaceToCheck,
leafDescriptor.ComponentName, leafDescriptor.ComponentName),
StringComparison.InvariantCultureIgnoreCase));
if (typeData == null)
continue;
endPoint = (DefaultEndpoint) Activator.CreateInstance(typeData, leafDescriptor.FullUri, route);
Camel.EnPointCollection.TryAdd(leafDescriptor.FullUri, endPoint);
break;
}
}
if (endPoint != null)
{
if (exchangeData == null)
endPoint.Start();
else
{
endPoint.StartWithExistingExchange(exchangeData);
}
}
else
throw new AppCoreException("end-point not found: " + leafDescriptor.ComponentName);
}
catch (AggregateException exception)
{
}
catch (Exception exception)
{
throw new AppCoreException("error handling [from-tag] :" + exception.Message, exception);
}
}
public List<string> Split(Exchange exchange)
{
if (exchange.InMessage.Body == null)
return null;
var bodyLines = exchange.InMessage.Body.ToString().Split(new[] {Environment.NewLine}, StringSplitOptions.None);
return bodyLines.ToList();
}
public override Exchange Execute()
{
var exchange = new Exchange(_sedaProcessor.Route);
Camel.TryLog(exchange, "consumer", _sedaProcessor.UriInformation.ComponentName);
_sedaProcessor.Process(exchange);
return exchange;
}
private void ProcessResponse(string fileData, Exchange exchange, string fileFolderPath)
{
exchange.InMessage.SetHeader("fileFolderPath", fileFolderPath);
exchange.InMessage.Body = fileData;
Camel.TryLog(exchange);
_fileProcessor.Process(exchange);
exchange.OutMessage.Body = exchange.InMessage.Body;
}
public override void Process(Exchange exchange)
{
var rawMsg = exchange.InMessage.Body.ToString();
var data = JsonConvert.DeserializeObject<UserLogin>(rawMsg);
var rsp = JsonConvert.SerializeObject(new UserLogin.UserLoginStatus { ResponseCode = "90000", ResponseMessage = "Success", });
exchange.InMessage.Body = GetBankSummary();
base.Process(exchange);
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
LogStack.Enqueue(new UriExchange { Exchange = exchange, UriDescriptor = endPointDescriptor });
if (LogTask == null)
LogTask = System.Threading.Tasks.Task.Factory.StartNew(ProcessLogQueue);
return exchange;
}
public bool IsHttpGenericRequest(Exchange exchange)
{
var request = XElement.Parse(exchange.InMessage.Body.ToString());
var xElement = request.Element("routeid");
if (xElement == null) return false;
var routeId = xElement.Value;
return routeId == "HTTPGENERIC";
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
var path = endPointDescriptor.ComponentPath;
var route = Camel.GetRouteBy(path);
if (route != null)
route.CurrentRouteStep.ProcessChannel(exchange);
return exchange;
}
public override Exchange Aggregate(Exchange oldExchange, Exchange newExchange)
{
var dateTime = XElement.Parse(newExchange.InMessage.Body.ToString());
var result = XmlHelper.GetValue<DateTime>(dateTime, "datetime");
var notifyRes = XElement.Parse(oldExchange.InMessage.Body.ToString());
notifyRes.Add(new XElement("aggregator_date_time", result));
oldExchange.InMessage.Body = notifyRes.ToString();
return oldExchange;
}
public void Log(Exchange exchange, string processorType, string componentName, Exception exception = null)
{
try
{
System.Threading.Tasks.Task.Factory.StartNew(() => InitLog(exchange, processorType, componentName));
}
catch (Exception)
{
}
}
public override void Process(Exchange exchange)
{
var elem = XElement.Parse(exchange.InMessage.Body.ToString());
elem.Add(new XElement("responsecode","00"));
elem.Add(new XElement("responsemessage", "Successful"));
elem.Add(new XElement("pin",Guid.NewGuid().ToString()));
exchange.OutMessage.Body = elem.ToString();
exchange.InMessage.SetHeader("htt-request-bean", DateTime.Now.ToString());
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
var fileData = exchange.OutMessage.Body != null ? exchange.OutMessage.Body.ToString() : "";
var fileName = endPointDescriptor.ComponentPath;
if (!string.IsNullOrEmpty(fileData) && !string.IsNullOrEmpty(fileName))
File.AppendAllText(fileName, fileData);
Camel.TryLog(exchange, "provider", endPointDescriptor.ComponentName);
return exchange;
}
public override void Process(Exchange exchange)
{
var body = exchange.InMessage.Body.ToString();
if (body.EndsWith("\\r\\n"))
body = body.Replace("\\r\\n", "");
var msg = $"http://{body}";
var xml = XElement.Parse(body);
xml.Add(new XElement("response", "00"));
exchange.InMessage.Body = xml.ToString();
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
Route route;
if (!Camel.RouteCollection.TryGetValue(endPointDescriptor.ComponentPath, out route))
return exchange;
Camel.TryLog(exchange, "producer", endPointDescriptor.ComponentName);
exchange.Route = route;
SedaDriver.SedaQueue.TryAdd(endPointDescriptor, exchange);
return exchange;
}
private static void Tap(Exchange exchange, string path, Route route)
{
try
{
var leafNodeParts = UriDescriptor.Parse(path, exchange);
EndPointBuilder.HandleTo(leafNodeParts, exchange, route);
}
catch(Exception exception)
{
Console.WriteLine(exception.Message);
}
}