Build a Complete Registration and Login System using PHP MVC
4.8 (70 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
394 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Build a Complete Registration and Login System using PHP MVC to your Wishlist.

Add to Wishlist

Build a Complete Registration and Login System using PHP MVC

Add registration, login, remember me, account activation, password reset by email and more using the PHP MVC framework
4.8 (70 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
394 students enrolled
Created by Dave Hollingworth
Last updated 7/2017
English
Current price: $10 Original price: $80 Discount: 88% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 5 hours on-demand video
  • 91 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Let new users sign up for a new account
  • Validate the users' registration data, both on the server and in the browser
  • Store passwords securely in the database
  • Allow users to log in using their email and password
  • Restrict content to logged-in users only
  • Use sessions for handling logins
  • Use cookies to optionally remember the user's login
  • Allow users to securely reset their own passwords when they forget them
  • Let users update their own profile details
  • Use a CSS UI framework to easily add styling to a project
View Curriculum
Requirements
  • You need to have taken the "Write PHP Like a Pro: Build a PHP MVC Framework From Scratch" course
  • You should already be familiar with the basics of PHP, HTML, CSS and JavaScript
  • You should be comfortable installing software on your computer
  • You need to be familiar with the model - view - controller (MVC) pattern
Description

Learn the basic concepts, tools and functions that you will need for user authentication using a PHP MVC framework.

Add registration and login to the PHP MVC framework we built on the "Build a PHP MVC Framework From Scratch" course.

  • Let new users sign up and log in
  • Store passwords securely in the database
  • Restrict content to logged-in users only
  • Use sessions for handling logins
  • Use cookies to optionally remember the user's login
  • Allow users to securely reset their own passwords


Build Registration and Login using Models, Views and Controllers

Most websites and web applications need user authentication. Once users sign up to your site, you can tailor content specifically to them, and restrict content to logged-in users only.

By developing user authentication using an MVC framework, your code will be easier to write and maintain.

All the concepts you need to know to understand why the system is developed the way it is are explained in detail.

Content and Overview

I designed this course to follow on from the Write PHP Like a Pro: Build a PHP MVC Framework From Scratch course. At the end of that course you had built your own PHP MVC framework. If you want to add user registration and login to that framework, then this course will cover all you need to know, starting from where that course left off.

Starting with the basic concepts of authentication, this course will take you through all the steps needed to build a complete registration and login system, one piece at a time.

Beginning with the PHP MVC framework from the previous course, each lecture explains what you're going to add to the code and why, building up the project step by step. At the end of this course, you'll have built a complete registration and login system using the PHP MVC framework, ready to use in your own projects.

Complete with working source code at every stage, you'll be able to work alongside the instructor and will receive a verifiable certificate of completion upon finishing the course. Also, at all times throughout the course you have access to the instructor to ask for help with any topic related to the course.

Who is the target audience?
  • This course is for those who want to add authentication to the PHP MVC framework
  • This course is NOT for you if you're not familiar with MVC
Students Who Viewed This Course Also Viewed
Curriculum For This Course
106 Lectures
05:09:07
+
Introduction and project setup
5 Lectures 09:36

Welcome to the course!

In this lecture we'll look at:

  • A summary of what you're going to learn throughout the course.
  • How to get the most out of the course: experimenting with the code yourself, where to find the source code and how to get help.
Preview 01:40

To get the most out of the course, you should be running the code yourself as we go along. The best place to do this is on your own web server, installed locally on your computer. In this lecture you'll learn how to do that.

At the end of this lecture, you should have a web server and database server running on your computer.

Preview 02:00

Throughout this course we’re going to be developing the login system using the PHP MVC framework that we developed on the Write a PHP MVC framework from Scratch course.

So you'll need a copy of that framework code as a starting point. This lecture shows you how to get a fresh copy of that code from Github if you need it.

Preview 01:45

Now that you've got the framework installed, we need to configure the web server. 

In this lecture you'll configure the root of the web server to point to the public folder of the framework.

Preview 01:33

The application that you’re going to be creating needs a database. In this lecture you'll learn how to use phpMyAdmin to create one, that we'll be using throughout the rest of the course.

Preview 02:38
+
New user signup: create the registration form and save the data in the database
10 Lectures 33:36

The first thing we need to do is let visitors to our site register or sign up. They can’t login until they’ve created an account. We need a table of users in the db to store these user accounts.

In this lecture you'll learn how to uniquely identify each user account. We'll look at the advantages and disadvantages of using a username or an email address.

Preview 02:34

When a user logs in, they’re going to enter their username and their password. To authenticate them, we need to take the username they supplied, look it up in the database, and check their password is correct.

So along with the username, we need to store the password in the database.

In this lecture you'll learn the most secure way to do that, so that even if the database is stolen, an attacker can't use the data in the database to login.

Preview 04:10

In this lecture you'll learn the various options for generating a hash in PHP, for example md5, sha1 and bcrypt. We'll look at which ones to use, and which ones not to use. You'll also learn the most secure method for generating a secure password hash in PHP.

Preview 03:41

To store user accounts in the database, we need a users table. In this lecture we'll use phpMyAdmin to create the users table in the database. You'll also learn why we use a unique, numeric ID as the primary key and not the email address.

The SQL to create the users table is attached to this lecture in the resources section.

Preview 02:46

We'll start coding our application in this lecture by adding the signup controller and the signup page view.

Preview 02:19

In this lecture we'll add the signup form with its input fields to the signup page. In addition, you'll learn:

  • Which form method to use, GET or POST
  • How to associate a label element with an input. Also why doing this is beneficial - so that when you click on the label, it puts focus on the control, and it's also better for accessibility.
Preview 03:47

In this lecture we'll add the controller action method that will handle the submission of the signup form, and link this to the signup form with the form's action attribute.

Preview 01:36

In this lecture you'll learn exactly how SQL injection attacks work, and how dangerous they can be to your application.

Preview 04:07

In this lecture you'll learn how SQL injection attacks work when inserting variables into SQL statements. You'll also learn how to use PDO's quote function and prepared statements to avoid them.

Preview 04:01

In this lecture you'll learn how to create the user record in the database by adding a method to the user model

We'll also add code to get the data from the signup form to the model via the controller, and we'll learn how to use the class constructor to assign property values.

At the end of this lecture a new user will be able to sign up for a new account, creating a new record in the database.

Preview 04:35

Test your knowledge of the concepts covered in this section.

New user signup
7 questions
+
Validate the signup data on the server
6 Lectures 18:08

Before we insert a new record into the database, we want to validate the data in the form.

In this lecture we'll add a validate function to our user model that’s going to validate the current property values.

Validate the data before saving the new user record
03:56

If we try to sign up another user with an email address that already exists in the database, we get an error.

In this lecture we'll add validation that an email address doesn’t already exist in the database before we save the data.

Validate the email address is unique in the user table
02:11

When there are validation errors, it would be much better to redisplay the signup form and have the error messages on the same page

In this lecture we'll use the user model to pass validation error messages back to the signup form when there are validation errors.

Display validation error messages in the signup form
03:30

If you reload or refresh a page after submitting a form that uses the POST method, you might see a warning message.

It’s a warning that if you refresh the page, the form data will be submitted again, and any action taken on the server might be repeated. This could include placing an order or charging a credit card for example.

In this lecture you'll learn how to avoid this using the post / redirect / get pattern.

Prevent duplicate form submissions using the Post / Redirect / Get pattern
02:04

Normally, a user requests a page by typing in a URL, clicking on a link or submitting a form. The server receives the request, and sends back a response, for example, a page of HTML. Sometimes though, instead of replying with some content, the server replies with a message to tell the browser to request a different URL.

This is known as a redirect. It’s common to redirect to another page after inserting some data into a database, or logging in for example. 

In this lecture you'll learn how and why to redirect to another page using PHP, including best practices.

Redirecting to another page using PHP: how, why and best practices
05:15

Now that we know why we should redirect after making changes in the database, in this lecture you'll change the result of a successful signup to redirect to another page instead of just showing a template as part of the same request.

Redirect to the success page after a successful signup
01:12

Test your knowledge of the material covered in this section.

Validate the signup data on the server
4 questions
+
Validate the signup data in the browser
8 Lectures 24:19

If you can validate form data in the browser using JavaScript, why do you need to bother validating data on the server? The answer is because client-side validation can easily be bypassed.

In this lecture you'll learn how client-side validation can enhance the user experience and can save server resources, but shouldn't be relied on as the only validation. You should always validate data on the server as well.

Why you should validate data on the server as well as the client
02:45

Prior to HTML5, client-side validation had to be done with JavaScript, there was no alternative. However, HTML5 gives us various options for form validation without using any scripts at all.

In this lecture you'll add HTML5 validation to the signup form.

Validate the signup page in the browser using HTML5 validation
02:59

Instead of writing all your validation code from scratch, there are some excellent libraries available that make the job much easier.

In this lecture you'll add the jQuery Validation Plugin and jQuery library to the code. You'll also learn the best place to put external JavaScript file references in your code.

Add a JavaScript validation library
03:34

In this lecture you'll add client-side validation to the signup form using the jQuery Validation Plugin.

Validate the signup page in the browser using JavaScript
03:11

Built-in jQuery Validation Plugin methods don’t include a method for a custom format, which is what we need to validate the password.

In this lecture you'll add a custom validation method to the jQuery Validation Plugin to validate the password, using a regular expression to check its validity.

Validate the format of the password with a custom validation method
02:19

Even though we're validating the form data in the browser, to validate the uniqueness of the email address, we need to communicate with the server to check if the email address already exists in the database or not. The jquery validation plugin provides us with the remote method so we can do this.

In this lecture we'll add a remote validation call to validate the email address, using Ajax. You'll also learn how "regular" and Ajax requests differ, and how to do Ajax requests using the MVC framework.

Validate the email address is unique using an Ajax request
05:04

When you sign up for a new account on a website, one of the pieces of data you have to provide is a password. You usually have to type these into password-type input fields, which are masked, meaning that you can't see what you've typed. This is to prevent someone seeing the password you've entered. Because you can't see it, it's common for websites to make you repeat what you've typed in another password field. This is to make sure you know what you've typed.

In this lecture you'll learn why this can be a problem, and how to solve it.

The password confirmation field: why it's a problem and how to fix it
01:46

In this lecture you'll change the password confirmation field on the signup form so that there's a single password field, but with a button to reveal the password if the user wants to.

Remove the password confirmation field and add a show password button
02:41

Test your knowledge of the material learnt in this section.

Validate the signup data in the browser
5 questions
+
Login: authenticate the user using their email address and password
11 Lectures 36:06

To log in, the user needs to supply their email address and their password.

In this lecture, you'll add the login screen and its associated controller. You'll also add a custom route for a "pretty" login URL.

Create and display the login page
03:14

In this lecture you'll add the controller action that's going to authenticate the user when they submit the login form.

Create the login action in the controller
02:01

The first thing we need to do when authenticating is to find the user based on their email address. In this lecture you'll add a method to the user model to do this.

You'll also learn how to return an object of the User class when fetching a record from the database using PDO.

Find the user object using the email address
05:01

We're not storing the passwords in plain text, rather we're storing a hash of the password. So to check the password when the user logs in, we can't just compare what they typed in to what we have in the database using a simple string comparison.

So how do we check the password? We're using the password_hash function to generate the hash from the plain text password, and PHP also provides the password_verify function that we can use to check a password matches a hash.

In this lecture you'll add a method to the User model to authenticate a user by checking their password.

Authenticate the user by verifying their password is correct
03:09

When we login incorrectly, the form is redisplayed. As the password is masked, it's more likely that we've typed the password incorrectly than the email address. So if we login incorrectly, it would be good if the email address was remembered when the form was redisplayed.

In this lecture you'll redisplay the email address in the login form when the login is incorrect.

Redisplay the email address in the login form when authentication fails
01:30

We just added code in our login controller to redirect to another page. We're also doing this exact same thing in our signup controller. Redirecting is something you probably want to do quite often in a controller.

To make this easier and to remove this repetition, in this lecture you'll add a redirect method to the core controller.

Add a redirect method to the core controller
01:45

As far as the web server is concerned, each request is unrelated and independent to any previous one. This is because HTTP, the protocol used between web browsers and servers, is stateless.

Not having state isn't very useful however if we want to remember that someone has already been to our site, so we can do things like logging in, shopping carts, and so on.

We can add state by using sessions.

In this lecture you'll learn how sessions can be used to remember that someone has already visited your site, and exactly how sessions work in PHP.

Sessions in PHP: make the web browser remember you
05:17

In this lecture you'll use sessions to store the user's ID in order to remember that they've logged in. You'll also add code to show on the homepage if the user is logged in or not.

Use the session to remember the login and view the logged-in status
04:10

PHP sessions are destroyed automatically when the browser is closed. However, our users will need to be able to log out without closing the browser. In this lecture you'll learn how to completely destroy a session in PHP without having to close the browser.

Sessions in PHP: completely destroy a session, even without closing the browser
03:05

When we logged the user in, we stored the user ID in the session. To log the user out, we could just remove this value from the session array, but we might have stored other values in the session in other places in the application. Much better to simply destroy the session when the user wants to log out.

In this lecture you'll completely destroy the session when the user logs out.

Destroy the session to log the user out
02:32

Sessions in PHP: prevent session fixation attacks
04:22

Test your knowledge of the material covered in this section.

Login
6 questions
+
Restrict access to authenticated users only
8 Lectures 23:04

In this section we're going to learn how to restrict content based on whether the user is logged in or not. Before we do that though, in this lecture let's create a class to group together all the authentication code, so it's not distributed around different controllers and models, and therefore easier to manage.

Add a class to organise the authentication code in one place
03:55

One of the reasons you want login is to be able to restrict content to those users that have identified themselves, or logged in.

In this lecture you'll restrict access to a page if the user is not logged in, redirecting them to the login page.

Restrict a page to logged-in users only
03:02

At the moment, if a user tries to access a page that requires login, we redirect them to the login page. But once they've logged in, it goes back to the homepage, so the user has to type the URL of the original page again.

In this lecture we'll remember the page they originally requested, and once they've logged-in successfully, redirect them back to it.

Redirect back to the originally requested page after login
03:03

To require the user to login before viewing a page, we're using all this code:

  • checking to see if they're logged in
  • remembering the requested page
  • redirecting to the login page

It's likely that we're going to have more than one page that requires login, so we don't want to be repeating all this code for every action that requires login.

In this lecture you'll extract this out into a reusable method in the core controller.

Add a method to the core controller for requiring login
02:01

To restrict access to an action to logged-in users only, we call the requireLogin method we just added. 

If we're doing this for every action method in the controller, there's an easier way to do it. In this lecture you'll add a before filter method to restrict access to every action method in a controller.

Require login for all action methods in a controller
01:59

In this lecture you'll add a base controller that automatically requires login for all action methods in the controller.

Add a base controller that requires login for all action methods
03:04

Having access to the current logged-in user in our controllers and views will be useful for things like showing the username, getting records from the database that are linked to the user record and so on.

In this lecture you'll add a method to the Auth class that returns the current logged-in user.

Get the current authenticated user in controllers and views
03:27

The isLoggedIn method and the getUser method contain repeated code.

In this lecture you'll simplify the code to clean up this repetition.

Simplify the code: remove the isLoggedIn method
02:33
+
Flash messages: display status messages to users
7 Lectures 18:05

So far in our site we can do things like login, logout, request a page that requires login and get redirected to the login screen and so on. What it lacks though are status messages telling the user what's going on. For example, if they try to access a page that requires login, it simply redirects to the login screen without saying anything else. Not very user friendly. So what we need to add are notification messages at different points in our application.

In this section we'll add flash messages that allow us to pass status messages between requests. In this lecture you'll learn how these are going to work.

Flash notification messages: display status messages to users
02:47

In this lecture we'll start by adding a class to handle the flash messages.

Then we'll start using this by showing a message when the user tries to access a restricted page, but they're not logged in.

Add a flash message when requiring login
02:07

In order to display the messages, we want to get them from the session first.

In this lecture you'll add a method to do that, then we'll display the messages in the base view. We'll also add a global variable to Twig to make the messages available in our Twig templates.

Display the flash messages to the user
03:03

Now we have our flash messages established, we can add them to more controllers. Let's add messages to the login controller.

In this lecture you'll add a flash message for when the user authenticates successfully and also unsuccessfully.

Add flash messages when logging in
01:49

In this lecture we'll add a flash message when the user logs out. We'll also learn why we have to do this via an intermediate request.

Add a flash message when logging out
01:55

At the moment the flash messages are just text, and they all look the same. We can make these stand out a bit more by styling them using CSS.

In this lecture we'll add a CSS stylesheet and style the flash messages.

Add a CSS style sheet and style the flash messages
01:48

At the moment the flash message shown when login fails is styled in the same way as when login is successful. We could style these differently though, to show the user that some messages require more attention than others.

In this lecture we'll add different types of flash messages, and associated styles that make the messages look different depending on their type.

Add flash message types and give them different styles
04:36
+
Remember me: give users the option of remembering the login
11 Lectures 39:12

If we close the browser when we're logged in, when we restart the browser we're no longer logged in.

It would be nice for your users if the site could remember the login for their next visit, so they don't have to login again.

In this section you'll learn why the user is logged out when the browser is closed, and how we can give the user the option of remembering the login even after the browser is closed.

How to remember the login after closing the browser
04:24

In this lecture you'll learn how to create unique, random tokens, and also how to create secure hashes of these tokens. We'll use these methods in this and subsequent sections.

Generate unique, random tokens and secure hashes
03:38

Now that we know how to generate a unique token and also hash it, in this lecture we'll create a utility class to do that for us. That way we can reuse that class throughout the site.

Add a class to generate and create hashes of random tokens
03:51

To enable remember me functionality, we're going to store the hash of the token in the database.

In this lecture we'll learn where the best place to store this in the database is, and we'll use phpMyAdmin to create the new fields in the database table.

Create a database table to store remembered logins
02:14

When the user logs in, we're going to give them the option of remembering the login.

Checkboxes are excellent for options, so in this lecture we'll do this by adding a checkbox to the login form. We'll also learn how checkboxes are handled when coming from the HTML to PHP.

Add a remember me checkbox to the login form
03:32

Now that we have the value coming in from the login form, we can start to actually remember the login. The first thing we need to do is generate a unique token, and save a hash of this in the database. That's what we'll do in this lecture.


Remember the login in the database
03:39

In this lecture, you'll learn:

  • what cookies are
  • how browsers use them
  • how different websites can see them
  • how to create them in PHP
Cookies in PHP: the basics
05:05

Now that we've generated a unique token, and saved a hash of it in the database, next we need to set this value in a cookie. That's what we'll do in this lecture.

Remember the login in a cookie
02:10

We can login and remember the login by checking the remember me checkbox, which sets the cookie. But if we close the browser and restart it, it doesn't remember the login yet. The cookie is still there, so in this lecture we'll use the cookie to automatically log the user back in.

Log in automatically using the token in the cookie
04:08

At the moment, when we log in using the token in the remember cookie, all we're doing is checking that a record exists in the database that corresponds to the token. As we're also storing the expiry in the database, we can add an additional layer of security by checking the remembered login hasn't expired. That's what we'll do in this lecture.

Prevent automatic login if the remember token has expired in the database
02:41

If the user has logged in and remembered the login, the logout link no longer works to log the user out. In this lecture you'll learn why this is broken, and we'll also fix it so it works again.

Forget the remembered login when logging out
03:50

Test your knowledge of the material learnt in this section.

Remember me
4 questions
+
Password reset part 1: securely request reset of a forgotten password
9 Lectures 22:29

What happens when a user forgets their password?

In this lecture we'll look at options for resetting a user's password when they forget it, and the pros and cons of each.

You'll learn how we're going to allow the user to securely reset their password, which we'll develop the code for in this and the next section.

Allow users to securely reset their passwords when they forget them
02:40

Starting in this section we're going to be sending emails from our code. If you've taken my PHP email course, you'll already know all about this, but don't worry if you haven't, I'll go over all you need to know in this section.

In this lecture we'll look at the different options for sending email, from SMTP servers to API services, and get access to an email service, ready to start sending emails.

Get access to an email service
03:13

In this lecture we'll create a mail class in our project so we can send an email easily. 

We'll also learn why we send the same content both as text and html.

Add a class to send emails
03:07

We'll start the password reset process by giving the user the form where they can supply their email address.

In this lecture we'll add a new controller, a method to show the form and a view that contains the form.

Create and display the forgotten password page
01:27

Next we need to process this form once it's submitted.

In this lecture we'll add an action method for that, link it to the form, and add a method to the User model.

Process the forgotten password form in the controller
02:13

As we saw at the start of this section, we're going to send the user a token in an email, and save a hash of this token in the database.

In this lecture we'll look at the best place to save this data, and use phpMyAdmin to add fields to the database.

Add password reset fields to the user table in the database
01:30

Now we have the fields in the database, we can save the password reset token and expiry in them.

In this lecture we'll add a method to the User model that starts the password reset process, generating a new token, hash and expiry, then saving these in the new fields in the database.

Save a new password reset token and expiry with the user record
02:04

Now that we've generated the unique token, we can send the user the email containing the URL that includes this token.

In this lecture we'll send an email to the user containing the password reset URL.

Send the password reset email to the user
02:51

At the moment we've got the content of the emails inside a method in the User model. This isn't ideal, as if you want a lot of content you'd have lots of text in here; plus it's not very in keeping with the MVC paradigm. Content like this should be in a view

In this lecture we'll modify the Core View class to allow us to render a view template to a string, so we can use this as the content of an email.

Get the email content from a view template
03:24
+
Password reset part 2: securely reset a forgotten password
8 Lectures 25:44

At this point, the user has forgotten their password, and started the password reset process using the form we developed in the last section. They've received an email containing a URL, so now we need to add code to handle this link when they click on it.

In this lecture we'll add an action method in the password controller that matches the URL, and also a custom route that contains a regular expression so we can get the value of the token from the URL in the controller action.

Add an action to process the link and get the token from the URL
02:09

Now that we're getting the token from the URL, we can use this to get the associated user record

In this lecture we'll add a method to the User model to do that, first getting the token hash from the token in the URL, then using that to look up the user record in the database.

Get the user based on the token and check the expiry
03:55

Once we've got a valid reset token that hasn't expired, we can display the password reset form. 

In this lecture we'll add the password reset form, basing it on the signup form which has a lot in common with it.

Create and display the password reset form
02:35

To create the password reset form, we based it on the signup form. The code adds a jQuery Validation Plugin method to validate the password is repeated in both views. To avoid repeating ourselves, in this lecture we'll extract this out to a separate file.

Extract repeated JavaScript code out into a separate file
01:51

Now we have the password reset form, in this lecture we'll add an action method to process it when it's submitted. We'll add a hidden field to pass the token value through to the action method.

Process the password reset form in the controller
02:37

In the last two methods added to the password controller, we're getting the user based on the token, and if we find a user we do one thing, and if not we display a message.

In this lecture we'll clean this up by removing the repetition. We'll also add a view that will be displayed when the token is expired instead of just outputting a string.

Remove duplicated code and add an expired token view
03:07

At the moment we're validating the password in the browser using JavaScript, but remember you should always validate on the server as well, as client-side validation can be bypassed.

In this lecture we'll add code to the controller and model to validate the password on the server.

Validate the password reset form on the server
05:38

Now we have the server-side validation in place, we can finally reset the password.

In this lecture we'll add code to the User model to reset the password in the database, and also clear the password reset token and expiry.

Reset the user's password and clear the token and expiry
03:52

Test your knowledge of the material covered in this and the previous section.

Password reset
3 questions
4 More Sections
About the Instructor
Dave Hollingworth
4.7 Average rating
753 Reviews
3,599 Students
7 Courses
IT Trainer

Hi, I'm Dave Hollingworth. I'm an IT trainer and web application developer. I've been programming for over twenty-five years, and teaching IT since 1999.

I've developed enterprise-level applications on platforms ranging from mainframes to mobiles: from my first web application, a quotes system created for a major insurance company back in 1999 - the first of its type in the sector - to interactive learning management systems for online language learning.

I've taught courses ranging from basic use of email to advanced web application development, both online and in-person. I've been teaching on Udemy since 2012.

I'm passionate about technology, and love teaching it! I believe it's possible to explain even the most complex subjects in a simple, straightforward way that doesn't confuse the student.

I look forward to welcoming you onto one of my courses!