Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

ASP.NET Core 2 and Vue.js

By : Ratcliffe

4 (8)

ASP.NET Core 2 and Vue.js

4 (8)

By: Ratcliffe

Overview of this book

This book will walk you through the process of developing an e-commerce application from start to finish, utilizing an ASP.NET Core web API and Vue.js Single-Page Application (SPA) frontend. We will build the application using a featureslice approach, whereby in each chapter we will add the required frontend and backend changes to complete an entire feature. In the early chapters, we’ll keep things fairly simple to get you started, but by the end of the book, you’ll be utilizing some advanced concepts, such as server-side rendering and continuous integration and deployment. You will learn how to set up and configure a modern development environment for building ASP.NET Core web APIs and Vue.js SPA frontends.You will also learn about how ASP.NET Core differs from its predecessors, and how we can utilize those changes to our benefit. Finally, you will learn the fundamentals of building modern frontend applications using Vue.js, as well as some of the more advanced concepts, which can help make you more productive in your own applications in the future.

Preface

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Free Chapter

Understanding the Fundamentals

Understanding the Fundamentals

Thinking in components

Introduction to Vue

Component behavior

Component presentation

ASP.NET Core – what's new?

EF Core – what's new?

Summary

Setting Up the Development Environment

Setting Up the Development Environment

Choosing a web browser

Installing frontend tools and dependencies

Installing backend tools and dependencies

Productivity tools

Summary

Getting Started with the Project

Getting Started with the Project

ASP.NET Core SPA templates versus CLI tools

An introduction to webpack

Scaffolding a project with the dotnet CLI

Refactoring the frontend setup

Refactoring the backend setup

Setting up the database

Testing the completed setup

Summary

Building Our First Vue.js Components

Building Our First Vue.js Components

Displaying a list of products

Conditional rendering

Component composition

Client-side routing

Fetching data from an API

Summary

Building a Product Catalog

Building a Product Catalog

Improving the existing UX

Extending the existing data model

Filtering on the server

Filtering on the client

Client-side sorting

Creating a search bar component

Summary

Building a Shopping Cart

Building a Shopping Cart

Evaluating our options

Finishing the product details page

Introduction to Vuex

Installing and configuring Vuex

Adding products to the cart

Creating a shopping cart page

Creating a currency filter

Removing products from the cart

Updating cart items

Adding a getter to display the cart total

Creating a cart summary component

Persisting the cart to local storage

Improving the UX with add to cart feedback

Summary

User Registration and Authentication

User Registration and Authentication

Adding JWT authentication to the API

Authentication and user registration in the client app

Protecting pages with navigation guards

Setting the authentication state on app startup

Summary

Processing Payments

Processing Payments

Why use Stripe?

Getting started with Stripe and client-side validation

Building the checkout components

Building a my account page

Fixing the register form component

Server-side payment processing

Adding an order list API endpoint

Summary

Building an Admin Panel

Building an Admin Panel

Extending the authentication endpoint with user roles

Client-side role-based authorization

Server-side role-based authorization

Hiding UI elements based on role

Building the admin panel components

Vue component inheritance

Building custom input controls

Persisting new products to the database

Remote validation with Vee-Validate

Tidying things up

Summary

Deployment

Deployment

Registering for an Azure account

Setting up an Azure environment

Preparing the application for deployment

Configuring Git deployments

Finalizing the apps configuration

Summary

Authentication and Refresh Token Flow

Authentication and Refresh Token Flow

Understanding refresh tokens

Adding refresh token support to the backend

Adding refresh token support to the frontend

Refreshing access tokens with axios interceptors

Finishing up

Summary

Server-Side Rendering

Server-Side Rendering

Why use SSR in the first place?

How does SSR work?

The easy way – Nuxt.js

Preparing the application for SSR

Setting up and configuring SSR

Enabling SSR

Conditionally rendering elements that rely on the browser

Testing our server-rendered application

Summary

Continuous Integration and Continuous Deployment

Continuous Integration and Continuous Deployment

CI/CD – why bother?

Disabling Azure app service Git deployments

Getting started with VSTS

Building a CI/CD pipeline

Enabling CD

Summary

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

4 (8)

5 star

50%

4 star

12.5%

3 star

25%

2 star

12.5%

1 star

0

Server-side payment processing

As part of our server-side payment processing, we're going to actually persist the user's orders into the database, and to do that we need to make some changes to our data model. We have a couple of new entities to create, and a few minor tweaks for our existing ones. We'll also be looking at some of the new features introduced in EF Core 2.0 such as owned entity types.

Adding orders to the data model

The first and most obvious new entity we need is the Order entity. Create a new Data/Entities/Order.cs file with the following contents:

namespace ECommerce.Data.Entities
{
  public class Order
  {
    public int Id { get; set; }
    public int UserId { get; set; }
    public DateTime...

Search

Your notes and bookmarks