Learn to build an e-commerce app with .Net Core and Angular

Udemy

Learn the fundamentals of creating an interactive e-commerce application with the help of the development features of Angular and .Net core.

Online

₹ 3099

particular

details

                                    Medium of instructions
                                    English

                                    Mode of learning
                                    Self study

                                    Mode of Delivery
                                    Video and Text Based

Introduction

Introduction
Setting up the developer environment
Setting up VS Code for C# development
Where to get the source code and course assets

API Basics

Introduction
Creating the Web API Project
Running the API using the DotNet CLI
.Net 6 Project changes
Reviewing the Web API startup files
Adding our first API Controller
Adding a C# Entity class
Setting up Entity Framework
Adding a connection string
Adding an Entity Framework migration
Updating the database
Reading the data from the Database in the API
Postman Collections
Creating the additional projects
Saving our project into source control using Git and GitHub
Summary of section 2

API Architecture

Introduction
The Repository Pattern
Adding a Repository and Interface
Adding the repository methods
Extending the products entity and creating related entities
Creating a new migration for the entities
Configuring the migrations
Applying the migrations and creating the Database at app startup
Adding Seed data
Adding the code to get the product brands and types
Eager loading of navigation properties
Summary of section 3

API Generic Repository

Introduction
Creating a Generic repository and interface
Implementing the methods in the Generic repository
Introduction to the specification pattern
Creating a specification class
Creating a specification evaluator
Implementing the repository with specification methods
Using the specification methods in the controller
Using the specification methods in the controller
Using the Debugger to view the spec pattern in action
Shaping the data to return with DTOs
Adding AutoMapper to the API project
Configuring AutoMapper profiles
Adding a Custom Value Resolver for AutoMapper
Serving static content from the API
Summary of section 4

API Error Handling

Introduction
Creating a test controller for errors
Creating a consistent error response from the API
Adding a not found endpoint error handler
Creating Exception handler middleware
Improving the validation error responses
Adding Swagger for documenting our API
Improving the swagger documentation
Cleaning up the Startup class
Summary of section 5

API Paging, Filtering, Sorting & Searching

Introduction
Adding a sorting specification class
Adding a sorting specification part 2
Working around the decimal problem in Sqlite
Adding filtering functionality
Adding Pagination Part 1
Adding Pagination Part 2
Adding Pagination Part 3
Adding the search functionality
Adding CORS Support to the API
Summary of section 6

Client - Angular setup

Introduction
Setting up the developer environment for Angular
Creating the Angular project
Reviewing the Angular project files in the template
Setting up Angular to use HTTPS
Adding bootstrap and font-awesome
Adding VS Code extensions for Angular

Client - Angular Basics

Introduction
Adding a Nav Bar component
Adding the NavBar HTML code
Styling the nav bar
Intro to the Http Client Module
Observables
Intro to Typescript
Typescript Demo
Creating a products interface
Summary of section 8

Client - Building the UI for our shop

Introduction
Organizing our files and folders
Intro to Angular services
Consuming services in the component
Designing the shop page
Adding a child component for the product items
Passing down data to child components
Adding the product filters
Adding the filter functionality
Hooking up the filter to the HTML
Adding the sort functionality
Adding the pagination functionality
Adding the pagination functionality part 2
Adding the pagination functionality part 3
Adding a pagination header
Making the pagination component a shared component
Pagination and Output properties
Adding the search functionality
Resolving the Bug!
Summary of section 9

Client - Routing

Introduction
Creating additional components to route to
Creating the routes
Setting up the nav links
Making the links active
Getting an individual product
Adding the product detail page
Lazy loading angular modules
Summary of section 10

Client - Error handling

Introduction
Creating an error component for testing the error responses
Creating additional error components
Using the Http Interceptor to catch errors
Adding toast notifications
Handling validation errrors
Improving the internal server error component
Summary of section 11

Client - Pazzazz

Introduction
Adding a section header
Adding breadcrumbs
Using the breadcrumb service
Setting the section header title from the breadcrumb service
Styling the product items
Changing the bootstrap theme
Adding loading indicators
Cleaning up loading issues
Adding the home page content
Summary of section 12

API - Basket

Introduction
Setting up Redis
Setting up the basket class
Creating a basket repository interface
Implementing the basket repository
Adding the basket controller
Installing Redis with Docker
Installing Redis on a Mac
Installing Redis on Windows
Testing the basket functionality
Summary of section 13

Client - Basket

Introduction
Creating the basket module
Creating the basket types
Basket service methods
Adding an item to the basket service method
Adding the add item to basket in the component method
Persisting the basket on startup
Displaying the basket item count in the nav bar
Styling the basket page
Adding the basket totals to the service
Creating the order summary component
Adding the increment and decrement functionality
Adding the basket component functions
Hooking up the product detail component to the basket
Adding the checkout module
Summary of section 14

API - Identity

Introduction
Setting up the identity packages
Setting up the identity classes
Adding the IdentityDbContext
Adding a new migration
Seeding identity data
Adding the Startup services for identity
Adding identity to program class
Adding an Account controller
Registering a user
Adding a token generation service
Setting up identity to use the token
Testing the token
Troubleshooting auth issues
Adding additional account methods
Adding user manager extension methods
Adding another Dto for the user
Summary of section 15

API - Validation

Introduction
.Net core error responses
Model validation
Checking for duplicate email addresses
Validating the basket
Updating swagger config for identity
Summary of section 16

Client - Identity

Introduction
Creating the account module
Creating the account service methods
Creating the login form
Angular forms introduction
Using reactive forms in Angular
Submitting data to the server
Updating the nav bar for the logged in user
Persisting the login
Adding a dropdown to the navbar
Form Validation in Angular
Displaying validation errors
Creating a reusable text input
Reusable text input template
Creating a register form
Dealing with modelstate errors
Async validation
Improving the async validator
Creating an auth guard
Using the replay subject
Summary of section 17

API - Orders

Introduction
Creating the order aggregate part 1
Creating the order aggregate part 2
Configuring the order entities
Store context update and seeding delivery methods
Creating the order migration
Creating an order service
Implementing the create order method
Creating the order controller
Debugging the order method
Introducing the Unit of work
Implementing the Unit of work
Updating the generic repository
Refactoring the Order service to use the Unit of work
Using the debugger to view the order creation
Implementing the Order get methods
Order controller get methods
Testing the order controller get methods
Shaping the order data
AutoMapper config for orders
Another AutoMapper value resolver
Summary of section 18

Client - Checkout

Introduction
Checkout page layout
Creating a stepper component
Setting up the stepper component
Creating the checkout components
Adding the checkout form
Creating the address form
Creating the delivery form
Delivery method template
Using the Http interceptor to send the token
Making the basket summary shared
Checkout review component
Adding the forward back buttons for the stepper
Using the form status to mark the step complete
Populating the address form from API
Letting the user save the address
Updating the shipping price
Creating the order interface
Order submission
Problem solution and redirect to success
Checkout success page
Summary of section 19

Client - Order Module

Introduction
Demo of finished solution
Solution to orders exercise
Solution to orders exercise stretch challenge

Taking Payments

Introduction
PCI DSS
Strong Customer Authentication
Setting up stripe
Creating the payment service and interface
Implementing the payment intent
Creating the payment controller
Updating the client basket
Adding the payment intent function
Persisting the shipping price
Implementing stripe elements
Adding stripe elements to the components
Displaying card validation errors
Using the app stepper as an input property
Submitting the payment
Testing card failures
Tying the payment intent to the order
Making the submission a better experience
Loading indicators
Enabling linear mode
Stripe validation
Webhooks
Updating the payments service
Testing our webhooks with the stripe CLI
Summary of section 21

Performance

Introduction
Setting up caching on the API
Creating a cache attribute class
Testing the caching
Caching on the client part 1
Caching on the client part 2
Caching on the client part 3
Pre-publishing adjustments
Summary of section 22

Publishing

Introduction
Angular build configuration
Angular config changes
Building the angular app and running from Kestrel
Angular Ahead of Time compilation build
Installing PostgreSQL
Switching DB Servers
Switching to the production database
Pre deployment work
Deploying app to Linux server part 1
Deploying app to Linux part 2
Getting an HTTPS certificate from Lets encrypt
End of course summary

Bonus - Updating project to .Net 5 and Angular 11

Updating .Net project from .Net Core 3.1 to .Net 5.0
Updating Angular project from Angular v9 to Angular v11

Bonus - Updating project to .Net 6, Angular 12 and Bootstrap 5

Updating .Net project from .Net 5 to .Net 6
.Net 6 Project changes and new features
Updating from Angular 11 to Angular 12
Updating from Bootstrap 4 to Bootstrap 5

Legacy - Publishing to a LAMP server using MySQL (.Net Core 3.1 only)

Installing MySQL - Legacy
Switching DB Servers - Legacy
Switching to the production database - Legacy
Pre deployment work - Legacy
Setting up a linux server part 1 - Legacy
Setting up a linux server part 2 - Legacy
Getting an HTTPS certificate from Lets Encrypt - Legacy

Popular Courses

Popular Platforms

Popular Searches

Learn to build an e-commerce app with .Net Core and Angular

Online

₹ 3099

Quick Facts

Course overview

The highlights

Program offerings

Course and certificate fees

Fees information

certificate availability

certificate providing authority

Who it is for

What you will learn

The syllabus