All language subtitles for 1. Error and processing

Hello, guys, welcome back.

In the last lecture, we have successfully, I start to users.

The functionality is prepared, it's working, but it requires some improvement.

So let's continue this lecture and let's work on the improvement.

OK, let's take a look on that page in the register page.

And the one thing I don't currently like is that we don't know that we are registering the user we should

display.

Here is some indicator that we are registering.

They use that.

So for example, when the user is getting registered, I would like to disable this sign up button,

so I would like to know Register is processing, OK?

And also, I would like to maybe start the error into the state of the module so I can use it on my

page.

And maybe I can display here this error on the screen.

So let's try to implement this.

And let's start in their user module to start this information that they are processing the register

and that we have an error of the need to, of course, create here some data we need to create here

state.

So you know how to create a stable does create a state function and you will return to state and the

the data you would like to store in a state.

What data we like to store would like to store here.

I'll call it is processing and the error alerts by the register are industrial properties.

So because in the inside here we can have a multiple states, right, so we can have a state register.

Now these are what you are looking to have a steady state for logging and so on.

So I would like to have a state for register and in register state.

I would like to know if we are currently registering in our call.

It is processing.

I'll make it as a default, as a false and the error message.

Will be searching and by default, this will be empty string.

OK, perfect, so they have already stayed here.

Now in our actions.

Well, they want to do.

We would like to tackle these states depending on our state of our education, so if they are, for

example, getting authenticated, then they can set its processing is through.

When that indication is finished, we can say it is processing is false.

OK.

But first, let's prepare three permutations, which will be responsible for handling this data changes.

So it's better to two mutations meal days since I am actually in the wrong field, I guess.

Let me see status here.

Excellence is here.

Yeah, here should be mutations after the actions should be meal.

They shouldn't make sure you have your nesting at this property.

So mutation has to be on the same level as the actions and at the same level as the state.

Any mistake here can result into that issue.

So mutations here and will call these mutations, said Preregister is processing, said the register

is processing the other mutation will be set register error, set register error as you know, be mutations

and mutation function will receive a state as the first value.

The first argument, the second one will be the data are payload.

We consent.

So in the case of its processing, it will be is processing value in a case of an error.

This will be an error of value and then simply connect to the state to the register that is processing

and the US is processing the same bit here.

State register does not error equal error like this.

OK, so embarrassing state register is processing, so basically accusing state a register is processing

and setting the value that I'm not sending right now, but I will be sending it very soon.

As you can see here, we are getting here out.

If you want to simplify, you just get to get out and simply get it here.

OK, just call here.

Get out.

And this line can remove.

Now, when somebody will call these pages that are immediately would like to set here, registries processing

through natural disaster is is empty.

So I hear comet meaning to the secretary's comet from the context of other comet able to commit here

our actions, you can copy them.

So first action transmutation would like to comet.

It'll be said registries processing.

I'll sit here and I will say I am processing register true.

Then, Eleanor Comet, that set produced an error that register error.

OK.

And I will say here, this is empty error because they don't have any error yet.

We are just starting the legislative process.

This is just a cleanup.

OK, so in the case, we got previously registered error and we want to register again.

We would like to clean up the data, so register error will be empty again.

OK, Elliot, we don't need a bill anymore to alert.

What we'll do instead in the catch block here as a council error error message, we donate to council.

Look, anything, I will remove it.

I will committed.

Rather, I will say here, said register error and will provide the error message.

OK.

And in the bottle, the case has been the catch, the error or going to be successfully registered,

the user who would like to set its processing to false.

You can handle this in the final block.

Finally, Block is called always doesn't matter if you get error or you will be successful with the

register, you will always execute the finally block and finally block you can commit.

Set register its processing.

Dough falls, OK, guys, and that's basically it.

Now we would like to get this data to our page.

OK, so we need to compete at properties in our page and we would like to get his data and display them

so you will see that something is happening.

Let's do it.

Let's go to our pages that are.

OK, and look at how this computer properties above the metal, my photos out here computed it would

like to get here, Arora.

And its processing is processing, you need to wait on air date has already returned.

These we are accessing store, we are accessing state on the store, they are accessing user module.

We are accessing all the user module.

What?

They are testing register and are.

So used to be accessing the register and to air.

The same thing here, Star State user register and here is processing.

We will simplify there, that's a very long expression, as you can see.

OK, so let's save it, guys.

Let's see a template and simply display this data somewhere.

Let's say.

And this here as you have a paragraph.

OK should be formatted correctly from either lowly sparking up here, and let's right here.

Error call on, so this will be for error here.

The curly brackets will display error here and here will be processing like this and the brackets and

is processing.

So you'll see some data on the screen.

OK, let's save it back to browser refresh.

And you can see her error is empty, you don't have any error and processing is false.

S., A. L. Click here.

Sign up processing will be true.

Could see.

Sign up protesting is true.

And then it's false when it's done, but we don't see error, that's actually wrong.

But by the NRA, I have a double triple R here in the Iraqi war, it's my mistake here.

I have a triple R.

I should be does error.

OK, let me verify why.

Yeah, here is everything correct?

OK.

It doesn't misspelt.

OK, refresh, and you'll see error zero processing false suspicions, I look like sign up processing

will be true, then when it's finished will be false and then we'll display error because I'm not providing

any data to sign up processing through.

And now we have an error.

Perfect.

Whenever provide, here are some Kodak Theatre able to sign up.

Ed Miller is a pilot and the processing.

And we are getting better immediately.

But I will say up, be that some use that are, let's say, Test one at Gmail dot com that your password

test test, I will sign up processing true and the false and the error.

So we have successfully successfully registered.

OK, guys, so that's going to be it from this functionality.

You can go to the next lecture if you want to understand it, but if it's still something something

else to clear up, please stay here and I will provide you additional explanation.

So go step by step.

So we are dispatching just right, so there are pitching this election to get the greatest data here.

So first thing what we are doing, we are committing here mutations.

So they are saying he had said that instead of processing is true.

And so that is their error is empty.

Strings of this bill are coming into the state, right?

Pretty clear.

This means when Bill coming to the state, the truth here will be is processing will be true, an empty

string theory said here.

OK.

Then.

OK, then after.

Will execute this function.

But the function will be successfully executed.

They'll simply to jump into the final in the end, and it'll set here, protesting is false soil study

here.

Protesting is false.

This means they're just there has been done.

There are no errors.

So these men who had been successful in occasional executed days but will jump into the cage, look

here.

So there was an hour get the error message and it was said to the register.

So here in the edit, we'll have a message we will propagate towards their page to the consulate property

because the state is linked here.

OK, so we'll get also add here.

OK, and in the final block, which will be executed after the catch because they finally block is always

execute, it doesn't matter.

The try is successful or we will get the error to finally execute.

We all set here so that it starts processing is false because we are down rapidly to propagate this

value any longer.

We can sell it back to the false.

So in a case, because previously error, as you can see here.

We'll be keeping error state, as you thought you saw it when I was submitting the forms to have your

error.

So that's what I hear when I will register again.

Oh, let's say I will correct my data and I will click register again.

I would like to clean up the errors if I had them before, because in this case, maybe my register

will be successful and I don't want to display any error.

So that's why I'm cleaning them up beforehand.

And of course, I'm starting processing through again so I can display some load their icon or I can

disable buttons and so on.

So, guys, that's how it works and the questions today, you can ask what I think is working now,

well, let's continue in the next lecture.

Cheers.