Build Your Own PHP Framework
This episode is for members only

Sign up to access "Build Your Own PHP Framework" right now.

Get started
Already a member? Sign in to continue
Playing
49. Paginating with Eloquent

Episodes

0%
Your progress
  • Total: 4h 45m
  • Played: 0m
  • Remaining: 4h 45m
Join or sign in to track your progress
01. Setting up
01. Introduction
2m 23s
0%
02. Composer and PSR-4 Autoloading
6m 17s
0%
03. Bootstrapping and structure
3m 18s
0%
04. Error reporting with Ignition
3m 49s
0%
02. Container
05. Using a container
3m 21s
0%
06. Adding service providers
5m 23s
0%
07. Autowiring with reflection
5m 5s
0%
08. Refactoring to a singleton
4m 17s
0%
03. Application config
09. Building the Config class
6m 19s
0%
10. Reading and merging config files
6m 21s
0%
11. Registering service providers through config
2m 13s
0%
12. Using env files
6m 26s
0%
04. Routing and controllers
13. Everything starts with requests
6m 52s
0%
14. Adding routing
5m 27s
0%
15. Responding in routes
4m 13s
0%
16. Cleaning up responding
7m 12s
0%
17. Defining routes in a separate file
3m 10s
0%
18. Creating a controller
5m 17s
0%
19. Using services inside controllers
2m 3s
0%
05. Views
20. Installing Twig
6m 22s
0%
21. Rendering a view
3m 36s
0%
22. Debugging in Twig
4m 45s
0%
23. Creating a base layout
3m 38s
0%
24. Page titles in Twig
4m 31s
0%
25. Creating a Twig config helper
8m 57s
0%
06. Database
26. Setting up and querying the database
13m 29s
0%
27. Working with models
4m 32s
0%
28. Creating an example user profile page
5m 49s
0%
07. Authentication
29. Setting up Sentinel
8m 36s
0%
30. Creating the registration flow
5m 44s
0%
31. Registering and authenticating a user
5m
0%
32. Showing authenticated state
5m 40s
0%
33. Logging in
3m 59s
0%
34. Logging out
3m 2s
0%
08. CSRF Protection
35. Protecting routes with CSRF
7m 51s
0%
36. Adding tokens to forms
6m 5s
0%
09. Flashing messages
37. Basic session flashing
5m 46s
0%
38. Creating a Twig helper and flashing globally
1m 39s
0%
10. Validation
39. Validating the login form
6m 40s
0%
40. Manually adding validation errors
1m 24s
0%
41. Validating the registration form
4m 5s
0%
42. Custom validation rules
9m 39s
0%
11. Middleware
43. How middleware works
5m 41s
0%
44. Adding auth middleware and grouping routes
7m 37s
0%
45. Persisting old form data
6m 53s
0%
12. Exception handling
46. Creating an exception handler
3m 38s
0%
47. Custom 404 (and other error) views
7m 27s
0%
48. Rendering views for CSRF errors
5m 18s
0%
13. Pagination
49. Paginating with Eloquent
7m 48s
0%
50. Building a pagination view with Twig
7m 38s
0%
14. Global helpers
51. Registering functions with PSR-4
1m 50s
0%
52. Container resolution helper
2m 24s
0%
53. View and config helpers
4m 12s
0%
54. Route generator helper
4m 34s
0%

Transcript

00:00
Eloquent, which we're using to access our database, comes pre-built with pagination. So let's look at how we invoke this to get back just the data we want
00:09
to see on the page that we're on. And then we'll start to configure this. In the next episode, we're going to build up some custom pagination views so we can design these and have
00:21
them directly within our Twig templates. OK, so the first thing that we're going to do is head over to the home controller where we are outputting all of these users.
00:32
Now, regardless of how you're building this query up, for example, if you're using any where clauses or anything else like that, it doesn't matter. At the end of this, you just need
00:41
to swap out get for paginate. And the only argument this requires is how many you want per page. So we're going to go ahead and say
00:50
that we want one per page because we've got two records. So let's head over and give this a refresh. And the first issue that we have is although Eloquent uses this paginate method
01:01
and it's very closely tied to it, we don't have the pagination package installed. So again, we're going to come over and do a composer require here on illuminate and you guessed it, pagination.
01:15
So once we've got this installed, we will be able to see this on the page. Let's go over, give this a refresh. And as you can see, we are now only
01:24
seeing one record per page. So let's just dive into what's happening behind the scenes here when we actually use paginate. What are we getting back from this?
01:34
Well, let's go to the top here, dump this out, kill the page, and see what this gives us. OK, so I'm going to give the page a refresh. And as you can see, we've got a length aware paginator.
01:45
Length aware just means it's aware of how many records are in the database so it can paginate accordingly. And you'll see that inside of here, we have a collection. So the items within this paginator are a collection.
01:58
The paginator is iterable, so we can still iterate over this in our view. But the only items that we have in here are just on the first page.
02:06
So at the moment, we have Alex. Now, sure enough, if we go over to the query string and type page 2, what do we think is going to happen? Well, not much.
02:15
We're still going to get the first result here because our paginator does not know where to take this data from in order to select this in the database for page 2.
02:27
So what we need to do is a little bit of configuring to get this to work. What we can do now, though, is just get rid of this dump because whichever page we select on here,
02:36
we will see the data for that down here. OK, so we can configure this anywhere, but we're going to do this over in our app service provider. So you can either create out a separate service
02:46
provider for this and put this in your boot method, or you could just put it in app service provider. So there's quite a few things that we can customize on the paginator instance.
02:56
Let's go ahead and open that up here. We've got things like the current path resolver. If we just open up this base class here, you'll see that we've got a current path
03:05
resolver, a current page resolver, which needs to feed into the paginator what page we're currently on. There's a ton that we can configure here. Let's just configure the most basic ones now,
03:17
and then we'll tidy this up in a bit. So let's go ahead and grab out the paginator from illuminate and pagination. And let's set the current path resolver.
03:27
So the current path is just going to be the path that exists within our application. So basically, just the following. Or if we're within a sub page, for example, a user's page,
03:38
it will be this. So we just need to return the current path that we're on. OK, we get an error here, of course, because we haven't filled this in with a closure.
03:45
But let's go ahead and do that now. OK, so how are we going to do this? Well, we can return from our request, which, remember, is on our container.
03:52
So we can say this, get container, and get our request. That gives us our global request, remember, that we built up a little bit earlier. If we need reminding about this, let's
04:04
go over to our request service provider. And remember that we created the server object from globals. So this will contain everything about our path and everything that we need.
04:16
So on this request object, we have a get URI method, which returns to us the current URI that we are on, including the forward slash path. Unfortunately, it also includes anything in the query string.
04:30
So if we head back over to the browser, give this a refresh, that looks like it works. But we're going to end up with too much data in here. So let's just go ahead and dump this out in here
04:41
and kill the page again, just so we can see what this gives us. So you can see that we've got this URI object. We will get all of this data when we cast this to a string. So let's just cast this to a string inside of here,
04:54
so it gives us back the full path. And you can see it includes page 2. That's not what we want, because the paginator needs to know the path here, so it can construct page equals
05:05
3, 4, when we output our pagination links. So already by just returning this, this will cast this to a string. So we don't need to do that manually.
05:15
But we do need to get rid of that end part. To do this, we can use the string to token method or function in PHP. And we can wrap all of this.
05:27
And then as the argument here, we're just going to give the query string question mark. And as you can see, if we just fix that by putting the argument in the right place,
05:37
you will be able to see that we just get the path to our app, which is great. That's all we need. So now we can take all of this and just go ahead
05:45
and return that directly from our path resolver. And we know that the path will always be correct now. OK, so the next thing is the query string resolver. This is pretty important, because it
05:55
needs to know what the current query string is if we need to append these on later. We'll be doing this later and see how this looks in action. But let's go ahead and add this in now,
06:04
because it's pretty straightforward. So let's go ahead and again pull out our closure. We're going to do exactly the same thing here. We're going to grab our container with our request.
06:14
And then we're just going to say get query params. We already saw that a little bit earlier when we set everything up. Now, the most important here is the current page resolver.
06:24
So current page resolver just needs to be what page we're currently on. Let's hard code it into two for now. And as you can imagine, when we refresh this,
06:33
we get the second page of results. Alex was on the first page, and Mabel was on the second, because we're splitting them by one. So we're going to do exactly the same thing as we did here.
06:42
So let's grab the query string. And then we can just read from that. So let's read the page name that we get passed into here. So let's say page name.
06:51
We'll set that as a default of page. And then here, we'll grab the page name. So basically, whatever's passed into the query string here under page will be read, sent back,
07:03
and then we can access that in there. And that gives us back the value of the page we're on. Now, as a default, we'll stick that to one, because we're always going to assume
07:11
that we'll be on the first page. OK, so now I'm going to go back to the home page. We're on the first page, so that's working. When we go to page two, that works.
07:21
And when we go to page three, rather than cause an error, it just gives us an empty set of results, which is absolutely fine. OK, so now that we've built our pagination,
07:30
we can use this anywhere. You can just iterate over everything as you normally would. Of course, the only problem is we don't have any links.
07:38
So let's go ahead and look at how we can create our own custom template, and more importantly, get the pagination package to actually use Twig to render this out.

Episode summary

In this episode, we dive into how to paginate our data with Eloquent. We start by swapping out the usual get() method for paginate(), and we talk through what Eloquent's pagination gives us out of the box—like being able to specify how many records you want per page.

You'll see what happens behind the scenes when using paginate() (hint: it's a length-aware paginator that knows how many total items you have), and we inspect the paginator output to understand its structure. We face a small roadblock where, even though the paginator is ready to go, it doesn't know what page we're on. That means clicking different pages in the query string doesn't do anything yet!

To fix this, we install the pagination package and then head over to our application's service provider to do some essential config: setting up the path, query string, and current page resolvers. You'll see how to clean up the current path (removing the query string, so pagination links stay clean) and properly determine which page should be displayed.

By the end, pagination is working in our app—changing the page in the URL actually works! But there are no navigation links yet. That's the perfect setup for next time, where we'll get into making custom pagination templates using Twig.

So after this episode, you’ll know how to paginate data, make sure your app understands which page it should show, and you'll be prepped to customize the UI of your pagination controls next!

Episode discussion

No comments, yet. Be the first!