Connected jQuery Grids

This example shows how to configure connected jquery datagrids by using row selection event

<!DOCTYPE html>
<html>
<head>
    <title>Connected jQuery Grids</title>
    <meta charset="utf-8" />
    <script src="https://code.jquery.com/jquery-3.3.1.min.js"></script>
    <script src="https://unpkg.com/gijgo@1.9.14/js/gijgo.min.js" type="text/javascript"></script>
    <link href="https://unpkg.com/gijgo@1.9.14/css/gijgo.min.css" rel="stylesheet" type="text/css" />
</head>
<body>
    <div class="">
        <table id="grid1" data-primary-key="ID"></table>
        <br /><br />
        <table id="grid2"></table>
    </div>
    <script type="text/javascript">
        $(document).ready(function () {
            var grid1, grid2;
            grid1 = $('#grid1').grid({
                primaryKey: 'ID',
                dataSource: '/Players/Get',
                columns: [{ field: 'ID', width: 56 }, { field: 'Name' }, { field: 'PlaceOfBirth' }],
                pager: { limit: 5 }
            });
            grid2 = $('#grid2').grid({
                primaryKey: 'ID',
                dataSource: '/Players/GetTeams',
                autoLoad: false,
                columns: [
                    { title: 'Years', tmpl: '{FromYear} - {ToYear}', width: 140 },
                    { field: 'Team' },
                    { field: 'Apps', width: 90 },
                    { field: 'Goals', width: 90 }
                ],
                pager: { limit: 5 }
            });
            grid1.on('rowSelect', function (e, $row, id, record) {
                grid2.reload({ playerId: id, page: 1 });
            });
        });
    </script>
</body>
</html>

using Gijgo.Asp.NET.Examples.Models.Entities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;

namespace Gijgo.Asp.NET.Examples.Controllers
{
    public class PlayersController : Controller
    {
        public JsonResult Get(int? page, int? limit, string sortBy, string direction, string name, string nationality, string placeOfBirth)
        {
            List<Models.DTO.Player> records;
            int total;
            using (ApplicationDbContext context = new ApplicationDbContext())
            {
                var query = context.Players.Select(p => new Models.DTO.Player
                {
                    ID = p.ID,
                    Name = p.Name,
                    PlaceOfBirth = p.PlaceOfBirth,
                    DateOfBirth = p.DateOfBirth,
                    CountryID = p.CountryID,
                    CountryName = p.Country != null ? p.Country.Name : "",
                    IsActive = p.IsActive,
                    OrderNumber = p.OrderNumber
                });

if (!string.IsNullOrWhiteSpace(name))
                {
                    query = query.Where(q => q.Name.Contains(name));
                }

if (!string.IsNullOrWhiteSpace(nationality))
                {
                    query = query.Where(q => q.CountryName != null && q.CountryName.Contains(nationality));
                }

if (!string.IsNullOrWhiteSpace(placeOfBirth))
                {
                    query = query.Where(q => q.PlaceOfBirth != null && q.PlaceOfBirth.Contains(placeOfBirth));
                }

if (!string.IsNullOrEmpty(sortBy) && !string.IsNullOrEmpty(direction))
                {
                    if (direction.Trim().ToLower() == "asc")
                    {
                        switch (sortBy.Trim().ToLower())
                        {
                            case "name":
                                query = query.OrderBy(q => q.Name);
                                break;
                            case "countryname":
                                query = query.OrderBy(q => q.CountryName);
                                break;
                            case "placeOfBirth":
                                query = query.OrderBy(q => q.PlaceOfBirth);
                                break;
                            case "dateofbirth":
                                query = query.OrderBy(q => q.DateOfBirth);
                                break;
                        }
                    }
                    else
                    {
                        switch (sortBy.Trim().ToLower())
                        {
                            case "name":
                                query = query.OrderByDescending(q => q.Name);
                                break;
                            case "countryname":
                                query = query.OrderByDescending(q => q.CountryName);
                                break;
                            case "placeOfBirth":
                                query = query.OrderByDescending(q => q.PlaceOfBirth);
                                break;
                            case "dateofbirth":
                                query = query.OrderByDescending(q => q.DateOfBirth);
                                break;
                        }
                    }
                }
                else
                {
                    query = query.OrderBy(q => q.OrderNumber);
                }

total = query.Count();
                if (page.HasValue && limit.HasValue)
                {
                    int start = (page.Value - 1) * limit.Value;
                    records = query.Skip(start).Take(limit.Value).ToList();
                }
                else
                {
                    records = query.ToList();
                }
            }

return this.Json(new { records, total }, JsonRequestBehavior.AllowGet);
        }

[HttpPost]
        public JsonResult Save(Models.DTO.Player record)
        {
            Player entity;
            using (ApplicationDbContext context = new ApplicationDbContext())
            {
                if (record.ID > 0)
                {
                    entity = context.Players.First(p => p.ID == record.ID);
                    entity.Name = record.Name;
                    entity.PlaceOfBirth = record.PlaceOfBirth;
                    entity.DateOfBirth = record.DateOfBirth;
                    entity.CountryID = record.CountryID;
                    entity.Country = context.Locations.FirstOrDefault(l => l.ID == record.CountryID);
                    entity.IsActive = record.IsActive;
                }
                else
                {
                    context.Players.Add(new Player
                    {
                        Name = record.Name,
                        PlaceOfBirth = record.PlaceOfBirth,
                        DateOfBirth = record.DateOfBirth,
                        CountryID = record.CountryID,
                        Country = context.Locations.FirstOrDefault(l => l.ID == record.CountryID),
                        IsActive = record.IsActive
                    });
                }
                context.SaveChanges();
            }
            return Json(new { result = true });
        }

[HttpPost]
        public JsonResult Delete(int id)
        {
            using (ApplicationDbContext context = new ApplicationDbContext())
            {
                Player entity = context.Players.First(p => p.ID == id);
                context.Players.Remove(entity);
                context.SaveChanges();
            }
            return Json(new { result = true });
        }

public JsonResult GetTeams(int playerId, int? page, int? limit)
        {
            List<Models.DTO.PlayerTeam> records;
            int total;
            using (ApplicationDbContext context = new ApplicationDbContext())
            {
                var query = context.PlayerTeams.Where(pt => pt.PlayerID == playerId).Select(pt => new Models.DTO.PlayerTeam
                {
                    ID = pt.ID,
                    PlayerID = pt.PlayerID,
                    FromYear = pt.FromYear,
                    ToYear = pt.ToYear,
                    Team = pt.Team,
                    Apps = pt.Apps,
                    Goals = pt.Goals
                });

total = query.Count();
                if (page.HasValue && limit.HasValue)
                {
                    int start = (page.Value - 1) * limit.Value;
                    records = query.OrderBy(pt => pt.FromYear).Skip(start).Take(limit.Value).ToList();
                }
                else
                {
                    records = query.ToList();
                }
            }

return this.Json(new { records, total }, JsonRequestBehavior.AllowGet);
        }
    }
}