示例#1
0
        public override void RegisterGrids()
        {
            MVCGridDefinitionTable.Add("ContainerGrid", new MVCGridBuilder <Person>()
                                       .AddColumns(cols =>
            {
                cols.Add("Id").WithValueExpression((p, c) => p.Id.ToString());
                cols.Add("FirstName").WithHeaderText("First Name")
                .WithValueExpression((p, c) => p.FirstName);
                cols.Add("LastName").WithHeaderText("Last Name")
                .WithValueExpression((p, c) => p.LastName);
            })
                                       .WithRenderingMode(RenderingMode.Controller)
                                       .WithViewPath("~/Views/MVCGrid/_Grid.cshtml")
                                       .WithContainerViewPath("~/Views/MVCGrid/_Container.cshtml")
                                       .WithRetrieveDataMethod((options) =>
            {
                var result = new QueryResult <Person>();

                using (var db = new SampleDatabaseEntities())
                {
                    result.Items = db.People.Where(p => p.Employee).ToList();
                }

                return(result);
            })
                                       );
        }
 /// <summary>
 /// sets the context to the sample database entities
 /// </summary>
 public DataAccessService()
 {
     dataContext = new SampleDatabaseEntities();
 }
        public IEnumerable <Person> GetData(out int totalRecords, string globalSearch, string filterFirstName, string filterLastName, bool?filterActive, int?limitOffset, int?limitRowCount, string orderBy, bool desc)
        {
            using (var db = new SampleDatabaseEntities())
            {
                var query = db.People.AsQueryable();

                if (!String.IsNullOrWhiteSpace(filterFirstName))
                {
                    query = query.Where(p => p.FirstName.Contains(filterFirstName));
                }
                if (!String.IsNullOrWhiteSpace(filterLastName))
                {
                    query = query.Where(p => p.LastName.Contains(filterLastName));
                }
                if (filterActive.HasValue)
                {
                    query = query.Where(p => p.Active == filterActive.Value);
                }

                if (!String.IsNullOrWhiteSpace(globalSearch))
                {
                    query = query.Where(p => (p.FirstName + " " + p.LastName).Contains(globalSearch));
                }

                totalRecords = query.Count();

                if (!String.IsNullOrWhiteSpace(orderBy))
                {
                    switch (orderBy.ToLower())
                    {
                    case "firstname":
                        if (!desc)
                        {
                            query = query.OrderBy(p => p.FirstName);
                        }
                        else
                        {
                            query = query.OrderByDescending(p => p.FirstName);
                        }
                        break;

                    case "lastname":
                        if (!desc)
                        {
                            query = query.OrderBy(p => p.LastName);
                        }
                        else
                        {
                            query = query.OrderByDescending(p => p.LastName);
                        }
                        break;

                    case "active":
                        if (!desc)
                        {
                            query = query.OrderBy(p => p.Active);
                        }
                        else
                        {
                            query = query.OrderByDescending(p => p.Active);
                        }
                        break;

                    case "email":
                        if (!desc)
                        {
                            query = query.OrderBy(p => p.Email);
                        }
                        else
                        {
                            query = query.OrderByDescending(p => p.Email);
                        }
                        break;

                    case "gender":
                        if (!desc)
                        {
                            query = query.OrderBy(p => p.Gender);
                        }
                        else
                        {
                            query = query.OrderByDescending(p => p.Gender);
                        }
                        break;

                    case "id":
                        if (!desc)
                        {
                            query = query.OrderBy(p => p.Id);
                        }
                        else
                        {
                            query = query.OrderByDescending(p => p.Id);
                        }
                        break;

                    case "startdate":
                        if (!desc)
                        {
                            query = query.OrderBy(p => p.StartDate);
                        }
                        else
                        {
                            query = query.OrderByDescending(p => p.StartDate);
                        }
                        break;
                    }
                }


                if (limitOffset.HasValue)
                {
                    query = query.Skip(limitOffset.Value).Take(limitRowCount.Value);
                }

                return(query.ToList());
            }
        }
示例#4
0
 public ParentClass()
 {
     connexion = new SampleDatabaseEntities();
 }
示例#5
0
 public BaseRepository(SampleDatabaseEntities context)
 {
     DbContext = context;
     DbContext.Configuration.LazyLoadingEnabled = true;
     Dbset = context.Set <T>();
 }