GoLang Tutorial - Web App 4 (Handling non-existent pages and saving pages)

Continued from Web Application Part 3.

In this post, we'll be adding features such as Handling non-existent pages and Saving Pages.

Let's start with the feature for Handling non-existent pages.

What if you visit /view/APageThatDoesntExist?

We see a page containing HTML. This is because it ignores the error return value from loadPage as shown in the code below and continues to try and fill out the template with no data:

func viewHandler(w http.ResponseWriter, r *http.Request) {
	title := r.URL.Path[len("/view/"):]
	p, _ := loadPage(title)
	renderTemplate(w, "view", p)
}

Instead, if the requested Page doesn't exist, it should redirect the client to the edit Page so the content may be created:

func viewHandler(w http.ResponseWriter, r *http.Request) {
    title := r.URL.Path[len("/view/"):]
    p, err := loadPage(title)
    if err != nil {
        http.Redirect(w, r, "/edit/"+title, http.StatusFound)
        return
    }
    renderTemplate(w, "view", p)
}

The http.Redirect function adds an HTTP status code of http.StatusFound (302) and a Location header to the HTTP response.

The function saveHandler will handle the submission of forms located on the edit pages. After uncommenting the related line in main, let's implement the handler:

func saveHandler(w http.ResponseWriter, r *http.Request) {
    title := r.URL.Path[len("/save/"):]
    body := r.FormValue("body")
    p := &Page{Title: title, Body: []byte(body)}
    p.save()
    http.Redirect(w, r, "/view/"+title, http.StatusFound)
}

The page title (provided in the URL) and the form's only field, Body, are stored in a new Page. The save() method is then called to write the data to a file, and the client is redirected to the /view/ page.

The value returned by FormValue is of type string. We must convert that value to []byte before it will fit into the Page struct. We use []byte(body) to perform the conversion.

Let's compile and access the app again with the updated test.txt:

Hello GoLang.
I am using html/template package.
Just added 302 redirect for the non-exist pages.
Also, the "save" should work now.

Click "edit" button, add some text:

and then hit "save":

Ok, we saved the newly added text!

Here is the code so far:

This file is available: wiki-app-4.go

Continues to Web Application Part 5 (Error handling and template caching).

Go Tutorial

1. GoLang Tutorial - HelloWorld
2. Calling code in an external package & go.mod / go.sum files
3. Workspaces
4. Workspaces II
5. Visual Studio Code
6. Data Types and Variables
7. byte and rune
8. Packages
9. Functions
10. Arrays and Slices
11. A function taking and returning a slice
12. Conditionals
13. Loops
14. Maps
15. Range
16. Pointers
17. Closures and Anonymous Functions
18. Structs and receiver methods
19. Value or Pointer Receivers
20. Interfaces
21. Web Application Part 0 (Introduction)
22. Web Application Part 1 (Basic)
23. Web Application Part 2 (Using net/http)
24. Web Application Part 3 (Adding "edit" capability)
25. Web Application Part 4 (Handling non-existent pages and saving pages)
26. Web Application Part 5 (Error handling and template caching)
27. Web Application Part 6 (Validating the title with a regular expression)
28. Web Application Part 7 (Function Literals and Closures)
29. Building Docker image and deploying Go application to a Kubernetes cluster (minikube)
30. Serverless Framework (Serverless Application Model-SAM)
31. Serverless Web API with AWS Lambda
32. Arrays vs Slices with an array left rotation sample
33. Variadic Functions
34. Goroutines
35. Channels ("<-")
36. Channels ("<-") with Select
37. Channels ("<-") with worker pools
38. Defer
39. GoLang Panic and Recover
40. String Formatting
41. JSON
42. SQLite
43. Modules 0: Using External Go Modules from GitHub
44. Modules 1 (Creating a new module)
45. Modules 2 (Adding Dependencies)
46. AWS SDK for Go (S3 listing)
47. Linked List
48. Binary Search Tree (BST) Part 1 (Tree/Node structs with insert and print functions)
49. Go Application Authentication I (BasicAuth, Bearer-Token-Based Authentication)
50. Go Application Authentication II (JWT Authentication)