Beginning .NET Core MVC, Razor, API, Blazor, Azure, Identity

Create an employee model mapped to the employees table, enforce required fields and string length, and configure a database-generated identity for the primary key with display attributes.

Modify the list view to add update, delete, and insert links for each employee, display a temp data message, and use tag helpers to route to the employee manager actions.

Create a delete view for a single employee using a form that shows details, posts a hidden employee ID to the delete action, and includes authentication via core identity.

Create and validate a register action with http get and post actions, initialize an admin role if missing, build and save the register model, then sign in or display errors.

Sign in displays a username and password view, validates model, and signs in with remember me and forgery token. Redirects to employee list on success; shows invalid details on failure.

Create a Razor Pages version of an mvc app in the same solution by reusing models, db context, and identity, updating namespaces, app settings, and startup for Razor pages.

Install and configure entity framework core packages for ASP.NET Core MVC and Razor Pages, resolve context name and namespace issues, and verify the project builds successfully.

create a razor pages list for employees by injecting the db context, querying all employees, and exposing them in a list property with on get and on post handlers.

Create an insert view for adding a new employee with a post form, including fields for first name, last name, title, birth date, hire date, country, notes, and validation messages.

Create a delete page and implement the code-behind to locate, remove, and redirect after deleting an employee using a deep context, with error handling and temp data messaging.

Create a sign-in page with the sign-in manager, binding username and password, then validate input, sign in asynchronously with remember me, and redirect on success or show error on failure.

Configure the API to use a context with SQL Server by wiring the app settings connection string App DB in startup, and map endpoints to controllers for the repository pattern.

Implement the repository interface by creating an employee repository class using sql statements, inject the db context via constructor, and prepare for stored procedure implementations.

Implement an API select all method to return employees by querying the employees table and selecting fields id, first name, last name, title, birthdate, hire date, country, ordered by id.

Implement the delete method by executing a delete statement against the employees table, using a placeholder for the id to remove a single record, without returning data.

Create a restful employee API with controller actions for getting all employees, fetching by id, and creating, updating, and deleting employees, wired via a repository pattern and proper model binding.

During testing, this lecture shows fixing logical api bugs in employees controller and repository, including id handling for put and delete and correcting update with where clause and insert syntax.

Create a managers-only employees controller that injects an HTTP client and configuration to call the employees API, set the base URL from app settings, and prepare country data retrieval.

Fetch employee data with get async, populate an edit view with text boxes and a dropdown, and submit updates via put async to employee API, handling success or error messages.

Test the API client by performing insert, update, and delete operations, validate required fields, sign in and register users, and compare API-driven workflows across three projects.

Create SQL stored procedures for inserting, updating, and deleting employees with parameters for first name, last name, title, birth date, country, notes, and return the new employee id via scope_identity.

Explore optional testing within a .NET Core MVC project by inserting, updating, and deleting employees, debugging serialization and stored procedures, and validating API calls to manage employees.

Create a razor component named list and set it as a page with the main route and employees/list route. Inject navigation manager and the employee repository, and import web utilities.

Remove unused layout code and bootstrap to establish a simple employee manager layout with a Razor Blazor main layout, and render the body for insert, update, and delete links.

Configure ASP.NET core identity by adding identity context, identity user, and identity stores, wiring a sql server connection string, and securing razor pages for sign in, register, and sign out.

Practice testing and debugging a blazer app by configuring authorized views, sign-in flows, cascading authentication state, and sign-out behavior, while verifying create, update, delete, and date formatting.

Learn how to migrate a local ASP.NET MVC project to Azure SQL Database, wrap data access with repositories, and deploy the project and ASP.NET Core Identity to Azure cloud.

Implement the select all method in the employee repository by connecting to the database using a configuration-provided connection string, executing a SQL select, and returning a list of employees.

Implement the insert method to add an employee with id generated by the database, using parameterized values for first name, last name, title, birth date, hire date, country, and notes.

Implement the update method by copying the insert method, updating a single employee’s fields first name, last name, title, birth date, country, notes with parameters and filtering by employee id.

Implement the delete method by wiring a parameterized delete statement that removes an employee by id, opens the connection, executes the command, and closes the connection.

Test and debug the app against the Azure database, validating employee creation, listing, updating, and deletion. Fix note handling and prepare for identity to secure access.

Add and configure .NET Core Identity in an Azure database by creating identity migrations, applying them to the identity context, securing the app with role-based authorization, and deploying to Azure.