En este tutorial vamos a ver cómo crear un CRM inmobiliario con Laravel. Guardará la cartera de inmuebles de una agencia y los clientes con lo que busca cada uno, cruzará automáticamente unos con otros y llevará la agenda de visitas. Así, al dar de alta un piso verás qué clientes lo están buscando, y al dar de alta un cliente verás qué inmuebles le encajan.

Como ejemplo crearemos el CRM de Atalaya Inmobiliaria, una agencia inventada de Valencia. Las pantallas las haremos con Livewire 4, que es lo que uso para casi todos los paneles internos, así que todo el tutorial se escribe en PHP y Blade, sin montar un frontend aparte. Y para no reinventar la tabla, los formularios en ventana, el calendario, los avisos y el buscador, usaremos cinco paquetes que he publicado yo mismo.

Introducción

Cualquier agencia inmobiliaria trabaja con dos listas, la de lo que tiene para vender o alquilar y la de lo que buscan sus clientes. El trabajo diario consiste en cruzarlas, y cuando se hace de memoria o con una hoja de cálculo siempre se escapa alguna oportunidad, como un piso que entra en cartera el lunes y que encajaba con un cliente que llamó hace un mes. Eso es lo que resolveremos aquí, con cuatro pantallas:

  • Inmuebles: la cartera, con la foto de portada de cada inmueble, un buscador, filtros por operación y zona, orden por precio o superficie y el número de clientes interesados en cada uno.
  • Ficha del inmueble: sus datos y sus fotos, los clientes cuya demanda encaja y las visitas, con un calendario para programar la siguiente.
  • Clientes: cada cliente con lo que busca y los inmuebles que le encajan ahora mismo, con su propio buscador.
  • Visitas: la agenda de los próximos días y qué le pareció cada inmueble al cliente.

Antes de continuar, te recomiendo tener ciertos conocimientos previos:

Puedes consultar el código de la aplicación que vamos a crear en GitHub. Al terminar, el listado de inmuebles tendrá este aspecto, con el número de clientes interesados en la última columna:

Listado de inmuebles con su foto de portada en un CRM inmobiliario creado con Laravel, Livewire y Wiretables

Instalación de Laravel y Livewire

Empezaremos por crear el proyecto, instalar Livewire y dejar el idioma y la hora en español.

Crea un proyecto con Laravel

Crea un proyecto nuevo con Laravel 13 y entra en su carpeta:

composer create-project laravel/laravel:^13.0 crm-inmobiliario
cd crm-inmobiliario

Laravel 13 usa SQLite por defecto y deja creada la base de datos, así que no necesitas instalar ningún servidor de bases de datos para seguir el tutorial. También trae Tailwind configurado con Vite.

Instala Livewire

Livewire permite crear pantallas interactivas escribiendo solo PHP y Blade. Cuando el usuario cambia un filtro o pulsa un botón, Livewire llama al servidor y vuelve a pintar únicamente la parte de la página que ha cambiado. Instala la versión 4 con Composer:

composer require livewire/livewire:^4.4

En Livewire 4 cada pantalla puede ser un componente de un solo archivo, con la clase PHP arriba y la vista Blade debajo, en un fichero dentro de resources/views/pages. Es la forma que usaremos para las cuatro pantallas del CRM.

Instala los paquetes de la interfaz

La tabla de inmuebles, los formularios de alta, el calendario de las visitas y los avisos podríamos programarlos a mano, pero cualquier panel de administración los necesita. Yo los tengo resueltos en paquetes que uso en mis propios proyectos, y en este CRM usaremos estos cinco:

  • Wiretables: componentes de Blade para tablas que también se leen bien en el móvil, con orden por columnas y un menú de acciones en cada fila.
  • Wiremodal: ventanas modales que se abren desde JavaScript o desde Livewire. Meteremos en ellas los formularios de alta.
  • Wirepicker: un selector de fecha y hora con el calendario en español, que además puede marcar los días que ya tienen algo.
  • Wiretoast: los avisos que aparecen en una esquina de la pantalla, como «Visita programada», y que cualquier componente lanza con $this->notify().
  • Larasearch: búsqueda de texto sobre la propia base de datos, sin Meilisearch ni Elasticsearch. No distingue mayúsculas ni tildes, así que «lucia» encuentra a Lucía.

Instálalos con Composer:

composer require edulazaro/wiretables edulazaro/wiremodal edulazaro/wirepicker edulazaro/wiretoast edulazaro/larasearch

Larasearch trae una migración propia, que se ejecutará junto con las nuestras. Los otros cuatro traen sus estilos, que no dependen de Tailwind. Añádelos al archivo resources/css/app.css, que quedará así:

@import 'tailwindcss';

/* Los componentes de edulazaro: tablas, modales, calendario y avisos. Van en la capa
   components para que las clases de Tailwind que les pongamos tengan prioridad. */
@import '../../vendor/edulazaro/wiretables/resources/css/wiretables-core.css' layer(components);
@import '../../vendor/edulazaro/wiretables/resources/css/themes/megaflow.css' layer(components);
@import '../../vendor/edulazaro/wiremodal/resources/css/wiremodal.css' layer(components);
@import '../../vendor/edulazaro/wirepicker/resources/css/wirepicker.css' layer(components);
@import '../../vendor/edulazaro/wiretoast/resources/css/wiretoast.css' layer(components);

@source '../../vendor/laravel/framework/src/Illuminate/Pagination/resources/views/*.blade.php';
@source '../../storage/framework/views/*.php';

@theme {
    --font-sans: 'Instrument Sans', ui-sans-serif, system-ui, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji',
        'Segoe UI Symbol', 'Noto Color Emoji';
}

/* El verde azulado de la agencia en lugar del azul del tema. */
@layer components {
    [data-wire-theme="megaflow"] {
        --wire-accent: var(--color-teal-700);
    }
}

Las importaciones van en la capa components de Tailwind. Así, cuando le pongamos a uno de sus componentes una clase como border, la clase gana a los estilos del paquete. Megaflow es uno de los temas que comparten los cuatro, de fondo blanco, y la última regla cambia su azul por el verde azulado de la agencia.

Los scripts van en resources/js/app.js:

import '../../vendor/edulazaro/wiremodal/resources/js/wiremodal.js';
import '../../vendor/edulazaro/wirepicker/resources/js/wirepicker.js';
import '../../vendor/edulazaro/wiretoast/resources/js/wiretoast.js';

Wiretables no necesita script propio, porque su menú de acciones funciona con Alpine, que ya viene incluido en Livewire.

Configura el idioma y la hora

Edita el archivo .env para darle nombre a la aplicación y usar el español:

APP_NAME="Atalaya CRM"
APP_LOCALE=es

Las visitas se programan a una hora concreta, así que conviene que Laravel trabaje con la hora de la agencia. En config/app.php, cambia la zona horaria:

'timezone' => 'Europe/Madrid',

Laravel no incluye los mensajes de validación en español. En lugar de instalar un paquete de traducciones, crea el archivo lang/es/validation.php solo con los mensajes que vamos a usar. El archivo empieza por los mensajes de las reglas que usan nuestros formularios. Debajo van los nombres de los campos, que puedes copiar del repositorio:

<?php

// Solo los mensajes que usa el CRM. Para el resto, publica los ficheros de idioma completos.
return [
    'required' => 'Rellena :attribute.',
    'integer' => ':Attribute tiene que ser un número entero.',
    'min' => ['numeric' => ':Attribute tiene que ser como mínimo :min.'],
    'max' => [
        'numeric' => ':Attribute no puede pasar de :max.',
        'string' => ':Attribute no puede tener más de :max caracteres.',
        'file' => ':Attribute no puede ocupar más de :max kilobytes.',
        'array' => 'Sube como máximo :max fotos a la vez.',
    ],
    'image' => ':Attribute tiene que ser una imagen.',
    'mimes' => ':Attribute tiene que ser JPG, PNG o WebP.',
    'uploaded' => 'No se ha podido subir :attribute.',
    'unique' => 'Ya existe un registro con esa :attribute.',
    'in' => 'Elige :attribute de la lista.',
    'enum' => 'Elige :attribute de la lista.',
    'email' => 'Ese email no es válido.',
    'date' => ':Attribute no es una fecha válida.',
    'after' => ':Attribute tiene que ser posterior a ahora.',
    'exists' => 'Elige :attribute de la lista.',

La base de datos

El CRM tiene cinco tablas, que guardan los inmuebles y sus fotos, los clientes, lo que busca cada cliente, al que llamaremos demanda, y las visitas. Antes de crearlas definiremos los valores fijos que usan.

Crea los enums

Un inmueble se vende o se alquila, es de un tipo concreto y está disponible, reservado o cerrado. En lugar de repetir esos valores como textos sueltos por todo el código, crearemos un enum para cada uno. Empezaremos por la operación, que solo puede ser una venta o un alquiler. Crea el archivo app/Enums/Operation.php:

<?php

namespace App\Enums;

enum Operation: string
{
    case Sale = 'sale';
    case Rent = 'rent';

    public function label(): string
    {
        return match ($this) {
            self::Sale => 'Venta',
            self::Rent => 'Alquiler',
        };
    }
}

El valor que se guarda en la base de datos va en inglés, como el resto del código, y el método label() devuelve el texto que verá la agencia. Crea de la misma forma PropertyType (piso, casa, local y oficina), PropertyStatus (disponible, reservado y vendido o alquilado) y VisitOutcome (pendiente, le interesa y descartado). Los cuatro están en la carpeta app/Enums del repositorio.

Guarda las zonas de la agencia

Para cruzar inmuebles y demandas por zona, las dos tienen que escribir la zona exactamente igual. Si un comercial guarda un piso en «Ruzafa» y otro apunta que un cliente busca en «ruzafa», el cruce no los une. Lo más sencillo es que la agencia trabaje con una lista cerrada de zonas. Crea el archivo config/crm.php:

<?php

return [

    // La agencia de ejemplo del tutorial. Es inventada, igual que sus datos.
    'agency' => 'Atalaya Inmobiliaria',

    // Las zonas en las que trabaja la agencia. Inmuebles y demandas eligen de esta lista,
    // así una búsqueda en «Ruzafa» nunca deja fuera un piso guardado como «ruzafa».
    'zones' => ['Benimaclet', 'Campanar', 'El Carmen', 'Malvarrosa', 'Patraix', 'Ruzafa'],

];

Crea las tablas

Crea las cuatro migraciones:

php artisan make:migration create_properties_table
php artisan make:migration create_contacts_table
php artisan make:migration create_demands_table
php artisan make:migration create_visits_table
php artisan make:migration create_property_photos_table

La tabla de inmuebles guarda la referencia interna de la agencia, la operación, el tipo, la zona, el precio en euros, los dormitorios, la superficie y el estado:

        Schema::create('properties', function (Blueprint $table) {
            $table->id();
            $table->string('reference')->unique();
            $table->string('title');
            $table->string('operation');
            $table->string('type');
            $table->string('zone');
            $table->unsignedInteger('price');
            $table->unsignedTinyInteger('bedrooms')->default(0);
            $table->unsignedSmallInteger('area');
            $table->string('status')->default('available');
            $table->text('description')->nullable();
            // El texto en el que busca Larasearch: referencia, título y zona.
            $table->searchable();
            $table->timestamps();

            $table->index(['operation', 'status']);
        });

El precio es un número entero, en euros si es una venta y en euros al mes si es un alquiler. La columna que añade $table->searchable() es de Larasearch. Guarda en un solo texto, en minúsculas y sin tildes, los campos por los que buscaremos, y se actualiza sola cada vez que se guarda el inmueble. El índice sobre operation y status acelera el cruce, que siempre filtra por esas dos columnas.

La demanda guarda lo que busca un cliente. Los campos que el cliente no fija, como el tipo o la zona, quedan vacíos y significan «me vale cualquiera»:

        Schema::create('demands', function (Blueprint $table) {
            $table->id();
            $table->foreignId('contact_id')->constrained()->cascadeOnDelete();
            $table->string('operation');
            $table->string('type')->nullable();
            $table->string('zone')->nullable();
            $table->unsignedInteger('max_price');
            $table->unsignedTinyInteger('min_bedrooms')->default(0);
            $table->unsignedSmallInteger('min_area')->default(0);
            $table->boolean('active')->default(true);
            $table->timestamps();
        });

La tabla de clientes guarda el nombre, el email, el teléfono, unas notas y su propia columna de búsqueda. La de visitas une un inmueble con un cliente en una fecha, con el resultado de la visita:

        Schema::create('visits', function (Blueprint $table) {
            $table->id();
            $table->foreignId('property_id')->constrained()->cascadeOnDelete();
            $table->foreignId('contact_id')->constrained()->cascadeOnDelete();
            $table->dateTime('scheduled_at');
            $table->string('outcome')->default('pending');
            $table->text('notes')->nullable();
            $table->timestamps();

            $table->index('scheduled_at');
        });

Las fotos tienen su propia tabla, porque un inmueble puede tener muchas. La base de datos solo guarda la ruta de cada archivo y su posición, y la foto con la posición más baja será la portada:

        Schema::create('property_photos', function (Blueprint $table) {
            $table->id();
            $table->foreignId('property_id')->constrained()->cascadeOnDelete();
            // La ruta dentro del disco public, por ejemplo properties/8/salon.jpg.
            $table->string('path');
            // El orden de las fotos. La primera es la portada del inmueble.
            $table->unsignedSmallInteger('position')->default(0);
            $table->timestamps();
        });

Ejecuta las migraciones:

php artisan migrate

El cruce de inmuebles y demandas

El cruce es el corazón del CRM. En todos los CRM inmobiliarios en los que he trabajado ha acabado siendo la pieza central, y aquí también lo será. Un inmueble encaja con una demanda cuando la operación coincide, el precio no supera el máximo, tiene al menos los dormitorios y la superficie que pide el cliente y, si la demanda fija un tipo o una zona, también coinciden. El cruce lo necesitamos en los dos sentidos, para saber qué inmuebles le sirven a un cliente y a qué clientes les sirve un inmueble.

Busca inmuebles para una demanda

Crea el modelo Property:

php artisan make:model Property

Edita el archivo app/Models/Property.php. Además de los campos y los casts a los enums, añadiremos un scope con el cruce:

<?php

namespace App\Models;

use App\Enums\Operation;
use App\Enums\PropertyStatus;
use App\Enums\PropertyType;
use EduLazaro\Larasearch\Concerns\HasSearch;
use Illuminate\Database\Eloquent\Attributes\Scope;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\HasOne;

class Property extends Model
{
    use HasSearch;

    protected $fillable = [
        'reference', 'title', 'operation', 'type', 'zone', 'price',
        'bedrooms', 'area', 'status', 'description',
    ];

    // Los mismos valores por defecto que la tabla, para que un inmueble recién creado los tenga
    // ya en memoria sin volver a leerlo de la base de datos.
    protected $attributes = [
        'status' => 'available',
        'bedrooms' => 0,
    ];

    // Los campos que encuentra el buscador del listado.
    protected array $searchable = ['reference', 'title', 'zone'];

    protected function casts(): array
    {
        return [
            'operation' => Operation::class,
            'type' => PropertyType::class,
            'status' => PropertyStatus::class,
            'price' => 'integer',
            'bedrooms' => 'integer',
            'area' => 'integer',
        ];
    }

    /** 289.000 € en venta y 850 €/mes en alquiler. */
    public function priceLabel(): string
    {
        $amount = number_format($this->price, 0, ',', '.').' €';

        return $this->operation === Operation::Rent ? $amount.'/mes' : $amount;
    }

    public function visits(): HasMany
    {
        return $this->hasMany(Visit::class);
    }

    public function photos(): HasMany
    {
        return $this->hasMany(PropertyPhoto::class)->orderBy('position');
    }

    /** La portada: la primera foto del inmueble. */
    public function cover(): HasOne
    {
        return $this->hasOne(PropertyPhoto::class)->oldestOfMany('position');
    }

    /**
     * Los inmuebles disponibles que encajan con lo que busca una demanda. Si la demanda no
     * fija tipo o zona, vale cualquiera.
     */
    #[Scope]
    protected function matching(Builder $query, Demand $demand): void
    {
        $query->where('status', PropertyStatus::Available)
            ->where('operation', $demand->operation)
            ->where('price', '<=', $demand->max_price)
            ->where('bedrooms', '>=', $demand->min_bedrooms)
            ->where('area', '>=', $demand->min_area)
            ->when($demand->type, fn (Builder $q) => $q->where('type', $demand->type))
            ->when($demand->zone, fn (Builder $q) => $q->where('zone', $demand->zone));
    }
}

El atributo #[Scope] convierte el método matching() en un scope de Eloquent, así que podremos escribir Property::matching($demanda) y encadenar después cualquier otra condición. Solo se cruzan los inmuebles disponibles, porque un piso reservado no le sirve a nadie. Los dos when() aplican el tipo y la zona solo si la demanda los fija.

La propiedad $attributes repite los valores por defecto de la tabla. Eloquent no vuelve a leer el registro después de crearlo, así que sin ella un inmueble recién creado tendría el estado y los dormitorios vacíos en memoria. El método priceLabel() formatea el precio a la española y añade «/mes» en los alquileres. El trait HasSearch y la propiedad $searchable le dicen a Larasearch qué campos entran en el buscador, que en los inmuebles son la referencia, el título y la zona. Por último, photos() devuelve las fotos en orden y cover() solo la primera, gracias a oldestOfMany('position'), que se queda con la de menor posición de cada inmueble.

Busca clientes para un inmueble

Crea los modelos de clientes, demandas, visitas y fotos:

php artisan make:model Contact
php artisan make:model Demand
php artisan make:model Visit
php artisan make:model PropertyPhoto

El modelo Demand tiene el mismo cruce, visto desde el otro lado. Aquí son las columnas de la demanda las que se comparan con los valores del inmueble, y un tipo o una zona vacíos aceptan cualquiera. Si el inmueble está reservado o vendido, el scope no devuelve ninguna demanda. Para eso usamos whereIn('id', []), que es la forma de Eloquent de pedir una consulta sin resultados. Esta comprobación se me pasó en la primera versión, y al probar el CRM me encontré un piso reservado que seguía mostrando interesados. También repite en $attributes los mínimos por defecto, porque un where() con null como valor lanza una excepción, y eso es lo que pasaría al cruzar una demanda recién creada sin dormitorios ni superficie mínimos:

<?php

namespace App\Models;

use App\Enums\Operation;
use App\Enums\PropertyStatus;
use App\Enums\PropertyType;
use Illuminate\Database\Eloquent\Attributes\Scope;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;

class Demand extends Model
{
    protected $fillable = [
        'contact_id', 'operation', 'type', 'zone', 'max_price',
        'min_bedrooms', 'min_area', 'active',
    ];

    protected $attributes = [
        'min_bedrooms' => 0,
        'min_area' => 0,
        'active' => true,
    ];

    protected function casts(): array
    {
        return [
            'operation' => Operation::class,
            'type' => PropertyType::class,
            'max_price' => 'integer',
            'min_bedrooms' => 'integer',
            'min_area' => 'integer',
            'active' => 'boolean',
        ];
    }

    public function contact(): BelongsTo
    {
        return $this->belongsTo(Contact::class);
    }

    /**
     * Las demandas activas a las que les sirve un inmueble: el cruce visto desde el otro
     * lado. Una demanda sin tipo o sin zona acepta cualquiera.
     */
    #[Scope]
    protected function matching(Builder $query, Property $property): void
    {
        // Un inmueble reservado o vendido ya no le sirve a nadie.
        if ($property->status !== PropertyStatus::Available) {
            $query->whereIn('id', []);

            return;
        }

        $query->where('active', true)
            ->where('operation', $property->operation)
            ->where('max_price', '>=', $property->price)
            ->where('min_bedrooms', '<=', $property->bedrooms)
            ->where('min_area', '<=', $property->area)
            ->where(fn (Builder $q) => $q->whereNull('type')->orWhere('type', $property->type))
            ->where(fn (Builder $q) => $q->whereNull('zone')->orWhere('zone', $property->zone));
    }
}

Los otros dos modelos son más sencillos. Un cliente tiene demandas y visitas, y también usa HasSearch para poder buscarlo por nombre, email o teléfono:

class Contact extends Model
{
    use HasSearch;

    protected $fillable = ['name', 'email', 'phone', 'notes'];

    // Los campos que encuentra el buscador de clientes.
    protected array $searchable = ['name', 'email', 'phone'];

    public function demands(): HasMany
    {
        return $this->hasMany(Demand::class);
    }

    public function visits(): HasMany
    {
        return $this->hasMany(Visit::class);
    }
}

Y una visita pertenece a un inmueble y a un cliente, con la fecha convertida a Carbon y el resultado al enum VisitOutcome:

class Visit extends Model
{
    protected $fillable = ['property_id', 'contact_id', 'scheduled_at', 'outcome', 'notes'];

    protected $attributes = [
        'outcome' => 'pending',
    ];

    protected function casts(): array
    {
        return [
            'scheduled_at' => 'datetime',
            'outcome' => VisitOutcome::class,
        ];
    }

    public function property(): BelongsTo
    {
        return $this->belongsTo(Property::class);
    }

    public function contact(): BelongsTo
    {
        return $this->belongsTo(Contact::class);
    }
}

La foto sabe construir su dirección pública con Storage::url(). En booted() registramos un evento para que, al borrar el registro de una foto, se borre también su archivo del disco:

class PropertyPhoto extends Model
{
    protected $fillable = ['path', 'position'];

    protected static function booted(): void
    {
        // Al borrar la foto se borra también el archivo, para no dejar imágenes huérfanas.
        static::deleted(fn (PropertyPhoto $photo) => Storage::disk('public')->delete($photo->path));
    }

    public function property(): BelongsTo
    {
        return $this->belongsTo(Property::class);
    }

    public function url(): string
    {
        return Storage::disk('public')->url($this->path);
    }
}

Carga datos de ejemplo

Para probar el cruce necesitamos inmuebles y clientes. El seeder del repositorio, en database/seeders/DatabaseSeeder.php, carga diez inmuebles con una foto cada uno, cinco clientes con lo que busca cada uno y dos visitas. Las fotos de ejemplo, que he generado con IA, están en database/seeders/photos, y el seeder copia la de cada inmueble al disco public con putFile(), que le da un nombre aleatorio:

        Storage::disk('public')->deleteDirectory('properties');

        foreach ($properties as [$reference, $title, $operation, $type, $zone, $price, $bedrooms, $area]) {
            $property = Property::create(compact('reference', 'title', 'operation', 'type', 'zone', 'price', 'bedrooms', 'area'));

            $path = Storage::disk('public')->putFile("properties/{$property->id}", new File(__DIR__."/photos/{$reference}.jpg"));
            $property->photos()->create(['path' => $path]);
        }

En este otro fragmento se crean Lucía y Marc, dos de los clientes, cada uno con su demanda:

        $lucia = Contact::create(['name' => 'Lucía Ferrer', 'email' => 'lucia@example.test', 'phone' => '600 111 222']);
        $lucia->demands()->create(['operation' => 'sale', 'type' => 'flat', 'zone' => 'Ruzafa', 'max_price' => 300000, 'min_bedrooms' => 2]);

        $marc = Contact::create(['name' => 'Marc Soler', 'email' => 'marc@example.test']);
        $marc->demands()->create(['operation' => 'sale', 'max_price' => 340000, 'min_bedrooms' => 3, 'min_area' => 100]);

Ejecútalo:

php artisan db:seed

Los archivos del disco public se guardan en storage/app/public, que no es una carpeta pública. Para que el navegador pueda verlos, crea el enlace public/storage que apunta a ella:

php artisan storage:link

Prueba el cruce

Antes de crear las pantallas, comprueba que el cruce funciona con Tinker:

php artisan tinker

Pide los inmuebles que le encajan a cada cliente y los clientes interesados en el piso AT-108:

foreach (App\Models\Demand::with('contact')->get() as $demand) {
    echo $demand->contact->name.': '.App\Models\Property::matching($demand)->pluck('reference')->implode(', ').PHP_EOL;
}

$piso = App\Models\Property::where('reference', 'AT-108')->first();
App\Models\Demand::matching($piso)->with('contact')->get()->pluck('contact.name');

Marc busca algo en venta de hasta 340.000 €, con tres dormitorios y 100 m² como mínimo, y el cruce le devuelve el AT-108, un piso de cuatro dormitorios y 124 m² por 325.000 €. La casa de la Malvarrosa también tiene cuatro dormitorios, pero cuesta 352.000 €, así que no aparece.

Las pantallas del CRM

Con el modelo de datos listo, crearemos la plantilla, las rutas y las cuatro pantallas.

Crea el layout

Livewire busca la plantilla de las páginas en resources/views/layouts/app.blade.php. Crea el archivo con el menú de la agencia:

<!DOCTYPE html>
<html lang="es" data-wire-theme="megaflow">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>{{ $title ?? 'CRM' }} · {{ config('crm.agency') }}</title>
    @vite(['resources/css/app.css', 'resources/js/app.js'])
</head>
<body class="min-h-screen bg-slate-50 text-slate-800">
    <header class="border-b border-slate-200 bg-white">
        <nav class="mx-auto flex max-w-6xl items-center gap-6 px-4 py-3">
            <span class="font-semibold text-teal-700">{{ config('crm.agency') }}</span>
            <a href="{{ route('properties') }}" wire:navigate class="text-sm hover:text-teal-700" wire:current="font-semibold text-teal-700">Inmuebles</a>
            <a href="{{ route('contacts') }}" wire:navigate class="text-sm hover:text-teal-700" wire:current="font-semibold text-teal-700">Clientes</a>
            <a href="{{ route('visits') }}" wire:navigate class="text-sm hover:text-teal-700" wire:current="font-semibold text-teal-700">Visitas</a>
        </nav>
    </header>

    <main class="mx-auto max-w-6xl px-4 py-8">
        {{ $slot }}
    </main>

    <x-wiretoast theme="megaflow" />
</body>
</html>

El atributo wire:navigate hace que Livewire cambie de pantalla sin recargar la página entera, y wire:current marca el enlace de la sección en la que estás. El atributo data-wire-theme de la etiqueta <html> elige el tema de los paquetes de la interfaz, y el componente <x-wiretoast> del final es el lugar donde aparecerán los avisos.

Crea las rutas

Edita el archivo routes/web.php. Con Route::livewire() cada ruta apunta directamente a un componente de página:

<?php

use Illuminate\Support\Facades\Route;

Route::redirect('/', '/inmuebles');

Route::livewire('/inmuebles', 'pages::properties')->name('properties');
Route::livewire('/inmuebles/{property}', 'pages::property')->name('property');
Route::livewire('/clientes', 'pages::contacts')->name('contacts');
Route::livewire('/visitas', 'pages::visits')->name('visits');

El prefijo pages:: corresponde a la carpeta resources/views/pages. En la ruta de la ficha, Laravel convierte el {property} de la URL en el modelo, igual que en un controlador.

Crea el formulario de inmuebles

El alta de un inmueble tiene ocho campos con sus reglas de validación. Para no llenar la página con ellos, usaremos un formulario de Livewire. Crea el archivo app/Livewire/Forms/PropertyForm.php:

<?php

namespace App\Livewire\Forms;

use App\Enums\Operation;
use App\Enums\PropertyType;
use App\Models\Property;
use Illuminate\Validation\Rule;
use Livewire\Form;

class PropertyForm extends Form
{
    public string $reference = '';

    public string $title = '';

    public string $operation = 'sale';

    public string $type = 'flat';

    public string $zone = '';

    public ?int $price = null;

    public int $bedrooms = 2;

    public ?int $area = null;

    protected function rules(): array
    {
        return [
            'reference' => ['required', 'string', 'max:20', Rule::unique('properties', 'reference')],
            'title' => ['required', 'string', 'max:120'],
            'operation' => ['required', Rule::enum(Operation::class)],
            'type' => ['required', Rule::enum(PropertyType::class)],
            'zone' => ['required', Rule::in(config('crm.zones'))],
            'price' => ['required', 'integer', 'min:1'],
            'bedrooms' => ['required', 'integer', 'min:0', 'max:20'],
            'area' => ['required', 'integer', 'min:1'],
        ];
    }

    public function store(): Property
    {
        $property = Property::create($this->validate());

        $this->reset();

        return $property;
    }
}

Rule::enum() acepta solo los valores de los enums y Rule::in() solo las zonas de la agencia, así que nadie puede guardar una zona escrita a mano.

Crea el listado de inmuebles

Crea el archivo resources/views/pages/⚡properties.blade.php. El rayo del nombre es como Livewire 4 distingue los componentes de un solo archivo. La clase del componente guarda la búsqueda y los filtros, carga los inmuebles en el orden elegido, cuenta sus interesados, da de alta los nuevos y cambia su estado desde el menú de cada fila:

<?php

use App\Enums\Operation;
use App\Enums\PropertyStatus;
use App\Enums\PropertyType;
use App\Livewire\Forms\PropertyForm;
use App\Models\Demand;
use App\Models\Property;
use EduLazaro\Wiretables\Concerns\WithSorting;
use Livewire\Attributes\Computed;
use Livewire\Attributes\Title;
use Livewire\Attributes\Url;
use Livewire\Component;

/**
 * La cartera de la agencia: los inmuebles con su buscador y sus filtros, el alta de uno nuevo
 * y, en cada fila, cuántos clientes buscan justo algo así.
 */
new #[Title('Inmuebles')] class extends Component
{
    use WithSorting;

    #[Url]
    public string $search = '';

    #[Url]
    public string $operation = '';

    #[Url]
    public string $zone = '';

    public PropertyForm $form;

    /** Las columnas por las que se puede ordenar desde la cabecera de la tabla. */
    protected function sortable(): array
    {
        return ['price', 'area'];
    }

    #[Computed]
    public function properties()
    {
        return Property::query()
            ->with('cover')
            ->searchText($this->search)
            ->when($this->operation, fn ($q) => $q->where('operation', $this->operation))
            ->when($this->zone, fn ($q) => $q->where('zone', $this->zone))
            ->when($this->sort, fn ($q) => $q->orderBy($this->sort, $this->direction), fn ($q) => $q->orderBy('reference'))
            ->get();
    }

    public function interested(Property $property): int
    {
        return Demand::matching($property)->count();
    }

    public function save(): void
    {
        $property = $this->form->store();
        $interested = $this->interested($property);

        $this->form->reset();
        $this->closeModal('new-property');
        $this->notify(match ($interested) {
            0 => "{$property->reference} guardado. Todavía no lo busca ningún cliente.",
            1 => "{$property->reference} guardado. Lo busca un cliente.",
            default => "{$property->reference} guardado. Lo buscan {$interested} clientes.",
        });
    }

    public function setStatus(int $propertyId, string $status): void
    {
        $property = Property::findOrFail($propertyId);
        $property->update(['status' => PropertyStatus::from($status)]);

        $this->notify("{$property->reference} ahora está ".mb_strtolower($property->status->label()).'.', 'info');
    }
};

La búsqueda y los filtros llevan el atributo #[Url], que los guarda en la dirección. Así, si filtras por alquiler en Ruzafa y compartes el enlace, la otra persona ve lo mismo. El scope searchText() es de Larasearch y, si la búsqueda está vacía, no añade ninguna condición. El trait WithSorting de Wiretables guarda la columna y el sentido del orden en $sort y $direction, y solo acepta las columnas que devuelve sortable(), porque el navegador podría enviar cualquier texto.

Al guardar un inmueble, closeModal() cierra la ventana del formulario y notify() muestra un aviso que ya dice cuántos clientes lo buscan. Esos dos métodos los añaden Wiremodal y Wiretoast a todos los componentes de Livewire.

Debajo de la parte de PHP va la vista. El buscador y los filtros usan wire:model.live, que vuelve a pintar el listado en cuanto escribes o cambias de opción. En el buscador añadimos debounce.300ms para que espere a que dejes de teclear:

        <input type="search" wire:model.live.debounce.300ms="search" placeholder="Buscar por referencia, título o zona"
            class="w-64 rounded border border-slate-300 px-2 py-1.5 text-sm">

        <select wire:model.live="operation" class="rounded border border-slate-300 px-2 py-1.5 text-sm">
            <option value="">Venta y alquiler</option>
            @foreach (Operation::cases() as $case)
                <option value="{{ $case->value }}">{{ $case->label() }}</option>
            @endforeach
        </select>

La tabla se escribe con los componentes de Wiretables. La primera columna es el inmueble y las demás se ajustan a su contenido con shrink. Las que llevan hide solo aparecen a partir de ese ancho de pantalla, y en el móvil su información se repite bajo el título. Las cabeceras con sortable se convierten en botones que llaman a sortBy(), toda la fila lleva a la ficha del inmueble y el slot leading de la primera celda muestra la portada. La consulta la carga con with('cover'), para no hacer una consulta más por cada fila:

    <x-wiretable>
        <x-slot:head>
            <x-wiretable.th>Inmueble</x-wiretable.th>
            <x-wiretable.th hide="md" shrink>Zona</x-wiretable.th>
            <x-wiretable.th shrink align="right" sortable="price" :sort="$sort" :direction="$direction">Precio</x-wiretable.th>
            <x-wiretable.th hide="lg" shrink align="right" sortable="area" :sort="$sort" :direction="$direction">Superficie</x-wiretable.th>
            <x-wiretable.th hide="md" shrink>Estado</x-wiretable.th>
            <x-wiretable.th shrink align="right">Interesados</x-wiretable.th>
            <x-wiretable.th actions />
        </x-slot:head>

        @forelse ($this->properties as $property)
            <x-wiretable.row :href="route('property', $property)" navigate wire:key="property-{{ $property->id }}">
                <x-wiretable.td>
                    <x-wiretable.primary :title="$property->title" :subtitle="$property->reference.' · '.$property->type->label().($property->bedrooms ? ' · '.$property->bedrooms.' dorm.' : '')">
                        <x-slot:leading>
                            @if ($property->cover)
                                <img src="{{ $property->cover->url() }}" alt="" class="h-12 w-18 rounded object-cover">
                            @else
                                <div class="h-12 w-18 rounded bg-slate-100"></div>
                            @endif
                        </x-slot:leading>
                        <p class="text-xs text-slate-500 md:hidden">{{ $property->zone }} · {{ $property->status->label() }}</p>
                    </x-wiretable.primary>
                </x-wiretable.td>
                <x-wiretable.td hide="md" shrink>{{ $property->zone }}</x-wiretable.td>
                <x-wiretable.td shrink align="right">{{ $property->priceLabel() }}</x-wiretable.td>
                <x-wiretable.td hide="lg" shrink align="right">{{ $property->area }} m²</x-wiretable.td>
                <x-wiretable.td hide="md" shrink>{{ $property->status->label() }}</x-wiretable.td>
                <x-wiretable.td shrink align="right">{{ $this->interested($property) }}</x-wiretable.td>
                <x-wiretable.td actions>
                    <x-wiretable.menu :label="'Acciones de '.$property->reference">
                        <x-wiretable.menu-item :href="route('property', $property)">Ver ficha</x-wiretable.menu-item>
                        <x-wiretable.menu-separator />
                        @foreach (PropertyStatus::cases() as $case)
                            @continue($case === $property->status)
                            <x-wiretable.menu-item wire:click="setStatus({{ $property->id }}, '{{ $case->value }}')">
                                Marcar como {{ mb_strtolower($case->label()) }}
                            </x-wiretable.menu-item>
                        @endforeach
                    </x-wiretable.menu>
                </x-wiretable.td>
            </x-wiretable.row>
        @empty
            <x-wiretable.empty colspan="7">No hay inmuebles con esa búsqueda.</x-wiretable.empty>
        @endforelse
    </x-wiretable>

El menú de cada fila ofrece los estados que el inmueble todavía no tiene, y cada opción llama a setStatus().

El formulario de alta va dentro de un <x-wiremodal>. Con as="form", la ventana entera es el formulario, así que el botón de guardar puede ir en el pie junto al de cancelar. El botón «Nuevo inmueble» de la cabecera la abre con Wiremodal.open('new-property'), y cualquier elemento con data-wm-dismiss la cierra:

    <x-wiremodal name="new-property" title="Nuevo inmueble" size="3xl" as="form" wire:submit="save">
        <x-slot:body>
            <div class="grid gap-4 sm:grid-cols-4">
                <label class="text-sm">Referencia
                    <input wire:model="form.reference" class="mt-1 w-full rounded border border-slate-300 px-2 py-1.5">
                    @error('form.reference') <span class="text-xs text-red-600">{{ $message }}</span> @enderror
                </label>

Cada campo se enlaza con wire:model="form.campo" y muestra su error debajo, como la referencia. El resto de campos y el pie de la ventana los tienes en el repositorio.

Si pulsas en «Nuevo inmueble» e intentas guardar sin rellenar nada, verás los mensajes de validación en español sin que se cierre la ventana:

Ventana de alta de un inmueble con los mensajes de validación en español

Crea la ficha del inmueble

La ficha muestra los datos y las fotos del inmueble, deja cambiar su estado, lista los clientes interesados y permite programar una visita. Crea el archivo resources/views/pages/⚡property.blade.php con esta parte de PHP. Los métodos de las fotos, addPhotos() y deletePhoto(), los explico en el siguiente apartado:

<?php

use App\Enums\PropertyStatus;
use App\Models\Contact;
use App\Models\Demand;
use App\Models\Property;
use Illuminate\Validation\Rule;
use Livewire\Attributes\Computed;
use Livewire\Component;
use Livewire\WithFileUploads;

/**
 * La ficha de un inmueble: sus datos y sus fotos, los clientes cuya demanda encaja con él y
 * las visitas, con un formulario para programar la siguiente.
 */
new class extends Component
{
    use WithFileUploads;

    public Property $property;

    /** Las fotos elegidas en el formulario, todavía sin guardar. */
    public array $uploads = [];

    public string $status = '';

    public ?int $contact_id = null;

    public string $scheduled_at = '';

    public function mount(): void
    {
        $this->status = $this->property->status->value;
    }

    public function render()
    {
        return $this->view()->title($this->property->title);
    }

    #[Computed]
    public function interested()
    {
        return Demand::matching($this->property)->with('contact')->get();
    }

    #[Computed]
    public function contacts()
    {
        return Contact::orderBy('name')->get();
    }

    /** Los días que el inmueble ya tiene visitas, para marcarlos en el calendario. */
    #[Computed]
    public function busyDays(): array
    {
        return $this->property->visits()->with('contact')
            ->where('scheduled_at', '>=', today())
            ->orderBy('scheduled_at')
            ->get()
            ->groupBy(fn ($visit) => $visit->scheduled_at->toDateString())
            ->map(fn ($visits) => $visits->map(fn ($visit) => $visit->scheduled_at->format('H:i').' '.$visit->contact->name)->all())
            ->all();
    }

    public function updatedStatus(): void
    {
        $this->validate(['status' => [Rule::enum(PropertyStatus::class)]]);

        $this->property->update(['status' => $this->status]);

        $this->notify('Estado cambiado a '.mb_strtolower($this->property->status->label()).'.', 'info');
    }

    public function addPhotos(): void
    {
        $this->validate([
            'uploads' => ['required', 'array', 'max:6'],
            'uploads.*' => ['image', 'mimes:jpg,jpeg,png,webp', 'max:5120'],
        ]);

        $position = (int) $this->property->photos()->max('position');

        foreach ($this->uploads as $upload) {
            $this->property->photos()->create([
                'path' => $upload->store("properties/{$this->property->id}", 'public'),
                'position' => ++$position,
            ]);
        }

        $this->notify(count($this->uploads) === 1 ? 'Foto añadida.' : count($this->uploads).' fotos añadidas.');
        $this->reset('uploads');
    }

    public function deletePhoto(int $photoId): void
    {
        $this->property->photos()->findOrFail($photoId)->delete();

        $this->notify('Foto eliminada.', 'info');
    }

    public function propose(int $contactId): void
    {
        $this->contact_id = $contactId;
    }

    public function schedule(): void
    {
        $data = $this->validate([
            'contact_id' => ['required', Rule::exists('contacts', 'id')],
            'scheduled_at' => ['required', 'date', 'after:now'],
        ]);

        $visit = $this->property->visits()->create($data);

        $this->reset('contact_id', 'scheduled_at');
        $this->notify('Visita con '.$visit->contact->name.' el '.$visit->scheduled_at->isoFormat('dddd D [de] MMMM [a las] HH:mm').'.');
    }
};

Livewire rellena la propiedad $property con el modelo de la ruta. El método render() pone el título del inmueble como título de la página. Cuando cambias el estado, updatedStatus() lo valida, lo guarda al momento y lo confirma con un aviso. Si marcas el piso como reservado, desaparece de los cruces. El botón «Programar visita» de cada interesado llama a propose(), que deja elegido a ese cliente en el formulario. La propiedad computada busyDays agrupa las próximas visitas del inmueble por día, con la hora y el cliente de cada una, para marcarlas en el calendario.

La regla after:now impide programar visitas en el pasado. En la vista, la lista de interesados queda así:

        <ul class="divide-y divide-slate-100 rounded-lg border border-slate-200 bg-white">
            @forelse ($this->interested as $demand)
                <li wire:key="demand-{{ $demand->id }}" class="flex items-center gap-4 px-4 py-3 text-sm">
                    <div class="mr-auto">
                        <div class="font-medium">{{ $demand->contact->name }}</div>
                        <div class="text-xs text-slate-500">
                            Hasta {{ number_format($demand->max_price, 0, ',', '.') }} € · {{ $demand->zone ?? 'cualquier zona' }}
                        </div>
                    </div>
                    <button wire:click="propose({{ $demand->contact_id }})" class="rounded border border-teal-700 px-3 py-1 text-teal-700 hover:bg-teal-50">
                        Programar visita
                    </button>
                </li>
            @empty
                <li class="px-4 py-3 text-sm text-slate-500">
                    {{ $property->status === PropertyStatus::Available ? 'Ningún cliente busca algo así todavía.' : 'Solo se cruzan los inmuebles disponibles.' }}
                </li>
            @endforelse
        </ul>

El formulario de la visita, en la columna de la derecha, usa el selector de Wirepicker:

        <form wire:submit="schedule" class="rounded-lg border border-slate-200 bg-white p-5">
            <h2 class="mb-4 text-lg font-semibold">Programar visita</h2>
            <label class="block text-sm">Cliente
                <select wire:model="contact_id" class="mt-1 w-full rounded border border-slate-300 px-2 py-1.5">
                    <option value="">Elige uno</option>
                    @foreach ($this->contacts as $contact)
                        <option value="{{ $contact->id }}">{{ $contact->name }}</option>
                    @endforeach
                </select>
                @error('contact_id') <span class="text-xs text-red-600">{{ $message }}</span> @enderror
            </label>
            <label for="scheduled-at" class="mt-3 block text-sm">Día y hora</label>
            <x-wirepicker id="scheduled-at" wire:model="scheduled_at" time :step="30" default-time="10:00"
                :min="today()->toDateString()" :marked="$this->busyDays" trigger-class="mt-1 rounded border border-slate-300 px-2 py-1.5 text-sm" />
            @error('scheduled_at') <span class="text-xs text-red-600">{{ $message }}</span> @enderror
            <button class="mt-4 w-full rounded bg-teal-700 px-4 py-2 text-sm font-medium text-white hover:bg-teal-800">Guardar visita</button>
        </form>

Con time, el calendario también pide la hora, en intervalos de step minutos, y el valor llega a Livewire como 2026-11-25 10:00, un formato que la regla date entiende sin más. min impide elegir días pasados y marked pone un punto bajo los días que ya tienen visita, con el detalle al pasar el ratón. Con trigger-class, el campo toma las mismas clases que el resto del formulario.

En la ficha del piso AT-108 aparece Marc como interesado. Al abrir el calendario, el miércoles 18 tiene un punto, porque Marc ya tiene una visita ese día:

Ficha de un inmueble con el calendario de Wirepicker abierto y el día de una visita marcado

Sube las fotos del inmueble

Para subir archivos, Livewire tiene el trait WithFileUploads. En cuanto eliges las fotos en el formulario, Livewire las sube a una carpeta temporal y la propiedad $uploads recibe un objeto por cada una, con el que podemos enseñar una vista previa antes de guardarlas. La ficha se ocupa de las fotos con dos métodos:

    public function addPhotos(): void
    {
        $this->validate([
            'uploads' => ['required', 'array', 'max:6'],
            'uploads.*' => ['image', 'mimes:jpg,jpeg,png,webp', 'max:5120'],
        ]);

        $position = (int) $this->property->photos()->max('position');

        foreach ($this->uploads as $upload) {
            $this->property->photos()->create([
                'path' => $upload->store("properties/{$this->property->id}", 'public'),
                'position' => ++$position,
            ]);
        }

        $this->notify(count($this->uploads) === 1 ? 'Foto añadida.' : count($this->uploads).' fotos añadidas.');
        $this->reset('uploads');
    }

    public function deletePhoto(int $photoId): void
    {
        $this->property->photos()->findOrFail($photoId)->delete();

        $this->notify('Foto eliminada.', 'info');
    }

addPhotos() comprueba que haya entre una y seis fotos y que cada una sea una imagen JPG, PNG o WebP de 5 MB como mucho. Las reglas image y mimes miran el contenido del archivo, así que un PDF renombrado a .jpg no pasa. Después, store() guarda cada foto en el disco public, en una carpeta por inmueble y con un nombre aleatorio, y crea su registro con la posición siguiente a la última. deletePhoto() busca la foto entre las del inmueble, de modo que nadie puede borrar la de otro cambiando el número en la petición.

En la vista, la galería va bajo los datos del inmueble, con la etiqueta «Portada» en la primera foto. Debajo está el campo de archivos, con wire:model="uploads" y multiple, y un botón para guardar que solo aparece cuando hay fotos elegidas:

        <div class="mt-6 grid grid-cols-2 gap-3 sm:grid-cols-3">
            @foreach ($property->photos as $photo)
                <figure wire:key="photo-{{ $photo->id }}" class="group relative">
                    <img src="{{ $photo->url() }}" alt="{{ $property->title }}" class="aspect-[3/2] w-full rounded-lg object-cover">
                    @if ($loop->first)
                        <span class="absolute left-2 top-2 rounded bg-white/90 px-2 py-0.5 text-xs font-medium">Portada</span>
                    @endif
                    <button type="button" x-on:click="Wiremodal.open('delete-photo').then(result => result === 'confirmed' && $wire.deletePhoto({{ $photo->id }}))"
                        class="absolute right-2 top-2 rounded bg-white/90 px-2 py-0.5 text-xs text-red-700 opacity-0 group-hover:opacity-100">
                        Eliminar
                    </button>
                </figure>
            @endforeach
        </div>

        <form wire:submit="addPhotos" class="mt-3 flex flex-wrap items-center gap-3 text-sm">
            <input type="file" wire:model="uploads" multiple accept="image/jpeg,image/png,image/webp"
                class="text-sm file:mr-3 file:rounded file:border-0 file:bg-slate-100 file:px-3 file:py-1.5 hover:file:bg-slate-200">
            <span wire:loading wire:target="uploads" class="text-slate-500">Subiendo…</span>
            @if ($uploads)
                <button wire:loading.attr="disabled" class="rounded bg-teal-700 px-3 py-1.5 font-medium text-white hover:bg-teal-800">
                    Guardar {{ count($uploads) === 1 ? 'foto' : count($uploads).' fotos' }}
                </button>
            @endif
            @error('uploads') <span class="w-full text-xs text-red-600">{{ $message }}</span> @enderror
            @error('uploads.*') <span class="w-full text-xs text-red-600">{{ $message }}</span> @enderror
        </form>

Mientras las fotos viajan a la carpeta temporal, wire:loading muestra «Subiendo…». Las vistas previas usan temporaryUrl(), que solo funciona con imágenes, y por eso antes le preguntamos a isPreviewable():

        @if ($uploads)
            <div class="mt-3 flex flex-wrap gap-2">
                @foreach ($uploads as $upload)
                    {{-- Un PDF elegido por error no tiene vista previa, solo las imágenes. --}}
                    @if ($upload->isPreviewable())
                        <img src="{{ $upload->temporaryUrl() }}" alt="" class="h-16 w-24 rounded object-cover opacity-80">
                    @endif
                @endforeach
            </div>
        @endif

Para borrar una foto pedimos confirmación con una ventana de Wiremodal. Wiremodal.open() devuelve una promesa que se resuelve con el valor que reciba Wiremodal.close(), así que el botón de cada foto solo llama a deletePhoto() cuando se pulsa «Eliminar» en la ventana:

                    <button type="button" x-on:click="Wiremodal.open('delete-photo').then(result => result === 'confirmed' && $wire.deletePhoto({{ $photo->id }}))"
                        class="absolute right-2 top-2 rounded bg-white/90 px-2 py-0.5 text-xs text-red-700 opacity-0 group-hover:opacity-100">
                        Eliminar
                    </button>

La ventana va al final de la vista. Su botón «Eliminar» la cierra con el valor confirmed, y «Cancelar» la cierra sin valor gracias a data-wm-dismiss:

        <x-wiremodal name="delete-photo" title="¿Eliminar esta foto?" size="sm">
            <x-slot:body>
                <p class="text-sm text-slate-600">Se borrará también el archivo. Si era la portada, la siguiente foto ocupará su lugar.</p>
            </x-slot:body>
            <x-slot:footer>
                <button type="button" data-wm-dismiss class="rounded border border-slate-300 px-4 py-2 text-sm hover:bg-slate-50">Cancelar</button>
                <button type="button" onclick="Wiremodal.close('delete-photo', 'confirmed')" class="rounded bg-red-700 px-4 py-2 text-sm font-medium text-white hover:bg-red-800">Eliminar</button>
            </x-slot:footer>
        </x-wiremodal>

En la ficha del AT-108, después de subir dos fotos más, la de la cocina y la del dormitorio, la galería ya tiene tres y el aviso confirma la subida:

Ficha de un inmueble con su galería de fotos y el aviso tras subir dos fotos

Crea la pantalla de clientes

En una agencia casi nadie entra en la base de datos si no es porque busca algo, así que daremos de alta al cliente y su demanda en el mismo formulario. Crea el archivo app/Livewire/Forms/ContactForm.php con los campos de los dos y este método store():

    public function store(): Contact
    {
        $data = $this->validate();

        $contact = DB::transaction(function () use ($data) {
            $contact = Contact::create([
                'name' => $data['name'],
                'email' => $data['email'] ?: null,
                'phone' => $data['phone'] ?: null,
            ]);

            $contact->demands()->create([
                'operation' => $data['operation'],
                'type' => $data['type'] ?: null,
                'zone' => $data['zone'] ?: null,
                'max_price' => $data['max_price'],
                'min_bedrooms' => $data['min_bedrooms'],
                'min_area' => $data['min_area'],
            ]);

            return $contact;
        });

        $this->reset();

        return $contact;
    }
}

La transacción garantiza que no quede un cliente sin demanda si algo falla a mitad. Los campos opcionales que llegan vacíos se guardan como null, que para el cruce significa «cualquiera». Las propiedades y las reglas del formulario las tienes completas en el repositorio.

La página, en resources/views/pages/⚡contacts.blade.php, usa las mismas piezas que la de inmuebles. Tiene un buscador con Larasearch, el formulario va en una ventana de Wiremodal y, al guardar, un aviso dice cuántos inmuebles de la cartera le encajan ya al cliente nuevo:

<?php

use App\Enums\Operation;
use App\Enums\PropertyType;
use App\Livewire\Forms\ContactForm;
use App\Models\Contact;
use App\Models\Demand;
use App\Models\Property;
use Livewire\Attributes\Computed;
use Livewire\Attributes\Title;
use Livewire\Attributes\Url;
use Livewire\Component;

/**
 * Los clientes de la agencia con su buscador, lo que busca cada uno y los inmuebles de la
 * cartera que le encajan ahora mismo.
 */
new #[Title('Clientes')] class extends Component
{
    #[Url]
    public string $search = '';

    public ContactForm $form;

    #[Computed]
    public function contacts()
    {
        return Contact::searchText($this->search)->with('demands')->orderBy('name')->get();
    }

    public function matches(Demand $demand)
    {
        return Property::matching($demand)->orderBy('price')->get();
    }

    public function save(): void
    {
        $contact = $this->form->store();
        $matches = $this->matches($contact->demands->first())->count();

        $this->form->reset();
        $this->closeModal('new-contact');
        $this->notify(match ($matches) {
            0 => "{$contact->name} guardado. Todavía no hay nada en cartera que le encaje.",
            1 => "{$contact->name} guardado. Le encaja un inmueble.",
            default => "{$contact->name} guardado. Le encajan {$matches} inmuebles.",
        });
    }
};

En la vista, bajo cada cliente, se describe lo que busca y se muestran los inmuebles que le encajan, cada uno con un enlace a su ficha:

                    <div class="mt-2 flex flex-wrap gap-2">
                        @forelse ($this->matches($demand) as $property)
                            <a href="{{ route('property', $property) }}" wire:navigate class="rounded-full bg-teal-50 px-3 py-1 text-xs text-teal-800 hover:bg-teal-100">
                                {{ $property->reference }} · {{ $property->priceLabel() }}
                            </a>
                        @empty
                            <span class="text-xs text-slate-400">Nada en cartera por ahora.</span>
                        @endforelse
                    </div>

Con los datos de ejemplo, cada cliente aparece con su búsqueda y los inmuebles que le encajan:

Clientes del CRM inmobiliario con su buscador, lo que busca cada uno y los inmuebles que le encajan

Crea la agenda de visitas

La última pantalla agrupa las visitas de hoy en adelante por día y permite anotar cómo fue cada una. Crea el archivo resources/views/pages/⚡visits.blade.php:

<?php

use App\Enums\VisitOutcome;
use App\Models\Visit;
use Livewire\Attributes\Computed;
use Livewire\Attributes\Title;
use Livewire\Component;

/**
 * La agenda: las visitas de hoy en adelante, agrupadas por día, y qué le pareció cada
 * inmueble al cliente cuando ya se ha hecho.
 */
new #[Title('Visitas')] class extends Component
{
    #[Computed]
    public function days()
    {
        return Visit::with(['property', 'contact'])
            ->where('scheduled_at', '>=', today())
            ->orderBy('scheduled_at')
            ->get()
            ->groupBy(fn (Visit $visit) => $visit->scheduled_at->toDateString());
    }

    public function mark(int $visitId, string $outcome): void
    {
        $visit = Visit::with('contact')->findOrFail($visitId);
        $visit->update(['outcome' => VisitOutcome::from($outcome)]);

        $this->notify('Visita de '.$visit->contact->name.' anotada como «'.$visit->outcome->label().'».', 'info');
    }
};

groupBy() agrupa la colección por la fecha de cada visita, y mark() guarda el resultado y lo confirma con un aviso. En la vista, cada grupo se pinta con el nombre del día. Carbon usa el idioma de la aplicación, así que isoFormat('dddd D [de] MMMM') escribe «miércoles 18 de noviembre» sin hacer nada más:

            <h2 class="mb-2 text-sm font-semibold uppercase tracking-wide text-slate-500">
                {{ \Illuminate\Support\Carbon::parse($day)->isoFormat('dddd D [de] MMMM') }}
            </h2>

Los botones para anotar cómo fue la visita solo aparecen mientras está pendiente. Una vez anotada, la fila muestra el resultado en una etiqueta, verde si al cliente le interesa:

                        @if ($visit->outcome === \App\Enums\VisitOutcome::Pending)
                            <button wire:click="mark({{ $visit->id }}, 'interested')" class="rounded border border-slate-300 px-2 py-1 text-xs hover:bg-slate-50">Le interesa</button>
                            <button wire:click="mark({{ $visit->id }}, 'discarded')" class="rounded border border-slate-300 px-2 py-1 text-xs hover:bg-slate-50">Descartado</button>
                        @else
                            <span @class(['rounded-full px-2 py-0.5 text-xs', 'bg-teal-50 text-teal-800' => $visit->outcome === \App\Enums\VisitOutcome::Interested, 'bg-slate-100 text-slate-500' => $visit->outcome === \App\Enums\VisitOutcome::Discarded])>{{ $visit->outcome->label() }}</span>
                        @endif

Compila los estilos y arranca la aplicación:

npm install && npm run build
php artisan serve

Abre http://localhost:8000 y entra en «Visitas». Verás las dos visitas que crea el seeder, cada una bajo su día. Si anotas que a Lucía le interesó el piso, aparece el aviso en la esquina:

Agenda de visitas agrupada por días con el aviso de Wiretoast tras anotar una visita

Tests

El cruce es lo que más conviene proteger con tests, ya que si alguien cambia una condición, los resultados cambian en silencio. Crea la clase del test:

php artisan make:test CrmTest --phpunit

Las páginas usan @vite, así que en el setUp() del test llamamos a withoutVite() para no tener que compilar los estilos antes de ejecutarlos. El primer test comprueba el cruce en los dos sentidos:

    public function test_the_crossing_works_both_ways(): void
    {
        $property = $this->property();
        $demand = $this->demand();

        $this->assertTrue(Property::matching($demand)->whereKey($property->id)->exists());
        $this->assertTrue(Demand::matching($property)->whereKey($demand->id)->exists());
    }

Otro comprueba que no crucen un piso por encima del presupuesto, otro con menos dormitorios, uno ya vendido y uno en alquiler:

    public function test_over_budget_short_of_rooms_or_already_sold_does_not_match(): void
    {
        $demand = $this->demand();

        $this->property(['reference' => 'AT-2', 'price' => 310000]);
        $this->property(['reference' => 'AT-3', 'bedrooms' => 1]);
        $this->property(['reference' => 'AT-4', 'status' => PropertyStatus::Closed]);
        $this->property(['reference' => 'AT-5', 'operation' => 'rent', 'price' => 900]);

        $this->assertSame(0, Property::matching($demand)->count());
    }

Los componentes de Livewire también se prueban sin navegador. Este test intenta programar una visita en el pasado y después una válida:

    public function test_a_visit_cannot_be_scheduled_in_the_past(): void
    {
        $property = $this->property();
        $contact = Contact::create(['name' => 'Marc']);

        Livewire::test('pages::property', ['property' => $property])
            ->set('contact_id', $contact->id)
            ->set('scheduled_at', now()->subDay()->format('Y-m-d H:i'))
            ->call('schedule')
            ->assertHasErrors(['scheduled_at']);

        Livewire::test('pages::property', ['property' => $property])
            ->set('contact_id', $contact->id)
            ->set('scheduled_at', now()->addDay()->format('Y-m-d H:i'))
            ->call('schedule')
            ->assertHasNoErrors();

        $this->assertSame(1, $property->visits()->count());
    }

Las subidas también se prueban. En el setUp(), Storage::fake('public') cambia el disco por uno falso, así que los tests no tocan tus fotos, y UploadedFile::fake()->image() crea una imagen de prueba:

    public function test_photos_are_uploaded_and_the_first_one_is_the_cover(): void
    {
        $property = $this->property();

        Livewire::test('pages::property', ['property' => $property])
            ->set('uploads', [UploadedFile::fake()->image('salon.jpg'), UploadedFile::fake()->image('cocina.jpg')])
            ->call('addPhotos')
            ->assertHasNoErrors()
            ->assertSet('uploads', []);

        $photos = $property->photos()->get();
        $this->assertCount(2, $photos);
        $this->assertSame($photos->first()->id, $property->cover->id);
        Storage::disk('public')->assertExists($photos->pluck('path')->all());
    }

En el repositorio encontrarás doce tests, que cubren también el alta de inmuebles y clientes, que un PDF no pase por una foto, el borrado de fotos, los dos buscadores, el orden por precio, la agenda y que las cuatro pantallas cargan. Para ejecutarlos, usa este comando:

php artisan test

Finalizando

Con esto ya tienes un CRM inmobiliario que guarda la cartera con sus fotos y los clientes, los cruza en los dos sentidos y lleva la agenda de visitas. Para usarlo en una agencia de verdad te faltarían algunas piezas:

  • Usuarios y permisos: un acceso para cada comercial. Puedes partir del login sin contraseña con Livewire y, si la agencia tiene varias oficinas, limitar qué ve cada una con un paquete de roles como Larallow.
  • Fotos en la nube, vídeos y planos: aquí las fotos se guardan en el disco del servidor, tal cual se suben. Para casos más avanzados, como guardarlas en R2 o S3, generar miniaturas o añadir vídeos y planos, tienes dos buenas opciones. Laravel Media Library, de Spatie, es uno de los paquetes más usados de Laravel y asocia los archivos a cualquier modelo de Eloquent, con sus miniaturas. Mi paquete Laracrate los sube directamente desde el navegador a R2 o S3, sin pasar por tu servidor, y genera las miniaturas de las fotos y las vistas previas de los vídeos y los PDF.
  • Avisos de nuevos cruces: un evento al crear un inmueble que avise a los comerciales de los clientes a los que les encaja.
  • Publicación en portales: exportar la cartera en el formato XML que piden los portales inmobiliarios.

Si lo que necesitas es un CRM para una agencia real, con varias oficinas, publicación en portales e inmuebles compartidos con otras agencias, en Kenodo desarrollamos CRM inmobiliarios a medida.

Recuerda que siempre puedes consultar el código completo de la aplicación en GitHub.

Esto ha sido todo. Espero que este tutorial te haya resultado útil.