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
28. Creating an example user profile page

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
So let's solidify what we've learned about accessing the database and in
00:04
particular using models, and we want to be able to click on each of these users and go through to a dedicated profile page for that user and show some data about them. So if we head over to our web routes, this is where we're going to define out a new route for a user's profile.
00:22
So let's start to do this now. And we'll say get. And in here, we're going to say users slash. And then we want to include the ID or some sort of identifier of the user
00:35
so we can pull them out of the database. For this, we use placeholders wrapped in curly braces, and we just pass the name of the variable that we expect here. And then we go ahead and pass this over to a controller or a closure.
00:47
So let's go and create out a new controller. We'll grab the structure of the dashboard controller to keep this simple. And we'll call this user controller. So let's say user controller.
00:59
And we'll just go ahead and paste this in here. OK, so we need our view because we want to be able to render a view out. And we need a response. And we want to render something like user.twig.
01:09
You can put these in directories, by the way. So if you wanted to put this in a user's directory, just do this with a slash. OK, let's create the view out for this. So user.twig.
01:18
And for now, let's just put user in there just to make sure this is working. Head back over to our web routes and we'll reference that user controller in here, which doesn't exist at the moment. So let's just make sure we rename this.
01:35
And back over to our web routes, let's pull this in like so. OK, great. So now what we can do is over on our home view, we can link this up. So let's add in an href in here to link through to that page.
01:54
And in here, we want to say users slash. And then we want to take the user ID. Normally, we wouldn't use an ID. But since we're working with limited data, let's just leave it at that.
02:06
OK, so now I can click through to users slash one, two, or whichever user I want to access. So let's start with Mabel and we'll go ahead and access that user within the user controller. So when we use placeholders in our web routes like this, these get passed into our controller. So these are an array of arguments that we can use.
02:32
Let's just dump these out here just to see them. And then we'll extract them out and plug that user out of the database. So let's grab our arguments, come over, give that a refresh. And the user now matches up with the user that we're requesting.
02:47
So what we can do with this is either access this directly, or we could go ahead and destructure the arguments and give this a variable name. So we can take the arguments, pluck the user out of here, grab the user ID, and then we can look this user up.
03:01
So to do this, we can create a variable out here that represents the user. We can either use the database directly or we could use our models. So let's just use our models here. And we could say something like find passing in the user ID.
03:16
If we do a var dump on this again and kill the page, you'll see that we get back an instance of that user, app models user. And this contains a bunch of stuff, but it also contains all of the data inside of there as well. Our dump functionality isn't very pretty at the moment,
03:32
so we might change that up a little bit later. We could also use the dump function, which comes from Symfony, which we also use within Twig templates. And you can see that looks a lot better as well.
03:43
So under the attribute section, it just gives us all of the information about the user we want. And really, we can just pass this user directly down to our view and then start to extract any of the data out that we need. So we could just do this.
03:57
And then over in user, we could go ahead and create our page. So let's take one of our existing pages just to keep things simple, pull it over, and let's change this up. So we'll go ahead and set a title here.
04:09
So let's set the block title in that block there. And in here, let's output the user's name, user.name. And we can do this here as well, user.name. Remember, user is an object.
04:22
So now we're just accessing a property on that object using twigs.notation. OK, so down here, you could create some details about the user if you wanted to, depending on what you had in your database. And when we give that a refresh, there we go.
04:37
So if we head back to home and click on any of these others, this is now updating the title and the header on the page with all of that user's information. So you'll want to use the same kind of flow for any data
04:49
that you want to grab from the URL and display out here. There's a couple of other things that you can do as well. For example, if we had user ID of 10, that doesn't exist. But at the moment, what we're doing is just passing down an empty model to our view.
05:04
Now, what we can do is say something like find or fail. Or you could just do a manual if statement and throw a custom exception, which we'll be looking at later. But find or fail will just fail the request with no query result.
05:17
So it will just give you an error. And of course, if debugging is off, this will just give a standard error on the page or just not show anything. We'll look at this later, though, because we'll want to customize things
05:28
like 404 pages if this happens. So we'll come back to this a little bit later. But find or fail is a good option because we don't want to show the page at all if the user doesn't exist.
05:38
OK. So now that we've done that, we have now looked at an example of grabbing data from the URL, showing it on the page. And you can use this to build pretty much anything you need to.

Episode summary

In this episode, we're putting everything we've covered about models and database access into practice by creating a user profile page. The main goal here is to allow visitors to click on any user from a list and be taken to their own profile page, where we'll show some data about them.

First, we define a new route in our web routes file that will handle URLs like /users/{id} — essentially, a dynamic route that accepts the user's unique identifier. We then set up a new controller (the UserController) to handle these routes and render a user.twig view.

Once the route and controller are ready, we update our home view to link each user's name to their profile page. We use the user's ID for the URL for simplicity. When a user clicks the link, our controller receives that ID through the route placeholder, fetches the appropriate user from the database using the model's find method, and passes that user data to the view.

With the data now available in the Twig template, we display details about the user, such as their name. We also talk briefly about what happens if someone tries to access a user that doesn't exist: for now, you'll just see an error, but later we'll learn how to handle this more gracefully (like custom 404 pages).

By the end of the episode, we've built a basic and functional user profile page and set up a workflow you can reuse for any other dynamic, data-driven pages. This is a super useful pattern for almost any web application!

Episode discussion

No comments, yet. Be the first!