using System;

using System.Collections.Generic;

using System.Linq;

using NUnit.Framework;

using SharpRepository.Repository.Queries;

using Shouldly;

using SharpRepository.InMemoryRepository;

namespace SharpRepository.Samples

{

[TestFixture]

public class HowToUsePagingAndSorting

{

/*

* Paging and Sorting are both very common needs and SharpRepository handles

* them well. Let me show you how

*

* Both query methods (GetAll and FindAll) have an optional QueryOptions parameter

* which you will use when needing to sort or do paging.

*/

public class Order

{

public int OrderId { get; set; }

public string Name { get; set; }

public double Total { get; set; }

public DateTime OrderDate { get; set; }

}

[Test]

public void Repository_Handles_Sorting()

{

var repo = new InMemoryRepository<Order>();

repo.Add(OrdersToLoad());

// there are 2 ways to handle sorting, there is an Expression based way

// and a "magic string" based approach.

// Why the 2 approaches?

// For convenience really. In a Web based applicaiton sometimes it is easier to

// post back a string that represents the properrty that you want to sort on.

// First, the Expression way

var descendingOrders = repo.GetAll(new SortingOptions<Order, DateTime>(x => x.OrderDate, isDescending: true));

descendingOrders.First().OrderId.ShouldBe(1);

var ascendingOrders = repo.GetAll(new SortingOptions<Order, DateTime>(x => x.OrderDate, isDescending: false));

ascendingOrders.First().OrderId.ShouldBe(2);

// You can also combine sortings and selectors (See HowToUseGetSelectors for more info)

var descendingNames = repo.GetAll(x => x.Name, new SortingOptions<Order, DateTime>(x => x.OrderDate, isDescending: true));

descendingNames.First().ShouldBe("Order 1");

// The Magic String approach to sorting

// you can see that you don't need the second generic type (the property type to sort on), just the name of the property

ascendingOrders = repo.GetAll(new SortingOptions<Order>("OrderDate", isDescending: false));

ascendingOrders.First().OrderId.ShouldBe(2);

// using sorting with FindAll

var minDate = DateTime.Now.AddDays(-7);

var ordersWithinAWeek = repo.FindAll(x => x.OrderDate > minDate, new SortingOptions<Order, double>(x => x.Total, true));

ordersWithinAWeek.Count().ShouldBe(2);

}

[Test]

public void Repository_Handles_Pagination()

{

var repo = new InMemoryRepository<Order, int>();

repo.Add(OrdersToLoad());

// with PagingOptions you give it the pageNumber, number per page, and the sorting options

// since the sorting options are the same as described above, I will just do the Expression based approach here

var pagingOptions = new PagingOptions<Order, DateTime>(1, 2, x => x.OrderDate, isDescending: true);

var pageOneOrders = repo.GetAll(pagingOptions).ToList();

pageOneOrders.Count.ShouldBe(2);

pageOneOrders.First().OrderId.ShouldBe(1);

pagingOptions.TotalItems.ShouldBe(3);

// now we can get the second page of results

pagingOptions.PageNumber = 2;

var pageTwoOrders = repo.GetAll(pagingOptions).ToList();

pageTwoOrders.Count.ShouldBe(1);

pageTwoOrders.First().OrderId.ShouldBe(2);

pagingOptions.TotalItems.ShouldBe(3);

}

private IEnumerable<Order> OrdersToLoad()

{

return new List<Order>()

{

new Order()

{

Name = "Order 1",

Total = 120.00,

OrderDate = DateTime.Now

},

new Order()

{

Name = "Order 2",

Total = 80.00,

OrderDate = DateTime.Now.AddMonths(-1)

}

,

new Order()

{

Name = "Order 3",

Total = 100.00,

OrderDate = DateTime.Now.AddDays(-2)

}

};

}

}

}