bcc-code / bcc-linq Goto Github PK

Currently .ThenInclude(...) only works after a non-enumerable object. Often it needs to be applied to an enumerable.

For example.

client.Persons.GetQueryable().Include(p => p.Affiliations).ThenInclude(a => a.Org)

Note that Affiliations in the example above is a List of affiliations.

We should implement FetchAsync which is currently implemented in the Core API here

Example:

public class MyEntity
{
    [DataMember(Name = "other_entity")]
    [JsonProperty("other_entity")]
    public OtherEntity OtherEntity { get; set; }


 //...
}

...

var result = await client.MyEntities.Query().Include(e => e.OtherEntity).ToListAsync();

The above code results in fields=*,otherEntity.* in the query. The expected behaviour would be fields=*,other_entity.* if either DataMember or JsonProperty attributes are used with a name override.

The same applies to any query where the fields appear in the filter.

• If value is ValueTuple of DateTimes, there is problem with Parsings

• IQueryable could not translate Convert.ToDateTime()

Reng and @leo-schick had a chat about the library name and we decided that it shall be changed to BccCode.Linq.

Description

The test above fails because the query parser sets fields to "affiliations" instead of "affiliaitons.". Non-scalor fields need to have a trailing "" for the query to work.

If you're filtering on a nullable type the the ApplyRuleFilter throws an exception:
Contributions.Contracts.Standard.Exceptions.ApiRequestException : Failed to retrieve data from /contributions/Projects?limit=100&page=1. Status code: BadRequest. Content: {"error":{"code":null,"message":"Expression of type 'System.Nullable1[System.DateTime]' cannot be used for parameter of type 'System.Object' of method 'Double ToDouble(System.Object)' (Parameter 'arg0')"},"errors":[]}

        {
            var filter = new Filter(jsonFilter);
            basicQuery = basicQuery.ApplyRuleFilter(filter);
        }```

The current ApplyRuleFilter extension method makes it possible to apply a filter on IQueryable. But there are many other options like limit, offset, aggregte, sort, fields which we could apply to IQueryable.

I suggest to add a new IQueryable<TSource> ApplyApiRequest<TSource>(IApiRequest) which applies the IApiRequest properties Fields, Filter, Sort, Limit, Offset, Page, GroupBy, Deep and Alias in a single extension method. The IApiRequest properties Meta and Aggregate are not implemented by this.

Linq queries selecting a scalar value are not possible. For example, calling

var query = from p in api.Persons
            select p.Age;

is not possible, but

var query = from p in api.Persons
            select new { p.Age };

is possible.

It is easy to use the workaround given above (introducing an anonymous type in the select clause), but this restriction does not allow us to use aggregat functions like this:

double averageAge = (
    from p in api.Persons
    select p.Age
).Average();

• add missing cases in tests
• handle all the cases in the code

We should implement Include which is currently implemented in the Core API here

Using ToString() in a filter` operation should be supported on server-side proprerties. Example:

var query =
    from p in api.Persons.AsQueryable()
    where p.Uid.ToString() == "70a10bd7-7912-4451-84e8-82ad45408c0c"
    select p;

Date formatted like ""yyyy-mm-dd" in filter value should be cast to DateTime but it's string

We already have a json parser for Directus format and we need an implementation of a QueryProvider that will be used for conversion from IQueryable to a query string.

Check the implementation of a QueryProvider here:
https://github.com/bcc-code/bcc-core-api/tree/main/sdk/dotnet/src

We want to copy that part into this repository and make it available for all projects using rule-filter-parser-dotnet nuget package.

For Core API (api.bcc.no), we're using directus format for filtering and we send it as a query parameter to an endpoint like this:

 Task<CollectionResponse<ContributionRead>> Get(
        string jsonFilter,
        int pageNumber = 1,
        int itemsPerPage = 100,
        CancellationToken cancellationToken = default);

It doesn't make much sense using SDK Client if we need to still provide a json formatted string for filters. The idea is to create a C# implementation (Linq) that allows us to create a filter dynamically without taking care of validation of the filter.

How it could be used:

 var json = DirectusFilterBuilder<Project>.Create()
            .Where(x => x.Status == true)
            .Serialize();

We will focus on simple where operations:

• Equal
• GreaterThanOrEqual
• LessThanOrEqual
• GreaterThan
• LessThan
• IsTrue
• IsFalse
• operations for navigated properties
• OR operations

The implemented GitHub Action check-format always fails in pull requests, marking the pull requests always with a red cross.

Please fix the GitHub Actions check-format or remove it @piotrczyz

int, long, double values are always parsed as double, in the result it makes type mismatch with db entities.

Example RegistrationHours endpoint in Contribution API

Sending { "registrationId":{"_eq": 333755}} in the filter returns error because registrationId is type nullable Int32 but this value provided in the filter is always parsed to double

This is a collection ticket for improvements of the QueryProvider introduced via #20

Queryable Implementation matrix

When it is not implemented, the default behavior applies --> meaning: the query is performed on client side, possibly running heavy API loads against the API.

Other topics

• make async calls possible, e.g. ToListAsync or await foreach(var p in myQuery) #29
• revert sorting required for ...Last linq methods https://github.com/bcc-code/bcc-core-api/issues/367

Add documentation for ApplyApiRequest method

The package requires the ability to apply a rule filter on the IQueryable collection. At the moment it is only possible to use it on IEnumerable which is not enough if we want to handle database level filtering.

Linq brings multiple aggregate functions; Average, Count, LongCount, Max, Min, Sum

Currently it is not possible to use them. They are implemented without parameter, but cannot be used because of #26.

In addition, it would be great to have them implemented with parameter so that you can call them like this:

Call aggregation with property

double averageAge = api.Persons.Average(p => p.Age);

This option requires to have at least one row, otherwise Linq will crash because you cannot put null into double.

Call aggregation with property casted to null

double? averageAge = api.Persons.Average(p => (double?)p.Age);

This option will work when you have no row at all returning null.

Currently e.Parent.Id == null in a Linq query results in:

{ "parentId": { "_eq" : null }}

The expected directus-syntax is:

{ "parentId": { "_null" : true }}

for != null the expected syntax would be:

{ "parentId": { "_nnull" : true}}

With #37 we implement Include on just base level. Additional, we would like to add ThenInclude to define including/extending nested data from already nested data. e.g. api.Persons.Include(p => p.Car).ThenInclude(p.Manufacture)

This requires to implement interface IIncludableQueryable and return it in Include. This is required to implement ThenInclude.
The links refer to the EF Core implementation of such a logic.

Currently Async operations are not implemented for the QueryProvider introduced via #20