main.go

package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"strings"

	"github.com/digitalocean-apps/sample-with-database/pkg/model"
	"github.com/digitalocean-apps/sample-with-database/pkg/storer"
	"github.com/gofrs/uuid"
	"github.com/gorilla/mux"
	"github.com/pkg/errors"

	_ "github.com/jinzhu/gorm/dialects/postgres"
)

const (
	defaultPort        = "8080"
	defaultDatabaseURL = "postgresql://postgres:postgres@127.0.0.1:5432/notes/?sslmode=disable"

	startupMessage = `                                                                                
                                                   �                            
                                                                                
                                                                                
                                               ��������                         
                                              �������          �                
  ��        �� ��   ���  ��                  �������          � ����            
  �          ����       ����          ����          �         �  ���            
  �      �    ��    ���               ����                     �����            
                     �         �����������            �           ���������     
                                            �����   ����        ����������      
                                              �      �������                    
             � �  �                                 �����������       �         
                  �  �        ��  ��  �         � ����������������   ��         
                           ��� �     �� �           �����������������           
`
)

func main() {
	// Parse connection config.
	databaseURL := os.Getenv("DATABASE_URL")
	if databaseURL == "" {
		databaseURL = defaultDatabaseURL
	}
	caCert := os.Getenv("CA_CERT")

	db, err := storer.NewStorer(databaseURL, caCert)
	requireNoError(err, "connecting to database")
	defer db.Close()

	// Initialize the listening port.
	port := os.Getenv("PORT")
	if port == "" {
		port = defaultPort
	}

	// Initialize and start the HTTP server.
	r := mux.NewRouter()
	r.HandleFunc("/", notesHandler(db)).Methods("GET", "POST")
	r.HandleFunc("/{note_id}", noteHandler(db)).Methods("GET")

	bindAddr := fmt.Sprintf(":%s", port)
	lines := strings.Split(startupMessage, "\n")
	fmt.Println()
	for _, line := range lines {
		fmt.Println(line)
	}
	fmt.Println()
	fmt.Printf("==> Server listening at %s 🚀\n", bindAddr)

	err = http.ListenAndServe(fmt.Sprintf(":%s", port), r)
	requireNoError(err, "starting server")
}

func notesHandler(db storer.Storer) func(w http.ResponseWriter, r *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		if r.Method == http.MethodPost {
			var body string

			if r.Body != nil {
				buf := new(strings.Builder)
				_, err := io.Copy(buf, r.Body)
				if !requireNoErrorInHandler(w, err, "reading request body") {
					return
				}
				body = buf.String()
			}

			if body == "" {
				w.WriteHeader(http.StatusUnprocessableEntity)
				fmt.Fprintf(w, "invalid empty note")
				return
			}

			noteUUID, err := uuid.NewV4()
			if !requireNoErrorInHandler(w, err, "creating note uuid") {
				return
			}

			err = db.Create(&model.Note{
				UUID: noteUUID.String(),
				Body: body,
			})
			if !requireNoErrorInHandler(w, err, "creating note in db") {
				return
			}

			log.Printf("POST %s %s\n", noteUUID.String(), body)

			w.WriteHeader(http.StatusOK)
			fmt.Fprintf(w, noteUUID.String())
			return
		}

		w.WriteHeader(http.StatusOK)
		fmt.Fprintf(w, "POST a note")
	}
}

func noteHandler(db storer.Storer) func(w http.ResponseWriter, r *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		vars := mux.Vars(r)
		noteID := vars["note_id"]

		if noteID == "" {
			w.WriteHeader(http.StatusUnprocessableEntity)
			fmt.Fprintf(w, "note_id required")
			return
		}

		note, err := db.Get(noteID)
		if errors.Is(err, storer.ErrNotFound) {
			w.WriteHeader(http.StatusNotFound)
			return
		}
		if !requireNoErrorInHandler(w, err, "getting note from db") {
			return
		}

		w.WriteHeader(http.StatusOK)
		fmt.Fprintf(w, note.Body)
	}
}

func requireNoErrorInHandler(w http.ResponseWriter, err error, msg string) bool {
	if err != nil {
		log.Printf(errors.Wrap(err, msg).Error())
		w.WriteHeader(http.StatusInternalServerError)
		return false
	}
	return true
}

func requireNoError(err error, msg string) {
	if err != nil {
		panic(errors.Wrap(err, msg))
	}
}