All language subtitles for 015 Making the API Better_ Advanced Filtering_Downloadly.ir_en

So the filter feature that we have

implemented right now already works great,

but in this video we wanna take it to the next level

by allowing some even more complex queries.

So right now a user can only filter the documents

by setting one key equal to a value, right?

But now, we actually want to also implement

the greater than, the greater or equal than,

the less than, and the less or equal than operators.

So instead of just having equal,

we want to actually be able to, for example,

say duration greater or equal than five,

and not just equal, all right?

And so that makes everything a bit more complex.

Now, before writing any code, I will actually

do the exercise of writing out the query

how it should look like in MongoDB.

So what would the filter object actually look like?

And let's write it here as a comment,

and again, just as an exercise.

So the object would look a bit like this,

so difficulty, start with that one, set to easy,

and then duration; and now remember that when

we want to use an operator, we need to start another object.

And then for the greater or equal than operator

we use it like this, to five, right, remember that?

So this is how we would manually write

the filter object for the query that we just specified.

Now let's actually go back to Postman

so that I can show you a very kind of standard way

of writing a query string including these operators.

And we do it like this, so before the equals sign

we open up the brackets and then in here

we write the operator, so in this case

greater than or equal, and that's it.

And so basically like this, we add a third part

to the key value pair, so we have the key,

the value, and now also the operator.

And we use again these brackets

in order to specify the operator.

So again, that is a standard way

and so let's now actually go ahead

and take a look at the query string that Express gives us

and so just like before, let's actually

log a reg dot query to the console,

log reg dot query, all right.

And so let's take a look what our query object

is gonna look like when we specify

the query string like this.

All right, now the first thing that you notice

is that we get an error here,

but don't worry about that for now.

So what I'm interested here, is this object,

and so let me actually go ahead and copy it here.

All right, so what do you notice here?

Well, what we see here is that the query object

looks almost identical to the filter object

that we wrote manually, the only difference

is that in this one we have the MongoDB operator sign here.

So that's really the only thing that's missing here

in front of this operator name.

Okay, and so the solution for this

is to basically replace all the operators like this

with their correspondent MongoDB operators,

so basically adding this dollar sign here, okay.

So let's now implement that,

and in fact we do it somewhere up here,

let's actually add some more comments here.

So filtering that we did in the last lecture,

now here let's add some advanced filtering,

and so that's the code that we're gonna write now.

Now let's put this code here right at the top, all right.

Then this code here we don't really need

but I still want to keep it here

so let's put it just here at the end.

And then just this code here as a reference

just to make sure that we know what we're doing here.

All right, and so now that we know

what we need to do here, it is actually

just a simple Javascript problem.

And the way I'm solving it is this,

so first I'm gonna convert the object to a string

so query string equals JSON dot stringify of query object,

and so now I can use that query string

to use the replace function on it.

All right, and so what I want to replace now

is the gte with dollar sign gte,

and then also some other operator.

So the ones we want to replace are

greater than or equal, greater than,

less than or equal, and less than,

and there are a couple ways in which we can do it,

but I'm gonna use a regular expression.

And for me personally, regular expressions

are one of the most difficult concepts in Javascript

and actually in general in programming.

So usually when I need to do something like this,

I simply go on Stack Overflow or just Google around

to find the right solution for the problem

that I'm trying to solve, all right.

And so what we want to do now here

is to basically match one of these four words

and then replace it with the same words

but with the dollar sign in front.

And so the regular expression to

find one of these four words goes like this;

so we open up these parenthesis and then we write

the operators, so gte or gt or lte or lt.

And then we also need to add this \b before and after,

and that's because we only want to match these exact words.

So imagine there's a word which has lt in it,

then we of course do not want to match that

we only want to match if it is this exact word,

without any other string around it.

And so this regular expression that I have here

will take care of that, and actually there is

one piece missing and that is this g flag here

which means that it will actually happen multiple times.

So if we have like two or three operators

or even all of them, then it will replace all of them.

And without this g here, it would only

replace the first occurrence, so this one is very important.

Now, what do we actually want to replace it with?

Well, the replace method actually

accepts a callback which is very powerful,

and this callback has as the first argument,

the matched word, or the matched string.

So we can pass match into that callback function

and what we return from this callback is the new string

that will replace the old one, okay?

So let's do a template string here,

and so we want to replace the match

with dollar sign match, okay, so this is here

the part of the template string syntax.

So this here is this match, and then

we want to put the dollar sign in front of that.

And now just to make sure, let's actually log it

to the console and actually want the object back,

so JSON dot parse the query string.

All right, let me just go ahead and clear this here

so that you can see the results a bit better.

So again, we get this error here

and that's of course because MongoDB

cannot really use the query string or

the query object as we have it right now.

And here we have the two results

and you actually see that our result

is the exact same as before and so

something here is clearly not working.

So let's try to figure out what that is.

And here the regular expression looks just fine,

everything looks fine here, ah, but okay,

the problem is that I'm replacing it in the string

but then I'm not saving it anywhere.

And so actually we want to save it back to the query string.

So let's change this here to a let,

so that it can then mutate the data

and so let's say, query string, oh sorry.

So, query string equals the query string replaced,

just like before, so what I was forgetting is simply to

actually save the result here back into the variable.

Let's try that again, and now it's working.

So now we have the dollar sign

in front of the operator, great.

Okay, so it works, let's get rid of these comments here

and now finally, all we have to do is to actually here

not use the query object but just use this.

So JSON.parse query string, and of course

if you do not have any operator in the query string

then everything will work just fine.

It will simply not find any of these four operators there

but that's no problem, it will then

simply not replace anything.

And also let's go ahead and try this out

and it's taking a bit of time but indeed

it came back with three results,

and so let's now check if they're actually correct.

So the duration should be greater or equal than five,

and this one here is duration of five,

this has a duration of nine, which is

greater than or equal than five,

and so it's actually working, the difficulty is still easy

and so what it means is that the code

that we just implemented works just fine.

Perfect, now let's just for the fun of it

add another parameter up there,

so let's filter for the price now as well.

So this one has almost 2000, then 1100, this one has 300.

So let's now filter for prices less than a thousand,

or less than a thousand five hundred.

And price, and now again our brackets,

and we use less than 1500, and all right, send that.

And what do we get here, oh, now we only have two results.

And indeed, the prices here, 397, and here 1197,

and so the one before that was 2000 is now gone.

So we filtered that one out as well

using again the operator that we just implemented.

And we could now filter for all kinds of stuff here

but you get the point, and so yeah,

we implemented our kind of advanced filtering here

at this point, which now even accepts these four operators.

Now in the real world, we would then have to

write some documentation, basically in order to allow

the user to know which kinds of operation

they can do on our API, right?

So again, ideally we would completely document our API,

specifying which requests can be made

using which htp methods, and then also

what kind of filtering or sorting,

or all these features, which of them are available

and how they can use it, right?

Now, in our case we of course will not do that

but again, don't forget that if you're really implementing

an API that is gonna be used by someone else,

then you must really do this kind of documentation.

But anyway, let's now move on to our next video

and implement a sorting functionality.