Build the back-end API with basic EF model

   dotnet tool install -g dotnet-ef --version 3.0.0

    dotnet build
    dotnet ef migrations add Initial
    dotnet ef database update
    ```

Commands Explained

| Command       |Description       |
| ------------- |-------------|
| `dotnet ef migrations add Initial` / `Add-Migration Initial` | generates code to create the initial database schema based on the model specified in 'ApplicationDbContext.cs'. `Initial` is the name of the migration.|  
| `dotnet ef database update` / `Update-Database` | creates the database      |

  >For more information on these commands and scaffolding in general, see [this tutorial](https://docs.microsoft.com/en-us/aspnet/core/tutorials/first-mvc-app/adding-model#add-initial-migration-and-update-the-database).

  >If your database ever gets in a bad state and you'd like to reset things, you can use `dotnet ef database drop` followed by `dotnet ef database update` to remove your database and run all migrations again.

## A quick look at the Weather Forecast Controller

First, open the `Controllers` folder and take a quick look at the `WeatherForecastController` . You'll see a simple function that corresponds to the HTTP GET verb. You'll see the output of this controller in a bit, but first we'll build our own API controller for the `Speakers` model class.

## Scaffolding an API Controller

### Using Visual Studio

1. Right-click the `Controllers` folder and select Add/Controller. Select "API Controller with actions, using Entity Framework".

![](/img/aspdotnetcore/confplanner/2/18.png " API Controller")

1. In the dialog, select the `Speaker` model for the Model Class, `ApplicationDbContext` for the "Data Context Class" and click the `Add` button.

   ![](/img/aspdotnetcore/confplanner/2/19.png)

### Using the cmd line

1. Install the "Microsoft.VisualStudio.Web.CodeGeneration.Design" package

    

``` console
    dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design --version 3.0.0
    ```

1. Install the `aspnet-codegenerator` global tool by running the following command:

    

``` console
    dotnet tool install -g dotnet-aspnet-codegenerator --version 3.0.0
    ```

> Note: You will need to close and reopen the console window to be able to use this tool.

2. Run the following in the project folder at the cmd line:

    

``` console
    dotnet aspnet-codegenerator controller -api -name SpeakersController -m Speaker -dc BackEnd.Models.ApplicationDbContext -outDir Controllers
    ```

## Testing the API using the Swashbuckle

In this section, we'll be adding documentation to our API using the Swashbuckle NuGet package.

[Swashbuckle. AspNetCore](https://github.com/domaindrivendev/swashbuckle.aspnetcore) is an open source project for generating Swagger documents for Web APIs that are built with ASP. NET Core.

[Swagger](https://swagger.io) is a machine readable representation of a RESTful API that enables support for interactive documentation, client SDK generation and discoverability.

Additional information on using Swashbuckle in ASP. NET Core is available in this tutorial: [ASP. NET Web API Help Pages using Swagger](https://docs.microsoft.com/en-us/aspnet/core/tutorials/web-api-help-pages-using-swagger)

1. Add a reference to the NuGet package `Swashbuckle.AspNetCore` version `5.0.0-rc4` .

    ![](/img/aspdotnetcore/confplanner/2/21.png)
    > This can be done from the command line using `dotnet add package Swashbuckle.AspNetCore --version 5.0.0-rc4` 

1. Add the Swashbuckle services in your `ConfigureServices` method:

    

``` csharp
    services.AddControllers();

    services.AddSwaggerGen(options =>
        options.SwaggerDoc("v1", new OpenApiInfo { Title = "Conference Planner API", Version = "v1" })
    );
    ```

    ![](/img/aspdotnetcore/confplanner/2/22.png)

1. Configure Swashbuckle by adding the following lines just before `UseRouting` in the `Configure` method in `Startup.cs` :

    

``` csharp
    app.UseSwagger();

    app.UseSwaggerUI(options =>
        options.SwaggerEndpoint("/swagger/v1/swagger.json", "Conference Planner API v1")
    );
    ```

    ![](/img/aspdotnetcore/confplanner/2/23.png)
    > ***Note:* Due to how the middleware and pipeline are structured, you'll want to place this before the `app.UseEndpoints()` statement.**

1. Add a redirect to the end of the pipeline that redirects to the swagger end point. 

   

``` csharp
   app.Run(context =>
   {
       context.Response.Redirect("/swagger");
       return Task.CompletedTask;
   });