mirror of
https://github.com/Dvorinka/Bookra.git
synced 2026-06-03 20:13:00 +00:00
Tomas Dvorak
511 lines
17 KiB
Go
511 lines
17 KiB
Go
package bookings
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"net/mail"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"bookra/apps/backend/internal/db"
|
|
"bookra/apps/backend/internal/domain"
|
|
"bookra/apps/backend/internal/notifications"
|
|
"bookra/apps/backend/internal/shared"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
)
|
|
|
|
var (
|
|
ErrTenantNotFound = errors.New("tenant not found")
|
|
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
|
|
notifier Notifier
|
|
}
|
|
|
|
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) {
|
|
tenant, err := s.repo.GetTenantBySlug(ctx, tenantSlug)
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return domain.PublicAvailability{}, ErrTenantNotFound
|
|
}
|
|
return domain.PublicAvailability{}, err
|
|
}
|
|
|
|
services, err := s.repo.ListServicesByTenant(ctx, tenant.ID)
|
|
if err != nil {
|
|
return domain.PublicAvailability{}, err
|
|
}
|
|
rules, err := s.repo.ListAvailabilityRulesByTenant(ctx, tenant.ID)
|
|
if err != nil {
|
|
return domain.PublicAvailability{}, err
|
|
}
|
|
windowStart := time.Now().UTC()
|
|
windowEnd := windowStart.AddDate(0, 0, 7)
|
|
existingBookings, err := s.repo.ListBookingsByTenantBetween(ctx, tenant.ID, windowStart, windowEnd)
|
|
if err != nil {
|
|
return domain.PublicAvailability{}, err
|
|
}
|
|
classSessions, err := s.repo.ListClassSessionsByTenant(ctx, tenant.ID, windowStart, 8)
|
|
if err != nil {
|
|
return domain.PublicAvailability{}, err
|
|
}
|
|
|
|
slots := make([]domain.TimeSlot, 0, 8)
|
|
slots = append(slots, generateAppointmentSlots(tenant, services, rules, existingBookings)...)
|
|
slots = append(slots, generateClassSlots(classSessions, existingBookings)...)
|
|
sort.Slice(slots, func(i, j int) bool { return slots[i].StartsAt < slots[j].StartsAt })
|
|
if len(slots) > 8 {
|
|
slots = slots[:8]
|
|
}
|
|
|
|
return domain.PublicAvailability{
|
|
TenantSlug: tenant.Slug,
|
|
Timezone: tenant.Timezone,
|
|
Locale: tenant.Locale,
|
|
Slots: slots,
|
|
}, nil
|
|
}
|
|
|
|
func (s *Service) Create(ctx context.Context, request domain.CreateBookingRequest) (domain.CreateBookingResponse, error) {
|
|
tenant, err := s.repo.GetTenantBySlug(ctx, request.TenantSlug)
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return domain.CreateBookingResponse{}, ErrTenantNotFound
|
|
}
|
|
return domain.CreateBookingResponse{}, err
|
|
}
|
|
|
|
startsAt, err := time.Parse(time.RFC3339, request.StartsAt)
|
|
if err != nil {
|
|
return domain.CreateBookingResponse{}, fmt.Errorf("%w: startsAt must be RFC3339", ErrInvalidBooking)
|
|
}
|
|
endsAt, err := time.Parse(time.RFC3339, request.EndsAt)
|
|
if err != nil {
|
|
return domain.CreateBookingResponse{}, fmt.Errorf("%w: endsAt must be RFC3339", ErrInvalidBooking)
|
|
}
|
|
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 {
|
|
return domain.CreateBookingResponse{}, err
|
|
}
|
|
|
|
status := "confirmed"
|
|
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
|
|
}
|
|
if !ok {
|
|
return domain.CreateBookingResponse{}, fmt.Errorf("%w: serviceId is not available for tenant", ErrInvalidBooking)
|
|
}
|
|
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)
|
|
}
|
|
for _, booking := range existing {
|
|
if booking.Status == "cancelled" {
|
|
continue
|
|
}
|
|
if sameResource(booking.StaffID, request.StaffID) || sameResource(booking.LocationID, request.LocationID) {
|
|
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{
|
|
TenantID: tenant.ID,
|
|
ServiceID: request.ServiceID,
|
|
ClassSessionID: request.ClassSessionID,
|
|
StaffID: request.StaffID,
|
|
LocationID: request.LocationID,
|
|
BookingMode: request.BookingMode,
|
|
CustomerName: customerName,
|
|
CustomerEmail: customerEmail,
|
|
StartsAt: startsAt.UTC(),
|
|
EndsAt: endsAt.UTC(),
|
|
Status: status,
|
|
Reference: db.Reference("BK", time.Now()),
|
|
Notes: notes,
|
|
})
|
|
if err != nil {
|
|
return domain.CreateBookingResponse{}, err
|
|
}
|
|
|
|
if status == "waitlisted" && request.ClassSessionID != nil {
|
|
waitlistPosition := int(countClassBookings(existing, *request.ClassSessionID)) + 1
|
|
if err := s.repo.AppendWaitlistEntry(ctx, db.WaitlistEntryParams{
|
|
TenantID: tenant.ID,
|
|
ClassSessionID: *request.ClassSessionID,
|
|
CustomerName: customerName,
|
|
CustomerEmail: customerEmail,
|
|
Position: waitlistPosition,
|
|
}); err != nil {
|
|
return domain.CreateBookingResponse{}, err
|
|
}
|
|
}
|
|
|
|
if scheduledFor, ok := reminderSchedule(startsAt); ok {
|
|
if err := s.repo.CreateReminderJob(ctx, db.ReminderJobParams{
|
|
TenantID: tenant.ID,
|
|
BookingID: created.ID,
|
|
Channel: "email",
|
|
ScheduledFor: scheduledFor,
|
|
}); err != nil {
|
|
return domain.CreateBookingResponse{}, err
|
|
}
|
|
}
|
|
|
|
// 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,
|
|
Status: created.Status,
|
|
}, 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 {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return domain.DashboardSummary{}, ErrTenantMembership
|
|
}
|
|
return domain.DashboardSummary{}, err
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
weekEnd := now.AddDate(0, 0, 7)
|
|
metrics, err := s.repo.GetDashboardMetrics(ctx, membership.Tenant.ID, now, weekEnd)
|
|
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,
|
|
TenantSlug: membership.Tenant.Slug,
|
|
Locale: membership.Tenant.Locale,
|
|
Timezone: membership.Tenant.Timezone,
|
|
PlanCode: shared.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 generateAppointmentSlots(
|
|
tenant db.TenantRecord,
|
|
services []db.ServiceRecord,
|
|
rules []db.AvailabilityRuleRecord,
|
|
existing []db.BookingRecord,
|
|
) []domain.TimeSlot {
|
|
if len(services) == 0 || len(rules) == 0 {
|
|
return nil
|
|
}
|
|
|
|
location, err := time.LoadLocation(tenant.Timezone)
|
|
if err != nil {
|
|
location = time.UTC
|
|
}
|
|
|
|
service := services[0]
|
|
now := time.Now().In(location)
|
|
var slots []domain.TimeSlot
|
|
|
|
for dayOffset := 0; dayOffset < 7 && len(slots) < 6; dayOffset++ {
|
|
day := now.AddDate(0, 0, dayOffset)
|
|
for _, rule := range rules {
|
|
if int(day.Weekday()) != rule.DayOfWeek {
|
|
continue
|
|
}
|
|
|
|
startsLocal, err := time.ParseInLocation("15:04:05", rule.StartsLocal, location)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
endsLocal, err := time.ParseInLocation("15:04:05", rule.EndsLocal, location)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
windowStart := time.Date(day.Year(), day.Month(), day.Day(), startsLocal.Hour(), startsLocal.Minute(), 0, 0, location)
|
|
windowEnd := time.Date(day.Year(), day.Month(), day.Day(), endsLocal.Hour(), endsLocal.Minute(), 0, 0, location)
|
|
|
|
step := time.Duration(service.DurationMinutes+service.BufferAfterMinutes) * time.Minute
|
|
duration := time.Duration(service.DurationMinutes) * time.Minute
|
|
for slotStart := windowStart; slotStart.Add(duration).Before(windowEnd) || slotStart.Add(duration).Equal(windowEnd); slotStart = slotStart.Add(step) {
|
|
if slotStart.Before(now.Add(2 * time.Hour)) {
|
|
continue
|
|
}
|
|
|
|
slotEnd := slotStart.Add(duration)
|
|
if collides(existing, rule.StaffID, nil, slotStart.UTC(), slotEnd.UTC()) {
|
|
continue
|
|
}
|
|
|
|
serviceID := service.ID
|
|
slots = append(slots, domain.TimeSlot{
|
|
ServiceID: &serviceID,
|
|
StaffID: rule.StaffID,
|
|
StartsAt: slotStart.UTC().Format(time.RFC3339),
|
|
EndsAt: slotEnd.UTC().Format(time.RFC3339),
|
|
Mode: "appointment",
|
|
Label: service.Name,
|
|
})
|
|
if len(slots) >= 6 {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return slots
|
|
}
|
|
|
|
func generateClassSlots(classSessions []db.ClassSessionRecord, existing []db.BookingRecord) []domain.TimeSlot {
|
|
slots := make([]domain.TimeSlot, 0, len(classSessions))
|
|
for _, session := range classSessions {
|
|
remaining := session.Capacity - countClassBookings(existing, session.ID)
|
|
if remaining < 0 {
|
|
remaining = 0
|
|
}
|
|
classSessionID := session.ID
|
|
locationID := session.LocationID
|
|
slots = append(slots, domain.TimeSlot{
|
|
ClassSessionID: &classSessionID,
|
|
LocationID: locationID,
|
|
StartsAt: session.StartsAt.UTC().Format(time.RFC3339),
|
|
EndsAt: session.EndsAt.UTC().Format(time.RFC3339),
|
|
Mode: "class",
|
|
Label: session.Title,
|
|
RemainingCapacity: &remaining,
|
|
})
|
|
}
|
|
return slots
|
|
}
|
|
|
|
func collides(bookings []db.BookingRecord, staffID *string, locationID *string, startsAt time.Time, endsAt time.Time) bool {
|
|
for _, booking := range bookings {
|
|
if booking.Status == "cancelled" || booking.Status == "waitlisted" {
|
|
continue
|
|
}
|
|
if !(booking.StartsAt.Before(endsAt) && booking.EndsAt.After(startsAt)) {
|
|
continue
|
|
}
|
|
if sameResource(booking.StaffID, staffID) || sameResource(booking.LocationID, locationID) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func sameResource(left *string, right *string) bool {
|
|
if left == nil || right == nil {
|
|
return false
|
|
}
|
|
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 {
|
|
if booking.ClassSessionID == nil {
|
|
continue
|
|
}
|
|
if *booking.ClassSessionID == classSessionID && booking.Status == "confirmed" {
|
|
total++
|
|
}
|
|
}
|
|
return total
|
|
}
|
|
|
|
func reminderSchedule(startsAt time.Time) (time.Time, bool) {
|
|
now := time.Now().UTC()
|
|
switch {
|
|
case startsAt.After(now.Add(25 * time.Hour)):
|
|
return startsAt.Add(-24 * time.Hour), true
|
|
case startsAt.After(now.Add(3 * time.Hour)):
|
|
return startsAt.Add(-2 * time.Hour), true
|
|
default:
|
|
return time.Time{}, false
|
|
}
|
|
}
|