Creating a Shopping Cart in a Go Web Application

Introduction
Prerequisites
Setup and Software
Step 1: Creating the Web Application
Step 2: Creating the Product Catalog
Step 3: Implementing the Shopping Cart
Step 4: Updating the Web Interface
Step 5: Adding Checkout and Order Summary
Conclusion

Introduction

In this tutorial, we will learn how to create a shopping cart feature in a Go web application. By the end of this tutorial, you will be able to build a web application that allows users to browse products, add them to a cart, and place an order.

Prerequisites

Before starting this tutorial, you should have a basic understanding of Go programming language. Familiarity with HTML, CSS, and web development concepts will be beneficial but not mandatory.

Setup and Software

To follow along with this tutorial, make sure you have Go installed on your system. You can download and install Go from the official Go website at https://golang.org/.

Additionally, you will need a text editor or Integrated Development Environment (IDE) to write and run Go code. Some popular options include Visual Studio Code, GoLand, and Atom.

Step 1: Creating the Web Application

Open your preferred text editor or IDE.
Create a new directory for your project and navigate to it using the command line.

Initialize a new Go module by running the following command:

```
go mod init github.com/your-username/shopping-cart
```

Create a new file named main.go and open it for editing.

Import the necessary packages:

```go
package main
   
import (
    "fmt"
    "log"
    "net/http"
)
```

Define a handler function to handle the root route:

```go
func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to the Shopping Cart!")
}
```

Define a main function to set up the web server:

```go
func main() {
    http.HandleFunc("/", homeHandler)
   
    log.Println("Starting server on http://localhost:8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}
```

Save the file and exit the text editor or IDE.
Run the web application by executing the following command in the terminal:
```
```
go run main.go
```
```
Open your web browser and visit http://localhost:8080 to see the “Welcome to the Shopping Cart!” message.

Congratulations! You have created a basic Go web application. Let’s proceed to the next step to implement the shopping cart functionality.

Step 2: Creating the Product Catalog

Create a new file named product.go and open it for editing.

Define a Product struct to represent a product:

```go
package main
   
type Product struct {
    ID    string
    Name  string
    Price float64
}
```

Create a slice of Product to store the catalog:

```go
var catalog = []Product{
    {ID: "1", Name: "Product 1", Price: 9.99},
    {ID: "2", Name: "Product 2", Price: 19.99},
    {ID: "3", Name: "Product 3", Price: 29.99},
}
```

Implement a function to retrieve the catalog:

```go
func getProducts() []Product {
    return catalog
}
```

Save the file and exit the text editor or IDE.

Now we have a product catalog ready to be used in our shopping cart.

Step 3: Implementing the Shopping Cart

Create a new file named cart.go and open it for editing.

Define a Cart struct to represent a shopping cart:

```go
package main
   
type Cart struct {
    Items []Product
}
```

Implement methods to add and remove items from the cart:

```go
func (c *Cart) addItem(item Product) {
    c.Items = append(c.Items, item)
}
   
func (c *Cart) removeItem(itemID string) {
    for i, item := range c.Items {
        if item.ID == itemID {
            c.Items = append(c.Items[:i], c.Items[i+1:]...)
            break
        }
    }
}
```

Save the file and exit the text editor or IDE.

The shopping cart functionality is now available. In the next step, we will update the web interface to interact with the shopping cart.

Step 4: Updating the Web Interface

Open the main.go file for editing.

Import the html/template package:

```go
import (
    "html/template"
)
```

Define a CartPage struct to represent the data needed for the cart page:

```go
type CartPage struct {
    Products []Product
    Cart     Cart
}
```

Implement a handler function to render the cart page:

```go
func cartHandler(w http.ResponseWriter, r *http.Request) {
    data := CartPage{
        Products: getProducts(),
        Cart:     Cart{
            Items: []Product{},
        },
    }
   
    tmpl := template.Must(template.ParseFiles("cart.html"))
    tmpl.Execute(w, data)
}
```

Define a cart.html template file to display the cart page:

```html
<!DOCTYPE html>
<html>
<head>
    <title>Shopping Cart</title>
</head>
<body>
    <h1>Shopping Cart</h1>
   
    <ul>
        {{ range .Products }}
        <li>
            {{ .Name }} - ${{ .Price }}
            <form action="/add-to-cart/{{ .ID }}" method="POST">
                <input type="submit" value="Add to Cart">
            </form>
        </li>
        {{ end }}
    </ul>
   
    <h2>Cart</h2>
    <ul>
        {{ range .Cart.Items }}
        <li>{{ .Name }} - ${{ .Price }}</li>
        {{ end }}
    </ul>
</body>
</html>
```

Update the main function to include the cart route:

```go
func main() {
    http.HandleFunc("/", homeHandler)
    http.HandleFunc("/cart", cartHandler)
   
    log.Println("Starting server on http://localhost:8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}
```

Save the file and exit the text editor or IDE.

Now you can visit http://localhost:8080/cart to see the cart page with the product catalog and an empty cart. However, the “Add to Cart” functionality is not yet implemented. Let’s proceed to the next step to add it.

Step 5: Adding Checkout and Order Summary

Open the main.go file for editing.

Implement a handler function to add products to the cart:

```go
func addToCartHandler(w http.ResponseWriter, r *http.Request) {
    itemID := r.URL.Path[len("/add-to-cart/"):]
   
    for _, product := range getProducts() {
        if product.ID == itemID {
            data.Cart.addItem(product)
            break
        }
    }
   
    http.Redirect(w, r, "/cart", http.StatusFound)
}
```

Update the main function to include the add-to-cart route:

```go
func main() {
    http.HandleFunc("/", homeHandler)
    http.HandleFunc("/cart", cartHandler)
    http.HandleFunc("/add-to-cart/", addToCartHandler)
   
    log.Println("Starting server on http://localhost:8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}
```

Save the file and exit the text editor or IDE.

Now you can visit http://localhost:8080/cart and add products to the cart. The added items will be displayed on the cart page. You have successfully implemented the shopping cart functionality in your Go web application!

Conclusion

In this tutorial, we have learned how to create a shopping cart feature in a Go web application. We started by setting up a basic web application, then implemented the product catalog, shopping cart, and the web interface to interact with the cart. Finally, we added the functionality to add products to the cart.

You can further enhance this application by implementing the checkout process, storing cart data in a database, and adding more advanced features like user authentication and order management.

Feel free to explore and experiment with the code provided. Happy coding!

Note: Make sure to properly structure and organize your code in a larger project.

Published: 11 May 2023