This course will be retired on June 1, 2025.
Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
Now that we’ve built and examined both regular and resource controllers, we’re ready to speed up our development process by using the time-saving resource controller with all of the CRUD functionality pre-built for the Author and Book controllers!
Resource Controllers
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
Welcome back.
0:00
Now that we've built and examine both
regular and resource controllers,
0:02
we're ready to speed up our development
process by using the time saving resource
0:07
controller with all of the CRUD
functionality pre built for us.
0:11
We learned how to use the r flag
to create a resource controller.
0:17
And in the next section we'll use a new
flag just for APIs, the --api flag.
0:21
Next, we're going to
validate our requests and
0:28
return a response to the API consumer or
user.
0:32
See you there.
0:36
Remember, resource
controllers are also located
0:37
in the app/Http/cCntrollers directory.
0:42
Next, let's build both resource
controllers using artisan commands
0:46
like this.
0:51
And the book controller like this
1:10
Let's examine the CRUD boilerplate
inside of the AuthorController.php file.
1:21
Great, this looks like
a resource controller.
1:29
Thanks, artisan.
1:31
Before we get started, let's import Author
1:35
at the top like this, use App\Author;.
1:39
Next, let's create all of
the CRD functionality,
1:44
validation requests, and HTTP responses.
1:47
First, let's start by creating the index
function which returns all authors.
1:52
Return, response(Author::all(), 200.
1:58
The 200 is the success status
HTTP response of okay.
2:06
To learn more about HTTP status codes,
check out the teachers' notes below.
2:12
Next, let's create the store function
with some validation like this.
2:18
First, create a validation array.
2:24
Inside of the array,
we'll add some rules to validate the data.
2:35
So let's open the author model to
reference the rules we want to validate.
2:39
Name,
2:53
Code update.
3:24
In this code snippet,
3:26
be sure to remove the |unique because
we're not checking for unique emails.
3:27
Check the teachers' notes
below to learn more.
3:32
Finally, let's populate
the author like this.
3:37
$author = new Author();
3:48
$author->name = $data name;
3:56
$author->title =
4:08
$data->title.
4:14
$author->company=$data->company.
4:19
$author->email=$data->email.
4:31
And $author-save().
4:45
Then we return a response like this.
4:56
Return response($author, 201).
5:02
To review, we capture the request,
5:09
then we validate the request to ensure
we are getting the correct data.
5:12
And if validation passes,
5:17
we create a new author from the validated
data stored in the $data variable.
5:19
Finally, we return the author
that was just created.
5:26
However, Laravel makes this way easier for
us.
5:33
Instead of six lines of code,
we can use this one line of code,
5:37
which creates a new author from
the validated $data variable.
5:41
How cool is that?
5:46
Next up, the show function.
5:48
First change $id to Author $author.
5:50
Remember, the show function only shows
one author or resource like this.
5:58
Moving on to the update function,
let's change $id to Author $id, like this.
6:14
Next, copy and
paste the store validation, like this.
6:31
Then we'll capture the existing author,
like this.
6:53
And next we'll return
the response like this.
7:09
return response
7:15
($author->update ($data),
7:19
200).
7:28
Finally, let's build
the destroy function like this.
7:31
$author delete(),
7:39
return response(null,
7:45
204).
7:53
And be sure to change $id
to Author $author as well.
7:57
It's worth noting that if we delete
the author and leave the author's
8:06
books in place, we'll cause an error
because the author might still have books.
8:10
Remember, we're using
eloquent relationships.
8:17
So deleting an author will
leave the author's ID behind,
8:20
inside of the book model causing an error.
8:24
We can fix this with
a foreach loop like this.
8:27
Foreach($author->books as
8:37
$book){$book->delete();.
8:47
Now we can delete the author and
8:58
finally return a response of
null with a 204 or no content.
9:01
Which means the request was successful,
but no content was returned.
9:07
Perfect.
9:12
Now that we've built the CRUD
operations for the author controller,
9:14
let's build the book controller
CRUD functions next.
9:18
First, import book at the top,
just like we did with AuthorController.
9:22
Next, let's create the index function
which returns all books like this.
9:30
Up next we have the show function.
10:01
Let's change the show($id)
to show(Book $book).
10:04
Next add return response ($book, 200);.
10:16
Moving on to the destroy function,
10:31
let's change destroy($id)
to destroy(Book $book).
10:34
Next, let's delete our book like this.
10:45
Finally we return a response of null,
204 like this.
10:59
Next up, the store function,
also known as create.
11:12
When thinking about CRUD, just like
we did with the AuthorController,
11:16
let's open up the book.php file side by
side so we can validate our requests.
11:21
$data = $request->validate.
11:43
'title' =>
12:00
'required'.
12:05
Author_id is also required.
12:18
And 'abstract' => 'required'.
12:26
Finally, instead of doing what we did
in the AuthorController.php file,
12:34
let's add this one line of
code instead of the six lines
12:41
of code that it would normally take,
like this.
12:47
$book = Book::create($data).
12:52
Finally we have the update function.
12:58
So let's start by copying pasting
the validation from store.
13:01
And return a response like this.
13:15
Before we move on, let's change
the $id to Book $book like this.
13:47
Great work.
13:57
We created a controller and
a resource controller,
13:58
then compared the differences between
the two types of controllers.
14:01
We validated requests,
then returned responses for
14:06
both the AuthorController and
BookController.
14:10
By now, you should have a good
understanding of CRUD operations and
14:15
how to build them using Laravel.
14:19
In the next section, we're going to
cover resources, routes, and testing.
14:22
See you there.
14:27
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up