public async Task <IActionResult> GetConcreteResourcePredicate(
[FromQuery] QueryStringParameters queryStringParametersDto)
{
Parameters parameters =
_parametersProcessorService.ProcessParameters(Request.RouteValues, Request.QueryString);
string?query = _sparqlFactoryService.GetFinalSelectQueryForPredicate(parameters);
if (query != null)
{
var sparqlResults = await _endpointService.ExecuteSelectSparqlQueryAsync(
parameters.RouteParameters.Endpoint,
parameters.RouteParameters.Graph, query);
if (sparqlResults != null)
{
PredicateVm predicateVm =
_resultFormatterService.FormatSparqlResultToCurieAndLiteralList(
parameters.RouteParameters.Predicate, sparqlResults);
return(Ok(predicateVm));
}
}
return(NotFound(new CustomErrorVm()
{
CustomErrorMessage = "No results were found!",
GeneratedQuery = query
}));
}
public async Task <IActionResult> PutPredicate(PredicateVm predicateVm)
{
Parameters parameters =
_parametersProcessorService.ProcessParameters(Request.RouteValues, Request.QueryString);
string?query = _sparqlFactoryService.GetFinalPutQueryForPredicate(parameters, predicateVm);
if (query != null)
{
bool successful = await _endpointService.ExecuteUpdateSparqlQueryAsync(
parameters.RouteParameters.Endpoint,
parameters.RouteParameters.Graph, query);
if (successful)
{
return(Created(new Uri(Request.GetEncodedUrl()), predicateVm));
}
}
return(BadRequest(new ValidationErrorVm()
{
CustomError = new CustomErrorVm()
{
CustomErrorMessage =
$"Predicate could not have been created! Check selected endpoint configuration at {UrlHelperClass.GetEndpointUrl(Request.GetEncodedUrl())}.",
GeneratedQuery = query
}
}));
}
public string?GetFinalPutQueryForPredicate(Parameters parameters, PredicateVm predicateVm)
{
string resourceCurie = parameters.RouteParameters.Resource;
string predicateCurie = parameters.RouteParameters.Predicate;
if (_namespaceFactoryService.GetAbsoluteUriFromQname(resourceCurie, out string resourceAbsoluteUri) &&
_namespaceFactoryService.GetAbsoluteUriFromQname(predicateCurie, out string predicateAbsoluteUri))
{
SparqlParameterizedString sparqlParameterizedDeleteQuery = new();
sparqlParameterizedDeleteQuery.CommandText = "DELETE {@sub @pred ?o} WHERE {@sub @pred ?o} ";
sparqlParameterizedDeleteQuery.SetUri("sub", new Uri(resourceAbsoluteUri));
sparqlParameterizedDeleteQuery.SetUri("pred", new Uri(predicateAbsoluteUri));
string?deleteQuery = sparqlParameterizedDeleteQuery.ToString();
string?insertQuery =
ConstructInsertPredicateQueryString(predicateVm, resourceAbsoluteUri, predicateAbsoluteUri);
if (string.IsNullOrEmpty(insertQuery))
{
return(null);
}
deleteQuery = ImplementFromGraphClauseToInsertDeleteQuery(deleteQuery, parameters);
if (string.IsNullOrEmpty(deleteQuery))
{
return(null);
}
string finalQuery = deleteQuery + insertQuery;
return(finalQuery);
}
return(null);
}
public async Task TestPostPredicateEndpoint_ShouldReturnCreated(string endpoint, string graph,
string resourceCurie, string predicateCurie)
{
NamedPredicateVm resourceVm = new NamedPredicateVm()
{
PredicateCurie = predicateCurie,
Curies = new List <string>()
{
"ex:curie1", "ex:curie2", "ex:curie3"
},
Literals = new List <Literal>()
{
new() { Value = "value1", Datatype = "ex:exampleDatatype" },
new() { Value = "value2", Language = "en" },
new() { Value = "value3" }
}
};
var response = await TestClient.PostAsJsonAsync(
ApiRoutes.NamedGraphResourcesConcreteResource.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie), resourceVm);
PredicateVm createdPredicate = await TestClient.GetAsync(ApiRoutes.NamedGraphResourceStartConcreteResourcePredicate
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie)
.Replace("{predicate:regex(.+:.+)}", predicateCurie)).Result.Content.ReadAsAsync <PredicateVm>();
Assert.True(createdPredicate.Curies.Count == 3);
Assert.True(createdPredicate.Literals.Count == 3);
//Possibly additional checks about ValidationErrorVm
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
}
public PredicateVm FormatSparqlResultToCurieAndLiteralList(string predicate,
IEnumerable <SparqlResult> sparqlResults)
{
PredicateVm predicateVm = new PredicateVm();
foreach (var sparqlResult in sparqlResults)
{
string obj = sparqlResult.Value("o").ToString();
if (CheckIfValueIsLiteral(obj, predicate, out Literal literal))
{
if (predicateVm.Literals == null)
{
predicateVm.Literals = new List <Literal>();
}
predicateVm.Literals.Add(literal);
}
else
{
if (_namespaceFactoryService.GetQnameFromAbsoluteUri(obj, out var objQname))
{
if (predicateVm.Curies == null)
{
predicateVm.Curies = new List <string>();
}
predicateVm.Curies.Add(HttpUtility.UrlDecode(objQname));
}
}
}
return(predicateVm);
}
public async Task TestPutPredicateEndpoint_ShouldReturnCreated(string endpoint, string graph,
string resourceCurie, string predicateCurie)
{
PredicateVm predicateVm = new PredicateVm()
{
Curies = new List <string>()
{
"ex:newCurie"
}
};
//Predicate exists
var responseOnGetNotYetModifiedPredicate = await TestClient.GetAsync(ApiRoutes
.NamedGraphResourceStartConcreteResourcePredicate
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie)
.Replace("{predicate:regex(.+:.+)}", predicateCurie));
Assert.Equal(HttpStatusCode.OK, responseOnGetNotYetModifiedPredicate.StatusCode);
//Same resource different predicate
var responseOnGetSameResourceDifferenctPredicate = await TestClient.GetAsync(ApiRoutes
.NamedGraphResourceStartConcreteResourcePredicate
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie)
.Replace("{predicate:regex(.+:.+)}", "ex:uniquePutPredicate3"));
Assert.Equal(HttpStatusCode.OK, responseOnGetSameResourceDifferenctPredicate.StatusCode);
//Predicate modified
var response =
await TestClient.PutAsJsonAsync(ApiRoutes.NamedGraphResourceStartConcreteResourcePredicate
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie)
.Replace("{predicate:regex(.+:.+)}", predicateCurie), predicateVm);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
//Modified predicate confirmation
var recreatedResource = await TestClient.GetAsync(ApiRoutes
.NamedGraphResourcesConcreteResource
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie)).Result.Content
.ReadAsAsync <ResourceVm>();
//Predicate was recreated to desired value
Assert.Contains("ex:newCurie",
recreatedResource.Predicates.First(keyValuePair => keyValuePair.Key.Equals(predicateCurie)).Value.Curies
.First());
//Same resource different predicate still exists
Assert.True(recreatedResource.Predicates.ContainsKey("ex:uniquePutPredicate3"));
}
private string?ConstructInsertPredicateQueryString(PredicateVm predicateVm, string resourceAbsoluteUri,
string predicateAbsoluteUri)
{
SparqlParameterizedString sparqlParameterizedInsertQuery = new();
sparqlParameterizedInsertQuery.CommandText = "INSERT DATA {@sub @pred @obj";
SparqlParameterizedString sparqlParameterizedInsertSubQuery = new();
sparqlParameterizedInsertSubQuery.CommandText = "; @pred @obj";
string?insertQuery = null;
insertQuery += PopulateInsertQueryString(predicateVm,
sparqlParameterizedInsertQuery, sparqlParameterizedInsertSubQuery, resourceAbsoluteUri,
predicateAbsoluteUri);
if (string.IsNullOrEmpty(insertQuery))
{
return(null);
}
insertQuery += "}";
return(insertQuery);
}
