In the previous video we saw how under-posting was breaking our validation,

let's explore how we can resolve this issue.

Let's take a look at out Entry model class.

Adding required attributes to the Date, ActivityId, Duration,

and Intensity properties, unfortunately won't make a difference.

The Required attribute ensures that a property has a value, but

the default values for these property data types are in fact valid values.

In order for the required attribute to have the desired effect,

we need to change these properties to their corresponding nullable types.

But this classes' primary concern is to define the entry type in our EF

unity data model.

In this particular situation it doesn't feel right to change this class

in order to solve a problem with our API.

Also, if this class is being used across multiple projects,

changing a property's data type could break code throughout our solution.

The workaround that I'm going to employ, is to create a DTO,

a Data Transfer Object.

And update our entries controller post and

put methods to bind to the DTO instead of the entry model.

Having an entry DTO class will give us a way to define the properties using

nullable types, all without changing the entry model class.

Let's start by editing a folder for our DTO class to live in.

Right click on the Treehouse.FitnessFrog.Spa project and

select Add > NewFolder, let's name the folder Dto.

Now let's add a class to our new folder.

I'll name the class EntryDto.

Now we need to add our properties, which for

the most part will be one to one of the properties on the entry model class.

Public int Id { get; set;}.

Public DateTime?

Date { get; set; }.

public int?

ActivityId { get; set; }.

Public decimal?

Duration { get; set; }.

Public Entry, and let's add a using directive to the TreehouseFitnessFrog

shared model's namespace, and this will be of type IntensityLevel,

which is the enumeration defined in the entry model.

Add a question mark so it's nullable as well, and

the name of the property is Intensity.

Then public bool, Exclude { get; set; }.

And lastly, public string Notes { get; set; }..

Okay, now that we have our properties, we can add our data annotation attributes.

The Date, ActivityId, Duration and

Intensity properties all need required attributes.

And adding using directive for the system component model data annotation namespace.

Okay, so that was for the Date property,

now we need to add a required attribute for ActivityId, Duration, and Intensity.

I'm gonna add some extra white space, just to make this easier to read.

There, that looks better.

Let's review the Entry Model class to see if there's anything we might have missed.

That's just a display attribute, we can ignore that.

The Notes property is decorated with a max length data annotation attribute.

This limits the length of the string for

the Notes property to no more than 200 characters.

It'd be good for

this constraint to be enforced as a validation rule within our IAPI.

So, let's copy and paste this attribute to our DTO class property with the same name.

All right, now let's update the Entry's controller.

Scroll down to the Post action method.

And let's the method's parameter to be our DTO's type, so EntryDto.

Looks like we need to add a using directive for

our name space Teehouse.FitnessFrog.Spa.Dto.

There we go.

Now web API will bind to our EntryDto instead of the entry model.

That was easy enough to do, but

that broke the call to the entriesRepository Add method.

Which expects an instance of the Entry model class.

To resolve this issue, we need a method to convert our EntryDto class instance

to an Entry model class instance.

To do this, let's add a to model method to our DTO class.

Public, and for the return type we want this to be of type Entry,

our model class, and let's name the method ToModel().

We want to return a new instance of the Entry model class.

Then let's map each of our DTO properties to a model property.

So Id = Id, Date = Date, but

since this is a nullable date time property,

we need to actually set it to the Date.Value property.

Then ActivityId = ActivityId, and again the same thing,

it's a nullable integer so we want the Value property.

Duration = Duration.Value,

Intensity, Intensity.Value.

And then exclude this time, just Exclude,

because it's not a nullable type, and Notes = Notes.

Then back in our Entry controller, let's make a call to our new method

right before to the _entriesRepository.Add method.

Var, and let's use the variable name entryModel = entry.ToModel.

Now we can pass the entryModel variable into the Add method.

After the entry has been added to the database,

EF will set the model's ID property with a value that assigned by the database.

We'll want to update our DTO's ID property with that value.

So our call to the created method will have the new resource's id.

So entry.id = entryModel.id.

Before we test our changes let's also update the Put method.

To start, let's change our return type from void to IHttpActionResult.

And instead of binding to the Entry model class,

we wanna bind to our EntryDto class.

Then let's add an if statement to check to see if

the ModelState.IsValid property is false.

And if it is false we want to return a call to BadRequest,

parsing in our ModelState.

And just like with the repositories add method,

the update method expects an instance of the Entry model class.

So we need to call the ToModel method on our DTO object And

then lastly since we changed our void return type to IHttpActionResult,

we now need to explicitly return the no content status code.

We can do that by returning a call to the StatusCode method.

Passing in the System.Net.HttpStatusCode in numeration value of NoContent.

Next step let's test our changes.