At this point we've successfully implemented the adding of new

entities including categories and gifs.

By doing this we've addressed one of the three change operations in crud,

the create operation.

Moving right through the read operation, let's now focus on the update operation.

In implementing this for categories, we'll have to revisit the Thymeleaf view we used

to render a category form and the controller to capture URL requests for

both the update form and the update submission.

In implementing the category update let's first visit the controller method

that's used to render the update form.

So I'll will open the CategoryController now.

The method we're looking for is called formEditCategory.

I'll use this Structure tab here.

There it is, formEditCategory, this method here.

Actually, the code in here will be almost identical to the formNewCategory method,

so I'll start by copying and pasting code from there.

And that method is right above this one, so I will copy this and paste here.

Now there's one change we'll need to make for now.

Since this method is being used to edit an existing category, instead of adding a new

category to the model here, we need to grab the existing one from the database

according to the ID of the category that was passed into the method.

Let's use the category services find by ID method to do that.

So in place of the code I have highlighted here,

that call to the default constructor.

I will use the categoryService, and call it's findById method,

passing it the categoryId that was passed into this method.

Now you may have gone back to your category DAO in-service

to implement the findById method, but I have not.

So I'll do that now.

I'll start with the DaoImpl, so I'll open that.

That is the CategoryDaoImpl.

And here is my findById method, cool.

So, instead of copying and paste code here from another method, let's just walk

through this again as a good reminder and review of how this looks.

So, I'll start by opening the hibernate session, SessionFactory.openSession.

Cool, the next thing I’m going to do is create a category

object which will be our eventual return value.

And I will store into it the results of the call to the session that get method.

And this will be a category objects, so

I want to get it according to the category entity and here is the ID we received.

All right, the next thing I wanna do is close that session and

finally I want to return that category object.

Let's not forget our semicolon in there, sweet.

The next thing I wanna to hit is the ServiceImpl.

Let's make sure I've fully implemented things there.

So let's go to the CategoryServiceImpl and

it looks like I'm still returning null on that findByID method.

Now what I can do is call upon that categoryDao's findById method,

passing it the ID that this service method received, cool.

Now at this point we should be able to see the edit form, so let's test it.

Let me open this here, I'm gonna stop my currently running instance of

a giflib and then i'm in a rerun, the bootRun task.

Everything compiled correctly.

And we've got a running application.

So let's switch to Chrome.

And let's check out the category index page, and there are all of our categories.

Now, this little icon here is what will bring up the category edit form.

You can see the URL at the bottom there,

where it says localhost:8080/categories/1/edit and

I'll click on that and looks like I do indeed see the categories editform.

But there are a few UI elements here that we need to address.

When we want to update a category, it doesn't make much sense for

this heading to say New Category.

It should say something more like, edit categories, so

we should say, edit here instead of new.

In addition, it also doesn't make much sense for the submit button to say, add.

The action associated with it is updating so, maybe it would make more sense for

this to say, update here, instead of add.

The third item is not so apparent.

But if we inspect the page we'll see another item that needs attention.

Let me inspect this form.

Now looking closely at this form element, here, and

I can zoom in to make that clear, the action attribute is listed

as /categories which means this form's submission willl be sent to the same

URI as adding a new category, which is not true.

That's not how we were accepting our URI, mapping our URIs in our controllers.

So we'll need to fix that as well.

Let's address each one of these in intelliJ.

Here I'm going to open the category form template.

Let me collapse this here and we'll find that category form template

under resources, templates, category and form.

Now the three changes I mentioned certainly don't warrant the creation of

a brand new template.

Almost all of this is going to look identical, so

let's make some of these UI elements variable.

We'll start with the form's action attribute right here.

This action attribute, let's make this thing variable.

Let's assume this has been added to the model from the controller as an attribute

named action.

So, instead of /categories here,

let's assume that there is a model attribute named action.

Of course, we'll need to go back to the controller to

add a model attribute name action.

We'll do that in just a bit.

Next, let's assume that the heading has been added to the model

as an attribute named heading.

So here I could say th:text=${heading}.

Next let's assume that the submit button's text has been added as an attribute

named submit.

So down where you see the submit button right here,

let's change this to variable text.

Let's have Thymeleaf generate the name of this.

So here I'll say th:text= and then submit.

Just like that.

Now the final change we'll need to make here, is ensuring that our category's

ID is preserved across the http request response cycle.

When the form is submitted,

we want to make sure that the category is indeed updated,

instead of a new one being created with the next available integer as an ID.

And to do that we'll stick a hidden input in the form with the categories ID.

So I'll do that just below the opening form tag.

And we'll say input[type=hidden].

This is a little shortcut here in IntelliJ.

I'll hit tab, the type is hidden.

Make sure that's XHTML compliant, and

I'll bind it to the id property using that asterisk.

Now that's the id property of the bound object,

which will be category you see that th object that we were talking about earlier.

Okay so this ID won't be displayed but it will be present and

will be included as form data when this form is submitted.

And don't worry about this ID field being present when this template is used for

a new category, it won't have a value when the form is rendered.

And now, with all these template changes made, next

we'll flip back to the controller, and add those three attributes to the model.