using System;

namespace Brownbag.Data.Interfaces {
  public interface IAuditable {
    Guid CreatedBy { get; set; }

    DateTime CreatedDate { get; set; }

    Guid? UpdatedBy { get; set; }

    DateTime? UpdatedDate { get; set; }
  }
}

using System;
using System.Collections.Generic;
using Brownbag.Data.Interfaces;

namespace Brownbag.Data.Models
{
    public class Blog : IAuditable
    {
        public Blog()
        {
        }
        public int Id { get; set; }
        public string Url { get; set; }
        public int Rating { get; set; }
        public ICollection<Post> Posts { get; set; }
        public Guid CreatedBy { get; set; }
        public DateTime CreatedDate { get; set; }
        public Guid? UpdatedBy { get; set; }
        public DateTime? UpdatedDate { get; set; }
    }
}

using System;
using System.ComponentModel.DataAnnotations.Schema;
using Brownbag.Data.Interfaces;

namespace Brownbag.Data.Models {
    public class Post : IAuditable {
        public int Id { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }
        public int BlogId { get; set; }
        public virtual Blog Blog { get; set; }

        [ForeignKey ("CreatedByUser")]
        public Guid CreatedBy { get; set; }
        public User CreatedByUser { get; set; }
        public DateTime CreatedDate { get; set; }

        [ForeignKey ("UpdatedByUser")]
        public Guid? UpdatedBy { get; set; }
        public User UpdatedByUser { get; set; }

        public DateTime? UpdatedDate { get; set; }
    }
}

using System;
using System.Collections.Generic;
using Microsoft.AspNetCore.Identity;

namespace Brownbag.Data.Models
{
    public class User : IdentityUser<Guid>
    {
        public User()
        {

        }

        public string UserFullName { get; set; }

        /// Add back legacy Virtuals to support old Identity Style Queries

        /// <summary>
        /// Navigation property for the roles this user belongs to.
        /// </summary>
        public virtual ICollection<IdentityUserRole<Guid>> Roles { get; } = new List<IdentityUserRole<Guid>>();
    }
}

using System;
using Brownbag.Data.Interfaces;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;

namespace Brownbag.Data.Models
{
    public partial class ApplicationDataContext : IdentityDbContext<User, IdentityRole<Guid>, Guid>
    {
        private IHttpContextAccessor _context { get; set; }
        public DbSet<Blog> Blogs { get; set; }
        public DbSet<Post> Posts { get; set; }
        public ApplicationDataContext(DbContextOptions<ApplicationDataContext> options, IHttpContextAccessor contextAccessor) : base(options)
        {
            _context = contextAccessor;
        }
        public override int SaveChanges()
        {
            // https://stackoverflow.com/questions/36401026/how-to-get-user-information-in-dbcontext-using-net-core
            // https://stackoverflow.com/questions/35765204/how-can-i-get-user-and-claim-information-using-action-filters/35826744
            foreach (var auditableEntity in ChangeTracker.Entries<IAuditable>())
            {
                if (auditableEntity.State == EntityState.Added ||
                    auditableEntity.State == EntityState.Modified)
                {

                    auditableEntity.Entity.UpdatedDate = DateTime.Now;
                    auditableEntity.Entity.UpdatedBy = new Guid(_context.HttpContext.User.FindFirst("userId").Value);

                    if (auditableEntity.State == EntityState.Added)
                    {
                        auditableEntity.Entity.CreatedDate = DateTime.Now;
                        auditableEntity.Entity.CreatedBy = new Guid(_context.HttpContext.User.FindFirst("userId").Value);
                    }
                    else
                    {
                        auditableEntity.Property(p => p.CreatedDate).IsModified = false;
                        auditableEntity.Property(p => p.CreatedBy).IsModified = false;
                    }
                }
            }
            return base.SaveChanges();
        }
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<User>()
                .HasMany(e => e.Roles)
                .WithOne()
                .HasForeignKey(e => e.UserId)
                .IsRequired()
                .OnDelete(DeleteBehavior.Cascade);

            modelBuilder.Entity<User>(entity => {
                entity.HasKey(r => new { r.Id });
                entity.ToTable("AspNetUsers");
            });

            modelBuilder.Entity<IdentityRole<Guid>>(entity => {
                entity.HasKey(r => new { r.Id });
                entity.ToTable("AspNetRoles");
            });

            modelBuilder.Entity<IdentityUserClaim<Guid>>(entity => {
                entity.HasKey(r => new { r.Id });
                entity.ToTable("AspNetUserClaims");
            });

            modelBuilder.Entity<IdentityUserRole<Guid>>(entity => {
                entity.HasKey(r => new { r.UserId, r.RoleId });
                entity.ToTable("AspNetUserRoles");
            });

            modelBuilder.Entity<IdentityUserLogin<Guid>>(entity => {
                entity.HasKey(l => new { l.LoginProvider, l.ProviderKey, l.UserId });
                entity.ToTable("AspNetUserLogins");
            });

            modelBuilder.Entity<IdentityUserToken<Guid>>(entity => {
                entity.HasKey(r => r.UserId);
                entity.ToTable("AspNetUserTokens");
            });
        }
    }
}

using Brownbag.Data.Models;
using Brownbag.Web.Controllers;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;

namespace Brownbag.Web.Middleware
{
    public class RolesAuthorizationMiddleware : IMiddleware {
        private readonly ApplicationDataContext _db;

        public RolesAuthorizationMiddleware(ApplicationDataContext db) {
            _db = db;
        }

        public async Task InvokeAsync(HttpContext context, RequestDelegate next) {
            try {
                User user = _db.Users.Include(a => a.Roles).FirstOrDefault(u => u.UserName.Equals(context.User.Identity.Name, StringComparison.CurrentCultureIgnoreCase));
                if (user != null) {
                    var roles = from ur in user.Roles
                    from r in _db.Roles
                    where ur.RoleId.Equals(r.Id)
                    select r.Name;

                    var UserRoleClaims = roles.Select(i => new Claim(ClaimTypes.Role, i));
                    ((ClaimsIdentity) context.User.Identity).AddClaims(UserRoleClaims);
                    ((ClaimsIdentity) context.User.Identity).AddClaim(new Claim("userId", user.Id.ToString()));
                }
            } catch (Exception e) {
                Console.Write(e);
            }

            await next(context);
        }

    }
    public static class RolesAuthorizationMiddlewareExtensions {
        public static IApplicationBuilder RolesAuthorization(
            this IApplicationBuilder builder) {
            return builder.UseMiddleware<RolesAuthorizationMiddleware>();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Security.Claims;
using Brownbag.Web.Models;

namespace Brownbag.Web.Middleware
{
    public interface IBrownbagRoleProvider
    {
        string[] GetRolesForUser(string username);
        string GetRolesForUserFlat(string username);
        IList<GuidLookupViewModel> GetRolesForUserManagement(string username);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using Brownbag.Data.Models;
using Brownbag.Web.Middleware;
using Brownbag.Web.Models;
using Microsoft.EntityFrameworkCore;

namespace Brownbag.Web.Middleware {
    public class BrownbagRoleProvider: IBrownbagRoleProvider {
        private readonly ApplicationDataContext db;

        public BrownbagRoleProvider (ApplicationDataContext context) {
            db = context;
        }

        public string[] GetRolesForUser(string username) {
            User user = db.Users.Include(a => a.Roles).FirstOrDefault(u => u.UserName.Equals(username, StringComparison.CurrentCultureIgnoreCase));
            if (user != null) {
                //db.Use
                var roles = from ur in user.Roles
                from r in db.Roles
                where ur.RoleId.Equals(r.Id)
                select r.Name;
                if (roles != null)
                    return roles.ToArray();
                else
                    return new string[] { };
            }
            return new string[] { };
        }
        public IList<GuidLookupViewModel> GetRolesForUserManagement(string username) {
            User user = db.Users.Include(a => a.Roles).FirstOrDefault(u => u.UserName.Equals(username, StringComparison.CurrentCultureIgnoreCase));
            if (user != null) {
                var roles = from ur in user.Roles
                from r in db.Roles
                where ur.RoleId.Equals(r.Id)
                select r;
                if (roles != null)
                    return roles.Select(r => new GuidLookupViewModel { Value = r.Name, ID = r.Id }).ToList();
                else
                    return new List<GuidLookupViewModel>();
            }
            return new List<GuidLookupViewModel>();
        }
        public string GetRolesForUserFlat(string username) {
            User user = db.Users.Include(a => a.Roles).FirstOrDefault(u => u.UserName.Equals(username, StringComparison.CurrentCultureIgnoreCase));
            if (user != null) {
                var roles = from ur in user.Roles
                from r in db.Roles
                where ur.RoleId.Equals(r.Id)
                select r.Name;
                if (roles != null)
                    return roles.ToString();
                else
                    return "";
            }
            return "";
        }

        public string[] GetUsersInRole(string roleName) {
            var roleID = db.Roles
                .Where(role => role.Name == roleName)
                .FirstOrDefault();

            var users = db.Users.Where(x => x.Roles.Where(a => a.RoleId.Equals(roleID.Id)).Any()).Select(x => x.UserFullName).ToArray();
            return users;
        }

        public bool IsUserInRole(string username, string roleName) {
            User user = db.Users.Include(a => a.Roles).FirstOrDefault(u => u.UserName.Equals(username, StringComparison.CurrentCultureIgnoreCase));

            var roles = from ur in user.Roles
            from r in db.Roles
            where ur.RoleId.Equals(r.Id)
            select r.Name;
            if (user != null)
                return roles.Any(r => r.Equals(roleName, StringComparison.CurrentCultureIgnoreCase));
            else
                return false;
        }

        public Guid GetUserId(string username) {
            User user = db.Users.FirstOrDefault(u => u.UserName.Equals(username, StringComparison.CurrentCultureIgnoreCase));

            if (user != null)
                return user.Id;
            else
                return Guid.Parse("00000000-0000-0000-0000-000000000000");
        }
    }
}

using System;
using System.Security.Claims;
using AutoMapper;
using Brownbag.Data.Models;
using Brownbag.Web.Middleware;
using Brownbag.Web.Models;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Server.IISIntegration;
using Microsoft.AspNetCore.SpaServices.AngularCli;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;

namespace Brownbag.Web {
    public class Startup {
        public Startup (IHostingEnvironment env) {
            IConfigurationBuilder builder = new ConfigurationBuilder ()
                .SetBasePath (env.ContentRootPath)
                .AddJsonFile ("appsettings.json", optional : false, reloadOnChange : true)
                .AddJsonFile ($"appsettings.{env.EnvironmentName}.json", optional : false, reloadOnChange : true);
            this.Configuration = builder.Build ();
        }
        public Startup (IConfiguration configuration) {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices (IServiceCollection services) {
            services.AddMvc ();

            services.AddDbContext<ApplicationDataContext>(options => options.UseSqlServer(this.Configuration.GetConnectionString("ApiDb")));
            services.AddIdentity<User, IdentityRole<Guid>> (options =>
                    options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@/\\")
                .AddEntityFrameworkStores<ApplicationDataContext> ();
            services.TryAddSingleton<IHttpContextAccessor, HttpContextAccessor> ();
            services.AddMvc ()
                .AddJsonOptions (options => {
                    options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
                    options.SerializerSettings.ContractResolver = new Newtonsoft.Json.Serialization.DefaultContractResolver ();
                });

            services.AddKendo ();
            services.AddScoped<IBrownbagRoleProvider, BrownbagRoleProvider> ();

            // In production, the Angular files will be served from this directory
            services.AddSpaStaticFiles (configuration => {
                configuration.RootPath = "ClientApp/dist";
            });

            services.AddAutoMapper ();
            services.AddTransient<RolesAuthorizationMiddleware> ();

            services.AddAuthorization (options => {
                options.AddPolicy ("Admin",
                    policy => {
                        policy.RequireAuthenticatedUser ();
                        policy.RequireClaim (ClaimTypes.Role, "Admin");
                    });
            });
            services.Configure<IISOptions> (options => {
                options.AutomaticAuthentication = true;
            });
            services.AddAuthentication (IISDefaults.AuthenticationScheme);

        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure (IApplicationBuilder app, IHostingEnvironment env) {
            app.RolesAuthorization ();

            if (env.IsDevelopment ()) {
                app.UseDeveloperExceptionPage ();
            } else {
                app.UseExceptionHandler ("/Home/Error");
            }

            app.UseStaticFiles ();
            app.UseSpaStaticFiles ();

            app.UseMvc (routes => {
                routes.MapRoute (
                    name: "default",
                    template: "{controller}/{action=Index}/{id?}");
            });

            app.UseSpa (spa => {
                // To learn more about options for serving an Angular SPA from ASP.NET Core,
                // see https://go.microsoft.com/fwlink/?linkid=864501

                spa.Options.SourcePath = "ClientApp";

                if (env.IsDevelopment ()) {
#if DEBUG
                    spa.UseProxyToSpaDevelopmentServer ("http://localhost:4200");
#endif
#if INTEGRATED || RELEASE
                    spa.UseAngularCliServer (npmScript: "start");
#endif
                }
            });
            app.UseAuthentication ();
        }
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Brownbag.Data.Models;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Server.HttpSys;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace Brownbag.Web
{
    public class Program
    {

        public static void Main(string[] args)
        {
            var host = BuildWebHost(args);
            using (var scope = host.Services.CreateScope())
            {
                // Retrieve your DbContext instance here
                var dbContext = scope.ServiceProvider.GetService<ApplicationDataContext>();

                // place your DB seeding code here
                /*
                NEED TO ADD BACK IN SEEDING METHOD!
                https://www.ryadel.com/en/buildwebhost-unable-to-create-an-object-of-type-applicationdbcontext-error-idesigntimedbcontextfactory-ef-core-2-fix/
                 */
                // DbSeeder.Seed(dbContext);
            }
            host.Run();

            // ref.: https://docs.microsoft.com/en-us/aspnet/core/migration/1x-to-2x/
        }

        public static IWebHost BuildWebHost(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
            .UseKestrel()
#if DEBUG || INTEGRATED
            .UseHttpSys(options => {
                options.Authentication.Schemes =
                    AuthenticationSchemes.NTLM | AuthenticationSchemes.Negotiate;
                options.Authentication.AllowAnonymous = false;
            })
#endif
            .UseStartup<Startup>()
            .Build();
    }
}

using System;
using Brownbag.Data.Models;
using AutoMapper;
using Microsoft.AspNetCore.Mvc;
using Brownbag.Web.Middleware;

namespace Brownbag.Web.Controllers
{
    public class AccountController : Controller
    {
        private readonly ApplicationDataContext db;
        private readonly IBrownbagRoleProvider BrownbagRoleProvider;

        public AccountController(ApplicationDataContext context, IBrownbagRoleProvider rp)
        {
            db = context;
            BrownbagRoleProvider = rp;
        }
        public ActionResult Denied()
        {
            return View();
        }
        [Route("api/account/user")]
        public ActionResult GetRoles()
        {
            return Json(new { name = User.Identity.Name, roles = BrownbagRoleProvider.GetRolesForUser(User.Identity.Name) });
        }
    }
}

using AutoMapper;
using Brownbag.Data.Models;
using Brownbag.Web.Extensions;
using Brownbag.Web.Models;
using Brownbag.Web.Models.PrimeNG.Grid;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
namespace Brownbag.Web.Controllers
{
    [Route("api/[controller]")]
    [Authorize(Policy="Admin")]
    public class BlogController : Controller
    {
        private readonly ApplicationDataContext _context;
        private readonly IMapper _mapper;

        public BlogController(IMapper mapper, ApplicationDataContext appDbContext)
        {
            _mapper = mapper;
            _context = appDbContext;
        }

        // GET api/Admin/[controller]?{currentPage}&{rows}&{searchQuery}
        [HttpGet]
        public GridViewModel<BlogViewModel> Read(int currentPage, int rows, string searchQuery)
        {
            GridViewModel<BlogViewModel> vm = new GridViewModel<BlogViewModel>();

            try
            {
                int maxRows = rows == 0 ? 10 : rows;
                currentPage = currentPage == 0 ? 1 : currentPage;

                IQueryable<Blog> query = _context.Blogs.Include(x=>x.Posts);

                if (searchQuery != null)
                {
                    query = query.Where(
                        e => e.Url.CaseInsensitiveContains(searchQuery));
                    // Returns the search query to help maintain state
                    vm.SearchQuery = searchQuery;
                }
                double pageCount = (double)((decimal)query.Count() / Convert.ToDecimal(maxRows));
                vm.PageCount = (int)Math.Ceiling(pageCount);

                query = query
                        .OrderBy(item => item.Id).Skip((currentPage - 1) * maxRows)
                        .Take(maxRows);

                var mapped = _mapper.Map<BlogViewModel[]>(query);
                vm.Data = mapped;

                vm.Page = currentPage;
                vm.Rows = maxRows;

                return vm;
            }
            catch (Exception ex)
            {
                vm.Errors = ex.ToString();
                return vm;
            }

        }

        // GET api/Admin/[controller]/{id}
        [HttpGet("{id:int}")]
        public Blog Edit([FromRoute]int id)
        {
            /*
            We are NOT using automapper here even because we can just return the entity because
            it has no has virtual or irrelevant properties which should not be sent for no reason.
            If you look at OccupationalSpecialtyController it does the opposite
             */
            return _context.Blogs.Include(x => x.Posts).Where(y => y.Id.Equals(id)).FirstOrDefault();
        }

        // POST api/Admin/[controller]
        [HttpPost()]
        public ActionResult Create([FromBody]Blog entity)
        {
            /*
            To follow Microsoft API Guidance Post method is left here. 
            However since our add and update methods are basically
            the same, to save a step they share a save and update 
            method. This method simply passes the data to the update
            method.
            Source: http://aka.ms/RestApiGuidance
             */
            return Update(entity);
        }

        // PUT api/Admin/[controller]
        [HttpPut()]
        public ActionResult Update([FromBody]Brownbag.Data.Models.Blog entity)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState);
                }
                /*
                EF Core 2.0+ Assumes if Id = 0 then you want to add.
                So we can effectively use the same method for create
                and update since leaving out the Id or explicitly 
                setting it to 0 will let EF know that its an add not
                update
                 */
                _context.Blogs.Update(entity);
                _context.SaveChanges();
            }
            catch (Exception ex)
            {
                ModelState.AddModelError("Generic Error", "Something went wrong, please contact administrator" + ex);
                return BadRequest(ModelState);
            }
            return Json(new[] { entity });
        }



    }
}

using AutoMapper;
using Brownbag.Data.Models;
using Brownbag.Web.Extensions;
using Brownbag.Web.Models;
using Brownbag.Web.Models.PrimeNG.Grid;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
namespace Brownbag.Web.Controllers
{
    [Route("api/[controller]")]
    public class BlogViewController : Controller
    {
        private readonly ApplicationDataContext _context;
        private readonly IMapper _mapper;

        public BlogViewController(IMapper mapper, ApplicationDataContext appDbContext)
        {
            _mapper = mapper;
            _context = appDbContext;
        }

        // GET api/Admin/[controller]?{currentPage}&{rows}&{searchQuery}
        [HttpGet]
        public GridViewModel<BlogPostsViewModel> Read(int currentPage, int rows, int blogId)
        {
            GridViewModel<BlogPostsViewModel> vm = new GridViewModel<BlogPostsViewModel>();

            try
            {
                int maxRows = rows == 0 ? 10 : rows;
                currentPage = currentPage == 0 ? 1 : currentPage;

                IQueryable<Post> query = _context.Posts.Include(y=> y.CreatedByUser).Include(z=>z.UpdatedByUser);

                if (blogId != 0)
                {
                    query = query.Where(
                        e => e.BlogId.Equals(blogId));
                    // Returns the search query to help maintain state
                    vm.SearchQuery = blogId.ToString();
                }
                double pageCount = (double)((decimal)query.Count() / Convert.ToDecimal(maxRows));
                vm.PageCount = (int)Math.Ceiling(pageCount);

                query = query
                        .OrderBy(item => item.Id).Skip((currentPage - 1) * maxRows)
                        .Take(maxRows);

                var mapped = _mapper.Map<BlogPostsViewModel[]>(query);
                vm.Data = mapped;

                vm.Page = currentPage;
                vm.Rows = maxRows;

                return vm;
            }
            catch (Exception ex)
            {
                vm.Errors = ex.ToString();
                return vm;
            }

        }

        // GET api/Admin/[controller]/{id}
        [HttpGet("{id:int}")]
        public Blog Edit([FromRoute]int id)
        {
            /*
            We are NOT using automapper here even because we can just return the entity because
            it has no has virtual or irrelevant properties which should not be sent for no reason.
            If you look at OccupationalSpecialtyController it does the opposite
             */
            return _context.Blogs.Include(x => x.Posts).Where(y => y.Id.Equals(id)).FirstOrDefault();
        }

        // POST api/Admin/[controller]
        [HttpPost()]
        public ActionResult Create([FromBody]Blog entity)
        {
            /*
            To follow Microsoft API Guidance Post method is left here. 
            However since our add and update methods are basically
            the same, to save a step they share a save and update 
            method. This method simply passes the data to the update
            method.
            Source: http://aka.ms/RestApiGuidance
             */
            return Update(entity);
        }

        // PUT api/Admin/[controller]
        [HttpPut()]
        public ActionResult Update([FromBody]Brownbag.Data.Models.Blog entity)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState);
                }
                /*
                EF Core 2.0+ Assumes if Id = 0 then you want to add.
                So we can effectively use the same method for create
                and update since leaving out the Id or explicitly 
                setting it to 0 will let EF know that its an add not
                update
                 */
                _context.Blogs.Update(entity);
                _context.SaveChanges();
            }
            catch (Exception ex)
            {
                ModelState.AddModelError("Generic Error", "Something went wrong, please contact administrator" + ex);
                return BadRequest(ModelState);
            }
            return Json(new[] { entity });
        }



    }
}

using System.Collections.Generic;
using System.Linq;
using AutoMapper;
using Brownbag.Data.Models;
using Brownbag.Web.Models;
using Microsoft.AspNetCore.Mvc;

namespace Brownbag.Web.Controllers {

    [Route ("api/[controller]")]
    public class LookupsController : Controller {
        private readonly ApplicationDataContext _context;
        private readonly IMapper _mapper;
        public LookupsController (IMapper mapper, ApplicationDataContext appDbContext) {
            _mapper = mapper;
            _context = appDbContext;
        }

        [HttpGet ("[action]")]
        public IEnumerable<LookupViewModel> Blogs () {
            return _context.Blogs.Select (blog => new LookupViewModel {
                ID = blog.Id,
                    Value = blog.Url
            });
        }

    }
}

using AutoMapper;
using Brownbag.Data.Models;
using Brownbag.Web.Extensions;
using Brownbag.Web.Models;
using Brownbag.Web.Models.PrimeNG.Grid;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
namespace Brownbag.Web.Controllers
{
    [Route("api/[controller]")]
    public class PostController : Controller
    {
        private readonly ApplicationDataContext _context;
        private readonly IMapper _mapper;

        public PostController(IMapper mapper, ApplicationDataContext appDbContext)
        {
            _mapper = mapper;
            _context = appDbContext;
        }

        // GET api/Admin/[controller]?{currentPage}&{rows}&{searchQuery}
        [HttpGet]
        public GridViewModel<PostViewModel> Read(int currentPage, int rows, string searchQuery)
        {
            GridViewModel<PostViewModel> vm = new GridViewModel<PostViewModel>();

            try
            {
                int maxRows = rows == 0 ? 10 : rows;
                currentPage = currentPage == 0 ? 1 : currentPage;

                IQueryable<Post> query = _context.Posts.Include(x=>x.Blog);

                if (searchQuery != null)
                {
                    query = query.Where(
                        e => e.Content.CaseInsensitiveContains(searchQuery) ||
                        e.Title.CaseInsensitiveContains(searchQuery) ||
                        e.Blog.Url.CaseInsensitiveContains(searchQuery)
                        );
                    // Returns the search query to help maintain state
                    vm.SearchQuery = searchQuery;
                }
                double pageCount = (double)((decimal)query.Count() / Convert.ToDecimal(maxRows));
                vm.PageCount = (int)Math.Ceiling(pageCount);

                query = query
                        .OrderBy(item => item.Id).Skip((currentPage - 1) * maxRows)
                        .Take(maxRows);

                var mapped = _mapper.Map<PostViewModel[]>(query);
                vm.Data = mapped;

                vm.Page = currentPage;
                vm.Rows = maxRows;

                return vm;
            }
            catch (Exception ex)
            {
                vm.Errors = ex.ToString();
                return vm;
            }

        }

        // GET api/Admin/[controller]/{id}
        [HttpGet("{id:int}")]
        public Post Edit([FromRoute]int id)
        {
            /*
            We are NOT using automapper here even because we can just return the entity because
            it has no has virtual or irrelevant properties which should not be sent for no reason.
            If you look at OccupationalSpecialtyController it does the opposite
             */
            return _context.Posts.Include(x => x.Blog).Where(y => y.Id.Equals(id)).FirstOrDefault();
        }

        // POST api/Admin/[controller]
        [HttpPost()]
        public ActionResult Create([FromBody]Post entity)
        {
            /*
            To follow Microsoft API Guidance Post method is left here. 
            However since our add and update methods are basically
            the same, to save a step they share a save and update 
            method. This method simply passes the data to the update
            method.
            Source: http://aka.ms/RestApiGuidance
             */
            return Update(entity);
        }

        // PUT api/Admin/[controller]
        [HttpPut()]
        public ActionResult Update([FromBody]Brownbag.Data.Models.Post entity)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState);
                }
                /*
                EF Core 2.0+ Assumes if Id = 0 then you want to add.
                So we can effectively use the same method for create
                and update since leaving out the Id or explicitly 
                setting it to 0 will let EF know that its an add not
                update
                 */
                _context.Posts.Update(entity);
                _context.SaveChanges();
            }
            catch (Exception ex)
            {
                ModelState.AddModelError("Generic Error", "Something went wrong, please contact administrator" + ex);
                return BadRequest(ModelState);
            }
            return Json(new[] { entity });
        }



    }
}

using System;

namespace Brownbag.Web.Extensions
{
    public static class SearchExtensions
    {
        public static bool CaseInsensitiveContains(this string text, string value)
        {
            if (text != null && value!= null)
            {
                return text.IndexOf(value, StringComparison.CurrentCultureIgnoreCase) >= 0;
            }
            else
            {
                return false;
            }
        }
    }
}

using Brownbag.Data.Models;
using Reinforced.Typings.Attributes;

namespace Brownbag.Web.Models {
    [TsInterface (AutoI = false)]
    public class PostViewModel {
        public int Id { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }
        public int BlogId { get; set; }
        public Blog Blog { get; set; }

    }
}

using System;
using Brownbag.Data.Models;
using AutoMapper;
using Microsoft.AspNetCore.Mvc;
using Brownbag.Web.Middleware;
using System.Collections.Generic;
using Reinforced.Typings.Attributes;

namespace Brownbag.Web.Models
{
    [TsInterface(AutoI = false)]
    public class BlogViewModel
    {
        public int Id { get; set; }
        public string Url { get; set; }
        public int Rating { get; set; }
        public ICollection<PostViewModel> Posts { get; set; }

    }
}

using Reinforced.Typings.Attributes;

namespace Brownbag.Web.Models
{
    [TsInterface(AutoI=false)]
    public class WeatherForecast
    {
        public string DateFormatted { get; set; }   
        public int TemperatureC { get; set; }
        public int TemperatureF { get; set; }
        public string Summary { get; set; }
    }
}

using System;
using Reinforced.Typings.Attributes;

namespace Brownbag.Web.Models {
    [TsInterface (AutoI = false)]
    public class BlogPostsViewModel : PostViewModel {
        public UsersViewModel CreatedByUser { get; set; }
        public UsersViewModel UpdatedByUser { get; set; }
        public DateTime CreatedDate { get; set; }
        public DateTime UpdatedDate { get; set; }
    }
}

using System;
using Reinforced.Typings.Attributes;

namespace Brownbag.Web.Models
{
    [TsInterface (AutoI = false)]    
    public class GuidLookupViewModel
    {
        public Guid ID { get; set; }
        public string Value { get; set; }
    }
}

using Reinforced.Typings.Attributes;

namespace Brownbag.Web.Models
{
    [TsInterface (AutoI = false)]
    public class LookupViewModel
    {
        public int ID { get; set; }
        public string Value { get; set; }
    }
}

using Reinforced.Typings.Attributes;

namespace Brownbag.Web.Models
{
    [TsInterface (AutoI = false)]
    public class UsersViewModel
    {
        public string UserFullName { get; set; }
    }
}

using Reinforced.Typings.Attributes;

namespace Brownbag.Web.Models.PrimeNG.Grid
{
    [TsInterface(AutoI=false)]
    public class GridPaginator
    {
        ///<summary>
        /// First Item in PrimeNG Grid Data
        ///</summary>
        public int First { get; set; }
        ///<summary>
        /// Gets or sets CurrentPageIndex.
        ///</summary>
        public int Page { get; set; }

        ///<summary>
        /// Gets or sets PageCount.
        ///</summary>
        public int PageCount { get; set; }
        ///<summary>
        /// Gets or sets Rows
        ///</summary>
        public int Rows { get; set; }
    }
}

using Reinforced.Typings.Attributes;

namespace Brownbag.Web.Models.PrimeNG.Grid
{
    [TsInterface(AutoI=false)]
    public class GridViewModel<T> : GridPaginator
    {
        ///<summary>
        /// Generic Data responce holder for PrimeNG Grid Data
        ///</summary>
        public T[] Data { get; set; }
        ///<summary>
        /// Generic Error responce holder for PrimeNG Grid Data
        ///</summary>
        public string Errors { get; set; }
        ///<summary>
        /// Passes back the search query
        ///</summary>
        public string SearchQuery { get; set; }
    }
}

using Brownbag.Data.Models;
using Brownbag.Web.Models;

namespace Brownbag.Web.Automapper
{
    public class BrownbagMappingProfile : AutoMapper.Profile
    {
        public BrownbagMappingProfile()
        {
            CreateMap<Blog, BlogViewModel>()
           .ReverseMap();
            CreateMap<Post, PostViewModel>()
           .ReverseMap();
           CreateMap<Post, BlogPostsViewModel>();
        }
    }
}