There are currently no items in your shopping cart.

User Panel

Forgot your password?.

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

Video Introducing this tutorial

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

API Basics :
Creating the Web API project
Running the API using the DotNet CLI
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 :
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 :
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 :
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 :
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 :
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 :
Adding a Nav Bar component
Adding the NavBar HTML code
Styling the nav bar
Intro to the Http Client Module
Intro to Typescript
Typescript Demo
Creating a products interface
Summary of section 8

Client - Building the UI for our shop :
Organising 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 :
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 :
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 :
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 :
Setting up Redis
Setting up the basket class
Creating a basket repository interface
Implementing the basket repository
Adding the basket controller
Installing Redis on a Mac
Installing Redis on Windows
Testing the basket functionality
Summary of section 13

Client - Basket :
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 :
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 :
.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 :
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 :
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 :
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 :
Demo of finished solution
Solution to orders exercise
Solution to orders exercise stretch challenge

Taking Payments :
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
Updating the payments service
Testing our webhooks with the stripe CLI
Summary of section 21

Performance :
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 :
Angular build configuration
Angular config changes
Building the angular app and running from Kestrel
Angular Ahead of Time compilation build
Installing MySQL
Switching DB Servers
Switching to the production database
Pre deployment work
Setting up a linux server part 1
Setting up a linux server part 2
Getting an HTTPS certificate from Lets Encrypt
End of course summary