Changes to snapshot and session2

Author: davidfowl

docs/2. Build out BackEnd and Refactor.md

@@ -16,21 +16,25 @@ In this session, we'll add the rest of our models and controllers that expose th
 ### Adding the ConferenceDTO project via the Command Line
 1. Open a command prompt and navigate to the root `ConferencePlanner` directory.
 1. Run the following command: 
-   ```
+   ```console
    dotnet new classlib -o ConferenceDTO -f netstandard2.0
    ```
 1. Next we'll need to add a reference to the ConferenceDTO project from the BackEnd project. From the command line, navigate to the BackEnd project directory and execute the following command:
-   ```
-   dotnet add reference ../ConferenceDTO/ConferenceDTO.csproj
+   ```console
+   dotnet add reference ../ConferenceDTO
    ```
 1. Add the ConferenceDTO project to the solution:
-   ```
-   dotnet sln add ConferenceDTO\ConferenceDTO.csproj
+   ```console
+   dotnet sln add ConferenceDTO
    ```
 
 ## Refactoring the Speaker model into the ConferenceDTO project
 1. Copy the `Speaker.cs` class from the *BackEnd* application into the root of the new ConferenceDTO project, and change the namespace to `ConferenceDTO`.
-1. The data annotations references can't be resolved to a missing NuGet package. Add a reference to `System.ComponentModel.Annotations` version `4.5.0`. When the package restore completes, you should see that your data annotations are now resolved.
+1. The data annotations references should be broken at this point, to resovle it, we need to add a nuget the missing NuGet package into the `ConferenceDTO` project.
+1. Add a reference to the NuGet package `System.ComponentModel.Annotations` version `4.5.0`.
+    > This can be done from the command line using `dotnet add package System.ComponentModel.Annotations --version 4.5.0`
+
+1. When the package restore completes, you should see that your data annotations are now resolved.
 1. Go back to the *BackEnd* application and modify the code in `Speaker.cs` as shown:
    ```csharp
    public class Speaker : ConferenceDTO.Speaker
@@ -123,10 +127,11 @@ We've got several more models to add, and unfortunately it's a little mechanical
    ```
 
 ## Creating Derived Models in the BackEnd project
-We're not going to create our EF models directly from the *ConferenceDTO* classes. Instead, we'll create some composite classes such as *SessionSpeaker*, since these will map more closely to what our application will be working with.
+We're not going to create our EF models directly from the `ConferenceDTO` classes. Instead, we'll create some composite classes such as `SessionSpeaker`, since these will map more closely to what our application will be working with.
 
 We're also going to take this opportunity to rename the `Models` directory in the *BackEnd* project to `Data` since it no longer just contains models.
 1. Right-click the `Models` directory and select `Rename`, changing the name to `Data`.
+    > Note: If you are using Visual Studio, you can use refactoring to rename the namespace.
 1. Add a `SessionSpeaker.cs` class to the `Data` directory with the following code:
    ```csharp
    using System;
@@ -148,9 +153,10 @@ We're also going to take this opportunity to rename the `Models` directory in th
        }
    }
    ```
- 1. Add an `SessionAttendee.cs` class with the following code:
+1. Add an `SessionAttendee.cs` class with the following code:
+ 
    ```csharp
-    using System;
+   using System;
     using System.Collections.Generic;
     using System.Linq;
     using System.Threading.Tasks;
@@ -200,31 +206,30 @@ We're also going to take this opportunity to rename the `Models` directory in th
        }
    }
    ```
-1. Modify the `Speaker.cs` class we wrote previously to make the following two changes: update to the namespace to match our directory rename, and add a referece to the `SessionSpeaker` composite class:
+1. Add a `Track.cs` class with the following code:
    ```csharp
    using System;
    using System.Collections.Generic;
-   
+   using System.ComponentModel.DataAnnotations;
+
    namespace BackEnd.Data
    {
-       public class Speaker : ConferenceDTO.Speaker
+       public class Track : ConferenceDTO.Track
        {
-           public virtual ICollection<SessionSpeaker> SessionSpeakers { get; set; } = new List<SessionSpeaker>();
+           public virtual ICollection<Session> Sessions { get; set; }
        }
    }
    ```
-
-1. Add a `Track.cs` class with the following code:
+1. Modify the `Speaker.cs` class we wrote previously to make the following two changes: update to the namespace to match our directory rename, and add a referece to the `SessionSpeaker` composite class:
    ```csharp
    using System;
    using System.Collections.Generic;
-   using System.ComponentModel.DataAnnotations;
-
+   
    namespace BackEnd.Data
    {
-       public class Track : ConferenceDTO.Track
+       public class Speaker : ConferenceDTO.Speaker
        {
-           public virtual ICollection<Session> Sessions { get; set; }
+           public virtual ICollection<SessionSpeaker> SessionSpeakers { get; set; } = new List<SessionSpeaker>();
        }
    }
    ```
@@ -277,7 +282,7 @@ Okay, now we need to update our `ApplicationDbContext` so Entity Framework knows
 ## Add a new database migration
 
 ### Visual Studio: Package Manager Console 
-1. Run the following commands in the Package Manager Console
+1. Run the following commands in the Package Manager Console (specify the `BackEnd` project)
    ```console
    Add-Migration Refactor
    Update-Database
@@ -291,100 +296,99 @@ Okay, now we need to update our `ApplicationDbContext` so Entity Framework knows
    ```
 1. Now take a deep breath and run the application and navigate to `/swagger`. You should see the Swagger UI.
 
->Save point for above code changes is [here](/save-points/2a-Refactor-to-ConferenceDTO/ConferencePlanner)
-
 ## Updating the Speakers API controller
 
 1. Modify the query for the `GetSpeakers()` method as shown below:
    ```csharp
-    var speakers = await _context.Speakers.AsNoTracking()
-                            .Include(s => s.SessionSpeakers)
-                                .ThenInclude(ss => ss.Session)
-                            .ToListAsync();
-    return speakers;
+   var speakers = await _context.Speakers.AsNoTracking()
+                           .Include(s => s.SessionSpeakers)
+                               .ThenInclude(ss => ss.Session)
+                           .ToListAsync();
+   return speakers;
    ```
-1. While the above will work, this is directly returning our model class. A better practice is to return an output model class. Create a `SpeakerResponse.cs` class in the *ConferenceDTO* project with the following code:
+1. While the above will work, this is directly returning our model class. A better practice is to return an output model class. Create a `SpeakerResponse.cs` class in the `ConferenceDTO` project with the following code:
    ```csharp
-    using System;
-    using System.Collections.Generic;
-    using System.Text;
+   using System;
+   using System.Collections.Generic;
+   using System.Text;
 
-    namespace ConferenceDTO
-    {
-        public class SpeakerResponse : Speaker
-        {
-            public ICollection<Session> Sessions { get; set; } = new List<Session>();
-        }
-    }
+   namespace ConferenceDTO
+   {
+       public class SpeakerResponse : Speaker
+       {
+           public ICollection<Session> Sessions { get; set; } = new List<Session>();
+       }
+   }
    ```
 1. Now we'll add a utility method to map between these classes. In the *BackEnd* project, create an `Infrastructure` directory. Add a class named `EntityExtensions.cs` with the following mapping code:
    ```csharp
-    using BackEnd.Data;
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-    using System.Threading.Tasks;
+   using BackEnd.Data;
+   using System;
+   using System.Collections.Generic;
+   using System.Linq;
+   using System.Threading.Tasks;
 
-    namespace BackEnd.Data
-    {
-        public static class EntityExtensions
-        {
-            public static ConferenceDTO.SpeakerResponse MapSpeakerResponse(this Speaker speaker) =>
-                new ConferenceDTO.SpeakerResponse
-                {
-                    Id = speaker.Id,
-                    Name = speaker.Name,
-                    Bio = speaker.Bio,
-                    WebSite = speaker.WebSite,
-                    Sessions = speaker.SessionSpeakers?
-                        .Select(ss =>
-                            new ConferenceDTO.Session
-                            {
-                                Id = ss.SessionId,
-                                Title = ss.Session.Title
-                            })
-                        .ToList()
-                };
-        }
-    }
+   namespace BackEnd.Data
+   {
+       public static class EntityExtensions
+       {
+           public static ConferenceDTO.SpeakerResponse MapSpeakerResponse(this Speaker speaker) =>
+               new ConferenceDTO.SpeakerResponse
+               {
+                   Id = speaker.Id,
+                   Name = speaker.Name,
+                   Bio = speaker.Bio,
+                   WebSite = speaker.WebSite,
+                   Sessions = speaker.SessionSpeakers?
+                       .Select(ss =>
+                           new ConferenceDTO.Session
+                           {
+                               Id = ss.SessionId,
+                               Title = ss.Session.Title
+                           })
+                       .ToList()
+               };
+       }
+   }
    ```
 1. Now we can update the `GetSpeakers()` method of the *SpeakersController* so that it returns our response model. Update the last few lines so that the method reads as follows:
    ```csharp
-    [HttpGet]
-    public async Task<ActionResult<List<ConferenceDTO.SpeakerResponse>>> GetSpeakers()
-    {
-        var speakers = await _context.Speakers.AsNoTracking()
-                                        .Include(s => s.SessionSpeakers)
-                                            .ThenInclude(ss => ss.Session)
-                                        .Select(s => s.MapSpeakerResponse())
-                                        .ToListAsync();
-        return speakers;
-    }
+   [HttpGet]
+   public async Task<ActionResult<List<ConferenceDTO.SpeakerResponse>>> GetSpeakers()
+   {
+       var speakers = await _context.Speakers.AsNoTracking()
+                                       .Include(s => s.SessionSpeakers)
+                                           .ThenInclude(ss => ss.Session)
+                                       .Select(s => s.MapSpeakerResponse())
+                                       .ToListAsync();
+       return speakers;
+   }
    ```
 1. Update the `GetSpeaker()` method to use our mapped response models as follows:
    ```csharp
-    [HttpGet("{id}")]
-    public async Task<ActionResult<ConferenceDTO.SpeakerResponse>> GetSpeaker(int id)
-    {
-        var speaker = await _context.Speakers.AsNoTracking()
-                                        .Include(s => s.SessionSpeakers)
-                                            .ThenInclude(ss => ss.Session)
-                                        .SingleOrDefaultAsync(s => s.Id == id);
-        if (speaker == null)
-        {
-            return NotFound();
-        }
-        return speaker.MapSpeakerResponse();
-    }
+   [HttpGet("{id}")]
+   public async Task<ActionResult<ConferenceDTO.SpeakerResponse>> GetSpeaker(int id)
+   {
+       var speaker = await _context.Speakers.AsNoTracking()
+                                       .Include(s => s.SessionSpeakers)
+                                           .ThenInclude(ss => ss.Session)
+                                       .SingleOrDefaultAsync(s => s.Id == id);
+       if (speaker == null)
+       {
+           return NotFound();
+       }
+       return speaker.MapSpeakerResponse();
+   }
    ```
-1. Remove the other actions.
+1. Remove the other actions (`PutSpeaker`, `PostSpeaker`, `DeleteSpeaker`), on the `SpeakersController`.
+
+## Adding the remaining API Controllers and DTOs
 
-## Adding the remaining API Controllers
-1. Add the following response DTO classes from [the save point folder](/save-points/2b-BackEnd-completed/ConferencePlanner/ConferenceDTO)
+1. Add the following response DTO classes from [the save point folder](/save-points/2-BackEnd-completed/ConferencePlanner/ConferenceDTO)
    - `AttendeeResponse`
    - `SessionResponse`
-1. Update the `EntityExtensions` class with the extra mapping methods from [the save point folder](/save-points/2b-BackEnd-completed/ConferencePlanner/BackEnd/Infrastructure)
-1. Copy the following controllers from [the save point folder](/save-points/2b-BackEnd-completed/ConferencePlanner/BackEnd/Controllers) into the current project's `BackEnd/Controllers` directory:
+1. Update the `EntityExtensions` class with the extra mapping methods from [the save point folder](/save-points/2-BackEnd-completed/ConferencePlanner/BackEnd/Infrastructure)
+1. Copy the following controllers from [the save point folder](/save-points/2-BackEnd-completed/ConferencePlanner/BackEnd/Controllers) into the current project's `BackEnd/Controllers` directory:
    - `SessionsController`
    - `AttendeesController`
 
@@ -466,7 +470,7 @@ Okay, now we need to update our `ApplicationDbContext` so Entity Framework knows
 ## Adding Conference Upload support
 1. Copy the `DataLoader.cs` class from [here](/src/BackEnd/Data/DataLoader.cs) into the `Data` directory of the `BackEnd` project.
 1. Copy the `SessionizeLoader.cs` and `DevIntersectionLoader.cs` classes from [here](/src/BackEnd/Data/) into the current project's `/src/BackEnd/Data/` directory. 
- > Note: We have data loaders from the two conference series where this workshop has been presented most; you can update this to plug in your own conference file format.
+    > Note: We have data loaders from the two conference series where this workshop has been presented most; you can update this to plug in your own conference file format.
 1. To improve the UI for upload, turn on the option to display enums as strings by changing `AddSwaggerGen` in `Startup.cs` to the following:
     ```c#
     services.AddSwaggerGen(options =>

save-points/2-BackEnd-completed/ConferencePlanner/BackEnd/BackEnd.csproj

@@ -1,18 +1,22 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.2</TargetFramework>
-    <AspNetCoreHostingModel>InProcess</AspNetCoreHostingModel>
-  </PropertyGroup>
-
+    <TargetFramework>netcoreapp3.0</TargetFramework>
+  </PropertyGroup>  
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.App" />
-    <PackageReference Include="Microsoft.AspNetCore.Razor.Design" Version="2.2.0" PrivateAssets="All" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.1" />
-    <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="2.2.0" />
-    <PackageReference Include="Swashbuckle.AspNetCore" Version="4.0.1" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="2.2.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="2.2.4">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="3.0.0-preview5-19264-04">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="5.0.0-rc2" />
   </ItemGroup>
-
+  
   <ItemGroup>
     <ProjectReference Include="..\ConferenceDTO\ConferenceDTO.csproj" />
   </ItemGroup>