[Master Class] [Designer and Developer Workflow] [Creating the User Form]

So now, we set up our new user scaffold and we can go back and see a list

and create a new user, but there's still a lot of work to be done

to turn this into a real authentication system.

For instance, we added a lot of interesting columns that authlogic will use,

however, our user model itself has not been set up to actually use those fields.

For instance, if we wanted to add the form for our users, and that's in app, views,

users, form, we have our email and name field.

And let's say we wanted to add a password field.

And we'll go ahead and say "password,"

and let's go ahead and make that a password field.

Now, we should get an error here when we create new user

because there's no method password, and that's because in our database

it's called "crypted password," and there's also a password salt.

So, when we actually set up our user to use the authlogic logic

it will actually create a password field that when it's submitted

will encrypt the password and store in the crypted password field.

Since we haven't said our user model is an authenticatable model,

these magic methods have not been added, so let's go ahead and do that.

To do that, it's pretty simple.

We're going to go to app, models, and open up our user model.

Now, the simplest way to set this up is to use a method called "acts_as_authentic."

Now, we can just do that, and if we want to add configuration we can pass a block to it

and pass it some configuration options, but so far, we don't need that quite yet.

So, let's just leave acts_as_authentic, and this will include all of the information

and all of the logic for handling all those magical methods,

handling password crypting and all sorts of other good stuff.

So, let's save this out and if we go back, you'll now see that password works

because as we added the acts_as_authentic, it gives us a password field.

Now, there's one more field we want to add, and that's the password confirmation.

Be default, if we try to type this in, let's go ahead and see what happens.

We'll say "jim@carsonified" and "Jim Hoskins."

We're going to get an error saying our password confirmation is too short,

and that's because by default, it requires a password confirmation field,

and this is just another magic method where we'll add a field called "password confirmation"

and during the validation process it will confirm that password

and password confirmation are the same.

So, that's pretty easy to fix, and I'm going to add this to our form

so when Nick starts designing this form he'll have the fields,

and he'll be able to lay them out and style them properly.

So, we can go ahead and say "confirmation."

Let's see if that gets us what we want.

So, we'll just go to /user/new and here we have our information again.

So, let's try that again.

And let's just give it the wrong password.

So now, we see that it's actually checking the two against each other,

and since I didn't give them the same password it's not going to validate,

and we can't register.

So, I'm just going to edit this to be a matching password,

and now we've created a user, or you could say that we've registered.

Now, if we actually wanted to see what our user looked like in the database

we could actually open up our Rails console,

and we could take a look at the information for our user.

So, what I'll do is we'll just say "puts user.first.to_yaml."

So, we're grabbing the first user out of the database and just

printing out the yaml version.

So, we can see it has the name of Jim Hoskins, and we have our single access token

which we don't need right now, and if go down here, we can see our crypted password,

and this is what's actually stored in the database for my password.

Now, to tell you my password that I used here was just the word password,

but when it encrypted it, it creates a very long string

that any time we try to log in using password, it should generate the same string,

and if they match, then log in should work, and this is the salt

that is added to my password before actually encrypting it.

Then you can see we have our other fields.

We have our current log in IP, anything with our log in is going to be zero

because we've never logged in before, but that just gives you

an idea of what it looks like in the database.

Instead of storing our plain text password, it actually went ahead and encrypted it.

So, we can go back, and we can see our list of users.