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
41. Validating the registration form

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
Let's take this episode to validate the registration flow.
00:04
And in the next episode, we're going to be covering creating a custom validation rule to check if the email address that the user provides when they register is already in the database. So in this episode, we're pretty much just going to be doing everything that we've already done. So feel free to do this on your own or skip it. OK, so let's head over to our
00:25
register controller and let's just start to validate as we did before. So we'll actually borrow the namespace from here just so we don't have to keep doing that. And let's go ahead and pop that at the top just here. OK, so when we go ahead and send this through, we already know that we need a try catch block. So let's go and implement that first. Let's pull in the validator
00:48
exception. And we know that we're going to flash a message in here once we have our rules. OK, so what rules do we want here? Well, we've got a key here of the user's name. So again, you can choose which rules you want, but I'm going to go ahead and say that this needs to be alpha and it doesn't want to be empty. Now, I'd also recommend I'm not going to do this now setting minimum or
01:10
maximum values on any of these fields just so the user doesn't enter too much data. OK, so the next thing is going to be the email address. Once again, we know that that needs to be an email. So let's use the email rule. And again, we'll say not empty. And last but not least is the password. So let's add one for this. And we're just going to say that this is not empty. But of course, feel free to add
01:35
any validation rules here that you need. OK, so let's bring our session into this controller. So let's pull out our session and let's flash a message if this doesn't quite work. So we'll say this session, get flashback, add, and we'll just use the same key. So errors. And of course, grab the messages from that exception. And then we want to redirect the user back to the register page if
02:05
this happens. So let's redirect them back. OK, so again, we can steal the code from our login page here. So let's just grab one of these and let's head over to our register twig template and add each of the errors in here. So we've got the first name here. So let's change these two over and we have our email address. So let's go ahead and change these to email. And lastly, the password,
02:28
which is exactly the same. OK, so now if we come over and hit register and we see you have not passed a password. So that doesn't look like it's working. Let's go over to our register controller and see why. And yet we forgot to actually assert this. So that's really important. So we get that exception through. And again, we pull that from request and get pass body. OK, we should be good.
02:50
Let's hit register. And yet nothing's happening because we're not passing this through to our controller. Like I said, we're going to be tidying this up a little bit later. But to get this to work, let's pull out all of the errors from our session. So session, get flashback, get errors, and we'll grab the first item in there. Otherwise we will pass null through. OK, we should just be
03:14
about done. Let's just refresh this and hit register. And there we go. OK, so it looks like the first name is not working. So let's go over to our register controller and just try this out. We call that name, of course. So let's just change that over and we should be good. OK, so we are now validating our registration form. But of course, if I try and register a user here that has the
03:39
same email address, what's going to happen? Well, let's hit register and see. You can see that we just get a pure SQL error back because, of course, that email field in the database is set to unique. So rather than get to the point where we show a user an error, we want to validate that this doesn't already exist in the database. Let's look at how we create custom validation rules next.

Episode summary

In this episode, we focus on validating the registration form in our application. We'll go through adding the basic validation rules for the user's name, email, and password fields. You'll see how to set up rules like making sure the name is purely alphabetic, the email looks like an actual email address, and none of these fields are left empty.

We'll work directly in the register controller, borrowing some code from our login flow to keep things consistent. I show you how to handle validation errors using a try-catch block, flash error messages to the session, and display those errors back in the form. If you want, feel free to experiment with stricter validations like min/max lengths.

Towards the end, you'll notice there's a problem if someone tries to register with an email that's already taken—the app will throw a SQL error since the email is unique in the database. We'll address this by creating a custom validation rule to check the database before trying to save the user, but that's coming up in the next episode.

If you've already got the hang of form validation from previous lessons, feel free to do this part on your own or skip ahead!

Episode discussion

No comments, yet. Be the first!