‫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.