Building Web Applications with Go - Intermediate Level

Course Summary

Who Is This Course For

Developers who want to integrate Stripe into their applications
Developers who want to learn how to build a back end API in Go
Developers who want to learn best practices for building modern applications in Go (and JavaScript)

Requirements

A basic understanding of the Go programming language
A basic understanding of HTML, CSS, and JavaScript
A basic understanding of SQL syntax

What You Will Learn

How to build a front end website using Go
How to build multiple applications from a single code base
User authentication in Go
How to allow users to reset a password in a safe, secure manner
Make one time or recurring payments with Stripe

How to build a back end API using Go
How to build microservices in Go
API authentication using stateful tokens
How to integrate Stripe credit card processing with a Go back end
Best practices for making secure credit card transactions

Description

This course is the followup to Building Modern Web Applications in Go. In this course, we go further than we did the first time around. We will build a sample E-Commerce application that consists of multiple, separate applications: a front end (which services content to the end user as web pages); a back end API (which is called by the front end as necessary), and a microservice that performs only one task, but performs it extremely well (dynamically building PDF invoices and sending them to customers as an email attachment).

The application will sell individual items, as well as allow users to purchase a monthly subscription. All credit card transactions will be processed through Stripe, which is arguably one of the most popular payment processing systems available today, and for good reason: developers love it. Stripe offers a rich API (application programming interface), and it is available in more than 35 countries around the world, and works with more than 135 currencies. Literally millions of organizations and businesses use Stripe’s software and APIs to accept payments, send payouts, and manage their businesses online with the Stripe dashboard. However, in many cases, developers want to be able to build a more customized solution, and not require end users to log in to both a web application and the Stripe dashboard. That is precisely the kind of thing that we will be covering in this course.

We will start with a simple Virtual Terminal, which can be used to process so-called "card not present" transactions. This will be a fully functional web application, built from the ground up on Go (sometimes referred to as Golang). The front end will be rendered using Go's rich html/template package, and authenticated users will be able to process credit card payments from a secure form, integrated with the Stripe API. In this section of the course, we will cover the following:

How to build a secure, production ready web application in Go
How to capture the necessary information for a secure online credit card transaction
How to call the Stripe API from a Go back end to create a paymentIntent (Stripe's object for authorizing and making a transaction)

Once we have that out of the way, we'll build a second web application in the next section of the course, consisting of a simple web site that allows users to purchase a product, or purchase a monthly subscription. Again, this will be a web application built from the ground up in Go. In this section of the course, we'll cover the following:

How to allow users to purchase a single product
How to allow users to purchase a recurring monthly subscription (a Stripe Plan)
How to handle cancellations and refunds How to save all transaction information to a database (for refunds, reporting, etc).
How to refund a transaction How to cancel a subscription
How to secure access to the front end (via session authentication) How to secure access to the back end API (using stateful tokens)
How to manage users (add/edit/delete) How to allow users to reset their passwords safely and securely
How to log a user out and cancel their account instantly, over websockets

Once this is complete, we'll start work on the microservice. A microservice is a particular approach to software development that has the basic premise of building very small applications that do one thing, but do it very well. A microservice does not care in the slightest about what application calls it; it is completely separate, and completely agnostic. We'll build a microserivce that does the following:

Accepts a JSON payload describing an individual purchase
Produces a PDF invoice with information from the JSON payload
Creates an email to the customer, and attaches the PDF to it
Sends the email

All of these components (front end, back end, and microservice) will be built using a single code base that produces multiple binaries, using Gnu Make.

Course Pricing

Enroll in course

$24.99 CAD

Buy Now

Course Curriculum

Introduction
3 Lessons
- Introduction
  Preview
- Mistakes. We all make them.
  Start
- How to ask for help
  Start
Setting Up Our Environment
6 Lessons
- Installing Go
  Start
- Installing an IDE
  Start
- Get a free Stripe account
  Start
- Installing make
  Start
- Installing MariaDB
  Start
- Getting a database client
  Start
Building a virtual credit card terminal
16 Lessons
- What we're going to build
  Preview
- Setting up a (trivial) web application
  Preview
- Setting up routes and building a render function
  Start
- Displaying one page
  Start
- A better extension for Go templates and VS Code
  Start
- Creating the form
  Start
- Connecting our form to stripe.js
  Start
- Client side validation
  Start
- Getting the paymentIntent - setting up the back end package
  Start
- Getting the paymentIntent - starting work on the back end api
  Start
- Getting the paymentIntent - setting up a route and handler, and using make
  Start
- Getting the paymentIntent - finishing up our handler
  Start
- Updating the front end JavaScript to call our paymentIntent handler
  Start
- Getting the payment intent, and completing the transction
  Preview
- Generating a receipt
  Start
- Cleaning up the API url and Stripe Publishable Key on our form
  Start
Selling a product online
28 Lessons
- What are we going to build?
  Start
- Create the database
  Start
- Connecting to the database
  Start
- Creating a product page
  Start
- Creating the product form
  Start
- Moving JavaScript to a reusable file
  Start
- Modifying a handler to take a struct
  Start
- Update the Widget page to use data passed to the template
  Start
- Creating a formatCurrency template function
  Start
- Testing the transaction functionality
  Start
- Creating a database table for items for sale
  Start
- Running database migrations
  Start
- Creating database models
  Start
- Working on database functions
  Start
- Inserting a new transaction
  Start
- Inserting a new order
  Start
- An aside: fixing a problem with calculating the amount
  Start
- Getting more information about a transaction
  Start
- Customers
  Start
- Getting started saving customer and transaction information
  Start
- Create the save customer database method
  Start
- Saving the customer, transaction, and order from the handler
  Start
- Running a test transaction
  Start
- Fixing a database error, and saving more details
  Start
- Redirecting after post
  Start
- Simplifying our PaymentSucceeded handler
  Start
- Revising our Virtual Terminal
  Start
- Fixing a mistake in the formatCurrency template function
  Start
Setting up and charging a recurring payment using Stripe Plans
12 Lessons
- What are we going to build in this section?
  Start
- Creating a Plan on the Stripe Dashboard
  Start
- Creating stubs for the front end page and handler
  Start
- Setting up the form
  Start
- Working on the JavaScript for plans
  Start
- Continuing with the Javascript for subscribing to a plan
  Start
- Create a handler for the POST request after a user is subscribed
  Start
- Create methods to create a Stripe customer and subscribe to a plan
  Start
- Updating our handler to complete a subscription
  Start
- Saving transaction & customer information to the database
  Start
- Saving transaction & customer information II
  Start
- Displaying a receipt page for the Bronze Plan
  Start
Authentication
27 Lessons
- Introduction
  Start
- Creating a login page
  Start
- Writing the stub javascript to authenticate against the back end
  Start
- Create a route and handler for authentication
  Start
- Create a writeJSON helper function
  Start
- Starting the authentication process
  Preview
- Creating an invalidCredentials helper function
  Start
- Creating a passwordMatches helper function
  Start
- Making sure that everything works
  Start
- Create a function to generate a token
  Start
- Generating and sending back a token
  Start
- Saving the token to the database
  Start
- Saving the token to local storage
  Start
- Changing the login link based on authentication status
  Start
- Checking authentication on the back end
  Start
- A bit of housekeeping
  Start
- Creating stub functions to validate a token
  Start
- Extracting the token from the authorization header
  Start
- Validating the token on the back end
  Start
- Testing out our token validation
  Start
- Challenge: Checking for expiry
  Start
- Solution to challenge
  Start
- Implementing middleware to protect specfic routes
  Start
- Trying out a protected route
  Start
- Converting the Virtual Terminal post to use the back end
  Start
- Changing the virtual terminal page to use fetch
  Start
- Verifying the saved transaction
  Start
Protecting routes on the Front End and improving authentication
4 Lessons
- Writing middleware on the front end to check authentication
  Start
- Protecting routes on the front end
  Start
- Logging out from the front end
  Start
- Saving sessions in the database
  Start
Mail and Password Resets
13 Lessons
- Password resets
  Start
- Sending mail Part I
  Start
- Mailtrap.io
  Start
- Sending mail Part II
  Start
- Creating our mail templates and sending a test email
  Start
- Implementing signed links for our email message
  Start
- Using our urlsigner package
  Start
- Creating the reset password route and handler
  Start
- Setting up the reset password page
  Start
- Creating a back end route to handle password resets
  Start
- Setting an expiry for password reset emails
  Start
- Adding an encryption package
  Start
- Using our encryption package to lock down password resets
  Start
Building Admin pages to manage purchases
14 Lessons
- Improving our front end and setting up an Admin menu
  Start
- Setting up stub pages for sales and subscriptions
  Start
- Updating migrations and resetting the database
  Start
- Listing all sales: database query
  Start
- Listing all sales: database function
  Preview
- Listing all sales: writing the API handler and route
  Start
- Listing all sales: front end javascript
  Start
- Displaying our results in a table
  Start
- Making our table prettier, and adding some checks in JavaScript
  Start
- Challenge
  Start
- Solution to challenge
  Start
- Displaying a sale: part 1
  Start
- Displaying a sale: part 2
  Start
- Displaying a subscription
  Start
Refunds
7 Lessons
- Refunds from the Stripe Dashboard
  Start
- Adding a refund function to our cards package
  Start
- Creating an API handler to process refunds
  Start
- Update the front end for refunds
  Start
- Improving the front end
  Start
- Adding UI components to the sales page
  Start
- Updating status to refunded in the database
  Start
Canceling Subscriptions
5 Lessons
- Capturing the subscription id
  Start
- Adding a CancelSubscription function to our cards package
  Start
- Creating a handler to cancel a subscription
  Start
- Modifying the front end
  Start
- Finishing up the front end
  Start
Paginating Data
7 Lessons
- Creating a database method to paginate all orders
  Start
- Modifying the AllSales handler to use paginated data
  Start
- Updating the all-sales.page.gohtml template
  Start
- Improving pagination on the front end
  Start
- Adding listeners to page navigation buttons
  Start
- Taking user to correct page of data on click
  Start
- How I implemented pagination on the all subscriptions page
  Start
Managing Users
17 Lessons
- Setting up templates to manage users
  Start
- Adding routes and handlers on the front end
  Start
- Writing the database functions to manage user
  Start
- Creating a handler and route for all users on the back end
  Start
- Updating the front end to call AllUsers
  Start
- Displaying the list of users
  Start
- Creating a user add or edit form
  Start
- Call the api back end to get one user
  Start
- Populating the user form, and a challenge
  Start
- Solution to challenge
  Start
- Saving an edited user - part one
  Start
- Saving an edited user - part two
  Start
- Deleting a user
  Start
- Removing the deleted users token from the database
  Start
- Setting up websockets
  Start
- Connecting to WebSockets from the browser
  Start
- Logging the deleted user out over websockets
  Start
Microservices
9 Lessons
- What are microservices?
  Start
- Setting up a simple microservice
  Start
- Receiving data with our microservice
  Start
- Generating an invoice as a PDF
  Start
- Testing our PDF
  Start
- Mailing the invoice
  Start
- Call the microservice when a Widget is sold
  Start
- Challenge
  Start
- Solution
  Start
Validation
3 Lessons
- Setting up a validation package
  Start
- Adding validation on the API back end
  Start
- Modifying the front end javascript
  Start
Where to go next
1 Lesson
- gRPC, SOA, and more
  Start

Trevor Sawler

Trevor has more than twenty years of experience in professional software development, and over 30 years of experience as a university professor. As an entrepreneur, he has worked with a broad range of clients, including Thomson Nelson, Hewlett Packard, the Royal Bank of Canada, Keybank, Sprint, and many, many others. He also has extensive management and project management experience. He has led teams of fifty developers and artists on multi-million dollar projects, and much smaller teams on much smaller projects. Trevor continues to work projects for a variety of clients every day. As a professor, he has taught in a wide variety of course areas, including Computer Science, English, Irish, and American literature, and a number of "crossover" courses that bridge the liberal arts and technological fields. He has won regional, national, and international awards for his work in the IT field, and has also won awards for his teaching and research as a University professor.