├── Bloggie.Web
    ├── Views
    │   ├── _ViewStart.cshtml
    │   ├── _ViewImports.cshtml
    │   ├── Account
    │   │   ├── AccessDenied.cshtml
    │   │   ├── Login.cshtml
    │   │   └── Register.cshtml
    │   ├── Home
    │   │   ├── Privacy.cshtml
    │   │   └── Index.cshtml
    │   ├── Shared
    │   │   ├── _ValidationScriptsPartial.cshtml
    │   │   ├── Error.cshtml
    │   │   ├── _Layout.cshtml.css
    │   │   └── _Layout.cshtml
    │   ├── AdminTags
    │   │   ├── Add.cshtml
    │   │   ├── Edit.cshtml
    │   │   └── List.cshtml
    │   ├── AdminBlogPosts
    │   │   ├── List.cshtml
    │   │   ├── Add.cshtml
    │   │   └── Edit.cshtml
    │   ├── AdminUsers
    │   │   └── List.cshtml
    │   └── Blogs
    │   │   └── Index.cshtml
    ├── wwwroot
    │   ├── favicon.ico
    │   ├── js
    │   │   └── site.js
    │   ├── css
    │   │   └── site.css
    │   └── lib
    │   │   ├── jquery
    │   │       └── LICENSE.txt
    │   │   ├── jquery-validation
    │   │       └── LICENSE.md
    │   │   ├── bootstrap
    │   │       ├── LICENSE
    │   │       └── dist
    │   │       │   └── css
    │   │       │       ├── bootstrap-reboot.min.css
    │   │       │       ├── bootstrap-reboot.rtl.min.css
    │   │       │       ├── bootstrap-reboot.rtl.css
    │   │       │       └── bootstrap-reboot.css
    │   │   └── jquery-validation-unobtrusive
    │   │       ├── LICENSE.txt
    │   │       └── jquery.validate.unobtrusive.min.js
    ├── appsettings.Development.json
    ├── Repositories
    │   ├── IImageRespository.cs
    │   ├── IUserRepository.cs
    │   ├── IBlogPostCommentRepository.cs
    │   ├── IBlogPostLikeRepository.cs
    │   ├── IBlogPostRepository.cs
    │   ├── ITagRepository.cs
    │   ├── UserRepository.cs
    │   ├── BlogPostCommentRepository.cs
    │   ├── BlogPostLikeRepository.cs
    │   ├── CloudinaryImageRepository.cs
    │   ├── BlogPostRepository.cs
    │   └── TagRepository.cs
    ├── Models
    │   ├── ViewModels
    │   │   ├── AddLikeRequest.cs
    │   │   ├── User.cs
    │   │   ├── EditTagRequest.cs
    │   │   ├── BlogComment.cs
    │   │   ├── HomeViewModel.cs
    │   │   ├── AddTagRequest.cs
    │   │   ├── UserViewModel.cs
    │   │   ├── LoginViewModel.cs
    │   │   ├── RegisterViewModel.cs
    │   │   ├── AddBlogPostRequest.cs
    │   │   ├── EditBlogPostRequest.cs
    │   │   └── BlogDetailsViewModel.cs
    │   ├── ErrorViewModel.cs
    │   └── Domain
    │   │   ├── BlogPostLike.cs
    │   │   ├── Tag.cs
    │   │   ├── BlogPostComment.cs
    │   │   └── BlogPost.cs
    ├── Data
    │   ├── BloggieDbContext.cs
    │   └── AuthDbContext.cs
    ├── appsettings.json
    ├── Bloggie.Web.csproj
    ├── Controllers
    │   ├── ImagesController.cs
    │   ├── BlogPostLikeController.cs
    │   ├── HomeController.cs
    │   ├── AdminUsersController.cs
    │   ├── AccountController.cs
    │   ├── BlogsController.cs
    │   ├── AdminTagsController.cs
    │   └── AdminBlogPostsController.cs
    ├── Properties
    │   └── launchSettings.json
    ├── Migrations
    │   ├── 20230305212914_Adding like functionality.cs
    │   ├── 20230306005821_adding comments.cs
    │   ├── 20230216015207_Initial Migration.cs
    │   ├── 20230216015207_Initial Migration.Designer.cs
    │   ├── 20230305212914_Adding like functionality.Designer.cs
    │   ├── BloggieDbContextModelSnapshot.cs
    │   ├── 20230306005821_adding comments.Designer.cs
    │   └── AuthDb
    │   │   ├── 20230227010526_Creating Auth Db.cs
    │   │   └── AuthDbContextModelSnapshot.cs
    └── Program.cs
├── Bloggie.sln
├── .gitattributes
└── .gitignore


/Bloggie.Web/Views/_ViewStart.cshtml:
--------------------------------------------------------------------------------
1 | @{
2 |     Layout = "_Layout";
3 | }
4 | 


--------------------------------------------------------------------------------
/Bloggie.Web/wwwroot/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sameer8saini/BloggieMVC/HEAD/Bloggie.Web/wwwroot/favicon.ico


--------------------------------------------------------------------------------
/Bloggie.Web/Views/_ViewImports.cshtml:
--------------------------------------------------------------------------------
1 | @using Bloggie.Web
2 | @using Bloggie.Web.Models
3 | @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
4 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Views/Account/AccessDenied.cshtml:
--------------------------------------------------------------------------------
1 | 
2 | @{
3 | }
4 | 
5 | 
6 | <div class="container my-5">
7 |     <h2>You are not allowed to access this page!</h2>
8 | </div>


--------------------------------------------------------------------------------
/Bloggie.Web/appsettings.Development.json:
--------------------------------------------------------------------------------
1 | {
2 |   "Logging": {
3 |     "LogLevel": {
4 |       "Default": "Information",
5 |       "Microsoft.AspNetCore": "Warning"
6 |     }
7 |   }
8 | }
9 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Views/Home/Privacy.cshtml:
--------------------------------------------------------------------------------
1 | @{
2 |     ViewData["Title"] = "Privacy Policy";
3 | }
4 | <h1>@ViewData["Title"]</h1>
5 | 
6 | <p>Use this page to detail your site's privacy policy.</p>
7 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Repositories/IImageRespository.cs:
--------------------------------------------------------------------------------
1 | namespace Bloggie.Web.Repositories
2 | {
3 |     public interface IImageRespository
4 |     {
5 |         Task<string> UploadAsync(IFormFile file);
6 |     }
7 | }
8 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Views/Shared/_ValidationScriptsPartial.cshtml:
--------------------------------------------------------------------------------
1 | <script src="~/lib/jquery-validation/dist/jquery.validate.min.js"></script>
2 | <script src="~/lib/jquery-validation-unobtrusive/jquery.validate.unobtrusive.min.js"></script>
3 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/ViewModels/AddLikeRequest.cs:
--------------------------------------------------------------------------------
1 | namespace Bloggie.Web.Models.ViewModels
2 | {
3 |     public class AddLikeRequest
4 |     {
5 |         public Guid BlogPostId { get; set; }
6 |         public Guid UserId { get; set; }
7 |     }
8 | }
9 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/ErrorViewModel.cs:
--------------------------------------------------------------------------------
1 | namespace Bloggie.Web.Models
2 | {
3 |     public class ErrorViewModel
4 |     {
5 |         public string? RequestId { get; set; }
6 | 
7 |         public bool ShowRequestId => !string.IsNullOrEmpty(RequestId);
8 |     }
9 | }


--------------------------------------------------------------------------------
/Bloggie.Web/Repositories/IUserRepository.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.AspNetCore.Identity;
 2 | 
 3 | namespace Bloggie.Web.Repositories
 4 | {
 5 |     public interface IUserRepository
 6 |     {
 7 |         Task<IEnumerable<IdentityUser>> GetAll();
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/Bloggie.Web/wwwroot/js/site.js:
--------------------------------------------------------------------------------
1 | // Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
2 | // for details on configuring this project to bundle and minify static web assets.
3 | 
4 | // Write your JavaScript code.
5 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/Domain/BlogPostLike.cs:
--------------------------------------------------------------------------------
 1 | namespace Bloggie.Web.Models.Domain
 2 | {
 3 |     public class BlogPostLike
 4 |     {
 5 |         public Guid Id { get; set; }
 6 |         public Guid BlogPostId { get; set; }
 7 |         public Guid UserId { get; set; }
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/ViewModels/User.cs:
--------------------------------------------------------------------------------
 1 | namespace Bloggie.Web.Models.ViewModels
 2 | {
 3 |     public class User
 4 |     {
 5 |         public Guid Id { get; set; }
 6 |         public string Username { get; set; }
 7 |         public string EmailAddress { get; set; }
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/ViewModels/EditTagRequest.cs:
--------------------------------------------------------------------------------
 1 | namespace Bloggie.Web.Models.ViewModels
 2 | {
 3 |     public class EditTagRequest
 4 |     {
 5 |         public Guid Id { get; set; }
 6 |         public string Name { get; set; }
 7 |         public string DisplayName { get; set; }
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/ViewModels/BlogComment.cs:
--------------------------------------------------------------------------------
 1 | namespace Bloggie.Web.Models.ViewModels
 2 | {
 3 |     public class BlogComment
 4 |     {
 5 |         public string Description { get; set; }
 6 |         public DateTime DateAdded { get; set; }
 7 |         public string Username { get; set; }
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/ViewModels/HomeViewModel.cs:
--------------------------------------------------------------------------------
 1 | using Bloggie.Web.Models.Domain;
 2 | 
 3 | namespace Bloggie.Web.Models.ViewModels
 4 | {
 5 |     public class HomeViewModel
 6 |     {
 7 |         public IEnumerable<BlogPost> BlogPosts { get; set; }
 8 | 
 9 |         public IEnumerable<Tag> Tags { get; set; }
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/Domain/Tag.cs:
--------------------------------------------------------------------------------
 1 | namespace Bloggie.Web.Models.Domain
 2 | {
 3 |     public class Tag
 4 |     {
 5 |         public Guid Id { get; set; }
 6 |         public string Name { get; set; }
 7 |         public string DisplayName { get; set; }
 8 |         public ICollection<BlogPost> BlogPosts { get; set; }
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/ViewModels/AddTagRequest.cs:
--------------------------------------------------------------------------------
 1 | using System.ComponentModel.DataAnnotations;
 2 | 
 3 | namespace Bloggie.Web.Models.ViewModels
 4 | {
 5 |     public class AddTagRequest
 6 |     {
 7 |         [Required]
 8 |         public string Name { get; set; }
 9 |         [Required]
10 |         public string DisplayName { get; set; }
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Repositories/IBlogPostCommentRepository.cs:
--------------------------------------------------------------------------------
 1 | using Bloggie.Web.Models.Domain;
 2 | 
 3 | namespace Bloggie.Web.Repositories
 4 | {
 5 |     public interface IBlogPostCommentRepository
 6 |     {
 7 |         Task<BlogPostComment> AddAsync(BlogPostComment blogPostComment);
 8 | 
 9 |         Task<IEnumerable<BlogPostComment>> GetCommentsByBlogIdAsync(Guid blogPostId);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/Domain/BlogPostComment.cs:
--------------------------------------------------------------------------------
 1 | namespace Bloggie.Web.Models.Domain
 2 | {
 3 |     public class BlogPostComment
 4 |     {
 5 |         public Guid Id { get; set; }
 6 |         public string Description { get; set; }
 7 |         public Guid BlogPostId { get; set; }
 8 |         public Guid UserId { get; set; }
 9 |         public DateTime DateAdded { get; set; }
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/ViewModels/UserViewModel.cs:
--------------------------------------------------------------------------------
 1 | namespace Bloggie.Web.Models.ViewModels
 2 | {
 3 |     public class UserViewModel
 4 |     {
 5 |         public List<User> Users { get; set; }
 6 | 
 7 |         public string Username { get; set; }
 8 |         public string Email { get; set; }
 9 |         public string Password { get; set; }
10 |         public bool AdminRoleCheckbox { get; set; }
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Repositories/IBlogPostLikeRepository.cs:
--------------------------------------------------------------------------------
 1 | using Bloggie.Web.Models.Domain;
 2 | 
 3 | namespace Bloggie.Web.Repositories
 4 | {
 5 |     public interface IBlogPostLikeRepository
 6 |     {
 7 |         Task<int> GetTotalLikes(Guid blogPostId);
 8 | 
 9 |         Task<IEnumerable<BlogPostLike>> GetLikesForBlog(Guid blogPostId);
10 | 
11 |         Task<BlogPostLike> AddLikeForBlog(BlogPostLike blogPostLike);
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/ViewModels/LoginViewModel.cs:
--------------------------------------------------------------------------------
 1 | using System.ComponentModel.DataAnnotations;
 2 | 
 3 | namespace Bloggie.Web.Models.ViewModels
 4 | {
 5 |     public class LoginViewModel
 6 |     {
 7 |         [Required]
 8 |         public string Username { get; set; }
 9 |         
10 |         [Required]
11 |         [MinLength(6, ErrorMessage = "Password has to be at least 6 characters")]
12 |         public string Password { get; set; }
13 | 
14 |         public string? ReturnUrl { get; set; }
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/Bloggie.Web/wwwroot/css/site.css:
--------------------------------------------------------------------------------
 1 | html {
 2 |   font-size: 14px;
 3 | }
 4 | 
 5 | @media (min-width: 768px) {
 6 |   html {
 7 |     font-size: 16px;
 8 |   }
 9 | }
10 | 
11 | .btn:focus, .btn:active:focus, .btn-link.nav-link:focus, .form-control:focus, .form-check-input:focus {
12 |   box-shadow: 0 0 0 0.1rem white, 0 0 0 0.25rem #258cfb;
13 | }
14 | 
15 | html {
16 |   position: relative;
17 |   min-height: 100%;
18 | }
19 | 
20 | body {
21 |   margin-bottom: 60px;
22 | }
23 | 
24 | 
25 | .blog-details-content img {
26 |     max-width: 100%;
27 | }


--------------------------------------------------------------------------------
/Bloggie.Web/Models/ViewModels/RegisterViewModel.cs:
--------------------------------------------------------------------------------
 1 | using System.ComponentModel.DataAnnotations;
 2 | 
 3 | namespace Bloggie.Web.Models.ViewModels
 4 | {
 5 |     public class RegisterViewModel
 6 |     {
 7 |         [Required]
 8 |         public string Username { get; set; }
 9 | 
10 |         [Required]
11 |         [EmailAddress]
12 |         public string Email { get; set; }
13 | 
14 |         [Required]
15 |         [MinLength(6, ErrorMessage = "Password has to be at least 6 characters")]
16 |         public string Password { get; set; }
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Repositories/IBlogPostRepository.cs:
--------------------------------------------------------------------------------
 1 | using Bloggie.Web.Models.Domain;
 2 | 
 3 | namespace Bloggie.Web.Repositories
 4 | {
 5 |     public interface IBlogPostRepository
 6 |     {
 7 |         Task<IEnumerable<BlogPost>> GetAllAsync();
 8 | 
 9 |         Task<BlogPost?> GetAsync(Guid id);
10 | 
11 |         Task<BlogPost?> GetByUrlHandleAsync(string urlHandle);
12 | 
13 |         Task<BlogPost> AddAsync(BlogPost blogPost);
14 | 
15 |         Task<BlogPost?> UpdateAsync(BlogPost blogPost);
16 | 
17 |         Task<BlogPost?> DeleteAsync(Guid id);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Data/BloggieDbContext.cs:
--------------------------------------------------------------------------------
 1 | using Bloggie.Web.Models.Domain;
 2 | using Microsoft.EntityFrameworkCore;
 3 | 
 4 | namespace Bloggie.Web.Data
 5 | {
 6 |     public class BloggieDbContext : DbContext
 7 |     {
 8 |         public BloggieDbContext(DbContextOptions<BloggieDbContext> options) : base(options)
 9 |         {
10 |         }
11 | 
12 |         public DbSet<BlogPost> BlogPosts { get; set; }
13 |         public DbSet<Tag> Tags { get; set; }
14 |         public DbSet<BlogPostLike> BlogPostLike { get; set; }
15 |         public DbSet<BlogPostComment> BlogPostComment { get; set; }
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/Bloggie.Web/appsettings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "Logging": {
 3 |     "LogLevel": {
 4 |       "Default": "Information",
 5 |       "Microsoft.AspNetCore": "Warning"
 6 |     }
 7 |   },
 8 |   "AllowedHosts": "*",
 9 |   "ConnectionStrings": {
10 |     "BloggieDbConnectionString": "Server=localhost\\MSSQLSERVER01;Database=BloggieDb;Trusted_Connection=True;TrustServerCertificate=Yes",
11 |     "BloggieAuthDbConnectionString": "Server=localhost\\MSSQLSERVER01;Database=BloggieAuthDb;Trusted_Connection=True;TrustServerCertificate=Yes"
12 |   },
13 |   "Cloudinary": {
14 |     "CloudName": "dt3yqdbnt",
15 |     "ApiKey": "885466236757527",
16 |     "ApiSecret": "mykHItxbsTebQ2AATwDK5sGvbC0"
17 |   }
18 | }
19 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Repositories/ITagRepository.cs:
--------------------------------------------------------------------------------
 1 | using Bloggie.Web.Models.Domain;
 2 | 
 3 | namespace Bloggie.Web.Repositories
 4 | {
 5 |     public interface ITagRepository
 6 |     {
 7 |         Task<IEnumerable<Tag>> GetAllAsync(
 8 |             string? searchQuery = null,
 9 |             string? sortBy = null,
10 |             string? sortDirection = null,
11 |             int pageNumber = 1,
12 |             int pageSize = 100);
13 | 
14 |         Task<Tag?> GetAsync(Guid id);
15 | 
16 |         Task<Tag> AddAsync(Tag tag);
17 | 
18 |         Task<Tag?> UpdateAsync(Tag tag);
19 | 
20 |         Task<Tag?> DeleteAsync(Guid id);
21 | 
22 |         Task<int> CountAsync();
23 | 
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Bloggie.Web.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk.Web">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFramework>net7.0</TargetFramework>
 5 |     <Nullable>enable</Nullable>
 6 |     <ImplicitUsings>enable</ImplicitUsings>
 7 |   </PropertyGroup>
 8 | 
 9 |   <ItemGroup>
10 |     <PackageReference Include="CloudinaryDotNet" Version="1.20.0" />
11 |     <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="7.0.3" />
12 |     <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="7.0.3" />
13 |     <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="7.0.3">
14 |       <PrivateAssets>all</PrivateAssets>
15 |       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
16 |     </PackageReference>
17 |   </ItemGroup>
18 | 
19 | </Project>
20 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/Domain/BlogPost.cs:
--------------------------------------------------------------------------------
 1 | namespace Bloggie.Web.Models.Domain
 2 | {
 3 |     public class BlogPost
 4 |     {
 5 |         public Guid Id { get; set; }
 6 |         public string Heading { get; set; }
 7 |         public string PageTitle { get; set; }
 8 |         public string Content { get; set; }
 9 |         public string ShortDescription { get; set; }
10 |         public string FeaturedImageUrl { get; set; }
11 |         public string UrlHandle { get; set; }
12 |         public DateTime PublishedDate { get; set; }
13 |         public string Author { get; set; }
14 |         public bool Visible { get; set; }
15 | 
16 |         // Navigation property
17 |         public ICollection<Tag> Tags { get; set; }
18 | 
19 |         public ICollection<BlogPostLike> Likes { get; set; }
20 |         public ICollection<BlogPostComment> Comments { get; set; }
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/ViewModels/AddBlogPostRequest.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.AspNetCore.Mvc.Rendering;
 2 | 
 3 | namespace Bloggie.Web.Models.ViewModels
 4 | {
 5 |     public class AddBlogPostRequest
 6 |     {
 7 |         public string Heading { get; set; }
 8 |         public string PageTitle { get; set; }
 9 |         public string Content { get; set; }
10 |         public string ShortDescription { get; set; }
11 |         public string FeaturedImageUrl { get; set; }
12 |         public string UrlHandle { get; set; }
13 |         public DateTime PublishedDate { get; set; }
14 |         public string Author { get; set; }
15 |         public bool Visible { get; set; }
16 | 
17 | 
18 |         // Display tags
19 |         public IEnumerable<SelectListItem> Tags { get; set; }
20 |         // Collect Tag
21 |         public string[] SelectedTags { get; set; } = Array.Empty<string>();
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/ViewModels/EditBlogPostRequest.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.AspNetCore.Mvc.Rendering;
 2 | 
 3 | namespace Bloggie.Web.Models.ViewModels
 4 | {
 5 |     public class EditBlogPostRequest
 6 |     {
 7 |         public Guid Id { get; set; }
 8 |         public string Heading { get; set; }
 9 |         public string PageTitle { get; set; }
10 |         public string Content { get; set; }
11 |         public string ShortDescription { get; set; }
12 |         public string FeaturedImageUrl { get; set; }
13 |         public string UrlHandle { get; set; }
14 |         public DateTime PublishedDate { get; set; }
15 |         public string Author { get; set; }
16 |         public bool Visible { get; set; }
17 | 
18 | 
19 |         // Display tags
20 |         public IEnumerable<SelectListItem> Tags { get; set; }
21 |         // Collect Tag
22 |         public string[] SelectedTags { get; set; } = Array.Empty<string>();
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Repositories/UserRepository.cs:
--------------------------------------------------------------------------------
 1 | using Bloggie.Web.Data;
 2 | using Microsoft.AspNetCore.Identity;
 3 | using Microsoft.EntityFrameworkCore;
 4 | 
 5 | namespace Bloggie.Web.Repositories
 6 | {
 7 |     public class UserRepository : IUserRepository
 8 |     {
 9 |         private readonly AuthDbContext authDbContext;
10 | 
11 |         public UserRepository(AuthDbContext authDbContext)
12 |         {
13 |             this.authDbContext = authDbContext;
14 |         }
15 | 
16 | 
17 |         public async Task<IEnumerable<IdentityUser>> GetAll()
18 |         {
19 |             var users = await authDbContext.Users.ToListAsync();
20 | 
21 |             var superAdminUser = await authDbContext.Users
22 |                 .FirstOrDefaultAsync(x => x.Email == "superadmin@bloggie.com");
23 | 
24 |             if (superAdminUser is not null)
25 |             {
26 |                 users.Remove(superAdminUser);
27 |             }
28 | 
29 |             return users;
30 |         }
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Views/Shared/Error.cshtml:
--------------------------------------------------------------------------------
 1 | @model ErrorViewModel
 2 | @{
 3 |     ViewData["Title"] = "Error";
 4 | }
 5 | 
 6 | <h1 class="text-danger">Error.</h1>
 7 | <h2 class="text-danger">An error occurred while processing your request.</h2>
 8 | 
 9 | @if (Model.ShowRequestId)
10 | {
11 |     <p>
12 |         <strong>Request ID:</strong> <code>@Model.RequestId</code>
13 |     </p>
14 | }
15 | 
16 | <h3>Development Mode</h3>
17 | <p>
18 |     Swapping to <strong>Development</strong> environment will display more detailed information about the error that occurred.
19 | </p>
20 | <p>
21 |     <strong>The Development environment shouldn't be enabled for deployed applications.</strong>
22 |     It can result in displaying sensitive information from exceptions to end users.
23 |     For local debugging, enable the <strong>Development</strong> environment by setting the <strong>ASPNETCORE_ENVIRONMENT</strong> environment variable to <strong>Development</strong>
24 |     and restarting the app.
25 | </p>
26 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Models/ViewModels/BlogDetailsViewModel.cs:
--------------------------------------------------------------------------------
 1 | using Bloggie.Web.Models.Domain;
 2 | 
 3 | namespace Bloggie.Web.Models.ViewModels
 4 | {
 5 |     public class BlogDetailsViewModel
 6 |     {
 7 |         public Guid Id { get; set; }
 8 |         public string Heading { get; set; }
 9 |         public string PageTitle { get; set; }
10 |         public string Content { get; set; }
11 |         public string ShortDescription { get; set; }
12 |         public string FeaturedImageUrl { get; set; }
13 |         public string UrlHandle { get; set; }
14 |         public DateTime PublishedDate { get; set; }
15 |         public string Author { get; set; }
16 |         public bool Visible { get; set; }
17 |         public ICollection<Tag> Tags { get; set; }
18 | 
19 |         public int TotalLikes { get; set; }
20 | 
21 |         public bool Liked { get; set; }
22 |         public string CommentDescription { get; set; }
23 | 
24 |         public IEnumerable<BlogComment> Comments { get; set; }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Views/AdminTags/Add.cshtml:
--------------------------------------------------------------------------------
 1 | @model Bloggie.Web.Models.ViewModels.AddTagRequest
 2 | @{
 3 | }
 4 | 
 5 | 
 6 | <div class="bg-secondary bg-opacity-10 py-2">
 7 |     <div class="container">
 8 |         <h1>Add New Tag - Admin Functionality</h1>
 9 |     </div>
10 | </div>
11 | 
12 | <div class="container py-5">
13 |     <form method="post">
14 |         <div class="mb-3">
15 |             <label class="form-label">Name</label>
16 |             <input type="text" class="form-control" id="name" asp-for="Name" required />
17 |             <span class="text-danger" asp-validation-for="Name"></span>
18 |         </div>
19 | 
20 |         <div class="mb-3">
21 |             <label class="form-label">Display Name</label>
22 |             <input type="text" class="form-control" id="displayName" asp-for="DisplayName" required />
23 |             <span class="text-danger" asp-validation-for="DisplayName"></span>
24 |         </div>
25 | 
26 |         <div class="mb-3">
27 |             <button type="submit" class="btn btn-dark">Submit</button>
28 |         </div>
29 |     </form>
30 | </div>


--------------------------------------------------------------------------------
/Bloggie.Web/Controllers/ImagesController.cs:
--------------------------------------------------------------------------------
 1 | using Bloggie.Web.Repositories;
 2 | using Microsoft.AspNetCore.Http;
 3 | using Microsoft.AspNetCore.Mvc;
 4 | using System.Net;
 5 | 
 6 | namespace Bloggie.Web.Controllers
 7 | {
 8 |     [Route("api/[controller]")]
 9 |     [ApiController]
10 |     public class ImagesController : ControllerBase
11 |     {
12 |         private readonly IImageRespository imageRespository;
13 | 
14 |         public ImagesController(IImageRespository imageRespository)
15 |         {
16 |             this.imageRespository = imageRespository;
17 |         }
18 | 
19 | 
20 |         [HttpPost]
21 |         public async Task<IActionResult> UploadAsync(IFormFile file)
22 |         {
23 |             // call a repository
24 |             var imageURL = await imageRespository.UploadAsync(file);
25 | 
26 |             if (imageURL == null)
27 |             {
28 |                 return Problem("Sometihng went wrong!", null, (int)HttpStatusCode.InternalServerError);
29 |             }
30 | 
31 |             return new JsonResult(new { link = imageURL });
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Repositories/BlogPostCommentRepository.cs:
--------------------------------------------------------------------------------
 1 | using Bloggie.Web.Data;
 2 | using Bloggie.Web.Models.Domain;
 3 | using Microsoft.EntityFrameworkCore;
 4 | 
 5 | namespace Bloggie.Web.Repositories
 6 | {
 7 |     public class BlogPostCommentRepository : IBlogPostCommentRepository
 8 |     {
 9 |         private readonly BloggieDbContext bloggieDbContext;
10 | 
11 |         public BlogPostCommentRepository(BloggieDbContext bloggieDbContext)
12 |         {
13 |             this.bloggieDbContext = bloggieDbContext;
14 |         }
15 | 
16 |         public async Task<BlogPostComment> AddAsync(BlogPostComment blogPostComment)
17 |         {
18 |             await bloggieDbContext.BlogPostComment.AddAsync(blogPostComment);
19 |             await bloggieDbContext.SaveChangesAsync();
20 |             return blogPostComment;
21 |         }
22 | 
23 |         public async Task<IEnumerable<BlogPostComment>> GetCommentsByBlogIdAsync(Guid blogPostId)
24 |         {
25 |             return await bloggieDbContext.BlogPostComment.Where(x => x.BlogPostId == blogPostId)
26 |                 .ToListAsync();
27 |         }
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Views/Shared/_Layout.cshtml.css:
--------------------------------------------------------------------------------
 1 | /* Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
 2 | for details on configuring this project to bundle and minify static web assets. */
 3 | 
 4 | a.navbar-brand {
 5 |   white-space: normal;
 6 |   text-align: center;
 7 |   word-break: break-all;
 8 | }
 9 | 
10 | a {
11 |   color: #0077cc;
12 | }
13 | 
14 | .btn-primary {
15 |   color: #fff;
16 |   background-color: #1b6ec2;
17 |   border-color: #1861ac;
18 | }
19 | 
20 | .nav-pills .nav-link.active, .nav-pills .show > .nav-link {
21 |   color: #fff;
22 |   background-color: #1b6ec2;
23 |   border-color: #1861ac;
24 | }
25 | 
26 | .border-top {
27 |   border-top: 1px solid #e5e5e5;
28 | }
29 | .border-bottom {
30 |   border-bottom: 1px solid #e5e5e5;
31 | }
32 | 
33 | .box-shadow {
34 |   box-shadow: 0 .25rem .75rem rgba(0, 0, 0, .05);
35 | }
36 | 
37 | button.accept-policy {
38 |   font-size: 1rem;
39 |   line-height: inherit;
40 | }
41 | 
42 | .footer {
43 |   position: absolute;
44 |   bottom: 0;
45 |   width: 100%;
46 |   white-space: nowrap;
47 |   line-height: 60px;
48 | }
49 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Properties/launchSettings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "iisSettings": {
 3 |     "windowsAuthentication": false,
 4 |     "anonymousAuthentication": true,
 5 |     "iisExpress": {
 6 |       "applicationUrl": "http://localhost:31681",
 7 |       "sslPort": 44370
 8 |     }
 9 |   },
10 |   "profiles": {
11 |     "http": {
12 |       "commandName": "Project",
13 |       "dotnetRunMessages": true,
14 |       "launchBrowser": true,
15 |       "applicationUrl": "http://localhost:5177",
16 |       "environmentVariables": {
17 |         "ASPNETCORE_ENVIRONMENT": "Development"
18 |       }
19 |     },
20 |     "Bloggiehttps": {
21 |       "commandName": "Project",
22 |       "dotnetRunMessages": true,
23 |       "launchBrowser": true,
24 |       "applicationUrl": "https://localhost:7100;http://localhost:5177",
25 |       "environmentVariables": {
26 |         "ASPNETCORE_ENVIRONMENT": "Development"
27 |       }
28 |     },
29 |     "IIS Express": {
30 |       "commandName": "IISExpress",
31 |       "launchBrowser": true,
32 |       "environmentVariables": {
33 |         "ASPNETCORE_ENVIRONMENT": "Development"
34 |       }
35 |     }
36 |   }
37 | }
38 | 


--------------------------------------------------------------------------------
/Bloggie.Web/wwwroot/lib/jquery/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | Copyright OpenJS Foundation and other contributors, https://openjsf.org/
 3 | 
 4 | Permission is hereby granted, free of charge, to any person obtaining
 5 | a copy of this software and associated documentation files (the
 6 | "Software"), to deal in the Software without restriction, including
 7 | without limitation the rights to use, copy, modify, merge, publish,
 8 | distribute, sublicense, and/or sell copies of the Software, and to
 9 | permit persons to whom the Software is furnished to do so, subject to
10 | the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be
13 | included in all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
19 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
20 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/Bloggie.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 17
 4 | VisualStudioVersion = 17.4.33213.308
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bloggie.Web", "Bloggie.Web\Bloggie.Web.csproj", "{DBF32560-328F-4B27-847E-174F7FA7B644}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		Release|Any CPU = Release|Any CPU
12 | 	EndGlobalSection
13 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
14 | 		{DBF32560-328F-4B27-847E-174F7FA7B644}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
15 | 		{DBF32560-328F-4B27-847E-174F7FA7B644}.Debug|Any CPU.Build.0 = Debug|Any CPU
16 | 		{DBF32560-328F-4B27-847E-174F7FA7B644}.Release|Any CPU.ActiveCfg = Release|Any CPU
17 | 		{DBF32560-328F-4B27-847E-174F7FA7B644}.Release|Any CPU.Build.0 = Release|Any CPU
18 | 	EndGlobalSection
19 | 	GlobalSection(SolutionProperties) = preSolution
20 | 		HideSolutionNode = FALSE
21 | 	EndGlobalSection
22 | 	GlobalSection(ExtensibilityGlobals) = postSolution
23 | 		SolutionGuid = {62678387-B999-4A52-8295-B9AB2EAD0EA8}
24 | 	EndGlobalSection
25 | EndGlobal
26 | 


--------------------------------------------------------------------------------
/Bloggie.Web/wwwroot/lib/jquery-validation/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | =====================
 3 | 
 4 | Copyright Jörn Zaefferer
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in
14 | all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/Bloggie.Web/wwwroot/lib/bootstrap/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2011-2021 Twitter, Inc.
 4 | Copyright (c) 2011-2021 The Bootstrap Authors
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in
14 | all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/Bloggie.Web/wwwroot/lib/jquery-validation-unobtrusive/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) .NET Foundation and Contributors
 4 | 
 5 | All rights reserved.
 6 | 
 7 | Permission is hereby granted, free of charge, to any person obtaining a copy
 8 | of this software and associated documentation files (the "Software"), to deal
 9 | in the Software without restriction, including without limitation the rights
10 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 | copies of the Software, and to permit persons to whom the Software is
12 | furnished to do so, subject to the following conditions:
13 | 
14 | The above copyright notice and this permission notice shall be included in all
15 | copies or substantial portions of the Software.
16 | 
17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 | SOFTWARE.
24 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Repositories/BlogPostLikeRepository.cs:
--------------------------------------------------------------------------------
 1 | using Bloggie.Web.Data;
 2 | using Bloggie.Web.Models.Domain;
 3 | using Microsoft.EntityFrameworkCore;
 4 | 
 5 | namespace Bloggie.Web.Repositories
 6 | {
 7 |     public class BlogPostLikeRepository : IBlogPostLikeRepository
 8 |     {
 9 |         private readonly BloggieDbContext bloggieDbContext;
10 | 
11 |         public BlogPostLikeRepository(BloggieDbContext bloggieDbContext)
12 |         {
13 |             this.bloggieDbContext = bloggieDbContext;
14 |         }
15 | 
16 |         public async Task<BlogPostLike> AddLikeForBlog(BlogPostLike blogPostLike)
17 |         {
18 |             await bloggieDbContext.BlogPostLike.AddAsync(blogPostLike);
19 |             await bloggieDbContext.SaveChangesAsync();
20 |             return blogPostLike;
21 |         }
22 | 
23 |         public async Task<IEnumerable<BlogPostLike>> GetLikesForBlog(Guid blogPostId)
24 |         {
25 |             return await bloggieDbContext.BlogPostLike.Where(x => x.BlogPostId == blogPostId)
26 |                 .ToListAsync();
27 |         }
28 | 
29 |         public async Task<int> GetTotalLikes(Guid blogPostId)
30 |         {
31 |             return await bloggieDbContext.BlogPostLike
32 |                 .CountAsync(x => x.BlogPostId == blogPostId);
33 |         }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Views/Account/Login.cshtml:
--------------------------------------------------------------------------------
 1 | @model Bloggie.Web.Models.ViewModels.LoginViewModel
 2 | 
 3 | @{
 4 | }
 5 | 
 6 | 
 7 | <div class="container mx-auto">
 8 |     <div class="row justify-content-center">
 9 |         <div class="col-12 col-lg-6">
10 | 
11 |             <h1 class="mt-3 mb-3 h3">
12 |                 Login
13 |             </h1>
14 | 
15 |             <form method="post">
16 |                 <div class="mb-3">
17 |                     <label class="form-label">Username</label>
18 |                     <input type="text" id="username" class="form-control" asp-for="Username" required />
19 |                     <span class="text-danger" asp-validation-for="Username"></span>
20 |                 </div>
21 | 
22 |                 <div class="mb-3">
23 |                     <label class="form-label">Password</label>
24 |                     <input type="password" id="password" class="form-control" asp-for="Password" required minlength="6" />
25 |                     <span class="text-danger" asp-validation-for="Password"></span>
26 |                 </div>
27 | 
28 |                 <div class="mb-3">
29 |                     <button type="submit" class="btn btn-dark">Login</button>
30 |                 </div>
31 | 
32 |                 <input type="hidden" asp-for="ReturnUrl" />
33 |             </form>
34 |         </div>
35 |     </div>
36 | </div>


--------------------------------------------------------------------------------
/Bloggie.Web/Repositories/CloudinaryImageRepository.cs:
--------------------------------------------------------------------------------
 1 | using CloudinaryDotNet;
 2 | using CloudinaryDotNet.Actions;
 3 | 
 4 | namespace Bloggie.Web.Repositories
 5 | {
 6 |     public class CloudinaryImageRepository : IImageRespository
 7 |     {
 8 |         private readonly IConfiguration configuration;
 9 |         private readonly Account account;
10 | 
11 |         public CloudinaryImageRepository(IConfiguration configuration)
12 |         {
13 |             this.configuration = configuration;
14 |             account = new Account(
15 |                 configuration.GetSection("Cloudinary")["CloudName"],
16 |                 configuration.GetSection("Cloudinary")["ApiKey"],
17 |                 configuration.GetSection("Cloudinary")["ApiSecret"]);
18 |         }
19 | 
20 |         public async Task<string> UploadAsync(IFormFile file)
21 |         {
22 |             var client = new Cloudinary(account);
23 | 
24 |             var uploadParams = new ImageUploadParams()
25 |             {
26 |                 File = new FileDescription(file.FileName, file.OpenReadStream()),
27 |                 DisplayName = file.FileName
28 |             };
29 | 
30 |             var uploadResult = await client.UploadAsync(uploadParams);
31 | 
32 |             if (uploadResult != null && uploadResult.StatusCode == System.Net.HttpStatusCode.OK)
33 |             {
34 |                 return uploadResult.SecureUri.ToString();
35 |             }
36 | 
37 |             return null;
38 |         }
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Controllers/BlogPostLikeController.cs:
--------------------------------------------------------------------------------
 1 | using Bloggie.Web.Models.Domain;
 2 | using Bloggie.Web.Models.ViewModels;
 3 | using Bloggie.Web.Repositories;
 4 | using Microsoft.AspNetCore.Http;
 5 | using Microsoft.AspNetCore.Mvc;
 6 | 
 7 | namespace Bloggie.Web.Controllers
 8 | {
 9 |     [Route("api/[controller]")]
10 |     [ApiController]
11 |     public class BlogPostLikeController : ControllerBase
12 |     {
13 |         private readonly IBlogPostLikeRepository blogPostLikeRepository;
14 | 
15 |         public BlogPostLikeController(IBlogPostLikeRepository blogPostLikeRepository)
16 |         {
17 |             this.blogPostLikeRepository = blogPostLikeRepository;
18 |         }
19 | 
20 | 
21 |         [HttpPost]
22 |         [Route("Add")]
23 |         public async Task<IActionResult> AddLike([FromBody] AddLikeRequest addLikeRequest)
24 |         {
25 |             var model = new BlogPostLike
26 |             {
27 |                 BlogPostId = addLikeRequest.BlogPostId,
28 |                 UserId = addLikeRequest.UserId
29 |             };
30 | 
31 |             await blogPostLikeRepository.AddLikeForBlog(model);
32 | 
33 |             return Ok();
34 |         }
35 | 
36 | 
37 |         [HttpGet]
38 |         [Route("{blogPostId:Guid}/totalLikes")]
39 |         public async Task<IActionResult> GetTotalLikesForBlog([FromRoute] Guid blogPostId)
40 |         {
41 |             var totalLikes = await blogPostLikeRepository.GetTotalLikes(blogPostId);
42 | 
43 |             return Ok(totalLikes);
44 |         }
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Views/Account/Register.cshtml:
--------------------------------------------------------------------------------
 1 | @model Bloggie.Web.Models.ViewModels.RegisterViewModel
 2 | 
 3 | @{
 4 | }
 5 | 
 6 | 
 7 | <div class="container mx-auto">
 8 |     <div class="row justify-content-center">
 9 |         <div class="col-12 col-lg-6">
10 | 
11 |             <h1 class="mt-3 mb-3 h3">
12 |                 Register
13 |             </h1>
14 | 
15 |             <form method="post">
16 |                 <div class="mb-3">
17 |                     <label class="form-label">Username</label>
18 |                     <input type="text" id="username" class="form-control" asp-for="Username" required />
19 |                     <span class="text-danger" asp-validation-for="Username"></span>
20 |                 </div>
21 | 
22 |                 <div class="mb-3">
23 |                     <label class="form-label">Email</label>
24 |                     <input type="email" id="email" class="form-control" asp-for="Email" required/>
25 |                     <span class="text-danger" asp-validation-for="Email"></span>
26 |                 </div>
27 | 
28 |                 <div class="mb-3">
29 |                     <label class="form-label">Password</label>
30 |                     <input type="password" id="password" class="form-control" asp-for="Password" required minlength="6"/>
31 |                     <span class="text-danger" asp-validation-for="Password"></span>
32 |                 </div>
33 | 
34 |                 <div class="mb-3">
35 |                     <button type="submit" class="btn btn-dark">Register</button>
36 |                 </div>
37 |             </form>
38 |         </div>
39 |     </div>
40 | </div>


--------------------------------------------------------------------------------
/Bloggie.Web/Views/AdminTags/Edit.cshtml:
--------------------------------------------------------------------------------
 1 | @model Bloggie.Web.Models.ViewModels.EditTagRequest
 2 | @{
 3 | }
 4 | 
 5 | <div class="bg-secondary bg-opacity-10 py-2">
 6 |     <div class="container">
 7 |         <h1>Edit Tag - Admin Functionality</h1>
 8 |     </div>
 9 | </div>
10 | 
11 | 
12 | <div class="container py-5">
13 |     @if (Model != null)
14 |     {
15 |         <form method="post">
16 | 
17 |             <div class="mb-3">
18 |                 <label class="form-label">Id</label>
19 |                 <input type="text" id="id" class="form-control" asp-for="Id" readonly />
20 |             </div>
21 | 
22 |             <div class="mb-3">
23 |                 <label class="form-label">Name</label>
24 |                 <input type="text" id="name" class="form-control" asp-for="Name" />
25 |             </div>
26 | 
27 |             <div class="mb-3">
28 |                 <label class="form-label">Display Name</label>
29 |                 <input type="text" id="displayName" class="form-control" asp-for="DisplayName" />
30 |             </div>
31 | 
32 |             <div class="mb-3">
33 | 
34 |                 <div class="d-flex">
35 |                     <button type="submit" class="btn btn-dark">Update</button>
36 | 
37 |                     <button class="btn btn-danger ms-2" type="submit"
38 |                             asp-area=""
39 |                             asp-controller="AdminTags"
40 |                             asp-action="Delete">
41 |                         Delete
42 |                     </button>
43 | 
44 |                 </div>
45 | 
46 |             </div>
47 | 
48 |         </form>
49 |     }
50 |     else
51 |     {
52 |         <p>Tag not found!</p>
53 |     }
54 | </div>


--------------------------------------------------------------------------------
/Bloggie.Web/Controllers/HomeController.cs:
--------------------------------------------------------------------------------
 1 | using Bloggie.Web.Models;
 2 | using Bloggie.Web.Models.ViewModels;
 3 | using Bloggie.Web.Repositories;
 4 | using Microsoft.AspNetCore.Mvc;
 5 | using System.Diagnostics;
 6 | 
 7 | namespace Bloggie.Web.Controllers
 8 | {
 9 |     public class HomeController : Controller
10 |     {
11 |         private readonly ILogger<HomeController> _logger;
12 |         private readonly IBlogPostRepository blogPostRepository;
13 |         private readonly ITagRepository tagRepository;
14 | 
15 |         public HomeController(ILogger<HomeController> logger,
16 |             IBlogPostRepository blogPostRepository,
17 |             ITagRepository tagRepository
18 |             )
19 |         {
20 |             _logger = logger;
21 |             this.blogPostRepository = blogPostRepository;
22 |             this.tagRepository = tagRepository;
23 |         }
24 | 
25 |         public async Task<IActionResult> Index()
26 |         {
27 |             // getting all blogs
28 |             var blogPosts = await blogPostRepository.GetAllAsync();
29 | 
30 |             // get all tags
31 |             var tags = await tagRepository.GetAllAsync();
32 | 
33 |             var model = new HomeViewModel
34 |             {
35 |                 BlogPosts = blogPosts,
36 |                 Tags = tags
37 |             };
38 | 
39 |             return View(model);
40 |         }
41 | 
42 |         public IActionResult Privacy()
43 |         {
44 |             return View();
45 |         }
46 | 
47 |         [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
48 |         public IActionResult Error()
49 |         {
50 |             return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
51 |         }
52 |     }
53 | }


--------------------------------------------------------------------------------
/Bloggie.Web/Migrations/20230305212914_Adding like functionality.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Microsoft.EntityFrameworkCore.Migrations;
 3 | 
 4 | #nullable disable
 5 | 
 6 | namespace Bloggie.Web.Migrations
 7 | {
 8 |     /// <inheritdoc />
 9 |     public partial class Addinglikefunctionality : Migration
10 |     {
11 |         /// <inheritdoc />
12 |         protected override void Up(MigrationBuilder migrationBuilder)
13 |         {
14 |             migrationBuilder.CreateTable(
15 |                 name: "BlogPostLike",
16 |                 columns: table => new
17 |                 {
18 |                     Id = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
19 |                     BlogPostId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
20 |                     UserId = table.Column<Guid>(type: "uniqueidentifier", nullable: false)
21 |                 },
22 |                 constraints: table =>
23 |                 {
24 |                     table.PrimaryKey("PK_BlogPostLike", x => x.Id);
25 |                     table.ForeignKey(
26 |                         name: "FK_BlogPostLike_BlogPosts_BlogPostId",
27 |                         column: x => x.BlogPostId,
28 |                         principalTable: "BlogPosts",
29 |                         principalColumn: "Id",
30 |                         onDelete: ReferentialAction.Cascade);
31 |                 });
32 | 
33 |             migrationBuilder.CreateIndex(
34 |                 name: "IX_BlogPostLike_BlogPostId",
35 |                 table: "BlogPostLike",
36 |                 column: "BlogPostId");
37 |         }
38 | 
39 |         /// <inheritdoc />
40 |         protected override void Down(MigrationBuilder migrationBuilder)
41 |         {
42 |             migrationBuilder.DropTable(
43 |                 name: "BlogPostLike");
44 |         }
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Views/AdminBlogPosts/List.cshtml:
--------------------------------------------------------------------------------
 1 | @model List<Bloggie.Web.Models.Domain.BlogPost>
 2 | 
 3 | @{
 4 | }
 5 | 
 6 | <div class="bg-secondary bg-opacity-10 py-2">
 7 |     <div class="container">
 8 |         <h1>All BlogPosts - Admin Functionality</h1>
 9 |     </div>
10 | </div>
11 | 
12 | 
13 | <div class="container py-5">
14 |     @if (Model != null && Model.Any())
15 |     {
16 |         <table class="table">
17 |             <thead>
18 |                 <tr>
19 |                     <td>Id</td>
20 |                     <td>Heading</td>
21 |                     <td>Tags</td>
22 |                     <td> </td>
23 |                 </tr>
24 |             </thead>
25 |             <tbody>
26 |                 @foreach (var blogPost in Model)
27 |                 {
28 |                     <tr>
29 |                         <td>@blogPost.Id</td>
30 |                         <td>@blogPost.Heading</td>
31 |                         <td>
32 |                             <div class="d-flex">
33 |                                 @foreach (var tag in blogPost.Tags)
34 |                                 {
35 |                                     <span class="badge bg-secondary me-1">@tag.Name</span>
36 |                                 }
37 |                             </div>
38 |                         </td>
39 |                         <td>
40 |                             <a asp-area=""
41 |                                asp-controller="AdminBlogPosts"
42 |                                asp-action="Edit"
43 |                                asp-route-id="@blogPost.Id">
44 |                                 Edit
45 |                             </a>
46 |                         </td>
47 |                     </tr>
48 |                 }
49 |             </tbody>
50 |         </table>
51 |     }
52 |     else
53 |     {
54 |         <p>No Blog Posts Found!</p>
55 |     }
56 | 
57 | </div>


--------------------------------------------------------------------------------
/Bloggie.Web/Migrations/20230306005821_adding comments.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Microsoft.EntityFrameworkCore.Migrations;
 3 | 
 4 | #nullable disable
 5 | 
 6 | namespace Bloggie.Web.Migrations
 7 | {
 8 |     /// <inheritdoc />
 9 |     public partial class addingcomments : Migration
10 |     {
11 |         /// <inheritdoc />
12 |         protected override void Up(MigrationBuilder migrationBuilder)
13 |         {
14 |             migrationBuilder.CreateTable(
15 |                 name: "BlogPostComment",
16 |                 columns: table => new
17 |                 {
18 |                     Id = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
19 |                     Description = table.Column<string>(type: "nvarchar(max)", nullable: false),
20 |                     BlogPostId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
21 |                     UserId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
22 |                     DateAdded = table.Column<DateTime>(type: "datetime2", nullable: false)
23 |                 },
24 |                 constraints: table =>
25 |                 {
26 |                     table.PrimaryKey("PK_BlogPostComment", x => x.Id);
27 |                     table.ForeignKey(
28 |                         name: "FK_BlogPostComment_BlogPosts_BlogPostId",
29 |                         column: x => x.BlogPostId,
30 |                         principalTable: "BlogPosts",
31 |                         principalColumn: "Id",
32 |                         onDelete: ReferentialAction.Cascade);
33 |                 });
34 | 
35 |             migrationBuilder.CreateIndex(
36 |                 name: "IX_BlogPostComment_BlogPostId",
37 |                 table: "BlogPostComment",
38 |                 column: "BlogPostId");
39 |         }
40 | 
41 |         /// <inheritdoc />
42 |         protected override void Down(MigrationBuilder migrationBuilder)
43 |         {
44 |             migrationBuilder.DropTable(
45 |                 name: "BlogPostComment");
46 |         }
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Program.cs:
--------------------------------------------------------------------------------
 1 | using Bloggie.Web.Data;
 2 | using Bloggie.Web.Repositories;
 3 | using Microsoft.AspNetCore.Identity;
 4 | using Microsoft.EntityFrameworkCore;
 5 | 
 6 | var builder = WebApplication.CreateBuilder(args);
 7 | 
 8 | // Add services to the container.
 9 | builder.Services.AddControllersWithViews();
10 | 
11 | builder.Services.AddDbContext<BloggieDbContext>(options =>
12 | options.UseSqlServer(builder.Configuration.GetConnectionString("BloggieDbConnectionString")));
13 | 
14 | builder.Services.AddDbContext<AuthDbContext>(options =>
15 | options.UseSqlServer(builder.Configuration.GetConnectionString("BloggieAuthDbConnectionString")));
16 | 
17 | builder.Services.AddIdentity<IdentityUser, IdentityRole>()
18 |     .AddEntityFrameworkStores<AuthDbContext>();
19 | 
20 | builder.Services.Configure<IdentityOptions>(options =>
21 | {
22 |     // Default settings
23 |     options.Password.RequireDigit = true;
24 |     options.Password.RequireLowercase = true;
25 |     options.Password.RequireNonAlphanumeric = true;
26 |     options.Password.RequireUppercase = true;
27 |     options.Password.RequiredLength = 6;
28 |     options.Password.RequiredUniqueChars = 1;
29 | });
30 | 
31 | 
32 | builder.Services.AddScoped<ITagRepository, TagRepository>();
33 | builder.Services.AddScoped<IBlogPostRepository, BlogPostRepository>();
34 | builder.Services.AddScoped<IImageRespository, CloudinaryImageRepository>();
35 | builder.Services.AddScoped<IBlogPostLikeRepository, BlogPostLikeRepository>();
36 | builder.Services.AddScoped<IBlogPostCommentRepository, BlogPostCommentRepository>();
37 | builder.Services.AddScoped<IUserRepository, UserRepository>();
38 | 
39 | var app = builder.Build();
40 | 
41 | // Configure the HTTP request pipeline.
42 | if (!app.Environment.IsDevelopment())
43 | {
44 |     app.UseExceptionHandler("/Home/Error");
45 |     // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
46 |     app.UseHsts();
47 | }
48 | 
49 | app.UseHttpsRedirection();
50 | app.UseStaticFiles();
51 | 
52 | app.UseRouting();
53 | 
54 | app.UseAuthentication();
55 | app.UseAuthorization();
56 | 
57 | app.MapControllerRoute(
58 |     name: "default",
59 |     pattern: "{controller=Home}/{action=Index}/{id?}");
60 | 
61 | app.Run();
62 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | ###############################################################################
 2 | # Set default behavior to automatically normalize line endings.
 3 | ###############################################################################
 4 | * text=auto
 5 | 
 6 | ###############################################################################
 7 | # Set default behavior for command prompt diff.
 8 | #
 9 | # This is need for earlier builds of msysgit that does not have it on by
10 | # default for csharp files.
11 | # Note: This is only used by command line
12 | ###############################################################################
13 | #*.cs     diff=csharp
14 | 
15 | ###############################################################################
16 | # Set the merge driver for project and solution files
17 | #
18 | # Merging from the command prompt will add diff markers to the files if there
19 | # are conflicts (Merging from VS is not affected by the settings below, in VS
20 | # the diff markers are never inserted). Diff markers may cause the following 
21 | # file extensions to fail to load in VS. An alternative would be to treat
22 | # these files as binary and thus will always conflict and require user
23 | # intervention with every merge. To do so, just uncomment the entries below
24 | ###############################################################################
25 | #*.sln       merge=binary
26 | #*.csproj    merge=binary
27 | #*.vbproj    merge=binary
28 | #*.vcxproj   merge=binary
29 | #*.vcproj    merge=binary
30 | #*.dbproj    merge=binary
31 | #*.fsproj    merge=binary
32 | #*.lsproj    merge=binary
33 | #*.wixproj   merge=binary
34 | #*.modelproj merge=binary
35 | #*.sqlproj   merge=binary
36 | #*.wwaproj   merge=binary
37 | 
38 | ###############################################################################
39 | # behavior for image files
40 | #
41 | # image files are treated as binary by default.
42 | ###############################################################################
43 | #*.jpg   binary
44 | #*.png   binary
45 | #*.gif   binary
46 | 
47 | ###############################################################################
48 | # diff behavior for common document formats
49 | # 
50 | # Convert binary document formats to text before diffing them. This feature
51 | # is only available from the command line. Turn it on by uncommenting the 
52 | # entries below.
53 | ###############################################################################
54 | #*.doc   diff=astextplain
55 | #*.DOC   diff=astextplain
56 | #*.docx  diff=astextplain
57 | #*.DOCX  diff=astextplain
58 | #*.dot   diff=astextplain
59 | #*.DOT   diff=astextplain
60 | #*.pdf   diff=astextplain
61 | #*.PDF   diff=astextplain
62 | #*.rtf   diff=astextplain
63 | #*.RTF   diff=astextplain
64 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Repositories/BlogPostRepository.cs:
--------------------------------------------------------------------------------
 1 | using Bloggie.Web.Data;
 2 | using Bloggie.Web.Models.Domain;
 3 | using Microsoft.EntityFrameworkCore;
 4 | 
 5 | namespace Bloggie.Web.Repositories
 6 | {
 7 |     public class BlogPostRepository : IBlogPostRepository
 8 |     {
 9 |         private readonly BloggieDbContext bloggieDbContext;
10 | 
11 |         public BlogPostRepository(BloggieDbContext bloggieDbContext)
12 |         {
13 |             this.bloggieDbContext = bloggieDbContext;
14 |         }
15 | 
16 |         public async Task<BlogPost> AddAsync(BlogPost blogPost)
17 |         {
18 |             await bloggieDbContext.AddAsync(blogPost);
19 |             await bloggieDbContext.SaveChangesAsync();
20 |             return blogPost;
21 |         }
22 | 
23 |         public async Task<BlogPost?> DeleteAsync(Guid id)
24 |         {
25 |             var existingBlog = await bloggieDbContext.BlogPosts.FindAsync(id);
26 | 
27 |             if (existingBlog != null)
28 |             {
29 |                 bloggieDbContext.BlogPosts.Remove(existingBlog);
30 |                 await bloggieDbContext.SaveChangesAsync();
31 |                 return existingBlog;
32 |             }
33 | 
34 |             return null;
35 |         }
36 | 
37 |         public async Task<IEnumerable<BlogPost>> GetAllAsync()
38 |         {
39 |             return await bloggieDbContext.BlogPosts.Include(x => x.Tags).ToListAsync();
40 |         }
41 | 
42 |         public async Task<BlogPost?> GetAsync(Guid id)
43 |         {
44 |             return await bloggieDbContext.BlogPosts.Include(x => x.Tags).FirstOrDefaultAsync(x => x.Id == id);
45 |         }
46 | 
47 |         public async Task<BlogPost?> GetByUrlHandleAsync(string urlHandle)
48 |         {
49 |             return await bloggieDbContext.BlogPosts.Include(x => x.Tags)
50 |                 .FirstOrDefaultAsync(x => x.UrlHandle == urlHandle);
51 |         }
52 | 
53 |         public async Task<BlogPost?> UpdateAsync(BlogPost blogPost)
54 |         {
55 |             var existingBlog = await bloggieDbContext.BlogPosts.Include(x => x.Tags)
56 |                 .FirstOrDefaultAsync(x => x.Id == blogPost.Id);
57 | 
58 |             if (existingBlog != null)
59 |             {
60 |                 existingBlog.Id = blogPost.Id;
61 |                 existingBlog.Heading = blogPost.Heading;
62 |                 existingBlog.PageTitle = blogPost.PageTitle;
63 |                 existingBlog.Content = blogPost.Content;
64 |                 existingBlog.ShortDescription = blogPost.ShortDescription;
65 |                 existingBlog.Author = blogPost.Author;
66 |                 existingBlog.FeaturedImageUrl = blogPost.FeaturedImageUrl;
67 |                 existingBlog.UrlHandle = blogPost.UrlHandle;
68 |                 existingBlog.Visible = blogPost.Visible;
69 |                 existingBlog.PublishedDate = blogPost.PublishedDate;
70 |                 existingBlog.Tags = blogPost.Tags;
71 | 
72 |                 await bloggieDbContext.SaveChangesAsync();
73 |                 return existingBlog;
74 |             }
75 | 
76 |             return null;
77 |         }
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Views/Home/Index.cshtml:
--------------------------------------------------------------------------------
 1 | @model Bloggie.Web.Models.ViewModels.HomeViewModel
 2 | 
 3 | @{
 4 |     ViewData["Title"] = "Home Page";
 5 | }
 6 | 
 7 | 
 8 | <div class="container col-xxl-8 px-4 py-5">
 9 |     <div class="row align-items-center g-5 py-5">
10 |         <div class="col-12 col-lg-6">
11 |             <h1 class="display-5 fw-bold lh-1 mb-3">
12 |                 Bloggie - The Dev Blog
13 |             </h1>
14 |             <p class="lead">
15 |                 Bloggie is the gome to coding blogs covering a vast range of
16 |                 topics like HTML, CSS, Javascript, ASP.NET, C#, Angular etc.
17 |                 Want to read the latest dev articles? Join the bloggie app and
18 |                 get weekly blogs in your email.
19 |             </p>
20 |         </div>
21 | 
22 |         <div class="col-12 col-lg-6">
23 |             <img src="https://images.pexels.com/photos/57690/pexels-photo-57690.jpeg?auto=compress&cs=tinysrgb&w=600"
24 |                  alt="Bloggie - Dev blogs" 
25 |                  class="d-block mx-lg-auto img-fluid"  width="300"/>
26 |         </div>
27 |     </div>
28 | </div>
29 | 
30 | 
31 | <div class="container">
32 |     <div class="row justify-content-center">
33 |         <div class="col-6 d-flex">
34 |             @if (Model != null && Model.Tags.Any())
35 |             {
36 |                 foreach (var tag in Model.Tags)
37 |                 {
38 |                     <span class="badge bg-dark me-1">
39 |                         @tag.Name
40 |                     </span>
41 |                 }
42 |             }
43 |         </div>
44 |     </div>
45 | 
46 | </div>
47 | 
48 | 
49 | <div class="container">
50 |     <div class="row justify-content-center">
51 |         <div class="col-6">
52 |             @if (Model != null && Model.BlogPosts.Any())
53 |             {
54 |                 foreach (var blogPost in Model.BlogPosts)
55 |                 {
56 |                     <div class="mb-5 bg-light box-shadow p-5">
57 |                         <img src="@blogPost.FeaturedImageUrl" alt="@blogPost.Heading"
58 |                              class="mb-2 d-block img-fluid" />
59 | 
60 |                         <h2 class="mb-4">@blogPost.Heading</h2>
61 |                         <p class="mb-4">
62 |                             Author: @blogPost.Author
63 |                             <br />
64 |                             Published Date: @blogPost.PublishedDate.ToShortDateString()
65 |                         </p>
66 | 
67 |                         <p class="mb-4">
68 |                             @foreach (var tag in blogPost.Tags)
69 |                             {
70 |                                 <span class="badge bg-secondary me-1">@tag.Name</span>
71 |                             }
72 |                         </p>
73 | 
74 |                         <p class="mb-4">@blogPost.ShortDescription</p>
75 | 
76 |                         <a class="btn btn-dark"
77 |                            asp-area=""
78 |                            asp-controller="Blogs"
79 |                            asp-action="Index"
80 |                            asp-route-urlHandle="@blogPost.UrlHandle"
81 |                            >Read More</a>
82 |                     </div>
83 | 
84 |                 }
85 |             }
86 |         </div>
87 |     </div>
88 | </div>


--------------------------------------------------------------------------------
/Bloggie.Web/Data/AuthDbContext.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.AspNetCore.Identity;
 2 | using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
 3 | using Microsoft.EntityFrameworkCore;
 4 | 
 5 | namespace Bloggie.Web.Data
 6 | {
 7 |     public class AuthDbContext : IdentityDbContext
 8 |     {
 9 |         public AuthDbContext(DbContextOptions<AuthDbContext> options) : base(options)
10 |         {
11 |         }
12 | 
13 | 
14 |         protected override void OnModelCreating(ModelBuilder builder)
15 |         {
16 |             base.OnModelCreating(builder);
17 | 
18 | 
19 |             // Seed Roles (User, Admin, SuperAdmin)
20 | 
21 |             var adminRoleId = "37cc67e1-41ca-461c-bf34-2b5e62dbae32";
22 |             var superAdminRoleId = "3cfd9eee-08cb-4da3-9e6f-c3166b50d3b0";
23 |             var userRoleId = "a0cab2c3-6558-4a1c-be81-dfb39180da3d";
24 | 
25 |             var roles = new List<IdentityRole>
26 |             {
27 |                 new IdentityRole
28 |                 {
29 |                     Name= "Admin",
30 |                     NormalizedName = "Admin",
31 |                     Id = adminRoleId,
32 |                     ConcurrencyStamp = adminRoleId
33 |                 },
34 |                 new IdentityRole
35 |                 {
36 |                     Name = "SuperAdmin",
37 |                     NormalizedName = "SuperAdmin",
38 |                     Id = superAdminRoleId,
39 |                     ConcurrencyStamp = superAdminRoleId
40 |                 },
41 |                 new IdentityRole
42 |                 {
43 |                     Name = "User",
44 |                     NormalizedName = "User",
45 |                     Id = userRoleId,
46 |                     ConcurrencyStamp = userRoleId
47 |                 }
48 |             };
49 | 
50 |             builder.Entity<IdentityRole>().HasData(roles);
51 | 
52 |             // Seed SuperAdminUser
53 |             var superAdminId = "472ba632-6133-44a1-b158-6c10bd7d850d";
54 |             var superAdminUser = new IdentityUser
55 |             {
56 |                 UserName = "superadmin@bloggie.com",
57 |                 Email = "superadmin@bloggie.com",
58 |                 NormalizedEmail = "superadmin@bloggie.com".ToUpper(),
59 |                 NormalizedUserName = "superadmin@bloggie.com".ToUpper(),
60 |                 Id = superAdminId
61 |             };
62 | 
63 |             superAdminUser.PasswordHash = new PasswordHasher<IdentityUser>()
64 |                 .HashPassword(superAdminUser, "Superadmin@123");
65 | 
66 | 
67 |             builder.Entity<IdentityUser>().HasData(superAdminUser);
68 | 
69 | 
70 |             // Add All roles to SuperAdminUser
71 |             var superAdminRoles = new List<IdentityUserRole<string>>
72 |             {
73 |                 new IdentityUserRole<string>
74 |                 {
75 |                     RoleId = adminRoleId,
76 |                     UserId = superAdminId
77 |                 },
78 |                 new IdentityUserRole<string>
79 |                 {
80 |                     RoleId = superAdminRoleId,
81 |                     UserId = superAdminId
82 |                 },
83 |                 new IdentityUserRole<string>
84 |                 {
85 |                     RoleId = userRoleId,
86 |                     UserId = superAdminId
87 |                 }
88 |             };
89 | 
90 |             builder.Entity<IdentityUserRole<string>>().HasData(superAdminRoles);
91 | 
92 |         }
93 |     }
94 | }
95 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Controllers/AdminUsersController.cs:
--------------------------------------------------------------------------------
  1 | using Bloggie.Web.Models.ViewModels;
  2 | using Bloggie.Web.Repositories;
  3 | using Microsoft.AspNetCore.Authorization;
  4 | using Microsoft.AspNetCore.Identity;
  5 | using Microsoft.AspNetCore.Mvc;
  6 | 
  7 | namespace Bloggie.Web.Controllers
  8 | {
  9 |     [Authorize(Roles = "Admin")]
 10 |     public class AdminUsersController : Controller
 11 |     {
 12 |         private readonly IUserRepository userRepository;
 13 |         private readonly UserManager<IdentityUser> userManager;
 14 | 
 15 |         public AdminUsersController(IUserRepository userRepository,
 16 |             UserManager<IdentityUser> userManager)
 17 |         {
 18 |             this.userRepository = userRepository;
 19 |             this.userManager = userManager;
 20 |         }
 21 | 
 22 |         [HttpGet]
 23 |         public async Task<IActionResult> List()
 24 |         {
 25 |             var users = await userRepository.GetAll();
 26 | 
 27 |             var usersViewModel = new UserViewModel();
 28 |             usersViewModel.Users = new List<User>();
 29 | 
 30 |             foreach (var user in users)
 31 |             {
 32 |                 usersViewModel.Users.Add(new Models.ViewModels.User
 33 |                 {
 34 |                     Id = Guid.Parse(user.Id),
 35 |                     Username = user.UserName,
 36 |                     EmailAddress = user.Email
 37 |                 });
 38 |             }
 39 | 
 40 |             return View(usersViewModel);
 41 |         }
 42 | 
 43 |         [HttpPost]
 44 |         public async Task<IActionResult> List(UserViewModel request)
 45 |         {
 46 |             var identityUser = new IdentityUser
 47 |             {
 48 |                 UserName = request.Username,
 49 |                 Email = request.Email
 50 |             };
 51 | 
 52 | 
 53 |             var identityResult =
 54 |                 await userManager.CreateAsync(identityUser, request.Password);
 55 | 
 56 |             if (identityResult is not null)
 57 |             {
 58 |                 if (identityResult.Succeeded)
 59 |                 {
 60 |                     // assign roles to this user
 61 |                     var roles = new List<string> { "User" };
 62 | 
 63 |                     if (request.AdminRoleCheckbox)
 64 |                     {
 65 |                         roles.Add("Admin");
 66 |                     }
 67 | 
 68 |                     identityResult =
 69 |                         await userManager.AddToRolesAsync(identityUser, roles);
 70 | 
 71 |                     if (identityResult is not null && identityResult.Succeeded)
 72 |                     {
 73 |                         return RedirectToAction("List", "AdminUsers");
 74 |                     }
 75 | 
 76 |                 }
 77 |             }
 78 | 
 79 |             return View();
 80 |         }
 81 | 
 82 |         [HttpPost]
 83 |         public async Task<IActionResult> Delete(Guid id)
 84 |         {
 85 |             var user = await userManager.FindByIdAsync(id.ToString());
 86 | 
 87 |             if (user is not null)
 88 |             {
 89 |                 var identityResult = await userManager.DeleteAsync(user);
 90 | 
 91 |                 if (identityResult is not null && identityResult.Succeeded)
 92 |                 {
 93 |                     return RedirectToAction("List", "AdminUsers");
 94 |                 }
 95 |             }
 96 | 
 97 |             return View();
 98 |         }
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Controllers/AccountController.cs:
--------------------------------------------------------------------------------
  1 | using Bloggie.Web.Models.ViewModels;
  2 | using Microsoft.AspNetCore.Identity;
  3 | using Microsoft.AspNetCore.Mvc;
  4 | 
  5 | namespace Bloggie.Web.Controllers
  6 | {
  7 |     public class AccountController : Controller
  8 |     {
  9 |         private readonly UserManager<IdentityUser> userManager;
 10 |         private readonly SignInManager<IdentityUser> signInManager;
 11 | 
 12 |         public AccountController(UserManager<IdentityUser> userManager,
 13 |             SignInManager<IdentityUser> signInManager)
 14 |         {
 15 |             this.userManager = userManager;
 16 |             this.signInManager = signInManager;
 17 |         }
 18 | 
 19 | 
 20 |         [HttpGet]
 21 |         public IActionResult Register()
 22 |         {
 23 |             return View();
 24 |         }
 25 | 
 26 | 
 27 |         [HttpPost]
 28 |         public async Task<IActionResult> Register(RegisterViewModel registerViewModel)
 29 |         {
 30 |             if (ModelState.IsValid)
 31 |             {
 32 |                 var identityUser = new IdentityUser
 33 |                 {
 34 |                     UserName = registerViewModel.Username,
 35 |                     Email = registerViewModel.Email
 36 |                 };
 37 | 
 38 |                 var identityResult = await userManager.CreateAsync(identityUser, registerViewModel.Password);
 39 | 
 40 |                 if (identityResult.Succeeded)
 41 |                 {
 42 |                     // assign this user the "User" role
 43 |                     var roleIdentityResult = await userManager.AddToRoleAsync(identityUser, "User");
 44 | 
 45 |                     if (roleIdentityResult.Succeeded)
 46 |                     {
 47 |                         // Show success notification
 48 |                         return RedirectToAction("Register");
 49 |                     }
 50 |                 }
 51 |             }
 52 | 
 53 |             // Show error notification
 54 |             return View();
 55 |         }
 56 | 
 57 | 
 58 |         [HttpGet]
 59 |         public IActionResult Login(string ReturnUrl)
 60 |         {
 61 |             var model = new LoginViewModel
 62 |             {
 63 |                 ReturnUrl = ReturnUrl
 64 |             };
 65 | 
 66 |             return View(model);
 67 |         }
 68 | 
 69 | 
 70 |         [HttpPost]
 71 |         public async Task<IActionResult> Login(LoginViewModel loginViewModel)
 72 |         {
 73 |             if (!ModelState.IsValid)
 74 |             {
 75 |                 return View();
 76 |             }
 77 | 
 78 |             var signInResult = await signInManager.PasswordSignInAsync(loginViewModel.Username,
 79 |                 loginViewModel.Password, false, false);
 80 | 
 81 |             if (signInResult != null && signInResult.Succeeded)
 82 |             {
 83 |                 if (!string.IsNullOrWhiteSpace(loginViewModel.ReturnUrl))
 84 |                 {
 85 |                     return Redirect(loginViewModel.ReturnUrl);
 86 |                 }
 87 | 
 88 |                 return RedirectToAction("Index", "Home");
 89 |             }
 90 | 
 91 |             // Show errors
 92 |             return View();
 93 |         }
 94 | 
 95 |         [HttpGet]
 96 |         public async Task<IActionResult> Logout()
 97 |         {
 98 |             await signInManager.SignOutAsync();
 99 |             return RedirectToAction("Index", "Home");
100 |         }
101 | 
102 | 
103 |         [HttpGet]
104 |         public IActionResult AccessDenied()
105 |         {
106 |             return View();
107 |         }
108 |     }
109 | }
110 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Repositories/TagRepository.cs:
--------------------------------------------------------------------------------
  1 | using Bloggie.Web.Data;
  2 | using Bloggie.Web.Models.Domain;
  3 | using Microsoft.EntityFrameworkCore;
  4 | 
  5 | namespace Bloggie.Web.Repositories
  6 | {
  7 |     public class TagRepository : ITagRepository
  8 |     {
  9 |         private readonly BloggieDbContext bloggieDbContext;
 10 | 
 11 |         public TagRepository(BloggieDbContext bloggieDbContext)
 12 |         {
 13 |             this.bloggieDbContext = bloggieDbContext;
 14 |         }
 15 | 
 16 | 
 17 |         public async Task<IEnumerable<Tag>> GetAllAsync(
 18 |             string? searchQuery,
 19 |             string? sortBy,
 20 |             string? sortDirection,
 21 |             int pageNumber = 1,
 22 |             int pageSize = 100)
 23 |         {
 24 |             var query = bloggieDbContext.Tags.AsQueryable();
 25 | 
 26 |             // Filtering
 27 |             if (string.IsNullOrWhiteSpace(searchQuery) == false)
 28 |             {
 29 |                 query = query.Where(x => x.Name.Contains(searchQuery) ||
 30 |                                          x.DisplayName.Contains(searchQuery));
 31 |             }
 32 | 
 33 |             // Sorting
 34 |             if (string.IsNullOrWhiteSpace(sortBy) == false)
 35 |             {
 36 |                 var isDesc = string.Equals(sortDirection, "Desc", StringComparison.OrdinalIgnoreCase);
 37 | 
 38 |                 if (string.Equals(sortBy, "Name", StringComparison.OrdinalIgnoreCase))
 39 |                 {
 40 |                     query = isDesc ? query.OrderByDescending(x => x.Name) : query.OrderBy(x => x.Name);
 41 |                 }
 42 | 
 43 |                 if (string.Equals(sortBy, "DisplayName", StringComparison.OrdinalIgnoreCase))
 44 |                 {
 45 |                     query = isDesc ? query.OrderByDescending(x => x.DisplayName) : query.OrderBy(x => x.DisplayName);
 46 |                 }
 47 |             }
 48 | 
 49 |             // Pagination
 50 |             // Skip 0 Take 5 -> Page 1 of 5 results
 51 |             // Skip 5 Take next 5 -> Page 2 of 5 results
 52 |             var skipResults = (pageNumber - 1) * pageSize;
 53 |             query = query.Skip(skipResults).Take(pageSize);
 54 | 
 55 |             return await query.ToListAsync();
 56 | 
 57 |             // return await bloggieDbContext.Tags.ToListAsync();
 58 |         }
 59 | 
 60 | 
 61 |         public async Task<Tag> AddAsync(Tag tag)
 62 |         {
 63 |             await bloggieDbContext.Tags.AddAsync(tag);
 64 |             await bloggieDbContext.SaveChangesAsync();
 65 |             return tag;
 66 |         }
 67 | 
 68 |         public async Task<Tag?> DeleteAsync(Guid id)
 69 |         {
 70 |             var existingTag = await bloggieDbContext.Tags.FindAsync(id);
 71 | 
 72 |             if (existingTag != null)
 73 |             {
 74 |                 bloggieDbContext.Tags.Remove(existingTag);
 75 |                 await bloggieDbContext.SaveChangesAsync();
 76 |                 return existingTag;
 77 |             }
 78 | 
 79 |             return null;
 80 |         }
 81 | 
 82 |         public Task<Tag?> GetAsync(Guid id)
 83 |         {
 84 |             return bloggieDbContext.Tags.FirstOrDefaultAsync(x => x.Id == id);
 85 |         }
 86 | 
 87 |         public async Task<Tag?> UpdateAsync(Tag tag)
 88 |         {
 89 |             var existingTag = await bloggieDbContext.Tags.FindAsync(tag.Id);
 90 | 
 91 |             if (existingTag != null)
 92 |             {
 93 |                 existingTag.Name = tag.Name;
 94 |                 existingTag.DisplayName = tag.DisplayName;
 95 | 
 96 |                 await bloggieDbContext.SaveChangesAsync();
 97 | 
 98 |                 return existingTag;
 99 |             }
100 | 
101 |             return null;
102 |         }
103 | 
104 |         public async Task<int> CountAsync()
105 |         {
106 |             return await bloggieDbContext.Tags.CountAsync();
107 |         }
108 |     }
109 | }
110 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Migrations/20230216015207_Initial Migration.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Microsoft.EntityFrameworkCore.Migrations;
 3 | 
 4 | #nullable disable
 5 | 
 6 | namespace Bloggie.Web.Migrations
 7 | {
 8 |     /// <inheritdoc />
 9 |     public partial class InitialMigration : Migration
10 |     {
11 |         /// <inheritdoc />
12 |         protected override void Up(MigrationBuilder migrationBuilder)
13 |         {
14 |             migrationBuilder.CreateTable(
15 |                 name: "BlogPosts",
16 |                 columns: table => new
17 |                 {
18 |                     Id = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
19 |                     Heading = table.Column<string>(type: "nvarchar(max)", nullable: false),
20 |                     PageTitle = table.Column<string>(type: "nvarchar(max)", nullable: false),
21 |                     Content = table.Column<string>(type: "nvarchar(max)", nullable: false),
22 |                     ShortDescription = table.Column<string>(type: "nvarchar(max)", nullable: false),
23 |                     FeaturedImageUrl = table.Column<string>(type: "nvarchar(max)", nullable: false),
24 |                     UrlHandle = table.Column<string>(type: "nvarchar(max)", nullable: false),
25 |                     PublishedDate = table.Column<DateTime>(type: "datetime2", nullable: false),
26 |                     Author = table.Column<string>(type: "nvarchar(max)", nullable: false),
27 |                     Visible = table.Column<bool>(type: "bit", nullable: false)
28 |                 },
29 |                 constraints: table =>
30 |                 {
31 |                     table.PrimaryKey("PK_BlogPosts", x => x.Id);
32 |                 });
33 | 
34 |             migrationBuilder.CreateTable(
35 |                 name: "Tags",
36 |                 columns: table => new
37 |                 {
38 |                     Id = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
39 |                     Name = table.Column<string>(type: "nvarchar(max)", nullable: false),
40 |                     DisplayName = table.Column<string>(type: "nvarchar(max)", nullable: false)
41 |                 },
42 |                 constraints: table =>
43 |                 {
44 |                     table.PrimaryKey("PK_Tags", x => x.Id);
45 |                 });
46 | 
47 |             migrationBuilder.CreateTable(
48 |                 name: "BlogPostTag",
49 |                 columns: table => new
50 |                 {
51 |                     BlogPostsId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
52 |                     TagsId = table.Column<Guid>(type: "uniqueidentifier", nullable: false)
53 |                 },
54 |                 constraints: table =>
55 |                 {
56 |                     table.PrimaryKey("PK_BlogPostTag", x => new { x.BlogPostsId, x.TagsId });
57 |                     table.ForeignKey(
58 |                         name: "FK_BlogPostTag_BlogPosts_BlogPostsId",
59 |                         column: x => x.BlogPostsId,
60 |                         principalTable: "BlogPosts",
61 |                         principalColumn: "Id",
62 |                         onDelete: ReferentialAction.Cascade);
63 |                     table.ForeignKey(
64 |                         name: "FK_BlogPostTag_Tags_TagsId",
65 |                         column: x => x.TagsId,
66 |                         principalTable: "Tags",
67 |                         principalColumn: "Id",
68 |                         onDelete: ReferentialAction.Cascade);
69 |                 });
70 | 
71 |             migrationBuilder.CreateIndex(
72 |                 name: "IX_BlogPostTag_TagsId",
73 |                 table: "BlogPostTag",
74 |                 column: "TagsId");
75 |         }
76 | 
77 |         /// <inheritdoc />
78 |         protected override void Down(MigrationBuilder migrationBuilder)
79 |         {
80 |             migrationBuilder.DropTable(
81 |                 name: "BlogPostTag");
82 | 
83 |             migrationBuilder.DropTable(
84 |                 name: "BlogPosts");
85 | 
86 |             migrationBuilder.DropTable(
87 |                 name: "Tags");
88 |         }
89 |     }
90 | }
91 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Views/AdminBlogPosts/Add.cshtml:
--------------------------------------------------------------------------------
  1 | @model Bloggie.Web.Models.ViewModels.AddBlogPostRequest
  2 | @{
  3 | }
  4 | 
  5 | <div class="bg-secondary bg-opacity-10 py-2">
  6 |     <div class="container">
  7 |         <h1>Add New BlogPost - Admin Functionality</h1>
  8 |     </div>
  9 | </div>
 10 | 
 11 | <div class="container py-5">
 12 |     <form method="post">
 13 | 
 14 |         <div class="mb-3">
 15 |             <label class="form-label">Heading</label>
 16 |             <input type="text" class="form-control" id="heading" asp-for="Heading" />
 17 |         </div>
 18 | 
 19 |         <div class="mb-3">
 20 |             <label class="form-label">Page Title</label>
 21 |             <input type="text" class="form-control" id="pageTitle" asp-for="PageTitle" />
 22 |         </div>
 23 | 
 24 |         <div class="mb-3">
 25 |             <label class="form-label">Content</label>
 26 |             <textarea class="form-control" id="content" asp-for="Content"></textarea>
 27 |         </div>
 28 | 
 29 |         <div class="mb-3">
 30 |             <label class="form-label">Short Description</label>
 31 |             <input type="text" class="form-control" id="shortDescription" asp-for="ShortDescription" />
 32 |         </div>
 33 | 
 34 |         <div class="mb-3">
 35 |             <label class="form-label">Featured Image Upload</label>
 36 |             <input type="file" id="featuredImageUpload" class="form-control" />
 37 | 
 38 |             <img src="" id="featuredImageDisplay" style="display:none;width: 300px;" />
 39 |         </div>
 40 | 
 41 |         <div class="mb-3">
 42 |             <label class="form-label">Featured Image URL</label>
 43 |             <input type="text" class="form-control" id="featuredImageUrl" asp-for="FeaturedImageUrl" />
 44 |         </div>
 45 | 
 46 |         <div class="mb-3">
 47 |             <label class="form-label">URL Handle</label>
 48 |             <input type="text" class="form-control" id="urlHandle" asp-for="UrlHandle" />
 49 |         </div>
 50 | 
 51 |         <div class="mb-3">
 52 |             <label class="form-label">Published Date</label>
 53 |             <input type="date" class="form-control" id="publishedDate" asp-for="PublishedDate" />
 54 |         </div>
 55 | 
 56 |         <div class="mb-3">
 57 |             <label class="form-label">Author</label>
 58 |             <input type="text" class="form-control" id="author" asp-for="Author" />
 59 |         </div>
 60 | 
 61 |         <div class="form-check mb-3">
 62 |             <input class="form-check-input" type="checkbox" id="visible" asp-for="Visible">
 63 |             <label class="form-check-label">
 64 |                 Is Visible?
 65 |             </label>
 66 |         </div>
 67 | 
 68 |         <div class="mb-3">
 69 |             <label class="form-label">Tags</label>
 70 |             <select class="form-select"
 71 |                     asp-items="@Model.Tags"
 72 |                     asp-for="SelectedTags">
 73 |             </select>
 74 |         </div>
 75 | 
 76 | 
 77 |         <div class="mb-3">
 78 |             <button type="submit" class="btn btn-dark">
 79 |                 Save
 80 |             </button>
 81 |         </div>
 82 | 
 83 | 
 84 |     </form>
 85 | </div>
 86 | 
 87 | 
 88 | @section Scripts {
 89 |     <script>
 90 |         var editor = new FroalaEditor('#content', {
 91 |             imageUploadURL: '/api/images'
 92 |         });
 93 | 
 94 | 
 95 |         const featuredUploadElement = document.getElementById('featuredImageUpload');
 96 |         const featuredImageUrlElement = document.getElementById('featuredImageUrl');
 97 |         const featuredImageDisplayElement = document.getElementById('featuredImageDisplay');
 98 | 
 99 | 
100 |         async function uploadFeaturedImage(e) {
101 |             console.log(e.target.files[0]);
102 | 
103 |             let data = new FormData();
104 |             data.append('file', e.target.files[0]);
105 | 
106 |             await fetch('/api/images', {
107 |                 method: 'POST',
108 |                 headers: {
109 |                     'Aceept': '*/*',
110 |                 },
111 |                 body: data
112 |             }).then(response => response.json())
113 |                 .then(result => {
114 |                     featuredImageUrlElement.value = result.link;
115 |                     featuredImageDisplayElement.src = result.link;
116 |                     featuredImageDisplayElement.style.display = 'block';
117 |                 });
118 |         }
119 | 
120 | 
121 |         featuredUploadElement.addEventListener('change', uploadFeaturedImage);
122 | 
123 |     </script>
124 | }


--------------------------------------------------------------------------------
/Bloggie.Web/wwwroot/lib/bootstrap/dist/css/bootstrap-reboot.min.css:
--------------------------------------------------------------------------------
1 | /*!
2 |  * Bootstrap Reboot v5.1.0 (https://getbootstrap.com/)
3 |  * Copyright 2011-2021 The Bootstrap Authors
4 |  * Copyright 2011-2021 Twitter, Inc.
5 |  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
6 |  * Forked from Normalize.css, licensed MIT (https://github.com/necolas/normalize.css/blob/master/LICENSE.md)
7 |  */*,::after,::before{box-sizing:border-box}@media (prefers-reduced-motion:no-preference){:root{scroll-behavior:smooth}}body{margin:0;font-family:var(--bs-body-font-family);font-size:var(--bs-body-font-size);font-weight:var(--bs-body-font-weight);line-height:var(--bs-body-line-height);color:var(--bs-body-color);text-align:var(--bs-body-text-align);background-color:var(--bs-body-bg);-webkit-text-size-adjust:100%;-webkit-tap-highlight-color:transparent}hr{margin:1rem 0;color:inherit;background-color:currentColor;border:0;opacity:.25}hr:not([size]){height:1px}h1,h2,h3,h4,h5,h6{margin-top:0;margin-bottom:.5rem;font-weight:500;line-height:1.2}h1{font-size:calc(1.375rem + 1.5vw)}@media (min-width:1200px){h1{font-size:2.5rem}}h2{font-size:calc(1.325rem + .9vw)}@media (min-width:1200px){h2{font-size:2rem}}h3{font-size:calc(1.3rem + .6vw)}@media (min-width:1200px){h3{font-size:1.75rem}}h4{font-size:calc(1.275rem + .3vw)}@media (min-width:1200px){h4{font-size:1.5rem}}h5{font-size:1.25rem}h6{font-size:1rem}p{margin-top:0;margin-bottom:1rem}abbr[data-bs-original-title],abbr[title]{-webkit-text-decoration:underline dotted;text-decoration:underline dotted;cursor:help;-webkit-text-decoration-skip-ink:none;text-decoration-skip-ink:none}address{margin-bottom:1rem;font-style:normal;line-height:inherit}ol,ul{padding-left:2rem}dl,ol,ul{margin-top:0;margin-bottom:1rem}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}dt{font-weight:700}dd{margin-bottom:.5rem;margin-left:0}blockquote{margin:0 0 1rem}b,strong{font-weight:bolder}small{font-size:.875em}mark{padding:.2em;background-color:#fcf8e3}sub,sup{position:relative;font-size:.75em;line-height:0;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}a{color:#0d6efd;text-decoration:underline}a:hover{color:#0a58ca}a:not([href]):not([class]),a:not([href]):not([class]):hover{color:inherit;text-decoration:none}code,kbd,pre,samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;font-size:1em;direction:ltr;unicode-bidi:bidi-override}pre{display:block;margin-top:0;margin-bottom:1rem;overflow:auto;font-size:.875em}pre code{font-size:inherit;color:inherit;word-break:normal}code{font-size:.875em;color:#d63384;word-wrap:break-word}a>code{color:inherit}kbd{padding:.2rem .4rem;font-size:.875em;color:#fff;background-color:#212529;border-radius:.2rem}kbd kbd{padding:0;font-size:1em;font-weight:700}figure{margin:0 0 1rem}img,svg{vertical-align:middle}table{caption-side:bottom;border-collapse:collapse}caption{padding-top:.5rem;padding-bottom:.5rem;color:#6c757d;text-align:left}th{text-align:inherit;text-align:-webkit-match-parent}tbody,td,tfoot,th,thead,tr{border-color:inherit;border-style:solid;border-width:0}label{display:inline-block}button{border-radius:0}button:focus:not(:focus-visible){outline:0}button,input,optgroup,select,textarea{margin:0;font-family:inherit;font-size:inherit;line-height:inherit}button,select{text-transform:none}[role=button]{cursor:pointer}select{word-wrap:normal}select:disabled{opacity:1}[list]::-webkit-calendar-picker-indicator{display:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]:not(:disabled),[type=reset]:not(:disabled),[type=submit]:not(:disabled),button:not(:disabled){cursor:pointer}::-moz-focus-inner{padding:0;border-style:none}textarea{resize:vertical}fieldset{min-width:0;padding:0;margin:0;border:0}legend{float:left;width:100%;padding:0;margin-bottom:.5rem;font-size:calc(1.275rem + .3vw);line-height:inherit}@media (min-width:1200px){legend{font-size:1.5rem}}legend+*{clear:left}::-webkit-datetime-edit-day-field,::-webkit-datetime-edit-fields-wrapper,::-webkit-datetime-edit-hour-field,::-webkit-datetime-edit-minute,::-webkit-datetime-edit-month-field,::-webkit-datetime-edit-text,::-webkit-datetime-edit-year-field{padding:0}::-webkit-inner-spin-button{height:auto}[type=search]{outline-offset:-2px;-webkit-appearance:textfield}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-color-swatch-wrapper{padding:0}::file-selector-button{font:inherit}::-webkit-file-upload-button{font:inherit;-webkit-appearance:button}output{display:inline-block}iframe{border:0}summary{display:list-item;cursor:pointer}progress{vertical-align:baseline}[hidden]{display:none!important}
8 | /*# sourceMappingURL=bootstrap-reboot.min.css.map */


--------------------------------------------------------------------------------
/Bloggie.Web/wwwroot/lib/bootstrap/dist/css/bootstrap-reboot.rtl.min.css:
--------------------------------------------------------------------------------
1 | /*!
2 |  * Bootstrap Reboot v5.1.0 (https://getbootstrap.com/)
3 |  * Copyright 2011-2021 The Bootstrap Authors
4 |  * Copyright 2011-2021 Twitter, Inc.
5 |  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
6 |  * Forked from Normalize.css, licensed MIT (https://github.com/necolas/normalize.css/blob/master/LICENSE.md)
7 |  */*,::after,::before{box-sizing:border-box}@media (prefers-reduced-motion:no-preference){:root{scroll-behavior:smooth}}body{margin:0;font-family:var(--bs-body-font-family);font-size:var(--bs-body-font-size);font-weight:var(--bs-body-font-weight);line-height:var(--bs-body-line-height);color:var(--bs-body-color);text-align:var(--bs-body-text-align);background-color:var(--bs-body-bg);-webkit-text-size-adjust:100%;-webkit-tap-highlight-color:transparent}hr{margin:1rem 0;color:inherit;background-color:currentColor;border:0;opacity:.25}hr:not([size]){height:1px}h1,h2,h3,h4,h5,h6{margin-top:0;margin-bottom:.5rem;font-weight:500;line-height:1.2}h1{font-size:calc(1.375rem + 1.5vw)}@media (min-width:1200px){h1{font-size:2.5rem}}h2{font-size:calc(1.325rem + .9vw)}@media (min-width:1200px){h2{font-size:2rem}}h3{font-size:calc(1.3rem + .6vw)}@media (min-width:1200px){h3{font-size:1.75rem}}h4{font-size:calc(1.275rem + .3vw)}@media (min-width:1200px){h4{font-size:1.5rem}}h5{font-size:1.25rem}h6{font-size:1rem}p{margin-top:0;margin-bottom:1rem}abbr[data-bs-original-title],abbr[title]{-webkit-text-decoration:underline dotted;text-decoration:underline dotted;cursor:help;-webkit-text-decoration-skip-ink:none;text-decoration-skip-ink:none}address{margin-bottom:1rem;font-style:normal;line-height:inherit}ol,ul{padding-right:2rem}dl,ol,ul{margin-top:0;margin-bottom:1rem}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}dt{font-weight:700}dd{margin-bottom:.5rem;margin-right:0}blockquote{margin:0 0 1rem}b,strong{font-weight:bolder}small{font-size:.875em}mark{padding:.2em;background-color:#fcf8e3}sub,sup{position:relative;font-size:.75em;line-height:0;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}a{color:#0d6efd;text-decoration:underline}a:hover{color:#0a58ca}a:not([href]):not([class]),a:not([href]):not([class]):hover{color:inherit;text-decoration:none}code,kbd,pre,samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;font-size:1em;direction:ltr;unicode-bidi:bidi-override}pre{display:block;margin-top:0;margin-bottom:1rem;overflow:auto;font-size:.875em}pre code{font-size:inherit;color:inherit;word-break:normal}code{font-size:.875em;color:#d63384;word-wrap:break-word}a>code{color:inherit}kbd{padding:.2rem .4rem;font-size:.875em;color:#fff;background-color:#212529;border-radius:.2rem}kbd kbd{padding:0;font-size:1em;font-weight:700}figure{margin:0 0 1rem}img,svg{vertical-align:middle}table{caption-side:bottom;border-collapse:collapse}caption{padding-top:.5rem;padding-bottom:.5rem;color:#6c757d;text-align:right}th{text-align:inherit;text-align:-webkit-match-parent}tbody,td,tfoot,th,thead,tr{border-color:inherit;border-style:solid;border-width:0}label{display:inline-block}button{border-radius:0}button:focus:not(:focus-visible){outline:0}button,input,optgroup,select,textarea{margin:0;font-family:inherit;font-size:inherit;line-height:inherit}button,select{text-transform:none}[role=button]{cursor:pointer}select{word-wrap:normal}select:disabled{opacity:1}[list]::-webkit-calendar-picker-indicator{display:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]:not(:disabled),[type=reset]:not(:disabled),[type=submit]:not(:disabled),button:not(:disabled){cursor:pointer}::-moz-focus-inner{padding:0;border-style:none}textarea{resize:vertical}fieldset{min-width:0;padding:0;margin:0;border:0}legend{float:right;width:100%;padding:0;margin-bottom:.5rem;font-size:calc(1.275rem + .3vw);line-height:inherit}@media (min-width:1200px){legend{font-size:1.5rem}}legend+*{clear:right}::-webkit-datetime-edit-day-field,::-webkit-datetime-edit-fields-wrapper,::-webkit-datetime-edit-hour-field,::-webkit-datetime-edit-minute,::-webkit-datetime-edit-month-field,::-webkit-datetime-edit-text,::-webkit-datetime-edit-year-field{padding:0}::-webkit-inner-spin-button{height:auto}[type=search]{outline-offset:-2px;-webkit-appearance:textfield}[type=email],[type=number],[type=tel],[type=url]{direction:ltr}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-color-swatch-wrapper{padding:0}::file-selector-button{font:inherit}::-webkit-file-upload-button{font:inherit;-webkit-appearance:button}output{display:inline-block}iframe{border:0}summary{display:list-item;cursor:pointer}progress{vertical-align:baseline}[hidden]{display:none!important}
8 | /*# sourceMappingURL=bootstrap-reboot.rtl.min.css.map */


--------------------------------------------------------------------------------
/Bloggie.Web/Views/AdminUsers/List.cshtml:
--------------------------------------------------------------------------------
  1 | @model Bloggie.Web.Models.ViewModels.UserViewModel
  2 | 
  3 | @{
  4 | }
  5 | 
  6 | 
  7 | <div class="bg-secondary bg-opacity-10 py-2">
  8 |     <div class="container">
  9 |         <h1>Users - Admin Functionality</h1>
 10 |     </div>
 11 | </div>
 12 | 
 13 | <div>
 14 |     <div class="container py-5">
 15 | 
 16 |         <div class="mb-3 d-flex justify-content-end">
 17 |             <button type="button" class="btn btn-dark" data-bs-toggle="modal" data-bs-target="#modalCreateUser">
 18 |                 Create User
 19 |             </button>
 20 |         </div>
 21 | 
 22 | 
 23 |         @if (Model.Users is not null || Model.Users.Any())
 24 |         {
 25 |             <table class="table">
 26 |                 <thead>
 27 |                     <tr>
 28 |                         <th>Id</th>
 29 |                         <th>Username</th>
 30 |                         <th>Email</th>
 31 |                         <th> </th>
 32 |                     </tr>
 33 |                 </thead>
 34 |                 <tbody>
 35 |                     @foreach (var user in Model.Users)
 36 |                     {
 37 |                         <tr>
 38 |                             <td>@user.Id</td>
 39 |                             <td>@user.Username</td>
 40 |                             <td>@user.EmailAddress</td>
 41 |                             <td>
 42 |                                 <form method="post" 
 43 |                                       asp-controller="AdminUsers" 
 44 |                                       asp-action="Delete" 
 45 |                                       asp-route-id="@user.Id">
 46 |                                     <button class="btn btn-danger" type="submit">Delete</button>
 47 |                                 </form>
 48 |                             </td>
 49 |                         </tr>
 50 |                     }
 51 |                 </tbody>
 52 |             </table>
 53 |         }
 54 |         else
 55 |         {
 56 |             <p>No users found!</p>
 57 |         }
 58 | 
 59 | 
 60 | 
 61 |     </div>
 62 | </div>
 63 | 
 64 | 
 65 | <!-- Modal -->
 66 | <form method="post">
 67 |     <div class="modal fade" id="modalCreateUser" tabindex="-1" aria-labelledby="exampleModalLabel" aria-hidden="true">
 68 |         <div class="modal-dialog">
 69 |             <div class="modal-content">
 70 |                 <div class="modal-header">
 71 |                     <h1 class="modal-title fs-5" id="exampleModalLabel">Create New User</h1>
 72 |                     <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
 73 |                 </div>
 74 |                 <div class="modal-body">
 75 |                     <div class="mb-3">
 76 |                         <label class="form-label">Username</label>
 77 |                         <input type="text" class="form-control" asp-for="Username" />
 78 |                     </div>
 79 |                     <div class="mb-3">
 80 |                         <label class="form-label">Email Address</label>
 81 |                         <input type="text" class="form-control" asp-for="Email" />
 82 |                     </div>
 83 |                     <div class="mb-3">
 84 |                         <label class="form-label">Password</label>
 85 |                         <input type="password" class="form-control" asp-for="Password" />
 86 |                     </div>
 87 |                     <div class="mb-3">
 88 |                         <div class="form-check">
 89 |                             <input type="checkbox" id="chkUserRole" class="form-check-input" value="User" checked disabled />
 90 |                             <label class="form-check-label" for="chkUserRole">User Role</label>
 91 |                         </div>
 92 | 
 93 |                         @if (User.IsInRole("SuperAdmin"))
 94 |                         {
 95 |                             <div class="form-check">
 96 |                                 <input type="checkbox" id="chkAdminRole" class="form-check-input"
 97 |                                        asp-for="AdminRoleCheckbox" />
 98 |                                 <label class="form-check-label" for="chkAdminRole">Admin Role</label>
 99 |                             </div>
100 |                         }
101 | 
102 |                     </div>
103 |                 </div>
104 |                 <div class="modal-footer">
105 |                     <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Close</button>
106 |                     <button type="submit" class="btn btn-primary">Save changes</button>
107 |                 </div>
108 |             </div>
109 |         </div>
110 |     </div>
111 | 
112 | </form>


--------------------------------------------------------------------------------
/Bloggie.Web/Migrations/20230216015207_Initial Migration.Designer.cs:
--------------------------------------------------------------------------------
  1 | // <auto-generated />
  2 | using System;
  3 | using Bloggie.Web.Data;
  4 | using Microsoft.EntityFrameworkCore;
  5 | using Microsoft.EntityFrameworkCore.Infrastructure;
  6 | using Microsoft.EntityFrameworkCore.Metadata;
  7 | using Microsoft.EntityFrameworkCore.Migrations;
  8 | using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
  9 | 
 10 | #nullable disable
 11 | 
 12 | namespace Bloggie.Web.Migrations
 13 | {
 14 |     [DbContext(typeof(BloggieDbContext))]
 15 |     [Migration("20230216015207_Initial Migration")]
 16 |     partial class InitialMigration
 17 |     {
 18 |         /// <inheritdoc />
 19 |         protected override void BuildTargetModel(ModelBuilder modelBuilder)
 20 |         {
 21 | #pragma warning disable 612, 618
 22 |             modelBuilder
 23 |                 .HasAnnotation("ProductVersion", "7.0.3")
 24 |                 .HasAnnotation("Relational:MaxIdentifierLength", 128);
 25 | 
 26 |             SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
 27 | 
 28 |             modelBuilder.Entity("BlogPostTag", b =>
 29 |                 {
 30 |                     b.Property<Guid>("BlogPostsId")
 31 |                         .HasColumnType("uniqueidentifier");
 32 | 
 33 |                     b.Property<Guid>("TagsId")
 34 |                         .HasColumnType("uniqueidentifier");
 35 | 
 36 |                     b.HasKey("BlogPostsId", "TagsId");
 37 | 
 38 |                     b.HasIndex("TagsId");
 39 | 
 40 |                     b.ToTable("BlogPostTag");
 41 |                 });
 42 | 
 43 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPost", b =>
 44 |                 {
 45 |                     b.Property<Guid>("Id")
 46 |                         .ValueGeneratedOnAdd()
 47 |                         .HasColumnType("uniqueidentifier");
 48 | 
 49 |                     b.Property<string>("Author")
 50 |                         .IsRequired()
 51 |                         .HasColumnType("nvarchar(max)");
 52 | 
 53 |                     b.Property<string>("Content")
 54 |                         .IsRequired()
 55 |                         .HasColumnType("nvarchar(max)");
 56 | 
 57 |                     b.Property<string>("FeaturedImageUrl")
 58 |                         .IsRequired()
 59 |                         .HasColumnType("nvarchar(max)");
 60 | 
 61 |                     b.Property<string>("Heading")
 62 |                         .IsRequired()
 63 |                         .HasColumnType("nvarchar(max)");
 64 | 
 65 |                     b.Property<string>("PageTitle")
 66 |                         .IsRequired()
 67 |                         .HasColumnType("nvarchar(max)");
 68 | 
 69 |                     b.Property<DateTime>("PublishedDate")
 70 |                         .HasColumnType("datetime2");
 71 | 
 72 |                     b.Property<string>("ShortDescription")
 73 |                         .IsRequired()
 74 |                         .HasColumnType("nvarchar(max)");
 75 | 
 76 |                     b.Property<string>("UrlHandle")
 77 |                         .IsRequired()
 78 |                         .HasColumnType("nvarchar(max)");
 79 | 
 80 |                     b.Property<bool>("Visible")
 81 |                         .HasColumnType("bit");
 82 | 
 83 |                     b.HasKey("Id");
 84 | 
 85 |                     b.ToTable("BlogPosts");
 86 |                 });
 87 | 
 88 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.Tag", b =>
 89 |                 {
 90 |                     b.Property<Guid>("Id")
 91 |                         .ValueGeneratedOnAdd()
 92 |                         .HasColumnType("uniqueidentifier");
 93 | 
 94 |                     b.Property<string>("DisplayName")
 95 |                         .IsRequired()
 96 |                         .HasColumnType("nvarchar(max)");
 97 | 
 98 |                     b.Property<string>("Name")
 99 |                         .IsRequired()
100 |                         .HasColumnType("nvarchar(max)");
101 | 
102 |                     b.HasKey("Id");
103 | 
104 |                     b.ToTable("Tags");
105 |                 });
106 | 
107 |             modelBuilder.Entity("BlogPostTag", b =>
108 |                 {
109 |                     b.HasOne("Bloggie.Web.Models.Domain.BlogPost", null)
110 |                         .WithMany()
111 |                         .HasForeignKey("BlogPostsId")
112 |                         .OnDelete(DeleteBehavior.Cascade)
113 |                         .IsRequired();
114 | 
115 |                     b.HasOne("Bloggie.Web.Models.Domain.Tag", null)
116 |                         .WithMany()
117 |                         .HasForeignKey("TagsId")
118 |                         .OnDelete(DeleteBehavior.Cascade)
119 |                         .IsRequired();
120 |                 });
121 | #pragma warning restore 612, 618
122 |         }
123 |     }
124 | }
125 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Controllers/BlogsController.cs:
--------------------------------------------------------------------------------
  1 | using Bloggie.Web.Models.Domain;
  2 | using Bloggie.Web.Models.ViewModels;
  3 | using Bloggie.Web.Repositories;
  4 | using Microsoft.AspNetCore.Identity;
  5 | using Microsoft.AspNetCore.Mvc;
  6 | 
  7 | namespace Bloggie.Web.Controllers
  8 | {
  9 |     public class BlogsController : Controller
 10 |     {
 11 |         private readonly IBlogPostRepository blogPostRepository;
 12 |         private readonly IBlogPostLikeRepository blogPostLikeRepository;
 13 |         private readonly SignInManager<IdentityUser> signInManager;
 14 |         private readonly UserManager<IdentityUser> userManager;
 15 |         private readonly IBlogPostCommentRepository blogPostCommentRepository;
 16 | 
 17 |         public BlogsController(IBlogPostRepository blogPostRepository,
 18 |             IBlogPostLikeRepository blogPostLikeRepository,
 19 |             SignInManager<IdentityUser> signInManager,
 20 |             UserManager<IdentityUser> userManager,
 21 |             IBlogPostCommentRepository blogPostCommentRepository)
 22 |         {
 23 |             this.blogPostRepository = blogPostRepository;
 24 |             this.blogPostLikeRepository = blogPostLikeRepository;
 25 |             this.signInManager = signInManager;
 26 |             this.userManager = userManager;
 27 |             this.blogPostCommentRepository = blogPostCommentRepository;
 28 |         }
 29 | 
 30 | 
 31 |         [HttpGet]
 32 |         public async Task<IActionResult> Index(string urlHandle)
 33 |         {
 34 |             var liked = false;
 35 |             var blogPost = await blogPostRepository.GetByUrlHandleAsync(urlHandle);
 36 |             var blogDetailsViewModel = new BlogDetailsViewModel();
 37 | 
 38 |             if (blogPost != null)
 39 |             {
 40 |                 var totalLikes = await blogPostLikeRepository.GetTotalLikes(blogPost.Id);
 41 | 
 42 |                 if (signInManager.IsSignedIn(User))
 43 |                 {
 44 |                     // Get like for this blog for this user
 45 |                     var likesForBlog = await blogPostLikeRepository.GetLikesForBlog(blogPost.Id);
 46 | 
 47 |                     var userId = userManager.GetUserId(User);
 48 | 
 49 |                     if (userId != null)
 50 |                     {
 51 |                         var likeFromUser = likesForBlog.FirstOrDefault(x => x.UserId == Guid.Parse(userId));
 52 |                         liked = likeFromUser != null;
 53 |                     }
 54 | 
 55 | 
 56 |                 }
 57 | 
 58 |                 // Get comments for blog post
 59 |                 var blogCommentsDomainModel = await blogPostCommentRepository.GetCommentsByBlogIdAsync(blogPost.Id);
 60 | 
 61 |                 var blogCommentsForView = new List<BlogComment>();
 62 | 
 63 |                 foreach (var blogComment in blogCommentsDomainModel)
 64 |                 {
 65 |                     blogCommentsForView.Add(new BlogComment
 66 |                     {
 67 |                         Description = blogComment.Description,
 68 |                         DateAdded = blogComment.DateAdded,
 69 |                         Username = (await userManager.FindByIdAsync(blogComment.UserId.ToString())).UserName
 70 |                     });
 71 |                 }
 72 | 
 73 |                 blogDetailsViewModel = new BlogDetailsViewModel
 74 |                 {
 75 |                     Id = blogPost.Id,
 76 |                     Content = blogPost.Content,
 77 |                     PageTitle = blogPost.PageTitle,
 78 |                     Author = blogPost.Author,
 79 |                     FeaturedImageUrl = blogPost.FeaturedImageUrl,
 80 |                     Heading = blogPost.Heading,
 81 |                     PublishedDate = blogPost.PublishedDate,
 82 |                     ShortDescription = blogPost.ShortDescription,
 83 |                     UrlHandle = blogPost.UrlHandle,
 84 |                     Visible = blogPost.Visible,
 85 |                     Tags = blogPost.Tags,
 86 |                     TotalLikes = totalLikes,
 87 |                     Liked = liked,
 88 |                     Comments = blogCommentsForView
 89 |                 };
 90 | 
 91 |             }
 92 | 
 93 |             return View(blogDetailsViewModel);
 94 |         }
 95 | 
 96 | 
 97 |         [HttpPost]
 98 |         public async Task<IActionResult> Index(BlogDetailsViewModel blogDetailsViewModel)
 99 |         {
100 |             if (signInManager.IsSignedIn(User))
101 |             {
102 |                 var domainModel = new BlogPostComment
103 |                 {
104 |                     BlogPostId = blogDetailsViewModel.Id,
105 |                     Description = blogDetailsViewModel.CommentDescription,
106 |                     UserId = Guid.Parse(userManager.GetUserId(User)),
107 |                     DateAdded = DateTime.Now
108 |                 };
109 | 
110 |                 await blogPostCommentRepository.AddAsync(domainModel);
111 |                 return RedirectToAction("Index", "Blogs", 
112 |                     new { urlHandle = blogDetailsViewModel.UrlHandle });
113 |             }
114 | 
115 |             return View();
116 |         }
117 |     }
118 | }
119 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Controllers/AdminTagsController.cs:
--------------------------------------------------------------------------------
  1 | using Bloggie.Web.Data;
  2 | using Bloggie.Web.Models.Domain;
  3 | using Bloggie.Web.Models.ViewModels;
  4 | using Bloggie.Web.Repositories;
  5 | using Microsoft.AspNetCore.Authorization;
  6 | using Microsoft.AspNetCore.Mvc;
  7 | using Microsoft.EntityFrameworkCore;
  8 | 
  9 | namespace Bloggie.Web.Controllers
 10 | {
 11 |     [Authorize(Roles = "Admin")]
 12 |     public class AdminTagsController : Controller
 13 |     {
 14 |         private readonly ITagRepository tagRepository;
 15 | 
 16 |         public AdminTagsController(ITagRepository tagRepository)
 17 |         {
 18 |             this.tagRepository = tagRepository;
 19 |         }
 20 | 
 21 |         [HttpGet]
 22 |         public IActionResult Add()
 23 |         {
 24 |             return View();
 25 |         }
 26 | 
 27 |         [HttpPost]
 28 |         [ActionName("Add")]
 29 |         public async Task<IActionResult> Add(AddTagRequest addTagRequest)
 30 |         {
 31 |             ValidateAddTagRequest(addTagRequest);
 32 |             
 33 |             if (ModelState.IsValid == false)
 34 |             {
 35 |                 return View();
 36 |             }
 37 | 
 38 |             // Mapping AddTagRequest to Tag domain model
 39 |             var tag = new Tag
 40 |             {
 41 |                 Name = addTagRequest.Name,
 42 |                 DisplayName = addTagRequest.DisplayName
 43 |             };
 44 | 
 45 |             await tagRepository.AddAsync(tag);
 46 | 
 47 |             return RedirectToAction("List");
 48 |         }
 49 | 
 50 |         [HttpGet]
 51 |         [ActionName("List")]
 52 |         public async Task<IActionResult> List(
 53 |             string? searchQuery, 
 54 |             string? sortBy, 
 55 |             string? sortDirection,
 56 |             int pageSize = 3,
 57 |             int pageNumber = 1)
 58 |         {
 59 |             var totalRecords = await tagRepository.CountAsync();
 60 |             var totalPages = Math.Ceiling((decimal)totalRecords / pageSize);
 61 | 
 62 |             if (pageNumber > totalPages)
 63 |             {
 64 |                 pageNumber--;
 65 |             }
 66 | 
 67 |             if (pageNumber < 1)
 68 |             {
 69 |                 pageNumber++;
 70 |             }
 71 | 
 72 | 
 73 |             ViewBag.TotalPages = totalPages;
 74 |             ViewBag.SearchQuery = searchQuery;
 75 |             ViewBag.SortBy = sortBy;
 76 |             ViewBag.SortDirection = sortDirection;
 77 |             ViewBag.PageSize = pageSize;
 78 |             ViewBag.PageNumber = pageNumber;
 79 | 
 80 |             // use dbContext to read the tags
 81 |             var tags = await tagRepository.GetAllAsync(searchQuery, sortBy, sortDirection, pageNumber, pageSize);
 82 | 
 83 |             return View(tags);
 84 |         }
 85 | 
 86 |         [HttpGet]
 87 |         public async Task<IActionResult> Edit(Guid id)
 88 |         {
 89 |             var tag = await tagRepository.GetAsync(id);
 90 |             
 91 |             if (tag != null)
 92 |             {
 93 |                 var editTagRequest = new EditTagRequest
 94 |                 {
 95 |                     Id = tag.Id,
 96 |                     Name = tag.Name,
 97 |                     DisplayName = tag.DisplayName
 98 |                 };
 99 | 
100 |                 return View(editTagRequest);
101 |             }
102 | 
103 |             return View(null);
104 |         }
105 | 
106 |         [HttpPost]
107 |         public async Task<IActionResult> Edit(EditTagRequest editTagRequest)
108 |         {
109 |             var tag = new Tag
110 |             {
111 |                 Id = editTagRequest.Id,
112 |                 Name = editTagRequest.Name,
113 |                 DisplayName = editTagRequest.DisplayName
114 |             };
115 | 
116 |             var updatedTag = await tagRepository.UpdateAsync(tag);
117 | 
118 |             if (updatedTag != null)
119 |             {
120 |                 // Show success notification
121 |             }
122 |             else
123 |             {
124 |                 // Show error notification
125 |             }
126 | 
127 |             return RedirectToAction("Edit", new { id = editTagRequest.Id });
128 |         }
129 | 
130 |         [HttpPost]
131 |         public async Task<IActionResult> Delete(EditTagRequest editTagRequest)
132 |         {
133 |             var deletedTag = await tagRepository.DeleteAsync(editTagRequest.Id);
134 | 
135 |             if (deletedTag != null)
136 |             {
137 |                 // Show success notification
138 |                 return RedirectToAction("List");
139 |             }
140 | 
141 |             // Show an error notification
142 |             return RedirectToAction("Edit", new { id = editTagRequest.Id });
143 |         }
144 | 
145 | 
146 |         private void ValidateAddTagRequest(AddTagRequest request)
147 |         {
148 |             if (request.Name is not null && request.DisplayName is not null)
149 |             {
150 |                 if (request.Name == request.DisplayName)
151 |                 {
152 |                     ModelState.AddModelError("DisplayName", "Name cannot be the same as DisplayName");
153 |                 }
154 |             }
155 |         }
156 |     }
157 | }
158 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Views/AdminBlogPosts/Edit.cshtml:
--------------------------------------------------------------------------------
  1 | @model Bloggie.Web.Models.ViewModels.EditBlogPostRequest
  2 | 
  3 | @{
  4 | }
  5 | 
  6 | <div class="bg-secondary bg-opacity-10 py-2">
  7 |     <div class="container">
  8 |         <h1>Edit BlogPost - Admin Functionality</h1>
  9 |     </div>
 10 | </div>
 11 | 
 12 | <div class="container py-5">
 13 |     @if (Model != null)
 14 |     {
 15 |         <form method="post">
 16 | 
 17 |             <div class="mb-3">
 18 |                 <label class="form-label">Id</label>
 19 |                 <input type="text" class="form-control" id="id" asp-for="Id" readonly />
 20 |             </div>
 21 | 
 22 |             <div class="mb-3">
 23 |                 <label class="form-label">Heading</label>
 24 |                 <input type="text" class="form-control" id="heading" asp-for="Heading" />
 25 |             </div>
 26 | 
 27 |             <div class="mb-3">
 28 |                 <label class="form-label">Page Title</label>
 29 |                 <input type="text" class="form-control" id="pageTitle" asp-for="PageTitle" />
 30 |             </div>
 31 | 
 32 |             <div class="mb-3">
 33 |                 <label class="form-label">Content</label>
 34 |                 <textarea class="form-control" id="content" asp-for="Content"></textarea>
 35 |             </div>
 36 | 
 37 |             <div class="mb-3">
 38 |                 <label class="form-label">Short Description</label>
 39 |                 <input type="text" class="form-control" id="shortDescription" asp-for="ShortDescription" />
 40 |             </div>
 41 | 
 42 |             <div class="mb-3">
 43 |                 <label class="form-label">Featured Image Upload</label>
 44 |                 <input type="file" id="featuredImageUpload" class="form-control" />
 45 | 
 46 |                 @if (Model.FeaturedImageUrl != null)
 47 |                 {
 48 |                     <img src="@Model.FeaturedImageUrl" id="featuredImageDisplay" style="display:block;width: 300px;" />
 49 |                 }
 50 |                 else
 51 |                 {
 52 |                     <img src="" id="featuredImageDisplay" style="display:none;width: 300px;" />
 53 |                 }
 54 |             </div>
 55 | 
 56 |             <div class="mb-3">
 57 |                 <label class="form-label">Featured Image URL</label>
 58 |                 <input type="text" class="form-control" id="featuredImageUrl" asp-for="FeaturedImageUrl" />
 59 |             </div>
 60 | 
 61 |             <div class="mb-3">
 62 |                 <label class="form-label">URL Handle</label>
 63 |                 <input type="text" class="form-control" id="urlHandle" asp-for="UrlHandle" />
 64 |             </div>
 65 | 
 66 |             <div class="mb-3">
 67 |                 <label class="form-label">Published Date</label>
 68 |                 <input type="date" class="form-control" id="publishedDate" asp-for="PublishedDate" />
 69 |             </div>
 70 | 
 71 |             <div class="mb-3">
 72 |                 <label class="form-label">Author</label>
 73 |                 <input type="text" class="form-control" id="author" asp-for="Author" />
 74 |             </div>
 75 | 
 76 |             <div class="form-check mb-3">
 77 |                 <input class="form-check-input" type="checkbox" id="visible" asp-for="Visible">
 78 |                 <label class="form-check-label">
 79 |                     Is Visible?
 80 |                 </label>
 81 |             </div>
 82 | 
 83 |             <div class="mb-3">
 84 |                 <label class="form-label">Tags</label>
 85 |                 <select class="form-select"
 86 |                         asp-items="@Model.Tags"
 87 |                         asp-for="SelectedTags">
 88 |                 </select>
 89 |             </div>
 90 | 
 91 |             <div class="mb-3 d-flex">
 92 |                 <button type="submit" class="btn btn-dark">Update</button>
 93 | 
 94 |                 <button type="submit"
 95 |                         class="btn btn-danger ms-2"
 96 |                         asp-area=""
 97 |                         asp-controller="AdminBlogPosts"
 98 |                         asp-action="Delete">
 99 |                     Delete
100 |                 </button>
101 |             </div>
102 | 
103 |         </form>
104 |     }
105 | 
106 |     else
107 |     {
108 |         <p>No blog post found!</p>
109 | 
110 |     }
111 | 
112 | 
113 | </div>
114 | 
115 | 
116 | @section Scripts {
117 |     <script>
118 |         var editor = new FroalaEditor('#content', {
119 |             imageUploadURL: '/api/images'
120 |         });
121 | 
122 | 
123 |         const featuredUploadElement = document.getElementById('featuredImageUpload');
124 |         const featuredImageUrlElement = document.getElementById('featuredImageUrl');
125 |         const featuredImageDisplayElement = document.getElementById('featuredImageDisplay');
126 | 
127 | 
128 |         async function uploadFeaturedImage(e) {
129 |             console.log(e.target.files[0]);
130 | 
131 |             let data = new FormData();
132 |             data.append('file', e.target.files[0]);
133 | 
134 |             await fetch('/api/images', {
135 |                 method: 'POST',
136 |                 headers: {
137 |                     'Aceept': '*/*',
138 |                 },
139 |                 body: data
140 |             }).then(response => response.json())
141 |                 .then(result => {
142 |                     featuredImageUrlElement.value = result.link;
143 |                     featuredImageDisplayElement.src = result.link;
144 |                     featuredImageDisplayElement.style.display = 'block';
145 |                 });
146 |         }
147 | 
148 | 
149 |         featuredUploadElement.addEventListener('change', uploadFeaturedImage);
150 | 
151 | 
152 |     </script>
153 | }


--------------------------------------------------------------------------------
/Bloggie.Web/wwwroot/lib/jquery-validation-unobtrusive/jquery.validate.unobtrusive.min.js:
--------------------------------------------------------------------------------
1 | /**
2 |  * @license
3 |  * Unobtrusive validation support library for jQuery and jQuery Validate
4 |  * Copyright (c) .NET Foundation. All rights reserved.
5 |  * Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
6 |  * @version v4.0.0
7 |  */
8 | !function(a){"function"==typeof define&&define.amd?define("jquery.validate.unobtrusive",["jquery-validation"],a):"object"==typeof module&&module.exports?module.exports=a(require("jquery-validation")):jQuery.validator.unobtrusive=a(jQuery)}(function(s){var a,o=s.validator,d="unobtrusiveValidation";function l(a,e,n){a.rules[e]=n,a.message&&(a.messages[e]=a.message)}function u(a){return a.replace(/([!"#$%&'()*+,./:;<=>?@\[\\\]^`{|}~])/g,"\\$1")}function n(a){return a.substr(0,a.lastIndexOf(".")+1)}function m(a,e){return a=0===a.indexOf("*.")?a.replace("*.",e):a}function f(a){var e=s(this),n="__jquery_unobtrusive_validation_form_reset";if(!e.data(n)){e.data(n,!0);try{e.data("validator").resetForm()}finally{e.removeData(n)}e.find(".validation-summary-errors").addClass("validation-summary-valid").removeClass("validation-summary-errors"),e.find(".field-validation-error").addClass("field-validation-valid").removeClass("field-validation-error").removeData("unobtrusiveContainer").find(">*").removeData("unobtrusiveContainer")}}function p(n){function a(a,e){(a=r[a])&&s.isFunction(a)&&a.apply(n,e)}var e=s(n),t=e.data(d),i=s.proxy(f,n),r=o.unobtrusive.options||{};return t||(t={options:{errorClass:r.errorClass||"input-validation-error",errorElement:r.errorElement||"span",errorPlacement:function(){!function(a,e){var e=s(this).find("[data-valmsg-for='"+u(e[0].name)+"']"),n=(n=e.attr("data-valmsg-replace"))?!1!==s.parseJSON(n):null;e.removeClass("field-validation-valid").addClass("field-validation-error"),a.data("unobtrusiveContainer",e),n?(e.empty(),a.removeClass("input-validation-error").appendTo(e)):a.hide()}.apply(n,arguments),a("errorPlacement",arguments)},invalidHandler:function(){!function(a,e){var n=s(this).find("[data-valmsg-summary=true]"),t=n.find("ul");t&&t.length&&e.errorList.length&&(t.empty(),n.addClass("validation-summary-errors").removeClass("validation-summary-valid"),s.each(e.errorList,function(){s("<li />").html(this.message).appendTo(t)}))}.apply(n,arguments),a("invalidHandler",arguments)},messages:{},rules:{},success:function(){!function(a){var e,n=a.data("unobtrusiveContainer");n&&(e=(e=n.attr("data-valmsg-replace"))?s.parseJSON(e):null,n.addClass("field-validation-valid").removeClass("field-validation-error"),a.removeData("unobtrusiveContainer"),e&&n.empty())}.apply(n,arguments),a("success",arguments)}},attachValidation:function(){e.off("reset."+d,i).on("reset."+d,i).validate(this.options)},validate:function(){return e.validate(),e.valid()}},e.data(d,t)),t}return o.unobtrusive={adapters:[],parseElement:function(t,a){var e,i,r,o=s(t),d=o.parents("form")[0];d&&((e=p(d)).options.rules[t.name]=i={},e.options.messages[t.name]=r={},s.each(this.adapters,function(){var a="data-val-"+this.name,e=o.attr(a),n={};void 0!==e&&(a+="-",s.each(this.params,function(){n[this]=o.attr(a+this)}),this.adapt({element:t,form:d,message:e,params:n,rules:i,messages:r}))}),s.extend(i,{__dummy__:!0}),a||e.attachValidation())},parse:function(a){var a=s(a),e=a.parents().addBack().filter("form").add(a.find("form")).has("[data-val=true]");a.find("[data-val=true]").each(function(){o.unobtrusive.parseElement(this,!0)}),e.each(function(){var a=p(this);a&&a.attachValidation()})}},(a=o.unobtrusive.adapters).add=function(a,e,n){return n||(n=e,e=[]),this.push({name:a,params:e,adapt:n}),this},a.addBool=function(e,n){return this.add(e,function(a){l(a,n||e,!0)})},a.addMinMax=function(a,t,i,r,e,n){return this.add(a,[e||"min",n||"max"],function(a){var e=a.params.min,n=a.params.max;e&&n?l(a,r,[e,n]):e?l(a,t,e):n&&l(a,i,n)})},a.addSingleVal=function(e,n,t){return this.add(e,[n||"val"],function(a){l(a,t||e,a.params[n])})},o.addMethod("__dummy__",function(a,e,n){return!0}),o.addMethod("regex",function(a,e,n){return!!this.optional(e)||(e=new RegExp(n).exec(a))&&0===e.index&&e[0].length===a.length}),o.addMethod("nonalphamin",function(a,e,n){var t;return t=n?(t=a.match(/\W/g))&&t.length>=n:t}),o.methods.extension?(a.addSingleVal("accept","mimtype"),a.addSingleVal("extension","extension")):a.addSingleVal("extension","extension","accept"),a.addSingleVal("regex","pattern"),a.addBool("creditcard").addBool("date").addBool("digits").addBool("email").addBool("number").addBool("url"),a.addMinMax("length","minlength","maxlength","rangelength").addMinMax("range","min","max","range"),a.addMinMax("minlength","minlength").addMinMax("maxlength","minlength","maxlength"),a.add("equalto",["other"],function(a){var e=n(a.element.name),e=m(a.params.other,e);l(a,"equalTo",s(a.form).find(":input").filter("[name='"+u(e)+"']")[0])}),a.add("required",function(a){"INPUT"===a.element.tagName.toUpperCase()&&"CHECKBOX"===a.element.type.toUpperCase()||l(a,"required",!0)}),a.add("remote",["url","type","additionalfields"],function(t){var i={url:t.params.url,type:t.params.type||"GET",data:{}},r=n(t.element.name);s.each((t.params.additionalfields||t.element.name).replace(/^\s+|\s+$/g,"").split(/\s*,\s*/g),function(a,e){var n=m(e,r);i.data[n]=function(){var a=s(t.form).find(":input").filter("[name='"+u(n)+"']");return a.is(":checkbox")?a.filter(":checked").val()||a.filter(":hidden").val()||"":a.is(":radio")?a.filter(":checked").val()||"":a.val()}}),l(t,"remote",i)}),a.add("password",["min","nonalphamin","regex"],function(a){a.params.min&&l(a,"minlength",a.params.min),a.params.nonalphamin&&l(a,"nonalphamin",a.params.nonalphamin),a.params.regex&&l(a,"regex",a.params.regex)}),a.add("fileextensions",["extensions"],function(a){l(a,"extension",a.params.extensions)}),s(function(){o.unobtrusive.parse(document)}),o.unobtrusive});


--------------------------------------------------------------------------------
/Bloggie.Web/Views/Blogs/Index.cshtml:
--------------------------------------------------------------------------------
  1 | @using Microsoft.AspNetCore.Identity
  2 | @inject SignInManager<IdentityUser> signInManager
  3 | @inject UserManager<IdentityUser> userManager
  4 | 
  5 | @model Bloggie.Web.Models.ViewModels.BlogDetailsViewModel
  6 | 
  7 | @{
  8 |     ViewData["Title"] = Model.PageTitle;
  9 | }
 10 | 
 11 | 
 12 | <div class="container my-5">
 13 |     <div class="row justify-content-center">
 14 |         <div class="col-12 col-lg-6">
 15 | 
 16 |             @if (Model != null)
 17 |             {
 18 |                 <h1 class="mb-3">@Model.Heading</h1>
 19 | 
 20 |                 <div class="d-flex justify-content-between mb-3">
 21 |                     <span class="text-secondary">@Model.Author</span>
 22 |                     <span class="text-secondary">@Model.PublishedDate.ToShortDateString()</span>
 23 |                 </div>
 24 | 
 25 |                 <div class="mb-3">
 26 |                     @if (signInManager.IsSignedIn(User))
 27 |                     {
 28 |                         if (Model.Liked)
 29 |                         {
 30 |                             <a style="cursor: pointer;">
 31 |                                 <i class="bi bi-hand-thumbs-up-fill"></i>
 32 |                             </a>
 33 |                         }
 34 |                         else
 35 |                         {
 36 |                             <a id="btnLike" style="cursor: pointer;">
 37 |                                 <i class="bi bi-hand-thumbs-up"></i>
 38 |                             </a>
 39 |                         }
 40 |                     }
 41 | 
 42 |                     <span id="totalLikes">@Model.TotalLikes</span> likes
 43 |                 </div>
 44 | 
 45 |                 <div class="mb-3 d-flex">
 46 |                     @foreach (var tag in Model.Tags)
 47 |                     {
 48 |                         <span class="badge bg-secondary me-1">@tag.Name</span>
 49 |                     }
 50 |                 </div>
 51 | 
 52 |                 <img src="@Model.FeaturedImageUrl" class="d-block img-fluid mb-3" />
 53 | 
 54 |                 <div class="mb-3 blog-details-content">
 55 |                     @Html.Raw(Model.Content)
 56 |                 </div>
 57 | 
 58 | 
 59 |                 <div class="card">
 60 |                     <div class="card-header">
 61 |                         <h5>Comments</h5>
 62 | 
 63 |                         @if (signInManager.IsSignedIn(User))
 64 |                         {
 65 |                             <form method="post">
 66 |                                 <div class="mb-3">
 67 |                                     <label class="form-label">Comment Description</label>
 68 |                                     <input type="text" class="form-control" asp-for="CommentDescription" />
 69 |                                 </div>
 70 |                                 <div class="mb-3">
 71 |                                     <button type="submit" class="btn btn-dark">Submit</button>
 72 |                                     <input type="hidden" asp-for="Id" />
 73 |                                     <input type="hidden" asp-for="UrlHandle" />
 74 |                                 </div>
 75 |                             </form>
 76 |                         }
 77 |                     </div>
 78 |                     <div class="card-body">
 79 |                         @if (Model.Comments != null && Model.Comments.Any())
 80 |                         {
 81 |                             @foreach (var comment in Model.Comments)
 82 |                             {
 83 |                                 <div class="card mb-3">
 84 |                                     <div class="card-body">
 85 |                                         <div>
 86 |                                             @comment.Description
 87 |                                         </div>
 88 |                                         <div class="d-flex justify-content-between">
 89 |                                             <span class="text-secondary">@comment.Username</span>
 90 |                                             <span class="text-secondary">@comment.DateAdded.ToShortDateString()</span>
 91 |                                         </div>
 92 |                                     </div>
 93 |                                 </div>
 94 |                             }
 95 |                         }
 96 |                     </div>
 97 |                 </div>
 98 | 
 99 | 
100 | 
101 |             }
102 |             else
103 |             {
104 |                 <p>Blog post not found!</p>
105 |             }
106 |         </div>
107 |     </div>
108 | </div>
109 | 
110 | 
111 | @section Scripts {
112 |     <script>
113 |         const btnLikeElement = document.getElementById('btnLike');
114 |         const totalLikeElement = document.getElementById('totalLikes');
115 | 
116 |         async function getTotalLikes() {
117 |             fetch('/api/blogpostlike/@Model.Id/totalLikes', {
118 |                 method: 'GET',
119 |                 headers: {
120 |                     'Content-Type': 'application/json',
121 |                     'Accept': '*/*'
122 |                 }
123 |             })
124 |                 .then(data => data.json())
125 |                 .then(result => totalLikeElement.innerHTML = result);
126 |         }
127 | 
128 | 
129 |         async function addLikeForBlog() {
130 |             fetch('/api/BlogPostLike/Add', {
131 |                 method: 'POST',
132 |                 headers: {
133 |                     'Content-Type': 'application/json',
134 |                     'Accept': '*/*'
135 |                 },
136 |                 body: JSON.stringify({
137 |                     blogPostId: '@Model.Id',
138 |                     userId: '@userManager.GetUserId(User)'
139 |                 })
140 |             }).then(() => {
141 |                 btnLikeElement.innerHTML = '<i class="bi bi-hand-thumbs-up-fill"></i>';
142 |                 btnLikeElement.removeEventListener('click', addLikeForBlog);
143 |                 getTotalLikes();
144 |             });
145 |         }
146 | 
147 | 
148 |         btnLikeElement.addEventListener('click', addLikeForBlog);
149 | 
150 |     </script>
151 | }


--------------------------------------------------------------------------------
/Bloggie.Web/Migrations/20230305212914_Adding like functionality.Designer.cs:
--------------------------------------------------------------------------------
  1 | // <auto-generated />
  2 | using System;
  3 | using Bloggie.Web.Data;
  4 | using Microsoft.EntityFrameworkCore;
  5 | using Microsoft.EntityFrameworkCore.Infrastructure;
  6 | using Microsoft.EntityFrameworkCore.Metadata;
  7 | using Microsoft.EntityFrameworkCore.Migrations;
  8 | using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
  9 | 
 10 | #nullable disable
 11 | 
 12 | namespace Bloggie.Web.Migrations
 13 | {
 14 |     [DbContext(typeof(BloggieDbContext))]
 15 |     [Migration("20230305212914_Adding like functionality")]
 16 |     partial class Addinglikefunctionality
 17 |     {
 18 |         /// <inheritdoc />
 19 |         protected override void BuildTargetModel(ModelBuilder modelBuilder)
 20 |         {
 21 | #pragma warning disable 612, 618
 22 |             modelBuilder
 23 |                 .HasAnnotation("ProductVersion", "7.0.3")
 24 |                 .HasAnnotation("Relational:MaxIdentifierLength", 128);
 25 | 
 26 |             SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
 27 | 
 28 |             modelBuilder.Entity("BlogPostTag", b =>
 29 |                 {
 30 |                     b.Property<Guid>("BlogPostsId")
 31 |                         .HasColumnType("uniqueidentifier");
 32 | 
 33 |                     b.Property<Guid>("TagsId")
 34 |                         .HasColumnType("uniqueidentifier");
 35 | 
 36 |                     b.HasKey("BlogPostsId", "TagsId");
 37 | 
 38 |                     b.HasIndex("TagsId");
 39 | 
 40 |                     b.ToTable("BlogPostTag");
 41 |                 });
 42 | 
 43 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPost", b =>
 44 |                 {
 45 |                     b.Property<Guid>("Id")
 46 |                         .ValueGeneratedOnAdd()
 47 |                         .HasColumnType("uniqueidentifier");
 48 | 
 49 |                     b.Property<string>("Author")
 50 |                         .IsRequired()
 51 |                         .HasColumnType("nvarchar(max)");
 52 | 
 53 |                     b.Property<string>("Content")
 54 |                         .IsRequired()
 55 |                         .HasColumnType("nvarchar(max)");
 56 | 
 57 |                     b.Property<string>("FeaturedImageUrl")
 58 |                         .IsRequired()
 59 |                         .HasColumnType("nvarchar(max)");
 60 | 
 61 |                     b.Property<string>("Heading")
 62 |                         .IsRequired()
 63 |                         .HasColumnType("nvarchar(max)");
 64 | 
 65 |                     b.Property<string>("PageTitle")
 66 |                         .IsRequired()
 67 |                         .HasColumnType("nvarchar(max)");
 68 | 
 69 |                     b.Property<DateTime>("PublishedDate")
 70 |                         .HasColumnType("datetime2");
 71 | 
 72 |                     b.Property<string>("ShortDescription")
 73 |                         .IsRequired()
 74 |                         .HasColumnType("nvarchar(max)");
 75 | 
 76 |                     b.Property<string>("UrlHandle")
 77 |                         .IsRequired()
 78 |                         .HasColumnType("nvarchar(max)");
 79 | 
 80 |                     b.Property<bool>("Visible")
 81 |                         .HasColumnType("bit");
 82 | 
 83 |                     b.HasKey("Id");
 84 | 
 85 |                     b.ToTable("BlogPosts");
 86 |                 });
 87 | 
 88 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPostLike", b =>
 89 |                 {
 90 |                     b.Property<Guid>("Id")
 91 |                         .ValueGeneratedOnAdd()
 92 |                         .HasColumnType("uniqueidentifier");
 93 | 
 94 |                     b.Property<Guid>("BlogPostId")
 95 |                         .HasColumnType("uniqueidentifier");
 96 | 
 97 |                     b.Property<Guid>("UserId")
 98 |                         .HasColumnType("uniqueidentifier");
 99 | 
100 |                     b.HasKey("Id");
101 | 
102 |                     b.HasIndex("BlogPostId");
103 | 
104 |                     b.ToTable("BlogPostLike");
105 |                 });
106 | 
107 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.Tag", b =>
108 |                 {
109 |                     b.Property<Guid>("Id")
110 |                         .ValueGeneratedOnAdd()
111 |                         .HasColumnType("uniqueidentifier");
112 | 
113 |                     b.Property<string>("DisplayName")
114 |                         .IsRequired()
115 |                         .HasColumnType("nvarchar(max)");
116 | 
117 |                     b.Property<string>("Name")
118 |                         .IsRequired()
119 |                         .HasColumnType("nvarchar(max)");
120 | 
121 |                     b.HasKey("Id");
122 | 
123 |                     b.ToTable("Tags");
124 |                 });
125 | 
126 |             modelBuilder.Entity("BlogPostTag", b =>
127 |                 {
128 |                     b.HasOne("Bloggie.Web.Models.Domain.BlogPost", null)
129 |                         .WithMany()
130 |                         .HasForeignKey("BlogPostsId")
131 |                         .OnDelete(DeleteBehavior.Cascade)
132 |                         .IsRequired();
133 | 
134 |                     b.HasOne("Bloggie.Web.Models.Domain.Tag", null)
135 |                         .WithMany()
136 |                         .HasForeignKey("TagsId")
137 |                         .OnDelete(DeleteBehavior.Cascade)
138 |                         .IsRequired();
139 |                 });
140 | 
141 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPostLike", b =>
142 |                 {
143 |                     b.HasOne("Bloggie.Web.Models.Domain.BlogPost", null)
144 |                         .WithMany("Likes")
145 |                         .HasForeignKey("BlogPostId")
146 |                         .OnDelete(DeleteBehavior.Cascade)
147 |                         .IsRequired();
148 |                 });
149 | 
150 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPost", b =>
151 |                 {
152 |                     b.Navigation("Likes");
153 |                 });
154 | #pragma warning restore 612, 618
155 |         }
156 |     }
157 | }
158 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Views/AdminTags/List.cshtml:
--------------------------------------------------------------------------------
  1 | @model List<Bloggie.Web.Models.Domain.Tag>
  2 | 
  3 | @{
  4 |     int nextPage = Convert.ToInt32(ViewBag.PageNumber) + 1;
  5 |     int prevPage = Convert.ToInt32(ViewBag.PageNumber) - 1;
  6 | }
  7 | 
  8 | <div class="bg-secondary bg-opacity-10 py-2">
  9 |     <div class="container">
 10 |         <h1>Show All Tags - Admin Functionality</h1>
 11 |     </div>
 12 | </div>
 13 | 
 14 | 
 15 | <form method="get"
 16 |       asp-controller="AdminTags" ,
 17 |       asp-action="List">
 18 |     <div class="container mt-5">
 19 |         <div class="row">
 20 |             <div class="col col-md-3 d-flex">
 21 |                 <input type="text" class="form-control"
 22 |                        name="searchQuery" value="@ViewBag.SearchQuery" />
 23 |                 <button type="submit" class="btn btn-warning ms-3">Search</button>
 24 |             </div>
 25 |         </div>
 26 |     </div>
 27 | </form>
 28 | 
 29 | 
 30 | <div class="container mt-3">
 31 |     @if (Model != null && Model.Any())
 32 |     {
 33 |         <table class="table">
 34 |             <thead>
 35 |                 <tr>
 36 |                     <th>Id</th>
 37 |                     <th>
 38 |                         Name
 39 |                         <span>
 40 |                             <span>
 41 |                                 <a class="btn btn-light"
 42 |                                    asp-controller="AdminTags"
 43 |                                    asp-action="List"
 44 |                                    asp-route-sortBy="Name"
 45 |                                    asp-route-sortDirection="Asc"
 46 |                                    asp-route-searchQuery="@ViewBag.SearchQuery">
 47 |                                     <i class="bi bi-arrow-up"></i>
 48 |                                 </a>
 49 |                             </span>
 50 |                             <span>
 51 |                                 <a class="btn btn-light"
 52 |                                    asp-controller="AdminTags"
 53 |                                    asp-action="List"
 54 |                                    asp-route-sortBy="Name"
 55 |                                    asp-route-sortDirection="Desc"
 56 |                                    asp-route-searchQuery="@ViewBag.SearchQuery">
 57 |                                     <i class="bi bi-arrow-down"></i>
 58 |                                 </a>
 59 |                             </span>
 60 |                         </span>
 61 | 
 62 |                     </th>
 63 |                     <th>
 64 |                         Display Name
 65 |                         <span>
 66 |                             <span>
 67 |                                 <a class="btn btn-light"
 68 |                                    asp-controller="AdminTags"
 69 |                                    asp-action="List"
 70 |                                    asp-route-sortBy="DisplayName"
 71 |                                    asp-route-sortDirection="Asc"
 72 |                                    asp-route-searchQuery="@ViewBag.SearchQuery">
 73 |                                     <i class="bi bi-arrow-up"></i>
 74 |                                 </a>
 75 |                             </span>
 76 |                             <span>
 77 |                                 <a class="btn btn-light"
 78 |                                    asp-controller="AdminTags"
 79 |                                    asp-action="List"
 80 |                                    asp-route-sortBy="DisplayName"
 81 |                                    asp-route-sortDirection="Desc"
 82 |                                    asp-route-searchQuery="@ViewBag.SearchQuery">
 83 |                                     <i class="bi bi-arrow-down"></i>
 84 |                                 </a>
 85 |                             </span>
 86 |                         </span>
 87 |                     </th>
 88 |                     <th> </th>
 89 |                 </tr>
 90 |             </thead>
 91 |             <tbody>
 92 |                 @foreach (var tag in Model)
 93 |                 {
 94 |                     <tr>
 95 |                         <td>@tag.Id</td>
 96 |                         <td>@tag.Name</td>
 97 |                         <td>@tag.DisplayName</td>
 98 |                         <td>
 99 |                             <a asp-area="" asp-controller="AdminTags"
100 |                                asp-action="Edit"
101 |                                asp-route-id="@tag.Id">Edit</a>
102 |                         </td>
103 |                     </tr>
104 |                 }
105 |             </tbody>
106 |         </table>
107 | 
108 |         <nav aria-label="Page navigation example">
109 |             <ul class="pagination">
110 |                 <li class="page-item">
111 |                     <a class="page-link"
112 |                        asp-controller="AdminTags"
113 |                        asp-action="List"
114 |                        asp-route-pageNumber="@prevPage"
115 |                        asp-route-pageSize="@ViewBag.PageSize"
116 |                        asp-route-sortBy="@ViewBag.SortBy"
117 |                        asp-route-sortDirection="@ViewBag.SortDirection">
118 |                         Previous
119 |                     </a>
120 |                 </li>
121 | 
122 |                 @for (int i = 1; i <= ViewBag.TotalPages; i++)
123 |                 {
124 |                     <li class="page-item">
125 |                         <a class="page-link"
126 |                            asp-controller="AdminTags"
127 |                            asp-action="List"
128 |                            asp-route-pageNumber="@i"
129 |                            asp-route-pageSize="@ViewBag.PageSize"
130 |                            asp-route-sortBy="@ViewBag.SortBy"
131 |                            asp-route-sortDirection="@ViewBag.SortDirection">
132 |                             @i
133 |                         </a>
134 |                     </li>
135 |                 }
136 | 
137 | 
138 |                 <li class="page-item">
139 |                     <a class="page-link"
140 |                        asp-controller="AdminTags"
141 |                        asp-action="List"
142 |                        asp-route-pageNumber="@nextPage"
143 |                        asp-route-pageSize="@ViewBag.PageSize"
144 |                        asp-route-sortBy="@ViewBag.SortBy"
145 |                        asp-route-sortDirection="@ViewBag.SortDirection">
146 |                         Next
147 |                     </a>
148 |                 </li>
149 |             </ul>
150 |         </nav>
151 | 
152 |     }
153 |     else
154 |     {
155 |         <p>No tags found!</p>
156 |     }
157 | </div>
158 | 
159 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Views/Shared/_Layout.cshtml:
--------------------------------------------------------------------------------
  1 | @using Microsoft.AspNetCore.Identity
  2 | @inject SignInManager<IdentityUser> signInManager
  3 | 
  4 | <!DOCTYPE html>
  5 | <html lang="en">
  6 | <head>
  7 |     <meta charset="utf-8" />
  8 |     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  9 |     <title>@ViewData["Title"] - Bloggie.Web</title>
 10 |     <link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.min.css" />
 11 |     <link rel="stylesheet" href="~/css/site.css" asp-append-version="true" />
 12 |     <link rel="stylesheet" href="~/Bloggie.Web.styles.css" asp-append-version="true" />
 13 |     <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.10.3/font/bootstrap-icons.css">
 14 | 
 15 |     <link href='https://cdn.jsdelivr.net/npm/froala-editor@latest/css/froala_editor.pkgd.min.css' rel='stylesheet' type='text/css' />
 16 |     <script type='text/javascript' src='https://cdn.jsdelivr.net/npm/froala-editor@latest/js/froala_editor.pkgd.min.js'></script>
 17 | </head>
 18 | <body>
 19 |     <header>
 20 |         <nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-dark bg-dark border-bottom box-shadow">
 21 |             <div class="container">
 22 |                 <a class="navbar-brand" asp-area="" asp-controller="Home" asp-action="Index">Bloggie.Web</a>
 23 |                 <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target=".navbar-collapse" aria-controls="navbarSupportedContent"
 24 |                         aria-expanded="false" aria-label="Toggle navigation">
 25 |                     <span class="navbar-toggler-icon"></span>
 26 |                 </button>
 27 |                 <div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">
 28 |                     <ul class="navbar-nav flex-grow-1">
 29 |                         <li class="nav-item">
 30 |                             <a class="nav-link text-light" asp-area="" asp-controller="Home" asp-action="Index">Home</a>
 31 |                         </li>
 32 | 
 33 | 
 34 |                         @if (signInManager.IsSignedIn(User) && User.IsInRole("Admin"))
 35 |                         {
 36 |                             <li class="nav-item dropdown">
 37 |                                 <a class="nav-link dropdown-toggle" href="#" role="button" data-bs-toggle="dropdown" aria-expanded="false">
 38 |                                     Admin
 39 |                                 </a>
 40 |                                 <ul class="dropdown-menu">
 41 |                                     <li>
 42 |                                         <a class="dropdown-item"
 43 |                                            asp-area=""
 44 |                                            asp-controller="AdminTags"
 45 |                                            asp-action="Add">
 46 |                                             Add Tag
 47 |                                         </a>
 48 |                                     </li>
 49 | 
 50 |                                     <li>
 51 |                                         <a class="dropdown-item"
 52 |                                            asp-area=""
 53 |                                            asp-controller="AdminTags"
 54 |                                            asp-action="List">
 55 |                                             Show All Tags
 56 |                                         </a>
 57 |                                     </li>
 58 | 
 59 |                                     <li>
 60 |                                         <a class="dropdown-item"
 61 |                                            asp-area=""
 62 |                                            asp-controller="AdminBlogPosts"
 63 |                                            asp-action="Add">
 64 |                                             Add Blog Post
 65 |                                         </a>
 66 |                                     </li>
 67 | 
 68 | 
 69 |                                     <li>
 70 |                                         <a class="dropdown-item"
 71 |                                            asp-area=""
 72 |                                            asp-controller="AdminBlogPosts"
 73 |                                            asp-action="List">
 74 |                                             All BlogPosts
 75 |                                         </a>
 76 |                                     </li>
 77 | 
 78 | 
 79 |                                     <li>
 80 |                                         <a class="dropdown-item"
 81 |                                            asp-area=""
 82 |                                            asp-controller="AdminUsers"
 83 |                                            asp-action="List">
 84 |                                             All Users
 85 |                                         </a>
 86 |                                     </li>
 87 |                                 </ul>
 88 |                             </li>
 89 |                         }
 90 | 
 91 |                     </ul>
 92 | 
 93 |                     <div class="d-flex align-items-center">
 94 | 
 95 |                         @if (signInManager.IsSignedIn(User))
 96 |                         {
 97 |                             <div class="me-3 text-light">
 98 |                                 @User?.Identity?.Name
 99 |                             </div>
100 | 
101 |                             <a class="btn me-3 bg-light text-dark"
102 |                                asp-area=""
103 |                                asp-controller="Account"
104 |                                asp-action="Logout">Logout</a>
105 |                         }
106 |                         else
107 |                         {
108 |                             <a class="btn me-3 bg-light text-dark"
109 |                                asp-area=""
110 |                                asp-controller="Account"
111 |                                asp-action="Login">Login</a>
112 | 
113 |                             <a class="btn me-3 bg-light text-dark"
114 |                                asp-area=""
115 |                                asp-controller="Account"
116 |                                asp-action="Register">Register</a>
117 | 
118 |                         }
119 | 
120 |                     </div>
121 | 
122 |                 </div>
123 |             </div>
124 |         </nav>
125 |     </header>
126 |     <div>
127 |         <main role="main" class="pb-3">
128 |             @RenderBody()
129 |         </main>
130 |     </div>
131 | 
132 |     <footer class="border-top footer text-muted">
133 |         <div class="container">
134 |             &copy; 2023 - Bloggie.Web - <a asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>
135 |         </div>
136 |     </footer>
137 |     <script src="~/lib/jquery/dist/jquery.min.js"></script>
138 |     <script src="~/lib/bootstrap/dist/js/bootstrap.bundle.min.js"></script>
139 |     <script src="~/js/site.js" asp-append-version="true"></script>
140 |     @await RenderSectionAsync("Scripts", required: false)
141 | </body>
142 | </html>
143 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Controllers/AdminBlogPostsController.cs:
--------------------------------------------------------------------------------
  1 | using Bloggie.Web.Models.Domain;
  2 | using Bloggie.Web.Models.ViewModels;
  3 | using Bloggie.Web.Repositories;
  4 | using Microsoft.AspNetCore.Authorization;
  5 | using Microsoft.AspNetCore.Mvc;
  6 | using Microsoft.AspNetCore.Mvc.Rendering;
  7 | 
  8 | namespace Bloggie.Web.Controllers
  9 | {
 10 |     [Authorize(Roles = "Admin")]
 11 |     public class AdminBlogPostsController : Controller
 12 |     {
 13 |         private readonly ITagRepository tagRepository;
 14 |         private readonly IBlogPostRepository blogPostRepository;
 15 | 
 16 |         public AdminBlogPostsController(ITagRepository tagRepository, IBlogPostRepository blogPostRepository)
 17 |         {
 18 |             this.tagRepository = tagRepository;
 19 |             this.blogPostRepository = blogPostRepository;
 20 |         }
 21 | 
 22 | 
 23 |         [HttpGet]
 24 |         public async Task<IActionResult> Add()
 25 |         {
 26 |             // get tags from repository
 27 |             var tags = await tagRepository.GetAllAsync();
 28 | 
 29 |             var model = new AddBlogPostRequest
 30 |             {
 31 |                 Tags = tags.Select(x => new SelectListItem { Text = x.Name, Value = x.Id.ToString() })
 32 |             };
 33 | 
 34 |             return View(model);
 35 |         }
 36 | 
 37 |         [HttpPost]
 38 |         public async Task<IActionResult> Add(AddBlogPostRequest addBlogPostRequest)
 39 |         {
 40 |             // Map view model to domain model
 41 |             var blogPost = new BlogPost
 42 |             {
 43 |                 Heading = addBlogPostRequest.Heading,
 44 |                 PageTitle = addBlogPostRequest.PageTitle,
 45 |                 Content = addBlogPostRequest.Content,
 46 |                 ShortDescription = addBlogPostRequest.ShortDescription,
 47 |                 FeaturedImageUrl = addBlogPostRequest.FeaturedImageUrl,
 48 |                 UrlHandle = addBlogPostRequest.UrlHandle,
 49 |                 PublishedDate = addBlogPostRequest.PublishedDate,
 50 |                 Author = addBlogPostRequest.Author,
 51 |                 Visible = addBlogPostRequest.Visible,
 52 |             };
 53 | 
 54 |             // Map Tags from selected tags
 55 |             var selectedTags = new List<Tag>();
 56 |             foreach (var selectedTagId in addBlogPostRequest.SelectedTags)
 57 |             {
 58 |                 var selectedTagIdAsGuid = Guid.Parse(selectedTagId);
 59 |                 var existingTag = await tagRepository.GetAsync(selectedTagIdAsGuid);
 60 | 
 61 |                 if (existingTag != null)
 62 |                 {
 63 |                     selectedTags.Add(existingTag);
 64 |                 }
 65 |             }
 66 | 
 67 |             // Mapping tags back to domain model
 68 |             blogPost.Tags = selectedTags;
 69 | 
 70 | 
 71 |             await blogPostRepository.AddAsync(blogPost);
 72 | 
 73 |             return RedirectToAction("Add");
 74 |         }
 75 | 
 76 | 
 77 |         [HttpGet]
 78 |         public async Task<IActionResult> List()
 79 |         {
 80 |             // Call the repository 
 81 |             var blogPosts = await blogPostRepository.GetAllAsync();
 82 | 
 83 |             return View(blogPosts);
 84 |         }
 85 | 
 86 | 
 87 |         [HttpGet]
 88 |         public async Task<IActionResult> Edit(Guid id)
 89 |         {
 90 |             // Retrieve the result from the repository 
 91 |             var blogPost = await blogPostRepository.GetAsync(id);
 92 |             var tagsDomainModel = await tagRepository.GetAllAsync();
 93 | 
 94 |             if (blogPost != null)
 95 |             {
 96 |                 // map the domain model into the view model
 97 |                 var model = new EditBlogPostRequest
 98 |                 {
 99 |                     Id = blogPost.Id,
100 |                     Heading = blogPost.Heading,
101 |                     PageTitle = blogPost.PageTitle,
102 |                     Content = blogPost.Content,
103 |                     Author = blogPost.Author,
104 |                     FeaturedImageUrl = blogPost.FeaturedImageUrl,
105 |                     UrlHandle = blogPost.UrlHandle,
106 |                     ShortDescription = blogPost.ShortDescription,
107 |                     PublishedDate = blogPost.PublishedDate,
108 |                     Visible = blogPost.Visible,
109 |                     Tags = tagsDomainModel.Select(x => new SelectListItem
110 |                     {
111 |                         Text = x.Name,
112 |                         Value = x.Id.ToString()
113 |                     }),
114 |                     SelectedTags = blogPost.Tags.Select(x => x.Id.ToString()).ToArray()
115 |                 };
116 | 
117 |                 return View(model);
118 | 
119 |             }
120 | 
121 |             // pass data to view
122 |             return View(null);
123 |         }
124 | 
125 |         [HttpPost]
126 |         public async Task<IActionResult> Edit(EditBlogPostRequest editBlogPostRequest)
127 |         {
128 |             // map view model back to domain model
129 |             var blogPostDomainModel = new BlogPost
130 |             {
131 |                 Id = editBlogPostRequest.Id,
132 |                 Heading = editBlogPostRequest.Heading,
133 |                 PageTitle = editBlogPostRequest.PageTitle,
134 |                 Content = editBlogPostRequest.Content,
135 |                 Author = editBlogPostRequest.Author,
136 |                 ShortDescription = editBlogPostRequest.ShortDescription,
137 |                 FeaturedImageUrl = editBlogPostRequest.FeaturedImageUrl,
138 |                 PublishedDate = editBlogPostRequest.PublishedDate,
139 |                 UrlHandle = editBlogPostRequest.UrlHandle,
140 |                 Visible = editBlogPostRequest.Visible
141 |             };
142 | 
143 |             // Map tags into domain model
144 | 
145 |             var selectedTags = new List<Tag>();
146 |             foreach (var selectedTag in editBlogPostRequest.SelectedTags)
147 |             {
148 |                 if (Guid.TryParse(selectedTag, out var tag))
149 |                 {
150 |                     var foundTag = await tagRepository.GetAsync(tag);
151 | 
152 |                     if (foundTag != null)
153 |                     {
154 |                         selectedTags.Add(foundTag);
155 |                     }
156 |                 }
157 |             }
158 | 
159 |             blogPostDomainModel.Tags = selectedTags;
160 | 
161 |             // Submit information to repository to update
162 |             var updatedBlog =  await blogPostRepository.UpdateAsync(blogPostDomainModel);
163 | 
164 |             if (updatedBlog != null)
165 |             {
166 |                 // Show success notification
167 |                 return RedirectToAction("Edit");
168 |             }
169 | 
170 |             // Show error notification
171 |             return RedirectToAction("Edit");
172 |         }
173 | 
174 |         [HttpPost]
175 |         public async Task<IActionResult> Delete(EditBlogPostRequest editBlogPostRequest)
176 |         {
177 |             // Talk to repository to delete this blog post and tags
178 |             var deletedBlogPost = await blogPostRepository.DeleteAsync(editBlogPostRequest.Id);
179 | 
180 |             if (deletedBlogPost != null)
181 |             {
182 |                 // Show success notification
183 |                 return RedirectToAction("List");
184 |             }
185 | 
186 |             // Show error notification
187 |             return RedirectToAction("Edit", new { id = editBlogPostRequest.Id });
188 |         }
189 |     }
190 | }
191 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Migrations/BloggieDbContextModelSnapshot.cs:
--------------------------------------------------------------------------------
  1 | // <auto-generated />
  2 | using System;
  3 | using Bloggie.Web.Data;
  4 | using Microsoft.EntityFrameworkCore;
  5 | using Microsoft.EntityFrameworkCore.Infrastructure;
  6 | using Microsoft.EntityFrameworkCore.Metadata;
  7 | using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
  8 | 
  9 | #nullable disable
 10 | 
 11 | namespace Bloggie.Web.Migrations
 12 | {
 13 |     [DbContext(typeof(BloggieDbContext))]
 14 |     partial class BloggieDbContextModelSnapshot : ModelSnapshot
 15 |     {
 16 |         protected override void BuildModel(ModelBuilder modelBuilder)
 17 |         {
 18 | #pragma warning disable 612, 618
 19 |             modelBuilder
 20 |                 .HasAnnotation("ProductVersion", "7.0.3")
 21 |                 .HasAnnotation("Relational:MaxIdentifierLength", 128);
 22 | 
 23 |             SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
 24 | 
 25 |             modelBuilder.Entity("BlogPostTag", b =>
 26 |                 {
 27 |                     b.Property<Guid>("BlogPostsId")
 28 |                         .HasColumnType("uniqueidentifier");
 29 | 
 30 |                     b.Property<Guid>("TagsId")
 31 |                         .HasColumnType("uniqueidentifier");
 32 | 
 33 |                     b.HasKey("BlogPostsId", "TagsId");
 34 | 
 35 |                     b.HasIndex("TagsId");
 36 | 
 37 |                     b.ToTable("BlogPostTag");
 38 |                 });
 39 | 
 40 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPost", b =>
 41 |                 {
 42 |                     b.Property<Guid>("Id")
 43 |                         .ValueGeneratedOnAdd()
 44 |                         .HasColumnType("uniqueidentifier");
 45 | 
 46 |                     b.Property<string>("Author")
 47 |                         .IsRequired()
 48 |                         .HasColumnType("nvarchar(max)");
 49 | 
 50 |                     b.Property<string>("Content")
 51 |                         .IsRequired()
 52 |                         .HasColumnType("nvarchar(max)");
 53 | 
 54 |                     b.Property<string>("FeaturedImageUrl")
 55 |                         .IsRequired()
 56 |                         .HasColumnType("nvarchar(max)");
 57 | 
 58 |                     b.Property<string>("Heading")
 59 |                         .IsRequired()
 60 |                         .HasColumnType("nvarchar(max)");
 61 | 
 62 |                     b.Property<string>("PageTitle")
 63 |                         .IsRequired()
 64 |                         .HasColumnType("nvarchar(max)");
 65 | 
 66 |                     b.Property<DateTime>("PublishedDate")
 67 |                         .HasColumnType("datetime2");
 68 | 
 69 |                     b.Property<string>("ShortDescription")
 70 |                         .IsRequired()
 71 |                         .HasColumnType("nvarchar(max)");
 72 | 
 73 |                     b.Property<string>("UrlHandle")
 74 |                         .IsRequired()
 75 |                         .HasColumnType("nvarchar(max)");
 76 | 
 77 |                     b.Property<bool>("Visible")
 78 |                         .HasColumnType("bit");
 79 | 
 80 |                     b.HasKey("Id");
 81 | 
 82 |                     b.ToTable("BlogPosts");
 83 |                 });
 84 | 
 85 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPostComment", b =>
 86 |                 {
 87 |                     b.Property<Guid>("Id")
 88 |                         .ValueGeneratedOnAdd()
 89 |                         .HasColumnType("uniqueidentifier");
 90 | 
 91 |                     b.Property<Guid>("BlogPostId")
 92 |                         .HasColumnType("uniqueidentifier");
 93 | 
 94 |                     b.Property<DateTime>("DateAdded")
 95 |                         .HasColumnType("datetime2");
 96 | 
 97 |                     b.Property<string>("Description")
 98 |                         .IsRequired()
 99 |                         .HasColumnType("nvarchar(max)");
100 | 
101 |                     b.Property<Guid>("UserId")
102 |                         .HasColumnType("uniqueidentifier");
103 | 
104 |                     b.HasKey("Id");
105 | 
106 |                     b.HasIndex("BlogPostId");
107 | 
108 |                     b.ToTable("BlogPostComment");
109 |                 });
110 | 
111 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPostLike", b =>
112 |                 {
113 |                     b.Property<Guid>("Id")
114 |                         .ValueGeneratedOnAdd()
115 |                         .HasColumnType("uniqueidentifier");
116 | 
117 |                     b.Property<Guid>("BlogPostId")
118 |                         .HasColumnType("uniqueidentifier");
119 | 
120 |                     b.Property<Guid>("UserId")
121 |                         .HasColumnType("uniqueidentifier");
122 | 
123 |                     b.HasKey("Id");
124 | 
125 |                     b.HasIndex("BlogPostId");
126 | 
127 |                     b.ToTable("BlogPostLike");
128 |                 });
129 | 
130 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.Tag", b =>
131 |                 {
132 |                     b.Property<Guid>("Id")
133 |                         .ValueGeneratedOnAdd()
134 |                         .HasColumnType("uniqueidentifier");
135 | 
136 |                     b.Property<string>("DisplayName")
137 |                         .IsRequired()
138 |                         .HasColumnType("nvarchar(max)");
139 | 
140 |                     b.Property<string>("Name")
141 |                         .IsRequired()
142 |                         .HasColumnType("nvarchar(max)");
143 | 
144 |                     b.HasKey("Id");
145 | 
146 |                     b.ToTable("Tags");
147 |                 });
148 | 
149 |             modelBuilder.Entity("BlogPostTag", b =>
150 |                 {
151 |                     b.HasOne("Bloggie.Web.Models.Domain.BlogPost", null)
152 |                         .WithMany()
153 |                         .HasForeignKey("BlogPostsId")
154 |                         .OnDelete(DeleteBehavior.Cascade)
155 |                         .IsRequired();
156 | 
157 |                     b.HasOne("Bloggie.Web.Models.Domain.Tag", null)
158 |                         .WithMany()
159 |                         .HasForeignKey("TagsId")
160 |                         .OnDelete(DeleteBehavior.Cascade)
161 |                         .IsRequired();
162 |                 });
163 | 
164 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPostComment", b =>
165 |                 {
166 |                     b.HasOne("Bloggie.Web.Models.Domain.BlogPost", null)
167 |                         .WithMany("Comments")
168 |                         .HasForeignKey("BlogPostId")
169 |                         .OnDelete(DeleteBehavior.Cascade)
170 |                         .IsRequired();
171 |                 });
172 | 
173 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPostLike", b =>
174 |                 {
175 |                     b.HasOne("Bloggie.Web.Models.Domain.BlogPost", null)
176 |                         .WithMany("Likes")
177 |                         .HasForeignKey("BlogPostId")
178 |                         .OnDelete(DeleteBehavior.Cascade)
179 |                         .IsRequired();
180 |                 });
181 | 
182 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPost", b =>
183 |                 {
184 |                     b.Navigation("Comments");
185 | 
186 |                     b.Navigation("Likes");
187 |                 });
188 | #pragma warning restore 612, 618
189 |         }
190 |     }
191 | }
192 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Migrations/20230306005821_adding comments.Designer.cs:
--------------------------------------------------------------------------------
  1 | // <auto-generated />
  2 | using System;
  3 | using Bloggie.Web.Data;
  4 | using Microsoft.EntityFrameworkCore;
  5 | using Microsoft.EntityFrameworkCore.Infrastructure;
  6 | using Microsoft.EntityFrameworkCore.Metadata;
  7 | using Microsoft.EntityFrameworkCore.Migrations;
  8 | using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
  9 | 
 10 | #nullable disable
 11 | 
 12 | namespace Bloggie.Web.Migrations
 13 | {
 14 |     [DbContext(typeof(BloggieDbContext))]
 15 |     [Migration("20230306005821_adding comments")]
 16 |     partial class addingcomments
 17 |     {
 18 |         /// <inheritdoc />
 19 |         protected override void BuildTargetModel(ModelBuilder modelBuilder)
 20 |         {
 21 | #pragma warning disable 612, 618
 22 |             modelBuilder
 23 |                 .HasAnnotation("ProductVersion", "7.0.3")
 24 |                 .HasAnnotation("Relational:MaxIdentifierLength", 128);
 25 | 
 26 |             SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
 27 | 
 28 |             modelBuilder.Entity("BlogPostTag", b =>
 29 |                 {
 30 |                     b.Property<Guid>("BlogPostsId")
 31 |                         .HasColumnType("uniqueidentifier");
 32 | 
 33 |                     b.Property<Guid>("TagsId")
 34 |                         .HasColumnType("uniqueidentifier");
 35 | 
 36 |                     b.HasKey("BlogPostsId", "TagsId");
 37 | 
 38 |                     b.HasIndex("TagsId");
 39 | 
 40 |                     b.ToTable("BlogPostTag");
 41 |                 });
 42 | 
 43 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPost", b =>
 44 |                 {
 45 |                     b.Property<Guid>("Id")
 46 |                         .ValueGeneratedOnAdd()
 47 |                         .HasColumnType("uniqueidentifier");
 48 | 
 49 |                     b.Property<string>("Author")
 50 |                         .IsRequired()
 51 |                         .HasColumnType("nvarchar(max)");
 52 | 
 53 |                     b.Property<string>("Content")
 54 |                         .IsRequired()
 55 |                         .HasColumnType("nvarchar(max)");
 56 | 
 57 |                     b.Property<string>("FeaturedImageUrl")
 58 |                         .IsRequired()
 59 |                         .HasColumnType("nvarchar(max)");
 60 | 
 61 |                     b.Property<string>("Heading")
 62 |                         .IsRequired()
 63 |                         .HasColumnType("nvarchar(max)");
 64 | 
 65 |                     b.Property<string>("PageTitle")
 66 |                         .IsRequired()
 67 |                         .HasColumnType("nvarchar(max)");
 68 | 
 69 |                     b.Property<DateTime>("PublishedDate")
 70 |                         .HasColumnType("datetime2");
 71 | 
 72 |                     b.Property<string>("ShortDescription")
 73 |                         .IsRequired()
 74 |                         .HasColumnType("nvarchar(max)");
 75 | 
 76 |                     b.Property<string>("UrlHandle")
 77 |                         .IsRequired()
 78 |                         .HasColumnType("nvarchar(max)");
 79 | 
 80 |                     b.Property<bool>("Visible")
 81 |                         .HasColumnType("bit");
 82 | 
 83 |                     b.HasKey("Id");
 84 | 
 85 |                     b.ToTable("BlogPosts");
 86 |                 });
 87 | 
 88 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPostComment", b =>
 89 |                 {
 90 |                     b.Property<Guid>("Id")
 91 |                         .ValueGeneratedOnAdd()
 92 |                         .HasColumnType("uniqueidentifier");
 93 | 
 94 |                     b.Property<Guid>("BlogPostId")
 95 |                         .HasColumnType("uniqueidentifier");
 96 | 
 97 |                     b.Property<DateTime>("DateAdded")
 98 |                         .HasColumnType("datetime2");
 99 | 
100 |                     b.Property<string>("Description")
101 |                         .IsRequired()
102 |                         .HasColumnType("nvarchar(max)");
103 | 
104 |                     b.Property<Guid>("UserId")
105 |                         .HasColumnType("uniqueidentifier");
106 | 
107 |                     b.HasKey("Id");
108 | 
109 |                     b.HasIndex("BlogPostId");
110 | 
111 |                     b.ToTable("BlogPostComment");
112 |                 });
113 | 
114 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPostLike", b =>
115 |                 {
116 |                     b.Property<Guid>("Id")
117 |                         .ValueGeneratedOnAdd()
118 |                         .HasColumnType("uniqueidentifier");
119 | 
120 |                     b.Property<Guid>("BlogPostId")
121 |                         .HasColumnType("uniqueidentifier");
122 | 
123 |                     b.Property<Guid>("UserId")
124 |                         .HasColumnType("uniqueidentifier");
125 | 
126 |                     b.HasKey("Id");
127 | 
128 |                     b.HasIndex("BlogPostId");
129 | 
130 |                     b.ToTable("BlogPostLike");
131 |                 });
132 | 
133 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.Tag", b =>
134 |                 {
135 |                     b.Property<Guid>("Id")
136 |                         .ValueGeneratedOnAdd()
137 |                         .HasColumnType("uniqueidentifier");
138 | 
139 |                     b.Property<string>("DisplayName")
140 |                         .IsRequired()
141 |                         .HasColumnType("nvarchar(max)");
142 | 
143 |                     b.Property<string>("Name")
144 |                         .IsRequired()
145 |                         .HasColumnType("nvarchar(max)");
146 | 
147 |                     b.HasKey("Id");
148 | 
149 |                     b.ToTable("Tags");
150 |                 });
151 | 
152 |             modelBuilder.Entity("BlogPostTag", b =>
153 |                 {
154 |                     b.HasOne("Bloggie.Web.Models.Domain.BlogPost", null)
155 |                         .WithMany()
156 |                         .HasForeignKey("BlogPostsId")
157 |                         .OnDelete(DeleteBehavior.Cascade)
158 |                         .IsRequired();
159 | 
160 |                     b.HasOne("Bloggie.Web.Models.Domain.Tag", null)
161 |                         .WithMany()
162 |                         .HasForeignKey("TagsId")
163 |                         .OnDelete(DeleteBehavior.Cascade)
164 |                         .IsRequired();
165 |                 });
166 | 
167 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPostComment", b =>
168 |                 {
169 |                     b.HasOne("Bloggie.Web.Models.Domain.BlogPost", null)
170 |                         .WithMany("Comments")
171 |                         .HasForeignKey("BlogPostId")
172 |                         .OnDelete(DeleteBehavior.Cascade)
173 |                         .IsRequired();
174 |                 });
175 | 
176 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPostLike", b =>
177 |                 {
178 |                     b.HasOne("Bloggie.Web.Models.Domain.BlogPost", null)
179 |                         .WithMany("Likes")
180 |                         .HasForeignKey("BlogPostId")
181 |                         .OnDelete(DeleteBehavior.Cascade)
182 |                         .IsRequired();
183 |                 });
184 | 
185 |             modelBuilder.Entity("Bloggie.Web.Models.Domain.BlogPost", b =>
186 |                 {
187 |                     b.Navigation("Comments");
188 | 
189 |                     b.Navigation("Likes");
190 |                 });
191 | #pragma warning restore 612, 618
192 |         }
193 |     }
194 | }
195 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | ##
  4 | ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
  5 | 
  6 | # User-specific files
  7 | *.rsuser
  8 | *.suo
  9 | *.user
 10 | *.userosscache
 11 | *.sln.docstates
 12 | 
 13 | # User-specific files (MonoDevelop/Xamarin Studio)
 14 | *.userprefs
 15 | 
 16 | # Mono auto generated files
 17 | mono_crash.*
 18 | 
 19 | # Build results
 20 | [Dd]ebug/
 21 | [Dd]ebugPublic/
 22 | [Rr]elease/
 23 | [Rr]eleases/
 24 | x64/
 25 | x86/
 26 | [Ww][Ii][Nn]32/
 27 | [Aa][Rr][Mm]/
 28 | [Aa][Rr][Mm]64/
 29 | bld/
 30 | [Bb]in/
 31 | [Oo]bj/
 32 | [Oo]ut/
 33 | [Ll]og/
 34 | [Ll]ogs/
 35 | 
 36 | # Visual Studio 2015/2017 cache/options directory
 37 | .vs/
 38 | # Uncomment if you have tasks that create the project's static files in wwwroot
 39 | #wwwroot/
 40 | 
 41 | # Visual Studio 2017 auto generated files
 42 | Generated\ Files/
 43 | 
 44 | # MSTest test Results
 45 | [Tt]est[Rr]esult*/
 46 | [Bb]uild[Ll]og.*
 47 | 
 48 | # NUnit
 49 | *.VisualState.xml
 50 | TestResult.xml
 51 | nunit-*.xml
 52 | 
 53 | # Build Results of an ATL Project
 54 | [Dd]ebugPS/
 55 | [Rr]eleasePS/
 56 | dlldata.c
 57 | 
 58 | # Benchmark Results
 59 | BenchmarkDotNet.Artifacts/
 60 | 
 61 | # .NET Core
 62 | project.lock.json
 63 | project.fragment.lock.json
 64 | artifacts/
 65 | 
 66 | # ASP.NET Scaffolding
 67 | ScaffoldingReadMe.txt
 68 | 
 69 | # StyleCop
 70 | StyleCopReport.xml
 71 | 
 72 | # Files built by Visual Studio
 73 | *_i.c
 74 | *_p.c
 75 | *_h.h
 76 | *.ilk
 77 | *.meta
 78 | *.obj
 79 | *.iobj
 80 | *.pch
 81 | *.pdb
 82 | *.ipdb
 83 | *.pgc
 84 | *.pgd
 85 | *.rsp
 86 | *.sbr
 87 | *.tlb
 88 | *.tli
 89 | *.tlh
 90 | *.tmp
 91 | *.tmp_proj
 92 | *_wpftmp.csproj
 93 | *.log
 94 | *.vspscc
 95 | *.vssscc
 96 | .builds
 97 | *.pidb
 98 | *.svclog
 99 | *.scc
100 | 
101 | # Chutzpah Test files
102 | _Chutzpah*
103 | 
104 | # Visual C++ cache files
105 | ipch/
106 | *.aps
107 | *.ncb
108 | *.opendb
109 | *.opensdf
110 | *.sdf
111 | *.cachefile
112 | *.VC.db
113 | *.VC.VC.opendb
114 | 
115 | # Visual Studio profiler
116 | *.psess
117 | *.vsp
118 | *.vspx
119 | *.sap
120 | 
121 | # Visual Studio Trace Files
122 | *.e2e
123 | 
124 | # TFS 2012 Local Workspace
125 | $tf/
126 | 
127 | # Guidance Automation Toolkit
128 | *.gpState
129 | 
130 | # ReSharper is a .NET coding add-in
131 | _ReSharper*/
132 | *.[Rr]e[Ss]harper
133 | *.DotSettings.user
134 | 
135 | # TeamCity is a build add-in
136 | _TeamCity*
137 | 
138 | # DotCover is a Code Coverage Tool
139 | *.dotCover
140 | 
141 | # AxoCover is a Code Coverage Tool
142 | .axoCover/*
143 | !.axoCover/settings.json
144 | 
145 | # Coverlet is a free, cross platform Code Coverage Tool
146 | coverage*.json
147 | coverage*.xml
148 | coverage*.info
149 | 
150 | # Visual Studio code coverage results
151 | *.coverage
152 | *.coveragexml
153 | 
154 | # NCrunch
155 | _NCrunch_*
156 | .*crunch*.local.xml
157 | nCrunchTemp_*
158 | 
159 | # MightyMoose
160 | *.mm.*
161 | AutoTest.Net/
162 | 
163 | # Web workbench (sass)
164 | .sass-cache/
165 | 
166 | # Installshield output folder
167 | [Ee]xpress/
168 | 
169 | # DocProject is a documentation generator add-in
170 | DocProject/buildhelp/
171 | DocProject/Help/*.HxT
172 | DocProject/Help/*.HxC
173 | DocProject/Help/*.hhc
174 | DocProject/Help/*.hhk
175 | DocProject/Help/*.hhp
176 | DocProject/Help/Html2
177 | DocProject/Help/html
178 | 
179 | # Click-Once directory
180 | publish/
181 | 
182 | # Publish Web Output
183 | *.[Pp]ublish.xml
184 | *.azurePubxml
185 | # Note: Comment the next line if you want to checkin your web deploy settings,
186 | # but database connection strings (with potential passwords) will be unencrypted
187 | *.pubxml
188 | *.publishproj
189 | 
190 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
191 | # checkin your Azure Web App publish settings, but sensitive information contained
192 | # in these scripts will be unencrypted
193 | PublishScripts/
194 | 
195 | # NuGet Packages
196 | *.nupkg
197 | # NuGet Symbol Packages
198 | *.snupkg
199 | # The packages folder can be ignored because of Package Restore
200 | **/[Pp]ackages/*
201 | # except build/, which is used as an MSBuild target.
202 | !**/[Pp]ackages/build/
203 | # Uncomment if necessary however generally it will be regenerated when needed
204 | #!**/[Pp]ackages/repositories.config
205 | # NuGet v3's project.json files produces more ignorable files
206 | *.nuget.props
207 | *.nuget.targets
208 | 
209 | # Microsoft Azure Build Output
210 | csx/
211 | *.build.csdef
212 | 
213 | # Microsoft Azure Emulator
214 | ecf/
215 | rcf/
216 | 
217 | # Windows Store app package directories and files
218 | AppPackages/
219 | BundleArtifacts/
220 | Package.StoreAssociation.xml
221 | _pkginfo.txt
222 | *.appx
223 | *.appxbundle
224 | *.appxupload
225 | 
226 | # Visual Studio cache files
227 | # files ending in .cache can be ignored
228 | *.[Cc]ache
229 | # but keep track of directories ending in .cache
230 | !?*.[Cc]ache/
231 | 
232 | # Others
233 | ClientBin/
234 | ~$*
235 | *~
236 | *.dbmdl
237 | *.dbproj.schemaview
238 | *.jfm
239 | *.pfx
240 | *.publishsettings
241 | orleans.codegen.cs
242 | 
243 | # Including strong name files can present a security risk
244 | # (https://github.com/github/gitignore/pull/2483#issue-259490424)
245 | #*.snk
246 | 
247 | # Since there are multiple workflows, uncomment next line to ignore bower_components
248 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
249 | #bower_components/
250 | 
251 | # RIA/Silverlight projects
252 | Generated_Code/
253 | 
254 | # Backup & report files from converting an old project file
255 | # to a newer Visual Studio version. Backup files are not needed,
256 | # because we have git ;-)
257 | _UpgradeReport_Files/
258 | Backup*/
259 | UpgradeLog*.XML
260 | UpgradeLog*.htm
261 | ServiceFabricBackup/
262 | *.rptproj.bak
263 | 
264 | # SQL Server files
265 | *.mdf
266 | *.ldf
267 | *.ndf
268 | 
269 | # Business Intelligence projects
270 | *.rdl.data
271 | *.bim.layout
272 | *.bim_*.settings
273 | *.rptproj.rsuser
274 | *- [Bb]ackup.rdl
275 | *- [Bb]ackup ([0-9]).rdl
276 | *- [Bb]ackup ([0-9][0-9]).rdl
277 | 
278 | # Microsoft Fakes
279 | FakesAssemblies/
280 | 
281 | # GhostDoc plugin setting file
282 | *.GhostDoc.xml
283 | 
284 | # Node.js Tools for Visual Studio
285 | .ntvs_analysis.dat
286 | node_modules/
287 | 
288 | # Visual Studio 6 build log
289 | *.plg
290 | 
291 | # Visual Studio 6 workspace options file
292 | *.opt
293 | 
294 | # Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
295 | *.vbw
296 | 
297 | # Visual Studio LightSwitch build output
298 | **/*.HTMLClient/GeneratedArtifacts
299 | **/*.DesktopClient/GeneratedArtifacts
300 | **/*.DesktopClient/ModelManifest.xml
301 | **/*.Server/GeneratedArtifacts
302 | **/*.Server/ModelManifest.xml
303 | _Pvt_Extensions
304 | 
305 | # Paket dependency manager
306 | .paket/paket.exe
307 | paket-files/
308 | 
309 | # FAKE - F# Make
310 | .fake/
311 | 
312 | # CodeRush personal settings
313 | .cr/personal
314 | 
315 | # Python Tools for Visual Studio (PTVS)
316 | __pycache__/
317 | *.pyc
318 | 
319 | # Cake - Uncomment if you are using it
320 | # tools/**
321 | # !tools/packages.config
322 | 
323 | # Tabs Studio
324 | *.tss
325 | 
326 | # Telerik's JustMock configuration file
327 | *.jmconfig
328 | 
329 | # BizTalk build output
330 | *.btp.cs
331 | *.btm.cs
332 | *.odx.cs
333 | *.xsd.cs
334 | 
335 | # OpenCover UI analysis results
336 | OpenCover/
337 | 
338 | # Azure Stream Analytics local run output
339 | ASALocalRun/
340 | 
341 | # MSBuild Binary and Structured Log
342 | *.binlog
343 | 
344 | # NVidia Nsight GPU debugger configuration file
345 | *.nvuser
346 | 
347 | # MFractors (Xamarin productivity tool) working folder
348 | .mfractor/
349 | 
350 | # Local History for Visual Studio
351 | .localhistory/
352 | 
353 | # BeatPulse healthcheck temp database
354 | healthchecksdb
355 | 
356 | # Backup folder for Package Reference Convert tool in Visual Studio 2017
357 | MigrationBackup/
358 | 
359 | # Ionide (cross platform F# VS Code tools) working folder
360 | .ionide/
361 | 
362 | # Fody - auto-generated XML schema
363 | FodyWeavers.xsd


--------------------------------------------------------------------------------
/Bloggie.Web/wwwroot/lib/bootstrap/dist/css/bootstrap-reboot.rtl.css:
--------------------------------------------------------------------------------
  1 | /*!
  2 |  * Bootstrap Reboot v5.1.0 (https://getbootstrap.com/)
  3 |  * Copyright 2011-2021 The Bootstrap Authors
  4 |  * Copyright 2011-2021 Twitter, Inc.
  5 |  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
  6 |  * Forked from Normalize.css, licensed MIT (https://github.com/necolas/normalize.css/blob/master/LICENSE.md)
  7 |  */
  8 | *,
  9 | *::before,
 10 | *::after {
 11 |   box-sizing: border-box;
 12 | }
 13 | 
 14 | @media (prefers-reduced-motion: no-preference) {
 15 |   :root {
 16 |     scroll-behavior: smooth;
 17 |   }
 18 | }
 19 | 
 20 | body {
 21 |   margin: 0;
 22 |   font-family: var(--bs-body-font-family);
 23 |   font-size: var(--bs-body-font-size);
 24 |   font-weight: var(--bs-body-font-weight);
 25 |   line-height: var(--bs-body-line-height);
 26 |   color: var(--bs-body-color);
 27 |   text-align: var(--bs-body-text-align);
 28 |   background-color: var(--bs-body-bg);
 29 |   -webkit-text-size-adjust: 100%;
 30 |   -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
 31 | }
 32 | 
 33 | hr {
 34 |   margin: 1rem 0;
 35 |   color: inherit;
 36 |   background-color: currentColor;
 37 |   border: 0;
 38 |   opacity: 0.25;
 39 | }
 40 | 
 41 | hr:not([size]) {
 42 |   height: 1px;
 43 | }
 44 | 
 45 | h6, h5, h4, h3, h2, h1 {
 46 |   margin-top: 0;
 47 |   margin-bottom: 0.5rem;
 48 |   font-weight: 500;
 49 |   line-height: 1.2;
 50 | }
 51 | 
 52 | h1 {
 53 |   font-size: calc(1.375rem + 1.5vw);
 54 | }
 55 | @media (min-width: 1200px) {
 56 |   h1 {
 57 |     font-size: 2.5rem;
 58 |   }
 59 | }
 60 | 
 61 | h2 {
 62 |   font-size: calc(1.325rem + 0.9vw);
 63 | }
 64 | @media (min-width: 1200px) {
 65 |   h2 {
 66 |     font-size: 2rem;
 67 |   }
 68 | }
 69 | 
 70 | h3 {
 71 |   font-size: calc(1.3rem + 0.6vw);
 72 | }
 73 | @media (min-width: 1200px) {
 74 |   h3 {
 75 |     font-size: 1.75rem;
 76 |   }
 77 | }
 78 | 
 79 | h4 {
 80 |   font-size: calc(1.275rem + 0.3vw);
 81 | }
 82 | @media (min-width: 1200px) {
 83 |   h4 {
 84 |     font-size: 1.5rem;
 85 |   }
 86 | }
 87 | 
 88 | h5 {
 89 |   font-size: 1.25rem;
 90 | }
 91 | 
 92 | h6 {
 93 |   font-size: 1rem;
 94 | }
 95 | 
 96 | p {
 97 |   margin-top: 0;
 98 |   margin-bottom: 1rem;
 99 | }
100 | 
101 | abbr[title],
102 | abbr[data-bs-original-title] {
103 |   -webkit-text-decoration: underline dotted;
104 |   text-decoration: underline dotted;
105 |   cursor: help;
106 |   -webkit-text-decoration-skip-ink: none;
107 |   text-decoration-skip-ink: none;
108 | }
109 | 
110 | address {
111 |   margin-bottom: 1rem;
112 |   font-style: normal;
113 |   line-height: inherit;
114 | }
115 | 
116 | ol,
117 | ul {
118 |   padding-right: 2rem;
119 | }
120 | 
121 | ol,
122 | ul,
123 | dl {
124 |   margin-top: 0;
125 |   margin-bottom: 1rem;
126 | }
127 | 
128 | ol ol,
129 | ul ul,
130 | ol ul,
131 | ul ol {
132 |   margin-bottom: 0;
133 | }
134 | 
135 | dt {
136 |   font-weight: 700;
137 | }
138 | 
139 | dd {
140 |   margin-bottom: 0.5rem;
141 |   margin-right: 0;
142 | }
143 | 
144 | blockquote {
145 |   margin: 0 0 1rem;
146 | }
147 | 
148 | b,
149 | strong {
150 |   font-weight: bolder;
151 | }
152 | 
153 | small {
154 |   font-size: 0.875em;
155 | }
156 | 
157 | mark {
158 |   padding: 0.2em;
159 |   background-color: #fcf8e3;
160 | }
161 | 
162 | sub,
163 | sup {
164 |   position: relative;
165 |   font-size: 0.75em;
166 |   line-height: 0;
167 |   vertical-align: baseline;
168 | }
169 | 
170 | sub {
171 |   bottom: -0.25em;
172 | }
173 | 
174 | sup {
175 |   top: -0.5em;
176 | }
177 | 
178 | a {
179 |   color: #0d6efd;
180 |   text-decoration: underline;
181 | }
182 | a:hover {
183 |   color: #0a58ca;
184 | }
185 | 
186 | a:not([href]):not([class]), a:not([href]):not([class]):hover {
187 |   color: inherit;
188 |   text-decoration: none;
189 | }
190 | 
191 | pre,
192 | code,
193 | kbd,
194 | samp {
195 |   font-family: SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
196 |   font-size: 1em;
197 |   direction: ltr ;
198 |   unicode-bidi: bidi-override;
199 | }
200 | 
201 | pre {
202 |   display: block;
203 |   margin-top: 0;
204 |   margin-bottom: 1rem;
205 |   overflow: auto;
206 |   font-size: 0.875em;
207 | }
208 | pre code {
209 |   font-size: inherit;
210 |   color: inherit;
211 |   word-break: normal;
212 | }
213 | 
214 | code {
215 |   font-size: 0.875em;
216 |   color: #d63384;
217 |   word-wrap: break-word;
218 | }
219 | a > code {
220 |   color: inherit;
221 | }
222 | 
223 | kbd {
224 |   padding: 0.2rem 0.4rem;
225 |   font-size: 0.875em;
226 |   color: #fff;
227 |   background-color: #212529;
228 |   border-radius: 0.2rem;
229 | }
230 | kbd kbd {
231 |   padding: 0;
232 |   font-size: 1em;
233 |   font-weight: 700;
234 | }
235 | 
236 | figure {
237 |   margin: 0 0 1rem;
238 | }
239 | 
240 | img,
241 | svg {
242 |   vertical-align: middle;
243 | }
244 | 
245 | table {
246 |   caption-side: bottom;
247 |   border-collapse: collapse;
248 | }
249 | 
250 | caption {
251 |   padding-top: 0.5rem;
252 |   padding-bottom: 0.5rem;
253 |   color: #6c757d;
254 |   text-align: right;
255 | }
256 | 
257 | th {
258 |   text-align: inherit;
259 |   text-align: -webkit-match-parent;
260 | }
261 | 
262 | thead,
263 | tbody,
264 | tfoot,
265 | tr,
266 | td,
267 | th {
268 |   border-color: inherit;
269 |   border-style: solid;
270 |   border-width: 0;
271 | }
272 | 
273 | label {
274 |   display: inline-block;
275 | }
276 | 
277 | button {
278 |   border-radius: 0;
279 | }
280 | 
281 | button:focus:not(:focus-visible) {
282 |   outline: 0;
283 | }
284 | 
285 | input,
286 | button,
287 | select,
288 | optgroup,
289 | textarea {
290 |   margin: 0;
291 |   font-family: inherit;
292 |   font-size: inherit;
293 |   line-height: inherit;
294 | }
295 | 
296 | button,
297 | select {
298 |   text-transform: none;
299 | }
300 | 
301 | [role=button] {
302 |   cursor: pointer;
303 | }
304 | 
305 | select {
306 |   word-wrap: normal;
307 | }
308 | select:disabled {
309 |   opacity: 1;
310 | }
311 | 
312 | [list]::-webkit-calendar-picker-indicator {
313 |   display: none;
314 | }
315 | 
316 | button,
317 | [type=button],
318 | [type=reset],
319 | [type=submit] {
320 |   -webkit-appearance: button;
321 | }
322 | button:not(:disabled),
323 | [type=button]:not(:disabled),
324 | [type=reset]:not(:disabled),
325 | [type=submit]:not(:disabled) {
326 |   cursor: pointer;
327 | }
328 | 
329 | ::-moz-focus-inner {
330 |   padding: 0;
331 |   border-style: none;
332 | }
333 | 
334 | textarea {
335 |   resize: vertical;
336 | }
337 | 
338 | fieldset {
339 |   min-width: 0;
340 |   padding: 0;
341 |   margin: 0;
342 |   border: 0;
343 | }
344 | 
345 | legend {
346 |   float: right;
347 |   width: 100%;
348 |   padding: 0;
349 |   margin-bottom: 0.5rem;
350 |   font-size: calc(1.275rem + 0.3vw);
351 |   line-height: inherit;
352 | }
353 | @media (min-width: 1200px) {
354 |   legend {
355 |     font-size: 1.5rem;
356 |   }
357 | }
358 | legend + * {
359 |   clear: right;
360 | }
361 | 
362 | ::-webkit-datetime-edit-fields-wrapper,
363 | ::-webkit-datetime-edit-text,
364 | ::-webkit-datetime-edit-minute,
365 | ::-webkit-datetime-edit-hour-field,
366 | ::-webkit-datetime-edit-day-field,
367 | ::-webkit-datetime-edit-month-field,
368 | ::-webkit-datetime-edit-year-field {
369 |   padding: 0;
370 | }
371 | 
372 | ::-webkit-inner-spin-button {
373 |   height: auto;
374 | }
375 | 
376 | [type=search] {
377 |   outline-offset: -2px;
378 |   -webkit-appearance: textfield;
379 | }
380 | 
381 | [type="tel"],
382 | [type="url"],
383 | [type="email"],
384 | [type="number"] {
385 |   direction: ltr;
386 | }
387 | ::-webkit-search-decoration {
388 |   -webkit-appearance: none;
389 | }
390 | 
391 | ::-webkit-color-swatch-wrapper {
392 |   padding: 0;
393 | }
394 | 
395 | ::file-selector-button {
396 |   font: inherit;
397 | }
398 | 
399 | ::-webkit-file-upload-button {
400 |   font: inherit;
401 |   -webkit-appearance: button;
402 | }
403 | 
404 | output {
405 |   display: inline-block;
406 | }
407 | 
408 | iframe {
409 |   border: 0;
410 | }
411 | 
412 | summary {
413 |   display: list-item;
414 |   cursor: pointer;
415 | }
416 | 
417 | progress {
418 |   vertical-align: baseline;
419 | }
420 | 
421 | [hidden] {
422 |   display: none !important;
423 | }
424 | /*# sourceMappingURL=bootstrap-reboot.rtl.css.map */


--------------------------------------------------------------------------------
/Bloggie.Web/wwwroot/lib/bootstrap/dist/css/bootstrap-reboot.css:
--------------------------------------------------------------------------------
  1 | /*!
  2 |  * Bootstrap Reboot v5.1.0 (https://getbootstrap.com/)
  3 |  * Copyright 2011-2021 The Bootstrap Authors
  4 |  * Copyright 2011-2021 Twitter, Inc.
  5 |  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
  6 |  * Forked from Normalize.css, licensed MIT (https://github.com/necolas/normalize.css/blob/master/LICENSE.md)
  7 |  */
  8 | *,
  9 | *::before,
 10 | *::after {
 11 |   box-sizing: border-box;
 12 | }
 13 | 
 14 | @media (prefers-reduced-motion: no-preference) {
 15 |   :root {
 16 |     scroll-behavior: smooth;
 17 |   }
 18 | }
 19 | 
 20 | body {
 21 |   margin: 0;
 22 |   font-family: var(--bs-body-font-family);
 23 |   font-size: var(--bs-body-font-size);
 24 |   font-weight: var(--bs-body-font-weight);
 25 |   line-height: var(--bs-body-line-height);
 26 |   color: var(--bs-body-color);
 27 |   text-align: var(--bs-body-text-align);
 28 |   background-color: var(--bs-body-bg);
 29 |   -webkit-text-size-adjust: 100%;
 30 |   -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
 31 | }
 32 | 
 33 | hr {
 34 |   margin: 1rem 0;
 35 |   color: inherit;
 36 |   background-color: currentColor;
 37 |   border: 0;
 38 |   opacity: 0.25;
 39 | }
 40 | 
 41 | hr:not([size]) {
 42 |   height: 1px;
 43 | }
 44 | 
 45 | h6, h5, h4, h3, h2, h1 {
 46 |   margin-top: 0;
 47 |   margin-bottom: 0.5rem;
 48 |   font-weight: 500;
 49 |   line-height: 1.2;
 50 | }
 51 | 
 52 | h1 {
 53 |   font-size: calc(1.375rem + 1.5vw);
 54 | }
 55 | @media (min-width: 1200px) {
 56 |   h1 {
 57 |     font-size: 2.5rem;
 58 |   }
 59 | }
 60 | 
 61 | h2 {
 62 |   font-size: calc(1.325rem + 0.9vw);
 63 | }
 64 | @media (min-width: 1200px) {
 65 |   h2 {
 66 |     font-size: 2rem;
 67 |   }
 68 | }
 69 | 
 70 | h3 {
 71 |   font-size: calc(1.3rem + 0.6vw);
 72 | }
 73 | @media (min-width: 1200px) {
 74 |   h3 {
 75 |     font-size: 1.75rem;
 76 |   }
 77 | }
 78 | 
 79 | h4 {
 80 |   font-size: calc(1.275rem + 0.3vw);
 81 | }
 82 | @media (min-width: 1200px) {
 83 |   h4 {
 84 |     font-size: 1.5rem;
 85 |   }
 86 | }
 87 | 
 88 | h5 {
 89 |   font-size: 1.25rem;
 90 | }
 91 | 
 92 | h6 {
 93 |   font-size: 1rem;
 94 | }
 95 | 
 96 | p {
 97 |   margin-top: 0;
 98 |   margin-bottom: 1rem;
 99 | }
100 | 
101 | abbr[title],
102 | abbr[data-bs-original-title] {
103 |   -webkit-text-decoration: underline dotted;
104 |   text-decoration: underline dotted;
105 |   cursor: help;
106 |   -webkit-text-decoration-skip-ink: none;
107 |   text-decoration-skip-ink: none;
108 | }
109 | 
110 | address {
111 |   margin-bottom: 1rem;
112 |   font-style: normal;
113 |   line-height: inherit;
114 | }
115 | 
116 | ol,
117 | ul {
118 |   padding-left: 2rem;
119 | }
120 | 
121 | ol,
122 | ul,
123 | dl {
124 |   margin-top: 0;
125 |   margin-bottom: 1rem;
126 | }
127 | 
128 | ol ol,
129 | ul ul,
130 | ol ul,
131 | ul ol {
132 |   margin-bottom: 0;
133 | }
134 | 
135 | dt {
136 |   font-weight: 700;
137 | }
138 | 
139 | dd {
140 |   margin-bottom: 0.5rem;
141 |   margin-left: 0;
142 | }
143 | 
144 | blockquote {
145 |   margin: 0 0 1rem;
146 | }
147 | 
148 | b,
149 | strong {
150 |   font-weight: bolder;
151 | }
152 | 
153 | small {
154 |   font-size: 0.875em;
155 | }
156 | 
157 | mark {
158 |   padding: 0.2em;
159 |   background-color: #fcf8e3;
160 | }
161 | 
162 | sub,
163 | sup {
164 |   position: relative;
165 |   font-size: 0.75em;
166 |   line-height: 0;
167 |   vertical-align: baseline;
168 | }
169 | 
170 | sub {
171 |   bottom: -0.25em;
172 | }
173 | 
174 | sup {
175 |   top: -0.5em;
176 | }
177 | 
178 | a {
179 |   color: #0d6efd;
180 |   text-decoration: underline;
181 | }
182 | a:hover {
183 |   color: #0a58ca;
184 | }
185 | 
186 | a:not([href]):not([class]), a:not([href]):not([class]):hover {
187 |   color: inherit;
188 |   text-decoration: none;
189 | }
190 | 
191 | pre,
192 | code,
193 | kbd,
194 | samp {
195 |   font-family: SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
196 |   font-size: 1em;
197 |   direction: ltr /* rtl:ignore */;
198 |   unicode-bidi: bidi-override;
199 | }
200 | 
201 | pre {
202 |   display: block;
203 |   margin-top: 0;
204 |   margin-bottom: 1rem;
205 |   overflow: auto;
206 |   font-size: 0.875em;
207 | }
208 | pre code {
209 |   font-size: inherit;
210 |   color: inherit;
211 |   word-break: normal;
212 | }
213 | 
214 | code {
215 |   font-size: 0.875em;
216 |   color: #d63384;
217 |   word-wrap: break-word;
218 | }
219 | a > code {
220 |   color: inherit;
221 | }
222 | 
223 | kbd {
224 |   padding: 0.2rem 0.4rem;
225 |   font-size: 0.875em;
226 |   color: #fff;
227 |   background-color: #212529;
228 |   border-radius: 0.2rem;
229 | }
230 | kbd kbd {
231 |   padding: 0;
232 |   font-size: 1em;
233 |   font-weight: 700;
234 | }
235 | 
236 | figure {
237 |   margin: 0 0 1rem;
238 | }
239 | 
240 | img,
241 | svg {
242 |   vertical-align: middle;
243 | }
244 | 
245 | table {
246 |   caption-side: bottom;
247 |   border-collapse: collapse;
248 | }
249 | 
250 | caption {
251 |   padding-top: 0.5rem;
252 |   padding-bottom: 0.5rem;
253 |   color: #6c757d;
254 |   text-align: left;
255 | }
256 | 
257 | th {
258 |   text-align: inherit;
259 |   text-align: -webkit-match-parent;
260 | }
261 | 
262 | thead,
263 | tbody,
264 | tfoot,
265 | tr,
266 | td,
267 | th {
268 |   border-color: inherit;
269 |   border-style: solid;
270 |   border-width: 0;
271 | }
272 | 
273 | label {
274 |   display: inline-block;
275 | }
276 | 
277 | button {
278 |   border-radius: 0;
279 | }
280 | 
281 | button:focus:not(:focus-visible) {
282 |   outline: 0;
283 | }
284 | 
285 | input,
286 | button,
287 | select,
288 | optgroup,
289 | textarea {
290 |   margin: 0;
291 |   font-family: inherit;
292 |   font-size: inherit;
293 |   line-height: inherit;
294 | }
295 | 
296 | button,
297 | select {
298 |   text-transform: none;
299 | }
300 | 
301 | [role=button] {
302 |   cursor: pointer;
303 | }
304 | 
305 | select {
306 |   word-wrap: normal;
307 | }
308 | select:disabled {
309 |   opacity: 1;
310 | }
311 | 
312 | [list]::-webkit-calendar-picker-indicator {
313 |   display: none;
314 | }
315 | 
316 | button,
317 | [type=button],
318 | [type=reset],
319 | [type=submit] {
320 |   -webkit-appearance: button;
321 | }
322 | button:not(:disabled),
323 | [type=button]:not(:disabled),
324 | [type=reset]:not(:disabled),
325 | [type=submit]:not(:disabled) {
326 |   cursor: pointer;
327 | }
328 | 
329 | ::-moz-focus-inner {
330 |   padding: 0;
331 |   border-style: none;
332 | }
333 | 
334 | textarea {
335 |   resize: vertical;
336 | }
337 | 
338 | fieldset {
339 |   min-width: 0;
340 |   padding: 0;
341 |   margin: 0;
342 |   border: 0;
343 | }
344 | 
345 | legend {
346 |   float: left;
347 |   width: 100%;
348 |   padding: 0;
349 |   margin-bottom: 0.5rem;
350 |   font-size: calc(1.275rem + 0.3vw);
351 |   line-height: inherit;
352 | }
353 | @media (min-width: 1200px) {
354 |   legend {
355 |     font-size: 1.5rem;
356 |   }
357 | }
358 | legend + * {
359 |   clear: left;
360 | }
361 | 
362 | ::-webkit-datetime-edit-fields-wrapper,
363 | ::-webkit-datetime-edit-text,
364 | ::-webkit-datetime-edit-minute,
365 | ::-webkit-datetime-edit-hour-field,
366 | ::-webkit-datetime-edit-day-field,
367 | ::-webkit-datetime-edit-month-field,
368 | ::-webkit-datetime-edit-year-field {
369 |   padding: 0;
370 | }
371 | 
372 | ::-webkit-inner-spin-button {
373 |   height: auto;
374 | }
375 | 
376 | [type=search] {
377 |   outline-offset: -2px;
378 |   -webkit-appearance: textfield;
379 | }
380 | 
381 | /* rtl:raw:
382 | [type="tel"],
383 | [type="url"],
384 | [type="email"],
385 | [type="number"] {
386 |   direction: ltr;
387 | }
388 | */
389 | ::-webkit-search-decoration {
390 |   -webkit-appearance: none;
391 | }
392 | 
393 | ::-webkit-color-swatch-wrapper {
394 |   padding: 0;
395 | }
396 | 
397 | ::file-selector-button {
398 |   font: inherit;
399 | }
400 | 
401 | ::-webkit-file-upload-button {
402 |   font: inherit;
403 |   -webkit-appearance: button;
404 | }
405 | 
406 | output {
407 |   display: inline-block;
408 | }
409 | 
410 | iframe {
411 |   border: 0;
412 | }
413 | 
414 | summary {
415 |   display: list-item;
416 |   cursor: pointer;
417 | }
418 | 
419 | progress {
420 |   vertical-align: baseline;
421 | }
422 | 
423 | [hidden] {
424 |   display: none !important;
425 | }
426 | 
427 | /*# sourceMappingURL=bootstrap-reboot.css.map */


--------------------------------------------------------------------------------
/Bloggie.Web/Migrations/AuthDb/20230227010526_Creating Auth Db.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using Microsoft.EntityFrameworkCore.Migrations;
  3 | 
  4 | #nullable disable
  5 | 
  6 | #pragma warning disable CA1814 // Prefer jagged arrays over multidimensional
  7 | 
  8 | namespace Bloggie.Web.Migrations.AuthDb
  9 | {
 10 |     /// <inheritdoc />
 11 |     public partial class CreatingAuthDb : Migration
 12 |     {
 13 |         /// <inheritdoc />
 14 |         protected override void Up(MigrationBuilder migrationBuilder)
 15 |         {
 16 |             migrationBuilder.CreateTable(
 17 |                 name: "AspNetRoles",
 18 |                 columns: table => new
 19 |                 {
 20 |                     Id = table.Column<string>(type: "nvarchar(450)", nullable: false),
 21 |                     Name = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
 22 |                     NormalizedName = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
 23 |                     ConcurrencyStamp = table.Column<string>(type: "nvarchar(max)", nullable: true)
 24 |                 },
 25 |                 constraints: table =>
 26 |                 {
 27 |                     table.PrimaryKey("PK_AspNetRoles", x => x.Id);
 28 |                 });
 29 | 
 30 |             migrationBuilder.CreateTable(
 31 |                 name: "AspNetUsers",
 32 |                 columns: table => new
 33 |                 {
 34 |                     Id = table.Column<string>(type: "nvarchar(450)", nullable: false),
 35 |                     UserName = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
 36 |                     NormalizedUserName = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
 37 |                     Email = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
 38 |                     NormalizedEmail = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
 39 |                     EmailConfirmed = table.Column<bool>(type: "bit", nullable: false),
 40 |                     PasswordHash = table.Column<string>(type: "nvarchar(max)", nullable: true),
 41 |                     SecurityStamp = table.Column<string>(type: "nvarchar(max)", nullable: true),
 42 |                     ConcurrencyStamp = table.Column<string>(type: "nvarchar(max)", nullable: true),
 43 |                     PhoneNumber = table.Column<string>(type: "nvarchar(max)", nullable: true),
 44 |                     PhoneNumberConfirmed = table.Column<bool>(type: "bit", nullable: false),
 45 |                     TwoFactorEnabled = table.Column<bool>(type: "bit", nullable: false),
 46 |                     LockoutEnd = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: true),
 47 |                     LockoutEnabled = table.Column<bool>(type: "bit", nullable: false),
 48 |                     AccessFailedCount = table.Column<int>(type: "int", nullable: false)
 49 |                 },
 50 |                 constraints: table =>
 51 |                 {
 52 |                     table.PrimaryKey("PK_AspNetUsers", x => x.Id);
 53 |                 });
 54 | 
 55 |             migrationBuilder.CreateTable(
 56 |                 name: "AspNetRoleClaims",
 57 |                 columns: table => new
 58 |                 {
 59 |                     Id = table.Column<int>(type: "int", nullable: false)
 60 |                         .Annotation("SqlServer:Identity", "1, 1"),
 61 |                     RoleId = table.Column<string>(type: "nvarchar(450)", nullable: false),
 62 |                     ClaimType = table.Column<string>(type: "nvarchar(max)", nullable: true),
 63 |                     ClaimValue = table.Column<string>(type: "nvarchar(max)", nullable: true)
 64 |                 },
 65 |                 constraints: table =>
 66 |                 {
 67 |                     table.PrimaryKey("PK_AspNetRoleClaims", x => x.Id);
 68 |                     table.ForeignKey(
 69 |                         name: "FK_AspNetRoleClaims_AspNetRoles_RoleId",
 70 |                         column: x => x.RoleId,
 71 |                         principalTable: "AspNetRoles",
 72 |                         principalColumn: "Id",
 73 |                         onDelete: ReferentialAction.Cascade);
 74 |                 });
 75 | 
 76 |             migrationBuilder.CreateTable(
 77 |                 name: "AspNetUserClaims",
 78 |                 columns: table => new
 79 |                 {
 80 |                     Id = table.Column<int>(type: "int", nullable: false)
 81 |                         .Annotation("SqlServer:Identity", "1, 1"),
 82 |                     UserId = table.Column<string>(type: "nvarchar(450)", nullable: false),
 83 |                     ClaimType = table.Column<string>(type: "nvarchar(max)", nullable: true),
 84 |                     ClaimValue = table.Column<string>(type: "nvarchar(max)", nullable: true)
 85 |                 },
 86 |                 constraints: table =>
 87 |                 {
 88 |                     table.PrimaryKey("PK_AspNetUserClaims", x => x.Id);
 89 |                     table.ForeignKey(
 90 |                         name: "FK_AspNetUserClaims_AspNetUsers_UserId",
 91 |                         column: x => x.UserId,
 92 |                         principalTable: "AspNetUsers",
 93 |                         principalColumn: "Id",
 94 |                         onDelete: ReferentialAction.Cascade);
 95 |                 });
 96 | 
 97 |             migrationBuilder.CreateTable(
 98 |                 name: "AspNetUserLogins",
 99 |                 columns: table => new
100 |                 {
101 |                     LoginProvider = table.Column<string>(type: "nvarchar(450)", nullable: false),
102 |                     ProviderKey = table.Column<string>(type: "nvarchar(450)", nullable: false),
103 |                     ProviderDisplayName = table.Column<string>(type: "nvarchar(max)", nullable: true),
104 |                     UserId = table.Column<string>(type: "nvarchar(450)", nullable: false)
105 |                 },
106 |                 constraints: table =>
107 |                 {
108 |                     table.PrimaryKey("PK_AspNetUserLogins", x => new { x.LoginProvider, x.ProviderKey });
109 |                     table.ForeignKey(
110 |                         name: "FK_AspNetUserLogins_AspNetUsers_UserId",
111 |                         column: x => x.UserId,
112 |                         principalTable: "AspNetUsers",
113 |                         principalColumn: "Id",
114 |                         onDelete: ReferentialAction.Cascade);
115 |                 });
116 | 
117 |             migrationBuilder.CreateTable(
118 |                 name: "AspNetUserRoles",
119 |                 columns: table => new
120 |                 {
121 |                     UserId = table.Column<string>(type: "nvarchar(450)", nullable: false),
122 |                     RoleId = table.Column<string>(type: "nvarchar(450)", nullable: false)
123 |                 },
124 |                 constraints: table =>
125 |                 {
126 |                     table.PrimaryKey("PK_AspNetUserRoles", x => new { x.UserId, x.RoleId });
127 |                     table.ForeignKey(
128 |                         name: "FK_AspNetUserRoles_AspNetRoles_RoleId",
129 |                         column: x => x.RoleId,
130 |                         principalTable: "AspNetRoles",
131 |                         principalColumn: "Id",
132 |                         onDelete: ReferentialAction.Cascade);
133 |                     table.ForeignKey(
134 |                         name: "FK_AspNetUserRoles_AspNetUsers_UserId",
135 |                         column: x => x.UserId,
136 |                         principalTable: "AspNetUsers",
137 |                         principalColumn: "Id",
138 |                         onDelete: ReferentialAction.Cascade);
139 |                 });
140 | 
141 |             migrationBuilder.CreateTable(
142 |                 name: "AspNetUserTokens",
143 |                 columns: table => new
144 |                 {
145 |                     UserId = table.Column<string>(type: "nvarchar(450)", nullable: false),
146 |                     LoginProvider = table.Column<string>(type: "nvarchar(450)", nullable: false),
147 |                     Name = table.Column<string>(type: "nvarchar(450)", nullable: false),
148 |                     Value = table.Column<string>(type: "nvarchar(max)", nullable: true)
149 |                 },
150 |                 constraints: table =>
151 |                 {
152 |                     table.PrimaryKey("PK_AspNetUserTokens", x => new { x.UserId, x.LoginProvider, x.Name });
153 |                     table.ForeignKey(
154 |                         name: "FK_AspNetUserTokens_AspNetUsers_UserId",
155 |                         column: x => x.UserId,
156 |                         principalTable: "AspNetUsers",
157 |                         principalColumn: "Id",
158 |                         onDelete: ReferentialAction.Cascade);
159 |                 });
160 | 
161 |             migrationBuilder.InsertData(
162 |                 table: "AspNetRoles",
163 |                 columns: new[] { "Id", "ConcurrencyStamp", "Name", "NormalizedName" },
164 |                 values: new object[,]
165 |                 {
166 |                     { "37cc67e1-41ca-461c-bf34-2b5e62dbae32", "37cc67e1-41ca-461c-bf34-2b5e62dbae32", "Admin", "Admin" },
167 |                     { "3cfd9eee-08cb-4da3-9e6f-c3166b50d3b0", "3cfd9eee-08cb-4da3-9e6f-c3166b50d3b0", "SuperAdmin", "SuperAdmin" },
168 |                     { "a0cab2c3-6558-4a1c-be81-dfb39180da3d", "a0cab2c3-6558-4a1c-be81-dfb39180da3d", "User", "User" }
169 |                 });
170 | 
171 |             migrationBuilder.InsertData(
172 |                 table: "AspNetUsers",
173 |                 columns: new[] { "Id", "AccessFailedCount", "ConcurrencyStamp", "Email", "EmailConfirmed", "LockoutEnabled", "LockoutEnd", "NormalizedEmail", "NormalizedUserName", "PasswordHash", "PhoneNumber", "PhoneNumberConfirmed", "SecurityStamp", "TwoFactorEnabled", "UserName" },
174 |                 values: new object[] { "472ba632-6133-44a1-b158-6c10bd7d850d", 0, "02dcd5f7-a690-45e5-95d4-d2706865a55a", "superadmin@bloggie.com", false, false, null, "SUPERADMIN@BLOGGIE.COM", "SUPERADMIN@BLOGGIE.COM", "AQAAAAIAAYagAAAAEAv/okdecnfYm+tdXFAarHPtq8vkpGhFZQD+B7E9GrxWzpWmeOoLPvoad1NUUX8s7A==", null, false, "22993975-2e15-4a4e-9476-37b5ca1adbea", false, "superadmin@bloggie.com" });
175 | 
176 |             migrationBuilder.InsertData(
177 |                 table: "AspNetUserRoles",
178 |                 columns: new[] { "RoleId", "UserId" },
179 |                 values: new object[,]
180 |                 {
181 |                     { "37cc67e1-41ca-461c-bf34-2b5e62dbae32", "472ba632-6133-44a1-b158-6c10bd7d850d" },
182 |                     { "3cfd9eee-08cb-4da3-9e6f-c3166b50d3b0", "472ba632-6133-44a1-b158-6c10bd7d850d" },
183 |                     { "a0cab2c3-6558-4a1c-be81-dfb39180da3d", "472ba632-6133-44a1-b158-6c10bd7d850d" }
184 |                 });
185 | 
186 |             migrationBuilder.CreateIndex(
187 |                 name: "IX_AspNetRoleClaims_RoleId",
188 |                 table: "AspNetRoleClaims",
189 |                 column: "RoleId");
190 | 
191 |             migrationBuilder.CreateIndex(
192 |                 name: "RoleNameIndex",
193 |                 table: "AspNetRoles",
194 |                 column: "NormalizedName",
195 |                 unique: true,
196 |                 filter: "[NormalizedName] IS NOT NULL");
197 | 
198 |             migrationBuilder.CreateIndex(
199 |                 name: "IX_AspNetUserClaims_UserId",
200 |                 table: "AspNetUserClaims",
201 |                 column: "UserId");
202 | 
203 |             migrationBuilder.CreateIndex(
204 |                 name: "IX_AspNetUserLogins_UserId",
205 |                 table: "AspNetUserLogins",
206 |                 column: "UserId");
207 | 
208 |             migrationBuilder.CreateIndex(
209 |                 name: "IX_AspNetUserRoles_RoleId",
210 |                 table: "AspNetUserRoles",
211 |                 column: "RoleId");
212 | 
213 |             migrationBuilder.CreateIndex(
214 |                 name: "EmailIndex",
215 |                 table: "AspNetUsers",
216 |                 column: "NormalizedEmail");
217 | 
218 |             migrationBuilder.CreateIndex(
219 |                 name: "UserNameIndex",
220 |                 table: "AspNetUsers",
221 |                 column: "NormalizedUserName",
222 |                 unique: true,
223 |                 filter: "[NormalizedUserName] IS NOT NULL");
224 |         }
225 | 
226 |         /// <inheritdoc />
227 |         protected override void Down(MigrationBuilder migrationBuilder)
228 |         {
229 |             migrationBuilder.DropTable(
230 |                 name: "AspNetRoleClaims");
231 | 
232 |             migrationBuilder.DropTable(
233 |                 name: "AspNetUserClaims");
234 | 
235 |             migrationBuilder.DropTable(
236 |                 name: "AspNetUserLogins");
237 | 
238 |             migrationBuilder.DropTable(
239 |                 name: "AspNetUserRoles");
240 | 
241 |             migrationBuilder.DropTable(
242 |                 name: "AspNetUserTokens");
243 | 
244 |             migrationBuilder.DropTable(
245 |                 name: "AspNetRoles");
246 | 
247 |             migrationBuilder.DropTable(
248 |                 name: "AspNetUsers");
249 |         }
250 |     }
251 | }
252 | 


--------------------------------------------------------------------------------
/Bloggie.Web/Migrations/AuthDb/AuthDbContextModelSnapshot.cs:
--------------------------------------------------------------------------------
  1 | // <auto-generated />
  2 | using System;
  3 | using Bloggie.Web.Data;
  4 | using Microsoft.EntityFrameworkCore;
  5 | using Microsoft.EntityFrameworkCore.Infrastructure;
  6 | using Microsoft.EntityFrameworkCore.Metadata;
  7 | using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
  8 | 
  9 | #nullable disable
 10 | 
 11 | namespace Bloggie.Web.Migrations.AuthDb
 12 | {
 13 |     [DbContext(typeof(AuthDbContext))]
 14 |     partial class AuthDbContextModelSnapshot : ModelSnapshot
 15 |     {
 16 |         protected override void BuildModel(ModelBuilder modelBuilder)
 17 |         {
 18 | #pragma warning disable 612, 618
 19 |             modelBuilder
 20 |                 .HasAnnotation("ProductVersion", "7.0.3")
 21 |                 .HasAnnotation("Relational:MaxIdentifierLength", 128);
 22 | 
 23 |             SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
 24 | 
 25 |             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
 26 |                 {
 27 |                     b.Property<string>("Id")
 28 |                         .HasColumnType("nvarchar(450)");
 29 | 
 30 |                     b.Property<string>("ConcurrencyStamp")
 31 |                         .IsConcurrencyToken()
 32 |                         .HasColumnType("nvarchar(max)");
 33 | 
 34 |                     b.Property<string>("Name")
 35 |                         .HasMaxLength(256)
 36 |                         .HasColumnType("nvarchar(256)");
 37 | 
 38 |                     b.Property<string>("NormalizedName")
 39 |                         .HasMaxLength(256)
 40 |                         .HasColumnType("nvarchar(256)");
 41 | 
 42 |                     b.HasKey("Id");
 43 | 
 44 |                     b.HasIndex("NormalizedName")
 45 |                         .IsUnique()
 46 |                         .HasDatabaseName("RoleNameIndex")
 47 |                         .HasFilter("[NormalizedName] IS NOT NULL");
 48 | 
 49 |                     b.ToTable("AspNetRoles", (string)null);
 50 | 
 51 |                     b.HasData(
 52 |                         new
 53 |                         {
 54 |                             Id = "37cc67e1-41ca-461c-bf34-2b5e62dbae32",
 55 |                             ConcurrencyStamp = "37cc67e1-41ca-461c-bf34-2b5e62dbae32",
 56 |                             Name = "Admin",
 57 |                             NormalizedName = "Admin"
 58 |                         },
 59 |                         new
 60 |                         {
 61 |                             Id = "3cfd9eee-08cb-4da3-9e6f-c3166b50d3b0",
 62 |                             ConcurrencyStamp = "3cfd9eee-08cb-4da3-9e6f-c3166b50d3b0",
 63 |                             Name = "SuperAdmin",
 64 |                             NormalizedName = "SuperAdmin"
 65 |                         },
 66 |                         new
 67 |                         {
 68 |                             Id = "a0cab2c3-6558-4a1c-be81-dfb39180da3d",
 69 |                             ConcurrencyStamp = "a0cab2c3-6558-4a1c-be81-dfb39180da3d",
 70 |                             Name = "User",
 71 |                             NormalizedName = "User"
 72 |                         });
 73 |                 });
 74 | 
 75 |             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
 76 |                 {
 77 |                     b.Property<int>("Id")
 78 |                         .ValueGeneratedOnAdd()
 79 |                         .HasColumnType("int");
 80 | 
 81 |                     SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
 82 | 
 83 |                     b.Property<string>("ClaimType")
 84 |                         .HasColumnType("nvarchar(max)");
 85 | 
 86 |                     b.Property<string>("ClaimValue")
 87 |                         .HasColumnType("nvarchar(max)");
 88 | 
 89 |                     b.Property<string>("RoleId")
 90 |                         .IsRequired()
 91 |                         .HasColumnType("nvarchar(450)");
 92 | 
 93 |                     b.HasKey("Id");
 94 | 
 95 |                     b.HasIndex("RoleId");
 96 | 
 97 |                     b.ToTable("AspNetRoleClaims", (string)null);
 98 |                 });
 99 | 
100 |             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUser", b =>
101 |                 {
102 |                     b.Property<string>("Id")
103 |                         .HasColumnType("nvarchar(450)");
104 | 
105 |                     b.Property<int>("AccessFailedCount")
106 |                         .HasColumnType("int");
107 | 
108 |                     b.Property<string>("ConcurrencyStamp")
109 |                         .IsConcurrencyToken()
110 |                         .HasColumnType("nvarchar(max)");
111 | 
112 |                     b.Property<string>("Email")
113 |                         .HasMaxLength(256)
114 |                         .HasColumnType("nvarchar(256)");
115 | 
116 |                     b.Property<bool>("EmailConfirmed")
117 |                         .HasColumnType("bit");
118 | 
119 |                     b.Property<bool>("LockoutEnabled")
120 |                         .HasColumnType("bit");
121 | 
122 |                     b.Property<DateTimeOffset?>("LockoutEnd")
123 |                         .HasColumnType("datetimeoffset");
124 | 
125 |                     b.Property<string>("NormalizedEmail")
126 |                         .HasMaxLength(256)
127 |                         .HasColumnType("nvarchar(256)");
128 | 
129 |                     b.Property<string>("NormalizedUserName")
130 |                         .HasMaxLength(256)
131 |                         .HasColumnType("nvarchar(256)");
132 | 
133 |                     b.Property<string>("PasswordHash")
134 |                         .HasColumnType("nvarchar(max)");
135 | 
136 |                     b.Property<string>("PhoneNumber")
137 |                         .HasColumnType("nvarchar(max)");
138 | 
139 |                     b.Property<bool>("PhoneNumberConfirmed")
140 |                         .HasColumnType("bit");
141 | 
142 |                     b.Property<string>("SecurityStamp")
143 |                         .HasColumnType("nvarchar(max)");
144 | 
145 |                     b.Property<bool>("TwoFactorEnabled")
146 |                         .HasColumnType("bit");
147 | 
148 |                     b.Property<string>("UserName")
149 |                         .HasMaxLength(256)
150 |                         .HasColumnType("nvarchar(256)");
151 | 
152 |                     b.HasKey("Id");
153 | 
154 |                     b.HasIndex("NormalizedEmail")
155 |                         .HasDatabaseName("EmailIndex");
156 | 
157 |                     b.HasIndex("NormalizedUserName")
158 |                         .IsUnique()
159 |                         .HasDatabaseName("UserNameIndex")
160 |                         .HasFilter("[NormalizedUserName] IS NOT NULL");
161 | 
162 |                     b.ToTable("AspNetUsers", (string)null);
163 | 
164 |                     b.HasData(
165 |                         new
166 |                         {
167 |                             Id = "472ba632-6133-44a1-b158-6c10bd7d850d",
168 |                             AccessFailedCount = 0,
169 |                             ConcurrencyStamp = "02dcd5f7-a690-45e5-95d4-d2706865a55a",
170 |                             Email = "superadmin@bloggie.com",
171 |                             EmailConfirmed = false,
172 |                             LockoutEnabled = false,
173 |                             NormalizedEmail = "SUPERADMIN@BLOGGIE.COM",
174 |                             NormalizedUserName = "SUPERADMIN@BLOGGIE.COM",
175 |                             PasswordHash = "AQAAAAIAAYagAAAAEAv/okdecnfYm+tdXFAarHPtq8vkpGhFZQD+B7E9GrxWzpWmeOoLPvoad1NUUX8s7A==",
176 |                             PhoneNumberConfirmed = false,
177 |                             SecurityStamp = "22993975-2e15-4a4e-9476-37b5ca1adbea",
178 |                             TwoFactorEnabled = false,
179 |                             UserName = "superadmin@bloggie.com"
180 |                         });
181 |                 });
182 | 
183 |             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
184 |                 {
185 |                     b.Property<int>("Id")
186 |                         .ValueGeneratedOnAdd()
187 |                         .HasColumnType("int");
188 | 
189 |                     SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
190 | 
191 |                     b.Property<string>("ClaimType")
192 |                         .HasColumnType("nvarchar(max)");
193 | 
194 |                     b.Property<string>("ClaimValue")
195 |                         .HasColumnType("nvarchar(max)");
196 | 
197 |                     b.Property<string>("UserId")
198 |                         .IsRequired()
199 |                         .HasColumnType("nvarchar(450)");
200 | 
201 |                     b.HasKey("Id");
202 | 
203 |                     b.HasIndex("UserId");
204 | 
205 |                     b.ToTable("AspNetUserClaims", (string)null);
206 |                 });
207 | 
208 |             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
209 |                 {
210 |                     b.Property<string>("LoginProvider")
211 |                         .HasColumnType("nvarchar(450)");
212 | 
213 |                     b.Property<string>("ProviderKey")
214 |                         .HasColumnType("nvarchar(450)");
215 | 
216 |                     b.Property<string>("ProviderDisplayName")
217 |                         .HasColumnType("nvarchar(max)");
218 | 
219 |                     b.Property<string>("UserId")
220 |                         .IsRequired()
221 |                         .HasColumnType("nvarchar(450)");
222 | 
223 |                     b.HasKey("LoginProvider", "ProviderKey");
224 | 
225 |                     b.HasIndex("UserId");
226 | 
227 |                     b.ToTable("AspNetUserLogins", (string)null);
228 |                 });
229 | 
230 |             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
231 |                 {
232 |                     b.Property<string>("UserId")
233 |                         .HasColumnType("nvarchar(450)");
234 | 
235 |                     b.Property<string>("RoleId")
236 |                         .HasColumnType("nvarchar(450)");
237 | 
238 |                     b.HasKey("UserId", "RoleId");
239 | 
240 |                     b.HasIndex("RoleId");
241 | 
242 |                     b.ToTable("AspNetUserRoles", (string)null);
243 | 
244 |                     b.HasData(
245 |                         new
246 |                         {
247 |                             UserId = "472ba632-6133-44a1-b158-6c10bd7d850d",
248 |                             RoleId = "37cc67e1-41ca-461c-bf34-2b5e62dbae32"
249 |                         },
250 |                         new
251 |                         {
252 |                             UserId = "472ba632-6133-44a1-b158-6c10bd7d850d",
253 |                             RoleId = "3cfd9eee-08cb-4da3-9e6f-c3166b50d3b0"
254 |                         },
255 |                         new
256 |                         {
257 |                             UserId = "472ba632-6133-44a1-b158-6c10bd7d850d",
258 |                             RoleId = "a0cab2c3-6558-4a1c-be81-dfb39180da3d"
259 |                         });
260 |                 });
261 | 
262 |             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
263 |                 {
264 |                     b.Property<string>("UserId")
265 |                         .HasColumnType("nvarchar(450)");
266 | 
267 |                     b.Property<string>("LoginProvider")
268 |                         .HasColumnType("nvarchar(450)");
269 | 
270 |                     b.Property<string>("Name")
271 |                         .HasColumnType("nvarchar(450)");
272 | 
273 |                     b.Property<string>("Value")
274 |                         .HasColumnType("nvarchar(max)");
275 | 
276 |                     b.HasKey("UserId", "LoginProvider", "Name");
277 | 
278 |                     b.ToTable("AspNetUserTokens", (string)null);
279 |                 });
280 | 
281 |             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
282 |                 {
283 |                     b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
284 |                         .WithMany()
285 |                         .HasForeignKey("RoleId")
286 |                         .OnDelete(DeleteBehavior.Cascade)
287 |                         .IsRequired();
288 |                 });
289 | 
290 |             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
291 |                 {
292 |                     b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
293 |                         .WithMany()
294 |                         .HasForeignKey("UserId")
295 |                         .OnDelete(DeleteBehavior.Cascade)
296 |                         .IsRequired();
297 |                 });
298 | 
299 |             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
300 |                 {
301 |                     b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
302 |                         .WithMany()
303 |                         .HasForeignKey("UserId")
304 |                         .OnDelete(DeleteBehavior.Cascade)
305 |                         .IsRequired();
306 |                 });
307 | 
308 |             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
309 |                 {
310 |                     b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
311 |                         .WithMany()
312 |                         .HasForeignKey("RoleId")
313 |                         .OnDelete(DeleteBehavior.Cascade)
314 |                         .IsRequired();
315 | 
316 |                     b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
317 |                         .WithMany()
318 |                         .HasForeignKey("UserId")
319 |                         .OnDelete(DeleteBehavior.Cascade)
320 |                         .IsRequired();
321 |                 });
322 | 
323 |             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
324 |                 {
325 |                     b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
326 |                         .WithMany()
327 |                         .HasForeignKey("UserId")
328 |                         .OnDelete(DeleteBehavior.Cascade)
329 |                         .IsRequired();
330 |                 });
331 | #pragma warning restore 612, 618
332 |         }
333 |     }
334 | }
335 | 


--------------------------------------------------------------------------------