private async Task RunNegativeRdfTest(CsvwTestDescription test)
{
var actual = new Graph();
var insertHandler = new GraphHandler(actual);
var errorMessages = new List <string>();
// Set up converter
var converter = new Converter(
insertHandler,
new DefaultResolver(),
test.Options.Minimal ? ConverterMode.Minimal : ConverterMode.Standard,
errorMessage => errorMessages.Add(errorMessage),
suppressStringDatatype: true);
if (test.Options.Metadata != null)
{
var localMetadata = File.ReadAllText(test.Options.Metadata.LocalPath);
await converter.ConvertWithLocalMetadata(new Uri(_baseUri, test.Action.Uri), new HttpClient(), localMetadata);
}
else
{
await converter.ConvertAsync(new Uri(_baseUri, test.Action.Uri), new HttpClient());
}
Assert.NotEmpty(errorMessages);
}
public static void Load(this IRdfReader parser, GraphHandler handler, string filename)
{
using (var inputStream = new StreamReader(filename))
{
parser.Load(handler, inputStream);
}
}
/// <summary>
/// This method fixes the chromosome - there could be cycles before => this method removes the cycles
/// using graph.
/// </summary>
public void FixChromosome()
{
if (Fitness != null)
{
return;
}
var graphHandler = new GraphHandler();
// in order to fix the chromosome we need to create graph and remove cycles from it
// cycles are removed by rotating edges of the cycle until there is no cycle
var graph = graphHandler.CreateGraph(this);
graphHandler.BreakCycles(graph);
// update the chromosome => get topologically sorted graph and rewrite values in machine indices
var topologicalOrder = graphHandler.GetTopologicalOrder(graph);
var machineIndices = new int[JobShop.MachinesCount];
var machineChromosomes = GetGenes().Select(x => x.Value).Cast <MachineChromosome>().ToList();
foreach (var operation in topologicalOrder.Where(x => x.Id > int.MinValue && x.Id < int.MaxValue))
{
int machineId = operation.MachineId;
ref int machineOperationIndex = ref machineIndices[machineId];
machineChromosomes[machineId].ReplaceGene(machineOperationIndex, new Gene(operation));
machineOperationIndex++;
}
public async Task <JsonResult> getData(string json = null)
{
Error.TraceStart();
string controllerName = this.ControllerContext.RouteData.Values["controller"].ToString();
//Error.TraceLog("GraphController.getData, point1");
StreamReader stream = new StreamReader(Request.InputStream);
if (json == null)
{
json = stream.ReadToEnd();
}
if (json != "")
{
object data = new object();
DataRequest dataRequest = new JavaScriptSerializer().Deserialize <DataRequest>(json);
Error.TraceLog("GraphController.getData, point1");
try
{
GraphHandler GH = new GraphHandler();
DataRequest dataResponse = await GH.proceedSQLquery(dataRequest, config);
Error.TraceLog("GraphController.getData, point2");
if ((dataRequest.beginTime + dataRequest.timeAxisLength) <= AlarmHelper.DateTimeTopkTime(DateTime.Now))
{
if (dataResponse.tags.All(p => p.vals.All(q => (q == double.MaxValue)) == true))
{
for (int i = 0; i < dataResponse.tags.Count; i++)
{
dataResponse.tags[i].vals = null;
}
}
}
data = dataResponse;
Error.TraceLog("GraphController.getData, point3");
return(Json(data, "application/json", JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
data = dataRequest;
string k = e.Message.ToString() + e.Source.ToString() + e.StackTrace.ToString();
string name = this.ControllerContext.RouteData.Values["controller"].ToString();
Error.toFile(k, name);
Session["tempforview"] = Error.timestamp + " Error " + MvcApplication.ErrorId.ToString() + " occured so please try it again after some time"; //To screen also with id
return(Json(data, "application/json", JsonRequestBehavior.AllowGet));
}
}
else
{
return(null);
}
}
private static IGraph executeGraphQuery(string sparql, string infer)
{
IGraph result = new Graph();
using (GraphDBConnector connector = new GraphDBConnector($"infer={infer}"))
{
connector.Timeout = 180 * 1000;
GraphHandler rdfHandler = new GraphHandler(result);
connector.Query(rdfHandler, null, sparql);
}
return(result);
}
private static IGraph Load(string source)
{
var result = new Graph();
var graphHandler = new GraphHandler(result);
var strippingHandler = new StripStringHandler(graphHandler);
var parser = new TurtleParser();
using (var reader = new StringReader(source))
{
parser.Load(strippingHandler, reader);
}
return(result);
}
public Home(FileStoreManager fileStore, IController controller)
{
_fileStore = fileStore;
_controller = controller;
InitializeComponent();
_highlightedMonth = DateTime.Today;
_plotter = new GraphHandler(monthPlot, controller);
viewer.Controller = controller;
_toolTipHandler = new ToolTipHandler();
controller.AddView(this);
}
private void TestGraphHandler(ISparqlQueryProcessor processor, String query)
{
SparqlQuery q = this._parser.ParseFromString(query);
Graph expected = processor.ProcessQuery(q) as Graph;
Assert.NotNull(expected);
Graph actual = new Graph();
GraphHandler handler = new GraphHandler(actual);
processor.ProcessQuery(handler, null, q);
Assert.Equal(expected, actual);
}
private void NavigateLudkoncentration()
{
ResetMange();
LudkoncentrationVisibility = Visibility.Visible;
OnPropertyChanged(nameof(LudkoncentrationVisibility));
GraphHandler g = new GraphHandler();
Graf = g.DrawLudKoncentration(0);
GrafTwo = null;
GraphHolder = "LK";
SorteringsValg = "Alle";
}
private void NavigateVægt()
{
ResetMange();
VægtVisibility = Visibility.Visible;
OnPropertyChanged(nameof(VægtVisibility));
GraphHandler g = new GraphHandler();
Graf = g.DrawVægt(0, "30L");
GrafTwo = g.DrawVægt(0, "25L");
GraphHolder = "VA";
SorteringsValg = "Alle";
}
private void NavigateMs()
{
ResetMange();
MsVisiblity = Visibility.Visible;
OnPropertyChanged(nameof(MsVisiblity));
GraphHandler g = new GraphHandler();
Graf = g.DrawMs(0);
GrafTwo = null;
GraphHolder = "MS";
SorteringsValg = "Alle";
}
public void ParsingRdfXmlStreamingDoesNotExhaustMemory()
{
IGraph g = new Graph();
GraphHandler graphHandler = new GraphHandler(g);
PagingHandler paging = new PagingHandler(graphHandler, 1000);
CountHandler counter = new CountHandler();
ChainedHandler handler = new ChainedHandler(new IRdfHandler[] { paging, counter });
GZippedRdfXmlParser parser = new GZippedRdfXmlParser(RdfXmlParserMode.Streaming);
parser.Load(handler, @"resources\oom.rdf.gz");
Assert.False(g.IsEmpty);
Assert.Equal(1000, counter.Count);
// Note that the source produces some duplicate triples so triples in the graph will be at most 1000
Assert.True(g.Triples.Count <= 1000);
}
private double Evaluate(ScheduleChromosome chromosome)
{
if (chromosome.Fitness != null)
{
return(chromosome.Fitness.Value);
}
// create graph
chromosome.FixChromosome();
var graph = chromosome.Graph;
double scheduleLength = new GraphHandler().GetMaximumCost(graph, chromosome.TopologicalOrder);
chromosome.ScheduleLength = scheduleLength;
chromosome.Fitness = 1 / (scheduleLength + 1);
return(chromosome.Fitness.Value);
}
private void TestGraphHandler(ISparqlQueryProcessor processor, String query)
{
SparqlQuery q = this._parser.ParseFromString(query);
Graph expected = processor.ProcessQuery(q) as Graph;
if (expected == null)
{
Assert.Fail("Query failed to return a Grah as expected");
}
Graph actual = new Graph();
GraphHandler handler = new GraphHandler(actual);
processor.ProcessQuery(handler, null, q);
Assert.AreEqual(expected, actual, "Graphs should be equal");
}
private async Task RunToRdfTest(CsvwTestDescription test, bool expectWarnings)
{
var expect = new Graph();
expect.LoadFromUri(new Uri(_baseUri, test.Result.Uri));
var actual = new Graph();
var insertHandler = new GraphHandler(actual);
var errorMessages = new List <string>();
// Set up converter
var converter = new Converter(
insertHandler,
new DefaultResolver(),
test.Options.Minimal ? ConverterMode.Minimal : ConverterMode.Standard,
errorMessage => errorMessages.Add(errorMessage),
suppressStringDatatype: true);
if (test.Options.Metadata != null)
{
var localMetadata = File.ReadAllText(test.Options.Metadata.LocalPath);
await converter.ConvertWithLocalMetadata(new Uri(_baseUri, test.Action.Uri), new HttpClient(), localMetadata);
}
else
{
await converter.ConvertAsync(new Uri(_baseUri, test.Action.Uri), new HttpClient());
}
//var tableGroup = new TableGroup();
//var table = new Table(tableGroup) {Url = new Uri(_baseUri, test.Action.Uri)};
//await converter.ConvertAsync(tableGroup, new DefaultResolver());
converter.Errors.Should().BeEmpty("expected no errors during conversion");
var differ = new GraphDiff();
NormalizeLiterals(expect);
NormalizeLiterals(actual);
var graphDiff = differ.Difference(expect, actual);
// Assert graphs are equal
//actual.Triples.Count.Should().Be(expect.Triples.Count,
// "Count of triples in output graph should match the count of triples in the expected result graph");
//Assert.Equal(expect.Triples.Count, actual.Triples.Count);
Assert.True(graphDiff.AreEqual, "Expected graphs to be the same.\n" + ReportGraphDiff(graphDiff));
}
/// <inheritdoc />
public object Query(string sparqlQuery)
{
var graph = new Graph();
var graphHandler = new GraphHandler(graph);
var resultSet = new SparqlResultSet();
var resultSetHandler = new ResultSetHandler(resultSet);
Query(graphHandler, resultSetHandler, sparqlQuery);
if (resultSet.ResultsType != SparqlResultsType.Unknown)
{
return(resultSet);
}
else
{
return(graph);
}
}
/// <summary>
/// Pushes the current in-scope Graph onto the Graph stack and creates a new empty Graph to be the in-scope Graph.
/// </summary>
/// <remarks>
/// Used for Graph Literal parsing - Base Uri and Namespace Maps of the outermost Graph is propogated to the innermost Graph.
/// </remarks>
public void PushGraph()
{
Graph h = new Graph();
h.NamespaceMap.Import(Namespaces);
h.BaseUri = BaseUri;
_handlers.Push(_handler);
_handler = new GraphHandler(h);
_handler.StartRdf();
_subgraphs.Push(_g);
_g = h;
VariableContext v = new VariableContext(VariableContextType.None);
_varContexts.Push(_varContext);
_varContext = v;
}
public void SetUp()
{
jobShop = new JobShopLoader().Load("TestExamples/test1.in", false);
chromosome = new ScheduleChromosome(jobShop);
var machineChromosome1 = new MachineChromosome(new int[]
{
4, 5, 0, 2
}.Select(x => jobShop.Operations[x]).ToArray());
chromosome.ReplaceGene(0, new Gene(machineChromosome1));
var machineChromosome2 = new MachineChromosome(new int[]
{
1, 3
}.Select(x => jobShop.Operations[x]).ToArray());
chromosome.ReplaceGene(1, new Gene(machineChromosome2));
graphHandler = new GraphHandler();
}
public async void TestValidConversions(string tableMetadataPath, string csvFilePath,
string expectedOutputGraphPath)
{
var metadataParser =
new JsonMetadataParser(new DefaultResolver(), new Uri("http://example.org/metadata.json"));
tableMetadataPath = Path.Combine("data", tableMetadataPath);
csvFilePath = Path.Combine("data", csvFilePath);
expectedOutputGraphPath = Path.Combine("data", expectedOutputGraphPath);
TableGroup tableGroup;
using (var metadataReader = File.OpenText(tableMetadataPath))
{
tableGroup = metadataParser.Parse(metadataReader);
}
tableGroup.Should().NotBeNull();
tableGroup.Tables.Should().HaveCount(1);
var tableMeta = tableGroup.Tables[0];
tableMeta.Should().NotBeNull(because: "The metadata file should parse as table metadata");
var outputGraph = new Graph();
var graphHandler = new GraphHandler(outputGraph);
var resolverMock = new Mock <ITableResolver>();
resolverMock.Setup(x => x.ResolveAsync(It.IsAny <Uri>())).Returns(Task.FromResult(File.OpenRead(csvFilePath) as Stream));
var converter = new Converter(graphHandler, resolverMock.Object, ConverterMode.Minimal);
await converter.ConvertAsync(tableMeta.Parent as TableGroup);
converter.Errors.Count.Should().Be(0, "Expected 0 errors. Got {0}. Error listing is:\n{1}", converter.Errors.Count, string.Join("\n", converter.Errors));
var turtleParser = new TurtleParser(TurtleSyntax.W3C);
var expectGraph = new Graph();
turtleParser.Load(expectGraph, expectedOutputGraphPath);
var diff = new GraphDiff();
var diffReport = diff.Difference(expectGraph, outputGraph);
diffReport.AreEqual.Should().BeTrue("Graphs differ");
}
private async Task <Graph> GenerateDatasetGraphAsync(string csvPath, JObject metadataJson, Uri metadataUri)
{
var parser = new JsonMetadataParser(null, metadataUri);
var tableGroup = new TableGroup();
try
{
var tableMeta = parser.ParseTable(tableGroup, metadataJson);
if (tableMeta == null)
{
throw new WorkerException("CSV Conversion failed. Unable to read CSV table metadata.");
}
}
catch (MetadataParseException ex)
{
Log.Error(ex, "Invalid CSV table metadata: " + ex.Message);
throw new WorkerException(ex, "CSV conversion failed. Invalid CSV table metadata: " + ex.Message);
}
var graph = new Graph();
ProgressLog.Info("Running CSV to RDF conversion");
var graphHandler = new GraphHandler(graph);
var tableResolver = new LocalTableResolver(tableGroup.Tables[0].Url, csvPath);
var converter = new Converter(graphHandler, tableResolver, ConverterMode.Minimal, (msg) => ProgressLog.Error(msg), this, reportInterval: CsvConversionReportInterval);
await converter.ConvertAsync(tableGroup);
if (converter.Errors.Any())
{
foreach (var e in converter.Errors)
{
ProgressLog.Error(e);
}
throw new WorkerException("One or more errors where encountered during the CSV to RDF conversion.");
}
return(graph);
}
public FindPathCommand(Func <DesiredPathData> desiredPathDataFunc, Action <PathfindingResult> finalAction, GraphHandler graphHandler)
{
getDesiredPathData = desiredPathDataFunc;
this.finalAction = finalAction;
this.graphHandler = graphHandler;
}
/// <summary>
/// Runs the task
/// </summary>
/// <returns></returns>
protected override TaskResult RunTaskInternal()
{
if (this.Target.IsReadOnly)
{
throw new RdfStorageException("Cannot Copy/Move a Graph when the Target is a read-only Store!");
}
switch (this.Name)
{
case "Rename":
case "Move":
//Move/Rename a Graph
if (ReferenceEquals(this.Source, this.Target) && this.Source.StorageProvider is IUpdateableStorage)
{
//If the Source and Target are identical and it supports SPARQL Update natively then we'll just issue a MOVE command
this.Information = "Issuing a MOVE command to rename Graph '" + this._sourceUri.ToSafeString() + "' to '" + this._targetUri.ToSafeString() + "'";
SparqlParameterizedString update = new SparqlParameterizedString {
CommandText = "MOVE"
};
if (this._sourceUri == null)
{
update.CommandText += " DEFAULT TO";
}
else
{
update.CommandText += " GRAPH @source TO";
update.SetUri("source", this._sourceUri);
}
if (this._targetUri == null)
{
update.CommandText += " DEFAULT";
}
else
{
update.CommandText += " GRAPH @target";
update.SetUri("target", this._targetUri);
}
((IUpdateableStorage)this.Source.StorageProvider).Update(update.ToString());
this.Information = "MOVE command completed OK, Graph renamed to '" + this._targetUri.ToSafeString() + "'";
}
else
{
//Otherwise do a load of the source graph writing through to the target graph
IRdfHandler handler;
IGraph g = null;
if (this.Target.StorageProvider.UpdateSupported)
{
//If Target supports update then we'll use a WriteToStoreHandler combined with a GraphUriRewriteHandler
handler = new WriteToStoreHandler(this.Target.StorageProvider, this._targetUri);
handler = new GraphUriRewriteHandler(handler, this._targetUri);
}
else
{
//Otherwise we'll use a GraphHandler and do a save at the end
g = new Graph();
handler = new GraphHandler(g);
}
handler = new CopyMoveProgressHandler(handler, this, "Moving", this.Target.StorageProvider.UpdateSupported);
this._canceller = new CancellableHandler(handler);
if (this.HasBeenCancelled)
{
this._canceller.Cancel();
}
//Now start reading out the data
this.Information = "Copying data from Graph '" + this._sourceUri.ToSafeString() + "' to '" + this._targetUri.ToSafeString() + "'";
this.Source.StorageProvider.LoadGraph(this._canceller, this._sourceUri);
//If we weren't moving the data directly need to save the resulting graph now
if (g != null)
{
this.Information = "Saving copied data to Target Store...";
this.Target.StorageProvider.SaveGraph(g);
}
//And finally since we've done a copy (not a move) so far we need to delete the original graph
//to effect a rename
if (this.Source.StorageProvider.DeleteSupported)
{
this.Information = "Removing source graph to complete the move operation";
this.Source.StorageProvider.DeleteGraph(this._sourceUri);
this.Information = "Move completed OK, Graph moved to '" + this._targetUri.ToSafeString() + "'" + (ReferenceEquals(this.Source, this.Target) ? String.Empty : " on " + this.Target);
}
else
{
this.Information = "Copy completed OK, Graph copied to '" + this._targetUri.ToSafeString() + "'" + (ReferenceEquals(this.Source, this.Target) ? String.Empty : " on " + this.Target) + ". Please note that as the Source Triple Store does not support deleting Graphs so the Graph remains present in the Source Store";
}
}
break;
case "Copy":
if (ReferenceEquals(this.Source, this.Target) && this.Source.StorageProvider is IUpdateableStorage)
{
//If the Source and Target are identical and it supports SPARQL Update natively then we'll just issue a COPY command
this.Information = "Issuing a COPY command to copy Graph '" + this._sourceUri.ToSafeString() + "' to '" + this._targetUri.ToSafeString() + "'";
SparqlParameterizedString update = new SparqlParameterizedString();
update.CommandText = "COPY";
if (this._sourceUri == null)
{
update.CommandText += " DEFAULT TO";
}
else
{
update.CommandText += " GRAPH @source TO";
update.SetUri("source", this._sourceUri);
}
if (this._targetUri == null)
{
update.CommandText += " DEFAULT";
}
else
{
update.CommandText += " GRAPH @target";
update.SetUri("target", this._targetUri);
}
((IUpdateableStorage)this.Source.StorageProvider).Update(update.ToString());
this.Information = "COPY command completed OK, Graph copied to '" + this._targetUri.ToSafeString() + "'";
}
else
{
//Otherwise do a load of the source graph writing through to the target graph
IRdfHandler handler;
IGraph g = null;
if (this.Target.StorageProvider.UpdateSupported)
{
//If Target supports update then we'll use a WriteToStoreHandler combined with a GraphUriRewriteHandler
handler = new WriteToStoreHandler(this.Target.StorageProvider, this._targetUri);
handler = new GraphUriRewriteHandler(handler, this._targetUri);
}
else
{
//Otherwise we'll use a GraphHandler and do a save at the end
g = new Graph();
handler = new GraphHandler(g);
}
handler = new CopyMoveProgressHandler(handler, this, "Copying", this.Target.StorageProvider.UpdateSupported);
this._canceller = new CancellableHandler(handler);
if (this.HasBeenCancelled)
{
this._canceller.Cancel();
}
//Now start reading out the data
this.Information = "Copying data from Graph '" + this._sourceUri.ToSafeString() + "' to '" + this._targetUri.ToSafeString() + "'";
this.Source.StorageProvider.LoadGraph(this._canceller, this._sourceUri);
//If we weren't moving the data directly need to save the resulting graph now
if (g != null)
{
this.Information = "Saving copied data to Store...";
this.Target.StorageProvider.SaveGraph(g);
}
this.Information = "Copy completed OK, Graph copied to '" + this._targetUri.ToSafeString() + "'" + (ReferenceEquals(this.Source, this.Target) ? String.Empty : " on " + this.Target.ToString());
}
break;
}
return(new TaskResult(true));
}