public async Task <IActionResult> GetConcreteResource(
[FromQuery] QueryStringParameters queryStringParametersDto)
{
Parameters parameters =
_parametersProcessorService.ProcessParameters(Request.RouteValues, Request.QueryString);
string?query = _sparqlFactoryService.GetFinalSelectQueryForResource(parameters);
if (query != null)
{
var sparqlResults = await _endpointService.ExecuteSelectSparqlQueryAsync(
parameters.RouteParameters.Endpoint,
parameters.RouteParameters.Graph, query);
if (sparqlResults != null)
{
ResourceVm resourceVm = _resultFormatterService.FormatSparqlResultToResourceDetail(sparqlResults);
return(Ok(resourceVm));
}
}
return(NotFound(new CustomErrorVm()
{
CustomErrorMessage = "No results were found!",
GeneratedQuery = query
}));
}
public async Task <IActionResult> PutResource([FromBody] ResourceVm resourceVm)
{
Parameters parameters =
_parametersProcessorService.ProcessParameters(Request.RouteValues, Request.QueryString);
string?query = _sparqlFactoryService.GetFinalPutQueryForResource(parameters, resourceVm);
if (query != null)
{
bool successful = await _endpointService.ExecuteUpdateSparqlQueryAsync(
parameters.RouteParameters.Endpoint,
parameters.RouteParameters.Graph, query);
if (successful)
{
return(Created(new Uri(Request.GetEncodedUrl()), resourceVm));
}
}
return(BadRequest(new ValidationErrorVm()
{
CustomError = new CustomErrorVm()
{
CustomErrorMessage =
$"Resource could not have been created! Check selected endpoint configuration at {UrlHelperClass.GetEndpointUrl(Request.GetEncodedUrl())}.",
GeneratedQuery = query
}
}));
}
public string?GetFinalPutQueryForResource(Parameters parameters, ResourceVm resourceVm)
{
string resourceCurie = parameters.RouteParameters.Resource;
if (_namespaceFactoryService.GetAbsoluteUriFromQname(resourceCurie, out string resourceAbsoluteUri))
{
SparqlParameterizedString sparqlParameterizedDeleteQuery = new();
sparqlParameterizedDeleteQuery.CommandText = "DELETE {@sub ?p ?o} WHERE {@sub ?p ?o} ";
sparqlParameterizedDeleteQuery.SetUri("sub", new Uri(resourceAbsoluteUri));
string?deleteQuery = sparqlParameterizedDeleteQuery.ToString();
string?insertQuery = ConstructInsertResourceQueryString(resourceVm, resourceAbsoluteUri);
if (string.IsNullOrEmpty(insertQuery))
{
return(null);
}
deleteQuery = ImplementFromGraphClauseToInsertDeleteQuery(deleteQuery, parameters);
if (string.IsNullOrEmpty(deleteQuery))
{
return(null);
}
string finalQuery = deleteQuery + insertQuery;
return(finalQuery);
}
return(null);
}
private string?ConstructInsertResourceQueryString(ResourceVm resourceVm, string resourceAbsoluteUri)
{
SparqlParameterizedString sparqlParameterizedInsertQuery = new();
sparqlParameterizedInsertQuery.CommandText = "INSERT DATA {@sub @pred @obj";
string?insertQuery = null;
sparqlParameterizedInsertQuery.SetUri("sub", new Uri(resourceAbsoluteUri));
SparqlParameterizedString sparqlParameterizedInsertSubQuery = new();
sparqlParameterizedInsertSubQuery.CommandText = "; @pred @obj";
foreach (var propertyName in resourceVm.Predicates.Keys)
{
if (_namespaceFactoryService.GetAbsoluteUriFromQname(propertyName, out string predAbsoluteUri))
{
PredicateContent propertyContent = resourceVm.Predicates[propertyName];
insertQuery += PopulateInsertQueryString(propertyContent,
sparqlParameterizedInsertQuery, sparqlParameterizedInsertSubQuery,
resourceAbsoluteUri, predAbsoluteUri);
if (string.IsNullOrEmpty(insertQuery))
{
return(null);
}
insertQuery += "} ";
}
else
{
return(null);
}
}
return(insertQuery);
}
public async Task TestPutResourceEndpoint_ShouldRBadRequest(string endpoint, string graph,
string resourceCurie, string predicateCurie)
{
ResourceVm resourceVm = new ResourceVm()
{
Predicates = new Dictionary <string, PredicateContent>()
{
{
predicateCurie,
new PredicateContent()
{
Curies = new List <string>()
{
"ex:newCurie"
},
}
}
}
};
var response =
await TestClient.PutAsJsonAsync(ApiRoutes.NamedGraphResourcesConcreteResource
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie), resourceVm);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task <ActionResult> Detail(int id)
{
var retVal = new ResourceVm
{
Success = false,
Message = ""
};
if (id <= 0)
{
retVal.Message = "Please provide an id.";
return(PartialView("Partial/_resourceDetailsPartial", retVal));
}
var result = await _resourceService.FindAsync(id);
if (result != null)
{
retVal.Success = true;
if (Request.IsAjaxRequest())
{
retVal.Resource = result.ConvertToViewModel();
}
}
else
{
retVal.Message = "Item with requested Id was not found.";
}
return(PartialView("Partial/_resourceDetailsPartial", retVal));
}
public ActionResult Edit(int?id)
{
var retVal = new ResourceVm
{
Success = false,
Message = ""
};
if (id <= 0)
{
retVal.Message = "Please provide an id.";
// return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
return(PartialView("Partial/_resourceEditPartial", retVal));
}
var result = _resourceService.Find(id);
if (result != null)
{
retVal.Success = true;
retVal.Resource = result.ConvertToViewModel();
}
else
{
retVal.Message = "Item with requested Id was not found.";
}
return(PartialView("Partial/_resourceEditPartial", retVal));
}
private void UpdateResource()
{
if (_resVm == null)
{
Assert.Fail("UpdateResource: Test Failed to create a new manager.");
}
var dbEdited = _resVm;
dbEdited.Name = "Test Manager Edited";
var dbRes = ManagerSvc.UpdateResource(dbEdited);
_resVm = dbRes.Resource;
Assert.IsTrue(dbRes.IsSuccess);
}
/*TODO : MAKE SURE THAT ALL THE TRANSACTION ON SET ARE LOGGED IN A TABLE*/
/// <summary>
/// Create a new Resource Manager
/// </summary>
/// <param name="name">Resource Name</param>
/// <param name="type">Resource Type</param>
/// <param name="settings">Settings</param>
/// <returns><![CDATA[ (ResourceVm Resource, ResourceSettingsVm Settings) ]]></returns>
public (ResourceVm Resource, ResourceSettingsVm Settings, bool IsSuccess, String Message) Create(string name, ResourceType type, ResourceSettingsVm settings)
{
try
{
// Check if the claim already exists
var dbCheck = ResourceDataAccess.ResourceClaim.Find(f => f.ClaimName.ToLower() == name.ToLower());
if (dbCheck != null)
{
return(null, null, false, ResourceManagerMessages.Error.RESOURCE_ALREADY_EXISTS);
}
// Create the Resource
var dbView = (new ResourceVm()
{
Name = name
}).ToEntityCreate(type);
dbView = ResourceDataAccess.ResourceManager.Create(dbView);
// Create the Resource Settings
var dbSettings = settings.ToEntityCreate(dbView);
dbSettings = ResourceDataAccess.ResourceSettings.Create(dbSettings);
ResourceDataAccess.Save();
var res = new ResourceVm(dbView);
settings = new ResourceSettingsVm(dbSettings);
return(res, settings, true, ResourceManagerMessages.Success.RESOURCE_CREATED);
}
catch (DbEntityValidationException ex)
{
#if (DEBUG)
// for debuging entity framework
foreach (var error in ex.EntityValidationErrors.SelectMany(valError => valError.ValidationErrors))
{
Console.WriteLine(error.ErrorMessage);
}
#endif
throw;
}
catch
{
throw;
}
}
/// <summary>
/// Update an existing resource
/// </summary>
/// <param name="resource">ResourceVm</param>
/// <returns><![CDATA[ (ResourceVm Resource, bool IsSuccess, String Message) ]]></returns>
public (ResourceVm Resource, bool IsSuccess, String Message) UpdateResource(ResourceVm resource)
{
// Check and make sure that the data exisits.
var dbRes = ResourceDataAccess.ResourceManager.GetById(resource.Id);
if (dbRes == null)
{
return(null, false, ResourceManagerMessages.Error.RESOURCE_NOT_FOUND);
}
// Update the resource manager.
dbRes = resource.ToEntity(dbRes);
ResourceDataAccess.ResourceManager.Update(dbRes);
ResourceDataAccess.Save();
resource = new ResourceVm(dbRes);
return(resource, true, ResourceManagerMessages.Success.RESOUCE_UPDATED);
}
private void CreateManager()
{
#region Set Settings
var dbSettings = new ResourceSettingsVm()
{
Status = ResourceStatus.Pending
};
#endregion Set Settings
var dbRes = ManagerSvc.Create("Test Manager", ResourceType.Member, dbSettings);
_resVm = dbRes.Resource;
_resSettingsVm = dbRes.Settings;
Assert.IsTrue(dbRes.IsSuccess);
}
public async Task TestPutResourceEndpoint_ShouldReturnCreated(string endpoint, string graph,
string resourceCurie)
{
ResourceVm resourceVm = new ResourceVm()
{
Predicates = new Dictionary <string, PredicateContent>()
{
{
"ex:newProperty",
new PredicateContent()
{
Curies = new List <string>()
{
"ex:newCurie"
},
}
}
}
};
//Resource exists
var responseOnGetNotYetModifiedResource = await TestClient.GetAsync(ApiRoutes
.NamedGraphResourcesConcreteResource
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie));
Assert.Equal(HttpStatusCode.OK, responseOnGetNotYetModifiedResource.StatusCode);
//Resource modified
var response =
await TestClient.PutAsJsonAsync(ApiRoutes.NamedGraphResourcesConcreteResource
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie), resourceVm);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
//Modified resource confirmation
var recreatedResource = await TestClient.GetAsync(ApiRoutes.NamedGraphResourcesConcreteResource
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie)).Result.Content
.ReadAsAsync <ResourceVm>();
Assert.True(recreatedResource.Predicates.ContainsKey("ex:newProperty"));
}
public async Task <ActionResult> Edit([Bind(Include = "Id, Name, Description, Active, ActiveFrom, ActiveTo")] ApplicationResource resource)
{
// https://stackoverflow.com/questions/39533599/mvc-5-with-bootstrap-modal-from-partial-view-validation-not-working
// https://stackoverflow.com/questions/2845852/asp-net-mvc-how-to-convert-modelstate-errors-to-json
var retVal = new ResourceVm
{
Success = false,
Message = ""
};
if (ModelState.IsValid)
{
var repo = _unitOfWorkAsync.RepositoryAsync <ApplicationResource>();
var valid = resource.Validate();
try
{
repo.Update(resource);
var result = await _unitOfWorkAsync.SaveChangesAsync();
if (result > 0)
{
retVal.Success = true;
}
}
catch (Exception e)
{
Console.WriteLine(e);
Debug.WriteLine(e);
retVal.Message = e.Message;
}
}
else
{
retVal.FormErrors = ModelState.Select(kvp => new { key = kvp.Key, errors = kvp.Value.Errors.Select(e => e.ErrorMessage) });
retVal.Message = "Model state invalid";
}
return(PartialView("Partial/_resourceEditPartial", retVal));
}
public ResourceVm FormatSparqlResultToResourceDetail(IEnumerable <SparqlResult> sparqlResults)
{
ResourceVm resourceVm = new ResourceVm()
{
Predicates = new Dictionary <string, PredicateContent>()
};
foreach (var sparqlResult in sparqlResults)
{
string property = sparqlResult.Value("p").ToString();
if (!_namespaceFactoryService.GetQnameFromAbsoluteUri(property, out var propertyQname))
{
continue;
}
if (!resourceVm.Predicates.ContainsKey(propertyQname))
{
resourceVm.Predicates.Add(propertyQname, new PredicateContent());
}
string obj = sparqlResult.Value("o").ToString();
if (CheckIfValueIsLiteral(obj, propertyQname, out Literal literal))
{
if (resourceVm.Predicates[propertyQname].Literals == null)
{
resourceVm.Predicates[propertyQname].Literals = new List <Literal>();
}
resourceVm.Predicates[propertyQname].Literals.Add(literal);
}
else
{
if (_namespaceFactoryService.GetQnameFromAbsoluteUri(obj, out var objQname))
{
if (resourceVm.Predicates[propertyQname].Curies == null)
{
resourceVm.Predicates[propertyQname].Curies = new List <string>();
}
resourceVm.Predicates[propertyQname].Curies.Add(HttpUtility.UrlDecode(objQname));
}
}
}
return(resourceVm);
}
public async Task TestPostResourceEndpoint_ShouldReturnCreated(string endpoint, string graph, string resourceCurie)
{
NamedResourceVm resourceVm = new NamedResourceVm()
{
ResourceCurie = resourceCurie,
Predicates = new Dictionary <string, PredicateContent>()
{
{
"ex:examplePredicate",
new PredicateContent()
{
Curies = new List <string>()
{
"ex:curie1", "ex:curie2", "ex:curie3"
},
Literals = new List <Literal>()
{
new() { Value = "Example language text...", Language = "en" },
new() { Value = "2021-03-02T20:00:00-01:00", Datatype = "xsd:dateTime" },
new() { Value = "String value" }
}
}
}
}
};
var response = await TestClient.PostAsJsonAsync(
ApiRoutes.NamedGraphResources.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph), resourceVm);
ResourceVm createdResource = await TestClient.GetAsync(ApiRoutes.NamedGraphResourcesConcreteResource
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph)
.Replace("{resource:regex(.+:.+)}", resourceCurie)).Result.Content.ReadAsAsync <ResourceVm>();
Assert.Contains("ex:examplePredicate", createdResource.Predicates.Keys);
Assert.True(createdResource.Predicates.Values.First().Curies.Count() == 3);
Assert.True(createdResource.Predicates.Values.First().Literals.Count() == 3);
//Possibly additional checks on returned object which should same as NamedResourceObjectAbove
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
}
