Florida Vacation Rental Management with PHP & Laravel Solutions

// app/Http/Controllers/BookingController.php - Multi-platform booking management
<?php

namespace App\Http\Controllers;

use App\Models\Property;
use App\Models\Booking;
use App\Services\AirbnbService;
use App\Services\VrboService;
use App\Services\CleaningService;
use App\Jobs\SendGuestWelcomeEmail;
use App\Jobs\ScheduleCleaningJob;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Carbon\Carbon;

class BookingController extends Controller
{
    protected $airbnbService;
    protected $vrboService;
    protected $cleaningService;

    public function __construct(
        AirbnbService $airbnbService,
        VrboService $vrboService,
        CleaningService $cleaningService
    ) {
        $this->airbnbService = $airbnbService;
        $this->vrboService = $vrboService;
        $this->cleaningService = $cleaningService;
    }

    /**
     * Handle incoming booking webhook from platforms
     */
    public function handleBookingWebhook(Request $request, $platform)
    {
        $this->validate($request, [
            'booking_id' => 'required|string',
            'property_id' => 'required|string',
            'check_in' => 'required|date',
            'check_out' => 'required|date',
            'guest_count' => 'required|integer',
            'total_amount' => 'required|numeric'
        ]);

        DB::beginTransaction();
        
        try {
            // Find property in our system
            $property = Property::where('external_id', $request->property_id)
                ->where('platform', $platform)
                ->firstOrFail();

            // Create booking record
            $booking = Booking::create([
                'property_id' => $property->id,
                'external_booking_id' => $request->booking_id,
                'platform' => $platform,
                'check_in' => Carbon::parse($request->check_in),
                'check_out' => Carbon::parse($request->check_out),
                'guest_count' => $request->guest_count,
                'total_amount' => $request->total_amount,
                'status' => 'confirmed',
                'guest_data' => $request->guest ?? [],
                'created_at' => now()
            ]);

            // Block calendar on other platforms
            $this->syncCalendarAcrossPlatforms($property, $booking);

            // Schedule automated tasks
            $this->scheduleBookingTasks($booking);

            // Update property pricing if needed
            $this->updateDynamicPricing($property);

            DB::commit();

            return response()->json([
                'success' => true,
                'booking_id' => $booking->id,
                'message' => 'Booking processed successfully'
            ]);

        } catch (\Exception $e) {
            DB::rollback();
            
            \Log::error('Booking webhook failed: ' . $e->getMessage(), [
                'platform' => $platform,
                'booking_data' => $request->all()
            ]);

            return response()->json([
                'success' => false,
                'error' => 'Failed to process booking'
            ], 500);
        }
    }

    /**
     * Sync calendar across all platforms to prevent double booking
     */
    protected function syncCalendarAcrossPlatforms(Property $property, Booking $booking)
    {
        $platforms = $property->activePlatforms();
        
        foreach ($platforms as $platformConfig) {
            if ($platformConfig['name'] === $booking->platform) {
                continue; // Skip the platform where booking originated
            }

            switch ($platformConfig['name']) {
                case 'airbnb':
                    $this->airbnbService->blockDates(
                        $platformConfig['external_id'],
                        $booking->check_in,
                        $booking->check_out
                    );
                    break;
                    
                case 'vrbo':
                    $this->vrboService->updateAvailability(
                        $platformConfig['external_id'],
                        $booking->check_in,
                        $booking->check_out,
                        false // available = false
                    );
                    break;
            }
        }
    }

    /**
     * Schedule automated tasks for booking lifecycle
     */
    protected function scheduleBookingTasks(Booking $booking)
    {
        // Send welcome email immediately
        SendGuestWelcomeEmail::dispatch($booking)
            ->delay(now()->addMinutes(5));

        // Send check-in instructions 24 hours before arrival
        SendCheckInInstructions::dispatch($booking)
            ->delay($booking->check_in->subDay());

        // Schedule cleaning after checkout
        ScheduleCleaningJob::dispatch($booking)
            ->delay($booking->check_out->addHours(2));

        // Send review request 2 days after checkout
        SendReviewRequest::dispatch($booking)
            ->delay($booking->check_out->addDays(2));

        // Florida-specific: Hurricane season reminder if applicable
        if ($this->isHurricaneSeason($booking->check_in)) {
            SendHurricaneSeasonInfo::dispatch($booking)
                ->delay($booking->check_in->subDays(7));
        }
    }

    /**
     * Dynamic pricing update based on demand and seasonality
     */
    protected function updateDynamicPricing(Property $property)
    {
        $pricingRules = $property->pricingRules;
        $currentOccupancy = $this->calculateOccupancyRate($property);
        $seasonalMultiplier = $this->getFloridaSeasonalMultiplier();
        
        // Adjust pricing based on occupancy and Florida seasons
        if ($currentOccupancy > 0.85) {
            $newPrice = $pricingRules->base_price * 1.2 * $seasonalMultiplier;
        } elseif ($currentOccupancy < 0.6) {
            $newPrice = $pricingRules->base_price * 0.9 * $seasonalMultiplier;
        } else {
            $newPrice = $pricingRules->base_price * $seasonalMultiplier;
        }

        // Update pricing across all platforms
        $this->updatePricingAcrossPlatforms($property, $newPrice);
    }

    /**
     * Check if date falls within Florida hurricane season
     */
    protected function isHurricaneSeason(Carbon $date): bool
    {
        $hurricaneStart = Carbon::create($date->year, 6, 1); // June 1st
        $hurricaneEnd = Carbon::create($date->year, 11, 30); // November 30th
        
        return $date->between($hurricaneStart, $hurricaneEnd);
    }
}

// app/Models/Property.php - Property model with relationships
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Carbon\Carbon;

class Property extends Model
{
    protected $fillable = [
        'name', 'description', 'address', 'city', 'state',
        'zip_code', 'latitude', 'longitude', 'bedrooms',
        'bathrooms', 'max_guests', 'property_type', 'amenities',
        'base_price', 'cleaning_fee', 'security_deposit',
        'minimum_stay', 'maximum_stay', 'user_id'
    ];

    protected $casts = [
        'amenities' => 'array',
        'latitude' => 'float',
        'longitude' => 'float',
        'base_price' => 'decimal:2',
        'cleaning_fee' => 'decimal:2',
        'security_deposit' => 'decimal:2'
    ];

    /**
     * Get all bookings for this property
     */
    public function bookings(): HasMany
    {
        return $this->hasMany(Booking::class);
    }

    /**
     * Get property owner
     */
    public function owner(): BelongsTo
    {
        return $this->belongsTo(User::class, 'user_id');
    }

    /**
     * Get cleaning schedules
     */
    public function cleaningSchedules(): HasMany
    {
        return $this->hasMany(CleaningSchedule::class);
    }

    /**
     * Get platform integrations
     */
    public function platformIntegrations(): HasMany
    {
        return $this->hasMany(PlatformIntegration::class);
    }

    /**
     * Calculate occupancy rate for a given period
     */
    public function occupancyRate(Carbon $startDate, Carbon $endDate): float
    {
        $totalDays = $startDate->diffInDays($endDate);
        $bookedDays = $this->bookings()
            ->where('status', 'confirmed')
            ->where(function ($query) use ($startDate, $endDate) {
                $query->whereBetween('check_in', [$startDate, $endDate])
                      ->orWhereBetween('check_out', [$startDate, $endDate]);
            })
            ->get()
            ->sum(function ($booking) {
                return $booking->check_in->diffInDays($booking->check_out);
            });

        return $totalDays > 0 ? ($bookedDays / $totalDays) * 100 : 0;
    }

    /**
     * Get revenue for a given period
     */
    public function revenue(Carbon $startDate, Carbon $endDate): float
    {
        return $this->bookings()
            ->where('status', 'confirmed')
            ->whereBetween('check_in', [$startDate, $endDate])
            ->sum('total_amount');
    }

    /**
     * Get active platform integrations
     */
    public function activePlatforms(): array
    {
        return $this->platformIntegrations()
            ->where('is_active', true)
            ->get()
            ->map(function ($integration) {
                return [
                    'name' => $integration->platform_name,
                    'external_id' => $integration->external_property_id,
                    'last_sync' => $integration->last_sync_at
                ];
            })
            ->toArray();
    }

    /**
     * Get next cleaning schedule
     */
    public function nextCleaning(): ?CleaningSchedule
    {
        return $this->cleaningSchedules()
            ->where('scheduled_date', '>=', now())
            ->where('status', 'scheduled')
            ->orderBy('scheduled_date')
            ->first();
    }

    /**
     * Check availability for given dates
     */
    public function isAvailable(Carbon $checkIn, Carbon $checkOut): bool
    {
        $conflictingBookings = $this->bookings()
            ->where('status', 'confirmed')
            ->where(function ($query) use ($checkIn, $checkOut) {
                $query->where(function ($q) use ($checkIn, $checkOut) {
                    $q->whereBetween('check_in', [$checkIn, $checkOut])
                      ->orWhereBetween('check_out', [$checkIn, $checkOut]);
                })->orWhere(function ($q) use ($checkIn, $checkOut) {
                    $q->where('check_in', '<=', $checkIn)
                      ->where('check_out', '>=', $checkOut);
                });
            })
            ->exists();

        return !$conflictingBookings;
    }

    /**
     * Get Florida-specific attributes
     */
    public function getFloridaAttributesAttribute(): array
    {
        return [
            'hurricane_zone' => $this->getHurricaneZone(),
            'beach_distance' => $this->calculateBeachDistance(),
            'theme_park_proximity' => $this->getThemeParkProximity(),
            'season_type' => $this->getCurrentSeason()
        ];
    }

    /**
     * Determine hurricane evacuation zone
     */
    protected function getHurricaneZone(): string
    {
        // Simple coastal proximity check (real implementation would use FEMA data)
        $coastalDistance = $this->calculateCoastalDistance();
        
        if ($coastalDistance <= 1) return 'A'; // Highest risk
        if ($coastalDistance <= 3) return 'B';
        if ($coastalDistance <= 5) return 'C';
        return 'X'; // Minimal flood risk
    }
}

// app/Jobs/SendGuestWelcomeEmail.php - Automated guest messaging
<?php

namespace App\Jobs;

use App\Models\Booking;
use App\Mail\GuestWelcomeMail;
use App\Services\MessageTemplateService;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Mail;

class SendGuestWelcomeEmail implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    protected $booking;
    public $tries = 3;
    public $timeout = 300;

    public function __construct(Booking $booking)
    {
        $this->booking = $booking;
    }

    public function handle(MessageTemplateService $templateService)
    {
        $property = $this->booking->property;
        $guest = $this->booking->guest_data;

        // Generate personalized welcome message with Florida-specific info
        $messageData = [
            'guest_name' => $guest['first_name'] ?? 'Guest',
            'property_name' => $property->name,
            'check_in_date' => $this->booking->check_in->format('F j, Y'),
            'check_out_date' => $this->booking->check_out->format('F j, Y'),
            'local_attractions' => $this->getLocalAttractions($property),
            'weather_info' => $this->getWeatherInfo($property, $this->booking->check_in),
            'hurricane_season_info' => $this->getHurricaneSeasonInfo($this->booking->check_in),
            'wifi_password' => $property->wifi_password,
            'parking_info' => $property->parking_instructions,
            'emergency_contacts' => $property->emergency_contacts
        ];

        // Get template based on property location and season
        $template = $templateService->getWelcomeTemplate($property, $this->booking->check_in);
        $personalizedMessage = $templateService->personalize($template, $messageData);

        // Send email via platform-specific channels
        switch ($this->booking->platform) {
            case 'airbnb':
                $this->sendAirbnbMessage($personalizedMessage);
                break;
            case 'vrbo':
                $this->sendVrboMessage($personalizedMessage);
                break;
            default:
                // Direct booking - send email
                Mail::to($guest['email'])->send(new GuestWelcomeMail($personalizedMessage));
        }

        // Log successful communication
        $this->booking->communications()->create([
            'type' => 'welcome_message',
            'channel' => $this->booking->platform,
            'content' => $personalizedMessage,
            'sent_at' => now(),
            'status' => 'sent'
        ]);
    }

    /**
     * Get local attractions based on property location
     */
    protected function getLocalAttractions($property): array
    {
        $attractions = [];
        
        // Orlando area attractions
        if (stripos($property->city, 'orlando') !== false || 
            stripos($property->city, 'kissimmee') !== false) {
            $attractions = [
                'Walt Disney World Resort - 15 minutes',
                'Universal Studios Orlando - 20 minutes',
                'Icon Park - 25 minutes',
                'City Walk - 20 minutes'
            ];
        }
        
        // Miami area attractions
        elseif (stripos($property->city, 'miami') !== false) {
            $attractions = [
                'South Beach - 10 minutes',
                'Art Deco District - 5 minutes',
                'Little Havana - 15 minutes',
                'Wynwood Arts District - 20 minutes'
            ];
        }
        
        // Key West attractions
        elseif (stripos($property->city, 'key west') !== false) {
            $attractions = [
                'Mallory Square Sunset - 10 minutes',
                'Duval Street - 5 minutes',
                'Ernest Hemingway House - 8 minutes',
                'Key West Butterfly Conservatory - 12 minutes'
            ];
        }

        return $attractions;
    }

    /**
     * Get hurricane season information if applicable
     */
    protected function getHurricaneSeasonInfo($checkInDate): ?array
    {
        $hurricaneStart = Carbon::create($checkInDate->year, 6, 1);
        $hurricaneEnd = Carbon::create($checkInDate->year, 11, 30);
        
        if ($checkInDate->between($hurricaneStart, $hurricaneEnd)) {
            return [
                'season_active' => true,
                'emergency_info' => 'Florida is currently in hurricane season (June 1 - November 30). Please stay informed about weather conditions during your stay.',
                'resources' => [
                    'National Hurricane Center: nhc.noaa.gov',
                    'Florida Emergency Management: floridadisaster.org',
                    'Local Emergency Services: 911'
                ],
                'evacuation_zone' => $property->florida_attributes['hurricane_zone'] ?? 'X'
            ];
        }

        return null;
    }
}

// app/Services/DynamicPricingService.php - Florida seasonal pricing optimization
<?php

namespace App\Services;

use App\Models\Property;
use App\Models\Booking;
use Carbon\Carbon;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Http;

class DynamicPricingService
{
    protected $competitorAnalysisService;
    protected $eventCalendarService;

    public function __construct(
        CompetitorAnalysisService $competitorAnalysisService,
        EventCalendarService $eventCalendarService
    ) {
        $this->competitorAnalysisService = $competitorAnalysisService;
        $this->eventCalendarService = $eventCalendarService;
    }

    /**
     * Calculate optimal pricing for Florida property
     */
    public function calculateOptimalPrice(Property $property, Carbon $date): float
    {
        $basePrice = $property->base_price;
        
        // Get Florida seasonal multiplier
        $seasonalMultiplier = $this->getFloridaSeasonalMultiplier($property, $date);
        
        // Get demand multiplier based on occupancy
        $demandMultiplier = $this->getDemandMultiplier($property, $date);
        
        // Get event multiplier for local events
        $eventMultiplier = $this->getEventMultiplier($property, $date);
        
        // Get competitor pricing influence
        $competitorAdjustment = $this->getCompetitorAdjustment($property, $date);
        
        // Hurricane season adjustment (lower prices during active storms)
        $hurricaneAdjustment = $this->getHurricaneAdjustment($date);

        $calculatedPrice = $basePrice * 
            $seasonalMultiplier * 
            $demandMultiplier * 
            $eventMultiplier * 
            $competitorAdjustment * 
            $hurricaneAdjustment;

        // Apply minimum and maximum price constraints
        $minPrice = $property->minimum_price ?? ($basePrice * 0.7);
        $maxPrice = $property->maximum_price ?? ($basePrice * 3.0);

        return max($minPrice, min($maxPrice, round($calculatedPrice, 2)));
    }

    /**
     * Get Florida seasonal pricing multiplier
     */
    protected function getFloridaSeasonalMultiplier(Property $property, Carbon $date): float
    {
        $month = $date->month;
        
        // Different seasonal patterns for different Florida regions
        if ($this->isOrlandoArea($property)) {
            // Orlando: High season during school breaks and holidays
            if (in_array($month, [12, 1, 3, 6, 7, 8])) { // Winter holidays, Spring break, Summer
                return 1.4;
            } elseif (in_array($month, [2, 4, 11])) {
                return 1.2;
            }
            return 1.0;
        }
        
        elseif ($this->isMiamiArea($property)) {
            // Miami: High season in winter, Art Basel, Spring Break
            if (in_array($month, [12, 1, 2, 3])) { // Winter season
                return 1.5;
            } elseif (in_array($month, [4, 11])) {
                return 1.2;
            }
            return 0.9; // Lower in summer due to heat/humidity
        }
        
        elseif ($this->isKeyWestArea($property)) {
            // Key West: High season in winter, lower in hurricane season
            if (in_array($month, [12, 1, 2, 3, 4])) {
                return 1.6; // Peak season
            } elseif (in_array($month, [9, 10, 11])) {
                return 0.8; // Hurricane season
            }
            return 1.0;
        }

        return 1.0; // Default multiplier
    }

    /**
     * Get demand multiplier based on current occupancy
     */
    protected function getDemandMultiplier(Property $property, Carbon $date): float
    {
        $startDate = $date->copy()->subDays(30);
        $endDate = $date->copy()->addDays(30);
        
        $occupancyRate = $property->occupancyRate($startDate, $endDate);
        
        if ($occupancyRate >= 90) return 1.3;
        if ($occupancyRate >= 80) return 1.15;
        if ($occupancyRate >= 70) return 1.05;
        if ($occupancyRate <= 40) return 0.9;
        if ($occupancyRate <= 30) return 0.85;
        
        return 1.0;
    }

    /**
     * Get event-based pricing multiplier
     */
    protected function getEventMultiplier(Property $property, Carbon $date): float
    {
        $events = $this->eventCalendarService->getEventsNearProperty($property, $date);
        
        foreach ($events as $event) {
            switch ($event['impact_level']) {
                case 'major': // Super Bowl, Art Basel, etc.
                    return 2.0;
                case 'high': // Large conventions, festivals
                    return 1.5;
                case 'medium': // Local events
                    return 1.2;
            }
        }
        
        return 1.0;
    }

    /**
     * Check if property is in Orlando area
     */
    protected function isOrlandoArea(Property $property): bool
    {
        $orlandoCities = ['orlando', 'kissimmee', 'celebration', 'winter park', 'lake buena vista'];
        return in_array(strtolower($property->city), $orlandoCities);
    }
}