How to reuse same where-clause on different entities?

In my app a logged in admin-user can see "partners" based on some permissions:

public async Task<IList<Partner>> GetPartners(IList<Permission> permissions, Admin admin)
{
	bool all = permissions.Any(x => x.Key == "SeePartners" && x.Value == "All");
	bool sameArea = permissions.Any(x => x.Key == "SeePartners" && x.Value == "SameArea");

    var p = _dbContext.Partners.Where(x => all || (sameArea && x.AreaId == Admin.AreaId));

    return await p.AsNoTracking().ToListAsync();
}

Each partner is associated to different programs. The admin can see all programs, but when accessing it still only the partners based on the permissions. Like:

public async Task<IList<ProgramPartner>> GetProgramPartners(IList<Permission> permissions, Admin admin, Guid programId)
{
	bool all = permissions.Any(x => x.Key == "SeePartners" && x.Value == "All");
	bool sameArea = permissions.Any(x => x.Key == "SeePartners" && x.Value == "SameArea");

    var p = _dbContext.ProgramPartners.Where(x => x.ProgramId == programId && 
        (all || (sameArea && x.Partner.AreaId == Admin.AreaId))
    );

    return await p.AsNoTracking().ToListAsync()
}

These are very basic examples. The permission handling is much more complicated, so I'd like to reuse the Where-clause that handles it.

I've tried to make a method that returns true/false, but EF gives me an error, that the query couldn't be translated:

public bool FilterPartners(Partner partner, IList<Permission> permissions, Admin admin)
{
	bool all = permissions.Any(x => x.Key == "SeePartners" && x.Value == "All");
	bool ownArea = permissions.Any(x => x.Key == "SeePartners" && x.Value == "OwnArea");

	return all || (ownArea && partner.AreaId == admin.AreaId);
}

public async Task<IList<Partner>> GetPartners(IList<Permission> permissions, Admin admin)
{
    var p = _dbContext.Partners.Where(x => FilterPartners(x, permissions, admin));

    return await p.AsNoTracking().ToListAsync();
}

public async Task<IList<ProgramPartner>> GetProgramPartners(IList<Permission> permissions, Admin admin, Guid programId)
{
    var p = _dbContext.Partners.Where(x => x.ProgramId == programId).Where(x => FilterPartners(x.Partner, permissions, admin));

    return await p.AsNoTracking().ToListAsync();
}

I've also tried passing an IQueryable to a method and back and also looked at Expressions functions, but that didn't work at all.

Is this possible at all?

It's long shot, but have you tried something among these lines:

IQueryable<T> FilterPartners<T>(
    IQueryable<T> query,
    Func<T, Partner> getPartner,
    IList<Permission> permissions,
    Admin admin)
{
    return query.Where(item =>
        permissions.Any(x => x.Key == "SeePartners" && x.Value == "All")
        || (permissions.Any(x => x.Key == "SeePartners" && x.Value == "OwnArea") 
            && getPartner(item).AreaId == admin.AreaId));
}

async Task<IList<Partner>> GetPartners(IList<Permission> permissions, Admin admin)
{
    var p = _dbContext.Partners.Where(x => FilterPartners(x, permissions, admin));

    return await p.AsNoTracking().ToListAsync();
}

async Task<IList<ProgramPartner>> GetProgramPartners(
    IList<Permission> permissions, 
    Admin admin, 
    Guid programId)
{
    IQueryable<ProgramPartner> dbQuery = null; //_dbContext.Partners
    dbQuery = dbQuery
        .Where(x => x.ProgramId == programId);

    dbQuery = FilterPartners(dbQuery, x => x.Partner, permissions, admin);

    return await p.AsNoTracking().ToListAsync();
}

An IQueryable is not materialized until ToListAsync is called, and all functions applied to it must be translatable, so you can't just call any function you like inside its lambdas.

You need the filter function to receive and return an IQueryable. Then the function rewrites the query contained in that and returns a new one with the filter added.

You can do this as an extension function to make it easier to read.

public static class DbContextExtensions
{
    (bool all, bool ownArea) CalculatePermissions(IList<Permission> permissions, Admin admin)
    {
        bool all = permissions.Any(x => x.Key == "SeePartners" && x.Value == "All");
        bool ownArea = permissions.Any(x => x.Key == "SeePartners" && x.Value == "OwnArea");
        return (all, ownArea);
    }

    public IQueryable<Partner> FilterPartners(this IQueryable<Partner> source,
        IList<Permission> permissions, Admin admin)
    {
        (var all, var ownArea) = CalculatePermissions(permissions, admin);
        return source.Where(p => all || (ownArea && p.AreaId == admin.AreaId));
    }

    public IQueryable<ProgramPartner> FilterProgramPartners(this IQueryable<ProgramPartner> source,
        IList<Permission> permissions, Admin admin, Guid programId)
    {
        (var all, var ownArea) = CalculatePermissions(permissions, admin);
        return source.Where(pp =>
            all ||
            (
               ownArea &&
               pp.Partner.Any(p => p.AreaId == admin.AreaId))
            );
    }
}

public async Task<IList<Partner>> GetPartners(IList<Permission> permissions, Admin admin)
{
    var p = _dbContext.Partners.FilterPartners(permissions, admin);
    return await p.AsNoTracking().ToListAsync();
}

public async Task<IList<ProgramPartner>> GetProgramPartners(IList<Permission> permissions, Admin admin, Guid programId)
{
    var p = _dbContext.ProgramPartners
        .Where(p => p.ProgramId == programId)
        .FilterProgramPartners(permissions, admin);

    return await p.AsNoTracking().ToListAsync();
}

Note that depending on your setup, it may be possible to pass through permissions as IQueryable<Permission> (ie you don't store the permission list in memory), and then your extension function should look like this

public IQueryable<Partner> FilterPartners(this IQueryable<Partner> partnerSource,
    IQueryable<Permission> permissions, Admin admin)
{
    return partnerSource.Where(p =>
        permissions.Any(x => x.Key == "SeePartners" && x.Value == "All")
        || (
           permissions.Any(x => x.Key == "SeePartners" && x.Value == "OwnArea") &&
           p.AreaId == admin.AreaId
          )
        );
}

In other words, you mustn't use an IQueryable by itself, only as part of another query, so that you just do a single .ToListAsync as the end which materializes it from the database.