cleanup

apps/backend/internal/bookings/customer_service.go

@@ -0,0 +1,200 @@
+package bookings
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"bookra/apps/backend/internal/db"
+	"bookra/apps/backend/internal/domain"
+	"bookra/apps/backend/internal/notifications"
+)
+
+var (
+	ErrInvalidReschedule = errors.New("invalid reschedule request")
+	ErrBookingCancelled  = errors.New("booking already cancelled")
+	ErrUnauthorized      = errors.New("unauthorized access")
+)
+
+type CustomerService struct {
+	repo     db.Repository
+	notifier CustomerNotifier
+}
+
+type CustomerNotifier interface {
+	SendBookingReschedule(ctx context.Context, data notifications.BookingEmailData) error
+	SendBookingCancellation(ctx context.Context, data notifications.BookingEmailData) error
+}
+
+func NewCustomerService(repo db.Repository, notifier CustomerNotifier) *CustomerService {
+	if notifier == nil {
+		notifier = &customerNoopNotifier{}
+	}
+	return &CustomerService{repo: repo, notifier: notifier}
+}
+
+type customerNoopNotifier struct{}
+
+func (n *customerNoopNotifier) SendBookingReschedule(ctx context.Context, data notifications.BookingEmailData) error {
+	return nil
+}
+
+func (n *customerNoopNotifier) SendBookingCancellation(ctx context.Context, data notifications.BookingEmailData) error {
+	return nil
+}
+
+// GetBookingByReference returns booking details for customer management link
+func (s *CustomerService) GetBookingByReference(ctx context.Context, reference string, token string) (domain.CustomerBookingView, error) {
+	booking, err := s.repo.GetBookingByReference(ctx, reference)
+	if err != nil {
+		return domain.CustomerBookingView{}, ErrBookingNotFound
+	}
+
+	// Get tenant details for business name
+	tenant, err := s.repo.GetTenantByID(ctx, booking.TenantID)
+	if err != nil {
+		return domain.CustomerBookingView{}, err
+	}
+
+	return domain.CustomerBookingView{
+		Reference:     booking.Reference,
+		CustomerName:  booking.CustomerName,
+		CustomerEmail: booking.CustomerEmail,
+		Service:       "Service", // Would get from service ID in full implementation
+		BusinessName:  tenant.Name,
+		StartsAt:      booking.StartsAt,
+		EndsAt:        booking.EndsAt,
+		Location:      "Location", // Would get from location ID in full implementation
+		Status:        booking.Status,
+	}, nil
+}
+
+// RescheduleBooking allows customers to reschedule their booking
+func (s *CustomerService) RescheduleBooking(ctx context.Context, reference string, req domain.RescheduleBookingRequest, token string) error {
+	booking, err := s.repo.GetBookingByReference(ctx, reference)
+	if err != nil {
+		return ErrBookingNotFound
+	}
+
+	if booking.Status == "cancelled" {
+		return ErrBookingCancelled
+	}
+
+	newStartsAt, err := time.Parse(time.RFC3339, req.NewStartsAt)
+	if err != nil {
+		return ErrInvalidReschedule
+	}
+
+	newEndsAt, err := time.Parse(time.RFC3339, req.NewEndsAt)
+	if err != nil {
+		return ErrInvalidReschedule
+	}
+
+	if !newEndsAt.After(newStartsAt) {
+		return ErrInvalidReschedule
+	}
+
+	if newStartsAt.Before(time.Now().UTC()) {
+		return ErrInvalidReschedule
+	}
+
+	if err := s.repo.RescheduleBooking(ctx, booking.ID, newStartsAt, newEndsAt); err != nil {
+		return err
+	}
+
+	// Send reschedule email (async)
+	go s.sendRescheduleEmail(booking, newStartsAt, newEndsAt)
+
+	return nil
+}
+
+// CancelBooking allows customers to cancel their booking
+func (s *CustomerService) CancelBooking(ctx context.Context, reference string, token string) error {
+	booking, err := s.repo.GetBookingByReference(ctx, reference)
+	if err != nil {
+		return ErrBookingNotFound
+	}
+
+	if booking.Status == "cancelled" {
+		return ErrBookingCancelled
+	}
+
+	if err := s.repo.UpdateBookingStatus(ctx, booking.ID, "cancelled"); err != nil {
+		return err
+	}
+
+	// Send cancellation email (async)
+	go s.sendCancellationEmail(booking)
+
+	return nil
+}
+
+func (s *CustomerService) sendRescheduleEmail(booking db.BookingRecord, newStartsAt, newEndsAt time.Time) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	tenant, err := s.repo.GetTenantByID(ctx, booking.TenantID)
+	if err != nil {
+		return
+	}
+
+	brand, _ := s.repo.GetBrandProfile(ctx, tenant.ID)
+	brandColor := brand.PrimaryColor
+	if brandColor == "" {
+		brandColor = "#a65c3e"
+	}
+
+	managementURL := "https://bookra.eu/manage/" + booking.Reference + "?token=" + booking.Reference
+
+	emailData := notifications.BookingEmailData{
+		TenantName:    tenant.Name,
+		TenantSlug:    tenant.Slug,
+		BrandColor:    brandColor,
+		CustomerName:  booking.CustomerName,
+		CustomerEmail: booking.CustomerEmail,
+		Service:       "Service",
+		Location:      "Location",
+		Reference:     booking.Reference,
+		StartsAt:      newStartsAt,
+		EndsAt:        newEndsAt,
+		Timezone:      tenant.Timezone,
+		Locale:        tenant.Locale,
+		ManagementURL: managementURL,
+	}
+
+	s.notifier.SendBookingReschedule(ctx, emailData)
+}
+
+func (s *CustomerService) sendCancellationEmail(booking db.BookingRecord) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	tenant, err := s.repo.GetTenantByID(ctx, booking.TenantID)
+	if err != nil {
+		return
+	}
+
+	brand, _ := s.repo.GetBrandProfile(ctx, tenant.ID)
+	brandColor := brand.PrimaryColor
+	if brandColor == "" {
+		brandColor = "#a65c3e"
+	}
+
+	emailData := notifications.BookingEmailData{
+		TenantName:    tenant.Name,
+		TenantSlug:    tenant.Slug,
+		BrandColor:    brandColor,
+		CustomerName:  booking.CustomerName,
+		CustomerEmail: booking.CustomerEmail,
+		Service:       "Service",
+		Location:      "Location",
+		Reference:     booking.Reference,
+		StartsAt:      booking.StartsAt,
+		EndsAt:        booking.EndsAt,
+		Timezone:      tenant.Timezone,
+		Locale:        tenant.Locale,
+		ManagementURL: "",
+	}
+
+	s.notifier.SendBookingCancellation(ctx, emailData)
+}

apps/backend/internal/bookings/service.go

@@ -4,11 +4,14 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"net/mail"
 	"sort"
+	"strings"
 	"time"
 
 	"bookra/apps/backend/internal/db"
 	"bookra/apps/backend/internal/domain"
+	"bookra/apps/backend/internal/notifications"
 
 	"github.com/jackc/pgx/v5"
 )
@@ -18,14 +21,34 @@ var (
 	ErrInvalidBooking   = errors.New("invalid booking request")
 	ErrBookingConflict  = errors.New("booking conflict")
 	ErrTenantMembership = errors.New("tenant membership not found")
+	ErrBookingNotFound  = errors.New("booking not found")
 )
 
 type Service struct {
-	repo db.Repository
+	repo     db.Repository
+	notifier Notifier
 }
 
-func NewService(repo db.Repository) *Service {
-	return &Service{repo: repo}
+type Notifier interface {
+	SendBookingConfirmation(ctx context.Context, data notifications.BookingEmailData) error
+	SendBusinessNotification(ctx context.Context, businessEmail string, data notifications.BookingEmailData) error
+}
+
+func NewService(repo db.Repository, notifier Notifier) *Service {
+	if notifier == nil {
+		notifier = &noopNotifier{}
+	}
+	return &Service{repo: repo, notifier: notifier}
+}
+
+type noopNotifier struct{}
+
+func (n *noopNotifier) SendBookingConfirmation(ctx context.Context, data notifications.BookingEmailData) error {
+	return nil
+}
+
+func (n *noopNotifier) SendBusinessNotification(ctx context.Context, businessEmail string, data notifications.BookingEmailData) error {
+	return nil
 }
 
 func (s *Service) Availability(ctx context.Context, tenantSlug string) (domain.PublicAvailability, error) {
@@ -92,6 +115,22 @@ func (s *Service) Create(ctx context.Context, request domain.CreateBookingReques
 	if !endsAt.After(startsAt) {
 		return domain.CreateBookingResponse{}, fmt.Errorf("%w: endsAt must be after startsAt", ErrInvalidBooking)
 	}
+	if startsAt.Before(time.Now().UTC()) {
+		return domain.CreateBookingResponse{}, fmt.Errorf("%w: startsAt must be in the future", ErrInvalidBooking)
+	}
+
+	customerName := strings.TrimSpace(request.CustomerName)
+	customerEmail := strings.TrimSpace(request.CustomerEmail)
+	notes := strings.TrimSpace(request.Notes)
+	if len(customerName) < 2 || len(customerName) > 120 {
+		return domain.CreateBookingResponse{}, fmt.Errorf("%w: customerName must be between 2 and 120 characters", ErrInvalidBooking)
+	}
+	if _, err := mail.ParseAddress(customerEmail); err != nil {
+		return domain.CreateBookingResponse{}, fmt.Errorf("%w: customerEmail must be valid", ErrInvalidBooking)
+	}
+	if len(notes) > 1000 {
+		return domain.CreateBookingResponse{}, fmt.Errorf("%w: notes must be at most 1000 characters", ErrInvalidBooking)
+	}
 
 	existing, err := s.repo.ListBookingsByTenantBetween(ctx, tenant.ID, startsAt, endsAt)
 	if err != nil {
@@ -99,23 +138,22 @@ func (s *Service) Create(ctx context.Context, request domain.CreateBookingReques
 	}
 
 	status := "confirmed"
-	if request.BookingMode == "class" && request.ClassSessionID != nil {
-		classBookings := countClassBookings(existing, *request.ClassSessionID)
-		classSessions, err := s.repo.ListClassSessionsByTenant(ctx, tenant.ID, startsAt.Add(-1*time.Minute), 16)
+	switch request.BookingMode {
+	case "appointment":
+		if request.ServiceID == nil || request.ClassSessionID != nil {
+			return domain.CreateBookingResponse{}, fmt.Errorf("%w: appointment bookings require serviceId only", ErrInvalidBooking)
+		}
+		service, ok, err := s.serviceForRequest(ctx, tenant.ID, *request.ServiceID)
 		if err != nil {
 			return domain.CreateBookingResponse{}, err
 		}
-		sessionCapacity := int32(0)
-		for _, session := range classSessions {
-			if session.ID == *request.ClassSessionID {
-				sessionCapacity = session.Capacity
-				break
-			}
+		if !ok {
+			return domain.CreateBookingResponse{}, fmt.Errorf("%w: serviceId is not available for tenant", ErrInvalidBooking)
 		}
-		if sessionCapacity > 0 && classBookings >= sessionCapacity {
-			status = "waitlisted"
+		expectedDuration := time.Duration(service.DurationMinutes) * time.Minute
+		if !startsAt.Add(expectedDuration).Equal(endsAt) {
+			return domain.CreateBookingResponse{}, fmt.Errorf("%w: appointment duration must match service duration", ErrInvalidBooking)
 		}
-	} else {
 		for _, booking := range existing {
 			if booking.Status == "cancelled" {
 				continue
@@ -124,6 +162,26 @@ func (s *Service) Create(ctx context.Context, request domain.CreateBookingReques
 				return domain.CreateBookingResponse{}, ErrBookingConflict
 			}
 		}
+	case "class":
+		if request.ClassSessionID == nil || request.ServiceID != nil {
+			return domain.CreateBookingResponse{}, fmt.Errorf("%w: class bookings require classSessionId only", ErrInvalidBooking)
+		}
+		session, ok, err := s.classSessionForRequest(ctx, tenant.ID, *request.ClassSessionID, startsAt)
+		if err != nil {
+			return domain.CreateBookingResponse{}, err
+		}
+		if !ok {
+			return domain.CreateBookingResponse{}, fmt.Errorf("%w: classSessionId is not available for tenant", ErrInvalidBooking)
+		}
+		if !sameSecond(session.StartsAt, startsAt) || !sameSecond(session.EndsAt, endsAt) {
+			return domain.CreateBookingResponse{}, fmt.Errorf("%w: class booking time must match class session", ErrInvalidBooking)
+		}
+		classBookings := countClassBookings(existing, *request.ClassSessionID)
+		if session.Capacity > 0 && classBookings >= session.Capacity {
+			status = "waitlisted"
+		}
+	default:
+		return domain.CreateBookingResponse{}, fmt.Errorf("%w: bookingMode must be appointment or class", ErrInvalidBooking)
 	}
 
 	created, err := s.repo.CreateBooking(ctx, db.CreateBookingParams{
@@ -133,13 +191,13 @@ func (s *Service) Create(ctx context.Context, request domain.CreateBookingReques
 		StaffID:        request.StaffID,
 		LocationID:     request.LocationID,
 		BookingMode:    request.BookingMode,
-		CustomerName:   request.CustomerName,
-		CustomerEmail:  request.CustomerEmail,
+		CustomerName:   customerName,
+		CustomerEmail:  customerEmail,
 		StartsAt:       startsAt.UTC(),
 		EndsAt:         endsAt.UTC(),
 		Status:         status,
 		Reference:      db.Reference("BK", time.Now()),
-		Notes:          request.Notes,
+		Notes:          notes,
 	})
 	if err != nil {
 		return domain.CreateBookingResponse{}, err
@@ -150,8 +208,8 @@ func (s *Service) Create(ctx context.Context, request domain.CreateBookingReques
 		if err := s.repo.AppendWaitlistEntry(ctx, db.WaitlistEntryParams{
 			TenantID:       tenant.ID,
 			ClassSessionID: *request.ClassSessionID,
-			CustomerName:   request.CustomerName,
-			CustomerEmail:  request.CustomerEmail,
+			CustomerName:   customerName,
+			CustomerEmail:  customerEmail,
 			Position:       waitlistPosition,
 		}); err != nil {
 			return domain.CreateBookingResponse{}, err
@@ -169,6 +227,9 @@ func (s *Service) Create(ctx context.Context, request domain.CreateBookingReques
 		}
 	}
 
+	// Send confirmation emails (async - don't fail booking if email fails)
+	go s.sendBookingConfirmationEmails(tenant, created, customerName, customerEmail, startsAt, endsAt)
+
 	return domain.CreateBookingResponse{
 		BookingID: created.ID,
 		Reference: created.Reference,
@@ -176,6 +237,65 @@ func (s *Service) Create(ctx context.Context, request domain.CreateBookingReques
 	}, nil
 }
 
+func (s *Service) sendBookingConfirmationEmails(tenant db.TenantRecord, booking db.CreatedBooking, customerName, customerEmail string, startsAt, endsAt time.Time) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	// Get brand profile for business details
+	brand, _ := s.repo.GetBrandProfile(ctx, tenant.ID)
+	brandColor := brand.PrimaryColor
+	if brandColor == "" {
+		brandColor = "#a65c3e" // Default terra color
+	}
+
+	managementURL := fmt.Sprintf("https://bookra.eu/manage/%s?token=%s", booking.Reference, booking.Reference)
+
+	emailData := notifications.BookingEmailData{
+		TenantName:    tenant.Name,
+		TenantSlug:    tenant.Slug,
+		BrandColor:    brandColor,
+		CustomerName:  customerName,
+		CustomerEmail: customerEmail,
+		Service:       "Service",  // Would lookup from booking.ServiceID in full implementation
+		Location:      "Location", // Would lookup from booking.LocationID in full implementation
+		Reference:     booking.Reference,
+		StartsAt:      startsAt,
+		EndsAt:        endsAt,
+		Timezone:      tenant.Timezone,
+		Locale:        tenant.Locale,
+		ManagementURL: managementURL,
+	}
+
+	// Send to customer
+	s.notifier.SendBookingConfirmation(ctx, emailData)
+}
+
+func (s *Service) serviceForRequest(ctx context.Context, tenantID string, serviceID string) (db.ServiceRecord, bool, error) {
+	services, err := s.repo.ListServicesByTenant(ctx, tenantID)
+	if err != nil {
+		return db.ServiceRecord{}, false, err
+	}
+	for _, service := range services {
+		if service.ID == serviceID {
+			return service, true, nil
+		}
+	}
+	return db.ServiceRecord{}, false, nil
+}
+
+func (s *Service) classSessionForRequest(ctx context.Context, tenantID string, classSessionID string, startsAt time.Time) (db.ClassSessionRecord, bool, error) {
+	sessions, err := s.repo.ListClassSessionsByTenant(ctx, tenantID, startsAt.Add(-1*time.Minute), 64)
+	if err != nil {
+		return db.ClassSessionRecord{}, false, err
+	}
+	for _, session := range sessions {
+		if session.ID == classSessionID {
+			return session, true, nil
+		}
+	}
+	return db.ClassSessionRecord{}, false, nil
+}
+
 func (s *Service) DashboardSummary(ctx context.Context, principal domain.Principal) (domain.DashboardSummary, error) {
 	membership, err := s.repo.GetTenantMembershipByUserID(ctx, principal.Subject)
 	if err != nil {
@@ -191,20 +311,72 @@ func (s *Service) DashboardSummary(ctx context.Context, principal domain.Princip
 	if err != nil {
 		return domain.DashboardSummary{}, err
 	}
+	upcomingRecords, err := s.repo.ListBookingsByTenantBetween(ctx, membership.Tenant.ID, now, weekEnd)
+	if err != nil {
+		return domain.DashboardSummary{}, err
+	}
+	upcoming := make([]domain.UpcomingBooking, 0, len(upcomingRecords))
+	for _, booking := range upcomingRecords {
+		upcoming = append(upcoming, domain.UpcomingBooking{
+			Reference:     booking.Reference,
+			CustomerName:  booking.CustomerName,
+			CustomerEmail: booking.CustomerEmail,
+			StartsAt:      booking.StartsAt,
+			EndsAt:        booking.EndsAt,
+			Status:        booking.Status,
+		})
+	}
+	if len(upcoming) > 5 {
+		upcoming = upcoming[:5]
+	}
 
 	return domain.DashboardSummary{
-		TenantName: membership.Tenant.Name,
-		Locale:     membership.Tenant.Locale,
-		Timezone:   membership.Tenant.Timezone,
-		PlanCode:   membership.Tenant.PlanCode,
+		TenantName:       membership.Tenant.Name,
+		TenantSlug:       membership.Tenant.Slug,
+		Locale:           membership.Tenant.Locale,
+		Timezone:         membership.Tenant.Timezone,
+		PlanCode:         normalizePlanCode(membership.Tenant.PlanCode),
+		PublicBookingURL: "/book/" + membership.Tenant.Slug,
+		SetupCompletion:  100,
 		KPIs: []domain.DashboardKPI{
 			{Code: "bookings_this_week", Label: "Bookings this week", Value: fmt.Sprintf("%d", metrics.BookingsCount)},
 			{Code: "cancellations", Label: "Cancellations", Value: fmt.Sprintf("%d", metrics.CancellationsCount)},
 			{Code: "utilization", Label: "Utilization", Value: fmt.Sprintf("%d%%", metrics.UtilizationPercent)},
 		},
+		UpcomingBookings: upcoming,
+		WidgetSnippets:   widgetSnippets(membership.Tenant),
+		Tracking:         trackingStatus(s.repo, ctx, membership.Tenant),
 	}, nil
 }
 
+func widgetSnippets(tenant db.TenantRecord) []domain.WidgetSnippet {
+	path := "/book/" + tenant.Slug
+	return []domain.WidgetSnippet{
+		{Kind: "html", Code: fmt.Sprintf(`<iframe src="%s" title="%s booking" style="width:100%%;min-height:760px;border:0;"></iframe>`, path, tenant.Name)},
+		{Kind: "react", Code: fmt.Sprintf(`export function BookraWidget() { return <iframe src="%s" title="%s booking" style={{ width: "100%%", minHeight: 760, border: 0 }} />; }`, path, tenant.Name)},
+		{Kind: "typescript", Code: fmt.Sprintf(`const bookraWidgetUrl = new URL("%s", window.location.origin);`, path)},
+	}
+}
+
+func trackingStatus(repo db.Repository, ctx context.Context, tenant db.TenantRecord) domain.TrackingStatus {
+	brand, err := repo.GetBrandProfile(ctx, tenant.ID)
+	if err != nil || strings.TrimSpace(brand.UmamiSiteID) == "" {
+		return domain.TrackingStatus{Provider: "umami", Connected: false, Message: "Umami tracking is not connected."}
+	}
+	return domain.TrackingStatus{Provider: "umami", Connected: true, SiteID: brand.UmamiSiteID, Message: "Umami tracking is connected."}
+}
+
+func normalizePlanCode(planCode string) string {
+	switch planCode {
+	case "growth":
+		return "pro"
+	case "multi-location":
+		return "business"
+	default:
+		return planCode
+	}
+}
+
 func generateAppointmentSlots(
 	tenant db.TenantRecord,
 	services []db.ServiceRecord,
@@ -318,6 +490,10 @@ func sameResource(left *string, right *string) bool {
 	return *left == *right
 }
 
+func sameSecond(left time.Time, right time.Time) bool {
+	return left.UTC().Truncate(time.Second).Equal(right.UTC().Truncate(time.Second))
+}
+
 func countClassBookings(bookings []db.BookingRecord, classSessionID string) int32 {
 	var total int32
 	for _, booking := range bookings {

apps/backend/internal/bookings/service_test.go

@@ -2,6 +2,7 @@ package bookings
 
 import (
 	"context"
+	"errors"
 	"testing"
 	"time"
 
@@ -11,7 +12,7 @@ import (
 
 func TestCreateAppointmentRejectsConflict(t *testing.T) {
 	repo := db.NewMemoryRepository()
-	service := NewService(repo)
+	service := NewService(repo, nil)
 
 	availability, err := service.Availability(context.Background(), "studio-atelier")
 	if err != nil {
@@ -68,7 +69,7 @@ func TestCreateAppointmentRejectsConflict(t *testing.T) {
 
 func TestCreateClassFallsBackToWaitlistWhenCapacityReached(t *testing.T) {
 	repo := db.NewMemoryRepository()
-	service := NewService(repo)
+	service := NewService(repo, nil)
 
 	availability, err := service.Availability(context.Background(), "studio-atelier")
 	if err != nil {
@@ -123,9 +124,45 @@ func TestCreateClassFallsBackToWaitlistWhenCapacityReached(t *testing.T) {
 	}
 }
 
+func TestCreateAppointmentRequiresTenantService(t *testing.T) {
+	repo := db.NewMemoryRepository()
+	service := NewService(repo, nil)
+
+	_, err := service.Create(context.Background(), domain.CreateBookingRequest{
+		TenantSlug:    "studio-atelier",
+		BookingMode:   "appointment",
+		CustomerName:  "Missing Service",
+		CustomerEmail: "missing@example.com",
+		StartsAt:      time.Now().UTC().Add(24 * time.Hour).Format(time.RFC3339),
+		EndsAt:        time.Now().UTC().Add(25 * time.Hour).Format(time.RFC3339),
+	})
+	if !errors.Is(err, ErrInvalidBooking) {
+		t.Fatalf("expected ErrInvalidBooking, got %v", err)
+	}
+}
+
+func TestCreateClassRequiresExistingSession(t *testing.T) {
+	repo := db.NewMemoryRepository()
+	service := NewService(repo, nil)
+	missingSessionID := "11111111-1111-1111-1111-111111111111"
+
+	_, err := service.Create(context.Background(), domain.CreateBookingRequest{
+		TenantSlug:     "studio-atelier",
+		BookingMode:    "class",
+		ClassSessionID: &missingSessionID,
+		CustomerName:   "Missing Session",
+		CustomerEmail:  "missing@example.com",
+		StartsAt:       time.Now().UTC().Add(48 * time.Hour).Format(time.RFC3339),
+		EndsAt:         time.Now().UTC().Add(49 * time.Hour).Format(time.RFC3339),
+	})
+	if !errors.Is(err, ErrInvalidBooking) {
+		t.Fatalf("expected ErrInvalidBooking, got %v", err)
+	}
+}
+
 func TestAvailabilityGeneratesUpcomingSlots(t *testing.T) {
 	repo := db.NewMemoryRepository()
-	service := NewService(repo)
+	service := NewService(repo, nil)
 
 	availability, err := service.Availability(context.Background(), "studio-atelier")
 	if err != nil {
@@ -148,7 +185,7 @@ func TestAvailabilityGeneratesUpcomingSlots(t *testing.T) {
 
 func TestCreateSchedulesReminderJobForUpcomingAppointment(t *testing.T) {
 	repo := db.NewMemoryRepository()
-	service := NewService(repo)
+	service := NewService(repo, nil)
 
 	availability, err := service.Availability(context.Background(), "studio-atelier")
 	if err != nil {