go · level 2 check

a tuck shop JSON API.

Time to build a real web service! The school tuck shop wants an API, so apps can see the menu and order snacks. Your `Shop` keeps its stock in a map and counts every snack it sells. Its `Handle` method answers every request with JSON.

`GET /menu` lists each snack and how many are left, A to Z. `POST /orders` reads an order such as `{"snack":"crisps","qty":2}`, takes it out of the stock and answers 201 with a receipt. Bad JSON or a `qty` below 1 gets 400, an unknown snack gets 404 and the wrong method gets 405. A snack that has sold out gets 409, which means conflict.

Each line you type is one pretend request: a method, a path and, for an order, its JSON with no spaces. `main` sends it through `httptest` and prints the status and the reply, then the number of snacks sold. Fill in each `____`, run it, then try your own requests, such as `GET /menu`.

Your program

package main

import "bufio"
import "encoding/json"
import "errors"
import "fmt"
import "net/http"
import "net/http/httptest"
import "os"
import "sort"
import "strings"

var ErrNoSnack = errors.New("no such snack")
var ErrSoldOut = errors.New("sold out")

type Order struct {
	Snack string `json:"snack"`
	Qty   int    `json:"qty"`
}

type Item struct {
	Snack string `json:"snack"`
	Left  int    `json:"left"`
}

type Receipt struct {
	Snack string `json:"snack"`
	Qty   int    `json:"qty"`
	Left  int    `json:"left"`
}

type Shop struct {
	Stock map[string]int
	Sold  int
}

func NewShop() *Shop {
	return &Shop{Stock: map[string]int{"crisps": 5, "apple": 3, "cake": 1}}
}

func (s *Shop) Menu() []Item {
	items := []Item{}
	for name, left := range s.Stock {
		items = append(items, Item{Snack: name, Left: left})
	}
	sort.Slice(items, func(i, j int) bool {
		return items[i].Snack ____ items[j].Snack
	})
	return items
}

func (s ____Shop) Buy(o Order) (Receipt, error) {
	left, ok := s.Stock[o.Snack]
	if !____ {
		return Receipt{}, fmt.Errorf("%s: %w", o.Snack, ErrNoSnack)
	}
	if o.Qty < 1 {
		return Receipt{}, errors.New("qty must be at least 1")
	}
	if o.Qty > left {
		return Receipt{}, fmt.Errorf("%s: ____", o.Snack, ErrSoldOut)
	}
	s.Stock[o.Snack] = left - o.Qty
	s.Sold = ____
	return Receipt{Snack: o.Snack, Qty: o.Qty, Left: left - o.Qty}, nil
}

func start(w http.ResponseWriter, status int) *json.Encoder {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	return json.NewEncoder(w)
}

func fail(w http.ResponseWriter, status int, message string) {
	start(w, status).Encode(map[string]string{"error": message})
}

func (s *Shop) Handle(w http.ResponseWriter, r *http.Request) {
	switch r.URL.Path {
	case "/menu":
		if r.Method != "GET" {
			fail(w, http.StatusMethodNotAllowed, "use GET")
			return
		}
		start(w, http.StatusOK).Encode(s.Menu())
	case "____":
		if r.Method != "POST" {
			fail(w, http.StatusMethodNotAllowed, "use POST")
			return
		}
		var o Order
		if err := json.NewDecoder(r.Body).Decode(____); err != nil {
			fail(w, http.StatusBadRequest, "bad JSON")
			return
		}
		receipt, err := s.Buy(o)
		if errors.Is(err, ErrNoSnack) {
			fail(w, http.StatusNotFound, err.Error())
		} else if errors.Is(err, ____) {
			fail(w, http.StatusConflict, err.Error())
		} else if err != nil {
			fail(w, http.StatusBadRequest, err.Error())
		} else {
			start(w, http.____).Encode(receipt)
		}
	default:
		fail(w, http.StatusNotFound, "no such page")
	}
}

func main() {
	shop := NewShop()
	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		parts := strings.Fields(scanner.Text())
		if len(parts) < 2 {
			continue
		}
		body := ""
		if len(parts) > 2 {
			body = parts[2]
		}
		rec := httptest.NewRecorder()
		shop.Handle(rec, httptest.NewRequest(parts[0], parts[1], strings.NewReader(body)))
		fmt.Print(rec.Code, " ", rec.Body.String())
	}
	fmt.Println("Snacks sold:", shop.Sold)
}

Fill in every ____ then run the checks.

1 It shows the menu from A to Zuses: maps and sorting
2 It takes an order and updates the stockuses: JSON
3 It says sorry when a snack sells outuses: wrapped errors
4 It turns away bad ordersuses: errors as values
5 It answers the wrong method or pageuses: routes and status codes
6 It counts every snack it sellsuses: pointer receivers

Take as long as you like and try as many times as you want.

a tuck shop JSON API.

level up.

playground