Master ASP.NET Core 3.1 MVC with 7 Step By Step Projects

Explore a simple ASP.NET Core MVC demo that lists products in a table, uses routing and MVC views with action links and partials to show the product of the month.

Create an asp.net core 3.1 mvc web application using the model-view-controller template and bootstrap, then configure startup, routing, controllers, views, and models for local development.

Create a product model with id, name, price, and a slug that replaces spaces with dashes for clean URLs, then build a simulated database for your MVC project.

Create a mock database by adding a database class with static methods to get all products and a single product, using a hard-coded list with id, name, price, and slug.

Implement a public static get product method that returns a product by slug by looping through all products and returning the match or null if none.

streamline the home controller in asp.net core 3.1 mvc by keeping only index and about actions that return default views and removing unused privacy, error, and logger code.

Create a product controller with a detail action that accepts a slug, fetches product via get product method, and returns the view. Set up a list action to display products.

Create a public list action in the product controller that retrieves all products via the static product method and passes the list to the view for display.

Modify the shared layout to use the about page, update navigation links, and enable dynamic titles with view data and asp tag helpers while preserving bootstrap scripts.

Build the home index view, pass a dynamic title via view back, and create links using asp route and asp tag syntax to product details, product list, and about.

Create product detail view in ASP.NET Core 3.1 MVC app using the product model, display id, name, and price in a bordered, striped bootstrap table, with a home button.

Display a list of products in a Bootstrap-styled table, looping through the product list to show name and price as currency, with links to each product's details using its slug.

Learn how the about view wires to the home controller's about action, rendering a static page and illustrating MVC structure, routing, partial views, and model binding.

Create a new asp.net core 3.1 mvc project with an empty template, then add folders for models, controllers, and wwwroot, and include a views/shared/_layout to load styling.

Create a future value model for a calculator with monthly investment, yearly interest rate, and years; add a calculate method that loops months to compute the future value.

Add a controller with get and post index actions, using a future value model to calculate results, validate input, and preserve user data on errors via the view bag.

Create a shared layout in views/shared named _layout to render the page body with common elements, and wire it via _ViewStart and _ViewImports to enable tag helpers.

Set up a home index view in an ASP.NET Core 3.1 MVC app. Bind inputs with asp-for to the FutureValueModel and post to calculate and display the future value.

Configure an ASP.NET Core 3.1 MVC project by enabling controllers with views, setting up routing with a default controller and action, and validating user input in a calculator example.

Enforce data validation in an ASP.NET Core 3.1 MVC app by applying required and range attributes, making fields nullable to capture empty submissions, and displaying errors with a validation summary.

Install bootstrap via the library manager to style pages, then add jquery, jquery validate, and unobtrusive validation for client-side form validation in the project.

Learn a quick bootstrap overview, using essential bootstrap classes and attributes to style forms, tables, text alignment, buttons, alerts, and navigation, with guidance to consult the official docs.

Add css and js to the asp.net core 3.1 mvc project by wiring bootstrap, jquery, and unobtrusive validation scripts in _layout header. Ensure every page renders with header and view.

Style the index view with Bootstrap classes, layout inputs and labels in rows, and use a read-only future value input from the view bag, along with primary and secondary buttons.

Wrap the page in a container, add a header with a responsive logo and a dynamic title from the view bag, and include a dismissable bootstrap alert for educational purposes.

Uninstall unstable bootstrap 5.0 alpha and install stable bootstrap 4.5.0 with css and js files. Learn to adjust layout so text boxes are smaller and aligned with labels.

Format the future value as currency with two decimals in the mvc app, updating the controller to use the model value, removing nullable fields, and showing errors beside text boxes.

Learn field-level validation in ASP.NET Core 3.1 MVC by using asp-for and spans for per-field errors, format results as currency, and apply bootstrap styling with get/post on a single view.

Build a songs list app with ASP.NET Core 3.1 MVC, creating a database with songs and genre tables, linking via a foreign key, and implementing CRUD with validation and bootstrap.

Create an ASP.NET Core 3.1 MVC project from the MVC template, customize the home controller and views, remove unused files, and prepare to install Entity Framework.

Install the entity framework core package version 3.1.5 via the package manager, then configure appsettings.json and startup middleware, and create a db context with db sets to enable migrations.

Create a song model with properties for song ID, name, year, and rating, using required attributes with custom messages and range constraints, and wire it to the Entity Framework context.

Create a song context by inheriting from DbContext, expose a DbSet<Song> Songs, and pass options to the base. Seed data with HasData in OnModelCreating and define the connection string.

Add a connection string named SongContext in appsettings.json with localdb server, database songs, trusted connection, and multiple active result sets; then configure the DbContext with UseSqlServer from GetConnectionString('SongContext').

Create and seed a database using the package manager console, add an initial migration, define a songs table (id, name, rating), and run update-database to apply migrations.

Inject the song context into the home controller, use link-based queries to fetch and order songs, then pass the list to the index view.

Modify the home index and layout to display a songs list from the model in a bootstrap table, with edit, delete, and add new song links using the song controller.

In master ASP.NET Core 3.1 MVC, create a song controller with add, edit, and delete actions, inject the db context, and reuse an edit view bound to a song model.

Learn to implement a song edit workflow in ASP.NET Core MVC: fetch by id, present editable view, validate, add or update via Entity Framework, save changes, and redirect to index.

Display the targeted song for deletion by id, perform a post action to remove it via the context, save changes, and redirect to the home index.

Show how to implement a delete view for the song controller in an ASP.NET Core MVC app, with a hidden id, a post delete action, and cancel navigation.

Add a genre model to the songs with a genre id and a name, mark genre as required with a custom message, and link songs to genres via foreign key.

Create a genre table and genre entity, seed data (Emma, metal; rap; hip hop; rock), and link songs via a genre ID foreign key, then apply the migration.

Include genre in the songs query and display its name in the view, while creating a genres dataset and migrating the table to genres.

Modify the song controller to load genres from the data context, order by name, and pass them to create and edit views via the view bag. Keep delete logic unchanged.

Add a genre dropdown bound to genre ID, populated from the genres list via the view bag, with a 'select a genre' placeholder and validation.

Learn to create user-friendly urls by generating a slug in the model, converting to lowercase, replacing spaces with dashes, and using optional slugs in edit and delete routes.

Master the basics of debugging with breakpoints in a songs list app, inspect variables with hover and the locals window, and use step commands in Visual Studio.

Learn to debug an ASP.NET Core 3.1 MVC app by using tracepoints and breakpoints to diagnose save changes errors, inspect locals, and output messages in the debug window.

Demonstrate routing in ASP.NET Core 3.1 MVC by creating an empty project with controllers, configuring a default route, and map controller route to actions like index.

Create a home controller, add actions that return content strings, and experiment with a display action accepting an id to show dynamic content through routes.

Demonstrate testing default routes in ASP.NET Core MVC by routing to home index when no controller or action is specified, and show how specifying a controller or action changes navigation.

Create a countdown action in ASP.NET Core MVC that returns a content string, looping from a user-supplied integer down to zero with an optional id parameter and attribute routing.

Apply an attribute route to a home controller action, learn how the route can specify only the action, and use an optional id that must match the method parameter.

Add start and end parameters and an optional message to a countdown action, enabling counting from a chosen start to an end value via attribute routing and returning content.

Explore how ASP.NET Core 3.1 MVC routing works, revealing why the default route (controller/action/optional id) may ignore extra countdown arguments and how to align routes with different patterns.

Add a product controller with list and detail actions using category and page parameters to paginate product listings, and demonstrate routing priorities from explicit paging endpoints to the default route.

Explore routes without controllers in ASP.NET Core MVC, using attribute and default routing to map domain paths like /about and / to actions, and return different result types.

Explore a sweets shop demo built with ASP.NET Core 3.1 MVC, featuring category filtering, product catalog, add to cart simulation, admin area management, and routing concepts.

Develop core asp.net core 3.1 mvc concepts using razor syntax, models, action results, areas, asp-items, select lists, and view models, then implement redirects and currency formatting.

Overhaul the starter app into a database-backed MVC project by adding categories, a simulated admin area and CRUD operations, while mastering areas, models and view models, and controller-to-view data flow.

Define the category model with id and name properties, mark the name as required, and display 'Please enter a category name' on validation errors for the candy shop.

Update the product model to require name and price with custom error messages, map price to decimal(18,2), generate a slug, enforce category relation, and add discount and code fields.

Modify the startup routing to add an optional slug parameter in the url, enabling routes with optional id and slug while preserving mvc, developer exception pages, and static views.

Configure a shop context connection string to connect Pavel's sweetshop localdb, specifying server=(localdb), database name Pavel's sweetshop, trusted_connection=true, and multiple active result sets; then create the database context.

Install entity framework core packages and tools, replace the simulated db context with a real DbContext, and enable migrations and database commands in an ASP.NET Core 3.1 MVC project.

Inject the context options into the shop context via a constructor that passes them to the base class, and define DbSet properties for categories and products with seed data.

Override on model creating to seed category data with the model builder, defining five categories (chocolate, fruit candy, gummy candy, Halloween candy, hard candy) and seed the product table.

Seed the products table using the model builder and health data method, creating 15 products across chocolate, fruit, gummy, halloween candy, and hard candy with IDs, codes, names, and prices.

Configure the shop context with a SQL Server connection string, apply an initial migration to create categories and products tables, seed data, and update the database.

Explore ASP.NET Core 3.1 MVC basics by adding index and about actions, routing, and a cart controller with an add action accepting a product id.

Inject the shop context into the product details action, load a product by id, and pass its category name and image file name to the view using a view bag.

Redesign the product controller list action to use the /products route with an optional id to filter by category name, load categories, order results, and index to redirect to list.

Modify the home index view to display links to the product list and the about page, using a list group with items linked to product/list and home/about actions.

Modify the product detail view to display a dynamic image from the view bag, show the product name and category, and present list price, discount, final price, and savings.

Modify the product list view to display a category menu, populate categories from a view bag, and link to product details and add-to-cart actions in an asp.net core mvc app.

Add a cart view in an ASP.NET Core MVC app by creating index and add actions, displaying cart status with view bag data, and enabling category filters and product details.

Implement dynamic category navigation in the ASP.NET MVC product list: display actual category text, highlight the selected category, and add an all link to view all products with proper routing.

Create an admin area in an asp.net core mvc app by organizing areas with controllers and views, reusing category and product models, and enabling editing, adding, and deleting products.

Add a home controller in the admin area and annotate it with the area attribute to serve admin/index. Then create a category controller for the admin section.

Create an admin category list action in the admin area, inject the shop context, fetch and order all categories by id, and render them in a view.

Create an admin category list view in ASP.NET Core 3.1 MVC, showing categories in a table with update and delete links and an add button in the admin layout.

Create admin routing by configuring an admin area with a dedicated route, map area controller, and admin slash categories that redirect to the category list, enabling admin category management.

Create an add category action in the admin area using a shared view for both adding and updating, passing a category model and a view bag flag to indicate action.

implement the update category action in ASP.NET Core MVC: retrieve by id, reuse the add/update view, validate the model, and persist changes via add or update with save.

Delete a category in the admin area of an ASP.NET Core MVC app by locating it, confirming, posting the delete, removing it from the DbContext, and saving changes.

Create an admin area product controller that injects the shop context, loads all categories, and exposes a list action with update or delete options for admin users.

Implement an admin product list action with an optional category id, route it under the admin area, and return a view with filtered products and categories for navigation.

Create an add new product action that uses the update view, initializes an empty product with a preselected category, binds fields to the model, and populates a categories dropdown.

Create http get and post actions to update a product, include its category, populate a categories dropdown via view bag, and save via add or update in the database.

Create a delete confirmation flow by passing the product ID, locating the product, and posting to delete it from the database, then saving changes and redirecting to the product list.

Create the admin home view in the admin area by copying the shopping area index layout and adding links to manage categories and products via category/index and product/index.

Create an admin category add/update view in asp.net core mvc, with a dynamic title, a form for name and hidden id, and post submit plus cancel navigation.

Create an admin delete confirmation view for categories, showing the category name and two options (delete or cancel) in a post form with a hidden id; confirm deletes the category.

Build the admin products list view in the product controller, displaying all products with update and delete links, a categories submenu including all categories, and an add new product option.

Create a shared add/update product view in the admin area with a post form, validation summary, category dropdown, and bound product fields (code, name, price, id) for updates.

Create an admin product delete view that shows the product name, asks for confirmation, and posts a hidden id to the product controller's delete action, with cancel returning to list.

Modify the main layout to add an admin link and use the view context to detect the current controller and action, so navigation links are active.

Modify the admin layout view in an ASP.NET Core MVC project, configure area routing and active navigation, and manage products and categories across admin and shop areas.

Implement a special deals filter for products under five dollars in an ASP.NET Core 3.1 MVC app, updating the controller, navigation, and replacing view bags with a combined view model.

Create a product list view model that combines categories and products, replacing view bags, with selectedCategory and a checkActiveCategory method to mark active category, and wire it into product controller.

Replace the view bag with a new product list view model, populate categories, products, and selected category in the controller, and pass the full view model to the view.

Implement a view model for product lists and categories in the ASP.NET Core MVC project, replacing view bag usage and enabling active category highlighting across product and admin views.

Implement the admin area’s product list using a view model to carry categories, products, and the selected category, replacing viewbag and exploring if statements and temp data.

Use temp data to show success messages after adding, updating, or deleting a product in the admin area; it persists for the next request and is rendered in the view.

Master a to do list app with category, due date, and status filters; highlight overdue tasks and manage edit, delete, and complete actions via view models and dropdowns.

Create an ASP.NET Core 3.1 MVC web app using the web template, install Bootstrap and NuGet packages, configure routing for lowercase URLs with trailing slash, and begin by creating models.

Create three models for a task management app: category, status, and task, each with id and name fields; remove the unnecessary view model and clean up references.

Create a to-do model with id, description, due date, and foreign keys to category and status, including validation messages and an overdue flag.

Design and implement a filters class that filters tasks by category, due date, and status using a dash-separated string from dropdowns, with read-only properties and a static due-filter dictionary.

Create a connection string in appsettings.json for a local sql server database, set up the db context and db sets with entity framework, and seed the database.

Create and configure a DbContext with options, define DbSets for to do, category, and status, seed initial categories and statuses, and apply migrations to create and update the database.

Inject the context into the home controller, create a view model with filters, statuses, categories, and tasks, and initialize a current task to support adding tasks in the index view.

Implement the index action to display all tasks or filter by category, status, or due date, using a view model, include categories and statuses, and return results to the view.

Master adding tasks in ASP.NET Core 3.1 MVC by implementing a get and post add action, using a view model for categories and statuses, and saving to the database.

Update or delete tasks through a single post action that handles open-to-complete status changes or removal, saves changes to the database, and redirects to the index with preserved filters.

Implement an http post action to receive a string array of category, due date, and status, join them with dashes, and redirect to index with the combined filter.

Configure the main layout for the asp.net core 3.1 mvc project by removing unused navigation and stylesheet, keep bootstrap, and render a container header with a centered h1 'my tasks'.

Create a task entry view in an ASP.NET Core MVC app, binding to a view model with description, category, due date, and status, plus validation and submit actions.

Create a two-part index view with a filters form for categories, due dates, and statuses, highlight overdue tasks, and display a table with change status and delete actions.

Create a new task link and render a tasks table on the index view using ASP.NET Core MVC, displaying description, category, due date, status, with edit and delete actions.

Demonstrate a to-do list in an ASP.NET Core MVC app by creating tasks with category, due date, and status, applying and preserving filters, and marking tasks completed or overdue.

Build an ASP.NET Core MVC app that filters NFL teams by conference and division, shows team details, and uses sessions and cookies to persist favorite teams across reloads and closures.

Create an ASP.NET Core 3.1 MVC project, remove unused models and privacy elements, adjust layout and development settings, enable lowercase URLs, enable sessions and cookies, and begin creating models.

Create models for conference, division, and team with id and name, define team relations to conference and division, include a logo image, and set up the connection string and database.

Install Entity Framework Core packages and Microsoft Identity framework tools, enabling migrations. Create a TeamContext DbContext with DbSet for teams, conferences, and divisions, and seed initial data.

Seed the database by overriding OnModelCreating, using modelBuilder to define conferences, divisions, and teams with foreign keys, and configuring a database context and connection string.

Create and configure a connection string for the NFL database, register the db context in startup, run migrations to generate tables for conferences, divisions, and teams, and seed data.

Create view models for team details and index views in ASP.NET Core MVC, preserving filters like conference and division, with active state handling and an all option.

In the index action, inject the context, load conferences and divisions, filter teams by the active conference and division, populate the teams list view model, and return the view.

Create an index view with left-side filters for conferences and divisions from the model, showing clickable team icons on the right and active highlighting for selections.

Render team logos as clickable images in the index view, posting to the details action with team id and the active conference and division.

Create a details action triggered from the index action to display a single team using the team view model, while preserving active conference and division with temp data and redirects.

Create a details view for teams that displays logo, name, conference, and division, with a back link preserving filters, and explore session-based favorites.

Implement session state in ASP.NET Core by persisting user data on the server with session IDs and cookies, configure idle timeout and cookie options, and enable sessions before routing.

Install and configure Newtonsoft.Json to enable JSON-based session storage in ASP.NET Core MVC, serializing complex objects to strings and deserializing them back for session state.

Add extension methods to the session to serialize objects to json strings and deserialize them back, enabling storing and retrieving typed objects as key-value pairs.

Define private constants for session keys like teams, count, kind, and division, and inject the session. Provide methods to set and get teams and manage conference and division.

Learn to set and get a list of teams in session, using a set object extension to serialize, and a get object method with a count key.

Manage session state by setting and getting active conferences and divisions with string values and keys, then remove teams and counts and set up the cookies.

Persist favorites across browser sessions by implementing an NFL cookies class that encapsulates request and response cookies, storing teams as a hyphen-delimited string with set, get, and remove methods.

Implement a public method to collect team IDs, join them into a hyphen-delimited string, and store them in a 30-day cookie named 'Kinsky' on the response, replacing any previous cookies.

Learn to get and delete the teams cookie in ASP.NET Core MVC app by reading a hyphen-delimited string from request cookies, converting it to an array, and clearing the cookie.

Update the index action to leverage session and cookies by initializing an NFL session, setting the active conference and division, and loading favorite teams (with conferences and divisions) for display.

Update the details action to use session state, persisting the active conference and division across requests. Add a favorites action that stores selections in a persistent session cookie.

Create a post action to add a team to favorites, fetch team with conferences and divisions, update session and cookies, and redirect to index with active conference and division.

Add a favorites controller with an http get index loading active conference, division, and teams from session, plus a post delete action that clears favorites by removing session and cookies.

Modify the home index view to display teams with clickable logos linking to the details action, using session-based active conference and division and showing each team's name, conference, and division.

Enhance the details view by adding a form with a hidden team id to add favorites and return to home, and update the shared layout for temp data messages.

Modify the shared layout to add a favorites link with a live count, display add-to-favorites messages via temp data, and render pages using a unified layout in ASP.NET Core MVC.

Diagnose a session persistence bug in an ASP.NET Core 3.1 MVC app and restore favorites from cookies. Learn to save teams into session so favorites persist after browser closes.

Add a custom route for conferences and divisions using map controller route, ordering routes by specificity and defaulting to home/index, with conference and division segments.

Explore a full ASP.NET Core 3.1 MVC book store demo with login, cart, offers, admin management, and filtering by genre and price.

Create a new ASP.NET Core 3.1 MVC project from the template, then clean up default scaffolding by removing the error view model and privacy page, and establish a folder structure.

Create a folder structure for an asp.net core mvc project, including data layer, domain models, repositories, and dtos. Add extension methods, view models, an admin area, and set up startup.

Configure the project to use lowercase urls, add routing, enable sessions and memory cache, and install Newtonsoft.Json and entity framework core tools for serializing objects in mvc controllers.

Configure routes in an ASP.NET Core MVC app by enabling sessions and authorization in order, setting default and admin routes with slug, and implementing paging, sorting, and filtering for books.

Develop an author model with id, first name, last name, and a computed full name, linking to books via a many-to-many book offers relation, with required and max length validation.

Define a book model with id, title, price, genre id, a genre navigation property, and an offers collection for many-to-many links, with required title and price range 0-1,000,000.

Define a genre model with id and name as required strings, enforce max lengths, and establish a many-to-many relationship to books via a navigation property.

Define the book authors model to enable a many-to-many relationship between books and authors with a composite key and foreign keys, including navigation properties.

Configure a bookstore connection string in app settings, target the local server and bookstore database, enable trusted connections and multiple active result sets, then create the bookstore context.

Define a bookstore context inheriting from DbContext with a constructor that passes options to base. Expose DbSets for books, genres, and book offers, and configure the many-to-many relationship.

Configure on model creating with model builder to define a many-to-many between book and author using composite keys; apply cascade delete restriction on genres; seed data with separate seed classes.

Configure genre entity via IEntityTypeConfiguration, seed genre data with HasData, including novel, memoirs, mystery, science fiction, and history in the bookstore context.

Seed a books dataset in an asp.net core mvc project by implementing identity type configuration for books, using a data builder to seed records with genre foreign keys and prices.

Seed authors using identity type configuration in asp.net core 3.1 mvc, with has data creating author instances by first and last names; full names aren’t stored.

Create seed data for book offers to map books to authors, implement the seed book offers class, and configure EF Core mappings before applying the connection string.

Configure the bookstore database by adding the context and a connection string, then apply an initial migration creating authors, genres, books, and book offers.

Implement extension methods on IQueryable to enable generic paging with skip and take, plus filtering and sorting, in a decoupled data access layer.

Define a generic query options class with lambda expressions for order by, filtering, and paging, enabling reusable where clauses and includes across books, offers, and genres.

Parse a comma-delimited string into an includes array by trimming spaces with replace, splitting it, and exposing the results via a public includes property, including arling expressions work clauses.

Master dynamic query options in ASP.NET Core 3.1 MVC by incrementally adding where clauses and conditionally applying order by and paging, guiding repository-oriented filtering.

Implement a generic repository class that implements IRepository<T>, injects the bookstore context, uses context.Set<T>() for DbSet access, and adds a helper to build query expressions.

Create a private helper method to build dynamic query expressions from query options, adding includes, where clauses, order by (ascending or descending), and paging by page number and page size.

Implement crud methods by making them virtual, deleting and inserting entities via DbContext Remove and Add, updating with Update, and saving changes with SaveChanges to enable overriding in derived classes.

Implement the repository pattern with virtual methods, build queries from options, and add get methods for integer and string ids, laying groundwork before introducing the unit of work pattern.

Coordinate multiple repositories using the repository and unit of work patterns, creating a central class with shared context and a single save method to commit or fail all changes.

Implement the unit of work pattern in a bookstore context by wiring repositories for books, authors, and genres, using a shared context and data validation before returning data.

Implement the unit of work pattern to manage book offers, selecting and creating offers with a lambda, cascading inserts on save, and deleting offers for a given book.

Create a static string extension methods class with slug generation, equals no case, to an integer, and capitalized methods for string handling.

Learn to create session extension methods in ASP.NET Core 3.1 MVC that serialize objects to JSON, store and retrieve them, and use simplified DTO classes to avoid circular references.

Create a book detail DTO to expose id, title, price, and an author dictionary for the view, avoiding circular JSON references, plus a grid detail for paging and sorting.

Create a filter prefix class to prefix the root route dictionary for genre, price, and author, enabling a string dictionary to store and pass route parameters for model binding.

Create a route dictionary class inheriting dictionary<string, string> with paging, sorting, and filtering properties, and methods to set search field and sort direction values.

Set thought and direction toggles sorting by field name, starting ascending for new columns. Clone route dictionary for paging links and configure genre, price, offers filters in a books class.

Create a book grid dto class that extends the generic grid dto to expose page, size, sort, and book-specific filters for offer, genre, and price.

Create a route dictionary class to implement genre, price, and offer filters in ASP.NET Core MVC, using slug parsing, prefixes, and a session-based paging and sorting utility.

Create a grid builder class that stores paging and sorting values in session via a root key and route dictionary, with constructors to load and to save the route data.

Extend the general great builder to create a books great builder that adds methods for loading and clearing filter out segments in the dictionary, including author, genre, and price filters.

Add load and clear filter segment methods to the book grid builder, handling author, genre, and price filters with prefixes and a slugged author name.

Set up a default all filter and flags to detect filtering by author, genre, or price. Extend query options with a sort filter for book sorting by genre or price.

Create a book query options class that inherits generic query options and adds a sort filter for genre, price, and offer, sorting by genre, price, or title, plus cookies extension.

Develop a static cookies extension class to simplify get and set operations for request cookies, including string, integer with try parse to nullable int, and JSON-serialized objects.

Create extension methods to set string, int, and object cookies in ASP.NET Core MVC, with optional expiration via cookie options and JSON serialization.

Create a cart item DTO and model in an ASP.NET Core 3.1 MVC app, store minimal cart data in a persistent cookie, and compute subtotals from book price and quantity.

Extend the cart item with a static extension class and a public static method that returns a list of cart item dtl by mapping book id and quantity.

Create the card model to store card item objects in session and cookies using a card key and count key, and load items from a book repository.

Build a cart model with a double subtotal and a nullable count loaded from session or cookies. Implement get by ID, add, update, remove, clear, and save to cookies.

Edit cart items by updating quantities, verify item presence with get by ID, and save the cart to session and cookies after creating view models.

This lecture demonstrates creating an awfullest view model with three properties: offers, current drought, and total pages, to drive a grid of offers with paging and sorting.

Create a booklist view model with a books collection, price range dictionary, author and genre dropdowns, and a per-page size dropdown to filter and display books.

Create a cart view model with a list of car items, a subtotal, and a root dictionary; add a navigation class to manage the bootstrap active link.

Define a static navigation helper in the view model folder to set the active bootstrap navigation link for layout and admin layout views, with overloads for string and integer values.

Create an index action in the home controller to fetch a random book from the repository and display it in the view, with a placeholder register action.

Create the home index view to display a randomly selected book of the day with a details link. Add a book controller and details action using ASP.NET tag helpers.

Create the list action in the book controller using the bookstore unit of work, build query options with includes, paging, and filtering, and return a view model for books.

Create a list view for the book controller using a view model, enabling paging, sorting, and filtering with current and clone route dictionaries and author, genre, price dropdowns.

Create a details action in the book controller using the bookstore unit of work to fetch a book by id, include author and genre, and return it to the view.

Create a details view for a book in ASP.NET Core MVC showing author, offers, price, and genre in a table with links to offers and author details and add-to-cart form.

Create a filter action in the book controller triggered by the filter button, processing an array of filters, updating session data, and redirecting to the list action.

Create a new http post action in the book controller to set the page size as a filter and redirect back to the list with the chosen size.

Add a page size filter to the book list with a simple dropdown 1-10 posting to the page size action, saving the choice, and updating the displayed books.

Add sortable column headers to the book list, enabling sorting by title, genre, and price with clickable links and an add-to-cart button per book.

Build a dynamic book list in ASP.NET Core 3.1 MVC, displaying each book's title, offers, genre, and price with detail links and an add-to-cart button, plus pagination and filters.

Learn to implement pagination in a list view with page links, active page highlighting, and preserved filters and sorting in the ASP.NET Core MVC project.

Create an author controller, inject the repository and context, and implement a list action that redirects index to list and builds the view with the great builder and session data.

Create a list action for the author controller with query options, including books and genres, and implement paging and ordering by last name or first name.

Create a list view for author controller in asp.net core 3.1 mvc, implementing sorting and filtering with an author model and a table showing first name, last name, and books.

Create a list view for authors in ASP.NET Core MVC with first and last name columns linking to author and book details, plus pagination.

Create a details action in the author controller that uses query options and includes to fetch the author by id with the book, then return the view.

Create a details view for an author in an ASP.NET Core 3.1 MVC app, display the author's full name and their books with links to each book's details page.

Create a cart controller in an ASP.NET Core 3.1 MVC project, wire a book repository with the bookstore context, and load cart contents via a private load method.

Create a new cart in the index action, load items from session, cookies, or database with a builder, and pass a view model with item list and subtotal to view.

Add a post action to the cart controller to add a book to the cart, load its author and genre, create a cart item, and redirect to the book list.

Explain the remove action in the cart controller, including fetching the cart and item by id, saving changes, and redirecting to the cart index with a confirmation.

Clear action removes all items from the cart, saves changes, shows a 'cart was cleared' message, redirects to cart index, and adds an action to edit items in the cart.

Edit cart items through a dedicated view showing the book title, price, and a quantity dropdown; update via get and post actions, then proceed to checkout.

Create the index view for the cart using the card view model, display the subtotal in currency, and provide checkout, clear, and remove items actions.

Create the index view for the cart in an ASP.NET Core 3.1 MVC app, listing items with title, author, price, quantity, subtotal, offers, and edit or remove actions.

Create an edit view for the cart item that posts to the edit action, binds title, price, and quantity, includes hidden id and title fields, and provides save or cancel.

Explore a simulated checkout view in an ASP.NET Core 3.1 MVC project, showing a checkout heading and placeholder items without real transactions. Prepare for admin, authentication, and authorization steps.

Modify the main layout view to add a top navigation card from the session and enable active navigation by area or controller.

Update the main layout to add navigation for home, cart, register, and admin area, and render temp data messages in the main body in an ASP.NET Core 3.1 MVC project.

Navigate the book catalogue, add and manage items in the cart, adjust quantities, view the subtotal, and proceed to checkout while testing session persistence and navigation.

Fix bugs in the cart by updating the index view, convert subtotal to total, and center navigation, while adding Font Awesome icons and ensuring the layout spans across pages.

Create an admin operation model in the admin area to determine field display for add and delete book actions, using a static class with two boolean methods.

Create an admin search class using temp data to store search term and type; include boolean checks and a clear method, plus a view model for term, type, and books.

Create a search view model in the admin area to pass books meeting the criteria to the view, with data annotations enforcing a search term, a type, and a header.

Create a book view model and a book review model, implement class-level validation with a validate method, handle genre and offers dropdowns, and validate selected offers for new books.

Create a validation class in models for admin area. It validates first name on insert against the database, using an operation class to decide when to query genre and author.

Create a validate class method to check a genre by querying the genre repository, validating the genre entity, and returning an error if the genre already exists.

Develop a validate class in the admin area to prevent duplicate offers by checking first and last names before adding to the database, using the add operation and repository data.

Create an admin area validation controller that checks genre and author with repository data, returning json results via a validate class.

Create an admin area book controller in asp.net core 3.1 using the bookstore unit of work and context, with an index action that clears searches and renders the view.

In the admin area, this lecture implements a private load method in the book controller to populate the book view model with genres and offers and support dropdowns for add/edit.

Create a private get book helper in the book controller that builds a book view model via load and returns a view with offers and genres for editing or adding.

Enable an admin area http post search in the book controller by validating the search term, using a search view model, and redirecting to display matching books.

Learn to implement a search workflow in ASP.NET Core MVC: validate post data, build a search view model, and render results via a get action for books, authors, or genres.

Create a crud operation for the book controller by adding a new book via get and post actions, populating the view model, validating input, and saving to the database.

uncover how to implement the admin edit action for a book: load the book data, validate input, replace and re-add offers, update, save, and redirect to search.

Implement the admin delete action for the book controller: display delete view, load the book by id, cascade delete with Entity Framework, and redirect to search with a deletion message.

Create an admin area author controller using the bookstore context and author repository; implement index to provide a dropdown of authors ordered by first name with query options.

Create a select action in the author controller that uses a switch to redirect to edit, delete, or view books based on the dropdown choice.

Describe implementing a private go to offer search method in the author controller to redirect to the book search action, passing author name via temp data.

Create a public admin action to display books by author, redirecting to the book controller's search action with the author offer data.

Add an admin action for the author controller in ASP.NET Core 3.1 MVC to display an offer form and process its post submission with validation, duplicate checks, and database save.

Understand how the admin area handles the author edit: display the current offer in the edit view, post updates, validate, save, and redirect to index with a success message.

Implement a safe delete action in the admin author controller: verify no books are linked, redirect to the book search if linked, otherwise delete and return to index.

Build an admin genre controller in ASP.NET Core MVC wired to the bookstore context and genre repository. Implement index and search actions with a sorted genre list and book results.

Extend the ASP.NET Core 3.1 MVC genre controller with helper actions to search books by genre, store results in temp data, and redirect to book controller's search to view them.

Add a genre via a get view with a text box and a post action that saves the new genre to the database, validating duplicates.

Master the admin edit action for the genre controller by retrieving a genre by id, validating the model, updating and saving changes, and handling deletes.

Demonstrates a get/post delete action for genre controller in ASP.NET Core 3.1 MVC, includes related books to prevent deletion, and redirects to book search results or genre index after deletion.

Create a main admin layout as a partial in the shared folder, reuse the user layout, and set up tag helpers, active bootstrap navigation, and jQuery validation.

Create the admin index view for the book controller in the asp.net core mvc course, featuring a search form, add book link, and title/author/genre options.

Create an admin search results view for books, showing the search term header, a results table with book links to details, and edit and delete actions.

Create an admin book view in ASP.NET Core MVC to handle add, edit, and delete actions for the book controller, using the action name to tailor the form and messages.

Display the admin book view with price input, genre dropdown, and authors multi-select when not deleting, binding to price, genre id, and selected authors, with ctrl/cmd guidance.

Demonstrate the admin book view in the book controller, adding submit and cancel buttons, implementing add/edit/delete redirects, and preserving the book title with a hidden field for delete messages.

Explore the admin area index view for the author controller, displaying offers in a list with a select dropdown to view books, edit, or delete, and add new offers.

Create a single admin offer view to handle add, edit, and delete with a shared form, including hidden id and operation fields and delete confirmation.

Create an admin author view with first name and last name inputs, labels, and validation, bound to the author model; submit, cancel, and navigate back to index after actions.

Create an admin genre index view that lists all genres in a table, with actions to view related books, edit, or delete, and a link to add new genres.

Explain how the admin genre view in the genre controller handles add, edit, and delete actions with a dynamic form, using a textbox for adds and a label for edits.

Learn how the admin genre view handles name input in add, edit, and delete operations, toggling between a text box and a label with validation and submit or cancel actions.

Fix a small view bug in the admin genre form by correcting tag closing and string ID handling, then validate genre, book, and offer CRUD flows.

Install and configure ASP.NET Core Identity with Entity Framework Core to authenticate and authorize users, and extend the user entity from IdentityUser with a not mapped real names property.

Seed identity with a default admin by creating a static async method in the db context that uses the service provider to create admin role and user and assign role.

Add identity to services in configure services, set password options (minimum length, digit requirement), use entity framework stores with the bookstore context, and enable authentication and admin user creation.

Add identity to the database by creating a migration for identity tables and updating the database. Verify admin role and prepare login and logout for admin access and user registration.

Enable authentication in the shared navigation by injecting sign in manager and conditionally showing login, logout, or register links in the layout. Add account controller actions and views.

Create a register view model with username, password, and confirmed password, enforcing required fields, string length 255, password data type, display attribute, and password confirmation via compare.

Add a log-in view model class in the view models folder, including username, password, return URL, and remember me properties, to prepare for creating the account controller.

Create an account controller in the regular area, inject the user manager and sign in manager via the constructor, and implement login and registration actions.

implement a register action in the account controller using async create and sign-in, validating the view model, persisting the user to the database, and handling errors.

Create a logout action as an HTTP post with the sign-in manager. Redirect to the home index, and add access denied and login actions.

Implement a login action in the account controller, get view and post action using password sign-in async, handling remember me, return url, and lockout, then redirect on success.

Create a registration view for the account controller using the register view model, with username, password, and confirm password fields, login link, and validation messages.

Create a login view for the account controller, fix the password field to password type, add username and remember me, and configure login, validation, and register flows.

Develop the admin area to manage users by creating a user view model with users and identity roles, enabling listing, adding, removing, and assigning roles.

Create an admin area user controller in an ASP.NET Core 3.1 MVC project by applying the admin area attribute, injecting user and role managers, and wiring constructor dependencies before actions.

Implement the admin index action to list all users with their roles by asynchronously fetching users and their roles, building a user view model, and returning it to the view.

Create an admin delete action that finds a user by id asynchronously, validates existence, calls delete async on the user, and handles IdentityResult errors before redirecting to the index action.

Add an admin action to the user controller to create new users via a form, validate input, call createAsync, and redirect to index on success while showing errors on failure.

Learn how an admin adds a user to admin role via an async post, verifying or creating the role, locating the user by ID, and assigning the role with redirects.

Implement an http post action to remove a user from the admin role using the user manager, handle errors via model state, and redirect to the index.

Create an admin role through a post action in the user controller, using the role manager to create an identity role, handle errors in model state, and delete admin role.

Implement an admin area delete action to remove a role by id, call the delete async method on the role, handle the results, and redirect to the index.

Manage users in the admin area using the user controller's index view, displaying usernames and roles in a table with actions to delete, add to admin, or remove from admin.

Add and manage roles in the admin index view for the user controller; display a create admin role form when none exist, or list roles with delete actions.

Add a users tab to the main admin layout to manage users via the index action, including role assignment and preparing a view to add new users.

Add a new user view in the admin area for the user controller, reusing the register form fields (username, password, confirm password) and validation. Ensure the admin area requires login.

secure the admin area by restricting access to authorized users with the admin role and require login to view the cart, using authorization attributes across controllers.