public async Task <PagedListResult <CourseItem> > GetPagedList(PageableListQuery query)
{
var lstCourse = await this.repository.GetPagedList(query);
var lstCourseItem = new List <CourseItem>();
foreach (var item in lstCourse.List)
{
var courseItem = new CourseItem()
{
Id = item.Id,
Name = item.Name,
Code = item.Code,
StudentItems = new List <StudentItem>()
};
foreach (var enrollment in item.Enrollments)
{
var studentItem = new StudentItem()
{
Id = enrollment.Student.Id,
Name = enrollment.Student.Name,
Roll = enrollment.Student.Roll,
Email = enrollment.Student.Email
};
courseItem.StudentItems.Add(studentItem);
}
lstCourseItem.Add(courseItem);
}
return(new PagedListResult <CourseItem>(lstCourseItem, lstCourseItem.Count));
}
public async Task <PagedListResult <Student> > GetPagedList(PageableListQuery query)
{
List <Student> students;
int count;
if (!string.IsNullOrEmpty(query.SearchValue))
{
students = await this.context.Students
.Where("name.Contains(@0)", query.SearchValue)
.OrderBy("name asc")
.Skip(query.Offset.GetValueOrDefault())
.Take(query.Limit)
.ToListAsync();
count = await this.context.Students.Where("name.Contains(@0)", query.SearchValue).CountAsync();
}
else
{
students = await this.context.Students
.OrderBy("name asc")
.Skip(query.Offset.GetValueOrDefault())
.Take(query.Limit)
.ToListAsync();
count = await this.context.Students.CountAsync();
}
return(new PagedListResult <Student>(students, count));
}
public async Task <HttpResponseMessage> Get(PageableListQuery query)
{
query = query ?? new PageableListQuery();
var students = await this.repositoryService.GetPagedList(query);
return(this.Request.CreateResponse(
HttpStatusCode.OK, students));
}
public async Task <HttpResponseMessage> Get(PageableListQuery query)
{
query = query ?? new PageableListQuery();
var students = await this.repository.GetPagedList(query);
var list = Mapper.Map <IEnumerable <Student>, IEnumerable <StudentItem> >(students.List);
return(this.Request.CreateResponse(
HttpStatusCode.OK, new PagedListResult <StudentItem>(list, students.Count)));
}
public async Task <HttpResponseMessage> Get(PageableListQuery query)
{
query = query ?? new PageableListQuery {
Limit = 500
};
var courses = await this.repositoryService.GetPagedList(query);
return(this.Request.CreateResponse(
HttpStatusCode.OK, courses));
}
public async Task <PagedListResult <CourseItem> > GetPagedList(PageableListQuery query)
{
var lstCourse = await this.repository.GetPagedList(query);
var lstCourseItem = lstCourse.List.Select(item => new CourseItem
{
Id = item.Id, Name = item.Name
}).ToList();
return(new PagedListResult <CourseItem>(lstCourseItem, lstCourseItem.Count));
}
public async Task <PagedListResult <StudentItem> > GetPagedList(PageableListQuery query)
{
var students = await this.repository.GetPagedList(query);
var studentItems = students.List.Select(item => new StudentItem
{
Id = item.Id, Name = item.Name, Phone = item.Phone
}).ToList();
return(new PagedListResult <StudentItem>(studentItems, students.Count));
}
public async Task <PagedListResult <Course> > GetPagedList(PageableListQuery query)
{
var courses = await this.context.Courses
.OrderBy("name asc")
.Skip(query.Offset.GetValueOrDefault())
.Take(query.Limit)
.ToListAsync();
var count = await this.context.Courses.CountAsync();
return(new PagedListResult <Course>(courses, count));
}
public async Task <PagedListResult <Student> > GetPagedList(PageableListQuery query)
{
var students = await this.context.Students
// .Where("name.Contains(@0)", "Em")
.OrderBy("name asc")
.Skip(query.Offset.GetValueOrDefault())
.Take(query.Limit)
.ToListAsync();
var count = await this.context.Students.CountAsync();
return(new PagedListResult <Student>(students, count));
}
public async Task <PagedListResult <TEntity> > GetPagedList(PageableListQuery query)
{
var entities = await this.dbSet
// .Where("name.Contains(@0)", "Em")
.OrderBy("name asc")
.Skip(query.Offset.GetValueOrDefault())
.Take(query.Limit)
.ToListAsync();
var count = await this.dbSet.CountAsync();
return(new PagedListResult <TEntity>(entities, count));
}
public async Task <PagedListResult <StudentItem> > GetPagedList(PageableListQuery query)
{
var studentItems = new List <StudentItem>();
var students = await this.repository.GetPagedList(query);
foreach (var item in students.List)
{
var studentItem = new StudentItem
{
Id = item.Id,
Name = item.Name,
Roll = item.Roll,
Email = item.Email
};
studentItems.Add(studentItem);
}
return(new PagedListResult <StudentItem>(studentItems, studentItems.Count));
}
static void Main(string[] args)
{
var builder = new ContainerBuilder();
builder.RegisterType <DataContext>();
builder.RegisterGeneric(typeof(GenericRepository <>)).As(typeof(IRepository <>));
var container = builder.Build();
var dataContext = container.Resolve <DataContext>();
var studentRepository = container.Resolve <IRepository <Student> >();
var courseRepository = container.Resolve <IRepository <Course> >();
Mapper.Initialize(
cfg =>
{
cfg.CreateMap <StudentCreateItem, Student>().BeforeMap(
(s, d) =>
{
s.CoursesList.ForEach(
x =>
{
d.Enrollments.Add(
new Enrollment
{
StudentId = s.Id,
CourseId = x,
EnrollmentDate = DateTime.Now
});
});
});
cfg.CreateMap <Student, StudentItem>()
.ForMember(dest => dest.CourseItems, opt => opt.MapFrom(src => src.Enrollments));
cfg.CreateMap <Enrollment, CourseItem>()
.ForMember(dest => dest.Id, opt => opt.MapFrom(src => src.CourseId))
.ForMember(dest => dest.Code, opt => opt.MapFrom(src => src.Course.Code))
.ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.Course.Name));
cfg.CreateMap <Enrollment, StudentItem>()
.ForMember(dest => dest.Id, opt => opt.MapFrom(src => src.StudentId))
.ForMember(dest => dest.Email, opt => opt.MapFrom(src => src.Student.Email))
.ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.Student.Name))
.ForMember(dest => dest.Roll, opt => opt.MapFrom(src => src.Student.Roll));
cfg.CreateMap <Course, CourseItem>()
.ForMember(dest => dest.StudentItems, opt => opt.MapFrom(src => src.Enrollments));
});
var course = dataContext.Courses.ToList();
var cs = Mapper.Map <IEnumerable <Course>, IEnumerable <CourseItem> >(course);
var student = dataContext.Students.First(x => x.Id == 1);
var stu = Mapper.Map <StudentItem>(student);
var query = new PageableListQuery();
var students = studentRepository.GetPagedList(query).Result;
var ssdd = Mapper.Map <IEnumerable <Student>, IEnumerable <StudentItem> >(students.List);
new PagedListResult <StudentItem>(ssdd, 20);
PagedListResult <StudentItem> listDest =
Mapper.Map <PagedListResult <Student>, PagedListResult <StudentItem> >(students);
Console.ReadLine();
}
