private void ProcessTransforms(ChutzpahTestSettingsFile settings, TestCaseSummary overallSummary, TransformResult results)
{
// Do this here per settings file in case an individual transformer has any associated state
// - we want them fresh
var knownTransforms =
transformerProvider
.GetTransformers(fileSystem)
.ToDictionary(x => x.Name, x => x, StringComparer.InvariantCultureIgnoreCase);
foreach (var transformConfig in settings.Transforms)
{
SummaryTransformer transform = null;
if (knownTransforms.TryGetValue(transformConfig.Name, out transform))
{
var outputPath = transformConfig.Path;
if (!fileSystem.IsPathRooted(outputPath) && !string.IsNullOrWhiteSpace(transformConfig.SettingsFileDirectory))
{
outputPath = fileSystem.GetFullPath(Path.Combine(transformConfig.SettingsFileDirectory, outputPath));
}
// TODO: In future, this would ideally split out the summary to just those parts
// relevant to the files associated with the settings file being handled
transform.Transform(overallSummary, outputPath);
results.AddResult(transform.Name, outputPath);
}
}
}
public TransformResult ProcessTransforms(IEnumerable<TestContext> testContexts, TestCaseSummary overallSummary)
{
var results = new TransformResult();
var allTestSettings = testContexts.Select(x => x.TestFileSettings).Distinct();
foreach (var settings in allTestSettings)
{
if (settings.Transforms != null && settings.Transforms.Any())
{
ProcessTransforms(settings, overallSummary, results);
}
}
return results;
}
private static string CallSOAP(string result, string template)
{
var data = new TransformResult();
var trans = new Transformation();
var xm = XElement.Parse(result);
var simpleXml = trans.RemoveAllNamespacesXml(xm);
simpleXml = simpleXml.Replace("amp;", "").Replace("<", "<").Replace(">", ">");
/*simpleXml = simpleXml.Replace("&", "");
* var encode = WebUtility.HtmlDecode(simpleXml);*/
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(simpleXml);
data.MediaType = "application/json";
data.Result = JsonConvert.SerializeXmlNode(xmlDoc);
return(trans.Execute(data, template));
}
/// <summary>
/// This function will be called at server after receive transform from clients
/// to interpolate and sync position to other clients
/// </summary>
/// <param name="reader"></param>
internal void HandleClientSendTransform(NetDataReader reader)
{
// Don't update transform follow client's request
// if not set "ownerClientCanSendTransform" to `TRUE`
// or it's this is owned by host
if (!ownerClientCanSendTransform || IsOwnerClient)
{
return;
}
TransformResult result = DeserializeResult(reader);
// Discard out of order results
if (result.timestamp <= lastReceivedTimestamp)
{
return;
}
lastReceivedTime = Time.fixedTime;
lastReceivedTimestamp = result.timestamp;
result.timestamp = GetTimeStamp();
previousEndInterpResult = endInterpResult;
endInterpResult = result;
}
public async Task <TransformResult> ConsumeRest(string url)
{
var client = new HttpClient();
var result = new TransformResult();
try
{
var service = await client.GetAsync(url);
if (service.IsSuccessStatusCode)
{
result.Result = await service.Content.ReadAsStringAsync();
result.MediaType = service.Content.Headers.ContentType.MediaType;
}
}
catch (Exception ex)
{
Console.WriteLine("Exception in Consume Rest: " + ex.Message);
}
return(result);
}
public TransformResult TransformDocument(string profile, FileInfo inputFile, FileInfo targetFile, JobContext context)
{
var retVal = new TransformResult();
var engine = enginesPool.GetEngine();
bool isRecycleRequired = false;
try
{
IFRDocument fineReaderDocument = null;
try
{
fineReaderDocument = LoadFineReaderDocument(inputFile.FullName, profile, engine, context);
SubscribeTransformEvents((FRDocument)fineReaderDocument);
fineReaderDocument.Process();
fineReaderDocument.Export(targetFile.FullName, FileExportFormatEnum.FEF_PDF, null);
// Alles OK
retVal.TargetFile = targetFile;
retVal.TargetFile.Refresh();
return(retVal);
}
finally
{
if (fineReaderDocument != null)
{
UnsubscribeTransformEvents((FRDocument)fineReaderDocument);
fineReaderDocument.Close();
if (Marshal.IsComObject(fineReaderDocument))
{
Marshal.ReleaseComObject(fineReaderDocument);
}
}
}
}
catch (Exception ex)
{
Log.Error(ex, $"Abbyy document conversion failed: {ex.Message}");
isRecycleRequired = enginesPool.ShouldRestartEngine(ex);
retVal.HasError = true;
retVal.ErrorMessage = ex.Message;
// Push an error message to indicate that the item has failed
bus.Publish <AbbyyProgressEvent>(new
{
__TimeToLive = TimeSpan.FromSeconds(3),
File = sourceFile,
Process = ProcessType.Rendering,
EventType = AbbyyEventType.AbbyyOnProgressEvent,
HasFailed = true
});
}
finally
{
// Push the final message to indicate that the item is finished
bus.Publish <AbbyyProgressEvent>(new
{
__TimeToLive = TimeSpan.FromSeconds(3),
File = sourceFile,
IsComplete = true,
Percentage = 100,
Process = ProcessType.Rendering,
EventType = AbbyyEventType.AbbyyOnProgressEvent
});
enginesPool.ReleaseEngine(engine, isRecycleRequired);
}
return(retVal);
}
/// <summary>
/// Converts hierarchical category structure to mvc route
/// </summary>
/// <param name="path">The route being processed</param>
/// <param name="dbContext">The main app storage: <see cref="Mp3EhbContext"/></param>
/// <returns></returns>
private async Task <TransformResult> TransformPathAsync(string path, Mp3EhbContext dbContext,
IDictionary <object, object> contextItems)
{
//The middleware will try to find a Category and a content in the database that matches the current path
var transformResult = new TransformResult();
var trimmedPath = path.TrimTail(tail: DEFAULT_EXTENSION);
var names = trimmedPath.Split(new[] { FOLDER_SEPARATOR_CHAR }, StringSplitOptions.RemoveEmptyEntries);
if (names.Length == 0)
{
return(transformResult); //None
}
string bestMatchingPath = null;
string correctPath = null;
var contentId = default(int);
var bestMatchingCategoryId = default(int);
var categores = dbContext.Categories.AsNoTracking();
foreach (var name in names)
{
var categoryId = default(int);
var currentPath = name;
if (bestMatchingPath == null) //first entry
{
if (MenuDictionary.ContainsKey(name))
{
categoryId = MenuDictionary[name];
}
}
else
{
currentPath = bestMatchingPath + "/" + name;
}
//let check if name is in idNumber-aliasString format
var match = Regex.Match(name, @"^(\d+)-(.*)$");
Expression <Func <Category, bool> > categoryPredicate = c => c.Path == currentPath;
int id = 0;
if (match.Success && match.Groups.Count > 2)
{
id = int.Parse(match.Groups[1].Value);
//name = match.Groups[2].Value;
categoryPredicate = c => c.Id == id; // && c.Alias == name;
}
if (categoryId == default(int))
{
//The midleware will try to find a Category in the database that matches the current Path
categoryId = await categores
.Where(categoryPredicate)
.Select(c => c.Id)
.FirstOrDefaultAsync();
}
if (categoryId == default(int)) //name may be content name
{
Expression <Func <Content, bool> > contentPredicate = c => c.Alias.Contains(name);
if (id != 0)
{
contentPredicate = c => c.Id == id; // || c.Alias.Contains(name);
}
//The midleware will try to find a content in the database that matches the current name
var contents = dbContext.Contents.AsNoTracking();
var content = await contents
.Where(contentPredicate)
.Select(c => new { c.Id, c.CatId, c.Alias })
.FirstOrDefaultAsync();
if (content == null)
{
break;
}
contentId = content.Id;
correctPath = await categores.GetCategoryPath(content.CatId) + "/" + content.Alias;
break;
}
bestMatchingPath = currentPath;
bestMatchingCategoryId = categoryId;
}
if (contentId != default(int))
{
contextItems[CATEGORY_ID] = contentId;
if (correctPath == path)
{
return(new TransformResult(HOME_CONTENT_URL + contentId, TransformAction.Substitute));
}
}
else if (bestMatchingCategoryId != default(int))
{
contextItems[CATEGORY_ID] = bestMatchingCategoryId;
correctPath = await categores.GetCategoryPath(bestMatchingCategoryId);
if (correctPath == path)
{
return(new TransformResult(HOME_CONTENT_URL + bestMatchingCategoryId, TransformAction.Substitute));
}
}
else
{
return(transformResult); //None
}
return(new TransformResult(correctPath, TransformAction.Redirect));
}
private static void kafkaProducer(string message)
{
var serv = new ServiceRouting();
var routing = serv.GetRouting(message).Result;
var json = "empty:" + routing.Code;
var data = new TransformResult();
var trans = new Transformation();
var req = "";
var url = "";
//create connetion
if (routing.Code == 200)
{
switch (routing.Data.Type)
{
case "REST-GET":
url = $"{routing.Data.Url}/{message}";
data = serv.ConsumeRest(url).Result;
json = trans.Execute(data, routing.Data.Template);
break;
case "REST-POST":
var vrest = message.Split('#');
url = $"{routing.Data.Url}/{vrest[0]}";
req = trans.CreateRequest(routing.Data.RequestTemplate, routing.Data.NumRequest, vrest);
data = serv.ConsumeRest(url, req, ServiceRouting.HttpUseMethod.POST).Result;
json = trans.Execute(data, routing.Data.Template);
break;
case "REST-DELETE":
var vdel = message.Split('#');
url = $"{routing.Data.Url}/{vdel[0]}";
req = trans.CreateRequest(routing.Data.RequestTemplate, routing.Data.NumRequest, vdel);
data = serv.ConsumeRest(url, req, ServiceRouting.HttpUseMethod.DELETE).Result;
json = trans.Execute(data, routing.Data.Template);
break;
case "SOAP-GET":
req = trans.CreateRequest(routing.Data.RequestTemplate, routing.Data.NumRequest, message);
data = serv.ConsumeSoap(routing.Data.Url, req).Result;
json = CallSOAP(data.Result, routing.Data.Template);
break;
case "SOAP-POST":
var vpost = message.Split('#');
req = trans.CreateRequest(routing.Data.RequestTemplate, routing.Data.NumRequest, vpost);
data = serv.ConsumeSoap(routing.Data.Url, req).Result;
json = CallSOAP(data.Result, routing.Data.Template);
break;
}
}
using (var producer = new Producer <Null, string>(producerConfigSend, null, new StringSerializer(Encoding.UTF8)))
{
var dr = producer.ProduceAsync(kafkaTopicSend, null, json).Result;
Console.WriteLine($"Message send to kafka: {json}");
}
}
