ASP.NET Core MVC - Up and Running Part 1 (.NET 5)

Create a category model mapped to a database table using Entity Framework Core, with category ID, category name, and display order, and use data annotations for key and identity.

Add a connection string in appsettings.json to create a Rocky database using a default connection, connecting to dot or localdb, with trusted_connection and multiple_active_result_sets enabled.

install and configure entity framework core and sql server, add a data folder, and create db context inheriting from dbcontext with a constructor that passes options to the database context.

Configure the DbContext by adding a DbSet for category, name the table category, configure sql server in startup, and use the default connection string from appsettings.json, setting up migrations.

Add a migration for the category table using entity framework core tools, then run update-database to create or update the database with pending migrations.

Inspect the SQL Server to verify the new database and category table with its three columns, while EF Core's migrations history shows the first migration Add category to database.

Add a category controller in an ASP.NET Core MVC app, update the shared layout navigation to category, and resolve the index view not found error.

Create an index view for the category controller by scaffolding a razor view inside a category folder. Configure the empty template and layout to render the category page.

Retrieve all categories from the database using entity framework and the application DB context via dependency injection, then pass the list to the view for display on the index page.

Display all categories by passing an enumerable category model from the controller to the view, then render a Bootstrap-styled table with category name, display order, and edit/delete actions.

Add a create action in the category controller, build its razor view with tag helpers, and implement a post method to submit the new category name and display order.

Add category part 2 demonstrates creating a category form with name and display order using tag helpers, data annotations, and bootstrap buttons for create and back.

Implement a post action to create a new category in the database using Entity Framework Core, validate anti-forgery token, save changes, and redirect to the index to display all categories.

Practice creating an application type modal with ID and name, push it to the database to create a table, and implement an application type controller with index and create actions.

Work through building and wiring the application type model, database context, migration, and views in an ASP.NET Core MVC project, then test and fix navigation and naming issues.

Learn how to implement validations in ASP.NET Core using data annotations, enforcing required fields and a display order greater than zero, with server-side and client-side validation and view helpers.

Explore implementing both client-side and server-side validations in asp.net core mvc, using model state, display order validation, custom error messages, and validation scripts partial.

Add edit and delete buttons to the category index, pass the category id with asp-route-id to the edit and delete actions, and note the actions are not yet implemented.

Retrieve the category by id in the edit get action, validate the id, and display the prefilled edit form through a shared razor view.

Implement update functionality for categories in the ASP.NET Core MVC app by adding an edit action and a hidden category id to update the correct database record.

Integrate font awesome into an asp.net core mvc project by adding assets, linking the css in _layout, and using icons for create, edit, delete, and back.

Add client-side and server-side validation for the application type name, and implement edit and delete functionality for the application type, following the category example from the course.

Add a product model with foreign key relations to category and application type, including id, name, description, price, and image path, and configure EF Core mappings and migrations.

Add the product model to the database by creating a db set, generating and applying migrations, then updating the database to establish a foreign key to category with an index for efficient queries.

Create a product controller to perform CRUD operations, load category data, and display a product list; implement a single view with an 'absurd' action for insert or update.

Explore the upsert get action for the final create product page in ASP.NET Core MVC, using a nullable id and dropdowns for category and application type.

Create a shared product upsert UI in a Razor view that toggles create and edit with a title and supports image uploads via multipart form data, including name, price, description.

Provide a category dropdown in the product upsert UI by projecting categories to select list items with EF Core and passing them via view bag, enabling category ID validation.

Explore how view bag and view data transfer data from controller to view in ASP.NET Core MVC, with view bag as dynamic properties and view data as a key-value dictionary.

Explore view models in ASP.NET Core MVC to create strongly typed views, replacing view bag and temp data, and combining data sources with validation via data annotations.

Create a product view model with a product property and an enumerable category select list, wire it into the controller, and render a strongly typed view with a working dropdown.

Implement custom validations for image uploads in the upsert method using the sweet alert CDN, and validate the upload box to prompt an alert if no image is provided.

Integrate a summernote rich editor into an ASP.NET Core MVC project, wire the CDN CSS/JS to a text area, and configure height for descriptions.

Master upsert post to create a product by validating the model, saving uploaded images to wwwroot/images/product, wiring web constants and host environment, and persisting the product with save changes.

Display the product image in the edit view by adding an image tag with the web constant path, and style grid image with width 100%, border radius, and a border.

Update a product by retrieving it, replacing the image with a new file and deleting the old one, and then apply a no-tracking approach to resolve EF Core conflicts.

Identify and fix common model state not valid errors by ensuring the view model and dropdowns reload when posting. Also re-enable client-side validation to prevent empty category selections.

Implement delete product flow by removing the server image, deleting the database record, and using eager loading to display the category; covers delete get, delete post, and the delete view.

Complete the assignment by adding a foreign key for application type to the product model, run a migration, push to the database, and implement CRUD for application type across pages.

Walks through adding application type to product, creating migrations, updating the database, and wiring CRUD operations, eager loading, and select lists in the product controller and views.

Apply eager loading with entity framework core to load each product's category and application type in a single query, reducing database calls and boosting efficiency in the index action.

Add a short description property to the product model, create and apply a migration, update views and database, and verify product edits in a running ASP.NET Core MVC app.

Add a Bootstrap nav bar dropdown to the layout and link content management, category, application type, and product, then design the home page to list products with their categories.

Create a home view model with IEnumerable products and categories, populate it in the home controller, and apply eager loading to include category and application type for the home page.

Add a partial view in the shared folder named with an underscore, called from the index view to render a product card for each individual product by passing the model.

Demonstrates building an ASP.NET Core MVC home page demo with category filters, toggling via jQuery based on selected category, and applying category names as classes (spaces replaced with underscores).

Create a details view model with the product and exists in cart flag, then fetch the product by ID in the details action to drive the details page.

Create a product details page in ASP.NET Core MVC by wiring the details action, binding a details view model, and displaying name, price with currency, image, category, and description.

Configure session in your asp.net core mvc project by adding session services and a ten-minute idle timeout, enabling http only and essential cookies, plus extension methods for complex objects.

Explore managing user sessions in an ASP.NET Core MVC app by implementing a shopping cart session with a dedicated model, injecting HttpContextAccessor, and displaying item counts in the layout.

Add items to a shopping cart by posting from the details view, storing product IDs in session, retrieving and updating the cart list, and persisting it with a session key.

Retrieve the session to check if the product ID exists in the cart, set the details view flag, and toggle between add to cart and remove from cart buttons.

Add a remove from cart action that accepts an id, finds the item in the shopping cart, removes it, updates the cart, and returns to the index.

Configure the identity dbcontext, install the ASP.NET Core Identity UI, and scaffold ASP.NET Core identity tables; update startup for authentication and apply a migration to create users and roles.

Scaffold identity pages for login, registration, and forgotten password using a razor class library, configure for razor pages, map endpoints, and integrate with the existing layout and db context.

Extend the identity model by adding a full name to a new application user class, update the db context, and push the new columns to the ASP.NET users table.

Add admin and customer roles and extend registration to capture full name and phone number. Bind new fields to the register model and create an application user with these properties.

Configure role manager and automatically assign the admin role to new users during registration, creating admin and customer roles when needed and wiring identity with roles in startup.

Register the first admin user using the user manager, assigning the web admin role, verify creation in the ASP.Net Users table, and plan to remove the row manager in production.

Implement role-based access in ASP.NET Core MVC by restricting admin creation to admins, assigning customer roles to new registrations, and exposing an admin register link via identity areas.

implement admin vs normal user registration using razor role checks to conditionally render the register title and button, with a warning for admin accounts to improve security.

Design and implement a cart controller to display cart items by retrieving session data and product IDs, then query the database for matching products in an ASP.NET Core MVC app.

Create a cart razor view using a model of enumerable products, display each item's image, name, short description, and price via a loop, with continue shopping and delete actions.

Implement delete cart items in an ASP.NET Core MVC app by passing the product ID, removing the item from the shopping cart, and updating the session.

Learn authorization basics in ASP.NET Core MVC by enforcing login for the shopping cart, using authorize attributes, and building a product user view model with an initialized product list.

Create a post action for index with http post and anti forgery validation, named index post. Redirect to a summary action that shows the logged-in user's name, email, and phone.

Build a Razor view using the product user view model with HTML, CSS, and bootstrap. Display a three-item order summary with name, email, and phone validation.

Fix the disappearing summary by loading and binding the product list in the view model, and enable inquiry submissions that email admin with user and product details using mail jet.

Register for MailJet, verify your email, and activate your account; then select C-sharp as the API language and preview the NuGet packages and sample code.

Configure Mail Jet API in an ASP.NET Core MVC project, implement a custom email sender by overriding send email async, and use the execute method to send HTML messages.

Register and test an email sender service via dependency injection in startup using a transient lifetime to send emails on user registration and password reset.

Learn how to send emails from an ASP.NET Core MVC app using ProtonMail when Gmail or Yahoo issues arise, and set up your own domain email with validated delivery.

Move API keys from hard-coded code to appsettings.json by creating a mail jet settings class and populating it with IConfiguration via dependency injection for secure email configuration.

Explore implementing inquiry submission with email notification in ASP.NET Core MVC, using an inquiry template, product list, and an inquiry confirmation view.

Convert the product list to a list and switch from foreach to a traditional for loop to post hidden product details and display id, name, and price.

Learn to read the inquiry HTML template, populate it with user and product data via dependency injection, and build the HTML body for sending the email.

Demonstrates wiring an email sender via dependency injection in Startup.cs, sending templated inquiries to an admin, testing with a Yahoo account, and troubleshooting parameter mismatches.

Implement role-based authorization to restrict content management of categories, products, and application types to admin users, and hide admin sections in the layout with Razor checks.

Fixes a bug in ASP.NET Core MVC's register admin flow by preventing sign-in of a new admin when an admin is already logged in, using a role check and redirect.