public void ResourceQueryTest()
{
var literal = "var";
var resourceUri = new Uri("ex:test:resource");
var property = new Property(new Uri("ex:test:property"));
var res = Model.CreateResource(resourceUri);
res.AddProperty(property, literal);
res.Commit();
ResourceQuery q = new ResourceQuery();
q.Where(property, literal);
var queryResult = Model.ExecuteQuery(q);
Assert.AreEqual(1, queryResult.Count());
var result = queryResult.GetResources <Resource>();
Assert.AreEqual(1, result.Count());
var resultResource = result.First();
Assert.AreEqual(resourceUri, resultResource.Uri);
List <Property> properties = resultResource.ListProperties().ToList();
Assert.AreEqual(1, properties.Count);
Assert.AreEqual(property, properties[0]);
Assert.AreEqual(literal, resultResource.GetValue(property));
}
public void ConnectTest()
{
Assert.NotNull(Model);
Assert.NotNull(Model2);
IModel model = Model;
ResourceQuery contact = new ResourceQuery(nco.PersonContact);
contact.Where(nco.birthDate).LessThan(new DateTime(1990, 1, 1));
ResourceQuery group = new ResourceQuery(nco.ContactGroup);
group.Where(nco.contactGroupName, "Family");
contact.Where(nco.belongsToGroup, group);
IResourceQueryResult result = model.ExecuteQuery(contact);
foreach (Resource r in result.GetResources())
{
Console.WriteLine(r.Uri);
}
Contact c = model.CreateResource <Contact>(); // create new resource with GUID
c.Birthday = new DateTime(1980, 6, 14);
c.Fullname = "John Doe";
c.Commit();
}
public uint?SelectCount(DataCatalog dbCatalog, string methodName)
{
ResourceQuery countRQ = IncludeResourceCountOnly(true);
string q = countRQ.ToString(methodName + "(count only)");
return(dbCatalog.NewQuery(q).ReadAsUInt());
}
public Task <IEnumerable <Operation> > GetAsync(CancellationToken cancellationToken)
{
var query = new ResourceQuery();
var operations = _service.Get(query, cancellationToken);
return(Task.FromResult(operations));
}
public ActionResult Query(ResourceQuery query)
{
SetPage(query);
var result = _resourceService.Query(query).Convert(p => p.ToTreeGridVm());
return(ToDataTreeGridResult(result, false, result.TotalCount));
}
private string GetOntologyTitle(IModel model)
{
try
{
ResourceQuery query = new ResourceQuery();
query.Where(rdf.type, owl.Ontology);
IResourceQueryResult result = model.ExecuteQuery(query);
if (result.Count() == 0)
{
return("");
}
IResource ontology = result.GetResources().First();
return(ontology.ListValues(dces.Title).OfType <string>().FirstOrDefault());
}
catch
{
string msg = "Could not retrieve title of ontology <{0}>";
Logger.LogWarning(string.Format(msg, model.Uri.ToString()));
return("");
}
}
/// <summary>
/// Transforms the string name and returned aggregate results into a Facet
/// </summary>
/// <returns>An facet</returns>
/// <param name="facetToFetch">The name of the facet to fetch</param>
/// <param name="resourceQuery">The resource query (used for determining currently-set filters)</param>
/// <param name="aggResults">The list of aggregate results to transform to facet items</param>
private Facet TransformFacet(string facetToFetch, ResourceQuery resourceQuery, KeyLabelAggResult[] aggResults)
{
R4RAPIOptions.FacetConfig config = _apiOptions.AvailableFacets[facetToFetch];
IEnumerable <string> filters = new string[] { };
if (resourceQuery.Filters.ContainsKey(config.FilterName))
{
filters = resourceQuery.Filters[config.FilterName];
}
Facet facet = new Facet
{
Param = config.FilterName,
Title = config.Label,
Items = aggResults.Select(fi =>
new FacetItem
{
Key = fi.Key,
Label = fi.Label,
Count = Convert.ToInt32(fi.Count),
Selected = filters.Contains(fi.Key)
}).ToArray()
};
if (config.FacetType == R4RAPIOptions.FacetTypes.Single && IsFilterSet(config.FilterName, resourceQuery))
{
facet.Items = facet.Items.Where(i => i.Selected).ToArray();
}
return(facet);
}
public void TestClone()
{
ResourceQuery b = new ResourceQuery(nco.PersonContact);
b.Where(nco.birthDate).LessThan(new DateTime(1990, 1, 1)).SortAscending();
ResourceQuery a = new ResourceQuery(nco.PersonContact);
a.Where(nco.gender);
a.Where(nie.relatedTo, b);
ResourceQuery c = b.Clone();
string q = SparqlSerializer.Serialize(Model, c);
IResourceQueryResult result = Model.ExecuteQuery(c);
int i = 0;
foreach (Resource r in result.GetResources())
{
i++;
}
Assert.AreEqual(18, i);
}
public IEnumerable <T> Get(ResourceQuery query, CancellationToken cancellationToken)
{
Debug.Assert(query.PageOffset.HasValue);
Debug.Assert(query.PageSize.HasValue);
var viewName = GetResourceName();
var orderBy = SqliteBuilder.OrderBySql(query);
var sql = SqliteBuilder.SelectSql(viewName, _members, query, out var hasWhere);
var pageSql = sql + SqliteBuilder.PageSql(query, viewName, orderBy, hasWhere);
var db = OpenConnection();
IEnumerable <T> result = db.Query <T>(pageSql);
if (!query.CountTotalRows)
{
return(result);
}
var countSql = SqliteBuilder.CountSql(sql, orderBy);
var total = db.QuerySingle <int>(countSql);
query.TotalRows = total;
return(result);
}
public object Get(ResourceQuery request)
{
var bindingFlags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance;
var types = GetType().Assembly.GetExportedTypes();
var resourceInfos = from t in types
select new
{
Class = t.Name,
Attrs = from cattr in t.GetCustomAttributes() select cattr.GetType().Name,
Methods = from m in t.GetMethods(bindingFlags)
select new
{
Name = m.Name,
Attrs = from mattr in m.GetCustomAttributes <RequiredPermissionExAttribute>() select new
{
Name = mattr.GetType().Name,
Props = from p in mattr.GetType().GetProperties(bindingFlags) select new
{
Name = p.Name,
Value = p.GetValue(mattr)
}
}
}
};
return(resourceInfos);
}
public void TestDebitFilter()
{
Debit[] debits = new Debit[3];
Dictionary <string, object> payload = new Dictionary <string, object>();
payload.Add("amount", 100000);
Dictionary <string, object> payload2 = new Dictionary <string, object>();
payload2.Add("amount", 777);
Dictionary <string, object> payload3 = new Dictionary <string, object>();
payload3.Add("amount", 555);
Card card = createCard();
debits[0] = card.Debit(payload);
debits[1] = card.Debit(payload2);
debits[2] = card.Debit(payload3);
ResourceQuery <Debit> query = card.debits.Query().Filter("amount", "=", 777);
Assert.AreEqual(1, query.Total());
Debit res = query.First();
Assert.AreEqual(debits[1].id, res.id);
query = card.debits.Query().Filter("amount", 777);
Assert.AreEqual(1, query.Total());
Assert.AreEqual(debits[1].id, query.First().id);
query = (
card
.debits
.Query()
.Filter("amount", "<", 800)
.OrderBy("created_at", ResourceQuery <Debit> .SortOrder.ASCENDING)
);
Assert.AreEqual(2, query.Total());
List <Debit> allDebits = query.All();
Assert.AreEqual(debits[1].id, allDebits[0].id);
Assert.AreEqual(debits[2].id, allDebits[1].id);
query = (
card
.debits
.Query()
.Filter("amount", ">", 600)
.Filter("amount", "<", 800)
.OrderBy("amount", ResourceQuery <Debit> .SortOrder.DESCENDING)
);
Assert.AreEqual(1, query.Total());
allDebits = query.All();
Assert.AreEqual(debits[1].id, allDebits[0].id);
}
public static IQueryable <T> ApplySorting <T>(this IQueryable <T> query, ResourceQuery requestQuery, Dictionary <string, Expression <Func <T, object> > > columnsMap)
{
if (string.IsNullOrWhiteSpace(requestQuery.SortBy) || !columnsMap.ContainsKey(requestQuery.SortBy))
{
return(query);
}
return(requestQuery.IsSortAscending ? query.OrderBy(columnsMap[requestQuery.SortBy])
: query.OrderByDescending(columnsMap[requestQuery.SortBy]));
}
public void TestContains()
{
ResourceQuery a = new ResourceQuery(nco.PersonContact);
a.Where(nco.fullname).Contains("0");
IResourceQueryResult result = Model.ExecuteQuery(a);
Assert.Greater(result.Count(), 0);
}
public ActionResult <ResourceModel[]> GetResources(ResourceQuery query)
{
var filter = new ResourceQueryFilter(query, _resourceTypeTree);
var resourceProxies = _resourceModification.GetAllResources <IResource>(r => filter.Match(r as Resource)).ToArray();
var converter = new ResourceQueryConverter(_resourceTypeTree, _serialization, query);
var values = resourceProxies.Select(p => _resourceModification.Read(p.Id, r => converter.QueryConversion(r))).ToArray();
return(values);
}
private static ResourceQuery DeserializeResourceQuery(byte[] buffer)
{
var query = new ResourceQuery();
var ms = new MemoryStream(buffer);
var br = new BinaryReader(ms);
query.PageOffset = br.ReadNullableInt32();
query.PageSize = br.ReadNullableInt32();
query.MaxPageSize = br.ReadNullableInt32();
query.CountTotalRows = br.ReadBoolean();
query.TotalRows = br.ReadNullableInt32();
if (br.ReadBoolean())
{
var fields = br.ReadInt32();
query.Fields = new List <string>(fields);
for (var i = 0; i < fields; i++)
{
query.Fields.Add(br.ReadString());
}
}
if (br.ReadBoolean())
{
var sorts = br.ReadInt32();
query.Sorting = new List <(AccessorMember, SortDirection)>(sorts);
for (var i = 0; i < sorts; i++)
{
var declaringTypeName = br.ReadNullableString();
if (declaringTypeName != null)
{
var declaringType = Type.GetType(declaringTypeName);
var memberName = br.ReadString();
var direction = (SortDirection)br.ReadByte();
if (declaringType == null)
{
continue;
}
var members = AccessorMembers.Create(declaringType, AccessorMemberTypes.Properties,
AccessorMemberScope.Public);
if (members.TryGetValue(memberName, out var member))
{
query.Sorting.Add((member, direction));
}
}
}
}
return(query);
}
public static IQueryable <FinSecurity> ApplyFiltering(this IQueryable <FinSecurity> query,
ResourceQuery requestQuery)
{
if (string.IsNullOrEmpty(requestQuery.SearchTerm))
{
return(query);
}
return(query.Where(r =>
r.Name.Contains(requestQuery.SearchTerm) || r.Symbol.Contains(requestQuery.SearchTerm)));
}
public void TestCount()
{
ResourceQuery query = new ResourceQuery(nco.PersonContact);
IResourceQueryResult result = Model.ExecuteQuery(query);
Assert.AreEqual(40, result.Count());
query = new ResourceQuery(_resource);
result = Model.ExecuteQuery(query);
Assert.AreEqual(1, result.Count());
}
/// <summary>
/// Fetches a single facet asynchronously
/// </summary>
/// <returns>The facet.</returns>
/// <param name="facetToFetch">Facet to fetch.</param>
/// <param name="resourceQuery">Resource query.</param>
private async Task <Facet> FetchFacet(string facetToFetch, ResourceQuery resourceQuery)
{
KeyLabelAggResult[] aggResults = await _aggService.GetKeyLabelAggregationAsync(facetToFetch, resourceQuery);
if (aggResults != null && aggResults.Length > 0)
{
return(TransformFacet(facetToFetch, resourceQuery, aggResults));
}
else
{
return(null);
}
}
//[Test]
public void QueryDBPediaTest()
{
IModel m = ModelManager.Instance.GetRemoteModel(new Uri("http://live.dbpedia.org/sparql"));
ResourceQuery q = new ResourceQuery();
//q.Where(dbpedia.wikiPageExternalLink, new Uri("http://dachau.de"));
var result = m.ExecuteQuery(q);
var b = result.GetResources();
foreach (var res in b)
{
Console.WriteLine(res);
}
}
//[Test]
public void QueryTest()
{
ResourceQuery q = new ResourceQuery();
q.Where(rdf.type, nao.Agent);
var result = _remoteModel.ExecuteQuery(q);
var b = result.GetResources();
foreach (var res in b)
{
Console.WriteLine(res);
}
}
public void TestSort()
{
ResourceQuery b = new ResourceQuery(nco.PersonContact);
b.Where(nco.birthDate).LessThan(new DateTime(1990, 1, 1)).SortAscending();
ResourceQuery a = new ResourceQuery(nco.PersonContact);
a.Where(nco.gender);
a.Where(nie.relatedTo, b);
IResourceQueryResult result = Model.ExecuteQuery(b);
List <Resource> resources = result.GetResources().ToList();
Assert.AreEqual(18, resources.Count);
DateTime?l = null;
foreach (Resource r in resources)
{
DateTime t = (DateTime)r.GetValue(nco.birthDate);
if (l.HasValue)
{
Assert.IsTrue(t > l);
}
l = t;
}
a = new ResourceQuery(nco.PersonContact);
a.Where(nco.gender);
a.Where(nie.relatedTo, b);
result = Model.ExecuteQuery(b, true);
resources = result.GetResources().ToList();
Assert.AreEqual(18, resources.Count);
l = null;
foreach (Resource r in resources)
{
DateTime t = (DateTime)r.GetValue(nco.birthDate);
if (l.HasValue)
{
Assert.IsTrue(t > l);
}
l = t;
}
}
public void TestConstructors()
{
ResourceQuery query;
IEnumerable <Resource> result;
query = new ResourceQuery();
result = Model.GetResources(query);
query = new ResourceQuery(nco.PersonContact);
result = Model.GetResources(query);
query = new ResourceQuery(_resource);
result = Model.GetResources(query);
}
//[Test]
public void QueryWordnetTest()
{
IModel m = ModelManager.Instance.GetRemoteModel(new Uri("http://wordnet.rkbexplorer.com/sparql/"));
ResourceQuery q = new ResourceQuery();
q.Where(rdfs.label, "eat");
var result = m.ExecuteQuery(q);
var b = result.GetResources();
foreach (var res in b)
{
Console.WriteLine(res);
}
}
public static IQueryable <T> ApplyPaging <T>(this IQueryable <T> query, ResourceQuery requestQuery)
{
if (requestQuery.Page <= 0)
{
requestQuery.Page = 1;
}
if (requestQuery.PageSize <= 0)
{
requestQuery.PageSize = 10;
}
return(query.Skip((requestQuery.Page - 1) * requestQuery.PageSize).Take(requestQuery.PageSize));
}
public IList <ResourceBE> Resources_GetByQuery(IList <uint> parentIds, ResourceBE.ParentType?parentType, IList <ResourceBE.Type> resourceTypes, IList <string> names, DeletionFilter deletionStateFilter, bool?populateRevisions, uint?offset, uint?limit)
{
ResourceQuery rq = new ResourceQuery();
rq = rq.WithParent(parentIds, parentType);
rq = rq.WithResourceType(resourceTypes);
rq = rq.WithNames(names);
rq = rq.WithDeletionFilter(deletionStateFilter);
rq = rq.IncludeRevisions(populateRevisions ?? false);
rq = rq.Limit(limit);
rq = rq.Offset(offset);
rq = rq.OrderBy(ResourceQuery.ResourceOrderClause.SortTable.RESOURCES, "res_id", SortDirection.ASC);
return(rq.SelectList(Catalog, "Resources_Get"));
}
/// <summary>
/// Determines whether a facet should be fetched
/// This returns false if a facet requires a different filter to be set, and that other filter isn't set
/// </summary>
/// <returns>A boolean, indicating whether to fetch the given facet</returns>
/// <param name="facetName">A list of facet names to include in our search</param>
/// <param name="resourceQuery">The resource query (used for determining currently-set filters)</param>
private bool ShouldFetchFacet(string facetName, ResourceQuery resourceQuery)
{
R4RAPIOptions.FacetConfig config = _apiOptions.AvailableFacets[facetName];
var filters = (!string.IsNullOrWhiteSpace(config.RequiresFilter) && resourceQuery.Filters.ContainsKey(config.RequiresFilter)) ? resourceQuery.Filters[config.RequiresFilter] : new string[] { };
if (!string.IsNullOrWhiteSpace(config.RequiresFilter) && filters.Length == 0)
{
return(false);
}
else
{
return(true);
}
}
//[Test]
public void QueryWordnetTest()
{
var store = StoreFactory.CreateStore("provider=sparqlendpoint;endpoint=http://wordnet.rkbexplorer.com/sparql/");
IModel m = store.GetModel(new Uri("http://wordnet.rkbexplorer.com/sparql/"));
ResourceQuery q = new ResourceQuery();
q.Where(rdfs.label, "eat");
var result = m.ExecuteQuery(q);
var b = result.GetResources();
foreach (var res in b)
{
Console.WriteLine(res);
}
}
/// <summary>
/// Gets a search query (the Query portion of a SearchRequest) with the
/// requested facet's filter removed.
/// </summary>
/// <returns>The search query for facet.</returns>
/// <param name="field">The facet filter being requested.</param>
/// <param name="resourceQuery">Resource query.</param>
private QueryContainer GetSearchQueryForFacet(string field, ResourceQuery resourceQuery)
{
QueryContainer query = null;
var filteredFilters = from filter in resourceQuery.Filters
where filter.Key != field
select filter;
query = this.GetFullQuery(
resourceQuery.Keyword,
new Dictionary <string, string[]>(filteredFilters)
);
return(query);
}
/// <summary>
/// Searches for all included facets
/// </summary>
/// <returns>An array of facets</returns>
/// <param name="includeFacets">A list of facet names to include in our search</param>
/// <param name="resourceQuery">The resource query (used for determining facet items)</param>
private async Task <Facet[]> GetFacets(string[] includeFacets, ResourceQuery resourceQuery)
{
List <Facet> facets = new List <Facet>();
//Get list of Tasks to await
//Use an array based on recommendations from Concurrency in C# Cookbook
//regarding possible issues with LINQ and async.
var facetsToFetch = (from facet in includeFacets
where ShouldFetchFacet(facet, resourceQuery)
select FetchFacet(facet, resourceQuery)).ToArray();
var returnedFacets = await Task.WhenAll(facetsToFetch);
return(returnedFacets.Where(f => f != null).ToArray());
}
public void ResourceQueryTest()
{
Uri resourceUri = new Uri("http://example.com/testResource");
IModelGroup g = Store.CreateModelGroup(Model.Uri, Model2.Uri);
Contact resource = Model.CreateResource <Contact>(resourceUri);
resource.Fullname = "Hans Peter";
resource.Commit();
ResourceQuery q = new ResourceQuery(nco.Contact);
var res = g.GetResources(q);
}
public IList<ResourceBE> Resources_GetByQuery(IList<uint> parentIds, ResourceBE.Type parentType, IList<ResourceBE.Type> resourceTypes, IList<string> names, DeletionFilter deletionStateFilter, bool? populateRevisions, uint? offset, uint? limit) {
ResourceQuery rq = new ResourceQuery();
rq = rq.WithParent(parentIds, parentType);
rq = rq.WithResourceType(resourceTypes);
rq = rq.WithNames(names);
rq = rq.WithDeletionFilter(deletionStateFilter);
rq = rq.IncludeRevisions(populateRevisions ?? false);
rq = rq.Limit(limit);
rq = rq.Offset(offset);
rq = rq.OrderBy(ResourceQuery.ResourceOrderClause.SortTable.RESOURCES, "res_id", SortDirection.ASC);
return rq.SelectList(Catalog, "Resources_Get");
}
public ResourceBE Resources_UpdateRevision(ResourceBE resource) {
//Prepare query for retrieving the resource after updating
string selectQuery = new ResourceQuery()
.WithResourceId(resource.ResourceId)
.WithRevision(resource.Revision)
.ToString();
//Note: The resrev_timestamp is not updated in order to preserve the initial timeline of revisions
string query = string.Format(@" /* Resources_UpdateRevision */
update resourcerevs set
resrev_rev = ?RESREV_REV,
resrev_user_id = ?RESREV_USER_ID,
resrev_parent_id = ?RESREV_PARENT_ID,
resrev_parent_page_id = ?RESREV_PARENT_PAGE_ID,
resrev_parent_user_id = ?RESREV_PARENT_USER_ID,
resrev_change_mask = ?RESREV_CHANGE_MASK,
resrev_name = ?RESREV_NAME,
resrev_change_description=?RESREV_CHANGE_DESCRIPTION,
resrev_content_id = ?RESREV_CONTENT_ID,
resrev_deleted = ?RESREV_DELETED,
resrev_changeset_id = ?RESREV_CHANGESET_ID,
resrev_size = ?RESREV_SIZE,
resrev_mimetype = ?RESREV_MIMETYPE,
resrev_language = ?RESREV_LANGUAGE,
resrev_is_hidden = ?RESREV_IS_HIDDEN,
resrev_meta = ?RESREV_META
WHERE
resrev_res_id = ?RES_ID
AND resrev_rev = ?RESREV_REV;
{0}
", selectQuery);
ResourceBE[] ret = Resources_ExecuteInsertUpdateQuery(resource, query);
if(resource.IsHeadRevision()) {
Resources_ResetHeadRevision(resource.ResourceId);
}
return (ArrayUtil.IsNullOrEmpty(ret)) ? null : ret[0];
}
