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