React to kpm subcommand renaming

MusicStore.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 14
-VisualStudioVersion = 14.0.22112.0
+VisualStudioVersion = 14.0.22230.1
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".nuget", ".nuget", "{44621553-AA7D-4893-8834-79582A7D8348}"
 EndProject

NuGet.Config

@@ -1,7 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <configuration>
   <packageSources>
-    <add key="AspNetVNext" value="https://www.myget.org/F/aspnetrelease/api/v2" />
+    <add key="AspNetVNext" value="https://www.myget.org/F/aspnetvnext/api/v2" />
     <add key="NuGet.org" value="https://nuget.org/api/v2/" />
+    <add key="AzureADNighty" value="http://www.myget.org/F/azureadwebstacknightly"/>
   </packageSources>
 </configuration>

README.md

@@ -1,43 +1,34 @@
 # MusicStore application
 
-This project is part of ASP.NET vNext. You can find samples, documentation and getting started instructions for ASP.NET vNext at the [Home](https://github.com/aspnet/home) repo.
+This project is part of ASP.NET 5.0. You can find samples, documentation and getting started instructions for ASP.NET 5.0 at the [Home](https://github.com/aspnet/home) repo.
 
-* Clone the repository
-
-### Run the application on Helios:
+## Run the application on Helios:
 * If you have Visual Studio 2015
-	1. Open MusicStore.sln in Visual Studio 2015 and run the individual applications on ```Helios```.
+	1. Open MusicStore.sln in Visual Studio 2015 and run the individual applications on `IIS Express`.
 * If you don't have Visual Studio 2015
-	1. Open a command prompt and cd ```\src\MusicStore\```
-	2. Execute ``kpm restore```
-	3. Execute ```Helios.cmd``` to launch the app on IISExpress from command line (Application started at URL **http://localhost:5001/**).
-	   NOTE: App and Tests require Visual Studio 2015 LocalDB on the machine to run. Please change the connection string if you don't have Visual studio 2015 installed.
+	1. Open a command prompt and cd `\src\MusicStore\`.
+	2. Execute `kpm restore`.
+	3. Execute `Helios.cmd` to launch the app on IISExpress from command line (Application started at URL **http://localhost:5001/**).
+	   NOTE: App and tests require Visual Studio 2015 LocalDB on the machine to run.
 
-### Run on WebListener/Kestrel:
-* Open a command prompt and cd ```\src\MusicStore\```
+## Run on WebListener/Kestrel:
+* Open a command prompt and cd `\src\MusicStore\`.
 * **[WebListener]:**
-	4. Run ```k WebListener``` (Application started at URL **http://localhost:5002/**)
+	4. Run `k web` (Application started at URL **http://localhost:5002/**).
 * **[Kestrel]:**
-	5. Run ```k Kestrel``` (Application started at URL **http://localhost:5004/**)
+	5. Run `k kestrel` (Application started at URL **http://localhost:5004/**).
 * **[CustomHost]:**
-	6. Run ```k run``` (This hosts the app in a console application - Application started at URL **http://localhost:5003/**)
+	6. Run `k run` (This hosts the app in a console application - Application started at URL **http://localhost:5003/**).
 
-### To run the sample on Mac/Mono:
-* Follow [Home](https://github.com/aspnet/home) instructions to install mono, kvm on Mac
-* Open a command prompt and cd ```\src\MusicStore\```
-* Execute ``kpm restore```
-* Try `k kestrel` to run the application
+## To run the sample on Mac/Mono:
+* Follow [Home](https://github.com/aspnet/home) instructions to install mono, kvm on Mac.
+* Open a command prompt and cd `\src\MusicStore\`.
+* Execute `kpm restore`.
+* Try `k kestrel` to run the application.
 **NOTE: On Mono since SQL client is not available the sample uses an InMemoryStore to run the application. So the changes that you make will not be persisted.
 
-### Run Tests:
-* Open a command prompt and cd ```\test\E2ETests\```
-* Execute ``kpm restore```
-* Set KRE_ENV environment variable to "SocialTesting"
-* Run ```k test```
-
 ###NTLM authentication
-More information at src/MusicStore/StartupNtlmAuthentication.cs
-**NOTE: Ntlm authentication works only on desktop CLR right now.
+More information at src/MusicStore/StartupNtlmAuthentication.cs.
 
-### Note:
-1. Application is started on different ports on different hosts. To change the port or URL modify ```Helios.cmd``` or project.json commands section in case of self-host and customhost.
+###OpenIdConnect authentication
+More information at src/MusicStore/StartupOpenIdConnect.cs.

build.sh

@@ -28,7 +28,7 @@ if test ! -d packages/KoreBuild; then
 fi
 
 if ! type k > /dev/null 2>&1; then
-    source setup/kvm.sh
+    source packages/KoreBuild/build/kvm.sh
 fi
 
 if ! type k > /dev/null 2>&1; then

src/MusicStore.Spa/Apis/AlbumsApiController.cs

@@ -1,8 +1,10 @@
-using System.Linq;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.AspNet.Mvc;
 using MusicStore.Infrastructure;
 using MusicStore.Models;
+using MusicStore.Spa.Infrastructure;
 
 namespace MusicStore.Apis
 {
@@ -17,17 +19,25 @@ public AlbumsApiController(MusicStoreContext storeContext)
         }
 
         [HttpGet]
+        [NoCache]
         public async Task<ActionResult> Paged(int page = 1, int pageSize = 50, string sortBy = null)
         {
+            await _storeContext.Genres.LoadAsync();
+            await _storeContext.Artists.LoadAsync();
+
             var albums = await _storeContext.Albums
                 //.Include(a => a.Genre)
                 //.Include(a => a.Artist)
-                .ToPagedListAsync(page, pageSize, sortBy, a => a.Title);
+                .ToPagedListAsync(page, pageSize, sortBy,
+                    a => a.Title,                                    // sortExpression
+                    SortDirection.Ascending,                         // defaultSortDirection
+                    a => SimpleMapper.Map(a, new AlbumResultDto())); // selector
 
             return Json(albums);
         }
 
         [HttpGet("all")]
+        [NoCache]
         public async Task<ActionResult> All()
         {
             var albums = await _storeContext.Albums
@@ -36,10 +46,11 @@ public async Task<ActionResult> All()
                 .OrderBy(a => a.Title)
                 .ToListAsync();
 
-            return Json(albums);
+            return Json(albums.Select(a => SimpleMapper.Map(a, new AlbumResultDto())));
         }
 
         [HttpGet("mostPopular")]
+        [NoCache]
         public async Task<ActionResult> MostPopular(int count = 6)
         {
             count = count > 0 && count < 20 ? count : 6;
@@ -48,60 +59,71 @@ public async Task<ActionResult> MostPopular(int count = 6)
                 .Take(count)
                 .ToListAsync();
 
-            return Json(albums);
+            // TODO: Move the .Select() to end of albums query when EF supports it
+            return Json(albums.Select(a => SimpleMapper.Map(a, new AlbumResultDto())));
         }
 
         [HttpGet("{albumId:int}")]
+        [NoCache]
         public async Task<ActionResult> Details(int albumId)
         {
-            // TODO: Remove this when EF supports related entity loading
-            await _storeContext.Artists.ToListAsync();
-            await _storeContext.Genres.ToListAsync();
+            await _storeContext.Genres.LoadAsync();
+            await _storeContext.Artists.LoadAsync();
 
-            // TODO: Make async when EF supports SingleOrDefaultAsync
-            var album = _storeContext.Albums
+            var album = await _storeContext.Albums
                 //.Include(a => a.Artist)
                 //.Include(a => a.Genre)
-                .SingleOrDefault(a => a.AlbumId == albumId);
+                .Where(a => a.AlbumId == albumId)
+                .SingleOrDefaultAsync();
+
+            var albumResult = SimpleMapper.Map(album, new AlbumResultDto());
+
+            // TODO: Get these from the related entities when EF supports that again, i.e. when .Include() works
+            //album.Artist.Name = (await _storeContext.Artists.SingleOrDefaultAsync(a => a.ArtistId == album.ArtistId)).Name;
+            //album.Genre.Name = (await _storeContext.Genres.SingleOrDefaultAsync(g => g.GenreId == album.GenreId)).Name;
 
             // TODO: Add null checking and return 404 in that case
 
-            return Json(album);
+            return Json(albumResult);
         }
 
         [HttpPost]
-        [Authorize("ManageStore", "Allowed")]
-        public async Task<ActionResult> CreateAlbum()
+        [Authorize("app-ManageStore")]
+        public async Task<ActionResult> CreateAlbum([FromBody]AlbumChangeDto album)
         {
-            var album = new Album();
-
-            //if (!await TryUpdateModelAsync(album, excludeProperties: new[] { "Genre", "Artist", "OrderDetails" }))
-            if (!await TryUpdateModelAsync(album))
+            if (!ModelState.IsValid)
             {
                 // Return the model errors
                 return new ApiResult(ModelState);
             }
 
             // Save the changes to the DB
-            await _storeContext.Albums.AddAsync(album);
+            var dbAlbum = new Album();
+            await _storeContext.Albums.AddAsync(SimpleMapper.Map(album, dbAlbum));
             await _storeContext.SaveChangesAsync();
 
             // TODO: Handle missing record, key violations, concurrency issues, etc.
 
             return new ApiResult
             {
-                Data = album.AlbumId,
+                Data = dbAlbum.AlbumId,
                 Message = "Album created successfully."
             };
         }
 
         [HttpPut("{albumId:int}/update")]
-        [Authorize("ManageStore", "Allowed")]
-        public async Task<ActionResult> UpdateAlbum(int albumId)
+        [Authorize("app-ManageStore")]
+        public async Task<ActionResult> UpdateAlbum(int albumId, [FromBody]AlbumChangeDto album)
         {
-            var album = _storeContext.Albums.SingleOrDefault(a => a.AlbumId == albumId);
+            if (!ModelState.IsValid)
+            {
+                // Return the model errors
+                return new ApiResult(ModelState);
+            }
 
-            if (album == null)
+            var dbAlbum = await _storeContext.Albums.SingleOrDefaultAsync(a => a.AlbumId == albumId);
+
+            if (dbAlbum == null)
             {
                 return new ApiResult
                 {
@@ -110,14 +132,8 @@ public async Task<ActionResult> UpdateAlbum(int albumId)
                 };
             }
 
-            //if (!TryUpdateModel(album, prefix: null, includeProperties: null, excludeProperties: new[] { "Genre", "Artist", "OrderDetails" }))
-            if (!await TryUpdateModelAsync(album))
-            {
-                // Return the model errors
-                return new ApiResult(ModelState);
-            }
-
             // Save the changes to the DB
+            SimpleMapper.Map(album, dbAlbum);
             await _storeContext.SaveChangesAsync();
 
             // TODO: Handle missing record, key violations, concurrency issues, etc.
@@ -129,11 +145,11 @@ public async Task<ActionResult> UpdateAlbum(int albumId)
         }
 
         [HttpDelete("{albumId:int}")]
-        [Authorize("ManageStore", "Allowed")]
+        [Authorize("app-ManageStore")]
         public async Task<ActionResult> DeleteAlbum(int albumId)
         {
-            //var album = await _storeContext.Albums.SingleOrDefaultAsync(a => a.AlbumId == albumId);
-            var album = _storeContext.Albums.SingleOrDefault(a => a.AlbumId == albumId);
+            var album = await _storeContext.Albums.SingleOrDefaultAsync(a => a.AlbumId == albumId);
+            //var album = _storeContext.Albums.SingleOrDefault(a => a.AlbumId == albumId);
 
             if (album != null)
             {
@@ -150,5 +166,44 @@ public async Task<ActionResult> DeleteAlbum(int albumId)
                 Message = "Album deleted successfully."
             };
         }
+
+        [BuddyType(typeof(Album))]
+        public class AlbumChangeDto
+        {
+            public int GenreId { get; set; }
+
+            public int ArtistId { get; set; }
+
+            public string Title { get; set; }
+
+            public decimal Price { get; set; }
+
+            public string AlbumArtUrl { get; set; }
+        }
+
+        public class AlbumResultDto : AlbumChangeDto
+        {
+            public AlbumResultDto()
+            {
+                Artist = new ArtistResultDto();
+                Genre = new GenreResultDto();
+            }
+
+            public int AlbumId { get; set; }
+
+            public ArtistResultDto Artist { get; private set; }
+
+            public GenreResultDto Genre { get; private set; }
+        }
+
+        public class ArtistResultDto
+        {
+            public string Name { get; set; }
+        }
+
+        public class GenreResultDto
+        {
+            public string Name { get; set; }
+        }
     }
 }

src/MusicStore.Spa/Apis/GenresApiController.cs

@@ -2,6 +2,7 @@
 using System.Threading.Tasks;
 using Microsoft.AspNet.Mvc;
 using MusicStore.Models;
+using MusicStore.Spa.Infrastructure;
 
 namespace MusicStore.Apis
 {
@@ -52,6 +53,7 @@ public async Task<ActionResult> GenreMenuList(int count = 9)
         }
 
         [HttpGet("{genreId:int}/albums")]
+        [NoCache]
         public async Task<ActionResult> GenreAlbums(int genreId)
         {
             var albums = await _storeContext.Albums

src/MusicStore.Spa/Controllers/AccountController.cs

@@ -37,18 +37,19 @@ public async Task<IActionResult> Login(LoginViewModel model, string returnUrl)
         {
             if (ModelState.IsValid == true)
             {
-                var signInStatus = await SignInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, shouldLockout: false);
-                switch (signInStatus)
+                var result = await SignInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, shouldLockout: false);
+                if (result.Succeeded)
+                {
+                    return RedirectToLocal(returnUrl);
+                }
+                if (result.IsLockedOut)
+                {
+                    ModelState.AddModelError("", "User is locked out, try again later.");
+                }
+                else
                 {
-                    case SignInStatus.Success:
-                        return RedirectToLocal(returnUrl);
-                    case SignInStatus.LockedOut:
-                        ModelState.AddModelError("", "User is locked out, try again later.");
-                        return View(model);
-                    case SignInStatus.Failure:
-                    default:
-                        ModelState.AddModelError("", "Invalid username or password.");
-                        return View(model);
+                    ModelState.AddModelError("", "Invalid username or password.");
+                    return View(model);
                 }
             }
 
@@ -138,7 +139,7 @@ private void AddErrors(IdentityResult result)
         {
             foreach (var error in result.Errors)
             {
-                ModelState.AddModelError("", error);
+                ModelState.AddModelError("", error.Description);
             }
         }
 

src/MusicStore.Spa/Controllers/PageController.cs

@@ -13,7 +13,7 @@ public IActionResult Home()
         }
 
         [HttpGet("admin")]
-        [Authorize("ManageStore", "Allowed")]
+        [Authorize("app-ManageStore")]
         public IActionResult Admin()
         {
             return View("/Pages/Admin.cshtml");