Generating Images For My Dad’s Meetups With Go

func verifySignature(payload []byte, secret, receivedSignature string) (bool, error) {
	signature, err := computeSignature(payload, secret)
	if err != nil {
		return false, err
	}

	return signature == receivedSignature, nil
}

func computeSignature(payload []byte, secret string) (string, error) {
	h := hmac.New(sha256.New, []byte(secret))

	_, err := h.Write(payload)
	if err != nil {
		return "", err
	}

	return "sha256=" + base64.StdEncoding.EncodeToString(h.Sum(nil)), nil
}

func generateHandler(w http.ResponseWriter, r *http.Request) {
	// 1. Read the request body
	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	defer r.Body.Close()

	// 2. Verify the signature
	ok, err := verifySignature(body, os.Getenv(secretToken), r.Header.Get("Typeform-Signature"))
	if err != nil || !ok {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	// 3. The verification succeeded so we can process the webhook 🙌
	...
}

func generateHandler(w http.ResponseWriter, r *http.Request) {
	// 1. Read the request body
	...
	// 2. Verify the signature
	...

	// 3. Parse the webhook from the request body
	var wh poster.Webhook
	err = json.Unmarshal(body, &wh)
	if err != nil {
		log.WithFields(log.Fields{"error": err}).Error("could not unmarshal webhook")
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	// 4. Convert the webhook data to a Poster
	p := wh.ToPoster()

	// 5. Generate the image
	...

type Poster struct {
	Title  string
	Guest  string
	Date   time.Time
	Time   string
	PicURL string
	Type   string
}

func (w Webhook) ToPoster() Poster {
	poster := Poster{}

	for _, answer := range w.FormResponse.Answers {
		switch answer.Field.Ref {
		case "title":
			poster.Title = answer.Text
		case "guest":
			poster.Guest = answer.Text
		case "date":
			date, _ := time.Parse("2006-01-02", answer.Date)
			poster.Date = date
		case "time":
			poster.Time = answer.Text
		case "type":
			poster.Type = answer.Choice.Label
		case "pic":
			poster.PicURL = answer.PicURL
		}
	}

	return poster
}

func generateHandler(w http.ResponseWriter, r *http.Request) {
	// 1. Read the request body
	...
	// 2. Verify the signature
	...
	// 3. Parse the webhook from the request body
	...
	// 4. Convert the webhook data to a Poster
	...
		
	// 5. Generate the image
	err = p.Render()
	if err != nil {
		log.WithFields(log.Fields{"error": err}).Error("could not generate poster")
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
}

func (p Poster) Render() error {
	ctx := gg.NewContext(width, height)

	err := drawBackground(ctx, "assets/images/background.png")
	if err != nil {
		return err
	}

	err = drawBackground(ctx, "assets/images/logos.png")
	if err != nil {
		return err
	}

	err = drawPicture(ctx, p)
	if err != nil {
		return err
	}

	err = drawText(ctx, p)
	if err != nil {
		return err
	}

	err = ctx.SavePNG("poster.png")
	if err != nil {
		return err
	}

	return nil
}

func drawPicture(ctx *gg.Context, poster Poster) error {
  	// Download the picture to a local file
	filepath, err := poster.Picture()
	if err != nil {
		return err
	}

  	// Load it
	pic, err := gg.LoadImage(filepath)
	if err != nil {
		return err
	}

  	// Resize it
	resizedPic := resize.Thumbnail(
		uint(pic.Bounds().Dx()),
		250,
		pic,
		resize.Lanczos3,
	)

  	// Position and draw it
	contentWidth := ctx.Width()/2 - margin
	ctx.DrawImageAnchored(resizedPic, margin+contentWidth/2, 185, 0.5, 0)

  	// Delete the temporary file
	err = os.Remove(filepath)
	if err != nil {
		return err
	}

	return nil
}

func drawText(ctx *gg.Context, poster Poster) error {
	ctx.SetColor(color.White)

        // Lines with all the info to render
	lines := []Line{
		...
		{
			text:      fmt.Sprintf(`"%s"`, poster.Title),
			marginTop: 290,
			fontSize:  45,
			fontPath:  RobotoBold,
		},
		{
			text:      "amb",
			marginTop: 25,
			fontSize:  25,
			fontPath:  RobotoLight,
		},
		{
			text:      fmt.Sprintf("%s", poster.Guest),
			marginTop: 20,
			fontSize:  45,
			fontPath:  RobotoBold,
		},
		{
			text:      poster.When(),
			marginTop: 35,
			fontSize:  45,
			fontPath:  RobotoLight,
		},
		{
			text:      poster.Where(),
			marginTop: 20,
			fontSize:  45,
			fontPath:  RobotoLight,
		},
		...
	}

	contentWidth := float64(ctx.Width()/2 - margin)
	positionX := margin + contentWidth/2
	positionY := margin

	// Loop through each line adjusting the font and drawing it
	for _, line := range lines {
		err := ctx.LoadFontFace(line.fontPath, line.fontSize)
		if err != nil {
			return err
		}

		err = adjustFontSize(ctx, line, contentWidth)
		if err != nil {
			return err
		}

		positionY = calculatePositionY(ctx, line, positionY)
		ctx.DrawStringAnchored(line.text, positionX, positionY, 0.5, 0)
	}

	return nil
} 

func (p Poster) Render() error {
        // Draw everything
	...

	// Store the poster in a file
	err = ctx.SavePNG("poster.png")
	if err != nil {
		return err
	}

	return nil
}

func download(w http.ResponseWriter, r *http.Request) {
	image, err := os.Open("poster.png")
	if err != nil {
		log.WithFields(log.Fields{"error": err}).Error("could not open image")
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	defer image.Close()

	w.Header().Set("Content-Type", "image/png")
	_, err = io.Copy(w, image)
	if err != nil {
		log.WithFields(log.Fields{"error": err}).Error("could not write image")
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
}

FROM golang:1.14-alpine AS builder
ADD . /poster
WORKDIR /poster
RUN go mod download
RUN CGO_ENABLED=0 go build -ldflags "-s -w" -o poster cmd/poster/*.go

FROM alpine:latest
RUN apk --no-cache add ca-certificates
COPY --from=builder /poster ./
RUN chmod +x poster
CMD ./poster

heroku create

build:
  docker:
    web: Dockerfile

git push heroku master