/// <summary>
/// Applies SPARQL Updates to the Store
/// </summary>
/// <param name="sparqlUpdate">SPARQL Update</param>
public void Update(String sparqlUpdate)
{
if (this._updateParser == null)
{
this._updateParser = new SparqlUpdateParser();
}
SparqlUpdateCommandSet cmds = this._updateParser.ParseFromString(sparqlUpdate);
if (this._updateProcessor == null)
{
this._updateProcessor = new LeviathanUpdateProcessor(this._dataset);
}
this._updateProcessor.ProcessCommandSet(cmds);
}
public void SparqlParameterizedString()
{
String test = @"INSERT DATA { GRAPH @graph {
<http://uri> <http://uri> <http://uri>
}}";
SparqlParameterizedString cmdString = new SparqlParameterizedString(test);
cmdString.SetUri("graph", new Uri("http://example.org/graph"));
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString(cmdString);
cmds.ToString();
}
/// <summary>
/// Processes a PATCH operation
/// </summary>
/// <param name="context">HTTP Context</param>
public override void ProcessPatch(IHttpContext context)
{
//Work out the Graph URI we want to patch
Uri graphUri = this.ResolveGraphUri(context);
//If the Request has the SPARQL Update MIME Type then we can process it
if (context.Request.ContentLength > 0)
{
if (context.Request.ContentType.Equals("application/sparql-update"))
{
//Try and parse the SPARQL Update
//No error handling here as we assume the calling IHttpHandler does that
String patchData;
using (StreamReader reader = new StreamReader(context.Request.InputStream))
{
patchData = reader.ReadToEnd();
reader.Close();
}
SparqlUpdateCommandSet cmds = this._parser.ParseFromString(patchData);
//Assuming that we've got here i.e. the SPARQL Updates are parseable then
//we need to check that they actually affect the relevant Graph
if (cmds.Commands.All(c => c.AffectsSingleGraph && c.AffectsGraph(graphUri)))
{
this._updateProcessor.ProcessCommandSet(cmds);
this._updateProcessor.Flush();
}
else
{
//One/More commands either do no affect a Single Graph or don't affect the Graph
//implied by the HTTP Request so give a 422 response
context.Response.StatusCode = 422;
return;
}
}
else
{
//Don't understand other forms of PATCH requests
context.Response.StatusCode = (int)HttpStatusCode.UnsupportedMediaType;
return;
}
}
else
{
//Empty Request is a Bad Request
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
}
/// <summary>
/// Processes a POST operation which adds triples to a new Graph in the Store and returns the URI of the newly created Graph
/// </summary>
/// <param name="context">HTTP Context</param>
/// <remarks>
/// <para>
/// This operation allows clients to POST data to an endpoint and have it create a Graph and assign a URI for them.
/// </para>
/// </remarks>
public override void ProcessPostCreate(IHttpContext context)
{
//Get the payload assuming there is one
IGraph g = this.ParsePayload(context);
//Mint a URI for the Graph
Uri graphUri = this.MintGraphUri(context, g);
//First generate a CREATE to ensure that the Graph exists
//We don't do a CREATE SILENT as this operation is supposed to generate a new Graph URI
//so if MintGraphUri() fails to deliver a unused Graph URI then the operation should fail
StringBuilder insert = new StringBuilder();
insert.AppendLine("CREATE GRAPH @graph ;");
//Then Generate an INSERT DATA command for the actual POST
//Note that if the payload is empty this still has the effect of creating a Graph
if (g != null)
{
insert.AppendLine("INSERT DATA { GRAPH @graph {");
TurtleFormatter formatter = new TurtleFormatter(g.NamespaceMap);
foreach (Triple t in g.Triples)
{
insert.AppendLine(t.ToString(formatter));
}
insert.AppendLine("} }");
}
//Parse and evaluate the command
SparqlParameterizedString insertCmd = new SparqlParameterizedString(insert.ToString());
insertCmd.Namespaces = g.NamespaceMap;
insertCmd.SetUri("graph", graphUri);
SparqlUpdateCommandSet cmds = this._parser.ParseFromString(insertCmd);
this._updateProcessor.ProcessCommandSet(cmds);
this._updateProcessor.Flush();
//Finally return a 201 Created and a Location header with the new Graph URI
context.Response.StatusCode = (int)HttpStatusCode.Created;
try
{
context.Response.Headers.Add("Location", graphUri.AbsoluteUri);
}
catch (PlatformNotSupportedException)
{
context.Response.AddHeader("Location", graphUri.AbsoluteUri);
}
}
public void SparqlDatasetDefaultGraphManagementWithUpdate()
{
TripleStore store = new TripleStore();
Graph g = new Graph();
store.Add(g);
Graph h = new Graph();
h.BaseUri = new Uri("http://example.org/someOtherGraph");
store.Add(h);
InMemoryDataset dataset = new InMemoryDataset(store, h.BaseUri);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString("LOAD <http://www.dotnetrdf.org/configuration#>");
processor.ProcessCommandSet(cmds);
Assert.True(g.IsEmpty, "Graph with null URI (normally the default Graph) should be empty as the Default Graph for the Dataset should have been a named Graph so this Graph should not have been filled by the LOAD Command");
Assert.False(h.IsEmpty, "Graph with name should be non-empty as it should have been the Default Graph for the Dataset and so filled by the LOAD Command");
}
public void SparqlUpdateModify()
{
TripleStore store = new TripleStore();
Graph g = new Graph();
FileLoader.Load(g, "InferenceTest.ttl");
g.BaseUri = null;
store.Add(g);
IUriNode rdfType = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
Assert.AreNotEqual(0, store.GetTriplesWithPredicate(rdfType).Count(), "Store should contain some rdf:type Triples");
String update = "DELETE {?s a ?type} WHERE {?s a ?type}";
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString(update);
store.ExecuteUpdate(cmds);
Assert.AreEqual(0, store.GetTriplesWithPredicate(rdfType).Count(), "Store should contain no rdf:type Triples after DELETE command executes");
}
public void SparqlDatasetDefaultGraphManagementWithUpdate2()
{
TripleStore store = new TripleStore();
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org/graph");
store.Add(g);
Graph h = new Graph();
h.BaseUri = new Uri("http://example.org/someOtherGraph");
store.Add(h);
InMemoryDataset dataset = new InMemoryDataset(store, h.BaseUri);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString("LOAD <http://www.dotnetrdf.org/configuration#> INTO GRAPH <http://example.org/graph>");
processor.ProcessCommandSet(cmds);
Assert.False(g.IsEmpty, "First Graph should not be empty as should have been filled by the LOAD command");
Assert.True(h.IsEmpty, "Second Graph should be empty as should not have been filled by the LOAD command");
}
/// <summary>
/// Elimina los triples http://purl.org/roh/mirror/foaf#primaryTopic del RDF a cargar y los triples que tenían cagados en la BBDD
/// </summary>
/// <param name="pDataGraph">Grafo con los datos a cargar</param>
/// <returns>Lista de grafos afectados</returns>
private HashSet <string> RemovePrimaryTopics(ref RohGraph pDataGraph)
{
HashSet <string> graphs = new HashSet <string>();
List <string> mainEntities = new List <string>();
string query = @"select distinct * where{?s <http://purl.org/roh/mirror/foaf#primaryTopic> ""true""^^<http://www.w3.org/2001/XMLSchema#boolean>}";
SparqlResultSet sparqlResultSet = (SparqlResultSet)pDataGraph.ExecuteQuery(query.ToString());
foreach (SparqlResult sparqlResult in sparqlResultSet.Results)
{
mainEntities.Add(sparqlResult["s"].ToString());
}
//Se eliminan todas las referncias a las entidades principales
if (mainEntities.Count > 0)
{
foreach (string mainEntity in mainEntities)
{
graphs.UnionWith(DeleteUpdatedEntity(mainEntity));
}
}
//Eliminamos el triple que marca las entidades principales para que no se inserte en la BBDD
{
TripleStore store = new TripleStore();
store.Add(pDataGraph);
SparqlUpdateParser parser = new SparqlUpdateParser();
//Actualizamos los sujetos
SparqlUpdateCommandSet updateSubject = parser.ParseFromString(
@" DELETE { ?s ?p ?o. }
WHERE
{
?s ?p ?o. FILTER(?p =<http://purl.org/roh/mirror/foaf#primaryTopic>)
}");
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(store);
processor.ProcessCommandSet(updateSubject);
}
return(graphs);
}
public void SparqlDatasetDefaultGraphManagementWithUpdate5()
{
TripleStore store = new TripleStore();
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org/graph");
store.Add(g);
Graph h = new Graph();
h.BaseUri = new Uri("http://example.org/someOtherGraph");
store.Add(h);
InMemoryDataset dataset = new InMemoryDataset(store, h.BaseUri);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString("LOAD <http://www.dotnetrdf.org/configuration#>; WITH <http://example.org/graph> INSERT { ?s a ?type } USING <http://example.org/someOtherGraph> WHERE { ?s a ?type }; DELETE WHERE { ?s a ?type }");
processor.ProcessCommandSet(cmds);
Assert.False(g.IsEmpty, "First Graph should not be empty as should have been filled by the INSERT command");
Assert.False(h.IsEmpty, "Second Graph should not be empty as should not have been filled by the LOAD command");
Assert.False(h.HasSubGraph(g), "First Graph should not be a subgraph of the Second Graph as the DELETE should have eliminated the subgraph relationship");
}
private void RunUpdate(SparqlUpdateCommandSet cmds, ISparqlUpdateProcessor processor)
{
processor.ProcessCommandSet(cmds);
}
/// <summary>
/// Processes SPARQL Updates
/// </summary>
/// <param name="cmds">Update Command Set</param>
/// <remarks>
/// <para>
/// Implementations should override this method if their behaviour requires more than just invoking the configured Update processor
/// </para>
/// </remarks>
protected virtual void ProcessUpdates(SparqlUpdateCommandSet cmds)
{
this._config.Processor.ProcessCommandSet(cmds);
}
/// <summary>
/// Attempt to auto-detect the syntax of the current document using the filename as a guide
/// </summary>
public void AutoDetectSyntax(String filename)
{
if (this._editor == null)
{
return; //Not yet ready
}
if (filename == null || System.IO.Path.GetExtension(filename).Equals(String.Empty))
{
try
{
//First see if it's an RDF format
IRdfReader parser = StringParser.GetParser(this._editor.Text);
if (parser is NTriplesParser)
{
//NTriples is the fallback so if we get this check if it's actually SPARQL Results
try
{
ISparqlResultsReader sparqlParser = StringParser.GetResultSetParser(this._editor.Text);
}
catch (RdfParserSelectionException)
{
//Not a valid SPARQL Results format - may be a SPARQL Query or a SPARQL Update?
SparqlQueryParser queryParser = new SparqlQueryParser(SparqlQuerySyntax.Sparql_1_1);
try
{
SparqlQuery q = queryParser.ParseFromString(this._editor.Text);
this.SetHighlighter("SparqlQuery11");
}
catch (RdfParseException)
{
//Not a valid SPARQL Query - valid SPARQL Update?
SparqlUpdateParser updateParser = new SparqlUpdateParser();
try
{
SparqlUpdateCommandSet cmds = updateParser.ParseFromString(this._editor.Text);
this.SetHighlighter("SparqlUpdate11");
}
catch (RdfParseException)
{
//Was probably actually NTriples
this.SetHighlighter(parser);
}
}
}
}
else
{
//Got a non NTriples RDF parser so use that to set Highlighter
this.SetHighlighter(parser);
}
}
catch (RdfParserSelectionException)
{
this.SetNoHighlighting();
}
return;
}
try
{
IHighlightingDefinition def = HighlightingManager.Instance.GetDefinitionByExtension(System.IO.Path.GetExtension(filename));
if (this._enableHighlighting)
{
this._editor.SyntaxHighlighting = def;
}
if (def != null)
{
this._currSyntax = def.Name;
this.SetCurrentHighlighterChecked(def.Name);
this.SetCurrentValidator(def.Name);
this.SetCurrentAutoCompleter(def.Name);
}
else
{
this.SetNoHighlighting();
}
}
catch
{
this.SetNoHighlighting();
}
}
/// <summary>
/// Returns that the optimiser is applicable
/// </summary>
/// <param name="cmds">Update Commands</param>
/// <returns></returns>
public bool IsApplicable(SparqlUpdateCommandSet cmds)
{
return(PropertyFunctionFactory.FactoryCount > 0);
}
/// <summary>
/// Processes a PUT operation
/// </summary>
/// <param name="context">HTTP Context</param>
public override void ProcessPut(IHttpContext context)
{
//Get the payload assuming there is one
IGraph g = this.ParsePayload(context);
//Get the Graph URI of the Graph to be added
Uri graphUri = this.ResolveGraphUri(context, g);
//Determine whether the Graph already exists or not, if it doesn't then we have to send a 201 Response
bool created = false;
try
{
SparqlQueryParser parser = new SparqlQueryParser();
SparqlParameterizedString graphExistsQuery = new SparqlParameterizedString();
graphExistsQuery.CommandText = "ASK WHERE { GRAPH @graph { } }";
graphExistsQuery.SetUri("graph", graphUri);
Object temp = this._queryProcessor.ProcessQuery(parser.ParseFromString(graphExistsQuery));
if (temp is SparqlResultSet)
{
created = !((SparqlResultSet)temp).Result;
}
}
catch
{
//If any error occurs assume the Graph doesn't exist and so we'll return a 201 created
created = true;
}
//Generate a set of commands based upon this
StringBuilder cmdSequence = new StringBuilder();
if (graphUri != null)
{
cmdSequence.AppendLine("DROP SILENT GRAPH @graph ;");
cmdSequence.Append("CREATE SILENT GRAPH @graph");
}
else
{
cmdSequence.Append("DROP SILENT DEFAULT");
}
if (g != null)
{
cmdSequence.AppendLine(" ;");
if (graphUri != null)
{
cmdSequence.AppendLine("INSERT DATA { GRAPH @graph {");
}
else
{
cmdSequence.AppendLine("INSERT DATA { ");
}
TurtleFormatter formatter = new TurtleFormatter(g.NamespaceMap);
foreach (Triple t in g.Triples)
{
cmdSequence.AppendLine(t.ToString(formatter));
}
if (graphUri != null)
{
cmdSequence.AppendLine("} }");
}
else
{
cmdSequence.AppendLine("}");
}
}
SparqlParameterizedString put = new SparqlParameterizedString(cmdSequence.ToString());
put.Namespaces = g.NamespaceMap;
if (graphUri != null)
{
put.SetUri("graph", graphUri);
}
SparqlUpdateCommandSet putCmds = this._parser.ParseFromString(put);
this._updateProcessor.ProcessCommandSet(putCmds);
this._updateProcessor.Flush();
//Return a 201 if required, otherwise the default behaviour of returning a 200 will occur automatically
if (created)
{
context.Response.StatusCode = (int)HttpStatusCode.Created;
}
}
private void SparqlQueryAndUpdateThreadSafeEvaluationActual()
{
String query1 = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <http://example.org/1> { ?s ?p ?o } }";
String query2 = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <http://example.org/2> { ?s ?p ?o } }";
String query3 = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <http://example.org/3> { ?s ?p ?o } }";
String update1 = "INSERT DATA { GRAPH <http://example.org/3> { <ex:subj> <ex:pred> <ex:obj> } }";
SparqlQuery q1 = this._parser.ParseFromString(query1);
SparqlQuery q2 = this._parser.ParseFromString(query2);
SparqlQuery q3 = this._parser.ParseFromString(query3);
Assert.False(q1.UsesDefaultDataset, "Query 1 should not be thread safe");
Assert.False(q2.UsesDefaultDataset, "Query 2 should not be thread safe");
Assert.False(q3.UsesDefaultDataset, "Query 3 should not be thread safe");
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString(update1);
InMemoryDataset dataset = new InMemoryDataset();
Graph g = new Graph();
g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl");
g.BaseUri = new Uri("http://example.org/1");
Graph h = new Graph();
h.LoadFromEmbeddedResource("VDS.RDF.Query.Expressions.LeviathanFunctionLibrary.ttl");
h.BaseUri = new Uri("http://example.org/2");
Graph i = new Graph();
i.BaseUri = new Uri("http://example.org/3");
dataset.AddGraph(g);
dataset.AddGraph(h);
dataset.AddGraph(i);
LeviathanQueryProcessor processor = new LeviathanQueryProcessor(dataset);
LeviathanUpdateProcessor upProcessor = new LeviathanUpdateProcessor(dataset);
QueryWithGraphDelegate d = new QueryWithGraphDelegate(this.QueryWithGraph);
RunUpdateDelegate d2 = new RunUpdateDelegate(this.RunUpdate);
IAsyncResult r1 = d.BeginInvoke(q1, processor, null, null);
IAsyncResult r2 = d.BeginInvoke(q2, processor, null, null);
IAsyncResult r3 = d.BeginInvoke(q3, processor, null, null);
IAsyncResult r4 = d2.BeginInvoke(cmds, upProcessor, null, null);
WaitHandle.WaitAll(new WaitHandle[] { r1.AsyncWaitHandle, r2.AsyncWaitHandle, r3.AsyncWaitHandle, r4.AsyncWaitHandle });
IGraph gQuery = d.EndInvoke(r1);
Assert.Equal(g, gQuery);
IGraph hQuery = d.EndInvoke(r2);
Assert.Equal(h, hQuery);
IGraph iQuery = d.EndInvoke(r3);
if (iQuery.IsEmpty)
{
Console.WriteLine("Query 3 executed before the INSERT DATA command - running again to get the resulting graph");
iQuery = this.QueryWithGraph(q3, processor);
}
else
{
Console.WriteLine("Query 3 executed after the INSERT DATA command");
}
//Test iQuery against an empty Graph
Assert.False(iQuery.IsEmpty, "Graph should not be empty as INSERT DATA should have inserted a Triple");
Assert.NotEqual(new Graph(), iQuery);
Assert.NotEqual(g, h);
}
/// <summary>
/// Aplica el descubrimiento sobre las entidades cargadas en el SGI
/// </summary>
/// <param name="pSecondsSleep">Segundos para dormir después de procesar una entidad</param>
/// <param name="pCallUrisFactoryApiService">Servicio para hacer llamadas a los métodos del Uris Factory</param>
public void ApplyDiscoverLoadedEntities(int pSecondsSleep, CallUrisFactoryApiService pCallUrisFactoryApiService)
{
CallEtlApiService callEtlApiService = _serviceScopeFactory.CreateScope().ServiceProvider.GetRequiredService <CallEtlApiService>();
#region Cargamos configuraciones
ConfigSparql ConfigSparql = new ConfigSparql();
string SGI_SPARQLEndpoint = ConfigSparql.GetEndpoint();
string SGI_SPARQLGraph = ConfigSparql.GetGraph();
string SGI_SPARQLQueryParam = ConfigSparql.GetQueryParam();
string SGI_SPARQLUsername = ConfigSparql.GetUsername();
string SGI_SPARQLPassword = ConfigSparql.GetPassword();
string Unidata_SPARQLEndpoint = ConfigSparql.GetUnidataEndpoint();
string Unidata_SPARQLGraph = ConfigSparql.GetUnidataGraph();
string Unidata_SPARQLQueryParam = ConfigSparql.GetUnidataQueryParam();
string Unidata_SPARQLUsername = ConfigSparql.GetUnidataUsername();
string Unidata_SPARQLPassword = ConfigSparql.GetUnidataPassword();
ConfigService ConfigService = new ConfigService();
string UnidataDomain = ConfigService.GetUnidataDomain();
string UnidataUriTransform = ConfigService.GetUnidataUriTransform();
float MaxScore = ConfigService.GetMaxScore();
float MinScore = ConfigService.GetMinScore();
ConfigScopus ConfigScopus = new ConfigScopus();
string ScopusApiKey = ConfigScopus.GetScopusApiKey();
string ScopusUrl = ConfigScopus.GetScopusUrl();
ConfigCrossref ConfigCrossref = new ConfigCrossref();
string CrossrefUserAgent = ConfigCrossref.GetCrossrefUserAgent();
ConfigWOS ConfigWOS = new ConfigWOS();
string WOSAuthorization = ConfigWOS.GetWOSAuthorization();
#endregion
DiscoverUtility discoverUtility = new DiscoverUtility();
//Cargar todas las personas en la lista de manera aleatoria.
List <string> personList = discoverUtility.GetPersonList(SGI_SPARQLEndpoint, SGI_SPARQLGraph, SGI_SPARQLQueryParam, SGI_SPARQLUsername, SGI_SPARQLPassword);
List <string> randomPersonList = GetRandomOrderList(personList);
RohGraph ontologyGraph = callEtlApiService.CallGetOntology();
foreach (string person in randomPersonList)
{
try
{
//Hora de inicio de la ejecución
DateTime startTime = DateTime.Now;
//Obtener el RohGraph de una única persona.
RohGraph dataGraph = discoverUtility.GetDataGraphPersonLoadedForDiscover(person, SGI_SPARQLEndpoint, SGI_SPARQLGraph, SGI_SPARQLQueryParam, SGI_SPARQLUsername, SGI_SPARQLPassword);
//Clonamos el grafo original para hacer luego comprobaciones
RohGraph originalDataGraph = dataGraph.Clone();
RohRdfsReasoner reasoner = new RohRdfsReasoner();
reasoner.Initialise(ontologyGraph);
RohGraph dataInferenceGraph = dataGraph.Clone();
reasoner.Apply(dataInferenceGraph);
bool hasChanges = false;
//Dictionary<string, string> discoveredEntityList = new Dictionary<string, string>();
Dictionary <string, Dictionary <string, float> > discoveredEntitiesProbability = new Dictionary <string, Dictionary <string, float> >();
Dictionary <string, ReconciliationData.ReconciliationScore> entidadesReconciliadasConIntegracionExternaAux;
Dictionary <string, HashSet <string> > discardDissambiguations = new Dictionary <string, HashSet <string> >();
DiscoverCache discoverCache = new DiscoverCache();
DiscoverCacheGlobal discoverCacheGlobal = new DiscoverCacheGlobal();
//Obtención de la integración externa
ReconciliationData reconciliationData = new ReconciliationData();
DiscoverLinkData discoverLinkData = new DiscoverLinkData();
Dictionary <string, List <DiscoverLinkData.PropertyData> > integration = discoverUtility.ExternalIntegration(ref hasChanges, ref reconciliationData, ref discoverLinkData, ref discoveredEntitiesProbability, ref dataGraph, reasoner, null, ontologyGraph, out entidadesReconciliadasConIntegracionExternaAux, discardDissambiguations, discoverCache, discoverCacheGlobal, ScopusApiKey, ScopusUrl, CrossrefUserAgent, WOSAuthorization, MinScore, MaxScore, SGI_SPARQLEndpoint, SGI_SPARQLGraph, SGI_SPARQLQueryParam, SGI_SPARQLUsername, SGI_SPARQLPassword, pCallUrisFactoryApiService, false);
//Limpiamos 'integration' para no insertar triples en caso de que ya estén cargados
foreach (string entity in integration.Keys.ToList())
{
foreach (DiscoverLinkData.PropertyData propertyData in integration[entity].ToList())
{
string p = propertyData.property;
HashSet <string> objetos = new HashSet <string>(propertyData.valueProvenance.Keys.ToList());
foreach (string o in objetos)
{
if (((SparqlResultSet)originalDataGraph.ExecuteQuery($@"ASK
WHERE
{{
?s ?p ?o.
FILTER(?s=<{entity}>)
FILTER(?p=<{p}>)
FILTER(str(?o)='{o}')
}}")).Result)
{
//Elimiamos el valor porque ya estaba cargado
propertyData.valueProvenance.Remove(o);
}
}
if (propertyData.valueProvenance.Count == 0)
{
integration[entity].Remove(propertyData);
}
}
if (integration[entity].Count == 0)
{
integration.Remove(entity);
}
}
//Creación de dataGraph con el contenido de 'integration' + RdfTypes + SameAS
RohGraph dataGraphIntegration = new RohGraph();
foreach (string sujeto in integration.Keys)
{
IUriNode s = dataGraphIntegration.CreateUriNode(UriFactory.Create(sujeto));
//Agregamos SameAs y RDFType de las entidades
SparqlResultSet sparqlResultSet = (SparqlResultSet)dataGraph.ExecuteQuery("select ?rdftype ?sameas where {?s a ?rdftype. OPTIONAL{?s <http://www.w3.org/2002/07/owl#sameAs> ?sameAS} FILTER(?s=<" + sujeto + ">)}");
foreach (SparqlResult sparqlResult in sparqlResultSet.Results)
{
string rdfType = sparqlResult["rdftype"].ToString();
IUriNode pRdfType = dataGraphIntegration.CreateUriNode(UriFactory.Create("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"));
IUriNode oRdfType = dataGraphIntegration.CreateUriNode(UriFactory.Create(rdfType));
dataGraphIntegration.Assert(new Triple(s, pRdfType, oRdfType));
if (sparqlResult.Variables.Contains("sameas"))
{
string sameas = sparqlResult["sameas"].ToString();
IUriNode pSameAs = dataGraphIntegration.CreateUriNode(UriFactory.Create("http://www.w3.org/2002/07/owl#sameAs"));
IUriNode oSameAs = dataGraphIntegration.CreateUriNode(UriFactory.Create(sameas));
dataGraphIntegration.Assert(new Triple(s, pSameAs, oSameAs));
}
}
foreach (DiscoverLinkData.PropertyData propertyData in integration[sujeto])
{
foreach (string valor in propertyData.valueProvenance.Keys)
{
IUriNode p = dataGraphIntegration.CreateUriNode(UriFactory.Create(propertyData.property));
if (Uri.IsWellFormedUriString(valor, UriKind.Absolute))
{
IUriNode uriNode = dataGraphIntegration.CreateUriNode(UriFactory.Create(propertyData.property));
dataGraphIntegration.Assert(new Triple(s, p, uriNode));
}
else
{
ILiteralNode literalNode = dataGraphIntegration.CreateLiteralNode(valor, new Uri("http://www.w3.org/2001/XMLSchema#string"));
dataGraphIntegration.Assert(new Triple(s, p, literalNode));
}
foreach (string org in propertyData.valueProvenance[valor])
{
//Agregamos los datos de las organizaciones y los grafos
SparqlResultSet sparqlResultSetOrgs = (SparqlResultSet)dataGraph.ExecuteQuery("select ?s ?p ?o where {?s ?p ?o. FILTER(?s in(<" + pCallUrisFactoryApiService.GetUri("http://purl.org/roh/mirror/foaf#Organization", org) + ">,<" + pCallUrisFactoryApiService.GetUri("Graph", org) + "> ))}");
foreach (SparqlResult sparqlResult in sparqlResultSetOrgs.Results)
{
INode sOrg = dataGraphIntegration.CreateUriNode(UriFactory.Create(sparqlResult["s"].ToString()));
INode pOrg = dataGraphIntegration.CreateUriNode(UriFactory.Create(sparqlResult["p"].ToString()));
if (sparqlResult["o"] is UriNode)
{
INode oOrg = dataGraphIntegration.CreateUriNode(UriFactory.Create(sparqlResult["o"].ToString()));
dataGraphIntegration.Assert(new Triple(sOrg, pOrg, oOrg));
}
else if (sparqlResult["o"] is LiteralNode)
{
INode oOrg = dataGraphIntegration.CreateLiteralNode(((LiteralNode)sparqlResult["o"]).Value, ((LiteralNode)sparqlResult["o"]).DataType);
dataGraphIntegration.Assert(new Triple(sOrg, pOrg, oOrg));
}
}
}
}
}
}
//Hora fin de la ejecución
DateTime endTime = DateTime.Now;
if (integration.Count > 0)
{
//Si hay datos nuevos los cargamos
string urlDiscoverAgent = pCallUrisFactoryApiService.GetUri("Agent", "discover");
//Publicamos en el SGI
AsioPublication asioPublication = new AsioPublication(SGI_SPARQLEndpoint, SGI_SPARQLQueryParam, SGI_SPARQLGraph, SGI_SPARQLUsername, SGI_SPARQLPassword);
asioPublication.PublishRDF(dataGraphIntegration, null, new KeyValuePair <string, string>(urlDiscoverAgent, "Algoritmos de descubrimiento"), startTime, endTime, discoverLinkData, pCallUrisFactoryApiService);
//Preparamos los datos para cargarlos en Unidata
RohGraph unidataGraph = dataGraphIntegration.Clone();
#region Si no tiene un sameAs apuntando a Unidata lo eliminamos, no hay que cargar la entidad
SparqlResultSet sparqlResultSet = (SparqlResultSet)unidataGraph.ExecuteQuery("select ?s ?rdftype ?sameas where {?s a ?rdftype. OPTIONAL{?s <http://www.w3.org/2002/07/owl#sameAs> ?sameAS} }");
Dictionary <string, bool> entidadesConSameAsUnidata = new Dictionary <string, bool>();
foreach (SparqlResult sparqlResult in sparqlResultSet.Results)
{
string s = sparqlResult["s"].ToString();
if (!entidadesConSameAsUnidata.ContainsKey(s))
{
entidadesConSameAsUnidata.Add(s, false);
}
if (sparqlResult.Variables.Contains("sameas"))
{
if (sparqlResult["sameas"].ToString().StartsWith(UnidataDomain))
{
entidadesConSameAsUnidata[s] = true;
}
}
}
TripleStore store = new TripleStore();
store.Add(unidataGraph);
foreach (string entity in entidadesConSameAsUnidata.Keys)
{
if (!entidadesConSameAsUnidata[entity])
{
//Cambiamos candidato.Key por entityID
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet delete = parser.ParseFromString(@"DELETE { ?s ?p ?o. }
WHERE
{
?s ?p ?o.
FILTER(?s = <" + entity + @">)
}");
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(store);
processor.ProcessCommandSet(delete);
}
}
#endregion
//TODO descomentar cuando esté habilitaado Unidata
////Si hay triples para cargar en Unidata procedemos
//if (unidataGraph.Triples.ToList().Count > 0)
//{
// //Publicamos en UNIDATA
// AsioPublication asioPublicationUnidata = new AsioPublication(Unidata_SPARQLEndpoint, Unidata_SPARQLQueryParam, Unidata_SPARQLGraph, Unidata_SPARQLUsername, Unidata_SPARQLPassword);
// // Prepara el grafo para su carga en Unidata, para ello coge las URIs de Unidata del SameAs y la aplica a los sujetos y los antiguos sujetos se agregan al SameAs
// unidataGraph = AsioPublication.TransformUrisToUnidata(unidataGraph, UnidataDomain, UnidataUriTransform);
// asioPublicationUnidata.PublishRDF(unidataGraph, null, new KeyValuePair<string, string>(urlDiscoverAgent, "Algoritmos de descubrimiento"), startTime, endTime, discoverLinkData,pCallUrisFactoryApiService);
//}
}
}
catch (Exception exception)
{
Logging.Error(exception);
}
Thread.Sleep(pSecondsSleep * 1000);
}
}
/// <summary>
/// Returns false because this optimiser is never globally applicable
/// </summary>
/// <param name="cmds">Update Commands</param>
/// <returns></returns>
public bool IsApplicable(SparqlUpdateCommandSet cmds)
{
return(false);
}
/// <summary>
/// Executes a SPARQL Update on the Virtuoso store
/// </summary>
/// <param name="updates">SPARQL Updates</param>
/// <remarks>
/// <para>
/// <strong>Warning:</strong> In rare cases we have been able to crash Virtuoso by issuing malformed Sparql Update commands to it, this appears to be an issue with Virtuoso.
/// </para>
/// </remarks>
public void ExecuteUpdate(SparqlUpdateCommandSet updates)
{
this._manager.Update(updates.ToString());
}
/// <summary>
/// Processes SPARQL Update requests
/// </summary>
/// <param name="context">HTTP Context</param>
public void ProcessRequest(HttpContext context)
{
this._config = this.LoadConfig(context);
//Add our Standard Headers
HandlerHelper.AddStandardHeaders(context, this._config);
if (context.Request.HttpMethod.Equals("OPTIONS"))
{
//OPTIONS requests always result in the Service Description document
IGraph svcDescrip = SparqlServiceDescriber.GetServiceDescription(context, this._config, UriFactory.Create(context.Request.Url.AbsoluteUri));
HandlerHelper.SendToClient(context, svcDescrip, this._config);
return;
}
//See if there has been an update submitted
String updateText = null;
if (context.Request.ContentType != null)
{
if (context.Request.ContentType.Equals(MimeTypesHelper.WWWFormURLEncoded))
{
updateText = context.Request.Form["update"];
}
else if (context.Request.ContentType.Equals(MimeTypesHelper.SparqlUpdate))
{
updateText = new StreamReader(context.Request.InputStream).ReadToEnd();
}
}
else
{
updateText = context.Request.Form["update"];
}
//If no Update sent either show Update Form or give a HTTP 400 response
if (updateText == null || updateText.Equals(String.Empty))
{
//If there is no Update we may return the SPARQL Service Description where appropriate
try
{
//If we might show the Update Form only show the Description if the selected writer is
//not a HTML writer
MimeTypeDefinition definition = MimeTypesHelper.GetDefinitions(HandlerHelper.GetAcceptTypes(context)).FirstOrDefault(d => d.CanWriteRdf);
if (definition != null)
{
IRdfWriter writer = definition.GetRdfWriter();
if (!this._config.ShowUpdateForm || !(writer is IHtmlWriter))
{
//If not a HTML Writer selected OR not showing Update Form then show the Service Description Graph
//unless an error occurs creating it
IGraph serviceDescrip = SparqlServiceDescriber.GetServiceDescription(context, this._config, UriFactory.Create(context.Request.Url.AbsoluteUri));
context.Response.ContentType = definition.CanonicalMimeType;
context.Response.ContentEncoding = definition.Encoding;
writer.Save(serviceDescrip, new StreamWriter(context.Response.OutputStream, definition.Encoding));
return;
}
}
}
catch
{
//Ignore Exceptions - we'll just show the Query Form or return a 400 Bad Request instead
}
//If a Writer can't be selected then we'll either show the Update Form or return a 400 Bad Request
if (this._config.ShowUpdateForm)
{
this.ShowUpdateForm(context);
}
else
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
return;
}
//Get Other options associated with this update
List <String> userDefaultGraphs = new List <String>();
List <String> userNamedGraphs = new List <String>();
//Get the USING URIs (if any)
if (context.Request.QueryString["using-graph-uri"] != null)
{
userDefaultGraphs.AddRange(context.Request.QueryString.GetValues("using-graph-uri"));
}
else if (context.Request.Form["using-graph-uri"] != null)
{
userDefaultGraphs.AddRange(context.Request.Form.GetValues("using-graph-uri"));
}
//Get the USING NAMED URIs (if any)
if (context.Request.QueryString["using-named-graph-uri"] != null)
{
userNamedGraphs.AddRange(context.Request.QueryString.GetValues("using-named-graph-uri"));
}
else if (context.Request.Form["using-named-graph-uri"] != null)
{
userNamedGraphs.AddRange(context.Request.Form.GetValues("using-named-graph-uri"));
}
try
{
//Now we're going to parse the Updates
SparqlUpdateParser parser = new SparqlUpdateParser();
parser.ExpressionFactories = this._config.ExpressionFactories;
SparqlUpdateCommandSet commands = parser.ParseFromString(updateText);
//Check whether we need to use authentication
//If there are no user groups then no authentication is in use so we default to authenticated with no per-action authentication needed
bool isAuth = true, requireActionAuth = false;
if (this._config.UserGroups.Any())
{
//If we have user
isAuth = HandlerHelper.IsAuthenticated(context, this._config.UserGroups);
requireActionAuth = true;
}
if (!isAuth)
{
return;
}
//First check actions to see whether they are all permissible and apply USING/USING NAMED parameters
foreach (SparqlUpdateCommand cmd in commands.Commands)
{
//Authenticate each action
bool actionAuth = true;
if (requireActionAuth)
{
actionAuth = HandlerHelper.IsAuthenticated(context, this._config.UserGroups, this.GetPermissionAction(cmd));
}
if (!actionAuth)
{
throw new SparqlUpdatePermissionException("You are not authorised to perform the " + this.GetPermissionAction(cmd) + " action");
}
//Check whether we need to (and are permitted to) apply USING/USING NAMED parameters
if (userDefaultGraphs.Count > 0 || userNamedGraphs.Count > 0)
{
BaseModificationCommand modify = cmd as BaseModificationCommand;
if (modify != null)
{
if (modify.GraphUri != null || modify.UsingUris.Any() || modify.UsingNamedUris.Any())
{
//Invalid if a command already has a WITH/USING/USING NAMED
throw new SparqlUpdateMalformedException("A command in your update request contains a WITH/USING/USING NAMED clause but you have also specified one/both of the using-graph-uri or using-named-graph-uri parameters which is not permitted by the SPARQL Protocol");
}
else
{
//Otherwise go ahead and apply
userDefaultGraphs.ForEach(u => modify.AddUsingUri(UriFactory.Create(u)));
userNamedGraphs.ForEach(u => modify.AddUsingNamedUri(UriFactory.Create(u)));
}
}
}
}
//Then assuming we got here this means all our actions are permitted so now we can process the updates
this.ProcessUpdates(commands);
//Flush outstanding changes
this._config.Processor.Flush();
//Update the Cache as the request may have changed the endpoint
this.UpdateConfig(context);
}
catch (RdfParseException parseEx)
{
HandleErrors(context, "Parsing Error", updateText, parseEx, (int)HttpStatusCode.BadRequest);
}
catch (SparqlUpdatePermissionException permEx)
{
HandleErrors(context, "Permissions Error", updateText, permEx, (int)HttpStatusCode.Forbidden);
}
catch (SparqlUpdateMalformedException malEx)
{
HandleErrors(context, "Malformed Update Error", updateText, malEx, (int)HttpStatusCode.BadRequest);
}
catch (SparqlUpdateException updateEx)
{
HandleErrors(context, "Update Error", updateText, updateEx);
}
catch (RdfException rdfEx)
{
HandleErrors(context, "RDF Error", updateText, rdfEx);
}
catch (Exception ex)
{
HandleErrors(context, "Error", updateText, ex);
}
}
/// <inheritdoc />
public new void ExecuteUpdate(SparqlUpdateCommandSet updates)
{
((IUpdateableTripleStore)this).ExecuteUpdate(updates);
}
public void SparqlParsingDeleteDataWithGraphVar()
{
String update = "DELETE DATA { GRAPH ?g { } }";
SparqlUpdateCommandSet commands = this._updateParser.ParseFromString(update);
}
public void SparqlParsingInsertDataWithGraphVar()
{
String update = "INSERT DATA { GRAPH ?g { } }";
SparqlUpdateCommandSet commands = this._updateParser.ParseFromString(update);
}
/// <summary>
/// Processes SPARQL Update requests
/// </summary>
/// <param name="context">HTTP Context</param>
public void ProcessRequest(HttpContext context)
{
this._config = this.LoadConfig(context);
WebContext webContext = new WebContext(context);
// Add our Standard Headers
HandlerHelper.AddStandardHeaders(webContext, this._config);
// Options we need to determine based on the HTTP Method used
String[] updates;
String updateText = null;
List <String> userDefaultGraphs = new List <String>();
List <String> userNamedGraphs = new List <String>();
try
{
// Decide what to do based on the HTTP Method
switch (context.Request.HttpMethod.ToUpper())
{
case "OPTIONS":
// OPTIONS requests always result in the Service Description document
IGraph svcDescrip = SparqlServiceDescriber.GetServiceDescription(this._config, UriFactory.Create(context.Request.Url.AbsoluteUri));
HandlerHelper.SendToClient(webContext, svcDescrip, this._config);
return;
case "HEAD":
// Just return from a HEAD request
return;
case "GET":
// A GET with an update parameter is a Bad Request
updates = context.Request.QueryString.GetValues("update");
if (updates != null && updates.Length > 0)
{
throw new ArgumentException("Updates cannot be submitted as GET requests");
}
// Otherwise GET either results in the Service Description if appropriately conneg'd or
// the update form if enabled
try
{
// If we might show the Update Form only show the Description if the selected writer is
// not a HTML writer
MimeTypeDefinition definition = MimeTypesHelper.GetDefinitions(webContext.GetAcceptTypes()).FirstOrDefault(d => d.CanWriteRdf);
if (definition != null)
{
IRdfWriter writer = definition.GetRdfWriter();
if (!(writer is IHtmlWriter))
{
// If not a HTML Writer selected then show the Service Description Graph
// unless an error occurs creating it
IGraph serviceDescrip = SparqlServiceDescriber.GetServiceDescription(this._config, UriFactory.Create(context.Request.Url.AbsoluteUri));
context.Response.ContentType = definition.CanonicalMimeType;
context.Response.ContentEncoding = definition.Encoding;
writer.Save(serviceDescrip, new StreamWriter(context.Response.OutputStream, definition.Encoding));
return;
}
}
}
catch
{
// Ignore Exceptions - we'll just show the Query Form or return a 400 Bad Request instead
}
// If a Writer can't be selected then we'll either show the Update Form or return a 400 Bad Request
if (this._config.ShowUpdateForm)
{
this.ShowUpdateForm(context);
}
else
{
throw new ArgumentException("Updates cannot be submitted as GET requests");
}
return;
case "POST":
if (context.Request.ContentType != null)
{
MimeTypeSelector contentType = MimeTypeSelector.Create(context.Request.ContentType, 0);
if (contentType.Type.Equals(MimeTypesHelper.WWWFormURLEncoded))
{
// Form URL Encoded was declared type so expect an update parameter in the Form parameters
updates = context.Request.Form.GetValues("update");
if (updates == null)
{
throw new ArgumentException("Required update parameter in POST body was missing");
}
if (updates.Length == 0)
{
throw new ArgumentException("Required update parameter in POST body was missing");
}
if (updates.Length > 1)
{
throw new ArgumentException("The update parameter was specified multiple times in the POST body");
}
updateText = updates[0];
// For Form URL Encoded the Using/Using Named Graphs may be specified by Form parameters
// Get the USING URIs (if any)
if (context.Request.Form["using-graph-uri"] != null)
{
userDefaultGraphs.AddRange(context.Request.Form.GetValues("using-graph-uri"));
}
// Get the USING NAMED URIs (if any)
if (context.Request.Form["using-named-graph-uri"] != null)
{
userNamedGraphs.AddRange(context.Request.Form.GetValues("using-named-graph-uri"));
}
break;
}
else if (contentType.Type.Equals(MimeTypesHelper.SparqlUpdate))
{
// application/sparql-update was declared type so expect utf-8 charset (if present)
if (contentType.Charset != null && !contentType.Charset.ToLower().Equals(MimeTypesHelper.CharsetUtf8))
{
throw new ArgumentException("HTTP POST request was received with a " + MimeTypesHelper.SparqlUpdate + " Content-Type but a non UTF-8 charset parameter");
}
using (StreamReader reader = new StreamReader(context.Request.InputStream))
{
updateText = reader.ReadToEnd();
reader.Close();
}
// For application/sparql-update the Using/Using Named Graphs may be specified by querystring parameters
// Get the USING URIs (if any)
if (context.Request.QueryString["using-graph-uri"] != null)
{
userDefaultGraphs.AddRange(context.Request.QueryString.GetValues("using-graph-uri"));
}
// Get the USING NAMED URIs (if any)
if (context.Request.QueryString["using-named-graph-uri"] != null)
{
userNamedGraphs.AddRange(context.Request.QueryString.GetValues("using-named-graph-uri"));
}
break;
}
else
{
throw new ArgumentException("HTTP POST made to SPARQL update endpoint had an invalid Content-Type header, only " + MimeTypesHelper.WWWFormURLEncoded + " and " + MimeTypesHelper.SparqlUpdate + " are acceptable");
}
}
throw new ArgumentException("HTTP POST made to SPARQL Query endpoint was missing the required Content-Type header");
default:
throw new NotSupportedException("HTTP " + context.Request.HttpMethod.ToUpper() + " is not supported by a SPARQL Update endpoint");
}
// Clean up protocol provided dataset
userDefaultGraphs.RemoveAll(g => String.IsNullOrEmpty(g));
userNamedGraphs.RemoveAll(g => String.IsNullOrEmpty(g));
// Now we're going to parse the Updates
SparqlUpdateParser parser = new SparqlUpdateParser();
parser.DefaultBaseUri = context.Request.Url;
parser.ExpressionFactories = this._config.ExpressionFactories;
SparqlUpdateCommandSet commands = parser.ParseFromString(updateText);
// Check whether we need to use authentication
// If there are no user groups then no authentication is in use so we default to authenticated with no per-action authentication needed
bool isAuth = true, requireActionAuth = false;
if (this._config.UserGroups.Any())
{
// If we have user
isAuth = HandlerHelper.IsAuthenticated(webContext, this._config.UserGroups);
requireActionAuth = true;
}
if (!isAuth)
{
return;
}
// First check actions to see whether they are all permissible and apply USING/USING NAMED parameters
foreach (SparqlUpdateCommand cmd in commands.Commands)
{
// Authenticate each action
bool actionAuth = true;
if (requireActionAuth)
{
actionAuth = HandlerHelper.IsAuthenticated(webContext, this._config.UserGroups, this.GetPermissionAction(cmd));
}
if (!actionAuth)
{
throw new SparqlUpdatePermissionException("You are not authorised to perform the " + this.GetPermissionAction(cmd) + " action");
}
// Check whether we need to (and are permitted to) apply USING/USING NAMED parameters
if (userDefaultGraphs.Count > 0 || userNamedGraphs.Count > 0)
{
BaseModificationCommand modify = cmd as BaseModificationCommand;
if (modify != null)
{
if (modify.GraphUri != null || modify.UsingUris.Any() || modify.UsingNamedUris.Any())
{
// Invalid if a command already has a WITH/USING/USING NAMED
throw new SparqlUpdateMalformedException("A command in your update request contains a WITH/USING/USING NAMED clause but you have also specified one/both of the using-graph-uri or using-named-graph-uri parameters which is not permitted by the SPARQL Protocol");
}
else
{
// Otherwise go ahead and apply
userDefaultGraphs.ForEach(u => modify.AddUsingUri(UriFactory.Create(u)));
userNamedGraphs.ForEach(u => modify.AddUsingNamedUri(UriFactory.Create(u)));
}
}
}
}
// Then assuming we got here this means all our actions are permitted so now we can process the updates
this.ProcessUpdates(commands);
// Flush outstanding changes
this._config.Processor.Flush();
// Update the Cache as the request may have changed the endpoint
this.UpdateConfig(context);
}
catch (RdfParseException parseEx)
{
HandleErrors(context, "Parsing Error", updateText, parseEx, (int)HttpStatusCode.BadRequest);
}
catch (SparqlUpdatePermissionException permEx)
{
HandleErrors(context, "Permissions Error", updateText, permEx, (int)HttpStatusCode.Forbidden);
}
catch (SparqlUpdateMalformedException malEx)
{
HandleErrors(context, "Malformed Update Error", updateText, malEx, (int)HttpStatusCode.BadRequest);
}
catch (SparqlUpdateException updateEx)
{
HandleErrors(context, "Update Error", updateText, updateEx);
}
catch (RdfException rdfEx)
{
HandleErrors(context, "RDF Error", updateText, rdfEx);
}
catch (NotSupportedException notSupEx)
{
HandleErrors(context, "HTTP Request Error", null, notSupEx, (int)HttpStatusCode.MethodNotAllowed);
}
catch (ArgumentException argEx)
{
HandleErrors(context, "HTTP Request Error", null, argEx, (int)HttpStatusCode.BadRequest);
}
catch (Exception ex)
{
HandleErrors(context, "Error", updateText, ex);
}
}
/// <summary>
/// Processes SPARQL Update requests
/// </summary>
/// <param name="context">HTTP Context</param>
public void ProcessRequest(HttpContext context)
{
this._config = this.LoadConfig(context);
//Add our Standard Headers
HandlerHelper.AddStandardHeaders(context, this._config);
if (context.Request.HttpMethod.Equals("OPTIONS"))
{
//OPTIONS requests always result in the Service Description document
IGraph svcDescrip = SparqlServiceDescriber.GetServiceDescription(context, this._config, new Uri(context.Request.Url.AbsoluteUri));
HandlerHelper.SendToClient(context, svcDescrip, this._config);
return;
}
//See if there has been an update submitted
String updateText = context.Request.QueryString["update"];
if (updateText == null || updateText.Equals(String.Empty))
{
updateText = context.Request.Form["update"];
}
//If no Update sent either show Update Form or give a HTTP 400 response
if (updateText == null || updateText.Equals(String.Empty))
{
//If there is no Update we may return the SPARQL Service Description where appropriate
try
{
//If we might show the Update Form only show the Description if the selected writer is
//not a HTML writer
MimeTypeDefinition definition = MimeTypesHelper.GetDefinitions(HandlerHelper.GetAcceptTypes(context)).FirstOrDefault(d => d.CanWriteRdf);
if (definition != null)
{
IRdfWriter writer = definition.GetRdfWriter();
if (!this._config.ShowUpdateForm || !(writer is IHtmlWriter))
{
//If not a HTML Writer selected OR not showing Update Form then show the Service Description Graph
//unless an error occurs creating it
IGraph serviceDescrip = SparqlServiceDescriber.GetServiceDescription(context, this._config, new Uri(context.Request.Url.AbsoluteUri));
context.Response.ContentType = definition.CanonicalMimeType;
context.Response.ContentEncoding = definition.Encoding;
writer.Save(serviceDescrip, new StreamWriter(context.Response.OutputStream, definition.Encoding));
return;
}
}
}
catch
{
//Ignore Exceptions - we'll just show the Query Form or return a 400 Bad Request instead
}
//If a Writer can't be selected then we'll either show the Update Form or return a 400 Bad Request
if (this._config.ShowUpdateForm)
{
this.ShowUpdateForm(context);
}
else
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
return;
}
try
{
//Now we're going to parse the Updates
SparqlUpdateParser parser = new SparqlUpdateParser();
parser.ExpressionFactories = this._config.ExpressionFactories;
SparqlUpdateCommandSet commands = parser.ParseFromString(updateText);
//Check whether we need to use authentication
//If there are no user groups then no authentication is in use so we default to authenticated with no per-action authentication needed
bool isAuth = true, requireActionAuth = false;
if (this._config.UserGroups.Any())
{
//If we have user
isAuth = HandlerHelper.IsAuthenticated(context, this._config.UserGroups);
requireActionAuth = true;
}
if (!isAuth)
{
return;
}
//First check actions to see whether they are all permissible
foreach (SparqlUpdateCommand cmd in commands.Commands)
{
//Authenticate each action
bool actionAuth = true;
if (requireActionAuth)
{
actionAuth = HandlerHelper.IsAuthenticated(context, this._config.UserGroups, this.GetPermissionAction(cmd));
}
if (!actionAuth)
{
throw new SparqlUpdateException("You are not authorised to perform the " + this.GetPermissionAction(cmd) + " action");
}
}
//Then assuming we got here this means all our actions are permitted so now we can process the updates
this.ProcessUpdates(commands);
//Flush outstanding changes
this._config.Processor.Flush();
//Update the Cache as the request may have changed the endpoint
this.UpdateConfig(context);
}
catch (RdfParseException parseEx)
{
HandleErrors(context, "Parsing Error", updateText, parseEx);
}
catch (SparqlUpdateException updateEx)
{
HandleErrors(context, "Update Error", updateText, updateEx);
}
catch (RdfException rdfEx)
{
HandleErrors(context, "RDF Error", updateText, rdfEx);
}
catch (Exception ex)
{
HandleErrors(context, "Error", updateText, ex);
}
}
/// <summary> /// Determines whether the Optimiser can be applied to a given Update Command Set /// </summary> /// <param name="cmds">Command Set</param> /// <returns></returns> public abstract bool IsApplicable(SparqlUpdateCommandSet cmds);
/// <summary>
/// Executes a set of Update Commands against the Triple Store.
/// </summary>
/// <param name="updates">SPARQL Update Command Set.</param>
public void ExecuteUpdate(SparqlUpdateCommandSet updates)
{
ExecuteUpdate(updates.ToString());
}
public IActionResult ResolveDiscover(string idJob, string IdDiscoverItem, Dictionary <string, string> DissambiguationProblemsResolve)
{
DiscoverItem item = _discoverItemService.GetDiscoverItemById(new Guid(IdDiscoverItem));
//Cargamos el RDF
RohGraph dataGraph = new RohGraph();
dataGraph.LoadFromString(item.DiscoverRdf, new RdfXmlParser());
//Modificamos el RDF
TripleStore store = new TripleStore();
store.Add(dataGraph);
//Cambiamos candidato.Key por entityID
foreach (string uriOriginal in DissambiguationProblemsResolve.Keys)
{
if (!string.IsNullOrEmpty(DissambiguationProblemsResolve[uriOriginal]))
{
//En caso de que la resolución sea una URI de Unidata añadimos el SameAs
if (!string.IsNullOrEmpty(_unidataPrefix.GetUnidataDomain()) && DissambiguationProblemsResolve[uriOriginal].StartsWith(_unidataPrefix.GetUnidataDomain()))
{
IUriNode t_subject = dataGraph.CreateUriNode(UriFactory.Create(uriOriginal));
IUriNode t_predicate = dataGraph.CreateUriNode(UriFactory.Create("http://www.w3.org/2002/07/owl#sameAs"));
IUriNode t_object = dataGraph.CreateUriNode(UriFactory.Create(DissambiguationProblemsResolve[uriOriginal]));
dataGraph.Assert(new Triple(t_subject, t_predicate, t_object));
}
else
{
//En caso de que la resolución NO sea una URI de Unidata modificamos las URLs
SparqlUpdateParser parser = new SparqlUpdateParser();
//Actualizamos los sujetos
SparqlUpdateCommandSet updateSubject = parser.ParseFromString(@"DELETE { ?s ?p ?o. }
INSERT{<" + DissambiguationProblemsResolve[uriOriginal] + @"> ?p ?o.}
WHERE
{
?s ?p ?o. FILTER(?s = <" + uriOriginal + @">)
}");
//Actualizamos los objetos
SparqlUpdateCommandSet updateObject = parser.ParseFromString(@"DELETE { ?s ?p ?o. }
INSERT{?s ?p <" + DissambiguationProblemsResolve[uriOriginal] + @">.}
WHERE
{
?s ?p ?o. FILTER(?o = <" + uriOriginal + @">)
}");
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(store);
processor.ProcessCommandSet(updateSubject);
processor.ProcessCommandSet(updateObject);
}
}
}
System.IO.StringWriter sw = new System.IO.StringWriter();
RdfXmlWriter rdfXmlWriter = new RdfXmlWriter();
rdfXmlWriter.Save(dataGraph, sw);
string rdfXml = sw.ToString();
Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(rdfXml));
FormFile file = new FormFile(stream, 0, stream.Length, "rdfFile", "rdf.xml");
//Actualizamos el item
Dictionary <string, List <string> > discards = new Dictionary <string, List <string> >();
foreach (DiscoverItem.DiscoverDissambiguation dissambiguation in item.DissambiguationProblems)
{
if (DissambiguationProblemsResolve.ContainsKey(dissambiguation.IDOrigin) && DissambiguationProblemsResolve[dissambiguation.IDOrigin] == null)
{
discards.Add(dissambiguation.IDOrigin, dissambiguation.DissambiguationCandiates.Select(x => x.IDCandidate).ToList());
}
}
item.UpdateDissambiguationDiscards(discards, rdfXml);
item.DiscoverRdf = rdfXml;
item.Status = "Pending";
_discoverItemService.ModifyDiscoverItem(item);
//Lo reencolamos corregido junto con su identificador
_callEDtlPublishService.CallDataPublish(file, idJob, false, IdDiscoverItem);
return(RedirectToAction("DetailsJob", "Job", new { id = idJob }));
}
/// <summary>
/// Processes Update requests
/// </summary>
/// <param name="context">HTTP Context</param>
public void ProcessUpdateRequest(HttpContext context)
{
if (this._config.UpdateProcessor == null)
{
context.Response.StatusCode = (int)HttpStatusCode.NotImplemented;
return;
}
if (context.Request.HttpMethod.Equals("OPTIONS"))
{
//OPTIONS requests always result in the Service Description document
IGraph svcDescrip = SparqlServiceDescriber.GetServiceDescription(context, this._config, new Uri(context.Request.Url.AbsoluteUri), ServiceDescriptionType.Update);
HandlerHelper.SendToClient(context, svcDescrip, this._config);
return;
}
//See if there has been an update submitted
String updateText = context.Request.QueryString["update"];
if (updateText == null || updateText.Equals(String.Empty))
{
updateText = context.Request.Form["update"];
}
//If no Update sent either show Update Form or give a HTTP 400 response
if (updateText == null || updateText.Equals(String.Empty))
{
if (this._config.ShowUpdateForm)
{
this.ShowUpdateForm(context);
return;
}
else
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
}
try
{
//Now we're going to parse the Updates
SparqlUpdateParser parser = new SparqlUpdateParser();
parser.ExpressionFactories = this._config.ExpressionFactories;
SparqlUpdateCommandSet commands = parser.ParseFromString(updateText);
//Check whether we need to use authentication
//If there are no user groups then no authentication is in use so we default to authenticated with no per-action authentication needed
bool isAuth = true, requireActionAuth = false;
if (this._config.UserGroups.Any())
{
//If we have user
isAuth = HandlerHelper.IsAuthenticated(context, this._config.UserGroups);
requireActionAuth = true;
}
if (!isAuth)
{
return;
}
//First check actions to see whether they are all permissible
foreach (SparqlUpdateCommand cmd in commands.Commands)
{
//Authenticate each action
bool actionAuth = true;
if (requireActionAuth)
{
actionAuth = HandlerHelper.IsAuthenticated(context, this._config.UserGroups, this.GetUpdatePermissionAction(cmd));
}
if (!actionAuth)
{
throw new SparqlUpdateException("You are not authorised to perform the " + this.GetUpdatePermissionAction(cmd) + " action");
}
}
//Then assuming we got here this means all our actions are permitted so now we can process the updates
this.ProcessUpdates(commands);
//Flush outstanding changes
this._config.UpdateProcessor.Flush();
//Update the Cache as the request may have changed the endpoint
this.UpdateConfig(context);
}
catch (RdfParseException parseEx)
{
HandleUpdateErrors(context, "Parsing Error", updateText, parseEx);
}
catch (SparqlUpdateException updateEx)
{
HandleUpdateErrors(context, "Update Error", updateText, updateEx);
}
catch (RdfException rdfEx)
{
HandleUpdateErrors(context, "RDF Error", updateText, rdfEx);
}
catch (Exception ex)
{
HandleUpdateErrors(context, "Error", updateText, ex);
}
}
/// <summary>
/// Procesa los resultados del descubrimiento
/// </summary>
/// <param name="pDiscoverItem">Objeto con los datos de com procesar el proeso de descubrimiento</param>
/// <param name="pDiscoverResult">Resultado de la aplicación del descubrimiento</param>
/// <param name="pDiscoverItemBDService">Clase para gestionar las operaciones de las tareas de descubrimiento</param>
/// <param name="pCallCronApiService">Servicio para hacer llamadas a los métodos del apiCron</param>
/// <param name="pCallUrisFactoryApiService">Servicio para hacer llamadas a los métodos del Uris Factory</param>
/// <param name="pProcessDiscoverStateJobBDService">Clase para gestionar los estados de descubrimiento de las tareas</param>
/// <returns></returns>
public void Process(DiscoverItem pDiscoverItem, DiscoverResult pDiscoverResult, DiscoverItemBDService pDiscoverItemBDService, CallCronApiService pCallCronApiService, CallUrisFactoryApiService pCallUrisFactoryApiService, ProcessDiscoverStateJobBDService pProcessDiscoverStateJobBDService)
{
#region Cargamos configuraciones
ConfigSparql ConfigSparql = new ConfigSparql();
string SGI_SPARQLEndpoint = ConfigSparql.GetEndpoint();
string SGI_SPARQLGraph = ConfigSparql.GetGraph();
string SGI_SPARQLQueryParam = ConfigSparql.GetQueryParam();
string SGI_SPARQLUsername = ConfigSparql.GetUsername();
string SGI_SPARQLPassword = ConfigSparql.GetPassword();
string Unidata_SPARQLEndpoint = ConfigSparql.GetUnidataEndpoint();
string Unidata_SPARQLGraph = ConfigSparql.GetUnidataGraph();
string Unidata_SPARQLQueryParam = ConfigSparql.GetUnidataQueryParam();
string Unidata_SPARQLUsername = ConfigSparql.GetUnidataUsername();
string Unidata_SPARQLPassword = ConfigSparql.GetUnidataPassword();
ConfigService ConfigService = new ConfigService();
string UnidataDomain = ConfigService.GetUnidataDomain();
string UnidataUriTransform = ConfigService.GetUnidataUriTransform();
#endregion
/*
* En función del resultado obtenido se realiza una de las siguientes acciones:
* Si para alguna entidad hay más de un candidato que supere el umbral máximo o hay alguna entidad que supere el umbral mínimo pero no alcance el máximo se agregará el RDF a una BBDD junto con todos los datos necesarios para que el administrador decida como proceder.
* Si no estamos en el punto anterior
* Se obtienen las entidades principales del RDF y se eliminan todos los triples que haya en la BBDD en los que aparezcan como sujeto u objeto.
* Se eliminan todos los triples cuyo sujeto y predicado estén en el RDF a cargar y estén marcados como monovaluados.
* Se vuelcan los triples a la BBDD.
*
*
*/
if (pDiscoverItem.Publish)
{
if (pDiscoverResult.discoveredEntitiesProbability.Count > 0)
{
//Hay dudas en la desambiguación, por lo que lo actualizamos en la BBDD con su estado correspondiente
pDiscoverItem.UpdateDissambiguationProblems(
pDiscoverResult.discoveredEntitiesProbability,
pDiscoverResult.reconciliationData.reconciliatedEntitiesWithBBDD.Values.Select(x => x.uri).Union(pDiscoverResult.reconciliationData.reconciliatedEntitiesWithIds.Values).Union(pDiscoverResult.reconciliationData.reconciliatedEntitiesWithSubject).Union(pDiscoverResult.reconciliationData.reconciliatedEntitiesWithExternalIntegration.Values.Select(x => x.uri)).ToList(),
pDiscoverResult.GetDataGraphRDF());
pDiscoverItemBDService.ModifyDiscoverItem(pDiscoverItem);
}
else
{
string urlDiscoverAgent = pCallUrisFactoryApiService.GetUri("Agent", "discover");
//Creamos los SameAs hacia unidata para las entidades que NO lo tengan hacia Unidata
//TODO descomentar cuando esté habilitaado Unidata
//pDiscoverResult.dataGraph = AsioPublication.CreateUnidataSameAs(pDiscoverResult.dataGraph, UnidataDomain, UnidataUriTransform);
//Publicamos en el SGI
AsioPublication asioPublication = new AsioPublication(SGI_SPARQLEndpoint, SGI_SPARQLQueryParam, SGI_SPARQLGraph, SGI_SPARQLUsername, SGI_SPARQLPassword);
asioPublication.PublishRDF(pDiscoverResult.dataGraph, pDiscoverResult.ontologyGraph, new KeyValuePair <string, string>(urlDiscoverAgent, "Algoritmos de descubrimiento"), pDiscoverResult.start, pDiscoverResult.end, pDiscoverResult.discoverLinkData, pCallUrisFactoryApiService);
//TODO Lógica nombres de personas
SparqlResultSet sparqlResultSet = (SparqlResultSet)pDiscoverResult.dataGraph.ExecuteQuery("select ?s ?name where {?s a <http://purl.org/roh/mirror/foaf#Person>. ?s <http://purl.org/roh/mirror/foaf#name> ?name}");
foreach (SparqlResult sparqlResult in sparqlResultSet.Results)
{
string s = sparqlResult["s"].ToString();
string nombre = sparqlResult["name"].ToString();
if (sparqlResult["name"] is ILiteralNode)
{
nombre = ((ILiteralNode)sparqlResult["name"]).Value;
}
_discoverCacheGlobal.PersonsNormalizedNames[s] = DiscoverUtility.NormalizeName(nombre);
}
//TODO Lógica titles
SparqlResultSet sparqlResultSetTitles = (SparqlResultSet)pDiscoverResult.dataGraph.ExecuteQuery("select * where {?s a ?rdftype. ?s <http://purl.org/roh#title> ?title}");
foreach (SparqlResult sparqlResult in sparqlResultSetTitles.Results)
{
string s = sparqlResult["s"].ToString();
string rdftype = sparqlResult["rdftype"].ToString();
string title = sparqlResult["title"].ToString();
if (sparqlResult["title"] is ILiteralNode)
{
title = ((ILiteralNode)sparqlResult["title"]).Value;
}
title = DiscoverUtility.NormalizeTitle(title);
if (!_discoverCacheGlobal.EntitiesNormalizedTitles.ContainsKey(rdftype))
{
_discoverCacheGlobal.EntitiesNormalizedTitles.Add(rdftype, new Dictionary <string, HashSet <string> >());
}
if (!_discoverCacheGlobal.EntitiesNormalizedTitles[rdftype].ContainsKey(title))
{
_discoverCacheGlobal.EntitiesNormalizedTitles[rdftype].Add(title, new HashSet <string>());
}
_discoverCacheGlobal.EntitiesNormalizedTitles[rdftype][title].Add(s);
}
//TODO descomentar cuando esté habilitaado Unidata
if (false)
{
//Publicamos en UNIDATA
AsioPublication asioPublicationUnidata = new AsioPublication(Unidata_SPARQLEndpoint, Unidata_SPARQLQueryParam, Unidata_SPARQLGraph, Unidata_SPARQLUsername, Unidata_SPARQLPassword);
// Prepara el grafo para su carga en Unidata, para ello coge las URIs de Unidata del SameAs y la aplica a los sujetos y los antiguos sujetos se agregan al SameAs
RohGraph unidataGraph = AsioPublication.TransformUrisToUnidata(pDiscoverResult.dataGraph, UnidataDomain, UnidataUriTransform);
//Eliminamos los triples de crisIdentifier ya que no hay que volcarlos en unidata
{
TripleStore store = new TripleStore();
store.Add(unidataGraph);
SparqlUpdateParser parser = new SparqlUpdateParser();
//Actualizamos los sujetos
SparqlUpdateCommandSet updateSubject = parser.ParseFromString(
@" DELETE { ?s ?p ?o. }
WHERE
{
?s ?p ?o. FILTER(?p =<" + mPropertySGIRohCrisIdentifier + @">)
}");
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(store);
processor.ProcessCommandSet(updateSubject);
}
asioPublicationUnidata.PublishRDF(unidataGraph, pDiscoverResult.ontologyGraph, new KeyValuePair <string, string>(urlDiscoverAgent, "Algoritmos de descubrimiento"), pDiscoverResult.start, pDiscoverResult.end, pDiscoverResult.discoverLinkData, pCallUrisFactoryApiService);
}
//Lo marcamos como procesado en la BBDD y eliminamos sus metadatos
pDiscoverItem.UpdateProcessed();
pDiscoverItemBDService.ModifyDiscoverItem(pDiscoverItem);
}
//Actualizamos el estado de descubrimiento de la tarea si el estado encolado esta en estado Succeeded o Failed (ha finalizado)
//TODO cambiar por query a BBDD
string statusQueueJob = pCallCronApiService.GetJob(pDiscoverItem.JobID).State;
if ((statusQueueJob == "Failed" || statusQueueJob == "Succeeded"))
{
ProcessDiscoverStateJob processDiscoverStateJob = pProcessDiscoverStateJobBDService.GetProcessDiscoverStateJobByIdJob(pDiscoverItem.JobID);
string state;
//Actualizamos a error si existen items en estado error o con problemas de desambiguación
if (pDiscoverItemBDService.ExistsDiscoverItemsErrorOrDissambiguatinProblems(pDiscoverItem.JobID))
{
state = "Error";
}
else if (pDiscoverItemBDService.ExistsDiscoverItemsPending(pDiscoverItem.JobID))
{
//Actualizamos a 'Pending' si aún existen items pendientes
state = "Pending";
}
else
{
//Actualizamos a Success si no existen items en estado error ni con problemas de desambiguación y no hay ninguno pendiente
state = "Success";
}
if (processDiscoverStateJob != null)
{
processDiscoverStateJob.State = state;
pProcessDiscoverStateJobBDService.ModifyProcessDiscoverStateJob(processDiscoverStateJob);
}
else
{
processDiscoverStateJob = new ProcessDiscoverStateJob()
{
State = state, JobId = pDiscoverItem.JobID
};
pProcessDiscoverStateJobBDService.AddProcessDiscoverStateJob(processDiscoverStateJob);
}
}
}
else
{
//Actualizamos en BBDD
DiscoverItem discoverItemBD = pDiscoverItemBDService.GetDiscoverItemById(pDiscoverItem.ID);
//Reporte de descubrimiento
string discoverReport = "Time processed (seconds): " + pDiscoverResult.secondsProcessed + "\n";
if (pDiscoverResult.reconciliationData.reconciliatedEntitiesWithSubject != null && pDiscoverResult.reconciliationData.reconciliatedEntitiesWithSubject.Count > 0)
{
discoverReport += "Entities discover with the same uri: " + pDiscoverResult.reconciliationData.reconciliatedEntitiesWithSubject.Count + "\n";
foreach (string uri in pDiscoverResult.reconciliationData.reconciliatedEntitiesWithSubject)
{
discoverReport += "\t" + uri + "\n";
}
}
if (pDiscoverResult.reconciliationData.reconciliatedEntitiesWithIds != null && pDiscoverResult.reconciliationData.reconciliatedEntitiesWithIds.Count > 0)
{
discoverReport += "Entities discover with some common identifier: " + pDiscoverResult.reconciliationData.reconciliatedEntitiesWithIds.Count + "\n";
foreach (string uri in pDiscoverResult.reconciliationData.reconciliatedEntitiesWithIds.Keys)
{
discoverReport += "\t" + uri + " --> " + pDiscoverResult.reconciliationData.reconciliatedEntitiesWithIds[uri] + "\n";
}
}
if (pDiscoverResult.reconciliationData.reconciliatedEntitiesWithBBDD != null && pDiscoverResult.reconciliationData.reconciliatedEntitiesWithBBDD.Count > 0)
{
discoverReport += "Entities discover with reconciliation config: " + pDiscoverResult.reconciliationData.reconciliatedEntitiesWithBBDD.Count + "\n";
foreach (string uri in pDiscoverResult.reconciliationData.reconciliatedEntitiesWithBBDD.Keys)
{
discoverReport += "\t" + uri + " --> " + pDiscoverResult.reconciliationData.reconciliatedEntitiesWithBBDD[uri] + "\n";
}
}
if (pDiscoverResult.reconciliationData.reconciliatedEntitiesWithExternalIntegration != null && pDiscoverResult.reconciliationData.reconciliatedEntitiesWithExternalIntegration.Count > 0)
{
discoverReport += "Entities discover with external integrations config: " + pDiscoverResult.reconciliationData.reconciliatedEntitiesWithExternalIntegration.Count + "\n";
foreach (string uri in pDiscoverResult.reconciliationData.reconciliatedEntitiesWithExternalIntegration.Keys)
{
discoverReport += "\t" + uri + " --> " + pDiscoverResult.reconciliationData.reconciliatedEntitiesWithExternalIntegration[uri] + "\n";
}
}
if (pDiscoverResult.discoverLinkData != null && pDiscoverResult.discoverLinkData.entitiesProperties != null && pDiscoverResult.discoverLinkData.entitiesProperties.Count > 0)
{
discoverReport += "Entities with identifiers obtained with External integration: " + pDiscoverResult.discoverLinkData.entitiesProperties.Count + "\n";
foreach (string uri in pDiscoverResult.discoverLinkData.entitiesProperties.Keys)
{
foreach (DiscoverLinkData.PropertyData property in pDiscoverResult.discoverLinkData.entitiesProperties[uri])
{
foreach (string value in property.valueProvenance.Keys)
{
foreach (string provenance in property.valueProvenance[value])
{
discoverReport += "\t" + uri + " - " + property.property + " - " + value + " --> " + provenance + "\n";
}
}
}
}
}
discoverItemBD.UpdateReport(pDiscoverResult.discoveredEntitiesProbability, pDiscoverResult.GetDataGraphRDF(), discoverReport);
pDiscoverItemBDService.ModifyDiscoverItem(discoverItemBD);
}
}
/// <summary>
/// Processes Update requests
/// </summary>
/// <param name="context">HTTP Context</param>
public void ProcessUpdateRequest(HttpServerContext context)
{
if (this._config.UpdateProcessor == null)
{
context.Response.StatusCode = (int)HttpStatusCode.NotImplemented;
return;
}
//Try and parse the Form Variables
FormVariables form = new FormVariables(context);
if (!form.IsValid)
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
if (context.Request.HttpMethod.Equals("OPTIONS"))
{
context.Response.StatusCode = (int)HttpStatusCode.NotImplemented;
return;
//TODO: Support Service Description?
////OPTIONS requests always result in the Service Description document
//IGraph svcDescrip = SparqlServiceDescriber.GetServiceDescription(context, this._config, UriFactory.Create(context.Request.Url.AbsoluteUri), ServiceDescriptionType.Update);
//HandlerHelper.SendToClient(context, svcDescrip, this._config);
//return;
}
//See if there has been an update submitted
String updateText = null;
if (context.Request.ContentType != null)
{
if (context.Request.ContentType.Equals(MimeTypesHelper.WWWFormURLEncoded))
{
updateText = form["update"];
}
else if (context.Request.ContentType.Equals(MimeTypesHelper.SparqlUpdate))
{
updateText = new StreamReader(context.Request.InputStream).ReadToEnd();
}
}
else
{
updateText = form["update"];
}
//If no Update sent either show Update Form or give a HTTP 400 response
if (updateText == null || updateText.Equals(String.Empty))
{
if (this._config.ShowUpdateForm)
{
this.ShowUpdateForm(context);
return;
}
else
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
}
//Get Other options associated with this update
List <String> userDefaultGraphs = new List <String>();
List <String> userNamedGraphs = new List <String>();
//Get the USING URIs (if any)
if (context.Request.QueryString["using-graph-uri"] != null)
{
userDefaultGraphs.AddRange(context.Request.QueryString.GetValues("using-graph-uri"));
}
else if (form["using-graph-uri"] != null)
{
userDefaultGraphs.AddRange(form.GetValues("using-graph-uri"));
}
//Get the USING NAMED URIs (if any)
if (context.Request.QueryString["using-named-graph-uri"] != null)
{
userNamedGraphs.AddRange(context.Request.QueryString.GetValues("using-named-graph-uri"));
}
else if (form["using-named-graph-uri"] != null)
{
userNamedGraphs.AddRange(form.GetValues("using-named-graph-uri"));
}
try
{
//Now we're going to parse the Updates
SparqlUpdateParser parser = new SparqlUpdateParser();
parser.ExpressionFactories = this._config.ExpressionFactories;
SparqlUpdateCommandSet commands = parser.ParseFromString(updateText);
//TODO: Support Authentication?
////Check whether we need to use authentication
////If there are no user groups then no authentication is in use so we default to authenticated with no per-action authentication needed
//bool isAuth = true, requireActionAuth = false;
//if (this._config.UserGroups.Any())
//{
// //If we have user
// isAuth = HandlerHelper.IsAuthenticated(context, this._config.UserGroups);
// requireActionAuth = true;
//}
//if (!isAuth) return;
//First check actions to see whether they are all permissible and apply USING/USING NAMED paramaters
foreach (SparqlUpdateCommand cmd in commands.Commands)
{
//TODO: Support Authentication?
////Authenticate each action
//bool actionAuth = true;
//if (requireActionAuth) actionAuth = HandlerHelper.IsAuthenticated(context, this._config.UserGroups, this.GetUpdatePermissionAction(cmd));
//if (!actionAuth)
//{
// throw new SparqlUpdatePermissionException("You are not authorised to perform the " + this.GetUpdatePermissionAction(cmd) + " action");
//}
//Check whether we need to (and are permitted to) apply USING/USING NAMED parameters
if (userDefaultGraphs.Count > 0 || userNamedGraphs.Count > 0)
{
BaseModificationCommand modify = cmd as BaseModificationCommand;
if (modify != null)
{
if (modify.GraphUri != null || modify.UsingUris.Any() || modify.UsingNamedUris.Any())
{
//Invalid if a command already has a WITH/USING/USING NAMED
throw new SparqlUpdateMalformedException("A command in your update request contains a WITH/USING/USING NAMED clause but you have also specified one/both of the using-graph-uri or using-named-graph-uri parameters which is not permitted by the SPARQL Protocol");
}
else
{
//Otherwise go ahead and apply
userDefaultGraphs.ForEach(u => modify.AddUsingUri(UriFactory.Create(u)));
userNamedGraphs.ForEach(u => modify.AddUsingNamedUri(UriFactory.Create(u)));
}
}
}
}
//Then assuming we got here this means all our actions are permitted so now we can process the updates
this._config.UpdateProcessor.ProcessCommandSet(commands);
//Flush outstanding changes
this._config.UpdateProcessor.Flush();
}
catch (RdfParseException parseEx)
{
HandleUpdateErrors(context, "Parsing Error", updateText, parseEx, (int)HttpStatusCode.BadRequest);
}
catch (SparqlUpdatePermissionException permEx)
{
HandleUpdateErrors(context, "Permissions Error", updateText, permEx, (int)HttpStatusCode.Forbidden);
}
catch (SparqlUpdateMalformedException malEx)
{
HandleUpdateErrors(context, "Malformed Update Error", updateText, malEx, (int)HttpStatusCode.BadRequest);
}
catch (SparqlUpdateException updateEx)
{
HandleUpdateErrors(context, "Update Error", updateText, updateEx);
}
catch (RdfException rdfEx)
{
HandleUpdateErrors(context, "RDF Error", updateText, rdfEx);
}
catch (Exception ex)
{
HandleUpdateErrors(context, "Error", updateText, ex);
}
}
