How to implement Sort Filter Page and Group using a view Model

I am trying to follow this ASP Core tutorial : https://docs.microsoft.com/en-us/aspnet/core/data/ef-rp/sort-filter-page?view=aspnetcore-3.1

however I am trying to use a view model and encountering numerous issues with making the changes, i think its something to do with PaginatedList customised to handle only type Routine from the DB and not the view model version but im not sure why.

The current error im facing is InvalidOperationException: Include has been used on non entity queryable.

TroydonFitnessWebsite.Models.PaginatedList<T>.CreateAsync(IQueryable<T> source, int pageIndex, int pageSize) in PaginatedList.cs
+
var count = await source.CountAsync();
TroydonFitnessWebsite.Pages.Products.TrainingRoutines.IndexModel.OnGetAsync(string sortOrder, string currentFilter, string searchString, Nullable<int> pageIndex) in Index.cshtml.cs
+
TrainingRoutineVMs = await PaginatedList<TrainingRoutineVM>.CreateAsync(

This is the PaginatedList.cs sample from the website:

namespace ContosoUniversity
{
    public class PaginatedList<T> : List<T>
    {
        public int PageIndex { get; private set; }
        public int TotalPages { get; private set; }

        public PaginatedList(List<T> items, int count, int pageIndex, int pageSize)
        {
            PageIndex = pageIndex;
            TotalPages = (int)Math.Ceiling(count / (double)pageSize);

            this.AddRange(items);
        }

        public bool HasPreviousPage
        {
            get
            {
                return (PageIndex > 1);
            }
        }

        public bool HasNextPage
        {
            get
            {
                return (PageIndex < TotalPages);
            }
        }

        public static async Task<PaginatedList<T>> CreateAsync(
            IQueryable<T> source, int pageIndex, int pageSize)
        {
            var count = await source.CountAsync();
            var items = await source.Skip(
                (pageIndex - 1) * pageSize)
                .Take(pageSize).ToListAsync();
            return new PaginatedList<T>(items, count, pageIndex, pageSize);
        }
    }
}

And here is my classes that I am implementing with it:

namespace FitnessWebsite.Pages.Products.Trainings
{
    public class IndexModel : FilterSortModel
    {
        private readonly ProductContext _context;

        public IndexModel(ProductContext context)
        {
            _context = context;
        }
        public PaginatedList<TrainingVM> TrainingVMs { get; set; }


        public async Task OnGetAsync(string sortOrder,
            string currentFilter, string searchString, int? pageIndex)
        {
            // assign hard prefix values
            AssigningSortOrderValues(sortOrder);

            if (searchString != null)
            {
                pageIndex = 1;
            }
            else
            {
                searchString = currentFilter;
            }

            CurrentFilter = searchString;
            CurrentSort = sortOrder;

            IQueryable<TrainingVM> trIQ = (IQueryable<TrainingVM>)(from s in _context.Trainings
                                                             select new TrainingVM();

            if (!String.IsNullOrEmpty(searchString))
            {
                trIQ = trIQ.Where(tr => tr.PersonalTrainingSession.Product.Title.Contains(searchString.ToUpper()) ||
                tr.PersonalTrainingSession.Product.ShortDescription.Contains(searchString.ToUpper())
                || tr.Description.Contains(searchString.ToUpper()));
            }

            trIQ = (IQueryable<TrainingVM>)DetermineSortOrder(sortOrder, trIQ);

            int pageSize = 5;

            TrainingVMs = await PaginatedList<TrainingVM>.CreateAsync(
               trIQ
               .Include(tr => tr.PersonalTrainingSession.Product)
               .ThenInclude(tr => tr.PersonalTrainingSessions)
               //.AsNoTracking()
               ,pageIndex ?? 1, pageSize);
        }

        private static IQueryable DetermineSortOrder(string sortOrder, IQueryable<TrainingVM> trIQ)
        {
            switch (sortOrder)
            {
                case "id_asc":
                    trIQ = trIQ.OrderBy(s => s.PersonalTrainingSession.ProdID);
                    break;
                case "id_desc":
                    trIQ = trIQ.OrderByDescending(s => s.PersonalTrainingSession.ProdID);
                    break;
            }
            return trIQ;
        }

In SortFIlterClass

  public void AssigningSortOrderValues(string sortOrder)
        {
            IdSort = sortOrder == "id_asc" ? "id_desc" : "id_asc";
        }