Using EF with Fluidity (for Umbraco)

FluidityEFRepository.cs

using Fluidity;
using XYZ.Core.Entities;
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using Umbraco.Core.Models;

namespace XYZ.Backoffice.Fluidity
{
    public abstract class Repository<T, TEntity> : global::Fluidity.Data.FluidityRepository<T, Guid>
        where T : class, TEntity, IEntity
        where TEntity : class, IEntity
    {
        protected readonly DbSet<TEntity> DbSet;

        public Repository()
        {
            DbSet = DatabaseFactory.DbSetFactory(typeof(TEntity)).Cast<TEntity>();
        }

        protected IQueryable<T> GetQueryable()
        {
            var map = MapAdapter();
            if (map != null)
            {
                return DbSet.Select(map);
            }

            return DbSet.Cast<T>();
        }

        protected override Guid GetIdImpl(T entity)
        {
            return entity.Id;
        }

        protected virtual Expression<Func<T, Guid>> IdAccessor => x => x.Id;

        protected override T GetImpl(Guid id)
        {
            IQueryable<T> queryable = GetQueryable();
            queryable = SetupEagerLoading(queryable);
            return queryable.FirstOrDefault(x => x.Id == id);
        }

        protected virtual IQueryable<T> SetupEagerLoading(IQueryable<T> queryable)
        {
            return queryable;
        }

        protected override IEnumerable<T> GetAllImpl()
        {
            return GetQueryable();
        }

        protected override PagedResult<T> GetPagedImpl(int pageNumber, int pageSize, Expression<Func<T, bool>> whereClause, Expression<Func<T, object>> orderBy, SortDirection orderDirection)
        {
            IQueryable<T> fullQueryable = GetQueryable();

            fullQueryable = SetupEagerLoading(fullQueryable);

            if (whereClause != null)
            {
                fullQueryable = fullQueryable.Where(whereClause);
            }

            var queryable = fullQueryable.AsQueryable();
            if (orderBy != null)
            {
                ParameterExpression param = Expression.Parameter(typeof(T), "x");
                var orderByBody = (UnaryExpression)orderBy.Body;
                var memberInfo = (PropertyInfo)((MemberExpression)orderByBody.Operand).Member;
                Expression member = Expression.Property(param, memberInfo.Name);
                var newOrder = Expression.Lambda(member, param);

                var orderMethod = orderDirection == SortDirection.Descending ? "OrderByDescending" : "OrderBy";
                var method = typeof(Queryable).GetMethods()
                    .Single(x => x.Name == orderMethod && x.GetParameters().Length == 2);
                var genMethod = method.MakeGenericMethod(typeof(T), memberInfo.PropertyType);

                queryable = (IQueryable<T>)genMethod.Invoke(null, new object[]{queryable, newOrder});
            }
            else
            {
                queryable = queryable.OrderBy(IdAccessor);
            }

            queryable = queryable.Skip(pageSize * (pageNumber - 1)).Take(pageSize);
            return new PagedResult<T>(fullQueryable.Count(), pageNumber, pageSize)
            {
                Items = queryable
            };
        }

        protected override T SaveImpl(T entity)
        {
            if (DbSet.Find(entity.Id) != null)
            {
                DbSet.Attach(entity);
            }
            else
            {
                DbSet.Add(entity);
            }

            return entity;
        }

        protected override void DeleteImpl(Guid id)
        {
            var entity = DbSet.Find(id);
            DbSet.Remove(entity);
        }

        protected override long GetTotalRecordCountImpl()
        {
            return DbSet.Count();
        }

        protected virtual Expression<Func<TEntity, T>> MapAdapter()
        {
            return null;
        }
    }
}