A Multi-Tenant Salon Platform, Built From a Static Prototype

Slots are generated as offsets over a combined duration, so a three-service booking behaves as one appointment. Every candidate slot is then checked against staff schedules, holidays, availability overrides, closures and existing bookings — including held slots that have not yet expired.

        // Calculate time offsets. Service 0 starts at minute 0, service 1 at
        // minute (dur0 + buffer), service 2 at (dur0 + dur1 + 2*buffer), etc.
        $totalDuration = 0;
        $offsets = [];
        foreach ($resolvedServices as $i => $rs) {
            $offsets[$i] = $totalDuration;
            $totalDuration += $rs['duration'];
            if ($i < count($resolvedServices) - 1) {
                $totalDuration += $bufferMinutes;
            }
        }

        // Fetch existing bookings for this date (include active holds)
        $existingBookings = Booking::where('booking_date', $date)
            ->whereNotIn('status', ['cancelled', 'no_show'])
            ->where(function ($q) {
                // Exclude expired holds (held_until passed)
                $q->where('status', '!=', 'held')
                  ->orWhere(function ($sq) {
                      $sq->where('status', 'held')
                         ->where('held_until', '>', now());
                  });
            })
            ->whereHas('bookingServices')
            ->with('bookingServices')
            ->get();

Any model using this trait is automatically filtered by the resolved tenant on every query, and new rows receive tenant_id on creation. A parallel creating() hook assigns the tenant — so a developer cannot forget to scope a query.

    public static function bootBelongsToTenant(): void
    {
        static::addGlobalScope("tenant", function (Builder $builder) {
            try {
                $t = tenant();
                if (!$t) {
                    return;
                }
                $table = $builder->getModel()->getTable();
                $builder->where(function ($q) use ($t, $table) {
                    $q->where($table . ".tenant_id", $t->id)
                      ->orWhereNull($table . ".tenant_id");
                });
            } catch (\Throwable) {
                // tenant() not resolved — skip scoping (e.g. in raw tinker)
            }
        });
    }

The API subdomain is deliberately excluded from subdomain resolution — a frontend identifies its salon with an explicit X-Tenant header, which keeps API hosts stable for every tenant.

    public function handle(Request $request, Closure $next)
    {
        $host = $request->getHost();
        $parts = explode(".", $host);

        // Super-admin panel
        if ($subdomain === "admin") {
            return $next($request);
        }

        // API subdomain — tenant may be passed via X-Tenant header instead.
        if ($subdomain === "bookings-api" || str_ends_with($subdomain, "-api")) {
            $slug = $request->header("X-Tenant");
            if ($slug) {
                $tenant = Tenant::where("subdomain", $slug)
                    ->orWhere("slug", $slug)
                    ->first();
                if ($tenant && $tenant->is_active) {
                    app()->instance("current_tenant", $tenant);
                }
            }
            return $next($request);
        }

        $tenant = Tenant::where("subdomain", $subdomain)->first();
        if (!$tenant || !$tenant->is_active) {
            abort(404, "Tenant not found");
        }

        app()->instance("current_tenant", $tenant);
        return $next($request);
    }

The Nuxt app reads its own hostname, maps the apex booking domain to the default salon, and attaches the tenant header to every request through an ofetch wrapper that also injects the Sanctum bearer token.

function tenantSlug(): string | null {
  if (!false) return null;
  const host = window.location.hostname;
  if (
    host === "localhost" ||
    host === "127.0.0.1" ||
    host.startsWith("192.168.") ||
    host.startsWith("10.")
  ) {
    return null;
  }
  const parts = host.split(".");
  // e.g. demo.localhost → tenant "demo" (local multi-tenant testing)
  if (host.endsWith(".localhost")) return parts[0].toLowerCase();
  if (parts.length <= 2) return null;
  const sub = parts[0].toLowerCase();
  if (["www", "admin", "app", "bookings-api"].includes(sub) || sub.endsWith("-api")) return null;
  // Main booking site (apex) — default/main salon tenant.
  if (sub === "bookings") return "amore";
  return sub;
}

Crediting happens when a booking is completed, not when it is created, so abandoned bookings never mint points. Membership tiers multiply earnings, and the same service decrements the ledger when a cancellation is processed.

        $pointsPerPound = $settings?->loyalty_points_per_pound ?? 1;
        $points = (int) floor($booking->total_price * $pointsPerPound);

        // Apply membership multiplier
        $multiplier = $this->getMultiplier($user);
        $points = (int) floor($points * $multiplier);

        if ($points <= 0) {
            return;
        }

        LoyaltyPoint::create([
            "user_id" => $user->id,
            "booking_id" => $booking->id,
            "points_earned" => $points,
            "points_redeemed" => null,
            "type" => "earned",
            "description" => "Booking #{$booking->id} — {$booking->booking_date->format(
                "d/m/Y",
            )}",
        ]);

        $user->increment("points_balance", $points);
    }

Refunds depend on how many hours remain before the appointment, the salon's cancellation window, deposit rules and what was actually paid. After the refund is recorded, the booking is cancelled, loyalty reversed and the cancellation automation fired.

        $cancellationHours = $settings?->cancellation_hours ?? 24;
        $depositPercentage = $settings?->deposit_percentage ?? 50;
        $requireDeposit = $settings?->require_deposit ?? false;

        $hoursUntilBooking = Carbon::now()->diffInHours($booking->booking_date, false);

        // Determine refund amount
        $totalPaid = Payment::where('booking_id', $booking->id)
            ->whereIn('type', ['full', 'deposit'])
            ->where('status', 'completed')
            ->sum('amount');

        $refundAmount = $this->calculateRefund(
            $booking,
            $totalPaid,
            $hoursUntilBooking,
            $cancellationHours,
            $depositPercentage,
            $requireDeposit
        );

One admin action pulls the official England and Wales bank-holiday feed and inserts future dates as full-day closures — idempotently, skipping anything already on the calendar.

        $events = $data["england-and-wales"]["events"] ?? [];

        $imported = 0;
        $skipped = 0;

        foreach ($events as $event) {
            $eventYear = (int) substr($event["date"], 0, 4);

            if ($eventYear !== $year) continue;

            if ($event["date"] < date("Y-m-d")) {
                $skipped++;
                continue;
            }

            $exists = \App\Models\ShopClosure::where("location_id", $locationId)
                ->whereDate("closure_date", $event["date"])
                ->exists();

            if ($exists) {
                $skipped++;
                continue;
            }

            \App\Models\ShopClosure::create([
                "location_id" => $locationId,
                "closure_date" => $event["date"],
                "reason" => $event["title"],
                "source" => "gov_uk_import",
            ]);

            $imported++;
        }