Real world applications will almost always have some atypical behavior.

And our application is no exception.

Consider the sorting behavior we want for our API.

When the API serves the answers.

We'd like them to be ordered by votes first, and

then their updated app property.

This means that any time an answer is edited,

or voted on the order will be affected.

When an answer is saved to the database.

We want our application to sort the answers array

on the parent question document.

As we saw earlier Mongoose offers us a way to run code before

any save event with the pre method.

To save a child document in Mongoose you have to save its parent document.

Let's implement a pre save hook on the question schema.

Let's open up the models JS file, and under the question schema.

Let's set up a pre save callback

Inside, we'll sort the answers array before calling next.

There is a problem here though.

The default sort function supplied by JavaScript doesn't know how

we want to sort our array of answers.

If we leave it as is, it will sort the answer objects by the strings.

Resulting in the calling of two string on each of the answers,

which would all be identical.

It would be the string of object.

In other words, this line as it currently stands, does nothing at all.

To address this issue, we'll pass in a sorting function into the sorting method.

There's a link in the teacher's notes to read up on JavaScript arrays sort method.

In case this is the first time you're encountering it.

What our sorting function will need to do is compare two unsorted objects and

say which order they should go in.

The array sort method will then take that information and sort the array for us.

Let's put this sort function up at the top with the other variable declarations.

We'll call it sortAnswers.

This is a function that will accept two objects, a and b, and compare them.

It will need to return a negative.

If A should appear before B.

A zero to leave the order unchanged.

And a positive if A is to be sorted after B.

Let's think about how we want our answers ordered.

First, let's order them by vote.

So that the answers with the most votes appear at the top of the list

if the votes match.

Let's resort to ordering them by the last time they were updated.

The most recently updated answers appear above the least recent ones.

Let's start by ordering answers by votes.

We can return the value of A's votes subtracted from B's votes.

If A has more votes.

The number returned will be negative, and A will be placed before B.

If B has more votes.

The difference will be positive, and B will be placed before A.

If the votes match,

we want to place the answers with the most recent updated here first.

Let's first check the equality of votes.

Now, if the votes match.

We can compare the a.updatedAt to the b.updatedAt app.

And return the sorting order based on what we find there.

As you may or may not know,

JavaScript thinks about dir objects as numbers of milliseconds.

That have elapsed since midnight Thursday the 1st of January 1970.

More recent times are bigger in number than less recent.

So if a.updatedAt is greater

than b.updatedAt.

We'll want A to proceed B which requires a negative number to achieve.

So we'll return minus one.

Let's check the reverse of this case and reverse the elements order if it's true.

If both of these fall through.

We'll just return zero to leave the ordering unchanged.

There's a much simpler method we could use for comparing date objects.

Even though dates are objects in JavaScript.

You can subtract them.

When you do, you get the difference in milliseconds.

So we can return the value of A updatedAt subtracted from BupdatedAt.

[BLANK AUDIO] Just

as with votes this will order the larger, or later dates first.

Now we can supply the source answers function to the sort method.

Mongoose will now sort the answers right every time it is saved.

Keeping the state of our database up to date.

Now let's think about when the answer is updated.

We'll want to do a couple of things for this to happen.

We want to apply the updates to unanswered document.

And we also want the answers updated property to be the current time.

Let's do this with an instance method.

So we can call it directly on the answer when we want to update it.

Although the answer schemas declaration.

Let's create an instance method called update.

We want the update method to accept two parameters.

An update subject and a callback for when the operation is completed.

Make sure you create this method above the question schema declaration.

Where the answerschema becomes a sub document, or else you'll get an error.

Remember that we learned to write instance methods

by placing the property on the methods property on the answer schema.

Mongoose gives us an alternative way to create instance methods.

So let's use that here to see in action.

Instead of setting a property of methods on the schema we can call the method

method.

Passing in two parameters.

The first, a string of the name of the method you want to create.

And then the second, a function that you want to become the actual method.

We can't name our instance method Save.

That's because there's already an instance method called Saved.

And overwriting it will conflict with Mongoose internal logic in

unpredictable ways.

The first thing we'll want to do is merge the updates into the answer document.

We can do this with object.assign.

We'll pass in the document first referenced by this.

Then the updates object.

And then we want to set a fresh date on the updated app.

We can pass that in as a third parameter, and objects assigned will match that too.

After that, we'll need to save the parent document.

In other words, the question associated with the answer.

To access the question, we can use the answers parent method.

Since the save is the last thing we want to do.

We can pass in the callback as a parameter.

There's just one other addition we'll need to make on the answer schema.

A vote instance method to help with translating strings from

the URL into math that moves the counts up or down.

Let's start with the function signature,

which is almost identical to the last instance method.

Since we've all ready validated the string that is passed into the vote parameter.

There are only two possibilities.

If the vote is equal to up.

We want to add one to the votes.

If it's down.

It's minus one.

And just like the last method call, we need to save the parent and

pass in the callback to save.

Our data modeling seems to be complete.

It would be nice to test what we've done so far.

Let's take the final step in building our API, and connect it to the database.

Then we can use Postman to test our fully functional routes.