Let's start with reviewing our project files by taking a look

at the EntriesController class.

I'll collapse the solution explorer window to make more room for the editor.

The EntriesController constructor is instantiating an instance of

the entriesRepository class,

which we'll be using throughout this course to manage our data.

We'll take a look at our repositories in just a bit.

Our controller contains an index action method for our list page.

Shortly, we'll take a closer look at this method and its associated view.

We also have add,

edit, And delete action methods.

We'll be making changes to these methods as we add functionality to our web app.

Notice how the edit and

delete action methods both accept an ID parameter of type int.

The question mark following the data type indicates that the data type is nullable.

Meaning that the ID parameter can have a value of null.

For more information about nullable types, see the teacher's notes.

Making our ID parameter nullable, allows the entries/edit and

entries/delete pass to be successfully routed to our action methods.

If we didn't allow nulls, MVC would throw a routing error.

Instead, we're checking to see if the ID parameter is null and

returning a 400 BadRequest HTTPStatusCode in

order to reject requests that don't include an ID parameter.

This is in contrast to returning a 404 Not Found HTTPStatusCode

when an entry can't be found for the provided ID parameter value.

We'll extend these action methods to do exactly that in a later video.

See the teachers notes for more information about HTTPStatusCodes.

Next, let's take a look at our views.

We have four views, one each for our action methods Add [SOUND],

Index [SOUND], Edit [SOUND], and Delete [SOUND].

These action method and view names map to our crowd action.

Ad maps to create, index maps to read,

edit maps to update, and delete maps to well, delete.

Here's our entries index view.

We'll take a closer look at this view in the next video.

The edit and delete views are just stubs at this point.

In the ad view, contains a basic HTML only version of our add entry form.

We'll be updating all of these views throughout this course.

In the shared folder is our layout page,

which provides the overall look and feel for each of our pages.

For more information about MVC layout pages, see the teacher's notes.

Let's finish up our review by taking a look at our project's models and

repositories.

The models are located in the Models folder.

We have two models, activity and entry.

The activity model contains an activity type enum that defines the list of

available activities.

Further down in the class, we can see its properties.

Id and Name.

The entry model also contains an enumeration,

intensity level which defines the available intensity levels.

Low, medium and high.

The entry model has more properties than the activity model.

ID, date, ActivityId,

Activity, Duration,

Intensity, Exclude and Notes.

You might wonder why we need two properties for the activity.

An activity ID property of type int and an activity property of type activity.

We'll be taking a closer look at these properties in later videos.

Now let's look at the repositories in the Data folder.

We have one for entries, and another for activities.

The activities repository class contains just a single method, get activities.

The entries repository class is a little more involved.

Let's toggle all of the class outlining by pressing Ctrl+M followed by Ctrl+L.

Then we can hold down the Ctrl key and

press M twice to expand the namespace and class sections.

Now we can see that the class contains the following methods.

GetEntries, GetEntry.

AddEntry, UpdateEntry and DeleteEntry.

Both of these repositories use the collections that are defined

in the data class to provide the data for our web app.

As mentioned earlier, data would typically be persisted using a database or

an API given that the code in the repository in data classes

should be thought of as a work around instead of a best practice.

If you're using GitHub, let's commit our project files.

Switch back to the Team Explorer panel.

Then under the Project section, click the Changes button.

Under the Changes section, we can see a list of the files that we've added to our

repo, I'll

enter a commit message of added project files.

And then click the down arrow on the Commit All button and

select the Commit All and Push option.

This will commit and push our changes to the remote server.

Next up, we'll take a closer look at our entries list page controller and view.