interfaces

domain/batizado/batizado.go

@@ -0,0 +1,42 @@
+package batizado
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/eminetto/curso-go/domain"
+)
+
+type Batizado struct {
+	TotalCarne           int `json:"total-carne"`
+	TotalPessoas         int `json:"total-pessoas"`
+	TotalAcompanhamentos int `json:"total-acompanhamentos"`
+	NaoAlcoolicas        int `json:"nao-alcoolicas"`
+}
+
+func (b Batizado) ToJSON() ([]byte, error) {
+	return json.Marshal(b)
+}
+
+type Service struct{}
+
+func NewBatizado() Service {
+	return Service{}
+}
+
+/* Calcula calcula os itens para o bbatizado
+A primeira letra maiuscula no nome da função indica que ela é pública
+*/
+func (s Service) Calcula(p domain.Parametros) (domain.Resultado, error) {
+	b := Batizado{}
+	if p.Mulheres <= 0 || p.Homens <= 0 || p.Criancas <= 0 {
+		return b, fmt.Errorf("Festa fantasma?")
+	}
+
+	b.TotalCarne = p.Mulheres*150 + p.Homens*200 + p.Criancas*100
+	b.TotalPessoas = p.Mulheres + p.Homens + p.Criancas
+	b.TotalAcompanhamentos = b.TotalPessoas * 50
+	b.NaoAlcoolicas = 400 * b.TotalPessoas
+
+	return b, nil
+}

domain/churrasco.go → domain/churrasco/churrasco.go

@@ -1,14 +1,11 @@
-package domain
+package churrasco
 
-import "errors"
+import (
+	"encoding/json"
+	"errors"
 
-//Parametros parametros da função CalculaChurrasco
-type Parametros struct {
-	Homens          int  `json:"homens"`
-	Mulheres        int  `json:"mulheres"`
-	Criancas        int  `json:"criancas"`
-	Acompanhamentos bool `json:"acompanhamentos"`
-}
+	"github.com/eminetto/curso-go/domain"
+)
 
 //Churrasco churrasco calculado
 type Churrasco struct {
@@ -19,8 +16,20 @@ type Churrasco struct {
 	Alcoolicas           int `json:"alcoolicas"`
 }
 
-//CalculaChurrasco faz o cálculo do churrasco
-func CalculaChurrasco(p Parametros) (Churrasco, error) {
+func (c Churrasco) ToJSON() ([]byte, error) {
+	return json.Marshal(c)
+}
+
+//Service define um serviço de churrasco
+type Service struct{}
+
+//NewChurrasco cria um novo churrasco
+func NewChurrasco() Service {
+	return Service{}
+}
+
+//Calcula faz o cálculo do churrasco
+func (s Service) Calcula(p domain.Parametros) (domain.Resultado, error) {
 	churras := Churrasco{}
 	if p.Homens == 0 || p.Mulheres == 0 {
 		// return churras, fmt.Errorf("Homens e mulheres devem ser maiores que zero")

domain/churrasco_test.go → domain/churrasco/churrasco_test.go

@@ -1,13 +1,15 @@
-package domain
+package churrasco
 
 import (
 	"testing"
 
+	"github.com/eminetto/curso-go/domain"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestCalculaChurrascoFantasma(t *testing.T) {
-	_, err := CalculaChurrasco(Parametros{
+	s := NewChurrasco()
+	_, err := s.Calcula(domain.Parametros{
 		Homens:          0,
 		Mulheres:        1,
 		Criancas:        2,
@@ -20,7 +22,8 @@ func TestCalculaChurrascoFantasma(t *testing.T) {
 }
 
 func TestCalculaChurrascoBombando(t *testing.T) {
-	ch, err := CalculaChurrasco(Parametros{
+	s := NewChurrasco()
+	ch, err := s.Calcula(domain.Parametros{
 		Homens:          3,
 		Mulheres:        3,
 		Criancas:        6,

domain/festa.go

@@ -0,0 +1,19 @@
+package domain
+
+//Parametros parametros da função CalculaChurrasco
+type Parametros struct {
+	Homens          int  `json:"homens"`
+	Mulheres        int  `json:"mulheres"`
+	Criancas        int  `json:"criancas"`
+	Acompanhamentos bool `json:"acompanhamentos"`
+}
+
+//Festa define o que é uma festa
+type Festa interface {
+	Calcula(Parametros) (Resultado, error)
+}
+
+//Resultado define o que é um resultado
+type Resultado interface {
+	ToJSON() ([]byte, error)
+}

main.go

@@ -5,35 +5,46 @@ import (
 	"net/http"
 
 	"github.com/eminetto/curso-go/domain"
+	"github.com/eminetto/curso-go/domain/batizado"
+	"github.com/eminetto/curso-go/domain/churrasco"
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
 )
 
 func main() {
 	r := chi.NewRouter()
 	r.Use(middleware.Logger)
-	r.Post("/", calculaChurrasco)
+	r.Post("/churrasco", calculaFesta(churrasco.NewChurrasco()))
+	r.Post("/batizado", calculaFesta(batizado.NewBatizado()))
 	http.ListenAndServe(":3000", r)
 }
 
-func calculaChurrasco(w http.ResponseWriter, r *http.Request) {
-	var param domain.Parametros
-	err := json.NewDecoder(r.Body).Decode(&param)
-	if err != nil {
-		w.WriteHeader(http.StatusBadRequest)
-		w.Write([]byte(err.Error()))
-		return
-	}
-	ch, err := domain.CalculaChurrasco(param)
-	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-		w.Write([]byte(err.Error()))
-		return
-	}
-	err = json.NewEncoder(w).Encode(ch)
-	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-		w.Write([]byte(err.Error()))
-		return
+func calculaFesta(s domain.Festa) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var param domain.Parametros
+		err := json.NewDecoder(r.Body).Decode(&param)
+		if err != nil {
+			w.WriteHeader(http.StatusBadRequest)
+			w.Write([]byte(err.Error()))
+			return
+		}
+		ch, err := s.Calcula(param)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
+		j, err := ch.ToJSON()
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
+		_, err = w.Write(j)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
 	}
 }