팩토리, 레포지토리, 서비스

package chapter4

import (
	"errors"
	"fmt"
	"log"
)

type Car interface {
	BeepBeep()
}

type BMW struct {
	heatedSeatSubscriptionEnabled bool
}

func (B BMW) BeepBeep() {
	// TODO: implement me
	panic("implement me")
}

type Tesla struct {
	autopilotEnabled bool
}

func (T Tesla) BeepBeep() {
	// TODO: implement me
	panic("implement me")
}

func BuildCar(carType string) (Car, error) {
	switch carType {
	case "bmw":
		return BMW{heatedSeatSubscriptionEnabled: true}, nil
	case "tesla":
		return Tesla{autopilotEnabled: true}, nil
	default:
		return nil, errors.New("unknown car type")
	}
}

func main() {
	myCar, err := BuildCar("tesla")
	if err != nil {
		log.Fatal(err)
	}
	// TODO: do something with myCar
	fmt.Printf("%v is my car\n", myCar)
}

package chapter4

import (
"errors"
"github.com/google/uuid"
"time"
)

type Booking struct {
id uuid.UUID
userId uuid.UUID
from time.Time
to time.Time
hairDresserId uuid.UUID
}

func CreateBooking(from time.Time, to time.Time, userId uuid.UUID, hairDresserId uuid.UUID) (*Booking, error) {
closingTime, _ := time.Parse(time.Kitchen, "17:00pm")

    if from.After(closingTime) {
    	return nil, errors.New("no appointments after closing time")
    } else {
    	return &Booking{
    		hairDresserId: hairDresserId,
    		id:            uuid.New(),
    		userId:        userId,
    		from:          from,
    		to:            to,
    	}, nil
    }

}

package chapter4

import (
	"context"
	"fmt"
	"github.com/jackc/pgx/v4"
)

type BookingRepository interface {
	SaveBooking(ctx context.Context, booking Booking) error
	DeleteBooking(ctx context.Context, booking Booking) error
}

type PostgresRepository struct {
	connPool *pgx.Conn
}

func NewPostgresRepository(ctx context.Context, dbConnString string) (*PostgresRepository, error) {
	conn, err := pgx.Connect(ctx, dbConnString)
	if err != nil {
		return nil, fmt.Errorf("failed to connect to database: %w", err)
	}
	defer conn.Close(ctx)
	return &PostgresRepository{connPool: conn}, nil
}

func (p PostgresRepository) SaveBooking(ctx context.Context, booking Booking) error {
	_, err := p.connPool.Exec(
		ctx,
		"INSERT INTO bookings (id, from, to, hair_dresser_id) VALUES ($1, $2, $3, $4)",
		booking.id.String(),
		booking.from.String(),
		booking.to.String(),
		booking.hairDresserId.String(),
	)

	if err != nil {
		return fmt.Errorf("failed to save booking: %w", err)
	}
	return nil
}

func (p PostgresRepository) DeleteBooking(ctx context.Context, booking Booking) error {
	_, err := p.connPool.Exec(
		ctx,
		"DELETE FROM bookings WHERE id = $1",
		booking.id,
	)

	if err != nil {
		return fmt.Errorf("failed to delete booking: %w", err)
	}
	return nil
}

package chapter4

import "github.com/google/uuid"

type Product struct {
	Id             uuid.UUID
	InStock        bool
	InSomeonesCart bool
}

func (p Product) CanBeBought() bool {
	return p.InStock && !p.InSomeonesCart
}

type ShoppingCart struct {
	Id          uuid.UUID
	Products    []Product
	IsFull      bool
	MaxCartSize int
}

func (s *ShoppingCart) AddToCard(p Product) bool {
	if s.IsFull {
		return false
	}
	if p.CanBeBought() {
		s.Products = append(s.Products, p)
		return true
	}
	if s.MaxCartSize == len(s.Products) {
		s.IsFull = true
	}
	return true
}

package chapter4

import "errors"

type CheckOutService struct {
	shoppingCart *ShoppingCart
}

func NewCheckOutService(shoppingCart *ShoppingCart) *CheckOutService {
	return &CheckOutService{shoppingCart: shoppingCart}
}

func (c *CheckOutService) AddProductToCart(p *Product) error {
	if c.shoppingCart.IsFull {
		return errors.New("cannot add product to full cart")
	}
	if p.CanBeBought() {
		c.shoppingCart.Products = append(c.shoppingCart.Products, *p)
		return nil
	}
	if c.shoppingCart.MaxCartSize == len(c.shoppingCart.Products) {
		c.shoppingCart.IsFull = true
	}

	return nil
}

package chapter4

import (
	"context"
	"errors"
	"fmt"
	"github.com/jhseoeo/Golang-DDD/chapter2"
)

type accountKey = int

const accountCtxKey = accountKey(1)

type BookingDomainService interface {
	CreateBooking(ctx context.Context, booking Booking) error
}

type BookingAppService struct {
	bookingRepo          BookingRepository
	bookingDomainService BookingDomainService
}

func NewBookingAppService(bookingRepo BookingRepository, bookingDomainService BookingDomainService) *BookingAppService {
	return &BookingAppService{
		bookingRepo:          bookingRepo,
		bookingDomainService: bookingDomainService,
	}
}

func (b *BookingAppService) CreateBooking(ctx context.Context, booking Booking) error {
	u, ok := ctx.Value(accountCtxKey).(*chapter2.Customer)
	if !ok {
		return errors.New("invalid customer")
	}
	if u.UserID() != booking.userId.String() {
		return errors.New("cannot create booking for other users")
	}

	err := b.bookingDomainService.CreateBooking(ctx, booking)
	if err != nil {
		return fmt.Errorf("could not create booking: %w", err)
	}
	err = b.bookingRepo.SaveBooking(ctx, booking)
	if err != nil {
		return fmt.Errorf("could not save bookign: %w", err)
	}

	return nil
}

package chapter4

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"net/http"
)

type EmailSender interface {
	SendEmail(ctx context.Context, to string, title string, body string) error
}

const emailUrl = "https://maindrillapp.com/api/1.0/messages/send""

type MailChimp struct {
	apiKey     string
	from       string
	httpClient http.Client
}

type MailChimpReqBody struct {
	Key     string `json:"key"`
	Message struct {
		FromEmail string `json:"from_email"`
		Subject   string `json:"subject"`
		Text      string `json:"text"`
		To        []struct {
			Email string `json:"email"`
			Type  string `json:"type"`
		} `json:"to"`
	} `json:"message"`
}

func NewMailChimp(apiKey string, from string, httpClient http.Client) *MailChimp {
	return &MailChimp{
		apiKey:     apiKey,
		from:       from,
		httpClient: httpClient,
	}
}
func (m MailChimp) SendEmail(ctx context.Context, to string, title string, body string) error {
	mailBody := MailChimpReqBody{
		Key: m.apiKey,
		Message: struct {
			FromEmail string `json:"from_email"`
			Subject   string `json:"subject"`
			Text      string `json:"text"`
			To        []struct {
				Email string `json:"email"`
				Type  string `json:"type"`
			} `json:"to"`
		}{
			FromEmail: m.from,
			Subject:   title,
			Text:      body,
			To: []struct {
				Email string `json:"email"`
				Type  string `json:"type"`
			}{{Email: to, Type: "to"}},
		},
	}

	payload, err := json.Marshal(mailBody)
	if err != nil {
		return fmt.Errorf("failed to marshall body: %w", err)
	}
	req, err := http.NewRequest(http.MethodPost, emailUrl, bytes.NewReader(payload))
	if err != nil {
		return fmt.Errorf("failed to create request: %w", err)
	}
	_, err = m.httpClient.Do(req)
	if err != nil {
		return fmt.Errorf("failed to send email: %w", err)
	}
	return nil
}

type BookingAppService struct {
	bookingRepo          BookingRepository
	bookingDomainService BookingDomainService
	emailService         EmailSender
}

...


func (b *BookingAppService) CreateBooking(ctx context.Context, booking Booking) error {
	u, ok := ctx.Value(accountCtxKey).(*chapter2.Customer)
	if !ok {
		return errors.New("invalid customer")
	}
	if u.UserID() != booking.userId.String() {
		return errors.New("cannot create booking for other users")
	}

	err := b.bookingDomainService.CreateBooking(ctx, booking)
	if err != nil {
		return fmt.Errorf("could not create booking: %w", err)
	}
	err = b.bookingRepo.SaveBooking(ctx, booking)
	if err != nil {
		return fmt.Errorf("could not save bookign: %w", err)
	}
	err = b.emailService.SendEmail(ctx, ...)
	if err != nil {
		...
	}

	return nil
}